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