1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2016 The Khronos Group Inc.
6 * Copyright (c) 2016 The Android Open Source Project
7 *
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 *
20 *//*!
21 * \file
22 * \brief Memory qualifiers tests
23 *//*--------------------------------------------------------------------*/
24
25 #include "vktImageExtendedUsageBitTests.hpp"
26
27 #include "vkRef.hpp"
28 #include "vkQueryUtil.hpp"
29 #include "vktTestCaseUtil.hpp"
30 #include "vktImageTestsUtil.hpp"
31
32 #include "tcuTestLog.hpp"
33
34 using namespace vk;
35
36 namespace vkt
37 {
38 namespace image
39 {
40 namespace
41 {
42
isCompatibleCompressedFormat(VkFormat format0,VkFormat format1)43 bool isCompatibleCompressedFormat(VkFormat format0, VkFormat format1)
44 {
45 DE_ASSERT(isCompressedFormat(format0) && isCompressedFormat(format1));
46 // update this mapping if VkFormat changes
47 DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185);
48
49 bool result = false;
50
51 std::map<VkFormat, VkFormat> map = {
52 {VK_FORMAT_BC1_RGB_UNORM_BLOCK, VK_FORMAT_BC1_RGB_SRGB_BLOCK},
53 {VK_FORMAT_BC1_RGB_SRGB_BLOCK, VK_FORMAT_BC1_RGB_UNORM_BLOCK},
54 {VK_FORMAT_BC1_RGBA_UNORM_BLOCK, VK_FORMAT_BC1_RGBA_SRGB_BLOCK},
55 {VK_FORMAT_BC1_RGBA_SRGB_BLOCK, VK_FORMAT_BC1_RGBA_UNORM_BLOCK},
56 {VK_FORMAT_BC2_UNORM_BLOCK, VK_FORMAT_BC2_SRGB_BLOCK},
57 {VK_FORMAT_BC2_SRGB_BLOCK, VK_FORMAT_BC2_UNORM_BLOCK},
58 {VK_FORMAT_BC3_UNORM_BLOCK, VK_FORMAT_BC3_SRGB_BLOCK},
59 {VK_FORMAT_BC3_SRGB_BLOCK, VK_FORMAT_BC3_UNORM_BLOCK},
60 {VK_FORMAT_BC4_UNORM_BLOCK, VK_FORMAT_BC4_SNORM_BLOCK},
61 {VK_FORMAT_BC4_SNORM_BLOCK, VK_FORMAT_BC4_UNORM_BLOCK},
62 {VK_FORMAT_BC5_UNORM_BLOCK, VK_FORMAT_BC5_SNORM_BLOCK},
63 {VK_FORMAT_BC5_SNORM_BLOCK, VK_FORMAT_BC5_UNORM_BLOCK},
64 {VK_FORMAT_BC7_UNORM_BLOCK, VK_FORMAT_BC7_SRGB_BLOCK},
65 {VK_FORMAT_BC7_SRGB_BLOCK, VK_FORMAT_BC7_UNORM_BLOCK},
66 {VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK},
67 {VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK},
68 {VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK},
69 {VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK},
70 {VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK},
71 {VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK},
72 {VK_FORMAT_EAC_R11_UNORM_BLOCK, VK_FORMAT_EAC_R11_SNORM_BLOCK},
73 {VK_FORMAT_EAC_R11_SNORM_BLOCK, VK_FORMAT_EAC_R11_UNORM_BLOCK},
74 {VK_FORMAT_EAC_R11G11_UNORM_BLOCK, VK_FORMAT_EAC_R11G11_SNORM_BLOCK},
75 {VK_FORMAT_EAC_R11G11_SNORM_BLOCK, VK_FORMAT_EAC_R11G11_UNORM_BLOCK},
76 {VK_FORMAT_ASTC_4x4_UNORM_BLOCK, VK_FORMAT_ASTC_4x4_SRGB_BLOCK},
77 {VK_FORMAT_ASTC_4x4_SRGB_BLOCK, VK_FORMAT_ASTC_4x4_UNORM_BLOCK},
78 {VK_FORMAT_ASTC_5x4_UNORM_BLOCK, VK_FORMAT_ASTC_5x4_SRGB_BLOCK},
79 {VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_FORMAT_ASTC_5x4_UNORM_BLOCK},
80 {VK_FORMAT_ASTC_5x5_UNORM_BLOCK, VK_FORMAT_ASTC_5x5_SRGB_BLOCK},
81 {VK_FORMAT_ASTC_5x5_SRGB_BLOCK, VK_FORMAT_ASTC_5x5_UNORM_BLOCK},
82 {VK_FORMAT_ASTC_6x5_UNORM_BLOCK, VK_FORMAT_ASTC_6x5_SRGB_BLOCK},
83 {VK_FORMAT_ASTC_6x5_SRGB_BLOCK, VK_FORMAT_ASTC_6x5_UNORM_BLOCK},
84 {VK_FORMAT_ASTC_6x6_UNORM_BLOCK, VK_FORMAT_ASTC_6x6_SRGB_BLOCK},
85 {VK_FORMAT_ASTC_6x6_SRGB_BLOCK, VK_FORMAT_ASTC_6x6_UNORM_BLOCK},
86 {VK_FORMAT_ASTC_8x5_UNORM_BLOCK, VK_FORMAT_ASTC_8x5_SRGB_BLOCK},
87 {VK_FORMAT_ASTC_8x5_SRGB_BLOCK, VK_FORMAT_ASTC_8x5_UNORM_BLOCK},
88 {VK_FORMAT_ASTC_8x6_UNORM_BLOCK, VK_FORMAT_ASTC_8x6_SRGB_BLOCK},
89 {VK_FORMAT_ASTC_8x6_SRGB_BLOCK, VK_FORMAT_ASTC_8x6_UNORM_BLOCK},
90 {VK_FORMAT_ASTC_8x8_UNORM_BLOCK, VK_FORMAT_ASTC_8x8_SRGB_BLOCK},
91 {VK_FORMAT_ASTC_8x8_SRGB_BLOCK, VK_FORMAT_ASTC_8x8_UNORM_BLOCK},
92 {VK_FORMAT_ASTC_10x5_UNORM_BLOCK, VK_FORMAT_ASTC_10x5_SRGB_BLOCK},
93 {VK_FORMAT_ASTC_10x5_SRGB_BLOCK, VK_FORMAT_ASTC_10x5_UNORM_BLOCK},
94 {VK_FORMAT_ASTC_10x6_UNORM_BLOCK, VK_FORMAT_ASTC_10x6_SRGB_BLOCK},
95 {VK_FORMAT_ASTC_10x6_SRGB_BLOCK, VK_FORMAT_ASTC_10x6_UNORM_BLOCK},
96 {VK_FORMAT_ASTC_10x8_UNORM_BLOCK, VK_FORMAT_ASTC_10x8_SRGB_BLOCK},
97 {VK_FORMAT_ASTC_10x8_SRGB_BLOCK, VK_FORMAT_ASTC_10x8_UNORM_BLOCK},
98 {VK_FORMAT_ASTC_10x10_UNORM_BLOCK, VK_FORMAT_ASTC_10x10_SRGB_BLOCK},
99 {VK_FORMAT_ASTC_10x10_SRGB_BLOCK, VK_FORMAT_ASTC_10x10_UNORM_BLOCK},
100 {VK_FORMAT_ASTC_12x10_UNORM_BLOCK, VK_FORMAT_ASTC_12x10_SRGB_BLOCK},
101 {VK_FORMAT_ASTC_12x10_SRGB_BLOCK, VK_FORMAT_ASTC_12x10_UNORM_BLOCK},
102 {VK_FORMAT_ASTC_12x12_UNORM_BLOCK, VK_FORMAT_ASTC_12x12_SRGB_BLOCK},
103 {VK_FORMAT_ASTC_12x12_SRGB_BLOCK, VK_FORMAT_ASTC_12x12_UNORM_BLOCK},
104 };
105
106 if (map.find(format1) != map.end() && map.find(format1)->second == format0)
107 result = true;
108
109 return result;
110 }
111
isCompatibleFormat(VkFormat format0,VkFormat format1)112 bool isCompatibleFormat(VkFormat format0, VkFormat format1)
113 {
114 if (format0 == format1)
115 return true;
116
117 // Uncompressed color formats are compatible with each other if they occupy the same number of bits per texel block.
118 if (!isDepthStencilFormat(format0) && !isCompressedFormat(format0) && !isDepthStencilFormat(format1) &&
119 !isCompressedFormat(format1) && mapVkFormat(format0).getPixelSize() == mapVkFormat(format1).getPixelSize())
120 return true;
121
122 if (isCompressedFormat(format0) && isCompressedFormat(format1) && isCompatibleCompressedFormat(format0, format1))
123 return true;
124
125 return false;
126 }
127
128 struct TestParams
129 {
130 VkFormat imageFormat;
131 VkImageUsageFlags usage;
132 VkImageTiling tiling;
133 };
134
135 class PhysicalDeviceImageFormatProperties
136 {
137 public:
~PhysicalDeviceImageFormatProperties()138 virtual ~PhysicalDeviceImageFormatProperties()
139 {
140 }
141
getPhysicalDeviceImageFormatProperties(const InstanceInterface & vki,VkPhysicalDevice device,VkFormat viewFormat,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags)142 virtual VkResult getPhysicalDeviceImageFormatProperties(const InstanceInterface &vki, VkPhysicalDevice device,
143 VkFormat viewFormat, VkImageTiling tiling,
144 VkImageUsageFlags usage, VkImageCreateFlags flags)
145 {
146 VkImageFormatProperties formatProperties;
147 return vki.getPhysicalDeviceImageFormatProperties(device, viewFormat, VK_IMAGE_TYPE_2D, tiling, usage, flags,
148 &formatProperties);
149 }
150 };
151
152 class PhysicalDeviceImageFormatProperties2 : public PhysicalDeviceImageFormatProperties
153 {
154 public:
getPhysicalDeviceImageFormatProperties(const InstanceInterface & vki,VkPhysicalDevice device,VkFormat viewFormat,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags)155 virtual VkResult getPhysicalDeviceImageFormatProperties(const InstanceInterface &vki, VkPhysicalDevice device,
156 VkFormat viewFormat, VkImageTiling tiling,
157 VkImageUsageFlags usage, VkImageCreateFlags flags)
158 {
159 VkImageFormatProperties2 formatProperties2 = initVulkanStructure();
160 VkPhysicalDeviceImageFormatInfo2 imageFormatInfo2 = {
161 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, // VkStructureType sType
162 DE_NULL, // const void* pNext
163 viewFormat, // VkFormat format
164 VK_IMAGE_TYPE_2D, // VkImageType type
165 tiling, // VkImageTiling tiling
166 usage, // VkImageUsageFlags usage
167 flags // VkImageCreateFlags flags
168 };
169 return vki.getPhysicalDeviceImageFormatProperties2(device, &imageFormatInfo2, &formatProperties2);
170 }
171 };
172
173 class PhysicalDeviceImageFormatList : public PhysicalDeviceImageFormatProperties
174 {
175 public:
getPhysicalDeviceImageFormatProperties(const InstanceInterface & vki,VkPhysicalDevice device,VkFormat viewFormat,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags)176 virtual VkResult getPhysicalDeviceImageFormatProperties(const InstanceInterface &vki, VkPhysicalDevice device,
177 VkFormat viewFormat, VkImageTiling tiling,
178 VkImageUsageFlags usage, VkImageCreateFlags flags)
179 {
180 vk::VkImageFormatListCreateInfo imageFormatList = {
181 vk::VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, // VkStructureType sType;
182 DE_NULL, // const void* pNext;
183 1u, // uint32_t viewFormatCount;
184 &viewFormat, // const VkFormat* pViewFormats;
185 };
186 VkImageFormatProperties2 formatProperties2 = initVulkanStructure();
187 VkPhysicalDeviceImageFormatInfo2 imageFormatInfo2 = {
188 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, // VkStructureType sType
189 &imageFormatList, // const void* pNext
190 viewFormat, // VkFormat format
191 VK_IMAGE_TYPE_2D, // VkImageType type
192 tiling, // VkImageTiling tiling
193 usage, // VkImageUsageFlags usage
194 flags // VkImageCreateFlags flags
195 };
196 return vki.getPhysicalDeviceImageFormatProperties2(device, &imageFormatInfo2, &formatProperties2);
197 }
198 };
199
200 template <typename T>
testExtendedUsageBitCompatiblity(Context & context,TestParams params)201 tcu::TestStatus testExtendedUsageBitCompatiblity(Context &context, TestParams params)
202 {
203 T func;
204 VkFormat viewFormat;
205 VkResult expected = VK_ERROR_FORMAT_NOT_SUPPORTED;
206 const InstanceInterface &vki = context.getInstanceInterface();
207
208 for (viewFormat = (VkFormat)(VK_FORMAT_UNDEFINED + 1); viewFormat < VK_CORE_FORMAT_LAST;
209 viewFormat = (VkFormat)(viewFormat + 1))
210 {
211 if (!isCompatibleFormat((VkFormat)viewFormat, params.imageFormat))
212 continue;
213
214 if (func.getPhysicalDeviceImageFormatProperties(vki, context.getPhysicalDevice(), (VkFormat)viewFormat,
215 params.tiling, params.usage, 0) == VK_SUCCESS)
216 {
217 expected = VK_SUCCESS;
218 break;
219 }
220 }
221
222 // No compatible view format supports the tested usage.
223 if (viewFormat == VK_CORE_FORMAT_LAST)
224 {
225 std::ostringstream error;
226 error << "Usage is not supported by any compatible format";
227 throw tcu::NotSupportedError(error.str().c_str());
228 }
229
230 VkResult res = func.getPhysicalDeviceImageFormatProperties(
231 vki, context.getPhysicalDevice(), params.imageFormat, params.tiling, params.usage,
232 VK_IMAGE_CREATE_EXTENDED_USAGE_BIT | VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT);
233
234 if (res != expected)
235 {
236 std::ostringstream error;
237 error << "Fail: view format " << getFormatStr(viewFormat);
238 return tcu::TestStatus::fail(error.str().c_str());
239 }
240
241 return tcu::TestStatus::pass("Pass");
242 }
243
checkSupport(Context & context,TestParams params)244 void checkSupport(Context &context, TestParams params)
245 {
246 context.requireDeviceFunctionality("VK_KHR_maintenance2");
247
248 VkFormatProperties formatProperties;
249 context.getInstanceInterface().getPhysicalDeviceFormatProperties(context.getPhysicalDevice(), params.imageFormat,
250 &formatProperties);
251
252 if (params.tiling == vk::VK_IMAGE_TILING_OPTIMAL && formatProperties.optimalTilingFeatures == 0)
253 throw tcu::NotSupportedError("Format not supported");
254
255 if (params.tiling == vk::VK_IMAGE_TILING_LINEAR && formatProperties.linearTilingFeatures == 0)
256 throw tcu::NotSupportedError("Format not supported");
257
258 #ifndef CTS_USES_VULKANSC
259 if (params.usage & VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR ||
260 params.usage & VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR ||
261 params.usage & VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR)
262 context.requireDeviceFunctionality("VK_KHR_video_decode_queue");
263
264 if (params.usage & VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR ||
265 params.usage & VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR ||
266 params.usage & VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR)
267 context.requireDeviceFunctionality("VK_KHR_video_encode_queue");
268
269 if (params.usage & VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT)
270 context.requireDeviceFunctionality("VK_EXT_fragment_density_map");
271
272 if (params.usage & VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR)
273 context.requireDeviceFunctionality("VK_KHR_fragment_shading_rate");
274
275 if (params.usage & VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI)
276 context.requireDeviceFunctionality("VK_HUAWEI_invocation_mask");
277 #endif // CTS_USES_VULKANSC
278 }
279
280 } // namespace
281
createImageExtendedUsageBitTests(tcu::TestContext & testCtx)282 tcu::TestCaseGroup *createImageExtendedUsageBitTests(tcu::TestContext &testCtx)
283 {
284 de::MovePtr<tcu::TestCaseGroup> imageExtendedUsageBitTests(
285 new tcu::TestCaseGroup(testCtx, "extended_usage_bit_compatibility"));
286 de::MovePtr<tcu::TestCaseGroup> getPhysicalDeviceImageFormatPropertiesTests(
287 new tcu::TestCaseGroup(testCtx, "image_format_properties"));
288 de::MovePtr<tcu::TestCaseGroup> getPhysicalDeviceImageFormatProperties2Tests(
289 new tcu::TestCaseGroup(testCtx, "image_format_properties2"));
290 de::MovePtr<tcu::TestCaseGroup> getPhysicalDeviceImageFormatListTests(
291 new tcu::TestCaseGroup(testCtx, "image_format_list"));
292
293 struct ImageUsageFlags
294 {
295 VkImageUsageFlags usage;
296 const char *name;
297 };
298
299 ImageUsageFlags usages[] = {
300 {VK_IMAGE_USAGE_TRANSFER_SRC_BIT, "VK_IMAGE_USAGE_TRANSFER_SRC_BIT"},
301 {VK_IMAGE_USAGE_TRANSFER_DST_BIT, "VK_IMAGE_USAGE_TRANSFER_DST_BIT"},
302 {VK_IMAGE_USAGE_SAMPLED_BIT, "VK_IMAGE_USAGE_SAMPLED_BIT"},
303 {VK_IMAGE_USAGE_STORAGE_BIT, "VK_IMAGE_USAGE_STORAGE_BIT"},
304 {VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, "VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT"},
305 {VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, "VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT"},
306 {VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT"},
307 {VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT"},
308 #ifndef CTS_USES_VULKANSC
309 {VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR, "VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR"},
310 {VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR, "VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR"},
311 {VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR, "VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR"},
312 {VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, "VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT"},
313 {VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
314 "VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"},
315 {VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR, "VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR"},
316 {VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR, "VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR"},
317 {VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR, "VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR"},
318 {VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI, "VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI"},
319 {VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, "VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV"},
320 #endif // CTS_USES_VULKANSC
321 };
322
323 struct TilingParams
324 {
325 VkImageTiling tiling;
326 const char *name;
327 };
328 TilingParams tiling[] = {{VK_IMAGE_TILING_LINEAR, "linear"}, {VK_IMAGE_TILING_OPTIMAL, "optimal"}};
329
330 for (VkFormat imageFormat = (VkFormat)(VK_FORMAT_UNDEFINED + 1); imageFormat < VK_CORE_FORMAT_LAST;
331 imageFormat = (VkFormat)(imageFormat + 1))
332 {
333 for (unsigned tilingNdx = 0; tilingNdx < DE_LENGTH_OF_ARRAY(tiling); tilingNdx++)
334 {
335 for (unsigned usageNdx = 0; usageNdx < DE_LENGTH_OF_ARRAY(usages); usageNdx++)
336 {
337 struct TestParams params = {imageFormat, usages[usageNdx].usage, tiling[tilingNdx].tiling};
338 std::ostringstream name;
339 std::string usageName = usages[usageNdx].name;
340 name << getFormatShortString(imageFormat) << "_" << tiling[tilingNdx].name << "_"
341 << de::toLower(usageName.substr(15));
342 // Checks usage bit format compatibility among compatible image view formats
343 addFunctionCase(getPhysicalDeviceImageFormatPropertiesTests.get(), name.str().c_str(), checkSupport,
344 testExtendedUsageBitCompatiblity<PhysicalDeviceImageFormatProperties>, params);
345 addFunctionCase(getPhysicalDeviceImageFormatProperties2Tests.get(), name.str().c_str(), checkSupport,
346 testExtendedUsageBitCompatiblity<PhysicalDeviceImageFormatProperties2>, params);
347 addFunctionCase(getPhysicalDeviceImageFormatListTests.get(), name.str().c_str(), checkSupport,
348 testExtendedUsageBitCompatiblity<PhysicalDeviceImageFormatList>, params);
349 }
350 }
351 }
352
353 imageExtendedUsageBitTests->addChild(getPhysicalDeviceImageFormatPropertiesTests.release());
354 imageExtendedUsageBitTests->addChild(getPhysicalDeviceImageFormatProperties2Tests.release());
355 imageExtendedUsageBitTests->addChild(getPhysicalDeviceImageFormatListTests.release());
356 return imageExtendedUsageBitTests.release();
357 }
358
359 } // namespace image
360 } // namespace vkt
361