external/vulkancts/framework/vulkan/generated/vulkan/vkMandatoryFeatures.inl

   1 /* WARNING: This is auto-generated file. Do not modify, since changes will
   2  * be lost! Modify the generating script instead.
   3  * This file was generated by /scripts/gen_framework.py
   4  */
   5
   6 bool checkMandatoryFeatures(const vkt::Context& context)
   7 {
   8         if (!context.isInstanceFunctionalitySupported("VK_KHR_get_physical_device_properties2"))
   9                 TCU_THROW(NotSupportedError, "Extension VK_KHR_get_physical_device_properties2 is not present");
  10
  11         VkPhysicalDevice                                        physicalDevice          = context.getPhysicalDevice();
  12         const InstanceInterface&                        vki                                     = context.getInstanceInterface();
  13         const vector<VkExtensionProperties>     deviceExtensions        = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL);
  14
  15         tcu::TestLog& log = context.getTestContext().getLog();
  16         vk::VkPhysicalDeviceFeatures2 coreFeatures;
  17         deMemset(&coreFeatures, 0, sizeof(coreFeatures));
  18         coreFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
  19         void** nextPtr = &coreFeatures.pNext;
  20
  21         vk::VkPhysicalDevice16BitStorageFeatures physicalDevice16BitStorageFeatures;
  22         deMemset(&physicalDevice16BitStorageFeatures, 0, sizeof(physicalDevice16BitStorageFeatures));
  23
  24         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_16bit_storage")) )
  25         {
  26                 physicalDevice16BitStorageFeatures.sType = getStructureType<VkPhysicalDevice16BitStorageFeatures>();
  27                 *nextPtr = &physicalDevice16BitStorageFeatures;
  28                 nextPtr  = &physicalDevice16BitStorageFeatures.pNext;
  29         }
  30
  31         vk::VkPhysicalDevice4444FormatsFeaturesEXT physicalDevice4444FormatsFeaturesEXT;
  32         deMemset(&physicalDevice4444FormatsFeaturesEXT, 0, sizeof(physicalDevice4444FormatsFeaturesEXT));
  33
  34         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_4444_formats")) )
  35         {
  36                 physicalDevice4444FormatsFeaturesEXT.sType = getStructureType<VkPhysicalDevice4444FormatsFeaturesEXT>();
  37                 *nextPtr = &physicalDevice4444FormatsFeaturesEXT;
  38                 nextPtr  = &physicalDevice4444FormatsFeaturesEXT.pNext;
  39         }
  40
  41         vk::VkPhysicalDevice8BitStorageFeatures physicalDevice8BitStorageFeatures;
  42         deMemset(&physicalDevice8BitStorageFeatures, 0, sizeof(physicalDevice8BitStorageFeatures));
  43
  44         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_8bit_storage")) )
  45         {
  46                 physicalDevice8BitStorageFeatures.sType = getStructureType<VkPhysicalDevice8BitStorageFeatures>();
  47                 *nextPtr = &physicalDevice8BitStorageFeatures;
  48                 nextPtr  = &physicalDevice8BitStorageFeatures.pNext;
  49         }
  50
  51         vk::VkPhysicalDeviceAccelerationStructureFeaturesKHR physicalDeviceAccelerationStructureFeaturesKHR;
  52         deMemset(&physicalDeviceAccelerationStructureFeaturesKHR, 0, sizeof(physicalDeviceAccelerationStructureFeaturesKHR));
  53
  54         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
  55         {
  56                 physicalDeviceAccelerationStructureFeaturesKHR.sType = getStructureType<VkPhysicalDeviceAccelerationStructureFeaturesKHR>();
  57                 *nextPtr = &physicalDeviceAccelerationStructureFeaturesKHR;
  58                 nextPtr  = &physicalDeviceAccelerationStructureFeaturesKHR.pNext;
  59         }
  60
  61 #if defined(CTS_USES_VULKAN)
  62         vk::VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT;
  63         deMemset(&physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, 0, sizeof(physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT));
  64
  65         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_attachment_feedback_loop_layout")) )
  66         {
  67                 physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.sType = getStructureType<VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT>();
  68                 *nextPtr = &physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT;
  69                 nextPtr  = &physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.pNext;
  70         }
  71 #endif // defined(CTS_USES_VULKAN)
  72
  73 #if defined(CTS_USES_VULKAN)
  74         vk::VkPhysicalDeviceBorderColorSwizzleFeaturesEXT physicalDeviceBorderColorSwizzleFeaturesEXT;
  75         deMemset(&physicalDeviceBorderColorSwizzleFeaturesEXT, 0, sizeof(physicalDeviceBorderColorSwizzleFeaturesEXT));
  76
  77         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_border_color_swizzle")) )
  78         {
  79                 physicalDeviceBorderColorSwizzleFeaturesEXT.sType = getStructureType<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT>();
  80                 *nextPtr = &physicalDeviceBorderColorSwizzleFeaturesEXT;
  81                 nextPtr  = &physicalDeviceBorderColorSwizzleFeaturesEXT.pNext;
  82         }
  83 #endif // defined(CTS_USES_VULKAN)
  84
  85         vk::VkPhysicalDeviceBufferDeviceAddressFeatures physicalDeviceBufferDeviceAddressFeatures;
  86         deMemset(&physicalDeviceBufferDeviceAddressFeatures, 0, sizeof(physicalDeviceBufferDeviceAddressFeatures));
  87
  88         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_buffer_device_address")) || context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) )
  89         {
  90                 physicalDeviceBufferDeviceAddressFeatures.sType = getStructureType<VkPhysicalDeviceBufferDeviceAddressFeatures>();
  91                 *nextPtr = &physicalDeviceBufferDeviceAddressFeatures;
  92                 nextPtr  = &physicalDeviceBufferDeviceAddressFeatures.pNext;
  93         }
  94
  95         vk::VkPhysicalDeviceColorWriteEnableFeaturesEXT physicalDeviceColorWriteEnableFeaturesEXT;
  96         deMemset(&physicalDeviceColorWriteEnableFeaturesEXT, 0, sizeof(physicalDeviceColorWriteEnableFeaturesEXT));
  97
  98         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_color_write_enable")) )
  99         {
 100                 physicalDeviceColorWriteEnableFeaturesEXT.sType = getStructureType<VkPhysicalDeviceColorWriteEnableFeaturesEXT>();
 101                 *nextPtr = &physicalDeviceColorWriteEnableFeaturesEXT;
 102                 nextPtr  = &physicalDeviceColorWriteEnableFeaturesEXT.pNext;
 103         }
 104
 105         vk::VkPhysicalDeviceConditionalRenderingFeaturesEXT physicalDeviceConditionalRenderingFeaturesEXT;
 106         deMemset(&physicalDeviceConditionalRenderingFeaturesEXT, 0, sizeof(physicalDeviceConditionalRenderingFeaturesEXT));
 107
 108         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_conditional_rendering")) )
 109         {
 110                 physicalDeviceConditionalRenderingFeaturesEXT.sType = getStructureType<VkPhysicalDeviceConditionalRenderingFeaturesEXT>();
 111                 *nextPtr = &physicalDeviceConditionalRenderingFeaturesEXT;
 112                 nextPtr  = &physicalDeviceConditionalRenderingFeaturesEXT.pNext;
 113         }
 114
 115         vk::VkPhysicalDeviceDepthClampZeroOneFeaturesEXT physicalDeviceDepthClampZeroOneFeaturesEXT;
 116         deMemset(&physicalDeviceDepthClampZeroOneFeaturesEXT, 0, sizeof(physicalDeviceDepthClampZeroOneFeaturesEXT));
 117
 118         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_depth_clamp_zero_one")) )
 119         {
 120                 physicalDeviceDepthClampZeroOneFeaturesEXT.sType = getStructureType<VkPhysicalDeviceDepthClampZeroOneFeaturesEXT>();
 121                 *nextPtr = &physicalDeviceDepthClampZeroOneFeaturesEXT;
 122                 nextPtr  = &physicalDeviceDepthClampZeroOneFeaturesEXT.pNext;
 123         }
 124
 125         vk::VkPhysicalDeviceDepthClipControlFeaturesEXT physicalDeviceDepthClipControlFeaturesEXT;
 126         deMemset(&physicalDeviceDepthClipControlFeaturesEXT, 0, sizeof(physicalDeviceDepthClipControlFeaturesEXT));
 127
 128         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_depth_clip_control")) )
 129         {
 130                 physicalDeviceDepthClipControlFeaturesEXT.sType = getStructureType<VkPhysicalDeviceDepthClipControlFeaturesEXT>();
 131                 *nextPtr = &physicalDeviceDepthClipControlFeaturesEXT;
 132                 nextPtr  = &physicalDeviceDepthClipControlFeaturesEXT.pNext;
 133         }
 134
 135         vk::VkPhysicalDeviceDepthClipEnableFeaturesEXT physicalDeviceDepthClipEnableFeaturesEXT;
 136         deMemset(&physicalDeviceDepthClipEnableFeaturesEXT, 0, sizeof(physicalDeviceDepthClipEnableFeaturesEXT));
 137
 138         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_depth_clip_enable")) )
 139         {
 140                 physicalDeviceDepthClipEnableFeaturesEXT.sType = getStructureType<VkPhysicalDeviceDepthClipEnableFeaturesEXT>();
 141                 *nextPtr = &physicalDeviceDepthClipEnableFeaturesEXT;
 142                 nextPtr  = &physicalDeviceDepthClipEnableFeaturesEXT.pNext;
 143         }
 144
 145         vk::VkPhysicalDeviceDescriptorIndexingFeatures physicalDeviceDescriptorIndexingFeatures;
 146         deMemset(&physicalDeviceDescriptorIndexingFeatures, 0, sizeof(physicalDeviceDescriptorIndexingFeatures));
 147
 148         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) || context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) )
 149         {
 150                 physicalDeviceDescriptorIndexingFeatures.sType = getStructureType<VkPhysicalDeviceDescriptorIndexingFeatures>();
 151                 *nextPtr = &physicalDeviceDescriptorIndexingFeatures;
 152                 nextPtr  = &physicalDeviceDescriptorIndexingFeatures.pNext;
 153         }
 154
 155         vk::VkPhysicalDeviceExtendedDynamicState2FeaturesEXT physicalDeviceExtendedDynamicState2FeaturesEXT;
 156         deMemset(&physicalDeviceExtendedDynamicState2FeaturesEXT, 0, sizeof(physicalDeviceExtendedDynamicState2FeaturesEXT));
 157
 158         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_extended_dynamic_state2")) )
 159         {
 160                 physicalDeviceExtendedDynamicState2FeaturesEXT.sType = getStructureType<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT>();
 161                 *nextPtr = &physicalDeviceExtendedDynamicState2FeaturesEXT;
 162                 nextPtr  = &physicalDeviceExtendedDynamicState2FeaturesEXT.pNext;
 163         }
 164
 165         vk::VkPhysicalDeviceFragmentDensityMapFeaturesEXT physicalDeviceFragmentDensityMapFeaturesEXT;
 166         deMemset(&physicalDeviceFragmentDensityMapFeaturesEXT, 0, sizeof(physicalDeviceFragmentDensityMapFeaturesEXT));
 167
 168         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_fragment_density_map")) )
 169         {
 170                 physicalDeviceFragmentDensityMapFeaturesEXT.sType = getStructureType<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>();
 171                 *nextPtr = &physicalDeviceFragmentDensityMapFeaturesEXT;
 172                 nextPtr  = &physicalDeviceFragmentDensityMapFeaturesEXT.pNext;
 173         }
 174
 175         vk::VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT physicalDeviceFragmentShaderInterlockFeaturesEXT;
 176         deMemset(&physicalDeviceFragmentShaderInterlockFeaturesEXT, 0, sizeof(physicalDeviceFragmentShaderInterlockFeaturesEXT));
 177
 178         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_fragment_shader_interlock")) )
 179         {
 180                 physicalDeviceFragmentShaderInterlockFeaturesEXT.sType = getStructureType<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>();
 181                 *nextPtr = &physicalDeviceFragmentShaderInterlockFeaturesEXT;
 182                 nextPtr  = &physicalDeviceFragmentShaderInterlockFeaturesEXT.pNext;
 183         }
 184
 185 #if defined(CTS_USES_VULKAN)
 186         vk::VkPhysicalDeviceFragmentShadingRateFeaturesKHR physicalDeviceFragmentShadingRateFeaturesKHR;
 187         deMemset(&physicalDeviceFragmentShadingRateFeaturesKHR, 0, sizeof(physicalDeviceFragmentShadingRateFeaturesKHR));
 188
 189         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_fragment_shading_rate")) )
 190         {
 191                 physicalDeviceFragmentShadingRateFeaturesKHR.sType = getStructureType<VkPhysicalDeviceFragmentShadingRateFeaturesKHR>();
 192                 *nextPtr = &physicalDeviceFragmentShadingRateFeaturesKHR;
 193                 nextPtr  = &physicalDeviceFragmentShadingRateFeaturesKHR.pNext;
 194         }
 195 #endif // defined(CTS_USES_VULKAN)
 196
 197         vk::VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR physicalDeviceGlobalPriorityQueryFeaturesKHR;
 198         deMemset(&physicalDeviceGlobalPriorityQueryFeaturesKHR, 0, sizeof(physicalDeviceGlobalPriorityQueryFeaturesKHR));
 199
 200         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_global_priority_query")) || isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_global_priority")) )
 201         {
 202                 physicalDeviceGlobalPriorityQueryFeaturesKHR.sType = getStructureType<VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR>();
 203                 *nextPtr = &physicalDeviceGlobalPriorityQueryFeaturesKHR;
 204                 nextPtr  = &physicalDeviceGlobalPriorityQueryFeaturesKHR.pNext;
 205         }
 206
 207         vk::VkPhysicalDeviceHostQueryResetFeatures physicalDeviceHostQueryResetFeatures;
 208         deMemset(&physicalDeviceHostQueryResetFeatures, 0, sizeof(physicalDeviceHostQueryResetFeatures));
 209
 210         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_host_query_reset")) )
 211         {
 212                 physicalDeviceHostQueryResetFeatures.sType = getStructureType<VkPhysicalDeviceHostQueryResetFeatures>();
 213                 *nextPtr = &physicalDeviceHostQueryResetFeatures;
 214                 nextPtr  = &physicalDeviceHostQueryResetFeatures.pNext;
 215         }
 216
 217 #if defined(CTS_USES_VULKAN)
 218         vk::VkPhysicalDeviceImage2DViewOf3DFeaturesEXT physicalDeviceImage2DViewOf3DFeaturesEXT;
 219         deMemset(&physicalDeviceImage2DViewOf3DFeaturesEXT, 0, sizeof(physicalDeviceImage2DViewOf3DFeaturesEXT));
 220
 221         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_image_2d_view_of_3d")) )
 222         {
 223                 physicalDeviceImage2DViewOf3DFeaturesEXT.sType = getStructureType<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT>();
 224                 *nextPtr = &physicalDeviceImage2DViewOf3DFeaturesEXT;
 225                 nextPtr  = &physicalDeviceImage2DViewOf3DFeaturesEXT.pNext;
 226         }
 227 #endif // defined(CTS_USES_VULKAN)
 228
 229         vk::VkPhysicalDeviceImageCompressionControlFeaturesEXT physicalDeviceImageCompressionControlFeaturesEXT;
 230         deMemset(&physicalDeviceImageCompressionControlFeaturesEXT, 0, sizeof(physicalDeviceImageCompressionControlFeaturesEXT));
 231
 232         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_image_compression_control")) )
 233         {
 234                 physicalDeviceImageCompressionControlFeaturesEXT.sType = getStructureType<VkPhysicalDeviceImageCompressionControlFeaturesEXT>();
 235                 *nextPtr = &physicalDeviceImageCompressionControlFeaturesEXT;
 236                 nextPtr  = &physicalDeviceImageCompressionControlFeaturesEXT.pNext;
 237         }
 238
 239         vk::VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT physicalDeviceImageCompressionControlSwapchainFeaturesEXT;
 240         deMemset(&physicalDeviceImageCompressionControlSwapchainFeaturesEXT, 0, sizeof(physicalDeviceImageCompressionControlSwapchainFeaturesEXT));
 241
 242         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_image_compression_control")) )
 243         {
 244                 physicalDeviceImageCompressionControlSwapchainFeaturesEXT.sType = getStructureType<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT>();
 245                 *nextPtr = &physicalDeviceImageCompressionControlSwapchainFeaturesEXT;
 246                 nextPtr  = &physicalDeviceImageCompressionControlSwapchainFeaturesEXT.pNext;
 247         }
 248
 249         vk::VkPhysicalDeviceImagelessFramebufferFeatures physicalDeviceImagelessFramebufferFeatures;
 250         deMemset(&physicalDeviceImagelessFramebufferFeatures, 0, sizeof(physicalDeviceImagelessFramebufferFeatures));
 251
 252         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_imageless_framebuffer")) )
 253         {
 254                 physicalDeviceImagelessFramebufferFeatures.sType = getStructureType<VkPhysicalDeviceImagelessFramebufferFeatures>();
 255                 *nextPtr = &physicalDeviceImagelessFramebufferFeatures;
 256                 nextPtr  = &physicalDeviceImagelessFramebufferFeatures.pNext;
 257         }
 258
 259         vk::VkPhysicalDeviceIndexTypeUint8FeaturesEXT physicalDeviceIndexTypeUint8FeaturesEXT;
 260         deMemset(&physicalDeviceIndexTypeUint8FeaturesEXT, 0, sizeof(physicalDeviceIndexTypeUint8FeaturesEXT));
 261
 262         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_index_type_uint8")) )
 263         {
 264                 physicalDeviceIndexTypeUint8FeaturesEXT.sType = getStructureType<VkPhysicalDeviceIndexTypeUint8FeaturesEXT>();
 265                 *nextPtr = &physicalDeviceIndexTypeUint8FeaturesEXT;
 266                 nextPtr  = &physicalDeviceIndexTypeUint8FeaturesEXT.pNext;
 267         }
 268
 269         vk::VkPhysicalDeviceInlineUniformBlockFeaturesEXT physicalDeviceInlineUniformBlockFeaturesEXT;
 270         deMemset(&physicalDeviceInlineUniformBlockFeaturesEXT, 0, sizeof(physicalDeviceInlineUniformBlockFeaturesEXT));
 271
 272         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_inline_uniform_block")) )
 273         {
 274                 physicalDeviceInlineUniformBlockFeaturesEXT.sType = getStructureType<VkPhysicalDeviceInlineUniformBlockFeaturesEXT>();
 275                 *nextPtr = &physicalDeviceInlineUniformBlockFeaturesEXT;
 276                 nextPtr  = &physicalDeviceInlineUniformBlockFeaturesEXT.pNext;
 277         }
 278
 279         vk::VkPhysicalDeviceLegacyDitheringFeaturesEXT physicalDeviceLegacyDitheringFeaturesEXT;
 280         deMemset(&physicalDeviceLegacyDitheringFeaturesEXT, 0, sizeof(physicalDeviceLegacyDitheringFeaturesEXT));
 281
 282         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_legacy_dithering")) )
 283         {
 284                 physicalDeviceLegacyDitheringFeaturesEXT.sType = getStructureType<VkPhysicalDeviceLegacyDitheringFeaturesEXT>();
 285                 *nextPtr = &physicalDeviceLegacyDitheringFeaturesEXT;
 286                 nextPtr  = &physicalDeviceLegacyDitheringFeaturesEXT.pNext;
 287         }
 288
 289         vk::VkPhysicalDeviceLineRasterizationFeaturesEXT physicalDeviceLineRasterizationFeaturesEXT;
 290         deMemset(&physicalDeviceLineRasterizationFeaturesEXT, 0, sizeof(physicalDeviceLineRasterizationFeaturesEXT));
 291
 292         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_line_rasterization")) )
 293         {
 294                 physicalDeviceLineRasterizationFeaturesEXT.sType = getStructureType<VkPhysicalDeviceLineRasterizationFeaturesEXT>();
 295                 *nextPtr = &physicalDeviceLineRasterizationFeaturesEXT;
 296                 nextPtr  = &physicalDeviceLineRasterizationFeaturesEXT.pNext;
 297         }
 298
 299         vk::VkPhysicalDeviceMemoryPriorityFeaturesEXT physicalDeviceMemoryPriorityFeaturesEXT;
 300         deMemset(&physicalDeviceMemoryPriorityFeaturesEXT, 0, sizeof(physicalDeviceMemoryPriorityFeaturesEXT));
 301
 302         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_memory_priority")) )
 303         {
 304                 physicalDeviceMemoryPriorityFeaturesEXT.sType = getStructureType<VkPhysicalDeviceMemoryPriorityFeaturesEXT>();
 305                 *nextPtr = &physicalDeviceMemoryPriorityFeaturesEXT;
 306                 nextPtr  = &physicalDeviceMemoryPriorityFeaturesEXT.pNext;
 307         }
 308
 309 #if defined(CTS_USES_VULKAN)
 310         vk::VkPhysicalDeviceMeshShaderFeaturesEXT physicalDeviceMeshShaderFeaturesEXT;
 311         deMemset(&physicalDeviceMeshShaderFeaturesEXT, 0, sizeof(physicalDeviceMeshShaderFeaturesEXT));
 312
 313         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_mesh_shader")) )
 314         {
 315                 physicalDeviceMeshShaderFeaturesEXT.sType = getStructureType<VkPhysicalDeviceMeshShaderFeaturesEXT>();
 316                 *nextPtr = &physicalDeviceMeshShaderFeaturesEXT;
 317                 nextPtr  = &physicalDeviceMeshShaderFeaturesEXT.pNext;
 318         }
 319 #endif // defined(CTS_USES_VULKAN)
 320
 321         vk::VkPhysicalDeviceMultiDrawFeaturesEXT physicalDeviceMultiDrawFeaturesEXT;
 322         deMemset(&physicalDeviceMultiDrawFeaturesEXT, 0, sizeof(physicalDeviceMultiDrawFeaturesEXT));
 323
 324         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_multi_draw")) )
 325         {
 326                 physicalDeviceMultiDrawFeaturesEXT.sType = getStructureType<VkPhysicalDeviceMultiDrawFeaturesEXT>();
 327                 *nextPtr = &physicalDeviceMultiDrawFeaturesEXT;
 328                 nextPtr  = &physicalDeviceMultiDrawFeaturesEXT.pNext;
 329         }
 330
 331         vk::VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;
 332         deMemset(&physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, 0, sizeof(physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT));
 333
 334         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_multisampled_render_to_single_sampled")) )
 335         {
 336                 physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.sType = getStructureType<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT>();
 337                 *nextPtr = &physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;
 338                 nextPtr  = &physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.pNext;
 339         }
 340
 341         vk::VkPhysicalDeviceMultiviewFeatures physicalDeviceMultiviewFeatures;
 342         deMemset(&physicalDeviceMultiviewFeatures, 0, sizeof(physicalDeviceMultiviewFeatures));
 343
 344         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_multiview")) || context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) )
 345         {
 346                 physicalDeviceMultiviewFeatures.sType = getStructureType<VkPhysicalDeviceMultiviewFeatures>();
 347                 *nextPtr = &physicalDeviceMultiviewFeatures;
 348                 nextPtr  = &physicalDeviceMultiviewFeatures.pNext;
 349         }
 350
 351         vk::VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE physicalDeviceMutableDescriptorTypeFeaturesVALVE;
 352         deMemset(&physicalDeviceMutableDescriptorTypeFeaturesVALVE, 0, sizeof(physicalDeviceMutableDescriptorTypeFeaturesVALVE));
 353
 354         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_VALVE_mutable_descriptor_type")) )
 355         {
 356                 physicalDeviceMutableDescriptorTypeFeaturesVALVE.sType = getStructureType<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE>();
 357                 *nextPtr = &physicalDeviceMutableDescriptorTypeFeaturesVALVE;
 358                 nextPtr  = &physicalDeviceMutableDescriptorTypeFeaturesVALVE.pNext;
 359         }
 360
 361 #if defined(CTS_USES_VULKAN)
 362         vk::VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT physicalDeviceNonSeamlessCubeMapFeaturesEXT;
 363         deMemset(&physicalDeviceNonSeamlessCubeMapFeaturesEXT, 0, sizeof(physicalDeviceNonSeamlessCubeMapFeaturesEXT));
 364
 365         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_non_seamless_cube_map")) )
 366         {
 367                 physicalDeviceNonSeamlessCubeMapFeaturesEXT.sType = getStructureType<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT>();
 368                 *nextPtr = &physicalDeviceNonSeamlessCubeMapFeaturesEXT;
 369                 nextPtr  = &physicalDeviceNonSeamlessCubeMapFeaturesEXT.pNext;
 370         }
 371 #endif // defined(CTS_USES_VULKAN)
 372
 373 #if defined(CTS_USES_VULKAN)
 374         vk::VkPhysicalDeviceOpacityMicromapFeaturesEXT physicalDeviceOpacityMicromapFeaturesEXT;
 375         deMemset(&physicalDeviceOpacityMicromapFeaturesEXT, 0, sizeof(physicalDeviceOpacityMicromapFeaturesEXT));
 376
 377         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_opacity_micromap")) )
 378         {
 379                 physicalDeviceOpacityMicromapFeaturesEXT.sType = getStructureType<VkPhysicalDeviceOpacityMicromapFeaturesEXT>();
 380                 *nextPtr = &physicalDeviceOpacityMicromapFeaturesEXT;
 381                 nextPtr  = &physicalDeviceOpacityMicromapFeaturesEXT.pNext;
 382         }
 383 #endif // defined(CTS_USES_VULKAN)
 384
 385 #if defined(CTS_USES_VULKAN)
 386         vk::VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT physicalDevicePageableDeviceLocalMemoryFeaturesEXT;
 387         deMemset(&physicalDevicePageableDeviceLocalMemoryFeaturesEXT, 0, sizeof(physicalDevicePageableDeviceLocalMemoryFeaturesEXT));
 388
 389         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_pageable_device_local_memory")) )
 390         {
 391                 physicalDevicePageableDeviceLocalMemoryFeaturesEXT.sType = getStructureType<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT>();
 392                 *nextPtr = &physicalDevicePageableDeviceLocalMemoryFeaturesEXT;
 393                 nextPtr  = &physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pNext;
 394         }
 395 #endif // defined(CTS_USES_VULKAN)
 396
 397         vk::VkPhysicalDevicePerformanceQueryFeaturesKHR physicalDevicePerformanceQueryFeaturesKHR;
 398         deMemset(&physicalDevicePerformanceQueryFeaturesKHR, 0, sizeof(physicalDevicePerformanceQueryFeaturesKHR));
 399
 400         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_performance_query")) )
 401         {
 402                 physicalDevicePerformanceQueryFeaturesKHR.sType = getStructureType<VkPhysicalDevicePerformanceQueryFeaturesKHR>();
 403                 *nextPtr = &physicalDevicePerformanceQueryFeaturesKHR;
 404                 nextPtr  = &physicalDevicePerformanceQueryFeaturesKHR.pNext;
 405         }
 406
 407         vk::VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR physicalDevicePipelineExecutablePropertiesFeaturesKHR;
 408         deMemset(&physicalDevicePipelineExecutablePropertiesFeaturesKHR, 0, sizeof(physicalDevicePipelineExecutablePropertiesFeaturesKHR));
 409
 410         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_pipeline_executable_properties")) )
 411         {
 412                 physicalDevicePipelineExecutablePropertiesFeaturesKHR.sType = getStructureType<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>();
 413                 *nextPtr = &physicalDevicePipelineExecutablePropertiesFeaturesKHR;
 414                 nextPtr  = &physicalDevicePipelineExecutablePropertiesFeaturesKHR.pNext;
 415         }
 416
 417 #if defined(CTS_USES_VULKAN)
 418         vk::VkPhysicalDevicePresentIdFeaturesKHR physicalDevicePresentIdFeaturesKHR;
 419         deMemset(&physicalDevicePresentIdFeaturesKHR, 0, sizeof(physicalDevicePresentIdFeaturesKHR));
 420
 421         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_present_id")) )
 422         {
 423                 physicalDevicePresentIdFeaturesKHR.sType = getStructureType<VkPhysicalDevicePresentIdFeaturesKHR>();
 424                 *nextPtr = &physicalDevicePresentIdFeaturesKHR;
 425                 nextPtr  = &physicalDevicePresentIdFeaturesKHR.pNext;
 426         }
 427 #endif // defined(CTS_USES_VULKAN)
 428
 429 #if defined(CTS_USES_VULKAN)
 430         vk::VkPhysicalDevicePresentWaitFeaturesKHR physicalDevicePresentWaitFeaturesKHR;
 431         deMemset(&physicalDevicePresentWaitFeaturesKHR, 0, sizeof(physicalDevicePresentWaitFeaturesKHR));
 432
 433         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_present_wait")) )
 434         {
 435                 physicalDevicePresentWaitFeaturesKHR.sType = getStructureType<VkPhysicalDevicePresentWaitFeaturesKHR>();
 436                 *nextPtr = &physicalDevicePresentWaitFeaturesKHR;
 437                 nextPtr  = &physicalDevicePresentWaitFeaturesKHR.pNext;
 438         }
 439 #endif // defined(CTS_USES_VULKAN)
 440
 441 #if defined(CTS_USES_VULKAN)
 442         vk::VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT physicalDevicePrimitiveTopologyListRestartFeaturesEXT;
 443         deMemset(&physicalDevicePrimitiveTopologyListRestartFeaturesEXT, 0, sizeof(physicalDevicePrimitiveTopologyListRestartFeaturesEXT));
 444
 445         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_primitive_topology_list_restart")) )
 446         {
 447                 physicalDevicePrimitiveTopologyListRestartFeaturesEXT.sType = getStructureType<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>();
 448                 *nextPtr = &physicalDevicePrimitiveTopologyListRestartFeaturesEXT;
 449                 nextPtr  = &physicalDevicePrimitiveTopologyListRestartFeaturesEXT.pNext;
 450         }
 451 #endif // defined(CTS_USES_VULKAN)
 452
 453         vk::VkPhysicalDeviceRayQueryFeaturesKHR physicalDeviceRayQueryFeaturesKHR;
 454         deMemset(&physicalDeviceRayQueryFeaturesKHR, 0, sizeof(physicalDeviceRayQueryFeaturesKHR));
 455
 456         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_ray_query")) )
 457         {
 458                 physicalDeviceRayQueryFeaturesKHR.sType = getStructureType<VkPhysicalDeviceRayQueryFeaturesKHR>();
 459                 *nextPtr = &physicalDeviceRayQueryFeaturesKHR;
 460                 nextPtr  = &physicalDeviceRayQueryFeaturesKHR.pNext;
 461         }
 462
 463         vk::VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR physicalDeviceRayTracingMaintenance1FeaturesKHR;
 464         deMemset(&physicalDeviceRayTracingMaintenance1FeaturesKHR, 0, sizeof(physicalDeviceRayTracingMaintenance1FeaturesKHR));
 465
 466         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_ray_tracing_maintenance1")) )
 467         {
 468                 physicalDeviceRayTracingMaintenance1FeaturesKHR.sType = getStructureType<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR>();
 469                 *nextPtr = &physicalDeviceRayTracingMaintenance1FeaturesKHR;
 470                 nextPtr  = &physicalDeviceRayTracingMaintenance1FeaturesKHR.pNext;
 471         }
 472
 473         vk::VkPhysicalDeviceRayTracingPipelineFeaturesKHR physicalDeviceRayTracingPipelineFeaturesKHR;
 474         deMemset(&physicalDeviceRayTracingPipelineFeaturesKHR, 0, sizeof(physicalDeviceRayTracingPipelineFeaturesKHR));
 475
 476         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_ray_tracing_pipeline")) )
 477         {
 478                 physicalDeviceRayTracingPipelineFeaturesKHR.sType = getStructureType<VkPhysicalDeviceRayTracingPipelineFeaturesKHR>();
 479                 *nextPtr = &physicalDeviceRayTracingPipelineFeaturesKHR;
 480                 nextPtr  = &physicalDeviceRayTracingPipelineFeaturesKHR.pNext;
 481         }
 482
 483         vk::VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR physicalDeviceSamplerYcbcrConversionFeaturesKHR;
 484         deMemset(&physicalDeviceSamplerYcbcrConversionFeaturesKHR, 0, sizeof(physicalDeviceSamplerYcbcrConversionFeaturesKHR));
 485
 486         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_sampler_ycbcr_conversion")) )
 487         {
 488                 physicalDeviceSamplerYcbcrConversionFeaturesKHR.sType = getStructureType<VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR>();
 489                 *nextPtr = &physicalDeviceSamplerYcbcrConversionFeaturesKHR;
 490                 nextPtr  = &physicalDeviceSamplerYcbcrConversionFeaturesKHR.pNext;
 491         }
 492
 493         vk::VkPhysicalDeviceScalarBlockLayoutFeatures physicalDeviceScalarBlockLayoutFeatures;
 494         deMemset(&physicalDeviceScalarBlockLayoutFeatures, 0, sizeof(physicalDeviceScalarBlockLayoutFeatures));
 495
 496         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_scalar_block_layout")) )
 497         {
 498                 physicalDeviceScalarBlockLayoutFeatures.sType = getStructureType<VkPhysicalDeviceScalarBlockLayoutFeatures>();
 499                 *nextPtr = &physicalDeviceScalarBlockLayoutFeatures;
 500                 nextPtr  = &physicalDeviceScalarBlockLayoutFeatures.pNext;
 501         }
 502
 503         vk::VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures physicalDeviceSeparateDepthStencilLayoutsFeatures;
 504         deMemset(&physicalDeviceSeparateDepthStencilLayoutsFeatures, 0, sizeof(physicalDeviceSeparateDepthStencilLayoutsFeatures));
 505
 506         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_separate_depth_stencil_layouts")) )
 507         {
 508                 physicalDeviceSeparateDepthStencilLayoutsFeatures.sType = getStructureType<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures>();
 509                 *nextPtr = &physicalDeviceSeparateDepthStencilLayoutsFeatures;
 510                 nextPtr  = &physicalDeviceSeparateDepthStencilLayoutsFeatures.pNext;
 511         }
 512
 513 #if defined(CTS_USES_VULKAN)
 514         vk::VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT physicalDeviceShaderAtomicFloat2FeaturesEXT;
 515         deMemset(&physicalDeviceShaderAtomicFloat2FeaturesEXT, 0, sizeof(physicalDeviceShaderAtomicFloat2FeaturesEXT));
 516
 517         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_atomic_float2")) )
 518         {
 519                 physicalDeviceShaderAtomicFloat2FeaturesEXT.sType = getStructureType<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>();
 520                 *nextPtr = &physicalDeviceShaderAtomicFloat2FeaturesEXT;
 521                 nextPtr  = &physicalDeviceShaderAtomicFloat2FeaturesEXT.pNext;
 522         }
 523 #endif // defined(CTS_USES_VULKAN)
 524
 525         vk::VkPhysicalDeviceShaderAtomicFloatFeaturesEXT physicalDeviceShaderAtomicFloatFeaturesEXT;
 526         deMemset(&physicalDeviceShaderAtomicFloatFeaturesEXT, 0, sizeof(physicalDeviceShaderAtomicFloatFeaturesEXT));
 527
 528         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_atomic_float")) )
 529         {
 530                 physicalDeviceShaderAtomicFloatFeaturesEXT.sType = getStructureType<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>();
 531                 *nextPtr = &physicalDeviceShaderAtomicFloatFeaturesEXT;
 532                 nextPtr  = &physicalDeviceShaderAtomicFloatFeaturesEXT.pNext;
 533         }
 534
 535         vk::VkPhysicalDeviceShaderAtomicInt64Features physicalDeviceShaderAtomicInt64Features;
 536         deMemset(&physicalDeviceShaderAtomicInt64Features, 0, sizeof(physicalDeviceShaderAtomicInt64Features));
 537
 538         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_atomic_int64")) )
 539         {
 540                 physicalDeviceShaderAtomicInt64Features.sType = getStructureType<VkPhysicalDeviceShaderAtomicInt64Features>();
 541                 *nextPtr = &physicalDeviceShaderAtomicInt64Features;
 542                 nextPtr  = &physicalDeviceShaderAtomicInt64Features.pNext;
 543         }
 544
 545         vk::VkPhysicalDeviceShaderClockFeaturesKHR physicalDeviceShaderClockFeaturesKHR;
 546         deMemset(&physicalDeviceShaderClockFeaturesKHR, 0, sizeof(physicalDeviceShaderClockFeaturesKHR));
 547
 548         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_clock")) )
 549         {
 550                 physicalDeviceShaderClockFeaturesKHR.sType = getStructureType<VkPhysicalDeviceShaderClockFeaturesKHR>();
 551                 *nextPtr = &physicalDeviceShaderClockFeaturesKHR;
 552                 nextPtr  = &physicalDeviceShaderClockFeaturesKHR.pNext;
 553         }
 554
 555         vk::VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
 556         deMemset(&physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, 0, sizeof(physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT));
 557
 558         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_demote_to_helper_invocation")) )
 559         {
 560                 physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.sType = getStructureType<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>();
 561                 *nextPtr = &physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
 562                 nextPtr  = &physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.pNext;
 563         }
 564
 565         vk::VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD;
 566         deMemset(&physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, 0, sizeof(physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD));
 567
 568         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_AMD_shader_early_and_late_fragment_tests")) )
 569         {
 570                 physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.sType = getStructureType<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD>();
 571                 *nextPtr = &physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD;
 572                 nextPtr  = &physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.pNext;
 573         }
 574
 575         vk::VkPhysicalDeviceShaderFloat16Int8Features physicalDeviceShaderFloat16Int8Features;
 576         deMemset(&physicalDeviceShaderFloat16Int8Features, 0, sizeof(physicalDeviceShaderFloat16Int8Features));
 577
 578         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_float16_int8")) )
 579         {
 580                 physicalDeviceShaderFloat16Int8Features.sType = getStructureType<VkPhysicalDeviceShaderFloat16Int8Features>();
 581                 *nextPtr = &physicalDeviceShaderFloat16Int8Features;
 582                 nextPtr  = &physicalDeviceShaderFloat16Int8Features.pNext;
 583         }
 584
 585         vk::VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT physicalDeviceShaderImageAtomicInt64FeaturesEXT;
 586         deMemset(&physicalDeviceShaderImageAtomicInt64FeaturesEXT, 0, sizeof(physicalDeviceShaderImageAtomicInt64FeaturesEXT));
 587
 588         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_image_atomic_int64")) )
 589         {
 590                 physicalDeviceShaderImageAtomicInt64FeaturesEXT.sType = getStructureType<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT>();
 591                 *nextPtr = &physicalDeviceShaderImageAtomicInt64FeaturesEXT;
 592                 nextPtr  = &physicalDeviceShaderImageAtomicInt64FeaturesEXT.pNext;
 593         }
 594
 595 #if defined(CTS_USES_VULKAN)
 596         vk::VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR physicalDeviceShaderIntegerDotProductFeaturesKHR;
 597         deMemset(&physicalDeviceShaderIntegerDotProductFeaturesKHR, 0, sizeof(physicalDeviceShaderIntegerDotProductFeaturesKHR));
 598
 599         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_integer_dot_product")) )
 600         {
 601                 physicalDeviceShaderIntegerDotProductFeaturesKHR.sType = getStructureType<VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR>();
 602                 *nextPtr = &physicalDeviceShaderIntegerDotProductFeaturesKHR;
 603                 nextPtr  = &physicalDeviceShaderIntegerDotProductFeaturesKHR.pNext;
 604         }
 605 #endif // defined(CTS_USES_VULKAN)
 606
 607         vk::VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT physicalDeviceShaderModuleIdentifierFeaturesEXT;
 608         deMemset(&physicalDeviceShaderModuleIdentifierFeaturesEXT, 0, sizeof(physicalDeviceShaderModuleIdentifierFeaturesEXT));
 609
 610         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_module_identifier")) )
 611         {
 612                 physicalDeviceShaderModuleIdentifierFeaturesEXT.sType = getStructureType<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT>();
 613                 *nextPtr = &physicalDeviceShaderModuleIdentifierFeaturesEXT;
 614                 nextPtr  = &physicalDeviceShaderModuleIdentifierFeaturesEXT.pNext;
 615         }
 616
 617         vk::VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures physicalDeviceShaderSubgroupExtendedTypesFeatures;
 618         deMemset(&physicalDeviceShaderSubgroupExtendedTypesFeatures, 0, sizeof(physicalDeviceShaderSubgroupExtendedTypesFeatures));
 619
 620         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_subgroup_extended_types")) )
 621         {
 622                 physicalDeviceShaderSubgroupExtendedTypesFeatures.sType = getStructureType<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures>();
 623                 *nextPtr = &physicalDeviceShaderSubgroupExtendedTypesFeatures;
 624                 nextPtr  = &physicalDeviceShaderSubgroupExtendedTypesFeatures.pNext;
 625         }
 626
 627         vk::VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
 628         deMemset(&physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, 0, sizeof(physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR));
 629
 630         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_subgroup_uniform_control_flow")) )
 631         {
 632                 physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.sType = getStructureType<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>();
 633                 *nextPtr = &physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
 634                 nextPtr  = &physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.pNext;
 635         }
 636
 637         vk::VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR physicalDeviceShaderTerminateInvocationFeaturesKHR;
 638         deMemset(&physicalDeviceShaderTerminateInvocationFeaturesKHR, 0, sizeof(physicalDeviceShaderTerminateInvocationFeaturesKHR));
 639
 640         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_terminate_invocation")) )
 641         {
 642                 physicalDeviceShaderTerminateInvocationFeaturesKHR.sType = getStructureType<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR>();
 643                 *nextPtr = &physicalDeviceShaderTerminateInvocationFeaturesKHR;
 644                 nextPtr  = &physicalDeviceShaderTerminateInvocationFeaturesKHR.pNext;
 645         }
 646
 647         vk::VkPhysicalDeviceSubgroupSizeControlFeaturesEXT physicalDeviceSubgroupSizeControlFeaturesEXT;
 648         deMemset(&physicalDeviceSubgroupSizeControlFeaturesEXT, 0, sizeof(physicalDeviceSubgroupSizeControlFeaturesEXT));
 649
 650         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_subgroup_size_control")) )
 651         {
 652                 physicalDeviceSubgroupSizeControlFeaturesEXT.sType = getStructureType<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT>();
 653                 *nextPtr = &physicalDeviceSubgroupSizeControlFeaturesEXT;
 654                 nextPtr  = &physicalDeviceSubgroupSizeControlFeaturesEXT.pNext;
 655         }
 656
 657         vk::VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT physicalDeviceSubpassMergeFeedbackFeaturesEXT;
 658         deMemset(&physicalDeviceSubpassMergeFeedbackFeaturesEXT, 0, sizeof(physicalDeviceSubpassMergeFeedbackFeaturesEXT));
 659
 660         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_subpass_merge_feedback")) )
 661         {
 662                 physicalDeviceSubpassMergeFeedbackFeaturesEXT.sType = getStructureType<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT>();
 663                 *nextPtr = &physicalDeviceSubpassMergeFeedbackFeaturesEXT;
 664                 nextPtr  = &physicalDeviceSubpassMergeFeedbackFeaturesEXT.pNext;
 665         }
 666
 667         vk::VkPhysicalDeviceSynchronization2FeaturesKHR physicalDeviceSynchronization2FeaturesKHR;
 668         deMemset(&physicalDeviceSynchronization2FeaturesKHR, 0, sizeof(physicalDeviceSynchronization2FeaturesKHR));
 669
 670         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_synchronization2")) )
 671         {
 672                 physicalDeviceSynchronization2FeaturesKHR.sType = getStructureType<VkPhysicalDeviceSynchronization2FeaturesKHR>();
 673                 *nextPtr = &physicalDeviceSynchronization2FeaturesKHR;
 674                 nextPtr  = &physicalDeviceSynchronization2FeaturesKHR.pNext;
 675         }
 676
 677         vk::VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT physicalDeviceTexelBufferAlignmentFeaturesEXT;
 678         deMemset(&physicalDeviceTexelBufferAlignmentFeaturesEXT, 0, sizeof(physicalDeviceTexelBufferAlignmentFeaturesEXT));
 679
 680         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_texel_buffer_alignment")) )
 681         {
 682                 physicalDeviceTexelBufferAlignmentFeaturesEXT.sType = getStructureType<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT>();
 683                 *nextPtr = &physicalDeviceTexelBufferAlignmentFeaturesEXT;
 684                 nextPtr  = &physicalDeviceTexelBufferAlignmentFeaturesEXT.pNext;
 685         }
 686
 687         vk::VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT physicalDeviceTextureCompressionASTCHDRFeaturesEXT;
 688         deMemset(&physicalDeviceTextureCompressionASTCHDRFeaturesEXT, 0, sizeof(physicalDeviceTextureCompressionASTCHDRFeaturesEXT));
 689
 690         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_texture_compression_astc_hdr")) )
 691         {
 692                 physicalDeviceTextureCompressionASTCHDRFeaturesEXT.sType = getStructureType<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT>();
 693                 *nextPtr = &physicalDeviceTextureCompressionASTCHDRFeaturesEXT;
 694                 nextPtr  = &physicalDeviceTextureCompressionASTCHDRFeaturesEXT.pNext;
 695         }
 696
 697 #if defined(CTS_USES_VULKAN)
 698         vk::VkPhysicalDeviceTimelineSemaphoreFeatures physicalDeviceTimelineSemaphoreFeatures;
 699         deMemset(&physicalDeviceTimelineSemaphoreFeatures, 0, sizeof(physicalDeviceTimelineSemaphoreFeatures));
 700
 701         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_timeline_semaphore")) )
 702         {
 703                 physicalDeviceTimelineSemaphoreFeatures.sType = getStructureType<VkPhysicalDeviceTimelineSemaphoreFeatures>();
 704                 *nextPtr = &physicalDeviceTimelineSemaphoreFeatures;
 705                 nextPtr  = &physicalDeviceTimelineSemaphoreFeatures.pNext;
 706         }
 707 #endif // defined(CTS_USES_VULKAN)
 708
 709         vk::VkPhysicalDeviceTransformFeedbackFeaturesEXT physicalDeviceTransformFeedbackFeaturesEXT;
 710         deMemset(&physicalDeviceTransformFeedbackFeaturesEXT, 0, sizeof(physicalDeviceTransformFeedbackFeaturesEXT));
 711
 712         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_transform_feedback")) )
 713         {
 714                 physicalDeviceTransformFeedbackFeaturesEXT.sType = getStructureType<VkPhysicalDeviceTransformFeedbackFeaturesEXT>();
 715                 *nextPtr = &physicalDeviceTransformFeedbackFeaturesEXT;
 716                 nextPtr  = &physicalDeviceTransformFeedbackFeaturesEXT.pNext;
 717         }
 718
 719         vk::VkPhysicalDeviceUniformBufferStandardLayoutFeatures physicalDeviceUniformBufferStandardLayoutFeatures;
 720         deMemset(&physicalDeviceUniformBufferStandardLayoutFeatures, 0, sizeof(physicalDeviceUniformBufferStandardLayoutFeatures));
 721
 722         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_uniform_buffer_standard_layout")) )
 723         {
 724                 physicalDeviceUniformBufferStandardLayoutFeatures.sType = getStructureType<VkPhysicalDeviceUniformBufferStandardLayoutFeatures>();
 725                 *nextPtr = &physicalDeviceUniformBufferStandardLayoutFeatures;
 726                 nextPtr  = &physicalDeviceUniformBufferStandardLayoutFeatures.pNext;
 727         }
 728
 729         vk::VkPhysicalDeviceVariablePointersFeatures physicalDeviceVariablePointersFeatures;
 730         deMemset(&physicalDeviceVariablePointersFeatures, 0, sizeof(physicalDeviceVariablePointersFeatures));
 731
 732         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_variable_pointers")) )
 733         {
 734                 physicalDeviceVariablePointersFeatures.sType = getStructureType<VkPhysicalDeviceVariablePointersFeatures>();
 735                 *nextPtr = &physicalDeviceVariablePointersFeatures;
 736                 nextPtr  = &physicalDeviceVariablePointersFeatures.pNext;
 737         }
 738
 739         vk::VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT physicalDeviceVertexAttributeDivisorFeaturesEXT;
 740         deMemset(&physicalDeviceVertexAttributeDivisorFeaturesEXT, 0, sizeof(physicalDeviceVertexAttributeDivisorFeaturesEXT));
 741
 742         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_vertex_attribute_divisor")) )
 743         {
 744                 physicalDeviceVertexAttributeDivisorFeaturesEXT.sType = getStructureType<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT>();
 745                 *nextPtr = &physicalDeviceVertexAttributeDivisorFeaturesEXT;
 746                 nextPtr  = &physicalDeviceVertexAttributeDivisorFeaturesEXT.pNext;
 747         }
 748
 749         vk::VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT physicalDeviceVertexInputDynamicStateFeaturesEXT;
 750         deMemset(&physicalDeviceVertexInputDynamicStateFeaturesEXT, 0, sizeof(physicalDeviceVertexInputDynamicStateFeaturesEXT));
 751
 752         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_vertex_input_dynamic_state")) )
 753         {
 754                 physicalDeviceVertexInputDynamicStateFeaturesEXT.sType = getStructureType<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT>();
 755                 *nextPtr = &physicalDeviceVertexInputDynamicStateFeaturesEXT;
 756                 nextPtr  = &physicalDeviceVertexInputDynamicStateFeaturesEXT.pNext;
 757         }
 758
 759 #if defined(CTS_USES_VULKAN)
 760         vk::VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features;
 761         deMemset(&physicalDeviceVulkan11Features, 0, sizeof(physicalDeviceVulkan11Features));
 762
 763         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) )
 764         {
 765                 physicalDeviceVulkan11Features.sType = getStructureType<VkPhysicalDeviceVulkan11Features>();
 766                 *nextPtr = &physicalDeviceVulkan11Features;
 767                 nextPtr  = &physicalDeviceVulkan11Features.pNext;
 768         }
 769 #endif // defined(CTS_USES_VULKAN)
 770
 771         vk::VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features;
 772         deMemset(&physicalDeviceVulkan12Features, 0, sizeof(physicalDeviceVulkan12Features));
 773
 774         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) || context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
 775         {
 776                 physicalDeviceVulkan12Features.sType = getStructureType<VkPhysicalDeviceVulkan12Features>();
 777                 *nextPtr = &physicalDeviceVulkan12Features;
 778                 nextPtr  = &physicalDeviceVulkan12Features.pNext;
 779         }
 780
 781 #if defined(CTS_USES_VULKAN)
 782         vk::VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features;
 783         deMemset(&physicalDeviceVulkan13Features, 0, sizeof(physicalDeviceVulkan13Features));
 784
 785         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
 786         {
 787                 physicalDeviceVulkan13Features.sType = getStructureType<VkPhysicalDeviceVulkan13Features>();
 788                 *nextPtr = &physicalDeviceVulkan13Features;
 789                 nextPtr  = &physicalDeviceVulkan13Features.pNext;
 790         }
 791 #endif // defined(CTS_USES_VULKAN)
 792
 793         vk::VkPhysicalDeviceVulkanMemoryModelFeatures physicalDeviceVulkanMemoryModelFeatures;
 794         deMemset(&physicalDeviceVulkanMemoryModelFeatures, 0, sizeof(physicalDeviceVulkanMemoryModelFeatures));
 795
 796         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_vulkan_memory_model")) )
 797         {
 798                 physicalDeviceVulkanMemoryModelFeatures.sType = getStructureType<VkPhysicalDeviceVulkanMemoryModelFeatures>();
 799                 *nextPtr = &physicalDeviceVulkanMemoryModelFeatures;
 800                 nextPtr  = &physicalDeviceVulkanMemoryModelFeatures.pNext;
 801         }
 802
 803         vk::VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
 804         deMemset(&physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, 0, sizeof(physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR));
 805
 806         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_workgroup_memory_explicit_layout")) )
 807         {
 808                 physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.sType = getStructureType<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>();
 809                 *nextPtr = &physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
 810                 nextPtr  = &physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.pNext;
 811         }
 812
 813         vk::VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT physicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
 814         deMemset(&physicalDeviceYcbcr2Plane444FormatsFeaturesEXT, 0, sizeof(physicalDeviceYcbcr2Plane444FormatsFeaturesEXT));
 815
 816         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_ycbcr_2plane_444_formats")) )
 817         {
 818                 physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.sType = getStructureType<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT>();
 819                 *nextPtr = &physicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
 820                 nextPtr  = &physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.pNext;
 821         }
 822
 823         vk::VkPhysicalDeviceYcbcrImageArraysFeaturesEXT physicalDeviceYcbcrImageArraysFeaturesEXT;
 824         deMemset(&physicalDeviceYcbcrImageArraysFeaturesEXT, 0, sizeof(physicalDeviceYcbcrImageArraysFeaturesEXT));
 825
 826         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_ycbcr_image_arrays")) )
 827         {
 828                 physicalDeviceYcbcrImageArraysFeaturesEXT.sType = getStructureType<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT>();
 829                 *nextPtr = &physicalDeviceYcbcrImageArraysFeaturesEXT;
 830                 nextPtr  = &physicalDeviceYcbcrImageArraysFeaturesEXT.pNext;
 831         }
 832
 833         vk::VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;
 834         deMemset(&physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR, 0, sizeof(physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR));
 835
 836         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_zero_initialize_workgroup_memory")) )
 837         {
 838                 physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.sType = getStructureType<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR>();
 839                 *nextPtr = &physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;
 840                 nextPtr  = &physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.pNext;
 841         }
 842
 843         context.getInstanceInterface().getPhysicalDeviceFeatures2(context.getPhysicalDevice(), &coreFeatures);
 844         bool result = true;
 845
 846         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_AMD_shader_early_and_late_fragment_tests")) )
 847         {
 848                 if ( physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.shaderEarlyAndLateFragmentTests == VK_FALSE )
 849                 {
 850                         log << tcu::TestLog::Message << "Mandatory feature shaderEarlyAndLateFragmentTests not supported" << tcu::TestLog::EndMessage;
 851                         result = false;
 852                 }
 853         }
 854
 855         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_4444_formats")) )
 856         {
 857                 if ( physicalDevice4444FormatsFeaturesEXT.formatA4R4G4B4 == VK_FALSE )
 858                 {
 859                         log << tcu::TestLog::Message << "Mandatory feature formatA4R4G4B4 not supported" << tcu::TestLog::EndMessage;
 860                         result = false;
 861                 }
 862         }
 863
 864 #if defined(CTS_USES_VULKAN)
 865         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_attachment_feedback_loop_layout")) )
 866         {
 867                 if ( physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.attachmentFeedbackLoopLayout == VK_FALSE )
 868                 {
 869                         log << tcu::TestLog::Message << "Mandatory feature attachmentFeedbackLoopLayout not supported" << tcu::TestLog::EndMessage;
 870                         result = false;
 871                 }
 872         }
 873 #endif // defined(CTS_USES_VULKAN)
 874
 875 #if defined(CTS_USES_VULKAN)
 876         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_border_color_swizzle")) )
 877         {
 878                 if ( physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzle == VK_FALSE )
 879                 {
 880                         log << tcu::TestLog::Message << "Mandatory feature borderColorSwizzle not supported" << tcu::TestLog::EndMessage;
 881                         result = false;
 882                 }
 883         }
 884 #endif // defined(CTS_USES_VULKAN)
 885
 886         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_color_write_enable")) )
 887         {
 888                 if ( physicalDeviceColorWriteEnableFeaturesEXT.colorWriteEnable == VK_FALSE )
 889                 {
 890                         log << tcu::TestLog::Message << "Mandatory feature colorWriteEnable not supported" << tcu::TestLog::EndMessage;
 891                         result = false;
 892                 }
 893         }
 894
 895         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_conditional_rendering")) )
 896         {
 897                 if ( physicalDeviceConditionalRenderingFeaturesEXT.conditionalRendering == VK_FALSE )
 898                 {
 899                         log << tcu::TestLog::Message << "Mandatory feature conditionalRendering not supported" << tcu::TestLog::EndMessage;
 900                         result = false;
 901                 }
 902         }
 903
 904         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_depth_clamp_zero_one")) )
 905         {
 906                 if ( physicalDeviceDepthClampZeroOneFeaturesEXT.depthClampZeroOne == VK_FALSE )
 907                 {
 908                         log << tcu::TestLog::Message << "Mandatory feature depthClampZeroOne not supported" << tcu::TestLog::EndMessage;
 909                         result = false;
 910                 }
 911         }
 912
 913         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_depth_clip_control")) )
 914         {
 915                 if ( physicalDeviceDepthClipControlFeaturesEXT.depthClipControl == VK_FALSE )
 916                 {
 917                         log << tcu::TestLog::Message << "Mandatory feature depthClipControl not supported" << tcu::TestLog::EndMessage;
 918                         result = false;
 919                 }
 920         }
 921
 922         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_depth_clip_enable")) )
 923         {
 924                 if ( physicalDeviceDepthClipEnableFeaturesEXT.depthClipEnable == VK_FALSE )
 925                 {
 926                         log << tcu::TestLog::Message << "Mandatory feature depthClipEnable not supported" << tcu::TestLog::EndMessage;
 927                         result = false;
 928                 }
 929         }
 930
 931         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
 932         {
 933                 if ( physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayDynamicIndexing == VK_FALSE )
 934                 {
 935                         log << tcu::TestLog::Message << "Mandatory feature shaderUniformTexelBufferArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
 936                         result = false;
 937                 }
 938         }
 939
 940         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
 941         {
 942                 if ( physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayDynamicIndexing == VK_FALSE )
 943                 {
 944                         log << tcu::TestLog::Message << "Mandatory feature shaderStorageTexelBufferArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
 945                         result = false;
 946                 }
 947         }
 948
 949         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
 950         {
 951                 if ( physicalDeviceDescriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing == VK_FALSE )
 952                 {
 953                         log << tcu::TestLog::Message << "Mandatory feature shaderSampledImageArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
 954                         result = false;
 955                 }
 956         }
 957
 958         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
 959         {
 960                 if ( physicalDeviceDescriptorIndexingFeatures.shaderStorageBufferArrayNonUniformIndexing == VK_FALSE )
 961                 {
 962                         log << tcu::TestLog::Message << "Mandatory feature shaderStorageBufferArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
 963                         result = false;
 964                 }
 965         }
 966
 967         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
 968         {
 969                 if ( physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayNonUniformIndexing == VK_FALSE )
 970                 {
 971                         log << tcu::TestLog::Message << "Mandatory feature shaderUniformTexelBufferArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
 972                         result = false;
 973                 }
 974         }
 975
 976         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
 977         {
 978                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind == VK_FALSE )
 979                 {
 980                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingSampledImageUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
 981                         result = false;
 982                 }
 983         }
 984
 985         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
 986         {
 987                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageImageUpdateAfterBind == VK_FALSE )
 988                 {
 989                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageImageUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
 990                         result = false;
 991                 }
 992         }
 993
 994         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
 995         {
 996                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageBufferUpdateAfterBind == VK_FALSE )
 997                 {
 998                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
 999                         result = false;
1000                 }
1001         }
1002
1003         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1004         {
1005                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformTexelBufferUpdateAfterBind == VK_FALSE )
1006                 {
1007                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingUniformTexelBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
1008                         result = false;
1009                 }
1010         }
1011
1012         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1013         {
1014                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageTexelBufferUpdateAfterBind == VK_FALSE )
1015                 {
1016                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageTexelBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
1017                         result = false;
1018                 }
1019         }
1020
1021         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1022         {
1023                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingUpdateUnusedWhilePending == VK_FALSE )
1024                 {
1025                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingUpdateUnusedWhilePending not supported" << tcu::TestLog::EndMessage;
1026                         result = false;
1027                 }
1028         }
1029
1030         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1031         {
1032                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingPartiallyBound == VK_FALSE )
1033                 {
1034                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingPartiallyBound not supported" << tcu::TestLog::EndMessage;
1035                         result = false;
1036                 }
1037         }
1038
1039         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1040         {
1041                 if ( physicalDeviceDescriptorIndexingFeatures.runtimeDescriptorArray == VK_FALSE )
1042                 {
1043                         log << tcu::TestLog::Message << "Mandatory feature runtimeDescriptorArray not supported" << tcu::TestLog::EndMessage;
1044                         result = false;
1045                 }
1046         }
1047
1048         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1049         {
1050                 if ( physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayDynamicIndexing == VK_FALSE )
1051                 {
1052                         log << tcu::TestLog::Message << "Mandatory feature shaderUniformTexelBufferArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
1053                         result = false;
1054                 }
1055         }
1056
1057         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1058         {
1059                 if ( physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayDynamicIndexing == VK_FALSE )
1060                 {
1061                         log << tcu::TestLog::Message << "Mandatory feature shaderStorageTexelBufferArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
1062                         result = false;
1063                 }
1064         }
1065
1066         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1067         {
1068                 if ( physicalDeviceDescriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing == VK_FALSE )
1069                 {
1070                         log << tcu::TestLog::Message << "Mandatory feature shaderSampledImageArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
1071                         result = false;
1072                 }
1073         }
1074
1075         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1076         {
1077                 if ( physicalDeviceDescriptorIndexingFeatures.shaderStorageBufferArrayNonUniformIndexing == VK_FALSE )
1078                 {
1079                         log << tcu::TestLog::Message << "Mandatory feature shaderStorageBufferArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
1080                         result = false;
1081                 }
1082         }
1083
1084         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1085         {
1086                 if ( physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayNonUniformIndexing == VK_FALSE )
1087                 {
1088                         log << tcu::TestLog::Message << "Mandatory feature shaderUniformTexelBufferArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
1089                         result = false;
1090                 }
1091         }
1092
1093         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1094         {
1095                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind == VK_FALSE )
1096                 {
1097                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingSampledImageUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
1098                         result = false;
1099                 }
1100         }
1101
1102         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1103         {
1104                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageImageUpdateAfterBind == VK_FALSE )
1105                 {
1106                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageImageUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
1107                         result = false;
1108                 }
1109         }
1110
1111         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1112         {
1113                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageBufferUpdateAfterBind == VK_FALSE )
1114                 {
1115                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
1116                         result = false;
1117                 }
1118         }
1119
1120         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1121         {
1122                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformTexelBufferUpdateAfterBind == VK_FALSE )
1123                 {
1124                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingUniformTexelBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
1125                         result = false;
1126                 }
1127         }
1128
1129         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1130         {
1131                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageTexelBufferUpdateAfterBind == VK_FALSE )
1132                 {
1133                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageTexelBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
1134                         result = false;
1135                 }
1136         }
1137
1138         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1139         {
1140                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingUpdateUnusedWhilePending == VK_FALSE )
1141                 {
1142                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingUpdateUnusedWhilePending not supported" << tcu::TestLog::EndMessage;
1143                         result = false;
1144                 }
1145         }
1146
1147         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1148         {
1149                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingPartiallyBound == VK_FALSE )
1150                 {
1151                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingPartiallyBound not supported" << tcu::TestLog::EndMessage;
1152                         result = false;
1153                 }
1154         }
1155
1156         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1157         {
1158                 if ( physicalDeviceDescriptorIndexingFeatures.runtimeDescriptorArray == VK_FALSE )
1159                 {
1160                         log << tcu::TestLog::Message << "Mandatory feature runtimeDescriptorArray not supported" << tcu::TestLog::EndMessage;
1161                         result = false;
1162                 }
1163         }
1164
1165         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1166         {
1167                 if ( coreFeatures.features.shaderSampledImageArrayDynamicIndexing == VK_FALSE )
1168                 {
1169                         log << tcu::TestLog::Message << "Mandatory feature shaderSampledImageArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
1170                         result = false;
1171                 }
1172         }
1173
1174         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1175         {
1176                 if ( coreFeatures.features.shaderStorageBufferArrayDynamicIndexing == VK_FALSE )
1177                 {
1178                         log << tcu::TestLog::Message << "Mandatory feature shaderStorageBufferArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
1179                         result = false;
1180                 }
1181         }
1182
1183         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1184         {
1185                 if ( coreFeatures.features.shaderSampledImageArrayDynamicIndexing == VK_FALSE )
1186                 {
1187                         log << tcu::TestLog::Message << "Mandatory feature shaderSampledImageArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
1188                         result = false;
1189                 }
1190         }
1191
1192         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1193         {
1194                 if ( coreFeatures.features.shaderStorageBufferArrayDynamicIndexing == VK_FALSE )
1195                 {
1196                         log << tcu::TestLog::Message << "Mandatory feature shaderStorageBufferArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
1197                         result = false;
1198                 }
1199         }
1200
1201         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_extended_dynamic_state2")) )
1202         {
1203                 if ( physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2 == VK_FALSE )
1204                 {
1205                         log << tcu::TestLog::Message << "Mandatory feature extendedDynamicState2 not supported" << tcu::TestLog::EndMessage;
1206                         result = false;
1207                 }
1208         }
1209
1210         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_fragment_density_map")) )
1211         {
1212                 if ( physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMap == VK_FALSE )
1213                 {
1214                         log << tcu::TestLog::Message << "Mandatory feature fragmentDensityMap not supported" << tcu::TestLog::EndMessage;
1215                         result = false;
1216                 }
1217         }
1218
1219         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_fragment_shader_interlock")) )
1220         {
1221                 if ( ( physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderSampleInterlock == VK_FALSE ) && ( physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderPixelInterlock == VK_FALSE ) && ( physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderShadingRateInterlock == VK_FALSE ) )
1222                 {
1223                         log << tcu::TestLog::Message << "Mandatory feature fragmentShaderSampleInterlock or fragmentShaderPixelInterlock or fragmentShaderShadingRateInterlock not supported" << tcu::TestLog::EndMessage;
1224                         result = false;
1225                 }
1226         }
1227
1228         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_host_query_reset")) )
1229         {
1230                 if ( physicalDeviceHostQueryResetFeatures.hostQueryReset == VK_FALSE )
1231                 {
1232                         log << tcu::TestLog::Message << "Mandatory feature hostQueryReset not supported" << tcu::TestLog::EndMessage;
1233                         result = false;
1234                 }
1235         }
1236
1237 #if defined(CTS_USES_VULKAN)
1238         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_image_2d_view_of_3d")) )
1239         {
1240                 if ( physicalDeviceImage2DViewOf3DFeaturesEXT.image2DViewOf3D == VK_FALSE )
1241                 {
1242                         log << tcu::TestLog::Message << "Mandatory feature image2DViewOf3D not supported" << tcu::TestLog::EndMessage;
1243                         result = false;
1244                 }
1245         }
1246 #endif // defined(CTS_USES_VULKAN)
1247
1248         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_image_compression_control")) )
1249         {
1250                 if ( physicalDeviceImageCompressionControlFeaturesEXT.imageCompressionControl == VK_FALSE )
1251                 {
1252                         log << tcu::TestLog::Message << "Mandatory feature imageCompressionControl not supported" << tcu::TestLog::EndMessage;
1253                         result = false;
1254                 }
1255         }
1256
1257         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_image_compression_control")) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_image_compression_control_swapchain")) )
1258         {
1259                 if ( physicalDeviceImageCompressionControlSwapchainFeaturesEXT.imageCompressionControlSwapchain == VK_FALSE )
1260                 {
1261                         log << tcu::TestLog::Message << "Mandatory feature imageCompressionControlSwapchain not supported" << tcu::TestLog::EndMessage;
1262                         result = false;
1263                 }
1264         }
1265
1266         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_index_type_uint8")) )
1267         {
1268                 if ( physicalDeviceIndexTypeUint8FeaturesEXT.indexTypeUint8 == VK_FALSE )
1269                 {
1270                         log << tcu::TestLog::Message << "Mandatory feature indexTypeUint8 not supported" << tcu::TestLog::EndMessage;
1271                         result = false;
1272                 }
1273         }
1274
1275         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_inline_uniform_block")) )
1276         {
1277                 if ( physicalDeviceInlineUniformBlockFeaturesEXT.inlineUniformBlock == VK_FALSE )
1278                 {
1279                         log << tcu::TestLog::Message << "Mandatory feature inlineUniformBlock not supported" << tcu::TestLog::EndMessage;
1280                         result = false;
1281                 }
1282         }
1283
1284         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_inline_uniform_block")) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1285         {
1286                 if ( physicalDeviceInlineUniformBlockFeaturesEXT.descriptorBindingInlineUniformBlockUpdateAfterBind == VK_FALSE )
1287                 {
1288                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingInlineUniformBlockUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
1289                         result = false;
1290                 }
1291         }
1292
1293         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_legacy_dithering")) )
1294         {
1295                 if ( physicalDeviceLegacyDitheringFeaturesEXT.legacyDithering == VK_FALSE )
1296                 {
1297                         log << tcu::TestLog::Message << "Mandatory feature legacyDithering not supported" << tcu::TestLog::EndMessage;
1298                         result = false;
1299                 }
1300         }
1301
1302         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_line_rasterization")) )
1303         {
1304                 if ( ( physicalDeviceLineRasterizationFeaturesEXT.rectangularLines == VK_FALSE ) && ( physicalDeviceLineRasterizationFeaturesEXT.bresenhamLines == VK_FALSE ) && ( physicalDeviceLineRasterizationFeaturesEXT.smoothLines == VK_FALSE ) && ( physicalDeviceLineRasterizationFeaturesEXT.stippledRectangularLines == VK_FALSE ) && ( physicalDeviceLineRasterizationFeaturesEXT.stippledBresenhamLines == VK_FALSE ) && ( physicalDeviceLineRasterizationFeaturesEXT.stippledSmoothLines == VK_FALSE ) )
1305                 {
1306                         log << tcu::TestLog::Message << "Mandatory feature rectangularLines or bresenhamLines or smoothLines or stippledRectangularLines or stippledBresenhamLines or stippledSmoothLines not supported" << tcu::TestLog::EndMessage;
1307                         result = false;
1308                 }
1309         }
1310
1311         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_memory_priority")) )
1312         {
1313                 if ( physicalDeviceMemoryPriorityFeaturesEXT.memoryPriority == VK_FALSE )
1314                 {
1315                         log << tcu::TestLog::Message << "Mandatory feature memoryPriority not supported" << tcu::TestLog::EndMessage;
1316                         result = false;
1317                 }
1318         }
1319
1320 #if defined(CTS_USES_VULKAN)
1321         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_fragment_shading_rate")) && physicalDeviceMeshShaderFeaturesEXT.primitiveFragmentShadingRateMeshShader )
1322         {
1323                 if ( physicalDeviceFragmentShadingRateFeaturesKHR.primitiveFragmentShadingRate == VK_FALSE )
1324                 {
1325                         log << tcu::TestLog::Message << "Mandatory feature primitiveFragmentShadingRate not supported" << tcu::TestLog::EndMessage;
1326                         result = false;
1327                 }
1328         }
1329 #endif // defined(CTS_USES_VULKAN)
1330
1331 #if defined(CTS_USES_VULKAN)
1332         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_mesh_shader")) )
1333         {
1334                 if ( ( physicalDeviceMeshShaderFeaturesEXT.meshShader == VK_FALSE ) && ( physicalDeviceMeshShaderFeaturesEXT.taskShader == VK_FALSE ) )
1335                 {
1336                         log << tcu::TestLog::Message << "Mandatory feature meshShader or taskShader not supported" << tcu::TestLog::EndMessage;
1337                         result = false;
1338                 }
1339         }
1340 #endif // defined(CTS_USES_VULKAN)
1341
1342         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_multi_draw")) )
1343         {
1344                 if ( physicalDeviceMultiDrawFeaturesEXT.multiDraw == VK_FALSE )
1345                 {
1346                         log << tcu::TestLog::Message << "Mandatory feature multiDraw not supported" << tcu::TestLog::EndMessage;
1347                         result = false;
1348                 }
1349         }
1350
1351         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_multisampled_render_to_single_sampled")) )
1352         {
1353                 if ( physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.multisampledRenderToSingleSampled == VK_FALSE )
1354                 {
1355                         log << tcu::TestLog::Message << "Mandatory feature multisampledRenderToSingleSampled not supported" << tcu::TestLog::EndMessage;
1356                         result = false;
1357                 }
1358         }
1359
1360 #if defined(CTS_USES_VULKAN)
1361         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_non_seamless_cube_map")) )
1362         {
1363                 if ( physicalDeviceNonSeamlessCubeMapFeaturesEXT.nonSeamlessCubeMap == VK_FALSE )
1364                 {
1365                         log << tcu::TestLog::Message << "Mandatory feature nonSeamlessCubeMap not supported" << tcu::TestLog::EndMessage;
1366                         result = false;
1367                 }
1368         }
1369 #endif // defined(CTS_USES_VULKAN)
1370
1371 #if defined(CTS_USES_VULKAN)
1372         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_opacity_micromap")) )
1373         {
1374                 if ( physicalDeviceOpacityMicromapFeaturesEXT.micromap == VK_FALSE )
1375                 {
1376                         log << tcu::TestLog::Message << "Mandatory feature micromap not supported" << tcu::TestLog::EndMessage;
1377                         result = false;
1378                 }
1379         }
1380 #endif // defined(CTS_USES_VULKAN)
1381
1382 #if defined(CTS_USES_VULKAN)
1383         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_pageable_device_local_memory")) )
1384         {
1385                 if ( physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pageableDeviceLocalMemory == VK_FALSE )
1386                 {
1387                         log << tcu::TestLog::Message << "Mandatory feature pageableDeviceLocalMemory not supported" << tcu::TestLog::EndMessage;
1388                         result = false;
1389                 }
1390         }
1391 #endif // defined(CTS_USES_VULKAN)
1392
1393 #if defined(CTS_USES_VULKAN)
1394         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_primitive_topology_list_restart")) )
1395         {
1396                 if ( physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyListRestart == VK_FALSE )
1397                 {
1398                         log << tcu::TestLog::Message << "Mandatory feature primitiveTopologyListRestart not supported" << tcu::TestLog::EndMessage;
1399                         result = false;
1400                 }
1401         }
1402 #endif // defined(CTS_USES_VULKAN)
1403
1404         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_scalar_block_layout")) )
1405         {
1406                 if ( physicalDeviceScalarBlockLayoutFeatures.scalarBlockLayout == VK_FALSE )
1407                 {
1408                         log << tcu::TestLog::Message << "Mandatory feature scalarBlockLayout not supported" << tcu::TestLog::EndMessage;
1409                         result = false;
1410                 }
1411         }
1412
1413         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_atomic_float")) && physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32Atomics )
1414         {
1415                 if ( physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32Atomics == VK_FALSE )
1416                 {
1417                         log << tcu::TestLog::Message << "Mandatory feature shaderImageFloat32Atomics not supported" << tcu::TestLog::EndMessage;
1418                         result = false;
1419                 }
1420         }
1421
1422         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_atomic_float")) && physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32AtomicAdd )
1423         {
1424                 if ( physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32AtomicAdd == VK_FALSE )
1425                 {
1426                         log << tcu::TestLog::Message << "Mandatory feature shaderImageFloat32AtomicAdd not supported" << tcu::TestLog::EndMessage;
1427                         result = false;
1428                 }
1429         }
1430
1431 #if defined(CTS_USES_VULKAN)
1432         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_atomic_float2")) && physicalDeviceShaderAtomicFloat2FeaturesEXT.sparseImageFloat32AtomicMinMax )
1433         {
1434                 if ( physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderImageFloat32AtomicMinMax == VK_FALSE )
1435                 {
1436                         log << tcu::TestLog::Message << "Mandatory feature shaderImageFloat32AtomicMinMax not supported" << tcu::TestLog::EndMessage;
1437                         result = false;
1438                 }
1439         }
1440 #endif // defined(CTS_USES_VULKAN)
1441
1442         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_demote_to_helper_invocation")) )
1443         {
1444                 if ( physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.shaderDemoteToHelperInvocation == VK_FALSE )
1445                 {
1446                         log << tcu::TestLog::Message << "Mandatory feature shaderDemoteToHelperInvocation not supported" << tcu::TestLog::EndMessage;
1447                         result = false;
1448                 }
1449         }
1450
1451         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_image_atomic_int64")) )
1452         {
1453                 if ( coreFeatures.features.shaderInt64 == VK_FALSE )
1454                 {
1455                         log << tcu::TestLog::Message << "Mandatory feature shaderInt64 not supported" << tcu::TestLog::EndMessage;
1456                         result = false;
1457                 }
1458         }
1459
1460         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_image_atomic_int64")) )
1461         {
1462                 if ( physicalDeviceShaderImageAtomicInt64FeaturesEXT.shaderImageInt64Atomics == VK_FALSE )
1463                 {
1464                         log << tcu::TestLog::Message << "Mandatory feature shaderImageInt64Atomics not supported" << tcu::TestLog::EndMessage;
1465                         result = false;
1466                 }
1467         }
1468
1469         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_image_atomic_int64")) && physicalDeviceShaderImageAtomicInt64FeaturesEXT.sparseImageInt64Atomics )
1470         {
1471                 if ( physicalDeviceShaderImageAtomicInt64FeaturesEXT.shaderImageInt64Atomics == VK_FALSE )
1472                 {
1473                         log << tcu::TestLog::Message << "Mandatory feature shaderImageInt64Atomics not supported" << tcu::TestLog::EndMessage;
1474                         result = false;
1475                 }
1476         }
1477
1478         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_module_identifier")) )
1479         {
1480                 if ( physicalDeviceShaderModuleIdentifierFeaturesEXT.shaderModuleIdentifier == VK_FALSE )
1481                 {
1482                         log << tcu::TestLog::Message << "Mandatory feature shaderModuleIdentifier not supported" << tcu::TestLog::EndMessage;
1483                         result = false;
1484                 }
1485         }
1486
1487         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_subgroup_size_control")) )
1488         {
1489                 if ( physicalDeviceSubgroupSizeControlFeaturesEXT.subgroupSizeControl == VK_FALSE )
1490                 {
1491                         log << tcu::TestLog::Message << "Mandatory feature subgroupSizeControl not supported" << tcu::TestLog::EndMessage;
1492                         result = false;
1493                 }
1494         }
1495
1496         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_subgroup_size_control")) )
1497         {
1498                 if ( physicalDeviceSubgroupSizeControlFeaturesEXT.computeFullSubgroups == VK_FALSE )
1499                 {
1500                         log << tcu::TestLog::Message << "Mandatory feature computeFullSubgroups not supported" << tcu::TestLog::EndMessage;
1501                         result = false;
1502                 }
1503         }
1504
1505         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_subpass_merge_feedback")) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_create_renderpass2")) )
1506         {
1507                 if ( physicalDeviceSubpassMergeFeedbackFeaturesEXT.subpassMergeFeedback == VK_FALSE )
1508                 {
1509                         log << tcu::TestLog::Message << "Mandatory feature subpassMergeFeedback not supported" << tcu::TestLog::EndMessage;
1510                         result = false;
1511                 }
1512         }
1513
1514         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_texel_buffer_alignment")) )
1515         {
1516                 if ( physicalDeviceTexelBufferAlignmentFeaturesEXT.texelBufferAlignment == VK_FALSE )
1517                 {
1518                         log << tcu::TestLog::Message << "Mandatory feature texelBufferAlignment not supported" << tcu::TestLog::EndMessage;
1519                         result = false;
1520                 }
1521         }
1522
1523         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_texture_compression_astc_hdr")) )
1524         {
1525                 if ( physicalDeviceTextureCompressionASTCHDRFeaturesEXT.textureCompressionASTC_HDR == VK_FALSE )
1526                 {
1527                         log << tcu::TestLog::Message << "Mandatory feature textureCompressionASTC_HDR not supported" << tcu::TestLog::EndMessage;
1528                         result = false;
1529                 }
1530         }
1531
1532         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_transform_feedback")) )
1533         {
1534                 if ( physicalDeviceTransformFeedbackFeaturesEXT.transformFeedback == VK_FALSE )
1535                 {
1536                         log << tcu::TestLog::Message << "Mandatory feature transformFeedback not supported" << tcu::TestLog::EndMessage;
1537                         result = false;
1538                 }
1539         }
1540
1541         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_vertex_attribute_divisor")) )
1542         {
1543                 if ( physicalDeviceVertexAttributeDivisorFeaturesEXT.vertexAttributeInstanceRateDivisor == VK_FALSE )
1544                 {
1545                         log << tcu::TestLog::Message << "Mandatory feature vertexAttributeInstanceRateDivisor not supported" << tcu::TestLog::EndMessage;
1546                         result = false;
1547                 }
1548         }
1549
1550         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_vertex_input_dynamic_state")) )
1551         {
1552                 if ( physicalDeviceVertexInputDynamicStateFeaturesEXT.vertexInputDynamicState == VK_FALSE )
1553                 {
1554                         log << tcu::TestLog::Message << "Mandatory feature vertexInputDynamicState not supported" << tcu::TestLog::EndMessage;
1555                         result = false;
1556                 }
1557         }
1558
1559         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_ycbcr_2plane_444_formats")) )
1560         {
1561                 if ( physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.ycbcr2plane444Formats == VK_FALSE )
1562                 {
1563                         log << tcu::TestLog::Message << "Mandatory feature ycbcr2plane444Formats not supported" << tcu::TestLog::EndMessage;
1564                         result = false;
1565                 }
1566         }
1567
1568         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_ycbcr_image_arrays")) )
1569         {
1570                 if ( physicalDeviceYcbcrImageArraysFeaturesEXT.ycbcrImageArrays == VK_FALSE )
1571                 {
1572                         log << tcu::TestLog::Message << "Mandatory feature ycbcrImageArrays not supported" << tcu::TestLog::EndMessage;
1573                         result = false;
1574                 }
1575         }
1576
1577         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_16bit_storage")) )
1578         {
1579                 if ( physicalDevice16BitStorageFeatures.storageBuffer16BitAccess == VK_FALSE )
1580                 {
1581                         log << tcu::TestLog::Message << "Mandatory feature storageBuffer16BitAccess not supported" << tcu::TestLog::EndMessage;
1582                         result = false;
1583                 }
1584         }
1585
1586         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_8bit_storage")) )
1587         {
1588                 if ( physicalDevice8BitStorageFeatures.storageBuffer8BitAccess == VK_FALSE )
1589                 {
1590                         log << tcu::TestLog::Message << "Mandatory feature storageBuffer8BitAccess not supported" << tcu::TestLog::EndMessage;
1591                         result = false;
1592                 }
1593         }
1594
1595         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1596         {
1597                 if ( physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructure == VK_FALSE )
1598                 {
1599                         log << tcu::TestLog::Message << "Mandatory feature accelerationStructure not supported" << tcu::TestLog::EndMessage;
1600                         result = false;
1601                 }
1602         }
1603
1604         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1605         {
1606                 if ( physicalDeviceAccelerationStructureFeaturesKHR.descriptorBindingAccelerationStructureUpdateAfterBind == VK_FALSE )
1607                 {
1608                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingAccelerationStructureUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
1609                         result = false;
1610                 }
1611         }
1612
1613         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_buffer_device_address")) )
1614         {
1615                 if ( physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddress == VK_FALSE )
1616                 {
1617                         log << tcu::TestLog::Message << "Mandatory feature bufferDeviceAddress not supported" << tcu::TestLog::EndMessage;
1618                         result = false;
1619                 }
1620         }
1621
1622         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1623         {
1624                 if ( physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddress == VK_FALSE )
1625                 {
1626                         log << tcu::TestLog::Message << "Mandatory feature bufferDeviceAddress not supported" << tcu::TestLog::EndMessage;
1627                         result = false;
1628                 }
1629         }
1630
1631         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_global_priority_query")) )
1632         {
1633                 if ( physicalDeviceGlobalPriorityQueryFeaturesKHR.globalPriorityQuery == VK_FALSE )
1634                 {
1635                         log << tcu::TestLog::Message << "Mandatory feature globalPriorityQuery not supported" << tcu::TestLog::EndMessage;
1636                         result = false;
1637                 }
1638         }
1639
1640         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_global_priority")) )
1641         {
1642                 if ( physicalDeviceGlobalPriorityQueryFeaturesKHR.globalPriorityQuery == VK_FALSE )
1643                 {
1644                         log << tcu::TestLog::Message << "Mandatory feature globalPriorityQuery not supported" << tcu::TestLog::EndMessage;
1645                         result = false;
1646                 }
1647         }
1648
1649         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_imageless_framebuffer")) )
1650         {
1651                 if ( physicalDeviceImagelessFramebufferFeatures.imagelessFramebuffer == VK_FALSE )
1652                 {
1653                         log << tcu::TestLog::Message << "Mandatory feature imagelessFramebuffer not supported" << tcu::TestLog::EndMessage;
1654                         result = false;
1655                 }
1656         }
1657
1658         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_multiview")) )
1659         {
1660                 if ( physicalDeviceMultiviewFeatures.multiview == VK_FALSE )
1661                 {
1662                         log << tcu::TestLog::Message << "Mandatory feature multiview not supported" << tcu::TestLog::EndMessage;
1663                         result = false;
1664                 }
1665         }
1666
1667         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_performance_query")) )
1668         {
1669                 if ( physicalDevicePerformanceQueryFeaturesKHR.performanceCounterQueryPools == VK_FALSE )
1670                 {
1671                         log << tcu::TestLog::Message << "Mandatory feature performanceCounterQueryPools not supported" << tcu::TestLog::EndMessage;
1672                         result = false;
1673                 }
1674         }
1675
1676         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_pipeline_executable_properties")) )
1677         {
1678                 if ( physicalDevicePipelineExecutablePropertiesFeaturesKHR.pipelineExecutableInfo == VK_FALSE )
1679                 {
1680                         log << tcu::TestLog::Message << "Mandatory feature pipelineExecutableInfo not supported" << tcu::TestLog::EndMessage;
1681                         result = false;
1682                 }
1683         }
1684
1685 #if defined(CTS_USES_VULKAN)
1686         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_present_id")) )
1687         {
1688                 if ( physicalDevicePresentIdFeaturesKHR.presentId == VK_FALSE )
1689                 {
1690                         log << tcu::TestLog::Message << "Mandatory feature presentId not supported" << tcu::TestLog::EndMessage;
1691                         result = false;
1692                 }
1693         }
1694 #endif // defined(CTS_USES_VULKAN)
1695
1696 #if defined(CTS_USES_VULKAN)
1697         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_present_wait")) )
1698         {
1699                 if ( physicalDevicePresentWaitFeaturesKHR.presentWait == VK_FALSE )
1700                 {
1701                         log << tcu::TestLog::Message << "Mandatory feature presentWait not supported" << tcu::TestLog::EndMessage;
1702                         result = false;
1703                 }
1704         }
1705 #endif // defined(CTS_USES_VULKAN)
1706
1707         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_ray_query")) )
1708         {
1709                 if ( physicalDeviceRayQueryFeaturesKHR.rayQuery == VK_FALSE )
1710                 {
1711                         log << tcu::TestLog::Message << "Mandatory feature rayQuery not supported" << tcu::TestLog::EndMessage;
1712                         result = false;
1713                 }
1714         }
1715
1716         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_ray_tracing_maintenance1")) )
1717         {
1718                 if ( physicalDeviceRayTracingMaintenance1FeaturesKHR.rayTracingMaintenance1 == VK_FALSE )
1719                 {
1720                         log << tcu::TestLog::Message << "Mandatory feature rayTracingMaintenance1 not supported" << tcu::TestLog::EndMessage;
1721                         result = false;
1722                 }
1723         }
1724
1725         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_ray_tracing_pipeline")) )
1726         {
1727                 if ( ( physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline == VK_FALSE ) && ( physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineTraceRaysIndirect == VK_FALSE ) )
1728                 {
1729                         log << tcu::TestLog::Message << "Mandatory feature rayTracingPipeline or rayTracingPipelineTraceRaysIndirect not supported" << tcu::TestLog::EndMessage;
1730                         result = false;
1731                 }
1732         }
1733
1734         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_ray_tracing_pipeline")) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_ray_query")) )
1735         {
1736                 if ( physicalDeviceRayTracingPipelineFeaturesKHR.rayTraversalPrimitiveCulling == VK_FALSE )
1737                 {
1738                         log << tcu::TestLog::Message << "Mandatory feature rayTraversalPrimitiveCulling not supported" << tcu::TestLog::EndMessage;
1739                         result = false;
1740                 }
1741         }
1742
1743         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_sampler_ycbcr_conversion")) )
1744         {
1745                 if ( physicalDeviceSamplerYcbcrConversionFeaturesKHR.samplerYcbcrConversion == VK_FALSE )
1746                 {
1747                         log << tcu::TestLog::Message << "Mandatory feature samplerYcbcrConversion not supported" << tcu::TestLog::EndMessage;
1748                         result = false;
1749                 }
1750         }
1751
1752         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_separate_depth_stencil_layouts")) )
1753         {
1754                 if ( physicalDeviceSeparateDepthStencilLayoutsFeatures.separateDepthStencilLayouts == VK_FALSE )
1755                 {
1756                         log << tcu::TestLog::Message << "Mandatory feature separateDepthStencilLayouts not supported" << tcu::TestLog::EndMessage;
1757                         result = false;
1758                 }
1759         }
1760
1761         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_atomic_int64")) )
1762         {
1763                 if ( physicalDeviceShaderAtomicInt64Features.shaderBufferInt64Atomics == VK_FALSE )
1764                 {
1765                         log << tcu::TestLog::Message << "Mandatory feature shaderBufferInt64Atomics not supported" << tcu::TestLog::EndMessage;
1766                         result = false;
1767                 }
1768         }
1769
1770         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_clock")) )
1771         {
1772                 if ( physicalDeviceShaderClockFeaturesKHR.shaderSubgroupClock == VK_FALSE )
1773                 {
1774                         log << tcu::TestLog::Message << "Mandatory feature shaderSubgroupClock not supported" << tcu::TestLog::EndMessage;
1775                         result = false;
1776                 }
1777         }
1778
1779         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_float16_int8")) )
1780         {
1781                 if ( ( physicalDeviceShaderFloat16Int8Features.shaderFloat16 == VK_FALSE ) && ( physicalDeviceShaderFloat16Int8Features.shaderInt8 == VK_FALSE ) )
1782                 {
1783                         log << tcu::TestLog::Message << "Mandatory feature shaderFloat16 or shaderInt8 not supported" << tcu::TestLog::EndMessage;
1784                         result = false;
1785                 }
1786         }
1787
1788 #if defined(CTS_USES_VULKAN)
1789         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_integer_dot_product")) )
1790         {
1791                 if ( physicalDeviceShaderIntegerDotProductFeaturesKHR.shaderIntegerDotProduct == VK_FALSE )
1792                 {
1793                         log << tcu::TestLog::Message << "Mandatory feature shaderIntegerDotProduct not supported" << tcu::TestLog::EndMessage;
1794                         result = false;
1795                 }
1796         }
1797 #endif // defined(CTS_USES_VULKAN)
1798
1799         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_subgroup_extended_types")) )
1800         {
1801                 if ( physicalDeviceShaderSubgroupExtendedTypesFeatures.shaderSubgroupExtendedTypes == VK_FALSE )
1802                 {
1803                         log << tcu::TestLog::Message << "Mandatory feature shaderSubgroupExtendedTypes not supported" << tcu::TestLog::EndMessage;
1804                         result = false;
1805                 }
1806         }
1807
1808         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_subgroup_uniform_control_flow")) )
1809         {
1810                 if ( physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.shaderSubgroupUniformControlFlow == VK_FALSE )
1811                 {
1812                         log << tcu::TestLog::Message << "Mandatory feature shaderSubgroupUniformControlFlow not supported" << tcu::TestLog::EndMessage;
1813                         result = false;
1814                 }
1815         }
1816
1817         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_terminate_invocation")) )
1818         {
1819                 if ( physicalDeviceShaderTerminateInvocationFeaturesKHR.shaderTerminateInvocation == VK_FALSE )
1820                 {
1821                         log << tcu::TestLog::Message << "Mandatory feature shaderTerminateInvocation not supported" << tcu::TestLog::EndMessage;
1822                         result = false;
1823                 }
1824         }
1825
1826         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_synchronization2")) )
1827         {
1828                 if ( physicalDeviceSynchronization2FeaturesKHR.synchronization2 == VK_FALSE )
1829                 {
1830                         log << tcu::TestLog::Message << "Mandatory feature synchronization2 not supported" << tcu::TestLog::EndMessage;
1831                         result = false;
1832                 }
1833         }
1834
1835 #if defined(CTS_USES_VULKAN)
1836         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_timeline_semaphore")) )
1837         {
1838                 if ( physicalDeviceTimelineSemaphoreFeatures.timelineSemaphore == VK_FALSE )
1839                 {
1840                         log << tcu::TestLog::Message << "Mandatory feature timelineSemaphore not supported" << tcu::TestLog::EndMessage;
1841                         result = false;
1842                 }
1843         }
1844 #endif // defined(CTS_USES_VULKAN)
1845
1846         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_uniform_buffer_standard_layout")) )
1847         {
1848                 if ( physicalDeviceUniformBufferStandardLayoutFeatures.uniformBufferStandardLayout == VK_FALSE )
1849                 {
1850                         log << tcu::TestLog::Message << "Mandatory feature uniformBufferStandardLayout not supported" << tcu::TestLog::EndMessage;
1851                         result = false;
1852                 }
1853         }
1854
1855         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_variable_pointers")) )
1856         {
1857                 if ( physicalDeviceVariablePointersFeatures.variablePointersStorageBuffer == VK_FALSE )
1858                 {
1859                         log << tcu::TestLog::Message << "Mandatory feature variablePointersStorageBuffer not supported" << tcu::TestLog::EndMessage;
1860                         result = false;
1861                 }
1862         }
1863
1864         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_vulkan_memory_model")) )
1865         {
1866                 if ( physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModel == VK_FALSE )
1867                 {
1868                         log << tcu::TestLog::Message << "Mandatory feature vulkanMemoryModel not supported" << tcu::TestLog::EndMessage;
1869                         result = false;
1870                 }
1871         }
1872
1873         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_workgroup_memory_explicit_layout")) )
1874         {
1875                 if ( ( physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout == VK_FALSE ) && ( physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayoutScalarBlockLayout == VK_FALSE ) && ( physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout8BitAccess == VK_FALSE ) && ( physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout16BitAccess == VK_FALSE ) )
1876                 {
1877                         log << tcu::TestLog::Message << "Mandatory feature workgroupMemoryExplicitLayout or workgroupMemoryExplicitLayoutScalarBlockLayout or workgroupMemoryExplicitLayout8BitAccess or workgroupMemoryExplicitLayout16BitAccess not supported" << tcu::TestLog::EndMessage;
1878                         result = false;
1879                 }
1880         }
1881
1882         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_zero_initialize_workgroup_memory")) )
1883         {
1884                 if ( physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.shaderZeroInitializeWorkgroupMemory == VK_FALSE )
1885                 {
1886                         log << tcu::TestLog::Message << "Mandatory feature shaderZeroInitializeWorkgroupMemory not supported" << tcu::TestLog::EndMessage;
1887                         result = false;
1888                 }
1889         }
1890
1891         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_VALVE_mutable_descriptor_type")) )
1892         {
1893                 if ( physicalDeviceMutableDescriptorTypeFeaturesVALVE.mutableDescriptorType == VK_FALSE )
1894                 {
1895                         log << tcu::TestLog::Message << "Mandatory feature mutableDescriptorType not supported" << tcu::TestLog::EndMessage;
1896                         result = false;
1897                 }
1898         }
1899
1900         {
1901                 if ( coreFeatures.features.robustBufferAccess == VK_FALSE )
1902                 {
1903                         log << tcu::TestLog::Message << "Mandatory feature robustBufferAccess not supported" << tcu::TestLog::EndMessage;
1904                         result = false;
1905                 }
1906         }
1907
1908         if ( physicalDeviceShaderAtomicInt64Features.shaderBufferInt64Atomics )
1909         {
1910                 if ( coreFeatures.features.shaderInt64 == VK_FALSE )
1911                 {
1912                         log << tcu::TestLog::Message << "Mandatory feature shaderInt64 not supported" << tcu::TestLog::EndMessage;
1913                         result = false;
1914                 }
1915         }
1916
1917         if ( physicalDeviceVulkan12Features.shaderBufferInt64Atomics )
1918         {
1919                 if ( coreFeatures.features.shaderInt64 == VK_FALSE )
1920                 {
1921                         log << tcu::TestLog::Message << "Mandatory feature shaderInt64 not supported" << tcu::TestLog::EndMessage;
1922                         result = false;
1923                 }
1924         }
1925
1926         if ( physicalDeviceShaderAtomicInt64Features.shaderSharedInt64Atomics )
1927         {
1928                 if ( coreFeatures.features.shaderInt64 == VK_FALSE )
1929                 {
1930                         log << tcu::TestLog::Message << "Mandatory feature shaderInt64 not supported" << tcu::TestLog::EndMessage;
1931                         result = false;
1932                 }
1933         }
1934
1935         if ( physicalDeviceVulkan12Features.shaderSharedInt64Atomics )
1936         {
1937                 if ( coreFeatures.features.shaderInt64 == VK_FALSE )
1938                 {
1939                         log << tcu::TestLog::Message << "Mandatory feature shaderInt64 not supported" << tcu::TestLog::EndMessage;
1940                         result = false;
1941                 }
1942         }
1943
1944 #if defined(CTS_USES_VULKAN)
1945         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) )
1946         {
1947                 if ( physicalDeviceMultiviewFeatures.multiview == VK_FALSE )
1948                 {
1949                         log << tcu::TestLog::Message << "Mandatory feature multiview not supported" << tcu::TestLog::EndMessage;
1950                         result = false;
1951                 }
1952         }
1953 #endif // defined(CTS_USES_VULKAN)
1954
1955         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
1956         {
1957                 if ( coreFeatures.features.shaderSampledImageArrayDynamicIndexing == VK_FALSE )
1958                 {
1959                         log << tcu::TestLog::Message << "Mandatory feature shaderSampledImageArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
1960                         result = false;
1961                 }
1962         }
1963
1964         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
1965         {
1966                 if ( coreFeatures.features.shaderStorageBufferArrayDynamicIndexing == VK_FALSE )
1967                 {
1968                         log << tcu::TestLog::Message << "Mandatory feature shaderStorageBufferArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
1969                         result = false;
1970                 }
1971         }
1972
1973 #if defined(CTS_USES_VULKAN)
1974         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) )
1975         {
1976                 if ( physicalDeviceVulkan11Features.multiview == VK_FALSE )
1977                 {
1978                         log << tcu::TestLog::Message << "Mandatory feature multiview not supported" << tcu::TestLog::EndMessage;
1979                         result = false;
1980                 }
1981         }
1982 #endif // defined(CTS_USES_VULKAN)
1983
1984         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) )
1985         {
1986                 if ( physicalDeviceVulkan12Features.subgroupBroadcastDynamicId == VK_FALSE )
1987                 {
1988                         log << tcu::TestLog::Message << "Mandatory feature subgroupBroadcastDynamicId not supported" << tcu::TestLog::EndMessage;
1989                         result = false;
1990                 }
1991         }
1992
1993         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) )
1994         {
1995                 if ( physicalDeviceVulkan12Features.shaderSubgroupExtendedTypes == VK_FALSE )
1996                 {
1997                         log << tcu::TestLog::Message << "Mandatory feature shaderSubgroupExtendedTypes not supported" << tcu::TestLog::EndMessage;
1998                         result = false;
1999                 }
2000         }
2001
2002         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) )
2003         {
2004                 if ( physicalDeviceVulkan12Features.imagelessFramebuffer == VK_FALSE )
2005                 {
2006                         log << tcu::TestLog::Message << "Mandatory feature imagelessFramebuffer not supported" << tcu::TestLog::EndMessage;
2007                         result = false;
2008                 }
2009         }
2010
2011         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) )
2012         {
2013                 if ( physicalDeviceVulkan12Features.uniformBufferStandardLayout == VK_FALSE )
2014                 {
2015                         log << tcu::TestLog::Message << "Mandatory feature uniformBufferStandardLayout not supported" << tcu::TestLog::EndMessage;
2016                         result = false;
2017                 }
2018         }
2019
2020         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) )
2021         {
2022                 if ( physicalDeviceVulkan12Features.separateDepthStencilLayouts == VK_FALSE )
2023                 {
2024                         log << tcu::TestLog::Message << "Mandatory feature separateDepthStencilLayouts not supported" << tcu::TestLog::EndMessage;
2025                         result = false;
2026                 }
2027         }
2028
2029         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) )
2030         {
2031                 if ( physicalDeviceVulkan12Features.hostQueryReset == VK_FALSE )
2032                 {
2033                         log << tcu::TestLog::Message << "Mandatory feature hostQueryReset not supported" << tcu::TestLog::EndMessage;
2034                         result = false;
2035                 }
2036         }
2037
2038 #if defined(CTS_USES_VULKAN)
2039         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) )
2040         {
2041                 if ( physicalDeviceVulkan12Features.timelineSemaphore == VK_FALSE )
2042                 {
2043                         log << tcu::TestLog::Message << "Mandatory feature timelineSemaphore not supported" << tcu::TestLog::EndMessage;
2044                         result = false;
2045                 }
2046         }
2047 #endif // defined(CTS_USES_VULKAN)
2048
2049         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2050         {
2051                 if ( physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayDynamicIndexing == VK_FALSE )
2052                 {
2053                         log << tcu::TestLog::Message << "Mandatory feature shaderUniformTexelBufferArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
2054                         result = false;
2055                 }
2056         }
2057
2058         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2059         {
2060                 if ( physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayDynamicIndexing == VK_FALSE )
2061                 {
2062                         log << tcu::TestLog::Message << "Mandatory feature shaderStorageTexelBufferArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
2063                         result = false;
2064                 }
2065         }
2066
2067         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2068         {
2069                 if ( physicalDeviceVulkan12Features.shaderSampledImageArrayNonUniformIndexing == VK_FALSE )
2070                 {
2071                         log << tcu::TestLog::Message << "Mandatory feature shaderSampledImageArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
2072                         result = false;
2073                 }
2074         }
2075
2076         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2077         {
2078                 if ( physicalDeviceVulkan12Features.shaderStorageBufferArrayNonUniformIndexing == VK_FALSE )
2079                 {
2080                         log << tcu::TestLog::Message << "Mandatory feature shaderStorageBufferArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
2081                         result = false;
2082                 }
2083         }
2084
2085         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2086         {
2087                 if ( physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayNonUniformIndexing == VK_FALSE )
2088                 {
2089                         log << tcu::TestLog::Message << "Mandatory feature shaderUniformTexelBufferArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
2090                         result = false;
2091                 }
2092         }
2093
2094         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2095         {
2096                 if ( physicalDeviceVulkan12Features.descriptorBindingSampledImageUpdateAfterBind == VK_FALSE )
2097                 {
2098                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingSampledImageUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
2099                         result = false;
2100                 }
2101         }
2102
2103         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2104         {
2105                 if ( physicalDeviceVulkan12Features.descriptorBindingStorageImageUpdateAfterBind == VK_FALSE )
2106                 {
2107                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageImageUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
2108                         result = false;
2109                 }
2110         }
2111
2112         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2113         {
2114                 if ( physicalDeviceVulkan12Features.descriptorBindingStorageBufferUpdateAfterBind == VK_FALSE )
2115                 {
2116                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
2117                         result = false;
2118                 }
2119         }
2120
2121         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2122         {
2123                 if ( physicalDeviceVulkan12Features.descriptorBindingUniformTexelBufferUpdateAfterBind == VK_FALSE )
2124                 {
2125                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingUniformTexelBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
2126                         result = false;
2127                 }
2128         }
2129
2130         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2131         {
2132                 if ( physicalDeviceVulkan12Features.descriptorBindingStorageTexelBufferUpdateAfterBind == VK_FALSE )
2133                 {
2134                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageTexelBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
2135                         result = false;
2136                 }
2137         }
2138
2139         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2140         {
2141                 if ( physicalDeviceVulkan12Features.descriptorBindingUpdateUnusedWhilePending == VK_FALSE )
2142                 {
2143                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingUpdateUnusedWhilePending not supported" << tcu::TestLog::EndMessage;
2144                         result = false;
2145                 }
2146         }
2147
2148         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2149         {
2150                 if ( physicalDeviceVulkan12Features.descriptorBindingPartiallyBound == VK_FALSE )
2151                 {
2152                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingPartiallyBound not supported" << tcu::TestLog::EndMessage;
2153                         result = false;
2154                 }
2155         }
2156
2157         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2158         {
2159                 if ( physicalDeviceVulkan12Features.runtimeDescriptorArray == VK_FALSE )
2160                 {
2161                         log << tcu::TestLog::Message << "Mandatory feature runtimeDescriptorArray not supported" << tcu::TestLog::EndMessage;
2162                         result = false;
2163                 }
2164         }
2165
2166         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceShaderAtomicInt64Features.shaderBufferInt64Atomics )
2167         {
2168                 if ( physicalDeviceVulkan12Features.shaderBufferInt64Atomics == VK_FALSE )
2169                 {
2170                         log << tcu::TestLog::Message << "Mandatory feature shaderBufferInt64Atomics not supported" << tcu::TestLog::EndMessage;
2171                         result = false;
2172                 }
2173         }
2174
2175         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_draw_indirect_count")) )
2176         {
2177                 if ( physicalDeviceVulkan12Features.drawIndirectCount == VK_FALSE )
2178                 {
2179                         log << tcu::TestLog::Message << "Mandatory feature drawIndirectCount not supported" << tcu::TestLog::EndMessage;
2180                         result = false;
2181                 }
2182         }
2183
2184         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_sampler_mirror_clamp_to_edge")) )
2185         {
2186                 if ( physicalDeviceVulkan12Features.samplerMirrorClampToEdge == VK_FALSE )
2187                 {
2188                         log << tcu::TestLog::Message << "Mandatory feature samplerMirrorClampToEdge not supported" << tcu::TestLog::EndMessage;
2189                         result = false;
2190                 }
2191         }
2192
2193         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_sampler_filter_minmax")) )
2194         {
2195                 if ( physicalDeviceVulkan12Features.samplerFilterMinmax == VK_FALSE )
2196                 {
2197                         log << tcu::TestLog::Message << "Mandatory feature samplerFilterMinmax not supported" << tcu::TestLog::EndMessage;
2198                         result = false;
2199                 }
2200         }
2201
2202         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_viewport_index_layer")) )
2203         {
2204                 if ( physicalDeviceVulkan12Features.shaderOutputViewportIndex == VK_FALSE )
2205                 {
2206                         log << tcu::TestLog::Message << "Mandatory feature shaderOutputViewportIndex not supported" << tcu::TestLog::EndMessage;
2207                         result = false;
2208                 }
2209         }
2210
2211         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_viewport_index_layer")) )
2212         {
2213                 if ( physicalDeviceVulkan12Features.shaderOutputLayer == VK_FALSE )
2214                 {
2215                         log << tcu::TestLog::Message << "Mandatory feature shaderOutputLayer not supported" << tcu::TestLog::EndMessage;
2216                         result = false;
2217                 }
2218         }
2219
2220         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2221         {
2222                 if ( physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayDynamicIndexing == VK_FALSE )
2223                 {
2224                         log << tcu::TestLog::Message << "Mandatory feature shaderUniformTexelBufferArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
2225                         result = false;
2226                 }
2227         }
2228
2229         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2230         {
2231                 if ( physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayDynamicIndexing == VK_FALSE )
2232                 {
2233                         log << tcu::TestLog::Message << "Mandatory feature shaderStorageTexelBufferArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
2234                         result = false;
2235                 }
2236         }
2237
2238         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2239         {
2240                 if ( physicalDeviceVulkan12Features.shaderSampledImageArrayNonUniformIndexing == VK_FALSE )
2241                 {
2242                         log << tcu::TestLog::Message << "Mandatory feature shaderSampledImageArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
2243                         result = false;
2244                 }
2245         }
2246
2247         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2248         {
2249                 if ( physicalDeviceVulkan12Features.shaderStorageBufferArrayNonUniformIndexing == VK_FALSE )
2250                 {
2251                         log << tcu::TestLog::Message << "Mandatory feature shaderStorageBufferArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
2252                         result = false;
2253                 }
2254         }
2255
2256         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2257         {
2258                 if ( physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayNonUniformIndexing == VK_FALSE )
2259                 {
2260                         log << tcu::TestLog::Message << "Mandatory feature shaderUniformTexelBufferArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
2261                         result = false;
2262                 }
2263         }
2264
2265         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2266         {
2267                 if ( physicalDeviceVulkan12Features.descriptorBindingSampledImageUpdateAfterBind == VK_FALSE )
2268                 {
2269                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingSampledImageUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
2270                         result = false;
2271                 }
2272         }
2273
2274         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2275         {
2276                 if ( physicalDeviceVulkan12Features.descriptorBindingStorageImageUpdateAfterBind == VK_FALSE )
2277                 {
2278                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageImageUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
2279                         result = false;
2280                 }
2281         }
2282
2283         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2284         {
2285                 if ( physicalDeviceVulkan12Features.descriptorBindingStorageBufferUpdateAfterBind == VK_FALSE )
2286                 {
2287                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
2288                         result = false;
2289                 }
2290         }
2291
2292         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2293         {
2294                 if ( physicalDeviceVulkan12Features.descriptorBindingUniformTexelBufferUpdateAfterBind == VK_FALSE )
2295                 {
2296                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingUniformTexelBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
2297                         result = false;
2298                 }
2299         }
2300
2301         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2302         {
2303                 if ( physicalDeviceVulkan12Features.descriptorBindingStorageTexelBufferUpdateAfterBind == VK_FALSE )
2304                 {
2305                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageTexelBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
2306                         result = false;
2307                 }
2308         }
2309
2310         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2311         {
2312                 if ( physicalDeviceVulkan12Features.descriptorBindingUpdateUnusedWhilePending == VK_FALSE )
2313                 {
2314                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingUpdateUnusedWhilePending not supported" << tcu::TestLog::EndMessage;
2315                         result = false;
2316                 }
2317         }
2318
2319         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2320         {
2321                 if ( physicalDeviceVulkan12Features.descriptorBindingPartiallyBound == VK_FALSE )
2322                 {
2323                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingPartiallyBound not supported" << tcu::TestLog::EndMessage;
2324                         result = false;
2325                 }
2326         }
2327
2328         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2329         {
2330                 if ( physicalDeviceVulkan12Features.runtimeDescriptorArray == VK_FALSE )
2331                 {
2332                         log << tcu::TestLog::Message << "Mandatory feature runtimeDescriptorArray not supported" << tcu::TestLog::EndMessage;
2333                         result = false;
2334                 }
2335         }
2336
2337         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2338         {
2339                 if ( physicalDeviceVulkan12Features.bufferDeviceAddress == VK_FALSE )
2340                 {
2341                         log << tcu::TestLog::Message << "Mandatory feature bufferDeviceAddress not supported" << tcu::TestLog::EndMessage;
2342                         result = false;
2343                 }
2344         }
2345
2346 #if defined(CTS_USES_VULKAN)
2347         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2348         {
2349                 if ( physicalDeviceVulkan12Features.bufferDeviceAddress == VK_FALSE )
2350                 {
2351                         log << tcu::TestLog::Message << "Mandatory feature bufferDeviceAddress not supported" << tcu::TestLog::EndMessage;
2352                         result = false;
2353                 }
2354         }
2355 #endif // defined(CTS_USES_VULKAN)
2356
2357 #if defined(CTS_USES_VULKANSC)
2358         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2359         {
2360                 if ( physicalDeviceVulkan12Features.vulkanMemoryModel == VK_FALSE )
2361                 {
2362                         log << tcu::TestLog::Message << "Mandatory feature vulkanMemoryModel not supported" << tcu::TestLog::EndMessage;
2363                         result = false;
2364                 }
2365         }
2366 #endif // defined(CTS_USES_VULKANSC)
2367
2368 #if defined(CTS_USES_VULKAN)
2369         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2370         {
2371                 if ( physicalDeviceVulkan12Features.vulkanMemoryModelDeviceScope == VK_FALSE )
2372                 {
2373                         log << tcu::TestLog::Message << "Mandatory feature vulkanMemoryModelDeviceScope not supported" << tcu::TestLog::EndMessage;
2374                         result = false;
2375                 }
2376         }
2377 #endif // defined(CTS_USES_VULKAN)
2378
2379 #if defined(CTS_USES_VULKAN)
2380         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2381         {
2382                 if ( physicalDeviceVulkan13Features.robustImageAccess == VK_FALSE )
2383                 {
2384                         log << tcu::TestLog::Message << "Mandatory feature robustImageAccess not supported" << tcu::TestLog::EndMessage;
2385                         result = false;
2386                 }
2387         }
2388 #endif // defined(CTS_USES_VULKAN)
2389
2390 #if defined(CTS_USES_VULKAN)
2391         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2392         {
2393                 if ( physicalDeviceVulkan13Features.inlineUniformBlock == VK_FALSE )
2394                 {
2395                         log << tcu::TestLog::Message << "Mandatory feature inlineUniformBlock not supported" << tcu::TestLog::EndMessage;
2396                         result = false;
2397                 }
2398         }
2399 #endif // defined(CTS_USES_VULKAN)
2400
2401 #if defined(CTS_USES_VULKAN)
2402         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2403         {
2404                 if ( physicalDeviceVulkan13Features.descriptorBindingInlineUniformBlockUpdateAfterBind == VK_FALSE )
2405                 {
2406                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingInlineUniformBlockUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
2407                         result = false;
2408                 }
2409         }
2410 #endif // defined(CTS_USES_VULKAN)
2411
2412 #if defined(CTS_USES_VULKAN)
2413         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2414         {
2415                 if ( physicalDeviceVulkan13Features.pipelineCreationCacheControl == VK_FALSE )
2416                 {
2417                         log << tcu::TestLog::Message << "Mandatory feature pipelineCreationCacheControl not supported" << tcu::TestLog::EndMessage;
2418                         result = false;
2419                 }
2420         }
2421 #endif // defined(CTS_USES_VULKAN)
2422
2423 #if defined(CTS_USES_VULKAN)
2424         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2425         {
2426                 if ( physicalDeviceVulkan13Features.privateData == VK_FALSE )
2427                 {
2428                         log << tcu::TestLog::Message << "Mandatory feature privateData not supported" << tcu::TestLog::EndMessage;
2429                         result = false;
2430                 }
2431         }
2432 #endif // defined(CTS_USES_VULKAN)
2433
2434 #if defined(CTS_USES_VULKAN)
2435         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2436         {
2437                 if ( physicalDeviceVulkan13Features.shaderDemoteToHelperInvocation == VK_FALSE )
2438                 {
2439                         log << tcu::TestLog::Message << "Mandatory feature shaderDemoteToHelperInvocation not supported" << tcu::TestLog::EndMessage;
2440                         result = false;
2441                 }
2442         }
2443 #endif // defined(CTS_USES_VULKAN)
2444
2445 #if defined(CTS_USES_VULKAN)
2446         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2447         {
2448                 if ( physicalDeviceVulkan13Features.shaderTerminateInvocation == VK_FALSE )
2449                 {
2450                         log << tcu::TestLog::Message << "Mandatory feature shaderTerminateInvocation not supported" << tcu::TestLog::EndMessage;
2451                         result = false;
2452                 }
2453         }
2454 #endif // defined(CTS_USES_VULKAN)
2455
2456 #if defined(CTS_USES_VULKAN)
2457         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2458         {
2459                 if ( physicalDeviceVulkan13Features.subgroupSizeControl == VK_FALSE )
2460                 {
2461                         log << tcu::TestLog::Message << "Mandatory feature subgroupSizeControl not supported" << tcu::TestLog::EndMessage;
2462                         result = false;
2463                 }
2464         }
2465 #endif // defined(CTS_USES_VULKAN)
2466
2467 #if defined(CTS_USES_VULKAN)
2468         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2469         {
2470                 if ( physicalDeviceVulkan13Features.computeFullSubgroups == VK_FALSE )
2471                 {
2472                         log << tcu::TestLog::Message << "Mandatory feature computeFullSubgroups not supported" << tcu::TestLog::EndMessage;
2473                         result = false;
2474                 }
2475         }
2476 #endif // defined(CTS_USES_VULKAN)
2477
2478 #if defined(CTS_USES_VULKAN)
2479         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2480         {
2481                 if ( physicalDeviceVulkan13Features.synchronization2 == VK_FALSE )
2482                 {
2483                         log << tcu::TestLog::Message << "Mandatory feature synchronization2 not supported" << tcu::TestLog::EndMessage;
2484                         result = false;
2485                 }
2486         }
2487 #endif // defined(CTS_USES_VULKAN)
2488
2489 #if defined(CTS_USES_VULKAN)
2490         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2491         {
2492                 if ( physicalDeviceVulkan13Features.shaderZeroInitializeWorkgroupMemory == VK_FALSE )
2493                 {
2494                         log << tcu::TestLog::Message << "Mandatory feature shaderZeroInitializeWorkgroupMemory not supported" << tcu::TestLog::EndMessage;
2495                         result = false;
2496                 }
2497         }
2498 #endif // defined(CTS_USES_VULKAN)
2499
2500 #if defined(CTS_USES_VULKAN)
2501         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2502         {
2503                 if ( physicalDeviceVulkan13Features.dynamicRendering == VK_FALSE )
2504                 {
2505                         log << tcu::TestLog::Message << "Mandatory feature dynamicRendering not supported" << tcu::TestLog::EndMessage;
2506                         result = false;
2507                 }
2508         }
2509 #endif // defined(CTS_USES_VULKAN)
2510
2511 #if defined(CTS_USES_VULKAN)
2512         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2513         {
2514                 if ( physicalDeviceVulkan13Features.shaderIntegerDotProduct == VK_FALSE )
2515                 {
2516                         log << tcu::TestLog::Message << "Mandatory feature shaderIntegerDotProduct not supported" << tcu::TestLog::EndMessage;
2517                         result = false;
2518                 }
2519         }
2520 #endif // defined(CTS_USES_VULKAN)
2521
2522 #if defined(CTS_USES_VULKAN)
2523         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2524         {
2525                 if ( physicalDeviceVulkan13Features.maintenance4 == VK_FALSE )
2526                 {
2527                         log << tcu::TestLog::Message << "Mandatory feature maintenance4 not supported" << tcu::TestLog::EndMessage;
2528                         result = false;
2529                 }
2530         }
2531 #endif // defined(CTS_USES_VULKAN)
2532
2533         return result;
2534 }
2535