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