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));
45 auto& driver = env.get_test_icd();
46 driver.physical_devices.emplace_back("physical_device_0");
47
48 InstWrapper instance(env.vulkan_functions);
49 instance.CheckCreate();
50
51 auto bad_instance = get_bad_handle<VkInstance>();
52 uint32_t returned_physical_count = 0;
53
54 ASSERT_DEATH(env.vulkan_functions.vkEnumeratePhysicalDevices(bad_instance, &returned_physical_count, nullptr),
55 "vkEnumeratePhysicalDevices: Invalid instance \\[VUID-vkEnumeratePhysicalDevices-instance-parameter\\]");
56 }
57
TEST(LoaderHandleValidTests,BadInstGetInstProcAddr)58 TEST(LoaderHandleValidTests, BadInstGetInstProcAddr) {
59 FrameworkEnvironment env{};
60 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
61 auto& driver = env.get_test_icd();
62 driver.physical_devices.emplace_back("physical_device_0");
63
64 InstWrapper instance(env.vulkan_functions);
65 instance.CheckCreate();
66
67 auto bad_instance = get_bad_handle<VkInstance>();
68 ASSERT_DEATH(env.vulkan_functions.vkGetInstanceProcAddr(bad_instance, "vkGetBufferDeviceAddress"),
69 "vkGetInstanceProcAddr: Invalid instance \\[VUID-vkGetInstanceProcAddr-instance-parameter\\]");
70 }
71
TEST(LoaderHandleValidTests,BadInstDestroyInstance)72 TEST(LoaderHandleValidTests, BadInstDestroyInstance) {
73 FrameworkEnvironment env{};
74 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
75 auto& driver = env.get_test_icd();
76 driver.physical_devices.emplace_back("physical_device_0");
77
78 InstWrapper instance(env.vulkan_functions);
79 instance.CheckCreate();
80
81 auto bad_instance = get_bad_handle<VkInstance>();
82
83 ASSERT_DEATH(env.vulkan_functions.vkDestroyInstance(bad_instance, nullptr),
84 "vkDestroyInstance: Invalid instance \\[VUID-vkDestroyInstance-instance-parameter\\]");
85 }
86
TEST(LoaderHandleValidTests,BadInstDestroySurface)87 TEST(LoaderHandleValidTests, BadInstDestroySurface) {
88 FrameworkEnvironment env{};
89 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
90 Extension first_ext{"VK_KHR_surface"};
91 Extension second_ext{"VK_EXT_headless_surface"};
92 auto& driver = env.get_test_icd();
93 driver.add_instance_extensions({first_ext, second_ext});
94 driver.physical_devices.emplace_back("physical_device_0");
95
96 InstWrapper instance(env.vulkan_functions);
97 instance.create_info.add_extension("VK_KHR_surface");
98 instance.CheckCreate();
99
100 auto bad_instance = get_bad_handle<VkInstance>();
101
102 ASSERT_DEATH(env.vulkan_functions.vkDestroySurfaceKHR(bad_instance, VK_NULL_HANDLE, nullptr),
103 "vkDestroySurfaceKHR: Invalid instance \\[VUID-vkDestroySurfaceKHR-instance-parameter\\]");
104 }
105
TEST(LoaderHandleValidTests,BadInstCreateHeadlessSurf)106 TEST(LoaderHandleValidTests, BadInstCreateHeadlessSurf) {
107 FrameworkEnvironment env{};
108 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
109 Extension first_ext{"VK_KHR_surface"};
110 Extension second_ext{"VK_EXT_headless_surface"};
111 auto& driver = env.get_test_icd();
112 driver.add_instance_extensions({first_ext, second_ext});
113 driver.physical_devices.emplace_back("physical_device_0");
114
115 InstWrapper instance(env.vulkan_functions);
116 instance.create_info.add_extension("VK_KHR_surface");
117 instance.create_info.add_extension("VK_EXT_headless_surface");
118 instance.CheckCreate();
119
120 auto bad_instance = get_bad_handle<VkInstance>();
121
122 VkHeadlessSurfaceCreateInfoEXT surf_create_info = {};
123 surf_create_info.sType = VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT;
124 surf_create_info.pNext = nullptr;
125 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
126 ASSERT_DEATH(env.vulkan_functions.vkCreateHeadlessSurfaceEXT(bad_instance, &surf_create_info, nullptr, &created_surface),
127 "vkCreateHeadlessSurfaceEXT: Invalid instance \\[VUID-vkCreateHeadlessSurfaceEXT-instance-parameter\\]");
128 }
129
TEST(LoaderHandleValidTests,BadInstCreateDisplayPlaneSurf)130 TEST(LoaderHandleValidTests, BadInstCreateDisplayPlaneSurf) {
131 FrameworkEnvironment env{};
132 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
133 Extension first_ext{"VK_KHR_surface"};
134 Extension second_ext{"VK_KHR_display"};
135 auto& driver = env.get_test_icd();
136 driver.add_instance_extensions({first_ext, second_ext});
137 driver.physical_devices.emplace_back("physical_device_0");
138
139 InstWrapper instance(env.vulkan_functions);
140 instance.create_info.add_extension("VK_KHR_surface");
141 instance.create_info.add_extension("VK_KHR_display");
142 instance.CheckCreate();
143
144 auto bad_instance = get_bad_handle<VkInstance>();
145
146 VkDisplaySurfaceCreateInfoKHR surf_create_info = {};
147 surf_create_info.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
148 surf_create_info.pNext = nullptr;
149 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
150 ASSERT_DEATH(env.vulkan_functions.vkCreateDisplayPlaneSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
151 "vkCreateDisplayPlaneSurfaceKHR: Invalid instance \\[VUID-vkCreateDisplayPlaneSurfaceKHR-instance-parameter\\]");
152 }
153
154 #ifdef VK_USE_PLATFORM_ANDROID_KHR
TEST(LoaderHandleValidTests,BadInstCreateAndroidSurf)155 TEST(LoaderHandleValidTests, BadInstCreateAndroidSurf) {
156 FrameworkEnvironment env{};
157 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
158 auto& driver = env.get_test_icd();
159 setup_WSI_in_ICD(driver);
160 driver.physical_devices.emplace_back("physical_device_0");
161
162 InstWrapper instance(env.vulkan_functions);
163 setup_WSI_in_create_instance(instance);
164 instance.CheckCreate();
165
166 auto bad_instance = get_bad_handle<VkInstance>();
167
168 VkAndroidSurfaceCreateInfoKHR surf_create_info = {};
169 surf_create_info.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
170 surf_create_info.pNext = nullptr;
171 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
172 ASSERT_DEATH(env.vulkan_functions.vkCreateAndroidSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
173 "vkCreateAndroidSurfaceKHR: Invalid instance \\[VUID-vkCreateAndroidSurfaceKHR-instance-parameter\\]");
174 }
175 #endif // VK_USE_PLATFORM_ANDROID_KHR
176
177 #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
TEST(LoaderHandleValidTests,BadInstCreateDirectFBSurf)178 TEST(LoaderHandleValidTests, BadInstCreateDirectFBSurf) {
179 FrameworkEnvironment env{};
180 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
181 auto& driver = env.get_test_icd();
182 setup_WSI_in_ICD(driver);
183 driver.physical_devices.emplace_back("physical_device_0");
184
185 InstWrapper instance(env.vulkan_functions);
186 setup_WSI_in_create_instance(instance);
187 instance.CheckCreate();
188
189 auto bad_instance = get_bad_handle<VkInstance>();
190
191 VkDirectFBSurfaceCreateInfoEXT surf_create_info = {};
192 surf_create_info.sType = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT;
193 surf_create_info.pNext = nullptr;
194 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
195 ASSERT_DEATH(env.vulkan_functions.vkCreateDirectFBSurfaceEXT(bad_instance, &surf_create_info, nullptr, &created_surface),
196 "vkCreateDirectFBSurfaceEXT: Invalid instance \\[VUID-vkCreateDirectFBSurfaceEXT-instance-parameter\\]");
197 }
198 #endif // VK_USE_PLATFORM_DIRECTFB_EXT
199
200 #ifdef VK_USE_PLATFORM_FUCHSIA
TEST(LoaderHandleValidTests,BadInstCreateFuchsiaSurf)201 TEST(LoaderHandleValidTests, BadInstCreateFuchsiaSurf) {
202 FrameworkEnvironment env{};
203 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
204 auto& driver = env.get_test_icd();
205 setup_WSI_in_ICD(driver);
206 driver.physical_devices.emplace_back("physical_device_0");
207
208 InstWrapper instance(env.vulkan_functions);
209 setup_WSI_in_create_instance(instance);
210 instance.CheckCreate();
211
212 auto bad_instance = get_bad_handle<VkInstance>();
213
214 VkImagePipeSurfaceCreateInfoFUCHSIA surf_create_info = {};
215 surf_create_info.sType = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA;
216 surf_create_info.pNext = nullptr;
217 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
218 ASSERT_DEATH(env.vulkan_functions.vkCreateImagePipeSurfaceFUCHSIA(bad_instance, &surf_create_info, nullptr, &created_surface),
219 "vkCreateImagePipeSurfaceFUCHSIA: Invalid instance \\[VUID-vkCreateImagePipeSurfaceFUCHSIA-instance-parameter\\]");
220 }
221 #endif // VK_USE_PLATFORM_FUCHSIA
222
223 #ifdef VK_USE_PLATFORM_GGP
TEST(LoaderHandleValidTests,BadInstCreateGGPSurf)224 TEST(LoaderHandleValidTests, BadInstCreateGGPSurf) {
225 FrameworkEnvironment env{};
226 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
227 auto& driver = env.get_test_icd();
228 setup_WSI_in_ICD(driver);
229 driver.physical_devices.emplace_back("physical_device_0");
230
231 InstWrapper instance(env.vulkan_functions);
232 setup_WSI_in_create_instance(instance);
233 instance.CheckCreate();
234
235 auto bad_instance = get_bad_handle<VkInstance>();
236
237 VkStreamDescriptorSurfaceCreateInfoGGP surf_create_info = {};
238 surf_create_info.sType = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP;
239 surf_create_info.pNext = nullptr;
240 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
241 ASSERT_DEATH(
242 env.vulkan_functions.vkCreateStreamDescriptorSurfaceGGP(bad_instance, &surf_create_info, nullptr, &created_surface),
243 "vkCreateStreamDescriptorSurfaceGGP: Invalid instance \\[VUID-vkCreateStreamDescriptorSurfaceGGP-instance-parameter\\]");
244 }
245 #endif // VK_USE_PLATFORM_GGP
246
247 #ifdef VK_USE_PLATFORM_IOS_MVK
TEST(LoaderHandleValidTests,BadInstCreateIOSSurf)248 TEST(LoaderHandleValidTests, BadInstCreateIOSSurf) {
249 FrameworkEnvironment env{};
250 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
251 auto& driver = env.get_test_icd();
252 setup_WSI_in_ICD(driver);
253 driver.physical_devices.emplace_back("physical_device_0");
254
255 InstWrapper instance(env.vulkan_functions);
256 setup_WSI_in_create_instance(instance);
257 instance.CheckCreate();
258
259 auto bad_instance = get_bad_handle<VkInstance>();
260
261 VkIOSSurfaceCreateInfoMVK surf_create_info = {};
262 surf_create_info.sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK;
263 surf_create_info.pNext = nullptr;
264 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
265 ASSERT_DEATH(env.vulkan_functions.vkCreateIOSSurfaceMVK(bad_instance, &surf_create_info, nullptr, &created_surface),
266 "vkCreateIOSSurfaceMVK: Invalid instance \\[VUID-vkCreateIOSSurfaceMVK-instance-parameter\\]");
267 }
268 #endif // VK_USE_PLATFORM_IOS_MVK
269
270 #ifdef VK_USE_PLATFORM_MACOS_MVK
TEST(LoaderHandleValidTests,BadInstCreateMacOSSurf)271 TEST(LoaderHandleValidTests, BadInstCreateMacOSSurf) {
272 FrameworkEnvironment env{};
273 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
274 auto& driver = env.get_test_icd();
275 setup_WSI_in_ICD(driver);
276 driver.physical_devices.emplace_back("physical_device_0");
277
278 InstWrapper instance(env.vulkan_functions);
279 setup_WSI_in_create_instance(instance);
280 instance.CheckCreate();
281
282 auto bad_instance = get_bad_handle<VkInstance>();
283
284 VkMacOSSurfaceCreateInfoMVK surf_create_info = {};
285 surf_create_info.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
286 surf_create_info.pNext = nullptr;
287 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
288 ASSERT_DEATH(env.vulkan_functions.vkCreateMacOSSurfaceMVK(bad_instance, &surf_create_info, nullptr, &created_surface),
289 "vkCreateMacOSSurfaceMVK: Invalid instance \\[VUID-vkCreateMacOSSurfaceMVK-instance-parameter\\]");
290 }
291 #endif // VK_USE_PLATFORM_MACOS_MVK
292
293 #if defined(VK_USE_PLATFORM_METAL_EXT)
TEST(LoaderHandleValidTests,BadInstCreateMetalSurf)294 TEST(LoaderHandleValidTests, BadInstCreateMetalSurf) {
295 FrameworkEnvironment env{};
296 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
297 auto& driver = env.get_test_icd();
298 setup_WSI_in_ICD(driver);
299 driver.physical_devices.emplace_back("physical_device_0");
300
301 InstWrapper instance(env.vulkan_functions);
302 setup_WSI_in_create_instance(instance);
303 instance.CheckCreate();
304
305 auto bad_instance = get_bad_handle<VkInstance>();
306
307 VkMetalSurfaceCreateInfoEXT surf_create_info = {};
308 surf_create_info.sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT;
309 surf_create_info.pNext = nullptr;
310 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
311 ASSERT_DEATH(env.vulkan_functions.vkCreateMetalSurfaceEXT(bad_instance, &surf_create_info, nullptr, &created_surface),
312 "vkCreateMetalSurfaceEXT: Invalid instance \\[VUID-vkCreateMetalSurfaceEXT-instance-parameter\\]");
313 }
314 #endif // VK_USE_PLATFORM_METAL_EXT
315
316 #ifdef VK_USE_PLATFORM_SCREEN_QNX
TEST(LoaderHandleValidTests,BadInstCreateQNXSurf)317 TEST(LoaderHandleValidTests, BadInstCreateQNXSurf) {
318 FrameworkEnvironment env{};
319 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
320 auto& driver = env.get_test_icd();
321 setup_WSI_in_ICD(driver);
322 driver.physical_devices.emplace_back("physical_device_0");
323
324 InstWrapper instance(env.vulkan_functions);
325 setup_WSI_in_create_instance(instance);
326 instance.CheckCreate();
327
328 auto bad_instance = get_bad_handle<VkInstance>();
329
330 VkScreenSurfaceCreateInfoQNX surf_create_info = {};
331 surf_create_info.sType = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX;
332 surf_create_info.pNext = nullptr;
333 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
334 ASSERT_DEATH(env.vulkan_functions.vkCreateScreenSurfaceQNX(bad_instance, &surf_create_info, nullptr, &created_surface),
335 "vkCreateScreenSurfaceQNX: Invalid instance \\[VUID-vkCreateScreenSurfaceQNX-instance-parameter\\]");
336 // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
337 }
338 #endif // VK_USE_PLATFORM_SCREEN_QNX
339
340 #ifdef VK_USE_PLATFORM_VI_NN
TEST(LoaderHandleValidTests,BadInstCreateViNNSurf)341 TEST(LoaderHandleValidTests, BadInstCreateViNNSurf) {
342 FrameworkEnvironment env{};
343 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
344 auto& driver = env.get_test_icd();
345 setup_WSI_in_ICD(driver);
346 driver.physical_devices.emplace_back("physical_device_0");
347
348 InstWrapper instance(env.vulkan_functions);
349 setup_WSI_in_create_instance(instance);
350 instance.CheckCreate();
351
352 auto bad_instance = get_bad_handle<VkInstance>();
353
354 VkViSurfaceCreateInfoNN surf_create_info = {};
355 surf_create_info.sType = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN;
356 surf_create_info.pNext = nullptr;
357 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
358 ASSERT_DEATH(env.vulkan_functions.vkCreateViSurfaceNN(bad_instance, &surf_create_info, nullptr, &created_surface),
359 "vkCreateViSurfaceNN: Invalid instance \\[VUID-vkCreateViSurfaceNN-instance-parameter\\]");
360 // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
361 }
362 #endif // VK_USE_PLATFORM_VI_NN
363
364 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
TEST(LoaderHandleValidTests,BadInstCreateWaylandSurf)365 TEST(LoaderHandleValidTests, BadInstCreateWaylandSurf) {
366 FrameworkEnvironment env{};
367 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
368 auto& driver = env.get_test_icd();
369 setup_WSI_in_ICD(driver);
370 driver.physical_devices.emplace_back("physical_device_0");
371
372 InstWrapper instance(env.vulkan_functions);
373 setup_WSI_in_create_instance(instance);
374 instance.CheckCreate();
375
376 auto bad_instance = get_bad_handle<VkInstance>();
377
378 VkWaylandSurfaceCreateInfoKHR surf_create_info = {};
379 surf_create_info.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
380 surf_create_info.pNext = nullptr;
381 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
382 ASSERT_DEATH(env.vulkan_functions.vkCreateWaylandSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
383 "vkCreateWaylandSurfaceKHR: Invalid instance \\[VUID-vkCreateWaylandSurfaceKHR-instance-parameter\\]");
384 // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
385 }
386 #endif // VK_USE_PLATFORM_WAYLAND_KHR
387
388 #ifdef VK_USE_PLATFORM_WIN32_KHR
TEST(LoaderHandleValidTests,BadInstCreateWin32Surf)389 TEST(LoaderHandleValidTests, BadInstCreateWin32Surf) {
390 FrameworkEnvironment env{};
391 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
392 auto& driver = env.get_test_icd();
393 setup_WSI_in_ICD(driver);
394 driver.physical_devices.emplace_back("physical_device_0");
395
396 InstWrapper instance(env.vulkan_functions);
397 setup_WSI_in_create_instance(instance);
398 instance.CheckCreate();
399
400 auto bad_instance = get_bad_handle<VkInstance>();
401
402 VkWin32SurfaceCreateInfoKHR surf_create_info = {};
403 surf_create_info.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
404 surf_create_info.pNext = nullptr;
405 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
406 ASSERT_DEATH(env.vulkan_functions.vkCreateWin32SurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
407 "vkCreateWin32SurfaceKHR: Invalid instance \\[VUID-vkCreateWin32SurfaceKHR-instance-parameter\\]");
408 // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
409 }
410 #endif // VK_USE_PLATFORM_WIN32_KHR
411
412 #ifdef VK_USE_PLATFORM_XCB_KHR
TEST(LoaderHandleValidTests,BadInstCreateXCBSurf)413 TEST(LoaderHandleValidTests, BadInstCreateXCBSurf) {
414 FrameworkEnvironment env{};
415 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
416 auto& driver = env.get_test_icd();
417 setup_WSI_in_ICD(driver);
418 driver.physical_devices.emplace_back("physical_device_0");
419
420 InstWrapper instance(env.vulkan_functions);
421 setup_WSI_in_create_instance(instance);
422 instance.CheckCreate();
423
424 auto bad_instance = get_bad_handle<VkInstance>();
425
426 VkXcbSurfaceCreateInfoKHR surf_create_info = {};
427 surf_create_info.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
428 surf_create_info.pNext = nullptr;
429 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
430 ASSERT_DEATH(env.vulkan_functions.vkCreateXcbSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
431 "vkCreateXcbSurfaceKHR: Invalid instance \\[VUID-vkCreateXcbSurfaceKHR-instance-parameter\\]");
432 // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
433 }
434 #endif // VK_USE_PLATFORM_XCB_KHR
435
436 #ifdef VK_USE_PLATFORM_XLIB_KHR
TEST(LoaderHandleValidTests,BadInstCreateXlibSurf)437 TEST(LoaderHandleValidTests, BadInstCreateXlibSurf) {
438 FrameworkEnvironment env{};
439 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
440 auto& driver = env.get_test_icd();
441 setup_WSI_in_ICD(driver);
442 driver.physical_devices.emplace_back("physical_device_0");
443
444 InstWrapper instance(env.vulkan_functions);
445 setup_WSI_in_create_instance(instance);
446 instance.CheckCreate();
447
448 auto bad_instance = get_bad_handle<VkInstance>();
449
450 VkXlibSurfaceCreateInfoKHR surf_create_info = {};
451 surf_create_info.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
452 surf_create_info.pNext = nullptr;
453 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
454 ASSERT_DEATH(env.vulkan_functions.vkCreateXlibSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
455 "vkCreateXlibSurfaceKHR: Invalid instance \\[VUID-vkCreateXlibSurfaceKHR-instance-parameter\\]");
456 // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
457 }
458 #endif // VK_USE_PLATFORM_XLIB_KHR
459
460 // ---- Invalid Physical Device tests
461
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevFeature)462 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFeature) {
463 FrameworkEnvironment env{};
464 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
465 env.get_test_icd().physical_devices.push_back({});
466 env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
467
468 InstWrapper instance(env.vulkan_functions);
469 instance.create_info.set_api_version(1, 1, 0);
470 instance.CheckCreate();
471
472 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
473
474 VkPhysicalDeviceFeatures features = {};
475 ASSERT_DEATH(
476 env.vulkan_functions.vkGetPhysicalDeviceFeatures(bad_physical_dev, &features),
477 "vkGetPhysicalDeviceFeatures: Invalid physicalDevice \\[VUID-vkGetPhysicalDeviceFeatures-physicalDevice-parameter\\]");
478 }
479
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevFormatProps)480 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFormatProps) {
481 FrameworkEnvironment env{};
482 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
483 env.get_test_icd().physical_devices.push_back({});
484 env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
485
486 InstWrapper instance(env.vulkan_functions);
487 instance.create_info.set_api_version(1, 1, 0);
488 instance.CheckCreate();
489
490 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
491
492 VkFormatProperties format_info = {};
493 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceFormatProperties(bad_physical_dev, VK_FORMAT_R8G8B8A8_UNORM, &format_info),
494 "vkGetPhysicalDeviceFormatProperties: Invalid physicalDevice "
495 "\\[VUID-vkGetPhysicalDeviceFormatProperties-physicalDevice-parameter\\]");
496 }
497
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevImgFormatProps)498 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevImgFormatProps) {
499 FrameworkEnvironment env{};
500 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
501 env.get_test_icd().physical_devices.push_back({});
502 env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
503
504 InstWrapper instance(env.vulkan_functions);
505 instance.create_info.set_api_version(1, 1, 0);
506 instance.CheckCreate();
507
508 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
509
510 VkImageFormatProperties format_info = {};
511 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceImageFormatProperties(bad_physical_dev, VK_FORMAT_R8G8B8A8_UNORM,
512 VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_LINEAR,
513 VK_IMAGE_USAGE_STORAGE_BIT, 0, &format_info),
514 "vkGetPhysicalDeviceImageFormatProperties: Invalid physicalDevice "
515 "\\[VUID-vkGetPhysicalDeviceImageFormatProperties-physicalDevice-parameter\\]");
516 }
517
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevProps)518 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevProps) {
519 FrameworkEnvironment env{};
520 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
521 env.get_test_icd().physical_devices.push_back({});
522 env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
523
524 InstWrapper instance(env.vulkan_functions);
525 instance.create_info.set_api_version(1, 1, 0);
526 instance.CheckCreate();
527
528 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
529
530 VkPhysicalDeviceProperties properties = {};
531 ASSERT_DEATH(
532 env.vulkan_functions.vkGetPhysicalDeviceProperties(bad_physical_dev, &properties),
533 "vkGetPhysicalDeviceProperties: Invalid physicalDevice \\[VUID-vkGetPhysicalDeviceProperties-physicalDevice-parameter\\]");
534 }
535
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevQueueFamProps)536 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamProps) {
537 FrameworkEnvironment env{};
538 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
539 env.get_test_icd().physical_devices.push_back({});
540 env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
541
542 InstWrapper instance(env.vulkan_functions);
543 instance.create_info.set_api_version(1, 1, 0);
544 instance.CheckCreate();
545
546 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
547 uint32_t count = 0;
548 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(bad_physical_dev, &count, nullptr),
549 "vkGetPhysicalDeviceQueueFamilyProperties: Invalid physicalDevice "
550 "\\[VUID-vkGetPhysicalDeviceQueueFamilyProperties-physicalDevice-parameter\\]");
551 }
552
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevDevMemProps)553 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDevMemProps) {
554 FrameworkEnvironment env{};
555 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
556 env.get_test_icd().physical_devices.push_back({});
557 env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
558
559 InstWrapper instance(env.vulkan_functions);
560 instance.create_info.set_api_version(1, 1, 0);
561 instance.CheckCreate();
562
563 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
564
565 VkPhysicalDeviceMemoryProperties properties = {};
566 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceMemoryProperties(bad_physical_dev, &properties),
567 "vkGetPhysicalDeviceMemoryProperties: Invalid physicalDevice "
568 "\\[VUID-vkGetPhysicalDeviceMemoryProperties-physicalDevice-parameter\\]");
569 }
570
TEST(LoaderHandleValidTests,BadPhysDevCreateDevice)571 TEST(LoaderHandleValidTests, BadPhysDevCreateDevice) {
572 FrameworkEnvironment env{};
573 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
574 env.get_test_icd().physical_devices.push_back({});
575 env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
576
577 InstWrapper instance(env.vulkan_functions);
578 instance.create_info.set_api_version(1, 1, 0);
579 instance.CheckCreate();
580
581 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
582
583 float queue_priorities[3] = {0.0f, 0.5f, 1.0f};
584 VkDeviceQueueCreateInfo dev_queue_create_info = {};
585 dev_queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
586 dev_queue_create_info.pNext = nullptr;
587 dev_queue_create_info.flags = 0;
588 dev_queue_create_info.queueFamilyIndex = 0;
589 dev_queue_create_info.queueCount = 1;
590 dev_queue_create_info.pQueuePriorities = queue_priorities;
591 VkDeviceCreateInfo dev_create_info = {};
592 dev_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
593 dev_create_info.pNext = nullptr;
594 dev_create_info.flags = 0;
595 dev_create_info.queueCreateInfoCount = 1;
596 dev_create_info.pQueueCreateInfos = &dev_queue_create_info;
597 dev_create_info.enabledLayerCount = 0;
598 dev_create_info.ppEnabledLayerNames = nullptr;
599 dev_create_info.enabledExtensionCount = 0;
600 dev_create_info.ppEnabledExtensionNames = nullptr;
601 dev_create_info.pEnabledFeatures = nullptr;
602 VkDevice created_dev = VK_NULL_HANDLE;
603 ASSERT_DEATH(env.vulkan_functions.vkCreateDevice(bad_physical_dev, &dev_create_info, nullptr, &created_dev),
604 "vkCreateDevice: Invalid physicalDevice \\[VUID-vkCreateDevice-physicalDevice-parameter\\]");
605 }
606
TEST(LoaderHandleValidTests,BadPhysDevEnumDevExtProps)607 TEST(LoaderHandleValidTests, BadPhysDevEnumDevExtProps) {
608 FrameworkEnvironment env{};
609 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
610 env.get_test_icd().physical_devices.push_back({});
611 env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
612
613 InstWrapper instance(env.vulkan_functions);
614 instance.create_info.set_api_version(1, 1, 0);
615 instance.CheckCreate();
616
617 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
618 uint32_t count = 0;
619 ASSERT_DEATH(env.vulkan_functions.vkEnumerateDeviceExtensionProperties(bad_physical_dev, nullptr, &count, nullptr),
620 "vkEnumerateDeviceExtensionProperties: Invalid physicalDevice "
621 "\\[VUID-vkEnumerateDeviceExtensionProperties-physicalDevice-parameter\\]");
622 }
623
TEST(LoaderHandleValidTests,BadPhysDevEnumDevLayerProps)624 TEST(LoaderHandleValidTests, BadPhysDevEnumDevLayerProps) {
625 FrameworkEnvironment env{};
626 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
627 env.get_test_icd().physical_devices.push_back({});
628 env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
629
630 InstWrapper instance(env.vulkan_functions);
631 instance.create_info.set_api_version(1, 1, 0);
632 instance.CheckCreate();
633
634 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
635 uint32_t count = 0;
636 ASSERT_DEATH(env.vulkan_functions.vkEnumerateDeviceLayerProperties(bad_physical_dev, &count, nullptr),
637 "vkEnumerateDeviceLayerProperties: Invalid physicalDevice "
638 "\\[VUID-vkEnumerateDeviceLayerProperties-physicalDevice-parameter\\]");
639 }
640
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevSparseImgFormatProps)641 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSparseImgFormatProps) {
642 FrameworkEnvironment env{};
643 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
644 env.get_test_icd().physical_devices.push_back({});
645 env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
646
647 InstWrapper instance(env.vulkan_functions);
648 instance.create_info.set_api_version(1, 1, 0);
649 instance.CheckCreate();
650
651 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
652
653 uint32_t count = 0;
654 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSparseImageFormatProperties(
655 bad_physical_dev, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_TYPE_2D, VK_SAMPLE_COUNT_1_BIT,
656 VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_TILING_LINEAR, &count, nullptr),
657 "vkGetPhysicalDeviceSparseImageFormatProperties: Invalid physicalDevice "
658 "\\[VUID-vkGetPhysicalDeviceSparseImageFormatProperties-physicalDevice-parameter\\]");
659 }
660
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevFeature2)661 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFeature2) {
662 FrameworkEnvironment env{};
663 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
664 env.get_test_icd().physical_devices.push_back({});
665 env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
666
667 InstWrapper instance(env.vulkan_functions);
668 instance.create_info.set_api_version(1, 1, 0);
669 instance.CheckCreate();
670
671 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
672
673 VkPhysicalDeviceFeatures2 features = {};
674 features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
675 features.pNext = nullptr;
676 ASSERT_DEATH(
677 env.vulkan_functions.vkGetPhysicalDeviceFeatures2(bad_physical_dev, &features),
678 "vkGetPhysicalDeviceFeatures2: Invalid physicalDevice \\[VUID-vkGetPhysicalDeviceFeatures2-physicalDevice-parameter\\]");
679 }
680
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevFormatProps2)681 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFormatProps2) {
682 FrameworkEnvironment env{};
683 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
684 env.get_test_icd().physical_devices.push_back({});
685 env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
686
687 InstWrapper instance(env.vulkan_functions);
688 instance.create_info.set_api_version(1, 1, 0);
689 instance.CheckCreate();
690
691 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
692
693 VkFormatProperties2 properties = {};
694 properties.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
695 properties.pNext = nullptr;
696 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceFormatProperties2(bad_physical_dev, VK_FORMAT_R8G8B8A8_UNORM, &properties),
697 "vkGetPhysicalDeviceFormatProperties2: Invalid physicalDevice "
698 "\\[VUID-vkGetPhysicalDeviceFormatProperties2-physicalDevice-parameter\\]");
699 }
700
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevImgFormatProps2)701 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevImgFormatProps2) {
702 FrameworkEnvironment env{};
703 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
704 env.get_test_icd().physical_devices.push_back({});
705 env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
706
707 InstWrapper instance(env.vulkan_functions);
708 instance.create_info.set_api_version(1, 1, 0);
709 instance.CheckCreate();
710
711 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
712
713 VkPhysicalDeviceImageFormatInfo2 format_info = {};
714 format_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2;
715 format_info.pNext = nullptr;
716 VkImageFormatProperties2 properties = {};
717 properties.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
718 properties.pNext = nullptr;
719 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceImageFormatProperties2(bad_physical_dev, &format_info, &properties),
720 "vkGetPhysicalDeviceImageFormatProperties2: Invalid physicalDevice "
721 "\\[VUID-vkGetPhysicalDeviceImageFormatProperties2-physicalDevice-parameter\\]");
722 }
723
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevProps2)724 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevProps2) {
725 FrameworkEnvironment env{};
726 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
727 env.get_test_icd().physical_devices.push_back({});
728 env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
729
730 InstWrapper instance(env.vulkan_functions);
731 instance.create_info.set_api_version(1, 1, 0);
732 instance.CheckCreate();
733
734 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
735
736 VkPhysicalDeviceProperties2 properties = {};
737 properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
738 properties.pNext = nullptr;
739 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceProperties2(bad_physical_dev, &properties),
740 "vkGetPhysicalDeviceProperties2: Invalid physicalDevice "
741 "\\[VUID-vkGetPhysicalDeviceProperties2-physicalDevice-parameter\\]");
742 }
743
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevQueueFamProps2)744 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamProps2) {
745 FrameworkEnvironment env{};
746 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
747 env.get_test_icd().physical_devices.push_back({});
748 env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
749
750 InstWrapper instance(env.vulkan_functions);
751 instance.create_info.set_api_version(1, 1, 0);
752 instance.CheckCreate();
753
754 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
755 uint32_t count = 0;
756 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties2(bad_physical_dev, &count, nullptr),
757 "vkGetPhysicalDeviceQueueFamilyProperties2: Invalid physicalDevice "
758 "\\[VUID-vkGetPhysicalDeviceQueueFamilyProperties2-physicalDevice-parameter\\]");
759 }
760
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevDevMemProps2)761 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDevMemProps2) {
762 FrameworkEnvironment env{};
763 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
764 env.get_test_icd().physical_devices.push_back({});
765 env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
766
767 InstWrapper instance(env.vulkan_functions);
768 instance.create_info.set_api_version(1, 1, 0);
769 instance.CheckCreate();
770
771 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
772
773 VkPhysicalDeviceMemoryProperties2 properties = {};
774 properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
775 properties.pNext = nullptr;
776 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceMemoryProperties2(bad_physical_dev, &properties),
777 "vkGetPhysicalDeviceMemoryProperties2: Invalid physicalDevice "
778 "\\[VUID-vkGetPhysicalDeviceMemoryProperties2-physicalDevice-parameter\\]");
779 }
780
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevSparseImgFormatProps2)781 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSparseImgFormatProps2) {
782 FrameworkEnvironment env{};
783 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
784 env.get_test_icd().physical_devices.push_back({});
785 env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
786
787 InstWrapper instance(env.vulkan_functions);
788 instance.create_info.set_api_version(1, 1, 0);
789 instance.CheckCreate();
790
791 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
792
793 VkPhysicalDeviceSparseImageFormatInfo2 info = {};
794 info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2;
795 info.pNext = nullptr;
796 uint32_t count = 0;
797 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSparseImageFormatProperties2(bad_physical_dev, &info, &count, nullptr),
798 "vkGetPhysicalDeviceSparseImageFormatProperties2: Invalid physicalDevice "
799 "\\[VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-physicalDevice-parameter\\]");
800 }
801
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevExternFenceProps)802 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevExternFenceProps) {
803 FrameworkEnvironment env{};
804 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
805 env.get_test_icd().physical_devices.push_back({});
806 env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
807
808 InstWrapper instance(env.vulkan_functions);
809 instance.create_info.set_api_version(1, 1, 0);
810 instance.CheckCreate();
811
812 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
813
814 VkPhysicalDeviceExternalFenceInfo info = {};
815 info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO;
816 info.pNext = nullptr;
817 VkExternalFenceProperties props = {};
818 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceExternalFenceProperties(bad_physical_dev, &info, &props),
819 "vkGetPhysicalDeviceExternalFenceProperties: Invalid physicalDevice "
820 "\\[VUID-vkGetPhysicalDeviceExternalFenceProperties-physicalDevice-parameter\\]");
821 }
822
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevExternBufferProps)823 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevExternBufferProps) {
824 FrameworkEnvironment env{};
825 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
826 env.get_test_icd().physical_devices.push_back({});
827 env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
828
829 InstWrapper instance(env.vulkan_functions);
830 instance.create_info.set_api_version(1, 1, 0);
831 instance.CheckCreate();
832
833 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
834
835 VkPhysicalDeviceExternalBufferInfo info = {};
836 info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO;
837 info.pNext = nullptr;
838 VkExternalBufferProperties props = {};
839 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceExternalBufferProperties(bad_physical_dev, &info, &props),
840 "vkGetPhysicalDeviceExternalBufferProperties: Invalid physicalDevice "
841 "\\[VUID-vkGetPhysicalDeviceExternalBufferProperties-physicalDevice-parameter\\]");
842 }
843
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevExternSemaphoreProps)844 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevExternSemaphoreProps) {
845 FrameworkEnvironment env{};
846 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
847 env.get_test_icd().physical_devices.push_back({});
848 env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
849
850 InstWrapper instance(env.vulkan_functions);
851 instance.create_info.set_api_version(1, 1, 0);
852 instance.CheckCreate();
853
854 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
855
856 VkPhysicalDeviceExternalSemaphoreInfoKHR info = {};
857 info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO;
858 info.pNext = nullptr;
859 VkExternalSemaphoreProperties props = {};
860 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceExternalSemaphoreProperties(bad_physical_dev, &info, &props),
861 "vkGetPhysicalDeviceExternalSemaphoreProperties: Invalid physicalDevice "
862 "\\[VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-physicalDevice-parameter\\]");
863 }
864
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevSurfaceSupportKHR)865 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceSupportKHR) {
866 FrameworkEnvironment env{};
867 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
868 Extension first_ext{"VK_KHR_surface"};
869 Extension second_ext{"VK_EXT_headless_surface"};
870 auto& driver = env.get_test_icd();
871 driver.add_instance_extensions({first_ext, second_ext});
872 driver.physical_devices.emplace_back("physical_device_0");
873
874 InstWrapper instance(env.vulkan_functions);
875 instance.create_info.add_extension("VK_KHR_surface");
876 instance.CheckCreate();
877
878 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
879 VkBool32 supported = VK_FALSE;
880
881 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfaceSupportKHR(bad_physical_dev, 0, VK_NULL_HANDLE, &supported),
882 "vkGetPhysicalDeviceSurfaceSupportKHR: Invalid physicalDevice "
883 "\\[VUID-vkGetPhysicalDeviceSurfaceSupportKHR-physicalDevice-parameter\\]");
884 }
885
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevSurfaceCapsKHR)886 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceCapsKHR) {
887 FrameworkEnvironment env{};
888 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
889 Extension first_ext{"VK_KHR_surface"};
890 Extension second_ext{"VK_EXT_headless_surface"};
891 auto& driver = env.get_test_icd();
892 driver.add_instance_extensions({first_ext, second_ext});
893 driver.physical_devices.emplace_back("physical_device_0");
894
895 InstWrapper instance(env.vulkan_functions);
896 instance.create_info.add_extension("VK_KHR_surface");
897 instance.CheckCreate();
898
899 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
900 VkSurfaceCapabilitiesKHR caps = {};
901 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(bad_physical_dev, VK_NULL_HANDLE, &caps),
902 "vkGetPhysicalDeviceSurfaceCapabilitiesKHR: Invalid physicalDevice "
903 "\\[VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-physicalDevice-parameter\\]");
904 }
905
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevSurfaceFormatsKHR)906 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceFormatsKHR) {
907 FrameworkEnvironment env{};
908 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
909 Extension first_ext{"VK_KHR_surface"};
910 Extension second_ext{"VK_EXT_headless_surface"};
911 auto& driver = env.get_test_icd();
912 driver.add_instance_extensions({first_ext, second_ext});
913 driver.physical_devices.emplace_back("physical_device_0");
914
915 InstWrapper instance(env.vulkan_functions);
916 instance.create_info.add_extension("VK_KHR_surface");
917 instance.CheckCreate();
918
919 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
920 uint32_t count = 0;
921 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfaceFormatsKHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
922 "vkGetPhysicalDeviceSurfaceFormatsKHR: Invalid physicalDevice "
923 "\\[VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-physicalDevice-parameter\\]");
924 }
925
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevSurfacePresentModesKHR)926 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfacePresentModesKHR) {
927 FrameworkEnvironment env{};
928 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
929 Extension first_ext{"VK_KHR_surface"};
930 Extension second_ext{"VK_EXT_headless_surface"};
931 auto& driver = env.get_test_icd();
932 driver.add_instance_extensions({first_ext, second_ext});
933 driver.physical_devices.emplace_back("physical_device_0");
934
935 InstWrapper instance(env.vulkan_functions);
936 instance.create_info.add_extension("VK_KHR_surface");
937 instance.CheckCreate();
938
939 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
940 uint32_t count = 0;
941 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfacePresentModesKHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
942 "vkGetPhysicalDeviceSurfacePresentModesKHR: Invalid physicalDevice "
943 "\\[VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-physicalDevice-parameter\\]");
944 }
945
946 #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
TEST(LoaderHandleValidTests,BadPhysDevGetDirectFBPresentSupportKHR)947 TEST(LoaderHandleValidTests, BadPhysDevGetDirectFBPresentSupportKHR) {
948 FrameworkEnvironment env{};
949 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
950 auto& driver = env.get_test_icd();
951 setup_WSI_in_ICD(driver);
952 driver.physical_devices.emplace_back("physical_device_0");
953
954 InstWrapper instance(env.vulkan_functions);
955 setup_WSI_in_create_instance(instance);
956 instance.CheckCreate();
957
958 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
959 IDirectFB directfb;
960 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceDirectFBPresentationSupportEXT(bad_physical_dev, 0, &directfb),
961 "vkGetPhysicalDeviceDirectFBPresentationSupportEXT: Invalid physicalDevice "
962 "\\[VUID-vkGetPhysicalDeviceDirectFBPresentationSupportEXT-physicalDevice-parameter\\]");
963 }
964 #endif // VK_USE_PLATFORM_DIRECTFB_EXT
965
966 #ifdef VK_USE_PLATFORM_SCREEN_QNX
TEST(LoaderHandleValidTests,BadPhysDevGetQNXPresentSupportKHR)967 TEST(LoaderHandleValidTests, BadPhysDevGetQNXPresentSupportKHR) {
968 FrameworkEnvironment env{};
969 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
970 auto& driver = env.get_test_icd();
971 setup_WSI_in_ICD(driver);
972 driver.physical_devices.emplace_back("physical_device_0");
973
974 InstWrapper instance(env.vulkan_functions);
975 setup_WSI_in_create_instance(instance);
976 instance.CheckCreate();
977
978 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
979 ASSERT_DEATH(env.vulkan_functions.PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX(bad_physical_dev, 0, nullptr),
980 "vkGetPhysicalDeviceScreenPresentationSupportQNX: Invalid instance "
981 "\\[VUID-vkGetPhysicalDeviceScreenPresentationSupportQNX-instance-parameter\\]");
982 }
983 #endif // VK_USE_PLATFORM_SCREEN_QNX
984
985 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevWaylandPresentSupportKHR)986 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevWaylandPresentSupportKHR) {
987 FrameworkEnvironment env{};
988 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
989 auto& driver = env.get_test_icd();
990 setup_WSI_in_ICD(driver);
991 driver.physical_devices.emplace_back("physical_device_0");
992
993 InstWrapper instance(env.vulkan_functions);
994 setup_WSI_in_create_instance(instance);
995 instance.CheckCreate();
996
997 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
998 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceWaylandPresentationSupportKHR(bad_physical_dev, 0, nullptr),
999 "vkGetPhysicalDeviceWaylandPresentationSupportKHR: Invalid physicalDevice "
1000 "\\[VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-physicalDevice-parameter\\]");
1001 }
1002 #endif // VK_USE_PLATFORM_WAYLAND_KHR
1003
1004 #ifdef VK_USE_PLATFORM_WIN32_KHR
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevWin32PresentSupportKHR)1005 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevWin32PresentSupportKHR) {
1006 FrameworkEnvironment env{};
1007 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1008 auto& driver = env.get_test_icd();
1009 setup_WSI_in_ICD(driver);
1010 driver.physical_devices.emplace_back("physical_device_0");
1011
1012 InstWrapper instance(env.vulkan_functions);
1013 setup_WSI_in_create_instance(instance);
1014 instance.CheckCreate();
1015
1016 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1017 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceWin32PresentationSupportKHR(bad_physical_dev, 0),
1018 "vkGetPhysicalDeviceWin32PresentationSupportKHR: Invalid physicalDevice "
1019 "\\[VUID-vkGetPhysicalDeviceWin32PresentationSupportKHR-physicalDevice-parameter\\]");
1020 }
1021 #endif // VK_USE_PLATFORM_WIN32_KHR
1022
1023 #ifdef VK_USE_PLATFORM_XCB_KHR
TEST(LoaderHandleValidTests,BadPhysDevGetXCBPresentSupportKHR)1024 TEST(LoaderHandleValidTests, BadPhysDevGetXCBPresentSupportKHR) {
1025 FrameworkEnvironment env{};
1026 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1027 auto& driver = env.get_test_icd();
1028 setup_WSI_in_ICD(driver);
1029 driver.physical_devices.emplace_back("physical_device_0");
1030
1031 InstWrapper instance(env.vulkan_functions);
1032 setup_WSI_in_create_instance(instance);
1033 instance.CheckCreate();
1034 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1035
1036 xcb_visualid_t visual = 0;
1037 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceXcbPresentationSupportKHR(bad_physical_dev, 0, nullptr, visual),
1038 "vkGetPhysicalDeviceXcbPresentationSupportKHR: Invalid physicalDevice "
1039 "\\[VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-physicalDevice-parameter\\]");
1040 }
1041 #endif // VK_USE_PLATFORM_XCB_KHR
1042
1043 #ifdef VK_USE_PLATFORM_XLIB_KHR
TEST(LoaderHandleValidTests,BadPhysDevGetXlibPresentSupportKHR)1044 TEST(LoaderHandleValidTests, BadPhysDevGetXlibPresentSupportKHR) {
1045 FrameworkEnvironment env{};
1046 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1047 auto& driver = env.get_test_icd();
1048 setup_WSI_in_ICD(driver);
1049 driver.physical_devices.emplace_back("physical_device_0");
1050
1051 InstWrapper instance(env.vulkan_functions);
1052 setup_WSI_in_create_instance(instance);
1053 instance.CheckCreate();
1054
1055 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1056
1057 VisualID visual = 0;
1058 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceXlibPresentationSupportKHR(bad_physical_dev, 0, nullptr, visual),
1059 "vkGetPhysicalDeviceXlibPresentationSupportKHR: Invalid physicalDevice "
1060 "\\[VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-physicalDevice-parameter\\]");
1061 }
1062 #endif // VK_USE_PLATFORM_XLIB_KHR
1063
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevDisplayPropsKHR)1064 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPropsKHR) {
1065 FrameworkEnvironment env{};
1066 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1067 Extension first_ext{"VK_KHR_surface"};
1068 Extension second_ext{"VK_KHR_display"};
1069 auto& driver = env.get_test_icd();
1070 driver.add_instance_extensions({first_ext, second_ext});
1071 driver.physical_devices.emplace_back("physical_device_0");
1072
1073 InstWrapper instance(env.vulkan_functions);
1074 instance.create_info.add_extension("VK_KHR_surface");
1075 instance.create_info.add_extension("VK_KHR_display");
1076 instance.CheckCreate();
1077
1078 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1079 uint32_t count = 0;
1080 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceDisplayPropertiesKHR(bad_physical_dev, &count, nullptr),
1081 "vkGetPhysicalDeviceDisplayPropertiesKHR: Invalid physicalDevice "
1082 "\\[VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-physicalDevice-parameter\\]");
1083 }
1084
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevDisplayPlanePropsKHR)1085 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPlanePropsKHR) {
1086 FrameworkEnvironment env{};
1087 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1088 Extension first_ext{"VK_KHR_surface"};
1089 Extension second_ext{"VK_KHR_display"};
1090 auto& driver = env.get_test_icd();
1091 driver.add_instance_extensions({first_ext, second_ext});
1092 driver.physical_devices.emplace_back("physical_device_0");
1093
1094 InstWrapper instance(env.vulkan_functions);
1095 instance.create_info.add_extension("VK_KHR_surface");
1096 instance.create_info.add_extension("VK_KHR_display");
1097 instance.CheckCreate();
1098
1099 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1100 uint32_t count = 0;
1101 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceDisplayPlanePropertiesKHR(bad_physical_dev, &count, nullptr),
1102 "vkGetPhysicalDeviceDisplayPlanePropertiesKHR: Invalid physicalDevice "
1103 "\\[VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-physicalDevice-parameter\\]");
1104 }
1105
TEST(LoaderHandleValidTests,BadPhysDevGetDisplayPlaneSupportedDisplaysKHR)1106 TEST(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneSupportedDisplaysKHR) {
1107 FrameworkEnvironment env{};
1108 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1109 Extension first_ext{"VK_KHR_surface"};
1110 Extension second_ext{"VK_KHR_display"};
1111 auto& driver = env.get_test_icd();
1112 driver.add_instance_extensions({first_ext, second_ext});
1113 driver.physical_devices.emplace_back("physical_device_0");
1114
1115 InstWrapper instance(env.vulkan_functions);
1116 instance.create_info.add_extension("VK_KHR_surface");
1117 instance.create_info.add_extension("VK_KHR_display");
1118 instance.CheckCreate();
1119
1120 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1121 uint32_t count = 0;
1122 ASSERT_DEATH(env.vulkan_functions.vkGetDisplayPlaneSupportedDisplaysKHR(bad_physical_dev, 0, &count, nullptr),
1123 "vkGetDisplayPlaneSupportedDisplaysKHR: Invalid physicalDevice "
1124 "\\[VUID-vkGetDisplayPlaneSupportedDisplaysKHR-physicalDevice-parameter\\]");
1125 }
1126
TEST(LoaderHandleValidTests,BadPhysDevGetDisplayModePropsKHR)1127 TEST(LoaderHandleValidTests, BadPhysDevGetDisplayModePropsKHR) {
1128 FrameworkEnvironment env{};
1129 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1130 Extension first_ext{"VK_KHR_surface"};
1131 Extension second_ext{"VK_KHR_display"};
1132 auto& driver = env.get_test_icd();
1133 driver.add_instance_extensions({first_ext, second_ext});
1134 driver.physical_devices.emplace_back("physical_device_0");
1135
1136 InstWrapper instance(env.vulkan_functions);
1137 instance.create_info.add_extension("VK_KHR_surface");
1138 instance.create_info.add_extension("VK_KHR_display");
1139 instance.CheckCreate();
1140
1141 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1142 uint32_t count = 0;
1143 ASSERT_DEATH(
1144 env.vulkan_functions.vkGetDisplayModePropertiesKHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
1145 "vkGetDisplayModePropertiesKHR: Invalid physicalDevice \\[VUID-vkGetDisplayModePropertiesKHR-physicalDevice-parameter\\]");
1146 }
1147
TEST(LoaderHandleValidTests,BadPhysDevCreateDisplayModeKHR)1148 TEST(LoaderHandleValidTests, BadPhysDevCreateDisplayModeKHR) {
1149 FrameworkEnvironment env{};
1150 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1151 Extension first_ext{"VK_KHR_surface"};
1152 Extension second_ext{"VK_KHR_display"};
1153 auto& driver = env.get_test_icd();
1154 driver.add_instance_extensions({first_ext, second_ext});
1155 driver.physical_devices.emplace_back("physical_device_0");
1156
1157 InstWrapper instance(env.vulkan_functions);
1158 instance.create_info.add_extension("VK_KHR_surface");
1159 instance.create_info.add_extension("VK_KHR_display");
1160 instance.CheckCreate();
1161
1162 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1163 VkDisplayModeCreateInfoKHR create_info = {};
1164 create_info.sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
1165 create_info.pNext = nullptr;
1166 VkDisplayModeKHR display_mode;
1167 ASSERT_DEATH(
1168 env.vulkan_functions.vkCreateDisplayModeKHR(bad_physical_dev, VK_NULL_HANDLE, &create_info, nullptr, &display_mode),
1169 "vkCreateDisplayModeKHR: Invalid physicalDevice \\[VUID-vkCreateDisplayModeKHR-physicalDevice-parameter\\]");
1170 }
1171
TEST(LoaderHandleValidTests,BadPhysDevGetDisplayPlaneCapsKHR)1172 TEST(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneCapsKHR) {
1173 FrameworkEnvironment env{};
1174 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1175 Extension first_ext{"VK_KHR_surface"};
1176 Extension second_ext{"VK_KHR_display"};
1177 auto& driver = env.get_test_icd();
1178 driver.add_instance_extensions({first_ext, second_ext});
1179 driver.physical_devices.emplace_back("physical_device_0");
1180
1181 InstWrapper instance(env.vulkan_functions);
1182 instance.create_info.add_extension("VK_KHR_surface");
1183 instance.create_info.add_extension("VK_KHR_display");
1184 instance.CheckCreate();
1185
1186 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1187 VkDisplayPlaneCapabilitiesKHR caps = {};
1188 ASSERT_DEATH(env.vulkan_functions.vkGetDisplayPlaneCapabilitiesKHR(bad_physical_dev, VK_NULL_HANDLE, 0, &caps),
1189 "vkGetDisplayPlaneCapabilitiesKHR: Invalid physicalDevice "
1190 "\\[VUID-vkGetDisplayPlaneCapabilitiesKHR-physicalDevice-parameter\\]");
1191 }
1192
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevPresentRectsKHR)1193 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevPresentRectsKHR) {
1194 FrameworkEnvironment env{};
1195 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1196 Extension first_ext{"VK_KHR_surface"};
1197 Extension second_ext{"VK_KHR_display"};
1198 auto& driver = env.get_test_icd();
1199 driver.add_instance_extensions({first_ext, second_ext});
1200 driver.physical_devices.emplace_back("physical_device_0");
1201
1202 InstWrapper instance(env.vulkan_functions);
1203 instance.create_info.add_extension("VK_KHR_surface");
1204 instance.create_info.add_extension("VK_KHR_display");
1205 instance.CheckCreate();
1206
1207 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1208 uint32_t count = 0;
1209 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDevicePresentRectanglesKHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
1210 "vkGetPhysicalDevicePresentRectanglesKHR: Invalid physicalDevice "
1211 "\\[VUID-vkGetPhysicalDevicePresentRectanglesKHR-physicalDevice-parameter\\]");
1212 }
1213
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevDisplayProps2KHR)1214 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayProps2KHR) {
1215 FrameworkEnvironment env{};
1216 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1217 Extension first_ext{"VK_KHR_surface"};
1218 Extension second_ext{"VK_KHR_get_display_properties2"};
1219 auto& driver = env.get_test_icd();
1220 driver.add_instance_extensions({first_ext, second_ext});
1221 driver.physical_devices.emplace_back("physical_device_0");
1222
1223 InstWrapper instance(env.vulkan_functions);
1224 instance.create_info.add_extension("VK_KHR_surface");
1225 instance.create_info.add_extension("VK_KHR_get_display_properties2");
1226 instance.CheckCreate();
1227
1228 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1229 uint32_t count = 0;
1230 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceDisplayProperties2KHR(bad_physical_dev, &count, nullptr),
1231 "vkGetPhysicalDeviceDisplayProperties2KHR: Invalid physicalDevice "
1232 "\\[VUID-vkGetPhysicalDeviceDisplayProperties2KHR-physicalDevice-parameter\\]");
1233 }
1234
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevDisplayPlaneProps2KHR)1235 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPlaneProps2KHR) {
1236 FrameworkEnvironment env{};
1237 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1238 Extension first_ext{"VK_KHR_surface"};
1239 Extension second_ext{"VK_KHR_get_display_properties2"};
1240 auto& driver = env.get_test_icd();
1241 driver.add_instance_extensions({first_ext, second_ext});
1242 driver.physical_devices.emplace_back("physical_device_0");
1243
1244 InstWrapper instance(env.vulkan_functions);
1245 instance.create_info.add_extension("VK_KHR_surface");
1246 instance.create_info.add_extension("VK_KHR_get_display_properties2");
1247 instance.CheckCreate();
1248
1249 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1250 uint32_t count = 0;
1251 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceDisplayPlaneProperties2KHR(bad_physical_dev, &count, nullptr),
1252 "vkGetPhysicalDeviceDisplayPlaneProperties2KHR: Invalid physicalDevice "
1253 "\\[VUID-vkGetPhysicalDeviceDisplayPlaneProperties2KHR-physicalDevice-parameter\\]");
1254 }
1255
TEST(LoaderHandleValidTests,BadPhysDevGetDisplayModeProps2KHR)1256 TEST(LoaderHandleValidTests, BadPhysDevGetDisplayModeProps2KHR) {
1257 FrameworkEnvironment env{};
1258 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1259 Extension first_ext{"VK_KHR_surface"};
1260 Extension second_ext{"VK_KHR_get_display_properties2"};
1261 auto& driver = env.get_test_icd();
1262 driver.add_instance_extensions({first_ext, second_ext});
1263 driver.physical_devices.emplace_back("physical_device_0");
1264
1265 InstWrapper instance(env.vulkan_functions);
1266 instance.create_info.add_extension("VK_KHR_surface");
1267 instance.create_info.add_extension("VK_KHR_get_display_properties2");
1268 instance.CheckCreate();
1269
1270 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1271 uint32_t count = 0;
1272 ASSERT_DEATH(env.vulkan_functions.vkGetDisplayModeProperties2KHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
1273 "vkGetDisplayModeProperties2KHR: Invalid physicalDevice "
1274 "\\[VUID-vkGetDisplayModeProperties2KHR-physicalDevice-parameter\\]");
1275 }
1276
TEST(LoaderHandleValidTests,BadPhysDevGetDisplayPlaneCaps2KHR)1277 TEST(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneCaps2KHR) {
1278 FrameworkEnvironment env{};
1279 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1280 Extension first_ext{"VK_KHR_surface"};
1281 Extension second_ext{"VK_KHR_get_display_properties2"};
1282 auto& driver = env.get_test_icd();
1283 driver.add_instance_extensions({first_ext, second_ext});
1284 driver.physical_devices.emplace_back("physical_device_0");
1285
1286 InstWrapper instance(env.vulkan_functions);
1287 instance.create_info.add_extension("VK_KHR_surface");
1288 instance.create_info.add_extension("VK_KHR_get_display_properties2");
1289 instance.CheckCreate();
1290
1291 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1292 VkDisplayPlaneInfo2KHR disp_plane_info = {};
1293 disp_plane_info.sType = VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR;
1294 disp_plane_info.pNext = nullptr;
1295 VkDisplayPlaneCapabilities2KHR caps = {};
1296 ASSERT_DEATH(env.vulkan_functions.vkGetDisplayPlaneCapabilities2KHR(bad_physical_dev, &disp_plane_info, &caps),
1297 "vkGetDisplayPlaneCapabilities2KHR: Invalid physicalDevice "
1298 "\\[VUID-vkGetDisplayPlaneCapabilities2KHR-physicalDevice-parameter\\]");
1299 }
1300
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevSurfaceCaps2KHR)1301 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceCaps2KHR) {
1302 FrameworkEnvironment env{};
1303 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1304 Extension first_ext{"VK_KHR_surface"};
1305 Extension second_ext{"VK_KHR_get_surface_capabilities2"};
1306 auto& driver = env.get_test_icd();
1307 driver.add_instance_extensions({first_ext, second_ext});
1308 driver.physical_devices.emplace_back("physical_device_0");
1309
1310 InstWrapper instance(env.vulkan_functions);
1311 instance.create_info.add_extension("VK_KHR_surface");
1312 instance.create_info.add_extension("VK_KHR_get_surface_capabilities2");
1313 instance.CheckCreate();
1314
1315 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1316 VkPhysicalDeviceSurfaceInfo2KHR phys_dev_surf_info = {};
1317 phys_dev_surf_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
1318 phys_dev_surf_info.pNext = nullptr;
1319 VkSurfaceCapabilities2KHR caps = {};
1320 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfaceCapabilities2KHR(bad_physical_dev, &phys_dev_surf_info, &caps),
1321 "vkGetPhysicalDeviceSurfaceCapabilities2KHR: Invalid physicalDevice "
1322 "\\[VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-physicalDevice-parameter\\]");
1323 }
1324
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevSurfaceFormats2KHR)1325 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceFormats2KHR) {
1326 FrameworkEnvironment env{};
1327 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1328 Extension first_ext{"VK_KHR_surface"};
1329 Extension second_ext{"VK_KHR_get_surface_capabilities2"};
1330 auto& driver = env.get_test_icd();
1331 driver.add_instance_extensions({first_ext, second_ext});
1332 driver.physical_devices.emplace_back("physical_device_0");
1333
1334 InstWrapper instance(env.vulkan_functions);
1335 instance.create_info.add_extension("VK_KHR_get_surface_capabilities2");
1336 instance.CheckCreate();
1337
1338 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1339 VkPhysicalDeviceSurfaceInfo2KHR phys_dev_surf_info = {};
1340 phys_dev_surf_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
1341 phys_dev_surf_info.pNext = nullptr;
1342 uint32_t count = 0;
1343 ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfaceFormats2KHR(bad_physical_dev, &phys_dev_surf_info, &count, nullptr),
1344 "vkGetPhysicalDeviceSurfaceFormats2KHR: Invalid physicalDevice "
1345 "\\[VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-physicalDevice-parameter\\]");
1346 }
1347
TEST(LoaderHandleValidTests,BadPhysDevEnumPhysDevQueueFamilyPerfQueryCountersKHR)1348 TEST(LoaderHandleValidTests, BadPhysDevEnumPhysDevQueueFamilyPerfQueryCountersKHR) {
1349 FrameworkEnvironment env{};
1350 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1351 auto& driver = env.get_test_icd();
1352 driver.physical_devices.emplace_back("physical_device_0");
1353
1354 InstWrapper instance(env.vulkan_functions);
1355 instance.CheckCreate();
1356
1357 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1358 uint32_t count = 0;
1359 PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR pfn =
1360 instance.load("vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR");
1361 ASSERT_NE(pfn, nullptr);
1362 ASSERT_DEATH(pfn(bad_physical_dev, 0, &count, nullptr, nullptr),
1363 "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR: Invalid physicalDevice "
1364 "\\[VUID-vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR-physicalDevice-parameter\\]");
1365 }
1366
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevQueueFamilyPerfQueryPassesKHR)1367 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamilyPerfQueryPassesKHR) {
1368 FrameworkEnvironment env{};
1369 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1370 auto& driver = env.get_test_icd();
1371 driver.physical_devices.emplace_back("physical_device_0");
1372
1373 InstWrapper instance(env.vulkan_functions);
1374 instance.CheckCreate();
1375
1376 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1377 VkQueryPoolPerformanceCreateInfoKHR create_info = {};
1378 create_info.sType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR;
1379 create_info.pNext = nullptr;
1380 uint32_t count = 0;
1381 PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR pfn =
1382 instance.load("vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR");
1383 ASSERT_NE(pfn, nullptr);
1384 ASSERT_DEATH(pfn(bad_physical_dev, &create_info, &count),
1385 "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR: Invalid physicalDevice "
1386 "\\[VUID-vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR-physicalDevice-parameter\\]");
1387 }
1388
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevFragmentShadingRatesKHR)1389 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFragmentShadingRatesKHR) {
1390 FrameworkEnvironment env{};
1391 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1392 auto& driver = env.get_test_icd();
1393 driver.physical_devices.emplace_back("physical_device_0");
1394
1395 InstWrapper instance(env.vulkan_functions);
1396 instance.CheckCreate();
1397
1398 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1399 uint32_t count = 0;
1400 PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR pfn = instance.load("vkGetPhysicalDeviceFragmentShadingRatesKHR");
1401 ASSERT_NE(pfn, nullptr);
1402 ASSERT_DEATH(pfn(bad_physical_dev, &count, nullptr),
1403 "vkGetPhysicalDeviceFragmentShadingRatesKHR: Invalid physicalDevice "
1404 "\\[VUID-vkGetPhysicalDeviceFragmentShadingRatesKHR-physicalDevice-parameter\\]");
1405 }
1406
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevMSPropsEXT)1407 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevMSPropsEXT) {
1408 FrameworkEnvironment env{};
1409 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1410 auto& driver = env.get_test_icd();
1411 driver.physical_devices.emplace_back("physical_device_0");
1412
1413 InstWrapper instance(env.vulkan_functions);
1414 instance.CheckCreate();
1415
1416 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1417 VkMultisamplePropertiesEXT props = {};
1418 PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT pfn = instance.load("vkGetPhysicalDeviceMultisamplePropertiesEXT");
1419 ASSERT_NE(pfn, nullptr);
1420 ASSERT_DEATH(pfn(bad_physical_dev, VK_SAMPLE_COUNT_1_BIT, &props),
1421 "vkGetPhysicalDeviceMultisamplePropertiesEXT: Invalid physicalDevice "
1422 "\\[VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-physicalDevice-parameter\\]");
1423 }
1424
TEST(LoaderHandleValidTests,BadPhysDevAcquireDrmDisplayEXT)1425 TEST(LoaderHandleValidTests, BadPhysDevAcquireDrmDisplayEXT) {
1426 FrameworkEnvironment env{};
1427 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1428 Extension first_ext{"VK_KHR_surface"};
1429 Extension second_ext{"VK_EXT_acquire_drm_display"};
1430 auto& driver = env.get_test_icd();
1431 driver.add_instance_extensions({first_ext, second_ext});
1432 driver.physical_devices.emplace_back("physical_device_0");
1433
1434 InstWrapper instance(env.vulkan_functions);
1435 instance.create_info.add_extension("VK_EXT_acquire_drm_display");
1436 instance.CheckCreate();
1437
1438 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1439 PFN_vkAcquireDrmDisplayEXT pfn = instance.load("vkAcquireDrmDisplayEXT");
1440 ASSERT_NE(pfn, nullptr);
1441 ASSERT_DEATH(pfn(bad_physical_dev, 0, VK_NULL_HANDLE),
1442 "vkAcquireDrmDisplayEXT: Invalid physicalDevice \\[VUID-vkAcquireDrmDisplayEXT-physicalDevice-parameter\\]");
1443 }
1444
TEST(LoaderHandleValidTests,BadPhysDevGetDrmDisplayEXT)1445 TEST(LoaderHandleValidTests, BadPhysDevGetDrmDisplayEXT) {
1446 FrameworkEnvironment env{};
1447 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1448 Extension first_ext{"VK_KHR_surface"};
1449 Extension second_ext{"VK_EXT_acquire_drm_display"};
1450 auto& driver = env.get_test_icd();
1451 driver.add_instance_extensions({first_ext, second_ext});
1452 driver.physical_devices.emplace_back("physical_device_0");
1453
1454 InstWrapper instance(env.vulkan_functions);
1455 instance.create_info.add_extension("VK_EXT_acquire_drm_display");
1456 instance.CheckCreate();
1457
1458 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1459 PFN_vkGetDrmDisplayEXT pfn = instance.load("vkGetDrmDisplayEXT");
1460 ASSERT_NE(pfn, nullptr);
1461 ASSERT_DEATH(pfn(bad_physical_dev, 0, 0, VK_NULL_HANDLE),
1462 "vkGetDrmDisplayEXT: Invalid physicalDevice "
1463 "\\[VUID-vkGetDrmDisplayEXT-physicalDevice-parameter\\]");
1464 }
1465
TEST(LoaderHandleValidTests,BadPhysDevReleaseDisplayEXT)1466 TEST(LoaderHandleValidTests, BadPhysDevReleaseDisplayEXT) {
1467 FrameworkEnvironment env{};
1468 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1469 Extension first_ext{"VK_KHR_surface"};
1470 Extension second_ext{"VK_EXT_direct_mode_display"};
1471 auto& driver = env.get_test_icd();
1472 driver.add_instance_extensions({first_ext, second_ext});
1473 driver.physical_devices.emplace_back("physical_device_0");
1474
1475 InstWrapper instance(env.vulkan_functions);
1476 instance.create_info.add_extension("VK_EXT_direct_mode_display");
1477 instance.CheckCreate();
1478
1479 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1480 PFN_vkReleaseDisplayEXT pfn = instance.load("vkReleaseDisplayEXT");
1481 ASSERT_NE(pfn, nullptr);
1482 ASSERT_DEATH(pfn(bad_physical_dev, VK_NULL_HANDLE),
1483 "vkReleaseDisplayEXT: Invalid physicalDevice \\[VUID-vkReleaseDisplayEXT-physicalDevice-parameter\\]");
1484 }
1485
1486 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
TEST(LoaderHandleValidTests,BadPhysDevAcquireXlibDisplayEXT)1487 TEST(LoaderHandleValidTests, BadPhysDevAcquireXlibDisplayEXT) {
1488 FrameworkEnvironment env{};
1489 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1490 Extension first_ext{"VK_KHR_surface"};
1491 Extension second_ext{"VK_EXT_acquire_xlib_display"};
1492 auto& driver = env.get_test_icd();
1493 driver.add_instance_extensions({first_ext, second_ext});
1494 driver.physical_devices.emplace_back("physical_device_0");
1495
1496 InstWrapper instance(env.vulkan_functions);
1497 instance.create_info.add_extension("VK_EXT_acquire_xlib_display");
1498 instance.CheckCreate();
1499
1500 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1501 PFN_vkAcquireXlibDisplayEXT pfn = instance.load("vkAcquireXlibDisplayEXT");
1502 ASSERT_NE(pfn, nullptr);
1503 ASSERT_DEATH(pfn(bad_physical_dev, nullptr, VK_NULL_HANDLE),
1504 "vkAcquireXlibDisplayEXT: Invalid physicalDevice \\[VUID-vkAcquireXlibDisplayEXT-physicalDevice-parameter\\]");
1505 }
1506
TEST(LoaderHandleValidTests,BadPhysDevGetRandROutputDisplayEXT)1507 TEST(LoaderHandleValidTests, BadPhysDevGetRandROutputDisplayEXT) {
1508 FrameworkEnvironment env{};
1509 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1510 Extension first_ext{"VK_KHR_surface"};
1511 Extension second_ext{"VK_EXT_acquire_xlib_display"};
1512 auto& driver = env.get_test_icd();
1513 driver.add_instance_extensions({first_ext, second_ext});
1514 driver.physical_devices.emplace_back("physical_device_0");
1515
1516 InstWrapper instance(env.vulkan_functions);
1517 instance.create_info.add_extension("VK_EXT_acquire_xlib_display");
1518 instance.CheckCreate();
1519
1520 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1521 RROutput rrout = {};
1522 VkDisplayKHR disp;
1523 PFN_vkGetRandROutputDisplayEXT pfn = instance.load("vkGetRandROutputDisplayEXT");
1524 ASSERT_NE(pfn, nullptr);
1525 ASSERT_DEATH(
1526 pfn(bad_physical_dev, nullptr, rrout, &disp),
1527 "vkGetRandROutputDisplayEXT: Invalid physicalDevice \\[VUID-vkGetRandROutputDisplayEXT-physicalDevice-parameter\\]");
1528 }
1529 #endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
1530
1531 #ifdef VK_USE_PLATFORM_WIN32_KHR
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevSurfacePresentModes2EXT)1532 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfacePresentModes2EXT) {
1533 FrameworkEnvironment env{};
1534 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1535 auto& driver = env.get_test_icd();
1536 setup_WSI_in_ICD(driver);
1537 driver.physical_devices.emplace_back("physical_device_0");
1538
1539 InstWrapper instance(env.vulkan_functions);
1540 instance.CheckCreate();
1541
1542 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1543 VkPhysicalDeviceSurfaceInfo2KHR phys_dev_surf_info = {};
1544 phys_dev_surf_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
1545 phys_dev_surf_info.pNext = nullptr;
1546 uint32_t count = 0;
1547 PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT pfn = instance.load("vkGetPhysicalDeviceSurfacePresentModes2EXT");
1548 ASSERT_NE(pfn, nullptr);
1549 ASSERT_DEATH(pfn(bad_physical_dev, &phys_dev_surf_info, &count, nullptr),
1550 "vkGetPhysicalDeviceSurfacePresentModes2EXT: Invalid physicalDevice "
1551 "\\[VUID-vkGetPhysicalDeviceSurfacePresentModes2EXT-physicalDevice-parameter\\]");
1552 }
1553 #endif // VK_USE_PLATFORM_WIN32_KHR
1554
TEST(LoaderHandleValidTests,BadPhysDevGetPhysDevToolPropertiesEXT)1555 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevToolPropertiesEXT) {
1556 FrameworkEnvironment env{};
1557 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1558 auto& driver = env.get_test_icd();
1559 driver.physical_devices.emplace_back("physical_device_0");
1560
1561 InstWrapper instance(env.vulkan_functions);
1562 instance.CheckCreate();
1563
1564 auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
1565 PFN_vkGetPhysicalDeviceToolPropertiesEXT pfn = instance.load("vkGetPhysicalDeviceToolPropertiesEXT");
1566 ASSERT_NE(pfn, nullptr);
1567 uint32_t count = 0;
1568 ASSERT_DEATH(pfn(bad_physical_dev, &count, nullptr),
1569 "vkGetPhysicalDeviceToolPropertiesEXT: Invalid physicalDevice "
1570 "\\[VUID-vkGetPhysicalDeviceToolPropertiesEXT-physicalDevice-parameter\\]");
1571 }
1572
1573 #ifdef VK_USE_PLATFORM_ANDROID_KHR
TEST(LoaderHandleValidTests,VerifyHandleWrappingAndroidSurface)1574 TEST(LoaderHandleValidTests, VerifyHandleWrappingAndroidSurface) {
1575 FrameworkEnvironment env{};
1576 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1577 auto& driver = env.get_test_icd();
1578 setup_WSI_in_ICD(driver);
1579
1580 const char* wrap_objects_name = "WrapObjectsLayer";
1581 env.add_explicit_layer(ManifestLayer{}.add_layer(
1582 ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1583 "wrap_objects_layer.json");
1584
1585 driver.physical_devices.emplace_back("physical_device_0");
1586 MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
1587 driver.physical_devices.back().queue_family_properties.push_back(family_props);
1588
1589 InstWrapper instance(env.vulkan_functions);
1590 setup_WSI_in_create_instance(instance);
1591 instance.CheckCreate();
1592 instance.create_info.add_layer(wrap_objects_name);
1593
1594 VkAndroidSurfaceCreateInfoKHR surf_create_info = {};
1595 surf_create_info.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
1596 surf_create_info.pNext = nullptr;
1597 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1598 PFN_vkCreateAndroidSurfaceKHR pfn_CreateSurface = instance.load("vkCreateAndroidSurfaceKHR");
1599 ASSERT_NE(pfn_CreateSurface, nullptr);
1600 PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1601 ASSERT_NE(pfn_DestroySurface, nullptr);
1602 ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1603 pfn_DestroySurface(instance, created_surface, nullptr);
1604 }
1605 #endif // VK_USE_PLATFORM_ANDROID_KHR
1606
1607 #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
TEST(LoaderHandleValidTests,VerifyHandleWrappingDirectFBSurf)1608 TEST(LoaderHandleValidTests, VerifyHandleWrappingDirectFBSurf) {
1609 FrameworkEnvironment env{};
1610 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1611 auto& driver = env.get_test_icd();
1612 setup_WSI_in_ICD(driver);
1613
1614 const char* wrap_objects_name = "WrapObjectsLayer";
1615 env.add_explicit_layer(ManifestLayer{}.add_layer(
1616 ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1617 "wrap_objects_layer.json");
1618
1619 driver.physical_devices.emplace_back("physical_device_0");
1620 MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
1621 driver.physical_devices.back().queue_family_properties.push_back(family_props);
1622
1623 InstWrapper instance(env.vulkan_functions);
1624 setup_WSI_in_create_instance(instance);
1625 instance.CheckCreate();
1626 instance.create_info.add_layer(wrap_objects_name);
1627
1628 VkDirectFBSurfaceCreateInfoEXT surf_create_info = {};
1629 surf_create_info.sType = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT;
1630 surf_create_info.pNext = nullptr;
1631 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1632 PFN_vkCreateDirectFBSurfaceEXT pfn_CreateSurface = instance.load("vkCreateDirectFBSurfaceEXT");
1633 ASSERT_NE(pfn_CreateSurface, nullptr);
1634 PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1635 ASSERT_NE(pfn_DestroySurface, nullptr);
1636 ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1637 pfn_DestroySurface(instance, created_surface, nullptr);
1638 }
1639 #endif // VK_USE_PLATFORM_DIRECTFB_EXT
1640
1641 #ifdef VK_USE_PLATFORM_FUCHSIA
TEST(LoaderHandleValidTests,VerifyHandleWrappingFuchsiaSurf)1642 TEST(LoaderHandleValidTests, VerifyHandleWrappingFuchsiaSurf) {
1643 FrameworkEnvironment env{};
1644 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1645 auto& driver = env.get_test_icd();
1646 setup_WSI_in_ICD(driver);
1647
1648 const char* wrap_objects_name = "WrapObjectsLayer";
1649 env.add_explicit_layer(ManifestLayer{}.add_layer(
1650 ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1651 "wrap_objects_layer.json");
1652
1653 driver.physical_devices.emplace_back("physical_device_0");
1654 MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
1655 driver.physical_devices.back().queue_family_properties.push_back(family_props);
1656
1657 InstWrapper instance(env.vulkan_functions);
1658 setup_WSI_in_create_instance(instance);
1659 instance.CheckCreate();
1660 instance.create_info.add_layer(wrap_objects_name);
1661
1662 VkImagePipeSurfaceCreateInfoFUCHSIA surf_create_info = {};
1663 surf_create_info.sType = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA;
1664 surf_create_info.pNext = nullptr;
1665 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1666 PFN_vkCreateImagePipeSurfaceFUCHSIA pfn_CreateSurface = instance.load("vkCreateImagePipeSurfaceFUCHSIA");
1667 ASSERT_NE(pfn_CreateSurface, nullptr);
1668 PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1669 ASSERT_NE(pfn_DestroySurface, nullptr);
1670 ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1671 pfn_DestroySurface(instance, created_surface, nullptr);
1672 }
1673 #endif // VK_USE_PLATFORM_FUCHSIA
1674
1675 #ifdef VK_USE_PLATFORM_GGP
TEST(LoaderHandleValidTests,VerifyHandleWrappingGGPSurf)1676 TEST(LoaderHandleValidTests, VerifyHandleWrappingGGPSurf) {
1677 FrameworkEnvironment env{};
1678 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1679 auto& driver = env.get_test_icd();
1680 setup_WSI_in_ICD(driver);
1681
1682 const char* wrap_objects_name = "WrapObjectsLayer";
1683 env.add_explicit_layer(ManifestLayer{}.add_layer(
1684 ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1685 "wrap_objects_layer.json");
1686
1687 driver.physical_devices.emplace_back("physical_device_0");
1688 MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
1689 driver.physical_devices.back().queue_family_properties.push_back(family_props);
1690
1691 InstWrapper instance(env.vulkan_functions);
1692 setup_WSI_in_create_instance(instance);
1693 instance.CheckCreate();
1694 instance.create_info.add_layer(wrap_objects_name);
1695
1696 VkStreamDescriptorSurfaceCreateInfoGGP surf_create_info = {};
1697 surf_create_info.sType = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP;
1698 surf_create_info.pNext = nullptr;
1699 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1700 PFN_vkCreateStreamDescriptorSurfaceGGP pfn_CreateSurface = instance.load("vkCreateStreamDescriptorSurfaceGGP");
1701 ASSERT_NE(pfn_CreateSurface, nullptr);
1702 PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1703 ASSERT_NE(pfn_DestroySurface, nullptr);
1704 ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1705 pfn_DestroySurface(instance, created_surface, nullptr);
1706 }
1707 #endif // VK_USE_PLATFORM_GGP
1708
1709 #ifdef VK_USE_PLATFORM_IOS_MVK
TEST(LoaderHandleValidTests,VerifyHandleWrappingIOSSurf)1710 TEST(LoaderHandleValidTests, VerifyHandleWrappingIOSSurf) {
1711 FrameworkEnvironment env{};
1712 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1713 auto& driver = env.get_test_icd();
1714 setup_WSI_in_ICD(driver);
1715
1716 const char* wrap_objects_name = "WrapObjectsLayer";
1717 env.add_explicit_layer(ManifestLayer{}.add_layer(
1718 ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1719 "wrap_objects_layer.json");
1720
1721 driver.physical_devices.emplace_back("physical_device_0");
1722 MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
1723 driver.physical_devices.back().queue_family_properties.push_back(family_props);
1724
1725 InstWrapper instance(env.vulkan_functions);
1726 setup_WSI_in_create_instance(instance);
1727 instance.CheckCreate();
1728 instance.create_info.add_layer(wrap_objects_name);
1729
1730 VkIOSSurfaceCreateInfoMVK surf_create_info = {};
1731 surf_create_info.sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK;
1732 surf_create_info.pNext = nullptr;
1733 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1734 PFN_vkCreateIOSSurfaceMVK pfn_CreateSurface = instance.load("vkCreateIOSSurfaceMVK");
1735 ASSERT_NE(pfn_CreateSurface, nullptr);
1736 PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1737 ASSERT_NE(pfn_DestroySurface, nullptr);
1738 ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1739 pfn_DestroySurface(instance, created_surface, nullptr);
1740 }
1741 #endif // VK_USE_PLATFORM_IOS_MVK
1742
1743 #ifdef VK_USE_PLATFORM_MACOS_MVK
TEST(LoaderHandleValidTests,VerifyHandleWrappingMacOSSurf)1744 TEST(LoaderHandleValidTests, VerifyHandleWrappingMacOSSurf) {
1745 FrameworkEnvironment env{};
1746 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1747 auto& driver = env.get_test_icd();
1748 setup_WSI_in_ICD(driver);
1749
1750 const char* wrap_objects_name = "WrapObjectsLayer";
1751 env.add_explicit_layer(ManifestLayer{}.add_layer(
1752 ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1753 "wrap_objects_layer.json");
1754
1755 driver.physical_devices.emplace_back("physical_device_0");
1756 MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
1757 driver.physical_devices.back().queue_family_properties.push_back(family_props);
1758
1759 InstWrapper instance(env.vulkan_functions);
1760 setup_WSI_in_create_instance(instance);
1761 instance.CheckCreate();
1762 instance.create_info.add_layer(wrap_objects_name);
1763
1764 VkMacOSSurfaceCreateInfoMVK surf_create_info = {};
1765 surf_create_info.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
1766 surf_create_info.pNext = nullptr;
1767 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1768 PFN_vkCreateMacOSSurfaceMVK pfn_CreateSurface = instance.load("vkCreateMacOSSurfaceMVK");
1769 ASSERT_NE(pfn_CreateSurface, nullptr);
1770 PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1771 ASSERT_NE(pfn_DestroySurface, nullptr);
1772 ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1773 pfn_DestroySurface(instance, created_surface, nullptr);
1774 }
1775 #endif // VK_USE_PLATFORM_MACOS_MVK
1776
1777 #if defined(VK_USE_PLATFORM_METAL_EXT)
TEST(LoaderHandleValidTests,VerifyHandleWrappingMetalSurf)1778 TEST(LoaderHandleValidTests, VerifyHandleWrappingMetalSurf) {
1779 FrameworkEnvironment env{};
1780 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1781 auto& driver = env.get_test_icd();
1782 setup_WSI_in_ICD(driver);
1783
1784 const char* wrap_objects_name = "WrapObjectsLayer";
1785 env.add_explicit_layer(ManifestLayer{}.add_layer(
1786 ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1787 "wrap_objects_layer.json");
1788
1789 driver.physical_devices.emplace_back("physical_device_0");
1790 MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
1791 driver.physical_devices.back().queue_family_properties.push_back(family_props);
1792
1793 InstWrapper instance(env.vulkan_functions);
1794 setup_WSI_in_create_instance(instance);
1795 instance.CheckCreate();
1796 instance.create_info.add_layer(wrap_objects_name);
1797
1798 VkMetalSurfaceCreateInfoEXT surf_create_info = {};
1799 surf_create_info.sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT;
1800 surf_create_info.pNext = nullptr;
1801 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1802 PFN_vkCreateMetalSurfaceEXT pfn_CreateSurface = instance.load("vkCreateMetalSurfaceEXT");
1803 ASSERT_NE(pfn_CreateSurface, nullptr);
1804 PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1805 ASSERT_NE(pfn_DestroySurface, nullptr);
1806 ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1807 pfn_DestroySurface(instance, created_surface, nullptr);
1808 }
1809 #endif // VK_USE_PLATFORM_METAL_EXT
1810
1811 #ifdef VK_USE_PLATFORM_SCREEN_QNX
TEST(LoaderHandleValidTests,VerifyHandleWrappingQNXSurf)1812 TEST(LoaderHandleValidTests, VerifyHandleWrappingQNXSurf) {
1813 FrameworkEnvironment env{};
1814 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1815 auto& driver = env.get_test_icd();
1816 setup_WSI_in_ICD(driver);
1817
1818 const char* wrap_objects_name = "WrapObjectsLayer";
1819 env.add_explicit_layer(ManifestLayer{}.add_layer(
1820 ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1821 "wrap_objects_layer.json");
1822
1823 driver.physical_devices.emplace_back("physical_device_0");
1824 MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
1825 driver.physical_devices.back().queue_family_properties.push_back(family_props);
1826
1827 InstWrapper instance(env.vulkan_functions);
1828 setup_WSI_in_create_instance(instance);
1829 instance.CheckCreate();
1830 instance.create_info.add_layer(wrap_objects_name);
1831
1832 VkScreenSurfaceCreateInfoQNX surf_create_info = {};
1833 surf_create_info.sType = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX;
1834 surf_create_info.pNext = nullptr;
1835 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1836 PFN_vkCreateScreenSurfaceQNX pfn_CreateSurface = instance.load("vkCreateScreenSurfaceQNX");
1837 ASSERT_NE(pfn_CreateSurface, nullptr);
1838 PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1839 ASSERT_NE(pfn_DestroySurface, nullptr);
1840 ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1841 pfn_DestroySurface(instance, created_surface, nullptr);
1842 }
1843 #endif // VK_USE_PLATFORM_SCREEN_QNX
1844
1845 #ifdef VK_USE_PLATFORM_VI_NN
TEST(LoaderHandleValidTests,VerifyHandleWrappingViNNSurf)1846 TEST(LoaderHandleValidTests, VerifyHandleWrappingViNNSurf) {
1847 FrameworkEnvironment env{};
1848 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1849 auto& driver = env.get_test_icd();
1850 setup_WSI_in_ICD(driver);
1851
1852 const char* wrap_objects_name = "WrapObjectsLayer";
1853 env.add_explicit_layer(ManifestLayer{}.add_layer(
1854 ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1855 "wrap_objects_layer.json");
1856
1857 driver.physical_devices.emplace_back("physical_device_0");
1858 MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
1859 driver.physical_devices.back().queue_family_properties.push_back(family_props);
1860
1861 InstWrapper instance(env.vulkan_functions);
1862 setup_WSI_in_create_instance(instance);
1863 instance.CheckCreate();
1864 instance.create_info.add_layer(wrap_objects_name);
1865
1866 VkViSurfaceCreateInfoNN surf_create_info = {};
1867 surf_create_info.sType = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN;
1868 surf_create_info.pNext = nullptr;
1869 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1870 PFN_vkCreateViSurfaceNN pfn_CreateSurface = instance.load("vkCreateViSurfaceNN");
1871 ASSERT_NE(pfn_CreateSurface, nullptr);
1872 PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1873 ASSERT_NE(pfn_DestroySurface, nullptr);
1874 ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1875 pfn_DestroySurface(instance, created_surface, nullptr);
1876 }
1877 #endif // VK_USE_PLATFORM_VI_NN
1878
1879 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
TEST(LoaderHandleValidTests,VerifyHandleWrappingWaylandSurf)1880 TEST(LoaderHandleValidTests, VerifyHandleWrappingWaylandSurf) {
1881 FrameworkEnvironment env{};
1882 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1883 auto& driver = env.get_test_icd();
1884 setup_WSI_in_ICD(driver);
1885
1886 const char* wrap_objects_name = "WrapObjectsLayer";
1887 env.add_explicit_layer(ManifestLayer{}.add_layer(
1888 ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1889 "wrap_objects_layer.json");
1890
1891 driver.physical_devices.emplace_back("physical_device_0");
1892 MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
1893 driver.physical_devices.back().queue_family_properties.push_back(family_props);
1894
1895 InstWrapper instance(env.vulkan_functions);
1896 setup_WSI_in_create_instance(instance);
1897 instance.CheckCreate();
1898 instance.create_info.add_layer(wrap_objects_name);
1899
1900 VkWaylandSurfaceCreateInfoKHR surf_create_info = {};
1901 surf_create_info.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
1902 surf_create_info.pNext = nullptr;
1903 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1904 PFN_vkCreateWaylandSurfaceKHR pfn_CreateSurface = instance.load("vkCreateWaylandSurfaceKHR");
1905 ASSERT_NE(pfn_CreateSurface, nullptr);
1906 PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1907 ASSERT_NE(pfn_DestroySurface, nullptr);
1908 ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1909 pfn_DestroySurface(instance, created_surface, nullptr);
1910 }
1911 #endif // VK_USE_PLATFORM_WAYLAND_KHR
1912
1913 #ifdef VK_USE_PLATFORM_WIN32_KHR
TEST(LoaderHandleValidTests,VerifyHandleWrappingWin32Surf)1914 TEST(LoaderHandleValidTests, VerifyHandleWrappingWin32Surf) {
1915 FrameworkEnvironment env{};
1916 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1917 auto& driver = env.get_test_icd();
1918 setup_WSI_in_ICD(driver);
1919
1920 const char* wrap_objects_name = "WrapObjectsLayer";
1921 env.add_explicit_layer(ManifestLayer{}.add_layer(
1922 ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1923 "wrap_objects_layer.json");
1924
1925 driver.physical_devices.emplace_back("physical_device_0");
1926 MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
1927 driver.physical_devices.back().queue_family_properties.push_back(family_props);
1928
1929 InstWrapper instance(env.vulkan_functions);
1930 setup_WSI_in_create_instance(instance);
1931 instance.CheckCreate();
1932 instance.create_info.add_layer(wrap_objects_name);
1933
1934 VkWin32SurfaceCreateInfoKHR surf_create_info = {};
1935 surf_create_info.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
1936 surf_create_info.pNext = nullptr;
1937 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1938 PFN_vkCreateWin32SurfaceKHR pfn_CreateSurface = instance.load("vkCreateWin32SurfaceKHR");
1939 ASSERT_NE(pfn_CreateSurface, nullptr);
1940 PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1941 ASSERT_NE(pfn_DestroySurface, nullptr);
1942 ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1943 pfn_DestroySurface(instance, created_surface, nullptr);
1944 }
1945 #endif // VK_USE_PLATFORM_WIN32_KHR
1946
1947 #ifdef VK_USE_PLATFORM_XCB_KHR
TEST(LoaderHandleValidTests,VerifyHandleWrappingXCBSurf)1948 TEST(LoaderHandleValidTests, VerifyHandleWrappingXCBSurf) {
1949 FrameworkEnvironment env{};
1950 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1951 auto& driver = env.get_test_icd();
1952 setup_WSI_in_ICD(driver);
1953
1954 const char* wrap_objects_name = "WrapObjectsLayer";
1955 env.add_explicit_layer(ManifestLayer{}.add_layer(
1956 ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1957 "wrap_objects_layer.json");
1958
1959 driver.physical_devices.emplace_back("physical_device_0");
1960 MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
1961 driver.physical_devices.back().queue_family_properties.push_back(family_props);
1962
1963 InstWrapper instance(env.vulkan_functions);
1964 setup_WSI_in_create_instance(instance);
1965 instance.CheckCreate();
1966 instance.create_info.add_layer(wrap_objects_name);
1967
1968 VkXcbSurfaceCreateInfoKHR surf_create_info = {};
1969 surf_create_info.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
1970 surf_create_info.pNext = nullptr;
1971 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
1972 PFN_vkCreateXcbSurfaceKHR pfn_CreateSurface = instance.load("vkCreateXcbSurfaceKHR");
1973 ASSERT_NE(pfn_CreateSurface, nullptr);
1974 PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
1975 ASSERT_NE(pfn_DestroySurface, nullptr);
1976 ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
1977 pfn_DestroySurface(instance, created_surface, nullptr);
1978 }
1979 #endif // VK_USE_PLATFORM_XCB_KHR
1980
1981 #ifdef VK_USE_PLATFORM_XLIB_KHR
TEST(LoaderHandleValidTests,VerifyHandleWrappingXlibSurf)1982 TEST(LoaderHandleValidTests, VerifyHandleWrappingXlibSurf) {
1983 FrameworkEnvironment env{};
1984 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
1985 auto& driver = env.get_test_icd();
1986 setup_WSI_in_ICD(driver);
1987
1988 const char* wrap_objects_name = "WrapObjectsLayer";
1989 env.add_explicit_layer(ManifestLayer{}.add_layer(
1990 ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
1991 "wrap_objects_layer.json");
1992
1993 driver.physical_devices.emplace_back("physical_device_0");
1994 MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
1995 driver.physical_devices.back().queue_family_properties.push_back(family_props);
1996
1997 InstWrapper instance(env.vulkan_functions);
1998 setup_WSI_in_create_instance(instance);
1999 instance.CheckCreate();
2000 instance.create_info.add_layer(wrap_objects_name);
2001
2002 VkXlibSurfaceCreateInfoKHR surf_create_info = {};
2003 surf_create_info.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
2004 surf_create_info.pNext = nullptr;
2005 VkSurfaceKHR created_surface = VK_NULL_HANDLE;
2006 PFN_vkCreateXlibSurfaceKHR pfn_CreateSurface = instance.load("vkCreateXlibSurfaceKHR");
2007 ASSERT_NE(pfn_CreateSurface, nullptr);
2008 PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
2009 ASSERT_NE(pfn_DestroySurface, nullptr);
2010 ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
2011 pfn_DestroySurface(instance, created_surface, nullptr);
2012 }
2013 #endif // VK_USE_PLATFORM_XLIB_KHR
2014
JunkDebugUtilsCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,VkDebugUtilsMessageTypeFlagsEXT messageTypes,const VkDebugUtilsMessengerCallbackDataEXT * pCallbackData,void * pUserData)2015 static VKAPI_ATTR VkBool32 VKAPI_CALL JunkDebugUtilsCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
2016 VkDebugUtilsMessageTypeFlagsEXT messageTypes,
2017 const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
2018 void* pUserData) {
2019 // This is just a stub callback in case the loader or any other layer triggers it.
2020 (void)messageSeverity;
2021 (void)messageTypes;
2022 (void)pCallbackData;
2023 (void)pUserData;
2024 return VK_FALSE;
2025 }
2026
TEST(LoaderHandleValidTests,VerifyHandleWrappingDebugUtilsMessenger)2027 TEST(LoaderHandleValidTests, VerifyHandleWrappingDebugUtilsMessenger) {
2028 FrameworkEnvironment env{};
2029 env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
2030 Extension ext{"VK_EXT_debug_utils"};
2031 auto& driver = env.get_test_icd();
2032 driver.add_instance_extensions({ext});
2033
2034 const char* wrap_objects_name = "WrapObjectsLayer";
2035 env.add_explicit_layer(ManifestLayer{}.add_layer(
2036 ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
2037 "wrap_objects_layer.json");
2038
2039 driver.physical_devices.emplace_back("physical_device_0");
2040 MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
2041 driver.physical_devices.back().queue_family_properties.push_back(family_props);
2042
2043 InstWrapper instance(env.vulkan_functions);
2044 instance.create_info.add_extension("VK_EXT_debug_utils");
2045 instance.create_info.add_layer(wrap_objects_name);
2046 instance.CheckCreate();
2047
2048 VkDebugUtilsMessengerCreateInfoEXT debug_messenger_create_info = {};
2049 debug_messenger_create_info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
2050 debug_messenger_create_info.pNext = nullptr;
2051 debug_messenger_create_info.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
2052 debug_messenger_create_info.messageType =
2053 VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT;
2054 debug_messenger_create_info.pfnUserCallback = reinterpret_cast<PFN_vkDebugUtilsMessengerCallbackEXT>(JunkDebugUtilsCallback);
2055 VkDebugUtilsMessengerEXT messenger = VK_NULL_HANDLE;
2056 PFN_vkCreateDebugUtilsMessengerEXT pfn_CreateMessenger = instance.load("vkCreateDebugUtilsMessengerEXT");
2057 ASSERT_NE(pfn_CreateMessenger, nullptr);
2058 PFN_vkDestroyDebugUtilsMessengerEXT pfn_DestroyMessenger = instance.load("vkDestroyDebugUtilsMessengerEXT");
2059 ASSERT_NE(pfn_DestroyMessenger, nullptr);
2060 ASSERT_EQ(VK_SUCCESS, pfn_CreateMessenger(instance, &debug_messenger_create_info, nullptr, &messenger));
2061 pfn_DestroyMessenger(instance, messenger, nullptr);
2062 }
2063