1 /*
2  * Copyright (c) 2021-2022 The Khronos Group Inc.
3  * Copyright (c) 2021-2022 Valve Corporation
4  * Copyright (c) 2021-2022 LunarG, Inc.
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and/or associated documentation files (the "Materials"), to
8  * deal in the Materials without restriction, including without limitation the
9  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10  * sell copies of the Materials, and to permit persons to whom the Materials are
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice(s) and this permission notice shall be included in
14  * all copies or substantial portions of the Materials.
15  *
16  * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19  *
20  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
21  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
22  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE
23  * USE OR OTHER DEALINGS IN THE MATERIALS.
24  *
25  * Author(s): Charles Giessen <charles@lunarg.com>
26  *            Mark Young <marky@lunarg.com>
27  */
28 
29 #include "test_environment.h"
30 
31 // ---- Invalid Instance tests
32 
33 struct BadData {
34     uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
35 };
36 template <typename T>
get_bad_handle()37 T get_bad_handle() {
38     static BadData my_bad_data;
39     return reinterpret_cast<T>(static_cast<void*>(&my_bad_data));
40 }
41 
TEST(LoaderHandleValidTests, BadInstEnumPhysDevices)42 TEST(LoaderHandleValidTests, BadInstEnumPhysDevices) {
43     FrameworkEnvironment env{};
44     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
45 
46     InstWrapper instance(env.vulkan_functions);
47     instance.CheckCreate();
48 
49     auto bad_instance = get_bad_handle<VkInstance>();
50     uint32_t returned_physical_count = 0;
51 
52     ASSERT_DEATH(env.vulkan_functions.vkEnumeratePhysicalDevices(bad_instance, &returned_physical_count, nullptr),
53                  "vkEnumeratePhysicalDevices: Invalid instance \\[VUID-vkEnumeratePhysicalDevices-instance-parameter\\]");
54 }
55 
TEST(LoaderHandleValidTests, BadInstGetInstProcAddr)56 TEST(LoaderHandleValidTests, BadInstGetInstProcAddr) {
57     FrameworkEnvironment env{};
58     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
59 
60     InstWrapper instance(env.vulkan_functions);
61     instance.CheckCreate();
62 
63     auto bad_instance = get_bad_handle<VkInstance>();
64     ASSERT_DEATH(env.vulkan_functions.vkGetInstanceProcAddr(bad_instance, "vkGetBufferDeviceAddress"),
65                  "vkGetInstanceProcAddr: Invalid instance \\[VUID-vkGetInstanceProcAddr-instance-parameter\\]");
66 }
67 
TEST(LoaderHandleValidTests, BadInstDestroyInstance)68 TEST(LoaderHandleValidTests, BadInstDestroyInstance) {
69     FrameworkEnvironment env{};
70     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");
71 
72     InstWrapper instance(env.vulkan_functions);
73     instance.CheckCreate();
74 
75     auto bad_instance = get_bad_handle<VkInstance>();
76 
77     ASSERT_DEATH(env.vulkan_functions.vkDestroyInstance(bad_instance, nullptr),
78                  "vkDestroyInstance: Invalid instance \\[VUID-vkDestroyInstance-instance-parameter\\]");
79 }
80 
TEST(LoaderHandleValidTests, BadInstDestroySurface)81 TEST(LoaderHandleValidTests, BadInstDestroySurface) {
82     FrameworkEnvironment env{};
83     Extension first_ext{"VK_KHR_surface"};
84     Extension second_ext{"VK_EXT_headless_surface"};
85     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
86         .add_instance_extensions({first_ext, second_ext})
87         .add_physical_device("physical_device_0");
88 
89     InstWrapper instance(env.vulkan_functions);
90     instance.create_info.add_extension(first_ext.extensionName.c_str());
91     instance.CheckCreate();
92 
93     auto bad_instance = get_bad_handle<VkInstance>();
94 
95     ASSERT_DEATH(env.vulkan_functions.vkDestroySurfaceKHR(bad_instance, VK_NULL_HANDLE, nullptr),
96                  "vkDestroySurfaceKHR: Invalid instance \\[VUID-vkDestroySurfaceKHR-instance-parameter\\]");
97 }
98 
TEST(LoaderHandleValidTests, BadInstCreateHeadlessSurf)99 TEST(LoaderHandleValidTests, BadInstCreateHeadlessSurf) {
100     FrameworkEnvironment env{};
101     Extension first_ext{"VK_KHR_surface"};
102     Extension second_ext{"VK_EXT_headless_surface"};
103     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
104         .add_instance_extensions({first_ext, second_ext})
105         .add_physical_device("physical_device_0");
106 
107     InstWrapper instance(env.vulkan_functions);
108     instance.create_info.add_extensions({first_ext.extensionName.c_str(), second_ext.extensionName.c_str()});
109     instance.CheckCreate();
110 
111     auto bad_instance = get_bad_handle<VkInstance>();
112 
113     VkHeadlessSurfaceCreateInfoEXT surf_create_info = {};
114     surf_create_info.sType = VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT;
115     surf_create_info.pNext = nullptr;
116     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
117     ASSERT_DEATH(env.vulkan_functions.vkCreateHeadlessSurfaceEXT(bad_instance, &surf_create_info, nullptr, &created_surface),
118                  "vkCreateHeadlessSurfaceEXT: Invalid instance \\[VUID-vkCreateHeadlessSurfaceEXT-instance-parameter\\]");
119 }
120 
TEST(LoaderHandleValidTests, BadInstCreateDisplayPlaneSurf)121 TEST(LoaderHandleValidTests, BadInstCreateDisplayPlaneSurf) {
122     FrameworkEnvironment env{};
123     Extension first_ext{"VK_KHR_surface"};
124     Extension second_ext{"VK_KHR_display"};
125     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
126         .add_instance_extensions({first_ext, second_ext})
127         .add_physical_device("physical_device_0");
128 
129     InstWrapper instance(env.vulkan_functions);
130     instance.create_info.add_extensions({first_ext.extensionName.c_str(), second_ext.extensionName.c_str()});
131     instance.CheckCreate();
132 
133     auto bad_instance = get_bad_handle<VkInstance>();
134 
135     VkDisplaySurfaceCreateInfoKHR surf_create_info = {};
136     surf_create_info.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
137     surf_create_info.pNext = nullptr;
138     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
139     ASSERT_DEATH(env.vulkan_functions.vkCreateDisplayPlaneSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
140                  "vkCreateDisplayPlaneSurfaceKHR: Invalid instance \\[VUID-vkCreateDisplayPlaneSurfaceKHR-instance-parameter\\]");
141 }
142 
143 #if defined(VK_USE_PLATFORM_ANDROID_KHR)
TEST(LoaderHandleValidTests, BadInstCreateAndroidSurf)144 TEST(LoaderHandleValidTests, BadInstCreateAndroidSurf) {
145     FrameworkEnvironment env{};
146     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
147 
148     InstWrapper instance(env.vulkan_functions);
149     instance.create_info.setup_WSI();
150     instance.CheckCreate();
151 
152     auto bad_instance = get_bad_handle<VkInstance>();
153 
154     VkAndroidSurfaceCreateInfoKHR surf_create_info = {};
155     surf_create_info.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
156     surf_create_info.pNext = nullptr;
157     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
158     ASSERT_DEATH(env.vulkan_functions.vkCreateAndroidSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
159                  "vkCreateAndroidSurfaceKHR: Invalid instance \\[VUID-vkCreateAndroidSurfaceKHR-instance-parameter\\]");
160 }
161 #endif  // VK_USE_PLATFORM_ANDROID_KHR
162 
163 #if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
TEST(LoaderHandleValidTests, BadInstCreateDirectFBSurf)164 TEST(LoaderHandleValidTests, BadInstCreateDirectFBSurf) {
165     FrameworkEnvironment env{};
166     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
167 
168     InstWrapper instance(env.vulkan_functions);
169     instance.create_info.setup_WSI();
170     instance.CheckCreate();
171 
172     auto bad_instance = get_bad_handle<VkInstance>();
173 
174     VkDirectFBSurfaceCreateInfoEXT surf_create_info = {};
175     surf_create_info.sType = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT;
176     surf_create_info.pNext = nullptr;
177     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
178     ASSERT_DEATH(env.vulkan_functions.vkCreateDirectFBSurfaceEXT(bad_instance, &surf_create_info, nullptr, &created_surface),
179                  "vkCreateDirectFBSurfaceEXT: Invalid instance \\[VUID-vkCreateDirectFBSurfaceEXT-instance-parameter\\]");
180 }
181 #endif  // VK_USE_PLATFORM_DIRECTFB_EXT
182 
183 #if defined(VK_USE_PLATFORM_FUCHSIA)
TEST(LoaderHandleValidTests, BadInstCreateFuchsiaSurf)184 TEST(LoaderHandleValidTests, BadInstCreateFuchsiaSurf) {
185     FrameworkEnvironment env{};
186     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
187 
188     InstWrapper instance(env.vulkan_functions);
189     instance.create_info.setup_WSI();
190     instance.CheckCreate();
191 
192     auto bad_instance = get_bad_handle<VkInstance>();
193 
194     VkImagePipeSurfaceCreateInfoFUCHSIA surf_create_info = {};
195     surf_create_info.sType = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA;
196     surf_create_info.pNext = nullptr;
197     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
198     ASSERT_DEATH(env.vulkan_functions.vkCreateImagePipeSurfaceFUCHSIA(bad_instance, &surf_create_info, nullptr, &created_surface),
199                  "vkCreateImagePipeSurfaceFUCHSIA: Invalid instance \\[VUID-vkCreateImagePipeSurfaceFUCHSIA-instance-parameter\\]");
200 }
201 #endif  // VK_USE_PLATFORM_FUCHSIA
202 
203 #if defined(VK_USE_PLATFORM_GGP)
TEST(LoaderHandleValidTests, BadInstCreateGGPSurf)204 TEST(LoaderHandleValidTests, BadInstCreateGGPSurf) {
205     FrameworkEnvironment env{};
206     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
207 
208     InstWrapper instance(env.vulkan_functions);
209     instance.create_info.setup_WSI();
210     instance.CheckCreate();
211 
212     auto bad_instance = get_bad_handle<VkInstance>();
213 
214     VkStreamDescriptorSurfaceCreateInfoGGP surf_create_info = {};
215     surf_create_info.sType = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP;
216     surf_create_info.pNext = nullptr;
217     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
218     ASSERT_DEATH(
219         env.vulkan_functions.vkCreateStreamDescriptorSurfaceGGP(bad_instance, &surf_create_info, nullptr, &created_surface),
220         "vkCreateStreamDescriptorSurfaceGGP: Invalid instance \\[VUID-vkCreateStreamDescriptorSurfaceGGP-instance-parameter\\]");
221 }
222 #endif  // VK_USE_PLATFORM_GGP
223 
224 #if defined(VK_USE_PLATFORM_IOS_MVK)
TEST(LoaderHandleValidTests, BadInstCreateIOSSurf)225 TEST(LoaderHandleValidTests, BadInstCreateIOSSurf) {
226     FrameworkEnvironment env{};
227     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
228 
229     InstWrapper instance(env.vulkan_functions);
230     instance.create_info.setup_WSI();
231     instance.CheckCreate();
232 
233     auto bad_instance = get_bad_handle<VkInstance>();
234 
235     VkIOSSurfaceCreateInfoMVK surf_create_info = {};
236     surf_create_info.sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK;
237     surf_create_info.pNext = nullptr;
238     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
239     ASSERT_DEATH(env.vulkan_functions.vkCreateIOSSurfaceMVK(bad_instance, &surf_create_info, nullptr, &created_surface),
240                  "vkCreateIOSSurfaceMVK: Invalid instance \\[VUID-vkCreateIOSSurfaceMVK-instance-parameter\\]");
241 }
242 #endif  // VK_USE_PLATFORM_IOS_MVK
243 
244 #if defined(VK_USE_PLATFORM_MACOS_MVK)
TEST(LoaderHandleValidTests, BadInstCreateMacOSSurf)245 TEST(LoaderHandleValidTests, BadInstCreateMacOSSurf) {
246     FrameworkEnvironment env{};
247     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
248 
249     InstWrapper instance(env.vulkan_functions);
250     instance.create_info.setup_WSI();
251     instance.CheckCreate();
252 
253     auto bad_instance = get_bad_handle<VkInstance>();
254 
255     VkMacOSSurfaceCreateInfoMVK surf_create_info = {};
256     surf_create_info.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
257     surf_create_info.pNext = nullptr;
258     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
259     ASSERT_DEATH(env.vulkan_functions.vkCreateMacOSSurfaceMVK(bad_instance, &surf_create_info, nullptr, &created_surface),
260                  "vkCreateMacOSSurfaceMVK: Invalid instance \\[VUID-vkCreateMacOSSurfaceMVK-instance-parameter\\]");
261 }
262 #endif  // VK_USE_PLATFORM_MACOS_MVK
263 
264 #if defined(VK_USE_PLATFORM_METAL_EXT)
TEST(LoaderHandleValidTests, BadInstCreateMetalSurf)265 TEST(LoaderHandleValidTests, BadInstCreateMetalSurf) {
266     FrameworkEnvironment env{};
267     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
268 
269     InstWrapper instance(env.vulkan_functions);
270     instance.create_info.setup_WSI();
271     instance.CheckCreate();
272 
273     auto bad_instance = get_bad_handle<VkInstance>();
274 
275     VkMetalSurfaceCreateInfoEXT surf_create_info = {};
276     surf_create_info.sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT;
277     surf_create_info.pNext = nullptr;
278     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
279     ASSERT_DEATH(env.vulkan_functions.vkCreateMetalSurfaceEXT(bad_instance, &surf_create_info, nullptr, &created_surface),
280                  "vkCreateMetalSurfaceEXT: Invalid instance \\[VUID-vkCreateMetalSurfaceEXT-instance-parameter\\]");
281 }
282 #endif  // VK_USE_PLATFORM_METAL_EXT
283 
284 #if defined(VK_USE_PLATFORM_SCREEN_QNX)
TEST(LoaderHandleValidTests, BadInstCreateQNXSurf)285 TEST(LoaderHandleValidTests, BadInstCreateQNXSurf) {
286     FrameworkEnvironment env{};
287     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
288 
289     InstWrapper instance(env.vulkan_functions);
290     instance.create_info.setup_WSI();
291     instance.CheckCreate();
292 
293     auto bad_instance = get_bad_handle<VkInstance>();
294 
295     VkScreenSurfaceCreateInfoQNX surf_create_info = {};
296     surf_create_info.sType = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX;
297     surf_create_info.pNext = nullptr;
298     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
299     ASSERT_DEATH(env.vulkan_functions.vkCreateScreenSurfaceQNX(bad_instance, &surf_create_info, nullptr, &created_surface),
300                  "vkCreateScreenSurfaceQNX: Invalid instance \\[VUID-vkCreateScreenSurfaceQNX-instance-parameter\\]");
301     // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
302 }
303 #endif  // VK_USE_PLATFORM_SCREEN_QNX
304 
305 #if defined(VK_USE_PLATFORM_VI_NN)
TEST(LoaderHandleValidTests, BadInstCreateViNNSurf)306 TEST(LoaderHandleValidTests, BadInstCreateViNNSurf) {
307     FrameworkEnvironment env{};
308     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
309 
310     InstWrapper instance(env.vulkan_functions);
311     instance.create_info.setup_WSI();
312     instance.CheckCreate();
313 
314     auto bad_instance = get_bad_handle<VkInstance>();
315 
316     VkViSurfaceCreateInfoNN surf_create_info = {};
317     surf_create_info.sType = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN;
318     surf_create_info.pNext = nullptr;
319     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
320     ASSERT_DEATH(env.vulkan_functions.vkCreateViSurfaceNN(bad_instance, &surf_create_info, nullptr, &created_surface),
321                  "vkCreateViSurfaceNN: Invalid instance \\[VUID-vkCreateViSurfaceNN-instance-parameter\\]");
322     // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
323 }
324 #endif  // VK_USE_PLATFORM_VI_NN
325 
326 #if defined(VK_USE_PLATFORM_WAYLAND_KHR)
TEST(LoaderHandleValidTests, BadInstCreateWaylandSurf)327 TEST(LoaderHandleValidTests, BadInstCreateWaylandSurf) {
328     FrameworkEnvironment env{};
329     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
330 
331     InstWrapper instance(env.vulkan_functions);
332     instance.create_info.setup_WSI();
333     instance.CheckCreate();
334 
335     auto bad_instance = get_bad_handle<VkInstance>();
336 
337     VkWaylandSurfaceCreateInfoKHR surf_create_info = {};
338     surf_create_info.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
339     surf_create_info.pNext = nullptr;
340     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
341     ASSERT_DEATH(env.vulkan_functions.vkCreateWaylandSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
342                  "vkCreateWaylandSurfaceKHR: Invalid instance \\[VUID-vkCreateWaylandSurfaceKHR-instance-parameter\\]");
343     // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
344 }
345 #endif  // VK_USE_PLATFORM_WAYLAND_KHR
346 
347 #if defined(VK_USE_PLATFORM_WIN32_KHR)
TEST(LoaderHandleValidTests, BadInstCreateWin32Surf)348 TEST(LoaderHandleValidTests, BadInstCreateWin32Surf) {
349     FrameworkEnvironment env{};
350     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
351 
352     InstWrapper instance(env.vulkan_functions);
353     instance.create_info.setup_WSI();
354     instance.CheckCreate();
355 
356     auto bad_instance = get_bad_handle<VkInstance>();
357 
358     VkWin32SurfaceCreateInfoKHR surf_create_info = {};
359     surf_create_info.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
360     surf_create_info.pNext = nullptr;
361     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
362     ASSERT_DEATH(env.vulkan_functions.vkCreateWin32SurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
363                  "vkCreateWin32SurfaceKHR: Invalid instance \\[VUID-vkCreateWin32SurfaceKHR-instance-parameter\\]");
364     // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
365 }
366 #endif  // VK_USE_PLATFORM_WIN32_KHR
367 
368 #if defined(VK_USE_PLATFORM_XCB_KHR)
TEST(LoaderHandleValidTests, BadInstCreateXCBSurf)369 TEST(LoaderHandleValidTests, BadInstCreateXCBSurf) {
370     FrameworkEnvironment env{};
371     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
372 
373     InstWrapper instance(env.vulkan_functions);
374     instance.create_info.setup_WSI();
375     instance.CheckCreate();
376 
377     auto bad_instance = get_bad_handle<VkInstance>();
378 
379     VkXcbSurfaceCreateInfoKHR surf_create_info = {};
380     surf_create_info.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
381     surf_create_info.pNext = nullptr;
382     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
383     ASSERT_DEATH(env.vulkan_functions.vkCreateXcbSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
384                  "vkCreateXcbSurfaceKHR: Invalid instance \\[VUID-vkCreateXcbSurfaceKHR-instance-parameter\\]");
385     // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
386 }
387 #endif  // VK_USE_PLATFORM_XCB_KHR
388 
389 #if defined(VK_USE_PLATFORM_XLIB_KHR)
TEST(LoaderHandleValidTests, BadInstCreateXlibSurf)390 TEST(LoaderHandleValidTests, BadInstCreateXlibSurf) {
391     FrameworkEnvironment env{};
392     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
393 
394     InstWrapper instance(env.vulkan_functions);
395     instance.create_info.setup_WSI();
396     instance.CheckCreate();
397 
398     auto bad_instance = get_bad_handle<VkInstance>();
399 
400     VkXlibSurfaceCreateInfoKHR surf_create_info = {};
401     surf_create_info.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
402     surf_create_info.pNext = nullptr;
403     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
404     ASSERT_DEATH(env.vulkan_functions.vkCreateXlibSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
405                  "vkCreateXlibSurfaceKHR: Invalid instance \\[VUID-vkCreateXlibSurfaceKHR-instance-parameter\\]");
406     // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
407 }
408 #endif  // VK_USE_PLATFORM_XLIB_KHR
409 
410 // ---- Invalid Physical Device tests
411 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFeature)412 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFeature) {
413     FrameworkEnvironment env{};
414     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
415         .add_physical_device({})
416         .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
417 
418     InstWrapper instance(env.vulkan_functions);
419     instance.create_info.set_api_version(1, 1, 0);
420     instance.CheckCreate();
421 
422     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
423 
424     VkPhysicalDeviceFeatures features = {};
425     ASSERT_DEATH(
426         env.vulkan_functions.vkGetPhysicalDeviceFeatures(bad_physical_dev, &features),
427         "vkGetPhysicalDeviceFeatures: Invalid physicalDevice \\[VUID-vkGetPhysicalDeviceFeatures-physicalDevice-parameter\\]");
428 }
429 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFormatProps)430 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFormatProps) {
431     FrameworkEnvironment env{};
432     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
433         .add_physical_device({})
434         .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
435 
436     InstWrapper instance(env.vulkan_functions);
437     instance.create_info.set_api_version(1, 1, 0);
438     instance.CheckCreate();
439 
440     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
441 
442     VkFormatProperties format_info = {};
443     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceFormatProperties(bad_physical_dev, VK_FORMAT_R8G8B8A8_UNORM, &format_info),
444                  "vkGetPhysicalDeviceFormatProperties: Invalid physicalDevice "
445                  "\\[VUID-vkGetPhysicalDeviceFormatProperties-physicalDevice-parameter\\]");
446 }
447 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevImgFormatProps)448 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevImgFormatProps) {
449     FrameworkEnvironment env{};
450     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
451         .add_physical_device({})
452         .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
453 
454     InstWrapper instance(env.vulkan_functions);
455     instance.create_info.set_api_version(1, 1, 0);
456     instance.CheckCreate();
457 
458     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
459 
460     VkImageFormatProperties format_info = {};
461     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceImageFormatProperties(bad_physical_dev, VK_FORMAT_R8G8B8A8_UNORM,
462                                                                                VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_LINEAR,
463                                                                                VK_IMAGE_USAGE_STORAGE_BIT, 0, &format_info),
464                  "vkGetPhysicalDeviceImageFormatProperties: Invalid physicalDevice "
465                  "\\[VUID-vkGetPhysicalDeviceImageFormatProperties-physicalDevice-parameter\\]");
466 }
467 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevProps)468 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevProps) {
469     FrameworkEnvironment env{};
470     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
471         .add_physical_device({})
472         .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
473 
474     InstWrapper instance(env.vulkan_functions);
475     instance.create_info.set_api_version(1, 1, 0);
476     instance.CheckCreate();
477 
478     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
479 
480     VkPhysicalDeviceProperties properties = {};
481     ASSERT_DEATH(
482         env.vulkan_functions.vkGetPhysicalDeviceProperties(bad_physical_dev, &properties),
483         "vkGetPhysicalDeviceProperties: Invalid physicalDevice \\[VUID-vkGetPhysicalDeviceProperties-physicalDevice-parameter\\]");
484 }
485 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamProps)486 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamProps) {
487     FrameworkEnvironment env{};
488     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
489         .add_physical_device({})
490         .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
491 
492     InstWrapper instance(env.vulkan_functions);
493     instance.create_info.set_api_version(1, 1, 0);
494     instance.CheckCreate();
495 
496     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
497     uint32_t count = 0;
498     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(bad_physical_dev, &count, nullptr),
499                  "vkGetPhysicalDeviceQueueFamilyProperties: Invalid physicalDevice "
500                  "\\[VUID-vkGetPhysicalDeviceQueueFamilyProperties-physicalDevice-parameter\\]");
501 }
502 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDevMemProps)503 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDevMemProps) {
504     FrameworkEnvironment env{};
505     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
506         .add_physical_device({})
507         .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
508 
509     InstWrapper instance(env.vulkan_functions);
510     instance.create_info.set_api_version(1, 1, 0);
511     instance.CheckCreate();
512 
513     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
514 
515     VkPhysicalDeviceMemoryProperties properties = {};
516     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceMemoryProperties(bad_physical_dev, &properties),
517                  "vkGetPhysicalDeviceMemoryProperties: Invalid physicalDevice "
518                  "\\[VUID-vkGetPhysicalDeviceMemoryProperties-physicalDevice-parameter\\]");
519 }
520 
TEST(LoaderHandleValidTests, BadPhysDevCreateDevice)521 TEST(LoaderHandleValidTests, BadPhysDevCreateDevice) {
522     FrameworkEnvironment env{};
523     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
524         .add_physical_device({})
525         .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
526 
527     InstWrapper instance(env.vulkan_functions);
528     instance.create_info.set_api_version(1, 1, 0);
529     instance.CheckCreate();
530 
531     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
532 
533     float queue_priorities[3] = {0.0f, 0.5f, 1.0f};
534     VkDeviceQueueCreateInfo dev_queue_create_info = {};
535     dev_queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
536     dev_queue_create_info.pNext = nullptr;
537     dev_queue_create_info.flags = 0;
538     dev_queue_create_info.queueFamilyIndex = 0;
539     dev_queue_create_info.queueCount = 1;
540     dev_queue_create_info.pQueuePriorities = queue_priorities;
541     VkDeviceCreateInfo dev_create_info = {};
542     dev_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
543     dev_create_info.pNext = nullptr;
544     dev_create_info.flags = 0;
545     dev_create_info.queueCreateInfoCount = 1;
546     dev_create_info.pQueueCreateInfos = &dev_queue_create_info;
547     dev_create_info.enabledLayerCount = 0;
548     dev_create_info.ppEnabledLayerNames = nullptr;
549     dev_create_info.enabledExtensionCount = 0;
550     dev_create_info.ppEnabledExtensionNames = nullptr;
551     dev_create_info.pEnabledFeatures = nullptr;
552     VkDevice created_dev = VK_NULL_HANDLE;
553     ASSERT_DEATH(env.vulkan_functions.vkCreateDevice(bad_physical_dev, &dev_create_info, nullptr, &created_dev),
554                  "vkCreateDevice: Invalid physicalDevice \\[VUID-vkCreateDevice-physicalDevice-parameter\\]");
555 }
556 
TEST(LoaderHandleValidTests, BadPhysDevEnumDevExtProps)557 TEST(LoaderHandleValidTests, BadPhysDevEnumDevExtProps) {
558     FrameworkEnvironment env{};
559     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
560         .add_physical_device({})
561         .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
562 
563     InstWrapper instance(env.vulkan_functions);
564     instance.create_info.set_api_version(1, 1, 0);
565     instance.CheckCreate();
566 
567     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
568     uint32_t count = 0;
569     ASSERT_DEATH(env.vulkan_functions.vkEnumerateDeviceExtensionProperties(bad_physical_dev, nullptr, &count, nullptr),
570                  "vkEnumerateDeviceExtensionProperties: Invalid physicalDevice "
571                  "\\[VUID-vkEnumerateDeviceExtensionProperties-physicalDevice-parameter\\]");
572 }
573 
TEST(LoaderHandleValidTests, BadPhysDevEnumDevLayerProps)574 TEST(LoaderHandleValidTests, BadPhysDevEnumDevLayerProps) {
575     FrameworkEnvironment env{};
576     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
577         .add_physical_device({})
578         .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
579 
580     InstWrapper instance(env.vulkan_functions);
581     instance.create_info.set_api_version(1, 1, 0);
582     instance.CheckCreate();
583 
584     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
585     uint32_t count = 0;
586     ASSERT_DEATH(env.vulkan_functions.vkEnumerateDeviceLayerProperties(bad_physical_dev, &count, nullptr),
587                  "vkEnumerateDeviceLayerProperties: Invalid physicalDevice "
588                  "\\[VUID-vkEnumerateDeviceLayerProperties-physicalDevice-parameter\\]");
589 }
590 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSparseImgFormatProps)591 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSparseImgFormatProps) {
592     FrameworkEnvironment env{};
593     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
594         .add_physical_device({})
595         .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
596 
597     InstWrapper instance(env.vulkan_functions);
598     instance.create_info.set_api_version(1, 1, 0);
599     instance.CheckCreate();
600 
601     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
602 
603     uint32_t count = 0;
604     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSparseImageFormatProperties(
605                      bad_physical_dev, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_TYPE_2D, VK_SAMPLE_COUNT_1_BIT,
606                      VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_TILING_LINEAR, &count, nullptr),
607                  "vkGetPhysicalDeviceSparseImageFormatProperties: Invalid physicalDevice "
608                  "\\[VUID-vkGetPhysicalDeviceSparseImageFormatProperties-physicalDevice-parameter\\]");
609 }
610 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFeature2)611 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFeature2) {
612     FrameworkEnvironment env{};
613     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
614         .add_physical_device({})
615         .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
616 
617     InstWrapper instance(env.vulkan_functions);
618     instance.create_info.set_api_version(1, 1, 0);
619     instance.CheckCreate();
620 
621     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
622 
623     VkPhysicalDeviceFeatures2 features = {};
624     features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
625     features.pNext = nullptr;
626     ASSERT_DEATH(
627         env.vulkan_functions.vkGetPhysicalDeviceFeatures2(bad_physical_dev, &features),
628         "vkGetPhysicalDeviceFeatures2: Invalid physicalDevice \\[VUID-vkGetPhysicalDeviceFeatures2-physicalDevice-parameter\\]");
629 }
630 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFormatProps2)631 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFormatProps2) {
632     FrameworkEnvironment env{};
633     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
634         .add_physical_device({})
635         .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
636 
637     InstWrapper instance(env.vulkan_functions);
638     instance.create_info.set_api_version(1, 1, 0);
639     instance.CheckCreate();
640 
641     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
642 
643     VkFormatProperties2 properties = {};
644     properties.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
645     properties.pNext = nullptr;
646     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceFormatProperties2(bad_physical_dev, VK_FORMAT_R8G8B8A8_UNORM, &properties),
647                  "vkGetPhysicalDeviceFormatProperties2: Invalid physicalDevice "
648                  "\\[VUID-vkGetPhysicalDeviceFormatProperties2-physicalDevice-parameter\\]");
649 }
650 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevImgFormatProps2)651 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevImgFormatProps2) {
652     FrameworkEnvironment env{};
653     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
654         .add_physical_device({})
655         .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
656 
657     InstWrapper instance(env.vulkan_functions);
658     instance.create_info.set_api_version(1, 1, 0);
659     instance.CheckCreate();
660 
661     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
662 
663     VkPhysicalDeviceImageFormatInfo2 format_info = {};
664     format_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2;
665     format_info.pNext = nullptr;
666     VkImageFormatProperties2 properties = {};
667     properties.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
668     properties.pNext = nullptr;
669     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceImageFormatProperties2(bad_physical_dev, &format_info, &properties),
670                  "vkGetPhysicalDeviceImageFormatProperties2: Invalid physicalDevice "
671                  "\\[VUID-vkGetPhysicalDeviceImageFormatProperties2-physicalDevice-parameter\\]");
672 }
673 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevProps2)674 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevProps2) {
675     FrameworkEnvironment env{};
676     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
677         .add_physical_device({})
678         .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
679 
680     InstWrapper instance(env.vulkan_functions);
681     instance.create_info.set_api_version(1, 1, 0);
682     instance.CheckCreate();
683 
684     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
685 
686     VkPhysicalDeviceProperties2 properties = {};
687     properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
688     properties.pNext = nullptr;
689     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceProperties2(bad_physical_dev, &properties),
690                  "vkGetPhysicalDeviceProperties2: Invalid physicalDevice "
691                  "\\[VUID-vkGetPhysicalDeviceProperties2-physicalDevice-parameter\\]");
692 }
693 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamProps2)694 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamProps2) {
695     FrameworkEnvironment env{};
696     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
697         .add_physical_device({})
698         .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
699 
700     InstWrapper instance(env.vulkan_functions);
701     instance.create_info.set_api_version(1, 1, 0);
702     instance.CheckCreate();
703 
704     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
705     uint32_t count = 0;
706     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties2(bad_physical_dev, &count, nullptr),
707                  "vkGetPhysicalDeviceQueueFamilyProperties2: Invalid physicalDevice "
708                  "\\[VUID-vkGetPhysicalDeviceQueueFamilyProperties2-physicalDevice-parameter\\]");
709 }
710 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDevMemProps2)711 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDevMemProps2) {
712     FrameworkEnvironment env{};
713     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
714         .add_physical_device({})
715         .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
716 
717     InstWrapper instance(env.vulkan_functions);
718     instance.create_info.set_api_version(1, 1, 0);
719     instance.CheckCreate();
720 
721     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
722 
723     VkPhysicalDeviceMemoryProperties2 properties = {};
724     properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
725     properties.pNext = nullptr;
726     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceMemoryProperties2(bad_physical_dev, &properties),
727                  "vkGetPhysicalDeviceMemoryProperties2: Invalid physicalDevice "
728                  "\\[VUID-vkGetPhysicalDeviceMemoryProperties2-physicalDevice-parameter\\]");
729 }
730 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSparseImgFormatProps2)731 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSparseImgFormatProps2) {
732     FrameworkEnvironment env{};
733     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
734         .add_physical_device({})
735         .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
736 
737     InstWrapper instance(env.vulkan_functions);
738     instance.create_info.set_api_version(1, 1, 0);
739     instance.CheckCreate();
740 
741     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
742 
743     VkPhysicalDeviceSparseImageFormatInfo2 info = {};
744     info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2;
745     info.pNext = nullptr;
746     uint32_t count = 0;
747     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSparseImageFormatProperties2(bad_physical_dev, &info, &count, nullptr),
748                  "vkGetPhysicalDeviceSparseImageFormatProperties2: Invalid physicalDevice "
749                  "\\[VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-physicalDevice-parameter\\]");
750 }
751 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevExternFenceProps)752 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevExternFenceProps) {
753     FrameworkEnvironment env{};
754     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
755         .add_physical_device({})
756         .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
757 
758     InstWrapper instance(env.vulkan_functions);
759     instance.create_info.set_api_version(1, 1, 0);
760     instance.CheckCreate();
761 
762     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
763 
764     VkPhysicalDeviceExternalFenceInfo info = {};
765     info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO;
766     info.pNext = nullptr;
767     VkExternalFenceProperties props = {};
768     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceExternalFenceProperties(bad_physical_dev, &info, &props),
769                  "vkGetPhysicalDeviceExternalFenceProperties: Invalid physicalDevice "
770                  "\\[VUID-vkGetPhysicalDeviceExternalFenceProperties-physicalDevice-parameter\\]");
771 }
772 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevExternBufferProps)773 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevExternBufferProps) {
774     FrameworkEnvironment env{};
775     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
776         .add_physical_device({})
777         .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
778 
779     InstWrapper instance(env.vulkan_functions);
780     instance.create_info.set_api_version(1, 1, 0);
781     instance.CheckCreate();
782 
783     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
784 
785     VkPhysicalDeviceExternalBufferInfo info = {};
786     info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO;
787     info.pNext = nullptr;
788     VkExternalBufferProperties props = {};
789     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceExternalBufferProperties(bad_physical_dev, &info, &props),
790                  "vkGetPhysicalDeviceExternalBufferProperties: Invalid physicalDevice "
791                  "\\[VUID-vkGetPhysicalDeviceExternalBufferProperties-physicalDevice-parameter\\]");
792 }
793 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevExternSemaphoreProps)794 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevExternSemaphoreProps) {
795     FrameworkEnvironment env{};
796     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
797         .add_physical_device({})
798         .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
799 
800     InstWrapper instance(env.vulkan_functions);
801     instance.create_info.set_api_version(1, 1, 0);
802     instance.CheckCreate();
803 
804     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
805 
806     VkPhysicalDeviceExternalSemaphoreInfo info = {};
807     info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO;
808     info.pNext = nullptr;
809     VkExternalSemaphoreProperties props = {};
810     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceExternalSemaphoreProperties(bad_physical_dev, &info, &props),
811                  "vkGetPhysicalDeviceExternalSemaphoreProperties: Invalid physicalDevice "
812                  "\\[VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-physicalDevice-parameter\\]");
813 }
814 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceSupportKHR)815 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceSupportKHR) {
816     FrameworkEnvironment env{};
817     Extension first_ext{"VK_KHR_surface"};
818     Extension second_ext{"VK_KHR_display"};
819     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
820         .add_instance_extensions({first_ext, second_ext})
821         .add_physical_device("physical_device_0");
822 
823     InstWrapper instance(env.vulkan_functions);
824     instance.create_info.add_extension(first_ext.extensionName.c_str());
825     instance.CheckCreate();
826 
827     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
828     VkBool32 supported = VK_FALSE;
829 
830     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfaceSupportKHR(bad_physical_dev, 0, VK_NULL_HANDLE, &supported),
831                  "vkGetPhysicalDeviceSurfaceSupportKHR: Invalid physicalDevice "
832                  "\\[VUID-vkGetPhysicalDeviceSurfaceSupportKHR-physicalDevice-parameter\\]");
833 }
834 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceCapsKHR)835 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceCapsKHR) {
836     FrameworkEnvironment env{};
837     Extension first_ext{"VK_KHR_surface"};
838     Extension second_ext{"VK_KHR_display"};
839     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
840         .add_instance_extensions({first_ext, second_ext})
841         .add_physical_device("physical_device_0");
842 
843     InstWrapper instance(env.vulkan_functions);
844     instance.create_info.add_extension(first_ext.extensionName.c_str());
845     instance.CheckCreate();
846 
847     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
848     VkSurfaceCapabilitiesKHR caps = {};
849     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(bad_physical_dev, VK_NULL_HANDLE, &caps),
850                  "vkGetPhysicalDeviceSurfaceCapabilitiesKHR: Invalid physicalDevice "
851                  "\\[VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-physicalDevice-parameter\\]");
852 }
853 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceFormatsKHR)854 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceFormatsKHR) {
855     FrameworkEnvironment env{};
856     Extension first_ext{"VK_KHR_surface"};
857     Extension second_ext{"VK_KHR_display"};
858     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
859         .add_instance_extensions({first_ext, second_ext})
860         .add_physical_device("physical_device_0");
861 
862     InstWrapper instance(env.vulkan_functions);
863     instance.create_info.add_extension(first_ext.extensionName.c_str());
864     instance.CheckCreate();
865 
866     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
867     uint32_t count = 0;
868     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfaceFormatsKHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
869                  "vkGetPhysicalDeviceSurfaceFormatsKHR: Invalid physicalDevice "
870                  "\\[VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-physicalDevice-parameter\\]");
871 }
872 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfacePresentModesKHR)873 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfacePresentModesKHR) {
874     FrameworkEnvironment env{};
875     Extension first_ext{"VK_KHR_surface"};
876     Extension second_ext{"VK_KHR_display"};
877     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
878         .add_instance_extensions({first_ext, second_ext})
879         .add_physical_device("physical_device_0");
880 
881     InstWrapper instance(env.vulkan_functions);
882     instance.create_info.add_extension(first_ext.extensionName.c_str());
883     instance.CheckCreate();
884 
885     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
886     uint32_t count = 0;
887     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfacePresentModesKHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
888                  "vkGetPhysicalDeviceSurfacePresentModesKHR: Invalid physicalDevice "
889                  "\\[VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-physicalDevice-parameter\\]");
890 }
891 
892 #if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
TEST(LoaderHandleValidTests, BadPhysDevGetDirectFBPresentSupportKHR)893 TEST(LoaderHandleValidTests, BadPhysDevGetDirectFBPresentSupportKHR) {
894     FrameworkEnvironment env{};
895     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
896 
897     InstWrapper instance(env.vulkan_functions);
898     instance.create_info.setup_WSI();
899     instance.CheckCreate();
900 
901     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
902     IDirectFB directfb;
903     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceDirectFBPresentationSupportEXT(bad_physical_dev, 0, &directfb),
904                  "vkGetPhysicalDeviceDirectFBPresentationSupportEXT: Invalid physicalDevice "
905                  "\\[VUID-vkGetPhysicalDeviceDirectFBPresentationSupportEXT-physicalDevice-parameter\\]");
906 }
907 #endif  // VK_USE_PLATFORM_DIRECTFB_EXT
908 
909 #if defined(VK_USE_PLATFORM_SCREEN_QNX)
TEST(LoaderHandleValidTests, BadPhysDevGetQNXPresentSupportKHR)910 TEST(LoaderHandleValidTests, BadPhysDevGetQNXPresentSupportKHR) {
911     FrameworkEnvironment env{};
912     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
913 
914     InstWrapper instance(env.vulkan_functions);
915     instance.create_info.setup_WSI();
916     instance.CheckCreate();
917 
918     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
919     ASSERT_DEATH(env.vulkan_functions.PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX(bad_physical_dev, 0, nullptr),
920                  "vkGetPhysicalDeviceScreenPresentationSupportQNX: Invalid instance "
921                  "\\[VUID-vkGetPhysicalDeviceScreenPresentationSupportQNX-instance-parameter\\]");
922 }
923 #endif  // VK_USE_PLATFORM_SCREEN_QNX
924 
925 #if defined(VK_USE_PLATFORM_WAYLAND_KHR)
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevWaylandPresentSupportKHR)926 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevWaylandPresentSupportKHR) {
927     FrameworkEnvironment env{};
928     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
929 
930     InstWrapper instance(env.vulkan_functions);
931     instance.create_info.setup_WSI();
932     instance.CheckCreate();
933 
934     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
935     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceWaylandPresentationSupportKHR(bad_physical_dev, 0, nullptr),
936                  "vkGetPhysicalDeviceWaylandPresentationSupportKHR: Invalid physicalDevice "
937                  "\\[VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-physicalDevice-parameter\\]");
938 }
939 #endif  // VK_USE_PLATFORM_WAYLAND_KHR
940 
941 #if defined(VK_USE_PLATFORM_WIN32_KHR)
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevWin32PresentSupportKHR)942 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevWin32PresentSupportKHR) {
943     FrameworkEnvironment env{};
944     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
945 
946     InstWrapper instance(env.vulkan_functions);
947     instance.create_info.setup_WSI();
948     instance.CheckCreate();
949 
950     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
951     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceWin32PresentationSupportKHR(bad_physical_dev, 0),
952                  "vkGetPhysicalDeviceWin32PresentationSupportKHR: Invalid physicalDevice "
953                  "\\[VUID-vkGetPhysicalDeviceWin32PresentationSupportKHR-physicalDevice-parameter\\]");
954 }
955 #endif  // VK_USE_PLATFORM_WIN32_KHR
956 
957 #if defined(VK_USE_PLATFORM_XCB_KHR)
TEST(LoaderHandleValidTests, BadPhysDevGetXCBPresentSupportKHR)958 TEST(LoaderHandleValidTests, BadPhysDevGetXCBPresentSupportKHR) {
959     FrameworkEnvironment env{};
960     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
961 
962     InstWrapper instance(env.vulkan_functions);
963     instance.create_info.setup_WSI();
964     instance.CheckCreate();
965     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
966 
967     xcb_visualid_t visual = 0;
968     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceXcbPresentationSupportKHR(bad_physical_dev, 0, nullptr, visual),
969                  "vkGetPhysicalDeviceXcbPresentationSupportKHR: Invalid physicalDevice "
970                  "\\[VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-physicalDevice-parameter\\]");
971 }
972 #endif  // VK_USE_PLATFORM_XCB_KHR
973 
974 #if defined(VK_USE_PLATFORM_XLIB_KHR)
TEST(LoaderHandleValidTests, BadPhysDevGetXlibPresentSupportKHR)975 TEST(LoaderHandleValidTests, BadPhysDevGetXlibPresentSupportKHR) {
976     FrameworkEnvironment env{};
977     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
978 
979     InstWrapper instance(env.vulkan_functions);
980     instance.create_info.setup_WSI();
981     instance.CheckCreate();
982 
983     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
984 
985     VisualID visual = 0;
986     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceXlibPresentationSupportKHR(bad_physical_dev, 0, nullptr, visual),
987                  "vkGetPhysicalDeviceXlibPresentationSupportKHR: Invalid physicalDevice "
988                  "\\[VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-physicalDevice-parameter\\]");
989 }
990 #endif  // VK_USE_PLATFORM_XLIB_KHR
991 
setup_BadPhysDev_env(FrameworkEnvironment& env, std::vector<const char*> exts)992 InstWrapper setup_BadPhysDev_env(FrameworkEnvironment& env, std::vector<const char*> exts) {
993     std::vector<Extension> ext_modified;
994     for (const auto& ext : exts) {
995         ext_modified.push_back(Extension{ext});
996     }
997     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
998         .add_instance_extensions(ext_modified)
999         .setup_WSI()
1000         .add_physical_device("physical_device_0");
1001 
1002     InstWrapper instance(env.vulkan_functions);
1003     instance.create_info.add_extensions(exts);
1004     instance.CheckCreate();
1005     return instance;
1006 }
1007 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPropsKHR)1008 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPropsKHR) {
1009     FrameworkEnvironment env{};
1010     auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_display"});
1011 
1012     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1013     uint32_t count = 0;
1014     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceDisplayPropertiesKHR(bad_physical_dev, &count, nullptr),
1015                  "vkGetPhysicalDeviceDisplayPropertiesKHR: Invalid physicalDevice "
1016                  "\\[VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-physicalDevice-parameter\\]");
1017 }
1018 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPlanePropsKHR)1019 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPlanePropsKHR) {
1020     FrameworkEnvironment env{};
1021     auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_display"});
1022 
1023     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1024     uint32_t count = 0;
1025     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceDisplayPlanePropertiesKHR(bad_physical_dev, &count, nullptr),
1026                  "vkGetPhysicalDeviceDisplayPlanePropertiesKHR: Invalid physicalDevice "
1027                  "\\[VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-physicalDevice-parameter\\]");
1028 }
1029 
TEST(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneSupportedDisplaysKHR)1030 TEST(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneSupportedDisplaysKHR) {
1031     FrameworkEnvironment env{};
1032     auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_display"});
1033 
1034     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1035     uint32_t count = 0;
1036     ASSERT_DEATH(env.vulkan_functions.vkGetDisplayPlaneSupportedDisplaysKHR(bad_physical_dev, 0, &count, nullptr),
1037                  "vkGetDisplayPlaneSupportedDisplaysKHR: Invalid physicalDevice "
1038                  "\\[VUID-vkGetDisplayPlaneSupportedDisplaysKHR-physicalDevice-parameter\\]");
1039 }
1040 
TEST(LoaderHandleValidTests, BadPhysDevGetDisplayModePropsKHR)1041 TEST(LoaderHandleValidTests, BadPhysDevGetDisplayModePropsKHR) {
1042     FrameworkEnvironment env{};
1043     auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_display"});
1044 
1045     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1046     uint32_t count = 0;
1047     ASSERT_DEATH(
1048         env.vulkan_functions.vkGetDisplayModePropertiesKHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
1049         "vkGetDisplayModePropertiesKHR: Invalid physicalDevice \\[VUID-vkGetDisplayModePropertiesKHR-physicalDevice-parameter\\]");
1050 }
1051 
TEST(LoaderHandleValidTests, BadPhysDevCreateDisplayModeKHR)1052 TEST(LoaderHandleValidTests, BadPhysDevCreateDisplayModeKHR) {
1053     FrameworkEnvironment env{};
1054     auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_display"});
1055 
1056     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1057     VkDisplayModeCreateInfoKHR create_info = {};
1058     create_info.sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
1059     create_info.pNext = nullptr;
1060     VkDisplayModeKHR display_mode;
1061     ASSERT_DEATH(
1062         env.vulkan_functions.vkCreateDisplayModeKHR(bad_physical_dev, VK_NULL_HANDLE, &create_info, nullptr, &display_mode),
1063         "vkCreateDisplayModeKHR: Invalid physicalDevice \\[VUID-vkCreateDisplayModeKHR-physicalDevice-parameter\\]");
1064 }
1065 
TEST(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneCapsKHR)1066 TEST(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneCapsKHR) {
1067     FrameworkEnvironment env{};
1068     auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_display"});
1069 
1070     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1071     VkDisplayPlaneCapabilitiesKHR caps = {};
1072     ASSERT_DEATH(env.vulkan_functions.vkGetDisplayPlaneCapabilitiesKHR(bad_physical_dev, VK_NULL_HANDLE, 0, &caps),
1073                  "vkGetDisplayPlaneCapabilitiesKHR: Invalid physicalDevice "
1074                  "\\[VUID-vkGetDisplayPlaneCapabilitiesKHR-physicalDevice-parameter\\]");
1075 }
1076 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevPresentRectsKHR)1077 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevPresentRectsKHR) {
1078     FrameworkEnvironment env{};
1079     auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_display"});
1080 
1081     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1082     uint32_t count = 0;
1083     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDevicePresentRectanglesKHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
1084                  "vkGetPhysicalDevicePresentRectanglesKHR: Invalid physicalDevice "
1085                  "\\[VUID-vkGetPhysicalDevicePresentRectanglesKHR-physicalDevice-parameter\\]");
1086 }
1087 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayProps2KHR)1088 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayProps2KHR) {
1089     FrameworkEnvironment env{};
1090     auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_get_display_properties2"});
1091 
1092     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1093     uint32_t count = 0;
1094     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceDisplayProperties2KHR(bad_physical_dev, &count, nullptr),
1095                  "vkGetPhysicalDeviceDisplayProperties2KHR: Invalid physicalDevice "
1096                  "\\[VUID-vkGetPhysicalDeviceDisplayProperties2KHR-physicalDevice-parameter\\]");
1097 }
1098 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPlaneProps2KHR)1099 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPlaneProps2KHR) {
1100     FrameworkEnvironment env{};
1101     auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_get_display_properties2"});
1102 
1103     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1104     uint32_t count = 0;
1105     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceDisplayPlaneProperties2KHR(bad_physical_dev, &count, nullptr),
1106                  "vkGetPhysicalDeviceDisplayPlaneProperties2KHR: Invalid physicalDevice "
1107                  "\\[VUID-vkGetPhysicalDeviceDisplayPlaneProperties2KHR-physicalDevice-parameter\\]");
1108 }
1109 
TEST(LoaderHandleValidTests, BadPhysDevGetDisplayModeProps2KHR)1110 TEST(LoaderHandleValidTests, BadPhysDevGetDisplayModeProps2KHR) {
1111     FrameworkEnvironment env{};
1112     auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_get_display_properties2"});
1113 
1114     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1115     uint32_t count = 0;
1116     ASSERT_DEATH(env.vulkan_functions.vkGetDisplayModeProperties2KHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
1117                  "vkGetDisplayModeProperties2KHR: Invalid physicalDevice "
1118                  "\\[VUID-vkGetDisplayModeProperties2KHR-physicalDevice-parameter\\]");
1119 }
1120 
TEST(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneCaps2KHR)1121 TEST(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneCaps2KHR) {
1122     FrameworkEnvironment env{};
1123     auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_get_display_properties2"});
1124 
1125     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1126     VkDisplayPlaneInfo2KHR disp_plane_info = {};
1127     disp_plane_info.sType = VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR;
1128     disp_plane_info.pNext = nullptr;
1129     VkDisplayPlaneCapabilities2KHR caps = {};
1130     ASSERT_DEATH(env.vulkan_functions.vkGetDisplayPlaneCapabilities2KHR(bad_physical_dev, &disp_plane_info, &caps),
1131                  "vkGetDisplayPlaneCapabilities2KHR: Invalid physicalDevice "
1132                  "\\[VUID-vkGetDisplayPlaneCapabilities2KHR-physicalDevice-parameter\\]");
1133 }
1134 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceCaps2KHR)1135 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceCaps2KHR) {
1136     FrameworkEnvironment env{};
1137     auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_get_surface_capabilities2"});
1138 
1139     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1140     VkPhysicalDeviceSurfaceInfo2KHR phys_dev_surf_info = {};
1141     phys_dev_surf_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
1142     phys_dev_surf_info.pNext = nullptr;
1143     VkSurfaceCapabilities2KHR caps = {};
1144     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfaceCapabilities2KHR(bad_physical_dev, &phys_dev_surf_info, &caps),
1145                  "vkGetPhysicalDeviceSurfaceCapabilities2KHR: Invalid physicalDevice "
1146                  "\\[VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-physicalDevice-parameter\\]");
1147 }
1148 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceFormats2KHR)1149 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceFormats2KHR) {
1150     FrameworkEnvironment env{};
1151     auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_get_surface_capabilities2"});
1152 
1153     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1154     VkPhysicalDeviceSurfaceInfo2KHR phys_dev_surf_info = {};
1155     phys_dev_surf_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
1156     phys_dev_surf_info.pNext = nullptr;
1157     uint32_t count = 0;
1158     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfaceFormats2KHR(bad_physical_dev, &phys_dev_surf_info, &count, nullptr),
1159                  "vkGetPhysicalDeviceSurfaceFormats2KHR: Invalid physicalDevice "
1160                  "\\[VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-physicalDevice-parameter\\]");
1161 }
1162 
TEST(LoaderHandleValidTests, BadPhysDevEnumPhysDevQueueFamilyPerfQueryCountersKHR)1163 TEST(LoaderHandleValidTests, BadPhysDevEnumPhysDevQueueFamilyPerfQueryCountersKHR) {
1164     FrameworkEnvironment env{};
1165     auto instance = setup_BadPhysDev_env(env, {});
1166 
1167     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1168     uint32_t count = 0;
1169     PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR pfn =
1170         instance.load("vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR");
1171     ASSERT_NE(pfn, nullptr);
1172     ASSERT_DEATH(pfn(bad_physical_dev, 0, &count, nullptr, nullptr),
1173                  "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR: Invalid physicalDevice "
1174                  "\\[VUID-vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR-physicalDevice-parameter\\]");
1175 }
1176 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamilyPerfQueryPassesKHR)1177 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamilyPerfQueryPassesKHR) {
1178     FrameworkEnvironment env{};
1179     auto instance = setup_BadPhysDev_env(env, {});
1180 
1181     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1182     VkQueryPoolPerformanceCreateInfoKHR create_info = {};
1183     create_info.sType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR;
1184     create_info.pNext = nullptr;
1185     uint32_t count = 0;
1186     PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR pfn =
1187         instance.load("vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR");
1188     ASSERT_NE(pfn, nullptr);
1189     ASSERT_DEATH(pfn(bad_physical_dev, &create_info, &count),
1190                  "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR: Invalid physicalDevice "
1191                  "\\[VUID-vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR-physicalDevice-parameter\\]");
1192 }
1193 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFragmentShadingRatesKHR)1194 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFragmentShadingRatesKHR) {
1195     FrameworkEnvironment env{};
1196     auto instance = setup_BadPhysDev_env(env, {});
1197 
1198     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1199     uint32_t count = 0;
1200     PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR pfn = instance.load("vkGetPhysicalDeviceFragmentShadingRatesKHR");
1201     ASSERT_NE(pfn, nullptr);
1202     ASSERT_DEATH(pfn(bad_physical_dev, &count, nullptr),
1203                  "vkGetPhysicalDeviceFragmentShadingRatesKHR: Invalid physicalDevice "
1204                  "\\[VUID-vkGetPhysicalDeviceFragmentShadingRatesKHR-physicalDevice-parameter\\]");
1205 }
1206 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevMSPropsEXT)1207 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevMSPropsEXT) {
1208     FrameworkEnvironment env{};
1209     auto instance = setup_BadPhysDev_env(env, {});
1210 
1211     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1212     VkMultisamplePropertiesEXT props = {};
1213     PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT pfn = instance.load("vkGetPhysicalDeviceMultisamplePropertiesEXT");
1214     ASSERT_NE(pfn, nullptr);
1215     ASSERT_DEATH(pfn(bad_physical_dev, VK_SAMPLE_COUNT_1_BIT, &props),
1216                  "vkGetPhysicalDeviceMultisamplePropertiesEXT: Invalid physicalDevice "
1217                  "\\[VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-physicalDevice-parameter\\]");
1218 }
1219 
TEST(LoaderHandleValidTests, BadPhysDevAcquireDrmDisplayEXT)1220 TEST(LoaderHandleValidTests, BadPhysDevAcquireDrmDisplayEXT) {
1221     FrameworkEnvironment env{};
1222     auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_EXT_acquire_drm_display"});
1223 
1224     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1225     PFN_vkAcquireDrmDisplayEXT pfn = instance.load("vkAcquireDrmDisplayEXT");
1226     ASSERT_NE(pfn, nullptr);
1227     ASSERT_DEATH(pfn(bad_physical_dev, 0, VK_NULL_HANDLE),
1228                  "vkAcquireDrmDisplayEXT: Invalid physicalDevice \\[VUID-vkAcquireDrmDisplayEXT-physicalDevice-parameter\\]");
1229 }
1230 
TEST(LoaderHandleValidTests, BadPhysDevGetDrmDisplayEXT)1231 TEST(LoaderHandleValidTests, BadPhysDevGetDrmDisplayEXT) {
1232     FrameworkEnvironment env{};
1233     auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_EXT_acquire_drm_display"});
1234 
1235     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1236     PFN_vkGetDrmDisplayEXT pfn = instance.load("vkGetDrmDisplayEXT");
1237     ASSERT_NE(pfn, nullptr);
1238     ASSERT_DEATH(pfn(bad_physical_dev, 0, 0, VK_NULL_HANDLE),
1239                  "vkGetDrmDisplayEXT: Invalid physicalDevice "
1240                  "\\[VUID-vkGetDrmDisplayEXT-physicalDevice-parameter\\]");
1241 }
1242 
TEST(LoaderHandleValidTests, BadPhysDevReleaseDisplayEXT)1243 TEST(LoaderHandleValidTests, BadPhysDevReleaseDisplayEXT) {
1244     FrameworkEnvironment env{};
1245     auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_EXT_direct_mode_display"});
1246 
1247     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1248     PFN_vkReleaseDisplayEXT pfn = instance.load("vkReleaseDisplayEXT");
1249     ASSERT_NE(pfn, nullptr);
1250     ASSERT_DEATH(pfn(bad_physical_dev, VK_NULL_HANDLE),
1251                  "vkReleaseDisplayEXT: Invalid physicalDevice \\[VUID-vkReleaseDisplayEXT-physicalDevice-parameter\\]");
1252 }
1253 
1254 #if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT)
TEST(LoaderHandleValidTests, BadPhysDevAcquireXlibDisplayEXT)1255 TEST(LoaderHandleValidTests, BadPhysDevAcquireXlibDisplayEXT) {
1256     FrameworkEnvironment env{};
1257     auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_EXT_acquire_xlib_display"});
1258 
1259     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1260     PFN_vkAcquireXlibDisplayEXT pfn = instance.load("vkAcquireXlibDisplayEXT");
1261     ASSERT_NE(pfn, nullptr);
1262     ASSERT_DEATH(pfn(bad_physical_dev, nullptr, VK_NULL_HANDLE),
1263                  "vkAcquireXlibDisplayEXT: Invalid physicalDevice \\[VUID-vkAcquireXlibDisplayEXT-physicalDevice-parameter\\]");
1264 }
1265 
TEST(LoaderHandleValidTests, BadPhysDevGetRandROutputDisplayEXT)1266 TEST(LoaderHandleValidTests, BadPhysDevGetRandROutputDisplayEXT) {
1267     FrameworkEnvironment env{};
1268     auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_EXT_acquire_xlib_display"});
1269 
1270     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1271     RROutput rrout = {};
1272     VkDisplayKHR disp;
1273     PFN_vkGetRandROutputDisplayEXT pfn = instance.load("vkGetRandROutputDisplayEXT");
1274     ASSERT_NE(pfn, nullptr);
1275     ASSERT_DEATH(
1276         pfn(bad_physical_dev, nullptr, rrout, &disp),
1277         "vkGetRandROutputDisplayEXT: Invalid physicalDevice \\[VUID-vkGetRandROutputDisplayEXT-physicalDevice-parameter\\]");
1278 }
1279 #endif  // VK_USE_PLATFORM_XLIB_XRANDR_EXT
1280 
1281 #if defined(VK_USE_PLATFORM_WIN32_KHR)
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfacePresentModes2EXT)1282 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfacePresentModes2EXT) {
1283     FrameworkEnvironment env{};
1284     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
1285 
1286     InstWrapper instance(env.vulkan_functions);
1287     instance.CheckCreate();
1288 
1289     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1290     VkPhysicalDeviceSurfaceInfo2KHR phys_dev_surf_info = {};
1291     phys_dev_surf_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
1292     phys_dev_surf_info.pNext = nullptr;
1293     uint32_t count = 0;
1294     PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT pfn = instance.load("vkGetPhysicalDeviceSurfacePresentModes2EXT");
1295     ASSERT_NE(pfn, nullptr);
1296     ASSERT_DEATH(pfn(bad_physical_dev, &phys_dev_surf_info, &count, nullptr),
1297                  "vkGetPhysicalDeviceSurfacePresentModes2EXT: Invalid physicalDevice "
1298                  "\\[VUID-vkGetPhysicalDeviceSurfacePresentModes2EXT-physicalDevice-parameter\\]");
1299 }
1300 #endif  // VK_USE_PLATFORM_WIN32_KHR
1301 
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevToolPropertiesEXT)1302 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevToolPropertiesEXT) {
1303     FrameworkEnvironment env{};
1304     auto instance = setup_BadPhysDev_env(env, {});
1305 
1306     auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1307     PFN_vkGetPhysicalDeviceToolPropertiesEXT pfn = instance.load("vkGetPhysicalDeviceToolPropertiesEXT");
1308     ASSERT_NE(pfn, nullptr);
1309     uint32_t count = 0;
1310     ASSERT_DEATH(pfn(bad_physical_dev, &count, nullptr),
1311                  "vkGetPhysicalDeviceToolPropertiesEXT: Invalid physicalDevice "
1312                  "\\[VUID-vkGetPhysicalDeviceToolPropertiesEXT-physicalDevice-parameter\\]");
1313 }
1314 
1315 #if defined(VK_USE_PLATFORM_ANDROID_KHR)
TEST(LoaderHandleValidTests, VerifyHandleWrappingAndroidSurface)1316 TEST(LoaderHandleValidTests, VerifyHandleWrappingAndroidSurface) {
1317     FrameworkEnvironment env{};
1318     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
1319 
1320     const char* wrap_objects_name = "WrapObjectsLayer";
1321     env.add_explicit_layer(ManifestLayer{}.add_layer(
1322                                ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1323                            "wrap_objects_layer.json");
1324 
1325     InstWrapper instance(env.vulkan_functions);
1326     instance.create_info.setup_WSI();
1327     instance.create_info.add_layer(wrap_objects_name);
1328     instance.CheckCreate();
1329 
1330     VkAndroidSurfaceCreateInfoKHR surf_create_info = {};
1331     surf_create_info.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
1332     surf_create_info.pNext = nullptr;
1333     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1334     PFN_vkCreateAndroidSurfaceKHR pfn_CreateSurface = instance.load("vkCreateAndroidSurfaceKHR");
1335     ASSERT_NE(pfn_CreateSurface, nullptr);
1336     PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1337     ASSERT_NE(pfn_DestroySurface, nullptr);
1338     ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1339     pfn_DestroySurface(instance, created_surface, nullptr);
1340 }
1341 #endif  // VK_USE_PLATFORM_ANDROID_KHR
1342 
1343 #if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
TEST(LoaderHandleValidTests, VerifyHandleWrappingDirectFBSurf)1344 TEST(LoaderHandleValidTests, VerifyHandleWrappingDirectFBSurf) {
1345     FrameworkEnvironment env{};
1346     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
1347 
1348     const char* wrap_objects_name = "WrapObjectsLayer";
1349     env.add_explicit_layer(ManifestLayer{}.add_layer(
1350                                ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1351                            "wrap_objects_layer.json");
1352 
1353     InstWrapper instance(env.vulkan_functions);
1354     instance.create_info.setup_WSI();
1355     instance.create_info.add_layer(wrap_objects_name);
1356     instance.CheckCreate();
1357 
1358     VkDirectFBSurfaceCreateInfoEXT surf_create_info = {};
1359     surf_create_info.sType = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT;
1360     surf_create_info.pNext = nullptr;
1361     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1362     PFN_vkCreateDirectFBSurfaceEXT pfn_CreateSurface = instance.load("vkCreateDirectFBSurfaceEXT");
1363     ASSERT_NE(pfn_CreateSurface, nullptr);
1364     PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1365     ASSERT_NE(pfn_DestroySurface, nullptr);
1366     ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1367     pfn_DestroySurface(instance, created_surface, nullptr);
1368 }
1369 #endif  // VK_USE_PLATFORM_DIRECTFB_EXT
1370 
1371 #if defined(VK_USE_PLATFORM_FUCHSIA)
TEST(LoaderHandleValidTests, VerifyHandleWrappingFuchsiaSurf)1372 TEST(LoaderHandleValidTests, VerifyHandleWrappingFuchsiaSurf) {
1373     FrameworkEnvironment env{};
1374     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
1375 
1376     const char* wrap_objects_name = "WrapObjectsLayer";
1377     env.add_explicit_layer(ManifestLayer{}.add_layer(
1378                                ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1379                            "wrap_objects_layer.json");
1380 
1381     InstWrapper instance(env.vulkan_functions);
1382     instance.create_info.setup_WSI();
1383     instance.create_info.add_layer(wrap_objects_name);
1384     instance.CheckCreate();
1385 
1386     VkImagePipeSurfaceCreateInfoFUCHSIA surf_create_info = {};
1387     surf_create_info.sType = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA;
1388     surf_create_info.pNext = nullptr;
1389     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1390     PFN_vkCreateImagePipeSurfaceFUCHSIA pfn_CreateSurface = instance.load("vkCreateImagePipeSurfaceFUCHSIA");
1391     ASSERT_NE(pfn_CreateSurface, nullptr);
1392     PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1393     ASSERT_NE(pfn_DestroySurface, nullptr);
1394     ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1395     pfn_DestroySurface(instance, created_surface, nullptr);
1396 }
1397 #endif  // VK_USE_PLATFORM_FUCHSIA
1398 
1399 #if defined(VK_USE_PLATFORM_GGP)
TEST(LoaderHandleValidTests, VerifyHandleWrappingGGPSurf)1400 TEST(LoaderHandleValidTests, VerifyHandleWrappingGGPSurf) {
1401     FrameworkEnvironment env{};
1402     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
1403 
1404     const char* wrap_objects_name = "WrapObjectsLayer";
1405     env.add_explicit_layer(ManifestLayer{}.add_layer(
1406                                ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1407                            "wrap_objects_layer.json");
1408 
1409     InstWrapper instance(env.vulkan_functions);
1410     instance.create_info.setup_WSI();
1411     instance.create_info.add_layer(wrap_objects_name);
1412     instance.CheckCreate();
1413 
1414     VkStreamDescriptorSurfaceCreateInfoGGP surf_create_info = {};
1415     surf_create_info.sType = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP;
1416     surf_create_info.pNext = nullptr;
1417     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1418     PFN_vkCreateStreamDescriptorSurfaceGGP pfn_CreateSurface = instance.load("vkCreateStreamDescriptorSurfaceGGP");
1419     ASSERT_NE(pfn_CreateSurface, nullptr);
1420     PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1421     ASSERT_NE(pfn_DestroySurface, nullptr);
1422     ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1423     pfn_DestroySurface(instance, created_surface, nullptr);
1424 }
1425 #endif  // VK_USE_PLATFORM_GGP
1426 
1427 #if defined(VK_USE_PLATFORM_IOS_MVK)
TEST(LoaderHandleValidTests, VerifyHandleWrappingIOSSurf)1428 TEST(LoaderHandleValidTests, VerifyHandleWrappingIOSSurf) {
1429     FrameworkEnvironment env{};
1430     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
1431 
1432     const char* wrap_objects_name = "WrapObjectsLayer";
1433     env.add_explicit_layer(ManifestLayer{}.add_layer(
1434                                ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1435                            "wrap_objects_layer.json");
1436 
1437     InstWrapper instance(env.vulkan_functions);
1438     instance.create_info.setup_WSI();
1439     instance.create_info.add_layer(wrap_objects_name);
1440     instance.CheckCreate();
1441 
1442     VkIOSSurfaceCreateInfoMVK surf_create_info = {};
1443     surf_create_info.sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK;
1444     surf_create_info.pNext = nullptr;
1445     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1446     PFN_vkCreateIOSSurfaceMVK pfn_CreateSurface = instance.load("vkCreateIOSSurfaceMVK");
1447     ASSERT_NE(pfn_CreateSurface, nullptr);
1448     PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1449     ASSERT_NE(pfn_DestroySurface, nullptr);
1450     ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1451     pfn_DestroySurface(instance, created_surface, nullptr);
1452 }
1453 #endif  // VK_USE_PLATFORM_IOS_MVK
1454 
1455 #if defined(VK_USE_PLATFORM_MACOS_MVK)
TEST(LoaderHandleValidTests, VerifyHandleWrappingMacOSSurf)1456 TEST(LoaderHandleValidTests, VerifyHandleWrappingMacOSSurf) {
1457     FrameworkEnvironment env{};
1458     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI("VK_USE_PLATFORM_MACOS_MVK");
1459 
1460     const char* wrap_objects_name = "WrapObjectsLayer";
1461     env.add_explicit_layer(ManifestLayer{}.add_layer(
1462                                ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1463                            "wrap_objects_layer.json");
1464 
1465     InstWrapper instance(env.vulkan_functions);
1466     instance.create_info.setup_WSI("VK_USE_PLATFORM_MACOS_MVK");
1467     instance.create_info.add_layer(wrap_objects_name);
1468     instance.CheckCreate();
1469 
1470     VkMacOSSurfaceCreateInfoMVK surf_create_info = {};
1471     surf_create_info.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
1472     surf_create_info.pNext = nullptr;
1473     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1474     PFN_vkCreateMacOSSurfaceMVK pfn_CreateSurface = instance.load("vkCreateMacOSSurfaceMVK");
1475     ASSERT_NE(pfn_CreateSurface, nullptr);
1476     PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1477     ASSERT_NE(pfn_DestroySurface, nullptr);
1478     ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1479     pfn_DestroySurface(instance, created_surface, nullptr);
1480 }
1481 #endif  // VK_USE_PLATFORM_MACOS_MVK
1482 
1483 #if defined(VK_USE_PLATFORM_METAL_EXT)
TEST(LoaderHandleValidTests, VerifyHandleWrappingMetalSurf)1484 TEST(LoaderHandleValidTests, VerifyHandleWrappingMetalSurf) {
1485     FrameworkEnvironment env{};
1486     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI("VK_USE_PLATFORM_METAL_EXT");
1487 
1488     const char* wrap_objects_name = "WrapObjectsLayer";
1489     env.add_explicit_layer(ManifestLayer{}.add_layer(
1490                                ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1491                            "wrap_objects_layer.json");
1492 
1493     InstWrapper instance(env.vulkan_functions);
1494     instance.create_info.setup_WSI("VK_USE_PLATFORM_METAL_EXT");
1495     instance.create_info.add_layer(wrap_objects_name);
1496     instance.CheckCreate();
1497 
1498     VkMetalSurfaceCreateInfoEXT surf_create_info = {};
1499     surf_create_info.sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT;
1500     surf_create_info.pNext = nullptr;
1501     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1502     PFN_vkCreateMetalSurfaceEXT pfn_CreateSurface = instance.load("vkCreateMetalSurfaceEXT");
1503     ASSERT_NE(pfn_CreateSurface, nullptr);
1504     PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1505     ASSERT_NE(pfn_DestroySurface, nullptr);
1506     ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1507     pfn_DestroySurface(instance, created_surface, nullptr);
1508 }
1509 #endif  // VK_USE_PLATFORM_METAL_EXT
1510 
1511 #if defined(VK_USE_PLATFORM_SCREEN_QNX)
TEST(LoaderHandleValidTests, VerifyHandleWrappingQNXSurf)1512 TEST(LoaderHandleValidTests, VerifyHandleWrappingQNXSurf) {
1513     FrameworkEnvironment env{};
1514     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
1515 
1516     const char* wrap_objects_name = "WrapObjectsLayer";
1517     env.add_explicit_layer(ManifestLayer{}.add_layer(
1518                                ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1519                            "wrap_objects_layer.json");
1520 
1521     InstWrapper instance(env.vulkan_functions);
1522     instance.create_info.setup_WSI();
1523     instance.create_info.add_layer(wrap_objects_name);
1524     instance.CheckCreate();
1525 
1526     VkScreenSurfaceCreateInfoQNX surf_create_info = {};
1527     surf_create_info.sType = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX;
1528     surf_create_info.pNext = nullptr;
1529     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1530     PFN_vkCreateScreenSurfaceQNX pfn_CreateSurface = instance.load("vkCreateScreenSurfaceQNX");
1531     ASSERT_NE(pfn_CreateSurface, nullptr);
1532     PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1533     ASSERT_NE(pfn_DestroySurface, nullptr);
1534     ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1535     pfn_DestroySurface(instance, created_surface, nullptr);
1536 }
1537 #endif  // VK_USE_PLATFORM_SCREEN_QNX
1538 
1539 #if defined(VK_USE_PLATFORM_VI_NN)
TEST(LoaderHandleValidTests, VerifyHandleWrappingViNNSurf)1540 TEST(LoaderHandleValidTests, VerifyHandleWrappingViNNSurf) {
1541     FrameworkEnvironment env{};
1542     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
1543 
1544     const char* wrap_objects_name = "WrapObjectsLayer";
1545     env.add_explicit_layer(ManifestLayer{}.add_layer(
1546                                ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1547                            "wrap_objects_layer.json");
1548 
1549     InstWrapper instance(env.vulkan_functions);
1550     instance.create_info.setup_WSI();
1551     instance.create_info.add_layer(wrap_objects_name);
1552     instance.CheckCreate();
1553 
1554     VkViSurfaceCreateInfoNN surf_create_info = {};
1555     surf_create_info.sType = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN;
1556     surf_create_info.pNext = nullptr;
1557     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1558     PFN_vkCreateViSurfaceNN pfn_CreateSurface = instance.load("vkCreateViSurfaceNN");
1559     ASSERT_NE(pfn_CreateSurface, nullptr);
1560     PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1561     ASSERT_NE(pfn_DestroySurface, nullptr);
1562     ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1563     pfn_DestroySurface(instance, created_surface, nullptr);
1564 }
1565 #endif  // VK_USE_PLATFORM_VI_NN
1566 
1567 #if defined(VK_USE_PLATFORM_WAYLAND_KHR)
TEST(LoaderHandleValidTests, VerifyHandleWrappingWaylandSurf)1568 TEST(LoaderHandleValidTests, VerifyHandleWrappingWaylandSurf) {
1569     FrameworkEnvironment env{};
1570     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI("VK_USE_PLATFORM_WAYLAND_KHR");
1571 
1572     const char* wrap_objects_name = "WrapObjectsLayer";
1573     env.add_explicit_layer(ManifestLayer{}.add_layer(
1574                                ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1575                            "wrap_objects_layer.json");
1576 
1577     InstWrapper instance(env.vulkan_functions);
1578     instance.create_info.setup_WSI("VK_USE_PLATFORM_WAYLAND_KHR");
1579     instance.create_info.add_layer(wrap_objects_name);
1580     instance.CheckCreate();
1581 
1582     VkWaylandSurfaceCreateInfoKHR surf_create_info = {};
1583     surf_create_info.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
1584     surf_create_info.pNext = nullptr;
1585     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1586     PFN_vkCreateWaylandSurfaceKHR pfn_CreateSurface = instance.load("vkCreateWaylandSurfaceKHR");
1587     ASSERT_NE(pfn_CreateSurface, nullptr);
1588     PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1589     ASSERT_NE(pfn_DestroySurface, nullptr);
1590     ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1591     pfn_DestroySurface(instance, created_surface, nullptr);
1592 }
1593 #endif  // VK_USE_PLATFORM_WAYLAND_KHR
1594 
1595 #if defined(VK_USE_PLATFORM_WIN32_KHR)
TEST(LoaderHandleValidTests, VerifyHandleWrappingWin32Surf)1596 TEST(LoaderHandleValidTests, VerifyHandleWrappingWin32Surf) {
1597     FrameworkEnvironment env{};
1598     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
1599 
1600     const char* wrap_objects_name = "WrapObjectsLayer";
1601     env.add_explicit_layer(ManifestLayer{}.add_layer(
1602                                ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1603                            "wrap_objects_layer.json");
1604 
1605     InstWrapper instance(env.vulkan_functions);
1606     instance.create_info.setup_WSI();
1607     instance.create_info.add_layer(wrap_objects_name);
1608     instance.CheckCreate();
1609 
1610     VkWin32SurfaceCreateInfoKHR surf_create_info = {};
1611     surf_create_info.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
1612     surf_create_info.pNext = nullptr;
1613     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1614     PFN_vkCreateWin32SurfaceKHR pfn_CreateSurface = instance.load("vkCreateWin32SurfaceKHR");
1615     ASSERT_NE(pfn_CreateSurface, nullptr);
1616     PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1617     ASSERT_NE(pfn_DestroySurface, nullptr);
1618     ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1619     pfn_DestroySurface(instance, created_surface, nullptr);
1620 }
1621 #endif  // VK_USE_PLATFORM_WIN32_KHR
1622 
1623 #if defined(VK_USE_PLATFORM_XCB_KHR)
TEST(LoaderHandleValidTests, VerifyHandleWrappingXCBSurf)1624 TEST(LoaderHandleValidTests, VerifyHandleWrappingXCBSurf) {
1625     FrameworkEnvironment env{};
1626     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();
1627 
1628     const char* wrap_objects_name = "WrapObjectsLayer";
1629     env.add_explicit_layer(ManifestLayer{}.add_layer(
1630                                ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1631                            "wrap_objects_layer.json");
1632 
1633     InstWrapper instance(env.vulkan_functions);
1634     instance.create_info.setup_WSI();
1635     instance.create_info.add_layer(wrap_objects_name);
1636     instance.CheckCreate();
1637 
1638     VkXcbSurfaceCreateInfoKHR surf_create_info = {};
1639     surf_create_info.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
1640     surf_create_info.pNext = nullptr;
1641     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1642     PFN_vkCreateXcbSurfaceKHR pfn_CreateSurface = instance.load("vkCreateXcbSurfaceKHR");
1643     ASSERT_NE(pfn_CreateSurface, nullptr);
1644     PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1645     ASSERT_NE(pfn_DestroySurface, nullptr);
1646     ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1647     pfn_DestroySurface(instance, created_surface, nullptr);
1648 }
1649 #endif  // VK_USE_PLATFORM_XCB_KHR
1650 
1651 #if defined(VK_USE_PLATFORM_XLIB_KHR)
TEST(LoaderHandleValidTests, VerifyHandleWrappingXlibSurf)1652 TEST(LoaderHandleValidTests, VerifyHandleWrappingXlibSurf) {
1653     FrameworkEnvironment env{};
1654     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI("VK_USE_PLATFORM_XLIB_KHR");
1655 
1656     const char* wrap_objects_name = "WrapObjectsLayer";
1657     env.add_explicit_layer(ManifestLayer{}.add_layer(
1658                                ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1659                            "wrap_objects_layer.json");
1660 
1661     InstWrapper instance(env.vulkan_functions);
1662     instance.create_info.setup_WSI("VK_USE_PLATFORM_XLIB_KHR");
1663     //
1664     for (auto& ext : instance.create_info.enabled_extensions) {
1665         std::cout << ext << "\n";
1666     }
1667     instance.create_info.add_layer(wrap_objects_name);
1668     instance.CheckCreate();
1669 
1670     VkXlibSurfaceCreateInfoKHR surf_create_info = {};
1671     surf_create_info.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
1672     surf_create_info.pNext = nullptr;
1673     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1674     PFN_vkCreateXlibSurfaceKHR pfn_CreateSurface = instance.load("vkCreateXlibSurfaceKHR");
1675     ASSERT_NE(pfn_CreateSurface, nullptr);
1676     PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1677     ASSERT_NE(pfn_DestroySurface, nullptr);
1678     ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1679     pfn_DestroySurface(instance, created_surface, nullptr);
1680 }
1681 #endif  // VK_USE_PLATFORM_XLIB_KHR
1682 
JunkDebugUtilsCallback([[maybe_unused]] VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, [[maybe_unused]] VkDebugUtilsMessageTypeFlagsEXT messageTypes, [[maybe_unused]] const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, [[maybe_unused]] void* pUserData)1683 VKAPI_ATTR VkBool32 VKAPI_CALL JunkDebugUtilsCallback([[maybe_unused]] VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
1684                                                       [[maybe_unused]] VkDebugUtilsMessageTypeFlagsEXT messageTypes,
1685                                                       [[maybe_unused]] const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
1686                                                       [[maybe_unused]] void* pUserData) {
1687     // This is just a stub callback in case the loader or any other layer triggers it.
1688     return VK_FALSE;
1689 }
1690 
TEST(LoaderHandleValidTests, VerifyHandleWrappingDebugUtilsMessenger)1691 TEST(LoaderHandleValidTests, VerifyHandleWrappingDebugUtilsMessenger) {
1692     FrameworkEnvironment env{};
1693     Extension ext{"VK_EXT_debug_utils"};
1694     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_instance_extensions({ext});
1695 
1696     const char* wrap_objects_name = "WrapObjectsLayer";
1697     env.add_explicit_layer(ManifestLayer{}.add_layer(
1698                                ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1699                            "wrap_objects_layer.json");
1700 
1701     InstWrapper instance(env.vulkan_functions);
1702     instance.create_info.add_extension("VK_EXT_debug_utils");
1703     instance.create_info.add_layer(wrap_objects_name);
1704     instance.CheckCreate();
1705 
1706     VkDebugUtilsMessengerCreateInfoEXT debug_messenger_create_info = {};
1707     debug_messenger_create_info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
1708     debug_messenger_create_info.pNext = nullptr;
1709     debug_messenger_create_info.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
1710     debug_messenger_create_info.messageType =
1711         VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT;
1712     debug_messenger_create_info.pfnUserCallback = reinterpret_cast<PFN_vkDebugUtilsMessengerCallbackEXT>(JunkDebugUtilsCallback);
1713     VkDebugUtilsMessengerEXT messenger = VK_NULL_HANDLE;
1714     PFN_vkCreateDebugUtilsMessengerEXT pfn_CreateMessenger = instance.load("vkCreateDebugUtilsMessengerEXT");
1715     ASSERT_NE(pfn_CreateMessenger, nullptr);
1716     PFN_vkDestroyDebugUtilsMessengerEXT pfn_DestroyMessenger = instance.load("vkDestroyDebugUtilsMessengerEXT");
1717     ASSERT_NE(pfn_DestroyMessenger, nullptr);
1718     ASSERT_EQ(VK_SUCCESS, pfn_CreateMessenger(instance, &debug_messenger_create_info, nullptr, &messenger));
1719     pfn_DestroyMessenger(instance, messenger, nullptr);
1720 }
1721