external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp

   1 /*-------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2015 Google Inc.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Api Feature Query tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "vktApiFeatureInfo.hpp"
  25
  26 #include "vktTestCaseUtil.hpp"
  27 #include "vktTestGroupUtil.hpp"
  28 #include "vktCustomInstancesDevices.hpp"
  29
  30 #include "vkPlatform.hpp"
  31 #include "vkStrUtil.hpp"
  32 #include "vkRef.hpp"
  33 #include "vkRefUtil.hpp"
  34 #include "vkDeviceUtil.hpp"
  35 #include "vkQueryUtil.hpp"
  36 #include "vkImageUtil.hpp"
  37 #include "vkApiVersion.hpp"
  38
  39 #include "tcuTestLog.hpp"
  40 #include "tcuFormatUtil.hpp"
  41 #include "tcuTextureUtil.hpp"
  42 #include "tcuResultCollector.hpp"
  43 #include "tcuCommandLine.hpp"
  44
  45 #include "deUniquePtr.hpp"
  46 #include "deString.h"
  47 #include "deStringUtil.hpp"
  48 #include "deSTLUtil.hpp"
  49 #include "deMemory.h"
  50 #include "deMath.h"
  51
  52 #include <vector>
  53 #include <set>
  54 #include <string>
  55 #include <limits>
  56
  57 namespace vkt
  58 {
  59 namespace api
  60 {
  61 namespace
  62 {
  63
  64 #include "vkApiExtensionDependencyInfo.inl"
  65
  66 using namespace vk;
  67 using std::vector;
  68 using std::set;
  69 using std::string;
  70 using tcu::TestLog;
  71 using tcu::ScopedLogSection;
  72
  73 const deUint32 DEUINT32_MAX = std::numeric_limits<deUint32>::max();
  74
  75 enum
  76 {
  77         GUARD_SIZE                                                              = 0x20,                 //!< Number of bytes to check
  78         GUARD_VALUE                                                             = 0xcd,                 //!< Data pattern
  79 };
  80
  81 static const VkDeviceSize MINIMUM_REQUIRED_IMAGE_RESOURCE_SIZE =        (1LLU<<31);     //!< Minimum value for VkImageFormatProperties::maxResourceSize (2GiB)
  82
  83 enum LimitFormat
  84 {
  85         LIMIT_FORMAT_SIGNED_INT,
  86         LIMIT_FORMAT_UNSIGNED_INT,
  87         LIMIT_FORMAT_FLOAT,
  88         LIMIT_FORMAT_DEVICE_SIZE,
  89         LIMIT_FORMAT_BITMASK,
  90
  91         LIMIT_FORMAT_LAST
  92 };
  93
  94 enum LimitType
  95 {
  96         LIMIT_TYPE_MIN,
  97         LIMIT_TYPE_MAX,
  98         LIMIT_TYPE_NONE,
  99
 100         LIMIT_TYPE_LAST
 101 };
 102
 103 #define LIMIT(_X_)              DE_OFFSET_OF(VkPhysicalDeviceLimits, _X_), (const char*)(#_X_)
 104 #define FEATURE(_X_)    DE_OFFSET_OF(VkPhysicalDeviceFeatures, _X_)
 105
 106 bool validateFeatureLimits(VkPhysicalDeviceProperties* properties, VkPhysicalDeviceFeatures* features, TestLog& log)
 107 {
 108         bool                                            limitsOk                                = true;
 109         VkPhysicalDeviceLimits*         limits                                  = &properties->limits;
 110         deUint32                                        shaderStages                    = 3;
 111         deUint32                                        maxPerStageResourcesMin = deMin32(128,  limits->maxPerStageDescriptorUniformBuffers             +
 112                                                                                                                                                 limits->maxPerStageDescriptorStorageBuffers             +
 113                                                                                                                                                 limits->maxPerStageDescriptorSampledImages              +
 114                                                                                                                                                 limits->maxPerStageDescriptorStorageImages              +
 115                                                                                                                                                 limits->maxPerStageDescriptorInputAttachments   +
 116                                                                                                                                                 limits->maxColorAttachments);
 117
 118         if (features->tessellationShader)
 119         {
 120                 shaderStages += 2;
 121         }
 122
 123         if (features->geometryShader)
 124         {
 125                 shaderStages++;
 126         }
 127
 128         struct FeatureLimitTable
 129         {
 130                 deUint32                offset;
 131                 const char*             name;
 132                 deUint32                uintVal;                        //!< Format is UNSIGNED_INT
 133                 deInt32                 intVal;                         //!< Format is SIGNED_INT
 134                 deUint64                deviceSizeVal;          //!< Format is DEVICE_SIZE
 135                 float                   floatVal;                       //!< Format is FLOAT
 136                 LimitFormat             format;
 137                 LimitType               type;
 138                 deInt32                 unsuppTableNdx;
 139                 deBool                  pot;
 140         } featureLimitTable[] =   //!< Based on 1.0.28 Vulkan spec
 141         {
 142                 { LIMIT(maxImageDimension1D),                                                           4096, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 143                 { LIMIT(maxImageDimension2D),                                                           4096, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
 144                 { LIMIT(maxImageDimension3D),                                                           256, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 145                 { LIMIT(maxImageDimensionCube),                                                         4096, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
 146                 { LIMIT(maxImageArrayLayers),                                                           256, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN   , -1, false },
 147                 { LIMIT(maxTexelBufferElements),                                                        65536, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 148                 { LIMIT(maxUniformBufferRange),                                                         16384, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 149                 { LIMIT(maxStorageBufferRange),                                                         134217728, 0, 0, 0, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 150                 { LIMIT(maxPushConstantsSize),                                                          128, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 151                 { LIMIT(maxMemoryAllocationCount),                                                      4096, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
 152                 { LIMIT(maxSamplerAllocationCount),                                                     4000, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
 153                 { LIMIT(bufferImageGranularity),                                                        0, 0, 1, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MIN, -1, false },
 154                 { LIMIT(bufferImageGranularity),                                                        0, 0, 131072, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MAX, -1, false },
 155                 { LIMIT(sparseAddressSpaceSize),                                                        0, 0, 2UL*1024*1024*1024, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MIN, -1, false },
 156                 { LIMIT(maxBoundDescriptorSets),                                                        4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 157                 { LIMIT(maxPerStageDescriptorSamplers),                                         16, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 158                 { LIMIT(maxPerStageDescriptorUniformBuffers),                           12, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
 159                 { LIMIT(maxPerStageDescriptorStorageBuffers),                           4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
 160                 { LIMIT(maxPerStageDescriptorSampledImages),                            16, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
 161                 { LIMIT(maxPerStageDescriptorStorageImages),                            4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
 162                 { LIMIT(maxPerStageDescriptorInputAttachments),                         4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
 163                 { LIMIT(maxPerStageResources),                                                          maxPerStageResourcesMin, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
 164                 { LIMIT(maxDescriptorSetSamplers),                                                      shaderStages * 16, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 165                 { LIMIT(maxDescriptorSetUniformBuffers),                                        shaderStages * 12, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 166                 { LIMIT(maxDescriptorSetUniformBuffersDynamic),                         8, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 167                 { LIMIT(maxDescriptorSetStorageBuffers),                                        shaderStages * 4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 168                 { LIMIT(maxDescriptorSetStorageBuffersDynamic),                         4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 169                 { LIMIT(maxDescriptorSetSampledImages),                                         shaderStages * 16, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 170                 { LIMIT(maxDescriptorSetStorageImages),                                         shaderStages * 4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 171                 { LIMIT(maxDescriptorSetInputAttachments),                                      4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 172                 { LIMIT(maxVertexInputAttributes),                                                      16, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 173                 { LIMIT(maxVertexInputBindings),                                                        16, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 174                 { LIMIT(maxVertexInputAttributeOffset),                                         2047, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 175                 { LIMIT(maxVertexInputBindingStride),                                           2048, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 176                 { LIMIT(maxVertexOutputComponents),                                                     64, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 177                 { LIMIT(maxTessellationGenerationLevel),                                        64, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 178                 { LIMIT(maxTessellationPatchSize),                                                      32, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
 179                 { LIMIT(maxTessellationControlPerVertexInputComponents),        64, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 180                 { LIMIT(maxTessellationControlPerVertexOutputComponents),       64, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 181                 { LIMIT(maxTessellationControlPerPatchOutputComponents),        120, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 182                 { LIMIT(maxTessellationControlTotalOutputComponents),           2048, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 183                 { LIMIT(maxTessellationEvaluationInputComponents),                      64, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 184                 { LIMIT(maxTessellationEvaluationOutputComponents),                     64, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 185                 { LIMIT(maxGeometryShaderInvocations),                                          32, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 186                 { LIMIT(maxGeometryInputComponents),                                            64, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 187                 { LIMIT(maxGeometryOutputComponents),                                           64, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 188                 { LIMIT(maxGeometryOutputVertices),                                                     256, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 189                 { LIMIT(maxGeometryTotalOutputComponents),                                      1024, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 190                 { LIMIT(maxFragmentInputComponents),                                            64, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 191                 { LIMIT(maxFragmentOutputAttachments),                                          4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 192                 { LIMIT(maxFragmentDualSrcAttachments),                                         1, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 193                 { LIMIT(maxFragmentCombinedOutputResources),                            4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN  , -1, false },
 194                 { LIMIT(maxComputeSharedMemorySize),                                            16384, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN   , -1, false },
 195                 { LIMIT(maxComputeWorkGroupCount[0]),                                           65535, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN   , -1, false },
 196                 { LIMIT(maxComputeWorkGroupCount[1]),                                           65535, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN   , -1, false },
 197                 { LIMIT(maxComputeWorkGroupCount[2]),                                           65535,  0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN   , -1, false },
 198                 { LIMIT(maxComputeWorkGroupInvocations),                                        128, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN    , -1, false },
 199                 { LIMIT(maxComputeWorkGroupSize[0]),                                            128, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN    , -1, false },
 200                 { LIMIT(maxComputeWorkGroupSize[1]),                                            128, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN    , -1, false },
 201                 { LIMIT(maxComputeWorkGroupSize[2]),                                            64, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN    , -1, false },
 202                 { LIMIT(subPixelPrecisionBits),                                                         4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN    , -1, false },
 203                 { LIMIT(subTexelPrecisionBits),                                                         4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN    , -1, false },
 204                 { LIMIT(mipmapPrecisionBits),                                                           4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN    , -1, false },
 205                 { LIMIT(maxDrawIndexedIndexValue),                                                      (deUint32)~0, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 206                 { LIMIT(maxDrawIndirectCount),                                                          65535, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN    , -1, false },
 207                 { LIMIT(maxSamplerLodBias),                                                                     0, 0, 0, 2.0f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MIN, -1, false },
 208                 { LIMIT(maxSamplerAnisotropy),                                                          0, 0, 0, 16.0f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MIN, -1, false },
 209                 { LIMIT(maxViewports),                                                                          16, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 210                 { LIMIT(maxViewportDimensions[0]),                                                      4096, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
 211                 { LIMIT(maxViewportDimensions[1]),                                                      4096, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN , -1, false },
 212                 { LIMIT(viewportBoundsRange[0]),                                                        0, 0, 0, -8192.0f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MAX, -1, false },
 213                 { LIMIT(viewportBoundsRange[1]),                                                        0, 0, 0, 8191.0f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MIN, -1, false },
 214                 { LIMIT(viewportSubPixelBits),                                                          0, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 215                 { LIMIT(minMemoryMapAlignment),                                                         64, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 216                 { LIMIT(minTexelBufferOffsetAlignment),                                         0, 0, 1, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MIN, -1, true },
 217                 { LIMIT(minTexelBufferOffsetAlignment),                                         0, 0, 256, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MAX, -1, true },
 218                 { LIMIT(minUniformBufferOffsetAlignment),                                       0, 0, 1, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MIN, -1, true },
 219                 { LIMIT(minUniformBufferOffsetAlignment),                                       0, 0, 256, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MAX, -1, true },
 220                 { LIMIT(minStorageBufferOffsetAlignment),                                       0, 0, 1, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MIN, -1, true },
 221                 { LIMIT(minStorageBufferOffsetAlignment),                                       0, 0, 256, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MAX, -1, true },
 222                 { LIMIT(minTexelOffset),                                                                        0, -8, 0, 0.0f, LIMIT_FORMAT_SIGNED_INT, LIMIT_TYPE_MAX, -1, false },
 223                 { LIMIT(maxTexelOffset),                                                                        7, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 224                 { LIMIT(minTexelGatherOffset),                                                          0, -8, 0, 0.0f, LIMIT_FORMAT_SIGNED_INT, LIMIT_TYPE_MAX, -1, false },
 225                 { LIMIT(maxTexelGatherOffset),                                                          7, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 226                 { LIMIT(minInterpolationOffset),                                                        0, 0, 0, -0.5f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MAX, -1, false },
 227                 { LIMIT(maxInterpolationOffset),                                                        0, 0, 0, 0.5f - (1.0f/deFloatPow(2.0f, (float)limits->subPixelInterpolationOffsetBits)), LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MIN, -1, false },
 228                 { LIMIT(subPixelInterpolationOffsetBits),                                       4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 229                 { LIMIT(maxFramebufferWidth),                                                           4096, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 230                 { LIMIT(maxFramebufferHeight),                                                          4096, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 231                 { LIMIT(maxFramebufferLayers),                                                          0, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 232                 { LIMIT(framebufferColorSampleCounts),                                          VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT, 0, 0, 0.0f, LIMIT_FORMAT_BITMASK, LIMIT_TYPE_MIN, -1, false },
 233                 { LIMIT(framebufferDepthSampleCounts),                                          VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT, 0, 0, 0.0f, LIMIT_FORMAT_BITMASK, LIMIT_TYPE_MIN, -1, false },
 234                 { LIMIT(framebufferStencilSampleCounts),                                        VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT, 0, 0, 0.0f, LIMIT_FORMAT_BITMASK, LIMIT_TYPE_MIN, -1, false },
 235                 { LIMIT(framebufferNoAttachmentsSampleCounts),                          VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT, 0, 0, 0.0f, LIMIT_FORMAT_BITMASK, LIMIT_TYPE_MIN, -1, false },
 236                 { LIMIT(maxColorAttachments),                                                           4, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 237                 { LIMIT(sampledImageColorSampleCounts),                                         VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT, 0, 0, 0.0f, LIMIT_FORMAT_BITMASK, LIMIT_TYPE_MIN, -1, false },
 238                 { LIMIT(sampledImageIntegerSampleCounts),                                       VK_SAMPLE_COUNT_1_BIT, 0, 0, 0.0f, LIMIT_FORMAT_BITMASK, LIMIT_TYPE_MIN, -1, false },
 239                 { LIMIT(sampledImageDepthSampleCounts),                                         VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT, 0, 0, 0.0f, LIMIT_FORMAT_BITMASK, LIMIT_TYPE_MIN, -1, false },
 240                 { LIMIT(sampledImageStencilSampleCounts),                                       VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT, 0, 0, 0.0f, LIMIT_FORMAT_BITMASK, LIMIT_TYPE_MIN, -1, false },
 241                 { LIMIT(storageImageSampleCounts),                                                      VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT, 0, 0, 0.0f, LIMIT_FORMAT_BITMASK, LIMIT_TYPE_MIN, -1, false },
 242                 { LIMIT(maxSampleMaskWords),                                                            1, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 243                 { LIMIT(timestampComputeAndGraphics),                                           0, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_NONE, -1, false },
 244                 { LIMIT(timestampPeriod),                                                                       0, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_NONE, -1, false },
 245                 { LIMIT(maxClipDistances),                                                                      8, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 246                 { LIMIT(maxCullDistances),                                                                      8, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 247                 { LIMIT(maxCombinedClipAndCullDistances),                                       8, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 248                 { LIMIT(discreteQueuePriorities),                                                       2, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN, -1, false },
 249                 { LIMIT(pointSizeRange[0]),                                                                     0, 0, 0, 0.0f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MIN, -1, false },
 250                 { LIMIT(pointSizeRange[0]),                                                                     0, 0, 0, 1.0f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MAX, -1, false },
 251                 { LIMIT(pointSizeRange[1]),                                                                     0, 0, 0, 64.0f - limits->pointSizeGranularity , LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MIN, -1, false },
 252                 { LIMIT(lineWidthRange[0]),                                                                     0, 0, 0, 0.0f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MIN, -1, false },
 253                 { LIMIT(lineWidthRange[0]),                                                                     0, 0, 0, 1.0f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MAX, -1, false },
 254                 { LIMIT(lineWidthRange[1]),                                                                     0, 0, 0, 8.0f - limits->lineWidthGranularity, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MIN, -1, false },
 255                 { LIMIT(pointSizeGranularity),                                                          0, 0, 0, 1.0f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MAX, -1, false },
 256                 { LIMIT(lineWidthGranularity),                                                          0, 0, 0, 1.0f, LIMIT_FORMAT_FLOAT, LIMIT_TYPE_MAX, -1, false },
 257                 { LIMIT(strictLines),                                                                           0, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_NONE, -1, false },
 258                 { LIMIT(standardSampleLocations),                                                       0, 0, 0, 0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_NONE, -1, false },
 259                 { LIMIT(optimalBufferCopyOffsetAlignment),                                      0, 0, 0, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_NONE, -1, true },
 260                 { LIMIT(optimalBufferCopyRowPitchAlignment),                            0, 0, 0, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_NONE, -1, true },
 261                 { LIMIT(nonCoherentAtomSize),                                                           0, 0, 1, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MIN, -1, true },
 262                 { LIMIT(nonCoherentAtomSize),                                                           0, 0, 256, 0.0f, LIMIT_FORMAT_DEVICE_SIZE, LIMIT_TYPE_MAX, -1, true },
 263         };
 264
 265         const struct UnsupportedFeatureLimitTable
 266         {
 267                 deUint32                limitOffset;
 268                 const char*             name;
 269                 deUint32                featureOffset;
 270                 deUint32                uintVal;                        //!< Format is UNSIGNED_INT
 271                 deInt32                 intVal;                         //!< Format is SIGNED_INT
 272                 deUint64                deviceSizeVal;          //!< Format is DEVICE_SIZE
 273                 float                   floatVal;                       //!< Format is FLOAT
 274         } unsupportedFeatureTable[] =
 275         {
 276                 { LIMIT(sparseAddressSpaceSize),                                                        FEATURE(sparseBinding),                                 0, 0, 0, 0.0f },
 277                 { LIMIT(maxTessellationGenerationLevel),                                        FEATURE(tessellationShader),                    0, 0, 0, 0.0f },
 278                 { LIMIT(maxTessellationPatchSize),                                                      FEATURE(tessellationShader),                    0, 0, 0, 0.0f },
 279                 { LIMIT(maxTessellationControlPerVertexInputComponents),        FEATURE(tessellationShader),                    0, 0, 0, 0.0f },
 280                 { LIMIT(maxTessellationControlPerVertexOutputComponents),       FEATURE(tessellationShader),                    0, 0, 0, 0.0f },
 281                 { LIMIT(maxTessellationControlPerPatchOutputComponents),        FEATURE(tessellationShader),                    0, 0, 0, 0.0f },
 282                 { LIMIT(maxTessellationControlTotalOutputComponents),           FEATURE(tessellationShader),                    0, 0, 0, 0.0f },
 283                 { LIMIT(maxTessellationEvaluationInputComponents),                      FEATURE(tessellationShader),                    0, 0, 0, 0.0f },
 284                 { LIMIT(maxTessellationEvaluationOutputComponents),                     FEATURE(tessellationShader),                    0, 0, 0, 0.0f },
 285                 { LIMIT(maxGeometryShaderInvocations),                                          FEATURE(geometryShader),                                0, 0, 0, 0.0f },
 286                 { LIMIT(maxGeometryInputComponents),                                            FEATURE(geometryShader),                                0, 0, 0, 0.0f },
 287                 { LIMIT(maxGeometryOutputComponents),                                           FEATURE(geometryShader),                                0, 0, 0, 0.0f },
 288                 { LIMIT(maxGeometryOutputVertices),                                                     FEATURE(geometryShader),                                0, 0, 0, 0.0f },
 289                 { LIMIT(maxGeometryTotalOutputComponents),                                      FEATURE(geometryShader),                                0, 0, 0, 0.0f },
 290                 { LIMIT(maxFragmentDualSrcAttachments),                                         FEATURE(dualSrcBlend),                                  0, 0, 0, 0.0f },
 291                 { LIMIT(maxDrawIndexedIndexValue),                                                      FEATURE(fullDrawIndexUint32),                   (1<<24)-1, 0, 0, 0.0f },
 292                 { LIMIT(maxDrawIndirectCount),                                                          FEATURE(multiDrawIndirect),                             1, 0, 0, 0.0f },
 293                 { LIMIT(maxSamplerAnisotropy),                                                          FEATURE(samplerAnisotropy),                             1, 0, 0, 0.0f },
 294                 { LIMIT(maxViewports),                                                                          FEATURE(multiViewport),                                 1, 0, 0, 0.0f },
 295                 { LIMIT(minTexelGatherOffset),                                                          FEATURE(shaderImageGatherExtended),             0, 0, 0, 0.0f },
 296                 { LIMIT(maxTexelGatherOffset),                                                          FEATURE(shaderImageGatherExtended),             0, 0, 0, 0.0f },
 297                 { LIMIT(minInterpolationOffset),                                                        FEATURE(sampleRateShading),                             0, 0, 0, 0.0f },
 298                 { LIMIT(maxInterpolationOffset),                                                        FEATURE(sampleRateShading),                             0, 0, 0, 0.0f },
 299                 { LIMIT(subPixelInterpolationOffsetBits),                                       FEATURE(sampleRateShading),                             0, 0, 0, 0.0f },
 300                 { LIMIT(storageImageSampleCounts),                                                      FEATURE(shaderStorageImageMultisample), VK_SAMPLE_COUNT_1_BIT, 0, 0, 0.0f },
 301                 { LIMIT(maxClipDistances),                                                                      FEATURE(shaderClipDistance),                    0, 0, 0, 0.0f },
 302                 { LIMIT(maxCullDistances),                                                                      FEATURE(shaderCullDistance),                    0, 0, 0, 0.0f },
 303                 { LIMIT(maxCombinedClipAndCullDistances),                                       FEATURE(shaderClipDistance),                    0, 0, 0, 0.0f },
 304                 { LIMIT(pointSizeRange[0]),                                                                     FEATURE(largePoints),                                   0, 0, 0, 1.0f },
 305                 { LIMIT(pointSizeRange[1]),                                                                     FEATURE(largePoints),                                   0, 0, 0, 1.0f },
 306                 { LIMIT(lineWidthRange[0]),                                                                     FEATURE(wideLines),                                             0, 0, 0, 1.0f },
 307                 { LIMIT(lineWidthRange[1]),                                                                     FEATURE(wideLines),                                             0, 0, 0, 1.0f },
 308                 { LIMIT(pointSizeGranularity),                                                          FEATURE(largePoints),                                   0, 0, 0, 0.0f },
 309                 { LIMIT(lineWidthGranularity),                                                          FEATURE(wideLines),                                             0, 0, 0, 0.0f }
 310         };
 311
 312         log << TestLog::Message << *limits << TestLog::EndMessage;
 313
 314         //!< First build a map from limit to unsupported table index
 315         for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
 316         {
 317                 for (deUint32 unsuppNdx = 0; unsuppNdx < DE_LENGTH_OF_ARRAY(unsupportedFeatureTable); unsuppNdx++)
 318                 {
 319                         if (unsupportedFeatureTable[unsuppNdx].limitOffset == featureLimitTable[ndx].offset)
 320                         {
 321                                 featureLimitTable[ndx].unsuppTableNdx = unsuppNdx;
 322                                 break;
 323                         }
 324                 }
 325         }
 326
 327         for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
 328         {
 329                 switch (featureLimitTable[ndx].format)
 330                 {
 331                         case LIMIT_FORMAT_UNSIGNED_INT:
 332                         {
 333                                 deUint32 limitToCheck = featureLimitTable[ndx].uintVal;
 334                                 if (featureLimitTable[ndx].unsuppTableNdx != -1)
 335                                 {
 336                                         if (*((VkBool32*)((deUint8*)features+unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].featureOffset)) == VK_FALSE)
 337                                                 limitToCheck = unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].uintVal;
 338                                 }
 339
 340                                 if (featureLimitTable[ndx].pot)
 341                                 {
 342                                         if (!deIntIsPow2(*((deUint32*)((deUint8*)limits + featureLimitTable[ndx].offset))))
 343                                         {
 344                                                 log << TestLog::Message << "limit Validation failed " << featureLimitTable[ndx].name
 345                                                         << " is not a power of two." << TestLog::EndMessage;
 346                                                 limitsOk = false;
 347                                         }
 348                                 }
 349
 350                                 if (featureLimitTable[ndx].type == LIMIT_TYPE_MIN)
 351                                 {
 352                                         if (*((deUint32*)((deUint8*)limits+featureLimitTable[ndx].offset)) < limitToCheck)
 353                                         {
 354                                                 log << TestLog::Message << "limit Validation failed " << featureLimitTable[ndx].name
 355                                                         << " not valid-limit type MIN - actual is "
 356                                                         << *((deUint32*)((deUint8*)limits + featureLimitTable[ndx].offset)) << TestLog::EndMessage;
 357                                                 limitsOk = false;
 358                                         }
 359                                 }
 360                                 else if (featureLimitTable[ndx].type == LIMIT_TYPE_MAX)
 361                                 {
 362                                         if (*((deUint32*)((deUint8*)limits+featureLimitTable[ndx].offset)) > limitToCheck)
 363                                         {
 364                                                 log << TestLog::Message << "limit validation failed,  " << featureLimitTable[ndx].name
 365                                                         << " not valid-limit type MAX - actual is "
 366                                                         << *((deUint32*)((deUint8*)limits + featureLimitTable[ndx].offset)) << TestLog::EndMessage;
 367                                                 limitsOk = false;
 368                                         }
 369                                 }
 370                                 break;
 371                         }
 372
 373                         case LIMIT_FORMAT_FLOAT:
 374                         {
 375                                 float limitToCheck = featureLimitTable[ndx].floatVal;
 376                                 if (featureLimitTable[ndx].unsuppTableNdx != -1)
 377                                 {
 378                                         if (*((VkBool32*)((deUint8*)features+unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].featureOffset)) == VK_FALSE)
 379                                                 limitToCheck = unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].floatVal;
 380                                 }
 381
 382                                 if (featureLimitTable[ndx].type == LIMIT_TYPE_MIN)
 383                                 {
 384                                         if (*((float*)((deUint8*)limits+featureLimitTable[ndx].offset)) < limitToCheck)
 385                                         {
 386                                                 log << TestLog::Message << "limit validation failed, " << featureLimitTable[ndx].name
 387                                                         << " not valid-limit type MIN - actual is "
 388                                                         << *((float*)((deUint8*)limits + featureLimitTable[ndx].offset)) << TestLog::EndMessage;
 389                                                 limitsOk = false;
 390                                         }
 391                                 }
 392                                 else if (featureLimitTable[ndx].type == LIMIT_TYPE_MAX)
 393                                 {
 394                                         if (*((float*)((deUint8*)limits+featureLimitTable[ndx].offset)) > limitToCheck)
 395                                         {
 396                                                 log << TestLog::Message << "limit validation failed, " << featureLimitTable[ndx].name
 397                                                         << " not valid-limit type MAX actual is "
 398                                                         << *((float*)((deUint8*)limits + featureLimitTable[ndx].offset)) << TestLog::EndMessage;
 399                                                 limitsOk = false;
 400                                         }
 401                                 }
 402                                 break;
 403                         }
 404
 405                         case LIMIT_FORMAT_SIGNED_INT:
 406                         {
 407                                 deInt32 limitToCheck = featureLimitTable[ndx].intVal;
 408                                 if (featureLimitTable[ndx].unsuppTableNdx != -1)
 409                                 {
 410                                         if (*((VkBool32*)((deUint8*)features+unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].featureOffset)) == VK_FALSE)
 411                                                 limitToCheck = unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].intVal;
 412                                 }
 413                                 if (featureLimitTable[ndx].type == LIMIT_TYPE_MIN)
 414                                 {
 415                                         if (*((deInt32*)((deUint8*)limits+featureLimitTable[ndx].offset)) < limitToCheck)
 416                                         {
 417                                                 log << TestLog::Message <<  "limit validation failed, " << featureLimitTable[ndx].name
 418                                                         << " not valid-limit type MIN actual is "
 419                                                         << *((deInt32*)((deUint8*)limits + featureLimitTable[ndx].offset)) << TestLog::EndMessage;
 420                                                 limitsOk = false;
 421                                         }
 422                                 }
 423                                 else if (featureLimitTable[ndx].type == LIMIT_TYPE_MAX)
 424                                 {
 425                                         if (*((deInt32*)((deUint8*)limits+featureLimitTable[ndx].offset)) > limitToCheck)
 426                                         {
 427                                                 log << TestLog::Message << "limit validation failed, " << featureLimitTable[ndx].name
 428                                                         << " not valid-limit type MAX actual is "
 429                                                         << *((deInt32*)((deUint8*)limits + featureLimitTable[ndx].offset)) << TestLog::EndMessage;
 430                                                 limitsOk = false;
 431                                         }
 432                                 }
 433                                 break;
 434                         }
 435
 436                         case LIMIT_FORMAT_DEVICE_SIZE:
 437                         {
 438                                 deUint64 limitToCheck = featureLimitTable[ndx].deviceSizeVal;
 439                                 if (featureLimitTable[ndx].unsuppTableNdx != -1)
 440                                 {
 441                                         if (*((VkBool32*)((deUint8*)features+unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].featureOffset)) == VK_FALSE)
 442                                                 limitToCheck = unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].deviceSizeVal;
 443                                 }
 444
 445                                 if (featureLimitTable[ndx].type == LIMIT_TYPE_MIN)
 446                                 {
 447                                         if (*((deUint64*)((deUint8*)limits+featureLimitTable[ndx].offset)) < limitToCheck)
 448                                         {
 449                                                 log << TestLog::Message << "limit validation failed, " << featureLimitTable[ndx].name
 450                                                         << " not valid-limit type MIN actual is "
 451                                                         << *((deUint64*)((deUint8*)limits + featureLimitTable[ndx].offset)) << TestLog::EndMessage;
 452                                                 limitsOk = false;
 453                                         }
 454                                 }
 455                                 else if (featureLimitTable[ndx].type == LIMIT_TYPE_MAX)
 456                                 {
 457                                         if (*((deUint64*)((deUint8*)limits+featureLimitTable[ndx].offset)) > limitToCheck)
 458                                         {
 459                                                 log << TestLog::Message << "limit validation failed, " << featureLimitTable[ndx].name
 460                                                         << " not valid-limit type MAX actual is "
 461                                                         << *((deUint64*)((deUint8*)limits + featureLimitTable[ndx].offset)) << TestLog::EndMessage;
 462                                                 limitsOk = false;
 463                                         }
 464                                 }
 465                                 break;
 466                         }
 467
 468                         case LIMIT_FORMAT_BITMASK:
 469                         {
 470                                 deUint32 limitToCheck = featureLimitTable[ndx].uintVal;
 471                                 if (featureLimitTable[ndx].unsuppTableNdx != -1)
 472                                 {
 473                                         if (*((VkBool32*)((deUint8*)features+unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].featureOffset)) == VK_FALSE)
 474                                                 limitToCheck = unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].uintVal;
 475                                 }
 476
 477                                 if (featureLimitTable[ndx].type == LIMIT_TYPE_MIN)
 478                                 {
 479                                         if ((*((deUint32*)((deUint8*)limits+featureLimitTable[ndx].offset)) & limitToCheck) != limitToCheck)
 480                                         {
 481                                                 log << TestLog::Message << "limit validation failed, " << featureLimitTable[ndx].name
 482                                                         << " not valid-limit type bitmask actual is "
 483                                                         << *((deUint64*)((deUint8*)limits + featureLimitTable[ndx].offset)) << TestLog::EndMessage;
 484                                                 limitsOk = false;
 485                                         }
 486                                 }
 487                                 break;
 488                         }
 489
 490                         default:
 491                                 DE_ASSERT(0);
 492                                 limitsOk = false;
 493                 }
 494         }
 495
 496         if (limits->maxFramebufferWidth > limits->maxViewportDimensions[0] ||
 497                 limits->maxFramebufferHeight > limits->maxViewportDimensions[1])
 498         {
 499                 log << TestLog::Message << "limit validation failed, maxFramebufferDimension of "
 500                         << "[" << limits->maxFramebufferWidth << ", " << limits->maxFramebufferHeight << "] "
 501                         << "is larger than maxViewportDimension of "
 502                         << "[" << limits->maxViewportDimensions[0] << ", " << limits->maxViewportDimensions[1] << "]" << TestLog::EndMessage;
 503                 limitsOk = false;
 504         }
 505
 506         if (limits->viewportBoundsRange[0] > float(-2 * limits->maxViewportDimensions[0]))
 507         {
 508                 log << TestLog::Message << "limit validation failed, viewPortBoundsRange[0] of " << limits->viewportBoundsRange[0]
 509                         << "is larger than -2*maxViewportDimension[0] of " << -2*limits->maxViewportDimensions[0] << TestLog::EndMessage;
 510                 limitsOk = false;
 511         }
 512
 513         if (limits->viewportBoundsRange[1] < float(2 * limits->maxViewportDimensions[1] - 1))
 514         {
 515                 log << TestLog::Message << "limit validation failed, viewportBoundsRange[1] of " << limits->viewportBoundsRange[1]
 516                         << "is less than 2*maxViewportDimension[1] of " << 2*limits->maxViewportDimensions[1] << TestLog::EndMessage;
 517                 limitsOk = false;
 518         }
 519
 520         return limitsOk;
 521 }
 522
 523 template<deUint32 MAJOR, deUint32 MINOR>
 524 void checkApiVersionSupport(Context& context)
 525 {
 526         if (!context.contextSupports(vk::ApiVersion(MAJOR, MINOR, 0)))
 527                 TCU_THROW(NotSupportedError, std::string("At least Vulkan ") + std::to_string(MAJOR) + "." + std::to_string(MINOR) + " required to run test");
 528 }
 529
 530 typedef struct FeatureLimitTableItem_
 531 {
 532         const void*             cond;
 533         const char*             condName;
 534         const void*             ptr;
 535         const char*             name;
 536         deUint32                uintVal;                        //!< Format is UNSIGNED_INT
 537         deInt32                 intVal;                         //!< Format is SIGNED_INT
 538         deUint64                deviceSizeVal;          //!< Format is DEVICE_SIZE
 539         float                   floatVal;                       //!< Format is FLOAT
 540         LimitFormat             format;
 541         LimitType               type;
 542 } FeatureLimitTableItem;
 543
 544 template<typename T>
 545 bool validateNumericLimit (const T limitToCheck, const T reportedValue, const LimitType limitType, const char* limitName, TestLog& log)
 546 {
 547         if (limitType == LIMIT_TYPE_MIN)
 548         {
 549                 if (reportedValue < limitToCheck)
 550                 {
 551                         log << TestLog::Message << "Limit validation failed " << limitName
 552                                 << " reported value is " << reportedValue
 553                                 << " expected MIN " << limitToCheck
 554                                 << TestLog::EndMessage;
 555
 556                         return false;
 557                 }
 558
 559                 log << TestLog::Message << limitName
 560                         << "=" << reportedValue
 561                         << " (>=" << limitToCheck << ")"
 562                         << TestLog::EndMessage;
 563         }
 564         else if (limitType == LIMIT_TYPE_MAX)
 565         {
 566                 if (reportedValue > limitToCheck)
 567                 {
 568                         log << TestLog::Message << "Limit validation failed " << limitName
 569                                 << " reported value is " << reportedValue
 570                                 << " expected MAX " << limitToCheck
 571                                 << TestLog::EndMessage;
 572
 573                         return false;
 574                 }
 575
 576                 log << TestLog::Message << limitName
 577                         << "=" << reportedValue
 578                         << " (<=" << limitToCheck << ")"
 579                         << TestLog::EndMessage;
 580         }
 581
 582         return true;
 583 }
 584
 585 template<typename T>
 586 bool validateBitmaskLimit (const T limitToCheck, const T reportedValue, const LimitType limitType, const char* limitName, TestLog& log)
 587 {
 588         if (limitType == LIMIT_TYPE_MIN)
 589         {
 590                 if ((reportedValue & limitToCheck) != limitToCheck)
 591                 {
 592                         log << TestLog::Message << "Limit validation failed " << limitName
 593                                 << " reported value is " << reportedValue
 594                                 << " expected MIN " << limitToCheck
 595                                 << TestLog::EndMessage;
 596
 597                         return false;
 598                 }
 599
 600                 log << TestLog::Message << limitName
 601                         << "=" << tcu::toHex(reportedValue)
 602                         << " (contains " << tcu::toHex(limitToCheck) << ")"
 603                         << TestLog::EndMessage;
 604         }
 605
 606         return true;
 607 }
 608
 609 bool validateLimit (FeatureLimitTableItem limit, TestLog& log)
 610 {
 611         if (*((VkBool32*)limit.cond) == DE_FALSE)
 612         {
 613                 log << TestLog::Message
 614                         << "Limit validation skipped '" << limit.name << "' due to "
 615                         << limit.condName << " == false'"
 616                         << TestLog::EndMessage;
 617
 618                 return true;
 619         }
 620
 621         switch (limit.format)
 622         {
 623                 case LIMIT_FORMAT_UNSIGNED_INT:
 624                 {
 625                         const deUint32  limitToCheck    = limit.uintVal;
 626                         const deUint32  reportedValue   = *(deUint32*)limit.ptr;
 627
 628                         return validateNumericLimit(limitToCheck, reportedValue, limit.type, limit.name, log);
 629                 }
 630
 631                 case LIMIT_FORMAT_FLOAT:
 632                 {
 633                         const float             limitToCheck    = limit.floatVal;
 634                         const float             reportedValue   = *(float*)limit.ptr;
 635
 636                         return validateNumericLimit(limitToCheck, reportedValue, limit.type, limit.name, log);
 637                 }
 638
 639                 case LIMIT_FORMAT_SIGNED_INT:
 640                 {
 641                         const deInt32   limitToCheck    = limit.intVal;
 642                         const deInt32   reportedValue   = *(deInt32*)limit.ptr;
 643
 644                         return validateNumericLimit(limitToCheck, reportedValue, limit.type, limit.name, log);
 645                 }
 646
 647                 case LIMIT_FORMAT_DEVICE_SIZE:
 648                 {
 649                         const deUint64  limitToCheck    = limit.deviceSizeVal;
 650                         const deUint64  reportedValue   = *(deUint64*)limit.ptr;
 651
 652                         return validateNumericLimit(limitToCheck, reportedValue, limit.type, limit.name, log);
 653                 }
 654
 655                 case LIMIT_FORMAT_BITMASK:
 656                 {
 657                         const deUint32  limitToCheck    = limit.uintVal;
 658                         const deUint32  reportedValue   = *(deUint32*)limit.ptr;
 659
 660                         return validateBitmaskLimit(limitToCheck, reportedValue, limit.type, limit.name, log);
 661                 }
 662
 663                 default:
 664                         TCU_THROW(InternalError, "Unknown LimitFormat specified");
 665         }
 666 }
 667
 668 #ifdef PN
 669 #error PN defined
 670 #else
 671 #define PN(_X_) &(_X_), (const char*)(#_X_)
 672 #endif
 673
 674 #define LIM_MIN_UINT32(X)       deUint32(X),          0,               0,     0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MIN
 675 #define LIM_MAX_UINT32(X)       deUint32(X),          0,               0,     0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_MAX
 676 #define LIM_NONE_UINT32                   0,          0,               0,     0.0f, LIMIT_FORMAT_UNSIGNED_INT, LIMIT_TYPE_NONE
 677 #define LIM_MIN_INT32(X)                  0, deInt32(X),               0,     0.0f, LIMIT_FORMAT_SIGNED_INT,   LIMIT_TYPE_MIN
 678 #define LIM_MAX_INT32(X)                  0, deInt32(X),               0,     0.0f, LIMIT_FORMAT_SIGNED_INT,   LIMIT_TYPE_MAX
 679 #define LIM_NONE_INT32                    0,          0,               0,     0.0f, LIMIT_FORMAT_SIGNED_INT,   LIMIT_TYPE_NONE
 680 #define LIM_MIN_DEVSIZE(X)                0,          0, VkDeviceSize(X),     0.0f, LIMIT_FORMAT_DEVICE_SIZE,  LIMIT_TYPE_MIN
 681 #define LIM_MAX_DEVSIZE(X)                0,          0, VkDeviceSize(X),     0.0f, LIMIT_FORMAT_DEVICE_SIZE,  LIMIT_TYPE_MAX
 682 #define LIM_NONE_DEVSIZE                  0,          0,               0,     0.0f, LIMIT_FORMAT_DEVICE_SIZE,  LIMIT_TYPE_NONE
 683 #define LIM_MIN_FLOAT(X)                  0,          0,               0, float(X), LIMIT_FORMAT_FLOAT,        LIMIT_TYPE_MIN
 684 #define LIM_MAX_FLOAT(X)                  0,          0,               0, float(X), LIMIT_FORMAT_FLOAT,        LIMIT_TYPE_MAX
 685 #define LIM_NONE_FLOAT                    0,          0,               0,     0.0f, LIMIT_FORMAT_FLOAT,        LIMIT_TYPE_NONE
 686 #define LIM_MIN_BITI32(X)       deUint32(X),          0,               0,     0.0f, LIMIT_FORMAT_BITMASK,      LIMIT_TYPE_MIN
 687 #define LIM_MAX_BITI32(X)       deUint32(X),          0,               0,     0.0f, LIMIT_FORMAT_BITMASK,      LIMIT_TYPE_MAX
 688 #define LIM_NONE_BITI32                   0,          0,               0,     0.0f, LIMIT_FORMAT_BITMASK,      LIMIT_TYPE_NONE
 689
 690 tcu::TestStatus validateLimits12 (Context& context)
 691 {
 692         const VkPhysicalDevice                                          physicalDevice                  = context.getPhysicalDevice();
 693         const InstanceInterface&                                        vki                                             = context.getInstanceInterface();
 694         TestLog&                                                                        log                                             = context.getTestContext().getLog();
 695         bool                                                                            limitsOk                                = true;
 696
 697         const VkPhysicalDeviceFeatures2&                        features2                               = context.getDeviceFeatures2();
 698         const VkPhysicalDeviceFeatures&                         features                                = features2.features;
 699         const VkPhysicalDeviceVulkan12Features          features12                              = getPhysicalDeviceVulkan12Features(vki, physicalDevice);
 700
 701         const VkPhysicalDeviceProperties2&                      properties2                             = context.getDeviceProperties2();
 702         const VkPhysicalDeviceVulkan12Properties        vulkan12Properties              = getPhysicalDeviceVulkan12Properties(vki, physicalDevice);
 703         const VkPhysicalDeviceVulkan11Properties        vulkan11Properties              = getPhysicalDeviceVulkan11Properties(vki, physicalDevice);
 704         const VkPhysicalDeviceLimits&                           limits                                  = properties2.properties.limits;
 705
 706         const VkBool32                                                          checkAlways                             = VK_TRUE;
 707         const VkBool32                                                          checkVulkan12Limit              = VK_TRUE;
 708
 709         deUint32                                                                        shaderStages                    = 3;
 710         deUint32                                                                        maxPerStageResourcesMin = deMin32(128,  limits.maxPerStageDescriptorUniformBuffers              +
 711                                                                                                                                                                                 limits.maxPerStageDescriptorStorageBuffers              +
 712                                                                                                                                                                                 limits.maxPerStageDescriptorSampledImages               +
 713                                                                                                                                                                                 limits.maxPerStageDescriptorStorageImages               +
 714                                                                                                                                                                                 limits.maxPerStageDescriptorInputAttachments    +
 715                                                                                                                                                                                 limits.maxColorAttachments);
 716
 717         if (features.tessellationShader)
 718         {
 719                 shaderStages += 2;
 720         }
 721
 722         if (features.geometryShader)
 723         {
 724                 shaderStages++;
 725         }
 726
 727         FeatureLimitTableItem featureLimitTable[] =
 728         {
 729                 { PN(checkAlways),                                                              PN(limits.maxImageDimension1D),                                                                                                                                 LIM_MIN_UINT32(4096) },
 730                 { PN(checkAlways),                                                              PN(limits.maxImageDimension2D),                                                                                                                                 LIM_MIN_UINT32(4096) },
 731                 { PN(checkAlways),                                                              PN(limits.maxImageDimension3D),                                                                                                                                 LIM_MIN_UINT32(256) },
 732                 { PN(checkAlways),                                                              PN(limits.maxImageDimensionCube),                                                                                                                               LIM_MIN_UINT32(4096) },
 733                 { PN(checkAlways),                                                              PN(limits.maxImageArrayLayers),                                                                                                                                 LIM_MIN_UINT32(256) },
 734                 { PN(checkAlways),                                                              PN(limits.maxTexelBufferElements),                                                                                                                              LIM_MIN_UINT32(65536) },
 735                 { PN(checkAlways),                                                              PN(limits.maxUniformBufferRange),                                                                                                                               LIM_MIN_UINT32(16384) },
 736                 { PN(checkAlways),                                                              PN(limits.maxStorageBufferRange),                                                                                                                               LIM_MIN_UINT32((1<<27)) },
 737                 { PN(checkAlways),                                                              PN(limits.maxPushConstantsSize),                                                                                                                                LIM_MIN_UINT32(128) },
 738                 { PN(checkAlways),                                                              PN(limits.maxMemoryAllocationCount),                                                                                                                    LIM_MIN_UINT32(4096) },
 739                 { PN(checkAlways),                                                              PN(limits.maxSamplerAllocationCount),                                                                                                                   LIM_MIN_UINT32(4000) },
 740                 { PN(checkAlways),                                                              PN(limits.bufferImageGranularity),                                                                                                                              LIM_MIN_DEVSIZE(1) },
 741                 { PN(checkAlways),                                                              PN(limits.bufferImageGranularity),                                                                                                                              LIM_MAX_DEVSIZE(131072) },
 742                 { PN(features.sparseBinding),                                   PN(limits.sparseAddressSpaceSize),                                                                                                                              LIM_MIN_DEVSIZE((1ull<<31)) },
 743                 { PN(checkAlways),                                                              PN(limits.maxBoundDescriptorSets),                                                                                                                              LIM_MIN_UINT32(4) },
 744                 { PN(checkAlways),                                                              PN(limits.maxPerStageDescriptorSamplers),                                                                                                               LIM_MIN_UINT32(16) },
 745                 { PN(checkAlways),                                                              PN(limits.maxPerStageDescriptorUniformBuffers),                                                                                                 LIM_MIN_UINT32(12) },
 746                 { PN(checkAlways),                                                              PN(limits.maxPerStageDescriptorStorageBuffers),                                                                                                 LIM_MIN_UINT32(4) },
 747                 { PN(checkAlways),                                                              PN(limits.maxPerStageDescriptorSampledImages),                                                                                                  LIM_MIN_UINT32(16) },
 748                 { PN(checkAlways),                                                              PN(limits.maxPerStageDescriptorStorageImages),                                                                                                  LIM_MIN_UINT32(4) },
 749                 { PN(checkAlways),                                                              PN(limits.maxPerStageDescriptorInputAttachments),                                                                                               LIM_MIN_UINT32(4) },
 750                 { PN(checkAlways),                                                              PN(limits.maxPerStageResources),                                                                                                                                LIM_MIN_UINT32(maxPerStageResourcesMin) },
 751                 { PN(checkAlways),                                                              PN(limits.maxDescriptorSetSamplers),                                                                                                                    LIM_MIN_UINT32(shaderStages * 16) },
 752                 { PN(checkAlways),                                                              PN(limits.maxDescriptorSetUniformBuffers),                                                                                                              LIM_MIN_UINT32(shaderStages * 12) },
 753                 { PN(checkAlways),                                                              PN(limits.maxDescriptorSetUniformBuffersDynamic),                                                                                               LIM_MIN_UINT32(8) },
 754                 { PN(checkAlways),                                                              PN(limits.maxDescriptorSetStorageBuffers),                                                                                                              LIM_MIN_UINT32(shaderStages * 4) },
 755                 { PN(checkAlways),                                                              PN(limits.maxDescriptorSetStorageBuffersDynamic),                                                                                               LIM_MIN_UINT32(4) },
 756                 { PN(checkAlways),                                                              PN(limits.maxDescriptorSetSampledImages),                                                                                                               LIM_MIN_UINT32(shaderStages * 16) },
 757                 { PN(checkAlways),                                                              PN(limits.maxDescriptorSetStorageImages),                                                                                                               LIM_MIN_UINT32(shaderStages * 4) },
 758                 { PN(checkAlways),                                                              PN(limits.maxDescriptorSetInputAttachments),                                                                                                    LIM_MIN_UINT32(4) },
 759                 { PN(checkAlways),                                                              PN(limits.maxVertexInputAttributes),                                                                                                                    LIM_MIN_UINT32(16) },
 760                 { PN(checkAlways),                                                              PN(limits.maxVertexInputBindings),                                                                                                                              LIM_MIN_UINT32(16) },
 761                 { PN(checkAlways),                                                              PN(limits.maxVertexInputAttributeOffset),                                                                                                               LIM_MIN_UINT32(2047) },
 762                 { PN(checkAlways),                                                              PN(limits.maxVertexInputBindingStride),                                                                                                                 LIM_MIN_UINT32(2048) },
 763                 { PN(checkAlways),                                                              PN(limits.maxVertexOutputComponents),                                                                                                                   LIM_MIN_UINT32(64) },
 764                 { PN(features.tessellationShader),                              PN(limits.maxTessellationGenerationLevel),                                                                                                              LIM_MIN_UINT32(64) },
 765                 { PN(features.tessellationShader),                              PN(limits.maxTessellationPatchSize),                                                                                                                    LIM_MIN_UINT32(32) },
 766                 { PN(features.tessellationShader),                              PN(limits.maxTessellationControlPerVertexInputComponents),                                                                              LIM_MIN_UINT32(64) },
 767                 { PN(features.tessellationShader),                              PN(limits.maxTessellationControlPerVertexOutputComponents),                                                                             LIM_MIN_UINT32(64) },
 768                 { PN(features.tessellationShader),                              PN(limits.maxTessellationControlPerPatchOutputComponents),                                                                              LIM_MIN_UINT32(120) },
 769                 { PN(features.tessellationShader),                              PN(limits.maxTessellationControlTotalOutputComponents),                                                                                 LIM_MIN_UINT32(2048) },
 770                 { PN(features.tessellationShader),                              PN(limits.maxTessellationEvaluationInputComponents),                                                                                    LIM_MIN_UINT32(64) },
 771                 { PN(features.tessellationShader),                              PN(limits.maxTessellationEvaluationOutputComponents),                                                                                   LIM_MIN_UINT32(64) },
 772                 { PN(features.geometryShader),                                  PN(limits.maxGeometryShaderInvocations),                                                                                                                LIM_MIN_UINT32(32) },
 773                 { PN(features.geometryShader),                                  PN(limits.maxGeometryInputComponents),                                                                                                                  LIM_MIN_UINT32(64) },
 774                 { PN(features.geometryShader),                                  PN(limits.maxGeometryOutputComponents),                                                                                                                 LIM_MIN_UINT32(64) },
 775                 { PN(features.geometryShader),                                  PN(limits.maxGeometryOutputVertices),                                                                                                                   LIM_MIN_UINT32(256) },
 776                 { PN(features.geometryShader),                                  PN(limits.maxGeometryTotalOutputComponents),                                                                                                    LIM_MIN_UINT32(1024) },
 777                 { PN(checkAlways),                                                              PN(limits.maxFragmentInputComponents),                                                                                                                  LIM_MIN_UINT32(64) },
 778                 { PN(checkAlways),                                                              PN(limits.maxFragmentOutputAttachments),                                                                                                                LIM_MIN_UINT32(4) },
 779                 { PN(features.dualSrcBlend),                                    PN(limits.maxFragmentDualSrcAttachments),                                                                                                               LIM_MIN_UINT32(1) },
 780                 { PN(checkAlways),                                                              PN(limits.maxFragmentCombinedOutputResources),                                                                                                  LIM_MIN_UINT32(4) },
 781                 { PN(checkAlways),                                                              PN(limits.maxComputeSharedMemorySize),                                                                                                                  LIM_MIN_UINT32(16384) },
 782                 { PN(checkAlways),                                                              PN(limits.maxComputeWorkGroupCount[0]),                                                                                                                 LIM_MIN_UINT32(65535) },
 783                 { PN(checkAlways),                                                              PN(limits.maxComputeWorkGroupCount[1]),                                                                                                                 LIM_MIN_UINT32(65535) },
 784                 { PN(checkAlways),                                                              PN(limits.maxComputeWorkGroupCount[2]),                                                                                                                 LIM_MIN_UINT32(65535) },
 785                 { PN(checkAlways),                                                              PN(limits.maxComputeWorkGroupInvocations),                                                                                                              LIM_MIN_UINT32(128) },
 786                 { PN(checkAlways),                                                              PN(limits.maxComputeWorkGroupSize[0]),                                                                                                                  LIM_MIN_UINT32(128) },
 787                 { PN(checkAlways),                                                              PN(limits.maxComputeWorkGroupSize[1]),                                                                                                                  LIM_MIN_UINT32(128) },
 788                 { PN(checkAlways),                                                              PN(limits.maxComputeWorkGroupSize[2]),                                                                                                                  LIM_MIN_UINT32(64) },
 789                 { PN(checkAlways),                                                              PN(limits.subPixelPrecisionBits),                                                                                                                               LIM_MIN_UINT32(4) },
 790                 { PN(checkAlways),                                                              PN(limits.subTexelPrecisionBits),                                                                                                                               LIM_MIN_UINT32(4) },
 791                 { PN(checkAlways),                                                              PN(limits.mipmapPrecisionBits),                                                                                                                                 LIM_MIN_UINT32(4) },
 792                 { PN(features.fullDrawIndexUint32),                             PN(limits.maxDrawIndexedIndexValue),                                                                                                                    LIM_MIN_UINT32((deUint32)~0) },
 793                 { PN(features.multiDrawIndirect),                               PN(limits.maxDrawIndirectCount),                                                                                                                                LIM_MIN_UINT32(65535) },
 794                 { PN(checkAlways),                                                              PN(limits.maxSamplerLodBias),                                                                                                                                   LIM_MIN_FLOAT(2.0f) },
 795                 { PN(features.samplerAnisotropy),                               PN(limits.maxSamplerAnisotropy),                                                                                                                                LIM_MIN_FLOAT(16.0f) },
 796                 { PN(features.multiViewport),                                   PN(limits.maxViewports),                                                                                                                                                LIM_MIN_UINT32(16) },
 797                 { PN(checkAlways),                                                              PN(limits.maxViewportDimensions[0]),                                                                                                                    LIM_MIN_UINT32(4096) },
 798                 { PN(checkAlways),                                                              PN(limits.maxViewportDimensions[1]),                                                                                                                    LIM_MIN_UINT32(4096) },
 799                 { PN(checkAlways),                                                              PN(limits.viewportBoundsRange[0]),                                                                                                                              LIM_MAX_FLOAT(-8192.0f) },
 800                 { PN(checkAlways),                                                              PN(limits.viewportBoundsRange[1]),                                                                                                                              LIM_MIN_FLOAT(8191.0f) },
 801                 { PN(checkAlways),                                                              PN(limits.viewportSubPixelBits),                                                                                                                                LIM_MIN_UINT32(0) },
 802                 { PN(checkAlways),                                                              PN(limits.minMemoryMapAlignment),                                                                                                                               LIM_MIN_UINT32(64) },
 803                 { PN(checkAlways),                                                              PN(limits.minTexelBufferOffsetAlignment),                                                                                                               LIM_MIN_DEVSIZE(1) },
 804                 { PN(checkAlways),                                                              PN(limits.minTexelBufferOffsetAlignment),                                                                                                               LIM_MAX_DEVSIZE(256) },
 805                 { PN(checkAlways),                                                              PN(limits.minUniformBufferOffsetAlignment),                                                                                                             LIM_MIN_DEVSIZE(1) },
 806                 { PN(checkAlways),                                                              PN(limits.minUniformBufferOffsetAlignment),                                                                                                             LIM_MAX_DEVSIZE(256) },
 807                 { PN(checkAlways),                                                              PN(limits.minStorageBufferOffsetAlignment),                                                                                                             LIM_MIN_DEVSIZE(1) },
 808                 { PN(checkAlways),                                                              PN(limits.minStorageBufferOffsetAlignment),                                                                                                             LIM_MAX_DEVSIZE(256) },
 809                 { PN(checkAlways),                                                              PN(limits.minTexelOffset),                                                                                                                                              LIM_MAX_INT32(-8) },
 810                 { PN(checkAlways),                                                              PN(limits.maxTexelOffset),                                                                                                                                              LIM_MIN_INT32(7) },
 811                 { PN(features.shaderImageGatherExtended),               PN(limits.minTexelGatherOffset),                                                                                                                                LIM_MAX_INT32(-8) },
 812                 { PN(features.shaderImageGatherExtended),               PN(limits.maxTexelGatherOffset),                                                                                                                                LIM_MIN_INT32(7) },
 813                 { PN(features.sampleRateShading),                               PN(limits.minInterpolationOffset),                                                                                                                              LIM_MAX_FLOAT(-0.5f) },
 814                 { PN(features.sampleRateShading),                               PN(limits.maxInterpolationOffset),                                                                                                                              LIM_MIN_FLOAT(0.5f - (1.0f/deFloatPow(2.0f, (float)limits.subPixelInterpolationOffsetBits))) },
 815                 { PN(features.sampleRateShading),                               PN(limits.subPixelInterpolationOffsetBits),                                                                                                             LIM_MIN_UINT32(4) },
 816                 { PN(checkAlways),                                                              PN(limits.maxFramebufferWidth),                                                                                                                                 LIM_MIN_UINT32(4096) },
 817                 { PN(checkAlways),                                                              PN(limits.maxFramebufferHeight),                                                                                                                                LIM_MIN_UINT32(4096) },
 818                 { PN(checkAlways),                                                              PN(limits.maxFramebufferLayers),                                                                                                                                LIM_MIN_UINT32(256) },
 819                 { PN(checkAlways),                                                              PN(limits.framebufferColorSampleCounts),                                                                                                                LIM_MIN_BITI32(VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT) },
 820                 { PN(checkVulkan12Limit),                                               PN(vulkan12Properties.framebufferIntegerColorSampleCounts),                                                                             LIM_MIN_BITI32(VK_SAMPLE_COUNT_1_BIT) },
 821                 { PN(checkAlways),                                                              PN(limits.framebufferDepthSampleCounts),                                                                                                                LIM_MIN_BITI32(VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT) },
 822                 { PN(checkAlways),                                                              PN(limits.framebufferStencilSampleCounts),                                                                                                              LIM_MIN_BITI32(VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT) },
 823                 { PN(checkAlways),                                                              PN(limits.framebufferNoAttachmentsSampleCounts),                                                                                                LIM_MIN_BITI32(VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT) },
 824                 { PN(checkAlways),                                                              PN(limits.maxColorAttachments),                                                                                                                                 LIM_MIN_UINT32(4) },
 825                 { PN(checkAlways),                                                              PN(limits.sampledImageColorSampleCounts),                                                                                                               LIM_MIN_BITI32(VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT) },
 826                 { PN(checkAlways),                                                              PN(limits.sampledImageIntegerSampleCounts),                                                                                                             LIM_MIN_BITI32(VK_SAMPLE_COUNT_1_BIT) },
 827                 { PN(checkAlways),                                                              PN(limits.sampledImageDepthSampleCounts),                                                                                                               LIM_MIN_BITI32(VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT) },
 828                 { PN(checkAlways),                                                              PN(limits.sampledImageStencilSampleCounts),                                                                                                             LIM_MIN_BITI32(VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT) },
 829                 { PN(features.shaderStorageImageMultisample),   PN(limits.storageImageSampleCounts),                                                                                                                    LIM_MIN_BITI32(VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_4_BIT) },
 830                 { PN(checkAlways),                                                              PN(limits.maxSampleMaskWords),                                                                                                                                  LIM_MIN_UINT32(1) },
 831                 { PN(checkAlways),                                                              PN(limits.timestampComputeAndGraphics),                                                                                                                 LIM_NONE_UINT32 },
 832                 { PN(checkAlways),                                                              PN(limits.timestampPeriod),                                                                                                                                             LIM_NONE_UINT32 },
 833                 { PN(features.shaderClipDistance),                              PN(limits.maxClipDistances),                                                                                                                                    LIM_MIN_UINT32(8) },
 834                 { PN(features.shaderCullDistance),                              PN(limits.maxCullDistances),                                                                                                                                    LIM_MIN_UINT32(8) },
 835                 { PN(features.shaderClipDistance),                              PN(limits.maxCombinedClipAndCullDistances),                                                                                                             LIM_MIN_UINT32(8) },
 836                 { PN(checkAlways),                                                              PN(limits.discreteQueuePriorities),                                                                                                                             LIM_MIN_UINT32(2) },
 837                 { PN(features.largePoints),                                             PN(limits.pointSizeRange[0]),                                                                                                                                   LIM_MIN_FLOAT(0.0f) },
 838                 { PN(features.largePoints),                                             PN(limits.pointSizeRange[0]),                                                                                                                                   LIM_MAX_FLOAT(1.0f) },
 839                 { PN(features.largePoints),                                             PN(limits.pointSizeRange[1]),                                                                                                                                   LIM_MIN_FLOAT(64.0f - limits.pointSizeGranularity) },
 840                 { PN(features.wideLines),                                               PN(limits.lineWidthRange[0]),                                                                                                                                   LIM_MIN_FLOAT(0.0f) },
 841                 { PN(features.wideLines),                                               PN(limits.lineWidthRange[0]),                                                                                                                                   LIM_MAX_FLOAT(1.0f) },
 842                 { PN(features.wideLines),                                               PN(limits.lineWidthRange[1]),                                                                                                                                   LIM_MIN_FLOAT(8.0f - limits.lineWidthGranularity) },
 843                 { PN(features.largePoints),                                             PN(limits.pointSizeGranularity),                                                                                                                                LIM_MIN_FLOAT(0.0f) },
 844                 { PN(features.largePoints),                                             PN(limits.pointSizeGranularity),                                                                                                                                LIM_MAX_FLOAT(1.0f) },
 845                 { PN(features.wideLines),                                               PN(limits.lineWidthGranularity),                                                                                                                                LIM_MIN_FLOAT(0.0f) },
 846                 { PN(features.wideLines),                                               PN(limits.lineWidthGranularity),                                                                                                                                LIM_MAX_FLOAT(1.0f) },
 847                 { PN(checkAlways),                                                              PN(limits.strictLines),                                                                                                                                                 LIM_NONE_UINT32 },
 848                 { PN(checkAlways),                                                              PN(limits.standardSampleLocations),                                                                                                                             LIM_NONE_UINT32 },
 849                 { PN(checkAlways),                                                              PN(limits.optimalBufferCopyOffsetAlignment),                                                                                                    LIM_NONE_DEVSIZE },
 850                 { PN(checkAlways),                                                              PN(limits.optimalBufferCopyRowPitchAlignment),                                                                                                  LIM_NONE_DEVSIZE },
 851                 { PN(checkAlways),                                                              PN(limits.nonCoherentAtomSize),                                                                                                                                 LIM_MIN_DEVSIZE(1) },
 852                 { PN(checkAlways),                                                              PN(limits.nonCoherentAtomSize),                                                                                                                                 LIM_MAX_DEVSIZE(256) },
 853
 854                 // VK_KHR_multiview
 855                 { PN(checkVulkan12Limit),                                               PN(vulkan11Properties.maxMultiviewViewCount),                                                                                                   LIM_MIN_UINT32(6) },
 856                 { PN(checkVulkan12Limit),                                               PN(vulkan11Properties.maxMultiviewInstanceIndex),                                                                                               LIM_MIN_UINT32((1<<27) - 1) },
 857
 858                 // VK_KHR_maintenance3
 859                 { PN(checkVulkan12Limit),                                               PN(vulkan11Properties.maxPerSetDescriptors),                                                                                                    LIM_MIN_UINT32(1024) },
 860                 { PN(checkVulkan12Limit),                                               PN(vulkan11Properties.maxMemoryAllocationSize),                                                                                                 LIM_MIN_DEVSIZE(1<<30) },
 861
 862                 // VK_EXT_descriptor_indexing
 863                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxUpdateAfterBindDescriptorsInAllPools),                                                                 LIM_MIN_UINT32(500000) },
 864                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindSamplers),                                                    LIM_MIN_UINT32(500000) },
 865                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindUniformBuffers),                                              LIM_MIN_UINT32(12) },
 866                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageBuffers),                                              LIM_MIN_UINT32(500000) },
 867                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindSampledImages),                                               LIM_MIN_UINT32(500000) },
 868                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageImages),                                               LIM_MIN_UINT32(500000) },
 869                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindInputAttachments),                                    LIM_MIN_UINT32(4) },
 870                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxPerStageUpdateAfterBindResources),                                                                             LIM_MIN_UINT32(500000) },
 871                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindSamplers),                                                                 LIM_MIN_UINT32(500000) },
 872                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffers),                                                   LIM_MIN_UINT32(shaderStages * 12) },
 873                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic),                                    LIM_MIN_UINT32(8) },
 874                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffers),                                                   LIM_MIN_UINT32(500000) },
 875                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic),                                    LIM_MIN_UINT32(4) },
 876                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindSampledImages),                                                    LIM_MIN_UINT32(500000) },
 877                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindStorageImages),                                                    LIM_MIN_UINT32(500000) },
 878                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindInputAttachments),                                                 LIM_MIN_UINT32(4) },
 879                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindSamplers),                                                    LIM_MIN_UINT32(limits.maxPerStageDescriptorSamplers) },
 880                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindUniformBuffers),                                              LIM_MIN_UINT32(limits.maxPerStageDescriptorUniformBuffers) },
 881                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageBuffers),                                              LIM_MIN_UINT32(limits.maxPerStageDescriptorStorageBuffers) },
 882                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindSampledImages),                                               LIM_MIN_UINT32(limits.maxPerStageDescriptorSampledImages) },
 883                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageImages),                                               LIM_MIN_UINT32(limits.maxPerStageDescriptorStorageImages) },
 884                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxPerStageDescriptorUpdateAfterBindInputAttachments),                                    LIM_MIN_UINT32(limits.maxPerStageDescriptorInputAttachments) },
 885                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxPerStageUpdateAfterBindResources),                                                                             LIM_MIN_UINT32(limits.maxPerStageResources) },
 886                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindSamplers),                                                                 LIM_MIN_UINT32(limits.maxDescriptorSetSamplers) },
 887                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffers),                                                   LIM_MIN_UINT32(limits.maxDescriptorSetUniformBuffers) },
 888                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic),                                    LIM_MIN_UINT32(limits.maxDescriptorSetUniformBuffersDynamic) },
 889                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffers),                                                   LIM_MIN_UINT32(limits.maxDescriptorSetStorageBuffers) },
 890                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic),                                    LIM_MIN_UINT32(limits.maxDescriptorSetStorageBuffersDynamic) },
 891                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindSampledImages),                                                    LIM_MIN_UINT32(limits.maxDescriptorSetSampledImages) },
 892                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindStorageImages),                                                    LIM_MIN_UINT32(limits.maxDescriptorSetStorageImages) },
 893                 { PN(features12.descriptorIndexing),                    PN(vulkan12Properties.maxDescriptorSetUpdateAfterBindInputAttachments),                                                 LIM_MIN_UINT32(limits.maxDescriptorSetInputAttachments) },
 894
 895                 // timelineSemaphore
 896                 { PN(checkVulkan12Limit),                                               PN(vulkan12Properties.maxTimelineSemaphoreValueDifference),                                                                             LIM_MIN_DEVSIZE((1ull<<31) - 1) },
 897         };
 898
 899         log << TestLog::Message << limits << TestLog::EndMessage;
 900
 901         for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
 902                 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
 903
 904         if (limits.maxFramebufferWidth > limits.maxViewportDimensions[0] ||
 905                 limits.maxFramebufferHeight > limits.maxViewportDimensions[1])
 906         {
 907                 log << TestLog::Message << "limit validation failed, maxFramebufferDimension of "
 908                         << "[" << limits.maxFramebufferWidth << ", " << limits.maxFramebufferHeight << "] "
 909                         << "is larger than maxViewportDimension of "
 910                         << "[" << limits.maxViewportDimensions[0] << ", " << limits.maxViewportDimensions[1] << "]" << TestLog::EndMessage;
 911                 limitsOk = false;
 912         }
 913
 914         if (limits.viewportBoundsRange[0] > float(-2 * limits.maxViewportDimensions[0]))
 915         {
 916                 log << TestLog::Message << "limit validation failed, viewPortBoundsRange[0] of " << limits.viewportBoundsRange[0]
 917                         << "is larger than -2*maxViewportDimension[0] of " << -2*limits.maxViewportDimensions[0] << TestLog::EndMessage;
 918                 limitsOk = false;
 919         }
 920
 921         if (limits.viewportBoundsRange[1] < float(2 * limits.maxViewportDimensions[1] - 1))
 922         {
 923                 log << TestLog::Message << "limit validation failed, viewportBoundsRange[1] of " << limits.viewportBoundsRange[1]
 924                         << "is less than 2*maxViewportDimension[1] of " << 2*limits.maxViewportDimensions[1] << TestLog::EndMessage;
 925                 limitsOk = false;
 926         }
 927
 928         if (limitsOk)
 929                 return tcu::TestStatus::pass("pass");
 930         else
 931                 return tcu::TestStatus::fail("fail");
 932 }
 933
 934 void checkSupportKhrPushDescriptor (Context& context)
 935 {
 936         context.requireDeviceFunctionality("VK_KHR_push_descriptor");
 937 }
 938
 939 tcu::TestStatus validateLimitsKhrPushDescriptor (Context& context)
 940 {
 941         const VkBool32                                                                          checkAlways                                     = VK_TRUE;
 942         const VkPhysicalDevicePushDescriptorPropertiesKHR&      pushDescriptorPropertiesKHR     = context.getPushDescriptorProperties();
 943         TestLog&                                                                                        log                                                     = context.getTestContext().getLog();
 944         bool                                                                                            limitsOk                                        = true;
 945
 946         FeatureLimitTableItem featureLimitTable[] =
 947         {
 948                 { PN(checkAlways),      PN(pushDescriptorPropertiesKHR.maxPushDescriptors),     LIM_MIN_UINT32(32) },
 949         };
 950
 951         log << TestLog::Message << pushDescriptorPropertiesKHR << TestLog::EndMessage;
 952
 953         for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
 954                 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
 955
 956         if (limitsOk)
 957                 return tcu::TestStatus::pass("pass");
 958         else
 959                 return tcu::TestStatus::fail("fail");
 960 }
 961
 962 void checkSupportKhrMultiview (Context& context)
 963 {
 964         context.requireDeviceFunctionality("VK_KHR_multiview");
 965 }
 966
 967 tcu::TestStatus validateLimitsKhrMultiview (Context& context)
 968 {
 969         const VkBool32                                                          checkAlways                     = VK_TRUE;
 970         const VkPhysicalDeviceMultiviewProperties&      multiviewProperties     = context.getMultiviewProperties();
 971         TestLog&                                                                        log                                     = context.getTestContext().getLog();
 972         bool                                                                            limitsOk                        = true;
 973
 974         FeatureLimitTableItem featureLimitTable[] =
 975         {
 976                 // VK_KHR_multiview
 977                 { PN(checkAlways),      PN(multiviewProperties.maxMultiviewViewCount),          LIM_MIN_UINT32(6) },
 978                 { PN(checkAlways),      PN(multiviewProperties.maxMultiviewInstanceIndex),      LIM_MIN_UINT32((1<<27) - 1) },
 979         };
 980
 981         log << TestLog::Message << multiviewProperties << TestLog::EndMessage;
 982
 983         for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
 984                 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
 985
 986         if (limitsOk)
 987                 return tcu::TestStatus::pass("pass");
 988         else
 989                 return tcu::TestStatus::fail("fail");
 990 }
 991
 992 void checkSupportExtDiscardRectangles (Context& context)
 993 {
 994         context.requireDeviceFunctionality("VK_EXT_discard_rectangles");
 995 }
 996
 997 tcu::TestStatus validateLimitsExtDiscardRectangles (Context& context)
 998 {
 999         const VkBool32                                                                                  checkAlways                                             = VK_TRUE;
1000         const VkPhysicalDeviceDiscardRectanglePropertiesEXT&    discardRectanglePropertiesEXT   = context.getDiscardRectanglePropertiesEXT();
1001         TestLog&                                                                                                log                                                             = context.getTestContext().getLog();
1002         bool                                                                                                    limitsOk                                                = true;
1003
1004         FeatureLimitTableItem featureLimitTable[] =
1005         {
1006                 { PN(checkAlways),      PN(discardRectanglePropertiesEXT.maxDiscardRectangles), LIM_MIN_UINT32(4) },
1007         };
1008
1009         log << TestLog::Message << discardRectanglePropertiesEXT << TestLog::EndMessage;
1010
1011         for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1012                 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1013
1014         if (limitsOk)
1015                 return tcu::TestStatus::pass("pass");
1016         else
1017                 return tcu::TestStatus::fail("fail");
1018 }
1019
1020 void checkSupportExtSampleLocations (Context& context)
1021 {
1022         context.requireDeviceFunctionality("VK_EXT_sample_locations");
1023 }
1024
1025 tcu::TestStatus validateLimitsExtSampleLocations (Context& context)
1026 {
1027         const VkBool32                                                                          checkAlways                                             = VK_TRUE;
1028         const VkPhysicalDeviceSampleLocationsPropertiesEXT&     sampleLocationsPropertiesEXT    = context.getSampleLocationsPropertiesEXT();
1029         TestLog&                                                                                        log                                                             = context.getTestContext().getLog();
1030         bool                                                                                            limitsOk                                                = true;
1031
1032         FeatureLimitTableItem featureLimitTable[] =
1033         {
1034                 { PN(checkAlways),      PN(sampleLocationsPropertiesEXT.sampleLocationSampleCounts),            LIM_MIN_BITI32(VK_SAMPLE_COUNT_4_BIT) },
1035                 { PN(checkAlways),      PN(sampleLocationsPropertiesEXT.maxSampleLocationGridSize.width),       LIM_MIN_FLOAT(0.0f) },
1036                 { PN(checkAlways),      PN(sampleLocationsPropertiesEXT.maxSampleLocationGridSize.height),      LIM_MIN_FLOAT(0.0f) },
1037                 { PN(checkAlways),      PN(sampleLocationsPropertiesEXT.sampleLocationCoordinateRange[0]),      LIM_MAX_FLOAT(0.0f) },
1038                 { PN(checkAlways),      PN(sampleLocationsPropertiesEXT.sampleLocationCoordinateRange[1]),      LIM_MIN_FLOAT(0.9375f) },
1039                 { PN(checkAlways),      PN(sampleLocationsPropertiesEXT.sampleLocationSubPixelBits),            LIM_MIN_UINT32(4) },
1040         };
1041
1042         log << TestLog::Message << sampleLocationsPropertiesEXT << TestLog::EndMessage;
1043
1044         for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1045                 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1046
1047         if (limitsOk)
1048                 return tcu::TestStatus::pass("pass");
1049         else
1050                 return tcu::TestStatus::fail("fail");
1051 }
1052
1053 void checkSupportExtExternalMemoryHost (Context& context)
1054 {
1055         context.requireDeviceFunctionality("VK_EXT_external_memory_host");
1056 }
1057
1058 tcu::TestStatus validateLimitsExtExternalMemoryHost (Context& context)
1059 {
1060         const VkBool32                                                                                  checkAlways                                             = VK_TRUE;
1061         const VkPhysicalDeviceExternalMemoryHostPropertiesEXT&  externalMemoryHostPropertiesEXT = context.getExternalMemoryHostPropertiesEXT();
1062         TestLog&                                                                                                log                                                             = context.getTestContext().getLog();
1063         bool                                                                                                    limitsOk                                                = true;
1064
1065         FeatureLimitTableItem featureLimitTable[] =
1066         {
1067                 { PN(checkAlways),      PN(externalMemoryHostPropertiesEXT.minImportedHostPointerAlignment),    LIM_MAX_DEVSIZE(65536) },
1068         };
1069
1070         log << TestLog::Message << externalMemoryHostPropertiesEXT << TestLog::EndMessage;
1071
1072         for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1073                 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1074
1075         if (limitsOk)
1076                 return tcu::TestStatus::pass("pass");
1077         else
1078                 return tcu::TestStatus::fail("fail");
1079 }
1080
1081 void checkSupportExtBlendOperationAdvanced (Context& context)
1082 {
1083         context.requireDeviceFunctionality("VK_EXT_blend_operation_advanced");
1084 }
1085
1086 tcu::TestStatus validateLimitsExtBlendOperationAdvanced (Context& context)
1087 {
1088         const VkBool32                                                                                          checkAlways                                                     = VK_TRUE;
1089         const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT&      blendOperationAdvancedPropertiesEXT     = context.getBlendOperationAdvancedPropertiesEXT();
1090         TestLog&                                                                                                        log                                                                     = context.getTestContext().getLog();
1091         bool                                                                                                            limitsOk                                                        = true;
1092
1093         FeatureLimitTableItem featureLimitTable[] =
1094         {
1095                 { PN(checkAlways),      PN(blendOperationAdvancedPropertiesEXT.advancedBlendMaxColorAttachments),       LIM_MIN_UINT32(1) },
1096         };
1097
1098         log << TestLog::Message << blendOperationAdvancedPropertiesEXT << TestLog::EndMessage;
1099
1100         for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1101                 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1102
1103         if (limitsOk)
1104                 return tcu::TestStatus::pass("pass");
1105         else
1106                 return tcu::TestStatus::fail("fail");
1107 }
1108
1109 void checkSupportKhrMaintenance3 (Context& context)
1110 {
1111         context.requireDeviceFunctionality("VK_KHR_maintenance3");
1112 }
1113
1114 void checkSupportKhrMaintenance4 (Context& context)
1115 {
1116         context.requireDeviceFunctionality("VK_KHR_maintenance4");
1117 }
1118
1119 tcu::TestStatus validateLimitsKhrMaintenance3 (Context& context)
1120 {
1121         const VkBool32                                                                  checkAlways                             = VK_TRUE;
1122         const VkPhysicalDeviceMaintenance3Properties&   maintenance3Properties  = context.getMaintenance3Properties();
1123         TestLog&                                                                                log                                             = context.getTestContext().getLog();
1124         bool                                                                                    limitsOk                                = true;
1125
1126         FeatureLimitTableItem featureLimitTable[] =
1127         {
1128                 { PN(checkAlways),      PN(maintenance3Properties.maxPerSetDescriptors),        LIM_MIN_UINT32(1024) },
1129                 { PN(checkAlways),      PN(maintenance3Properties.maxMemoryAllocationSize),     LIM_MIN_DEVSIZE(1<<30) },
1130         };
1131
1132         log << TestLog::Message << maintenance3Properties << TestLog::EndMessage;
1133
1134         for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1135                 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1136
1137         if (limitsOk)
1138                 return tcu::TestStatus::pass("pass");
1139         else
1140                 return tcu::TestStatus::fail("fail");
1141 }
1142
1143 tcu::TestStatus validateLimitsKhrMaintenance4 (Context& context)
1144 {
1145         const VkBool32                                                                  checkAlways                             = VK_TRUE;
1146         const VkPhysicalDeviceMaintenance4Properties&   maintenance4Properties  = context.getMaintenance4Properties();
1147         TestLog&                                                                                log                                             = context.getTestContext().getLog();
1148         bool                                                                                    limitsOk                                = true;
1149
1150         FeatureLimitTableItem featureLimitTable[] =
1151         {
1152                 { PN(checkAlways),      PN(maintenance4Properties.maxBufferSize),       LIM_MIN_DEVSIZE(1<<30) },
1153         };
1154
1155         log << TestLog::Message << maintenance4Properties << TestLog::EndMessage;
1156
1157         for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1158                 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1159
1160         if (limitsOk)
1161                 return tcu::TestStatus::pass("pass");
1162         else
1163                 return tcu::TestStatus::fail("fail");
1164 }
1165
1166 void checkSupportExtConservativeRasterization (Context& context)
1167 {
1168         context.requireDeviceFunctionality("VK_EXT_conservative_rasterization");
1169 }
1170
1171 tcu::TestStatus validateLimitsExtConservativeRasterization (Context& context)
1172 {
1173         const VkBool32                                                                                                  checkAlways                                                             = VK_TRUE;
1174         const VkPhysicalDeviceConservativeRasterizationPropertiesEXT&   conservativeRasterizationPropertiesEXT  = context.getConservativeRasterizationPropertiesEXT();
1175         TestLog&                                                                                                                log                                                                             = context.getTestContext().getLog();
1176         bool                                                                                                                    limitsOk                                                                = true;
1177
1178         FeatureLimitTableItem featureLimitTable[] =
1179         {
1180                 { PN(checkAlways),      PN(conservativeRasterizationPropertiesEXT.primitiveOverestimationSize),                                 LIM_MIN_FLOAT(0.0f) },
1181                 { PN(checkAlways),      PN(conservativeRasterizationPropertiesEXT.maxExtraPrimitiveOverestimationSize),                 LIM_MIN_FLOAT(0.0f) },
1182                 { PN(checkAlways),      PN(conservativeRasterizationPropertiesEXT.extraPrimitiveOverestimationSizeGranularity), LIM_MIN_FLOAT(0.0f) },
1183         };
1184
1185         log << TestLog::Message << conservativeRasterizationPropertiesEXT << TestLog::EndMessage;
1186
1187         for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1188                 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1189
1190         if (limitsOk)
1191                 return tcu::TestStatus::pass("pass");
1192         else
1193                 return tcu::TestStatus::fail("fail");
1194 }
1195
1196 void checkSupportExtDescriptorIndexing (Context& context)
1197 {
1198         const std::string&                                                      requiredDeviceExtension         = "VK_EXT_descriptor_indexing";
1199         const VkPhysicalDevice                                          physicalDevice                          = context.getPhysicalDevice();
1200         const InstanceInterface&                                        vki                                                     = context.getInstanceInterface();
1201         const std::vector<VkExtensionProperties>        deviceExtensionProperties       = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL);
1202
1203         if (!isExtensionSupported(deviceExtensionProperties, RequiredExtension(requiredDeviceExtension)))
1204                 TCU_THROW(NotSupportedError, requiredDeviceExtension + " is not supported");
1205
1206         // Extension string is present, then extension is really supported and should have been added into chain in DefaultDevice properties and features
1207 }
1208
1209 tcu::TestStatus validateLimitsExtDescriptorIndexing (Context& context)
1210 {
1211         const VkBool32                                                                                  checkAlways                                             = VK_TRUE;
1212         const VkPhysicalDeviceProperties2&                                              properties2                                             = context.getDeviceProperties2();
1213         const VkPhysicalDeviceLimits&                                                   limits                                                  = properties2.properties.limits;
1214         const VkPhysicalDeviceDescriptorIndexingPropertiesEXT&  descriptorIndexingPropertiesEXT = context.getDescriptorIndexingProperties();
1215         const VkPhysicalDeviceFeatures&                                                 features                                                = context.getDeviceFeatures();
1216         const deUint32                                                                                  tessellationShaderCount                 = (features.tessellationShader) ? 2 : 0;
1217         const deUint32                                                                                  geometryShaderCount                             = (features.geometryShader) ? 1 : 0;
1218         const deUint32                                                                                  shaderStages                                    = 3 + tessellationShaderCount + geometryShaderCount;
1219         TestLog&                                                                                                log                                                             = context.getTestContext().getLog();
1220         bool                                                                                                    limitsOk                                                = true;
1221
1222         FeatureLimitTableItem featureLimitTable[] =
1223         {
1224                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxUpdateAfterBindDescriptorsInAllPools),                            LIM_MIN_UINT32(500000) },
1225                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindSamplers),                       LIM_MIN_UINT32(500000) },
1226                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindUniformBuffers),         LIM_MIN_UINT32(12) },
1227                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindStorageBuffers),         LIM_MIN_UINT32(500000) },
1228                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindSampledImages),          LIM_MIN_UINT32(500000) },
1229                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindStorageImages),          LIM_MIN_UINT32(500000) },
1230                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindInputAttachments),       LIM_MIN_UINT32(4) },
1231                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxPerStageUpdateAfterBindResources),                                        LIM_MIN_UINT32(500000) },
1232                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindSamplers),                            LIM_MIN_UINT32(500000) },
1233                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindUniformBuffers),                      LIM_MIN_UINT32(shaderStages * 12) },
1234                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic),       LIM_MIN_UINT32(8) },
1235                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindStorageBuffers),                      LIM_MIN_UINT32(500000) },
1236                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic),       LIM_MIN_UINT32(4) },
1237                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindSampledImages),                       LIM_MIN_UINT32(500000) },
1238                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindStorageImages),                       LIM_MIN_UINT32(500000) },
1239                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindInputAttachments),            LIM_MIN_UINT32(4) },
1240                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindSamplers),                       LIM_MIN_UINT32(limits.maxPerStageDescriptorSamplers) },
1241                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindUniformBuffers),         LIM_MIN_UINT32(limits.maxPerStageDescriptorUniformBuffers) },
1242                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindStorageBuffers),         LIM_MIN_UINT32(limits.maxPerStageDescriptorStorageBuffers) },
1243                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindSampledImages),          LIM_MIN_UINT32(limits.maxPerStageDescriptorSampledImages) },
1244                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindStorageImages),          LIM_MIN_UINT32(limits.maxPerStageDescriptorStorageImages) },
1245                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxPerStageDescriptorUpdateAfterBindInputAttachments),       LIM_MIN_UINT32(limits.maxPerStageDescriptorInputAttachments) },
1246                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxPerStageUpdateAfterBindResources),                                        LIM_MIN_UINT32(limits.maxPerStageResources) },
1247                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindSamplers),                            LIM_MIN_UINT32(limits.maxDescriptorSetSamplers) },
1248                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindUniformBuffers),                      LIM_MIN_UINT32(limits.maxDescriptorSetUniformBuffers) },
1249                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic),       LIM_MIN_UINT32(limits.maxDescriptorSetUniformBuffersDynamic) },
1250                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindStorageBuffers),                      LIM_MIN_UINT32(limits.maxDescriptorSetStorageBuffers) },
1251                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic),       LIM_MIN_UINT32(limits.maxDescriptorSetStorageBuffersDynamic) },
1252                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindSampledImages),                       LIM_MIN_UINT32(limits.maxDescriptorSetSampledImages) },
1253                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindStorageImages),                       LIM_MIN_UINT32(limits.maxDescriptorSetStorageImages) },
1254                 { PN(checkAlways),      PN(descriptorIndexingPropertiesEXT.maxDescriptorSetUpdateAfterBindInputAttachments),            LIM_MIN_UINT32(limits.maxDescriptorSetInputAttachments) },
1255         };
1256
1257         log << TestLog::Message << descriptorIndexingPropertiesEXT << TestLog::EndMessage;
1258
1259         for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1260                 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1261
1262         if (limitsOk)
1263                 return tcu::TestStatus::pass("pass");
1264         else
1265                 return tcu::TestStatus::fail("fail");
1266 }
1267
1268 void checkSupportExtInlineUniformBlock (Context& context)
1269 {
1270         context.requireDeviceFunctionality("VK_EXT_inline_uniform_block");
1271 }
1272
1273 tcu::TestStatus validateLimitsExtInlineUniformBlock (Context& context)
1274 {
1275         const VkBool32                                                                                  checkAlways                                             = VK_TRUE;
1276         const VkPhysicalDeviceInlineUniformBlockProperties&             inlineUniformBlockPropertiesEXT = context.getInlineUniformBlockProperties();
1277         TestLog&                                                                                                log                                                             = context.getTestContext().getLog();
1278         bool                                                                                                    limitsOk                                                = true;
1279
1280         FeatureLimitTableItem featureLimitTable[] =
1281         {
1282                 { PN(checkAlways),      PN(inlineUniformBlockPropertiesEXT.maxInlineUniformBlockSize),                                                                  LIM_MIN_UINT32(256) },
1283                 { PN(checkAlways),      PN(inlineUniformBlockPropertiesEXT.maxPerStageDescriptorInlineUniformBlocks),                                   LIM_MIN_UINT32(4) },
1284                 { PN(checkAlways),      PN(inlineUniformBlockPropertiesEXT.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks),    LIM_MIN_UINT32(4) },
1285                 { PN(checkAlways),      PN(inlineUniformBlockPropertiesEXT.maxDescriptorSetInlineUniformBlocks),                                                LIM_MIN_UINT32(4) },
1286                 { PN(checkAlways),      PN(inlineUniformBlockPropertiesEXT.maxDescriptorSetUpdateAfterBindInlineUniformBlocks),                 LIM_MIN_UINT32(4) },
1287         };
1288
1289         log << TestLog::Message << inlineUniformBlockPropertiesEXT << TestLog::EndMessage;
1290
1291         for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1292                 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1293
1294         if (limitsOk)
1295                 return tcu::TestStatus::pass("pass");
1296         else
1297                 return tcu::TestStatus::fail("fail");
1298 }
1299
1300 void checkSupportExtVertexAttributeDivisor (Context& context)
1301 {
1302         context.requireDeviceFunctionality("VK_EXT_vertex_attribute_divisor");
1303 }
1304
1305 tcu::TestStatus validateLimitsExtVertexAttributeDivisor (Context& context)
1306 {
1307         const VkBool32                                                                                          checkAlways                                                     = VK_TRUE;
1308         const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT&      vertexAttributeDivisorPropertiesEXT     = context.getVertexAttributeDivisorPropertiesEXT();
1309         TestLog&                                                                                                        log                                                                     = context.getTestContext().getLog();
1310         bool                                                                                                            limitsOk                                                        = true;
1311
1312         FeatureLimitTableItem featureLimitTable[] =
1313         {
1314                 { PN(checkAlways),      PN(vertexAttributeDivisorPropertiesEXT.maxVertexAttribDivisor), LIM_MIN_UINT32((1<<16) - 1) },
1315         };
1316
1317         log << TestLog::Message << vertexAttributeDivisorPropertiesEXT << TestLog::EndMessage;
1318
1319         for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1320                 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1321
1322         if (limitsOk)
1323                 return tcu::TestStatus::pass("pass");
1324         else
1325                 return tcu::TestStatus::fail("fail");
1326 }
1327
1328 void checkSupportNvMeshShader (Context& context)
1329 {
1330         const std::string&                                                      requiredDeviceExtension         = "VK_NV_mesh_shader";
1331         const VkPhysicalDevice                                          physicalDevice                          = context.getPhysicalDevice();
1332         const InstanceInterface&                                        vki                                                     = context.getInstanceInterface();
1333         const std::vector<VkExtensionProperties>        deviceExtensionProperties       = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL);
1334
1335         if (!isExtensionSupported(deviceExtensionProperties, RequiredExtension(requiredDeviceExtension)))
1336                 TCU_THROW(NotSupportedError, requiredDeviceExtension + " is not supported");
1337 }
1338
1339 tcu::TestStatus validateLimitsNvMeshShader (Context& context)
1340 {
1341         const VkBool32                                                  checkAlways                             = VK_TRUE;
1342         const VkPhysicalDevice                                  physicalDevice                  = context.getPhysicalDevice();
1343         const InstanceInterface&                                vki                                             = context.getInstanceInterface();
1344         TestLog&                                                                log                                             = context.getTestContext().getLog();
1345         bool                                                                    limitsOk                                = true;
1346         VkPhysicalDeviceMeshShaderPropertiesNV  meshShaderPropertiesNV  = initVulkanStructure();
1347         VkPhysicalDeviceProperties2                             properties2                             = initVulkanStructure(&meshShaderPropertiesNV);
1348
1349         vki.getPhysicalDeviceProperties2(physicalDevice, &properties2);
1350
1351         FeatureLimitTableItem featureLimitTable[] =
1352         {
1353                 { PN(checkAlways),      PN(meshShaderPropertiesNV.maxDrawMeshTasksCount),               LIM_MIN_UINT32(deUint32((1ull<<16) - 1)) },
1354                 { PN(checkAlways),      PN(meshShaderPropertiesNV.maxTaskWorkGroupInvocations), LIM_MIN_UINT32(32) },
1355                 { PN(checkAlways),      PN(meshShaderPropertiesNV.maxTaskWorkGroupSize[0]),             LIM_MIN_UINT32(32) },
1356                 { PN(checkAlways),      PN(meshShaderPropertiesNV.maxTaskWorkGroupSize[1]),             LIM_MIN_UINT32(1) },
1357                 { PN(checkAlways),      PN(meshShaderPropertiesNV.maxTaskWorkGroupSize[2]),             LIM_MIN_UINT32(1) },
1358                 { PN(checkAlways),      PN(meshShaderPropertiesNV.maxTaskTotalMemorySize),              LIM_MIN_UINT32(16384) },
1359                 { PN(checkAlways),      PN(meshShaderPropertiesNV.maxTaskOutputCount),                  LIM_MIN_UINT32((1<<16) - 1) },
1360                 { PN(checkAlways),      PN(meshShaderPropertiesNV.maxMeshWorkGroupInvocations), LIM_MIN_UINT32(32) },
1361                 { PN(checkAlways),      PN(meshShaderPropertiesNV.maxMeshWorkGroupSize[0]),             LIM_MIN_UINT32(32) },
1362                 { PN(checkAlways),      PN(meshShaderPropertiesNV.maxMeshWorkGroupSize[1]),             LIM_MIN_UINT32(1) },
1363                 { PN(checkAlways),      PN(meshShaderPropertiesNV.maxMeshWorkGroupSize[2]),             LIM_MIN_UINT32(1) },
1364                 { PN(checkAlways),      PN(meshShaderPropertiesNV.maxMeshTotalMemorySize),              LIM_MIN_UINT32(16384) },
1365                 { PN(checkAlways),      PN(meshShaderPropertiesNV.maxMeshOutputVertices),               LIM_MIN_UINT32(256) },
1366                 { PN(checkAlways),      PN(meshShaderPropertiesNV.maxMeshOutputPrimitives),             LIM_MIN_UINT32(256) },
1367                 { PN(checkAlways),      PN(meshShaderPropertiesNV.maxMeshMultiviewViewCount),   LIM_MIN_UINT32(1) },
1368         };
1369
1370         log << TestLog::Message << meshShaderPropertiesNV << TestLog::EndMessage;
1371
1372         for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1373                 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1374
1375         if (limitsOk)
1376                 return tcu::TestStatus::pass("pass");
1377         else
1378                 return tcu::TestStatus::fail("fail");
1379 }
1380
1381 void checkSupportExtTransformFeedback (Context& context)
1382 {
1383         context.requireDeviceFunctionality("VK_EXT_transform_feedback");
1384 }
1385
1386 tcu::TestStatus validateLimitsExtTransformFeedback (Context& context)
1387 {
1388         const VkBool32                                                                                  checkAlways                                             = VK_TRUE;
1389         const VkPhysicalDeviceTransformFeedbackPropertiesEXT&   transformFeedbackPropertiesEXT  = context.getTransformFeedbackPropertiesEXT();
1390         TestLog&                                                                                                log                                                             = context.getTestContext().getLog();
1391         bool                                                                                                    limitsOk                                                = true;
1392
1393         FeatureLimitTableItem featureLimitTable[] =
1394         {
1395                 { PN(checkAlways),      PN(transformFeedbackPropertiesEXT.maxTransformFeedbackStreams),                         LIM_MIN_UINT32(1) },
1396                 { PN(checkAlways),      PN(transformFeedbackPropertiesEXT.maxTransformFeedbackBuffers),                         LIM_MIN_UINT32(1) },
1397                 { PN(checkAlways),      PN(transformFeedbackPropertiesEXT.maxTransformFeedbackBufferSize),                      LIM_MIN_DEVSIZE(1ull<<27) },
1398                 { PN(checkAlways),      PN(transformFeedbackPropertiesEXT.maxTransformFeedbackStreamDataSize),          LIM_MIN_UINT32(512) },
1399                 { PN(checkAlways),      PN(transformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataSize),          LIM_MIN_UINT32(512) },
1400                 { PN(checkAlways),      PN(transformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataStride),        LIM_MIN_UINT32(512) },
1401         };
1402
1403         log << TestLog::Message << transformFeedbackPropertiesEXT << TestLog::EndMessage;
1404
1405         for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1406                 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1407
1408         if (limitsOk)
1409                 return tcu::TestStatus::pass("pass");
1410         else
1411                 return tcu::TestStatus::fail("fail");
1412 }
1413
1414 void checkSupportExtFragmentDensityMap (Context& context)
1415 {
1416         context.requireDeviceFunctionality("VK_EXT_fragment_density_map");
1417 }
1418
1419 tcu::TestStatus validateLimitsExtFragmentDensityMap (Context& context)
1420 {
1421         const VkBool32                                                                                  checkAlways                                             = VK_TRUE;
1422         const VkPhysicalDeviceFragmentDensityMapPropertiesEXT&  fragmentDensityMapPropertiesEXT = context.getFragmentDensityMapPropertiesEXT();
1423         TestLog&                                                                                                log                                                             = context.getTestContext().getLog();
1424         bool                                                                                                    limitsOk                                                = true;
1425
1426         FeatureLimitTableItem featureLimitTable[] =
1427         {
1428                 { PN(checkAlways),      PN(fragmentDensityMapPropertiesEXT.minFragmentDensityTexelSize.width),                                                  LIM_MIN_UINT32(1) },
1429                 { PN(checkAlways),      PN(fragmentDensityMapPropertiesEXT.minFragmentDensityTexelSize.height),                                                 LIM_MIN_UINT32(1) },
1430                 { PN(checkAlways),      PN(fragmentDensityMapPropertiesEXT.maxFragmentDensityTexelSize.width),                                                  LIM_MIN_UINT32(1) },
1431                 { PN(checkAlways),      PN(fragmentDensityMapPropertiesEXT.maxFragmentDensityTexelSize.height),                                                 LIM_MIN_UINT32(1) },
1432         };
1433
1434         log << TestLog::Message << fragmentDensityMapPropertiesEXT << TestLog::EndMessage;
1435
1436         for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1437                 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1438
1439         if (limitsOk)
1440                 return tcu::TestStatus::pass("pass");
1441         else
1442                 return tcu::TestStatus::fail("fail");
1443 }
1444
1445 void checkSupportNvRayTracing (Context& context)
1446 {
1447         const std::string&                                                      requiredDeviceExtension         = "VK_NV_ray_tracing";
1448         const VkPhysicalDevice                                          physicalDevice                          = context.getPhysicalDevice();
1449         const InstanceInterface&                                        vki                                                     = context.getInstanceInterface();
1450         const std::vector<VkExtensionProperties>        deviceExtensionProperties       = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL);
1451
1452         if (!isExtensionSupported(deviceExtensionProperties, RequiredExtension(requiredDeviceExtension)))
1453                 TCU_THROW(NotSupportedError, requiredDeviceExtension + " is not supported");
1454 }
1455
1456 tcu::TestStatus validateLimitsNvRayTracing (Context& context)
1457 {
1458         const VkBool32                                                  checkAlways                             = VK_TRUE;
1459         const VkPhysicalDevice                                  physicalDevice                  = context.getPhysicalDevice();
1460         const InstanceInterface&                                vki                                             = context.getInstanceInterface();
1461         TestLog&                                                                log                                             = context.getTestContext().getLog();
1462         bool                                                                    limitsOk                                = true;
1463         VkPhysicalDeviceRayTracingPropertiesNV  rayTracingPropertiesNV  = initVulkanStructure();
1464         VkPhysicalDeviceProperties2                             properties2                             = initVulkanStructure(&rayTracingPropertiesNV);
1465
1466         vki.getPhysicalDeviceProperties2(physicalDevice, &properties2);
1467
1468         FeatureLimitTableItem featureLimitTable[] =
1469         {
1470                 { PN(checkAlways),      PN(rayTracingPropertiesNV.shaderGroupHandleSize),                                       LIM_MIN_UINT32(16) },
1471                 { PN(checkAlways),      PN(rayTracingPropertiesNV.maxRecursionDepth),                                           LIM_MIN_UINT32(31) },
1472                 { PN(checkAlways),      PN(rayTracingPropertiesNV.shaderGroupBaseAlignment),                            LIM_MIN_UINT32(64) },
1473                 { PN(checkAlways),      PN(rayTracingPropertiesNV.maxGeometryCount),                                            LIM_MIN_UINT32((1<<24) - 1) },
1474                 { PN(checkAlways),      PN(rayTracingPropertiesNV.maxInstanceCount),                                            LIM_MIN_UINT32((1<<24) - 1) },
1475                 { PN(checkAlways),      PN(rayTracingPropertiesNV.maxTriangleCount),                                            LIM_MIN_UINT32((1<<29) - 1) },
1476                 { PN(checkAlways),      PN(rayTracingPropertiesNV.maxDescriptorSetAccelerationStructures),      LIM_MIN_UINT32(16) },
1477         };
1478
1479         log << TestLog::Message << rayTracingPropertiesNV << TestLog::EndMessage;
1480
1481         for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1482                 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1483
1484         if (limitsOk)
1485                 return tcu::TestStatus::pass("pass");
1486         else
1487                 return tcu::TestStatus::fail("fail");
1488 }
1489
1490 void checkSupportKhrTimelineSemaphore (Context& context)
1491 {
1492         context.requireDeviceFunctionality("VK_KHR_timeline_semaphore");
1493 }
1494
1495 tcu::TestStatus validateLimitsKhrTimelineSemaphore (Context& context)
1496 {
1497         const VkBool32                                                                                  checkAlways                                             = VK_TRUE;
1498         const VkPhysicalDeviceTimelineSemaphorePropertiesKHR&   timelineSemaphorePropertiesKHR  = context.getTimelineSemaphoreProperties();
1499         bool                                                                                                    limitsOk                                                = true;
1500         TestLog&                                                                                                log                                                             = context.getTestContext().getLog();
1501
1502         FeatureLimitTableItem featureLimitTable[] =
1503         {
1504                 { PN(checkAlways),      PN(timelineSemaphorePropertiesKHR.maxTimelineSemaphoreValueDifference), LIM_MIN_DEVSIZE((1ull<<31) - 1) },
1505         };
1506
1507         log << TestLog::Message << timelineSemaphorePropertiesKHR << TestLog::EndMessage;
1508
1509         for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1510                 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1511
1512         if (limitsOk)
1513                 return tcu::TestStatus::pass("pass");
1514         else
1515                 return tcu::TestStatus::fail("fail");
1516 }
1517
1518 void checkSupportExtLineRasterization (Context& context)
1519 {
1520         context.requireDeviceFunctionality("VK_EXT_line_rasterization");
1521 }
1522
1523 tcu::TestStatus validateLimitsExtLineRasterization (Context& context)
1524 {
1525         const VkBool32                                                                                  checkAlways                                             = VK_TRUE;
1526         const VkPhysicalDeviceLineRasterizationPropertiesEXT&   lineRasterizationPropertiesEXT  = context.getLineRasterizationPropertiesEXT();
1527         TestLog&                                                                                                log                                                             = context.getTestContext().getLog();
1528         bool                                                                                                    limitsOk                                                = true;
1529
1530         FeatureLimitTableItem featureLimitTable[] =
1531         {
1532                 { PN(checkAlways),      PN(lineRasterizationPropertiesEXT.lineSubPixelPrecisionBits),   LIM_MIN_UINT32(4) },
1533         };
1534
1535         log << TestLog::Message << lineRasterizationPropertiesEXT << TestLog::EndMessage;
1536
1537         for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1538                 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1539
1540         if (limitsOk)
1541                 return tcu::TestStatus::pass("pass");
1542         else
1543                 return tcu::TestStatus::fail("fail");
1544 }
1545
1546 tcu::TestStatus validateLimitsMaxInlineUniformTotalSize (Context& context)
1547 {
1548         const VkBool32                                                          checkAlways                     = VK_TRUE;
1549         const VkPhysicalDeviceVulkan13Properties&       vulkan13Properties      = context.getDeviceVulkan13Properties();
1550         bool                                                                            limitsOk                        = true;
1551         TestLog&                                                                        log                                     = context.getTestContext().getLog();
1552
1553         FeatureLimitTableItem featureLimitTable[] =
1554         {
1555                 { PN(checkAlways),      PN(vulkan13Properties.maxInlineUniformTotalSize),       LIM_MIN_DEVSIZE(256) },
1556         };
1557
1558         log << TestLog::Message << vulkan13Properties << TestLog::EndMessage;
1559
1560         for (deUint32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(featureLimitTable); ndx++)
1561                 limitsOk = validateLimit(featureLimitTable[ndx], log) && limitsOk;
1562
1563         if (limitsOk)
1564                 return tcu::TestStatus::pass("pass");
1565         else
1566                 return tcu::TestStatus::fail("fail");
1567 }
1568
1569 tcu::TestStatus validateRoadmap2022(Context& context)
1570 {
1571         if (context.getUsedApiVersion() < VK_API_VERSION_1_3)
1572                 TCU_THROW(NotSupportedError, "Profile not supported");
1573
1574         const VkBool32  checkAlways                             = VK_TRUE;
1575         VkBool32                oneOrMoreChecksFailed   = VK_FALSE;
1576         TestLog&                log                                             = context.getTestContext().getLog();
1577
1578         auto                    vk10Features                    = context.getDeviceFeatures();
1579         auto                    vk11Features                    = context.getDeviceVulkan11Features();
1580         auto                    vk12Features                    = context.getDeviceVulkan12Features();
1581
1582         const auto&             vk10Properties                  = context.getDeviceProperties2();
1583         const auto&             vk11Properties                  = context.getDeviceVulkan11Properties();
1584         const auto&             vk12Properties                  = context.getDeviceVulkan12Properties();
1585         const auto&             vk13Properties                  = context.getDeviceVulkan13Properties();
1586         const auto&             limits                                  = vk10Properties.properties.limits;
1587
1588         #define ROADMAP_FEATURE_ITEM(STRUC, FIELD) { &(STRUC), &(STRUC.FIELD), #STRUC "." #FIELD }
1589
1590         struct FeatureTable
1591         {
1592                 void*           structPtr;
1593                 VkBool32*       fieldPtr;
1594                 const char*     fieldName;
1595         };
1596
1597         std::vector<FeatureTable> featureTable
1598         {
1599                 // Vulkan 1.0 Features
1600                 ROADMAP_FEATURE_ITEM(vk10Features, fullDrawIndexUint32),
1601                 ROADMAP_FEATURE_ITEM(vk10Features, imageCubeArray),
1602                 ROADMAP_FEATURE_ITEM(vk10Features, independentBlend),
1603                 ROADMAP_FEATURE_ITEM(vk10Features, sampleRateShading),
1604                 ROADMAP_FEATURE_ITEM(vk10Features, drawIndirectFirstInstance),
1605                 ROADMAP_FEATURE_ITEM(vk10Features, depthClamp),
1606                 ROADMAP_FEATURE_ITEM(vk10Features, depthBiasClamp),
1607                 ROADMAP_FEATURE_ITEM(vk10Features, samplerAnisotropy),
1608                 ROADMAP_FEATURE_ITEM(vk10Features, occlusionQueryPrecise),
1609                 ROADMAP_FEATURE_ITEM(vk10Features, fragmentStoresAndAtomics),
1610                 ROADMAP_FEATURE_ITEM(vk10Features, shaderStorageImageExtendedFormats),
1611                 ROADMAP_FEATURE_ITEM(vk10Features, shaderUniformBufferArrayDynamicIndexing),
1612                 ROADMAP_FEATURE_ITEM(vk10Features, shaderSampledImageArrayDynamicIndexing),
1613                 ROADMAP_FEATURE_ITEM(vk10Features, shaderStorageBufferArrayDynamicIndexing),
1614                 ROADMAP_FEATURE_ITEM(vk10Features, shaderStorageImageArrayDynamicIndexing),
1615
1616                 // Vulkan 1.1 Features
1617                 ROADMAP_FEATURE_ITEM(vk11Features, samplerYcbcrConversion),
1618
1619                 // Vulkan 1.2 Features
1620                 ROADMAP_FEATURE_ITEM(vk12Features, samplerMirrorClampToEdge),
1621                 ROADMAP_FEATURE_ITEM(vk12Features, descriptorIndexing),
1622                 ROADMAP_FEATURE_ITEM(vk12Features, shaderUniformTexelBufferArrayDynamicIndexing),
1623                 ROADMAP_FEATURE_ITEM(vk12Features, shaderStorageTexelBufferArrayDynamicIndexing),
1624                 ROADMAP_FEATURE_ITEM(vk12Features, shaderUniformBufferArrayNonUniformIndexing),
1625                 ROADMAP_FEATURE_ITEM(vk12Features, shaderSampledImageArrayNonUniformIndexing),
1626                 ROADMAP_FEATURE_ITEM(vk12Features, shaderStorageBufferArrayNonUniformIndexing),
1627                 ROADMAP_FEATURE_ITEM(vk12Features, shaderStorageImageArrayNonUniformIndexing),
1628                 ROADMAP_FEATURE_ITEM(vk12Features, shaderUniformTexelBufferArrayNonUniformIndexing),
1629                 ROADMAP_FEATURE_ITEM(vk12Features, shaderStorageTexelBufferArrayNonUniformIndexing),
1630                 ROADMAP_FEATURE_ITEM(vk12Features, descriptorBindingSampledImageUpdateAfterBind),
1631                 ROADMAP_FEATURE_ITEM(vk12Features, descriptorBindingStorageImageUpdateAfterBind),
1632                 ROADMAP_FEATURE_ITEM(vk12Features, descriptorBindingStorageBufferUpdateAfterBind),
1633                 ROADMAP_FEATURE_ITEM(vk12Features, descriptorBindingUniformTexelBufferUpdateAfterBind),
1634                 ROADMAP_FEATURE_ITEM(vk12Features, descriptorBindingStorageTexelBufferUpdateAfterBind),
1635                 ROADMAP_FEATURE_ITEM(vk12Features, descriptorBindingUpdateUnusedWhilePending),
1636                 ROADMAP_FEATURE_ITEM(vk12Features, descriptorBindingPartiallyBound),
1637                 ROADMAP_FEATURE_ITEM(vk12Features, descriptorBindingVariableDescriptorCount),
1638                 ROADMAP_FEATURE_ITEM(vk12Features, runtimeDescriptorArray),
1639                 ROADMAP_FEATURE_ITEM(vk12Features, scalarBlockLayout),
1640         };
1641
1642         for (FeatureTable& testedFeature : featureTable)
1643         {
1644                 if (!testedFeature.fieldPtr[0])
1645                 {
1646                         log << TestLog::Message
1647                                 << "Feature " << testedFeature.fieldName << "is not supported"
1648                                 << TestLog::EndMessage;
1649                         oneOrMoreChecksFailed = VK_TRUE;
1650                 }
1651         }
1652
1653         std::vector<FeatureLimitTableItem> featureLimitTable
1654         {
1655                 // Vulkan 1.0 limits
1656                 { PN(checkAlways),              PN(limits.maxImageDimension1D),                                                         LIM_MIN_UINT32(8192) },
1657                 { PN(checkAlways),              PN(limits.maxImageDimension2D),                                                         LIM_MIN_UINT32(8192) },
1658                 { PN(checkAlways),              PN(limits.maxImageDimensionCube),                                                       LIM_MIN_UINT32(8192) },
1659                 { PN(checkAlways),              PN(limits.maxImageArrayLayers),                                                         LIM_MIN_UINT32(2048) },
1660                 { PN(checkAlways),              PN(limits.maxUniformBufferRange),                                                       LIM_MIN_UINT32(65536) },
1661                 { PN(checkAlways),              PN(limits.bufferImageGranularity),                                                      LIM_MAX_DEVSIZE(4096) },
1662                 { PN(checkAlways),              PN(limits.maxPerStageDescriptorSamplers),                                       LIM_MIN_UINT32(64) },
1663                 { PN(checkAlways),              PN(limits.maxPerStageDescriptorUniformBuffers),                         LIM_MIN_UINT32(15) },
1664                 { PN(checkAlways),              PN(limits.maxPerStageDescriptorStorageBuffers),                         LIM_MIN_UINT32(30) },
1665                 { PN(checkAlways),              PN(limits.maxPerStageDescriptorSampledImages),                          LIM_MIN_UINT32(200) },
1666                 { PN(checkAlways),              PN(limits.maxPerStageDescriptorStorageImages),                          LIM_MIN_UINT32(16) },
1667                 { PN(checkAlways),              PN(limits.maxPerStageResources),                                                        LIM_MIN_UINT32(200) },
1668                 { PN(checkAlways),              PN(limits.maxDescriptorSetSamplers),                                            LIM_MIN_UINT32(576) },
1669                 { PN(checkAlways),              PN(limits.maxDescriptorSetUniformBuffers),                                      LIM_MIN_UINT32(90) },
1670                 { PN(checkAlways),              PN(limits.maxDescriptorSetStorageBuffers),                                      LIM_MIN_UINT32(96) },
1671                 { PN(checkAlways),              PN(limits.maxDescriptorSetSampledImages),                                       LIM_MIN_UINT32(1800) },
1672                 { PN(checkAlways),              PN(limits.maxDescriptorSetStorageImages),                                       LIM_MIN_UINT32(144) },
1673                 { PN(checkAlways),              PN(limits.maxFragmentCombinedOutputResources),                          LIM_MIN_UINT32(16) },
1674                 { PN(checkAlways),              PN(limits.maxComputeWorkGroupInvocations),                                      LIM_MIN_UINT32(256) },
1675                 { PN(checkAlways),              PN(limits.maxComputeWorkGroupSize[0]),                                          LIM_MIN_UINT32(256) },
1676                 { PN(checkAlways),              PN(limits.maxComputeWorkGroupSize[1]),                                          LIM_MIN_UINT32(256) },
1677                 { PN(checkAlways),              PN(limits.maxComputeWorkGroupSize[2]),                                          LIM_MIN_UINT32(64) },
1678                 { PN(checkAlways),              PN(limits.subPixelPrecisionBits),                                                       LIM_MIN_UINT32(8) },
1679                 { PN(checkAlways),              PN(limits.mipmapPrecisionBits),                                                         LIM_MIN_UINT32(6) },
1680                 { PN(checkAlways),              PN(limits.maxSamplerLodBias),                                                           LIM_MIN_FLOAT(14.0f) },
1681                 { PN(checkAlways),              PN(limits.pointSizeGranularity),                                                        LIM_MAX_FLOAT(0.125f) },
1682                 { PN(checkAlways),              PN(limits.lineWidthGranularity),                                                        LIM_MAX_FLOAT(0.5f) },
1683                 { PN(checkAlways),              PN(limits.standardSampleLocations),                                                     LIM_MIN_UINT32(1) },
1684                 { PN(checkAlways),              PN(limits.maxColorAttachments),                                                         LIM_MIN_UINT32(7) },
1685
1686                 // Vulkan 1.1 limits
1687                 { PN(checkAlways),              PN(vk11Properties.subgroupSize),                                                        LIM_MIN_UINT32(4) },
1688                 { PN(checkAlways),              PN(vk11Properties.subgroupSupportedStages),                                     LIM_MIN_UINT32(VK_SHADER_STAGE_COMPUTE_BIT|VK_SHADER_STAGE_FRAGMENT_BIT) },
1689                 { PN(checkAlways),              PN(vk11Properties.subgroupSupportedOperations),                         LIM_MIN_UINT32(VK_SUBGROUP_FEATURE_BASIC_BIT|VK_SUBGROUP_FEATURE_VOTE_BIT|
1690                                                                                                                                                                                                                    VK_SUBGROUP_FEATURE_ARITHMETIC_BIT|VK_SUBGROUP_FEATURE_BALLOT_BIT|
1691                                                                                                                                                                                                                    VK_SUBGROUP_FEATURE_SHUFFLE_BIT|VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT|
1692                                                                                                                                                                                                                    VK_SUBGROUP_FEATURE_QUAD_BIT) },
1693                 // Vulkan 1.2 limits
1694                 { PN(checkAlways),              PN(vk12Properties.shaderSignedZeroInfNanPreserveFloat16),       LIM_MIN_UINT32(1) },
1695                 { PN(checkAlways),              PN(vk12Properties.shaderSignedZeroInfNanPreserveFloat32),       LIM_MIN_UINT32(1) },
1696
1697                 // Vulkan 1.3 limits
1698                 { PN(checkAlways),              PN(vk13Properties.maxSubgroupSize),                                                     LIM_MIN_UINT32(4) },
1699         };
1700
1701         for (const auto& featureLimit : featureLimitTable)
1702                 oneOrMoreChecksFailed |= !validateLimit(featureLimit, log);
1703
1704         if (!context.isDeviceFunctionalitySupported("VK_KHR_global_priority"))
1705         {
1706                 log << TestLog::Message
1707                         << "VK_KHR_global_priority is not supported"
1708                         << TestLog::EndMessage;
1709                 oneOrMoreChecksFailed = VK_TRUE;
1710         }
1711
1712         if (oneOrMoreChecksFailed)
1713                 TCU_THROW(NotSupportedError, "Profile not supported");
1714
1715         return tcu::TestStatus::pass("Profile supported");
1716 }
1717
1718 void createTestDevice (Context& context, void* pNext, const char* const* ppEnabledExtensionNames, deUint32 enabledExtensionCount)
1719 {
1720         const PlatformInterface&                                platformInterface               = context.getPlatformInterface();
1721         const auto                                                              validationEnabled               = context.getTestContext().getCommandLine().isValidationEnabled();
1722         const Unique<VkInstance>                                instance                                (createDefaultInstance(platformInterface, context.getUsedApiVersion()));
1723         const InstanceDriver                                    instanceDriver                  (platformInterface, instance.get());
1724         const VkPhysicalDevice                                  physicalDevice                  = chooseDevice(instanceDriver, instance.get(), context.getTestContext().getCommandLine());
1725         const deUint32                                                  queueFamilyIndex                = 0;
1726         const deUint32                                                  queueCount                              = 1;
1727         const deUint32                                                  queueIndex                              = 0;
1728         const float                                                             queuePriority                   = 1.0f;
1729         const vector<VkQueueFamilyProperties>   queueFamilyProperties   = getPhysicalDeviceQueueFamilyProperties(instanceDriver, physicalDevice);
1730         const VkDeviceQueueCreateInfo                   deviceQueueCreateInfo   =
1731         {
1732                 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,     //  VkStructureType                             sType;
1733                 DE_NULL,                                                                        //  const void*                                 pNext;
1734                 (VkDeviceQueueCreateFlags)0u,                           //  VkDeviceQueueCreateFlags    flags;
1735                 queueFamilyIndex,                                                       //  deUint32                                    queueFamilyIndex;
1736                 queueCount,                                                                     //  deUint32                                    queueCount;
1737                 &queuePriority,                                                         //  const float*                                pQueuePriorities;
1738         };
1739         const VkDeviceCreateInfo                                deviceCreateInfo                =
1740         {
1741                 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,           //  VkStructureType                                     sType;
1742                 pNext,                                                                          //  const void*                                         pNext;
1743                 (VkDeviceCreateFlags)0u,                                        //  VkDeviceCreateFlags                         flags;
1744                 1,                                                                                      //  deUint32                                            queueCreateInfoCount;
1745                 &deviceQueueCreateInfo,                                         //  const VkDeviceQueueCreateInfo*      pQueueCreateInfos;
1746                 0,                                                                                      //  deUint32                                            enabledLayerCount;
1747                 DE_NULL,                                                                        //  const char* const*                          ppEnabledLayerNames;
1748                 enabledExtensionCount,                                          //  deUint32                                            enabledExtensionCount;
1749                 ppEnabledExtensionNames,                                        //  const char* const*                          ppEnabledExtensionNames;
1750                 DE_NULL,                                                                        //  const VkPhysicalDeviceFeatures*     pEnabledFeatures;
1751         };
1752         const Unique<VkDevice>                                  device                                  (createCustomDevice(validationEnabled, platformInterface, *instance, instanceDriver, physicalDevice, &deviceCreateInfo));
1753         const DeviceDriver                                              deviceDriver                    (platformInterface, instance.get(), device.get());
1754         const VkQueue                                                   queue                                   = getDeviceQueue(deviceDriver, *device,  queueFamilyIndex, queueIndex);
1755
1756         VK_CHECK(deviceDriver.queueWaitIdle(queue));
1757 }
1758
1759 void cleanVulkanStruct (void* structPtr, size_t structSize)
1760 {
1761         struct StructureBase
1762         {
1763                 VkStructureType         sType;
1764                 void*                           pNext;
1765         };
1766
1767         VkStructureType         sType = ((StructureBase*)structPtr)->sType;
1768
1769         deMemset(structPtr, 0, structSize);
1770
1771         ((StructureBase*)structPtr)->sType = sType;
1772 }
1773
1774 template <deUint32 VK_API_VERSION>
1775 tcu::TestStatus featureBitInfluenceOnDeviceCreate (Context& context)
1776 {
1777 #define FEATURE_TABLE_ITEM(CORE, EXT, FIELD, STR) { &(CORE), sizeof(CORE), &(CORE.FIELD), #CORE "." #FIELD, &(EXT), sizeof(EXT), &(EXT.FIELD), #EXT "." #FIELD, STR }
1778 #define DEPENDENCY_DUAL_ITEM(CORE, EXT, FIELD, PARENT) { &(CORE.FIELD), &(CORE.PARENT) }, { &(EXT.FIELD), &(EXT.PARENT) }
1779 #define DEPENDENCY_SINGLE_ITEM(CORE, FIELD, PARENT) { &(CORE.FIELD), &(CORE.PARENT) }
1780
1781         const VkPhysicalDevice                                                                  physicalDevice                                                  = context.getPhysicalDevice();
1782         const InstanceInterface&                                                                vki                                                                             = context.getInstanceInterface();
1783         TestLog&                                                                                                log                                                                             = context.getTestContext().getLog();
1784         const std::vector<VkExtensionProperties>                                deviceExtensionProperties                               = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL);
1785
1786         VkPhysicalDeviceFeatures2                                                               features2                                                               = initVulkanStructure();
1787
1788         VkPhysicalDeviceVulkan11Features                                                vulkan11Features                                                = initVulkanStructure();
1789         VkPhysicalDeviceVulkan12Features                                                vulkan12Features                                                = initVulkanStructure();
1790         VkPhysicalDevice16BitStorageFeaturesKHR                                 sixteenBitStorageFeatures                               = initVulkanStructure();
1791         VkPhysicalDeviceMultiviewFeatures                                               multiviewFeatures                                               = initVulkanStructure();
1792         VkPhysicalDeviceVariablePointersFeatures                                variablePointersFeatures                                = initVulkanStructure();
1793         VkPhysicalDeviceProtectedMemoryFeatures                                 protectedMemoryFeatures                                 = initVulkanStructure();
1794         VkPhysicalDeviceSamplerYcbcrConversionFeatures                  samplerYcbcrConversionFeatures                  = initVulkanStructure();
1795         VkPhysicalDeviceShaderDrawParametersFeatures                    shaderDrawParametersFeatures                    = initVulkanStructure();
1796         VkPhysicalDevice8BitStorageFeatures                                             eightBitStorageFeatures                                 = initVulkanStructure();
1797         VkPhysicalDeviceShaderAtomicInt64Features                               shaderAtomicInt64Features                               = initVulkanStructure();
1798         VkPhysicalDeviceShaderFloat16Int8Features                               shaderFloat16Int8Features                               = initVulkanStructure();
1799         VkPhysicalDeviceDescriptorIndexingFeatures                              descriptorIndexingFeatures                              = initVulkanStructure();
1800         VkPhysicalDeviceScalarBlockLayoutFeatures                               scalarBlockLayoutFeatures                               = initVulkanStructure();
1801         VkPhysicalDeviceImagelessFramebufferFeatures                    imagelessFramebufferFeatures                    = initVulkanStructure();
1802         VkPhysicalDeviceUniformBufferStandardLayoutFeatures             uniformBufferStandardLayoutFeatures             = initVulkanStructure();
1803         VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures             shaderSubgroupExtendedTypesFeatures             = initVulkanStructure();
1804         VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures             separateDepthStencilLayoutsFeatures             = initVulkanStructure();
1805         VkPhysicalDeviceHostQueryResetFeatures                                  hostQueryResetFeatures                                  = initVulkanStructure();
1806         VkPhysicalDeviceTimelineSemaphoreFeatures                               timelineSemaphoreFeatures                               = initVulkanStructure();
1807         VkPhysicalDeviceBufferDeviceAddressFeatures                             bufferDeviceAddressFeatures                             = initVulkanStructure();
1808         VkPhysicalDeviceVulkanMemoryModelFeatures                               vulkanMemoryModelFeatures                               = initVulkanStructure();
1809
1810         VkPhysicalDeviceVulkan13Features                                                vulkan13Features                                                = initVulkanStructure();
1811         VkPhysicalDeviceImageRobustnessFeatures                                 imageRobustnessFeatures                                 = initVulkanStructure();
1812         VkPhysicalDeviceInlineUniformBlockFeatures                              inlineUniformBlockFeatures                              = initVulkanStructure();
1813         VkPhysicalDevicePipelineCreationCacheControlFeatures    pipelineCreationCacheControlFeatures    = initVulkanStructure();
1814         VkPhysicalDevicePrivateDataFeatures                                             privateDataFeatures                                             = initVulkanStructure();
1815         VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures  shaderDemoteToHelperInvocationFeatures  = initVulkanStructure();
1816         VkPhysicalDeviceShaderTerminateInvocationFeatures               shaderTerminateInvocationFeatures               = initVulkanStructure();
1817         VkPhysicalDeviceSubgroupSizeControlFeatures                             subgroupSizeControlFeatures                             = initVulkanStructure();
1818         VkPhysicalDeviceSynchronization2Features                                synchronization2Features                                = initVulkanStructure();
1819         VkPhysicalDeviceTextureCompressionASTCHDRFeatures               textureCompressionASTCHDRFeatures               = initVulkanStructure();
1820         VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures   zeroInitializeWorkgroupMemoryFeatures   = initVulkanStructure();
1821         VkPhysicalDeviceDynamicRenderingFeatures                                dynamicRenderingFeatures                                = initVulkanStructure();
1822         VkPhysicalDeviceShaderIntegerDotProductFeatures                 shaderIntegerDotProductFeatures                 = initVulkanStructure();
1823         VkPhysicalDeviceMaintenance4Features                                    maintenance4Features                                    = initVulkanStructure();
1824
1825         struct UnusedExtensionFeatures
1826         {
1827                 VkStructureType         sType;
1828                 void*                           pNext;
1829                 VkBool32                        descriptorIndexing;
1830                 VkBool32                        samplerFilterMinmax;
1831         } unusedExtensionFeatures;
1832
1833         struct FeatureTable
1834         {
1835                 void*           coreStructPtr;
1836                 size_t          coreStructSize;
1837                 VkBool32*       coreFieldPtr;
1838                 const char*     coreFieldName;
1839                 void*           extStructPtr;
1840                 size_t          extStructSize;
1841                 VkBool32*       extFieldPtr;
1842                 const char*     extFieldName;
1843                 const char*     extString;
1844         };
1845         struct FeatureDependencyTable
1846         {
1847                 VkBool32*       featurePtr;
1848                 VkBool32*       dependOnPtr;
1849         };
1850
1851         std::vector<FeatureTable>                       featureTable;
1852         std::vector<FeatureDependencyTable>     featureDependencyTable;
1853
1854         if (VK_API_VERSION == VK_API_VERSION_1_2)
1855         {
1856                 featureTable =
1857                 {
1858                         FEATURE_TABLE_ITEM(vulkan11Features,    sixteenBitStorageFeatures,                              storageBuffer16BitAccess,                                                       "VK_KHR_16bit_storage"),
1859                         FEATURE_TABLE_ITEM(vulkan11Features,    sixteenBitStorageFeatures,                              uniformAndStorageBuffer16BitAccess,                                     "VK_KHR_16bit_storage"),
1860                         FEATURE_TABLE_ITEM(vulkan11Features,    sixteenBitStorageFeatures,                              storagePushConstant16,                                                          "VK_KHR_16bit_storage"),
1861                         FEATURE_TABLE_ITEM(vulkan11Features,    sixteenBitStorageFeatures,                              storageInputOutput16,                                                           "VK_KHR_16bit_storage"),
1862                         FEATURE_TABLE_ITEM(vulkan11Features,    multiviewFeatures,                                              multiview,                                                                                      "VK_KHR_multiview"),
1863                         FEATURE_TABLE_ITEM(vulkan11Features,    multiviewFeatures,                                              multiviewGeometryShader,                                                        "VK_KHR_multiview"),
1864                         FEATURE_TABLE_ITEM(vulkan11Features,    multiviewFeatures,                                              multiviewTessellationShader,                                            "VK_KHR_multiview"),
1865                         FEATURE_TABLE_ITEM(vulkan11Features,    variablePointersFeatures,                               variablePointersStorageBuffer,                                          "VK_KHR_variable_pointers"),
1866                         FEATURE_TABLE_ITEM(vulkan11Features,    variablePointersFeatures,                               variablePointers,                                                                       "VK_KHR_variable_pointers"),
1867                         FEATURE_TABLE_ITEM(vulkan11Features,    protectedMemoryFeatures,                                protectedMemory,                                                                        DE_NULL),
1868                         FEATURE_TABLE_ITEM(vulkan11Features,    samplerYcbcrConversionFeatures,                 samplerYcbcrConversion,                                                         "VK_KHR_sampler_ycbcr_conversion"),
1869                         FEATURE_TABLE_ITEM(vulkan11Features,    shaderDrawParametersFeatures,                   shaderDrawParameters,                                                           DE_NULL),
1870                         FEATURE_TABLE_ITEM(vulkan12Features,    eightBitStorageFeatures,                                storageBuffer8BitAccess,                                                        "VK_KHR_8bit_storage"),
1871                         FEATURE_TABLE_ITEM(vulkan12Features,    eightBitStorageFeatures,                                uniformAndStorageBuffer8BitAccess,                                      "VK_KHR_8bit_storage"),
1872                         FEATURE_TABLE_ITEM(vulkan12Features,    eightBitStorageFeatures,                                storagePushConstant8,                                                           "VK_KHR_8bit_storage"),
1873                         FEATURE_TABLE_ITEM(vulkan12Features,    shaderAtomicInt64Features,                              shaderBufferInt64Atomics,                                                       "VK_KHR_shader_atomic_int64"),
1874                         FEATURE_TABLE_ITEM(vulkan12Features,    shaderAtomicInt64Features,                              shaderSharedInt64Atomics,                                                       "VK_KHR_shader_atomic_int64"),
1875                         FEATURE_TABLE_ITEM(vulkan12Features,    shaderFloat16Int8Features,                              shaderFloat16,                                                                          "VK_KHR_shader_float16_int8"),
1876                         FEATURE_TABLE_ITEM(vulkan12Features,    shaderFloat16Int8Features,                              shaderInt8,                                                                                     "VK_KHR_shader_float16_int8"),
1877                         FEATURE_TABLE_ITEM(vulkan12Features,    unusedExtensionFeatures,                                        descriptorIndexing,                                                                     DE_NULL),
1878                         FEATURE_TABLE_ITEM(vulkan12Features,    descriptorIndexingFeatures,                             shaderInputAttachmentArrayDynamicIndexing,                      "VK_EXT_descriptor_indexing"),
1879                         FEATURE_TABLE_ITEM(vulkan12Features,    descriptorIndexingFeatures,                             shaderUniformTexelBufferArrayDynamicIndexing,           "VK_EXT_descriptor_indexing"),
1880                         FEATURE_TABLE_ITEM(vulkan12Features,    descriptorIndexingFeatures,                             shaderStorageTexelBufferArrayDynamicIndexing,           "VK_EXT_descriptor_indexing"),
1881                         FEATURE_TABLE_ITEM(vulkan12Features,    descriptorIndexingFeatures,                             shaderUniformBufferArrayNonUniformIndexing,                     "VK_EXT_descriptor_indexing"),
1882                         FEATURE_TABLE_ITEM(vulkan12Features,    descriptorIndexingFeatures,                             shaderSampledImageArrayNonUniformIndexing,                      "VK_EXT_descriptor_indexing"),
1883                         FEATURE_TABLE_ITEM(vulkan12Features,    descriptorIndexingFeatures,                             shaderStorageBufferArrayNonUniformIndexing,                     "VK_EXT_descriptor_indexing"),
1884                         FEATURE_TABLE_ITEM(vulkan12Features,    descriptorIndexingFeatures,                             shaderStorageImageArrayNonUniformIndexing,                      "VK_EXT_descriptor_indexing"),
1885                         FEATURE_TABLE_ITEM(vulkan12Features,    descriptorIndexingFeatures,                             shaderInputAttachmentArrayNonUniformIndexing,           "VK_EXT_descriptor_indexing"),
1886                         FEATURE_TABLE_ITEM(vulkan12Features,    descriptorIndexingFeatures,                             shaderUniformTexelBufferArrayNonUniformIndexing,        "VK_EXT_descriptor_indexing"),
1887                         FEATURE_TABLE_ITEM(vulkan12Features,    descriptorIndexingFeatures,                             shaderStorageTexelBufferArrayNonUniformIndexing,        "VK_EXT_descriptor_indexing"),
1888                         FEATURE_TABLE_ITEM(vulkan12Features,    descriptorIndexingFeatures,                             descriptorBindingUniformBufferUpdateAfterBind,          "VK_EXT_descriptor_indexing"),
1889                         FEATURE_TABLE_ITEM(vulkan12Features,    descriptorIndexingFeatures,                             descriptorBindingSampledImageUpdateAfterBind,           "VK_EXT_descriptor_indexing"),
1890                         FEATURE_TABLE_ITEM(vulkan12Features,    descriptorIndexingFeatures,                             descriptorBindingStorageImageUpdateAfterBind,           "VK_EXT_descriptor_indexing"),
1891                         FEATURE_TABLE_ITEM(vulkan12Features,    descriptorIndexingFeatures,                             descriptorBindingStorageBufferUpdateAfterBind,          "VK_EXT_descriptor_indexing"),
1892                         FEATURE_TABLE_ITEM(vulkan12Features,    descriptorIndexingFeatures,                             descriptorBindingUniformTexelBufferUpdateAfterBind,     "VK_EXT_descriptor_indexing"),
1893                         FEATURE_TABLE_ITEM(vulkan12Features,    descriptorIndexingFeatures,                             descriptorBindingStorageTexelBufferUpdateAfterBind,     "VK_EXT_descriptor_indexing"),
1894                         FEATURE_TABLE_ITEM(vulkan12Features,    descriptorIndexingFeatures,                             descriptorBindingUpdateUnusedWhilePending,                      "VK_EXT_descriptor_indexing"),
1895                         FEATURE_TABLE_ITEM(vulkan12Features,    descriptorIndexingFeatures,                             descriptorBindingPartiallyBound,                                        "VK_EXT_descriptor_indexing"),
1896                         FEATURE_TABLE_ITEM(vulkan12Features,    descriptorIndexingFeatures,                             descriptorBindingVariableDescriptorCount,                       "VK_EXT_descriptor_indexing"),
1897                         FEATURE_TABLE_ITEM(vulkan12Features,    descriptorIndexingFeatures,                             runtimeDescriptorArray,                                                         "VK_EXT_descriptor_indexing"),
1898                         FEATURE_TABLE_ITEM(vulkan12Features,    unusedExtensionFeatures,                                        samplerFilterMinmax,                                                            "VK_EXT_sampler_filter_minmax"),
1899                         FEATURE_TABLE_ITEM(vulkan12Features,    scalarBlockLayoutFeatures,                              scalarBlockLayout,                                                                      "VK_EXT_scalar_block_layout"),
1900                         FEATURE_TABLE_ITEM(vulkan12Features,    imagelessFramebufferFeatures,                   imagelessFramebuffer,                                                           "VK_KHR_imageless_framebuffer"),
1901                         FEATURE_TABLE_ITEM(vulkan12Features,    uniformBufferStandardLayoutFeatures,    uniformBufferStandardLayout,                                            "VK_KHR_uniform_buffer_standard_layout"),
1902                         FEATURE_TABLE_ITEM(vulkan12Features,    shaderSubgroupExtendedTypesFeatures,    shaderSubgroupExtendedTypes,                                            "VK_KHR_shader_subgroup_extended_types"),
1903                         FEATURE_TABLE_ITEM(vulkan12Features,    separateDepthStencilLayoutsFeatures,    separateDepthStencilLayouts,                                            "VK_KHR_separate_depth_stencil_layouts"),
1904                         FEATURE_TABLE_ITEM(vulkan12Features,    hostQueryResetFeatures,                                 hostQueryReset,                                                                         "VK_EXT_host_query_reset"),
1905                         FEATURE_TABLE_ITEM(vulkan12Features,    timelineSemaphoreFeatures,                              timelineSemaphore,                                                                      "VK_KHR_timeline_semaphore"),
1906                         FEATURE_TABLE_ITEM(vulkan12Features,    bufferDeviceAddressFeatures,                    bufferDeviceAddress,                                                            "VK_EXT_buffer_device_address"),
1907                         FEATURE_TABLE_ITEM(vulkan12Features,    bufferDeviceAddressFeatures,                    bufferDeviceAddressCaptureReplay,                                       "VK_EXT_buffer_device_address"),
1908                         FEATURE_TABLE_ITEM(vulkan12Features,    bufferDeviceAddressFeatures,                    bufferDeviceAddressMultiDevice,                                         "VK_EXT_buffer_device_address"),
1909                         FEATURE_TABLE_ITEM(vulkan12Features,    vulkanMemoryModelFeatures,                              vulkanMemoryModel,                                                                      "VK_KHR_vulkan_memory_model"),
1910                         FEATURE_TABLE_ITEM(vulkan12Features,    vulkanMemoryModelFeatures,                              vulkanMemoryModelDeviceScope,                                           "VK_KHR_vulkan_memory_model"),
1911                         FEATURE_TABLE_ITEM(vulkan12Features,    vulkanMemoryModelFeatures,                              vulkanMemoryModelAvailabilityVisibilityChains,          "VK_KHR_vulkan_memory_model"),
1912                 };
1913
1914                 featureDependencyTable =
1915                 {
1916                         DEPENDENCY_DUAL_ITEM    (vulkan11Features,      multiviewFeatures,                              multiviewGeometryShader,                                                        multiview),
1917                         DEPENDENCY_DUAL_ITEM    (vulkan11Features,      multiviewFeatures,                              multiviewTessellationShader,                                            multiview),
1918                         DEPENDENCY_DUAL_ITEM    (vulkan11Features,      variablePointersFeatures,               variablePointers,                                                                       variablePointersStorageBuffer),
1919                         DEPENDENCY_DUAL_ITEM    (vulkan12Features,      bufferDeviceAddressFeatures,    bufferDeviceAddressCaptureReplay,                                       bufferDeviceAddress),
1920                         DEPENDENCY_DUAL_ITEM    (vulkan12Features,      bufferDeviceAddressFeatures,    bufferDeviceAddressMultiDevice,                                         bufferDeviceAddress),
1921                         DEPENDENCY_DUAL_ITEM    (vulkan12Features,      vulkanMemoryModelFeatures,              vulkanMemoryModelDeviceScope,                                           vulkanMemoryModel),
1922                         DEPENDENCY_DUAL_ITEM    (vulkan12Features,      vulkanMemoryModelFeatures,              vulkanMemoryModelAvailabilityVisibilityChains,          vulkanMemoryModel),
1923                 };
1924         }
1925         else // if (VK_API_VERSION == VK_API_VERSION_1_3)
1926         {
1927                 featureTable =
1928                 {
1929                         FEATURE_TABLE_ITEM(vulkan13Features,    imageRobustnessFeatures,                                robustImageAccess,                                                                      "VK_EXT_image_robustness"),
1930                         FEATURE_TABLE_ITEM(vulkan13Features,    inlineUniformBlockFeatures,                             inlineUniformBlock,                                                                     "VK_EXT_inline_uniform_block"),
1931                         FEATURE_TABLE_ITEM(vulkan13Features,    inlineUniformBlockFeatures,                             descriptorBindingInlineUniformBlockUpdateAfterBind,     "VK_EXT_inline_uniform_block"),
1932                         FEATURE_TABLE_ITEM(vulkan13Features,    pipelineCreationCacheControlFeatures,   pipelineCreationCacheControl,                                           "VK_EXT_pipeline_creation_cache_control"),
1933                         FEATURE_TABLE_ITEM(vulkan13Features,    privateDataFeatures,                                    privateData,                                                                            "VK_EXT_private_data"),
1934                         FEATURE_TABLE_ITEM(vulkan13Features,    shaderDemoteToHelperInvocationFeatures, shaderDemoteToHelperInvocation,                                         "VK_EXT_shader_demote_to_helper_invocation"),
1935                         FEATURE_TABLE_ITEM(vulkan13Features,    shaderTerminateInvocationFeatures,              shaderTerminateInvocation,                                                      "VK_KHR_shader_terminate_invocation"),
1936                         FEATURE_TABLE_ITEM(vulkan13Features,    subgroupSizeControlFeatures,                    subgroupSizeControl,                                                            "VK_EXT_subgroup_size_control"),
1937                         FEATURE_TABLE_ITEM(vulkan13Features,    subgroupSizeControlFeatures,                    computeFullSubgroups,                                                           "VK_EXT_subgroup_size_control"),
1938                         FEATURE_TABLE_ITEM(vulkan13Features,    synchronization2Features,                               synchronization2,                                                                       "VK_KHR_synchronization2"),
1939                         FEATURE_TABLE_ITEM(vulkan13Features,    textureCompressionASTCHDRFeatures,              textureCompressionASTC_HDR,                                                     "VK_EXT_texture_compression_astc_hdr"),
1940                         FEATURE_TABLE_ITEM(vulkan13Features,    zeroInitializeWorkgroupMemoryFeatures,  shaderZeroInitializeWorkgroupMemory,                            "VK_KHR_zero_initialize_workgroup_memory"),
1941                         FEATURE_TABLE_ITEM(vulkan13Features,    dynamicRenderingFeatures,                               dynamicRendering,                                                                       "VK_KHR_dynamic_rendering"),
1942                         FEATURE_TABLE_ITEM(vulkan13Features,    shaderIntegerDotProductFeatures,                shaderIntegerDotProduct,                                                        "VK_KHR_shader_integer_dot_product"),
1943                         FEATURE_TABLE_ITEM(vulkan13Features,    maintenance4Features,                                   maintenance4,                                                                           "VK_KHR_maintenance4"),
1944                 };
1945         }
1946
1947         deMemset(&unusedExtensionFeatures, 0, sizeof(unusedExtensionFeatures));
1948
1949         for (FeatureTable&      testedFeature : featureTable)
1950         {
1951                 VkBool32                coreFeatureState= DE_FALSE;
1952                 VkBool32                extFeatureState = DE_FALSE;
1953
1954                 // Core test
1955                 {
1956                         void*           structPtr       = testedFeature.coreStructPtr;
1957                         size_t          structSize      = testedFeature.coreStructSize;
1958                         VkBool32*       featurePtr      = testedFeature.coreFieldPtr;
1959
1960                         if (structPtr != &unusedExtensionFeatures)
1961                                 features2.pNext = structPtr;
1962
1963                         vki.getPhysicalDeviceFeatures2(physicalDevice, &features2);
1964
1965                         coreFeatureState = featurePtr[0];
1966
1967                         log << TestLog::Message
1968                                 << "Feature status "
1969                                 << testedFeature.coreFieldName << "=" << coreFeatureState
1970                                 << TestLog::EndMessage;
1971
1972                         if (coreFeatureState)
1973                         {
1974                                 cleanVulkanStruct(structPtr, structSize);
1975
1976                                 featurePtr[0] = DE_TRUE;
1977
1978                                 for (FeatureDependencyTable featureDependency : featureDependencyTable)
1979                                         if (featureDependency.featurePtr == featurePtr)
1980                                                 featureDependency.dependOnPtr[0] = DE_TRUE;
1981
1982                                 createTestDevice(context, &features2, DE_NULL, 0u);
1983                         }
1984                 }
1985
1986                 // ext test
1987                 {
1988                         void*           structPtr               = testedFeature.extStructPtr;
1989                         size_t          structSize              = testedFeature.extStructSize;
1990                         VkBool32*       featurePtr              = testedFeature.extFieldPtr;
1991                         const char*     extStringPtr    = testedFeature.extString;
1992
1993                         if (structPtr != &unusedExtensionFeatures)
1994                                 features2.pNext = structPtr;
1995
1996                         if (extStringPtr == DE_NULL || isExtensionSupported(deviceExtensionProperties, RequiredExtension(extStringPtr)))
1997                         {
1998                                 vki.getPhysicalDeviceFeatures2(physicalDevice, &features2);
1999
2000                                 extFeatureState = *featurePtr;
2001
2002                                 log << TestLog::Message
2003                                         << "Feature status "
2004                                         << testedFeature.extFieldName << "=" << extFeatureState
2005                                         << TestLog::EndMessage;
2006
2007                                 if (extFeatureState)
2008                                 {
2009                                         cleanVulkanStruct(structPtr, structSize);
2010
2011                                         featurePtr[0] = DE_TRUE;
2012
2013                                         for (FeatureDependencyTable& featureDependency : featureDependencyTable)
2014                                                 if (featureDependency.featurePtr == featurePtr)
2015                                                         featureDependency.dependOnPtr[0] = DE_TRUE;
2016
2017                                         createTestDevice(context, &features2, &extStringPtr, (extStringPtr == DE_NULL) ? 0u : 1u );
2018                                 }
2019                         }
2020                 }
2021         }
2022
2023         return tcu::TestStatus::pass("pass");
2024 }
2025
2026 template<typename T>
2027 class CheckIncompleteResult
2028 {
2029 public:
2030         virtual                 ~CheckIncompleteResult  (void) {}
2031         virtual void    getResult                               (Context& context, T* data) = 0;
2032
2033         void operator() (Context& context, tcu::ResultCollector& results, const std::size_t expectedCompleteSize)
2034         {
2035                 if (expectedCompleteSize == 0)
2036                         return;
2037
2038                 vector<T>               outputData      (expectedCompleteSize);
2039                 const deUint32  usedSize        = static_cast<deUint32>(expectedCompleteSize / 3);
2040
2041                 ValidateQueryBits::fillBits(outputData.begin(), outputData.end());      // unused entries should have this pattern intact
2042                 m_count         = usedSize;
2043                 m_result        = VK_SUCCESS;
2044
2045                 getResult(context, &outputData[0]);                                                                     // update m_count and m_result
2046
2047                 if (m_count != usedSize || m_result != VK_INCOMPLETE || !ValidateQueryBits::checkBits(outputData.begin() + m_count, outputData.end()))
2048                         results.fail("Query didn't return VK_INCOMPLETE");
2049         }
2050
2051 protected:
2052         deUint32        m_count;
2053         VkResult        m_result;
2054 };
2055
2056 struct CheckEnumeratePhysicalDevicesIncompleteResult : public CheckIncompleteResult<VkPhysicalDevice>
2057 {
2058         void getResult (Context& context, VkPhysicalDevice* data)
2059         {
2060                 m_result = context.getInstanceInterface().enumeratePhysicalDevices(context.getInstance(), &m_count, data);
2061         }
2062 };
2063
2064 struct CheckEnumeratePhysicalDeviceGroupsIncompleteResult : public CheckIncompleteResult<VkPhysicalDeviceGroupProperties>
2065 {
2066         CheckEnumeratePhysicalDeviceGroupsIncompleteResult (const InstanceInterface& vki, const VkInstance instance)
2067                 : m_vki                 (vki)
2068                 , m_instance    (instance)
2069                 {}
2070
2071         void getResult (Context&, VkPhysicalDeviceGroupProperties* data)
2072         {
2073                 for (uint32_t idx = 0u; idx < m_count; ++idx)
2074                         data[idx] = initVulkanStructure();
2075                 m_result = m_vki.enumeratePhysicalDeviceGroups(m_instance, &m_count, data);
2076         }
2077
2078 protected:
2079         const InstanceInterface&        m_vki;
2080         const VkInstance                        m_instance;
2081 };
2082
2083 struct CheckEnumerateInstanceLayerPropertiesIncompleteResult : public CheckIncompleteResult<VkLayerProperties>
2084 {
2085         void getResult (Context& context, VkLayerProperties* data)
2086         {
2087                 m_result = context.getPlatformInterface().enumerateInstanceLayerProperties(&m_count, data);
2088         }
2089 };
2090
2091 struct CheckEnumerateDeviceLayerPropertiesIncompleteResult : public CheckIncompleteResult<VkLayerProperties>
2092 {
2093         void getResult (Context& context, VkLayerProperties* data)
2094         {
2095                 m_result = context.getInstanceInterface().enumerateDeviceLayerProperties(context.getPhysicalDevice(), &m_count, data);
2096         }
2097 };
2098
2099 struct CheckEnumerateInstanceExtensionPropertiesIncompleteResult : public CheckIncompleteResult<VkExtensionProperties>
2100 {
2101         CheckEnumerateInstanceExtensionPropertiesIncompleteResult (std::string layerName = std::string()) : m_layerName(layerName) {}
2102
2103         void getResult (Context& context, VkExtensionProperties* data)
2104         {
2105                 const char* pLayerName = (m_layerName.length() != 0 ? m_layerName.c_str() : DE_NULL);
2106                 m_result = context.getPlatformInterface().enumerateInstanceExtensionProperties(pLayerName, &m_count, data);
2107         }
2108
2109 private:
2110         const std::string       m_layerName;
2111 };
2112
2113 struct CheckEnumerateDeviceExtensionPropertiesIncompleteResult : public CheckIncompleteResult<VkExtensionProperties>
2114 {
2115         CheckEnumerateDeviceExtensionPropertiesIncompleteResult (std::string layerName = std::string()) : m_layerName(layerName) {}
2116
2117         void getResult (Context& context, VkExtensionProperties* data)
2118         {
2119                 const char* pLayerName = (m_layerName.length() != 0 ? m_layerName.c_str() : DE_NULL);
2120                 m_result = context.getInstanceInterface().enumerateDeviceExtensionProperties(context.getPhysicalDevice(), pLayerName, &m_count, data);
2121         }
2122
2123 private:
2124         const std::string       m_layerName;
2125 };
2126
2127 tcu::TestStatus enumeratePhysicalDevices (Context& context)
2128 {
2129         TestLog&                                                log             = context.getTestContext().getLog();
2130         tcu::ResultCollector                    results (log);
2131         const vector<VkPhysicalDevice>  devices = enumeratePhysicalDevices(context.getInstanceInterface(), context.getInstance());
2132
2133         log << TestLog::Integer("NumDevices", "Number of devices", "", QP_KEY_TAG_NONE, deInt64(devices.size()));
2134
2135         for (size_t ndx = 0; ndx < devices.size(); ndx++)
2136                 log << TestLog::Message << ndx << ": " << devices[ndx] << TestLog::EndMessage;
2137
2138         CheckEnumeratePhysicalDevicesIncompleteResult()(context, results, devices.size());
2139
2140         return tcu::TestStatus(results.getResult(), results.getMessage());
2141 }
2142
2143 tcu::TestStatus enumeratePhysicalDeviceGroups (Context& context)
2144 {
2145         TestLog&                                                                                        log                             = context.getTestContext().getLog();
2146         tcu::ResultCollector                                                            results                 (log);
2147         CustomInstance                                                                          instance                (createCustomInstanceWithExtension(context, "VK_KHR_device_group_creation"));
2148         const InstanceDriver&                                                           vki                             (instance.getDriver());
2149         const vector<VkPhysicalDeviceGroupProperties>           devicegroups    = enumeratePhysicalDeviceGroups(vki, instance);
2150
2151         log << TestLog::Integer("NumDevices", "Number of device groups", "", QP_KEY_TAG_NONE, deInt64(devicegroups.size()));
2152
2153         for (size_t ndx = 0; ndx < devicegroups.size(); ndx++)
2154                 log << TestLog::Message << ndx << ": " << devicegroups[ndx] << TestLog::EndMessage;
2155
2156         CheckEnumeratePhysicalDeviceGroupsIncompleteResult(vki, instance)(context, results, devicegroups.size());
2157
2158         instance.collectMessages();
2159         return tcu::TestStatus(results.getResult(), results.getMessage());
2160 }
2161
2162 template<typename T>
2163 void collectDuplicates (set<T>& duplicates, const vector<T>& values)
2164 {
2165         set<T> seen;
2166
2167         for (size_t ndx = 0; ndx < values.size(); ndx++)
2168         {
2169                 const T& value = values[ndx];
2170
2171                 if (!seen.insert(value).second)
2172                         duplicates.insert(value);
2173         }
2174 }
2175
2176 void checkDuplicates (tcu::ResultCollector& results, const char* what, const vector<string>& values)
2177 {
2178         set<string> duplicates;
2179
2180         collectDuplicates(duplicates, values);
2181
2182         for (set<string>::const_iterator iter = duplicates.begin(); iter != duplicates.end(); ++iter)
2183         {
2184                 std::ostringstream msg;
2185                 msg << "Duplicate " << what << ": " << *iter;
2186                 results.fail(msg.str());
2187         }
2188 }
2189
2190 void checkDuplicateExtensions (tcu::ResultCollector& results, const vector<string>& extensions)
2191 {
2192         checkDuplicates(results, "extension", extensions);
2193 }
2194
2195 void checkDuplicateLayers (tcu::ResultCollector& results, const vector<string>& layers)
2196 {
2197         checkDuplicates(results, "layer", layers);
2198 }
2199
2200 void checkKhrExtensions (tcu::ResultCollector&          results,
2201                                                  const vector<string>&          extensions,
2202                                                  const int                                      numAllowedKhrExtensions,
2203                                                  const char* const*                     allowedKhrExtensions)
2204 {
2205         const set<string>       allowedExtSet           (allowedKhrExtensions, allowedKhrExtensions+numAllowedKhrExtensions);
2206
2207         for (vector<string>::const_iterator extIter = extensions.begin(); extIter != extensions.end(); ++extIter)
2208         {
2209                 // Only Khronos-controlled extensions are checked
2210                 if (de::beginsWith(*extIter, "VK_KHR_") &&
2211                         !de::contains(allowedExtSet, *extIter))
2212                 {
2213                         results.fail("Unknown extension " + *extIter);
2214                 }
2215         }
2216 }
2217
2218 void checkInstanceExtensions (tcu::ResultCollector& results, const vector<string>& extensions)
2219 {
2220 #include "vkInstanceExtensions.inl"
2221
2222         checkKhrExtensions(results, extensions, DE_LENGTH_OF_ARRAY(s_allowedInstanceKhrExtensions), s_allowedInstanceKhrExtensions);
2223         checkDuplicateExtensions(results, extensions);
2224 }
2225
2226 void checkDeviceExtensions (tcu::ResultCollector& results, const vector<string>& extensions)
2227 {
2228 #include "vkDeviceExtensions.inl"
2229
2230         checkKhrExtensions(results, extensions, DE_LENGTH_OF_ARRAY(s_allowedDeviceKhrExtensions), s_allowedDeviceKhrExtensions);
2231         checkDuplicateExtensions(results, extensions);
2232 }
2233
2234 void checkInstanceExtensionDependencies(tcu::ResultCollector&                                                                                   results,
2235                                                                                 int                                                                                                                             dependencyLength,
2236                                                                                 const std::tuple<deUint32, deUint32, const char*, const char*>* dependencies,
2237                                                                                 deUint32                                                                                                                versionMajor,
2238                                                                                 deUint32                                                                                                                versionMinor,
2239                                                                                 const vector<VkExtensionProperties>&                                                    extensionProperties)
2240 {
2241         for (int ndx = 0; ndx < dependencyLength; ndx++)
2242         {
2243                 deUint32 currentVersionMajor, currentVersionMinor;
2244                 const char* extensionFirst;
2245                 const char* extensionSecond;
2246                 std::tie(currentVersionMajor, currentVersionMinor, extensionFirst, extensionSecond) = dependencies[ndx];
2247                 if (currentVersionMajor != versionMajor || currentVersionMinor != versionMinor)
2248                         continue;
2249                 if (isExtensionSupported(extensionProperties, RequiredExtension(extensionFirst)) &&
2250                         !isExtensionSupported(extensionProperties, RequiredExtension(extensionSecond)))
2251                 {
2252                         results.fail("Extension " + string(extensionFirst) + " is missing dependency: " + string(extensionSecond));
2253                 }
2254         }
2255 }
2256
2257 void checkDeviceExtensionDependencies(tcu::ResultCollector&                                                                                             results,
2258                                                                           int                                                                                                                           dependencyLength,
2259                                                                           const std::tuple<deUint32, deUint32, const char*, const char*>*       dependencies,
2260                                                                           deUint32                                                                                                                      versionMajor,
2261                                                                           deUint32                                                                                                                      versionMinor,
2262                                                                           const vector<VkExtensionProperties>&                                                          instanceExtensionProperties,
2263                                                                           const vector<VkExtensionProperties>&                                                          deviceExtensionProperties)
2264 {
2265         for (int ndx = 0; ndx < dependencyLength; ndx++)
2266         {
2267                 deUint32 currentVersionMajor, currentVersionMinor;
2268                 const char* extensionFirst;
2269                 const char* extensionSecond;
2270                 std::tie(currentVersionMajor, currentVersionMinor, extensionFirst, extensionSecond) = dependencies[ndx];
2271                 if (currentVersionMajor != versionMajor || currentVersionMinor != versionMinor)
2272                         continue;
2273                 if (isExtensionSupported(deviceExtensionProperties, RequiredExtension(extensionFirst)) &&
2274                         !isExtensionSupported(deviceExtensionProperties, RequiredExtension(extensionSecond)) &&
2275                         !isExtensionSupported(instanceExtensionProperties, RequiredExtension(extensionSecond)))
2276                 {
2277                         results.fail("Extension " + string(extensionFirst) + " is missing dependency: " + string(extensionSecond));
2278                 }
2279         }
2280 }
2281
2282 tcu::TestStatus enumerateInstanceLayers (Context& context)
2283 {
2284         TestLog&                                                log                                     = context.getTestContext().getLog();
2285         tcu::ResultCollector                    results                         (log);
2286         const vector<VkLayerProperties> properties                      = enumerateInstanceLayerProperties(context.getPlatformInterface());
2287         vector<string>                                  layerNames;
2288
2289         for (size_t ndx = 0; ndx < properties.size(); ndx++)
2290         {
2291                 log << TestLog::Message << ndx << ": " << properties[ndx] << TestLog::EndMessage;
2292
2293                 layerNames.push_back(properties[ndx].layerName);
2294         }
2295
2296         checkDuplicateLayers(results, layerNames);
2297         CheckEnumerateInstanceLayerPropertiesIncompleteResult()(context, results, layerNames.size());
2298
2299         return tcu::TestStatus(results.getResult(), results.getMessage());
2300 }
2301
2302 tcu::TestStatus enumerateInstanceExtensions (Context& context)
2303 {
2304         TestLog&                                log             = context.getTestContext().getLog();
2305         tcu::ResultCollector    results (log);
2306
2307         {
2308                 const ScopedLogSection                          section         (log, "Global", "Global Extensions");
2309                 const vector<VkExtensionProperties>     properties      = enumerateInstanceExtensionProperties(context.getPlatformInterface(), DE_NULL);
2310                 vector<string>                                          extensionNames;
2311
2312                 for (size_t ndx = 0; ndx < properties.size(); ndx++)
2313                 {
2314                         log << TestLog::Message << ndx << ": " << properties[ndx] << TestLog::EndMessage;
2315
2316                         extensionNames.push_back(properties[ndx].extensionName);
2317                 }
2318
2319                 checkInstanceExtensions(results, extensionNames);
2320                 CheckEnumerateInstanceExtensionPropertiesIncompleteResult()(context, results, properties.size());
2321
2322                 for (const auto& version : releasedApiVersions)
2323                 {
2324                         deUint32 versionMajor, versionMinor;
2325                         std::tie(std::ignore, versionMajor, versionMinor) = version;
2326                         if (context.contextSupports(vk::ApiVersion(versionMajor, versionMinor, 0)))
2327                         {
2328                                 checkInstanceExtensionDependencies(results,
2329                                         DE_LENGTH_OF_ARRAY(instanceExtensionDependencies),
2330                                         instanceExtensionDependencies,
2331                                         versionMajor,
2332                                         versionMinor,
2333                                         properties);
2334                                 break;
2335                         }
2336                 }
2337         }
2338
2339         {
2340                 const vector<VkLayerProperties> layers  = enumerateInstanceLayerProperties(context.getPlatformInterface());
2341
2342                 for (vector<VkLayerProperties>::const_iterator layer = layers.begin(); layer != layers.end(); ++layer)
2343                 {
2344                         const ScopedLogSection                          section                         (log, layer->layerName, string("Layer: ") + layer->layerName);
2345                         const vector<VkExtensionProperties>     properties                      = enumerateInstanceExtensionProperties(context.getPlatformInterface(), layer->layerName);
2346                         vector<string>                                          extensionNames;
2347
2348                         for (size_t extNdx = 0; extNdx < properties.size(); extNdx++)
2349                         {
2350                                 log << TestLog::Message << extNdx << ": " << properties[extNdx] << TestLog::EndMessage;
2351
2352                                 extensionNames.push_back(properties[extNdx].extensionName);
2353                         }
2354
2355                         checkInstanceExtensions(results, extensionNames);
2356                         CheckEnumerateInstanceExtensionPropertiesIncompleteResult(layer->layerName)(context, results, properties.size());
2357                 }
2358         }
2359
2360         return tcu::TestStatus(results.getResult(), results.getMessage());
2361 }
2362
2363 tcu::TestStatus testNoKhxExtensions (Context& context)
2364 {
2365         VkPhysicalDevice                        physicalDevice  = context.getPhysicalDevice();
2366         const PlatformInterface&        vkp                             = context.getPlatformInterface();
2367         const InstanceInterface&        vki                             = context.getInstanceInterface();
2368
2369         tcu::ResultCollector            results(context.getTestContext().getLog());
2370         bool                                            testSucceeded = true;
2371         deUint32                                        instanceExtensionsCount;
2372         deUint32                                        deviceExtensionsCount;
2373
2374         // grab number of instance and device extensions
2375         vkp.enumerateInstanceExtensionProperties(DE_NULL, &instanceExtensionsCount, DE_NULL);
2376         vki.enumerateDeviceExtensionProperties(physicalDevice, DE_NULL, &deviceExtensionsCount, DE_NULL);
2377         vector<VkExtensionProperties> extensionsProperties(instanceExtensionsCount + deviceExtensionsCount);
2378
2379         // grab instance and device extensions into single vector
2380         if (instanceExtensionsCount)
2381                 vkp.enumerateInstanceExtensionProperties(DE_NULL, &instanceExtensionsCount, &extensionsProperties[0]);
2382         if (deviceExtensionsCount)
2383                 vki.enumerateDeviceExtensionProperties(physicalDevice, DE_NULL, &deviceExtensionsCount, &extensionsProperties[instanceExtensionsCount]);
2384
2385         // iterate over all extensions and verify their names
2386         vector<VkExtensionProperties>::const_iterator extension = extensionsProperties.begin();
2387         while (extension != extensionsProperties.end())
2388         {
2389                 // KHX author ID is no longer used, all KHX extensions have been promoted to KHR status
2390                 std::string extensionName(extension->extensionName);
2391                 bool caseFailed = de::beginsWith(extensionName, "VK_KHX_");
2392                 if (caseFailed)
2393                 {
2394                         results.fail("Invalid extension name " + extensionName);
2395                         testSucceeded = false;
2396                 }
2397                 ++extension;
2398         }
2399
2400         if (testSucceeded)
2401                 return tcu::TestStatus::pass("No extensions begining with \"VK_KHX\"");
2402         return tcu::TestStatus::fail("One or more extensions begins with \"VK_KHX\"");
2403 }
2404
2405 tcu::TestStatus enumerateDeviceLayers (Context& context)
2406 {
2407         TestLog&                                                log                     = context.getTestContext().getLog();
2408         tcu::ResultCollector                    results         (log);
2409         const vector<VkLayerProperties> properties      = enumerateDeviceLayerProperties(context.getInstanceInterface(), context.getPhysicalDevice());
2410         vector<string>                                  layerNames;
2411
2412         for (size_t ndx = 0; ndx < properties.size(); ndx++)
2413         {
2414                 log << TestLog::Message << ndx << ": " << properties[ndx] << TestLog::EndMessage;
2415
2416                 layerNames.push_back(properties[ndx].layerName);
2417         }
2418
2419         checkDuplicateLayers(results, layerNames);
2420         CheckEnumerateDeviceLayerPropertiesIncompleteResult()(context, results, layerNames.size());
2421
2422         return tcu::TestStatus(results.getResult(), results.getMessage());
2423 }
2424
2425 tcu::TestStatus enumerateDeviceExtensions (Context& context)
2426 {
2427         TestLog&                                log             = context.getTestContext().getLog();
2428         tcu::ResultCollector    results (log);
2429
2430         {
2431                 const ScopedLogSection                          section                                         (log, "Global", "Global Extensions");
2432                 const vector<VkExtensionProperties>     instanceExtensionProperties     = enumerateInstanceExtensionProperties(context.getPlatformInterface(), DE_NULL);
2433                 const vector<VkExtensionProperties>     deviceExtensionProperties       = enumerateDeviceExtensionProperties(context.getInstanceInterface(), context.getPhysicalDevice(), DE_NULL);
2434                 vector<string>                                          deviceExtensionNames;
2435
2436                 for (size_t ndx = 0; ndx < deviceExtensionProperties.size(); ndx++)
2437                 {
2438                         log << TestLog::Message << ndx << ": " << deviceExtensionProperties[ndx] << TestLog::EndMessage;
2439
2440                         deviceExtensionNames.push_back(deviceExtensionProperties[ndx].extensionName);
2441                 }
2442
2443                 checkDeviceExtensions(results, deviceExtensionNames);
2444                 CheckEnumerateDeviceExtensionPropertiesIncompleteResult()(context, results, deviceExtensionProperties.size());
2445
2446                 for (const auto& version : releasedApiVersions)
2447                 {
2448                         deUint32 versionMajor, versionMinor;
2449                         std::tie(std::ignore, versionMajor, versionMinor) = version;
2450                         if (context.contextSupports(vk::ApiVersion(versionMajor, versionMinor, 0)))
2451                         {
2452                                 checkDeviceExtensionDependencies(results,
2453                                         DE_LENGTH_OF_ARRAY(deviceExtensionDependencies),
2454                                         deviceExtensionDependencies,
2455                                         versionMajor,
2456                                         versionMinor,
2457                                         instanceExtensionProperties,
2458                                         deviceExtensionProperties);
2459                                 break;
2460                         }
2461                 }
2462         }
2463
2464         {
2465                 const vector<VkLayerProperties> layers  = enumerateDeviceLayerProperties(context.getInstanceInterface(), context.getPhysicalDevice());
2466
2467                 for (vector<VkLayerProperties>::const_iterator layer = layers.begin(); layer != layers.end(); ++layer)
2468                 {
2469                         const ScopedLogSection                          section         (log, layer->layerName, string("Layer: ") + layer->layerName);
2470                         const vector<VkExtensionProperties>     properties      = enumerateDeviceExtensionProperties(context.getInstanceInterface(), context.getPhysicalDevice(), layer->layerName);
2471                         vector<string>                                          extensionNames;
2472
2473                         for (size_t extNdx = 0; extNdx < properties.size(); extNdx++)
2474                         {
2475                                 log << TestLog::Message << extNdx << ": " << properties[extNdx] << TestLog::EndMessage;
2476
2477
2478                                 extensionNames.push_back(properties[extNdx].extensionName);
2479                         }
2480
2481                         checkDeviceExtensions(results, extensionNames);
2482                         CheckEnumerateDeviceExtensionPropertiesIncompleteResult(layer->layerName)(context, results, properties.size());
2483                 }
2484         }
2485
2486         return tcu::TestStatus(results.getResult(), results.getMessage());
2487 }
2488
2489 tcu::TestStatus extensionCoreVersions (Context& context)
2490 {
2491         deUint32        major;
2492         deUint32        minor;
2493         const char*     extName;
2494
2495         auto&                                   log             = context.getTestContext().getLog();
2496         tcu::ResultCollector    results (log);
2497
2498         const auto instanceExtensionProperties  = enumerateInstanceExtensionProperties(context.getPlatformInterface(), DE_NULL);
2499         const auto deviceExtensionProperties    = enumerateDeviceExtensionProperties(context.getInstanceInterface(), context.getPhysicalDevice(), DE_NULL);
2500
2501         for (const auto& majorMinorName : extensionRequiredCoreVersion)
2502         {
2503                 std::tie(major, minor, extName) = majorMinorName;
2504                 const RequiredExtension reqExt (extName);
2505
2506                 if ((isExtensionSupported(instanceExtensionProperties, reqExt) || isExtensionSupported(deviceExtensionProperties, reqExt)) &&
2507                     !context.contextSupports(vk::ApiVersion(major, minor, 0u)))
2508                 {
2509                         results.fail("Required core version for " + std::string(extName) + " not met (" + de::toString(major) + "." + de::toString(minor) + ")");
2510                 }
2511         }
2512
2513         return tcu::TestStatus(results.getResult(), results.getMessage());
2514 }
2515
2516 #define VK_SIZE_OF(STRUCT, MEMBER)                                      (sizeof(((STRUCT*)0)->MEMBER))
2517 #define OFFSET_TABLE_ENTRY(STRUCT, MEMBER)                      { (size_t)DE_OFFSET_OF(STRUCT, MEMBER), VK_SIZE_OF(STRUCT, MEMBER) }
2518
2519 tcu::TestStatus deviceFeatures (Context& context)
2520 {
2521         using namespace ValidateQueryBits;
2522
2523         TestLog&                                                log                     = context.getTestContext().getLog();
2524         VkPhysicalDeviceFeatures*               features;
2525         deUint8                                                 buffer[sizeof(VkPhysicalDeviceFeatures) + GUARD_SIZE];
2526
2527         const QueryMemberTableEntry featureOffsetTable[] =
2528         {
2529                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, robustBufferAccess),
2530                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, fullDrawIndexUint32),
2531                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, imageCubeArray),
2532                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, independentBlend),
2533                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, geometryShader),
2534                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, tessellationShader),
2535                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, sampleRateShading),
2536                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, dualSrcBlend),
2537                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, logicOp),
2538                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, multiDrawIndirect),
2539                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, drawIndirectFirstInstance),
2540                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, depthClamp),
2541                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, depthBiasClamp),
2542                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, fillModeNonSolid),
2543                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, depthBounds),
2544                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, wideLines),
2545                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, largePoints),
2546                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, alphaToOne),
2547                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, multiViewport),
2548                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, samplerAnisotropy),
2549                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, textureCompressionETC2),
2550                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, textureCompressionASTC_LDR),
2551                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, textureCompressionBC),
2552                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, occlusionQueryPrecise),
2553                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, pipelineStatisticsQuery),
2554                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, vertexPipelineStoresAndAtomics),
2555                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, fragmentStoresAndAtomics),
2556                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderTessellationAndGeometryPointSize),
2557                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderImageGatherExtended),
2558                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderStorageImageExtendedFormats),
2559                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderStorageImageMultisample),
2560                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderStorageImageReadWithoutFormat),
2561                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderStorageImageWriteWithoutFormat),
2562                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderUniformBufferArrayDynamicIndexing),
2563                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderSampledImageArrayDynamicIndexing),
2564                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderStorageBufferArrayDynamicIndexing),
2565                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderStorageImageArrayDynamicIndexing),
2566                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderClipDistance),
2567                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderCullDistance),
2568                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderFloat64),
2569                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderInt64),
2570                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderInt16),
2571                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderResourceResidency),
2572                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, shaderResourceMinLod),
2573                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, sparseBinding),
2574                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, sparseResidencyBuffer),
2575                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, sparseResidencyImage2D),
2576                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, sparseResidencyImage3D),
2577                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, sparseResidency2Samples),
2578                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, sparseResidency4Samples),
2579                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, sparseResidency8Samples),
2580                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, sparseResidency16Samples),
2581                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, sparseResidencyAliased),
2582                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, variableMultisampleRate),
2583                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceFeatures, inheritedQueries),
2584                 { 0, 0 }
2585         };
2586
2587         deMemset(buffer, GUARD_VALUE, sizeof(buffer));
2588         features = reinterpret_cast<VkPhysicalDeviceFeatures*>(buffer);
2589
2590         context.getInstanceInterface().getPhysicalDeviceFeatures(context.getPhysicalDevice(), features);
2591
2592         log << TestLog::Message << "device = " << context.getPhysicalDevice() << TestLog::EndMessage
2593                 << TestLog::Message << *features << TestLog::EndMessage;
2594
2595         // Requirements and dependencies
2596         {
2597                 if (!features->robustBufferAccess)
2598                         return tcu::TestStatus::fail("robustBufferAccess is not supported");
2599
2600                 // multiViewport requires MultiViewport (SPIR-V capability) support, which depends on Geometry
2601                 if (features->multiViewport && !features->geometryShader)
2602                         return tcu::TestStatus::fail("multiViewport is supported but geometryShader is not");
2603         }
2604
2605         for (int ndx = 0; ndx < GUARD_SIZE; ndx++)
2606         {
2607                 if (buffer[ndx + sizeof(VkPhysicalDeviceFeatures)] != GUARD_VALUE)
2608                 {
2609                         log << TestLog::Message << "deviceFeatures - Guard offset " << ndx << " not valid" << TestLog::EndMessage;
2610                         return tcu::TestStatus::fail("deviceFeatures buffer overflow");
2611                 }
2612         }
2613
2614         if (!validateInitComplete(context.getPhysicalDevice(), &InstanceInterface::getPhysicalDeviceFeatures, context.getInstanceInterface(), featureOffsetTable))
2615         {
2616                 log << TestLog::Message << "deviceFeatures - VkPhysicalDeviceFeatures not completely initialized" << TestLog::EndMessage;
2617                 return tcu::TestStatus::fail("deviceFeatures incomplete initialization");
2618         }
2619
2620         return tcu::TestStatus::pass("Query succeeded");
2621 }
2622
2623 static const ValidateQueryBits::QueryMemberTableEntry s_physicalDevicePropertiesOffsetTable[] =
2624 {
2625         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, apiVersion),
2626         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, driverVersion),
2627         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, vendorID),
2628         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, deviceID),
2629         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, deviceType),
2630         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, pipelineCacheUUID),
2631         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxImageDimension1D),
2632         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxImageDimension2D),
2633         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxImageDimension3D),
2634         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxImageDimensionCube),
2635         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxImageArrayLayers),
2636         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxTexelBufferElements),
2637         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxUniformBufferRange),
2638         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxStorageBufferRange),
2639         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxPushConstantsSize),
2640         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxMemoryAllocationCount),
2641         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxSamplerAllocationCount),
2642         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.bufferImageGranularity),
2643         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.sparseAddressSpaceSize),
2644         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxBoundDescriptorSets),
2645         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxPerStageDescriptorSamplers),
2646         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxPerStageDescriptorUniformBuffers),
2647         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxPerStageDescriptorStorageBuffers),
2648         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxPerStageDescriptorSampledImages),
2649         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxPerStageDescriptorStorageImages),
2650         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxPerStageDescriptorInputAttachments),
2651         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxPerStageResources),
2652         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxDescriptorSetSamplers),
2653         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxDescriptorSetUniformBuffers),
2654         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxDescriptorSetUniformBuffersDynamic),
2655         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxDescriptorSetStorageBuffers),
2656         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxDescriptorSetStorageBuffersDynamic),
2657         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxDescriptorSetSampledImages),
2658         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxDescriptorSetStorageImages),
2659         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxDescriptorSetInputAttachments),
2660         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxVertexInputAttributes),
2661         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxVertexInputBindings),
2662         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxVertexInputAttributeOffset),
2663         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxVertexInputBindingStride),
2664         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxVertexOutputComponents),
2665         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxTessellationGenerationLevel),
2666         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxTessellationPatchSize),
2667         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxTessellationControlPerVertexInputComponents),
2668         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxTessellationControlPerVertexOutputComponents),
2669         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxTessellationControlPerPatchOutputComponents),
2670         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxTessellationControlTotalOutputComponents),
2671         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxTessellationEvaluationInputComponents),
2672         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxTessellationEvaluationOutputComponents),
2673         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxGeometryShaderInvocations),
2674         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxGeometryInputComponents),
2675         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxGeometryOutputComponents),
2676         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxGeometryOutputVertices),
2677         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxGeometryTotalOutputComponents),
2678         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxFragmentInputComponents),
2679         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxFragmentOutputAttachments),
2680         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxFragmentDualSrcAttachments),
2681         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxFragmentCombinedOutputResources),
2682         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxComputeSharedMemorySize),
2683         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxComputeWorkGroupCount[3]),
2684         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxComputeWorkGroupInvocations),
2685         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxComputeWorkGroupSize[3]),
2686         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.subPixelPrecisionBits),
2687         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.subTexelPrecisionBits),
2688         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.mipmapPrecisionBits),
2689         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxDrawIndexedIndexValue),
2690         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxDrawIndirectCount),
2691         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxSamplerLodBias),
2692         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxSamplerAnisotropy),
2693         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxViewports),
2694         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxViewportDimensions[2]),
2695         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.viewportBoundsRange[2]),
2696         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.viewportSubPixelBits),
2697         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.minMemoryMapAlignment),
2698         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.minTexelBufferOffsetAlignment),
2699         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.minUniformBufferOffsetAlignment),
2700         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.minStorageBufferOffsetAlignment),
2701         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.minTexelOffset),
2702         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxTexelOffset),
2703         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.minTexelGatherOffset),
2704         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxTexelGatherOffset),
2705         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.minInterpolationOffset),
2706         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxInterpolationOffset),
2707         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.subPixelInterpolationOffsetBits),
2708         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxFramebufferWidth),
2709         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxFramebufferHeight),
2710         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxFramebufferLayers),
2711         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.framebufferColorSampleCounts),
2712         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.framebufferDepthSampleCounts),
2713         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.framebufferStencilSampleCounts),
2714         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.framebufferNoAttachmentsSampleCounts),
2715         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxColorAttachments),
2716         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.sampledImageColorSampleCounts),
2717         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.sampledImageIntegerSampleCounts),
2718         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.sampledImageDepthSampleCounts),
2719         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.sampledImageStencilSampleCounts),
2720         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.storageImageSampleCounts),
2721         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxSampleMaskWords),
2722         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.timestampComputeAndGraphics),
2723         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.timestampPeriod),
2724         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxClipDistances),
2725         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxCullDistances),
2726         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.maxCombinedClipAndCullDistances),
2727         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.discreteQueuePriorities),
2728         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.pointSizeRange[2]),
2729         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.lineWidthRange[2]),
2730         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.pointSizeGranularity),
2731         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.lineWidthGranularity),
2732         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.strictLines),
2733         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.standardSampleLocations),
2734         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.optimalBufferCopyOffsetAlignment),
2735         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.optimalBufferCopyRowPitchAlignment),
2736         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, limits.nonCoherentAtomSize),
2737         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, sparseProperties.residencyStandard2DBlockShape),
2738         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, sparseProperties.residencyStandard2DMultisampleBlockShape),
2739         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, sparseProperties.residencyStandard3DBlockShape),
2740         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, sparseProperties.residencyAlignedMipSize),
2741         OFFSET_TABLE_ENTRY(VkPhysicalDeviceProperties, sparseProperties.residencyNonResidentStrict),
2742         { 0, 0 }
2743 };
2744
2745 tcu::TestStatus deviceProperties (Context& context)
2746 {
2747         using namespace ValidateQueryBits;
2748
2749         TestLog&                                                log                     = context.getTestContext().getLog();
2750         VkPhysicalDeviceProperties*             props;
2751         VkPhysicalDeviceFeatures                features;
2752         deUint8                                                 buffer[sizeof(VkPhysicalDeviceProperties) + GUARD_SIZE];
2753
2754         props = reinterpret_cast<VkPhysicalDeviceProperties*>(buffer);
2755         deMemset(props, GUARD_VALUE, sizeof(buffer));
2756
2757         context.getInstanceInterface().getPhysicalDeviceProperties(context.getPhysicalDevice(), props);
2758         context.getInstanceInterface().getPhysicalDeviceFeatures(context.getPhysicalDevice(), &features);
2759
2760         log << TestLog::Message << "device = " << context.getPhysicalDevice() << TestLog::EndMessage
2761                 << TestLog::Message << *props << TestLog::EndMessage;
2762
2763         if (!validateFeatureLimits(props, &features, log))
2764                 return tcu::TestStatus::fail("deviceProperties - feature limits failed");
2765
2766         for (int ndx = 0; ndx < GUARD_SIZE; ndx++)
2767         {
2768                 if (buffer[ndx + sizeof(VkPhysicalDeviceProperties)] != GUARD_VALUE)
2769                 {
2770                         log << TestLog::Message << "deviceProperties - Guard offset " << ndx << " not valid" << TestLog::EndMessage;
2771                         return tcu::TestStatus::fail("deviceProperties buffer overflow");
2772                 }
2773         }
2774
2775         if (!validateInitComplete(context.getPhysicalDevice(), &InstanceInterface::getPhysicalDeviceProperties, context.getInstanceInterface(), s_physicalDevicePropertiesOffsetTable))
2776         {
2777                 log << TestLog::Message << "deviceProperties - VkPhysicalDeviceProperties not completely initialized" << TestLog::EndMessage;
2778                 return tcu::TestStatus::fail("deviceProperties incomplete initialization");
2779         }
2780
2781         // Check if deviceName string is properly terminated.
2782         if (deStrnlen(props->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE) == VK_MAX_PHYSICAL_DEVICE_NAME_SIZE)
2783         {
2784                 log << TestLog::Message << "deviceProperties - VkPhysicalDeviceProperties deviceName not properly initialized" << TestLog::EndMessage;
2785                 return tcu::TestStatus::fail("deviceProperties incomplete initialization");
2786         }
2787
2788         {
2789                 const ApiVersion deviceVersion = unpackVersion(props->apiVersion);
2790                 const ApiVersion deqpVersion = unpackVersion(VK_API_VERSION_1_3);
2791
2792                 if (deviceVersion.majorNum != deqpVersion.majorNum)
2793                 {
2794                         log << TestLog::Message << "deviceProperties - API Major Version " << deviceVersion.majorNum << " is not valid" << TestLog::EndMessage;
2795                         return tcu::TestStatus::fail("deviceProperties apiVersion not valid");
2796                 }
2797
2798                 if (deviceVersion.minorNum > deqpVersion.minorNum)
2799                 {
2800                         log << TestLog::Message << "deviceProperties - API Minor Version " << deviceVersion.minorNum << " is not valid for this version of dEQP" << TestLog::EndMessage;
2801                         return tcu::TestStatus::fail("deviceProperties apiVersion not valid");
2802                 }
2803         }
2804
2805         return tcu::TestStatus::pass("DeviceProperites query succeeded");
2806 }
2807
2808 tcu::TestStatus deviceQueueFamilyProperties (Context& context)
2809 {
2810         TestLog&                                                                log                                     = context.getTestContext().getLog();
2811         const vector<VkQueueFamilyProperties>   queueProperties         = getPhysicalDeviceQueueFamilyProperties(context.getInstanceInterface(), context.getPhysicalDevice());
2812
2813         log << TestLog::Message << "device = " << context.getPhysicalDevice() << TestLog::EndMessage;
2814
2815         for (size_t queueNdx = 0; queueNdx < queueProperties.size(); queueNdx++)
2816                 log << TestLog::Message << queueNdx << ": " << queueProperties[queueNdx] << TestLog::EndMessage;
2817
2818         return tcu::TestStatus::pass("Querying queue properties succeeded");
2819 }
2820
2821 tcu::TestStatus deviceMemoryProperties (Context& context)
2822 {
2823         TestLog&                                                        log                     = context.getTestContext().getLog();
2824         VkPhysicalDeviceMemoryProperties*       memProps;
2825         deUint8                                                         buffer[sizeof(VkPhysicalDeviceMemoryProperties) + GUARD_SIZE];
2826
2827         memProps = reinterpret_cast<VkPhysicalDeviceMemoryProperties*>(buffer);
2828         deMemset(buffer, GUARD_VALUE, sizeof(buffer));
2829
2830         context.getInstanceInterface().getPhysicalDeviceMemoryProperties(context.getPhysicalDevice(), memProps);
2831
2832         log << TestLog::Message << "device = " << context.getPhysicalDevice() << TestLog::EndMessage
2833                 << TestLog::Message << *memProps << TestLog::EndMessage;
2834
2835         for (deInt32 ndx = 0; ndx < GUARD_SIZE; ndx++)
2836         {
2837                 if (buffer[ndx + sizeof(VkPhysicalDeviceMemoryProperties)] != GUARD_VALUE)
2838                 {
2839                         log << TestLog::Message << "deviceMemoryProperties - Guard offset " << ndx << " not valid" << TestLog::EndMessage;
2840                         return tcu::TestStatus::fail("deviceMemoryProperties buffer overflow");
2841                 }
2842         }
2843
2844         if (memProps->memoryHeapCount >= VK_MAX_MEMORY_HEAPS)
2845         {
2846                 log << TestLog::Message << "deviceMemoryProperties - HeapCount larger than " << (deUint32)VK_MAX_MEMORY_HEAPS << TestLog::EndMessage;
2847                 return tcu::TestStatus::fail("deviceMemoryProperties HeapCount too large");
2848         }
2849
2850         if (memProps->memoryHeapCount == 1)
2851         {
2852                 if ((memProps->memoryHeaps[0].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) == 0)
2853                 {
2854                         log << TestLog::Message << "deviceMemoryProperties - Single heap is not marked DEVICE_LOCAL" << TestLog::EndMessage;
2855                         return tcu::TestStatus::fail("deviceMemoryProperties invalid HeapFlags");
2856                 }
2857         }
2858
2859         const VkMemoryPropertyFlags validPropertyFlags[] =
2860         {
2861                 0,
2862                 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
2863                 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT|VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
2864                 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT|VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
2865                 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT|VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_CACHED_BIT|VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
2866                 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
2867                 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
2868                 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_CACHED_BIT|VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
2869                 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT|VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT
2870         };
2871
2872         const VkMemoryPropertyFlags requiredPropertyFlags[] =
2873         {
2874                 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
2875         };
2876
2877         bool requiredFlagsFound[DE_LENGTH_OF_ARRAY(requiredPropertyFlags)];
2878         std::fill(DE_ARRAY_BEGIN(requiredFlagsFound), DE_ARRAY_END(requiredFlagsFound), false);
2879
2880         for (deUint32 memoryNdx = 0; memoryNdx < memProps->memoryTypeCount; memoryNdx++)
2881         {
2882                 bool validPropTypeFound = false;
2883
2884                 if (memProps->memoryTypes[memoryNdx].heapIndex >= memProps->memoryHeapCount)
2885                 {
2886                         log << TestLog::Message << "deviceMemoryProperties - heapIndex " << memProps->memoryTypes[memoryNdx].heapIndex << " larger than heapCount" << TestLog::EndMessage;
2887                         return tcu::TestStatus::fail("deviceMemoryProperties - invalid heapIndex");
2888                 }
2889
2890                 const VkMemoryPropertyFlags bitsToCheck = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT|VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_COHERENT_BIT|VK_MEMORY_PROPERTY_HOST_CACHED_BIT|VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;
2891
2892                 for (const VkMemoryPropertyFlags* requiredFlagsIterator = DE_ARRAY_BEGIN(requiredPropertyFlags); requiredFlagsIterator != DE_ARRAY_END(requiredPropertyFlags); requiredFlagsIterator++)
2893                         if ((memProps->memoryTypes[memoryNdx].propertyFlags & *requiredFlagsIterator) == *requiredFlagsIterator)
2894                                 requiredFlagsFound[requiredFlagsIterator - DE_ARRAY_BEGIN(requiredPropertyFlags)] = true;
2895
2896                 if (de::contains(DE_ARRAY_BEGIN(validPropertyFlags), DE_ARRAY_END(validPropertyFlags), memProps->memoryTypes[memoryNdx].propertyFlags & bitsToCheck))
2897                         validPropTypeFound = true;
2898
2899                 if (!validPropTypeFound)
2900                 {
2901                         log << TestLog::Message << "deviceMemoryProperties - propertyFlags "
2902                                 << memProps->memoryTypes[memoryNdx].propertyFlags << " not valid" << TestLog::EndMessage;
2903                         return tcu::TestStatus::fail("deviceMemoryProperties propertyFlags not valid");
2904                 }
2905
2906                 if (memProps->memoryTypes[memoryNdx].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)
2907                 {
2908                         if ((memProps->memoryHeaps[memProps->memoryTypes[memoryNdx].heapIndex].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) == 0)
2909                         {
2910                                 log << TestLog::Message << "deviceMemoryProperties - DEVICE_LOCAL memory type references heap which is not DEVICE_LOCAL" << TestLog::EndMessage;
2911                                 return tcu::TestStatus::fail("deviceMemoryProperties inconsistent memoryType and HeapFlags");
2912                         }
2913                 }
2914                 else
2915                 {
2916                         if (memProps->memoryHeaps[memProps->memoryTypes[memoryNdx].heapIndex].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)
2917                         {
2918                                 log << TestLog::Message << "deviceMemoryProperties - non-DEVICE_LOCAL memory type references heap with is DEVICE_LOCAL" << TestLog::EndMessage;
2919                                 return tcu::TestStatus::fail("deviceMemoryProperties inconsistent memoryType and HeapFlags");
2920                         }
2921                 }
2922         }
2923
2924         bool* requiredFlagsFoundIterator = std::find(DE_ARRAY_BEGIN(requiredFlagsFound), DE_ARRAY_END(requiredFlagsFound), false);
2925         if (requiredFlagsFoundIterator != DE_ARRAY_END(requiredFlagsFound))
2926         {
2927                 DE_ASSERT(requiredFlagsFoundIterator - DE_ARRAY_BEGIN(requiredFlagsFound) <= DE_LENGTH_OF_ARRAY(requiredPropertyFlags));
2928                 log << TestLog::Message << "deviceMemoryProperties - required property flags "
2929                         << getMemoryPropertyFlagsStr(requiredPropertyFlags[requiredFlagsFoundIterator - DE_ARRAY_BEGIN(requiredFlagsFound)]) << " not found" << TestLog::EndMessage;
2930
2931                 return tcu::TestStatus::fail("deviceMemoryProperties propertyFlags not valid");
2932         }
2933
2934         return tcu::TestStatus::pass("Querying memory properties succeeded");
2935 }
2936
2937 tcu::TestStatus deviceGroupPeerMemoryFeatures (Context& context)
2938 {
2939         TestLog&                                                        log                                             = context.getTestContext().getLog();
2940         const PlatformInterface&                        vkp                                             = context.getPlatformInterface();
2941         const CustomInstance                            instance                                (createCustomInstanceWithExtension(context, "VK_KHR_device_group_creation"));
2942         const InstanceDriver&                           vki                                             (instance.getDriver());
2943         const tcu::CommandLine&                         cmdLine                                 = context.getTestContext().getCommandLine();
2944         const deUint32                                          devGroupIdx                             = cmdLine.getVKDeviceGroupId() - 1;
2945         const deUint32                                          deviceIdx                               = vk::chooseDeviceIndex(context.getInstanceInterface(), instance, cmdLine);
2946         const float                                                     queuePriority                   = 1.0f;
2947         VkPhysicalDeviceMemoryProperties        memProps;
2948         VkPeerMemoryFeatureFlags*                       peerMemFeatures;
2949         deUint8                                                         buffer                                  [sizeof(VkPeerMemoryFeatureFlags) + GUARD_SIZE];
2950         deUint32                                                        numPhysicalDevices              = 0;
2951         deUint32                                                        queueFamilyIndex                = 0;
2952
2953         const vector<VkPhysicalDeviceGroupProperties>           deviceGroupProps = enumeratePhysicalDeviceGroups(vki, instance);
2954         std::vector<const char*>                                                        deviceExtensions;
2955         deviceExtensions.push_back("VK_KHR_device_group");
2956
2957         if (!isCoreDeviceExtension(context.getUsedApiVersion(), "VK_KHR_device_group"))
2958                 deviceExtensions.push_back("VK_KHR_device_group");
2959
2960         const std::vector<VkQueueFamilyProperties>      queueProps              = getPhysicalDeviceQueueFamilyProperties(vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx]);
2961         for (size_t queueNdx = 0; queueNdx < queueProps.size(); queueNdx++)
2962         {
2963                 if (queueProps[queueNdx].queueFlags & VK_QUEUE_GRAPHICS_BIT)
2964                         queueFamilyIndex = (deUint32)queueNdx;
2965         }
2966         const VkDeviceQueueCreateInfo           deviceQueueCreateInfo   =
2967         {
2968                 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,                     //type
2969                 DE_NULL,                                                                                        //pNext
2970                 (VkDeviceQueueCreateFlags)0u,                                           //flags
2971                 queueFamilyIndex,                                                                       //queueFamilyIndex;
2972                 1u,                                                                                                     //queueCount;
2973                 &queuePriority,                                                                         //pQueuePriorities;
2974         };
2975
2976         // Need atleast 2 devices for peer memory features
2977         numPhysicalDevices = deviceGroupProps[devGroupIdx].physicalDeviceCount;
2978         if (numPhysicalDevices < 2)
2979                 TCU_THROW(NotSupportedError, "Need a device Group with at least 2 physical devices.");
2980
2981         // Create device groups
2982         const VkDeviceGroupDeviceCreateInfo                                             deviceGroupInfo =
2983         {
2984                 VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO,      //stype
2985                 DE_NULL,                                                                                        //pNext
2986                 deviceGroupProps[devGroupIdx].physicalDeviceCount,      //physicalDeviceCount
2987                 deviceGroupProps[devGroupIdx].physicalDevices           //physicalDevices
2988         };
2989
2990         const VkDeviceCreateInfo                                                                deviceCreateInfo =
2991         {
2992                 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,                                                   //sType;
2993                 &deviceGroupInfo,                                                                                               //pNext;
2994                 (VkDeviceCreateFlags)0u,                                                                                //flags
2995                 1,                                                                                                                              //queueRecordCount;
2996                 &deviceQueueCreateInfo,                                                                                 //pRequestedQueues;
2997                 0,                                                                                                                              //layerCount;
2998                 DE_NULL,                                                                                                                //ppEnabledLayerNames;
2999                 deUint32(deviceExtensions.size()),                                                              //extensionCount;
3000                 (deviceExtensions.empty() ? DE_NULL : &deviceExtensions[0]),    //ppEnabledExtensionNames;
3001                 DE_NULL,                                                                                                                //pEnabledFeatures;
3002         };
3003
3004         Move<VkDevice>          deviceGroup = createCustomDevice(context.getTestContext().getCommandLine().isValidationEnabled(), vkp, instance, vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx], &deviceCreateInfo);
3005         const DeviceDriver      vk      (vkp, instance, *deviceGroup);
3006         context.getInstanceInterface().getPhysicalDeviceMemoryProperties(deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx], &memProps);
3007
3008         peerMemFeatures = reinterpret_cast<VkPeerMemoryFeatureFlags*>(buffer);
3009         deMemset(buffer, GUARD_VALUE, sizeof(buffer));
3010
3011         for (deUint32 heapIndex = 0; heapIndex < memProps.memoryHeapCount; heapIndex++)
3012         {
3013                 for (deUint32 localDeviceIndex = 0; localDeviceIndex < numPhysicalDevices; localDeviceIndex++)
3014                 {
3015                         for (deUint32 remoteDeviceIndex = 0; remoteDeviceIndex < numPhysicalDevices; remoteDeviceIndex++)
3016                         {
3017                                 if (localDeviceIndex != remoteDeviceIndex)
3018                                 {
3019                                         vk.getDeviceGroupPeerMemoryFeatures(deviceGroup.get(), heapIndex, localDeviceIndex, remoteDeviceIndex, peerMemFeatures);
3020
3021                                         // Check guard
3022                                         for (deInt32 ndx = 0; ndx < GUARD_SIZE; ndx++)
3023                                         {
3024                                                 if (buffer[ndx + sizeof(VkPeerMemoryFeatureFlags)] != GUARD_VALUE)
3025                                                 {
3026                                                         log << TestLog::Message << "deviceGroupPeerMemoryFeatures - Guard offset " << ndx << " not valid" << TestLog::EndMessage;
3027                                                         return tcu::TestStatus::fail("deviceGroupPeerMemoryFeatures buffer overflow");
3028                                                 }
3029                                         }
3030
3031                                         VkPeerMemoryFeatureFlags requiredFlag = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT;
3032                                         VkPeerMemoryFeatureFlags maxValidFlag = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT|VK_PEER_MEMORY_FEATURE_COPY_DST_BIT|
3033                                                                                                                                 VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT|VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT;
3034                                         if ((!(*peerMemFeatures & requiredFlag)) ||
3035                                                 *peerMemFeatures > maxValidFlag)
3036                                                 return tcu::TestStatus::fail("deviceGroupPeerMemoryFeatures invalid flag");
3037
3038                                         log << TestLog::Message << "deviceGroup = " << deviceGroup.get() << TestLog::EndMessage
3039                                                 << TestLog::Message << "heapIndex = " << heapIndex << TestLog::EndMessage
3040                                                 << TestLog::Message << "localDeviceIndex = " << localDeviceIndex << TestLog::EndMessage
3041                                                 << TestLog::Message << "remoteDeviceIndex = " << remoteDeviceIndex << TestLog::EndMessage
3042                                                 << TestLog::Message << "PeerMemoryFeatureFlags = " << *peerMemFeatures << TestLog::EndMessage;
3043                                 }
3044                         } // remote device
3045                 } // local device
3046         } // heap Index
3047
3048         return tcu::TestStatus::pass("Querying deviceGroup peer memory features succeeded");
3049 }
3050
3051 tcu::TestStatus deviceMemoryBudgetProperties (Context& context)
3052 {
3053         TestLog&                                                        log                     = context.getTestContext().getLog();
3054         deUint8                                                         buffer[sizeof(VkPhysicalDeviceMemoryBudgetPropertiesEXT) + GUARD_SIZE];
3055
3056         if (!context.isDeviceFunctionalitySupported("VK_EXT_memory_budget"))
3057                 TCU_THROW(NotSupportedError, "VK_EXT_memory_budget is not supported");
3058
3059         VkPhysicalDeviceMemoryBudgetPropertiesEXT *budgetProps = reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT *>(buffer);
3060         deMemset(buffer, GUARD_VALUE, sizeof(buffer));
3061
3062         budgetProps->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
3063         budgetProps->pNext = DE_NULL;
3064
3065         VkPhysicalDeviceMemoryProperties2       memProps;
3066         deMemset(&memProps, 0, sizeof(memProps));
3067         memProps.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
3068         memProps.pNext = budgetProps;
3069
3070         context.getInstanceInterface().getPhysicalDeviceMemoryProperties2(context.getPhysicalDevice(), &memProps);
3071
3072         log << TestLog::Message << "device = " << context.getPhysicalDevice() << TestLog::EndMessage
3073                 << TestLog::Message << *budgetProps << TestLog::EndMessage;
3074
3075         for (deInt32 ndx = 0; ndx < GUARD_SIZE; ndx++)
3076         {
3077                 if (buffer[ndx + sizeof(VkPhysicalDeviceMemoryBudgetPropertiesEXT)] != GUARD_VALUE)
3078                 {
3079                         log << TestLog::Message << "deviceMemoryBudgetProperties - Guard offset " << ndx << " not valid" << TestLog::EndMessage;
3080                         return tcu::TestStatus::fail("deviceMemoryBudgetProperties buffer overflow");
3081                 }
3082         }
3083
3084         for (deUint32 i = 0; i < memProps.memoryProperties.memoryHeapCount; ++i)
3085         {
3086                 if (budgetProps->heapBudget[i] == 0)
3087                 {
3088                         log << TestLog::Message << "deviceMemoryBudgetProperties - Supported heaps must report nonzero budget" << TestLog::EndMessage;
3089                         return tcu::TestStatus::fail("deviceMemoryBudgetProperties invalid heap budget (zero)");
3090                 }
3091                 if (budgetProps->heapBudget[i] > memProps.memoryProperties.memoryHeaps[i].size)
3092                 {
3093                         log << TestLog::Message << "deviceMemoryBudgetProperties - Heap budget must be less than or equal to heap size" << TestLog::EndMessage;
3094                         return tcu::TestStatus::fail("deviceMemoryBudgetProperties invalid heap budget (too large)");
3095                 }
3096         }
3097
3098         for (deUint32 i = memProps.memoryProperties.memoryHeapCount; i < VK_MAX_MEMORY_HEAPS; ++i)
3099         {
3100                 if (budgetProps->heapBudget[i] != 0 || budgetProps->heapUsage[i] != 0)
3101                 {
3102                         log << TestLog::Message << "deviceMemoryBudgetProperties - Unused heaps must report budget/usage of zero" << TestLog::EndMessage;
3103                         return tcu::TestStatus::fail("deviceMemoryBudgetProperties invalid unused heaps");
3104                 }
3105         }
3106
3107         return tcu::TestStatus::pass("Querying memory budget properties succeeded");
3108 }
3109
3110 namespace
3111 {
3112
3113 #include "vkMandatoryFeatures.inl"
3114
3115 }
3116
3117 tcu::TestStatus deviceMandatoryFeatures(Context& context)
3118 {
3119         if ( checkMandatoryFeatures(context) )
3120                 return tcu::TestStatus::pass("Passed");
3121         return tcu::TestStatus::fail("Not all mandatory features are supported ( see: vkspec.html#features-requirements )");
3122 }
3123
3124 VkFormatFeatureFlags getBaseRequiredOptimalTilingFeatures (VkFormat format)
3125 {
3126         struct Formatpair
3127         {
3128                 VkFormat                                format;
3129                 VkFormatFeatureFlags    flags;
3130         };
3131
3132         enum
3133         {
3134                 SAIM = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
3135                 BLSR = VK_FORMAT_FEATURE_BLIT_SRC_BIT,
3136                 SIFL = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT,
3137                 COAT = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT,
3138                 BLDS = VK_FORMAT_FEATURE_BLIT_DST_BIT,
3139                 CABL = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT,
3140                 STIM = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT,
3141                 STIA = VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT,
3142                 DSAT = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT,
3143                 TRSR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
3144                 TRDS = VK_FORMAT_FEATURE_TRANSFER_DST_BIT
3145         };
3146
3147         static const Formatpair formatflags[] =
3148         {
3149                 { VK_FORMAT_B4G4R4A4_UNORM_PACK16,              SAIM | BLSR | TRSR | TRDS |               SIFL },
3150                 { VK_FORMAT_R5G6B5_UNORM_PACK16,                SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL |        CABL },
3151                 { VK_FORMAT_A1R5G5B5_UNORM_PACK16,              SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL |        CABL },
3152                 { VK_FORMAT_R8_UNORM,                                   SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL |        CABL },
3153                 { VK_FORMAT_R8_SNORM,                                   SAIM | BLSR | TRSR | TRDS |               SIFL },
3154                 { VK_FORMAT_R8_UINT,                                    SAIM | BLSR | TRSR | TRDS | COAT | BLDS },
3155                 { VK_FORMAT_R8_SINT,                                    SAIM | BLSR | TRSR | TRDS | COAT | BLDS },
3156                 { VK_FORMAT_R8G8_UNORM,                                 SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL |        CABL },
3157                 { VK_FORMAT_R8G8_SNORM,                                 SAIM | BLSR | TRSR | TRDS |               SIFL },
3158                 { VK_FORMAT_R8G8_UINT,                                  SAIM | BLSR | TRSR | TRDS | COAT | BLDS },
3159                 { VK_FORMAT_R8G8_SINT,                                  SAIM | BLSR | TRSR | TRDS | COAT | BLDS },
3160                 { VK_FORMAT_R8G8B8A8_UNORM,                             SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL | STIM | CABL },
3161                 { VK_FORMAT_R8G8B8A8_SNORM,                             SAIM | BLSR | TRSR | TRDS |               SIFL | STIM },
3162                 { VK_FORMAT_R8G8B8A8_UINT,                              SAIM | BLSR | TRSR | TRDS | COAT | BLDS |        STIM },
3163                 { VK_FORMAT_R8G8B8A8_SINT,                              SAIM | BLSR | TRSR | TRDS | COAT | BLDS |        STIM },
3164                 { VK_FORMAT_R8G8B8A8_SRGB,                              SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL |        CABL },
3165                 { VK_FORMAT_B8G8R8A8_UNORM,                             SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL |        CABL },
3166                 { VK_FORMAT_B8G8R8A8_SRGB,                              SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL |        CABL },
3167                 { VK_FORMAT_A8B8G8R8_UNORM_PACK32,              SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL |        CABL },
3168                 { VK_FORMAT_A8B8G8R8_SNORM_PACK32,              SAIM | BLSR | TRSR | TRDS |               SIFL },
3169                 { VK_FORMAT_A8B8G8R8_UINT_PACK32,               SAIM | BLSR | TRSR | TRDS | COAT | BLDS },
3170                 { VK_FORMAT_A8B8G8R8_SINT_PACK32,               SAIM | BLSR | TRSR | TRDS | COAT | BLDS },
3171                 { VK_FORMAT_A8B8G8R8_SRGB_PACK32,               SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL |        CABL },
3172                 { VK_FORMAT_A2B10G10R10_UNORM_PACK32,   SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL |        CABL },
3173                 { VK_FORMAT_A2B10G10R10_UINT_PACK32,    SAIM | BLSR | TRSR | TRDS | COAT | BLDS },
3174                 { VK_FORMAT_R16_UINT,                                   SAIM | BLSR | TRSR | TRDS | COAT | BLDS },
3175                 { VK_FORMAT_R16_SINT,                                   SAIM | BLSR | TRSR | TRDS | COAT | BLDS },
3176                 { VK_FORMAT_R16_SFLOAT,                                 SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL |        CABL },
3177                 { VK_FORMAT_R16G16_UINT,                                SAIM | BLSR | TRSR | TRDS | COAT | BLDS },
3178                 { VK_FORMAT_R16G16_SINT,                                SAIM | BLSR | TRSR | TRDS | COAT | BLDS },
3179                 { VK_FORMAT_R16G16_SFLOAT,                              SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL |        CABL },
3180                 { VK_FORMAT_R16G16B16A16_UINT,                  SAIM | BLSR | TRSR | TRDS | COAT | BLDS |        STIM },
3181                 { VK_FORMAT_R16G16B16A16_SINT,                  SAIM | BLSR | TRSR | TRDS | COAT | BLDS |        STIM },
3182                 { VK_FORMAT_R16G16B16A16_SFLOAT,                SAIM | BLSR | TRSR | TRDS | COAT | BLDS | SIFL | STIM | CABL },
3183                 { VK_FORMAT_R32_UINT,                                   SAIM | BLSR | TRSR | TRDS | COAT | BLDS |        STIM |        STIA },
3184                 { VK_FORMAT_R32_SINT,                                   SAIM | BLSR | TRSR | TRDS | COAT | BLDS |        STIM |        STIA },
3185                 { VK_FORMAT_R32_SFLOAT,                                 SAIM | BLSR | TRSR | TRDS | COAT | BLDS |        STIM },
3186                 { VK_FORMAT_R32G32_UINT,                                SAIM | BLSR | TRSR | TRDS | COAT | BLDS |        STIM },
3187                 { VK_FORMAT_R32G32_SINT,                                SAIM | BLSR | TRSR | TRDS | COAT | BLDS |        STIM },
3188                 { VK_FORMAT_R32G32_SFLOAT,                              SAIM | BLSR | TRSR | TRDS | COAT | BLDS |        STIM },
3189                 { VK_FORMAT_R32G32B32A32_UINT,                  SAIM | BLSR | TRSR | TRDS | COAT | BLDS |        STIM },
3190                 { VK_FORMAT_R32G32B32A32_SINT,                  SAIM | BLSR | TRSR | TRDS | COAT | BLDS |        STIM },
3191                 { VK_FORMAT_R32G32B32A32_SFLOAT,                SAIM | BLSR | TRSR | TRDS | COAT | BLDS |        STIM },
3192                 { VK_FORMAT_B10G11R11_UFLOAT_PACK32,    SAIM | BLSR | TRSR | TRDS |               SIFL },
3193                 { VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,             SAIM | BLSR | TRSR | TRDS |               SIFL },
3194                 { VK_FORMAT_D16_UNORM,                                  SAIM | BLSR | TRSR | TRDS |                                           DSAT },
3195         };
3196
3197         size_t formatpairs = sizeof(formatflags) / sizeof(Formatpair);
3198
3199         for (unsigned int i = 0; i < formatpairs; i++)
3200                 if (formatflags[i].format == format)
3201                         return formatflags[i].flags;
3202         return 0;
3203 }
3204
3205 VkFormatFeatureFlags getRequiredOptimalExtendedTilingFeatures (Context& context, VkFormat format, VkFormatFeatureFlags queriedFlags)
3206 {
3207         VkFormatFeatureFlags    flags   = (VkFormatFeatureFlags)0;
3208
3209         // VK_EXT_sampler_filter_minmax:
3210         //      If filterMinmaxSingleComponentFormats is VK_TRUE, the following formats must
3211         //      support the VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT feature with
3212         //      VK_IMAGE_TILING_OPTIMAL, if they support VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT.
3213
3214         static const VkFormat s_requiredSampledImageFilterMinMaxFormats[] =
3215         {
3216                 VK_FORMAT_R8_UNORM,
3217                 VK_FORMAT_R8_SNORM,
3218                 VK_FORMAT_R16_UNORM,
3219                 VK_FORMAT_R16_SNORM,
3220                 VK_FORMAT_R16_SFLOAT,
3221                 VK_FORMAT_R32_SFLOAT,
3222                 VK_FORMAT_D16_UNORM,
3223                 VK_FORMAT_X8_D24_UNORM_PACK32,
3224                 VK_FORMAT_D32_SFLOAT,
3225                 VK_FORMAT_D16_UNORM_S8_UINT,
3226                 VK_FORMAT_D24_UNORM_S8_UINT,
3227                 VK_FORMAT_D32_SFLOAT_S8_UINT,
3228         };
3229
3230         if ((queriedFlags & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) != 0)
3231         {
3232                 if (de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_EXT_sampler_filter_minmax"))
3233                 {
3234                         if (de::contains(DE_ARRAY_BEGIN(s_requiredSampledImageFilterMinMaxFormats), DE_ARRAY_END(s_requiredSampledImageFilterMinMaxFormats), format))
3235                         {
3236                                 VkPhysicalDeviceSamplerFilterMinmaxProperties           physicalDeviceSamplerMinMaxProperties =
3237                                 {
3238                                         VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT,
3239                                         DE_NULL,
3240                                         DE_FALSE,
3241                                         DE_FALSE
3242                                 };
3243
3244                                 {
3245                                         VkPhysicalDeviceProperties2             physicalDeviceProperties;
3246                                         physicalDeviceProperties.sType  = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
3247                                         physicalDeviceProperties.pNext  = &physicalDeviceSamplerMinMaxProperties;
3248
3249                                         const InstanceInterface&                vk = context.getInstanceInterface();
3250                                         vk.getPhysicalDeviceProperties2(context.getPhysicalDevice(), &physicalDeviceProperties);
3251                                 }
3252
3253                                 if (physicalDeviceSamplerMinMaxProperties.filterMinmaxSingleComponentFormats)
3254                                 {
3255                                         flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT;
3256                                 }
3257                         }
3258                 }
3259         }
3260
3261         // VK_EXT_filter_cubic:
3262         // If cubic filtering is supported, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT must be supported for the following image view types:
3263         // VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_VIEW_TYPE_2D_ARRAY
3264         static const VkFormat s_requiredSampledImageFilterCubicFormats[] =
3265         {
3266                 VK_FORMAT_R4G4_UNORM_PACK8,
3267                 VK_FORMAT_R4G4B4A4_UNORM_PACK16,
3268                 VK_FORMAT_B4G4R4A4_UNORM_PACK16,
3269                 VK_FORMAT_R5G6B5_UNORM_PACK16,
3270                 VK_FORMAT_B5G6R5_UNORM_PACK16,
3271                 VK_FORMAT_R5G5B5A1_UNORM_PACK16,
3272                 VK_FORMAT_B5G5R5A1_UNORM_PACK16,
3273                 VK_FORMAT_A1R5G5B5_UNORM_PACK16,
3274                 VK_FORMAT_R8_UNORM,
3275                 VK_FORMAT_R8_SNORM,
3276                 VK_FORMAT_R8_SRGB,
3277                 VK_FORMAT_R8G8_UNORM,
3278                 VK_FORMAT_R8G8_SNORM,
3279                 VK_FORMAT_R8G8_SRGB,
3280                 VK_FORMAT_R8G8B8_UNORM,
3281                 VK_FORMAT_R8G8B8_SNORM,
3282                 VK_FORMAT_R8G8B8_SRGB,
3283                 VK_FORMAT_B8G8R8_UNORM,
3284                 VK_FORMAT_B8G8R8_SNORM,
3285                 VK_FORMAT_B8G8R8_SRGB,
3286                 VK_FORMAT_R8G8B8A8_UNORM,
3287                 VK_FORMAT_R8G8B8A8_SNORM,
3288                 VK_FORMAT_R8G8B8A8_SRGB,
3289                 VK_FORMAT_B8G8R8A8_UNORM,
3290                 VK_FORMAT_B8G8R8A8_SNORM,
3291                 VK_FORMAT_B8G8R8A8_SRGB,
3292                 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
3293                 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
3294                 VK_FORMAT_A8B8G8R8_SRGB_PACK32
3295         };
3296
3297         static const VkFormat s_requiredSampledImageFilterCubicFormatsETC2[] =
3298         {
3299                 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
3300                 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
3301                 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
3302                 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
3303                 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
3304                 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK
3305         };
3306
3307         if ( (queriedFlags & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) != 0 && de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_EXT_filter_cubic") )
3308         {
3309                 if ( de::contains(DE_ARRAY_BEGIN(s_requiredSampledImageFilterCubicFormats), DE_ARRAY_END(s_requiredSampledImageFilterCubicFormats), format) )
3310                         flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT;
3311
3312                 VkPhysicalDeviceFeatures2                                               coreFeatures;
3313                 deMemset(&coreFeatures, 0, sizeof(coreFeatures));
3314
3315                 coreFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
3316                 coreFeatures.pNext = DE_NULL;
3317                 context.getInstanceInterface().getPhysicalDeviceFeatures2(context.getPhysicalDevice(), &coreFeatures);
3318                 if ( coreFeatures.features.textureCompressionETC2 && de::contains(DE_ARRAY_BEGIN(s_requiredSampledImageFilterCubicFormatsETC2), DE_ARRAY_END(s_requiredSampledImageFilterCubicFormatsETC2), format) )
3319                         flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT;
3320         }
3321
3322         return flags;
3323 }
3324
3325 VkFormatFeatureFlags getRequiredBufferFeatures (VkFormat format)
3326 {
3327         static const VkFormat s_requiredVertexBufferFormats[] =
3328         {
3329                 VK_FORMAT_R8_UNORM,
3330                 VK_FORMAT_R8_SNORM,
3331                 VK_FORMAT_R8_UINT,
3332                 VK_FORMAT_R8_SINT,
3333                 VK_FORMAT_R8G8_UNORM,
3334                 VK_FORMAT_R8G8_SNORM,
3335                 VK_FORMAT_R8G8_UINT,
3336                 VK_FORMAT_R8G8_SINT,
3337                 VK_FORMAT_R8G8B8A8_UNORM,
3338                 VK_FORMAT_R8G8B8A8_SNORM,
3339                 VK_FORMAT_R8G8B8A8_UINT,
3340                 VK_FORMAT_R8G8B8A8_SINT,
3341                 VK_FORMAT_B8G8R8A8_UNORM,
3342                 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
3343                 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
3344                 VK_FORMAT_A8B8G8R8_UINT_PACK32,
3345                 VK_FORMAT_A8B8G8R8_SINT_PACK32,
3346                 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
3347                 VK_FORMAT_R16_UNORM,
3348                 VK_FORMAT_R16_SNORM,
3349                 VK_FORMAT_R16_UINT,
3350                 VK_FORMAT_R16_SINT,
3351                 VK_FORMAT_R16_SFLOAT,
3352                 VK_FORMAT_R16G16_UNORM,
3353                 VK_FORMAT_R16G16_SNORM,
3354                 VK_FORMAT_R16G16_UINT,
3355                 VK_FORMAT_R16G16_SINT,
3356                 VK_FORMAT_R16G16_SFLOAT,
3357                 VK_FORMAT_R16G16B16A16_UNORM,
3358                 VK_FORMAT_R16G16B16A16_SNORM,
3359                 VK_FORMAT_R16G16B16A16_UINT,
3360                 VK_FORMAT_R16G16B16A16_SINT,
3361                 VK_FORMAT_R16G16B16A16_SFLOAT,
3362                 VK_FORMAT_R32_UINT,
3363                 VK_FORMAT_R32_SINT,
3364                 VK_FORMAT_R32_SFLOAT,
3365                 VK_FORMAT_R32G32_UINT,
3366                 VK_FORMAT_R32G32_SINT,
3367                 VK_FORMAT_R32G32_SFLOAT,
3368                 VK_FORMAT_R32G32B32_UINT,
3369                 VK_FORMAT_R32G32B32_SINT,
3370                 VK_FORMAT_R32G32B32_SFLOAT,
3371                 VK_FORMAT_R32G32B32A32_UINT,
3372                 VK_FORMAT_R32G32B32A32_SINT,
3373                 VK_FORMAT_R32G32B32A32_SFLOAT
3374         };
3375         static const VkFormat s_requiredUniformTexelBufferFormats[] =
3376         {
3377                 VK_FORMAT_R8_UNORM,
3378                 VK_FORMAT_R8_SNORM,
3379                 VK_FORMAT_R8_UINT,
3380                 VK_FORMAT_R8_SINT,
3381                 VK_FORMAT_R8G8_UNORM,
3382                 VK_FORMAT_R8G8_SNORM,
3383                 VK_FORMAT_R8G8_UINT,
3384                 VK_FORMAT_R8G8_SINT,
3385                 VK_FORMAT_R8G8B8A8_UNORM,
3386                 VK_FORMAT_R8G8B8A8_SNORM,
3387                 VK_FORMAT_R8G8B8A8_UINT,
3388                 VK_FORMAT_R8G8B8A8_SINT,
3389                 VK_FORMAT_B8G8R8A8_UNORM,
3390                 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
3391                 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
3392                 VK_FORMAT_A8B8G8R8_UINT_PACK32,
3393                 VK_FORMAT_A8B8G8R8_SINT_PACK32,
3394                 VK_FORMAT_A2B10G10R10_UNORM_PACK32,
3395                 VK_FORMAT_A2B10G10R10_UINT_PACK32,
3396                 VK_FORMAT_R16_UINT,
3397                 VK_FORMAT_R16_SINT,
3398                 VK_FORMAT_R16_SFLOAT,
3399                 VK_FORMAT_R16G16_UINT,
3400                 VK_FORMAT_R16G16_SINT,
3401                 VK_FORMAT_R16G16_SFLOAT,
3402                 VK_FORMAT_R16G16B16A16_UINT,
3403                 VK_FORMAT_R16G16B16A16_SINT,
3404                 VK_FORMAT_R16G16B16A16_SFLOAT,
3405                 VK_FORMAT_R32_UINT,
3406                 VK_FORMAT_R32_SINT,
3407                 VK_FORMAT_R32_SFLOAT,
3408                 VK_FORMAT_R32G32_UINT,
3409                 VK_FORMAT_R32G32_SINT,
3410                 VK_FORMAT_R32G32_SFLOAT,
3411                 VK_FORMAT_R32G32B32A32_UINT,
3412                 VK_FORMAT_R32G32B32A32_SINT,
3413                 VK_FORMAT_R32G32B32A32_SFLOAT,
3414                 VK_FORMAT_B10G11R11_UFLOAT_PACK32
3415         };
3416         static const VkFormat s_requiredStorageTexelBufferFormats[] =
3417         {
3418                 VK_FORMAT_R8G8B8A8_UNORM,
3419                 VK_FORMAT_R8G8B8A8_SNORM,
3420                 VK_FORMAT_R8G8B8A8_UINT,
3421                 VK_FORMAT_R8G8B8A8_SINT,
3422                 VK_FORMAT_A8B8G8R8_UNORM_PACK32,
3423                 VK_FORMAT_A8B8G8R8_SNORM_PACK32,
3424                 VK_FORMAT_A8B8G8R8_UINT_PACK32,
3425                 VK_FORMAT_A8B8G8R8_SINT_PACK32,
3426                 VK_FORMAT_R16G16B16A16_UINT,
3427                 VK_FORMAT_R16G16B16A16_SINT,
3428                 VK_FORMAT_R16G16B16A16_SFLOAT,
3429                 VK_FORMAT_R32_UINT,
3430                 VK_FORMAT_R32_SINT,
3431                 VK_FORMAT_R32_SFLOAT,
3432                 VK_FORMAT_R32G32_UINT,
3433                 VK_FORMAT_R32G32_SINT,
3434                 VK_FORMAT_R32G32_SFLOAT,
3435                 VK_FORMAT_R32G32B32A32_UINT,
3436                 VK_FORMAT_R32G32B32A32_SINT,
3437                 VK_FORMAT_R32G32B32A32_SFLOAT
3438         };
3439         static const VkFormat s_requiredStorageTexelBufferAtomicFormats[] =
3440         {
3441                 VK_FORMAT_R32_UINT,
3442                 VK_FORMAT_R32_SINT
3443         };
3444
3445         VkFormatFeatureFlags    flags   = (VkFormatFeatureFlags)0;
3446
3447         if (de::contains(DE_ARRAY_BEGIN(s_requiredVertexBufferFormats), DE_ARRAY_END(s_requiredVertexBufferFormats), format))
3448                 flags |= VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT;
3449
3450         if (de::contains(DE_ARRAY_BEGIN(s_requiredUniformTexelBufferFormats), DE_ARRAY_END(s_requiredUniformTexelBufferFormats), format))
3451                 flags |= VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT;
3452
3453         if (de::contains(DE_ARRAY_BEGIN(s_requiredStorageTexelBufferFormats), DE_ARRAY_END(s_requiredStorageTexelBufferFormats), format))
3454                 flags |= VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT;
3455
3456         if (de::contains(DE_ARRAY_BEGIN(s_requiredStorageTexelBufferAtomicFormats), DE_ARRAY_END(s_requiredStorageTexelBufferAtomicFormats), format))
3457                 flags |= VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT;
3458
3459         return flags;
3460 }
3461
3462 VkPhysicalDeviceSamplerYcbcrConversionFeatures getPhysicalDeviceSamplerYcbcrConversionFeatures (const InstanceInterface& vk, VkPhysicalDevice physicalDevice)
3463 {
3464         VkPhysicalDeviceFeatures2                                               coreFeatures;
3465         VkPhysicalDeviceSamplerYcbcrConversionFeatures  ycbcrFeatures;
3466
3467         deMemset(&coreFeatures, 0, sizeof(coreFeatures));
3468         deMemset(&ycbcrFeatures, 0, sizeof(ycbcrFeatures));
3469
3470         coreFeatures.sType              = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
3471         coreFeatures.pNext              = &ycbcrFeatures;
3472         ycbcrFeatures.sType             = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
3473
3474         vk.getPhysicalDeviceFeatures2(physicalDevice, &coreFeatures);
3475
3476         return ycbcrFeatures;
3477 }
3478
3479 void checkYcbcrApiSupport (Context& context)
3480 {
3481         // check if YCbcr API and are supported by implementation
3482
3483         // the support for formats and YCbCr may still be optional - see isYcbcrConversionSupported below
3484
3485         if (!vk::isCoreDeviceExtension(context.getUsedApiVersion(), "VK_KHR_sampler_ycbcr_conversion"))
3486         {
3487                 if (!context.isDeviceFunctionalitySupported("VK_KHR_sampler_ycbcr_conversion"))
3488                         TCU_THROW(NotSupportedError, "VK_KHR_sampler_ycbcr_conversion is not supported");
3489
3490                 // Hard dependency for ycbcr
3491                 TCU_CHECK(de::contains(context.getInstanceExtensions().begin(), context.getInstanceExtensions().end(), "VK_KHR_get_physical_device_properties2"));
3492         }
3493 }
3494
3495 bool isYcbcrConversionSupported (Context& context)
3496 {
3497         checkYcbcrApiSupport(context);
3498
3499         const VkPhysicalDeviceSamplerYcbcrConversionFeatures    ycbcrFeatures   = getPhysicalDeviceSamplerYcbcrConversionFeatures(context.getInstanceInterface(), context.getPhysicalDevice());
3500
3501         return (ycbcrFeatures.samplerYcbcrConversion == VK_TRUE);
3502 }
3503
3504 VkFormatFeatureFlags getRequiredYcbcrFormatFeatures (Context& context, VkFormat format)
3505 {
3506         bool req = isYcbcrConversionSupported(context) && (     format == VK_FORMAT_G8_B8R8_2PLANE_420_UNORM ||
3507                                                                                                                 format == VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM);
3508
3509         const VkFormatFeatureFlags      required        = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT
3510                                                                                         | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT
3511                                                                                         | VK_FORMAT_FEATURE_TRANSFER_DST_BIT
3512                                                                                         | VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT;
3513         return req ? required : (VkFormatFeatureFlags)0;
3514 }
3515
3516 VkFormatFeatureFlags getRequiredOptimalTilingFeatures (Context& context, VkFormat format)
3517 {
3518         if (isYCbCrFormat(format))
3519                 return getRequiredYcbcrFormatFeatures(context, format);
3520         else
3521         {
3522                 VkFormatFeatureFlags ret = getBaseRequiredOptimalTilingFeatures(format);
3523
3524                 // \todo [2017-05-16 pyry] This should be extended to cover for example COLOR_ATTACHMENT for depth formats etc.
3525                 // \todo [2017-05-18 pyry] Any other color conversion related features that can't be supported by regular formats?
3526                 ret |= getRequiredOptimalExtendedTilingFeatures(context, format, ret);
3527
3528                 // Compressed formats have optional support for some features
3529                 // TODO: Is this really correct? It looks like it should be checking the different compressed features
3530                 if (isCompressedFormat(format) && (ret & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT))
3531                         ret |=  VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
3532                                         VK_FORMAT_FEATURE_TRANSFER_DST_BIT |
3533                                         VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
3534                                         VK_FORMAT_FEATURE_BLIT_SRC_BIT;
3535
3536                 return ret;
3537         }
3538 }
3539
3540 bool requiresYCbCrConversion(Context& context, VkFormat format)
3541 {
3542         if (format == VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16)
3543         {
3544                 if (!context.isDeviceFunctionalitySupported("VK_EXT_rgba10x6_formats"))
3545                         return true;
3546                 VkPhysicalDeviceFeatures2                                               coreFeatures;
3547                 VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT      rgba10x6features;
3548
3549                 deMemset(&coreFeatures, 0, sizeof(coreFeatures));
3550                 deMemset(&rgba10x6features, 0, sizeof(rgba10x6features));
3551
3552                 coreFeatures.sType              = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
3553                 coreFeatures.pNext              = &rgba10x6features;
3554                 rgba10x6features.sType          = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
3555
3556                 const InstanceInterface &vk = context.getInstanceInterface();
3557                 vk.getPhysicalDeviceFeatures2(context.getPhysicalDevice(), &coreFeatures);
3558
3559                 return !rgba10x6features.formatRgba10x6WithoutYCbCrSampler;
3560         }
3561
3562         return isYCbCrFormat(format) &&
3563                         format != VK_FORMAT_R10X6_UNORM_PACK16 && format != VK_FORMAT_R10X6G10X6_UNORM_2PACK16 &&
3564                         format != VK_FORMAT_R12X4_UNORM_PACK16 && format != VK_FORMAT_R12X4G12X4_UNORM_2PACK16;
3565 }
3566
3567 VkFormatFeatureFlags getAllowedOptimalTilingFeatures (Context &context, VkFormat format)
3568 {
3569         // YCbCr formats only support a subset of format feature flags
3570         const VkFormatFeatureFlags ycbcrAllows =
3571                 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
3572                 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT |
3573                 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG |
3574                 VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
3575                 VK_FORMAT_FEATURE_TRANSFER_DST_BIT |
3576                 VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT |
3577                 VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT |
3578                 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT |
3579                 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT |
3580                 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT |
3581                 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT |
3582                 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT |
3583                 VK_FORMAT_FEATURE_DISJOINT_BIT;
3584
3585         // By default everything is allowed.
3586         VkFormatFeatureFlags allow = (VkFormatFeatureFlags)~0u;
3587         // Formats for which SamplerYCbCrConversion is required may not support certain features.
3588         if (requiresYCbCrConversion(context, format))
3589                 allow &= ycbcrAllows;
3590         // single-plane formats *may not* support DISJOINT_BIT
3591         if (!isYCbCrFormat(format) || getPlaneCount(format) == 1)
3592                 allow &= ~VK_FORMAT_FEATURE_DISJOINT_BIT;
3593
3594         return allow;
3595 }
3596
3597 VkFormatFeatureFlags getAllowedBufferFeatures (Context &context, VkFormat format)
3598 {
3599         // TODO: Do we allow non-buffer flags in the bufferFeatures?
3600         return requiresYCbCrConversion(context, format) ? (VkFormatFeatureFlags)0 : (VkFormatFeatureFlags)(~VK_FORMAT_FEATURE_DISJOINT_BIT);
3601 }
3602
3603 tcu::TestStatus formatProperties (Context& context, VkFormat format)
3604 {
3605         // check if Ycbcr format enums are valid given the version and extensions
3606         if (isYCbCrFormat(format))
3607                 checkYcbcrApiSupport(context);
3608
3609         TestLog&                                        log                     = context.getTestContext().getLog();
3610         const VkFormatProperties        properties      = getPhysicalDeviceFormatProperties(context.getInstanceInterface(), context.getPhysicalDevice(), format);
3611         bool                                            allOk           = true;
3612
3613         const VkFormatFeatureFlags reqImg       = getRequiredOptimalTilingFeatures(context, format);
3614         const VkFormatFeatureFlags reqBuf       = getRequiredBufferFeatures(format);
3615         const VkFormatFeatureFlags allowImg     = getAllowedOptimalTilingFeatures(context, format);
3616         const VkFormatFeatureFlags allowBuf     = getAllowedBufferFeatures(context, format);
3617
3618         const struct feature_req
3619         {
3620                 const char*                             fieldName;
3621                 VkFormatFeatureFlags    supportedFeatures;
3622                 VkFormatFeatureFlags    requiredFeatures;
3623                 VkFormatFeatureFlags    allowedFeatures;
3624         } fields[] =
3625         {
3626                 { "linearTilingFeatures",       properties.linearTilingFeatures,        (VkFormatFeatureFlags)0,        allowImg },
3627                 { "optimalTilingFeatures",      properties.optimalTilingFeatures,       reqImg,                                         allowImg },
3628                 { "bufferFeatures",                     properties.bufferFeatures,                      reqBuf,                                         allowBuf }
3629         };
3630
3631         log << TestLog::Message << properties << TestLog::EndMessage;
3632
3633         for (int fieldNdx = 0; fieldNdx < DE_LENGTH_OF_ARRAY(fields); fieldNdx++)
3634         {
3635                 const char* const                       fieldName       = fields[fieldNdx].fieldName;
3636                 const VkFormatFeatureFlags      supported       = fields[fieldNdx].supportedFeatures;
3637                 const VkFormatFeatureFlags      required        = fields[fieldNdx].requiredFeatures;
3638                 const VkFormatFeatureFlags      allowed         = fields[fieldNdx].allowedFeatures;
3639
3640                 if ((supported & required) != required)
3641                 {
3642                         log << TestLog::Message << "ERROR in " << fieldName << ":\n"
3643                                                                         << "  required: " << getFormatFeatureFlagsStr(required) << "\n  "
3644                                                                         << "  missing: " << getFormatFeatureFlagsStr(~supported & required)
3645                                 << TestLog::EndMessage;
3646                         allOk = false;
3647                 }
3648
3649                 if ((supported & ~allowed) != 0)
3650                 {
3651                         log << TestLog::Message << "ERROR in " << fieldName << ":\n"
3652                                                                         << "  has: " << getFormatFeatureFlagsStr(supported & ~allowed)
3653                                 << TestLog::EndMessage;
3654                         allOk = false;
3655                 }
3656
3657                 if (((supported & VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT) != 0) &&
3658                         ((supported & VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT) == 0))
3659                 {
3660                         log << TestLog::Message << "ERROR in " << fieldName << ":\n"
3661                                                                         << " supports VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT"
3662                                                                         << " but not VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT"
3663                                 << TestLog::EndMessage;
3664                         allOk = false;
3665                 }
3666         }
3667
3668         if (allOk)
3669                 return tcu::TestStatus::pass("Query and validation passed");
3670         else
3671                 return tcu::TestStatus::fail("Required features not supported");
3672 }
3673
3674 bool optimalTilingFeaturesSupported (Context& context, VkFormat format, VkFormatFeatureFlags features)
3675 {
3676         const VkFormatProperties        properties      = getPhysicalDeviceFormatProperties(context.getInstanceInterface(), context.getPhysicalDevice(), format);
3677
3678         return (properties.optimalTilingFeatures & features) == features;
3679 }
3680
3681 bool optimalTilingFeaturesSupportedForAll (Context& context, const VkFormat* begin, const VkFormat* end, VkFormatFeatureFlags features)
3682 {
3683         for (const VkFormat* cur = begin; cur != end; ++cur)
3684         {
3685                 if (!optimalTilingFeaturesSupported(context, *cur, features))
3686                         return false;
3687         }
3688
3689         return true;
3690 }
3691
3692 tcu::TestStatus testDepthStencilSupported (Context& context)
3693 {
3694         if (!optimalTilingFeaturesSupported(context, VK_FORMAT_X8_D24_UNORM_PACK32, VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) &&
3695                 !optimalTilingFeaturesSupported(context, VK_FORMAT_D32_SFLOAT, VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT))
3696                 return tcu::TestStatus::fail("Doesn't support one of VK_FORMAT_X8_D24_UNORM_PACK32 or VK_FORMAT_D32_SFLOAT");
3697
3698         if (!optimalTilingFeaturesSupported(context, VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) &&
3699                 !optimalTilingFeaturesSupported(context, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT))
3700                 return tcu::TestStatus::fail("Doesn't support one of VK_FORMAT_D24_UNORM_S8_UINT or VK_FORMAT_D32_SFLOAT_S8_UINT");
3701
3702         return tcu::TestStatus::pass("Required depth/stencil formats supported");
3703 }
3704
3705 tcu::TestStatus testCompressedFormatsSupported (Context& context)
3706 {
3707         static const VkFormat s_allBcFormats[] =
3708         {
3709                 VK_FORMAT_BC1_RGB_UNORM_BLOCK,
3710                 VK_FORMAT_BC1_RGB_SRGB_BLOCK,
3711                 VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
3712                 VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
3713                 VK_FORMAT_BC2_UNORM_BLOCK,
3714                 VK_FORMAT_BC2_SRGB_BLOCK,
3715                 VK_FORMAT_BC3_UNORM_BLOCK,
3716                 VK_FORMAT_BC3_SRGB_BLOCK,
3717                 VK_FORMAT_BC4_UNORM_BLOCK,
3718                 VK_FORMAT_BC4_SNORM_BLOCK,
3719                 VK_FORMAT_BC5_UNORM_BLOCK,
3720                 VK_FORMAT_BC5_SNORM_BLOCK,
3721                 VK_FORMAT_BC6H_UFLOAT_BLOCK,
3722                 VK_FORMAT_BC6H_SFLOAT_BLOCK,
3723                 VK_FORMAT_BC7_UNORM_BLOCK,
3724                 VK_FORMAT_BC7_SRGB_BLOCK,
3725         };
3726         static const VkFormat s_allEtc2Formats[] =
3727         {
3728                 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
3729                 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
3730                 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
3731                 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
3732                 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
3733                 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
3734                 VK_FORMAT_EAC_R11_UNORM_BLOCK,
3735                 VK_FORMAT_EAC_R11_SNORM_BLOCK,
3736                 VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
3737                 VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
3738         };
3739         static const VkFormat s_allAstcLdrFormats[] =
3740         {
3741                 VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
3742                 VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
3743                 VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
3744                 VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
3745                 VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
3746                 VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
3747                 VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
3748                 VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
3749                 VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
3750                 VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
3751                 VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
3752                 VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
3753                 VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
3754                 VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
3755                 VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
3756                 VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
3757                 VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
3758                 VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
3759                 VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
3760                 VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
3761                 VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
3762                 VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
3763                 VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
3764                 VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
3765                 VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
3766                 VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
3767                 VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
3768                 VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
3769         };
3770
3771         static const struct
3772         {
3773                 const char*                                                                     setName;
3774                 const char*                                                                     featureName;
3775                 const VkBool32 VkPhysicalDeviceFeatures::*      feature;
3776                 const VkFormat*                                                         formatsBegin;
3777                 const VkFormat*                                                         formatsEnd;
3778         } s_compressedFormatSets[] =
3779         {
3780                 { "BC",                 "textureCompressionBC",                 &VkPhysicalDeviceFeatures::textureCompressionBC,                DE_ARRAY_BEGIN(s_allBcFormats),                 DE_ARRAY_END(s_allBcFormats)            },
3781                 { "ETC2",               "textureCompressionETC2",               &VkPhysicalDeviceFeatures::textureCompressionETC2,              DE_ARRAY_BEGIN(s_allEtc2Formats),               DE_ARRAY_END(s_allEtc2Formats)          },
3782                 { "ASTC LDR",   "textureCompressionASTC_LDR",   &VkPhysicalDeviceFeatures::textureCompressionASTC_LDR,  DE_ARRAY_BEGIN(s_allAstcLdrFormats),    DE_ARRAY_END(s_allAstcLdrFormats)       },
3783         };
3784
3785         TestLog&                                                log                                     = context.getTestContext().getLog();
3786         const VkPhysicalDeviceFeatures& features                        = context.getDeviceFeatures();
3787         int                                                             numSupportedSets        = 0;
3788         int                                                             numErrors                       = 0;
3789         int                                                             numWarnings                     = 0;
3790
3791         for (int setNdx = 0; setNdx < DE_LENGTH_OF_ARRAY(s_compressedFormatSets); ++setNdx)
3792         {
3793                 const char* const                       setName                         = s_compressedFormatSets[setNdx].setName;
3794                 const char* const                       featureName                     = s_compressedFormatSets[setNdx].featureName;
3795                 const bool                                      featureBitSet           = features.*s_compressedFormatSets[setNdx].feature == VK_TRUE;
3796                 const VkFormatFeatureFlags      requiredFeatures        =
3797                         VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT |
3798                         VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
3799                 const bool                      allSupported    = optimalTilingFeaturesSupportedForAll(context,
3800                                                                                                                                                                    s_compressedFormatSets[setNdx].formatsBegin,
3801                                                                                                                                                                    s_compressedFormatSets[setNdx].formatsEnd,
3802                                                                                                                                                                    requiredFeatures);
3803
3804                 if (featureBitSet && !allSupported)
3805                 {
3806                         log << TestLog::Message << "ERROR: " << featureName << " = VK_TRUE but " << setName << " formats not supported" << TestLog::EndMessage;
3807                         numErrors += 1;
3808                 }
3809                 else if (allSupported && !featureBitSet)
3810                 {
3811                         log << TestLog::Message << "WARNING: " << setName << " formats supported but " << featureName << " = VK_FALSE" << TestLog::EndMessage;
3812                         numWarnings += 1;
3813                 }
3814
3815                 if (featureBitSet)
3816                 {
3817                         log << TestLog::Message << "All " << setName << " formats are supported" << TestLog::EndMessage;
3818                         numSupportedSets += 1;
3819                 }
3820                 else
3821                         log << TestLog::Message << setName << " formats are not supported" << TestLog::EndMessage;
3822         }
3823
3824         if (numSupportedSets == 0)
3825         {
3826                 log << TestLog::Message << "No compressed format sets supported" << TestLog::EndMessage;
3827                 numErrors += 1;
3828         }
3829
3830         if (numErrors > 0)
3831                 return tcu::TestStatus::fail("Compressed format support not valid");
3832         else if (numWarnings > 0)
3833                 return tcu::TestStatus(QP_TEST_RESULT_QUALITY_WARNING, "Found inconsistencies in compressed format support");
3834         else
3835                 return tcu::TestStatus::pass("Compressed texture format support is valid");
3836 }
3837
3838 void createFormatTests (tcu::TestCaseGroup* testGroup)
3839 {
3840         DE_STATIC_ASSERT(VK_FORMAT_UNDEFINED == 0);
3841
3842         static const struct
3843         {
3844                 VkFormat        begin;
3845                 VkFormat        end;
3846         } s_formatRanges[] =
3847         {
3848                 // core formats
3849                 { (VkFormat)(VK_FORMAT_UNDEFINED+1),            VK_CORE_FORMAT_LAST                                                                             },
3850
3851                 // YCbCr formats
3852                 { VK_FORMAT_G8B8G8R8_422_UNORM,                         (VkFormat)(VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM+1)    },
3853
3854                 // YCbCr extended formats
3855                 { VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT,       (VkFormat)(VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT+1) },
3856         };
3857
3858         for (int rangeNdx = 0; rangeNdx < DE_LENGTH_OF_ARRAY(s_formatRanges); ++rangeNdx)
3859         {
3860                 const VkFormat                                                          rangeBegin              = s_formatRanges[rangeNdx].begin;
3861                 const VkFormat                                                          rangeEnd                = s_formatRanges[rangeNdx].end;
3862
3863                 for (VkFormat format = rangeBegin; format != rangeEnd; format = (VkFormat)(format+1))
3864                 {
3865                         const char* const       enumName        = getFormatName(format);
3866                         const string            caseName        = de::toLower(string(enumName).substr(10));
3867
3868                         addFunctionCase(testGroup, caseName, enumName, formatProperties, format);
3869                 }
3870         }
3871
3872         addFunctionCase(testGroup, "depth_stencil",                     "",     testDepthStencilSupported);
3873         addFunctionCase(testGroup, "compressed_formats",        "",     testCompressedFormatsSupported);
3874 }
3875
3876 VkImageUsageFlags getValidImageUsageFlags (const VkFormatFeatureFlags supportedFeatures, const bool useKhrMaintenance1Semantics)
3877 {
3878         VkImageUsageFlags       flags   = (VkImageUsageFlags)0;
3879
3880         if (useKhrMaintenance1Semantics)
3881         {
3882                 if ((supportedFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) != 0)
3883                         flags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
3884
3885                 if ((supportedFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) != 0)
3886                         flags |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
3887         }
3888         else
3889         {
3890                 // If format is supported at all, it must be valid transfer src+dst
3891                 if (supportedFeatures != 0)
3892                         flags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT;
3893         }
3894
3895         if ((supportedFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) != 0)
3896                 flags |= VK_IMAGE_USAGE_SAMPLED_BIT;
3897
3898         if ((supportedFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) != 0)
3899                 flags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT|VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
3900
3901         if ((supportedFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0)
3902                 flags |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
3903
3904         if ((supportedFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) != 0)
3905                 flags |= VK_IMAGE_USAGE_STORAGE_BIT;
3906
3907         return flags;
3908 }
3909
3910 bool isValidImageUsageFlagCombination (VkImageUsageFlags usage)
3911 {
3912         if ((usage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) != 0)
3913         {
3914                 const VkImageUsageFlags         allowedFlags    = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT
3915                                                                                                         | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
3916                                                                                                         | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
3917                                                                                                         | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
3918
3919                 // Only *_ATTACHMENT_BIT flags can be combined with TRANSIENT_ATTACHMENT_BIT
3920                 if ((usage & ~allowedFlags) != 0)
3921                         return false;
3922
3923                 // TRANSIENT_ATTACHMENT_BIT is not valid without COLOR_ or DEPTH_STENCIL_ATTACHMENT_BIT
3924                 if ((usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) == 0)
3925                         return false;
3926         }
3927
3928         return usage != 0;
3929 }
3930
3931 VkImageCreateFlags getValidImageCreateFlags (const VkPhysicalDeviceFeatures& deviceFeatures, VkFormat format, VkFormatFeatureFlags formatFeatures, VkImageType type, VkImageUsageFlags usage)
3932 {
3933         VkImageCreateFlags      flags   = (VkImageCreateFlags)0;
3934
3935         if ((usage & VK_IMAGE_USAGE_SAMPLED_BIT) != 0)
3936         {
3937                 flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
3938
3939                 if (type == VK_IMAGE_TYPE_2D && !isYCbCrFormat(format))
3940                 {
3941                         flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
3942                 }
3943         }
3944
3945         if (isYCbCrFormat(format) && getPlaneCount(format) > 1)
3946         {
3947                 if (formatFeatures & VK_FORMAT_FEATURE_DISJOINT_BIT_KHR)
3948                         flags |= VK_IMAGE_CREATE_DISJOINT_BIT_KHR;
3949         }
3950
3951         if ((usage & (VK_IMAGE_USAGE_SAMPLED_BIT|VK_IMAGE_USAGE_STORAGE_BIT)) != 0 &&
3952                 (usage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) == 0)
3953         {
3954                 if (deviceFeatures.sparseBinding)
3955                         flags |= VK_IMAGE_CREATE_SPARSE_BINDING_BIT|VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT;
3956
3957                 if (deviceFeatures.sparseResidencyAliased)
3958                         flags |= VK_IMAGE_CREATE_SPARSE_BINDING_BIT|VK_IMAGE_CREATE_SPARSE_ALIASED_BIT;
3959         }
3960
3961         return flags;
3962 }
3963
3964 bool isValidImageCreateFlagCombination (VkImageCreateFlags createFlags)
3965 {
3966         bool isValid = true;
3967
3968         if (((createFlags & (VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT|VK_IMAGE_CREATE_SPARSE_ALIASED_BIT)) != 0) &&
3969                 ((createFlags & VK_IMAGE_CREATE_SPARSE_BINDING_BIT) == 0))
3970         {
3971                 isValid = false;
3972         }
3973
3974         return isValid;
3975 }
3976
3977 bool isRequiredImageParameterCombination (const VkPhysicalDeviceFeatures&       deviceFeatures,
3978                                                                                   const VkFormat                                        format,
3979                                                                                   const VkFormatProperties&                     formatProperties,
3980                                                                                   const VkImageType                                     imageType,
3981                                                                                   const VkImageTiling                           imageTiling,
3982                                                                                   const VkImageUsageFlags                       usageFlags,
3983                                                                                   const VkImageCreateFlags                      createFlags)
3984 {
3985         DE_UNREF(deviceFeatures);
3986         DE_UNREF(formatProperties);
3987         DE_UNREF(createFlags);
3988
3989         // Linear images can have arbitrary limitations
3990         if (imageTiling == VK_IMAGE_TILING_LINEAR)
3991                 return false;
3992
3993         // Support for other usages for compressed formats is optional
3994         if (isCompressedFormat(format) &&
3995                 (usageFlags & ~(VK_IMAGE_USAGE_SAMPLED_BIT|VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT)) != 0)
3996                 return false;
3997
3998         // Support for 1D, and sliced 3D compressed formats is optional
3999         if (isCompressedFormat(format) && (imageType == VK_IMAGE_TYPE_1D || imageType == VK_IMAGE_TYPE_3D))
4000                 return false;
4001
4002         // Support for 1D and 3D depth/stencil textures is optional
4003         if (isDepthStencilFormat(format) && (imageType == VK_IMAGE_TYPE_1D || imageType == VK_IMAGE_TYPE_3D))
4004                 return false;
4005
4006         DE_ASSERT(deviceFeatures.sparseBinding || (createFlags & (VK_IMAGE_CREATE_SPARSE_BINDING_BIT|VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT)) == 0);
4007         DE_ASSERT(deviceFeatures.sparseResidencyAliased || (createFlags & VK_IMAGE_CREATE_SPARSE_ALIASED_BIT) == 0);
4008
4009         if (isYCbCrFormat(format) && (createFlags & (VK_IMAGE_CREATE_SPARSE_BINDING_BIT | VK_IMAGE_CREATE_SPARSE_ALIASED_BIT | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT)))
4010                 return false;
4011
4012         if (createFlags & VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT)
4013         {
4014                 if (isCompressedFormat(format))
4015                         return false;
4016
4017                 if (isDepthStencilFormat(format))
4018                         return false;
4019
4020                 if (!deIsPowerOfTwo32(mapVkFormat(format).getPixelSize()))
4021                         return false;
4022
4023                 switch (imageType)
4024                 {
4025                         case VK_IMAGE_TYPE_2D:
4026                                 return (deviceFeatures.sparseResidencyImage2D == VK_TRUE);
4027                         case VK_IMAGE_TYPE_3D:
4028                                 return (deviceFeatures.sparseResidencyImage3D == VK_TRUE);
4029                         default:
4030                                 return false;
4031                 }
4032         }
4033
4034         return true;
4035 }
4036
4037 VkSampleCountFlags getRequiredOptimalTilingSampleCounts (const VkPhysicalDeviceLimits&  deviceLimits,
4038                                                                                                                  const VkFormat                                 format,
4039                                                                                                                  const VkImageUsageFlags                usageFlags)
4040 {
4041         if (isCompressedFormat(format))
4042                 return VK_SAMPLE_COUNT_1_BIT;
4043
4044         bool            hasDepthComp    = false;
4045         bool            hasStencilComp  = false;
4046         const bool      isYCbCr                 = isYCbCrFormat(format);
4047         if (!isYCbCr)
4048         {
4049                 const tcu::TextureFormat        tcuFormat               = mapVkFormat(format);
4050                 hasDepthComp    = (tcuFormat.order == tcu::TextureFormat::D || tcuFormat.order == tcu::TextureFormat::DS);
4051                 hasStencilComp  = (tcuFormat.order == tcu::TextureFormat::S || tcuFormat.order == tcu::TextureFormat::DS);
4052         }
4053
4054         const bool                                              isColorFormat   = !hasDepthComp && !hasStencilComp;
4055         VkSampleCountFlags                              sampleCounts    = ~(VkSampleCountFlags)0;
4056
4057         DE_ASSERT((hasDepthComp || hasStencilComp) != isColorFormat);
4058
4059         if ((usageFlags & VK_IMAGE_USAGE_STORAGE_BIT) != 0)
4060                 sampleCounts &= deviceLimits.storageImageSampleCounts;
4061
4062         if ((usageFlags & VK_IMAGE_USAGE_SAMPLED_BIT) != 0)
4063         {
4064                 if (hasDepthComp)
4065                         sampleCounts &= deviceLimits.sampledImageDepthSampleCounts;
4066
4067                 if (hasStencilComp)
4068                         sampleCounts &= deviceLimits.sampledImageStencilSampleCounts;
4069
4070                 if (isColorFormat)
4071                 {
4072                         if (isYCbCr)
4073                                 sampleCounts &= deviceLimits.sampledImageColorSampleCounts;
4074                         else
4075                         {
4076                                 const tcu::TextureFormat                tcuFormat       = mapVkFormat(format);
4077                                 const tcu::TextureChannelClass  chnClass        = tcu::getTextureChannelClass(tcuFormat.type);
4078
4079                                 if (chnClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER ||
4080                                         chnClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER)
4081                                         sampleCounts &= deviceLimits.sampledImageIntegerSampleCounts;
4082                                 else
4083                                         sampleCounts &= deviceLimits.sampledImageColorSampleCounts;
4084                         }
4085                 }
4086         }
4087
4088         if ((usageFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) != 0)
4089                 sampleCounts &= deviceLimits.framebufferColorSampleCounts;
4090
4091         if ((usageFlags & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0)
4092         {
4093                 if (hasDepthComp)
4094                         sampleCounts &= deviceLimits.framebufferDepthSampleCounts;
4095
4096                 if (hasStencilComp)
4097                         sampleCounts &= deviceLimits.framebufferStencilSampleCounts;
4098         }
4099
4100         // If there is no usage flag set that would have corresponding device limit,
4101         // only VK_SAMPLE_COUNT_1_BIT is required.
4102         if (sampleCounts == ~(VkSampleCountFlags)0)
4103                 sampleCounts &= VK_SAMPLE_COUNT_1_BIT;
4104
4105         return sampleCounts;
4106 }
4107
4108 struct ImageFormatPropertyCase
4109 {
4110         typedef tcu::TestStatus (*Function) (Context& context, const VkFormat format, const VkImageType imageType, const VkImageTiling tiling);
4111
4112         Function                testFunction;
4113         VkFormat                format;
4114         VkImageType             imageType;
4115         VkImageTiling   tiling;
4116
4117         ImageFormatPropertyCase (Function testFunction_, VkFormat format_, VkImageType imageType_, VkImageTiling tiling_)
4118                 : testFunction  (testFunction_)
4119                 , format                (format_)
4120                 , imageType             (imageType_)
4121                 , tiling                (tiling_)
4122         {}
4123
4124         ImageFormatPropertyCase (void)
4125                 : testFunction  ((Function)DE_NULL)
4126                 , format                (VK_FORMAT_UNDEFINED)
4127                 , imageType             (VK_CORE_IMAGE_TYPE_LAST)
4128                 , tiling                (VK_CORE_IMAGE_TILING_LAST)
4129         {}
4130 };
4131
4132 tcu::TestStatus imageFormatProperties (Context& context, const VkFormat format, const VkImageType imageType, const VkImageTiling tiling)
4133 {
4134         if (isYCbCrFormat(format))
4135                 // check if Ycbcr format enums are valid given the version and extensions
4136                 checkYcbcrApiSupport(context);
4137
4138         TestLog&                                                log                                     = context.getTestContext().getLog();
4139         const VkPhysicalDeviceFeatures& deviceFeatures          = context.getDeviceFeatures();
4140         const VkPhysicalDeviceLimits&   deviceLimits            = context.getDeviceProperties().limits;
4141         const VkFormatProperties                formatProperties        = getPhysicalDeviceFormatProperties(context.getInstanceInterface(), context.getPhysicalDevice(), format);
4142         const bool                                              hasKhrMaintenance1      = context.isDeviceFunctionalitySupported("VK_KHR_maintenance1");
4143
4144         const VkFormatFeatureFlags              supportedFeatures       = tiling == VK_IMAGE_TILING_LINEAR ? formatProperties.linearTilingFeatures : formatProperties.optimalTilingFeatures;
4145         const VkImageUsageFlags                 usageFlagSet            = getValidImageUsageFlags(supportedFeatures, hasKhrMaintenance1);
4146
4147         tcu::ResultCollector                    results                         (log, "ERROR: ");
4148
4149         if (hasKhrMaintenance1 && (supportedFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) != 0)
4150         {
4151                 results.check((supportedFeatures & (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT|VK_FORMAT_FEATURE_TRANSFER_DST_BIT)) != 0,
4152                                           "A sampled image format must have VK_FORMAT_FEATURE_TRANSFER_SRC_BIT and VK_FORMAT_FEATURE_TRANSFER_DST_BIT format feature flags set");
4153         }
4154
4155         if (isYcbcrConversionSupported(context) && (format == VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR || format == VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR))
4156         {
4157                 VkFormatFeatureFlags requiredFeatures = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR | VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR;
4158                 if (tiling == VK_IMAGE_TILING_OPTIMAL)
4159                         requiredFeatures |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR;
4160
4161                 results.check((supportedFeatures & requiredFeatures) == requiredFeatures,
4162                                           getFormatName(format) + string(" must support ") + de::toString(getFormatFeatureFlagsStr(requiredFeatures)));
4163         }
4164
4165         for (VkImageUsageFlags curUsageFlags = 0; curUsageFlags <= usageFlagSet; curUsageFlags++)
4166         {
4167                 if ((curUsageFlags & ~usageFlagSet) != 0 ||
4168                         !isValidImageUsageFlagCombination(curUsageFlags))
4169                         continue;
4170
4171                 const VkImageCreateFlags        createFlagSet           = getValidImageCreateFlags(deviceFeatures, format, supportedFeatures, imageType, curUsageFlags);
4172
4173                 for (VkImageCreateFlags curCreateFlags = 0; curCreateFlags <= createFlagSet; curCreateFlags++)
4174                 {
4175                         if ((curCreateFlags & ~createFlagSet) != 0 ||
4176                                 !isValidImageCreateFlagCombination(curCreateFlags))
4177                                 continue;
4178
4179                         const bool                              isRequiredCombination   = isRequiredImageParameterCombination(deviceFeatures,
4180                                                                                                                                                                                                   format,
4181                                                                                                                                                                                                   formatProperties,
4182                                                                                                                                                                                                   imageType,
4183                                                                                                                                                                                                   tiling,
4184                                                                                                                                                                                                   curUsageFlags,
4185                                                                                                                                                                                                   curCreateFlags);
4186                         VkImageFormatProperties properties;
4187                         VkResult                                queryResult;
4188
4189                         log << TestLog::Message << "Testing " << getImageTypeStr(imageType) << ", "
4190                                                                         << getImageTilingStr(tiling) << ", "
4191                                                                         << getImageUsageFlagsStr(curUsageFlags) << ", "
4192                                                                         << getImageCreateFlagsStr(curCreateFlags)
4193                                 << TestLog::EndMessage;
4194
4195                         // Set return value to known garbage
4196                         deMemset(&properties, 0xcd, sizeof(properties));
4197
4198                         queryResult = context.getInstanceInterface().getPhysicalDeviceImageFormatProperties(context.getPhysicalDevice(),
4199                                                                                                                                                                                                 format,
4200                                                                                                                                                                                                 imageType,
4201                                                                                                                                                                                                 tiling,
4202                                                                                                                                                                                                 curUsageFlags,
4203                                                                                                                                                                                                 curCreateFlags,
4204                                                                                                                                                                                                 &properties);
4205
4206                         if (queryResult == VK_SUCCESS)
4207                         {
4208                                 const deUint32  fullMipPyramidSize      = de::max(de::max(deLog2Floor32(properties.maxExtent.width),
4209                                                                                                                                           deLog2Floor32(properties.maxExtent.height)),
4210                                                                                                                           deLog2Floor32(properties.maxExtent.depth)) + 1;
4211
4212                                 log << TestLog::Message << properties << "\n" << TestLog::EndMessage;
4213
4214                                 results.check(imageType != VK_IMAGE_TYPE_1D || (properties.maxExtent.width >= 1 && properties.maxExtent.height == 1 && properties.maxExtent.depth == 1), "Invalid dimensions for 1D image");
4215                                 results.check(imageType != VK_IMAGE_TYPE_2D || (properties.maxExtent.width >= 1 && properties.maxExtent.height >= 1 && properties.maxExtent.depth == 1), "Invalid dimensions for 2D image");
4216                                 results.check(imageType != VK_IMAGE_TYPE_3D || (properties.maxExtent.width >= 1 && properties.maxExtent.height >= 1 && properties.maxExtent.depth >= 1), "Invalid dimensions for 3D image");
4217                                 results.check(imageType != VK_IMAGE_TYPE_3D || properties.maxArrayLayers == 1, "Invalid maxArrayLayers for 3D image");
4218
4219                                 if (tiling == VK_IMAGE_TILING_OPTIMAL && imageType == VK_IMAGE_TYPE_2D && !(curCreateFlags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) &&
4220                                          (supportedFeatures & (VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)))
4221                                 {
4222                                         const VkSampleCountFlags        requiredSampleCounts    = getRequiredOptimalTilingSampleCounts(deviceLimits, format, curUsageFlags);
4223                                         results.check((properties.sampleCounts & requiredSampleCounts) == requiredSampleCounts, "Required sample counts not supported");
4224                                 }
4225                                 else
4226                                         results.check(properties.sampleCounts == VK_SAMPLE_COUNT_1_BIT, "sampleCounts != VK_SAMPLE_COUNT_1_BIT");
4227
4228                                 if (isRequiredCombination)
4229                                 {
4230                                         results.check(imageType != VK_IMAGE_TYPE_1D || (properties.maxExtent.width      >= deviceLimits.maxImageDimension1D),
4231                                                                   "Reported dimensions smaller than device limits");
4232                                         results.check(imageType != VK_IMAGE_TYPE_2D || (properties.maxExtent.width      >= deviceLimits.maxImageDimension2D &&
4233                                                                                                                                         properties.maxExtent.height     >= deviceLimits.maxImageDimension2D),
4234                                                                   "Reported dimensions smaller than device limits");
4235                                         results.check(imageType != VK_IMAGE_TYPE_3D || (properties.maxExtent.width      >= deviceLimits.maxImageDimension3D &&
4236                                                                                                                                         properties.maxExtent.height     >= deviceLimits.maxImageDimension3D &&
4237                                                                                                                                         properties.maxExtent.depth      >= deviceLimits.maxImageDimension3D),
4238                                                                   "Reported dimensions smaller than device limits");
4239                                         results.check((isYCbCrFormat(format) && (properties.maxMipLevels == 1)) || properties.maxMipLevels == fullMipPyramidSize,
4240                                                       "Invalid mip pyramid size");
4241                                         results.check((isYCbCrFormat(format) && (properties.maxArrayLayers == 1)) || imageType == VK_IMAGE_TYPE_3D ||
4242                                                       properties.maxArrayLayers >= deviceLimits.maxImageArrayLayers, "Invalid maxArrayLayers");
4243                                 }
4244                                 else
4245                                 {
4246                                         results.check(properties.maxMipLevels == 1 || properties.maxMipLevels == fullMipPyramidSize, "Invalid mip pyramid size");
4247                                         results.check(properties.maxArrayLayers >= 1, "Invalid maxArrayLayers");
4248                                 }
4249
4250                                 results.check(properties.maxResourceSize >= (VkDeviceSize)MINIMUM_REQUIRED_IMAGE_RESOURCE_SIZE,
4251                                                           "maxResourceSize smaller than minimum required size");
4252                         }
4253                         else if (queryResult == VK_ERROR_FORMAT_NOT_SUPPORTED)
4254                         {
4255                                 log << TestLog::Message << "Got VK_ERROR_FORMAT_NOT_SUPPORTED" << TestLog::EndMessage;
4256
4257                                 if (isRequiredCombination)
4258                                         results.fail("VK_ERROR_FORMAT_NOT_SUPPORTED returned for required image parameter combination");
4259
4260                                 // Specification requires that all fields are set to 0
4261                                 results.check(properties.maxExtent.width        == 0, "maxExtent.width != 0");
4262                                 results.check(properties.maxExtent.height       == 0, "maxExtent.height != 0");
4263                                 results.check(properties.maxExtent.depth        == 0, "maxExtent.depth != 0");
4264                                 results.check(properties.maxMipLevels           == 0, "maxMipLevels != 0");
4265                                 results.check(properties.maxArrayLayers         == 0, "maxArrayLayers != 0");
4266                                 results.check(properties.sampleCounts           == 0, "sampleCounts != 0");
4267                                 results.check(properties.maxResourceSize        == 0, "maxResourceSize != 0");
4268                         }
4269                         else
4270                         {
4271                                 results.fail("Got unexpected error" + de::toString(queryResult));
4272                         }
4273                 }
4274         }
4275
4276         return tcu::TestStatus(results.getResult(), results.getMessage());
4277 }
4278
4279 // VK_KHR_get_physical_device_properties2
4280
4281 string toString(const VkPhysicalDevicePCIBusInfoPropertiesEXT& value)
4282 {
4283         std::ostringstream  s;
4284         s << "VkPhysicalDevicePCIBusInfoPropertiesEXT = {\n";
4285         s << "\tsType = " << value.sType << '\n';
4286         s << "\tpciDomain = " << value.pciDomain << '\n';
4287         s << "\tpciBus = " << value.pciBus << '\n';
4288         s << "\tpciDevice = " << value.pciDevice << '\n';
4289         s << "\tpciFunction = " << value.pciFunction << '\n';
4290         s << '}';
4291         return s.str();
4292 }
4293
4294 bool checkExtension (vector<VkExtensionProperties>& properties, const char* extension)
4295 {
4296         for (size_t ndx = 0; ndx < properties.size(); ++ndx)
4297         {
4298                 if (strncmp(properties[ndx].extensionName, extension, VK_MAX_EXTENSION_NAME_SIZE) == 0)
4299                         return true;
4300         }
4301         return false;
4302 }
4303
4304 #include "vkDeviceFeatures2.inl"
4305
4306 tcu::TestStatus deviceFeatures2 (Context& context)
4307 {
4308         const VkPhysicalDevice      physicalDevice = context.getPhysicalDevice();
4309         const CustomInstance            instance                (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
4310         const InstanceDriver&           vki                             (instance.getDriver());
4311         TestLog&                                        log                             = context.getTestContext().getLog();
4312         VkPhysicalDeviceFeatures        coreFeatures;
4313         VkPhysicalDeviceFeatures2       extFeatures;
4314
4315         deMemset(&coreFeatures, 0xcd, sizeof(coreFeatures));
4316         deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features));
4317         std::vector<std::string> instExtensions = context.getInstanceExtensions();
4318
4319         extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
4320         extFeatures.pNext = DE_NULL;
4321
4322         vki.getPhysicalDeviceFeatures(physicalDevice, &coreFeatures);
4323         vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures);
4324
4325         TCU_CHECK(extFeatures.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
4326         TCU_CHECK(extFeatures.pNext == DE_NULL);
4327
4328         if (deMemCmp(&coreFeatures, &extFeatures.features, sizeof(VkPhysicalDeviceFeatures)) != 0)
4329                 TCU_FAIL("Mismatch between features reported by vkGetPhysicalDeviceFeatures and vkGetPhysicalDeviceFeatures2");
4330
4331         log << TestLog::Message << extFeatures << TestLog::EndMessage;
4332
4333         return tcu::TestStatus::pass("Querying device features succeeded");
4334 }
4335
4336 tcu::TestStatus deviceProperties2 (Context& context)
4337 {
4338         const CustomInstance                    instance                (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
4339         const InstanceDriver&                   vki                             (instance.getDriver());
4340         const VkPhysicalDevice                  physicalDevice  (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
4341         TestLog&                                                log                             = context.getTestContext().getLog();
4342         VkPhysicalDeviceProperties              coreProperties;
4343         VkPhysicalDeviceProperties2             extProperties;
4344
4345         extProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
4346         extProperties.pNext = DE_NULL;
4347
4348         vki.getPhysicalDeviceProperties(physicalDevice, &coreProperties);
4349         vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
4350
4351         TCU_CHECK(extProperties.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2);
4352         TCU_CHECK(extProperties.pNext == DE_NULL);
4353
4354         // We can't use memcmp() here because the structs may contain padding bytes that drivers may or may not
4355         // have written while writing the data and memcmp will compare them anyway, so we iterate through the
4356         // valid bytes for each field in the struct and compare only the valid bytes for each one.
4357         for (int propNdx = 0; propNdx < DE_LENGTH_OF_ARRAY(s_physicalDevicePropertiesOffsetTable); propNdx++)
4358         {
4359                 const size_t offset                                     = s_physicalDevicePropertiesOffsetTable[propNdx].offset;
4360                 const size_t size                                       = s_physicalDevicePropertiesOffsetTable[propNdx].size;
4361
4362                 const deUint8* corePropertyBytes        = reinterpret_cast<deUint8*>(&coreProperties) + offset;
4363                 const deUint8* extPropertyBytes         = reinterpret_cast<deUint8*>(&extProperties.properties) + offset;
4364
4365                 if (deMemCmp(corePropertyBytes, extPropertyBytes, size) != 0)
4366                         TCU_FAIL("Mismatch between properties reported by vkGetPhysicalDeviceProperties and vkGetPhysicalDeviceProperties2");
4367         }
4368
4369         log << TestLog::Message << extProperties.properties << TestLog::EndMessage;
4370
4371         const int count = 2u;
4372
4373         vector<VkExtensionProperties> properties                = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL);
4374         const bool khr_external_fence_capabilities              = checkExtension(properties, "VK_KHR_external_fence_capabilities")              ||      context.contextSupports(vk::ApiVersion(1, 1, 0));
4375         const bool khr_external_memory_capabilities             = checkExtension(properties, "VK_KHR_external_memory_capabilities")             ||      context.contextSupports(vk::ApiVersion(1, 1, 0));
4376         const bool khr_external_semaphore_capabilities  = checkExtension(properties, "VK_KHR_external_semaphore_capabilities")  ||      context.contextSupports(vk::ApiVersion(1, 1, 0));
4377         const bool khr_multiview                                                = checkExtension(properties, "VK_KHR_multiview")                                                ||      context.contextSupports(vk::ApiVersion(1, 1, 0));
4378         const bool khr_device_protected_memory                  =                                                                                                                                                       context.contextSupports(vk::ApiVersion(1, 1, 0));
4379         const bool khr_device_subgroup                                  =                                                                                                                                                       context.contextSupports(vk::ApiVersion(1, 1, 0));
4380         const bool khr_maintenance2                                             = checkExtension(properties, "VK_KHR_maintenance2")                                             ||      context.contextSupports(vk::ApiVersion(1, 1, 0));
4381         const bool khr_maintenance3                                             = checkExtension(properties, "VK_KHR_maintenance3")                                             ||      context.contextSupports(vk::ApiVersion(1, 1, 0));
4382         const bool khr_depth_stencil_resolve                    = checkExtension(properties, "VK_KHR_depth_stencil_resolve")                    ||      context.contextSupports(vk::ApiVersion(1, 2, 0));
4383         const bool khr_driver_properties                                = checkExtension(properties, "VK_KHR_driver_properties")                                ||      context.contextSupports(vk::ApiVersion(1, 2, 0));
4384         const bool khr_shader_float_controls                    = checkExtension(properties, "VK_KHR_shader_float_controls")                    ||      context.contextSupports(vk::ApiVersion(1, 2, 0));
4385         const bool khr_descriptor_indexing                              = checkExtension(properties, "VK_EXT_descriptor_indexing")                              ||      context.contextSupports(vk::ApiVersion(1, 2, 0));
4386         const bool khr_sampler_filter_minmax                    = checkExtension(properties, "VK_EXT_sampler_filter_minmax")                    ||      context.contextSupports(vk::ApiVersion(1, 2, 0));
4387         const bool khr_integer_dot_product                              = checkExtension(properties, "VK_KHR_shader_integer_dot_product")               ||      context.contextSupports(vk::ApiVersion(1, 3, 0));
4388         const bool khr_inline_uniform_block                             = checkExtension(properties, "VK_EXT_inline_uniform_block")                             ||      context.contextSupports(vk::ApiVersion(1, 3, 0));
4389         const bool khr_maintenance4                                             = checkExtension(properties, "VK_KHR_maintenance4")                                             ||      context.contextSupports(vk::ApiVersion(1, 3, 0));
4390         const bool khr_subgroup_size_control                    = checkExtension(properties, "VK_EXT_subgroup_size_control")                    ||      context.contextSupports(vk::ApiVersion(1, 3, 0));
4391         const bool khr_texel_buffer_alignment                   = checkExtension(properties, "VK_EXT_texel_buffer_alignment")                   ||      context.contextSupports(vk::ApiVersion(1, 3, 0));
4392
4393         VkPhysicalDeviceIDProperties                                                    idProperties[count];
4394         VkPhysicalDeviceMultiviewProperties                                             multiviewProperties[count];
4395         VkPhysicalDeviceProtectedMemoryProperties                               protectedMemoryPropertiesKHR[count];
4396         VkPhysicalDeviceSubgroupProperties                                              subgroupProperties[count];
4397         VkPhysicalDevicePointClippingProperties                                 pointClippingProperties[count];
4398         VkPhysicalDeviceMaintenance3Properties                                  maintenance3Properties[count];
4399         VkPhysicalDeviceDepthStencilResolveProperties                   depthStencilResolveProperties[count];
4400         VkPhysicalDeviceDriverProperties                                                driverProperties[count];
4401         VkPhysicalDeviceFloatControlsProperties                                 floatControlsProperties[count];
4402         VkPhysicalDeviceDescriptorIndexingProperties                    descriptorIndexingProperties[count];
4403         VkPhysicalDeviceSamplerFilterMinmaxProperties                   samplerFilterMinmaxProperties[count];
4404         VkPhysicalDeviceShaderIntegerDotProductProperties               integerDotProductProperties[count];
4405         VkPhysicalDeviceInlineUniformBlockProperties                    inlineUniformBlockProperties[count];
4406         VkPhysicalDeviceMaintenance4Properties                                  maintenance4Properties[count];
4407         VkPhysicalDeviceSubgroupSizeControlProperties                   subgroupSizeControlProperties[count];
4408         VkPhysicalDeviceTexelBufferAlignmentProperties                  texelBufferAlignmentProperties[count];
4409
4410         for (int ndx = 0; ndx < count; ++ndx)
4411         {
4412                 deMemset(&idProperties[ndx],                                    0xFF*ndx, sizeof(VkPhysicalDeviceIDProperties                                                   ));
4413                 deMemset(&multiviewProperties[ndx],                             0xFF*ndx, sizeof(VkPhysicalDeviceMultiviewProperties                                    ));
4414                 deMemset(&protectedMemoryPropertiesKHR[ndx],    0xFF*ndx, sizeof(VkPhysicalDeviceProtectedMemoryProperties                              ));
4415                 deMemset(&subgroupProperties[ndx],                              0xFF*ndx, sizeof(VkPhysicalDeviceSubgroupProperties                                             ));
4416                 deMemset(&pointClippingProperties[ndx],                 0xFF*ndx, sizeof(VkPhysicalDevicePointClippingProperties                                ));
4417                 deMemset(&maintenance3Properties[ndx],                  0xFF*ndx, sizeof(VkPhysicalDeviceMaintenance3Properties                                 ));
4418                 deMemset(&depthStencilResolveProperties[ndx],   0xFF*ndx, sizeof(VkPhysicalDeviceDepthStencilResolveProperties                  ));
4419                 deMemset(&driverProperties[ndx],                                0xFF*ndx, sizeof(VkPhysicalDeviceDriverProperties                                               ));
4420                 deMemset(&floatControlsProperties[ndx],                 0xFF*ndx, sizeof(VkPhysicalDeviceFloatControlsProperties                                ));
4421                 deMemset(&descriptorIndexingProperties[ndx],    0xFF*ndx, sizeof(VkPhysicalDeviceDescriptorIndexingProperties                   ));
4422                 deMemset(&samplerFilterMinmaxProperties[ndx],   0xFF*ndx, sizeof(VkPhysicalDeviceSamplerFilterMinmaxProperties                  ));
4423                 deMemset(&integerDotProductProperties[ndx],             0xFF*ndx, sizeof(VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR   ));
4424                 deMemset(&inlineUniformBlockProperties[ndx],    0xFF*ndx, sizeof(VkPhysicalDeviceInlineUniformBlockProperties                   ));
4425                 deMemset(&maintenance4Properties[ndx],                  0xFF*ndx, sizeof(VkPhysicalDeviceMaintenance4Properties                                 ));
4426                 deMemset(&subgroupSizeControlProperties[ndx],   0xFF*ndx, sizeof(VkPhysicalDeviceSubgroupSizeControlProperties                  ));
4427                 deMemset(&texelBufferAlignmentProperties[ndx],  0xFF*ndx, sizeof(VkPhysicalDeviceTexelBufferAlignmentProperties                 ));
4428
4429                 idProperties[ndx].sType                                         = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
4430                 idProperties[ndx].pNext                                         = &multiviewProperties[ndx];
4431
4432                 multiviewProperties[ndx].sType                          = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
4433                 multiviewProperties[ndx].pNext                          = &protectedMemoryPropertiesKHR[ndx];
4434
4435                 protectedMemoryPropertiesKHR[ndx].sType         = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
4436                 protectedMemoryPropertiesKHR[ndx].pNext         = &subgroupProperties[ndx];
4437
4438                 subgroupProperties[ndx].sType                           = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
4439                 subgroupProperties[ndx].pNext                           = &pointClippingProperties[ndx];
4440
4441                 pointClippingProperties[ndx].sType                      = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
4442                 pointClippingProperties[ndx].pNext                      = &maintenance3Properties[ndx];
4443
4444                 maintenance3Properties[ndx].sType                       = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
4445                 maintenance3Properties[ndx].pNext                       = &depthStencilResolveProperties[ndx];
4446
4447                 depthStencilResolveProperties[ndx].sType        = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
4448                 depthStencilResolveProperties[ndx].pNext        = &driverProperties[ndx];
4449
4450                 driverProperties[ndx].sType                                     = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
4451                 driverProperties[ndx].pNext                                     = &floatControlsProperties[ndx];
4452
4453                 floatControlsProperties[ndx].sType                      = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR;
4454                 floatControlsProperties[ndx].pNext                      = &descriptorIndexingProperties[ndx];
4455
4456                 descriptorIndexingProperties[ndx].sType         = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
4457                 descriptorIndexingProperties[ndx].pNext         = &samplerFilterMinmaxProperties[ndx];
4458
4459                 samplerFilterMinmaxProperties[ndx].sType        = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
4460                 samplerFilterMinmaxProperties[ndx].pNext        = &integerDotProductProperties[ndx];
4461
4462                 integerDotProductProperties[ndx].sType          = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR;
4463                 integerDotProductProperties[ndx].pNext          = &inlineUniformBlockProperties[ndx];
4464
4465                 inlineUniformBlockProperties[ndx].sType         = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
4466                 inlineUniformBlockProperties[ndx].pNext         = &maintenance4Properties[ndx];
4467
4468                 maintenance4Properties[ndx].sType                       = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
4469                 maintenance4Properties[ndx].pNext                       = &subgroupSizeControlProperties[ndx];
4470
4471                 subgroupSizeControlProperties[ndx].sType        = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
4472                 subgroupSizeControlProperties[ndx].pNext        = &texelBufferAlignmentProperties[ndx];
4473
4474                 texelBufferAlignmentProperties[ndx].sType       = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
4475                 texelBufferAlignmentProperties[ndx].pNext       = DE_NULL;
4476
4477                 extProperties.pNext                                                     = &idProperties[ndx];
4478
4479                 vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
4480         }
4481
4482         if ( khr_external_fence_capabilities || khr_external_memory_capabilities || khr_external_semaphore_capabilities )
4483                 log << TestLog::Message << idProperties[0]                                      << TestLog::EndMessage;
4484         if (khr_multiview)
4485                 log << TestLog::Message << multiviewProperties[0]                       << TestLog::EndMessage;
4486         if (khr_device_protected_memory)
4487                 log << TestLog::Message << protectedMemoryPropertiesKHR[0]      << TestLog::EndMessage;
4488         if (khr_device_subgroup)
4489                 log << TestLog::Message << subgroupProperties[0]                        << TestLog::EndMessage;
4490         if (khr_maintenance2)
4491                 log << TestLog::Message << pointClippingProperties[0]           << TestLog::EndMessage;
4492         if (khr_maintenance3)
4493                 log << TestLog::Message << maintenance3Properties[0]            << TestLog::EndMessage;
4494         if (khr_depth_stencil_resolve)
4495                 log << TestLog::Message << depthStencilResolveProperties[0] << TestLog::EndMessage;
4496         if (khr_driver_properties)
4497                 log << TestLog::Message << driverProperties[0]                          << TestLog::EndMessage;
4498         if (khr_shader_float_controls)
4499                 log << TestLog::Message << floatControlsProperties[0]           << TestLog::EndMessage;
4500         if (khr_descriptor_indexing)
4501                 log << TestLog::Message << descriptorIndexingProperties[0] << TestLog::EndMessage;
4502         if (khr_sampler_filter_minmax)
4503                 log << TestLog::Message << samplerFilterMinmaxProperties[0] << TestLog::EndMessage;
4504         if (khr_integer_dot_product)
4505                 log << TestLog::Message << integerDotProductProperties[0] << TestLog::EndMessage;
4506         if (khr_inline_uniform_block)
4507                 log << TestLog::Message << inlineUniformBlockProperties[0] << TestLog::EndMessage;
4508         if (khr_maintenance4)
4509                 log << TestLog::Message << maintenance4Properties[0] << TestLog::EndMessage;
4510         if (khr_subgroup_size_control)
4511                 log << TestLog::Message << subgroupSizeControlProperties[0] << TestLog::EndMessage;
4512         if (khr_texel_buffer_alignment)
4513                 log << TestLog::Message << texelBufferAlignmentProperties[0] << TestLog::EndMessage;
4514
4515         if (khr_integer_dot_product)
4516                 log << TestLog::Message << integerDotProductProperties[0] << TestLog::EndMessage;
4517
4518         if ( khr_external_fence_capabilities || khr_external_memory_capabilities || khr_external_semaphore_capabilities )
4519         {
4520                 if ((deMemCmp(idProperties[0].deviceUUID, idProperties[1].deviceUUID, VK_UUID_SIZE) != 0) ||
4521                         (deMemCmp(idProperties[0].driverUUID, idProperties[1].driverUUID, VK_UUID_SIZE) != 0) ||
4522                         (idProperties[0].deviceLUIDValid        != idProperties[1].deviceLUIDValid))
4523                 {
4524                         TCU_FAIL("Mismatch between VkPhysicalDeviceIDProperties");
4525                 }
4526                 else if (idProperties[0].deviceLUIDValid)
4527                 {
4528                         // If deviceLUIDValid is VK_FALSE, the contents of deviceLUID and deviceNodeMask are undefined
4529                         // so thay can only be compared when deviceLUIDValid is VK_TRUE.
4530                         if ((deMemCmp(idProperties[0].deviceLUID, idProperties[1].deviceLUID, VK_LUID_SIZE) != 0) ||
4531                                 (idProperties[0].deviceNodeMask         != idProperties[1].deviceNodeMask))
4532                         {
4533                                 TCU_FAIL("Mismatch between VkPhysicalDeviceIDProperties");
4534                         }
4535                 }
4536         }
4537         if (khr_multiview &&
4538                 (multiviewProperties[0].maxMultiviewViewCount           != multiviewProperties[1].maxMultiviewViewCount ||
4539                  multiviewProperties[0].maxMultiviewInstanceIndex       != multiviewProperties[1].maxMultiviewInstanceIndex))
4540         {
4541                 TCU_FAIL("Mismatch between VkPhysicalDeviceMultiviewProperties");
4542         }
4543         if (khr_device_protected_memory &&
4544                 (protectedMemoryPropertiesKHR[0].protectedNoFault       != protectedMemoryPropertiesKHR[1].protectedNoFault))
4545         {
4546                 TCU_FAIL("Mismatch between VkPhysicalDeviceProtectedMemoryProperties");
4547         }
4548         if (khr_device_subgroup &&
4549                 (subgroupProperties[0].subgroupSize                                     != subgroupProperties[1].subgroupSize ||
4550                  subgroupProperties[0].supportedStages                          != subgroupProperties[1].supportedStages ||
4551                  subgroupProperties[0].supportedOperations                      != subgroupProperties[1].supportedOperations ||
4552                  subgroupProperties[0].quadOperationsInAllStages        != subgroupProperties[1].quadOperationsInAllStages ))
4553         {
4554                 TCU_FAIL("Mismatch between VkPhysicalDeviceSubgroupProperties");
4555         }
4556         if (khr_maintenance2 &&
4557                 (pointClippingProperties[0].pointClippingBehavior       != pointClippingProperties[1].pointClippingBehavior))
4558         {
4559                 TCU_FAIL("Mismatch between VkPhysicalDevicePointClippingProperties");
4560         }
4561         if (khr_maintenance3 &&
4562                 (maintenance3Properties[0].maxPerSetDescriptors         != maintenance3Properties[1].maxPerSetDescriptors ||
4563                  maintenance3Properties[0].maxMemoryAllocationSize      != maintenance3Properties[1].maxMemoryAllocationSize))
4564         {
4565                 if (protectedMemoryPropertiesKHR[0].protectedNoFault != protectedMemoryPropertiesKHR[1].protectedNoFault)
4566                 {
4567                         TCU_FAIL("Mismatch between VkPhysicalDeviceProtectedMemoryProperties");
4568                 }
4569                 if ((subgroupProperties[0].subgroupSize                                 != subgroupProperties[1].subgroupSize) ||
4570                         (subgroupProperties[0].supportedStages                          != subgroupProperties[1].supportedStages) ||
4571                         (subgroupProperties[0].supportedOperations                      != subgroupProperties[1].supportedOperations) ||
4572                         (subgroupProperties[0].quadOperationsInAllStages        != subgroupProperties[1].quadOperationsInAllStages))
4573                 {
4574                         TCU_FAIL("Mismatch between VkPhysicalDeviceSubgroupProperties");
4575                 }
4576                 TCU_FAIL("Mismatch between VkPhysicalDeviceMaintenance3Properties");
4577         }
4578         if (khr_depth_stencil_resolve &&
4579                 (depthStencilResolveProperties[0].supportedDepthResolveModes    != depthStencilResolveProperties[1].supportedDepthResolveModes ||
4580                  depthStencilResolveProperties[0].supportedStencilResolveModes  != depthStencilResolveProperties[1].supportedStencilResolveModes ||
4581                  depthStencilResolveProperties[0].independentResolveNone                != depthStencilResolveProperties[1].independentResolveNone ||
4582                  depthStencilResolveProperties[0].independentResolve                    != depthStencilResolveProperties[1].independentResolve))
4583         {
4584                 TCU_FAIL("Mismatch between VkPhysicalDeviceDepthStencilResolveProperties");
4585         }
4586         if (khr_driver_properties &&
4587                 (driverProperties[0].driverID                                                                                           != driverProperties[1].driverID ||
4588                  strncmp(driverProperties[0].driverName, driverProperties[1].driverName, VK_MAX_DRIVER_NAME_SIZE)       != 0 ||
4589                  strncmp(driverProperties[0].driverInfo, driverProperties[1].driverInfo, VK_MAX_DRIVER_INFO_SIZE)               != 0 ||
4590                  driverProperties[0].conformanceVersion.major                                                           != driverProperties[1].conformanceVersion.major ||
4591                  driverProperties[0].conformanceVersion.minor                                                           != driverProperties[1].conformanceVersion.minor ||
4592                  driverProperties[0].conformanceVersion.subminor                                                        != driverProperties[1].conformanceVersion.subminor ||
4593                  driverProperties[0].conformanceVersion.patch                                                           != driverProperties[1].conformanceVersion.patch))
4594         {
4595                 TCU_FAIL("Mismatch between VkPhysicalDeviceDriverProperties");
4596         }
4597         if (khr_shader_float_controls &&
4598                 (floatControlsProperties[0].denormBehaviorIndependence                          != floatControlsProperties[1].denormBehaviorIndependence ||
4599                  floatControlsProperties[0].roundingModeIndependence                            != floatControlsProperties[1].roundingModeIndependence ||
4600                  floatControlsProperties[0].shaderSignedZeroInfNanPreserveFloat16       != floatControlsProperties[1].shaderSignedZeroInfNanPreserveFloat16 ||
4601                  floatControlsProperties[0].shaderSignedZeroInfNanPreserveFloat32       != floatControlsProperties[1].shaderSignedZeroInfNanPreserveFloat32 ||
4602                  floatControlsProperties[0].shaderSignedZeroInfNanPreserveFloat64       != floatControlsProperties[1].shaderSignedZeroInfNanPreserveFloat64 ||
4603                  floatControlsProperties[0].shaderDenormPreserveFloat16                         != floatControlsProperties[1].shaderDenormPreserveFloat16 ||
4604                  floatControlsProperties[0].shaderDenormPreserveFloat32                         != floatControlsProperties[1].shaderDenormPreserveFloat32 ||
4605                  floatControlsProperties[0].shaderDenormPreserveFloat64                         != floatControlsProperties[1].shaderDenormPreserveFloat64 ||
4606                  floatControlsProperties[0].shaderDenormFlushToZeroFloat16                      != floatControlsProperties[1].shaderDenormFlushToZeroFloat16 ||
4607                  floatControlsProperties[0].shaderDenormFlushToZeroFloat32                      != floatControlsProperties[1].shaderDenormFlushToZeroFloat32 ||
4608                  floatControlsProperties[0].shaderDenormFlushToZeroFloat64                      != floatControlsProperties[1].shaderDenormFlushToZeroFloat64 ||
4609                  floatControlsProperties[0].shaderRoundingModeRTEFloat16                        != floatControlsProperties[1].shaderRoundingModeRTEFloat16 ||
4610                  floatControlsProperties[0].shaderRoundingModeRTEFloat32                        != floatControlsProperties[1].shaderRoundingModeRTEFloat32 ||
4611                  floatControlsProperties[0].shaderRoundingModeRTEFloat64                        != floatControlsProperties[1].shaderRoundingModeRTEFloat64 ||
4612                  floatControlsProperties[0].shaderRoundingModeRTZFloat16                        != floatControlsProperties[1].shaderRoundingModeRTZFloat16 ||
4613                  floatControlsProperties[0].shaderRoundingModeRTZFloat32                        != floatControlsProperties[1].shaderRoundingModeRTZFloat32 ||
4614                  floatControlsProperties[0].shaderRoundingModeRTZFloat64                        != floatControlsProperties[1].shaderRoundingModeRTZFloat64 ))
4615         {
4616                 TCU_FAIL("Mismatch between VkPhysicalDeviceFloatControlsProperties");
4617         }
4618         if (khr_descriptor_indexing &&
4619                 (descriptorIndexingProperties[0].maxUpdateAfterBindDescriptorsInAllPools                                != descriptorIndexingProperties[1].maxUpdateAfterBindDescriptorsInAllPools ||
4620                  descriptorIndexingProperties[0].shaderUniformBufferArrayNonUniformIndexingNative               != descriptorIndexingProperties[1].shaderUniformBufferArrayNonUniformIndexingNative ||
4621                  descriptorIndexingProperties[0].shaderSampledImageArrayNonUniformIndexingNative                != descriptorIndexingProperties[1].shaderSampledImageArrayNonUniformIndexingNative ||
4622                  descriptorIndexingProperties[0].shaderStorageBufferArrayNonUniformIndexingNative               != descriptorIndexingProperties[1].shaderStorageBufferArrayNonUniformIndexingNative ||
4623                  descriptorIndexingProperties[0].shaderStorageImageArrayNonUniformIndexingNative                != descriptorIndexingProperties[1].shaderStorageImageArrayNonUniformIndexingNative ||
4624                  descriptorIndexingProperties[0].shaderInputAttachmentArrayNonUniformIndexingNative             != descriptorIndexingProperties[1].shaderInputAttachmentArrayNonUniformIndexingNative ||
4625                  descriptorIndexingProperties[0].robustBufferAccessUpdateAfterBind                                              != descriptorIndexingProperties[1].robustBufferAccessUpdateAfterBind ||
4626                  descriptorIndexingProperties[0].quadDivergentImplicitLod                                                               != descriptorIndexingProperties[1].quadDivergentImplicitLod ||
4627                  descriptorIndexingProperties[0].maxPerStageDescriptorUpdateAfterBindSamplers                   != descriptorIndexingProperties[1].maxPerStageDescriptorUpdateAfterBindSamplers ||
4628                  descriptorIndexingProperties[0].maxPerStageDescriptorUpdateAfterBindUniformBuffers             != descriptorIndexingProperties[1].maxPerStageDescriptorUpdateAfterBindUniformBuffers ||
4629                  descriptorIndexingProperties[0].maxPerStageDescriptorUpdateAfterBindStorageBuffers             != descriptorIndexingProperties[1].maxPerStageDescriptorUpdateAfterBindStorageBuffers ||
4630                  descriptorIndexingProperties[0].maxPerStageDescriptorUpdateAfterBindSampledImages              != descriptorIndexingProperties[1].maxPerStageDescriptorUpdateAfterBindSampledImages ||
4631                  descriptorIndexingProperties[0].maxPerStageDescriptorUpdateAfterBindStorageImages              != descriptorIndexingProperties[1].maxPerStageDescriptorUpdateAfterBindStorageImages ||
4632                  descriptorIndexingProperties[0].maxPerStageDescriptorUpdateAfterBindInputAttachments   != descriptorIndexingProperties[1].maxPerStageDescriptorUpdateAfterBindInputAttachments ||
4633                  descriptorIndexingProperties[0].maxPerStageUpdateAfterBindResources                                    != descriptorIndexingProperties[1].maxPerStageUpdateAfterBindResources ||
4634                  descriptorIndexingProperties[0].maxDescriptorSetUpdateAfterBindSamplers                                != descriptorIndexingProperties[1].maxDescriptorSetUpdateAfterBindSamplers ||
4635                  descriptorIndexingProperties[0].maxDescriptorSetUpdateAfterBindUniformBuffers                  != descriptorIndexingProperties[1].maxDescriptorSetUpdateAfterBindUniformBuffers ||
4636                  descriptorIndexingProperties[0].maxDescriptorSetUpdateAfterBindUniformBuffersDynamic   != descriptorIndexingProperties[1].maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ||
4637                  descriptorIndexingProperties[0].maxDescriptorSetUpdateAfterBindStorageBuffers                  != descriptorIndexingProperties[1].maxDescriptorSetUpdateAfterBindStorageBuffers ||
4638                  descriptorIndexingProperties[0].maxDescriptorSetUpdateAfterBindStorageBuffersDynamic   != descriptorIndexingProperties[1].maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ||
4639                  descriptorIndexingProperties[0].maxDescriptorSetUpdateAfterBindSampledImages                   != descriptorIndexingProperties[1].maxDescriptorSetUpdateAfterBindSampledImages ||
4640                  descriptorIndexingProperties[0].maxDescriptorSetUpdateAfterBindStorageImages                   != descriptorIndexingProperties[1].maxDescriptorSetUpdateAfterBindStorageImages ||
4641                  descriptorIndexingProperties[0].maxDescriptorSetUpdateAfterBindInputAttachments                != descriptorIndexingProperties[1].maxDescriptorSetUpdateAfterBindInputAttachments ))
4642         {
4643                 TCU_FAIL("Mismatch between VkPhysicalDeviceDescriptorIndexingProperties");
4644         }
4645         if (khr_sampler_filter_minmax &&
4646                 (samplerFilterMinmaxProperties[0].filterMinmaxSingleComponentFormats    != samplerFilterMinmaxProperties[1].filterMinmaxSingleComponentFormats ||
4647                  samplerFilterMinmaxProperties[0].filterMinmaxImageComponentMapping             != samplerFilterMinmaxProperties[1].filterMinmaxImageComponentMapping))
4648         {
4649                 TCU_FAIL("Mismatch between VkPhysicalDeviceSamplerFilterMinmaxProperties");
4650         }
4651         if (khr_integer_dot_product &&
4652                 (integerDotProductProperties[0].integerDotProduct8BitUnsignedAccelerated                                                                                != integerDotProductProperties[1].integerDotProduct8BitUnsignedAccelerated ||
4653                  integerDotProductProperties[0].integerDotProduct8BitSignedAccelerated                                                                                  != integerDotProductProperties[1].integerDotProduct8BitSignedAccelerated ||
4654                  integerDotProductProperties[0].integerDotProduct8BitMixedSignednessAccelerated                                                                 != integerDotProductProperties[1].integerDotProduct8BitMixedSignednessAccelerated ||
4655                  integerDotProductProperties[0].integerDotProduct4x8BitPackedUnsignedAccelerated                                                                != integerDotProductProperties[1].integerDotProduct4x8BitPackedUnsignedAccelerated ||
4656                  integerDotProductProperties[0].integerDotProduct4x8BitPackedSignedAccelerated                                                                  != integerDotProductProperties[1].integerDotProduct4x8BitPackedSignedAccelerated ||
4657                  integerDotProductProperties[0].integerDotProduct4x8BitPackedMixedSignednessAccelerated                                                 != integerDotProductProperties[1].integerDotProduct4x8BitPackedMixedSignednessAccelerated ||
4658                  integerDotProductProperties[0].integerDotProduct16BitUnsignedAccelerated                                                                               != integerDotProductProperties[1].integerDotProduct16BitUnsignedAccelerated ||
4659                  integerDotProductProperties[0].integerDotProduct16BitSignedAccelerated                                                                                 != integerDotProductProperties[1].integerDotProduct16BitSignedAccelerated ||
4660                  integerDotProductProperties[0].integerDotProduct16BitMixedSignednessAccelerated                                                                != integerDotProductProperties[1].integerDotProduct16BitMixedSignednessAccelerated ||
4661                  integerDotProductProperties[0].integerDotProduct32BitUnsignedAccelerated                                                                               != integerDotProductProperties[1].integerDotProduct32BitUnsignedAccelerated ||
4662                  integerDotProductProperties[0].integerDotProduct32BitSignedAccelerated                                                                                 != integerDotProductProperties[1].integerDotProduct32BitSignedAccelerated ||
4663                  integerDotProductProperties[0].integerDotProduct32BitMixedSignednessAccelerated                                                                != integerDotProductProperties[1].integerDotProduct32BitMixedSignednessAccelerated ||
4664                  integerDotProductProperties[0].integerDotProduct64BitUnsignedAccelerated                                                                               != integerDotProductProperties[1].integerDotProduct64BitUnsignedAccelerated ||
4665                  integerDotProductProperties[0].integerDotProduct64BitSignedAccelerated                                                                                 != integerDotProductProperties[1].integerDotProduct64BitSignedAccelerated ||
4666                  integerDotProductProperties[0].integerDotProduct64BitMixedSignednessAccelerated                                                                != integerDotProductProperties[1].integerDotProduct64BitMixedSignednessAccelerated ||
4667                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating8BitUnsignedAccelerated                                  != integerDotProductProperties[1].integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ||
4668                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating8BitSignedAccelerated                                    != integerDotProductProperties[1].integerDotProductAccumulatingSaturating8BitSignedAccelerated ||
4669                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated                   != integerDotProductProperties[1].integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ||
4670                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated                  != integerDotProductProperties[1].integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ||
4671                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated                    != integerDotProductProperties[1].integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ||
4672                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated   != integerDotProductProperties[1].integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ||
4673                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating16BitUnsignedAccelerated                                 != integerDotProductProperties[1].integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ||
4674                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating16BitSignedAccelerated                                   != integerDotProductProperties[1].integerDotProductAccumulatingSaturating16BitSignedAccelerated ||
4675                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated                  != integerDotProductProperties[1].integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ||
4676                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating32BitUnsignedAccelerated                                 != integerDotProductProperties[1].integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ||
4677                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating32BitSignedAccelerated                                   != integerDotProductProperties[1].integerDotProductAccumulatingSaturating32BitSignedAccelerated ||
4678                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated                  != integerDotProductProperties[1].integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ||
4679                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating64BitUnsignedAccelerated                                 != integerDotProductProperties[1].integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ||
4680                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating64BitSignedAccelerated                                   != integerDotProductProperties[1].integerDotProductAccumulatingSaturating64BitSignedAccelerated ||
4681                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated                  != integerDotProductProperties[1].integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated))
4682         {
4683                 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR");
4684         }
4685         if (khr_inline_uniform_block &&
4686                 (inlineUniformBlockProperties[0].maxInlineUniformBlockSize                                                                      != inlineUniformBlockProperties[1].maxInlineUniformBlockSize ||
4687                  inlineUniformBlockProperties[0].maxPerStageDescriptorInlineUniformBlocks                                       != inlineUniformBlockProperties[1].maxPerStageDescriptorInlineUniformBlocks ||
4688                  inlineUniformBlockProperties[0].maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks        != inlineUniformBlockProperties[1].maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ||
4689                  inlineUniformBlockProperties[0].maxDescriptorSetInlineUniformBlocks                                            != inlineUniformBlockProperties[1].maxDescriptorSetInlineUniformBlocks ||
4690                  inlineUniformBlockProperties[0].maxDescriptorSetUpdateAfterBindInlineUniformBlocks                     != inlineUniformBlockProperties[1].maxDescriptorSetUpdateAfterBindInlineUniformBlocks))
4691         {
4692                 TCU_FAIL("Mismatch between VkPhysicalDeviceInlineUniformBlockProperties");
4693         }
4694         if (khr_maintenance4 &&
4695                 (maintenance4Properties[0].maxBufferSize        != maintenance4Properties[1].maxBufferSize))
4696         {
4697                 TCU_FAIL("Mismatch between VkPhysicalDeviceMaintenance4Properties");
4698         }
4699         if (khr_subgroup_size_control &&
4700                 (subgroupSizeControlProperties[0].minSubgroupSize                               != subgroupSizeControlProperties[1].minSubgroupSize ||
4701                  subgroupSizeControlProperties[0].maxSubgroupSize                               != subgroupSizeControlProperties[1].maxSubgroupSize ||
4702                  subgroupSizeControlProperties[0].maxComputeWorkgroupSubgroups  != subgroupSizeControlProperties[1].maxComputeWorkgroupSubgroups ||
4703                  subgroupSizeControlProperties[0].requiredSubgroupSizeStages            != subgroupSizeControlProperties[1].requiredSubgroupSizeStages))
4704         {
4705                 TCU_FAIL("Mismatch between VkPhysicalDeviceSubgroupSizeControlProperties");
4706         }
4707         if (khr_texel_buffer_alignment &&
4708                 (texelBufferAlignmentProperties[0].storageTexelBufferOffsetAlignmentBytes               != texelBufferAlignmentProperties[1].storageTexelBufferOffsetAlignmentBytes ||
4709                  texelBufferAlignmentProperties[0].storageTexelBufferOffsetSingleTexelAlignment != texelBufferAlignmentProperties[1].storageTexelBufferOffsetSingleTexelAlignment ||
4710                  texelBufferAlignmentProperties[0].uniformTexelBufferOffsetAlignmentBytes               != texelBufferAlignmentProperties[1].uniformTexelBufferOffsetAlignmentBytes ||
4711                  texelBufferAlignmentProperties[0].uniformTexelBufferOffsetSingleTexelAlignment != texelBufferAlignmentProperties[1].uniformTexelBufferOffsetSingleTexelAlignment))
4712         {
4713                 TCU_FAIL("Mismatch between VkPhysicalDeviceTexelBufferAlignmentProperties");
4714         }
4715
4716         if (khr_integer_dot_product &&
4717                 (integerDotProductProperties[0].integerDotProduct8BitUnsignedAccelerated                                                                                != integerDotProductProperties[1].integerDotProduct8BitUnsignedAccelerated ||
4718                  integerDotProductProperties[0].integerDotProduct8BitSignedAccelerated                                                                                  != integerDotProductProperties[1].integerDotProduct8BitSignedAccelerated ||
4719                  integerDotProductProperties[0].integerDotProduct8BitMixedSignednessAccelerated                                                                 != integerDotProductProperties[1].integerDotProduct8BitMixedSignednessAccelerated ||
4720                  integerDotProductProperties[0].integerDotProduct4x8BitPackedUnsignedAccelerated                                                                != integerDotProductProperties[1].integerDotProduct4x8BitPackedUnsignedAccelerated ||
4721                  integerDotProductProperties[0].integerDotProduct4x8BitPackedSignedAccelerated                                                                  != integerDotProductProperties[1].integerDotProduct4x8BitPackedSignedAccelerated ||
4722                  integerDotProductProperties[0].integerDotProduct4x8BitPackedMixedSignednessAccelerated                                                 != integerDotProductProperties[1].integerDotProduct4x8BitPackedMixedSignednessAccelerated ||
4723                  integerDotProductProperties[0].integerDotProduct16BitUnsignedAccelerated                                                                               != integerDotProductProperties[1].integerDotProduct16BitUnsignedAccelerated ||
4724                  integerDotProductProperties[0].integerDotProduct16BitSignedAccelerated                                                                                 != integerDotProductProperties[1].integerDotProduct16BitSignedAccelerated ||
4725                  integerDotProductProperties[0].integerDotProduct16BitMixedSignednessAccelerated                                                                != integerDotProductProperties[1].integerDotProduct16BitMixedSignednessAccelerated ||
4726                  integerDotProductProperties[0].integerDotProduct32BitUnsignedAccelerated                                                                               != integerDotProductProperties[1].integerDotProduct32BitUnsignedAccelerated ||
4727                  integerDotProductProperties[0].integerDotProduct32BitSignedAccelerated                                                                                 != integerDotProductProperties[1].integerDotProduct32BitSignedAccelerated ||
4728                  integerDotProductProperties[0].integerDotProduct32BitMixedSignednessAccelerated                                                                != integerDotProductProperties[1].integerDotProduct32BitMixedSignednessAccelerated ||
4729                  integerDotProductProperties[0].integerDotProduct64BitUnsignedAccelerated                                                                               != integerDotProductProperties[1].integerDotProduct64BitUnsignedAccelerated ||
4730                  integerDotProductProperties[0].integerDotProduct64BitSignedAccelerated                                                                                 != integerDotProductProperties[1].integerDotProduct64BitSignedAccelerated ||
4731                  integerDotProductProperties[0].integerDotProduct64BitMixedSignednessAccelerated                                                                != integerDotProductProperties[1].integerDotProduct64BitMixedSignednessAccelerated ||
4732                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating8BitUnsignedAccelerated                                  != integerDotProductProperties[1].integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ||
4733                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating8BitSignedAccelerated                                    != integerDotProductProperties[1].integerDotProductAccumulatingSaturating8BitSignedAccelerated ||
4734                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated                   != integerDotProductProperties[1].integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ||
4735                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated                  != integerDotProductProperties[1].integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ||
4736                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated                    != integerDotProductProperties[1].integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ||
4737                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated   != integerDotProductProperties[1].integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ||
4738                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating16BitUnsignedAccelerated                                 != integerDotProductProperties[1].integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ||
4739                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating16BitSignedAccelerated                                   != integerDotProductProperties[1].integerDotProductAccumulatingSaturating16BitSignedAccelerated ||
4740                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated                  != integerDotProductProperties[1].integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ||
4741                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating32BitUnsignedAccelerated                                 != integerDotProductProperties[1].integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ||
4742                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating32BitSignedAccelerated                                   != integerDotProductProperties[1].integerDotProductAccumulatingSaturating32BitSignedAccelerated ||
4743                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated                  != integerDotProductProperties[1].integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ||
4744                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating64BitUnsignedAccelerated                                 != integerDotProductProperties[1].integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ||
4745                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating64BitSignedAccelerated                                   != integerDotProductProperties[1].integerDotProductAccumulatingSaturating64BitSignedAccelerated ||
4746                  integerDotProductProperties[0].integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated                  != integerDotProductProperties[1].integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated))
4747         {
4748                 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR");
4749         }
4750
4751         if (isExtensionSupported(properties, RequiredExtension("VK_KHR_push_descriptor")))
4752         {
4753                 VkPhysicalDevicePushDescriptorPropertiesKHR             pushDescriptorProperties[count];
4754
4755                 for (int ndx = 0; ndx < count; ++ndx)
4756                 {
4757                         deMemset(&pushDescriptorProperties[ndx], 0xFF * ndx, sizeof(VkPhysicalDevicePushDescriptorPropertiesKHR));
4758
4759                         pushDescriptorProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
4760                         pushDescriptorProperties[ndx].pNext     = DE_NULL;
4761
4762                         extProperties.pNext = &pushDescriptorProperties[ndx];
4763
4764                         vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
4765
4766                         pushDescriptorProperties[ndx].pNext = DE_NULL;
4767                 }
4768
4769                 log << TestLog::Message << pushDescriptorProperties[0] << TestLog::EndMessage;
4770
4771                 if ( pushDescriptorProperties[0].maxPushDescriptors != pushDescriptorProperties[1].maxPushDescriptors )
4772                 {
4773                         TCU_FAIL("Mismatch between VkPhysicalDevicePushDescriptorPropertiesKHR ");
4774                 }
4775                 if (pushDescriptorProperties[0].maxPushDescriptors < 32)
4776                 {
4777                         TCU_FAIL("VkPhysicalDevicePushDescriptorPropertiesKHR.maxPushDescriptors must be at least 32");
4778                 }
4779         }
4780
4781         if (isExtensionSupported(properties, RequiredExtension("VK_KHR_performance_query")))
4782         {
4783                 VkPhysicalDevicePerformanceQueryPropertiesKHR performanceQueryProperties[count];
4784
4785                 for (int ndx = 0; ndx < count; ++ndx)
4786                 {
4787                         deMemset(&performanceQueryProperties[ndx], 0xFF * ndx, sizeof(VkPhysicalDevicePerformanceQueryPropertiesKHR));
4788                         performanceQueryProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
4789                         performanceQueryProperties[ndx].pNext = DE_NULL;
4790
4791                         extProperties.pNext = &performanceQueryProperties[ndx];
4792
4793                         vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
4794                 }
4795
4796                 log << TestLog::Message << performanceQueryProperties[0] << TestLog::EndMessage;
4797
4798                 if (performanceQueryProperties[0].allowCommandBufferQueryCopies != performanceQueryProperties[1].allowCommandBufferQueryCopies)
4799                 {
4800                         TCU_FAIL("Mismatch between VkPhysicalDevicePerformanceQueryPropertiesKHR");
4801                 }
4802         }
4803
4804         if (isExtensionSupported(properties, RequiredExtension("VK_EXT_pci_bus_info", 2, 2)))
4805         {
4806                 VkPhysicalDevicePCIBusInfoPropertiesEXT pciBusInfoProperties[count];
4807
4808                 for (int ndx = 0; ndx < count; ++ndx)
4809                 {
4810                         // Each PCI device is identified by an 8-bit domain number, 5-bit
4811                         // device number and 3-bit function number[1][2].
4812                         //
4813                         // In addition, because PCI systems can be interconnected and
4814                         // divided in segments, Linux assigns a 16-bit number to the device
4815                         // as the "domain". In Windows, the segment or domain is stored in
4816                         // the higher 24-bit section of the bus number.
4817                         //
4818                         // This means the maximum unsigned 32-bit integer for these members
4819                         // are invalid values and should change after querying properties.
4820                         //
4821                         // [1] https://en.wikipedia.org/wiki/PCI_configuration_space
4822                         // [2] PCI Express Base Specification Revision 3.0, section 2.2.4.2.
4823                         deMemset(pciBusInfoProperties + ndx, 0xFF * ndx, sizeof(pciBusInfoProperties[ndx]));
4824                         pciBusInfoProperties[ndx].pciDomain   = DEUINT32_MAX;
4825                         pciBusInfoProperties[ndx].pciBus      = DEUINT32_MAX;
4826                         pciBusInfoProperties[ndx].pciDevice   = DEUINT32_MAX;
4827                         pciBusInfoProperties[ndx].pciFunction = DEUINT32_MAX;
4828
4829                         pciBusInfoProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
4830                         pciBusInfoProperties[ndx].pNext = DE_NULL;
4831
4832                         extProperties.pNext = pciBusInfoProperties + ndx;
4833                         vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
4834                 }
4835
4836                 log << TestLog::Message << toString(pciBusInfoProperties[0]) << TestLog::EndMessage;
4837
4838                 if (pciBusInfoProperties[0].pciDomain   != pciBusInfoProperties[1].pciDomain ||
4839                         pciBusInfoProperties[0].pciBus          != pciBusInfoProperties[1].pciBus ||
4840                         pciBusInfoProperties[0].pciDevice       != pciBusInfoProperties[1].pciDevice ||
4841                         pciBusInfoProperties[0].pciFunction     != pciBusInfoProperties[1].pciFunction)
4842                 {
4843                         TCU_FAIL("Mismatch between VkPhysicalDevicePCIBusInfoPropertiesEXT");
4844                 }
4845                 if (pciBusInfoProperties[0].pciDomain   == DEUINT32_MAX ||
4846                     pciBusInfoProperties[0].pciBus      == DEUINT32_MAX ||
4847                     pciBusInfoProperties[0].pciDevice   == DEUINT32_MAX ||
4848                     pciBusInfoProperties[0].pciFunction == DEUINT32_MAX)
4849                 {
4850                         TCU_FAIL("Invalid information in VkPhysicalDevicePCIBusInfoPropertiesEXT");
4851                 }
4852         }
4853
4854         if (isExtensionSupported(properties, RequiredExtension("VK_KHR_portability_subset")))
4855         {
4856                 VkPhysicalDevicePortabilitySubsetPropertiesKHR portabilitySubsetProperties[count];
4857
4858                 for (int ndx = 0; ndx < count; ++ndx)
4859                 {
4860                         deMemset(&portabilitySubsetProperties[ndx], 0xFF * ndx, sizeof(VkPhysicalDevicePortabilitySubsetPropertiesKHR));
4861                         portabilitySubsetProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR;
4862                         portabilitySubsetProperties[ndx].pNext = DE_NULL;
4863
4864                         extProperties.pNext = &portabilitySubsetProperties[ndx];
4865
4866                         vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
4867                 }
4868
4869                 log << TestLog::Message << portabilitySubsetProperties[0] << TestLog::EndMessage;
4870
4871                 if (portabilitySubsetProperties[0].minVertexInputBindingStrideAlignment != portabilitySubsetProperties[1].minVertexInputBindingStrideAlignment)
4872                 {
4873                         TCU_FAIL("Mismatch between VkPhysicalDevicePortabilitySubsetPropertiesKHR");
4874                 }
4875         }
4876
4877         return tcu::TestStatus::pass("Querying device properties succeeded");
4878 }
4879
4880 string toString (const VkFormatProperties2& value)
4881 {
4882         std::ostringstream      s;
4883         s << "VkFormatProperties2 = {\n";
4884         s << "\tsType = " << value.sType << '\n';
4885         s << "\tformatProperties = {\n";
4886         s << "\tlinearTilingFeatures = " << getFormatFeatureFlagsStr(value.formatProperties.linearTilingFeatures) << '\n';
4887         s << "\toptimalTilingFeatures = " << getFormatFeatureFlagsStr(value.formatProperties.optimalTilingFeatures) << '\n';
4888         s << "\tbufferFeatures = " << getFormatFeatureFlagsStr(value.formatProperties.bufferFeatures) << '\n';
4889         s << "\t}";
4890         s << "}";
4891         return s.str();
4892 }
4893
4894 tcu::TestStatus deviceFormatProperties2 (Context& context)
4895 {
4896         const CustomInstance                    instance                (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
4897         const InstanceDriver&                   vki                             (instance.getDriver());
4898         const VkPhysicalDevice                  physicalDevice  (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
4899         TestLog&                                                log                             = context.getTestContext().getLog();
4900
4901         for (int formatNdx = 0; formatNdx < VK_CORE_FORMAT_LAST; ++formatNdx)
4902         {
4903                 const VkFormat                  format                  = (VkFormat)formatNdx;
4904                 VkFormatProperties              coreProperties;
4905                 VkFormatProperties2             extProperties;
4906
4907                 deMemset(&coreProperties, 0xcd, sizeof(VkFormatProperties));
4908                 deMemset(&extProperties, 0xcd, sizeof(VkFormatProperties2));
4909
4910                 extProperties.sType     = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
4911                 extProperties.pNext = DE_NULL;
4912
4913                 vki.getPhysicalDeviceFormatProperties(physicalDevice, format, &coreProperties);
4914                 vki.getPhysicalDeviceFormatProperties2(physicalDevice, format, &extProperties);
4915
4916                 TCU_CHECK(extProperties.sType == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
4917                 TCU_CHECK(extProperties.pNext == DE_NULL);
4918
4919                 if (deMemCmp(&coreProperties, &extProperties.formatProperties, sizeof(VkFormatProperties)) != 0)
4920                         TCU_FAIL("Mismatch between format properties reported by vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceFormatProperties2");
4921
4922                 log << TestLog::Message << toString (extProperties) << TestLog::EndMessage;
4923         }
4924
4925         return tcu::TestStatus::pass("Querying device format properties succeeded");
4926 }
4927
4928 tcu::TestStatus deviceQueueFamilyProperties2 (Context& context)
4929 {
4930         const CustomInstance                    instance                                (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
4931         const InstanceDriver&                   vki                                             (instance.getDriver());
4932         const VkPhysicalDevice                  physicalDevice  (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
4933         TestLog&                                                log                                             = context.getTestContext().getLog();
4934         deUint32                                                numCoreQueueFamilies    = ~0u;
4935         deUint32                                                numExtQueueFamilies             = ~0u;
4936
4937         vki.getPhysicalDeviceQueueFamilyProperties(physicalDevice, &numCoreQueueFamilies, DE_NULL);
4938         vki.getPhysicalDeviceQueueFamilyProperties2(physicalDevice, &numExtQueueFamilies, DE_NULL);
4939
4940         TCU_CHECK_MSG(numCoreQueueFamilies == numExtQueueFamilies, "Different number of queue family properties reported");
4941         TCU_CHECK(numCoreQueueFamilies > 0);
4942
4943         {
4944                 std::vector<VkQueueFamilyProperties>            coreProperties  (numCoreQueueFamilies);
4945                 std::vector<VkQueueFamilyProperties2>           extProperties   (numExtQueueFamilies);
4946
4947                 deMemset(&coreProperties[0], 0xcd, sizeof(VkQueueFamilyProperties)*numCoreQueueFamilies);
4948                 deMemset(&extProperties[0], 0xcd, sizeof(VkQueueFamilyProperties2)*numExtQueueFamilies);
4949
4950                 for (size_t ndx = 0; ndx < extProperties.size(); ++ndx)
4951                 {
4952                         extProperties[ndx].sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2;
4953                         extProperties[ndx].pNext = DE_NULL;
4954                 }
4955
4956                 vki.getPhysicalDeviceQueueFamilyProperties(physicalDevice, &numCoreQueueFamilies, &coreProperties[0]);
4957                 vki.getPhysicalDeviceQueueFamilyProperties2(physicalDevice, &numExtQueueFamilies, &extProperties[0]);
4958
4959                 TCU_CHECK((size_t)numCoreQueueFamilies == coreProperties.size());
4960                 TCU_CHECK((size_t)numExtQueueFamilies == extProperties.size());
4961                 DE_ASSERT(numCoreQueueFamilies == numExtQueueFamilies);
4962
4963                 for (size_t ndx = 0; ndx < extProperties.size(); ++ndx)
4964                 {
4965                         TCU_CHECK(extProperties[ndx].sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2);
4966                         TCU_CHECK(extProperties[ndx].pNext == DE_NULL);
4967
4968                         if (deMemCmp(&coreProperties[ndx], &extProperties[ndx].queueFamilyProperties, sizeof(VkQueueFamilyProperties)) != 0)
4969                                 TCU_FAIL("Mismatch between format properties reported by vkGetPhysicalDeviceQueueFamilyProperties and vkGetPhysicalDeviceQueueFamilyProperties2");
4970
4971                         log << TestLog::Message << " queueFamilyNdx = " << ndx <<TestLog::EndMessage
4972                         << TestLog::Message << extProperties[ndx] << TestLog::EndMessage;
4973                 }
4974         }
4975
4976         return tcu::TestStatus::pass("Querying device queue family properties succeeded");
4977 }
4978
4979 tcu::TestStatus deviceMemoryProperties2 (Context& context)
4980 {
4981         const CustomInstance                            instance                (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
4982         const InstanceDriver&                           vki                             (instance.getDriver());
4983         const VkPhysicalDevice                          physicalDevice  (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
4984         TestLog&                                                        log                             = context.getTestContext().getLog();
4985         VkPhysicalDeviceMemoryProperties        coreProperties;
4986         VkPhysicalDeviceMemoryProperties2       extProperties;
4987
4988         deMemset(&coreProperties, 0xcd, sizeof(VkPhysicalDeviceMemoryProperties));
4989         deMemset(&extProperties, 0xcd, sizeof(VkPhysicalDeviceMemoryProperties2));
4990
4991         extProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
4992         extProperties.pNext = DE_NULL;
4993
4994         vki.getPhysicalDeviceMemoryProperties(physicalDevice, &coreProperties);
4995         vki.getPhysicalDeviceMemoryProperties2(physicalDevice, &extProperties);
4996
4997         TCU_CHECK(extProperties.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2);
4998         TCU_CHECK(extProperties.pNext == DE_NULL);
4999
5000         if (coreProperties.memoryTypeCount != extProperties.memoryProperties.memoryTypeCount)
5001                 TCU_FAIL("Mismatch between memoryTypeCount reported by vkGetPhysicalDeviceMemoryProperties and vkGetPhysicalDeviceMemoryProperties2");
5002         if (coreProperties.memoryHeapCount != extProperties.memoryProperties.memoryHeapCount)
5003                 TCU_FAIL("Mismatch between memoryHeapCount reported by vkGetPhysicalDeviceMemoryProperties and vkGetPhysicalDeviceMemoryProperties2");
5004         for (deUint32 i = 0; i < coreProperties.memoryTypeCount; i++) {
5005                 const VkMemoryType *coreType = &coreProperties.memoryTypes[i];
5006                 const VkMemoryType *extType = &extProperties.memoryProperties.memoryTypes[i];
5007                 if (coreType->propertyFlags != extType->propertyFlags || coreType->heapIndex != extType->heapIndex)
5008                         TCU_FAIL("Mismatch between memoryTypes reported by vkGetPhysicalDeviceMemoryProperties and vkGetPhysicalDeviceMemoryProperties2");
5009         }
5010         for (deUint32 i = 0; i < coreProperties.memoryHeapCount; i++) {
5011                 const VkMemoryHeap *coreHeap = &coreProperties.memoryHeaps[i];
5012                 const VkMemoryHeap *extHeap = &extProperties.memoryProperties.memoryHeaps[i];
5013                 if (coreHeap->size != extHeap->size || coreHeap->flags != extHeap->flags)
5014                         TCU_FAIL("Mismatch between memoryHeaps reported by vkGetPhysicalDeviceMemoryProperties and vkGetPhysicalDeviceMemoryProperties2");
5015         }
5016
5017         log << TestLog::Message << extProperties << TestLog::EndMessage;
5018
5019         return tcu::TestStatus::pass("Querying device memory properties succeeded");
5020 }
5021
5022 tcu::TestStatus deviceFeaturesVulkan12 (Context& context)
5023 {
5024         using namespace ValidateQueryBits;
5025
5026         const QueryMemberTableEntry                     feature11OffsetTable[] =
5027         {
5028                 // VkPhysicalDevice16BitStorageFeatures
5029                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, storageBuffer16BitAccess),
5030                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, uniformAndStorageBuffer16BitAccess),
5031                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, storagePushConstant16),
5032                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, storageInputOutput16),
5033
5034                 // VkPhysicalDeviceMultiviewFeatures
5035                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, multiview),
5036                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, multiviewGeometryShader),
5037                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, multiviewTessellationShader),
5038
5039                 // VkPhysicalDeviceVariablePointersFeatures
5040                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, variablePointersStorageBuffer),
5041                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, variablePointers),
5042
5043                 // VkPhysicalDeviceProtectedMemoryFeatures
5044                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, protectedMemory),
5045
5046                 // VkPhysicalDeviceSamplerYcbcrConversionFeatures
5047                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, samplerYcbcrConversion),
5048
5049                 // VkPhysicalDeviceShaderDrawParametersFeatures
5050                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Features, shaderDrawParameters),
5051                 { 0, 0 }
5052         };
5053         const QueryMemberTableEntry                     feature12OffsetTable[] =
5054         {
5055                 // None
5056                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, samplerMirrorClampToEdge),
5057                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, drawIndirectCount),
5058
5059                 // VkPhysicalDevice8BitStorageFeatures
5060                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, storageBuffer8BitAccess),
5061                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, uniformAndStorageBuffer8BitAccess),
5062                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, storagePushConstant8),
5063
5064                 // VkPhysicalDeviceShaderAtomicInt64Features
5065                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderBufferInt64Atomics),
5066                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderSharedInt64Atomics),
5067
5068                 // VkPhysicalDeviceShaderFloat16Int8Features
5069                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderFloat16),
5070                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderInt8),
5071
5072                 // VkPhysicalDeviceDescriptorIndexingFeatures
5073                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, descriptorIndexing),
5074                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderInputAttachmentArrayDynamicIndexing),
5075                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderUniformTexelBufferArrayDynamicIndexing),
5076                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderStorageTexelBufferArrayDynamicIndexing),
5077                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderUniformBufferArrayNonUniformIndexing),
5078                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderSampledImageArrayNonUniformIndexing),
5079                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderStorageBufferArrayNonUniformIndexing),
5080                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderStorageImageArrayNonUniformIndexing),
5081                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderInputAttachmentArrayNonUniformIndexing),
5082                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderUniformTexelBufferArrayNonUniformIndexing),
5083                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderStorageTexelBufferArrayNonUniformIndexing),
5084                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, descriptorBindingUniformBufferUpdateAfterBind),
5085                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, descriptorBindingSampledImageUpdateAfterBind),
5086                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, descriptorBindingStorageImageUpdateAfterBind),
5087                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, descriptorBindingStorageBufferUpdateAfterBind),
5088                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, descriptorBindingUniformTexelBufferUpdateAfterBind),
5089                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, descriptorBindingStorageTexelBufferUpdateAfterBind),
5090                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, descriptorBindingUpdateUnusedWhilePending),
5091                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, descriptorBindingPartiallyBound),
5092                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, descriptorBindingVariableDescriptorCount),
5093                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, runtimeDescriptorArray),
5094
5095                 // None
5096                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, samplerFilterMinmax),
5097
5098                 // VkPhysicalDeviceScalarBlockLayoutFeatures
5099                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, scalarBlockLayout),
5100
5101                 // VkPhysicalDeviceImagelessFramebufferFeatures
5102                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, imagelessFramebuffer),
5103
5104                 // VkPhysicalDeviceUniformBufferStandardLayoutFeatures
5105                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, uniformBufferStandardLayout),
5106
5107                 // VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures
5108                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderSubgroupExtendedTypes),
5109
5110                 // VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures
5111                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, separateDepthStencilLayouts),
5112
5113                 // VkPhysicalDeviceHostQueryResetFeatures
5114                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, hostQueryReset),
5115
5116                 // VkPhysicalDeviceTimelineSemaphoreFeatures
5117                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, timelineSemaphore),
5118
5119                 // VkPhysicalDeviceBufferDeviceAddressFeatures
5120                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, bufferDeviceAddress),
5121                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, bufferDeviceAddressCaptureReplay),
5122                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, bufferDeviceAddressMultiDevice),
5123
5124                 // VkPhysicalDeviceVulkanMemoryModelFeatures
5125                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, vulkanMemoryModel),
5126                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, vulkanMemoryModelDeviceScope),
5127                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, vulkanMemoryModelAvailabilityVisibilityChains),
5128
5129                 // None
5130                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderOutputViewportIndex),
5131                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, shaderOutputLayer),
5132                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Features, subgroupBroadcastDynamicId),
5133                 { 0, 0 }
5134         };
5135         TestLog&                                                                                        log                                                                             = context.getTestContext().getLog();
5136         const CustomInstance                                                            instance                                                                (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
5137         const InstanceDriver&                                                           vki                                                                             = instance.getDriver();
5138         const VkPhysicalDevice                                                          physicalDevice                                                  (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
5139         const deUint32                                                                          vulkan11FeaturesBufferSize                              = sizeof(VkPhysicalDeviceVulkan11Features) + GUARD_SIZE;
5140         const deUint32                                                                          vulkan12FeaturesBufferSize                              = sizeof(VkPhysicalDeviceVulkan12Features) + GUARD_SIZE;
5141         VkPhysicalDeviceFeatures2                                                       extFeatures;
5142         deUint8                                                                                         buffer11a[vulkan11FeaturesBufferSize];
5143         deUint8                                                                                         buffer11b[vulkan11FeaturesBufferSize];
5144         deUint8                                                                                         buffer12a[vulkan12FeaturesBufferSize];
5145         deUint8                                                                                         buffer12b[vulkan12FeaturesBufferSize];
5146         const int                                                                                       count                                                                   = 2u;
5147         VkPhysicalDeviceVulkan11Features*                                       vulkan11Features[count]                                 = { (VkPhysicalDeviceVulkan11Features*)(buffer11a), (VkPhysicalDeviceVulkan11Features*)(buffer11b)};
5148         VkPhysicalDeviceVulkan12Features*                                       vulkan12Features[count]                                 = { (VkPhysicalDeviceVulkan12Features*)(buffer12a), (VkPhysicalDeviceVulkan12Features*)(buffer12b)};
5149
5150         if (!context.contextSupports(vk::ApiVersion(1, 2, 0)))
5151                 TCU_THROW(NotSupportedError, "At least Vulkan 1.2 required to run test");
5152
5153         deMemset(buffer11b, GUARD_VALUE, sizeof(buffer11b));
5154         deMemset(buffer12a, GUARD_VALUE, sizeof(buffer12a));
5155         deMemset(buffer12b, GUARD_VALUE, sizeof(buffer12b));
5156         deMemset(buffer11a, GUARD_VALUE, sizeof(buffer11a));
5157
5158         // Validate all fields initialized
5159         for (int ndx = 0; ndx < count; ++ndx)
5160         {
5161                 deMemset(&extFeatures.features, 0x00, sizeof(extFeatures.features));
5162                 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
5163                 extFeatures.pNext = vulkan11Features[ndx];
5164
5165                 deMemset(vulkan11Features[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVulkan11Features));
5166                 vulkan11Features[ndx]->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
5167                 vulkan11Features[ndx]->pNext = vulkan12Features[ndx];
5168
5169                 deMemset(vulkan12Features[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVulkan12Features));
5170                 vulkan12Features[ndx]->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
5171                 vulkan12Features[ndx]->pNext = DE_NULL;
5172
5173                 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures);
5174         }
5175
5176         log << TestLog::Message << *vulkan11Features[0] << TestLog::EndMessage;
5177         log << TestLog::Message << *vulkan12Features[0] << TestLog::EndMessage;
5178
5179         if (!validateStructsWithGuard(feature11OffsetTable, vulkan11Features, GUARD_VALUE, GUARD_SIZE))
5180         {
5181                 log << TestLog::Message << "deviceFeatures - VkPhysicalDeviceVulkan11Features initialization failure" << TestLog::EndMessage;
5182
5183                 return tcu::TestStatus::fail("VkPhysicalDeviceVulkan11Features initialization failure");
5184         }
5185
5186         if (!validateStructsWithGuard(feature12OffsetTable, vulkan12Features, GUARD_VALUE, GUARD_SIZE))
5187         {
5188                 log << TestLog::Message << "deviceFeatures - VkPhysicalDeviceVulkan12Features initialization failure" << TestLog::EndMessage;
5189
5190                 return tcu::TestStatus::fail("VkPhysicalDeviceVulkan12Features initialization failure");
5191         }
5192
5193         return tcu::TestStatus::pass("Querying Vulkan 1.2 device features succeeded");
5194 }
5195
5196 tcu::TestStatus deviceFeaturesVulkan13 (Context& context)
5197 {
5198         using namespace ValidateQueryBits;
5199
5200         const QueryMemberTableEntry                     feature13OffsetTable[] =
5201         {
5202                 // VkPhysicalDeviceImageRobustnessFeatures
5203                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, robustImageAccess),
5204
5205                 // VkPhysicalDeviceInlineUniformBlockFeatures
5206                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, inlineUniformBlock),
5207                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, descriptorBindingInlineUniformBlockUpdateAfterBind),
5208
5209                 // VkPhysicalDevicePipelineCreationCacheControlFeatures
5210                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, pipelineCreationCacheControl),
5211
5212                 // VkPhysicalDevicePrivateDataFeatures
5213                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, privateData),
5214
5215                 // VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures
5216                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, shaderDemoteToHelperInvocation),
5217
5218                 // VkPhysicalDeviceShaderTerminateInvocationFeatures
5219                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, shaderTerminateInvocation),
5220
5221                 // VkPhysicalDeviceSubgroupSizeControlFeatures
5222                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, subgroupSizeControl),
5223                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, computeFullSubgroups),
5224
5225                 // VkPhysicalDeviceSynchronization2Features
5226                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, synchronization2),
5227
5228                 // VkPhysicalDeviceTextureCompressionASTCHDRFeatures
5229                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, textureCompressionASTC_HDR),
5230
5231                 // VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures
5232                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, shaderZeroInitializeWorkgroupMemory),
5233
5234                 // VkPhysicalDeviceDynamicRenderingFeatures
5235                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, dynamicRendering),
5236
5237                 // VkPhysicalDeviceShaderIntegerDotProductFeatures
5238                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, shaderIntegerDotProduct),
5239
5240                 // VkPhysicalDeviceMaintenance4Features
5241                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Features, maintenance4),
5242                 { 0, 0 }
5243         };
5244         TestLog&                                                                                        log                                                                             = context.getTestContext().getLog();
5245         const VkPhysicalDevice                                                          physicalDevice                                                  = context.getPhysicalDevice();
5246         const CustomInstance                                                            instance                                                                (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
5247         const InstanceDriver&                                                           vki                                                                             = instance.getDriver();
5248         const deUint32                                                                          vulkan13FeaturesBufferSize                              = sizeof(VkPhysicalDeviceVulkan13Features) + GUARD_SIZE;
5249         VkPhysicalDeviceFeatures2                                                       extFeatures;
5250         deUint8                                                                                         buffer13a[vulkan13FeaturesBufferSize];
5251         deUint8                                                                                         buffer13b[vulkan13FeaturesBufferSize];
5252         const int                                                                                       count                                                                   = 2u;
5253         VkPhysicalDeviceVulkan13Features*                                       vulkan13Features[count]                                 = { (VkPhysicalDeviceVulkan13Features*)(buffer13a), (VkPhysicalDeviceVulkan13Features*)(buffer13b)};
5254
5255         if (!context.contextSupports(vk::ApiVersion(1, 3, 0)))
5256                 TCU_THROW(NotSupportedError, "At least Vulkan 1.3 required to run test");
5257
5258         deMemset(buffer13a, GUARD_VALUE, sizeof(buffer13a));
5259         deMemset(buffer13b, GUARD_VALUE, sizeof(buffer13b));
5260
5261         // Validate all fields initialized
5262         for (int ndx = 0; ndx < count; ++ndx)
5263         {
5264                 deMemset(&extFeatures.features, 0x00, sizeof(extFeatures.features));
5265                 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
5266                 extFeatures.pNext = vulkan13Features[ndx];
5267
5268                 deMemset(vulkan13Features[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVulkan13Features));
5269                 vulkan13Features[ndx]->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
5270                 vulkan13Features[ndx]->pNext = DE_NULL;
5271
5272                 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures);
5273         }
5274
5275         log << TestLog::Message << *vulkan13Features[0] << TestLog::EndMessage;
5276
5277         if (!validateStructsWithGuard(feature13OffsetTable, vulkan13Features, GUARD_VALUE, GUARD_SIZE))
5278         {
5279                 log << TestLog::Message << "deviceFeatures - VkPhysicalDeviceVulkan13Features initialization failure" << TestLog::EndMessage;
5280
5281                 return tcu::TestStatus::fail("VkPhysicalDeviceVulkan13Features initialization failure");
5282         }
5283
5284         return tcu::TestStatus::pass("Querying Vulkan 1.3 device features succeeded");
5285 }
5286
5287 tcu::TestStatus devicePropertiesVulkan12 (Context& context)
5288 {
5289         using namespace ValidateQueryBits;
5290
5291         const QueryMemberTableEntry                     properties11OffsetTable[] =
5292         {
5293                 // VkPhysicalDeviceIDProperties
5294                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, deviceUUID),
5295                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, driverUUID),
5296                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, deviceLUID),
5297                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, deviceNodeMask),
5298                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, deviceLUIDValid),
5299
5300                 // VkPhysicalDeviceSubgroupProperties
5301                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, subgroupSize),
5302                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, subgroupSupportedStages),
5303                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, subgroupSupportedOperations),
5304                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, subgroupQuadOperationsInAllStages),
5305
5306                 // VkPhysicalDevicePointClippingProperties
5307                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, pointClippingBehavior),
5308
5309                 // VkPhysicalDeviceMultiviewProperties
5310                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, maxMultiviewViewCount),
5311                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, maxMultiviewInstanceIndex),
5312
5313                 // VkPhysicalDeviceProtectedMemoryProperties
5314                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, protectedNoFault),
5315
5316                 // VkPhysicalDeviceMaintenance3Properties
5317                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, maxPerSetDescriptors),
5318                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan11Properties, maxMemoryAllocationSize),
5319                 { 0, 0 }
5320         };
5321         const QueryMemberTableEntry                     properties12OffsetTable[] =
5322         {
5323                 // VkPhysicalDeviceDriverProperties
5324                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, driverID),
5325                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, conformanceVersion),
5326
5327                 // VkPhysicalDeviceFloatControlsProperties
5328                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, denormBehaviorIndependence),
5329                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, roundingModeIndependence),
5330                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderSignedZeroInfNanPreserveFloat16),
5331                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderSignedZeroInfNanPreserveFloat32),
5332                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderSignedZeroInfNanPreserveFloat64),
5333                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderDenormPreserveFloat16),
5334                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderDenormPreserveFloat32),
5335                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderDenormPreserveFloat64),
5336                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderDenormFlushToZeroFloat16),
5337                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderDenormFlushToZeroFloat32),
5338                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderDenormFlushToZeroFloat64),
5339                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderRoundingModeRTEFloat16),
5340                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderRoundingModeRTEFloat32),
5341                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderRoundingModeRTEFloat64),
5342                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderRoundingModeRTZFloat16),
5343                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderRoundingModeRTZFloat32),
5344                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderRoundingModeRTZFloat64),
5345
5346                 // VkPhysicalDeviceDescriptorIndexingProperties
5347                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxUpdateAfterBindDescriptorsInAllPools),
5348                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderUniformBufferArrayNonUniformIndexingNative),
5349                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderSampledImageArrayNonUniformIndexingNative),
5350                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderStorageBufferArrayNonUniformIndexingNative),
5351                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderStorageImageArrayNonUniformIndexingNative),
5352                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, shaderInputAttachmentArrayNonUniformIndexingNative),
5353                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, robustBufferAccessUpdateAfterBind),
5354                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, quadDivergentImplicitLod),
5355                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxPerStageDescriptorUpdateAfterBindSamplers),
5356                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxPerStageDescriptorUpdateAfterBindUniformBuffers),
5357                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxPerStageDescriptorUpdateAfterBindStorageBuffers),
5358                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxPerStageDescriptorUpdateAfterBindSampledImages),
5359                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxPerStageDescriptorUpdateAfterBindStorageImages),
5360                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxPerStageDescriptorUpdateAfterBindInputAttachments),
5361                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxPerStageUpdateAfterBindResources),
5362                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxDescriptorSetUpdateAfterBindSamplers),
5363                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxDescriptorSetUpdateAfterBindUniformBuffers),
5364                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxDescriptorSetUpdateAfterBindUniformBuffersDynamic),
5365                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxDescriptorSetUpdateAfterBindStorageBuffers),
5366                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxDescriptorSetUpdateAfterBindStorageBuffersDynamic),
5367                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxDescriptorSetUpdateAfterBindSampledImages),
5368                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxDescriptorSetUpdateAfterBindStorageImages),
5369                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxDescriptorSetUpdateAfterBindInputAttachments),
5370
5371                 // VkPhysicalDeviceDepthStencilResolveProperties
5372                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, supportedDepthResolveModes),
5373                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, supportedStencilResolveModes),
5374                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, independentResolveNone),
5375                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, independentResolve),
5376
5377                 // VkPhysicalDeviceSamplerFilterMinmaxProperties
5378                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, filterMinmaxSingleComponentFormats),
5379                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, filterMinmaxImageComponentMapping),
5380
5381                 // VkPhysicalDeviceTimelineSemaphoreProperties
5382                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, maxTimelineSemaphoreValueDifference),
5383
5384                 // None
5385                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan12Properties, framebufferIntegerColorSampleCounts),
5386                 { 0, 0 }
5387         };
5388         TestLog&                                                                                log                                                                                     = context.getTestContext().getLog();
5389         const CustomInstance                                                    instance                                                                        (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
5390         const InstanceDriver&                                                   vki                                                                                     = instance.getDriver();
5391         const VkPhysicalDevice                                                  physicalDevice                                                          (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
5392         const deUint32                                                                  vulkan11PropertiesBufferSize                            = sizeof(VkPhysicalDeviceVulkan11Properties) + GUARD_SIZE;
5393         const deUint32                                                                  vulkan12PropertiesBufferSize                            = sizeof(VkPhysicalDeviceVulkan12Properties) + GUARD_SIZE;
5394         VkPhysicalDeviceProperties2                                             extProperties;
5395         deUint8                                                                                 buffer11a[vulkan11PropertiesBufferSize];
5396         deUint8                                                                                 buffer11b[vulkan11PropertiesBufferSize];
5397         deUint8                                                                                 buffer12a[vulkan12PropertiesBufferSize];
5398         deUint8                                                                                 buffer12b[vulkan12PropertiesBufferSize];
5399         const int                                                                               count                                                                           = 2u;
5400         VkPhysicalDeviceVulkan11Properties*                             vulkan11Properties[count]                                       = { (VkPhysicalDeviceVulkan11Properties*)(buffer11a), (VkPhysicalDeviceVulkan11Properties*)(buffer11b)};
5401         VkPhysicalDeviceVulkan12Properties*                             vulkan12Properties[count]                                       = { (VkPhysicalDeviceVulkan12Properties*)(buffer12a), (VkPhysicalDeviceVulkan12Properties*)(buffer12b)};
5402
5403         if (!context.contextSupports(vk::ApiVersion(1, 2, 0)))
5404                 TCU_THROW(NotSupportedError, "At least Vulkan 1.2 required to run test");
5405
5406         deMemset(buffer11a, GUARD_VALUE, sizeof(buffer11a));
5407         deMemset(buffer11b, GUARD_VALUE, sizeof(buffer11b));
5408         deMemset(buffer12a, GUARD_VALUE, sizeof(buffer12a));
5409         deMemset(buffer12b, GUARD_VALUE, sizeof(buffer12b));
5410
5411         for (int ndx = 0; ndx < count; ++ndx)
5412         {
5413                 deMemset(&extProperties.properties, 0x00, sizeof(extProperties.properties));
5414                 extProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
5415                 extProperties.pNext = vulkan11Properties[ndx];
5416
5417                 deMemset(vulkan11Properties[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVulkan11Properties));
5418                 vulkan11Properties[ndx]->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
5419                 vulkan11Properties[ndx]->pNext = vulkan12Properties[ndx];
5420
5421                 deMemset(vulkan12Properties[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVulkan12Properties));
5422                 vulkan12Properties[ndx]->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
5423                 vulkan12Properties[ndx]->pNext = DE_NULL;
5424
5425                 vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
5426         }
5427
5428         log << TestLog::Message << *vulkan11Properties[0] << TestLog::EndMessage;
5429         log << TestLog::Message << *vulkan12Properties[0] << TestLog::EndMessage;
5430
5431         if (!validateStructsWithGuard(properties11OffsetTable, vulkan11Properties, GUARD_VALUE, GUARD_SIZE))
5432         {
5433                 log << TestLog::Message << "deviceProperties - VkPhysicalDeviceVulkan11Properties initialization failure" << TestLog::EndMessage;
5434
5435                 return tcu::TestStatus::fail("VkPhysicalDeviceVulkan11Properties initialization failure");
5436         }
5437
5438         if (!validateStructsWithGuard(properties12OffsetTable, vulkan12Properties, GUARD_VALUE, GUARD_SIZE) ||
5439                 strncmp(vulkan12Properties[0]->driverName, vulkan12Properties[1]->driverName, VK_MAX_DRIVER_NAME_SIZE) != 0 ||
5440                 strncmp(vulkan12Properties[0]->driverInfo, vulkan12Properties[1]->driverInfo, VK_MAX_DRIVER_INFO_SIZE) != 0 )
5441         {
5442                 log << TestLog::Message << "deviceProperties - VkPhysicalDeviceVulkan12Properties initialization failure" << TestLog::EndMessage;
5443
5444                 return tcu::TestStatus::fail("VkPhysicalDeviceVulkan12Properties initialization failure");
5445         }
5446
5447         return tcu::TestStatus::pass("Querying Vulkan 1.2 device properties succeeded");
5448 }
5449
5450 tcu::TestStatus devicePropertiesVulkan13 (Context& context)
5451 {
5452         using namespace ValidateQueryBits;
5453
5454         const QueryMemberTableEntry                     properties13OffsetTable[] =
5455         {
5456                 // VkPhysicalDeviceSubgroupSizeControlProperties
5457                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, minSubgroupSize),
5458                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, maxSubgroupSize),
5459                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, maxComputeWorkgroupSubgroups),
5460                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, requiredSubgroupSizeStages),
5461
5462                 // VkPhysicalDeviceInlineUniformBlockProperties
5463                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, maxInlineUniformBlockSize),
5464                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, maxPerStageDescriptorInlineUniformBlocks),
5465                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks),
5466                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, maxDescriptorSetInlineUniformBlocks),
5467                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, maxDescriptorSetUpdateAfterBindInlineUniformBlocks),
5468
5469                 // None
5470                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, maxInlineUniformTotalSize),
5471
5472                 // VkPhysicalDeviceShaderIntegerDotProductProperties
5473                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct8BitUnsignedAccelerated),
5474                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct8BitSignedAccelerated),
5475                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct8BitMixedSignednessAccelerated),
5476                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct4x8BitPackedUnsignedAccelerated),
5477                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct4x8BitPackedSignedAccelerated),
5478                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct4x8BitPackedMixedSignednessAccelerated),
5479                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct16BitUnsignedAccelerated),
5480                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct16BitSignedAccelerated),
5481                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct16BitMixedSignednessAccelerated),
5482                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct32BitUnsignedAccelerated),
5483                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct32BitSignedAccelerated),
5484                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct32BitMixedSignednessAccelerated),
5485                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct64BitUnsignedAccelerated),
5486                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct64BitSignedAccelerated),
5487                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProduct64BitMixedSignednessAccelerated),
5488                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating8BitUnsignedAccelerated),
5489                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating8BitSignedAccelerated),
5490                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated),
5491                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated),
5492                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated),
5493                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated),
5494                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating16BitUnsignedAccelerated),
5495                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating16BitSignedAccelerated),
5496                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated),
5497                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating32BitUnsignedAccelerated),
5498                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating32BitSignedAccelerated),
5499                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated),
5500                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating64BitUnsignedAccelerated),
5501                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating64BitSignedAccelerated),
5502                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated),
5503
5504                 // VkPhysicalDeviceTexelBufferAlignmentProperties
5505                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, storageTexelBufferOffsetAlignmentBytes),
5506                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, storageTexelBufferOffsetSingleTexelAlignment),
5507                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, uniformTexelBufferOffsetAlignmentBytes),
5508                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, uniformTexelBufferOffsetSingleTexelAlignment),
5509
5510                 // VkPhysicalDeviceMaintenance4Properties
5511                 OFFSET_TABLE_ENTRY(VkPhysicalDeviceVulkan13Properties, maxBufferSize),
5512                 { 0, 0 }
5513         };
5514
5515         TestLog&                                                                                log                                                                                     = context.getTestContext().getLog();
5516         const VkPhysicalDevice                                                  physicalDevice                                                          = context.getPhysicalDevice();
5517         const CustomInstance                                                    instance                                                                        (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
5518         const InstanceDriver&                                                   vki                                                                                     = instance.getDriver();
5519         const deUint32                                                                  vulkan13PropertiesBufferSize                            = sizeof(VkPhysicalDeviceVulkan13Properties) + GUARD_SIZE;
5520         VkPhysicalDeviceProperties2                                             extProperties;
5521         deUint8                                                                                 buffer13a[vulkan13PropertiesBufferSize];
5522         deUint8                                                                                 buffer13b[vulkan13PropertiesBufferSize];
5523         const int                                                                               count                                                                           = 2u;
5524         VkPhysicalDeviceVulkan13Properties*                             vulkan13Properties[count]                                       = { (VkPhysicalDeviceVulkan13Properties*)(buffer13a), (VkPhysicalDeviceVulkan13Properties*)(buffer13b)};
5525
5526         if (!context.contextSupports(vk::ApiVersion(1, 3, 0)))
5527                 TCU_THROW(NotSupportedError, "At least Vulkan 1.3 required to run test");
5528
5529         deMemset(buffer13a, GUARD_VALUE, sizeof(buffer13a));
5530         deMemset(buffer13b, GUARD_VALUE, sizeof(buffer13b));
5531
5532         for (int ndx = 0; ndx < count; ++ndx)
5533         {
5534                 deMemset(&extProperties.properties, 0x00, sizeof(extProperties.properties));
5535                 extProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
5536                 extProperties.pNext = vulkan13Properties[ndx];
5537
5538                 deMemset(vulkan13Properties[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVulkan13Properties));
5539                 vulkan13Properties[ndx]->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
5540                 vulkan13Properties[ndx]->pNext = DE_NULL;
5541
5542                 vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
5543         }
5544
5545         log << TestLog::Message << *vulkan13Properties[0] << TestLog::EndMessage;
5546
5547         if (!validateStructsWithGuard(properties13OffsetTable, vulkan13Properties, GUARD_VALUE, GUARD_SIZE))
5548         {
5549                 log << TestLog::Message << "deviceProperties - VkPhysicalDeviceVulkan13Properties initialization failure" << TestLog::EndMessage;
5550
5551                 return tcu::TestStatus::fail("VkPhysicalDeviceVulkan13Properties initialization failure");
5552         }
5553
5554         return tcu::TestStatus::pass("Querying Vulkan 1.3 device properties succeeded");
5555 }
5556
5557 tcu::TestStatus deviceFeatureExtensionsConsistencyVulkan12(Context& context)
5558 {
5559         TestLog&                                                                                        log                                                                             = context.getTestContext().getLog();
5560         const CustomInstance                                                            instance                                                                (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
5561         const InstanceDriver&                                                           vki                                                                             = instance.getDriver();
5562         const VkPhysicalDevice                                                          physicalDevice                                                  (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
5563
5564         if (!context.contextSupports(vk::ApiVersion(1, 2, 0)))
5565                 TCU_THROW(NotSupportedError, "At least Vulkan 1.2 required to run test");
5566
5567         VkPhysicalDeviceVulkan12Features                                        vulkan12Features                                                = initVulkanStructure();
5568         VkPhysicalDeviceVulkan11Features                                        vulkan11Features                                                = initVulkanStructure(&vulkan12Features);
5569         VkPhysicalDeviceFeatures2                                                       extFeatures                                                             = initVulkanStructure(&vulkan11Features);
5570
5571         vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures);
5572
5573         log << TestLog::Message << vulkan11Features << TestLog::EndMessage;
5574         log << TestLog::Message << vulkan12Features << TestLog::EndMessage;
5575
5576         // Validate if proper VkPhysicalDeviceVulkanXXFeatures fields are set when corresponding extensions are present
5577         std::pair<std::pair<const char*,const char*>, VkBool32> extensions2validate[] =
5578         {
5579                 { { "VK_KHR_sampler_mirror_clamp_to_edge",      "VkPhysicalDeviceVulkan12Features.samplerMirrorClampToEdge" },  vulkan12Features.samplerMirrorClampToEdge },
5580                 { { "VK_KHR_draw_indirect_count",                       "VkPhysicalDeviceVulkan12Features.drawIndirectCount" },                 vulkan12Features.drawIndirectCount },
5581                 { { "VK_EXT_descriptor_indexing",                       "VkPhysicalDeviceVulkan12Features.descriptorIndexing" },                vulkan12Features.descriptorIndexing },
5582                 { { "VK_EXT_sampler_filter_minmax",                     "VkPhysicalDeviceVulkan12Features.samplerFilterMinmax" },               vulkan12Features.samplerFilterMinmax },
5583                 { { "VK_EXT_shader_viewport_index_layer",       "VkPhysicalDeviceVulkan12Features.shaderOutputViewportIndex" }, vulkan12Features.shaderOutputViewportIndex },
5584                 { { "VK_EXT_shader_viewport_index_layer",       "VkPhysicalDeviceVulkan12Features.shaderOutputLayer" },                 vulkan12Features.shaderOutputLayer }
5585         };
5586         vector<VkExtensionProperties> extensionProperties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL);
5587         for (const auto& ext : extensions2validate)
5588                 if (checkExtension(extensionProperties, ext.first.first) && !ext.second)
5589                         TCU_FAIL(string("Mismatch between extension ") + ext.first.first + " and " + ext.first.second);
5590
5591         // collect all extension features
5592         {
5593                 VkPhysicalDevice16BitStorageFeatures                            device16BitStorageFeatures                              = initVulkanStructure();
5594                 VkPhysicalDeviceMultiviewFeatures                                       deviceMultiviewFeatures                                 = initVulkanStructure(&device16BitStorageFeatures);
5595                 VkPhysicalDeviceProtectedMemoryFeatures                         protectedMemoryFeatures                                 = initVulkanStructure(&deviceMultiviewFeatures);
5596                 VkPhysicalDeviceSamplerYcbcrConversionFeatures          samplerYcbcrConversionFeatures                  = initVulkanStructure(&protectedMemoryFeatures);
5597                 VkPhysicalDeviceShaderDrawParametersFeatures            shaderDrawParametersFeatures                    = initVulkanStructure(&samplerYcbcrConversionFeatures);
5598                 VkPhysicalDeviceVariablePointersFeatures                        variablePointerFeatures                                 = initVulkanStructure(&shaderDrawParametersFeatures);
5599                 VkPhysicalDevice8BitStorageFeatures                                     device8BitStorageFeatures                               = initVulkanStructure(&variablePointerFeatures);
5600                 VkPhysicalDeviceShaderAtomicInt64Features                       shaderAtomicInt64Features                               = initVulkanStructure(&device8BitStorageFeatures);
5601                 VkPhysicalDeviceShaderFloat16Int8Features                       shaderFloat16Int8Features                               = initVulkanStructure(&shaderAtomicInt64Features);
5602                 VkPhysicalDeviceDescriptorIndexingFeatures                      descriptorIndexingFeatures                              = initVulkanStructure(&shaderFloat16Int8Features);
5603                 VkPhysicalDeviceScalarBlockLayoutFeatures                       scalarBlockLayoutFeatures                               = initVulkanStructure(&descriptorIndexingFeatures);
5604                 VkPhysicalDeviceImagelessFramebufferFeatures            imagelessFramebufferFeatures                    = initVulkanStructure(&scalarBlockLayoutFeatures);
5605                 VkPhysicalDeviceUniformBufferStandardLayoutFeatures     uniformBufferStandardLayoutFeatures             = initVulkanStructure(&imagelessFramebufferFeatures);
5606                 VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures     shaderSubgroupExtendedTypesFeatures             = initVulkanStructure(&uniformBufferStandardLayoutFeatures);
5607                 VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures     separateDepthStencilLayoutsFeatures             = initVulkanStructure(&shaderSubgroupExtendedTypesFeatures);
5608                 VkPhysicalDeviceHostQueryResetFeatures                          hostQueryResetFeatures                                  = initVulkanStructure(&separateDepthStencilLayoutsFeatures);
5609                 VkPhysicalDeviceTimelineSemaphoreFeatures                       timelineSemaphoreFeatures                               = initVulkanStructure(&hostQueryResetFeatures);
5610                 VkPhysicalDeviceBufferDeviceAddressFeatures                     bufferDeviceAddressFeatures                             = initVulkanStructure(&timelineSemaphoreFeatures);
5611                 VkPhysicalDeviceVulkanMemoryModelFeatures                       vulkanMemoryModelFeatures                               = initVulkanStructure(&bufferDeviceAddressFeatures);
5612                 extFeatures = initVulkanStructure(&vulkanMemoryModelFeatures);
5613
5614                 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures);
5615
5616                 log << TestLog::Message << extFeatures << TestLog::EndMessage;
5617                 log << TestLog::Message << device16BitStorageFeatures << TestLog::EndMessage;
5618                 log << TestLog::Message << deviceMultiviewFeatures << TestLog::EndMessage;
5619                 log << TestLog::Message << protectedMemoryFeatures << TestLog::EndMessage;
5620                 log << TestLog::Message << samplerYcbcrConversionFeatures << TestLog::EndMessage;
5621                 log << TestLog::Message << shaderDrawParametersFeatures << TestLog::EndMessage;
5622                 log << TestLog::Message << variablePointerFeatures << TestLog::EndMessage;
5623                 log << TestLog::Message << device8BitStorageFeatures << TestLog::EndMessage;
5624                 log << TestLog::Message << shaderAtomicInt64Features << TestLog::EndMessage;
5625                 log << TestLog::Message << shaderFloat16Int8Features << TestLog::EndMessage;
5626                 log << TestLog::Message << descriptorIndexingFeatures << TestLog::EndMessage;
5627                 log << TestLog::Message << scalarBlockLayoutFeatures << TestLog::EndMessage;
5628                 log << TestLog::Message << imagelessFramebufferFeatures << TestLog::EndMessage;
5629                 log << TestLog::Message << uniformBufferStandardLayoutFeatures << TestLog::EndMessage;
5630                 log << TestLog::Message << shaderSubgroupExtendedTypesFeatures << TestLog::EndMessage;
5631                 log << TestLog::Message << separateDepthStencilLayoutsFeatures << TestLog::EndMessage;
5632                 log << TestLog::Message << hostQueryResetFeatures << TestLog::EndMessage;
5633                 log << TestLog::Message << timelineSemaphoreFeatures << TestLog::EndMessage;
5634                 log << TestLog::Message << bufferDeviceAddressFeatures << TestLog::EndMessage;
5635                 log << TestLog::Message << vulkanMemoryModelFeatures << TestLog::EndMessage;
5636
5637                 if ((   device16BitStorageFeatures.storageBuffer16BitAccess                             != vulkan11Features.storageBuffer16BitAccess ||
5638                                 device16BitStorageFeatures.uniformAndStorageBuffer16BitAccess   != vulkan11Features.uniformAndStorageBuffer16BitAccess ||
5639                                 device16BitStorageFeatures.storagePushConstant16                                != vulkan11Features.storagePushConstant16 ||
5640                                 device16BitStorageFeatures.storageInputOutput16                                 != vulkan11Features.storageInputOutput16 ))
5641                 {
5642                         TCU_FAIL("Mismatch between VkPhysicalDevice16BitStorageFeatures and VkPhysicalDeviceVulkan11Features");
5643                 }
5644
5645                 if ((   deviceMultiviewFeatures.multiview                                       != vulkan11Features.multiview ||
5646                                 deviceMultiviewFeatures.multiviewGeometryShader         != vulkan11Features.multiviewGeometryShader ||
5647                                 deviceMultiviewFeatures.multiviewTessellationShader     != vulkan11Features.multiviewTessellationShader ))
5648                 {
5649                         TCU_FAIL("Mismatch between VkPhysicalDeviceMultiviewFeatures and VkPhysicalDeviceVulkan11Features");
5650                 }
5651
5652                 if (    (protectedMemoryFeatures.protectedMemory        != vulkan11Features.protectedMemory ))
5653                 {
5654                         TCU_FAIL("Mismatch between VkPhysicalDeviceProtectedMemoryFeatures and VkPhysicalDeviceVulkan11Features");
5655                 }
5656
5657                 if (    (samplerYcbcrConversionFeatures.samplerYcbcrConversion  != vulkan11Features.samplerYcbcrConversion ))
5658                 {
5659                         TCU_FAIL("Mismatch between VkPhysicalDeviceSamplerYcbcrConversionFeatures and VkPhysicalDeviceVulkan11Features");
5660                 }
5661
5662                 if (    (shaderDrawParametersFeatures.shaderDrawParameters      != vulkan11Features.shaderDrawParameters ))
5663                 {
5664                         TCU_FAIL("Mismatch between VkPhysicalDeviceShaderDrawParametersFeatures and VkPhysicalDeviceVulkan11Features");
5665                 }
5666
5667                 if ((   variablePointerFeatures.variablePointersStorageBuffer   != vulkan11Features.variablePointersStorageBuffer ||
5668                                 variablePointerFeatures.variablePointers                                != vulkan11Features.variablePointers))
5669                 {
5670                         TCU_FAIL("Mismatch between VkPhysicalDeviceVariablePointersFeatures and VkPhysicalDeviceVulkan11Features");
5671                 }
5672
5673                 if ((   device8BitStorageFeatures.storageBuffer8BitAccess                       != vulkan12Features.storageBuffer8BitAccess ||
5674                                 device8BitStorageFeatures.uniformAndStorageBuffer8BitAccess     != vulkan12Features.uniformAndStorageBuffer8BitAccess ||
5675                                 device8BitStorageFeatures.storagePushConstant8                          != vulkan12Features.storagePushConstant8 ))
5676                 {
5677                         TCU_FAIL("Mismatch between VkPhysicalDevice8BitStorageFeatures and VkPhysicalDeviceVulkan12Features");
5678                 }
5679
5680                 if ((   shaderAtomicInt64Features.shaderBufferInt64Atomics != vulkan12Features.shaderBufferInt64Atomics ||
5681                                 shaderAtomicInt64Features.shaderSharedInt64Atomics != vulkan12Features.shaderSharedInt64Atomics ))
5682                 {
5683                         TCU_FAIL("Mismatch between VkPhysicalDeviceShaderAtomicInt64Features and VkPhysicalDeviceVulkan12Features");
5684                 }
5685
5686                 if ((   shaderFloat16Int8Features.shaderFloat16 != vulkan12Features.shaderFloat16 ||
5687                                 shaderFloat16Int8Features.shaderInt8            != vulkan12Features.shaderInt8 ))
5688                 {
5689                         TCU_FAIL("Mismatch between VkPhysicalDeviceShaderFloat16Int8Features and VkPhysicalDeviceVulkan12Features");
5690                 }
5691
5692                 if ((vulkan12Features.descriptorIndexing) &&
5693                         (       descriptorIndexingFeatures.shaderInputAttachmentArrayDynamicIndexing                    != vulkan12Features.shaderInputAttachmentArrayDynamicIndexing ||
5694                                 descriptorIndexingFeatures.shaderUniformTexelBufferArrayDynamicIndexing                 != vulkan12Features.shaderUniformTexelBufferArrayDynamicIndexing ||
5695                                 descriptorIndexingFeatures.shaderStorageTexelBufferArrayDynamicIndexing                 != vulkan12Features.shaderStorageTexelBufferArrayDynamicIndexing ||
5696                                 descriptorIndexingFeatures.shaderUniformBufferArrayNonUniformIndexing                   != vulkan12Features.shaderUniformBufferArrayNonUniformIndexing ||
5697                                 descriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing                    != vulkan12Features.shaderSampledImageArrayNonUniformIndexing ||
5698                                 descriptorIndexingFeatures.shaderStorageBufferArrayNonUniformIndexing                   != vulkan12Features.shaderStorageBufferArrayNonUniformIndexing ||
5699                                 descriptorIndexingFeatures.shaderStorageImageArrayNonUniformIndexing                    != vulkan12Features.shaderStorageImageArrayNonUniformIndexing ||
5700                                 descriptorIndexingFeatures.shaderInputAttachmentArrayNonUniformIndexing                 != vulkan12Features.shaderInputAttachmentArrayNonUniformIndexing ||
5701                                 descriptorIndexingFeatures.shaderUniformTexelBufferArrayNonUniformIndexing              != vulkan12Features.shaderUniformTexelBufferArrayNonUniformIndexing ||
5702                                 descriptorIndexingFeatures.shaderStorageTexelBufferArrayNonUniformIndexing              != vulkan12Features.shaderStorageTexelBufferArrayNonUniformIndexing ||
5703                                 descriptorIndexingFeatures.descriptorBindingUniformBufferUpdateAfterBind                != vulkan12Features.descriptorBindingUniformBufferUpdateAfterBind ||
5704                                 descriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind                 != vulkan12Features.descriptorBindingSampledImageUpdateAfterBind ||
5705                                 descriptorIndexingFeatures.descriptorBindingStorageImageUpdateAfterBind                 != vulkan12Features.descriptorBindingStorageImageUpdateAfterBind ||
5706                                 descriptorIndexingFeatures.descriptorBindingStorageBufferUpdateAfterBind                != vulkan12Features.descriptorBindingStorageBufferUpdateAfterBind ||
5707                                 descriptorIndexingFeatures.descriptorBindingUniformTexelBufferUpdateAfterBind   != vulkan12Features.descriptorBindingUniformTexelBufferUpdateAfterBind ||
5708                                 descriptorIndexingFeatures.descriptorBindingStorageTexelBufferUpdateAfterBind   != vulkan12Features.descriptorBindingStorageTexelBufferUpdateAfterBind ||
5709                                 descriptorIndexingFeatures.descriptorBindingUpdateUnusedWhilePending                    != vulkan12Features.descriptorBindingUpdateUnusedWhilePending ||
5710                                 descriptorIndexingFeatures.descriptorBindingPartiallyBound                                              != vulkan12Features.descriptorBindingPartiallyBound ||
5711                                 descriptorIndexingFeatures.descriptorBindingVariableDescriptorCount                             != vulkan12Features.descriptorBindingVariableDescriptorCount ||
5712                                 descriptorIndexingFeatures.runtimeDescriptorArray                                                               != vulkan12Features.runtimeDescriptorArray ))
5713                 {
5714                         TCU_FAIL("Mismatch between VkPhysicalDeviceDescriptorIndexingFeatures and VkPhysicalDeviceVulkan12Features");
5715                 }
5716
5717                 if ((   scalarBlockLayoutFeatures.scalarBlockLayout != vulkan12Features.scalarBlockLayout ))
5718                 {
5719                         TCU_FAIL("Mismatch between VkPhysicalDeviceScalarBlockLayoutFeatures and VkPhysicalDeviceVulkan12Features");
5720                 }
5721
5722                 if ((   imagelessFramebufferFeatures.imagelessFramebuffer != vulkan12Features.imagelessFramebuffer ))
5723                 {
5724                         TCU_FAIL("Mismatch between VkPhysicalDeviceImagelessFramebufferFeatures and VkPhysicalDeviceVulkan12Features");
5725                 }
5726
5727                 if ((   uniformBufferStandardLayoutFeatures.uniformBufferStandardLayout != vulkan12Features.uniformBufferStandardLayout ))
5728                 {
5729                         TCU_FAIL("Mismatch between VkPhysicalDeviceUniformBufferStandardLayoutFeatures and VkPhysicalDeviceVulkan12Features");
5730                 }
5731
5732                 if ((   shaderSubgroupExtendedTypesFeatures.shaderSubgroupExtendedTypes != vulkan12Features.shaderSubgroupExtendedTypes ))
5733                 {
5734                         TCU_FAIL("Mismatch between VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures and VkPhysicalDeviceVulkan12Features");
5735                 }
5736
5737                 if ((   separateDepthStencilLayoutsFeatures.separateDepthStencilLayouts != vulkan12Features.separateDepthStencilLayouts ))
5738                 {
5739                         TCU_FAIL("Mismatch between VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures and VkPhysicalDeviceVulkan12Features");
5740                 }
5741
5742                 if ((   hostQueryResetFeatures.hostQueryReset != vulkan12Features.hostQueryReset ))
5743                 {
5744                         TCU_FAIL("Mismatch between VkPhysicalDeviceHostQueryResetFeatures and VkPhysicalDeviceVulkan12Features");
5745                 }
5746
5747                 if ((   timelineSemaphoreFeatures.timelineSemaphore != vulkan12Features.timelineSemaphore ))
5748                 {
5749                         TCU_FAIL("Mismatch between VkPhysicalDeviceTimelineSemaphoreFeatures and VkPhysicalDeviceVulkan12Features");
5750                 }
5751
5752                 if ((   bufferDeviceAddressFeatures.bufferDeviceAddress                                 != vulkan12Features.bufferDeviceAddress ||
5753                                 bufferDeviceAddressFeatures.bufferDeviceAddressCaptureReplay    != vulkan12Features.bufferDeviceAddressCaptureReplay ||
5754                                 bufferDeviceAddressFeatures.bufferDeviceAddressMultiDevice              != vulkan12Features.bufferDeviceAddressMultiDevice ))
5755                 {
5756                         TCU_FAIL("Mismatch between VkPhysicalDeviceBufferDeviceAddressFeatures and VkPhysicalDeviceVulkan12Features");
5757                 }
5758
5759                 if ((   vulkanMemoryModelFeatures.vulkanMemoryModel                                                             != vulkan12Features.vulkanMemoryModel ||
5760                                 vulkanMemoryModelFeatures.vulkanMemoryModelDeviceScope                                  != vulkan12Features.vulkanMemoryModelDeviceScope ||
5761                                 vulkanMemoryModelFeatures.vulkanMemoryModelAvailabilityVisibilityChains != vulkan12Features.vulkanMemoryModelAvailabilityVisibilityChains ))
5762                 {
5763                         TCU_FAIL("Mismatch between VkPhysicalDeviceVulkanMemoryModelFeatures and VkPhysicalDeviceVulkan12Features");
5764                 }
5765         }
5766
5767         return tcu::TestStatus::pass("Vulkan 1.2 device features are consistent with extensions");
5768 }
5769
5770 tcu::TestStatus deviceFeatureExtensionsConsistencyVulkan13(Context& context)
5771 {
5772         TestLog&                                                        log                                     = context.getTestContext().getLog();
5773         const VkPhysicalDevice                          physicalDevice          = context.getPhysicalDevice();
5774         const CustomInstance                            instance                        = createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2");
5775         const InstanceDriver&                           vki                                     = instance.getDriver();
5776
5777         if (!context.contextSupports(vk::ApiVersion(1, 3, 0)))
5778                 TCU_THROW(NotSupportedError, "At least Vulkan 1.3 required to run test");
5779
5780         VkPhysicalDeviceVulkan13Features                                        vulkan13Features                                = initVulkanStructure();
5781         VkPhysicalDeviceFeatures2                                                       extFeatures                                             = initVulkanStructure(&vulkan13Features);
5782
5783         vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures);
5784
5785         log << TestLog::Message << vulkan13Features << TestLog::EndMessage;
5786
5787         // Validate if required VkPhysicalDeviceVulkan13Features fields are set
5788         std::pair<const char*, VkBool32> features2validate[]
5789         {
5790                 { { "VkPhysicalDeviceVulkan13Features.robustImageAccess" },                                                                             vulkan13Features.robustImageAccess },
5791                 { { "VkPhysicalDeviceVulkan13Features.inlineUniformBlock" },                                                                    vulkan13Features.inlineUniformBlock },
5792                 { { "VkPhysicalDeviceVulkan13Features.pipelineCreationCacheControl" },                                                  vulkan13Features.pipelineCreationCacheControl },
5793                 { { "VkPhysicalDeviceVulkan13Features.privateData" },                                                                                   vulkan13Features.privateData },
5794                 { { "VkPhysicalDeviceVulkan13Features.shaderDemoteToHelperInvocation" },                                                vulkan13Features.shaderDemoteToHelperInvocation },
5795                 { { "VkPhysicalDeviceVulkan13Features.shaderTerminateInvocation" },                                                             vulkan13Features.shaderTerminateInvocation },
5796                 { { "VkPhysicalDeviceVulkan13Features.subgroupSizeControl" },                                                                   vulkan13Features.subgroupSizeControl },
5797                 { { "VkPhysicalDeviceVulkan13Features.computeFullSubgroups" },                                                                  vulkan13Features.computeFullSubgroups },
5798                 { { "VkPhysicalDeviceVulkan13Features.synchronization2" },                                                                              vulkan13Features.synchronization2 },
5799                 { { "VkPhysicalDeviceVulkan13Features.shaderZeroInitializeWorkgroupMemory" },                                   vulkan13Features.shaderZeroInitializeWorkgroupMemory },
5800                 { { "VkPhysicalDeviceVulkan13Features.dynamicRendering" },                                                                              vulkan13Features.dynamicRendering },
5801                 { { "VkPhysicalDeviceVulkan13Features.shaderIntegerDotProduct" },                                                               vulkan13Features.shaderIntegerDotProduct },
5802                 { { "VkPhysicalDeviceVulkan13Features.maintenance4" },                                                                                  vulkan13Features.maintenance4 },
5803         };
5804         for (const auto& feature : features2validate)
5805         {
5806                 if (!feature.second)
5807                         TCU_FAIL(string("Required feature ") + feature.first + " is not set");
5808         }
5809
5810         // collect all extension features
5811         {
5812                 VkPhysicalDeviceImageRobustnessFeatures                                 imageRobustnessFeatures                                 = initVulkanStructure();
5813                 VkPhysicalDeviceInlineUniformBlockFeatures                              inlineUniformBlockFeatures                              = initVulkanStructure(&imageRobustnessFeatures);
5814                 VkPhysicalDevicePipelineCreationCacheControlFeatures    pipelineCreationCacheControlFeatures    = initVulkanStructure(&inlineUniformBlockFeatures);
5815                 VkPhysicalDevicePrivateDataFeatures                                             privateDataFeatures                                             = initVulkanStructure(&pipelineCreationCacheControlFeatures);
5816                 VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures  shaderDemoteToHelperInvocationFeatures  = initVulkanStructure(&privateDataFeatures);
5817                 VkPhysicalDeviceShaderTerminateInvocationFeatures               shaderTerminateInvocationFeatures               = initVulkanStructure(&shaderDemoteToHelperInvocationFeatures);
5818                 VkPhysicalDeviceSubgroupSizeControlFeatures                             subgroupSizeControlFeatures                             = initVulkanStructure(&shaderTerminateInvocationFeatures);
5819                 VkPhysicalDeviceSynchronization2Features                                synchronization2Features                                = initVulkanStructure(&subgroupSizeControlFeatures);
5820                 VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures   zeroInitializeWorkgroupMemoryFeatures   = initVulkanStructure(&synchronization2Features);
5821                 VkPhysicalDeviceDynamicRenderingFeatures                                dynamicRenderingFeatures                                = initVulkanStructure(&zeroInitializeWorkgroupMemoryFeatures);
5822                 VkPhysicalDeviceShaderIntegerDotProductFeatures                 shaderIntegerDotProductFeatures                 = initVulkanStructure(&dynamicRenderingFeatures);
5823                 VkPhysicalDeviceMaintenance4Features                                    maintenance4Features                                    = initVulkanStructure(&shaderIntegerDotProductFeatures);
5824
5825                 // those two structures are part of extensions promoted in vk1.2 but now in 1.3 have required features
5826                 VkPhysicalDeviceVulkanMemoryModelFeatures                               vulkanMemoryModelFeatures                               = initVulkanStructure(&maintenance4Features);
5827                 VkPhysicalDeviceBufferDeviceAddressFeatures                             bufferDeviceAddressFeatures                             = initVulkanStructure(&vulkanMemoryModelFeatures);
5828
5829                 extFeatures = initVulkanStructure(&bufferDeviceAddressFeatures);
5830
5831                 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures);
5832
5833                 log << TestLog::Message << extFeatures << TestLog::EndMessage;
5834                 log << TestLog::Message << imageRobustnessFeatures << TestLog::EndMessage;
5835                 log << TestLog::Message << inlineUniformBlockFeatures << TestLog::EndMessage;
5836                 log << TestLog::Message << pipelineCreationCacheControlFeatures << TestLog::EndMessage;
5837                 log << TestLog::Message << privateDataFeatures << TestLog::EndMessage;
5838                 log << TestLog::Message << shaderDemoteToHelperInvocationFeatures << TestLog::EndMessage;
5839                 log << TestLog::Message << shaderTerminateInvocationFeatures << TestLog::EndMessage;
5840                 log << TestLog::Message << subgroupSizeControlFeatures << TestLog::EndMessage;
5841                 log << TestLog::Message << synchronization2Features << TestLog::EndMessage;
5842                 log << TestLog::Message << zeroInitializeWorkgroupMemoryFeatures << TestLog::EndMessage;
5843                 log << TestLog::Message << dynamicRenderingFeatures << TestLog::EndMessage;
5844                 log << TestLog::Message << shaderIntegerDotProductFeatures << TestLog::EndMessage;
5845                 log << TestLog::Message << maintenance4Features << TestLog::EndMessage;
5846
5847                 if (imageRobustnessFeatures.robustImageAccess != vulkan13Features.robustImageAccess)
5848                         TCU_FAIL("Mismatch between VkPhysicalDeviceImageRobustnessFeatures and VkPhysicalDeviceVulkan13Features");
5849
5850                 if ((inlineUniformBlockFeatures.inlineUniformBlock != vulkan13Features.inlineUniformBlock) ||
5851                         (inlineUniformBlockFeatures.descriptorBindingInlineUniformBlockUpdateAfterBind != vulkan13Features.descriptorBindingInlineUniformBlockUpdateAfterBind))
5852                 {
5853                         TCU_FAIL("Mismatch between VkPhysicalDeviceInlineUniformBlockFeatures and VkPhysicalDeviceVulkan13Features");
5854                 }
5855
5856                 if (pipelineCreationCacheControlFeatures.pipelineCreationCacheControl != vulkan13Features.pipelineCreationCacheControl)
5857                         TCU_FAIL("Mismatch between VkPhysicalDevicePipelineCreationCacheControlFeatures and VkPhysicalDeviceVulkan13Features");
5858
5859                 if (privateDataFeatures.privateData != vulkan13Features.privateData)
5860                         TCU_FAIL("Mismatch between VkPhysicalDevicePrivateDataFeatures and VkPhysicalDeviceVulkan13Features");
5861
5862                 if (shaderDemoteToHelperInvocationFeatures.shaderDemoteToHelperInvocation != vulkan13Features.shaderDemoteToHelperInvocation)
5863                         TCU_FAIL("Mismatch between VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures and VkPhysicalDeviceVulkan13Features");
5864
5865                 if (shaderTerminateInvocationFeatures.shaderTerminateInvocation != vulkan13Features.shaderTerminateInvocation)
5866                         TCU_FAIL("Mismatch between VkPhysicalDeviceShaderTerminateInvocationFeatures and VkPhysicalDeviceVulkan13Features");
5867
5868                 if ((subgroupSizeControlFeatures.subgroupSizeControl != vulkan13Features.subgroupSizeControl) ||
5869                         (subgroupSizeControlFeatures.computeFullSubgroups != vulkan13Features.computeFullSubgroups))
5870                 {
5871                         TCU_FAIL("Mismatch between VkPhysicalDeviceSubgroupSizeControlFeatures and VkPhysicalDeviceVulkan13Features");
5872                 }
5873
5874                 if (synchronization2Features.synchronization2 != vulkan13Features.synchronization2)
5875                         TCU_FAIL("Mismatch between VkPhysicalDeviceSynchronization2Features and VkPhysicalDeviceVulkan13Features");
5876
5877                 if (zeroInitializeWorkgroupMemoryFeatures.shaderZeroInitializeWorkgroupMemory != vulkan13Features.shaderZeroInitializeWorkgroupMemory)
5878                         TCU_FAIL("Mismatch between VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures and VkPhysicalDeviceVulkan13Features");
5879
5880                 if (dynamicRenderingFeatures.dynamicRendering != vulkan13Features.dynamicRendering)
5881                         TCU_FAIL("Mismatch between VkPhysicalDeviceDynamicRenderingFeatures and VkPhysicalDeviceVulkan13Features");
5882
5883                 if (shaderIntegerDotProductFeatures.shaderIntegerDotProduct != vulkan13Features.shaderIntegerDotProduct)
5884                         TCU_FAIL("Mismatch between VkPhysicalDeviceShaderIntegerDotProductFeatures and VkPhysicalDeviceVulkan13Features");
5885
5886                 if (maintenance4Features.maintenance4 != vulkan13Features.maintenance4)
5887                         TCU_FAIL("Mismatch between VkPhysicalDeviceMaintenance4Features and VkPhysicalDeviceVulkan13Features");
5888
5889                 // check required features from extensions that were promoted in earlier vulkan version
5890                 if (!vulkanMemoryModelFeatures.vulkanMemoryModel)
5891                         TCU_FAIL("vulkanMemoryModel feature from VkPhysicalDeviceVulkanMemoryModelFeatures is required");
5892                 if (!vulkanMemoryModelFeatures.vulkanMemoryModelDeviceScope)
5893                         TCU_FAIL("vulkanMemoryModelDeviceScope feature from VkPhysicalDeviceVulkanMemoryModelFeatures is required");
5894                 if (!bufferDeviceAddressFeatures.bufferDeviceAddress)
5895                         TCU_FAIL("bufferDeviceAddress feature from VkPhysicalDeviceBufferDeviceAddressFeatures is required");
5896         }
5897
5898         return tcu::TestStatus::pass("Vulkan 1.3 device features are consistent with extensions");
5899 }
5900
5901 tcu::TestStatus devicePropertyExtensionsConsistencyVulkan12(Context& context)
5902 {
5903         TestLog&                                                                                log                                                                                     = context.getTestContext().getLog();
5904         const CustomInstance                                                    instance                                                                        (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
5905         const InstanceDriver&                                                   vki                                                                                     = instance.getDriver();
5906         const VkPhysicalDevice                                                  physicalDevice                                                          (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
5907
5908         if (!context.contextSupports(vk::ApiVersion(1, 2, 0)))
5909                 TCU_THROW(NotSupportedError, "At least Vulkan 1.2 required to run test");
5910
5911         VkPhysicalDeviceVulkan12Properties                              vulkan12Properties                                                      = initVulkanStructure();
5912         VkPhysicalDeviceVulkan11Properties                              vulkan11Properties                                                      = initVulkanStructure(&vulkan12Properties);
5913         VkPhysicalDeviceProperties2                                             extProperties                                                           = initVulkanStructure(&vulkan11Properties);
5914
5915         vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
5916
5917         log << TestLog::Message << vulkan11Properties << TestLog::EndMessage;
5918         log << TestLog::Message << vulkan12Properties << TestLog::EndMessage;
5919
5920         // Validate all fields initialized matching to extension structures
5921         {
5922                 VkPhysicalDeviceIDProperties                                    idProperties                                                            = initVulkanStructure();
5923                 VkPhysicalDeviceSubgroupProperties                              subgroupProperties                                                      = initVulkanStructure(&idProperties);
5924                 VkPhysicalDevicePointClippingProperties                 pointClippingProperties                                         = initVulkanStructure(&subgroupProperties);
5925                 VkPhysicalDeviceMultiviewProperties                             multiviewProperties                                                     = initVulkanStructure(&pointClippingProperties);
5926                 VkPhysicalDeviceProtectedMemoryProperties               protectedMemoryPropertiesKHR                            = initVulkanStructure(&multiviewProperties);
5927                 VkPhysicalDeviceMaintenance3Properties                  maintenance3Properties                                          = initVulkanStructure(&protectedMemoryPropertiesKHR);
5928                 VkPhysicalDeviceDriverProperties                                driverProperties                                                        = initVulkanStructure(&maintenance3Properties);
5929                 VkPhysicalDeviceFloatControlsProperties                 floatControlsProperties                                         = initVulkanStructure(&driverProperties);
5930                 VkPhysicalDeviceDescriptorIndexingProperties    descriptorIndexingProperties                            = initVulkanStructure(&floatControlsProperties);
5931                 VkPhysicalDeviceDepthStencilResolveProperties   depthStencilResolveProperties                           = initVulkanStructure(&descriptorIndexingProperties);
5932                 VkPhysicalDeviceSamplerFilterMinmaxProperties   samplerFilterMinmaxProperties                           = initVulkanStructure(&depthStencilResolveProperties);
5933                 VkPhysicalDeviceTimelineSemaphoreProperties             timelineSemaphoreProperties                                     = initVulkanStructure(&samplerFilterMinmaxProperties);
5934                 extProperties = initVulkanStructure(&timelineSemaphoreProperties);
5935
5936                 vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
5937
5938                 if ((deMemCmp(idProperties.deviceUUID, vulkan11Properties.deviceUUID, VK_UUID_SIZE) != 0) ||
5939                         (deMemCmp(idProperties.driverUUID, vulkan11Properties.driverUUID, VK_UUID_SIZE) != 0) ||
5940                         (idProperties.deviceLUIDValid != vulkan11Properties.deviceLUIDValid))
5941                 {
5942                         TCU_FAIL("Mismatch between VkPhysicalDeviceIDProperties and VkPhysicalDeviceVulkan11Properties");
5943                 }
5944                 else if (idProperties.deviceLUIDValid)
5945                 {
5946                         // If deviceLUIDValid is VK_FALSE, the contents of deviceLUID and deviceNodeMask are undefined
5947                         // so thay can only be compared when deviceLUIDValid is VK_TRUE.
5948                         if ((deMemCmp(idProperties.deviceLUID, vulkan11Properties.deviceLUID, VK_LUID_SIZE) != 0) ||
5949                                 (idProperties.deviceNodeMask != vulkan11Properties.deviceNodeMask))
5950                         {
5951                                 TCU_FAIL("Mismatch between VkPhysicalDeviceIDProperties and VkPhysicalDeviceVulkan11Properties");
5952                         }
5953                 }
5954
5955                 if ((subgroupProperties.subgroupSize                            != vulkan11Properties.subgroupSize ||
5956                          subgroupProperties.supportedStages                             != vulkan11Properties.subgroupSupportedStages ||
5957                          subgroupProperties.supportedOperations                 != vulkan11Properties.subgroupSupportedOperations ||
5958                          subgroupProperties.quadOperationsInAllStages   != vulkan11Properties.subgroupQuadOperationsInAllStages))
5959                 {
5960                         TCU_FAIL("Mismatch between VkPhysicalDeviceSubgroupProperties and VkPhysicalDeviceVulkan11Properties");
5961                 }
5962
5963                 if ((pointClippingProperties.pointClippingBehavior      != vulkan11Properties.pointClippingBehavior))
5964                 {
5965                         TCU_FAIL("Mismatch between VkPhysicalDevicePointClippingProperties and VkPhysicalDeviceVulkan11Properties");
5966                 }
5967
5968                 if ((multiviewProperties.maxMultiviewViewCount          != vulkan11Properties.maxMultiviewViewCount ||
5969                          multiviewProperties.maxMultiviewInstanceIndex  != vulkan11Properties.maxMultiviewInstanceIndex))
5970                 {
5971                         TCU_FAIL("Mismatch between VkPhysicalDeviceMultiviewProperties and VkPhysicalDeviceVulkan11Properties");
5972                 }
5973
5974                 if ((protectedMemoryPropertiesKHR.protectedNoFault      != vulkan11Properties.protectedNoFault))
5975                 {
5976                         TCU_FAIL("Mismatch between VkPhysicalDeviceProtectedMemoryProperties and VkPhysicalDeviceVulkan11Properties");
5977                 }
5978
5979                 if ((maintenance3Properties.maxPerSetDescriptors        != vulkan11Properties.maxPerSetDescriptors ||
5980                          maintenance3Properties.maxMemoryAllocationSize != vulkan11Properties.maxMemoryAllocationSize))
5981                 {
5982                         TCU_FAIL("Mismatch between VkPhysicalDeviceMaintenance3Properties and VkPhysicalDeviceVulkan11Properties");
5983                 }
5984
5985                 if ((driverProperties.driverID                                                                                          != vulkan12Properties.driverID ||
5986                          strncmp(driverProperties.driverName, vulkan12Properties.driverName, VK_MAX_DRIVER_NAME_SIZE)   != 0 ||
5987                          strncmp(driverProperties.driverInfo, vulkan12Properties.driverInfo, VK_MAX_DRIVER_INFO_SIZE)   != 0 ||
5988                          driverProperties.conformanceVersion.major                                                              != vulkan12Properties.conformanceVersion.major ||
5989                          driverProperties.conformanceVersion.minor                                                              != vulkan12Properties.conformanceVersion.minor ||
5990                          driverProperties.conformanceVersion.subminor                                                   != vulkan12Properties.conformanceVersion.subminor ||
5991                          driverProperties.conformanceVersion.patch                                                              != vulkan12Properties.conformanceVersion.patch))
5992                 {
5993                         TCU_FAIL("Mismatch between VkPhysicalDeviceDriverProperties and VkPhysicalDeviceVulkan12Properties");
5994                 }
5995
5996                 if ((floatControlsProperties.denormBehaviorIndependence                         != vulkan12Properties.denormBehaviorIndependence ||
5997                          floatControlsProperties.roundingModeIndependence                               != vulkan12Properties.roundingModeIndependence ||
5998                          floatControlsProperties.shaderSignedZeroInfNanPreserveFloat16  != vulkan12Properties.shaderSignedZeroInfNanPreserveFloat16 ||
5999                          floatControlsProperties.shaderSignedZeroInfNanPreserveFloat32  != vulkan12Properties.shaderSignedZeroInfNanPreserveFloat32 ||
6000                          floatControlsProperties.shaderSignedZeroInfNanPreserveFloat64  != vulkan12Properties.shaderSignedZeroInfNanPreserveFloat64 ||
6001                          floatControlsProperties.shaderDenormPreserveFloat16                    != vulkan12Properties.shaderDenormPreserveFloat16 ||
6002                          floatControlsProperties.shaderDenormPreserveFloat32                    != vulkan12Properties.shaderDenormPreserveFloat32 ||
6003                          floatControlsProperties.shaderDenormPreserveFloat64                    != vulkan12Properties.shaderDenormPreserveFloat64 ||
6004                          floatControlsProperties.shaderDenormFlushToZeroFloat16                 != vulkan12Properties.shaderDenormFlushToZeroFloat16 ||
6005                          floatControlsProperties.shaderDenormFlushToZeroFloat32                 != vulkan12Properties.shaderDenormFlushToZeroFloat32 ||
6006                          floatControlsProperties.shaderDenormFlushToZeroFloat64                 != vulkan12Properties.shaderDenormFlushToZeroFloat64 ||
6007                          floatControlsProperties.shaderRoundingModeRTEFloat16                   != vulkan12Properties.shaderRoundingModeRTEFloat16 ||
6008                          floatControlsProperties.shaderRoundingModeRTEFloat32                   != vulkan12Properties.shaderRoundingModeRTEFloat32 ||
6009                          floatControlsProperties.shaderRoundingModeRTEFloat64                   != vulkan12Properties.shaderRoundingModeRTEFloat64 ||
6010                          floatControlsProperties.shaderRoundingModeRTZFloat16                   != vulkan12Properties.shaderRoundingModeRTZFloat16 ||
6011                          floatControlsProperties.shaderRoundingModeRTZFloat32                   != vulkan12Properties.shaderRoundingModeRTZFloat32 ||
6012                          floatControlsProperties.shaderRoundingModeRTZFloat64                   != vulkan12Properties.shaderRoundingModeRTZFloat64 ))
6013                 {
6014                         TCU_FAIL("Mismatch between VkPhysicalDeviceFloatControlsProperties and VkPhysicalDeviceVulkan12Properties");
6015                 }
6016
6017                 if ((descriptorIndexingProperties.maxUpdateAfterBindDescriptorsInAllPools                               != vulkan12Properties.maxUpdateAfterBindDescriptorsInAllPools ||
6018                          descriptorIndexingProperties.shaderUniformBufferArrayNonUniformIndexingNative          != vulkan12Properties.shaderUniformBufferArrayNonUniformIndexingNative ||
6019                          descriptorIndexingProperties.shaderSampledImageArrayNonUniformIndexingNative           != vulkan12Properties.shaderSampledImageArrayNonUniformIndexingNative ||
6020                          descriptorIndexingProperties.shaderStorageBufferArrayNonUniformIndexingNative          != vulkan12Properties.shaderStorageBufferArrayNonUniformIndexingNative ||
6021                          descriptorIndexingProperties.shaderStorageImageArrayNonUniformIndexingNative           != vulkan12Properties.shaderStorageImageArrayNonUniformIndexingNative ||
6022                          descriptorIndexingProperties.shaderInputAttachmentArrayNonUniformIndexingNative        != vulkan12Properties.shaderInputAttachmentArrayNonUniformIndexingNative ||
6023                          descriptorIndexingProperties.robustBufferAccessUpdateAfterBind                                         != vulkan12Properties.robustBufferAccessUpdateAfterBind ||
6024                          descriptorIndexingProperties.quadDivergentImplicitLod                                                          != vulkan12Properties.quadDivergentImplicitLod ||
6025                          descriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSamplers                      != vulkan12Properties.maxPerStageDescriptorUpdateAfterBindSamplers ||
6026                          descriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindUniformBuffers        != vulkan12Properties.maxPerStageDescriptorUpdateAfterBindUniformBuffers ||
6027                          descriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageBuffers        != vulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageBuffers ||
6028                          descriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSampledImages         != vulkan12Properties.maxPerStageDescriptorUpdateAfterBindSampledImages ||
6029                          descriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageImages         != vulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageImages ||
6030                          descriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindInputAttachments      != vulkan12Properties.maxPerStageDescriptorUpdateAfterBindInputAttachments ||
6031                          descriptorIndexingProperties.maxPerStageUpdateAfterBindResources                                       != vulkan12Properties.maxPerStageUpdateAfterBindResources ||
6032                          descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSamplers                           != vulkan12Properties.maxDescriptorSetUpdateAfterBindSamplers ||
6033                          descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffers                     != vulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffers ||
6034                          descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic      != vulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ||
6035                          descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffers                     != vulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffers ||
6036                          descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic      != vulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ||
6037                          descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSampledImages                      != vulkan12Properties.maxDescriptorSetUpdateAfterBindSampledImages ||
6038                          descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageImages                      != vulkan12Properties.maxDescriptorSetUpdateAfterBindStorageImages ||
6039                          descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindInputAttachments           != vulkan12Properties.maxDescriptorSetUpdateAfterBindInputAttachments ))
6040                 {
6041                         TCU_FAIL("Mismatch between VkPhysicalDeviceDescriptorIndexingProperties and VkPhysicalDeviceVulkan12Properties");
6042                 }
6043
6044                 if ((depthStencilResolveProperties.supportedDepthResolveModes   != vulkan12Properties.supportedDepthResolveModes ||
6045                          depthStencilResolveProperties.supportedStencilResolveModes     != vulkan12Properties.supportedStencilResolveModes ||
6046                          depthStencilResolveProperties.independentResolveNone           != vulkan12Properties.independentResolveNone ||
6047                          depthStencilResolveProperties.independentResolve                       != vulkan12Properties.independentResolve))
6048                 {
6049                         TCU_FAIL("Mismatch between VkPhysicalDeviceDepthStencilResolveProperties and VkPhysicalDeviceVulkan12Properties");
6050                 }
6051
6052                 if ((samplerFilterMinmaxProperties.filterMinmaxSingleComponentFormats   != vulkan12Properties.filterMinmaxSingleComponentFormats ||
6053                          samplerFilterMinmaxProperties.filterMinmaxImageComponentMapping        != vulkan12Properties.filterMinmaxImageComponentMapping))
6054                 {
6055                         TCU_FAIL("Mismatch between VkPhysicalDeviceSamplerFilterMinmaxProperties and VkPhysicalDeviceVulkan12Properties");
6056                 }
6057
6058                 if ((timelineSemaphoreProperties.maxTimelineSemaphoreValueDifference    != vulkan12Properties.maxTimelineSemaphoreValueDifference))
6059                 {
6060                         TCU_FAIL("Mismatch between VkPhysicalDeviceTimelineSemaphoreProperties and VkPhysicalDeviceVulkan12Properties");
6061                 }
6062         }
6063
6064         return tcu::TestStatus::pass("Vulkan 1.2 device properties are consistent with extension properties");
6065 }
6066
6067 tcu::TestStatus devicePropertyExtensionsConsistencyVulkan13(Context& context)
6068 {
6069         TestLog&                                        log                                     = context.getTestContext().getLog();
6070         const VkPhysicalDevice          physicalDevice          = context.getPhysicalDevice();
6071         const CustomInstance            instance                        = createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2");
6072         const InstanceDriver&           vki                                     = instance.getDriver();
6073
6074         if (!context.contextSupports(vk::ApiVersion(1, 3, 0)))
6075                 TCU_THROW(NotSupportedError, "At least Vulkan 1.3 required to run test");
6076
6077         VkPhysicalDeviceVulkan13Properties              vulkan13Properties              = initVulkanStructure();
6078         VkPhysicalDeviceProperties2                             extProperties                   = initVulkanStructure(&vulkan13Properties);
6079
6080         vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
6081
6082         log << TestLog::Message << vulkan13Properties << TestLog::EndMessage;
6083
6084         // Validate all fields initialized matching to extension structures
6085         {
6086                 VkPhysicalDeviceSubgroupSizeControlProperties           subgroupSizeControlProperties           = initVulkanStructure();
6087                 VkPhysicalDeviceInlineUniformBlockProperties            inlineUniformBlockProperties            = initVulkanStructure(&subgroupSizeControlProperties);
6088                 VkPhysicalDeviceShaderIntegerDotProductProperties       shaderIntegerDotProductProperties       = initVulkanStructure(&inlineUniformBlockProperties);
6089                 VkPhysicalDeviceTexelBufferAlignmentProperties          texelBufferAlignmentProperties          = initVulkanStructure(&shaderIntegerDotProductProperties);
6090                 VkPhysicalDeviceMaintenance4Properties                          maintenance4Properties                          = initVulkanStructure(&texelBufferAlignmentProperties);
6091                 extProperties = initVulkanStructure(&maintenance4Properties);
6092
6093                 vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
6094
6095                 if (subgroupSizeControlProperties.minSubgroupSize                               != vulkan13Properties.minSubgroupSize ||
6096                         subgroupSizeControlProperties.maxSubgroupSize                           != vulkan13Properties.maxSubgroupSize ||
6097                         subgroupSizeControlProperties.maxComputeWorkgroupSubgroups      != vulkan13Properties.maxComputeWorkgroupSubgroups ||
6098                         subgroupSizeControlProperties.requiredSubgroupSizeStages        != vulkan13Properties.requiredSubgroupSizeStages)
6099                 {
6100                         TCU_FAIL("Mismatch between VkPhysicalDeviceSubgroupSizeControlProperties and VkPhysicalDeviceVulkan13Properties");
6101                 }
6102
6103                 if (inlineUniformBlockProperties.maxInlineUniformBlockSize                                                                      != vulkan13Properties.maxInlineUniformBlockSize ||
6104                         inlineUniformBlockProperties.maxPerStageDescriptorInlineUniformBlocks                                   != vulkan13Properties.maxPerStageDescriptorInlineUniformBlocks ||
6105                         inlineUniformBlockProperties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks    != vulkan13Properties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ||
6106                         inlineUniformBlockProperties.maxDescriptorSetInlineUniformBlocks                                                != vulkan13Properties.maxDescriptorSetInlineUniformBlocks ||
6107                         inlineUniformBlockProperties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks                 != vulkan13Properties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks)
6108                 {
6109                         TCU_FAIL("Mismatch between VkPhysicalDeviceInlineUniformBlockProperties and VkPhysicalDeviceVulkan13Properties");
6110                 }
6111
6112                 if (shaderIntegerDotProductProperties.integerDotProduct8BitUnsignedAccelerated                                                                                  != vulkan13Properties.integerDotProduct8BitUnsignedAccelerated ||
6113                         shaderIntegerDotProductProperties.integerDotProduct8BitSignedAccelerated                                                                                        != vulkan13Properties.integerDotProduct8BitSignedAccelerated ||
6114                         shaderIntegerDotProductProperties.integerDotProduct8BitMixedSignednessAccelerated                                                                       != vulkan13Properties.integerDotProduct8BitMixedSignednessAccelerated ||
6115                         shaderIntegerDotProductProperties.integerDotProduct4x8BitPackedUnsignedAccelerated                                                                      != vulkan13Properties.integerDotProduct4x8BitPackedUnsignedAccelerated ||
6116                         shaderIntegerDotProductProperties.integerDotProduct4x8BitPackedSignedAccelerated                                                                        != vulkan13Properties.integerDotProduct4x8BitPackedSignedAccelerated ||
6117                         shaderIntegerDotProductProperties.integerDotProduct4x8BitPackedMixedSignednessAccelerated                                                       != vulkan13Properties.integerDotProduct4x8BitPackedMixedSignednessAccelerated ||
6118                         shaderIntegerDotProductProperties.integerDotProduct16BitUnsignedAccelerated                                                                                     != vulkan13Properties.integerDotProduct16BitUnsignedAccelerated ||
6119                         shaderIntegerDotProductProperties.integerDotProduct16BitSignedAccelerated                                                                                       != vulkan13Properties.integerDotProduct16BitSignedAccelerated ||
6120                         shaderIntegerDotProductProperties.integerDotProduct16BitMixedSignednessAccelerated                                                                      != vulkan13Properties.integerDotProduct16BitMixedSignednessAccelerated ||
6121                         shaderIntegerDotProductProperties.integerDotProduct32BitUnsignedAccelerated                                                                                     != vulkan13Properties.integerDotProduct32BitUnsignedAccelerated ||
6122                         shaderIntegerDotProductProperties.integerDotProduct32BitSignedAccelerated                                                                                       != vulkan13Properties.integerDotProduct32BitSignedAccelerated ||
6123                         shaderIntegerDotProductProperties.integerDotProduct32BitMixedSignednessAccelerated                                                                      != vulkan13Properties.integerDotProduct32BitMixedSignednessAccelerated ||
6124                         shaderIntegerDotProductProperties.integerDotProduct64BitUnsignedAccelerated                                                                                     != vulkan13Properties.integerDotProduct64BitUnsignedAccelerated ||
6125                         shaderIntegerDotProductProperties.integerDotProduct64BitSignedAccelerated                                                                                       != vulkan13Properties.integerDotProduct64BitSignedAccelerated ||
6126                         shaderIntegerDotProductProperties.integerDotProduct64BitMixedSignednessAccelerated                                                                      != vulkan13Properties.integerDotProduct64BitMixedSignednessAccelerated ||
6127                         shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated                                        != vulkan13Properties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ||
6128                         shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitSignedAccelerated                                          != vulkan13Properties.integerDotProductAccumulatingSaturating8BitSignedAccelerated ||
6129                         shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated                         != vulkan13Properties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ||
6130                         shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated                        != vulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ||
6131                         shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated                          != vulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ||
6132                         shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated         != vulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ||
6133                         shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated                                       != vulkan13Properties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ||
6134                         shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitSignedAccelerated                                         != vulkan13Properties.integerDotProductAccumulatingSaturating16BitSignedAccelerated ||
6135                         shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated                        != vulkan13Properties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ||
6136                         shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated                                       != vulkan13Properties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ||
6137                         shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitSignedAccelerated                                         != vulkan13Properties.integerDotProductAccumulatingSaturating32BitSignedAccelerated ||
6138                         shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated                        != vulkan13Properties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ||
6139                         shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated                                       != vulkan13Properties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ||
6140                         shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitSignedAccelerated                                         != vulkan13Properties.integerDotProductAccumulatingSaturating64BitSignedAccelerated ||
6141                         shaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated                        != vulkan13Properties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated)
6142                 {
6143                         TCU_FAIL("Mismatch between VkPhysicalDeviceShaderIntegerDotProductProperties and VkPhysicalDeviceVulkan13Properties");
6144                 }
6145
6146                 if (texelBufferAlignmentProperties.storageTexelBufferOffsetAlignmentBytes               != vulkan13Properties.storageTexelBufferOffsetAlignmentBytes ||
6147                         texelBufferAlignmentProperties.storageTexelBufferOffsetSingleTexelAlignment     != vulkan13Properties.storageTexelBufferOffsetSingleTexelAlignment ||
6148                         texelBufferAlignmentProperties.uniformTexelBufferOffsetAlignmentBytes           != vulkan13Properties.uniformTexelBufferOffsetAlignmentBytes ||
6149                         texelBufferAlignmentProperties.uniformTexelBufferOffsetSingleTexelAlignment     != vulkan13Properties.uniformTexelBufferOffsetSingleTexelAlignment)
6150                 {
6151                         TCU_FAIL("Mismatch between VkPhysicalDeviceTexelBufferAlignmentProperties and VkPhysicalDeviceVulkan13Properties");
6152                 }
6153
6154                 if (maintenance4Properties.maxBufferSize != vulkan13Properties.maxBufferSize)
6155                 {
6156                         TCU_FAIL("Mismatch between VkPhysicalDeviceMaintenance4Properties and VkPhysicalDeviceVulkan13Properties");
6157                 }
6158         }
6159
6160         return tcu::TestStatus::pass("Vulkan 1.3 device properties are consistent with extension properties");
6161 }
6162
6163 tcu::TestStatus imageFormatProperties2 (Context& context, const VkFormat format, const VkImageType imageType, const VkImageTiling tiling)
6164 {
6165         if (isYCbCrFormat(format))
6166                 // check if Ycbcr format enums are valid given the version and extensions
6167                 checkYcbcrApiSupport(context);
6168
6169         TestLog&                                                log                             = context.getTestContext().getLog();
6170
6171         const CustomInstance                    instance                (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
6172         const InstanceDriver&                   vki                             (instance.getDriver());
6173         const VkPhysicalDevice                  physicalDevice  (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
6174
6175         const VkImageCreateFlags                ycbcrFlags              = isYCbCrFormat(format) ? (VkImageCreateFlags)VK_IMAGE_CREATE_DISJOINT_BIT_KHR : (VkImageCreateFlags)0u;
6176         const VkImageUsageFlags                 allUsageFlags   = VK_IMAGE_USAGE_TRANSFER_SRC_BIT
6177                                                                                                         | VK_IMAGE_USAGE_TRANSFER_DST_BIT
6178                                                                                                         | VK_IMAGE_USAGE_SAMPLED_BIT
6179                                                                                                         | VK_IMAGE_USAGE_STORAGE_BIT
6180                                                                                                         | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
6181                                                                                                         | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
6182                                                                                                         | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT
6183                                                                                                         | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
6184         const VkImageCreateFlags                allCreateFlags  = VK_IMAGE_CREATE_SPARSE_BINDING_BIT
6185                                                                                                         | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
6186                                                                                                         | VK_IMAGE_CREATE_SPARSE_ALIASED_BIT
6187                                                                                                         | VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT
6188                                                                                                         | VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT
6189                                                                                                         | ycbcrFlags;
6190
6191         for (VkImageUsageFlags curUsageFlags = (VkImageUsageFlags)1; curUsageFlags <= allUsageFlags; curUsageFlags++)
6192         {
6193                 if (!isValidImageUsageFlagCombination(curUsageFlags))
6194                         continue;
6195
6196                 for (VkImageCreateFlags curCreateFlags = 0; curCreateFlags <= allCreateFlags; curCreateFlags++)
6197                 {
6198                         const VkPhysicalDeviceImageFormatInfo2  imageFormatInfo =
6199                         {
6200                                 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
6201                                 DE_NULL,
6202                                 format,
6203                                 imageType,
6204                                 tiling,
6205                                 curUsageFlags,
6206                                 curCreateFlags
6207                         };
6208
6209                         VkImageFormatProperties                                         coreProperties;
6210                         VkImageFormatProperties2                                        extProperties;
6211                         VkResult                                                                        coreResult;
6212                         VkResult                                                                        extResult;
6213
6214                         deMemset(&coreProperties, 0xcd, sizeof(VkImageFormatProperties));
6215                         deMemset(&extProperties, 0xcd, sizeof(VkImageFormatProperties2));
6216
6217                         extProperties.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
6218                         extProperties.pNext = DE_NULL;
6219
6220                         coreResult      = vki.getPhysicalDeviceImageFormatProperties(physicalDevice, imageFormatInfo.format, imageFormatInfo.type, imageFormatInfo.tiling, imageFormatInfo.usage, imageFormatInfo.flags, &coreProperties);
6221                         extResult       = vki.getPhysicalDeviceImageFormatProperties2(physicalDevice, &imageFormatInfo, &extProperties);
6222
6223                         TCU_CHECK(extProperties.sType == VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2);
6224                         TCU_CHECK(extProperties.pNext == DE_NULL);
6225
6226                         if ((coreResult != extResult) ||
6227                                 (deMemCmp(&coreProperties, &extProperties.imageFormatProperties, sizeof(VkImageFormatProperties)) != 0))
6228                         {
6229                                 log << TestLog::Message << "ERROR: device mismatch with query " << imageFormatInfo << TestLog::EndMessage
6230                                         << TestLog::Message << "vkGetPhysicalDeviceImageFormatProperties() returned " << coreResult << ", " << coreProperties << TestLog::EndMessage
6231                                         << TestLog::Message << "vkGetPhysicalDeviceImageFormatProperties2() returned " << extResult << ", " << extProperties << TestLog::EndMessage;
6232                                 TCU_FAIL("Mismatch between image format properties reported by vkGetPhysicalDeviceImageFormatProperties and vkGetPhysicalDeviceImageFormatProperties2");
6233                         }
6234                 }
6235         }
6236
6237         return tcu::TestStatus::pass("Querying image format properties succeeded");
6238 }
6239
6240 tcu::TestStatus sparseImageFormatProperties2 (Context& context, const VkFormat format, const VkImageType imageType, const VkImageTiling tiling)
6241 {
6242         TestLog&                                                log                             = context.getTestContext().getLog();
6243
6244         const CustomInstance                    instance                (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
6245         const InstanceDriver&                   vki                             (instance.getDriver());
6246         const VkPhysicalDevice                  physicalDevice  (chooseDevice(vki, instance, context.getTestContext().getCommandLine()));
6247
6248         const VkImageUsageFlags                 allUsageFlags   = VK_IMAGE_USAGE_TRANSFER_SRC_BIT
6249                                                                                                         | VK_IMAGE_USAGE_TRANSFER_DST_BIT
6250                                                                                                         | VK_IMAGE_USAGE_SAMPLED_BIT
6251                                                                                                         | VK_IMAGE_USAGE_STORAGE_BIT
6252                                                                                                         | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
6253                                                                                                         | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
6254                                                                                                         | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT
6255                                                                                                         | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
6256
6257         for (deUint32 sampleCountBit = VK_SAMPLE_COUNT_1_BIT; sampleCountBit <= VK_SAMPLE_COUNT_64_BIT; sampleCountBit = (sampleCountBit << 1u))
6258         {
6259                 for (VkImageUsageFlags curUsageFlags = (VkImageUsageFlags)1; curUsageFlags <= allUsageFlags; curUsageFlags++)
6260                 {
6261                         if (!isValidImageUsageFlagCombination(curUsageFlags))
6262                                 continue;
6263
6264                         const VkPhysicalDeviceSparseImageFormatInfo2    imageFormatInfo =
6265                         {
6266                                 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
6267                                 DE_NULL,
6268                                 format,
6269                                 imageType,
6270                                 (VkSampleCountFlagBits)sampleCountBit,
6271                                 curUsageFlags,
6272                                 tiling,
6273                         };
6274
6275                         deUint32        numCoreProperties       = 0u;
6276                         deUint32        numExtProperties        = 0u;
6277
6278                         // Query count
6279                         vki.getPhysicalDeviceSparseImageFormatProperties(physicalDevice, imageFormatInfo.format, imageFormatInfo.type, imageFormatInfo.samples, imageFormatInfo.usage, imageFormatInfo.tiling, &numCoreProperties, DE_NULL);
6280                         vki.getPhysicalDeviceSparseImageFormatProperties2(physicalDevice, &imageFormatInfo, &numExtProperties, DE_NULL);
6281
6282                         if (numCoreProperties != numExtProperties)
6283                         {
6284                                 log << TestLog::Message << "ERROR: different number of properties reported for " << imageFormatInfo << TestLog::EndMessage;
6285                                 TCU_FAIL("Mismatch in reported property count");
6286                         }
6287
6288                         if (!context.getDeviceFeatures().sparseBinding)
6289                         {
6290                                 // There is no support for sparse binding, getPhysicalDeviceSparseImageFormatProperties* MUST report no properties
6291                                 // Only have to check one of the entrypoints as a mismatch in count is already caught.
6292                                 if (numCoreProperties > 0)
6293                                 {
6294                                         log << TestLog::Message << "ERROR: device does not support sparse binding but claims support for " << numCoreProperties << " properties in vkGetPhysicalDeviceSparseImageFormatProperties with parameters " << imageFormatInfo << TestLog::EndMessage;
6295                                         TCU_FAIL("Claimed format properties inconsistent with overall sparseBinding feature");
6296                                 }
6297                         }
6298
6299                         if (numCoreProperties > 0)
6300                         {
6301                                 std::vector<VkSparseImageFormatProperties>              coreProperties  (numCoreProperties);
6302                                 std::vector<VkSparseImageFormatProperties2>             extProperties   (numExtProperties);
6303
6304                                 deMemset(&coreProperties[0], 0xcd, sizeof(VkSparseImageFormatProperties)*numCoreProperties);
6305                                 deMemset(&extProperties[0], 0xcd, sizeof(VkSparseImageFormatProperties2)*numExtProperties);
6306
6307                                 for (deUint32 ndx = 0; ndx < numExtProperties; ++ndx)
6308                                 {
6309                                         extProperties[ndx].sType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2;
6310                                         extProperties[ndx].pNext = DE_NULL;
6311                                 }
6312
6313                                 vki.getPhysicalDeviceSparseImageFormatProperties(physicalDevice, imageFormatInfo.format, imageFormatInfo.type, imageFormatInfo.samples, imageFormatInfo.usage, imageFormatInfo.tiling, &numCoreProperties, &coreProperties[0]);
6314                                 vki.getPhysicalDeviceSparseImageFormatProperties2(physicalDevice, &imageFormatInfo, &numExtProperties, &extProperties[0]);
6315
6316                                 TCU_CHECK((size_t)numCoreProperties == coreProperties.size());
6317                                 TCU_CHECK((size_t)numExtProperties == extProperties.size());
6318
6319                                 for (deUint32 ndx = 0; ndx < numCoreProperties; ++ndx)
6320                                 {
6321                                         TCU_CHECK(extProperties[ndx].sType == VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2);
6322                                         TCU_CHECK(extProperties[ndx].pNext == DE_NULL);
6323
6324                                         if ((deMemCmp(&coreProperties[ndx], &extProperties[ndx].properties, sizeof(VkSparseImageFormatProperties)) != 0))
6325                                         {
6326                                                 log << TestLog::Message << "ERROR: device mismatch with query " << imageFormatInfo << " property " << ndx << TestLog::EndMessage
6327                                                         << TestLog::Message << "vkGetPhysicalDeviceSparseImageFormatProperties() returned " << coreProperties[ndx] << TestLog::EndMessage
6328                                                         << TestLog::Message << "vkGetPhysicalDeviceSparseImageFormatProperties2() returned " << extProperties[ndx] << TestLog::EndMessage;
6329                                                 TCU_FAIL("Mismatch between image format properties reported by vkGetPhysicalDeviceSparseImageFormatProperties and vkGetPhysicalDeviceSparseImageFormatProperties2");
6330                                         }
6331                                 }
6332                         }
6333                 }
6334         }
6335
6336         return tcu::TestStatus::pass("Querying sparse image format properties succeeded");
6337 }
6338
6339 tcu::TestStatus execImageFormatTest (Context& context, ImageFormatPropertyCase testCase)
6340 {
6341         return testCase.testFunction(context, testCase.format, testCase.imageType, testCase.tiling);
6342 }
6343
6344 void createImageFormatTypeTilingTests (tcu::TestCaseGroup* testGroup, ImageFormatPropertyCase params)
6345 {
6346         DE_ASSERT(params.format == VK_FORMAT_UNDEFINED);
6347
6348         static const struct
6349         {
6350                 VkFormat                                                                begin;
6351                 VkFormat                                                                end;
6352                 ImageFormatPropertyCase                                 params;
6353         } s_formatRanges[] =
6354         {
6355                 // core formats
6356                 { (VkFormat)(VK_FORMAT_UNDEFINED + 1),          VK_CORE_FORMAT_LAST,                                                                            params },
6357
6358                 // YCbCr formats
6359                 { VK_FORMAT_G8B8G8R8_422_UNORM_KHR,                     (VkFormat)(VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR + 1),     params },
6360
6361                 // YCbCr extended formats
6362                 { VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT,       (VkFormat)(VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT+1),        params },
6363         };
6364
6365         for (int rangeNdx = 0; rangeNdx < DE_LENGTH_OF_ARRAY(s_formatRanges); ++rangeNdx)
6366         {
6367                 const VkFormat                                                          rangeBegin              = s_formatRanges[rangeNdx].begin;
6368                 const VkFormat                                                          rangeEnd                = s_formatRanges[rangeNdx].end;
6369
6370                 for (VkFormat format = rangeBegin; format != rangeEnd; format = (VkFormat)(format+1))
6371                 {
6372                         const bool                      isYCbCr         = isYCbCrFormat(format);
6373                         const bool                      isSparse        = (params.testFunction == sparseImageFormatProperties2);
6374
6375                         if (isYCbCr && isSparse)
6376                                 continue;
6377
6378                         if (isYCbCr && params.imageType != VK_IMAGE_TYPE_2D)
6379                                 continue;
6380
6381                         const char* const       enumName        = getFormatName(format);
6382                         const string            caseName        = de::toLower(string(enumName).substr(10));
6383
6384                         params.format = format;
6385
6386                         addFunctionCase(testGroup, caseName, enumName, execImageFormatTest, params);
6387                 }
6388         }
6389 }
6390
6391 void createImageFormatTypeTests (tcu::TestCaseGroup* testGroup, ImageFormatPropertyCase params)
6392 {
6393         DE_ASSERT(params.tiling == VK_CORE_IMAGE_TILING_LAST);
6394
6395         testGroup->addChild(createTestGroup(testGroup->getTestContext(), "optimal",     "",     createImageFormatTypeTilingTests, ImageFormatPropertyCase(params.testFunction, VK_FORMAT_UNDEFINED, params.imageType, VK_IMAGE_TILING_OPTIMAL)));
6396         testGroup->addChild(createTestGroup(testGroup->getTestContext(), "linear",      "",     createImageFormatTypeTilingTests, ImageFormatPropertyCase(params.testFunction, VK_FORMAT_UNDEFINED, params.imageType, VK_IMAGE_TILING_LINEAR)));
6397 }
6398
6399 void createImageFormatTests (tcu::TestCaseGroup* testGroup, ImageFormatPropertyCase::Function testFunction)
6400 {
6401         testGroup->addChild(createTestGroup(testGroup->getTestContext(), "1d", "", createImageFormatTypeTests, ImageFormatPropertyCase(testFunction, VK_FORMAT_UNDEFINED, VK_IMAGE_TYPE_1D, VK_CORE_IMAGE_TILING_LAST)));
6402         testGroup->addChild(createTestGroup(testGroup->getTestContext(), "2d", "", createImageFormatTypeTests, ImageFormatPropertyCase(testFunction, VK_FORMAT_UNDEFINED, VK_IMAGE_TYPE_2D, VK_CORE_IMAGE_TILING_LAST)));
6403         testGroup->addChild(createTestGroup(testGroup->getTestContext(), "3d", "", createImageFormatTypeTests, ImageFormatPropertyCase(testFunction, VK_FORMAT_UNDEFINED, VK_IMAGE_TYPE_3D, VK_CORE_IMAGE_TILING_LAST)));
6404 }
6405
6406
6407 // Android CTS -specific tests
6408
6409 namespace android
6410 {
6411
6412 void checkExtensions (tcu::ResultCollector& results, const set<string>& allowedExtensions, const vector<VkExtensionProperties>& reportedExtensions)
6413 {
6414         for (vector<VkExtensionProperties>::const_iterator extension = reportedExtensions.begin(); extension != reportedExtensions.end(); ++extension)
6415         {
6416                 const string    extensionName   (extension->extensionName);
6417                 const bool              mustBeKnown             = de::beginsWith(extensionName, "VK_GOOGLE_")   ||
6418                                                                                   de::beginsWith(extensionName, "VK_ANDROID_");
6419
6420                 if (mustBeKnown && !de::contains(allowedExtensions, extensionName))
6421                         results.fail("Unknown extension: " + extensionName);
6422         }
6423 }
6424
6425 tcu::TestStatus testNoUnknownExtensions (Context& context)
6426 {
6427         TestLog&                                log                                     = context.getTestContext().getLog();
6428         tcu::ResultCollector    results                         (log);
6429         set<string>                             allowedInstanceExtensions;
6430         set<string>                             allowedDeviceExtensions;
6431
6432         // All known extensions should be added to allowedExtensions:
6433         // allowedExtensions.insert("VK_GOOGLE_extension1");
6434         allowedDeviceExtensions.insert("VK_ANDROID_external_memory_android_hardware_buffer");
6435         allowedDeviceExtensions.insert("VK_GOOGLE_display_timing");
6436         allowedDeviceExtensions.insert("VK_GOOGLE_decorate_string");
6437         allowedDeviceExtensions.insert("VK_GOOGLE_hlsl_functionality1");
6438         allowedInstanceExtensions.insert("VK_GOOGLE_surfaceless_query");
6439
6440         // Instance extensions
6441         checkExtensions(results,
6442                                         allowedInstanceExtensions,
6443                                         enumerateInstanceExtensionProperties(context.getPlatformInterface(), DE_NULL));
6444
6445         // Extensions exposed by instance layers
6446         {
6447                 const vector<VkLayerProperties> layers  = enumerateInstanceLayerProperties(context.getPlatformInterface());
6448
6449                 for (vector<VkLayerProperties>::const_iterator layer = layers.begin(); layer != layers.end(); ++layer)
6450                 {
6451                         checkExtensions(results,
6452                                                         allowedInstanceExtensions,
6453                                                         enumerateInstanceExtensionProperties(context.getPlatformInterface(), layer->layerName));
6454                 }
6455         }
6456
6457         // Device extensions
6458         checkExtensions(results,
6459                                         allowedDeviceExtensions,
6460                                         enumerateDeviceExtensionProperties(context.getInstanceInterface(), context.getPhysicalDevice(), DE_NULL));
6461
6462         // Extensions exposed by device layers
6463         {
6464                 const vector<VkLayerProperties> layers  = enumerateDeviceLayerProperties(context.getInstanceInterface(), context.getPhysicalDevice());
6465
6466                 for (vector<VkLayerProperties>::const_iterator layer = layers.begin(); layer != layers.end(); ++layer)
6467                 {
6468                         checkExtensions(results,
6469                                                         allowedDeviceExtensions,
6470                                                         enumerateDeviceExtensionProperties(context.getInstanceInterface(), context.getPhysicalDevice(), layer->layerName));
6471                 }
6472         }
6473
6474         return tcu::TestStatus(results.getResult(), results.getMessage());
6475 }
6476
6477 tcu::TestStatus testNoLayers (Context& context)
6478 {
6479         TestLog&                                log             = context.getTestContext().getLog();
6480         tcu::ResultCollector    results (log);
6481
6482         {
6483                 const vector<VkLayerProperties> layers  = enumerateInstanceLayerProperties(context.getPlatformInterface());
6484
6485                 for (vector<VkLayerProperties>::const_iterator layer = layers.begin(); layer != layers.end(); ++layer)
6486                         results.fail(string("Instance layer enumerated: ") + layer->layerName);
6487         }
6488
6489         {
6490                 const vector<VkLayerProperties> layers  = enumerateDeviceLayerProperties(context.getInstanceInterface(), context.getPhysicalDevice());
6491
6492                 for (vector<VkLayerProperties>::const_iterator layer = layers.begin(); layer != layers.end(); ++layer)
6493                         results.fail(string("Device layer enumerated: ") + layer->layerName);
6494         }
6495
6496         return tcu::TestStatus(results.getResult(), results.getMessage());
6497 }
6498
6499 tcu::TestStatus testMandatoryExtensions (Context& context)
6500 {
6501         TestLog&                                log             = context.getTestContext().getLog();
6502         tcu::ResultCollector    results (log);
6503
6504         // Instance extensions
6505         {
6506                 static const string mandatoryExtensions[]       =
6507                 {
6508                         "VK_KHR_get_physical_device_properties2",
6509                 };
6510
6511                 for (const auto &ext : mandatoryExtensions)
6512                 {
6513                         if (!context.isInstanceFunctionalitySupported(ext))
6514                                 results.fail(ext + " is not supported");
6515                 }
6516         }
6517
6518         // Device extensions
6519         {
6520                 static const string mandatoryExtensions[] =
6521                 {
6522                         "VK_KHR_maintenance1",
6523                 };
6524
6525                 for (const auto &ext : mandatoryExtensions)
6526                 {
6527                         if (!context.isDeviceFunctionalitySupported(ext))
6528                                 results.fail(ext + " is not supported");
6529                 }
6530         }
6531
6532         return tcu::TestStatus(results.getResult(), results.getMessage());
6533 }
6534
6535 } // android
6536
6537 } // anonymous
6538
6539 static inline void addFunctionCaseInNewSubgroup (
6540         tcu::TestContext&                       testCtx,
6541         tcu::TestCaseGroup*                     group,
6542         const std::string&                      subgroupName,
6543         const std::string&                      subgroupDescription,
6544         FunctionInstance0::Function     testFunc)
6545 {
6546         de::MovePtr<tcu::TestCaseGroup> subgroup(new tcu::TestCaseGroup(testCtx, subgroupName.c_str(), subgroupDescription.c_str()));
6547         addFunctionCase(subgroup.get(), "basic", "", testFunc);
6548         group->addChild(subgroup.release());
6549 }
6550
6551 tcu::TestCaseGroup* createFeatureInfoTests (tcu::TestContext& testCtx)
6552 {
6553         de::MovePtr<tcu::TestCaseGroup> infoTests       (new tcu::TestCaseGroup(testCtx, "info", "Platform Information Tests"));
6554
6555         infoTests->addChild(createTestGroup(testCtx, "format_properties",               "VkGetPhysicalDeviceFormatProperties() Tests",          createFormatTests));
6556         infoTests->addChild(createTestGroup(testCtx, "image_format_properties", "VkGetPhysicalDeviceImageFormatProperties() Tests",     createImageFormatTests, imageFormatProperties));
6557
6558         {
6559                 de::MovePtr<tcu::TestCaseGroup> extCoreVersionGrp (new tcu::TestCaseGroup(testCtx, "extension_core_versions", "Tests checking extension required core versions"));
6560
6561                 addFunctionCase(extCoreVersionGrp.get(), "extension_core_versions", "", extensionCoreVersions);
6562
6563                 infoTests->addChild(extCoreVersionGrp.release());
6564         }
6565
6566         {
6567                 de::MovePtr<tcu::TestCaseGroup> extendedPropertiesTests (new tcu::TestCaseGroup(testCtx, "get_physical_device_properties2", "VK_KHR_get_physical_device_properties2"));
6568
6569                 {
6570                         de::MovePtr<tcu::TestCaseGroup> subgroup(new tcu::TestCaseGroup(testCtx, "features", ""));
6571                         addFunctionCase(subgroup.get(), "core", "Extended Device Features", deviceFeatures2);
6572                         addSeparateFeatureTests(subgroup.get());
6573                         extendedPropertiesTests->addChild(subgroup.release());
6574                 }
6575                 addFunctionCaseInNewSubgroup(testCtx, extendedPropertiesTests.get(), "properties",                              "Extended Device Properties",                           deviceProperties2);
6576                 addFunctionCaseInNewSubgroup(testCtx, extendedPropertiesTests.get(), "format_properties",                       "Extended Device Format Properties",            deviceFormatProperties2);
6577                 addFunctionCaseInNewSubgroup(testCtx, extendedPropertiesTests.get(), "queue_family_properties", "Extended Device Queue Family Properties",      deviceQueueFamilyProperties2);
6578                 addFunctionCaseInNewSubgroup(testCtx, extendedPropertiesTests.get(), "memory_properties",                       "Extended Device Memory Properties",            deviceMemoryProperties2);
6579
6580                 infoTests->addChild(extendedPropertiesTests.release());
6581         }
6582
6583         {
6584                 de::MovePtr<tcu::TestCaseGroup> extendedPropertiesTests (new tcu::TestCaseGroup(testCtx, "vulkan1p2", "Vulkan 1.2 related tests"));
6585
6586                 addFunctionCase(extendedPropertiesTests.get(), "features",                                                      "Extended Vulkan 1.2 Device Features",                                          deviceFeaturesVulkan12);
6587                 addFunctionCase(extendedPropertiesTests.get(), "properties",                                            "Extended Vulkan 1.2 Device Properties",                                        devicePropertiesVulkan12);
6588                 addFunctionCase(extendedPropertiesTests.get(), "feature_extensions_consistency",        "Vulkan 1.2 consistency between Features and Extensions",       deviceFeatureExtensionsConsistencyVulkan12);
6589                 addFunctionCase(extendedPropertiesTests.get(), "property_extensions_consistency",       "Vulkan 1.2 consistency between Properties and Extensions", devicePropertyExtensionsConsistencyVulkan12);
6590                 addFunctionCase(extendedPropertiesTests.get(), "feature_bits_influence",                        "Validate feature bits influence on feature activation",        checkApiVersionSupport<1,2>, featureBitInfluenceOnDeviceCreate<VK_API_VERSION_1_2>);
6591
6592                 infoTests->addChild(extendedPropertiesTests.release());
6593         }
6594
6595         {
6596                 de::MovePtr<tcu::TestCaseGroup> extendedPropertiesTests (new tcu::TestCaseGroup(testCtx, "vulkan1p3", "Vulkan 1.3 related tests"));
6597
6598                 addFunctionCase(extendedPropertiesTests.get(), "features",                                                      "Extended Vulkan 1.3 Device Features",                                          deviceFeaturesVulkan13);
6599                 addFunctionCase(extendedPropertiesTests.get(), "properties",                                            "Extended Vulkan 1.3 Device Properties",                                        devicePropertiesVulkan13);
6600                 addFunctionCase(extendedPropertiesTests.get(), "feature_extensions_consistency",        "Vulkan 1.3 consistency between Features and Extensions",       deviceFeatureExtensionsConsistencyVulkan13);
6601                 addFunctionCase(extendedPropertiesTests.get(), "property_extensions_consistency",       "Vulkan 1.3 consistency between Properties and Extensions", devicePropertyExtensionsConsistencyVulkan13);
6602                 addFunctionCase(extendedPropertiesTests.get(), "feature_bits_influence",                        "Validate feature bits influence on feature activation",        checkApiVersionSupport<1, 3>, featureBitInfluenceOnDeviceCreate<VK_API_VERSION_1_3>);
6603
6604                 infoTests->addChild(extendedPropertiesTests.release());
6605         }
6606
6607         {
6608                 de::MovePtr<tcu::TestCaseGroup> limitsValidationTests (new tcu::TestCaseGroup(testCtx, "vulkan1p2_limits_validation", "Vulkan 1.2 and core extensions limits validation"));
6609
6610                 addFunctionCase(limitsValidationTests.get(), "general",                                                 "Vulkan 1.2 Limit validation",                                                  checkApiVersionSupport<1, 2>,                           validateLimits12);
6611                 addFunctionCase(limitsValidationTests.get(), "khr_push_descriptor",                             "VK_KHR_push_descriptor limit validation",                              checkSupportKhrPushDescriptor,                          validateLimitsKhrPushDescriptor);
6612                 addFunctionCase(limitsValidationTests.get(), "khr_multiview",                                   "VK_KHR_multiview limit validation",                                    checkSupportKhrMultiview,                                       validateLimitsKhrMultiview);
6613                 addFunctionCase(limitsValidationTests.get(), "ext_discard_rectangles",                  "VK_EXT_discard_rectangles limit validation",                   checkSupportExtDiscardRectangles,                       validateLimitsExtDiscardRectangles);
6614                 addFunctionCase(limitsValidationTests.get(), "ext_sample_locations",                    "VK_EXT_sample_locations limit validation",                             checkSupportExtSampleLocations,                         validateLimitsExtSampleLocations);
6615                 addFunctionCase(limitsValidationTests.get(), "ext_external_memory_host",                "VK_EXT_external_memory_host limit validation",                 checkSupportExtExternalMemoryHost,                      validateLimitsExtExternalMemoryHost);
6616                 addFunctionCase(limitsValidationTests.get(), "ext_blend_operation_advanced",    "VK_EXT_blend_operation_advanced limit validation",             checkSupportExtBlendOperationAdvanced,          validateLimitsExtBlendOperationAdvanced);
6617                 addFunctionCase(limitsValidationTests.get(), "khr_maintenance_3",                               "VK_KHR_maintenance3 limit validation",                                 checkSupportKhrMaintenance3,                            validateLimitsKhrMaintenance3);
6618                 addFunctionCase(limitsValidationTests.get(), "ext_conservative_rasterization",  "VK_EXT_conservative_rasterization limit validation",   checkSupportExtConservativeRasterization,       validateLimitsExtConservativeRasterization);
6619                 addFunctionCase(limitsValidationTests.get(), "ext_descriptor_indexing",                 "VK_EXT_descriptor_indexing limit validation",                  checkSupportExtDescriptorIndexing,                      validateLimitsExtDescriptorIndexing);
6620                 addFunctionCase(limitsValidationTests.get(), "ext_inline_uniform_block",                "VK_EXT_inline_uniform_block limit validation",                 checkSupportExtInlineUniformBlock,                      validateLimitsExtInlineUniformBlock);
6621                 addFunctionCase(limitsValidationTests.get(), "ext_vertex_attribute_divisor",    "VK_EXT_vertex_attribute_divisor limit validation",             checkSupportExtVertexAttributeDivisor,          validateLimitsExtVertexAttributeDivisor);
6622                 addFunctionCase(limitsValidationTests.get(), "nv_mesh_shader",                                  "VK_NV_mesh_shader limit validation",                                   checkSupportNvMeshShader,                                       validateLimitsNvMeshShader);
6623                 addFunctionCase(limitsValidationTests.get(), "ext_transform_feedback",                  "VK_EXT_transform_feedback limit validation",                   checkSupportExtTransformFeedback,                       validateLimitsExtTransformFeedback);
6624                 addFunctionCase(limitsValidationTests.get(), "fragment_density_map",                    "VK_EXT_fragment_density_map limit validation",                 checkSupportExtFragmentDensityMap,                      validateLimitsExtFragmentDensityMap);
6625                 addFunctionCase(limitsValidationTests.get(), "nv_ray_tracing",                                  "VK_NV_ray_tracing limit validation",                                   checkSupportNvRayTracing,                                       validateLimitsNvRayTracing);
6626                 addFunctionCase(limitsValidationTests.get(), "timeline_semaphore",                              "VK_KHR_timeline_semaphore limit validation",                   checkSupportKhrTimelineSemaphore,                       validateLimitsKhrTimelineSemaphore);
6627                 addFunctionCase(limitsValidationTests.get(), "ext_line_rasterization",                  "VK_EXT_line_rasterization limit validation",                   checkSupportExtLineRasterization,                       validateLimitsExtLineRasterization);
6628
6629                 infoTests->addChild(limitsValidationTests.release());
6630         }
6631
6632         {
6633                 de::MovePtr<tcu::TestCaseGroup> limitsValidationTests(new tcu::TestCaseGroup(testCtx, "vulkan1p3_limits_validation", "Vulkan 1.3 and core extensions limits validation"));
6634
6635                 addFunctionCase(limitsValidationTests.get(), "khr_maintenance4",                                "VK_KHR_maintenance4",                                                                  checkSupportKhrMaintenance4,                            validateLimitsKhrMaintenance4);
6636                 addFunctionCase(limitsValidationTests.get(), "max_inline_uniform_total_size",   "maxInlineUniformTotalSize limit validation",                   checkApiVersionSupport<1, 3>,                           validateLimitsMaxInlineUniformTotalSize);
6637
6638                 infoTests->addChild(limitsValidationTests.release());
6639         }
6640
6641         infoTests->addChild(createTestGroup(testCtx, "image_format_properties2",                "VkGetPhysicalDeviceImageFormatProperties2() Tests",            createImageFormatTests, imageFormatProperties2));
6642         infoTests->addChild(createTestGroup(testCtx, "sparse_image_format_properties2", "VkGetPhysicalDeviceSparseImageFormatProperties2() Tests",      createImageFormatTests, sparseImageFormatProperties2));
6643
6644         {
6645                 de::MovePtr<tcu::TestCaseGroup> profilesValidationTests(new tcu::TestCaseGroup(testCtx, "profiles", "Profiles limits and features validation"));
6646
6647                 addFunctionCase(profilesValidationTests.get(), "roadmap_2022", "Limits and features check for roadmap 2022", checkApiVersionSupport<1, 3>, validateRoadmap2022);
6648
6649                 infoTests->addChild(profilesValidationTests.release());
6650         }
6651
6652         {
6653                 de::MovePtr<tcu::TestCaseGroup> androidTests    (new tcu::TestCaseGroup(testCtx, "android", "Android CTS Tests"));
6654
6655                 addFunctionCase(androidTests.get(),     "mandatory_extensions",         "Test that all mandatory extensions are supported",     android::testMandatoryExtensions);
6656                 addFunctionCase(androidTests.get(), "no_unknown_extensions",    "Test for unknown device or instance extensions",       android::testNoUnknownExtensions);
6657                 addFunctionCase(androidTests.get(), "no_layers",                                "Test that no layers are enumerated",                           android::testNoLayers);
6658
6659                 infoTests->addChild(androidTests.release());
6660         }
6661
6662         return infoTests.release();
6663 }
6664
6665 void createFeatureInfoInstanceTests(tcu::TestCaseGroup* testGroup)
6666 {
6667         addFunctionCase(testGroup, "physical_devices",                                  "Physical devices",                                             enumeratePhysicalDevices);
6668         addFunctionCase(testGroup, "physical_device_groups",                    "Physical devices Groups",                              enumeratePhysicalDeviceGroups);
6669         addFunctionCase(testGroup, "instance_layers",                                   "Layers",                                                               enumerateInstanceLayers);
6670         addFunctionCase(testGroup, "instance_extensions",                               "Extensions",                                                   enumerateInstanceExtensions);
6671 }
6672
6673 void createFeatureInfoDeviceTests(tcu::TestCaseGroup* testGroup)
6674 {
6675         addFunctionCase(testGroup, "device_features",                                   "Device Features",                                              deviceFeatures);
6676         addFunctionCase(testGroup, "device_properties",                                 "Device Properties",                                    deviceProperties);
6677         addFunctionCase(testGroup, "device_queue_family_properties",    "Queue family properties",                              deviceQueueFamilyProperties);
6678         addFunctionCase(testGroup, "device_memory_properties",                  "Memory properties",                                    deviceMemoryProperties);
6679         addFunctionCase(testGroup, "device_layers",                                             "Layers",                                                               enumerateDeviceLayers);
6680         addFunctionCase(testGroup, "device_extensions",                                 "Extensions",                                                   enumerateDeviceExtensions);
6681         addFunctionCase(testGroup, "device_no_khx_extensions",                  "KHX extensions",                                               testNoKhxExtensions);
6682         addFunctionCase(testGroup, "device_memory_budget",                              "Memory budget",                                                deviceMemoryBudgetProperties);
6683         addFunctionCase(testGroup, "device_mandatory_features",                 "Mandatory features",                                   deviceMandatoryFeatures);
6684 }
6685
6686 void createFeatureInfoDeviceGroupTests(tcu::TestCaseGroup* testGroup)
6687 {
6688         addFunctionCase(testGroup, "device_group_peer_memory_features", "Device Group peer memory features",    deviceGroupPeerMemoryFeatures);
6689 }
6690
6691 } // api
6692 } // vkt