1/* WARNING: This is auto-generated file. Do not modify, since changes will 2 * be lost! Modify the generating script instead. 3 * This file was generated by /scripts/gen_framework.py 4 */ 5 6tcu::TestStatus testPhysicalDeviceFeatureVariablePointersFeatures (Context& context) 7{ 8 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 9 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 10 const InstanceDriver& vki (instance.getDriver()); 11 const int count = 2u; 12 TestLog& log = context.getTestContext().getLog(); 13 VkPhysicalDeviceFeatures2 extFeatures; 14 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 15 16 VkPhysicalDeviceVariablePointersFeatures deviceVariablePointersFeatures[count]; 17 const bool isVariablePointersFeatures = context.contextSupports(vk::ApiVersion(1, 1, 1, 0)); 18 19 for (int ndx = 0; ndx < count; ++ndx) 20 { 21 deMemset(&deviceVariablePointersFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVariablePointersFeatures)); 22 deviceVariablePointersFeatures[ndx].sType = isVariablePointersFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 23 deviceVariablePointersFeatures[ndx].pNext = DE_NULL; 24 25 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 26 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 27 extFeatures.pNext = &deviceVariablePointersFeatures[ndx]; 28 29 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 30 } 31 32 if (isVariablePointersFeatures) 33 log << TestLog::Message << deviceVariablePointersFeatures[0] << TestLog::EndMessage; 34 35 if (isVariablePointersFeatures && 36 (deviceVariablePointersFeatures[0].variablePointersStorageBuffer != deviceVariablePointersFeatures[1].variablePointersStorageBuffer || 37 deviceVariablePointersFeatures[0].variablePointers != deviceVariablePointersFeatures[1].variablePointers)) 38 { 39 TCU_FAIL("Mismatch between VkPhysicalDeviceVariablePointersFeatures"); 40 } 41 return tcu::TestStatus::pass("Querying succeeded"); 42} 43 44tcu::TestStatus testPhysicalDeviceFeatureMultiviewFeatures (Context& context) 45{ 46 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 47 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 48 const InstanceDriver& vki (instance.getDriver()); 49 const int count = 2u; 50 TestLog& log = context.getTestContext().getLog(); 51 VkPhysicalDeviceFeatures2 extFeatures; 52 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 53 54 VkPhysicalDeviceMultiviewFeatures deviceMultiviewFeatures[count]; 55 const bool isMultiviewFeatures = context.contextSupports(vk::ApiVersion(1, 1, 1, 0)); 56 57 for (int ndx = 0; ndx < count; ++ndx) 58 { 59 deMemset(&deviceMultiviewFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceMultiviewFeatures)); 60 deviceMultiviewFeatures[ndx].sType = isMultiviewFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 61 deviceMultiviewFeatures[ndx].pNext = DE_NULL; 62 63 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 64 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 65 extFeatures.pNext = &deviceMultiviewFeatures[ndx]; 66 67 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 68 } 69 70 if (isMultiviewFeatures) 71 log << TestLog::Message << deviceMultiviewFeatures[0] << TestLog::EndMessage; 72 73 if (isMultiviewFeatures && 74 (deviceMultiviewFeatures[0].multiview != deviceMultiviewFeatures[1].multiview || 75 deviceMultiviewFeatures[0].multiviewGeometryShader != deviceMultiviewFeatures[1].multiviewGeometryShader || 76 deviceMultiviewFeatures[0].multiviewTessellationShader != deviceMultiviewFeatures[1].multiviewTessellationShader)) 77 { 78 TCU_FAIL("Mismatch between VkPhysicalDeviceMultiviewFeatures"); 79 } 80 return tcu::TestStatus::pass("Querying succeeded"); 81} 82 83tcu::TestStatus testPhysicalDeviceFeature16BitStorageFeatures (Context& context) 84{ 85 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 86 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 87 const InstanceDriver& vki (instance.getDriver()); 88 const int count = 2u; 89 TestLog& log = context.getTestContext().getLog(); 90 VkPhysicalDeviceFeatures2 extFeatures; 91 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 92 93 VkPhysicalDevice16BitStorageFeatures device16BitStorageFeatures[count]; 94 const bool is16BitStorageFeatures = context.contextSupports(vk::ApiVersion(1, 1, 1, 0)); 95 96 for (int ndx = 0; ndx < count; ++ndx) 97 { 98 deMemset(&device16BitStorageFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDevice16BitStorageFeatures)); 99 device16BitStorageFeatures[ndx].sType = is16BitStorageFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 100 device16BitStorageFeatures[ndx].pNext = DE_NULL; 101 102 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 103 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 104 extFeatures.pNext = &device16BitStorageFeatures[ndx]; 105 106 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 107 } 108 109 if (is16BitStorageFeatures) 110 log << TestLog::Message << device16BitStorageFeatures[0] << TestLog::EndMessage; 111 112 if (is16BitStorageFeatures && 113 (device16BitStorageFeatures[0].storageBuffer16BitAccess != device16BitStorageFeatures[1].storageBuffer16BitAccess || 114 device16BitStorageFeatures[0].uniformAndStorageBuffer16BitAccess != device16BitStorageFeatures[1].uniformAndStorageBuffer16BitAccess || 115 device16BitStorageFeatures[0].storagePushConstant16 != device16BitStorageFeatures[1].storagePushConstant16 || 116 device16BitStorageFeatures[0].storageInputOutput16 != device16BitStorageFeatures[1].storageInputOutput16)) 117 { 118 TCU_FAIL("Mismatch between VkPhysicalDevice16BitStorageFeatures"); 119 } 120 return tcu::TestStatus::pass("Querying succeeded"); 121} 122 123tcu::TestStatus testPhysicalDeviceFeatureShaderSubgroupExtendedTypesFeatures (Context& context) 124{ 125 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 126 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 127 const InstanceDriver& vki (instance.getDriver()); 128 const int count = 2u; 129 TestLog& log = context.getTestContext().getLog(); 130 VkPhysicalDeviceFeatures2 extFeatures; 131 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 132 133 VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures deviceShaderSubgroupExtendedTypesFeatures[count]; 134 const bool isShaderSubgroupExtendedTypesFeatures = context.contextSupports(vk::ApiVersion(1, 1, 2, 0)); 135 136 for (int ndx = 0; ndx < count; ++ndx) 137 { 138 deMemset(&deviceShaderSubgroupExtendedTypesFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures)); 139 deviceShaderSubgroupExtendedTypesFeatures[ndx].sType = isShaderSubgroupExtendedTypesFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 140 deviceShaderSubgroupExtendedTypesFeatures[ndx].pNext = DE_NULL; 141 142 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 143 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 144 extFeatures.pNext = &deviceShaderSubgroupExtendedTypesFeatures[ndx]; 145 146 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 147 } 148 149 if (isShaderSubgroupExtendedTypesFeatures) 150 log << TestLog::Message << deviceShaderSubgroupExtendedTypesFeatures[0] << TestLog::EndMessage; 151 152 if (isShaderSubgroupExtendedTypesFeatures && 153 (deviceShaderSubgroupExtendedTypesFeatures[0].shaderSubgroupExtendedTypes != deviceShaderSubgroupExtendedTypesFeatures[1].shaderSubgroupExtendedTypes)) 154 { 155 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures"); 156 } 157 return tcu::TestStatus::pass("Querying succeeded"); 158} 159 160tcu::TestStatus testPhysicalDeviceFeatureSamplerYcbcrConversionFeatures (Context& context) 161{ 162 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 163 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 164 const InstanceDriver& vki (instance.getDriver()); 165 const int count = 2u; 166 TestLog& log = context.getTestContext().getLog(); 167 VkPhysicalDeviceFeatures2 extFeatures; 168 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 169 170 VkPhysicalDeviceSamplerYcbcrConversionFeatures deviceSamplerYcbcrConversionFeatures[count]; 171 const bool isSamplerYcbcrConversionFeatures = context.contextSupports(vk::ApiVersion(1, 1, 1, 0)); 172 173 for (int ndx = 0; ndx < count; ++ndx) 174 { 175 deMemset(&deviceSamplerYcbcrConversionFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures)); 176 deviceSamplerYcbcrConversionFeatures[ndx].sType = isSamplerYcbcrConversionFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 177 deviceSamplerYcbcrConversionFeatures[ndx].pNext = DE_NULL; 178 179 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 180 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 181 extFeatures.pNext = &deviceSamplerYcbcrConversionFeatures[ndx]; 182 183 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 184 } 185 186 if (isSamplerYcbcrConversionFeatures) 187 log << TestLog::Message << deviceSamplerYcbcrConversionFeatures[0] << TestLog::EndMessage; 188 189 if (isSamplerYcbcrConversionFeatures && 190 (deviceSamplerYcbcrConversionFeatures[0].samplerYcbcrConversion != deviceSamplerYcbcrConversionFeatures[1].samplerYcbcrConversion)) 191 { 192 TCU_FAIL("Mismatch between VkPhysicalDeviceSamplerYcbcrConversionFeatures"); 193 } 194 return tcu::TestStatus::pass("Querying succeeded"); 195} 196 197tcu::TestStatus testPhysicalDeviceFeatureProtectedMemoryFeatures (Context& context) 198{ 199 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 200 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 201 const InstanceDriver& vki (instance.getDriver()); 202 const int count = 2u; 203 TestLog& log = context.getTestContext().getLog(); 204 VkPhysicalDeviceFeatures2 extFeatures; 205 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 206 207 VkPhysicalDeviceProtectedMemoryFeatures deviceProtectedMemoryFeatures[count]; 208 const bool isProtectedMemoryFeatures = context.contextSupports(vk::ApiVersion(1, 1, 1, 0)); 209 210 for (int ndx = 0; ndx < count; ++ndx) 211 { 212 deMemset(&deviceProtectedMemoryFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceProtectedMemoryFeatures)); 213 deviceProtectedMemoryFeatures[ndx].sType = isProtectedMemoryFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 214 deviceProtectedMemoryFeatures[ndx].pNext = DE_NULL; 215 216 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 217 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 218 extFeatures.pNext = &deviceProtectedMemoryFeatures[ndx]; 219 220 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 221 } 222 223 if (isProtectedMemoryFeatures) 224 log << TestLog::Message << deviceProtectedMemoryFeatures[0] << TestLog::EndMessage; 225 226 if (isProtectedMemoryFeatures && 227 (deviceProtectedMemoryFeatures[0].protectedMemory != deviceProtectedMemoryFeatures[1].protectedMemory)) 228 { 229 TCU_FAIL("Mismatch between VkPhysicalDeviceProtectedMemoryFeatures"); 230 } 231 return tcu::TestStatus::pass("Querying succeeded"); 232} 233 234tcu::TestStatus testPhysicalDeviceFeatureBlendOperationAdvancedFeaturesEXT (Context& context) 235{ 236 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 237 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 238 const InstanceDriver& vki (instance.getDriver()); 239 const int count = 2u; 240 TestLog& log = context.getTestContext().getLog(); 241 VkPhysicalDeviceFeatures2 extFeatures; 242 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 243 244 VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT deviceBlendOperationAdvancedFeaturesEXT[count]; 245 const bool isBlendOperationAdvancedFeaturesEXT = checkExtension(properties, "VK_EXT_blend_operation_advanced"); 246 247 for (int ndx = 0; ndx < count; ++ndx) 248 { 249 deMemset(&deviceBlendOperationAdvancedFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT)); 250 deviceBlendOperationAdvancedFeaturesEXT[ndx].sType = isBlendOperationAdvancedFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 251 deviceBlendOperationAdvancedFeaturesEXT[ndx].pNext = DE_NULL; 252 253 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 254 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 255 extFeatures.pNext = &deviceBlendOperationAdvancedFeaturesEXT[ndx]; 256 257 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 258 } 259 260 if (isBlendOperationAdvancedFeaturesEXT) 261 log << TestLog::Message << deviceBlendOperationAdvancedFeaturesEXT[0] << TestLog::EndMessage; 262 263 if (isBlendOperationAdvancedFeaturesEXT && 264 (deviceBlendOperationAdvancedFeaturesEXT[0].advancedBlendCoherentOperations != deviceBlendOperationAdvancedFeaturesEXT[1].advancedBlendCoherentOperations)) 265 { 266 TCU_FAIL("Mismatch between VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT"); 267 } 268 return tcu::TestStatus::pass("Querying succeeded"); 269} 270 271tcu::TestStatus testPhysicalDeviceFeatureShaderDrawParametersFeatures (Context& context) 272{ 273 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 274 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 275 const InstanceDriver& vki (instance.getDriver()); 276 const int count = 2u; 277 TestLog& log = context.getTestContext().getLog(); 278 VkPhysicalDeviceFeatures2 extFeatures; 279 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 280 281 VkPhysicalDeviceShaderDrawParametersFeatures deviceShaderDrawParametersFeatures[count]; 282 const bool isShaderDrawParametersFeatures = context.contextSupports(vk::ApiVersion(1, 1, 1, 0)); 283 284 for (int ndx = 0; ndx < count; ++ndx) 285 { 286 deMemset(&deviceShaderDrawParametersFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceShaderDrawParametersFeatures)); 287 deviceShaderDrawParametersFeatures[ndx].sType = isShaderDrawParametersFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 288 deviceShaderDrawParametersFeatures[ndx].pNext = DE_NULL; 289 290 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 291 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 292 extFeatures.pNext = &deviceShaderDrawParametersFeatures[ndx]; 293 294 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 295 } 296 297 if (isShaderDrawParametersFeatures) 298 log << TestLog::Message << deviceShaderDrawParametersFeatures[0] << TestLog::EndMessage; 299 300 if (isShaderDrawParametersFeatures && 301 (deviceShaderDrawParametersFeatures[0].shaderDrawParameters != deviceShaderDrawParametersFeatures[1].shaderDrawParameters)) 302 { 303 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderDrawParametersFeatures"); 304 } 305 return tcu::TestStatus::pass("Querying succeeded"); 306} 307 308tcu::TestStatus testPhysicalDeviceFeatureShaderFloat16Int8Features (Context& context) 309{ 310 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 311 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 312 const InstanceDriver& vki (instance.getDriver()); 313 const int count = 2u; 314 TestLog& log = context.getTestContext().getLog(); 315 VkPhysicalDeviceFeatures2 extFeatures; 316 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 317 318 VkPhysicalDeviceShaderFloat16Int8Features deviceShaderFloat16Int8Features[count]; 319 const bool isShaderFloat16Int8Features = context.contextSupports(vk::ApiVersion(1, 1, 2, 0)); 320 321 for (int ndx = 0; ndx < count; ++ndx) 322 { 323 deMemset(&deviceShaderFloat16Int8Features[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceShaderFloat16Int8Features)); 324 deviceShaderFloat16Int8Features[ndx].sType = isShaderFloat16Int8Features ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 325 deviceShaderFloat16Int8Features[ndx].pNext = DE_NULL; 326 327 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 328 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 329 extFeatures.pNext = &deviceShaderFloat16Int8Features[ndx]; 330 331 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 332 } 333 334 if (isShaderFloat16Int8Features) 335 log << TestLog::Message << deviceShaderFloat16Int8Features[0] << TestLog::EndMessage; 336 337 if (isShaderFloat16Int8Features && 338 (deviceShaderFloat16Int8Features[0].shaderFloat16 != deviceShaderFloat16Int8Features[1].shaderFloat16 || 339 deviceShaderFloat16Int8Features[0].shaderInt8 != deviceShaderFloat16Int8Features[1].shaderInt8)) 340 { 341 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderFloat16Int8Features"); 342 } 343 return tcu::TestStatus::pass("Querying succeeded"); 344} 345 346tcu::TestStatus testPhysicalDeviceFeatureHostQueryResetFeatures (Context& context) 347{ 348 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 349 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 350 const InstanceDriver& vki (instance.getDriver()); 351 const int count = 2u; 352 TestLog& log = context.getTestContext().getLog(); 353 VkPhysicalDeviceFeatures2 extFeatures; 354 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 355 356 VkPhysicalDeviceHostQueryResetFeatures deviceHostQueryResetFeatures[count]; 357 const bool isHostQueryResetFeatures = context.contextSupports(vk::ApiVersion(1, 1, 2, 0)); 358 359 for (int ndx = 0; ndx < count; ++ndx) 360 { 361 deMemset(&deviceHostQueryResetFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceHostQueryResetFeatures)); 362 deviceHostQueryResetFeatures[ndx].sType = isHostQueryResetFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 363 deviceHostQueryResetFeatures[ndx].pNext = DE_NULL; 364 365 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 366 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 367 extFeatures.pNext = &deviceHostQueryResetFeatures[ndx]; 368 369 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 370 } 371 372 if (isHostQueryResetFeatures) 373 log << TestLog::Message << deviceHostQueryResetFeatures[0] << TestLog::EndMessage; 374 375 if (isHostQueryResetFeatures && 376 (deviceHostQueryResetFeatures[0].hostQueryReset != deviceHostQueryResetFeatures[1].hostQueryReset)) 377 { 378 TCU_FAIL("Mismatch between VkPhysicalDeviceHostQueryResetFeatures"); 379 } 380 return tcu::TestStatus::pass("Querying succeeded"); 381} 382 383tcu::TestStatus testPhysicalDeviceFeatureDescriptorIndexingFeatures (Context& context) 384{ 385 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 386 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 387 const InstanceDriver& vki (instance.getDriver()); 388 const int count = 2u; 389 TestLog& log = context.getTestContext().getLog(); 390 VkPhysicalDeviceFeatures2 extFeatures; 391 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 392 393 VkPhysicalDeviceDescriptorIndexingFeatures deviceDescriptorIndexingFeatures[count]; 394 const bool isDescriptorIndexingFeatures = context.contextSupports(vk::ApiVersion(1, 1, 2, 0)); 395 396 for (int ndx = 0; ndx < count; ++ndx) 397 { 398 deMemset(&deviceDescriptorIndexingFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceDescriptorIndexingFeatures)); 399 deviceDescriptorIndexingFeatures[ndx].sType = isDescriptorIndexingFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 400 deviceDescriptorIndexingFeatures[ndx].pNext = DE_NULL; 401 402 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 403 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 404 extFeatures.pNext = &deviceDescriptorIndexingFeatures[ndx]; 405 406 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 407 } 408 409 if (isDescriptorIndexingFeatures) 410 log << TestLog::Message << deviceDescriptorIndexingFeatures[0] << TestLog::EndMessage; 411 412 if (isDescriptorIndexingFeatures && 413 (deviceDescriptorIndexingFeatures[0].shaderInputAttachmentArrayDynamicIndexing != deviceDescriptorIndexingFeatures[1].shaderInputAttachmentArrayDynamicIndexing || 414 deviceDescriptorIndexingFeatures[0].shaderUniformTexelBufferArrayDynamicIndexing != deviceDescriptorIndexingFeatures[1].shaderUniformTexelBufferArrayDynamicIndexing || 415 deviceDescriptorIndexingFeatures[0].shaderStorageTexelBufferArrayDynamicIndexing != deviceDescriptorIndexingFeatures[1].shaderStorageTexelBufferArrayDynamicIndexing || 416 deviceDescriptorIndexingFeatures[0].shaderUniformBufferArrayNonUniformIndexing != deviceDescriptorIndexingFeatures[1].shaderUniformBufferArrayNonUniformIndexing || 417 deviceDescriptorIndexingFeatures[0].shaderSampledImageArrayNonUniformIndexing != deviceDescriptorIndexingFeatures[1].shaderSampledImageArrayNonUniformIndexing || 418 deviceDescriptorIndexingFeatures[0].shaderStorageBufferArrayNonUniformIndexing != deviceDescriptorIndexingFeatures[1].shaderStorageBufferArrayNonUniformIndexing || 419 deviceDescriptorIndexingFeatures[0].shaderStorageImageArrayNonUniformIndexing != deviceDescriptorIndexingFeatures[1].shaderStorageImageArrayNonUniformIndexing || 420 deviceDescriptorIndexingFeatures[0].shaderInputAttachmentArrayNonUniformIndexing != deviceDescriptorIndexingFeatures[1].shaderInputAttachmentArrayNonUniformIndexing || 421 deviceDescriptorIndexingFeatures[0].shaderUniformTexelBufferArrayNonUniformIndexing != deviceDescriptorIndexingFeatures[1].shaderUniformTexelBufferArrayNonUniformIndexing || 422 deviceDescriptorIndexingFeatures[0].shaderStorageTexelBufferArrayNonUniformIndexing != deviceDescriptorIndexingFeatures[1].shaderStorageTexelBufferArrayNonUniformIndexing || 423 deviceDescriptorIndexingFeatures[0].descriptorBindingUniformBufferUpdateAfterBind != deviceDescriptorIndexingFeatures[1].descriptorBindingUniformBufferUpdateAfterBind || 424 deviceDescriptorIndexingFeatures[0].descriptorBindingSampledImageUpdateAfterBind != deviceDescriptorIndexingFeatures[1].descriptorBindingSampledImageUpdateAfterBind || 425 deviceDescriptorIndexingFeatures[0].descriptorBindingStorageImageUpdateAfterBind != deviceDescriptorIndexingFeatures[1].descriptorBindingStorageImageUpdateAfterBind || 426 deviceDescriptorIndexingFeatures[0].descriptorBindingStorageBufferUpdateAfterBind != deviceDescriptorIndexingFeatures[1].descriptorBindingStorageBufferUpdateAfterBind || 427 deviceDescriptorIndexingFeatures[0].descriptorBindingUniformTexelBufferUpdateAfterBind != deviceDescriptorIndexingFeatures[1].descriptorBindingUniformTexelBufferUpdateAfterBind || 428 deviceDescriptorIndexingFeatures[0].descriptorBindingStorageTexelBufferUpdateAfterBind != deviceDescriptorIndexingFeatures[1].descriptorBindingStorageTexelBufferUpdateAfterBind || 429 deviceDescriptorIndexingFeatures[0].descriptorBindingUpdateUnusedWhilePending != deviceDescriptorIndexingFeatures[1].descriptorBindingUpdateUnusedWhilePending || 430 deviceDescriptorIndexingFeatures[0].descriptorBindingPartiallyBound != deviceDescriptorIndexingFeatures[1].descriptorBindingPartiallyBound || 431 deviceDescriptorIndexingFeatures[0].descriptorBindingVariableDescriptorCount != deviceDescriptorIndexingFeatures[1].descriptorBindingVariableDescriptorCount || 432 deviceDescriptorIndexingFeatures[0].runtimeDescriptorArray != deviceDescriptorIndexingFeatures[1].runtimeDescriptorArray)) 433 { 434 TCU_FAIL("Mismatch between VkPhysicalDeviceDescriptorIndexingFeatures"); 435 } 436 return tcu::TestStatus::pass("Querying succeeded"); 437} 438 439tcu::TestStatus testPhysicalDeviceFeatureTimelineSemaphoreFeatures (Context& context) 440{ 441 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 442 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 443 const InstanceDriver& vki (instance.getDriver()); 444 const int count = 2u; 445 TestLog& log = context.getTestContext().getLog(); 446 VkPhysicalDeviceFeatures2 extFeatures; 447 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 448 449 VkPhysicalDeviceTimelineSemaphoreFeatures deviceTimelineSemaphoreFeatures[count]; 450 const bool isTimelineSemaphoreFeatures = context.contextSupports(vk::ApiVersion(1, 1, 2, 0)); 451 452 for (int ndx = 0; ndx < count; ++ndx) 453 { 454 deMemset(&deviceTimelineSemaphoreFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceTimelineSemaphoreFeatures)); 455 deviceTimelineSemaphoreFeatures[ndx].sType = isTimelineSemaphoreFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 456 deviceTimelineSemaphoreFeatures[ndx].pNext = DE_NULL; 457 458 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 459 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 460 extFeatures.pNext = &deviceTimelineSemaphoreFeatures[ndx]; 461 462 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 463 } 464 465 if (isTimelineSemaphoreFeatures) 466 log << TestLog::Message << deviceTimelineSemaphoreFeatures[0] << TestLog::EndMessage; 467 468 if (isTimelineSemaphoreFeatures && 469 (deviceTimelineSemaphoreFeatures[0].timelineSemaphore != deviceTimelineSemaphoreFeatures[1].timelineSemaphore)) 470 { 471 TCU_FAIL("Mismatch between VkPhysicalDeviceTimelineSemaphoreFeatures"); 472 } 473 return tcu::TestStatus::pass("Querying succeeded"); 474} 475 476tcu::TestStatus testPhysicalDeviceFeature8BitStorageFeatures (Context& context) 477{ 478 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 479 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 480 const InstanceDriver& vki (instance.getDriver()); 481 const int count = 2u; 482 TestLog& log = context.getTestContext().getLog(); 483 VkPhysicalDeviceFeatures2 extFeatures; 484 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 485 486 VkPhysicalDevice8BitStorageFeatures device8BitStorageFeatures[count]; 487 const bool is8BitStorageFeatures = context.contextSupports(vk::ApiVersion(1, 1, 2, 0)); 488 489 for (int ndx = 0; ndx < count; ++ndx) 490 { 491 deMemset(&device8BitStorageFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDevice8BitStorageFeatures)); 492 device8BitStorageFeatures[ndx].sType = is8BitStorageFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 493 device8BitStorageFeatures[ndx].pNext = DE_NULL; 494 495 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 496 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 497 extFeatures.pNext = &device8BitStorageFeatures[ndx]; 498 499 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 500 } 501 502 if (is8BitStorageFeatures) 503 log << TestLog::Message << device8BitStorageFeatures[0] << TestLog::EndMessage; 504 505 if (is8BitStorageFeatures && 506 (device8BitStorageFeatures[0].storageBuffer8BitAccess != device8BitStorageFeatures[1].storageBuffer8BitAccess || 507 device8BitStorageFeatures[0].uniformAndStorageBuffer8BitAccess != device8BitStorageFeatures[1].uniformAndStorageBuffer8BitAccess || 508 device8BitStorageFeatures[0].storagePushConstant8 != device8BitStorageFeatures[1].storagePushConstant8)) 509 { 510 TCU_FAIL("Mismatch between VkPhysicalDevice8BitStorageFeatures"); 511 } 512 return tcu::TestStatus::pass("Querying succeeded"); 513} 514 515tcu::TestStatus testPhysicalDeviceFeatureVulkanMemoryModelFeatures (Context& context) 516{ 517 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 518 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 519 const InstanceDriver& vki (instance.getDriver()); 520 const int count = 2u; 521 TestLog& log = context.getTestContext().getLog(); 522 VkPhysicalDeviceFeatures2 extFeatures; 523 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 524 525 VkPhysicalDeviceVulkanMemoryModelFeatures deviceVulkanMemoryModelFeatures[count]; 526 const bool isVulkanMemoryModelFeatures = context.contextSupports(vk::ApiVersion(1, 1, 2, 0)); 527 528 for (int ndx = 0; ndx < count; ++ndx) 529 { 530 deMemset(&deviceVulkanMemoryModelFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVulkanMemoryModelFeatures)); 531 deviceVulkanMemoryModelFeatures[ndx].sType = isVulkanMemoryModelFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 532 deviceVulkanMemoryModelFeatures[ndx].pNext = DE_NULL; 533 534 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 535 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 536 extFeatures.pNext = &deviceVulkanMemoryModelFeatures[ndx]; 537 538 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 539 } 540 541 if (isVulkanMemoryModelFeatures) 542 log << TestLog::Message << deviceVulkanMemoryModelFeatures[0] << TestLog::EndMessage; 543 544 if (isVulkanMemoryModelFeatures && 545 (deviceVulkanMemoryModelFeatures[0].vulkanMemoryModel != deviceVulkanMemoryModelFeatures[1].vulkanMemoryModel || 546 deviceVulkanMemoryModelFeatures[0].vulkanMemoryModelDeviceScope != deviceVulkanMemoryModelFeatures[1].vulkanMemoryModelDeviceScope || 547 deviceVulkanMemoryModelFeatures[0].vulkanMemoryModelAvailabilityVisibilityChains != deviceVulkanMemoryModelFeatures[1].vulkanMemoryModelAvailabilityVisibilityChains)) 548 { 549 TCU_FAIL("Mismatch between VkPhysicalDeviceVulkanMemoryModelFeatures"); 550 } 551 return tcu::TestStatus::pass("Querying succeeded"); 552} 553 554tcu::TestStatus testPhysicalDeviceFeatureShaderAtomicInt64Features (Context& context) 555{ 556 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 557 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 558 const InstanceDriver& vki (instance.getDriver()); 559 const int count = 2u; 560 TestLog& log = context.getTestContext().getLog(); 561 VkPhysicalDeviceFeatures2 extFeatures; 562 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 563 564 VkPhysicalDeviceShaderAtomicInt64Features deviceShaderAtomicInt64Features[count]; 565 const bool isShaderAtomicInt64Features = context.contextSupports(vk::ApiVersion(1, 1, 2, 0)); 566 567 for (int ndx = 0; ndx < count; ++ndx) 568 { 569 deMemset(&deviceShaderAtomicInt64Features[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceShaderAtomicInt64Features)); 570 deviceShaderAtomicInt64Features[ndx].sType = isShaderAtomicInt64Features ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 571 deviceShaderAtomicInt64Features[ndx].pNext = DE_NULL; 572 573 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 574 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 575 extFeatures.pNext = &deviceShaderAtomicInt64Features[ndx]; 576 577 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 578 } 579 580 if (isShaderAtomicInt64Features) 581 log << TestLog::Message << deviceShaderAtomicInt64Features[0] << TestLog::EndMessage; 582 583 if (isShaderAtomicInt64Features && 584 (deviceShaderAtomicInt64Features[0].shaderBufferInt64Atomics != deviceShaderAtomicInt64Features[1].shaderBufferInt64Atomics || 585 deviceShaderAtomicInt64Features[0].shaderSharedInt64Atomics != deviceShaderAtomicInt64Features[1].shaderSharedInt64Atomics)) 586 { 587 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderAtomicInt64Features"); 588 } 589 return tcu::TestStatus::pass("Querying succeeded"); 590} 591 592tcu::TestStatus testPhysicalDeviceFeatureShaderAtomicFloatFeaturesEXT (Context& context) 593{ 594 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 595 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 596 const InstanceDriver& vki (instance.getDriver()); 597 const int count = 2u; 598 TestLog& log = context.getTestContext().getLog(); 599 VkPhysicalDeviceFeatures2 extFeatures; 600 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 601 602 VkPhysicalDeviceShaderAtomicFloatFeaturesEXT deviceShaderAtomicFloatFeaturesEXT[count]; 603 const bool isShaderAtomicFloatFeaturesEXT = checkExtension(properties, "VK_EXT_shader_atomic_float"); 604 605 for (int ndx = 0; ndx < count; ++ndx) 606 { 607 deMemset(&deviceShaderAtomicFloatFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT)); 608 deviceShaderAtomicFloatFeaturesEXT[ndx].sType = isShaderAtomicFloatFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 609 deviceShaderAtomicFloatFeaturesEXT[ndx].pNext = DE_NULL; 610 611 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 612 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 613 extFeatures.pNext = &deviceShaderAtomicFloatFeaturesEXT[ndx]; 614 615 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 616 } 617 618 if (isShaderAtomicFloatFeaturesEXT) 619 log << TestLog::Message << deviceShaderAtomicFloatFeaturesEXT[0] << TestLog::EndMessage; 620 621 if (isShaderAtomicFloatFeaturesEXT && 622 (deviceShaderAtomicFloatFeaturesEXT[0].shaderBufferFloat32Atomics != deviceShaderAtomicFloatFeaturesEXT[1].shaderBufferFloat32Atomics || 623 deviceShaderAtomicFloatFeaturesEXT[0].shaderBufferFloat32AtomicAdd != deviceShaderAtomicFloatFeaturesEXT[1].shaderBufferFloat32AtomicAdd || 624 deviceShaderAtomicFloatFeaturesEXT[0].shaderBufferFloat64Atomics != deviceShaderAtomicFloatFeaturesEXT[1].shaderBufferFloat64Atomics || 625 deviceShaderAtomicFloatFeaturesEXT[0].shaderBufferFloat64AtomicAdd != deviceShaderAtomicFloatFeaturesEXT[1].shaderBufferFloat64AtomicAdd || 626 deviceShaderAtomicFloatFeaturesEXT[0].shaderSharedFloat32Atomics != deviceShaderAtomicFloatFeaturesEXT[1].shaderSharedFloat32Atomics || 627 deviceShaderAtomicFloatFeaturesEXT[0].shaderSharedFloat32AtomicAdd != deviceShaderAtomicFloatFeaturesEXT[1].shaderSharedFloat32AtomicAdd || 628 deviceShaderAtomicFloatFeaturesEXT[0].shaderSharedFloat64Atomics != deviceShaderAtomicFloatFeaturesEXT[1].shaderSharedFloat64Atomics || 629 deviceShaderAtomicFloatFeaturesEXT[0].shaderSharedFloat64AtomicAdd != deviceShaderAtomicFloatFeaturesEXT[1].shaderSharedFloat64AtomicAdd || 630 deviceShaderAtomicFloatFeaturesEXT[0].shaderImageFloat32Atomics != deviceShaderAtomicFloatFeaturesEXT[1].shaderImageFloat32Atomics || 631 deviceShaderAtomicFloatFeaturesEXT[0].shaderImageFloat32AtomicAdd != deviceShaderAtomicFloatFeaturesEXT[1].shaderImageFloat32AtomicAdd || 632 deviceShaderAtomicFloatFeaturesEXT[0].sparseImageFloat32Atomics != deviceShaderAtomicFloatFeaturesEXT[1].sparseImageFloat32Atomics || 633 deviceShaderAtomicFloatFeaturesEXT[0].sparseImageFloat32AtomicAdd != deviceShaderAtomicFloatFeaturesEXT[1].sparseImageFloat32AtomicAdd)) 634 { 635 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderAtomicFloatFeaturesEXT"); 636 } 637 return tcu::TestStatus::pass("Querying succeeded"); 638} 639 640tcu::TestStatus testPhysicalDeviceFeatureVertexAttributeDivisorFeaturesEXT (Context& context) 641{ 642 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 643 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 644 const InstanceDriver& vki (instance.getDriver()); 645 const int count = 2u; 646 TestLog& log = context.getTestContext().getLog(); 647 VkPhysicalDeviceFeatures2 extFeatures; 648 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 649 650 VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT deviceVertexAttributeDivisorFeaturesEXT[count]; 651 const bool isVertexAttributeDivisorFeaturesEXT = checkExtension(properties, "VK_EXT_vertex_attribute_divisor"); 652 653 for (int ndx = 0; ndx < count; ++ndx) 654 { 655 deMemset(&deviceVertexAttributeDivisorFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT)); 656 deviceVertexAttributeDivisorFeaturesEXT[ndx].sType = isVertexAttributeDivisorFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 657 deviceVertexAttributeDivisorFeaturesEXT[ndx].pNext = DE_NULL; 658 659 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 660 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 661 extFeatures.pNext = &deviceVertexAttributeDivisorFeaturesEXT[ndx]; 662 663 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 664 } 665 666 if (isVertexAttributeDivisorFeaturesEXT) 667 log << TestLog::Message << deviceVertexAttributeDivisorFeaturesEXT[0] << TestLog::EndMessage; 668 669 if (isVertexAttributeDivisorFeaturesEXT && 670 (deviceVertexAttributeDivisorFeaturesEXT[0].vertexAttributeInstanceRateDivisor != deviceVertexAttributeDivisorFeaturesEXT[1].vertexAttributeInstanceRateDivisor || 671 deviceVertexAttributeDivisorFeaturesEXT[0].vertexAttributeInstanceRateZeroDivisor != deviceVertexAttributeDivisorFeaturesEXT[1].vertexAttributeInstanceRateZeroDivisor)) 672 { 673 TCU_FAIL("Mismatch between VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT"); 674 } 675 return tcu::TestStatus::pass("Querying succeeded"); 676} 677 678tcu::TestStatus testPhysicalDeviceFeatureASTCDecodeFeaturesEXT (Context& context) 679{ 680 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 681 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 682 const InstanceDriver& vki (instance.getDriver()); 683 const int count = 2u; 684 TestLog& log = context.getTestContext().getLog(); 685 VkPhysicalDeviceFeatures2 extFeatures; 686 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 687 688 VkPhysicalDeviceASTCDecodeFeaturesEXT deviceASTCDecodeFeaturesEXT[count]; 689 const bool isASTCDecodeFeaturesEXT = checkExtension(properties, "VK_EXT_astc_decode_mode"); 690 691 for (int ndx = 0; ndx < count; ++ndx) 692 { 693 deMemset(&deviceASTCDecodeFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceASTCDecodeFeaturesEXT)); 694 deviceASTCDecodeFeaturesEXT[ndx].sType = isASTCDecodeFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 695 deviceASTCDecodeFeaturesEXT[ndx].pNext = DE_NULL; 696 697 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 698 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 699 extFeatures.pNext = &deviceASTCDecodeFeaturesEXT[ndx]; 700 701 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 702 } 703 704 if (isASTCDecodeFeaturesEXT) 705 log << TestLog::Message << deviceASTCDecodeFeaturesEXT[0] << TestLog::EndMessage; 706 707 if (isASTCDecodeFeaturesEXT && 708 (deviceASTCDecodeFeaturesEXT[0].decodeModeSharedExponent != deviceASTCDecodeFeaturesEXT[1].decodeModeSharedExponent)) 709 { 710 TCU_FAIL("Mismatch between VkPhysicalDeviceASTCDecodeFeaturesEXT"); 711 } 712 return tcu::TestStatus::pass("Querying succeeded"); 713} 714 715tcu::TestStatus testPhysicalDeviceFeatureScalarBlockLayoutFeatures (Context& context) 716{ 717 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 718 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 719 const InstanceDriver& vki (instance.getDriver()); 720 const int count = 2u; 721 TestLog& log = context.getTestContext().getLog(); 722 VkPhysicalDeviceFeatures2 extFeatures; 723 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 724 725 VkPhysicalDeviceScalarBlockLayoutFeatures deviceScalarBlockLayoutFeatures[count]; 726 const bool isScalarBlockLayoutFeatures = context.contextSupports(vk::ApiVersion(1, 1, 2, 0)); 727 728 for (int ndx = 0; ndx < count; ++ndx) 729 { 730 deMemset(&deviceScalarBlockLayoutFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceScalarBlockLayoutFeatures)); 731 deviceScalarBlockLayoutFeatures[ndx].sType = isScalarBlockLayoutFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 732 deviceScalarBlockLayoutFeatures[ndx].pNext = DE_NULL; 733 734 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 735 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 736 extFeatures.pNext = &deviceScalarBlockLayoutFeatures[ndx]; 737 738 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 739 } 740 741 if (isScalarBlockLayoutFeatures) 742 log << TestLog::Message << deviceScalarBlockLayoutFeatures[0] << TestLog::EndMessage; 743 744 if (isScalarBlockLayoutFeatures && 745 (deviceScalarBlockLayoutFeatures[0].scalarBlockLayout != deviceScalarBlockLayoutFeatures[1].scalarBlockLayout)) 746 { 747 TCU_FAIL("Mismatch between VkPhysicalDeviceScalarBlockLayoutFeatures"); 748 } 749 return tcu::TestStatus::pass("Querying succeeded"); 750} 751 752tcu::TestStatus testPhysicalDeviceFeatureUniformBufferStandardLayoutFeatures (Context& context) 753{ 754 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 755 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 756 const InstanceDriver& vki (instance.getDriver()); 757 const int count = 2u; 758 TestLog& log = context.getTestContext().getLog(); 759 VkPhysicalDeviceFeatures2 extFeatures; 760 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 761 762 VkPhysicalDeviceUniformBufferStandardLayoutFeatures deviceUniformBufferStandardLayoutFeatures[count]; 763 const bool isUniformBufferStandardLayoutFeatures = context.contextSupports(vk::ApiVersion(1, 1, 2, 0)); 764 765 for (int ndx = 0; ndx < count; ++ndx) 766 { 767 deMemset(&deviceUniformBufferStandardLayoutFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceUniformBufferStandardLayoutFeatures)); 768 deviceUniformBufferStandardLayoutFeatures[ndx].sType = isUniformBufferStandardLayoutFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 769 deviceUniformBufferStandardLayoutFeatures[ndx].pNext = DE_NULL; 770 771 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 772 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 773 extFeatures.pNext = &deviceUniformBufferStandardLayoutFeatures[ndx]; 774 775 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 776 } 777 778 if (isUniformBufferStandardLayoutFeatures) 779 log << TestLog::Message << deviceUniformBufferStandardLayoutFeatures[0] << TestLog::EndMessage; 780 781 if (isUniformBufferStandardLayoutFeatures && 782 (deviceUniformBufferStandardLayoutFeatures[0].uniformBufferStandardLayout != deviceUniformBufferStandardLayoutFeatures[1].uniformBufferStandardLayout)) 783 { 784 TCU_FAIL("Mismatch between VkPhysicalDeviceUniformBufferStandardLayoutFeatures"); 785 } 786 return tcu::TestStatus::pass("Querying succeeded"); 787} 788 789tcu::TestStatus testPhysicalDeviceFeatureDepthClipEnableFeaturesEXT (Context& context) 790{ 791 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 792 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 793 const InstanceDriver& vki (instance.getDriver()); 794 const int count = 2u; 795 TestLog& log = context.getTestContext().getLog(); 796 VkPhysicalDeviceFeatures2 extFeatures; 797 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 798 799 VkPhysicalDeviceDepthClipEnableFeaturesEXT deviceDepthClipEnableFeaturesEXT[count]; 800 const bool isDepthClipEnableFeaturesEXT = checkExtension(properties, "VK_EXT_depth_clip_enable"); 801 802 for (int ndx = 0; ndx < count; ++ndx) 803 { 804 deMemset(&deviceDepthClipEnableFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceDepthClipEnableFeaturesEXT)); 805 deviceDepthClipEnableFeaturesEXT[ndx].sType = isDepthClipEnableFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 806 deviceDepthClipEnableFeaturesEXT[ndx].pNext = DE_NULL; 807 808 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 809 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 810 extFeatures.pNext = &deviceDepthClipEnableFeaturesEXT[ndx]; 811 812 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 813 } 814 815 if (isDepthClipEnableFeaturesEXT) 816 log << TestLog::Message << deviceDepthClipEnableFeaturesEXT[0] << TestLog::EndMessage; 817 818 if (isDepthClipEnableFeaturesEXT && 819 (deviceDepthClipEnableFeaturesEXT[0].depthClipEnable != deviceDepthClipEnableFeaturesEXT[1].depthClipEnable)) 820 { 821 TCU_FAIL("Mismatch between VkPhysicalDeviceDepthClipEnableFeaturesEXT"); 822 } 823 return tcu::TestStatus::pass("Querying succeeded"); 824} 825 826tcu::TestStatus testPhysicalDeviceFeatureBufferDeviceAddressFeatures (Context& context) 827{ 828 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 829 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 830 const InstanceDriver& vki (instance.getDriver()); 831 const int count = 2u; 832 TestLog& log = context.getTestContext().getLog(); 833 VkPhysicalDeviceFeatures2 extFeatures; 834 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 835 836 VkPhysicalDeviceBufferDeviceAddressFeatures deviceBufferDeviceAddressFeatures[count]; 837 const bool isBufferDeviceAddressFeatures = context.contextSupports(vk::ApiVersion(1, 1, 2, 0)); 838 839 for (int ndx = 0; ndx < count; ++ndx) 840 { 841 deMemset(&deviceBufferDeviceAddressFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceBufferDeviceAddressFeatures)); 842 deviceBufferDeviceAddressFeatures[ndx].sType = isBufferDeviceAddressFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 843 deviceBufferDeviceAddressFeatures[ndx].pNext = DE_NULL; 844 845 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 846 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 847 extFeatures.pNext = &deviceBufferDeviceAddressFeatures[ndx]; 848 849 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 850 } 851 852 if (isBufferDeviceAddressFeatures) 853 log << TestLog::Message << deviceBufferDeviceAddressFeatures[0] << TestLog::EndMessage; 854 855 if (isBufferDeviceAddressFeatures && 856 (deviceBufferDeviceAddressFeatures[0].bufferDeviceAddress != deviceBufferDeviceAddressFeatures[1].bufferDeviceAddress || 857 deviceBufferDeviceAddressFeatures[0].bufferDeviceAddressCaptureReplay != deviceBufferDeviceAddressFeatures[1].bufferDeviceAddressCaptureReplay || 858 deviceBufferDeviceAddressFeatures[0].bufferDeviceAddressMultiDevice != deviceBufferDeviceAddressFeatures[1].bufferDeviceAddressMultiDevice)) 859 { 860 TCU_FAIL("Mismatch between VkPhysicalDeviceBufferDeviceAddressFeatures"); 861 } 862 return tcu::TestStatus::pass("Querying succeeded"); 863} 864 865tcu::TestStatus testPhysicalDeviceFeatureImagelessFramebufferFeatures (Context& context) 866{ 867 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 868 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 869 const InstanceDriver& vki (instance.getDriver()); 870 const int count = 2u; 871 TestLog& log = context.getTestContext().getLog(); 872 VkPhysicalDeviceFeatures2 extFeatures; 873 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 874 875 VkPhysicalDeviceImagelessFramebufferFeatures deviceImagelessFramebufferFeatures[count]; 876 const bool isImagelessFramebufferFeatures = context.contextSupports(vk::ApiVersion(1, 1, 2, 0)); 877 878 for (int ndx = 0; ndx < count; ++ndx) 879 { 880 deMemset(&deviceImagelessFramebufferFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceImagelessFramebufferFeatures)); 881 deviceImagelessFramebufferFeatures[ndx].sType = isImagelessFramebufferFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 882 deviceImagelessFramebufferFeatures[ndx].pNext = DE_NULL; 883 884 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 885 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 886 extFeatures.pNext = &deviceImagelessFramebufferFeatures[ndx]; 887 888 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 889 } 890 891 if (isImagelessFramebufferFeatures) 892 log << TestLog::Message << deviceImagelessFramebufferFeatures[0] << TestLog::EndMessage; 893 894 if (isImagelessFramebufferFeatures && 895 (deviceImagelessFramebufferFeatures[0].imagelessFramebuffer != deviceImagelessFramebufferFeatures[1].imagelessFramebuffer)) 896 { 897 TCU_FAIL("Mismatch between VkPhysicalDeviceImagelessFramebufferFeatures"); 898 } 899 return tcu::TestStatus::pass("Querying succeeded"); 900} 901 902tcu::TestStatus testPhysicalDeviceFeatureTextureCompressionASTCHDRFeaturesEXT (Context& context) 903{ 904 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 905 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 906 const InstanceDriver& vki (instance.getDriver()); 907 const int count = 2u; 908 TestLog& log = context.getTestContext().getLog(); 909 VkPhysicalDeviceFeatures2 extFeatures; 910 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 911 912 VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT deviceTextureCompressionASTCHDRFeaturesEXT[count]; 913 const bool isTextureCompressionASTCHDRFeaturesEXT = checkExtension(properties, "VK_EXT_texture_compression_astc_hdr") || context.contextSupports(vk::ApiVersion(1, 1, 3, 0)); 914 915 for (int ndx = 0; ndx < count; ++ndx) 916 { 917 deMemset(&deviceTextureCompressionASTCHDRFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)); 918 deviceTextureCompressionASTCHDRFeaturesEXT[ndx].sType = isTextureCompressionASTCHDRFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 919 deviceTextureCompressionASTCHDRFeaturesEXT[ndx].pNext = DE_NULL; 920 921 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 922 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 923 extFeatures.pNext = &deviceTextureCompressionASTCHDRFeaturesEXT[ndx]; 924 925 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 926 } 927 928 if (isTextureCompressionASTCHDRFeaturesEXT) 929 log << TestLog::Message << deviceTextureCompressionASTCHDRFeaturesEXT[0] << TestLog::EndMessage; 930 931 if (isTextureCompressionASTCHDRFeaturesEXT && 932 (deviceTextureCompressionASTCHDRFeaturesEXT[0].textureCompressionASTC_HDR != deviceTextureCompressionASTCHDRFeaturesEXT[1].textureCompressionASTC_HDR)) 933 { 934 TCU_FAIL("Mismatch between VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT"); 935 } 936 return tcu::TestStatus::pass("Querying succeeded"); 937} 938 939tcu::TestStatus testPhysicalDeviceFeatureYcbcrImageArraysFeaturesEXT (Context& context) 940{ 941 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 942 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 943 const InstanceDriver& vki (instance.getDriver()); 944 const int count = 2u; 945 TestLog& log = context.getTestContext().getLog(); 946 VkPhysicalDeviceFeatures2 extFeatures; 947 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 948 949 VkPhysicalDeviceYcbcrImageArraysFeaturesEXT deviceYcbcrImageArraysFeaturesEXT[count]; 950 const bool isYcbcrImageArraysFeaturesEXT = checkExtension(properties, "VK_EXT_ycbcr_image_arrays"); 951 952 for (int ndx = 0; ndx < count; ++ndx) 953 { 954 deMemset(&deviceYcbcrImageArraysFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT)); 955 deviceYcbcrImageArraysFeaturesEXT[ndx].sType = isYcbcrImageArraysFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 956 deviceYcbcrImageArraysFeaturesEXT[ndx].pNext = DE_NULL; 957 958 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 959 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 960 extFeatures.pNext = &deviceYcbcrImageArraysFeaturesEXT[ndx]; 961 962 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 963 } 964 965 if (isYcbcrImageArraysFeaturesEXT) 966 log << TestLog::Message << deviceYcbcrImageArraysFeaturesEXT[0] << TestLog::EndMessage; 967 968 if (isYcbcrImageArraysFeaturesEXT && 969 (deviceYcbcrImageArraysFeaturesEXT[0].ycbcrImageArrays != deviceYcbcrImageArraysFeaturesEXT[1].ycbcrImageArrays)) 970 { 971 TCU_FAIL("Mismatch between VkPhysicalDeviceYcbcrImageArraysFeaturesEXT"); 972 } 973 return tcu::TestStatus::pass("Querying succeeded"); 974} 975 976tcu::TestStatus testPhysicalDeviceFeaturePerformanceQueryFeaturesKHR (Context& context) 977{ 978 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 979 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 980 const InstanceDriver& vki (instance.getDriver()); 981 const int count = 2u; 982 TestLog& log = context.getTestContext().getLog(); 983 VkPhysicalDeviceFeatures2 extFeatures; 984 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 985 986 VkPhysicalDevicePerformanceQueryFeaturesKHR devicePerformanceQueryFeaturesKHR[count]; 987 const bool isPerformanceQueryFeaturesKHR = checkExtension(properties, "VK_KHR_performance_query"); 988 989 for (int ndx = 0; ndx < count; ++ndx) 990 { 991 deMemset(&devicePerformanceQueryFeaturesKHR[ndx], 0xFF * ndx, sizeof(VkPhysicalDevicePerformanceQueryFeaturesKHR)); 992 devicePerformanceQueryFeaturesKHR[ndx].sType = isPerformanceQueryFeaturesKHR ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR : VK_STRUCTURE_TYPE_MAX_ENUM; 993 devicePerformanceQueryFeaturesKHR[ndx].pNext = DE_NULL; 994 995 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 996 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 997 extFeatures.pNext = &devicePerformanceQueryFeaturesKHR[ndx]; 998 999 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1000 } 1001 1002 if (isPerformanceQueryFeaturesKHR) 1003 log << TestLog::Message << devicePerformanceQueryFeaturesKHR[0] << TestLog::EndMessage; 1004 1005 if (isPerformanceQueryFeaturesKHR && 1006 (devicePerformanceQueryFeaturesKHR[0].performanceCounterQueryPools != devicePerformanceQueryFeaturesKHR[1].performanceCounterQueryPools || 1007 devicePerformanceQueryFeaturesKHR[0].performanceCounterMultipleQueryPools != devicePerformanceQueryFeaturesKHR[1].performanceCounterMultipleQueryPools)) 1008 { 1009 TCU_FAIL("Mismatch between VkPhysicalDevicePerformanceQueryFeaturesKHR"); 1010 } 1011 return tcu::TestStatus::pass("Querying succeeded"); 1012} 1013 1014tcu::TestStatus testPhysicalDeviceFeatureShaderClockFeaturesKHR (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 VkPhysicalDeviceShaderClockFeaturesKHR deviceShaderClockFeaturesKHR[count]; 1025 const bool isShaderClockFeaturesKHR = checkExtension(properties, "VK_KHR_shader_clock"); 1026 1027 for (int ndx = 0; ndx < count; ++ndx) 1028 { 1029 deMemset(&deviceShaderClockFeaturesKHR[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceShaderClockFeaturesKHR)); 1030 deviceShaderClockFeaturesKHR[ndx].sType = isShaderClockFeaturesKHR ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR : VK_STRUCTURE_TYPE_MAX_ENUM; 1031 deviceShaderClockFeaturesKHR[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 = &deviceShaderClockFeaturesKHR[ndx]; 1036 1037 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1038 } 1039 1040 if (isShaderClockFeaturesKHR) 1041 log << TestLog::Message << deviceShaderClockFeaturesKHR[0] << TestLog::EndMessage; 1042 1043 if (isShaderClockFeaturesKHR && 1044 (deviceShaderClockFeaturesKHR[0].shaderSubgroupClock != deviceShaderClockFeaturesKHR[1].shaderSubgroupClock || 1045 deviceShaderClockFeaturesKHR[0].shaderDeviceClock != deviceShaderClockFeaturesKHR[1].shaderDeviceClock)) 1046 { 1047 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderClockFeaturesKHR"); 1048 } 1049 return tcu::TestStatus::pass("Querying succeeded"); 1050} 1051 1052tcu::TestStatus testPhysicalDeviceFeatureIndexTypeUint8FeaturesEXT (Context& context) 1053{ 1054 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1055 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1056 const InstanceDriver& vki (instance.getDriver()); 1057 const int count = 2u; 1058 TestLog& log = context.getTestContext().getLog(); 1059 VkPhysicalDeviceFeatures2 extFeatures; 1060 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1061 1062 VkPhysicalDeviceIndexTypeUint8FeaturesEXT deviceIndexTypeUint8FeaturesEXT[count]; 1063 const bool isIndexTypeUint8FeaturesEXT = checkExtension(properties, "VK_EXT_index_type_uint8"); 1064 1065 for (int ndx = 0; ndx < count; ++ndx) 1066 { 1067 deMemset(&deviceIndexTypeUint8FeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceIndexTypeUint8FeaturesEXT)); 1068 deviceIndexTypeUint8FeaturesEXT[ndx].sType = isIndexTypeUint8FeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1069 deviceIndexTypeUint8FeaturesEXT[ndx].pNext = DE_NULL; 1070 1071 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1072 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1073 extFeatures.pNext = &deviceIndexTypeUint8FeaturesEXT[ndx]; 1074 1075 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1076 } 1077 1078 if (isIndexTypeUint8FeaturesEXT) 1079 log << TestLog::Message << deviceIndexTypeUint8FeaturesEXT[0] << TestLog::EndMessage; 1080 1081 if (isIndexTypeUint8FeaturesEXT && 1082 (deviceIndexTypeUint8FeaturesEXT[0].indexTypeUint8 != deviceIndexTypeUint8FeaturesEXT[1].indexTypeUint8)) 1083 { 1084 TCU_FAIL("Mismatch between VkPhysicalDeviceIndexTypeUint8FeaturesEXT"); 1085 } 1086 return tcu::TestStatus::pass("Querying succeeded"); 1087} 1088 1089tcu::TestStatus testPhysicalDeviceFeatureFragmentShaderInterlockFeaturesEXT (Context& context) 1090{ 1091 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1092 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1093 const InstanceDriver& vki (instance.getDriver()); 1094 const int count = 2u; 1095 TestLog& log = context.getTestContext().getLog(); 1096 VkPhysicalDeviceFeatures2 extFeatures; 1097 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1098 1099 VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT deviceFragmentShaderInterlockFeaturesEXT[count]; 1100 const bool isFragmentShaderInterlockFeaturesEXT = checkExtension(properties, "VK_EXT_fragment_shader_interlock"); 1101 1102 for (int ndx = 0; ndx < count; ++ndx) 1103 { 1104 deMemset(&deviceFragmentShaderInterlockFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT)); 1105 deviceFragmentShaderInterlockFeaturesEXT[ndx].sType = isFragmentShaderInterlockFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1106 deviceFragmentShaderInterlockFeaturesEXT[ndx].pNext = DE_NULL; 1107 1108 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1109 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1110 extFeatures.pNext = &deviceFragmentShaderInterlockFeaturesEXT[ndx]; 1111 1112 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1113 } 1114 1115 if (isFragmentShaderInterlockFeaturesEXT) 1116 log << TestLog::Message << deviceFragmentShaderInterlockFeaturesEXT[0] << TestLog::EndMessage; 1117 1118 if (isFragmentShaderInterlockFeaturesEXT && 1119 (deviceFragmentShaderInterlockFeaturesEXT[0].fragmentShaderSampleInterlock != deviceFragmentShaderInterlockFeaturesEXT[1].fragmentShaderSampleInterlock || 1120 deviceFragmentShaderInterlockFeaturesEXT[0].fragmentShaderPixelInterlock != deviceFragmentShaderInterlockFeaturesEXT[1].fragmentShaderPixelInterlock || 1121 deviceFragmentShaderInterlockFeaturesEXT[0].fragmentShaderShadingRateInterlock != deviceFragmentShaderInterlockFeaturesEXT[1].fragmentShaderShadingRateInterlock)) 1122 { 1123 TCU_FAIL("Mismatch between VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT"); 1124 } 1125 return tcu::TestStatus::pass("Querying succeeded"); 1126} 1127 1128tcu::TestStatus testPhysicalDeviceFeatureSeparateDepthStencilLayoutsFeatures (Context& context) 1129{ 1130 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1131 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1132 const InstanceDriver& vki (instance.getDriver()); 1133 const int count = 2u; 1134 TestLog& log = context.getTestContext().getLog(); 1135 VkPhysicalDeviceFeatures2 extFeatures; 1136 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1137 1138 VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures deviceSeparateDepthStencilLayoutsFeatures[count]; 1139 const bool isSeparateDepthStencilLayoutsFeatures = context.contextSupports(vk::ApiVersion(1, 1, 2, 0)); 1140 1141 for (int ndx = 0; ndx < count; ++ndx) 1142 { 1143 deMemset(&deviceSeparateDepthStencilLayoutsFeatures[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures)); 1144 deviceSeparateDepthStencilLayoutsFeatures[ndx].sType = isSeparateDepthStencilLayoutsFeatures ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 1145 deviceSeparateDepthStencilLayoutsFeatures[ndx].pNext = DE_NULL; 1146 1147 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1148 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1149 extFeatures.pNext = &deviceSeparateDepthStencilLayoutsFeatures[ndx]; 1150 1151 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1152 } 1153 1154 if (isSeparateDepthStencilLayoutsFeatures) 1155 log << TestLog::Message << deviceSeparateDepthStencilLayoutsFeatures[0] << TestLog::EndMessage; 1156 1157 if (isSeparateDepthStencilLayoutsFeatures && 1158 (deviceSeparateDepthStencilLayoutsFeatures[0].separateDepthStencilLayouts != deviceSeparateDepthStencilLayoutsFeatures[1].separateDepthStencilLayouts)) 1159 { 1160 TCU_FAIL("Mismatch between VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures"); 1161 } 1162 return tcu::TestStatus::pass("Querying succeeded"); 1163} 1164 1165tcu::TestStatus testPhysicalDeviceFeatureShaderDemoteToHelperInvocationFeaturesEXT (Context& context) 1166{ 1167 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1168 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1169 const InstanceDriver& vki (instance.getDriver()); 1170 const int count = 2u; 1171 TestLog& log = context.getTestContext().getLog(); 1172 VkPhysicalDeviceFeatures2 extFeatures; 1173 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1174 1175 VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT deviceShaderDemoteToHelperInvocationFeaturesEXT[count]; 1176 const bool isShaderDemoteToHelperInvocationFeaturesEXT = checkExtension(properties, "VK_EXT_shader_demote_to_helper_invocation") || context.contextSupports(vk::ApiVersion(1, 1, 3, 0)); 1177 1178 for (int ndx = 0; ndx < count; ++ndx) 1179 { 1180 deMemset(&deviceShaderDemoteToHelperInvocationFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT)); 1181 deviceShaderDemoteToHelperInvocationFeaturesEXT[ndx].sType = isShaderDemoteToHelperInvocationFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1182 deviceShaderDemoteToHelperInvocationFeaturesEXT[ndx].pNext = DE_NULL; 1183 1184 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1185 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1186 extFeatures.pNext = &deviceShaderDemoteToHelperInvocationFeaturesEXT[ndx]; 1187 1188 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1189 } 1190 1191 if (isShaderDemoteToHelperInvocationFeaturesEXT) 1192 log << TestLog::Message << deviceShaderDemoteToHelperInvocationFeaturesEXT[0] << TestLog::EndMessage; 1193 1194 if (isShaderDemoteToHelperInvocationFeaturesEXT && 1195 (deviceShaderDemoteToHelperInvocationFeaturesEXT[0].shaderDemoteToHelperInvocation != deviceShaderDemoteToHelperInvocationFeaturesEXT[1].shaderDemoteToHelperInvocation)) 1196 { 1197 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT"); 1198 } 1199 return tcu::TestStatus::pass("Querying succeeded"); 1200} 1201 1202tcu::TestStatus testPhysicalDeviceFeatureTexelBufferAlignmentFeaturesEXT (Context& context) 1203{ 1204 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1205 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1206 const InstanceDriver& vki (instance.getDriver()); 1207 const int count = 2u; 1208 TestLog& log = context.getTestContext().getLog(); 1209 VkPhysicalDeviceFeatures2 extFeatures; 1210 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1211 1212 VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT deviceTexelBufferAlignmentFeaturesEXT[count]; 1213 const bool isTexelBufferAlignmentFeaturesEXT = checkExtension(properties, "VK_EXT_texel_buffer_alignment"); 1214 1215 for (int ndx = 0; ndx < count; ++ndx) 1216 { 1217 deMemset(&deviceTexelBufferAlignmentFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT)); 1218 deviceTexelBufferAlignmentFeaturesEXT[ndx].sType = isTexelBufferAlignmentFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1219 deviceTexelBufferAlignmentFeaturesEXT[ndx].pNext = DE_NULL; 1220 1221 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1222 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1223 extFeatures.pNext = &deviceTexelBufferAlignmentFeaturesEXT[ndx]; 1224 1225 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1226 } 1227 1228 if (isTexelBufferAlignmentFeaturesEXT) 1229 log << TestLog::Message << deviceTexelBufferAlignmentFeaturesEXT[0] << TestLog::EndMessage; 1230 1231 if (isTexelBufferAlignmentFeaturesEXT && 1232 (deviceTexelBufferAlignmentFeaturesEXT[0].texelBufferAlignment != deviceTexelBufferAlignmentFeaturesEXT[1].texelBufferAlignment)) 1233 { 1234 TCU_FAIL("Mismatch between VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT"); 1235 } 1236 return tcu::TestStatus::pass("Querying succeeded"); 1237} 1238 1239tcu::TestStatus testPhysicalDeviceFeatureSubgroupSizeControlFeaturesEXT (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 VkPhysicalDeviceSubgroupSizeControlFeaturesEXT deviceSubgroupSizeControlFeaturesEXT[count]; 1250 const bool isSubgroupSizeControlFeaturesEXT = checkExtension(properties, "VK_EXT_subgroup_size_control") || context.contextSupports(vk::ApiVersion(1, 1, 3, 0)); 1251 1252 for (int ndx = 0; ndx < count; ++ndx) 1253 { 1254 deMemset(&deviceSubgroupSizeControlFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceSubgroupSizeControlFeaturesEXT)); 1255 deviceSubgroupSizeControlFeaturesEXT[ndx].sType = isSubgroupSizeControlFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1256 deviceSubgroupSizeControlFeaturesEXT[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 = &deviceSubgroupSizeControlFeaturesEXT[ndx]; 1261 1262 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1263 } 1264 1265 if (isSubgroupSizeControlFeaturesEXT) 1266 log << TestLog::Message << deviceSubgroupSizeControlFeaturesEXT[0] << TestLog::EndMessage; 1267 1268 if (isSubgroupSizeControlFeaturesEXT && 1269 (deviceSubgroupSizeControlFeaturesEXT[0].subgroupSizeControl != deviceSubgroupSizeControlFeaturesEXT[1].subgroupSizeControl || 1270 deviceSubgroupSizeControlFeaturesEXT[0].computeFullSubgroups != deviceSubgroupSizeControlFeaturesEXT[1].computeFullSubgroups)) 1271 { 1272 TCU_FAIL("Mismatch between VkPhysicalDeviceSubgroupSizeControlFeaturesEXT"); 1273 } 1274 return tcu::TestStatus::pass("Querying succeeded"); 1275} 1276 1277tcu::TestStatus testPhysicalDeviceFeatureLineRasterizationFeaturesEXT (Context& context) 1278{ 1279 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1280 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1281 const InstanceDriver& vki (instance.getDriver()); 1282 const int count = 2u; 1283 TestLog& log = context.getTestContext().getLog(); 1284 VkPhysicalDeviceFeatures2 extFeatures; 1285 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1286 1287 VkPhysicalDeviceLineRasterizationFeaturesEXT deviceLineRasterizationFeaturesEXT[count]; 1288 const bool isLineRasterizationFeaturesEXT = checkExtension(properties, "VK_EXT_line_rasterization"); 1289 1290 for (int ndx = 0; ndx < count; ++ndx) 1291 { 1292 deMemset(&deviceLineRasterizationFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceLineRasterizationFeaturesEXT)); 1293 deviceLineRasterizationFeaturesEXT[ndx].sType = isLineRasterizationFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1294 deviceLineRasterizationFeaturesEXT[ndx].pNext = DE_NULL; 1295 1296 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1297 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1298 extFeatures.pNext = &deviceLineRasterizationFeaturesEXT[ndx]; 1299 1300 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1301 } 1302 1303 if (isLineRasterizationFeaturesEXT) 1304 log << TestLog::Message << deviceLineRasterizationFeaturesEXT[0] << TestLog::EndMessage; 1305 1306 if (isLineRasterizationFeaturesEXT && 1307 (deviceLineRasterizationFeaturesEXT[0].rectangularLines != deviceLineRasterizationFeaturesEXT[1].rectangularLines || 1308 deviceLineRasterizationFeaturesEXT[0].bresenhamLines != deviceLineRasterizationFeaturesEXT[1].bresenhamLines || 1309 deviceLineRasterizationFeaturesEXT[0].smoothLines != deviceLineRasterizationFeaturesEXT[1].smoothLines || 1310 deviceLineRasterizationFeaturesEXT[0].stippledRectangularLines != deviceLineRasterizationFeaturesEXT[1].stippledRectangularLines || 1311 deviceLineRasterizationFeaturesEXT[0].stippledBresenhamLines != deviceLineRasterizationFeaturesEXT[1].stippledBresenhamLines || 1312 deviceLineRasterizationFeaturesEXT[0].stippledSmoothLines != deviceLineRasterizationFeaturesEXT[1].stippledSmoothLines)) 1313 { 1314 TCU_FAIL("Mismatch between VkPhysicalDeviceLineRasterizationFeaturesEXT"); 1315 } 1316 return tcu::TestStatus::pass("Querying succeeded"); 1317} 1318 1319tcu::TestStatus testPhysicalDeviceFeatureVulkan11Features (Context& context) 1320{ 1321 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1322 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1323 const InstanceDriver& vki (instance.getDriver()); 1324 const int count = 2u; 1325 TestLog& log = context.getTestContext().getLog(); 1326 VkPhysicalDeviceFeatures2 extFeatures; 1327 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1328 1329 VkPhysicalDeviceVulkan11Features deviceVulkan11Features[count]; 1330 const bool isVulkan11Features = context.contextSupports(vk::ApiVersion(1, 1, 2, 0)); 1331 1332 for (int ndx = 0; ndx < count; ++ndx) 1333 { 1334 deMemset(&deviceVulkan11Features[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVulkan11Features)); 1335 deviceVulkan11Features[ndx].sType = isVulkan11Features ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 1336 deviceVulkan11Features[ndx].pNext = DE_NULL; 1337 1338 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1339 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1340 extFeatures.pNext = &deviceVulkan11Features[ndx]; 1341 1342 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1343 } 1344 1345 if (isVulkan11Features) 1346 log << TestLog::Message << deviceVulkan11Features[0] << TestLog::EndMessage; 1347 1348 if (isVulkan11Features && 1349 (deviceVulkan11Features[0].storageBuffer16BitAccess != deviceVulkan11Features[1].storageBuffer16BitAccess || 1350 deviceVulkan11Features[0].uniformAndStorageBuffer16BitAccess != deviceVulkan11Features[1].uniformAndStorageBuffer16BitAccess || 1351 deviceVulkan11Features[0].storagePushConstant16 != deviceVulkan11Features[1].storagePushConstant16 || 1352 deviceVulkan11Features[0].storageInputOutput16 != deviceVulkan11Features[1].storageInputOutput16 || 1353 deviceVulkan11Features[0].multiview != deviceVulkan11Features[1].multiview || 1354 deviceVulkan11Features[0].multiviewGeometryShader != deviceVulkan11Features[1].multiviewGeometryShader || 1355 deviceVulkan11Features[0].multiviewTessellationShader != deviceVulkan11Features[1].multiviewTessellationShader || 1356 deviceVulkan11Features[0].variablePointersStorageBuffer != deviceVulkan11Features[1].variablePointersStorageBuffer || 1357 deviceVulkan11Features[0].variablePointers != deviceVulkan11Features[1].variablePointers || 1358 deviceVulkan11Features[0].protectedMemory != deviceVulkan11Features[1].protectedMemory || 1359 deviceVulkan11Features[0].samplerYcbcrConversion != deviceVulkan11Features[1].samplerYcbcrConversion || 1360 deviceVulkan11Features[0].shaderDrawParameters != deviceVulkan11Features[1].shaderDrawParameters)) 1361 { 1362 TCU_FAIL("Mismatch between VkPhysicalDeviceVulkan11Features"); 1363 } 1364 return tcu::TestStatus::pass("Querying succeeded"); 1365} 1366 1367tcu::TestStatus testPhysicalDeviceFeatureVulkan12Features (Context& context) 1368{ 1369 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1370 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1371 const InstanceDriver& vki (instance.getDriver()); 1372 const int count = 2u; 1373 TestLog& log = context.getTestContext().getLog(); 1374 VkPhysicalDeviceFeatures2 extFeatures; 1375 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1376 1377 VkPhysicalDeviceVulkan12Features deviceVulkan12Features[count]; 1378 const bool isVulkan12Features = context.contextSupports(vk::ApiVersion(1, 1, 2, 0)); 1379 1380 for (int ndx = 0; ndx < count; ++ndx) 1381 { 1382 deMemset(&deviceVulkan12Features[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVulkan12Features)); 1383 deviceVulkan12Features[ndx].sType = isVulkan12Features ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 1384 deviceVulkan12Features[ndx].pNext = DE_NULL; 1385 1386 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1387 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1388 extFeatures.pNext = &deviceVulkan12Features[ndx]; 1389 1390 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1391 } 1392 1393 if (isVulkan12Features) 1394 log << TestLog::Message << deviceVulkan12Features[0] << TestLog::EndMessage; 1395 1396 if (isVulkan12Features && 1397 (deviceVulkan12Features[0].samplerMirrorClampToEdge != deviceVulkan12Features[1].samplerMirrorClampToEdge || 1398 deviceVulkan12Features[0].drawIndirectCount != deviceVulkan12Features[1].drawIndirectCount || 1399 deviceVulkan12Features[0].storageBuffer8BitAccess != deviceVulkan12Features[1].storageBuffer8BitAccess || 1400 deviceVulkan12Features[0].uniformAndStorageBuffer8BitAccess != deviceVulkan12Features[1].uniformAndStorageBuffer8BitAccess || 1401 deviceVulkan12Features[0].storagePushConstant8 != deviceVulkan12Features[1].storagePushConstant8 || 1402 deviceVulkan12Features[0].shaderBufferInt64Atomics != deviceVulkan12Features[1].shaderBufferInt64Atomics || 1403 deviceVulkan12Features[0].shaderSharedInt64Atomics != deviceVulkan12Features[1].shaderSharedInt64Atomics || 1404 deviceVulkan12Features[0].shaderFloat16 != deviceVulkan12Features[1].shaderFloat16 || 1405 deviceVulkan12Features[0].shaderInt8 != deviceVulkan12Features[1].shaderInt8 || 1406 deviceVulkan12Features[0].descriptorIndexing != deviceVulkan12Features[1].descriptorIndexing || 1407 deviceVulkan12Features[0].shaderInputAttachmentArrayDynamicIndexing != deviceVulkan12Features[1].shaderInputAttachmentArrayDynamicIndexing || 1408 deviceVulkan12Features[0].shaderUniformTexelBufferArrayDynamicIndexing != deviceVulkan12Features[1].shaderUniformTexelBufferArrayDynamicIndexing || 1409 deviceVulkan12Features[0].shaderStorageTexelBufferArrayDynamicIndexing != deviceVulkan12Features[1].shaderStorageTexelBufferArrayDynamicIndexing || 1410 deviceVulkan12Features[0].shaderUniformBufferArrayNonUniformIndexing != deviceVulkan12Features[1].shaderUniformBufferArrayNonUniformIndexing || 1411 deviceVulkan12Features[0].shaderSampledImageArrayNonUniformIndexing != deviceVulkan12Features[1].shaderSampledImageArrayNonUniformIndexing || 1412 deviceVulkan12Features[0].shaderStorageBufferArrayNonUniformIndexing != deviceVulkan12Features[1].shaderStorageBufferArrayNonUniformIndexing || 1413 deviceVulkan12Features[0].shaderStorageImageArrayNonUniformIndexing != deviceVulkan12Features[1].shaderStorageImageArrayNonUniformIndexing || 1414 deviceVulkan12Features[0].shaderInputAttachmentArrayNonUniformIndexing != deviceVulkan12Features[1].shaderInputAttachmentArrayNonUniformIndexing || 1415 deviceVulkan12Features[0].shaderUniformTexelBufferArrayNonUniformIndexing != deviceVulkan12Features[1].shaderUniformTexelBufferArrayNonUniformIndexing || 1416 deviceVulkan12Features[0].shaderStorageTexelBufferArrayNonUniformIndexing != deviceVulkan12Features[1].shaderStorageTexelBufferArrayNonUniformIndexing || 1417 deviceVulkan12Features[0].descriptorBindingUniformBufferUpdateAfterBind != deviceVulkan12Features[1].descriptorBindingUniformBufferUpdateAfterBind || 1418 deviceVulkan12Features[0].descriptorBindingSampledImageUpdateAfterBind != deviceVulkan12Features[1].descriptorBindingSampledImageUpdateAfterBind || 1419 deviceVulkan12Features[0].descriptorBindingStorageImageUpdateAfterBind != deviceVulkan12Features[1].descriptorBindingStorageImageUpdateAfterBind || 1420 deviceVulkan12Features[0].descriptorBindingStorageBufferUpdateAfterBind != deviceVulkan12Features[1].descriptorBindingStorageBufferUpdateAfterBind || 1421 deviceVulkan12Features[0].descriptorBindingUniformTexelBufferUpdateAfterBind != deviceVulkan12Features[1].descriptorBindingUniformTexelBufferUpdateAfterBind || 1422 deviceVulkan12Features[0].descriptorBindingStorageTexelBufferUpdateAfterBind != deviceVulkan12Features[1].descriptorBindingStorageTexelBufferUpdateAfterBind || 1423 deviceVulkan12Features[0].descriptorBindingUpdateUnusedWhilePending != deviceVulkan12Features[1].descriptorBindingUpdateUnusedWhilePending || 1424 deviceVulkan12Features[0].descriptorBindingPartiallyBound != deviceVulkan12Features[1].descriptorBindingPartiallyBound || 1425 deviceVulkan12Features[0].descriptorBindingVariableDescriptorCount != deviceVulkan12Features[1].descriptorBindingVariableDescriptorCount || 1426 deviceVulkan12Features[0].runtimeDescriptorArray != deviceVulkan12Features[1].runtimeDescriptorArray || 1427 deviceVulkan12Features[0].samplerFilterMinmax != deviceVulkan12Features[1].samplerFilterMinmax || 1428 deviceVulkan12Features[0].scalarBlockLayout != deviceVulkan12Features[1].scalarBlockLayout || 1429 deviceVulkan12Features[0].imagelessFramebuffer != deviceVulkan12Features[1].imagelessFramebuffer || 1430 deviceVulkan12Features[0].uniformBufferStandardLayout != deviceVulkan12Features[1].uniformBufferStandardLayout || 1431 deviceVulkan12Features[0].shaderSubgroupExtendedTypes != deviceVulkan12Features[1].shaderSubgroupExtendedTypes || 1432 deviceVulkan12Features[0].separateDepthStencilLayouts != deviceVulkan12Features[1].separateDepthStencilLayouts || 1433 deviceVulkan12Features[0].hostQueryReset != deviceVulkan12Features[1].hostQueryReset || 1434 deviceVulkan12Features[0].timelineSemaphore != deviceVulkan12Features[1].timelineSemaphore || 1435 deviceVulkan12Features[0].bufferDeviceAddress != deviceVulkan12Features[1].bufferDeviceAddress || 1436 deviceVulkan12Features[0].bufferDeviceAddressCaptureReplay != deviceVulkan12Features[1].bufferDeviceAddressCaptureReplay || 1437 deviceVulkan12Features[0].bufferDeviceAddressMultiDevice != deviceVulkan12Features[1].bufferDeviceAddressMultiDevice || 1438 deviceVulkan12Features[0].vulkanMemoryModel != deviceVulkan12Features[1].vulkanMemoryModel || 1439 deviceVulkan12Features[0].vulkanMemoryModelDeviceScope != deviceVulkan12Features[1].vulkanMemoryModelDeviceScope || 1440 deviceVulkan12Features[0].vulkanMemoryModelAvailabilityVisibilityChains != deviceVulkan12Features[1].vulkanMemoryModelAvailabilityVisibilityChains || 1441 deviceVulkan12Features[0].shaderOutputViewportIndex != deviceVulkan12Features[1].shaderOutputViewportIndex || 1442 deviceVulkan12Features[0].shaderOutputLayer != deviceVulkan12Features[1].shaderOutputLayer || 1443 deviceVulkan12Features[0].subgroupBroadcastDynamicId != deviceVulkan12Features[1].subgroupBroadcastDynamicId)) 1444 { 1445 TCU_FAIL("Mismatch between VkPhysicalDeviceVulkan12Features"); 1446 } 1447 return tcu::TestStatus::pass("Querying succeeded"); 1448} 1449 1450tcu::TestStatus testPhysicalDeviceFeatureCustomBorderColorFeaturesEXT (Context& context) 1451{ 1452 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1453 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1454 const InstanceDriver& vki (instance.getDriver()); 1455 const int count = 2u; 1456 TestLog& log = context.getTestContext().getLog(); 1457 VkPhysicalDeviceFeatures2 extFeatures; 1458 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1459 1460 VkPhysicalDeviceCustomBorderColorFeaturesEXT deviceCustomBorderColorFeaturesEXT[count]; 1461 const bool isCustomBorderColorFeaturesEXT = checkExtension(properties, "VK_EXT_custom_border_color"); 1462 1463 for (int ndx = 0; ndx < count; ++ndx) 1464 { 1465 deMemset(&deviceCustomBorderColorFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceCustomBorderColorFeaturesEXT)); 1466 deviceCustomBorderColorFeaturesEXT[ndx].sType = isCustomBorderColorFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1467 deviceCustomBorderColorFeaturesEXT[ndx].pNext = DE_NULL; 1468 1469 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1470 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1471 extFeatures.pNext = &deviceCustomBorderColorFeaturesEXT[ndx]; 1472 1473 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1474 } 1475 1476 if (isCustomBorderColorFeaturesEXT) 1477 log << TestLog::Message << deviceCustomBorderColorFeaturesEXT[0] << TestLog::EndMessage; 1478 1479 if (isCustomBorderColorFeaturesEXT && 1480 (deviceCustomBorderColorFeaturesEXT[0].customBorderColors != deviceCustomBorderColorFeaturesEXT[1].customBorderColors || 1481 deviceCustomBorderColorFeaturesEXT[0].customBorderColorWithoutFormat != deviceCustomBorderColorFeaturesEXT[1].customBorderColorWithoutFormat)) 1482 { 1483 TCU_FAIL("Mismatch between VkPhysicalDeviceCustomBorderColorFeaturesEXT"); 1484 } 1485 return tcu::TestStatus::pass("Querying succeeded"); 1486} 1487 1488tcu::TestStatus testPhysicalDeviceFeatureExtendedDynamicStateFeaturesEXT (Context& context) 1489{ 1490 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1491 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1492 const InstanceDriver& vki (instance.getDriver()); 1493 const int count = 2u; 1494 TestLog& log = context.getTestContext().getLog(); 1495 VkPhysicalDeviceFeatures2 extFeatures; 1496 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1497 1498 VkPhysicalDeviceExtendedDynamicStateFeaturesEXT deviceExtendedDynamicStateFeaturesEXT[count]; 1499 const bool isExtendedDynamicStateFeaturesEXT = checkExtension(properties, "VK_EXT_extended_dynamic_state"); 1500 1501 for (int ndx = 0; ndx < count; ++ndx) 1502 { 1503 deMemset(&deviceExtendedDynamicStateFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT)); 1504 deviceExtendedDynamicStateFeaturesEXT[ndx].sType = isExtendedDynamicStateFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1505 deviceExtendedDynamicStateFeaturesEXT[ndx].pNext = DE_NULL; 1506 1507 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1508 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1509 extFeatures.pNext = &deviceExtendedDynamicStateFeaturesEXT[ndx]; 1510 1511 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1512 } 1513 1514 if (isExtendedDynamicStateFeaturesEXT) 1515 log << TestLog::Message << deviceExtendedDynamicStateFeaturesEXT[0] << TestLog::EndMessage; 1516 1517 if (isExtendedDynamicStateFeaturesEXT && 1518 (deviceExtendedDynamicStateFeaturesEXT[0].extendedDynamicState != deviceExtendedDynamicStateFeaturesEXT[1].extendedDynamicState)) 1519 { 1520 TCU_FAIL("Mismatch between VkPhysicalDeviceExtendedDynamicStateFeaturesEXT"); 1521 } 1522 return tcu::TestStatus::pass("Querying succeeded"); 1523} 1524 1525tcu::TestStatus testPhysicalDeviceFeatureExtendedDynamicState2FeaturesEXT (Context& context) 1526{ 1527 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1528 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1529 const InstanceDriver& vki (instance.getDriver()); 1530 const int count = 2u; 1531 TestLog& log = context.getTestContext().getLog(); 1532 VkPhysicalDeviceFeatures2 extFeatures; 1533 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1534 1535 VkPhysicalDeviceExtendedDynamicState2FeaturesEXT deviceExtendedDynamicState2FeaturesEXT[count]; 1536 const bool isExtendedDynamicState2FeaturesEXT = checkExtension(properties, "VK_EXT_extended_dynamic_state2"); 1537 1538 for (int ndx = 0; ndx < count; ++ndx) 1539 { 1540 deMemset(&deviceExtendedDynamicState2FeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT)); 1541 deviceExtendedDynamicState2FeaturesEXT[ndx].sType = isExtendedDynamicState2FeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1542 deviceExtendedDynamicState2FeaturesEXT[ndx].pNext = DE_NULL; 1543 1544 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1545 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1546 extFeatures.pNext = &deviceExtendedDynamicState2FeaturesEXT[ndx]; 1547 1548 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1549 } 1550 1551 if (isExtendedDynamicState2FeaturesEXT) 1552 log << TestLog::Message << deviceExtendedDynamicState2FeaturesEXT[0] << TestLog::EndMessage; 1553 1554 if (isExtendedDynamicState2FeaturesEXT && 1555 (deviceExtendedDynamicState2FeaturesEXT[0].extendedDynamicState2 != deviceExtendedDynamicState2FeaturesEXT[1].extendedDynamicState2 || 1556 deviceExtendedDynamicState2FeaturesEXT[0].extendedDynamicState2LogicOp != deviceExtendedDynamicState2FeaturesEXT[1].extendedDynamicState2LogicOp || 1557 deviceExtendedDynamicState2FeaturesEXT[0].extendedDynamicState2PatchControlPoints != deviceExtendedDynamicState2FeaturesEXT[1].extendedDynamicState2PatchControlPoints)) 1558 { 1559 TCU_FAIL("Mismatch between VkPhysicalDeviceExtendedDynamicState2FeaturesEXT"); 1560 } 1561 return tcu::TestStatus::pass("Querying succeeded"); 1562} 1563 1564tcu::TestStatus testPhysicalDeviceFeatureRobustness2FeaturesEXT (Context& context) 1565{ 1566 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1567 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1568 const InstanceDriver& vki (instance.getDriver()); 1569 const int count = 2u; 1570 TestLog& log = context.getTestContext().getLog(); 1571 VkPhysicalDeviceFeatures2 extFeatures; 1572 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1573 1574 VkPhysicalDeviceRobustness2FeaturesEXT deviceRobustness2FeaturesEXT[count]; 1575 const bool isRobustness2FeaturesEXT = checkExtension(properties, "VK_EXT_robustness2"); 1576 1577 for (int ndx = 0; ndx < count; ++ndx) 1578 { 1579 deMemset(&deviceRobustness2FeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceRobustness2FeaturesEXT)); 1580 deviceRobustness2FeaturesEXT[ndx].sType = isRobustness2FeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1581 deviceRobustness2FeaturesEXT[ndx].pNext = DE_NULL; 1582 1583 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1584 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1585 extFeatures.pNext = &deviceRobustness2FeaturesEXT[ndx]; 1586 1587 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1588 } 1589 1590 if (isRobustness2FeaturesEXT) 1591 log << TestLog::Message << deviceRobustness2FeaturesEXT[0] << TestLog::EndMessage; 1592 1593 if (isRobustness2FeaturesEXT && 1594 (deviceRobustness2FeaturesEXT[0].robustBufferAccess2 != deviceRobustness2FeaturesEXT[1].robustBufferAccess2 || 1595 deviceRobustness2FeaturesEXT[0].robustImageAccess2 != deviceRobustness2FeaturesEXT[1].robustImageAccess2 || 1596 deviceRobustness2FeaturesEXT[0].nullDescriptor != deviceRobustness2FeaturesEXT[1].nullDescriptor)) 1597 { 1598 TCU_FAIL("Mismatch between VkPhysicalDeviceRobustness2FeaturesEXT"); 1599 } 1600 return tcu::TestStatus::pass("Querying succeeded"); 1601} 1602 1603tcu::TestStatus testPhysicalDeviceFeatureImageRobustnessFeaturesEXT (Context& context) 1604{ 1605 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1606 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1607 const InstanceDriver& vki (instance.getDriver()); 1608 const int count = 2u; 1609 TestLog& log = context.getTestContext().getLog(); 1610 VkPhysicalDeviceFeatures2 extFeatures; 1611 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1612 1613 VkPhysicalDeviceImageRobustnessFeaturesEXT deviceImageRobustnessFeaturesEXT[count]; 1614 const bool isImageRobustnessFeaturesEXT = checkExtension(properties, "VK_EXT_image_robustness") || context.contextSupports(vk::ApiVersion(1, 1, 3, 0)); 1615 1616 for (int ndx = 0; ndx < count; ++ndx) 1617 { 1618 deMemset(&deviceImageRobustnessFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceImageRobustnessFeaturesEXT)); 1619 deviceImageRobustnessFeaturesEXT[ndx].sType = isImageRobustnessFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1620 deviceImageRobustnessFeaturesEXT[ndx].pNext = DE_NULL; 1621 1622 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1623 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1624 extFeatures.pNext = &deviceImageRobustnessFeaturesEXT[ndx]; 1625 1626 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1627 } 1628 1629 if (isImageRobustnessFeaturesEXT) 1630 log << TestLog::Message << deviceImageRobustnessFeaturesEXT[0] << TestLog::EndMessage; 1631 1632 if (isImageRobustnessFeaturesEXT && 1633 (deviceImageRobustnessFeaturesEXT[0].robustImageAccess != deviceImageRobustnessFeaturesEXT[1].robustImageAccess)) 1634 { 1635 TCU_FAIL("Mismatch between VkPhysicalDeviceImageRobustnessFeaturesEXT"); 1636 } 1637 return tcu::TestStatus::pass("Querying succeeded"); 1638} 1639 1640tcu::TestStatus testPhysicalDeviceFeature4444FormatsFeaturesEXT (Context& context) 1641{ 1642 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1643 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1644 const InstanceDriver& vki (instance.getDriver()); 1645 const int count = 2u; 1646 TestLog& log = context.getTestContext().getLog(); 1647 VkPhysicalDeviceFeatures2 extFeatures; 1648 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1649 1650 VkPhysicalDevice4444FormatsFeaturesEXT device4444FormatsFeaturesEXT[count]; 1651 const bool is4444FormatsFeaturesEXT = checkExtension(properties, "VK_EXT_4444_formats"); 1652 1653 for (int ndx = 0; ndx < count; ++ndx) 1654 { 1655 deMemset(&device4444FormatsFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDevice4444FormatsFeaturesEXT)); 1656 device4444FormatsFeaturesEXT[ndx].sType = is4444FormatsFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1657 device4444FormatsFeaturesEXT[ndx].pNext = DE_NULL; 1658 1659 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1660 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1661 extFeatures.pNext = &device4444FormatsFeaturesEXT[ndx]; 1662 1663 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1664 } 1665 1666 if (is4444FormatsFeaturesEXT) 1667 log << TestLog::Message << device4444FormatsFeaturesEXT[0] << TestLog::EndMessage; 1668 1669 if (is4444FormatsFeaturesEXT && 1670 (device4444FormatsFeaturesEXT[0].formatA4R4G4B4 != device4444FormatsFeaturesEXT[1].formatA4R4G4B4 || 1671 device4444FormatsFeaturesEXT[0].formatA4B4G4R4 != device4444FormatsFeaturesEXT[1].formatA4B4G4R4)) 1672 { 1673 TCU_FAIL("Mismatch between VkPhysicalDevice4444FormatsFeaturesEXT"); 1674 } 1675 return tcu::TestStatus::pass("Querying succeeded"); 1676} 1677 1678tcu::TestStatus testPhysicalDeviceFeatureShaderImageAtomicInt64FeaturesEXT (Context& context) 1679{ 1680 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1681 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1682 const InstanceDriver& vki (instance.getDriver()); 1683 const int count = 2u; 1684 TestLog& log = context.getTestContext().getLog(); 1685 VkPhysicalDeviceFeatures2 extFeatures; 1686 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1687 1688 VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT deviceShaderImageAtomicInt64FeaturesEXT[count]; 1689 const bool isShaderImageAtomicInt64FeaturesEXT = checkExtension(properties, "VK_EXT_shader_image_atomic_int64"); 1690 1691 for (int ndx = 0; ndx < count; ++ndx) 1692 { 1693 deMemset(&deviceShaderImageAtomicInt64FeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT)); 1694 deviceShaderImageAtomicInt64FeaturesEXT[ndx].sType = isShaderImageAtomicInt64FeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1695 deviceShaderImageAtomicInt64FeaturesEXT[ndx].pNext = DE_NULL; 1696 1697 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1698 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1699 extFeatures.pNext = &deviceShaderImageAtomicInt64FeaturesEXT[ndx]; 1700 1701 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1702 } 1703 1704 if (isShaderImageAtomicInt64FeaturesEXT) 1705 log << TestLog::Message << deviceShaderImageAtomicInt64FeaturesEXT[0] << TestLog::EndMessage; 1706 1707 if (isShaderImageAtomicInt64FeaturesEXT && 1708 (deviceShaderImageAtomicInt64FeaturesEXT[0].shaderImageInt64Atomics != deviceShaderImageAtomicInt64FeaturesEXT[1].shaderImageInt64Atomics || 1709 deviceShaderImageAtomicInt64FeaturesEXT[0].sparseImageInt64Atomics != deviceShaderImageAtomicInt64FeaturesEXT[1].sparseImageInt64Atomics)) 1710 { 1711 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT"); 1712 } 1713 return tcu::TestStatus::pass("Querying succeeded"); 1714} 1715 1716tcu::TestStatus testPhysicalDeviceFeatureFragmentShadingRateFeaturesKHR (Context& context) 1717{ 1718 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1719 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1720 const InstanceDriver& vki (instance.getDriver()); 1721 const int count = 2u; 1722 TestLog& log = context.getTestContext().getLog(); 1723 VkPhysicalDeviceFeatures2 extFeatures; 1724 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1725 1726 VkPhysicalDeviceFragmentShadingRateFeaturesKHR deviceFragmentShadingRateFeaturesKHR[count]; 1727 const bool isFragmentShadingRateFeaturesKHR = checkExtension(properties, "VK_KHR_fragment_shading_rate"); 1728 1729 for (int ndx = 0; ndx < count; ++ndx) 1730 { 1731 deMemset(&deviceFragmentShadingRateFeaturesKHR[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceFragmentShadingRateFeaturesKHR)); 1732 deviceFragmentShadingRateFeaturesKHR[ndx].sType = isFragmentShadingRateFeaturesKHR ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR : VK_STRUCTURE_TYPE_MAX_ENUM; 1733 deviceFragmentShadingRateFeaturesKHR[ndx].pNext = DE_NULL; 1734 1735 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1736 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1737 extFeatures.pNext = &deviceFragmentShadingRateFeaturesKHR[ndx]; 1738 1739 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1740 } 1741 1742 if (isFragmentShadingRateFeaturesKHR) 1743 log << TestLog::Message << deviceFragmentShadingRateFeaturesKHR[0] << TestLog::EndMessage; 1744 1745 if (isFragmentShadingRateFeaturesKHR && 1746 (deviceFragmentShadingRateFeaturesKHR[0].pipelineFragmentShadingRate != deviceFragmentShadingRateFeaturesKHR[1].pipelineFragmentShadingRate || 1747 deviceFragmentShadingRateFeaturesKHR[0].primitiveFragmentShadingRate != deviceFragmentShadingRateFeaturesKHR[1].primitiveFragmentShadingRate || 1748 deviceFragmentShadingRateFeaturesKHR[0].attachmentFragmentShadingRate != deviceFragmentShadingRateFeaturesKHR[1].attachmentFragmentShadingRate)) 1749 { 1750 TCU_FAIL("Mismatch between VkPhysicalDeviceFragmentShadingRateFeaturesKHR"); 1751 } 1752 return tcu::TestStatus::pass("Querying succeeded"); 1753} 1754 1755tcu::TestStatus testPhysicalDeviceFeatureShaderTerminateInvocationFeaturesKHR (Context& context) 1756{ 1757 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1758 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1759 const InstanceDriver& vki (instance.getDriver()); 1760 const int count = 2u; 1761 TestLog& log = context.getTestContext().getLog(); 1762 VkPhysicalDeviceFeatures2 extFeatures; 1763 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1764 1765 VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR deviceShaderTerminateInvocationFeaturesKHR[count]; 1766 const bool isShaderTerminateInvocationFeaturesKHR = checkExtension(properties, "VK_KHR_shader_terminate_invocation") || context.contextSupports(vk::ApiVersion(1, 1, 3, 0)); 1767 1768 for (int ndx = 0; ndx < count; ++ndx) 1769 { 1770 deMemset(&deviceShaderTerminateInvocationFeaturesKHR[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR)); 1771 deviceShaderTerminateInvocationFeaturesKHR[ndx].sType = isShaderTerminateInvocationFeaturesKHR ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR : VK_STRUCTURE_TYPE_MAX_ENUM; 1772 deviceShaderTerminateInvocationFeaturesKHR[ndx].pNext = DE_NULL; 1773 1774 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1775 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1776 extFeatures.pNext = &deviceShaderTerminateInvocationFeaturesKHR[ndx]; 1777 1778 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1779 } 1780 1781 if (isShaderTerminateInvocationFeaturesKHR) 1782 log << TestLog::Message << deviceShaderTerminateInvocationFeaturesKHR[0] << TestLog::EndMessage; 1783 1784 if (isShaderTerminateInvocationFeaturesKHR && 1785 (deviceShaderTerminateInvocationFeaturesKHR[0].shaderTerminateInvocation != deviceShaderTerminateInvocationFeaturesKHR[1].shaderTerminateInvocation)) 1786 { 1787 TCU_FAIL("Mismatch between VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR"); 1788 } 1789 return tcu::TestStatus::pass("Querying succeeded"); 1790} 1791 1792tcu::TestStatus testPhysicalDeviceFeatureVertexInputDynamicStateFeaturesEXT (Context& context) 1793{ 1794 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1795 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1796 const InstanceDriver& vki (instance.getDriver()); 1797 const int count = 2u; 1798 TestLog& log = context.getTestContext().getLog(); 1799 VkPhysicalDeviceFeatures2 extFeatures; 1800 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1801 1802 VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT deviceVertexInputDynamicStateFeaturesEXT[count]; 1803 const bool isVertexInputDynamicStateFeaturesEXT = checkExtension(properties, "VK_EXT_vertex_input_dynamic_state"); 1804 1805 for (int ndx = 0; ndx < count; ++ndx) 1806 { 1807 deMemset(&deviceVertexInputDynamicStateFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT)); 1808 deviceVertexInputDynamicStateFeaturesEXT[ndx].sType = isVertexInputDynamicStateFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1809 deviceVertexInputDynamicStateFeaturesEXT[ndx].pNext = DE_NULL; 1810 1811 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1812 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1813 extFeatures.pNext = &deviceVertexInputDynamicStateFeaturesEXT[ndx]; 1814 1815 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1816 } 1817 1818 if (isVertexInputDynamicStateFeaturesEXT) 1819 log << TestLog::Message << deviceVertexInputDynamicStateFeaturesEXT[0] << TestLog::EndMessage; 1820 1821 if (isVertexInputDynamicStateFeaturesEXT && 1822 (deviceVertexInputDynamicStateFeaturesEXT[0].vertexInputDynamicState != deviceVertexInputDynamicStateFeaturesEXT[1].vertexInputDynamicState)) 1823 { 1824 TCU_FAIL("Mismatch between VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT"); 1825 } 1826 return tcu::TestStatus::pass("Querying succeeded"); 1827} 1828 1829tcu::TestStatus testPhysicalDeviceFeatureColorWriteEnableFeaturesEXT (Context& context) 1830{ 1831 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1832 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1833 const InstanceDriver& vki (instance.getDriver()); 1834 const int count = 2u; 1835 TestLog& log = context.getTestContext().getLog(); 1836 VkPhysicalDeviceFeatures2 extFeatures; 1837 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1838 1839 VkPhysicalDeviceColorWriteEnableFeaturesEXT deviceColorWriteEnableFeaturesEXT[count]; 1840 const bool isColorWriteEnableFeaturesEXT = checkExtension(properties, "VK_EXT_color_write_enable"); 1841 1842 for (int ndx = 0; ndx < count; ++ndx) 1843 { 1844 deMemset(&deviceColorWriteEnableFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceColorWriteEnableFeaturesEXT)); 1845 deviceColorWriteEnableFeaturesEXT[ndx].sType = isColorWriteEnableFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1846 deviceColorWriteEnableFeaturesEXT[ndx].pNext = DE_NULL; 1847 1848 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1849 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1850 extFeatures.pNext = &deviceColorWriteEnableFeaturesEXT[ndx]; 1851 1852 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1853 } 1854 1855 if (isColorWriteEnableFeaturesEXT) 1856 log << TestLog::Message << deviceColorWriteEnableFeaturesEXT[0] << TestLog::EndMessage; 1857 1858 if (isColorWriteEnableFeaturesEXT && 1859 (deviceColorWriteEnableFeaturesEXT[0].colorWriteEnable != deviceColorWriteEnableFeaturesEXT[1].colorWriteEnable)) 1860 { 1861 TCU_FAIL("Mismatch between VkPhysicalDeviceColorWriteEnableFeaturesEXT"); 1862 } 1863 return tcu::TestStatus::pass("Querying succeeded"); 1864} 1865 1866tcu::TestStatus testPhysicalDeviceFeatureSynchronization2FeaturesKHR (Context& context) 1867{ 1868 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1869 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1870 const InstanceDriver& vki (instance.getDriver()); 1871 const int count = 2u; 1872 TestLog& log = context.getTestContext().getLog(); 1873 VkPhysicalDeviceFeatures2 extFeatures; 1874 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1875 1876 VkPhysicalDeviceSynchronization2FeaturesKHR deviceSynchronization2FeaturesKHR[count]; 1877 const bool isSynchronization2FeaturesKHR = checkExtension(properties, "VK_KHR_synchronization2") || context.contextSupports(vk::ApiVersion(1, 1, 3, 0)); 1878 1879 for (int ndx = 0; ndx < count; ++ndx) 1880 { 1881 deMemset(&deviceSynchronization2FeaturesKHR[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceSynchronization2FeaturesKHR)); 1882 deviceSynchronization2FeaturesKHR[ndx].sType = isSynchronization2FeaturesKHR ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR : VK_STRUCTURE_TYPE_MAX_ENUM; 1883 deviceSynchronization2FeaturesKHR[ndx].pNext = DE_NULL; 1884 1885 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1886 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1887 extFeatures.pNext = &deviceSynchronization2FeaturesKHR[ndx]; 1888 1889 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1890 } 1891 1892 if (isSynchronization2FeaturesKHR) 1893 log << TestLog::Message << deviceSynchronization2FeaturesKHR[0] << TestLog::EndMessage; 1894 1895 if (isSynchronization2FeaturesKHR && 1896 (deviceSynchronization2FeaturesKHR[0].synchronization2 != deviceSynchronization2FeaturesKHR[1].synchronization2)) 1897 { 1898 TCU_FAIL("Mismatch between VkPhysicalDeviceSynchronization2FeaturesKHR"); 1899 } 1900 return tcu::TestStatus::pass("Querying succeeded"); 1901} 1902 1903tcu::TestStatus testPhysicalDeviceFeatureVulkanSC10Features (Context& context) 1904{ 1905 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1906 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1907 const InstanceDriver& vki (instance.getDriver()); 1908 const int count = 2u; 1909 TestLog& log = context.getTestContext().getLog(); 1910 VkPhysicalDeviceFeatures2 extFeatures; 1911 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1912 1913 VkPhysicalDeviceVulkanSC10Features deviceVulkanSC10Features[count]; 1914 const bool isVulkanSC10Features = context.contextSupports(vk::ApiVersion(1, 1, 0, 0)); 1915 1916 for (int ndx = 0; ndx < count; ++ndx) 1917 { 1918 deMemset(&deviceVulkanSC10Features[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceVulkanSC10Features)); 1919 deviceVulkanSC10Features[ndx].sType = isVulkanSC10Features ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES : VK_STRUCTURE_TYPE_MAX_ENUM; 1920 deviceVulkanSC10Features[ndx].pNext = DE_NULL; 1921 1922 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1923 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1924 extFeatures.pNext = &deviceVulkanSC10Features[ndx]; 1925 1926 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1927 } 1928 1929 if (isVulkanSC10Features) 1930 log << TestLog::Message << deviceVulkanSC10Features[0] << TestLog::EndMessage; 1931 1932 if (isVulkanSC10Features && 1933 (deviceVulkanSC10Features[0].shaderAtomicInstructions != deviceVulkanSC10Features[1].shaderAtomicInstructions)) 1934 { 1935 TCU_FAIL("Mismatch between VkPhysicalDeviceVulkanSC10Features"); 1936 } 1937 return tcu::TestStatus::pass("Querying succeeded"); 1938} 1939 1940tcu::TestStatus testPhysicalDeviceFeatureYcbcr2Plane444FormatsFeaturesEXT (Context& context) 1941{ 1942 const VkPhysicalDevice physicalDevice = context.getPhysicalDevice(); 1943 const CustomInstance instance (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2")); 1944 const InstanceDriver& vki (instance.getDriver()); 1945 const int count = 2u; 1946 TestLog& log = context.getTestContext().getLog(); 1947 VkPhysicalDeviceFeatures2 extFeatures; 1948 vector<VkExtensionProperties> properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL); 1949 1950 VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT deviceYcbcr2Plane444FormatsFeaturesEXT[count]; 1951 const bool isYcbcr2Plane444FormatsFeaturesEXT = checkExtension(properties, "VK_EXT_ycbcr_2plane_444_formats"); 1952 1953 for (int ndx = 0; ndx < count; ++ndx) 1954 { 1955 deMemset(&deviceYcbcr2Plane444FormatsFeaturesEXT[ndx], 0xFF * ndx, sizeof(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT)); 1956 deviceYcbcr2Plane444FormatsFeaturesEXT[ndx].sType = isYcbcr2Plane444FormatsFeaturesEXT ? VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT : VK_STRUCTURE_TYPE_MAX_ENUM; 1957 deviceYcbcr2Plane444FormatsFeaturesEXT[ndx].pNext = DE_NULL; 1958 1959 deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features)); 1960 extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; 1961 extFeatures.pNext = &deviceYcbcr2Plane444FormatsFeaturesEXT[ndx]; 1962 1963 vki.getPhysicalDeviceFeatures2(physicalDevice, &extFeatures); 1964 } 1965 1966 if (isYcbcr2Plane444FormatsFeaturesEXT) 1967 log << TestLog::Message << deviceYcbcr2Plane444FormatsFeaturesEXT[0] << TestLog::EndMessage; 1968 1969 if (isYcbcr2Plane444FormatsFeaturesEXT && 1970 (deviceYcbcr2Plane444FormatsFeaturesEXT[0].ycbcr2plane444Formats != deviceYcbcr2Plane444FormatsFeaturesEXT[1].ycbcr2plane444Formats)) 1971 { 1972 TCU_FAIL("Mismatch between VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT"); 1973 } 1974 return tcu::TestStatus::pass("Querying succeeded"); 1975} 1976 1977void addSeparateFeatureTests (tcu::TestCaseGroup* testGroup) 1978{ 1979 addFunctionCase(testGroup, "variable_pointers_features", testPhysicalDeviceFeatureVariablePointersFeatures); 1980 addFunctionCase(testGroup, "multiview_features", testPhysicalDeviceFeatureMultiviewFeatures); 1981 addFunctionCase(testGroup, "16_bit_storage_features", testPhysicalDeviceFeature16BitStorageFeatures); 1982 addFunctionCase(testGroup, "shader_subgroup_extended_types_features", testPhysicalDeviceFeatureShaderSubgroupExtendedTypesFeatures); 1983 addFunctionCase(testGroup, "sampler_ycbcr_conversion_features", testPhysicalDeviceFeatureSamplerYcbcrConversionFeatures); 1984 addFunctionCase(testGroup, "protected_memory_features", testPhysicalDeviceFeatureProtectedMemoryFeatures); 1985 addFunctionCase(testGroup, "blend_operation_advanced_features_ext", testPhysicalDeviceFeatureBlendOperationAdvancedFeaturesEXT); 1986 addFunctionCase(testGroup, "shader_draw_parameters_features", testPhysicalDeviceFeatureShaderDrawParametersFeatures); 1987 addFunctionCase(testGroup, "shader_float16_int8_features", testPhysicalDeviceFeatureShaderFloat16Int8Features); 1988 addFunctionCase(testGroup, "host_query_reset_features", testPhysicalDeviceFeatureHostQueryResetFeatures); 1989 addFunctionCase(testGroup, "descriptor_indexing_features", testPhysicalDeviceFeatureDescriptorIndexingFeatures); 1990 addFunctionCase(testGroup, "timeline_semaphore_features", testPhysicalDeviceFeatureTimelineSemaphoreFeatures); 1991 addFunctionCase(testGroup, "8_bit_storage_features", testPhysicalDeviceFeature8BitStorageFeatures); 1992 addFunctionCase(testGroup, "vulkan_memory_model_features", testPhysicalDeviceFeatureVulkanMemoryModelFeatures); 1993 addFunctionCase(testGroup, "shader_atomic_int64_features", testPhysicalDeviceFeatureShaderAtomicInt64Features); 1994 addFunctionCase(testGroup, "shader_atomic_float_features_ext", testPhysicalDeviceFeatureShaderAtomicFloatFeaturesEXT); 1995 addFunctionCase(testGroup, "vertex_attribute_divisor_features_ext", testPhysicalDeviceFeatureVertexAttributeDivisorFeaturesEXT); 1996 addFunctionCase(testGroup, "astc_decode_features_ext", testPhysicalDeviceFeatureASTCDecodeFeaturesEXT); 1997 addFunctionCase(testGroup, "scalar_block_layout_features", testPhysicalDeviceFeatureScalarBlockLayoutFeatures); 1998 addFunctionCase(testGroup, "uniform_buffer_standard_layout_features", testPhysicalDeviceFeatureUniformBufferStandardLayoutFeatures); 1999 addFunctionCase(testGroup, "depth_clip_enable_features_ext", testPhysicalDeviceFeatureDepthClipEnableFeaturesEXT); 2000 addFunctionCase(testGroup, "buffer_device_address_features", testPhysicalDeviceFeatureBufferDeviceAddressFeatures); 2001 addFunctionCase(testGroup, "imageless_framebuffer_features", testPhysicalDeviceFeatureImagelessFramebufferFeatures); 2002 addFunctionCase(testGroup, "texture_compression_astchdr_features_ext", testPhysicalDeviceFeatureTextureCompressionASTCHDRFeaturesEXT); 2003 addFunctionCase(testGroup, "ycbcr_image_arrays_features_ext", testPhysicalDeviceFeatureYcbcrImageArraysFeaturesEXT); 2004 addFunctionCase(testGroup, "performance_query_features_khr", testPhysicalDeviceFeaturePerformanceQueryFeaturesKHR); 2005 addFunctionCase(testGroup, "shader_clock_features_khr", testPhysicalDeviceFeatureShaderClockFeaturesKHR); 2006 addFunctionCase(testGroup, "index_type_uint8_features_ext", testPhysicalDeviceFeatureIndexTypeUint8FeaturesEXT); 2007 addFunctionCase(testGroup, "fragment_shader_interlock_features_ext", testPhysicalDeviceFeatureFragmentShaderInterlockFeaturesEXT); 2008 addFunctionCase(testGroup, "separate_depth_stencil_layouts_features", testPhysicalDeviceFeatureSeparateDepthStencilLayoutsFeatures); 2009 addFunctionCase(testGroup, "shader_demote_to_helper_invocation_features_ext", testPhysicalDeviceFeatureShaderDemoteToHelperInvocationFeaturesEXT); 2010 addFunctionCase(testGroup, "texel_buffer_alignment_features_ext", testPhysicalDeviceFeatureTexelBufferAlignmentFeaturesEXT); 2011 addFunctionCase(testGroup, "subgroup_size_control_features_ext", testPhysicalDeviceFeatureSubgroupSizeControlFeaturesEXT); 2012 addFunctionCase(testGroup, "line_rasterization_features_ext", testPhysicalDeviceFeatureLineRasterizationFeaturesEXT); 2013 addFunctionCase(testGroup, "vulkan11_features", testPhysicalDeviceFeatureVulkan11Features); 2014 addFunctionCase(testGroup, "vulkan12_features", testPhysicalDeviceFeatureVulkan12Features); 2015 addFunctionCase(testGroup, "custom_border_color_features_ext", testPhysicalDeviceFeatureCustomBorderColorFeaturesEXT); 2016 addFunctionCase(testGroup, "extended_dynamic_state_features_ext", testPhysicalDeviceFeatureExtendedDynamicStateFeaturesEXT); 2017 addFunctionCase(testGroup, "extended_dynamic_state2_features_ext", testPhysicalDeviceFeatureExtendedDynamicState2FeaturesEXT); 2018 addFunctionCase(testGroup, "robustness2_features_ext", testPhysicalDeviceFeatureRobustness2FeaturesEXT); 2019 addFunctionCase(testGroup, "image_robustness_features_ext", testPhysicalDeviceFeatureImageRobustnessFeaturesEXT); 2020 addFunctionCase(testGroup, "4444_formats_features_ext", testPhysicalDeviceFeature4444FormatsFeaturesEXT); 2021 addFunctionCase(testGroup, "shader_image_atomic_int64_features_ext", testPhysicalDeviceFeatureShaderImageAtomicInt64FeaturesEXT); 2022 addFunctionCase(testGroup, "fragment_shading_rate_features_khr", testPhysicalDeviceFeatureFragmentShadingRateFeaturesKHR); 2023 addFunctionCase(testGroup, "shader_terminate_invocation_features_khr", testPhysicalDeviceFeatureShaderTerminateInvocationFeaturesKHR); 2024 addFunctionCase(testGroup, "vertex_input_dynamic_state_features_ext", testPhysicalDeviceFeatureVertexInputDynamicStateFeaturesEXT); 2025 addFunctionCase(testGroup, "color_write_enable_features_ext", testPhysicalDeviceFeatureColorWriteEnableFeaturesEXT); 2026 addFunctionCase(testGroup, "synchronization2_features_khr", testPhysicalDeviceFeatureSynchronization2FeaturesKHR); 2027 addFunctionCase(testGroup, "vulkan_sc10_features", testPhysicalDeviceFeatureVulkanSC10Features); 2028 addFunctionCase(testGroup, "ycbcr2_plane444_formats_features_ext", testPhysicalDeviceFeatureYcbcr2Plane444FormatsFeaturesEXT); 2029} 2030 2031