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 */ 5tcu::TestStatus testPhysicalDeviceFeature4444FormatsFeaturesEXT (Context& context) 6{ 7 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 8 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 9 const InstanceDriver& vki (instance.getDriver()); 10 const int count = 2u; 11 TestLog& log = context.getTestContext().getLog(); 12 VkPhysicalDeviceFeatures2 extFeatures; 13 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 14 15 VkPhysicalDevice4444FormatsFeaturesEXT device4444FormatsFeaturesEXT[count]; 16 const bool is4444FormatsFeaturesEXT = checkExtension(properties, "VK_EXT_4444_formats") || context.contextSupports(vk::ApiVersion(1, 3, 0)); 17 18 for (int ndx = 0; ndx < count; ++ndx) 19 { 20 deMemset(&device4444FormatsFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDevice4444FormatsFeaturesEXT)); 21 device4444FormatsFeaturesEXT[ndx].sType = is4444FormatsFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 22 device4444FormatsFeaturesEXT[ndx].pNext = DE_NULL; 23 24 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 25 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 26 extFeatures.pNext = &device4444FormatsFeaturesEXT[ndx]; 27 28 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 29 } 30 31 if (is4444FormatsFeaturesEXT) 32 log << TestLog::Message << device4444FormatsFeaturesEXT[0] << TestLog::EndMessage; 33 34 if (is4444FormatsFeaturesEXT && 35 (device4444FormatsFeaturesEXT[0].formatA4R4G4B4 != device4444FormatsFeaturesEXT[1].formatA4R4G4B4 || 36 device4444FormatsFeaturesEXT[0].formatA4B4G4R4 != device4444FormatsFeaturesEXT[1].formatA4B4G4R4)) 37 { 38 TCU_FAIL("Mismatch between VkPhysicalDevice4444FormatsFeaturesEXT"); 39 } 40 return tcu::TestStatus::pass("Querying succeeded"); 41} 42 43tcu::TestStatus testPhysicalDeviceFeature8BitStorageFeatures (Context& context) 44{ 45 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 46 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 47 const InstanceDriver& vki (instance.getDriver()); 48 const int count = 2u; 49 TestLog& log = context.getTestContext().getLog(); 50 VkPhysicalDeviceFeatures2 extFeatures; 51 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 52 53 VkPhysicalDevice8BitStorageFeatures device8BitStorageFeatures[count]; 54 const bool is8BitStorageFeatures = checkExtension(properties, "VK_KHR_8bit_storage") || context.contextSupports(vk::ApiVersion(1, 2, 0)); 55 56 for (int ndx = 0; ndx < count; ++ndx) 57 { 58 deMemset(&device8BitStorageFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDevice8BitStorageFeatures)); 59 device8BitStorageFeatures[ndx].sType = is8BitStorageFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 60 device8BitStorageFeatures[ndx].pNext = DE_NULL; 61 62 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 63 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 64 extFeatures.pNext = &device8BitStorageFeatures[ndx]; 65 66 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 67 } 68 69 if (is8BitStorageFeatures) 70 log << TestLog::Message << device8BitStorageFeatures[0] << TestLog::EndMessage; 71 72 if (is8BitStorageFeatures && 73 (device8BitStorageFeatures[0].storageBuffer8BitAccess != device8BitStorageFeatures[1].storageBuffer8BitAccess || 74 device8BitStorageFeatures[0].uniformAndStorageBuffer8BitAccess != device8BitStorageFeatures[1].uniformAndStorageBuffer8BitAccess || 75 device8BitStorageFeatures[0].storagePushConstant8 != device8BitStorageFeatures[1].storagePushConstant8)) 76 { 77 TCU_FAIL("Mismatch between VkPhysicalDevice8BitStorageFeatures"); 78 } 79 return tcu::TestStatus::pass("Querying succeeded"); 80} 81 82tcu::TestStatus testPhysicalDeviceFeature16BitStorageFeatures (Context& context) 83{ 84 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 85 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 86 const InstanceDriver& vki (instance.getDriver()); 87 const int count = 2u; 88 TestLog& log = context.getTestContext().getLog(); 89 VkPhysicalDeviceFeatures2 extFeatures; 90 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 91 92 VkPhysicalDevice16BitStorageFeatures device16BitStorageFeatures[count]; 93 const bool is16BitStorageFeatures = checkExtension(properties, "VK_KHR_16bit_storage") || context.contextSupports(vk::ApiVersion(1, 1, 0)); 94 95 for (int ndx = 0; ndx < count; ++ndx) 96 { 97 deMemset(&device16BitStorageFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDevice16BitStorageFeatures)); 98 device16BitStorageFeatures[ndx].sType = is16BitStorageFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 99 device16BitStorageFeatures[ndx].pNext = DE_NULL; 100 101 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 102 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 103 extFeatures.pNext = &device16BitStorageFeatures[ndx]; 104 105 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 106 } 107 108 if (is16BitStorageFeatures) 109 log << TestLog::Message << device16BitStorageFeatures[0] << TestLog::EndMessage; 110 111 if (is16BitStorageFeatures && 112 (device16BitStorageFeatures[0].storageBuffer16BitAccess != device16BitStorageFeatures[1].storageBuffer16BitAccess || 113 device16BitStorageFeatures[0].uniformAndStorageBuffer16BitAccess != device16BitStorageFeatures[1].uniformAndStorageBuffer16BitAccess || 114 device16BitStorageFeatures[0].storagePushConstant16 != device16BitStorageFeatures[1].storagePushConstant16 || 115 device16BitStorageFeatures[0].storageInputOutput16 != device16BitStorageFeatures[1].storageInputOutput16)) 116 { 117 TCU_FAIL("Mismatch between VkPhysicalDevice16BitStorageFeatures"); 118 } 119 return tcu::TestStatus::pass("Querying succeeded"); 120} 121 122tcu::TestStatus testPhysicalDeviceFeatureAccelerationStructureFeaturesKHR (Context& context) 123{ 124 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 125 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 126 const InstanceDriver& vki (instance.getDriver()); 127 const int count = 2u; 128 TestLog& log = context.getTestContext().getLog(); 129 VkPhysicalDeviceFeatures2 extFeatures; 130 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 131 132 VkPhysicalDeviceAccelerationStructureFeaturesKHR deviceAccelerationStructureFeaturesKHR[count]; 133 const bool isAccelerationStructureFeaturesKHR = checkExtension(properties, "VK_KHR_acceleration_structure"); 134 135 for (int ndx = 0; ndx < count; ++ndx) 136 { 137 deMemset(&deviceAccelerationStructureFeaturesKHR[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceAccelerationStructureFeaturesKHR)); 138 deviceAccelerationStructureFeaturesKHR[ndx].sType = isAccelerationStructureFeaturesKHR ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR : VK_STRUCTURE_TYPE_MAX_ENUM; 139 deviceAccelerationStructureFeaturesKHR[ndx].pNext = DE_NULL; 140 141 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 142 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 143 extFeatures.pNext = &deviceAccelerationStructureFeaturesKHR[ndx]; 144 145 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 146 } 147 148 if (isAccelerationStructureFeaturesKHR) 149 log << TestLog::Message << deviceAccelerationStructureFeaturesKHR[0] << TestLog::EndMessage; 150 151 if (isAccelerationStructureFeaturesKHR && 152 (deviceAccelerationStructureFeaturesKHR[0].accelerationStructure != deviceAccelerationStructureFeaturesKHR[1].accelerationStructure || 153 deviceAccelerationStructureFeaturesKHR[0].accelerationStructureCaptureReplay != deviceAccelerationStructureFeaturesKHR[1].accelerationStructureCaptureReplay || 154 deviceAccelerationStructureFeaturesKHR[0].accelerationStructureIndirectBuild != deviceAccelerationStructureFeaturesKHR[1].accelerationStructureIndirectBuild || 155 deviceAccelerationStructureFeaturesKHR[0].accelerationStructureHostCommands != deviceAccelerationStructureFeaturesKHR[1].accelerationStructureHostCommands || 156 deviceAccelerationStructureFeaturesKHR[0].descriptorBindingAccelerationStructureUpdateAfterBind != deviceAccelerationStructureFeaturesKHR[1].descriptorBindingAccelerationStructureUpdateAfterBind)) 157 { 158 TCU_FAIL("Mismatch between VkPhysicalDeviceAccelerationStructureFeaturesKHR"); 159 } 160 return tcu::TestStatus::pass("Querying succeeded"); 161} 162 163tcu::TestStatus testPhysicalDeviceFeatureASTCDecodeFeaturesEXT (Context& context) 164{ 165 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 166 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 167 const InstanceDriver& vki (instance.getDriver()); 168 const int count = 2u; 169 TestLog& log = context.getTestContext().getLog(); 170 VkPhysicalDeviceFeatures2 extFeatures; 171 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 172 173 VkPhysicalDeviceASTCDecodeFeaturesEXT deviceASTCDecodeFeaturesEXT[count]; 174 const bool isASTCDecodeFeaturesEXT = checkExtension(properties, "VK_EXT_astc_decode_mode"); 175 176 for (int ndx = 0; ndx < count; ++ndx) 177 { 178 deMemset(&deviceASTCDecodeFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceASTCDecodeFeaturesEXT)); 179 deviceASTCDecodeFeaturesEXT[ndx].sType = isASTCDecodeFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 180 deviceASTCDecodeFeaturesEXT[ndx].pNext = DE_NULL; 181 182 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 183 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 184 extFeatures.pNext = &deviceASTCDecodeFeaturesEXT[ndx]; 185 186 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 187 } 188 189 if (isASTCDecodeFeaturesEXT) 190 log << TestLog::Message << deviceASTCDecodeFeaturesEXT[0] << TestLog::EndMessage; 191 192 if (isASTCDecodeFeaturesEXT && 193 (deviceASTCDecodeFeaturesEXT[0].decodeModeSharedExponent != deviceASTCDecodeFeaturesEXT[1].decodeModeSharedExponent)) 194 { 195 TCU_FAIL("Mismatch between VkPhysicalDeviceASTCDecodeFeaturesEXT"); 196 } 197 return tcu::TestStatus::pass("Querying succeeded"); 198} 199 200tcu::TestStatus testPhysicalDeviceFeatureBlendOperationAdvancedFeaturesEXT (Context& context) 201{ 202 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 203 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 204 const InstanceDriver& vki (instance.getDriver()); 205 const int count = 2u; 206 TestLog& log = context.getTestContext().getLog(); 207 VkPhysicalDeviceFeatures2 extFeatures; 208 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 209 210 VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT deviceBlendOperationAdvancedFeaturesEXT[count]; 211 const bool isBlendOperationAdvancedFeaturesEXT = checkExtension(properties, "VK_EXT_blend_operation_advanced"); 212 213 for (int ndx = 0; ndx < count; ++ndx) 214 { 215 deMemset(&deviceBlendOperationAdvancedFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT)); 216 deviceBlendOperationAdvancedFeaturesEXT[ndx].sType = isBlendOperationAdvancedFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 217 deviceBlendOperationAdvancedFeaturesEXT[ndx].pNext = DE_NULL; 218 219 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 220 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 221 extFeatures.pNext = &deviceBlendOperationAdvancedFeaturesEXT[ndx]; 222 223 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 224 } 225 226 if (isBlendOperationAdvancedFeaturesEXT) 227 log << TestLog::Message << deviceBlendOperationAdvancedFeaturesEXT[0] << TestLog::EndMessage; 228 229 if (isBlendOperationAdvancedFeaturesEXT && 230 (deviceBlendOperationAdvancedFeaturesEXT[0].advancedBlendCoherentOperations != deviceBlendOperationAdvancedFeaturesEXT[1].advancedBlendCoherentOperations)) 231 { 232 TCU_FAIL("Mismatch between VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT"); 233 } 234 return tcu::TestStatus::pass("Querying succeeded"); 235} 236 237tcu::TestStatus testPhysicalDeviceFeatureBufferDeviceAddressFeaturesEXT (Context& context) 238{ 239 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 240 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 241 const InstanceDriver& vki (instance.getDriver()); 242 const int count = 2u; 243 TestLog& log = context.getTestContext().getLog(); 244 VkPhysicalDeviceFeatures2 extFeatures; 245 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 246 247 VkPhysicalDeviceBufferDeviceAddressFeaturesEXT deviceBufferDeviceAddressFeaturesEXT[count]; 248 const bool isBufferDeviceAddressFeaturesEXT = checkExtension(properties, "VK_EXT_buffer_device_address"); 249 250 for (int ndx = 0; ndx < count; ++ndx) 251 { 252 deMemset(&deviceBufferDeviceAddressFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT)); 253 deviceBufferDeviceAddressFeaturesEXT[ndx].sType = isBufferDeviceAddressFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 254 deviceBufferDeviceAddressFeaturesEXT[ndx].pNext = DE_NULL; 255 256 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 257 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 258 extFeatures.pNext = &deviceBufferDeviceAddressFeaturesEXT[ndx]; 259 260 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 261 } 262 263 if (isBufferDeviceAddressFeaturesEXT) 264 log << TestLog::Message << deviceBufferDeviceAddressFeaturesEXT[0] << TestLog::EndMessage; 265 266 if (isBufferDeviceAddressFeaturesEXT && 267 (deviceBufferDeviceAddressFeaturesEXT[0].bufferDeviceAddress != deviceBufferDeviceAddressFeaturesEXT[1].bufferDeviceAddress || 268 deviceBufferDeviceAddressFeaturesEXT[0].bufferDeviceAddressCaptureReplay != deviceBufferDeviceAddressFeaturesEXT[1].bufferDeviceAddressCaptureReplay || 269 deviceBufferDeviceAddressFeaturesEXT[0].bufferDeviceAddressMultiDevice != deviceBufferDeviceAddressFeaturesEXT[1].bufferDeviceAddressMultiDevice)) 270 { 271 TCU_FAIL("Mismatch between VkPhysicalDeviceBufferDeviceAddressFeaturesEXT"); 272 } 273 return tcu::TestStatus::pass("Querying succeeded"); 274} 275 276tcu::TestStatus testPhysicalDeviceFeatureBufferDeviceAddressFeatures (Context& context) 277{ 278 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 279 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 280 const InstanceDriver& vki (instance.getDriver()); 281 const int count = 2u; 282 TestLog& log = context.getTestContext().getLog(); 283 VkPhysicalDeviceFeatures2 extFeatures; 284 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 285 286 VkPhysicalDeviceBufferDeviceAddressFeatures deviceBufferDeviceAddressFeatures[count]; 287 const bool isBufferDeviceAddressFeatures = checkExtension(properties, "VK_KHR_buffer_device_address") || context.contextSupports(vk::ApiVersion(1, 2, 0)); 288 289 for (int ndx = 0; ndx < count; ++ndx) 290 { 291 deMemset(&deviceBufferDeviceAddressFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceBufferDeviceAddressFeatures)); 292 deviceBufferDeviceAddressFeatures[ndx].sType = isBufferDeviceAddressFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 293 deviceBufferDeviceAddressFeatures[ndx].pNext = DE_NULL; 294 295 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 296 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 297 extFeatures.pNext = &deviceBufferDeviceAddressFeatures[ndx]; 298 299 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 300 } 301 302 if (isBufferDeviceAddressFeatures) 303 log << TestLog::Message << deviceBufferDeviceAddressFeatures[0] << TestLog::EndMessage; 304 305 if (isBufferDeviceAddressFeatures && 306 (deviceBufferDeviceAddressFeatures[0].bufferDeviceAddress != deviceBufferDeviceAddressFeatures[1].bufferDeviceAddress || 307 deviceBufferDeviceAddressFeatures[0].bufferDeviceAddressCaptureReplay != deviceBufferDeviceAddressFeatures[1].bufferDeviceAddressCaptureReplay || 308 deviceBufferDeviceAddressFeatures[0].bufferDeviceAddressMultiDevice != deviceBufferDeviceAddressFeatures[1].bufferDeviceAddressMultiDevice)) 309 { 310 TCU_FAIL("Mismatch between VkPhysicalDeviceBufferDeviceAddressFeatures"); 311 } 312 return tcu::TestStatus::pass("Querying succeeded"); 313} 314 315tcu::TestStatus testPhysicalDeviceFeatureConditionalRenderingFeaturesEXT (Context& context) 316{ 317 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 318 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 319 const InstanceDriver& vki (instance.getDriver()); 320 const int count = 2u; 321 TestLog& log = context.getTestContext().getLog(); 322 VkPhysicalDeviceFeatures2 extFeatures; 323 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 324 325 VkPhysicalDeviceConditionalRenderingFeaturesEXT deviceConditionalRenderingFeaturesEXT[count]; 326 const bool isConditionalRenderingFeaturesEXT = checkExtension(properties, "VK_EXT_conditional_rendering"); 327 328 for (int ndx = 0; ndx < count; ++ndx) 329 { 330 deMemset(&deviceConditionalRenderingFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceConditionalRenderingFeaturesEXT)); 331 deviceConditionalRenderingFeaturesEXT[ndx].sType = isConditionalRenderingFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 332 deviceConditionalRenderingFeaturesEXT[ndx].pNext = DE_NULL; 333 334 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 335 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 336 extFeatures.pNext = &deviceConditionalRenderingFeaturesEXT[ndx]; 337 338 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 339 } 340 341 if (isConditionalRenderingFeaturesEXT) 342 log << TestLog::Message << deviceConditionalRenderingFeaturesEXT[0] << TestLog::EndMessage; 343 344 if (isConditionalRenderingFeaturesEXT && 345 (deviceConditionalRenderingFeaturesEXT[0].conditionalRendering != deviceConditionalRenderingFeaturesEXT[1].conditionalRendering || 346 deviceConditionalRenderingFeaturesEXT[0].inheritedConditionalRendering != deviceConditionalRenderingFeaturesEXT[1].inheritedConditionalRendering)) 347 { 348 TCU_FAIL("Mismatch between VkPhysicalDeviceConditionalRenderingFeaturesEXT"); 349 } 350 return tcu::TestStatus::pass("Querying succeeded"); 351} 352 353tcu::TestStatus testPhysicalDeviceFeatureCustomBorderColorFeaturesEXT (Context& context) 354{ 355 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 356 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 357 const InstanceDriver& vki (instance.getDriver()); 358 const int count = 2u; 359 TestLog& log = context.getTestContext().getLog(); 360 VkPhysicalDeviceFeatures2 extFeatures; 361 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 362 363 VkPhysicalDeviceCustomBorderColorFeaturesEXT deviceCustomBorderColorFeaturesEXT[count]; 364 const bool isCustomBorderColorFeaturesEXT = checkExtension(properties, "VK_EXT_custom_border_color"); 365 366 for (int ndx = 0; ndx < count; ++ndx) 367 { 368 deMemset(&deviceCustomBorderColorFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceCustomBorderColorFeaturesEXT)); 369 deviceCustomBorderColorFeaturesEXT[ndx].sType = isCustomBorderColorFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 370 deviceCustomBorderColorFeaturesEXT[ndx].pNext = DE_NULL; 371 372 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 373 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 374 extFeatures.pNext = &deviceCustomBorderColorFeaturesEXT[ndx]; 375 376 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 377 } 378 379 if (isCustomBorderColorFeaturesEXT) 380 log << TestLog::Message << deviceCustomBorderColorFeaturesEXT[0] << TestLog::EndMessage; 381 382 if (isCustomBorderColorFeaturesEXT && 383 (deviceCustomBorderColorFeaturesEXT[0].customBorderColors != deviceCustomBorderColorFeaturesEXT[1].customBorderColors || 384 deviceCustomBorderColorFeaturesEXT[0].customBorderColorWithoutFormat != deviceCustomBorderColorFeaturesEXT[1].customBorderColorWithoutFormat)) 385 { 386 TCU_FAIL("Mismatch between VkPhysicalDeviceCustomBorderColorFeaturesEXT"); 387 } 388 return tcu::TestStatus::pass("Querying succeeded"); 389} 390 391tcu::TestStatus testPhysicalDeviceFeatureColorWriteEnableFeaturesEXT (Context& context) 392{ 393 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 394 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 395 const InstanceDriver& vki (instance.getDriver()); 396 const int count = 2u; 397 TestLog& log = context.getTestContext().getLog(); 398 VkPhysicalDeviceFeatures2 extFeatures; 399 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 400 401 VkPhysicalDeviceColorWriteEnableFeaturesEXT deviceColorWriteEnableFeaturesEXT[count]; 402 const bool isColorWriteEnableFeaturesEXT = checkExtension(properties, "VK_EXT_color_write_enable"); 403 404 for (int ndx = 0; ndx < count; ++ndx) 405 { 406 deMemset(&deviceColorWriteEnableFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceColorWriteEnableFeaturesEXT)); 407 deviceColorWriteEnableFeaturesEXT[ndx].sType = isColorWriteEnableFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 408 deviceColorWriteEnableFeaturesEXT[ndx].pNext = DE_NULL; 409 410 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 411 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 412 extFeatures.pNext = &deviceColorWriteEnableFeaturesEXT[ndx]; 413 414 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 415 } 416 417 if (isColorWriteEnableFeaturesEXT) 418 log << TestLog::Message << deviceColorWriteEnableFeaturesEXT[0] << TestLog::EndMessage; 419 420 if (isColorWriteEnableFeaturesEXT && 421 (deviceColorWriteEnableFeaturesEXT[0].colorWriteEnable != deviceColorWriteEnableFeaturesEXT[1].colorWriteEnable)) 422 { 423 TCU_FAIL("Mismatch between VkPhysicalDeviceColorWriteEnableFeaturesEXT"); 424 } 425 return tcu::TestStatus::pass("Querying succeeded"); 426} 427 428tcu::TestStatus testPhysicalDeviceFeatureDescriptorIndexingFeatures (Context& context) 429{ 430 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 431 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 432 const InstanceDriver& vki (instance.getDriver()); 433 const int count = 2u; 434 TestLog& log = context.getTestContext().getLog(); 435 VkPhysicalDeviceFeatures2 extFeatures; 436 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 437 438 VkPhysicalDeviceDescriptorIndexingFeatures deviceDescriptorIndexingFeatures[count]; 439 const bool isDescriptorIndexingFeatures = checkExtension(properties, "VK_EXT_descriptor_indexing") || context.contextSupports(vk::ApiVersion(1, 2, 0)); 440 441 for (int ndx = 0; ndx < count; ++ndx) 442 { 443 deMemset(&deviceDescriptorIndexingFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceDescriptorIndexingFeatures)); 444 deviceDescriptorIndexingFeatures[ndx].sType = isDescriptorIndexingFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 445 deviceDescriptorIndexingFeatures[ndx].pNext = DE_NULL; 446 447 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 448 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 449 extFeatures.pNext = &deviceDescriptorIndexingFeatures[ndx]; 450 451 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 452 } 453 454 if (isDescriptorIndexingFeatures) 455 log << TestLog::Message << deviceDescriptorIndexingFeatures[0] << TestLog::EndMessage; 456 457 if (isDescriptorIndexingFeatures && 458 (deviceDescriptorIndexingFeatures[0].shaderInputAttachmentArrayDynamicIndexing != deviceDescriptorIndexingFeatures[1].shaderInputAttachmentArrayDynamicIndexing || 459 deviceDescriptorIndexingFeatures[0].shaderUniformTexelBufferArrayDynamicIndexing != deviceDescriptorIndexingFeatures[1].shaderUniformTexelBufferArrayDynamicIndexing || 460 deviceDescriptorIndexingFeatures[0].shaderStorageTexelBufferArrayDynamicIndexing != deviceDescriptorIndexingFeatures[1].shaderStorageTexelBufferArrayDynamicIndexing || 461 deviceDescriptorIndexingFeatures[0].shaderUniformBufferArrayNonUniformIndexing != deviceDescriptorIndexingFeatures[1].shaderUniformBufferArrayNonUniformIndexing || 462 deviceDescriptorIndexingFeatures[0].shaderSampledImageArrayNonUniformIndexing != deviceDescriptorIndexingFeatures[1].shaderSampledImageArrayNonUniformIndexing || 463 deviceDescriptorIndexingFeatures[0].shaderStorageBufferArrayNonUniformIndexing != deviceDescriptorIndexingFeatures[1].shaderStorageBufferArrayNonUniformIndexing || 464 deviceDescriptorIndexingFeatures[0].shaderStorageImageArrayNonUniformIndexing != deviceDescriptorIndexingFeatures[1].shaderStorageImageArrayNonUniformIndexing || 465 deviceDescriptorIndexingFeatures[0].shaderInputAttachmentArrayNonUniformIndexing != deviceDescriptorIndexingFeatures[1].shaderInputAttachmentArrayNonUniformIndexing || 466 deviceDescriptorIndexingFeatures[0].shaderUniformTexelBufferArrayNonUniformIndexing != deviceDescriptorIndexingFeatures[1].shaderUniformTexelBufferArrayNonUniformIndexing || 467 deviceDescriptorIndexingFeatures[0].shaderStorageTexelBufferArrayNonUniformIndexing != deviceDescriptorIndexingFeatures[1].shaderStorageTexelBufferArrayNonUniformIndexing || 468 deviceDescriptorIndexingFeatures[0].descriptorBindingUniformBufferUpdateAfterBind != deviceDescriptorIndexingFeatures[1].descriptorBindingUniformBufferUpdateAfterBind || 469 deviceDescriptorIndexingFeatures[0].descriptorBindingSampledImageUpdateAfterBind != deviceDescriptorIndexingFeatures[1].descriptorBindingSampledImageUpdateAfterBind || 470 deviceDescriptorIndexingFeatures[0].descriptorBindingStorageImageUpdateAfterBind != deviceDescriptorIndexingFeatures[1].descriptorBindingStorageImageUpdateAfterBind || 471 deviceDescriptorIndexingFeatures[0].descriptorBindingStorageBufferUpdateAfterBind != deviceDescriptorIndexingFeatures[1].descriptorBindingStorageBufferUpdateAfterBind || 472 deviceDescriptorIndexingFeatures[0].descriptorBindingUniformTexelBufferUpdateAfterBind != deviceDescriptorIndexingFeatures[1].descriptorBindingUniformTexelBufferUpdateAfterBind || 473 deviceDescriptorIndexingFeatures[0].descriptorBindingStorageTexelBufferUpdateAfterBind != deviceDescriptorIndexingFeatures[1].descriptorBindingStorageTexelBufferUpdateAfterBind || 474 deviceDescriptorIndexingFeatures[0].descriptorBindingUpdateUnusedWhilePending != deviceDescriptorIndexingFeatures[1].descriptorBindingUpdateUnusedWhilePending || 475 deviceDescriptorIndexingFeatures[0].descriptorBindingPartiallyBound != deviceDescriptorIndexingFeatures[1].descriptorBindingPartiallyBound || 476 deviceDescriptorIndexingFeatures[0].descriptorBindingVariableDescriptorCount != deviceDescriptorIndexingFeatures[1].descriptorBindingVariableDescriptorCount || 477 deviceDescriptorIndexingFeatures[0].runtimeDescriptorArray != deviceDescriptorIndexingFeatures[1].runtimeDescriptorArray)) 478 { 479 TCU_FAIL("Mismatch between VkPhysicalDeviceDescriptorIndexingFeatures"); 480 } 481 return tcu::TestStatus::pass("Querying succeeded"); 482} 483 484tcu::TestStatus testPhysicalDeviceFeatureDepthClipEnableFeaturesEXT (Context& context) 485{ 486 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 487 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 488 const InstanceDriver& vki (instance.getDriver()); 489 const int count = 2u; 490 TestLog& log = context.getTestContext().getLog(); 491 VkPhysicalDeviceFeatures2 extFeatures; 492 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 493 494 VkPhysicalDeviceDepthClipEnableFeaturesEXT deviceDepthClipEnableFeaturesEXT[count]; 495 const bool isDepthClipEnableFeaturesEXT = checkExtension(properties, "VK_EXT_depth_clip_enable"); 496 497 for (int ndx = 0; ndx < count; ++ndx) 498 { 499 deMemset(&deviceDepthClipEnableFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceDepthClipEnableFeaturesEXT)); 500 deviceDepthClipEnableFeaturesEXT[ndx].sType = isDepthClipEnableFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 501 deviceDepthClipEnableFeaturesEXT[ndx].pNext = DE_NULL; 502 503 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 504 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 505 extFeatures.pNext = &deviceDepthClipEnableFeaturesEXT[ndx]; 506 507 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 508 } 509 510 if (isDepthClipEnableFeaturesEXT) 511 log << TestLog::Message << deviceDepthClipEnableFeaturesEXT[0] << TestLog::EndMessage; 512 513 if (isDepthClipEnableFeaturesEXT && 514 (deviceDepthClipEnableFeaturesEXT[0].depthClipEnable != deviceDepthClipEnableFeaturesEXT[1].depthClipEnable)) 515 { 516 TCU_FAIL("Mismatch between VkPhysicalDeviceDepthClipEnableFeaturesEXT"); 517 } 518 return tcu::TestStatus::pass("Querying succeeded"); 519} 520 521tcu::TestStatus testPhysicalDeviceFeatureDynamicRenderingFeatures (Context& context) 522{ 523 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 524 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 525 const InstanceDriver& vki (instance.getDriver()); 526 const int count = 2u; 527 TestLog& log = context.getTestContext().getLog(); 528 VkPhysicalDeviceFeatures2 extFeatures; 529 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 530 531 VkPhysicalDeviceDynamicRenderingFeatures deviceDynamicRenderingFeatures[count]; 532 const bool isDynamicRenderingFeatures = checkExtension(properties, "VK_KHR_dynamic_rendering") || context.contextSupports(vk::ApiVersion(1, 3, 0)); 533 534 for (int ndx = 0; ndx < count; ++ndx) 535 { 536 deMemset(&deviceDynamicRenderingFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceDynamicRenderingFeatures)); 537 deviceDynamicRenderingFeatures[ndx].sType = isDynamicRenderingFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 538 deviceDynamicRenderingFeatures[ndx].pNext = DE_NULL; 539 540 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 541 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 542 extFeatures.pNext = &deviceDynamicRenderingFeatures[ndx]; 543 544 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 545 } 546 547 if (isDynamicRenderingFeatures) 548 log << TestLog::Message << deviceDynamicRenderingFeatures[0] << TestLog::EndMessage; 549 550 if (isDynamicRenderingFeatures && 551 (deviceDynamicRenderingFeatures[0].dynamicRendering != deviceDynamicRenderingFeatures[1].dynamicRendering)) 552 { 553 TCU_FAIL("Mismatch between VkPhysicalDeviceDynamicRenderingFeatures"); 554 } 555 return tcu::TestStatus::pass("Querying succeeded"); 556} 557 558tcu::TestStatus testPhysicalDeviceFeatureExtendedDynamicStateFeaturesEXT (Context& context) 559{ 560 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 561 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 562 const InstanceDriver& vki (instance.getDriver()); 563 const int count = 2u; 564 TestLog& log = context.getTestContext().getLog(); 565 VkPhysicalDeviceFeatures2 extFeatures; 566 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 567 568 VkPhysicalDeviceExtendedDynamicStateFeaturesEXT deviceExtendedDynamicStateFeaturesEXT[count]; 569 const bool isExtendedDynamicStateFeaturesEXT = checkExtension(properties, "VK_EXT_extended_dynamic_state") || context.contextSupports(vk::ApiVersion(1, 3, 0)); 570 571 for (int ndx = 0; ndx < count; ++ndx) 572 { 573 deMemset(&deviceExtendedDynamicStateFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT)); 574 deviceExtendedDynamicStateFeaturesEXT[ndx].sType = isExtendedDynamicStateFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 575 deviceExtendedDynamicStateFeaturesEXT[ndx].pNext = DE_NULL; 576 577 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 578 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 579 extFeatures.pNext = &deviceExtendedDynamicStateFeaturesEXT[ndx]; 580 581 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 582 } 583 584 if (isExtendedDynamicStateFeaturesEXT) 585 log << TestLog::Message << deviceExtendedDynamicStateFeaturesEXT[0] << TestLog::EndMessage; 586 587 if (isExtendedDynamicStateFeaturesEXT && 588 (deviceExtendedDynamicStateFeaturesEXT[0].extendedDynamicState != deviceExtendedDynamicStateFeaturesEXT[1].extendedDynamicState)) 589 { 590 TCU_FAIL("Mismatch between VkPhysicalDeviceExtendedDynamicStateFeaturesEXT"); 591 } 592 return tcu::TestStatus::pass("Querying succeeded"); 593} 594 595tcu::TestStatus testPhysicalDeviceFeatureExtendedDynamicState2FeaturesEXT (Context& context) 596{ 597 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 598 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 599 const InstanceDriver& vki (instance.getDriver()); 600 const int count = 2u; 601 TestLog& log = context.getTestContext().getLog(); 602 VkPhysicalDeviceFeatures2 extFeatures; 603 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 604 605 VkPhysicalDeviceExtendedDynamicState2FeaturesEXT deviceExtendedDynamicState2FeaturesEXT[count]; 606 const bool isExtendedDynamicState2FeaturesEXT = checkExtension(properties, "VK_EXT_extended_dynamic_state2"); 607 608 for (int ndx = 0; ndx < count; ++ndx) 609 { 610 deMemset(&deviceExtendedDynamicState2FeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT)); 611 deviceExtendedDynamicState2FeaturesEXT[ndx].sType = isExtendedDynamicState2FeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 612 deviceExtendedDynamicState2FeaturesEXT[ndx].pNext = DE_NULL; 613 614 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 615 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 616 extFeatures.pNext = &deviceExtendedDynamicState2FeaturesEXT[ndx]; 617 618 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 619 } 620 621 if (isExtendedDynamicState2FeaturesEXT) 622 log << TestLog::Message << deviceExtendedDynamicState2FeaturesEXT[0] << TestLog::EndMessage; 623 624 if (isExtendedDynamicState2FeaturesEXT && 625 (deviceExtendedDynamicState2FeaturesEXT[0].extendedDynamicState2 != deviceExtendedDynamicState2FeaturesEXT[1].extendedDynamicState2 || 626 deviceExtendedDynamicState2FeaturesEXT[0].extendedDynamicState2LogicOp != deviceExtendedDynamicState2FeaturesEXT[1].extendedDynamicState2LogicOp || 627 deviceExtendedDynamicState2FeaturesEXT[0].extendedDynamicState2PatchControlPoints != deviceExtendedDynamicState2FeaturesEXT[1].extendedDynamicState2PatchControlPoints)) 628 { 629 TCU_FAIL("Mismatch between VkPhysicalDeviceExtendedDynamicState2FeaturesEXT"); 630 } 631 return tcu::TestStatus::pass("Querying succeeded"); 632} 633 634tcu::TestStatus testPhysicalDeviceFeatureFragmentDensityMapFeaturesEXT (Context& context) 635{ 636 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 637 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 638 const InstanceDriver& vki (instance.getDriver()); 639 const int count = 2u; 640 TestLog& log = context.getTestContext().getLog(); 641 VkPhysicalDeviceFeatures2 extFeatures; 642 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 643 644 VkPhysicalDeviceFragmentDensityMapFeaturesEXT deviceFragmentDensityMapFeaturesEXT[count]; 645 const bool isFragmentDensityMapFeaturesEXT = checkExtension(properties, "VK_EXT_fragment_density_map"); 646 647 for (int ndx = 0; ndx < count; ++ndx) 648 { 649 deMemset(&deviceFragmentDensityMapFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT)); 650 deviceFragmentDensityMapFeaturesEXT[ndx].sType = isFragmentDensityMapFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 651 deviceFragmentDensityMapFeaturesEXT[ndx].pNext = DE_NULL; 652 653 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 654 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 655 extFeatures.pNext = &deviceFragmentDensityMapFeaturesEXT[ndx]; 656 657 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 658 } 659 660 if (isFragmentDensityMapFeaturesEXT) 661 log << TestLog::Message << deviceFragmentDensityMapFeaturesEXT[0] << TestLog::EndMessage; 662 663 if (isFragmentDensityMapFeaturesEXT && 664 (deviceFragmentDensityMapFeaturesEXT[0].fragmentDensityMap != deviceFragmentDensityMapFeaturesEXT[1].fragmentDensityMap || 665 deviceFragmentDensityMapFeaturesEXT[0].fragmentDensityMapDynamic != deviceFragmentDensityMapFeaturesEXT[1].fragmentDensityMapDynamic || 666 deviceFragmentDensityMapFeaturesEXT[0].fragmentDensityMapNonSubsampledImages != deviceFragmentDensityMapFeaturesEXT[1].fragmentDensityMapNonSubsampledImages)) 667 { 668 TCU_FAIL("Mismatch between VkPhysicalDeviceFragmentDensityMapFeaturesEXT"); 669 } 670 return tcu::TestStatus::pass("Querying succeeded"); 671} 672 673tcu::TestStatus testPhysicalDeviceFeatureFragmentDensityMap2FeaturesEXT (Context& context) 674{ 675 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 676 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 677 const InstanceDriver& vki (instance.getDriver()); 678 const int count = 2u; 679 TestLog& log = context.getTestContext().getLog(); 680 VkPhysicalDeviceFeatures2 extFeatures; 681 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 682 683 VkPhysicalDeviceFragmentDensityMap2FeaturesEXT deviceFragmentDensityMap2FeaturesEXT[count]; 684 const bool isFragmentDensityMap2FeaturesEXT = checkExtension(properties, "VK_EXT_fragment_density_map2"); 685 686 for (int ndx = 0; ndx < count; ++ndx) 687 { 688 deMemset(&deviceFragmentDensityMap2FeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceFragmentDensityMap2FeaturesEXT)); 689 deviceFragmentDensityMap2FeaturesEXT[ndx].sType = isFragmentDensityMap2FeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 690 deviceFragmentDensityMap2FeaturesEXT[ndx].pNext = DE_NULL; 691 692 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 693 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 694 extFeatures.pNext = &deviceFragmentDensityMap2FeaturesEXT[ndx]; 695 696 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 697 } 698 699 if (isFragmentDensityMap2FeaturesEXT) 700 log << TestLog::Message << deviceFragmentDensityMap2FeaturesEXT[0] << TestLog::EndMessage; 701 702 if (isFragmentDensityMap2FeaturesEXT && 703 (deviceFragmentDensityMap2FeaturesEXT[0].fragmentDensityMapDeferred != deviceFragmentDensityMap2FeaturesEXT[1].fragmentDensityMapDeferred)) 704 { 705 TCU_FAIL("Mismatch between VkPhysicalDeviceFragmentDensityMap2FeaturesEXT"); 706 } 707 return tcu::TestStatus::pass("Querying succeeded"); 708} 709 710tcu::TestStatus testPhysicalDeviceFeatureFragmentShadingRateFeaturesKHR (Context& context) 711{ 712 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 713 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 714 const InstanceDriver& vki (instance.getDriver()); 715 const int count = 2u; 716 TestLog& log = context.getTestContext().getLog(); 717 VkPhysicalDeviceFeatures2 extFeatures; 718 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 719 720 VkPhysicalDeviceFragmentShadingRateFeaturesKHR deviceFragmentShadingRateFeaturesKHR[count]; 721 const bool isFragmentShadingRateFeaturesKHR = checkExtension(properties, "VK_KHR_fragment_shading_rate"); 722 723 for (int ndx = 0; ndx < count; ++ndx) 724 { 725 deMemset(&deviceFragmentShadingRateFeaturesKHR[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceFragmentShadingRateFeaturesKHR)); 726 deviceFragmentShadingRateFeaturesKHR[ndx].sType = isFragmentShadingRateFeaturesKHR ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR : VK_STRUCTURE_TYPE_MAX_ENUM; 727 deviceFragmentShadingRateFeaturesKHR[ndx].pNext = DE_NULL; 728 729 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 730 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 731 extFeatures.pNext = &deviceFragmentShadingRateFeaturesKHR[ndx]; 732 733 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 734 } 735 736 if (isFragmentShadingRateFeaturesKHR) 737 log << TestLog::Message << deviceFragmentShadingRateFeaturesKHR[0] << TestLog::EndMessage; 738 739 if (isFragmentShadingRateFeaturesKHR && 740 (deviceFragmentShadingRateFeaturesKHR[0].pipelineFragmentShadingRate != deviceFragmentShadingRateFeaturesKHR[1].pipelineFragmentShadingRate || 741 deviceFragmentShadingRateFeaturesKHR[0].primitiveFragmentShadingRate != deviceFragmentShadingRateFeaturesKHR[1].primitiveFragmentShadingRate || 742 deviceFragmentShadingRateFeaturesKHR[0].attachmentFragmentShadingRate != deviceFragmentShadingRateFeaturesKHR[1].attachmentFragmentShadingRate)) 743 { 744 TCU_FAIL("Mismatch between VkPhysicalDeviceFragmentShadingRateFeaturesKHR"); 745 } 746 return tcu::TestStatus::pass("Querying succeeded"); 747} 748 749tcu::TestStatus testPhysicalDeviceFeatureGlobalPriorityQueryFeaturesKHR (Context& context) 750{ 751 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 752 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 753 const InstanceDriver& vki (instance.getDriver()); 754 const int count = 2u; 755 TestLog& log = context.getTestContext().getLog(); 756 VkPhysicalDeviceFeatures2 extFeatures; 757 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 758 759 VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR deviceGlobalPriorityQueryFeaturesKHR[count]; 760 const bool isGlobalPriorityQueryFeaturesKHR = checkExtension(properties, "VK_KHR_global_priority"); 761 762 for (int ndx = 0; ndx < count; ++ndx) 763 { 764 deMemset(&deviceGlobalPriorityQueryFeaturesKHR[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR)); 765 deviceGlobalPriorityQueryFeaturesKHR[ndx].sType = isGlobalPriorityQueryFeaturesKHR ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR : VK_STRUCTURE_TYPE_MAX_ENUM; 766 deviceGlobalPriorityQueryFeaturesKHR[ndx].pNext = DE_NULL; 767 768 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 769 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 770 extFeatures.pNext = &deviceGlobalPriorityQueryFeaturesKHR[ndx]; 771 772 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 773 } 774 775 if (isGlobalPriorityQueryFeaturesKHR) 776 log << TestLog::Message << deviceGlobalPriorityQueryFeaturesKHR[0] << TestLog::EndMessage; 777 778 if (isGlobalPriorityQueryFeaturesKHR && 779 (deviceGlobalPriorityQueryFeaturesKHR[0].globalPriorityQuery != deviceGlobalPriorityQueryFeaturesKHR[1].globalPriorityQuery)) 780 { 781 TCU_FAIL("Mismatch between VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR"); 782 } 783 return tcu::TestStatus::pass("Querying succeeded"); 784} 785 786tcu::TestStatus testPhysicalDeviceFeatureInlineUniformBlockFeatures (Context& context) 787{ 788 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 789 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 790 const InstanceDriver& vki (instance.getDriver()); 791 const int count = 2u; 792 TestLog& log = context.getTestContext().getLog(); 793 VkPhysicalDeviceFeatures2 extFeatures; 794 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 795 796 VkPhysicalDeviceInlineUniformBlockFeatures deviceInlineUniformBlockFeatures[count]; 797 const bool isInlineUniformBlockFeatures = checkExtension(properties, "VK_EXT_inline_uniform_block") || context.contextSupports(vk::ApiVersion(1, 3, 0)); 798 799 for (int ndx = 0; ndx < count; ++ndx) 800 { 801 deMemset(&deviceInlineUniformBlockFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceInlineUniformBlockFeatures)); 802 deviceInlineUniformBlockFeatures[ndx].sType = isInlineUniformBlockFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 803 deviceInlineUniformBlockFeatures[ndx].pNext = DE_NULL; 804 805 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 806 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 807 extFeatures.pNext = &deviceInlineUniformBlockFeatures[ndx]; 808 809 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 810 } 811 812 if (isInlineUniformBlockFeatures) 813 log << TestLog::Message << deviceInlineUniformBlockFeatures[0] << TestLog::EndMessage; 814 815 if (isInlineUniformBlockFeatures && 816 (deviceInlineUniformBlockFeatures[0].inlineUniformBlock != deviceInlineUniformBlockFeatures[1].inlineUniformBlock || 817 deviceInlineUniformBlockFeatures[0].descriptorBindingInlineUniformBlockUpdateAfterBind != deviceInlineUniformBlockFeatures[1].descriptorBindingInlineUniformBlockUpdateAfterBind)) 818 { 819 TCU_FAIL("Mismatch between VkPhysicalDeviceInlineUniformBlockFeatures"); 820 } 821 return tcu::TestStatus::pass("Querying succeeded"); 822} 823 824tcu::TestStatus testPhysicalDeviceFeatureIndexTypeUint8FeaturesEXT (Context& context) 825{ 826 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 827 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 828 const InstanceDriver& vki (instance.getDriver()); 829 const int count = 2u; 830 TestLog& log = context.getTestContext().getLog(); 831 VkPhysicalDeviceFeatures2 extFeatures; 832 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 833 834 VkPhysicalDeviceIndexTypeUint8FeaturesEXT deviceIndexTypeUint8FeaturesEXT[count]; 835 const bool isIndexTypeUint8FeaturesEXT = checkExtension(properties, "VK_EXT_index_type_uint8"); 836 837 for (int ndx = 0; ndx < count; ++ndx) 838 { 839 deMemset(&deviceIndexTypeUint8FeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceIndexTypeUint8FeaturesEXT)); 840 deviceIndexTypeUint8FeaturesEXT[ndx].sType = isIndexTypeUint8FeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 841 deviceIndexTypeUint8FeaturesEXT[ndx].pNext = DE_NULL; 842 843 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 844 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 845 extFeatures.pNext = &deviceIndexTypeUint8FeaturesEXT[ndx]; 846 847 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 848 } 849 850 if (isIndexTypeUint8FeaturesEXT) 851 log << TestLog::Message << deviceIndexTypeUint8FeaturesEXT[0] << TestLog::EndMessage; 852 853 if (isIndexTypeUint8FeaturesEXT && 854 (deviceIndexTypeUint8FeaturesEXT[0].indexTypeUint8 != deviceIndexTypeUint8FeaturesEXT[1].indexTypeUint8)) 855 { 856 TCU_FAIL("Mismatch between VkPhysicalDeviceIndexTypeUint8FeaturesEXT"); 857 } 858 return tcu::TestStatus::pass("Querying succeeded"); 859} 860 861tcu::TestStatus testPhysicalDeviceFeatureImagelessFramebufferFeatures (Context& context) 862{ 863 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 864 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 865 const InstanceDriver& vki (instance.getDriver()); 866 const int count = 2u; 867 TestLog& log = context.getTestContext().getLog(); 868 VkPhysicalDeviceFeatures2 extFeatures; 869 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 870 871 VkPhysicalDeviceImagelessFramebufferFeatures deviceImagelessFramebufferFeatures[count]; 872 const bool isImagelessFramebufferFeatures = checkExtension(properties, "VK_KHR_imageless_framebuffer") || context.contextSupports(vk::ApiVersion(1, 2, 0)); 873 874 for (int ndx = 0; ndx < count; ++ndx) 875 { 876 deMemset(&deviceImagelessFramebufferFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceImagelessFramebufferFeatures)); 877 deviceImagelessFramebufferFeatures[ndx].sType = isImagelessFramebufferFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 878 deviceImagelessFramebufferFeatures[ndx].pNext = DE_NULL; 879 880 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 881 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 882 extFeatures.pNext = &deviceImagelessFramebufferFeatures[ndx]; 883 884 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 885 } 886 887 if (isImagelessFramebufferFeatures) 888 log << TestLog::Message << deviceImagelessFramebufferFeatures[0] << TestLog::EndMessage; 889 890 if (isImagelessFramebufferFeatures && 891 (deviceImagelessFramebufferFeatures[0].imagelessFramebuffer != deviceImagelessFramebufferFeatures[1].imagelessFramebuffer)) 892 { 893 TCU_FAIL("Mismatch between VkPhysicalDeviceImagelessFramebufferFeatures"); 894 } 895 return tcu::TestStatus::pass("Querying succeeded"); 896} 897 898tcu::TestStatus testPhysicalDeviceFeatureImageRobustnessFeatures (Context& context) 899{ 900 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 901 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 902 const InstanceDriver& vki (instance.getDriver()); 903 const int count = 2u; 904 TestLog& log = context.getTestContext().getLog(); 905 VkPhysicalDeviceFeatures2 extFeatures; 906 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 907 908 VkPhysicalDeviceImageRobustnessFeatures deviceImageRobustnessFeatures[count]; 909 const bool isImageRobustnessFeatures = checkExtension(properties, "VK_EXT_image_robustness") || context.contextSupports(vk::ApiVersion(1, 3, 0)); 910 911 for (int ndx = 0; ndx < count; ++ndx) 912 { 913 deMemset(&deviceImageRobustnessFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceImageRobustnessFeatures)); 914 deviceImageRobustnessFeatures[ndx].sType = isImageRobustnessFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 915 deviceImageRobustnessFeatures[ndx].pNext = DE_NULL; 916 917 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 918 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 919 extFeatures.pNext = &deviceImageRobustnessFeatures[ndx]; 920 921 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 922 } 923 924 if (isImageRobustnessFeatures) 925 log << TestLog::Message << deviceImageRobustnessFeatures[0] << TestLog::EndMessage; 926 927 if (isImageRobustnessFeatures && 928 (deviceImageRobustnessFeatures[0].robustImageAccess != deviceImageRobustnessFeatures[1].robustImageAccess)) 929 { 930 TCU_FAIL("Mismatch between VkPhysicalDeviceImageRobustnessFeatures"); 931 } 932 return tcu::TestStatus::pass("Querying succeeded"); 933} 934 935tcu::TestStatus testPhysicalDeviceFeatureHostQueryResetFeatures (Context& context) 936{ 937 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 938 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 939 const InstanceDriver& vki (instance.getDriver()); 940 const int count = 2u; 941 TestLog& log = context.getTestContext().getLog(); 942 VkPhysicalDeviceFeatures2 extFeatures; 943 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 944 945 VkPhysicalDeviceHostQueryResetFeatures deviceHostQueryResetFeatures[count]; 946 const bool isHostQueryResetFeatures = checkExtension(properties, "VK_EXT_host_query_reset") || context.contextSupports(vk::ApiVersion(1, 2, 0)); 947 948 for (int ndx = 0; ndx < count; ++ndx) 949 { 950 deMemset(&deviceHostQueryResetFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceHostQueryResetFeatures)); 951 deviceHostQueryResetFeatures[ndx].sType = isHostQueryResetFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 952 deviceHostQueryResetFeatures[ndx].pNext = DE_NULL; 953 954 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 955 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 956 extFeatures.pNext = &deviceHostQueryResetFeatures[ndx]; 957 958 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 959 } 960 961 if (isHostQueryResetFeatures) 962 log << TestLog::Message << deviceHostQueryResetFeatures[0] << TestLog::EndMessage; 963 964 if (isHostQueryResetFeatures && 965 (deviceHostQueryResetFeatures[0].hostQueryReset != deviceHostQueryResetFeatures[1].hostQueryReset)) 966 { 967 TCU_FAIL("Mismatch between VkPhysicalDeviceHostQueryResetFeatures"); 968 } 969 return tcu::TestStatus::pass("Querying succeeded"); 970} 971 972tcu::TestStatus testPhysicalDeviceFeatureLineRasterizationFeaturesEXT (Context& context) 973{ 974 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 975 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 976 const InstanceDriver& vki (instance.getDriver()); 977 const int count = 2u; 978 TestLog& log = context.getTestContext().getLog(); 979 VkPhysicalDeviceFeatures2 extFeatures; 980 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 981 982 VkPhysicalDeviceLineRasterizationFeaturesEXT deviceLineRasterizationFeaturesEXT[count]; 983 const bool isLineRasterizationFeaturesEXT = checkExtension(properties, "VK_EXT_line_rasterization"); 984 985 for (int ndx = 0; ndx < count; ++ndx) 986 { 987 deMemset(&deviceLineRasterizationFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceLineRasterizationFeaturesEXT)); 988 deviceLineRasterizationFeaturesEXT[ndx].sType = isLineRasterizationFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 989 deviceLineRasterizationFeaturesEXT[ndx].pNext = DE_NULL; 990 991 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 992 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 993 extFeatures.pNext = &deviceLineRasterizationFeaturesEXT[ndx]; 994 995 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 996 } 997 998 if (isLineRasterizationFeaturesEXT) 999 log << TestLog::Message << deviceLineRasterizationFeaturesEXT[0] << TestLog::EndMessage; 1000 1001 if (isLineRasterizationFeaturesEXT && 1002 (deviceLineRasterizationFeaturesEXT[0].rectangularLines != deviceLineRasterizationFeaturesEXT[1].rectangularLines || 1003 deviceLineRasterizationFeaturesEXT[0].bresenhamLines != deviceLineRasterizationFeaturesEXT[1].bresenhamLines || 1004 deviceLineRasterizationFeaturesEXT[0].smoothLines != deviceLineRasterizationFeaturesEXT[1].smoothLines || 1005 deviceLineRasterizationFeaturesEXT[0].stippledRectangularLines != deviceLineRasterizationFeaturesEXT[1].stippledRectangularLines || 1006 deviceLineRasterizationFeaturesEXT[0].stippledBresenhamLines != deviceLineRasterizationFeaturesEXT[1].stippledBresenhamLines || 1007 deviceLineRasterizationFeaturesEXT[0].stippledSmoothLines != deviceLineRasterizationFeaturesEXT[1].stippledSmoothLines)) 1008 { 1009 TCU_FAIL("Mismatch between VkPhysicalDeviceLineRasterizationFeaturesEXT"); 1010 } 1011 return tcu::TestStatus::pass("Querying succeeded"); 1012} 1013 1014tcu::TestStatus testPhysicalDeviceFeatureMaintenance4Features (Context& context) 1015{ 1016 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1017 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1018 const InstanceDriver& vki (instance.getDriver()); 1019 const int count = 2u; 1020 TestLog& log = context.getTestContext().getLog(); 1021 VkPhysicalDeviceFeatures2 extFeatures; 1022 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1023 1024 VkPhysicalDeviceMaintenance4Features deviceMaintenance4Features[count]; 1025 const bool isMaintenance4Features = checkExtension(properties, "VK_KHR_maintenance4") || context.contextSupports(vk::ApiVersion(1, 3, 0)); 1026 1027 for (int ndx = 0; ndx < count; ++ndx) 1028 { 1029 deMemset(&deviceMaintenance4Features[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceMaintenance4Features)); 1030 deviceMaintenance4Features[ndx].sType = isMaintenance4Features ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 1031 deviceMaintenance4Features[ndx].pNext = DE_NULL; 1032 1033 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1034 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1035 extFeatures.pNext = &deviceMaintenance4Features[ndx]; 1036 1037 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1038 } 1039 1040 if (isMaintenance4Features) 1041 log << TestLog::Message << deviceMaintenance4Features[0] << TestLog::EndMessage; 1042 1043 if (isMaintenance4Features && 1044 (deviceMaintenance4Features[0].maintenance4 != deviceMaintenance4Features[1].maintenance4)) 1045 { 1046 TCU_FAIL("Mismatch between VkPhysicalDeviceMaintenance4Features"); 1047 } 1048 return tcu::TestStatus::pass("Querying succeeded"); 1049} 1050 1051tcu::TestStatus testPhysicalDeviceFeatureMultiviewFeatures (Context& context) 1052{ 1053 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1054 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1055 const InstanceDriver& vki (instance.getDriver()); 1056 const int count = 2u; 1057 TestLog& log = context.getTestContext().getLog(); 1058 VkPhysicalDeviceFeatures2 extFeatures; 1059 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1060 1061 VkPhysicalDeviceMultiviewFeatures deviceMultiviewFeatures[count]; 1062 const bool isMultiviewFeatures = checkExtension(properties, "VK_KHR_multiview") || context.contextSupports(vk::ApiVersion(1, 1, 0)); 1063 1064 for (int ndx = 0; ndx < count; ++ndx) 1065 { 1066 deMemset(&deviceMultiviewFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceMultiviewFeatures)); 1067 deviceMultiviewFeatures[ndx].sType = isMultiviewFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 1068 deviceMultiviewFeatures[ndx].pNext = DE_NULL; 1069 1070 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1071 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1072 extFeatures.pNext = &deviceMultiviewFeatures[ndx]; 1073 1074 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1075 } 1076 1077 if (isMultiviewFeatures) 1078 log << TestLog::Message << deviceMultiviewFeatures[0] << TestLog::EndMessage; 1079 1080 if (isMultiviewFeatures && 1081 (deviceMultiviewFeatures[0].multiview != deviceMultiviewFeatures[1].multiview || 1082 deviceMultiviewFeatures[0].multiviewGeometryShader != deviceMultiviewFeatures[1].multiviewGeometryShader || 1083 deviceMultiviewFeatures[0].multiviewTessellationShader != deviceMultiviewFeatures[1].multiviewTessellationShader)) 1084 { 1085 TCU_FAIL("Mismatch between VkPhysicalDeviceMultiviewFeatures"); 1086 } 1087 return tcu::TestStatus::pass("Querying succeeded"); 1088} 1089 1090tcu::TestStatus testPhysicalDeviceFeatureMultiDrawFeaturesEXT (Context& context) 1091{ 1092 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1093 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1094 const InstanceDriver& vki (instance.getDriver()); 1095 const int count = 2u; 1096 TestLog& log = context.getTestContext().getLog(); 1097 VkPhysicalDeviceFeatures2 extFeatures; 1098 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1099 1100 VkPhysicalDeviceMultiDrawFeaturesEXT deviceMultiDrawFeaturesEXT[count]; 1101 const bool isMultiDrawFeaturesEXT = checkExtension(properties, "VK_EXT_multi_draw"); 1102 1103 for (int ndx = 0; ndx < count; ++ndx) 1104 { 1105 deMemset(&deviceMultiDrawFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceMultiDrawFeaturesEXT)); 1106 deviceMultiDrawFeaturesEXT[ndx].sType = isMultiDrawFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1107 deviceMultiDrawFeaturesEXT[ndx].pNext = DE_NULL; 1108 1109 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1110 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1111 extFeatures.pNext = &deviceMultiDrawFeaturesEXT[ndx]; 1112 1113 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1114 } 1115 1116 if (isMultiDrawFeaturesEXT) 1117 log << TestLog::Message << deviceMultiDrawFeaturesEXT[0] << TestLog::EndMessage; 1118 1119 if (isMultiDrawFeaturesEXT && 1120 (deviceMultiDrawFeaturesEXT[0].multiDraw != deviceMultiDrawFeaturesEXT[1].multiDraw)) 1121 { 1122 TCU_FAIL("Mismatch between VkPhysicalDeviceMultiDrawFeaturesEXT"); 1123 } 1124 return tcu::TestStatus::pass("Querying succeeded"); 1125} 1126 1127tcu::TestStatus testPhysicalDeviceFeatureMemoryPriorityFeaturesEXT (Context& context) 1128{ 1129 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1130 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1131 const InstanceDriver& vki (instance.getDriver()); 1132 const int count = 2u; 1133 TestLog& log = context.getTestContext().getLog(); 1134 VkPhysicalDeviceFeatures2 extFeatures; 1135 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1136 1137 VkPhysicalDeviceMemoryPriorityFeaturesEXT deviceMemoryPriorityFeaturesEXT[count]; 1138 const bool isMemoryPriorityFeaturesEXT = checkExtension(properties, "VK_EXT_memory_priority"); 1139 1140 for (int ndx = 0; ndx < count; ++ndx) 1141 { 1142 deMemset(&deviceMemoryPriorityFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceMemoryPriorityFeaturesEXT)); 1143 deviceMemoryPriorityFeaturesEXT[ndx].sType = isMemoryPriorityFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1144 deviceMemoryPriorityFeaturesEXT[ndx].pNext = DE_NULL; 1145 1146 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1147 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1148 extFeatures.pNext = &deviceMemoryPriorityFeaturesEXT[ndx]; 1149 1150 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1151 } 1152 1153 if (isMemoryPriorityFeaturesEXT) 1154 log << TestLog::Message << deviceMemoryPriorityFeaturesEXT[0] << TestLog::EndMessage; 1155 1156 if (isMemoryPriorityFeaturesEXT && 1157 (deviceMemoryPriorityFeaturesEXT[0].memoryPriority != deviceMemoryPriorityFeaturesEXT[1].memoryPriority)) 1158 { 1159 TCU_FAIL("Mismatch between VkPhysicalDeviceMemoryPriorityFeaturesEXT"); 1160 } 1161 return tcu::TestStatus::pass("Querying succeeded"); 1162} 1163 1164tcu::TestStatus testPhysicalDeviceFeatureDeviceMemoryReportFeaturesEXT (Context& context) 1165{ 1166 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1167 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1168 const InstanceDriver& vki (instance.getDriver()); 1169 const int count = 2u; 1170 TestLog& log = context.getTestContext().getLog(); 1171 VkPhysicalDeviceFeatures2 extFeatures; 1172 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1173 1174 VkPhysicalDeviceDeviceMemoryReportFeaturesEXT deviceDeviceMemoryReportFeaturesEXT[count]; 1175 const bool isDeviceMemoryReportFeaturesEXT = checkExtension(properties, "VK_EXT_device_memory_report"); 1176 1177 for (int ndx = 0; ndx < count; ++ndx) 1178 { 1179 deMemset(&deviceDeviceMemoryReportFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceDeviceMemoryReportFeaturesEXT)); 1180 deviceDeviceMemoryReportFeaturesEXT[ndx].sType = isDeviceMemoryReportFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1181 deviceDeviceMemoryReportFeaturesEXT[ndx].pNext = DE_NULL; 1182 1183 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1184 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1185 extFeatures.pNext = &deviceDeviceMemoryReportFeaturesEXT[ndx]; 1186 1187 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1188 } 1189 1190 if (isDeviceMemoryReportFeaturesEXT) 1191 log << TestLog::Message << deviceDeviceMemoryReportFeaturesEXT[0] << TestLog::EndMessage; 1192 1193 if (isDeviceMemoryReportFeaturesEXT && 1194 (deviceDeviceMemoryReportFeaturesEXT[0].deviceMemoryReport != deviceDeviceMemoryReportFeaturesEXT[1].deviceMemoryReport)) 1195 { 1196 TCU_FAIL("Mismatch between VkPhysicalDeviceDeviceMemoryReportFeaturesEXT"); 1197 } 1198 return tcu::TestStatus::pass("Querying succeeded"); 1199} 1200 1201tcu::TestStatus testPhysicalDeviceFeaturePerformanceQueryFeaturesKHR (Context& context) 1202{ 1203 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1204 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1205 const InstanceDriver& vki (instance.getDriver()); 1206 const int count = 2u; 1207 TestLog& log = context.getTestContext().getLog(); 1208 VkPhysicalDeviceFeatures2 extFeatures; 1209 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1210 1211 VkPhysicalDevicePerformanceQueryFeaturesKHR devicePerformanceQueryFeaturesKHR[count]; 1212 const bool isPerformanceQueryFeaturesKHR = checkExtension(properties, "VK_KHR_performance_query"); 1213 1214 for (int ndx = 0; ndx < count; ++ndx) 1215 { 1216 deMemset(&devicePerformanceQueryFeaturesKHR[ndx], 0xFF * ndx, sizeof(VkPhysicalDevicePerformanceQueryFeaturesKHR)); 1217 devicePerformanceQueryFeaturesKHR[ndx].sType = isPerformanceQueryFeaturesKHR ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR : VK_STRUCTURE_TYPE_MAX_ENUM; 1218 devicePerformanceQueryFeaturesKHR[ndx].pNext = DE_NULL; 1219 1220 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1221 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1222 extFeatures.pNext = &devicePerformanceQueryFeaturesKHR[ndx]; 1223 1224 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1225 } 1226 1227 if (isPerformanceQueryFeaturesKHR) 1228 log << TestLog::Message << devicePerformanceQueryFeaturesKHR[0] << TestLog::EndMessage; 1229 1230 if (isPerformanceQueryFeaturesKHR && 1231 (devicePerformanceQueryFeaturesKHR[0].performanceCounterQueryPools != devicePerformanceQueryFeaturesKHR[1].performanceCounterQueryPools || 1232 devicePerformanceQueryFeaturesKHR[0].performanceCounterMultipleQueryPools != devicePerformanceQueryFeaturesKHR[1].performanceCounterMultipleQueryPools)) 1233 { 1234 TCU_FAIL("Mismatch between VkPhysicalDevicePerformanceQueryFeaturesKHR"); 1235 } 1236 return tcu::TestStatus::pass("Querying succeeded"); 1237} 1238 1239tcu::TestStatus testPhysicalDeviceFeaturePipelineCreationCacheControlFeatures (Context& context) 1240{ 1241 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1242 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1243 const InstanceDriver& vki (instance.getDriver()); 1244 const int count = 2u; 1245 TestLog& log = context.getTestContext().getLog(); 1246 VkPhysicalDeviceFeatures2 extFeatures; 1247 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1248 1249 VkPhysicalDevicePipelineCreationCacheControlFeatures devicePipelineCreationCacheControlFeatures[count]; 1250 const bool isPipelineCreationCacheControlFeatures = checkExtension(properties, "VK_EXT_pipeline_creation_cache_control") || context.contextSupports(vk::ApiVersion(1, 3, 0)); 1251 1252 for (int ndx = 0; ndx < count; ++ndx) 1253 { 1254 deMemset(&devicePipelineCreationCacheControlFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDevicePipelineCreationCacheControlFeatures)); 1255 devicePipelineCreationCacheControlFeatures[ndx].sType = isPipelineCreationCacheControlFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 1256 devicePipelineCreationCacheControlFeatures[ndx].pNext = DE_NULL; 1257 1258 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1259 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1260 extFeatures.pNext = &devicePipelineCreationCacheControlFeatures[ndx]; 1261 1262 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1263 } 1264 1265 if (isPipelineCreationCacheControlFeatures) 1266 log << TestLog::Message << devicePipelineCreationCacheControlFeatures[0] << TestLog::EndMessage; 1267 1268 if (isPipelineCreationCacheControlFeatures && 1269 (devicePipelineCreationCacheControlFeatures[0].pipelineCreationCacheControl != devicePipelineCreationCacheControlFeatures[1].pipelineCreationCacheControl)) 1270 { 1271 TCU_FAIL("Mismatch between VkPhysicalDevicePipelineCreationCacheControlFeatures"); 1272 } 1273 return tcu::TestStatus::pass("Querying succeeded"); 1274} 1275 1276tcu::TestStatus testPhysicalDeviceFeaturePipelineExecutablePropertiesFeaturesKHR (Context& context) 1277{ 1278 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1279 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1280 const InstanceDriver& vki (instance.getDriver()); 1281 const int count = 2u; 1282 TestLog& log = context.getTestContext().getLog(); 1283 VkPhysicalDeviceFeatures2 extFeatures; 1284 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1285 1286 VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR devicePipelineExecutablePropertiesFeaturesKHR[count]; 1287 const bool isPipelineExecutablePropertiesFeaturesKHR = checkExtension(properties, "VK_KHR_pipeline_executable_properties"); 1288 1289 for (int ndx = 0; ndx < count; ++ndx) 1290 { 1291 deMemset(&devicePipelineExecutablePropertiesFeaturesKHR[ndx], 0xFF * ndx, sizeof(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR)); 1292 devicePipelineExecutablePropertiesFeaturesKHR[ndx].sType = isPipelineExecutablePropertiesFeaturesKHR ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR : VK_STRUCTURE_TYPE_MAX_ENUM; 1293 devicePipelineExecutablePropertiesFeaturesKHR[ndx].pNext = DE_NULL; 1294 1295 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1296 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1297 extFeatures.pNext = &devicePipelineExecutablePropertiesFeaturesKHR[ndx]; 1298 1299 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1300 } 1301 1302 if (isPipelineExecutablePropertiesFeaturesKHR) 1303 log << TestLog::Message << devicePipelineExecutablePropertiesFeaturesKHR[0] << TestLog::EndMessage; 1304 1305 if (isPipelineExecutablePropertiesFeaturesKHR && 1306 (devicePipelineExecutablePropertiesFeaturesKHR[0].pipelineExecutableInfo != devicePipelineExecutablePropertiesFeaturesKHR[1].pipelineExecutableInfo)) 1307 { 1308 TCU_FAIL("Mismatch between VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR"); 1309 } 1310 return tcu::TestStatus::pass("Querying succeeded"); 1311} 1312 1313tcu::TestStatus testPhysicalDeviceFeaturePresentIdFeaturesKHR (Context& context) 1314{ 1315 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1316 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1317 const InstanceDriver& vki (instance.getDriver()); 1318 const int count = 2u; 1319 TestLog& log = context.getTestContext().getLog(); 1320 VkPhysicalDeviceFeatures2 extFeatures; 1321 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1322 1323 VkPhysicalDevicePresentIdFeaturesKHR devicePresentIdFeaturesKHR[count]; 1324 const bool isPresentIdFeaturesKHR = checkExtension(properties, "VK_KHR_present_id"); 1325 1326 for (int ndx = 0; ndx < count; ++ndx) 1327 { 1328 deMemset(&devicePresentIdFeaturesKHR[ndx], 0xFF * ndx, sizeof(VkPhysicalDevicePresentIdFeaturesKHR)); 1329 devicePresentIdFeaturesKHR[ndx].sType = isPresentIdFeaturesKHR ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR : VK_STRUCTURE_TYPE_MAX_ENUM; 1330 devicePresentIdFeaturesKHR[ndx].pNext = DE_NULL; 1331 1332 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1333 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1334 extFeatures.pNext = &devicePresentIdFeaturesKHR[ndx]; 1335 1336 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1337 } 1338 1339 if (isPresentIdFeaturesKHR) 1340 log << TestLog::Message << devicePresentIdFeaturesKHR[0] << TestLog::EndMessage; 1341 1342 if (isPresentIdFeaturesKHR && 1343 (devicePresentIdFeaturesKHR[0].presentId != devicePresentIdFeaturesKHR[1].presentId)) 1344 { 1345 TCU_FAIL("Mismatch between VkPhysicalDevicePresentIdFeaturesKHR"); 1346 } 1347 return tcu::TestStatus::pass("Querying succeeded"); 1348} 1349 1350tcu::TestStatus testPhysicalDeviceFeaturePresentWaitFeaturesKHR (Context& context) 1351{ 1352 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1353 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1354 const InstanceDriver& vki (instance.getDriver()); 1355 const int count = 2u; 1356 TestLog& log = context.getTestContext().getLog(); 1357 VkPhysicalDeviceFeatures2 extFeatures; 1358 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1359 1360 VkPhysicalDevicePresentWaitFeaturesKHR devicePresentWaitFeaturesKHR[count]; 1361 const bool isPresentWaitFeaturesKHR = checkExtension(properties, "VK_KHR_present_wait"); 1362 1363 for (int ndx = 0; ndx < count; ++ndx) 1364 { 1365 deMemset(&devicePresentWaitFeaturesKHR[ndx], 0xFF * ndx, sizeof(VkPhysicalDevicePresentWaitFeaturesKHR)); 1366 devicePresentWaitFeaturesKHR[ndx].sType = isPresentWaitFeaturesKHR ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR : VK_STRUCTURE_TYPE_MAX_ENUM; 1367 devicePresentWaitFeaturesKHR[ndx].pNext = DE_NULL; 1368 1369 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1370 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1371 extFeatures.pNext = &devicePresentWaitFeaturesKHR[ndx]; 1372 1373 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1374 } 1375 1376 if (isPresentWaitFeaturesKHR) 1377 log << TestLog::Message << devicePresentWaitFeaturesKHR[0] << TestLog::EndMessage; 1378 1379 if (isPresentWaitFeaturesKHR && 1380 (devicePresentWaitFeaturesKHR[0].presentWait != devicePresentWaitFeaturesKHR[1].presentWait)) 1381 { 1382 TCU_FAIL("Mismatch between VkPhysicalDevicePresentWaitFeaturesKHR"); 1383 } 1384 return tcu::TestStatus::pass("Querying succeeded"); 1385} 1386 1387tcu::TestStatus testPhysicalDeviceFeatureProtectedMemoryFeatures (Context& context) 1388{ 1389 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1390 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1391 const InstanceDriver& vki (instance.getDriver()); 1392 const int count = 2u; 1393 TestLog& log = context.getTestContext().getLog(); 1394 VkPhysicalDeviceFeatures2 extFeatures; 1395 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1396 1397 VkPhysicalDeviceProtectedMemoryFeatures deviceProtectedMemoryFeatures[count]; 1398 const bool isProtectedMemoryFeatures = context.contextSupports(vk::ApiVersion(1, 1, 0)); 1399 1400 for (int ndx = 0; ndx < count; ++ndx) 1401 { 1402 deMemset(&deviceProtectedMemoryFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceProtectedMemoryFeatures)); 1403 deviceProtectedMemoryFeatures[ndx].sType = isProtectedMemoryFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 1404 deviceProtectedMemoryFeatures[ndx].pNext = DE_NULL; 1405 1406 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1407 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1408 extFeatures.pNext = &deviceProtectedMemoryFeatures[ndx]; 1409 1410 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1411 } 1412 1413 if (isProtectedMemoryFeatures) 1414 log << TestLog::Message << deviceProtectedMemoryFeatures[0] << TestLog::EndMessage; 1415 1416 if (isProtectedMemoryFeatures && 1417 (deviceProtectedMemoryFeatures[0].protectedMemory != deviceProtectedMemoryFeatures[1].protectedMemory)) 1418 { 1419 TCU_FAIL("Mismatch between VkPhysicalDeviceProtectedMemoryFeatures"); 1420 } 1421 return tcu::TestStatus::pass("Querying succeeded"); 1422} 1423 1424tcu::TestStatus testPhysicalDeviceFeatureProvokingVertexFeaturesEXT (Context& context) 1425{ 1426 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1427 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1428 const InstanceDriver& vki (instance.getDriver()); 1429 const int count = 2u; 1430 TestLog& log = context.getTestContext().getLog(); 1431 VkPhysicalDeviceFeatures2 extFeatures; 1432 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1433 1434 VkPhysicalDeviceProvokingVertexFeaturesEXT deviceProvokingVertexFeaturesEXT[count]; 1435 const bool isProvokingVertexFeaturesEXT = checkExtension(properties, "VK_EXT_provoking_vertex"); 1436 1437 for (int ndx = 0; ndx < count; ++ndx) 1438 { 1439 deMemset(&deviceProvokingVertexFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceProvokingVertexFeaturesEXT)); 1440 deviceProvokingVertexFeaturesEXT[ndx].sType = isProvokingVertexFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1441 deviceProvokingVertexFeaturesEXT[ndx].pNext = DE_NULL; 1442 1443 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1444 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1445 extFeatures.pNext = &deviceProvokingVertexFeaturesEXT[ndx]; 1446 1447 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1448 } 1449 1450 if (isProvokingVertexFeaturesEXT) 1451 log << TestLog::Message << deviceProvokingVertexFeaturesEXT[0] << TestLog::EndMessage; 1452 1453 if (isProvokingVertexFeaturesEXT && 1454 (deviceProvokingVertexFeaturesEXT[0].provokingVertexLast != deviceProvokingVertexFeaturesEXT[1].provokingVertexLast || 1455 deviceProvokingVertexFeaturesEXT[0].transformFeedbackPreservesProvokingVertex != deviceProvokingVertexFeaturesEXT[1].transformFeedbackPreservesProvokingVertex)) 1456 { 1457 TCU_FAIL("Mismatch between VkPhysicalDeviceProvokingVertexFeaturesEXT"); 1458 } 1459 return tcu::TestStatus::pass("Querying succeeded"); 1460} 1461 1462tcu::TestStatus testPhysicalDeviceFeaturePrimitiveTopologyListRestartFeaturesEXT (Context& context) 1463{ 1464 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1465 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1466 const InstanceDriver& vki (instance.getDriver()); 1467 const int count = 2u; 1468 TestLog& log = context.getTestContext().getLog(); 1469 VkPhysicalDeviceFeatures2 extFeatures; 1470 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1471 1472 VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT devicePrimitiveTopologyListRestartFeaturesEXT[count]; 1473 const bool isPrimitiveTopologyListRestartFeaturesEXT = checkExtension(properties, "VK_EXT_primitive_topology_list_restart"); 1474 1475 for (int ndx = 0; ndx < count; ++ndx) 1476 { 1477 deMemset(&devicePrimitiveTopologyListRestartFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT)); 1478 devicePrimitiveTopologyListRestartFeaturesEXT[ndx].sType = isPrimitiveTopologyListRestartFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1479 devicePrimitiveTopologyListRestartFeaturesEXT[ndx].pNext = DE_NULL; 1480 1481 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1482 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1483 extFeatures.pNext = &devicePrimitiveTopologyListRestartFeaturesEXT[ndx]; 1484 1485 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1486 } 1487 1488 if (isPrimitiveTopologyListRestartFeaturesEXT) 1489 log << TestLog::Message << devicePrimitiveTopologyListRestartFeaturesEXT[0] << TestLog::EndMessage; 1490 1491 if (isPrimitiveTopologyListRestartFeaturesEXT && 1492 (devicePrimitiveTopologyListRestartFeaturesEXT[0].primitiveTopologyListRestart != devicePrimitiveTopologyListRestartFeaturesEXT[1].primitiveTopologyListRestart || 1493 devicePrimitiveTopologyListRestartFeaturesEXT[0].primitiveTopologyPatchListRestart != devicePrimitiveTopologyListRestartFeaturesEXT[1].primitiveTopologyPatchListRestart)) 1494 { 1495 TCU_FAIL("Mismatch between VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT"); 1496 } 1497 return tcu::TestStatus::pass("Querying succeeded"); 1498} 1499 1500tcu::TestStatus testPhysicalDeviceFeaturePrivateDataFeatures (Context& context) 1501{ 1502 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1503 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1504 const InstanceDriver& vki (instance.getDriver()); 1505 const int count = 2u; 1506 TestLog& log = context.getTestContext().getLog(); 1507 VkPhysicalDeviceFeatures2 extFeatures; 1508 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1509 1510 VkPhysicalDevicePrivateDataFeatures devicePrivateDataFeatures[count]; 1511 const bool isPrivateDataFeatures = checkExtension(properties, "VK_EXT_private_data") || context.contextSupports(vk::ApiVersion(1, 3, 0)); 1512 1513 for (int ndx = 0; ndx < count; ++ndx) 1514 { 1515 deMemset(&devicePrivateDataFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDevicePrivateDataFeatures)); 1516 devicePrivateDataFeatures[ndx].sType = isPrivateDataFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 1517 devicePrivateDataFeatures[ndx].pNext = DE_NULL; 1518 1519 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1520 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1521 extFeatures.pNext = &devicePrivateDataFeatures[ndx]; 1522 1523 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1524 } 1525 1526 if (isPrivateDataFeatures) 1527 log << TestLog::Message << devicePrivateDataFeatures[0] << TestLog::EndMessage; 1528 1529 if (isPrivateDataFeatures && 1530 (devicePrivateDataFeatures[0].privateData != devicePrivateDataFeatures[1].privateData)) 1531 { 1532 TCU_FAIL("Mismatch between VkPhysicalDevicePrivateDataFeatures"); 1533 } 1534 return tcu::TestStatus::pass("Querying succeeded"); 1535} 1536 1537tcu::TestStatus testPhysicalDeviceFeatureRayTracingPipelineFeaturesKHR (Context& context) 1538{ 1539 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1540 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1541 const InstanceDriver& vki (instance.getDriver()); 1542 const int count = 2u; 1543 TestLog& log = context.getTestContext().getLog(); 1544 VkPhysicalDeviceFeatures2 extFeatures; 1545 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1546 1547 VkPhysicalDeviceRayTracingPipelineFeaturesKHR deviceRayTracingPipelineFeaturesKHR[count]; 1548 const bool isRayTracingPipelineFeaturesKHR = checkExtension(properties, "VK_KHR_ray_tracing_pipeline"); 1549 1550 for (int ndx = 0; ndx < count; ++ndx) 1551 { 1552 deMemset(&deviceRayTracingPipelineFeaturesKHR[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceRayTracingPipelineFeaturesKHR)); 1553 deviceRayTracingPipelineFeaturesKHR[ndx].sType = isRayTracingPipelineFeaturesKHR ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR : VK_STRUCTURE_TYPE_MAX_ENUM; 1554 deviceRayTracingPipelineFeaturesKHR[ndx].pNext = DE_NULL; 1555 1556 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1557 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1558 extFeatures.pNext = &deviceRayTracingPipelineFeaturesKHR[ndx]; 1559 1560 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1561 } 1562 1563 if (isRayTracingPipelineFeaturesKHR) 1564 log << TestLog::Message << deviceRayTracingPipelineFeaturesKHR[0] << TestLog::EndMessage; 1565 1566 if (isRayTracingPipelineFeaturesKHR && 1567 (deviceRayTracingPipelineFeaturesKHR[0].rayTracingPipeline != deviceRayTracingPipelineFeaturesKHR[1].rayTracingPipeline || 1568 deviceRayTracingPipelineFeaturesKHR[0].rayTracingPipelineShaderGroupHandleCaptureReplay != deviceRayTracingPipelineFeaturesKHR[1].rayTracingPipelineShaderGroupHandleCaptureReplay || 1569 deviceRayTracingPipelineFeaturesKHR[0].rayTracingPipelineShaderGroupHandleCaptureReplayMixed != deviceRayTracingPipelineFeaturesKHR[1].rayTracingPipelineShaderGroupHandleCaptureReplayMixed || 1570 deviceRayTracingPipelineFeaturesKHR[0].rayTracingPipelineTraceRaysIndirect != deviceRayTracingPipelineFeaturesKHR[1].rayTracingPipelineTraceRaysIndirect || 1571 deviceRayTracingPipelineFeaturesKHR[0].rayTraversalPrimitiveCulling != deviceRayTracingPipelineFeaturesKHR[1].rayTraversalPrimitiveCulling)) 1572 { 1573 TCU_FAIL("Mismatch between VkPhysicalDeviceRayTracingPipelineFeaturesKHR"); 1574 } 1575 return tcu::TestStatus::pass("Querying succeeded"); 1576} 1577 1578tcu::TestStatus testPhysicalDeviceFeatureRayQueryFeaturesKHR (Context& context) 1579{ 1580 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1581 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1582 const InstanceDriver& vki (instance.getDriver()); 1583 const int count = 2u; 1584 TestLog& log = context.getTestContext().getLog(); 1585 VkPhysicalDeviceFeatures2 extFeatures; 1586 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1587 1588 VkPhysicalDeviceRayQueryFeaturesKHR deviceRayQueryFeaturesKHR[count]; 1589 const bool isRayQueryFeaturesKHR = checkExtension(properties, "VK_KHR_ray_query"); 1590 1591 for (int ndx = 0; ndx < count; ++ndx) 1592 { 1593 deMemset(&deviceRayQueryFeaturesKHR[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceRayQueryFeaturesKHR)); 1594 deviceRayQueryFeaturesKHR[ndx].sType = isRayQueryFeaturesKHR ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR : VK_STRUCTURE_TYPE_MAX_ENUM; 1595 deviceRayQueryFeaturesKHR[ndx].pNext = DE_NULL; 1596 1597 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1598 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1599 extFeatures.pNext = &deviceRayQueryFeaturesKHR[ndx]; 1600 1601 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1602 } 1603 1604 if (isRayQueryFeaturesKHR) 1605 log << TestLog::Message << deviceRayQueryFeaturesKHR[0] << TestLog::EndMessage; 1606 1607 if (isRayQueryFeaturesKHR && 1608 (deviceRayQueryFeaturesKHR[0].rayQuery != deviceRayQueryFeaturesKHR[1].rayQuery)) 1609 { 1610 TCU_FAIL("Mismatch between VkPhysicalDeviceRayQueryFeaturesKHR"); 1611 } 1612 return tcu::TestStatus::pass("Querying succeeded"); 1613} 1614 1615tcu::TestStatus testPhysicalDeviceFeatureRobustness2FeaturesEXT (Context& context) 1616{ 1617 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1618 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1619 const InstanceDriver& vki (instance.getDriver()); 1620 const int count = 2u; 1621 TestLog& log = context.getTestContext().getLog(); 1622 VkPhysicalDeviceFeatures2 extFeatures; 1623 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1624 1625 VkPhysicalDeviceRobustness2FeaturesEXT deviceRobustness2FeaturesEXT[count]; 1626 const bool isRobustness2FeaturesEXT = checkExtension(properties, "VK_EXT_robustness2"); 1627 1628 for (int ndx = 0; ndx < count; ++ndx) 1629 { 1630 deMemset(&deviceRobustness2FeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceRobustness2FeaturesEXT)); 1631 deviceRobustness2FeaturesEXT[ndx].sType = isRobustness2FeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1632 deviceRobustness2FeaturesEXT[ndx].pNext = DE_NULL; 1633 1634 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1635 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1636 extFeatures.pNext = &deviceRobustness2FeaturesEXT[ndx]; 1637 1638 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1639 } 1640 1641 if (isRobustness2FeaturesEXT) 1642 log << TestLog::Message << deviceRobustness2FeaturesEXT[0] << TestLog::EndMessage; 1643 1644 if (isRobustness2FeaturesEXT && 1645 (deviceRobustness2FeaturesEXT[0].robustBufferAccess2 != deviceRobustness2FeaturesEXT[1].robustBufferAccess2 || 1646 deviceRobustness2FeaturesEXT[0].robustImageAccess2 != deviceRobustness2FeaturesEXT[1].robustImageAccess2 || 1647 deviceRobustness2FeaturesEXT[0].nullDescriptor != deviceRobustness2FeaturesEXT[1].nullDescriptor)) 1648 { 1649 TCU_FAIL("Mismatch between VkPhysicalDeviceRobustness2FeaturesEXT"); 1650 } 1651 return tcu::TestStatus::pass("Querying succeeded"); 1652} 1653 1654tcu::TestStatus testPhysicalDeviceFeatureSamplerYcbcrConversionFeatures (Context& context) 1655{ 1656 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1657 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1658 const InstanceDriver& vki (instance.getDriver()); 1659 const int count = 2u; 1660 TestLog& log = context.getTestContext().getLog(); 1661 VkPhysicalDeviceFeatures2 extFeatures; 1662 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1663 1664 VkPhysicalDeviceSamplerYcbcrConversionFeatures deviceSamplerYcbcrConversionFeatures[count]; 1665 const bool isSamplerYcbcrConversionFeatures = checkExtension(properties, "VK_KHR_sampler_ycbcr_conversion") || context.contextSupports(vk::ApiVersion(1, 1, 0)); 1666 1667 for (int ndx = 0; ndx < count; ++ndx) 1668 { 1669 deMemset(&deviceSamplerYcbcrConversionFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures)); 1670 deviceSamplerYcbcrConversionFeatures[ndx].sType = isSamplerYcbcrConversionFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 1671 deviceSamplerYcbcrConversionFeatures[ndx].pNext = DE_NULL; 1672 1673 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1674 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1675 extFeatures.pNext = &deviceSamplerYcbcrConversionFeatures[ndx]; 1676 1677 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1678 } 1679 1680 if (isSamplerYcbcrConversionFeatures) 1681 log << TestLog::Message << deviceSamplerYcbcrConversionFeatures[0] << TestLog::EndMessage; 1682 1683 if (isSamplerYcbcrConversionFeatures && 1684 (deviceSamplerYcbcrConversionFeatures[0].samplerYcbcrConversion != deviceSamplerYcbcrConversionFeatures[1].samplerYcbcrConversion)) 1685 { 1686 TCU_FAIL("Mismatch between VkPhysicalDeviceSamplerYcbcrConversionFeatures"); 1687 } 1688 return tcu::TestStatus::pass("Querying succeeded"); 1689} 1690 1691tcu::TestStatus testPhysicalDeviceFeatureScalarBlockLayoutFeatures (Context& context) 1692{ 1693 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1694 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1695 const InstanceDriver& vki (instance.getDriver()); 1696 const int count = 2u; 1697 TestLog& log = context.getTestContext().getLog(); 1698 VkPhysicalDeviceFeatures2 extFeatures; 1699 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1700 1701 VkPhysicalDeviceScalarBlockLayoutFeatures deviceScalarBlockLayoutFeatures[count]; 1702 const bool isScalarBlockLayoutFeatures = checkExtension(properties, "VK_EXT_scalar_block_layout") || context.contextSupports(vk::ApiVersion(1, 2, 0)); 1703 1704 for (int ndx = 0; ndx < count; ++ndx) 1705 { 1706 deMemset(&deviceScalarBlockLayoutFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceScalarBlockLayoutFeatures)); 1707 deviceScalarBlockLayoutFeatures[ndx].sType = isScalarBlockLayoutFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 1708 deviceScalarBlockLayoutFeatures[ndx].pNext = DE_NULL; 1709 1710 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1711 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1712 extFeatures.pNext = &deviceScalarBlockLayoutFeatures[ndx]; 1713 1714 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1715 } 1716 1717 if (isScalarBlockLayoutFeatures) 1718 log << TestLog::Message << deviceScalarBlockLayoutFeatures[0] << TestLog::EndMessage; 1719 1720 if (isScalarBlockLayoutFeatures && 1721 (deviceScalarBlockLayoutFeatures[0].scalarBlockLayout != deviceScalarBlockLayoutFeatures[1].scalarBlockLayout)) 1722 { 1723 TCU_FAIL("Mismatch between VkPhysicalDeviceScalarBlockLayoutFeatures"); 1724 } 1725 return tcu::TestStatus::pass("Querying succeeded"); 1726} 1727 1728tcu::TestStatus testPhysicalDeviceFeatureSeparateDepthStencilLayoutsFeatures (Context& context) 1729{ 1730 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1731 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1732 const InstanceDriver& vki (instance.getDriver()); 1733 const int count = 2u; 1734 TestLog& log = context.getTestContext().getLog(); 1735 VkPhysicalDeviceFeatures2 extFeatures; 1736 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1737 1738 VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures deviceSeparateDepthStencilLayoutsFeatures[count]; 1739 const bool isSeparateDepthStencilLayoutsFeatures = checkExtension(properties, "VK_KHR_separate_depth_stencil_layouts") || context.contextSupports(vk::ApiVersion(1, 2, 0)); 1740 1741 for (int ndx = 0; ndx < count; ++ndx) 1742 { 1743 deMemset(&deviceSeparateDepthStencilLayoutsFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures)); 1744 deviceSeparateDepthStencilLayoutsFeatures[ndx].sType = isSeparateDepthStencilLayoutsFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 1745 deviceSeparateDepthStencilLayoutsFeatures[ndx].pNext = DE_NULL; 1746 1747 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1748 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1749 extFeatures.pNext = &deviceSeparateDepthStencilLayoutsFeatures[ndx]; 1750 1751 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1752 } 1753 1754 if (isSeparateDepthStencilLayoutsFeatures) 1755 log << TestLog::Message << deviceSeparateDepthStencilLayoutsFeatures[0] << TestLog::EndMessage; 1756 1757 if (isSeparateDepthStencilLayoutsFeatures && 1758 (deviceSeparateDepthStencilLayoutsFeatures[0].separateDepthStencilLayouts != deviceSeparateDepthStencilLayoutsFeatures[1].separateDepthStencilLayouts)) 1759 { 1760 TCU_FAIL("Mismatch between VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures"); 1761 } 1762 return tcu::TestStatus::pass("Querying succeeded"); 1763} 1764 1765tcu::TestStatus testPhysicalDeviceFeatureShaderAtomicInt64Features (Context& context) 1766{ 1767 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1768 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1769 const InstanceDriver& vki (instance.getDriver()); 1770 const int count = 2u; 1771 TestLog& log = context.getTestContext().getLog(); 1772 VkPhysicalDeviceFeatures2 extFeatures; 1773 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1774 1775 VkPhysicalDeviceShaderAtomicInt64Features deviceShaderAtomicInt64Features[count]; 1776 const bool isShaderAtomicInt64Features = checkExtension(properties, "VK_KHR_shader_atomic_int64") || context.contextSupports(vk::ApiVersion(1, 2, 0)); 1777 1778 for (int ndx = 0; ndx < count; ++ndx) 1779 { 1780 deMemset(&deviceShaderAtomicInt64Features[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceShaderAtomicInt64Features)); 1781 deviceShaderAtomicInt64Features[ndx].sType = isShaderAtomicInt64Features ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 1782 deviceShaderAtomicInt64Features[ndx].pNext = DE_NULL; 1783 1784 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1785 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1786 extFeatures.pNext = &deviceShaderAtomicInt64Features[ndx]; 1787 1788 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1789 } 1790 1791 if (isShaderAtomicInt64Features) 1792 log << TestLog::Message << deviceShaderAtomicInt64Features[0] << TestLog::EndMessage; 1793 1794 if (isShaderAtomicInt64Features && 1795 (deviceShaderAtomicInt64Features[0].shaderBufferInt64Atomics != deviceShaderAtomicInt64Features[1].shaderBufferInt64Atomics || 1796 deviceShaderAtomicInt64Features[0].shaderSharedInt64Atomics != deviceShaderAtomicInt64Features[1].shaderSharedInt64Atomics)) 1797 { 1798 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderAtomicInt64Features"); 1799 } 1800 return tcu::TestStatus::pass("Querying succeeded"); 1801} 1802 1803tcu::TestStatus testPhysicalDeviceFeatureShaderAtomicFloatFeaturesEXT (Context& context) 1804{ 1805 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1806 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1807 const InstanceDriver& vki (instance.getDriver()); 1808 const int count = 2u; 1809 TestLog& log = context.getTestContext().getLog(); 1810 VkPhysicalDeviceFeatures2 extFeatures; 1811 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1812 1813 VkPhysicalDeviceShaderAtomicFloatFeaturesEXT deviceShaderAtomicFloatFeaturesEXT[count]; 1814 const bool isShaderAtomicFloatFeaturesEXT = checkExtension(properties, "VK_EXT_shader_atomic_float"); 1815 1816 for (int ndx = 0; ndx < count; ++ndx) 1817 { 1818 deMemset(&deviceShaderAtomicFloatFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT)); 1819 deviceShaderAtomicFloatFeaturesEXT[ndx].sType = isShaderAtomicFloatFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1820 deviceShaderAtomicFloatFeaturesEXT[ndx].pNext = DE_NULL; 1821 1822 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1823 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1824 extFeatures.pNext = &deviceShaderAtomicFloatFeaturesEXT[ndx]; 1825 1826 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1827 } 1828 1829 if (isShaderAtomicFloatFeaturesEXT) 1830 log << TestLog::Message << deviceShaderAtomicFloatFeaturesEXT[0] << TestLog::EndMessage; 1831 1832 if (isShaderAtomicFloatFeaturesEXT && 1833 (deviceShaderAtomicFloatFeaturesEXT[0].shaderBufferFloat32Atomics != deviceShaderAtomicFloatFeaturesEXT[1].shaderBufferFloat32Atomics || 1834 deviceShaderAtomicFloatFeaturesEXT[0].shaderBufferFloat32AtomicAdd != deviceShaderAtomicFloatFeaturesEXT[1].shaderBufferFloat32AtomicAdd || 1835 deviceShaderAtomicFloatFeaturesEXT[0].shaderBufferFloat64Atomics != deviceShaderAtomicFloatFeaturesEXT[1].shaderBufferFloat64Atomics || 1836 deviceShaderAtomicFloatFeaturesEXT[0].shaderBufferFloat64AtomicAdd != deviceShaderAtomicFloatFeaturesEXT[1].shaderBufferFloat64AtomicAdd || 1837 deviceShaderAtomicFloatFeaturesEXT[0].shaderSharedFloat32Atomics != deviceShaderAtomicFloatFeaturesEXT[1].shaderSharedFloat32Atomics || 1838 deviceShaderAtomicFloatFeaturesEXT[0].shaderSharedFloat32AtomicAdd != deviceShaderAtomicFloatFeaturesEXT[1].shaderSharedFloat32AtomicAdd || 1839 deviceShaderAtomicFloatFeaturesEXT[0].shaderSharedFloat64Atomics != deviceShaderAtomicFloatFeaturesEXT[1].shaderSharedFloat64Atomics || 1840 deviceShaderAtomicFloatFeaturesEXT[0].shaderSharedFloat64AtomicAdd != deviceShaderAtomicFloatFeaturesEXT[1].shaderSharedFloat64AtomicAdd || 1841 deviceShaderAtomicFloatFeaturesEXT[0].shaderImageFloat32Atomics != deviceShaderAtomicFloatFeaturesEXT[1].shaderImageFloat32Atomics || 1842 deviceShaderAtomicFloatFeaturesEXT[0].shaderImageFloat32AtomicAdd != deviceShaderAtomicFloatFeaturesEXT[1].shaderImageFloat32AtomicAdd || 1843 deviceShaderAtomicFloatFeaturesEXT[0].sparseImageFloat32Atomics != deviceShaderAtomicFloatFeaturesEXT[1].sparseImageFloat32Atomics || 1844 deviceShaderAtomicFloatFeaturesEXT[0].sparseImageFloat32AtomicAdd != deviceShaderAtomicFloatFeaturesEXT[1].sparseImageFloat32AtomicAdd)) 1845 { 1846 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderAtomicFloatFeaturesEXT"); 1847 } 1848 return tcu::TestStatus::pass("Querying succeeded"); 1849} 1850 1851tcu::TestStatus testPhysicalDeviceFeatureShaderAtomicFloat2FeaturesEXT (Context& context) 1852{ 1853 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1854 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1855 const InstanceDriver& vki (instance.getDriver()); 1856 const int count = 2u; 1857 TestLog& log = context.getTestContext().getLog(); 1858 VkPhysicalDeviceFeatures2 extFeatures; 1859 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1860 1861 VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT deviceShaderAtomicFloat2FeaturesEXT[count]; 1862 const bool isShaderAtomicFloat2FeaturesEXT = checkExtension(properties, "VK_EXT_shader_atomic_float2"); 1863 1864 for (int ndx = 0; ndx < count; ++ndx) 1865 { 1866 deMemset(&deviceShaderAtomicFloat2FeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT)); 1867 deviceShaderAtomicFloat2FeaturesEXT[ndx].sType = isShaderAtomicFloat2FeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1868 deviceShaderAtomicFloat2FeaturesEXT[ndx].pNext = DE_NULL; 1869 1870 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1871 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1872 extFeatures.pNext = &deviceShaderAtomicFloat2FeaturesEXT[ndx]; 1873 1874 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1875 } 1876 1877 if (isShaderAtomicFloat2FeaturesEXT) 1878 log << TestLog::Message << deviceShaderAtomicFloat2FeaturesEXT[0] << TestLog::EndMessage; 1879 1880 if (isShaderAtomicFloat2FeaturesEXT && 1881 (deviceShaderAtomicFloat2FeaturesEXT[0].shaderBufferFloat16Atomics != deviceShaderAtomicFloat2FeaturesEXT[1].shaderBufferFloat16Atomics || 1882 deviceShaderAtomicFloat2FeaturesEXT[0].shaderBufferFloat16AtomicAdd != deviceShaderAtomicFloat2FeaturesEXT[1].shaderBufferFloat16AtomicAdd || 1883 deviceShaderAtomicFloat2FeaturesEXT[0].shaderBufferFloat16AtomicMinMax != deviceShaderAtomicFloat2FeaturesEXT[1].shaderBufferFloat16AtomicMinMax || 1884 deviceShaderAtomicFloat2FeaturesEXT[0].shaderBufferFloat32AtomicMinMax != deviceShaderAtomicFloat2FeaturesEXT[1].shaderBufferFloat32AtomicMinMax || 1885 deviceShaderAtomicFloat2FeaturesEXT[0].shaderBufferFloat64AtomicMinMax != deviceShaderAtomicFloat2FeaturesEXT[1].shaderBufferFloat64AtomicMinMax || 1886 deviceShaderAtomicFloat2FeaturesEXT[0].shaderSharedFloat16Atomics != deviceShaderAtomicFloat2FeaturesEXT[1].shaderSharedFloat16Atomics || 1887 deviceShaderAtomicFloat2FeaturesEXT[0].shaderSharedFloat16AtomicAdd != deviceShaderAtomicFloat2FeaturesEXT[1].shaderSharedFloat16AtomicAdd || 1888 deviceShaderAtomicFloat2FeaturesEXT[0].shaderSharedFloat16AtomicMinMax != deviceShaderAtomicFloat2FeaturesEXT[1].shaderSharedFloat16AtomicMinMax || 1889 deviceShaderAtomicFloat2FeaturesEXT[0].shaderSharedFloat32AtomicMinMax != deviceShaderAtomicFloat2FeaturesEXT[1].shaderSharedFloat32AtomicMinMax || 1890 deviceShaderAtomicFloat2FeaturesEXT[0].shaderSharedFloat64AtomicMinMax != deviceShaderAtomicFloat2FeaturesEXT[1].shaderSharedFloat64AtomicMinMax || 1891 deviceShaderAtomicFloat2FeaturesEXT[0].shaderImageFloat32AtomicMinMax != deviceShaderAtomicFloat2FeaturesEXT[1].shaderImageFloat32AtomicMinMax || 1892 deviceShaderAtomicFloat2FeaturesEXT[0].sparseImageFloat32AtomicMinMax != deviceShaderAtomicFloat2FeaturesEXT[1].sparseImageFloat32AtomicMinMax)) 1893 { 1894 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT"); 1895 } 1896 return tcu::TestStatus::pass("Querying succeeded"); 1897} 1898 1899tcu::TestStatus testPhysicalDeviceFeatureShaderFloat16Int8Features (Context& context) 1900{ 1901 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1902 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1903 const InstanceDriver& vki (instance.getDriver()); 1904 const int count = 2u; 1905 TestLog& log = context.getTestContext().getLog(); 1906 VkPhysicalDeviceFeatures2 extFeatures; 1907 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1908 1909 VkPhysicalDeviceShaderFloat16Int8Features deviceShaderFloat16Int8Features[count]; 1910 const bool isShaderFloat16Int8Features = checkExtension(properties, "VK_KHR_shader_float16_int8") || context.contextSupports(vk::ApiVersion(1, 2, 0)); 1911 1912 for (int ndx = 0; ndx < count; ++ndx) 1913 { 1914 deMemset(&deviceShaderFloat16Int8Features[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceShaderFloat16Int8Features)); 1915 deviceShaderFloat16Int8Features[ndx].sType = isShaderFloat16Int8Features ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 1916 deviceShaderFloat16Int8Features[ndx].pNext = DE_NULL; 1917 1918 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1919 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1920 extFeatures.pNext = &deviceShaderFloat16Int8Features[ndx]; 1921 1922 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1923 } 1924 1925 if (isShaderFloat16Int8Features) 1926 log << TestLog::Message << deviceShaderFloat16Int8Features[0] << TestLog::EndMessage; 1927 1928 if (isShaderFloat16Int8Features && 1929 (deviceShaderFloat16Int8Features[0].shaderFloat16 != deviceShaderFloat16Int8Features[1].shaderFloat16 || 1930 deviceShaderFloat16Int8Features[0].shaderInt8 != deviceShaderFloat16Int8Features[1].shaderInt8)) 1931 { 1932 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderFloat16Int8Features"); 1933 } 1934 return tcu::TestStatus::pass("Querying succeeded"); 1935} 1936 1937tcu::TestStatus testPhysicalDeviceFeatureShaderClockFeaturesKHR (Context& context) 1938{ 1939 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1940 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1941 const InstanceDriver& vki (instance.getDriver()); 1942 const int count = 2u; 1943 TestLog& log = context.getTestContext().getLog(); 1944 VkPhysicalDeviceFeatures2 extFeatures; 1945 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1946 1947 VkPhysicalDeviceShaderClockFeaturesKHR deviceShaderClockFeaturesKHR[count]; 1948 const bool isShaderClockFeaturesKHR = checkExtension(properties, "VK_KHR_shader_clock"); 1949 1950 for (int ndx = 0; ndx < count; ++ndx) 1951 { 1952 deMemset(&deviceShaderClockFeaturesKHR[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceShaderClockFeaturesKHR)); 1953 deviceShaderClockFeaturesKHR[ndx].sType = isShaderClockFeaturesKHR ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR : VK_STRUCTURE_TYPE_MAX_ENUM; 1954 deviceShaderClockFeaturesKHR[ndx].pNext = DE_NULL; 1955 1956 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1957 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1958 extFeatures.pNext = &deviceShaderClockFeaturesKHR[ndx]; 1959 1960 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1961 } 1962 1963 if (isShaderClockFeaturesKHR) 1964 log << TestLog::Message << deviceShaderClockFeaturesKHR[0] << TestLog::EndMessage; 1965 1966 if (isShaderClockFeaturesKHR && 1967 (deviceShaderClockFeaturesKHR[0].shaderSubgroupClock != deviceShaderClockFeaturesKHR[1].shaderSubgroupClock || 1968 deviceShaderClockFeaturesKHR[0].shaderDeviceClock != deviceShaderClockFeaturesKHR[1].shaderDeviceClock)) 1969 { 1970 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderClockFeaturesKHR"); 1971 } 1972 return tcu::TestStatus::pass("Querying succeeded"); 1973} 1974 1975tcu::TestStatus testPhysicalDeviceFeatureShaderDemoteToHelperInvocationFeatures (Context& context) 1976{ 1977 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1978 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1979 const InstanceDriver& vki (instance.getDriver()); 1980 const int count = 2u; 1981 TestLog& log = context.getTestContext().getLog(); 1982 VkPhysicalDeviceFeatures2 extFeatures; 1983 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1984 1985 VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures deviceShaderDemoteToHelperInvocationFeatures[count]; 1986 const bool isShaderDemoteToHelperInvocationFeatures = checkExtension(properties, "VK_EXT_shader_demote_to_helper_invocation") || context.contextSupports(vk::ApiVersion(1, 3, 0)); 1987 1988 for (int ndx = 0; ndx < count; ++ndx) 1989 { 1990 deMemset(&deviceShaderDemoteToHelperInvocationFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures)); 1991 deviceShaderDemoteToHelperInvocationFeatures[ndx].sType = isShaderDemoteToHelperInvocationFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 1992 deviceShaderDemoteToHelperInvocationFeatures[ndx].pNext = DE_NULL; 1993 1994 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1995 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1996 extFeatures.pNext = &deviceShaderDemoteToHelperInvocationFeatures[ndx]; 1997 1998 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1999 } 2000 2001 if (isShaderDemoteToHelperInvocationFeatures) 2002 log << TestLog::Message << deviceShaderDemoteToHelperInvocationFeatures[0] << TestLog::EndMessage; 2003 2004 if (isShaderDemoteToHelperInvocationFeatures && 2005 (deviceShaderDemoteToHelperInvocationFeatures[0].shaderDemoteToHelperInvocation != deviceShaderDemoteToHelperInvocationFeatures[1].shaderDemoteToHelperInvocation)) 2006 { 2007 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures"); 2008 } 2009 return tcu::TestStatus::pass("Querying succeeded"); 2010} 2011 2012tcu::TestStatus testPhysicalDeviceFeatureShaderDrawParametersFeatures (Context& context) 2013{ 2014 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 2015 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 2016 const InstanceDriver& vki (instance.getDriver()); 2017 const int count = 2u; 2018 TestLog& log = context.getTestContext().getLog(); 2019 VkPhysicalDeviceFeatures2 extFeatures; 2020 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 2021 2022 VkPhysicalDeviceShaderDrawParametersFeatures deviceShaderDrawParametersFeatures[count]; 2023 const bool isShaderDrawParametersFeatures = context.contextSupports(vk::ApiVersion(1, 1, 0)); 2024 2025 for (int ndx = 0; ndx < count; ++ndx) 2026 { 2027 deMemset(&deviceShaderDrawParametersFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceShaderDrawParametersFeatures)); 2028 deviceShaderDrawParametersFeatures[ndx].sType = isShaderDrawParametersFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 2029 deviceShaderDrawParametersFeatures[ndx].pNext = DE_NULL; 2030 2031 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 2032 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 2033 extFeatures.pNext = &deviceShaderDrawParametersFeatures[ndx]; 2034 2035 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 2036 } 2037 2038 if (isShaderDrawParametersFeatures) 2039 log << TestLog::Message << deviceShaderDrawParametersFeatures[0] << TestLog::EndMessage; 2040 2041 if (isShaderDrawParametersFeatures && 2042 (deviceShaderDrawParametersFeatures[0].shaderDrawParameters != deviceShaderDrawParametersFeatures[1].shaderDrawParameters)) 2043 { 2044 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderDrawParametersFeatures"); 2045 } 2046 return tcu::TestStatus::pass("Querying succeeded"); 2047} 2048 2049tcu::TestStatus testPhysicalDeviceFeatureShaderIntegerDotProductFeatures (Context& context) 2050{ 2051 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 2052 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 2053 const InstanceDriver& vki (instance.getDriver()); 2054 const int count = 2u; 2055 TestLog& log = context.getTestContext().getLog(); 2056 VkPhysicalDeviceFeatures2 extFeatures; 2057 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 2058 2059 VkPhysicalDeviceShaderIntegerDotProductFeatures deviceShaderIntegerDotProductFeatures[count]; 2060 const bool isShaderIntegerDotProductFeatures = checkExtension(properties, "VK_KHR_shader_integer_dot_product") || context.contextSupports(vk::ApiVersion(1, 3, 0)); 2061 2062 for (int ndx = 0; ndx < count; ++ndx) 2063 { 2064 deMemset(&deviceShaderIntegerDotProductFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceShaderIntegerDotProductFeatures)); 2065 deviceShaderIntegerDotProductFeatures[ndx].sType = isShaderIntegerDotProductFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 2066 deviceShaderIntegerDotProductFeatures[ndx].pNext = DE_NULL; 2067 2068 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 2069 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 2070 extFeatures.pNext = &deviceShaderIntegerDotProductFeatures[ndx]; 2071 2072 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 2073 } 2074 2075 if (isShaderIntegerDotProductFeatures) 2076 log << TestLog::Message << deviceShaderIntegerDotProductFeatures[0] << TestLog::EndMessage; 2077 2078 if (isShaderIntegerDotProductFeatures && 2079 (deviceShaderIntegerDotProductFeatures[0].shaderIntegerDotProduct != deviceShaderIntegerDotProductFeatures[1].shaderIntegerDotProduct)) 2080 { 2081 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderIntegerDotProductFeatures"); 2082 } 2083 return tcu::TestStatus::pass("Querying succeeded"); 2084} 2085 2086tcu::TestStatus testPhysicalDeviceFeatureShaderSubgroupExtendedTypesFeatures (Context& context) 2087{ 2088 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 2089 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 2090 const InstanceDriver& vki (instance.getDriver()); 2091 const int count = 2u; 2092 TestLog& log = context.getTestContext().getLog(); 2093 VkPhysicalDeviceFeatures2 extFeatures; 2094 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 2095 2096 VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures deviceShaderSubgroupExtendedTypesFeatures[count]; 2097 const bool isShaderSubgroupExtendedTypesFeatures = checkExtension(properties, "VK_KHR_shader_subgroup_extended_types") || context.contextSupports(vk::ApiVersion(1, 2, 0)); 2098 2099 for (int ndx = 0; ndx < count; ++ndx) 2100 { 2101 deMemset(&deviceShaderSubgroupExtendedTypesFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures)); 2102 deviceShaderSubgroupExtendedTypesFeatures[ndx].sType = isShaderSubgroupExtendedTypesFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 2103 deviceShaderSubgroupExtendedTypesFeatures[ndx].pNext = DE_NULL; 2104 2105 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 2106 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 2107 extFeatures.pNext = &deviceShaderSubgroupExtendedTypesFeatures[ndx]; 2108 2109 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 2110 } 2111 2112 if (isShaderSubgroupExtendedTypesFeatures) 2113 log << TestLog::Message << deviceShaderSubgroupExtendedTypesFeatures[0] << TestLog::EndMessage; 2114 2115 if (isShaderSubgroupExtendedTypesFeatures && 2116 (deviceShaderSubgroupExtendedTypesFeatures[0].shaderSubgroupExtendedTypes != deviceShaderSubgroupExtendedTypesFeatures[1].shaderSubgroupExtendedTypes)) 2117 { 2118 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures"); 2119 } 2120 return tcu::TestStatus::pass("Querying succeeded"); 2121} 2122 2123tcu::TestStatus testPhysicalDeviceFeatureShaderTerminateInvocationFeatures (Context& context) 2124{ 2125 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 2126 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 2127 const InstanceDriver& vki (instance.getDriver()); 2128 const int count = 2u; 2129 TestLog& log = context.getTestContext().getLog(); 2130 VkPhysicalDeviceFeatures2 extFeatures; 2131 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 2132 2133 VkPhysicalDeviceShaderTerminateInvocationFeatures deviceShaderTerminateInvocationFeatures[count]; 2134 const bool isShaderTerminateInvocationFeatures = checkExtension(properties, "VK_KHR_shader_terminate_invocation") || context.contextSupports(vk::ApiVersion(1, 3, 0)); 2135 2136 for (int ndx = 0; ndx < count; ++ndx) 2137 { 2138 deMemset(&deviceShaderTerminateInvocationFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceShaderTerminateInvocationFeatures)); 2139 deviceShaderTerminateInvocationFeatures[ndx].sType = isShaderTerminateInvocationFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 2140 deviceShaderTerminateInvocationFeatures[ndx].pNext = DE_NULL; 2141 2142 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 2143 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 2144 extFeatures.pNext = &deviceShaderTerminateInvocationFeatures[ndx]; 2145 2146 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 2147 } 2148 2149 if (isShaderTerminateInvocationFeatures) 2150 log << TestLog::Message << deviceShaderTerminateInvocationFeatures[0] << TestLog::EndMessage; 2151 2152 if (isShaderTerminateInvocationFeatures && 2153 (deviceShaderTerminateInvocationFeatures[0].shaderTerminateInvocation != deviceShaderTerminateInvocationFeatures[1].shaderTerminateInvocation)) 2154 { 2155 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderTerminateInvocationFeatures"); 2156 } 2157 return tcu::TestStatus::pass("Querying succeeded"); 2158} 2159 2160tcu::TestStatus testPhysicalDeviceFeatureSubgroupSizeControlFeatures (Context& context) 2161{ 2162 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 2163 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 2164 const InstanceDriver& vki (instance.getDriver()); 2165 const int count = 2u; 2166 TestLog& log = context.getTestContext().getLog(); 2167 VkPhysicalDeviceFeatures2 extFeatures; 2168 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 2169 2170 VkPhysicalDeviceSubgroupSizeControlFeatures deviceSubgroupSizeControlFeatures[count]; 2171 const bool isSubgroupSizeControlFeatures = checkExtension(properties, "VK_EXT_subgroup_size_control") || context.contextSupports(vk::ApiVersion(1, 3, 0)); 2172 2173 for (int ndx = 0; ndx < count; ++ndx) 2174 { 2175 deMemset(&deviceSubgroupSizeControlFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceSubgroupSizeControlFeatures)); 2176 deviceSubgroupSizeControlFeatures[ndx].sType = isSubgroupSizeControlFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 2177 deviceSubgroupSizeControlFeatures[ndx].pNext = DE_NULL; 2178 2179 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 2180 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 2181 extFeatures.pNext = &deviceSubgroupSizeControlFeatures[ndx]; 2182 2183 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 2184 } 2185 2186 if (isSubgroupSizeControlFeatures) 2187 log << TestLog::Message << deviceSubgroupSizeControlFeatures[0] << TestLog::EndMessage; 2188 2189 if (isSubgroupSizeControlFeatures && 2190 (deviceSubgroupSizeControlFeatures[0].subgroupSizeControl != deviceSubgroupSizeControlFeatures[1].subgroupSizeControl || 2191 deviceSubgroupSizeControlFeatures[0].computeFullSubgroups != deviceSubgroupSizeControlFeatures[1].computeFullSubgroups)) 2192 { 2193 TCU_FAIL("Mismatch between VkPhysicalDeviceSubgroupSizeControlFeatures"); 2194 } 2195 return tcu::TestStatus::pass("Querying succeeded"); 2196} 2197 2198tcu::TestStatus testPhysicalDeviceFeatureSynchronization2Features (Context& context) 2199{ 2200 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 2201 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 2202 const InstanceDriver& vki (instance.getDriver()); 2203 const int count = 2u; 2204 TestLog& log = context.getTestContext().getLog(); 2205 VkPhysicalDeviceFeatures2 extFeatures; 2206 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 2207 2208 VkPhysicalDeviceSynchronization2Features deviceSynchronization2Features[count]; 2209 const bool isSynchronization2Features = checkExtension(properties, "VK_KHR_synchronization2") || context.contextSupports(vk::ApiVersion(1, 3, 0)); 2210 2211 for (int ndx = 0; ndx < count; ++ndx) 2212 { 2213 deMemset(&deviceSynchronization2Features[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceSynchronization2Features)); 2214 deviceSynchronization2Features[ndx].sType = isSynchronization2Features ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 2215 deviceSynchronization2Features[ndx].pNext = DE_NULL; 2216 2217 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 2218 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 2219 extFeatures.pNext = &deviceSynchronization2Features[ndx]; 2220 2221 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 2222 } 2223 2224 if (isSynchronization2Features) 2225 log << TestLog::Message << deviceSynchronization2Features[0] << TestLog::EndMessage; 2226 2227 if (isSynchronization2Features && 2228 (deviceSynchronization2Features[0].synchronization2 != deviceSynchronization2Features[1].synchronization2)) 2229 { 2230 TCU_FAIL("Mismatch between VkPhysicalDeviceSynchronization2Features"); 2231 } 2232 return tcu::TestStatus::pass("Querying succeeded"); 2233} 2234 2235tcu::TestStatus testPhysicalDeviceFeatureFragmentShaderInterlockFeaturesEXT (Context& context) 2236{ 2237 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 2238 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 2239 const InstanceDriver& vki (instance.getDriver()); 2240 const int count = 2u; 2241 TestLog& log = context.getTestContext().getLog(); 2242 VkPhysicalDeviceFeatures2 extFeatures; 2243 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 2244 2245 VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT deviceFragmentShaderInterlockFeaturesEXT[count]; 2246 const bool isFragmentShaderInterlockFeaturesEXT = checkExtension(properties, "VK_EXT_fragment_shader_interlock"); 2247 2248 for (int ndx = 0; ndx < count; ++ndx) 2249 { 2250 deMemset(&deviceFragmentShaderInterlockFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT)); 2251 deviceFragmentShaderInterlockFeaturesEXT[ndx].sType = isFragmentShaderInterlockFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 2252 deviceFragmentShaderInterlockFeaturesEXT[ndx].pNext = DE_NULL; 2253 2254 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 2255 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 2256 extFeatures.pNext = &deviceFragmentShaderInterlockFeaturesEXT[ndx]; 2257 2258 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 2259 } 2260 2261 if (isFragmentShaderInterlockFeaturesEXT) 2262 log << TestLog::Message << deviceFragmentShaderInterlockFeaturesEXT[0] << TestLog::EndMessage; 2263 2264 if (isFragmentShaderInterlockFeaturesEXT && 2265 (deviceFragmentShaderInterlockFeaturesEXT[0].fragmentShaderSampleInterlock != deviceFragmentShaderInterlockFeaturesEXT[1].fragmentShaderSampleInterlock || 2266 deviceFragmentShaderInterlockFeaturesEXT[0].fragmentShaderPixelInterlock != deviceFragmentShaderInterlockFeaturesEXT[1].fragmentShaderPixelInterlock || 2267 deviceFragmentShaderInterlockFeaturesEXT[0].fragmentShaderShadingRateInterlock != deviceFragmentShaderInterlockFeaturesEXT[1].fragmentShaderShadingRateInterlock)) 2268 { 2269 TCU_FAIL("Mismatch between VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT"); 2270 } 2271 return tcu::TestStatus::pass("Querying succeeded"); 2272} 2273 2274tcu::TestStatus testPhysicalDeviceFeatureTexelBufferAlignmentFeaturesEXT (Context& context) 2275{ 2276 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 2277 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 2278 const InstanceDriver& vki (instance.getDriver()); 2279 const int count = 2u; 2280 TestLog& log = context.getTestContext().getLog(); 2281 VkPhysicalDeviceFeatures2 extFeatures; 2282 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 2283 2284 VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT deviceTexelBufferAlignmentFeaturesEXT[count]; 2285 const bool isTexelBufferAlignmentFeaturesEXT = checkExtension(properties, "VK_EXT_texel_buffer_alignment"); 2286 2287 for (int ndx = 0; ndx < count; ++ndx) 2288 { 2289 deMemset(&deviceTexelBufferAlignmentFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT)); 2290 deviceTexelBufferAlignmentFeaturesEXT[ndx].sType = isTexelBufferAlignmentFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 2291 deviceTexelBufferAlignmentFeaturesEXT[ndx].pNext = DE_NULL; 2292 2293 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 2294 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 2295 extFeatures.pNext = &deviceTexelBufferAlignmentFeaturesEXT[ndx]; 2296 2297 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 2298 } 2299 2300 if (isTexelBufferAlignmentFeaturesEXT) 2301 log << TestLog::Message << deviceTexelBufferAlignmentFeaturesEXT[0] << TestLog::EndMessage; 2302 2303 if (isTexelBufferAlignmentFeaturesEXT && 2304 (deviceTexelBufferAlignmentFeaturesEXT[0].texelBufferAlignment != deviceTexelBufferAlignmentFeaturesEXT[1].texelBufferAlignment)) 2305 { 2306 TCU_FAIL("Mismatch between VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT"); 2307 } 2308 return tcu::TestStatus::pass("Querying succeeded"); 2309} 2310 2311tcu::TestStatus testPhysicalDeviceFeatureTextureCompressionASTCHDRFeatures (Context& context) 2312{ 2313 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 2314 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 2315 const InstanceDriver& vki (instance.getDriver()); 2316 const int count = 2u; 2317 TestLog& log = context.getTestContext().getLog(); 2318 VkPhysicalDeviceFeatures2 extFeatures; 2319 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 2320 2321 VkPhysicalDeviceTextureCompressionASTCHDRFeatures deviceTextureCompressionASTCHDRFeatures[count]; 2322 const bool isTextureCompressionASTCHDRFeatures = checkExtension(properties, "VK_EXT_texture_compression_astc_hdr") || context.contextSupports(vk::ApiVersion(1, 3, 0)); 2323 2324 for (int ndx = 0; ndx < count; ++ndx) 2325 { 2326 deMemset(&deviceTextureCompressionASTCHDRFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceTextureCompressionASTCHDRFeatures)); 2327 deviceTextureCompressionASTCHDRFeatures[ndx].sType = isTextureCompressionASTCHDRFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 2328 deviceTextureCompressionASTCHDRFeatures[ndx].pNext = DE_NULL; 2329 2330 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 2331 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 2332 extFeatures.pNext = &deviceTextureCompressionASTCHDRFeatures[ndx]; 2333 2334 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 2335 } 2336 2337 if (isTextureCompressionASTCHDRFeatures) 2338 log << TestLog::Message << deviceTextureCompressionASTCHDRFeatures[0] << TestLog::EndMessage; 2339 2340 if (isTextureCompressionASTCHDRFeatures && 2341 (deviceTextureCompressionASTCHDRFeatures[0].textureCompressionASTC_HDR != deviceTextureCompressionASTCHDRFeatures[1].textureCompressionASTC_HDR)) 2342 { 2343 TCU_FAIL("Mismatch between VkPhysicalDeviceTextureCompressionASTCHDRFeatures"); 2344 } 2345 return tcu::TestStatus::pass("Querying succeeded"); 2346} 2347 2348tcu::TestStatus testPhysicalDeviceFeatureTimelineSemaphoreFeatures (Context& context) 2349{ 2350 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 2351 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 2352 const InstanceDriver& vki (instance.getDriver()); 2353 const int count = 2u; 2354 TestLog& log = context.getTestContext().getLog(); 2355 VkPhysicalDeviceFeatures2 extFeatures; 2356 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 2357 2358 VkPhysicalDeviceTimelineSemaphoreFeatures deviceTimelineSemaphoreFeatures[count]; 2359 const bool isTimelineSemaphoreFeatures = checkExtension(properties, "VK_KHR_timeline_semaphore") || context.contextSupports(vk::ApiVersion(1, 2, 0)); 2360 2361 for (int ndx = 0; ndx < count; ++ndx) 2362 { 2363 deMemset(&deviceTimelineSemaphoreFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceTimelineSemaphoreFeatures)); 2364 deviceTimelineSemaphoreFeatures[ndx].sType = isTimelineSemaphoreFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 2365 deviceTimelineSemaphoreFeatures[ndx].pNext = DE_NULL; 2366 2367 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 2368 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 2369 extFeatures.pNext = &deviceTimelineSemaphoreFeatures[ndx]; 2370 2371 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 2372 } 2373 2374 if (isTimelineSemaphoreFeatures) 2375 log << TestLog::Message << deviceTimelineSemaphoreFeatures[0] << TestLog::EndMessage; 2376 2377 if (isTimelineSemaphoreFeatures && 2378 (deviceTimelineSemaphoreFeatures[0].timelineSemaphore != deviceTimelineSemaphoreFeatures[1].timelineSemaphore)) 2379 { 2380 TCU_FAIL("Mismatch between VkPhysicalDeviceTimelineSemaphoreFeatures"); 2381 } 2382 return tcu::TestStatus::pass("Querying succeeded"); 2383} 2384 2385tcu::TestStatus testPhysicalDeviceFeatureTransformFeedbackFeaturesEXT (Context& context) 2386{ 2387 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 2388 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 2389 const InstanceDriver& vki (instance.getDriver()); 2390 const int count = 2u; 2391 TestLog& log = context.getTestContext().getLog(); 2392 VkPhysicalDeviceFeatures2 extFeatures; 2393 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 2394 2395 VkPhysicalDeviceTransformFeedbackFeaturesEXT deviceTransformFeedbackFeaturesEXT[count]; 2396 const bool isTransformFeedbackFeaturesEXT = checkExtension(properties, "VK_EXT_transform_feedback"); 2397 2398 for (int ndx = 0; ndx < count; ++ndx) 2399 { 2400 deMemset(&deviceTransformFeedbackFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceTransformFeedbackFeaturesEXT)); 2401 deviceTransformFeedbackFeaturesEXT[ndx].sType = isTransformFeedbackFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 2402 deviceTransformFeedbackFeaturesEXT[ndx].pNext = DE_NULL; 2403 2404 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 2405 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 2406 extFeatures.pNext = &deviceTransformFeedbackFeaturesEXT[ndx]; 2407 2408 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 2409 } 2410 2411 if (isTransformFeedbackFeaturesEXT) 2412 log << TestLog::Message << deviceTransformFeedbackFeaturesEXT[0] << TestLog::EndMessage; 2413 2414 if (isTransformFeedbackFeaturesEXT && 2415 (deviceTransformFeedbackFeaturesEXT[0].transformFeedback != deviceTransformFeedbackFeaturesEXT[1].transformFeedback || 2416 deviceTransformFeedbackFeaturesEXT[0].geometryStreams != deviceTransformFeedbackFeaturesEXT[1].geometryStreams)) 2417 { 2418 TCU_FAIL("Mismatch between VkPhysicalDeviceTransformFeedbackFeaturesEXT"); 2419 } 2420 return tcu::TestStatus::pass("Querying succeeded"); 2421} 2422 2423tcu::TestStatus testPhysicalDeviceFeatureUniformBufferStandardLayoutFeatures (Context& context) 2424{ 2425 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 2426 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 2427 const InstanceDriver& vki (instance.getDriver()); 2428 const int count = 2u; 2429 TestLog& log = context.getTestContext().getLog(); 2430 VkPhysicalDeviceFeatures2 extFeatures; 2431 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 2432 2433 VkPhysicalDeviceUniformBufferStandardLayoutFeatures deviceUniformBufferStandardLayoutFeatures[count]; 2434 const bool isUniformBufferStandardLayoutFeatures = checkExtension(properties, "VK_KHR_uniform_buffer_standard_layout") || context.contextSupports(vk::ApiVersion(1, 2, 0)); 2435 2436 for (int ndx = 0; ndx < count; ++ndx) 2437 { 2438 deMemset(&deviceUniformBufferStandardLayoutFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceUniformBufferStandardLayoutFeatures)); 2439 deviceUniformBufferStandardLayoutFeatures[ndx].sType = isUniformBufferStandardLayoutFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 2440 deviceUniformBufferStandardLayoutFeatures[ndx].pNext = DE_NULL; 2441 2442 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 2443 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 2444 extFeatures.pNext = &deviceUniformBufferStandardLayoutFeatures[ndx]; 2445 2446 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 2447 } 2448 2449 if (isUniformBufferStandardLayoutFeatures) 2450 log << TestLog::Message << deviceUniformBufferStandardLayoutFeatures[0] << TestLog::EndMessage; 2451 2452 if (isUniformBufferStandardLayoutFeatures && 2453 (deviceUniformBufferStandardLayoutFeatures[0].uniformBufferStandardLayout != deviceUniformBufferStandardLayoutFeatures[1].uniformBufferStandardLayout)) 2454 { 2455 TCU_FAIL("Mismatch between VkPhysicalDeviceUniformBufferStandardLayoutFeatures"); 2456 } 2457 return tcu::TestStatus::pass("Querying succeeded"); 2458} 2459 2460tcu::TestStatus testPhysicalDeviceFeatureWorkgroupMemoryExplicitLayoutFeaturesKHR (Context& context) 2461{ 2462 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 2463 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 2464 const InstanceDriver& vki (instance.getDriver()); 2465 const int count = 2u; 2466 TestLog& log = context.getTestContext().getLog(); 2467 VkPhysicalDeviceFeatures2 extFeatures; 2468 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 2469 2470 VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR deviceWorkgroupMemoryExplicitLayoutFeaturesKHR[count]; 2471 const bool isWorkgroupMemoryExplicitLayoutFeaturesKHR = checkExtension(properties, "VK_KHR_workgroup_memory_explicit_layout"); 2472 2473 for (int ndx = 0; ndx < count; ++ndx) 2474 { 2475 deMemset(&deviceWorkgroupMemoryExplicitLayoutFeaturesKHR[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR)); 2476 deviceWorkgroupMemoryExplicitLayoutFeaturesKHR[ndx].sType = isWorkgroupMemoryExplicitLayoutFeaturesKHR ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR : VK_STRUCTURE_TYPE_MAX_ENUM; 2477 deviceWorkgroupMemoryExplicitLayoutFeaturesKHR[ndx].pNext = DE_NULL; 2478 2479 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 2480 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 2481 extFeatures.pNext = &deviceWorkgroupMemoryExplicitLayoutFeaturesKHR[ndx]; 2482 2483 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 2484 } 2485 2486 if (isWorkgroupMemoryExplicitLayoutFeaturesKHR) 2487 log << TestLog::Message << deviceWorkgroupMemoryExplicitLayoutFeaturesKHR[0] << TestLog::EndMessage; 2488 2489 if (isWorkgroupMemoryExplicitLayoutFeaturesKHR && 2490 (deviceWorkgroupMemoryExplicitLayoutFeaturesKHR[0].workgroupMemoryExplicitLayout != deviceWorkgroupMemoryExplicitLayoutFeaturesKHR[1].workgroupMemoryExplicitLayout || 2491 deviceWorkgroupMemoryExplicitLayoutFeaturesKHR[0].workgroupMemoryExplicitLayoutScalarBlockLayout != deviceWorkgroupMemoryExplicitLayoutFeaturesKHR[1].workgroupMemoryExplicitLayoutScalarBlockLayout || 2492 deviceWorkgroupMemoryExplicitLayoutFeaturesKHR[0].workgroupMemoryExplicitLayout8BitAccess != deviceWorkgroupMemoryExplicitLayoutFeaturesKHR[1].workgroupMemoryExplicitLayout8BitAccess || 2493 deviceWorkgroupMemoryExplicitLayoutFeaturesKHR[0].workgroupMemoryExplicitLayout16BitAccess != deviceWorkgroupMemoryExplicitLayoutFeaturesKHR[1].workgroupMemoryExplicitLayout16BitAccess)) 2494 { 2495 TCU_FAIL("Mismatch between VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR"); 2496 } 2497 return tcu::TestStatus::pass("Querying succeeded"); 2498} 2499 2500tcu::TestStatus testPhysicalDeviceFeatureVariablePointersFeatures (Context& context) 2501{ 2502 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 2503 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 2504 const InstanceDriver& vki (instance.getDriver()); 2505 const int count = 2u; 2506 TestLog& log = context.getTestContext().getLog(); 2507 VkPhysicalDeviceFeatures2 extFeatures; 2508 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 2509 2510 VkPhysicalDeviceVariablePointersFeatures deviceVariablePointersFeatures[count]; 2511 const bool isVariablePointersFeatures = checkExtension(properties, "VK_KHR_variable_pointers") || context.contextSupports(vk::ApiVersion(1, 1, 0)); 2512 2513 for (int ndx = 0; ndx < count; ++ndx) 2514 { 2515 deMemset(&deviceVariablePointersFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVariablePointersFeatures)); 2516 deviceVariablePointersFeatures[ndx].sType = isVariablePointersFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 2517 deviceVariablePointersFeatures[ndx].pNext = DE_NULL; 2518 2519 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 2520 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 2521 extFeatures.pNext = &deviceVariablePointersFeatures[ndx]; 2522 2523 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 2524 } 2525 2526 if (isVariablePointersFeatures) 2527 log << TestLog::Message << deviceVariablePointersFeatures[0] << TestLog::EndMessage; 2528 2529 if (isVariablePointersFeatures && 2530 (deviceVariablePointersFeatures[0].variablePointersStorageBuffer != deviceVariablePointersFeatures[1].variablePointersStorageBuffer || 2531 deviceVariablePointersFeatures[0].variablePointers != deviceVariablePointersFeatures[1].variablePointers)) 2532 { 2533 TCU_FAIL("Mismatch between VkPhysicalDeviceVariablePointersFeatures"); 2534 } 2535 return tcu::TestStatus::pass("Querying succeeded"); 2536} 2537 2538tcu::TestStatus testPhysicalDeviceFeatureVertexAttributeDivisorFeaturesEXT (Context& context) 2539{ 2540 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 2541 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 2542 const InstanceDriver& vki (instance.getDriver()); 2543 const int count = 2u; 2544 TestLog& log = context.getTestContext().getLog(); 2545 VkPhysicalDeviceFeatures2 extFeatures; 2546 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 2547 2548 VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT deviceVertexAttributeDivisorFeaturesEXT[count]; 2549 const bool isVertexAttributeDivisorFeaturesEXT = checkExtension(properties, "VK_EXT_vertex_attribute_divisor"); 2550 2551 for (int ndx = 0; ndx < count; ++ndx) 2552 { 2553 deMemset(&deviceVertexAttributeDivisorFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT)); 2554 deviceVertexAttributeDivisorFeaturesEXT[ndx].sType = isVertexAttributeDivisorFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 2555 deviceVertexAttributeDivisorFeaturesEXT[ndx].pNext = DE_NULL; 2556 2557 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 2558 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 2559 extFeatures.pNext = &deviceVertexAttributeDivisorFeaturesEXT[ndx]; 2560 2561 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 2562 } 2563 2564 if (isVertexAttributeDivisorFeaturesEXT) 2565 log << TestLog::Message << deviceVertexAttributeDivisorFeaturesEXT[0] << TestLog::EndMessage; 2566 2567 if (isVertexAttributeDivisorFeaturesEXT && 2568 (deviceVertexAttributeDivisorFeaturesEXT[0].vertexAttributeInstanceRateDivisor != deviceVertexAttributeDivisorFeaturesEXT[1].vertexAttributeInstanceRateDivisor || 2569 deviceVertexAttributeDivisorFeaturesEXT[0].vertexAttributeInstanceRateZeroDivisor != deviceVertexAttributeDivisorFeaturesEXT[1].vertexAttributeInstanceRateZeroDivisor)) 2570 { 2571 TCU_FAIL("Mismatch between VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT"); 2572 } 2573 return tcu::TestStatus::pass("Querying succeeded"); 2574} 2575 2576tcu::TestStatus testPhysicalDeviceFeatureVertexInputDynamicStateFeaturesEXT (Context& context) 2577{ 2578 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 2579 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 2580 const InstanceDriver& vki (instance.getDriver()); 2581 const int count = 2u; 2582 TestLog& log = context.getTestContext().getLog(); 2583 VkPhysicalDeviceFeatures2 extFeatures; 2584 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 2585 2586 VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT deviceVertexInputDynamicStateFeaturesEXT[count]; 2587 const bool isVertexInputDynamicStateFeaturesEXT = checkExtension(properties, "VK_EXT_vertex_input_dynamic_state"); 2588 2589 for (int ndx = 0; ndx < count; ++ndx) 2590 { 2591 deMemset(&deviceVertexInputDynamicStateFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT)); 2592 deviceVertexInputDynamicStateFeaturesEXT[ndx].sType = isVertexInputDynamicStateFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 2593 deviceVertexInputDynamicStateFeaturesEXT[ndx].pNext = DE_NULL; 2594 2595 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 2596 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 2597 extFeatures.pNext = &deviceVertexInputDynamicStateFeaturesEXT[ndx]; 2598 2599 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 2600 } 2601 2602 if (isVertexInputDynamicStateFeaturesEXT) 2603 log << TestLog::Message << deviceVertexInputDynamicStateFeaturesEXT[0] << TestLog::EndMessage; 2604 2605 if (isVertexInputDynamicStateFeaturesEXT && 2606 (deviceVertexInputDynamicStateFeaturesEXT[0].vertexInputDynamicState != deviceVertexInputDynamicStateFeaturesEXT[1].vertexInputDynamicState)) 2607 { 2608 TCU_FAIL("Mismatch between VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT"); 2609 } 2610 return tcu::TestStatus::pass("Querying succeeded"); 2611} 2612 2613tcu::TestStatus testPhysicalDeviceFeatureVulkanMemoryModelFeaturesKHR (Context& context) 2614{ 2615 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 2616 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 2617 const InstanceDriver& vki (instance.getDriver()); 2618 const int count = 2u; 2619 TestLog& log = context.getTestContext().getLog(); 2620 VkPhysicalDeviceFeatures2 extFeatures; 2621 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 2622 2623 VkPhysicalDeviceVulkanMemoryModelFeaturesKHR deviceVulkanMemoryModelFeaturesKHR[count]; 2624 const bool isVulkanMemoryModelFeaturesKHR = context.contextSupports(vk::ApiVersion(1, 2, 0)); 2625 2626 for (int ndx = 0; ndx < count; ++ndx) 2627 { 2628 deMemset(&deviceVulkanMemoryModelFeaturesKHR[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVulkanMemoryModelFeaturesKHR)); 2629 deviceVulkanMemoryModelFeaturesKHR[ndx].sType = isVulkanMemoryModelFeaturesKHR ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR : VK_STRUCTURE_TYPE_MAX_ENUM; 2630 deviceVulkanMemoryModelFeaturesKHR[ndx].pNext = DE_NULL; 2631 2632 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 2633 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 2634 extFeatures.pNext = &deviceVulkanMemoryModelFeaturesKHR[ndx]; 2635 2636 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 2637 } 2638 2639 if (isVulkanMemoryModelFeaturesKHR) 2640 log << TestLog::Message << deviceVulkanMemoryModelFeaturesKHR[0] << TestLog::EndMessage; 2641 2642 if (isVulkanMemoryModelFeaturesKHR && 2643 (deviceVulkanMemoryModelFeaturesKHR[0].vulkanMemoryModel != deviceVulkanMemoryModelFeaturesKHR[1].vulkanMemoryModel || 2644 deviceVulkanMemoryModelFeaturesKHR[0].vulkanMemoryModelDeviceScope != deviceVulkanMemoryModelFeaturesKHR[1].vulkanMemoryModelDeviceScope || 2645 deviceVulkanMemoryModelFeaturesKHR[0].vulkanMemoryModelAvailabilityVisibilityChains != deviceVulkanMemoryModelFeaturesKHR[1].vulkanMemoryModelAvailabilityVisibilityChains)) 2646 { 2647 TCU_FAIL("Mismatch between VkPhysicalDeviceVulkanMemoryModelFeaturesKHR"); 2648 } 2649 return tcu::TestStatus::pass("Querying succeeded"); 2650} 2651 2652tcu::TestStatus testPhysicalDeviceFeatureYcbcrImageArraysFeaturesEXT (Context& context) 2653{ 2654 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 2655 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 2656 const InstanceDriver& vki (instance.getDriver()); 2657 const int count = 2u; 2658 TestLog& log = context.getTestContext().getLog(); 2659 VkPhysicalDeviceFeatures2 extFeatures; 2660 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 2661 2662 VkPhysicalDeviceYcbcrImageArraysFeaturesEXT deviceYcbcrImageArraysFeaturesEXT[count]; 2663 const bool isYcbcrImageArraysFeaturesEXT = checkExtension(properties, "VK_EXT_ycbcr_image_arrays"); 2664 2665 for (int ndx = 0; ndx < count; ++ndx) 2666 { 2667 deMemset(&deviceYcbcrImageArraysFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT)); 2668 deviceYcbcrImageArraysFeaturesEXT[ndx].sType = isYcbcrImageArraysFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 2669 deviceYcbcrImageArraysFeaturesEXT[ndx].pNext = DE_NULL; 2670 2671 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 2672 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 2673 extFeatures.pNext = &deviceYcbcrImageArraysFeaturesEXT[ndx]; 2674 2675 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 2676 } 2677 2678 if (isYcbcrImageArraysFeaturesEXT) 2679 log << TestLog::Message << deviceYcbcrImageArraysFeaturesEXT[0] << TestLog::EndMessage; 2680 2681 if (isYcbcrImageArraysFeaturesEXT && 2682 (deviceYcbcrImageArraysFeaturesEXT[0].ycbcrImageArrays != deviceYcbcrImageArraysFeaturesEXT[1].ycbcrImageArrays)) 2683 { 2684 TCU_FAIL("Mismatch between VkPhysicalDeviceYcbcrImageArraysFeaturesEXT"); 2685 } 2686 return tcu::TestStatus::pass("Querying succeeded"); 2687} 2688 2689tcu::TestStatus testPhysicalDeviceFeatureYcbcr2Plane444FormatsFeaturesEXT (Context& context) 2690{ 2691 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 2692 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 2693 const InstanceDriver& vki (instance.getDriver()); 2694 const int count = 2u; 2695 TestLog& log = context.getTestContext().getLog(); 2696 VkPhysicalDeviceFeatures2 extFeatures; 2697 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 2698 2699 VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT deviceYcbcr2Plane444FormatsFeaturesEXT[count]; 2700 const bool isYcbcr2Plane444FormatsFeaturesEXT = checkExtension(properties, "VK_EXT_ycbcr_2plane_444_formats"); 2701 2702 for (int ndx = 0; ndx < count; ++ndx) 2703 { 2704 deMemset(&deviceYcbcr2Plane444FormatsFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT)); 2705 deviceYcbcr2Plane444FormatsFeaturesEXT[ndx].sType = isYcbcr2Plane444FormatsFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 2706 deviceYcbcr2Plane444FormatsFeaturesEXT[ndx].pNext = DE_NULL; 2707 2708 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 2709 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 2710 extFeatures.pNext = &deviceYcbcr2Plane444FormatsFeaturesEXT[ndx]; 2711 2712 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 2713 } 2714 2715 if (isYcbcr2Plane444FormatsFeaturesEXT) 2716 log << TestLog::Message << deviceYcbcr2Plane444FormatsFeaturesEXT[0] << TestLog::EndMessage; 2717 2718 if (isYcbcr2Plane444FormatsFeaturesEXT && 2719 (deviceYcbcr2Plane444FormatsFeaturesEXT[0].ycbcr2plane444Formats != deviceYcbcr2Plane444FormatsFeaturesEXT[1].ycbcr2plane444Formats)) 2720 { 2721 TCU_FAIL("Mismatch between VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT"); 2722 } 2723 return tcu::TestStatus::pass("Querying succeeded"); 2724} 2725 2726tcu::TestStatus testPhysicalDeviceFeatureZeroInitializeWorkgroupMemoryFeatures (Context& context) 2727{ 2728 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 2729 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 2730 const InstanceDriver& vki (instance.getDriver()); 2731 const int count = 2u; 2732 TestLog& log = context.getTestContext().getLog(); 2733 VkPhysicalDeviceFeatures2 extFeatures; 2734 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 2735 2736 VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures deviceZeroInitializeWorkgroupMemoryFeatures[count]; 2737 const bool isZeroInitializeWorkgroupMemoryFeatures = checkExtension(properties, "VK_KHR_zero_initialize_workgroup_memory") || context.contextSupports(vk::ApiVersion(1, 3, 0)); 2738 2739 for (int ndx = 0; ndx < count; ++ndx) 2740 { 2741 deMemset(&deviceZeroInitializeWorkgroupMemoryFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures)); 2742 deviceZeroInitializeWorkgroupMemoryFeatures[ndx].sType = isZeroInitializeWorkgroupMemoryFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 2743 deviceZeroInitializeWorkgroupMemoryFeatures[ndx].pNext = DE_NULL; 2744 2745 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 2746 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 2747 extFeatures.pNext = &deviceZeroInitializeWorkgroupMemoryFeatures[ndx]; 2748 2749 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 2750 } 2751 2752 if (isZeroInitializeWorkgroupMemoryFeatures) 2753 log << TestLog::Message << deviceZeroInitializeWorkgroupMemoryFeatures[0] << TestLog::EndMessage; 2754 2755 if (isZeroInitializeWorkgroupMemoryFeatures && 2756 (deviceZeroInitializeWorkgroupMemoryFeatures[0].shaderZeroInitializeWorkgroupMemory != deviceZeroInitializeWorkgroupMemoryFeatures[1].shaderZeroInitializeWorkgroupMemory)) 2757 { 2758 TCU_FAIL("Mismatch between VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures"); 2759 } 2760 return tcu::TestStatus::pass("Querying succeeded"); 2761} 2762 2763 2764void addSeparateFeatureTests (tcu::TestCaseGroup* testGroup) 2765{ 2766 2767 addFunctionCase(testGroup, "4444_formats_features_ext", "VkPhysicalDevice4444FormatsFeaturesEXT", testPhysicalDeviceFeature4444FormatsFeaturesEXT); 2768 addFunctionCase(testGroup, "8_bit_storage_features", "VkPhysicalDevice8BitStorageFeatures", testPhysicalDeviceFeature8BitStorageFeatures); 2769 addFunctionCase(testGroup, "16_bit_storage_features", "VkPhysicalDevice16BitStorageFeatures", testPhysicalDeviceFeature16BitStorageFeatures); 2770 addFunctionCase(testGroup, "acceleration_structure_features_khr", "VkPhysicalDeviceAccelerationStructureFeaturesKHR", testPhysicalDeviceFeatureAccelerationStructureFeaturesKHR); 2771 addFunctionCase(testGroup, "astc_decode_features_ext", "VkPhysicalDeviceASTCDecodeFeaturesEXT", testPhysicalDeviceFeatureASTCDecodeFeaturesEXT); 2772 addFunctionCase(testGroup, "blend_operation_advanced_features_ext", "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT", testPhysicalDeviceFeatureBlendOperationAdvancedFeaturesEXT); 2773 addFunctionCase(testGroup, "buffer_device_address_features_ext", "VkPhysicalDeviceBufferDeviceAddressFeaturesEXT", testPhysicalDeviceFeatureBufferDeviceAddressFeaturesEXT); 2774 addFunctionCase(testGroup, "buffer_device_address_features", "VkPhysicalDeviceBufferDeviceAddressFeatures", testPhysicalDeviceFeatureBufferDeviceAddressFeatures); 2775 addFunctionCase(testGroup, "conditional_rendering_features_ext", "VkPhysicalDeviceConditionalRenderingFeaturesEXT", testPhysicalDeviceFeatureConditionalRenderingFeaturesEXT); 2776 addFunctionCase(testGroup, "custom_border_color_features_ext", "VkPhysicalDeviceCustomBorderColorFeaturesEXT", testPhysicalDeviceFeatureCustomBorderColorFeaturesEXT); 2777 addFunctionCase(testGroup, "color_write_enable_features_ext", "VkPhysicalDeviceColorWriteEnableFeaturesEXT", testPhysicalDeviceFeatureColorWriteEnableFeaturesEXT); 2778 addFunctionCase(testGroup, "descriptor_indexing_features", "VkPhysicalDeviceDescriptorIndexingFeatures", testPhysicalDeviceFeatureDescriptorIndexingFeatures); 2779 addFunctionCase(testGroup, "depth_clip_enable_features_ext", "VkPhysicalDeviceDepthClipEnableFeaturesEXT", testPhysicalDeviceFeatureDepthClipEnableFeaturesEXT); 2780 addFunctionCase(testGroup, "dynamic_rendering_features", "VkPhysicalDeviceDynamicRenderingFeatures", testPhysicalDeviceFeatureDynamicRenderingFeatures); 2781 addFunctionCase(testGroup, "extended_dynamic_state_features_ext", "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT", testPhysicalDeviceFeatureExtendedDynamicStateFeaturesEXT); 2782 addFunctionCase(testGroup, "extended_dynamic_state2_features_ext", "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT", testPhysicalDeviceFeatureExtendedDynamicState2FeaturesEXT); 2783 addFunctionCase(testGroup, "fragment_density_map_features_ext", "VkPhysicalDeviceFragmentDensityMapFeaturesEXT", testPhysicalDeviceFeatureFragmentDensityMapFeaturesEXT); 2784 addFunctionCase(testGroup, "fragment_density_map2_features_ext", "VkPhysicalDeviceFragmentDensityMap2FeaturesEXT", testPhysicalDeviceFeatureFragmentDensityMap2FeaturesEXT); 2785 addFunctionCase(testGroup, "fragment_shading_rate_features_khr", "VkPhysicalDeviceFragmentShadingRateFeaturesKHR", testPhysicalDeviceFeatureFragmentShadingRateFeaturesKHR); 2786 addFunctionCase(testGroup, "global_priority_query_features_khr", "VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR", testPhysicalDeviceFeatureGlobalPriorityQueryFeaturesKHR); 2787 addFunctionCase(testGroup, "inline_uniform_block_features", "VkPhysicalDeviceInlineUniformBlockFeatures", testPhysicalDeviceFeatureInlineUniformBlockFeatures); 2788 addFunctionCase(testGroup, "index_type_uint8_features_ext", "VkPhysicalDeviceIndexTypeUint8FeaturesEXT", testPhysicalDeviceFeatureIndexTypeUint8FeaturesEXT); 2789 addFunctionCase(testGroup, "imageless_framebuffer_features", "VkPhysicalDeviceImagelessFramebufferFeatures", testPhysicalDeviceFeatureImagelessFramebufferFeatures); 2790 addFunctionCase(testGroup, "image_robustness_features", "VkPhysicalDeviceImageRobustnessFeatures", testPhysicalDeviceFeatureImageRobustnessFeatures); 2791 addFunctionCase(testGroup, "host_query_reset_features", "VkPhysicalDeviceHostQueryResetFeatures", testPhysicalDeviceFeatureHostQueryResetFeatures); 2792 addFunctionCase(testGroup, "line_rasterization_features_ext", "VkPhysicalDeviceLineRasterizationFeaturesEXT", testPhysicalDeviceFeatureLineRasterizationFeaturesEXT); 2793 addFunctionCase(testGroup, "maintenance4_features", "VkPhysicalDeviceMaintenance4Features", testPhysicalDeviceFeatureMaintenance4Features); 2794 addFunctionCase(testGroup, "multiview_features", "VkPhysicalDeviceMultiviewFeatures", testPhysicalDeviceFeatureMultiviewFeatures); 2795 addFunctionCase(testGroup, "multi_draw_features_ext", "VkPhysicalDeviceMultiDrawFeaturesEXT", testPhysicalDeviceFeatureMultiDrawFeaturesEXT); 2796 addFunctionCase(testGroup, "memory_priority_features_ext", "VkPhysicalDeviceMemoryPriorityFeaturesEXT", testPhysicalDeviceFeatureMemoryPriorityFeaturesEXT); 2797 addFunctionCase(testGroup, "device_memory_report_features_ext", "VkPhysicalDeviceDeviceMemoryReportFeaturesEXT", testPhysicalDeviceFeatureDeviceMemoryReportFeaturesEXT); 2798 addFunctionCase(testGroup, "performance_query_features_khr", "VkPhysicalDevicePerformanceQueryFeaturesKHR", testPhysicalDeviceFeaturePerformanceQueryFeaturesKHR); 2799 addFunctionCase(testGroup, "pipeline_creation_cache_control_features", "VkPhysicalDevicePipelineCreationCacheControlFeatures", testPhysicalDeviceFeaturePipelineCreationCacheControlFeatures); 2800 addFunctionCase(testGroup, "pipeline_executable_properties_features_khr", "VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR", testPhysicalDeviceFeaturePipelineExecutablePropertiesFeaturesKHR); 2801 addFunctionCase(testGroup, "present_id_features_khr", "VkPhysicalDevicePresentIdFeaturesKHR", testPhysicalDeviceFeaturePresentIdFeaturesKHR); 2802 addFunctionCase(testGroup, "present_wait_features_khr", "VkPhysicalDevicePresentWaitFeaturesKHR", testPhysicalDeviceFeaturePresentWaitFeaturesKHR); 2803 addFunctionCase(testGroup, "protected_memory_features", "VkPhysicalDeviceProtectedMemoryFeatures", testPhysicalDeviceFeatureProtectedMemoryFeatures); 2804 addFunctionCase(testGroup, "provoking_vertex_features_ext", "VkPhysicalDeviceProvokingVertexFeaturesEXT", testPhysicalDeviceFeatureProvokingVertexFeaturesEXT); 2805 addFunctionCase(testGroup, "primitive_topology_list_restart_features_ext", "VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT", testPhysicalDeviceFeaturePrimitiveTopologyListRestartFeaturesEXT); 2806 addFunctionCase(testGroup, "private_data_features", "VkPhysicalDevicePrivateDataFeatures", testPhysicalDeviceFeaturePrivateDataFeatures); 2807 addFunctionCase(testGroup, "ray_tracing_pipeline_features_khr", "VkPhysicalDeviceRayTracingPipelineFeaturesKHR", testPhysicalDeviceFeatureRayTracingPipelineFeaturesKHR); 2808 addFunctionCase(testGroup, "ray_query_features_khr", "VkPhysicalDeviceRayQueryFeaturesKHR", testPhysicalDeviceFeatureRayQueryFeaturesKHR); 2809 addFunctionCase(testGroup, "robustness2_features_ext", "VkPhysicalDeviceRobustness2FeaturesEXT", testPhysicalDeviceFeatureRobustness2FeaturesEXT); 2810 addFunctionCase(testGroup, "sampler_ycbcr_conversion_features", "VkPhysicalDeviceSamplerYcbcrConversionFeatures", testPhysicalDeviceFeatureSamplerYcbcrConversionFeatures); 2811 addFunctionCase(testGroup, "scalar_block_layout_features", "VkPhysicalDeviceScalarBlockLayoutFeatures", testPhysicalDeviceFeatureScalarBlockLayoutFeatures); 2812 addFunctionCase(testGroup, "separate_depth_stencil_layouts_features", "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures", testPhysicalDeviceFeatureSeparateDepthStencilLayoutsFeatures); 2813 addFunctionCase(testGroup, "shader_atomic_int64_features", "VkPhysicalDeviceShaderAtomicInt64Features", testPhysicalDeviceFeatureShaderAtomicInt64Features); 2814 addFunctionCase(testGroup, "shader_atomic_float_features_ext", "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT", testPhysicalDeviceFeatureShaderAtomicFloatFeaturesEXT); 2815 addFunctionCase(testGroup, "shader_atomic_float2_features_ext", "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT", testPhysicalDeviceFeatureShaderAtomicFloat2FeaturesEXT); 2816 addFunctionCase(testGroup, "shader_float16_int8_features", "VkPhysicalDeviceShaderFloat16Int8Features", testPhysicalDeviceFeatureShaderFloat16Int8Features); 2817 addFunctionCase(testGroup, "shader_clock_features_khr", "VkPhysicalDeviceShaderClockFeaturesKHR", testPhysicalDeviceFeatureShaderClockFeaturesKHR); 2818 addFunctionCase(testGroup, "shader_demote_to_helper_invocation_features", "VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures", testPhysicalDeviceFeatureShaderDemoteToHelperInvocationFeatures); 2819 addFunctionCase(testGroup, "shader_draw_parameters_features", "VkPhysicalDeviceShaderDrawParametersFeatures", testPhysicalDeviceFeatureShaderDrawParametersFeatures); 2820 addFunctionCase(testGroup, "shader_integer_dot_product_features", "VkPhysicalDeviceShaderIntegerDotProductFeatures", testPhysicalDeviceFeatureShaderIntegerDotProductFeatures); 2821 addFunctionCase(testGroup, "shader_subgroup_extended_types_features", "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures", testPhysicalDeviceFeatureShaderSubgroupExtendedTypesFeatures); 2822 addFunctionCase(testGroup, "shader_terminate_invocation_features", "VkPhysicalDeviceShaderTerminateInvocationFeatures", testPhysicalDeviceFeatureShaderTerminateInvocationFeatures); 2823 addFunctionCase(testGroup, "subgroup_size_control_features", "VkPhysicalDeviceSubgroupSizeControlFeatures", testPhysicalDeviceFeatureSubgroupSizeControlFeatures); 2824 addFunctionCase(testGroup, "synchronization2_features", "VkPhysicalDeviceSynchronization2Features", testPhysicalDeviceFeatureSynchronization2Features); 2825 addFunctionCase(testGroup, "fragment_shader_interlock_features_ext", "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT", testPhysicalDeviceFeatureFragmentShaderInterlockFeaturesEXT); 2826 addFunctionCase(testGroup, "texel_buffer_alignment_features_ext", "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT", testPhysicalDeviceFeatureTexelBufferAlignmentFeaturesEXT); 2827 addFunctionCase(testGroup, "texture_compression_astchdr_features", "VkPhysicalDeviceTextureCompressionASTCHDRFeatures", testPhysicalDeviceFeatureTextureCompressionASTCHDRFeatures); 2828 addFunctionCase(testGroup, "timeline_semaphore_features", "VkPhysicalDeviceTimelineSemaphoreFeatures", testPhysicalDeviceFeatureTimelineSemaphoreFeatures); 2829 addFunctionCase(testGroup, "transform_feedback_features_ext", "VkPhysicalDeviceTransformFeedbackFeaturesEXT", testPhysicalDeviceFeatureTransformFeedbackFeaturesEXT); 2830 addFunctionCase(testGroup, "uniform_buffer_standard_layout_features", "VkPhysicalDeviceUniformBufferStandardLayoutFeatures", testPhysicalDeviceFeatureUniformBufferStandardLayoutFeatures); 2831 addFunctionCase(testGroup, "workgroup_memory_explicit_layout_features_khr", "VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR", testPhysicalDeviceFeatureWorkgroupMemoryExplicitLayoutFeaturesKHR); 2832 addFunctionCase(testGroup, "variable_pointers_features", "VkPhysicalDeviceVariablePointersFeatures", testPhysicalDeviceFeatureVariablePointersFeatures); 2833 addFunctionCase(testGroup, "vertex_attribute_divisor_features_ext", "VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT", testPhysicalDeviceFeatureVertexAttributeDivisorFeaturesEXT); 2834 addFunctionCase(testGroup, "vertex_input_dynamic_state_features_ext", "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT", testPhysicalDeviceFeatureVertexInputDynamicStateFeaturesEXT); 2835 addFunctionCase(testGroup, "vulkan_memory_model_features_khr", "VkPhysicalDeviceVulkanMemoryModelFeaturesKHR", testPhysicalDeviceFeatureVulkanMemoryModelFeaturesKHR); 2836 addFunctionCase(testGroup, "ycbcr_image_arrays_features_ext", "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT", testPhysicalDeviceFeatureYcbcrImageArraysFeaturesEXT); 2837 addFunctionCase(testGroup, "ycbcr2_plane444_formats_features_ext", "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT", testPhysicalDeviceFeatureYcbcr2Plane444FormatsFeaturesEXT); 2838 addFunctionCase(testGroup, "zero_initialize_workgroup_memory_features", "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures", testPhysicalDeviceFeatureZeroInitializeWorkgroupMemoryFeatures); 2839} 2840 2841