/*
 * Copyright (c) 2021-2022 The Khronos Group Inc.
 * Copyright (c) 2021-2022 Valve Corporation
 * Copyright (c) 2021-2022 LunarG, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and/or associated documentation files (the "Materials"), to
 * deal in the Materials without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Materials, and to permit persons to whom the Materials are
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice(s) and this permission notice shall be included in
 * all copies or substantial portions of the Materials.
 *
 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 *
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE
 * USE OR OTHER DEALINGS IN THE MATERIALS.
 *
 * Author(s): Charles Giessen <charles@lunarg.com>
 *            Mark Young <marky@lunarg.com>
 */

#include "test_environment.h"

// ---- Invalid Instance tests

struct BadData {
    uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
};
template <typename T>
T get_bad_handle() {
    static BadData my_bad_data;
    return reinterpret_cast<T>(static_cast<void*>(&my_bad_data));
}

TEST(LoaderHandleValidTests, BadInstEnumPhysDevices) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");

    InstWrapper instance(env.vulkan_functions);
    instance.CheckCreate();

    auto bad_instance = get_bad_handle<VkInstance>();
    uint32_t returned_physical_count = 0;

    ASSERT_DEATH(env.vulkan_functions.vkEnumeratePhysicalDevices(bad_instance, &returned_physical_count, nullptr),
                 "vkEnumeratePhysicalDevices: Invalid instance \\[VUID-vkEnumeratePhysicalDevices-instance-parameter\\]");
}

TEST(LoaderHandleValidTests, BadInstGetInstProcAddr) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");

    InstWrapper instance(env.vulkan_functions);
    instance.CheckCreate();

    auto bad_instance = get_bad_handle<VkInstance>();
    ASSERT_DEATH(env.vulkan_functions.vkGetInstanceProcAddr(bad_instance, "vkGetBufferDeviceAddress"),
                 "vkGetInstanceProcAddr: Invalid instance \\[VUID-vkGetInstanceProcAddr-instance-parameter\\]");
}

TEST(LoaderHandleValidTests, BadInstDestroyInstance) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_physical_device("physical_device_0");

    InstWrapper instance(env.vulkan_functions);
    instance.CheckCreate();

    auto bad_instance = get_bad_handle<VkInstance>();

    ASSERT_DEATH(env.vulkan_functions.vkDestroyInstance(bad_instance, nullptr),
                 "vkDestroyInstance: Invalid instance \\[VUID-vkDestroyInstance-instance-parameter\\]");
}

TEST(LoaderHandleValidTests, BadInstDestroySurface) {
    FrameworkEnvironment env{};
    Extension first_ext{"VK_KHR_surface"};
    Extension second_ext{"VK_EXT_headless_surface"};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_instance_extensions({first_ext, second_ext})
        .add_physical_device("physical_device_0");

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.add_extension(first_ext.extensionName.c_str());
    instance.CheckCreate();

    auto bad_instance = get_bad_handle<VkInstance>();

    ASSERT_DEATH(env.vulkan_functions.vkDestroySurfaceKHR(bad_instance, VK_NULL_HANDLE, nullptr),
                 "vkDestroySurfaceKHR: Invalid instance \\[VUID-vkDestroySurfaceKHR-instance-parameter\\]");
}

TEST(LoaderHandleValidTests, BadInstCreateHeadlessSurf) {
    FrameworkEnvironment env{};
    Extension first_ext{"VK_KHR_surface"};
    Extension second_ext{"VK_EXT_headless_surface"};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_instance_extensions({first_ext, second_ext})
        .add_physical_device("physical_device_0");

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.add_extensions({first_ext.extensionName.c_str(), second_ext.extensionName.c_str()});
    instance.CheckCreate();

    auto bad_instance = get_bad_handle<VkInstance>();

    VkHeadlessSurfaceCreateInfoEXT surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    ASSERT_DEATH(env.vulkan_functions.vkCreateHeadlessSurfaceEXT(bad_instance, &surf_create_info, nullptr, &created_surface),
                 "vkCreateHeadlessSurfaceEXT: Invalid instance \\[VUID-vkCreateHeadlessSurfaceEXT-instance-parameter\\]");
}

TEST(LoaderHandleValidTests, BadInstCreateDisplayPlaneSurf) {
    FrameworkEnvironment env{};
    Extension first_ext{"VK_KHR_surface"};
    Extension second_ext{"VK_KHR_display"};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_instance_extensions({first_ext, second_ext})
        .add_physical_device("physical_device_0");

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.add_extensions({first_ext.extensionName.c_str(), second_ext.extensionName.c_str()});
    instance.CheckCreate();

    auto bad_instance = get_bad_handle<VkInstance>();

    VkDisplaySurfaceCreateInfoKHR surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    ASSERT_DEATH(env.vulkan_functions.vkCreateDisplayPlaneSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
                 "vkCreateDisplayPlaneSurfaceKHR: Invalid instance \\[VUID-vkCreateDisplayPlaneSurfaceKHR-instance-parameter\\]");
}

#if defined(VK_USE_PLATFORM_ANDROID_KHR)
TEST(LoaderHandleValidTests, BadInstCreateAndroidSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.CheckCreate();

    auto bad_instance = get_bad_handle<VkInstance>();

    VkAndroidSurfaceCreateInfoKHR surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    ASSERT_DEATH(env.vulkan_functions.vkCreateAndroidSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
                 "vkCreateAndroidSurfaceKHR: Invalid instance \\[VUID-vkCreateAndroidSurfaceKHR-instance-parameter\\]");
}
#endif  // VK_USE_PLATFORM_ANDROID_KHR

#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
TEST(LoaderHandleValidTests, BadInstCreateDirectFBSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.CheckCreate();

    auto bad_instance = get_bad_handle<VkInstance>();

    VkDirectFBSurfaceCreateInfoEXT surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    ASSERT_DEATH(env.vulkan_functions.vkCreateDirectFBSurfaceEXT(bad_instance, &surf_create_info, nullptr, &created_surface),
                 "vkCreateDirectFBSurfaceEXT: Invalid instance \\[VUID-vkCreateDirectFBSurfaceEXT-instance-parameter\\]");
}
#endif  // VK_USE_PLATFORM_DIRECTFB_EXT

#if defined(VK_USE_PLATFORM_FUCHSIA)
TEST(LoaderHandleValidTests, BadInstCreateFuchsiaSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.CheckCreate();

    auto bad_instance = get_bad_handle<VkInstance>();

    VkImagePipeSurfaceCreateInfoFUCHSIA surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    ASSERT_DEATH(env.vulkan_functions.vkCreateImagePipeSurfaceFUCHSIA(bad_instance, &surf_create_info, nullptr, &created_surface),
                 "vkCreateImagePipeSurfaceFUCHSIA: Invalid instance \\[VUID-vkCreateImagePipeSurfaceFUCHSIA-instance-parameter\\]");
}
#endif  // VK_USE_PLATFORM_FUCHSIA

#if defined(VK_USE_PLATFORM_GGP)
TEST(LoaderHandleValidTests, BadInstCreateGGPSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.CheckCreate();

    auto bad_instance = get_bad_handle<VkInstance>();

    VkStreamDescriptorSurfaceCreateInfoGGP surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    ASSERT_DEATH(
        env.vulkan_functions.vkCreateStreamDescriptorSurfaceGGP(bad_instance, &surf_create_info, nullptr, &created_surface),
        "vkCreateStreamDescriptorSurfaceGGP: Invalid instance \\[VUID-vkCreateStreamDescriptorSurfaceGGP-instance-parameter\\]");
}
#endif  // VK_USE_PLATFORM_GGP

#if defined(VK_USE_PLATFORM_IOS_MVK)
TEST(LoaderHandleValidTests, BadInstCreateIOSSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.CheckCreate();

    auto bad_instance = get_bad_handle<VkInstance>();

    VkIOSSurfaceCreateInfoMVK surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    ASSERT_DEATH(env.vulkan_functions.vkCreateIOSSurfaceMVK(bad_instance, &surf_create_info, nullptr, &created_surface),
                 "vkCreateIOSSurfaceMVK: Invalid instance \\[VUID-vkCreateIOSSurfaceMVK-instance-parameter\\]");
}
#endif  // VK_USE_PLATFORM_IOS_MVK

#if defined(VK_USE_PLATFORM_MACOS_MVK)
TEST(LoaderHandleValidTests, BadInstCreateMacOSSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.CheckCreate();

    auto bad_instance = get_bad_handle<VkInstance>();

    VkMacOSSurfaceCreateInfoMVK surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    ASSERT_DEATH(env.vulkan_functions.vkCreateMacOSSurfaceMVK(bad_instance, &surf_create_info, nullptr, &created_surface),
                 "vkCreateMacOSSurfaceMVK: Invalid instance \\[VUID-vkCreateMacOSSurfaceMVK-instance-parameter\\]");
}
#endif  // VK_USE_PLATFORM_MACOS_MVK

#if defined(VK_USE_PLATFORM_METAL_EXT)
TEST(LoaderHandleValidTests, BadInstCreateMetalSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.CheckCreate();

    auto bad_instance = get_bad_handle<VkInstance>();

    VkMetalSurfaceCreateInfoEXT surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    ASSERT_DEATH(env.vulkan_functions.vkCreateMetalSurfaceEXT(bad_instance, &surf_create_info, nullptr, &created_surface),
                 "vkCreateMetalSurfaceEXT: Invalid instance \\[VUID-vkCreateMetalSurfaceEXT-instance-parameter\\]");
}
#endif  // VK_USE_PLATFORM_METAL_EXT

#if defined(VK_USE_PLATFORM_SCREEN_QNX)
TEST(LoaderHandleValidTests, BadInstCreateQNXSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.CheckCreate();

    auto bad_instance = get_bad_handle<VkInstance>();

    VkScreenSurfaceCreateInfoQNX surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    ASSERT_DEATH(env.vulkan_functions.vkCreateScreenSurfaceQNX(bad_instance, &surf_create_info, nullptr, &created_surface),
                 "vkCreateScreenSurfaceQNX: Invalid instance \\[VUID-vkCreateScreenSurfaceQNX-instance-parameter\\]");
    // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
}
#endif  // VK_USE_PLATFORM_SCREEN_QNX

#if defined(VK_USE_PLATFORM_VI_NN)
TEST(LoaderHandleValidTests, BadInstCreateViNNSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.CheckCreate();

    auto bad_instance = get_bad_handle<VkInstance>();

    VkViSurfaceCreateInfoNN surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    ASSERT_DEATH(env.vulkan_functions.vkCreateViSurfaceNN(bad_instance, &surf_create_info, nullptr, &created_surface),
                 "vkCreateViSurfaceNN: Invalid instance \\[VUID-vkCreateViSurfaceNN-instance-parameter\\]");
    // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
}
#endif  // VK_USE_PLATFORM_VI_NN

#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
TEST(LoaderHandleValidTests, BadInstCreateWaylandSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.CheckCreate();

    auto bad_instance = get_bad_handle<VkInstance>();

    VkWaylandSurfaceCreateInfoKHR surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    ASSERT_DEATH(env.vulkan_functions.vkCreateWaylandSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
                 "vkCreateWaylandSurfaceKHR: Invalid instance \\[VUID-vkCreateWaylandSurfaceKHR-instance-parameter\\]");
    // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
}
#endif  // VK_USE_PLATFORM_WAYLAND_KHR

#if defined(VK_USE_PLATFORM_WIN32_KHR)
TEST(LoaderHandleValidTests, BadInstCreateWin32Surf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.CheckCreate();

    auto bad_instance = get_bad_handle<VkInstance>();

    VkWin32SurfaceCreateInfoKHR surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    ASSERT_DEATH(env.vulkan_functions.vkCreateWin32SurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
                 "vkCreateWin32SurfaceKHR: Invalid instance \\[VUID-vkCreateWin32SurfaceKHR-instance-parameter\\]");
    // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
}
#endif  // VK_USE_PLATFORM_WIN32_KHR

#if defined(VK_USE_PLATFORM_XCB_KHR)
TEST(LoaderHandleValidTests, BadInstCreateXCBSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.CheckCreate();

    auto bad_instance = get_bad_handle<VkInstance>();

    VkXcbSurfaceCreateInfoKHR surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    ASSERT_DEATH(env.vulkan_functions.vkCreateXcbSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
                 "vkCreateXcbSurfaceKHR: Invalid instance \\[VUID-vkCreateXcbSurfaceKHR-instance-parameter\\]");
    // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
}
#endif  // VK_USE_PLATFORM_XCB_KHR

#if defined(VK_USE_PLATFORM_XLIB_KHR)
TEST(LoaderHandleValidTests, BadInstCreateXlibSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.CheckCreate();

    auto bad_instance = get_bad_handle<VkInstance>();

    VkXlibSurfaceCreateInfoKHR surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    ASSERT_DEATH(env.vulkan_functions.vkCreateXlibSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
                 "vkCreateXlibSurfaceKHR: Invalid instance \\[VUID-vkCreateXlibSurfaceKHR-instance-parameter\\]");
    // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
}
#endif  // VK_USE_PLATFORM_XLIB_KHR

// ---- Invalid Physical Device tests

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFeature) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_physical_device({})
        .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.set_api_version(1, 1, 0);
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();

    VkPhysicalDeviceFeatures features = {};
    ASSERT_DEATH(
        env.vulkan_functions.vkGetPhysicalDeviceFeatures(bad_physical_dev, &features),
        "vkGetPhysicalDeviceFeatures: Invalid physicalDevice \\[VUID-vkGetPhysicalDeviceFeatures-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFormatProps) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_physical_device({})
        .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.set_api_version(1, 1, 0);
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();

    VkFormatProperties format_info = {};
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceFormatProperties(bad_physical_dev, VK_FORMAT_R8G8B8A8_UNORM, &format_info),
                 "vkGetPhysicalDeviceFormatProperties: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceFormatProperties-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevImgFormatProps) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_physical_device({})
        .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.set_api_version(1, 1, 0);
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();

    VkImageFormatProperties format_info = {};
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceImageFormatProperties(bad_physical_dev, VK_FORMAT_R8G8B8A8_UNORM,
                                                                               VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_LINEAR,
                                                                               VK_IMAGE_USAGE_STORAGE_BIT, 0, &format_info),
                 "vkGetPhysicalDeviceImageFormatProperties: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceImageFormatProperties-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevProps) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_physical_device({})
        .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.set_api_version(1, 1, 0);
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();

    VkPhysicalDeviceProperties properties = {};
    ASSERT_DEATH(
        env.vulkan_functions.vkGetPhysicalDeviceProperties(bad_physical_dev, &properties),
        "vkGetPhysicalDeviceProperties: Invalid physicalDevice \\[VUID-vkGetPhysicalDeviceProperties-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamProps) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_physical_device({})
        .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.set_api_version(1, 1, 0);
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    uint32_t count = 0;
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(bad_physical_dev, &count, nullptr),
                 "vkGetPhysicalDeviceQueueFamilyProperties: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceQueueFamilyProperties-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDevMemProps) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_physical_device({})
        .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.set_api_version(1, 1, 0);
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();

    VkPhysicalDeviceMemoryProperties properties = {};
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceMemoryProperties(bad_physical_dev, &properties),
                 "vkGetPhysicalDeviceMemoryProperties: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceMemoryProperties-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevCreateDevice) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_physical_device({})
        .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.set_api_version(1, 1, 0);
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();

    float queue_priorities[3] = {0.0f, 0.5f, 1.0f};
    VkDeviceQueueCreateInfo dev_queue_create_info = {};
    dev_queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
    dev_queue_create_info.pNext = nullptr;
    dev_queue_create_info.flags = 0;
    dev_queue_create_info.queueFamilyIndex = 0;
    dev_queue_create_info.queueCount = 1;
    dev_queue_create_info.pQueuePriorities = queue_priorities;
    VkDeviceCreateInfo dev_create_info = {};
    dev_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
    dev_create_info.pNext = nullptr;
    dev_create_info.flags = 0;
    dev_create_info.queueCreateInfoCount = 1;
    dev_create_info.pQueueCreateInfos = &dev_queue_create_info;
    dev_create_info.enabledLayerCount = 0;
    dev_create_info.ppEnabledLayerNames = nullptr;
    dev_create_info.enabledExtensionCount = 0;
    dev_create_info.ppEnabledExtensionNames = nullptr;
    dev_create_info.pEnabledFeatures = nullptr;
    VkDevice created_dev = VK_NULL_HANDLE;
    ASSERT_DEATH(env.vulkan_functions.vkCreateDevice(bad_physical_dev, &dev_create_info, nullptr, &created_dev),
                 "vkCreateDevice: Invalid physicalDevice \\[VUID-vkCreateDevice-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevEnumDevExtProps) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_physical_device({})
        .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.set_api_version(1, 1, 0);
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    uint32_t count = 0;
    ASSERT_DEATH(env.vulkan_functions.vkEnumerateDeviceExtensionProperties(bad_physical_dev, nullptr, &count, nullptr),
                 "vkEnumerateDeviceExtensionProperties: Invalid physicalDevice "
                 "\\[VUID-vkEnumerateDeviceExtensionProperties-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevEnumDevLayerProps) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_physical_device({})
        .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.set_api_version(1, 1, 0);
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    uint32_t count = 0;
    ASSERT_DEATH(env.vulkan_functions.vkEnumerateDeviceLayerProperties(bad_physical_dev, &count, nullptr),
                 "vkEnumerateDeviceLayerProperties: Invalid physicalDevice "
                 "\\[VUID-vkEnumerateDeviceLayerProperties-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSparseImgFormatProps) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_physical_device({})
        .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.set_api_version(1, 1, 0);
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();

    uint32_t count = 0;
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSparseImageFormatProperties(
                     bad_physical_dev, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_TYPE_2D, VK_SAMPLE_COUNT_1_BIT,
                     VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_TILING_LINEAR, &count, nullptr),
                 "vkGetPhysicalDeviceSparseImageFormatProperties: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceSparseImageFormatProperties-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFeature2) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_physical_device({})
        .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.set_api_version(1, 1, 0);
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();

    VkPhysicalDeviceFeatures2 features = {};
    features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
    features.pNext = nullptr;
    ASSERT_DEATH(
        env.vulkan_functions.vkGetPhysicalDeviceFeatures2(bad_physical_dev, &features),
        "vkGetPhysicalDeviceFeatures2: Invalid physicalDevice \\[VUID-vkGetPhysicalDeviceFeatures2-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFormatProps2) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_physical_device({})
        .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.set_api_version(1, 1, 0);
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();

    VkFormatProperties2 properties = {};
    properties.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
    properties.pNext = nullptr;
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceFormatProperties2(bad_physical_dev, VK_FORMAT_R8G8B8A8_UNORM, &properties),
                 "vkGetPhysicalDeviceFormatProperties2: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceFormatProperties2-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevImgFormatProps2) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_physical_device({})
        .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.set_api_version(1, 1, 0);
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();

    VkPhysicalDeviceImageFormatInfo2 format_info = {};
    format_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2;
    format_info.pNext = nullptr;
    VkImageFormatProperties2 properties = {};
    properties.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
    properties.pNext = nullptr;
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceImageFormatProperties2(bad_physical_dev, &format_info, &properties),
                 "vkGetPhysicalDeviceImageFormatProperties2: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceImageFormatProperties2-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevProps2) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_physical_device({})
        .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.set_api_version(1, 1, 0);
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();

    VkPhysicalDeviceProperties2 properties = {};
    properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
    properties.pNext = nullptr;
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceProperties2(bad_physical_dev, &properties),
                 "vkGetPhysicalDeviceProperties2: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceProperties2-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamProps2) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_physical_device({})
        .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.set_api_version(1, 1, 0);
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    uint32_t count = 0;
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties2(bad_physical_dev, &count, nullptr),
                 "vkGetPhysicalDeviceQueueFamilyProperties2: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceQueueFamilyProperties2-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDevMemProps2) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_physical_device({})
        .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.set_api_version(1, 1, 0);
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();

    VkPhysicalDeviceMemoryProperties2 properties = {};
    properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
    properties.pNext = nullptr;
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceMemoryProperties2(bad_physical_dev, &properties),
                 "vkGetPhysicalDeviceMemoryProperties2: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceMemoryProperties2-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSparseImgFormatProps2) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_physical_device({})
        .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.set_api_version(1, 1, 0);
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();

    VkPhysicalDeviceSparseImageFormatInfo2 info = {};
    info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2;
    info.pNext = nullptr;
    uint32_t count = 0;
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSparseImageFormatProperties2(bad_physical_dev, &info, &count, nullptr),
                 "vkGetPhysicalDeviceSparseImageFormatProperties2: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevExternFenceProps) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_physical_device({})
        .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.set_api_version(1, 1, 0);
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();

    VkPhysicalDeviceExternalFenceInfo info = {};
    info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO;
    info.pNext = nullptr;
    VkExternalFenceProperties props = {};
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceExternalFenceProperties(bad_physical_dev, &info, &props),
                 "vkGetPhysicalDeviceExternalFenceProperties: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceExternalFenceProperties-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevExternBufferProps) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_physical_device({})
        .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.set_api_version(1, 1, 0);
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();

    VkPhysicalDeviceExternalBufferInfo info = {};
    info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO;
    info.pNext = nullptr;
    VkExternalBufferProperties props = {};
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceExternalBufferProperties(bad_physical_dev, &info, &props),
                 "vkGetPhysicalDeviceExternalBufferProperties: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceExternalBufferProperties-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevExternSemaphoreProps) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_physical_device({})
        .set_icd_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.set_api_version(1, 1, 0);
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();

    VkPhysicalDeviceExternalSemaphoreInfo info = {};
    info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO;
    info.pNext = nullptr;
    VkExternalSemaphoreProperties props = {};
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceExternalSemaphoreProperties(bad_physical_dev, &info, &props),
                 "vkGetPhysicalDeviceExternalSemaphoreProperties: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceSupportKHR) {
    FrameworkEnvironment env{};
    Extension first_ext{"VK_KHR_surface"};
    Extension second_ext{"VK_KHR_display"};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_instance_extensions({first_ext, second_ext})
        .add_physical_device("physical_device_0");

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.add_extension(first_ext.extensionName.c_str());
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    VkBool32 supported = VK_FALSE;

    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfaceSupportKHR(bad_physical_dev, 0, VK_NULL_HANDLE, &supported),
                 "vkGetPhysicalDeviceSurfaceSupportKHR: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceSurfaceSupportKHR-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceCapsKHR) {
    FrameworkEnvironment env{};
    Extension first_ext{"VK_KHR_surface"};
    Extension second_ext{"VK_KHR_display"};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_instance_extensions({first_ext, second_ext})
        .add_physical_device("physical_device_0");

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.add_extension(first_ext.extensionName.c_str());
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    VkSurfaceCapabilitiesKHR caps = {};
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(bad_physical_dev, VK_NULL_HANDLE, &caps),
                 "vkGetPhysicalDeviceSurfaceCapabilitiesKHR: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceFormatsKHR) {
    FrameworkEnvironment env{};
    Extension first_ext{"VK_KHR_surface"};
    Extension second_ext{"VK_KHR_display"};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_instance_extensions({first_ext, second_ext})
        .add_physical_device("physical_device_0");

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.add_extension(first_ext.extensionName.c_str());
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    uint32_t count = 0;
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfaceFormatsKHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
                 "vkGetPhysicalDeviceSurfaceFormatsKHR: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfacePresentModesKHR) {
    FrameworkEnvironment env{};
    Extension first_ext{"VK_KHR_surface"};
    Extension second_ext{"VK_KHR_display"};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_instance_extensions({first_ext, second_ext})
        .add_physical_device("physical_device_0");

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.add_extension(first_ext.extensionName.c_str());
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    uint32_t count = 0;
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfacePresentModesKHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
                 "vkGetPhysicalDeviceSurfacePresentModesKHR: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-physicalDevice-parameter\\]");
}

#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
TEST(LoaderHandleValidTests, BadPhysDevGetDirectFBPresentSupportKHR) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    IDirectFB directfb;
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceDirectFBPresentationSupportEXT(bad_physical_dev, 0, &directfb),
                 "vkGetPhysicalDeviceDirectFBPresentationSupportEXT: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceDirectFBPresentationSupportEXT-physicalDevice-parameter\\]");
}
#endif  // VK_USE_PLATFORM_DIRECTFB_EXT

#if defined(VK_USE_PLATFORM_SCREEN_QNX)
TEST(LoaderHandleValidTests, BadPhysDevGetQNXPresentSupportKHR) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    ASSERT_DEATH(env.vulkan_functions.PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX(bad_physical_dev, 0, nullptr),
                 "vkGetPhysicalDeviceScreenPresentationSupportQNX: Invalid instance "
                 "\\[VUID-vkGetPhysicalDeviceScreenPresentationSupportQNX-instance-parameter\\]");
}
#endif  // VK_USE_PLATFORM_SCREEN_QNX

#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevWaylandPresentSupportKHR) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceWaylandPresentationSupportKHR(bad_physical_dev, 0, nullptr),
                 "vkGetPhysicalDeviceWaylandPresentationSupportKHR: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-physicalDevice-parameter\\]");
}
#endif  // VK_USE_PLATFORM_WAYLAND_KHR

#if defined(VK_USE_PLATFORM_WIN32_KHR)
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevWin32PresentSupportKHR) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceWin32PresentationSupportKHR(bad_physical_dev, 0),
                 "vkGetPhysicalDeviceWin32PresentationSupportKHR: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceWin32PresentationSupportKHR-physicalDevice-parameter\\]");
}
#endif  // VK_USE_PLATFORM_WIN32_KHR

#if defined(VK_USE_PLATFORM_XCB_KHR)
TEST(LoaderHandleValidTests, BadPhysDevGetXCBPresentSupportKHR) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.CheckCreate();
    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();

    xcb_visualid_t visual = 0;
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceXcbPresentationSupportKHR(bad_physical_dev, 0, nullptr, visual),
                 "vkGetPhysicalDeviceXcbPresentationSupportKHR: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-physicalDevice-parameter\\]");
}
#endif  // VK_USE_PLATFORM_XCB_KHR

#if defined(VK_USE_PLATFORM_XLIB_KHR)
TEST(LoaderHandleValidTests, BadPhysDevGetXlibPresentSupportKHR) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();

    VisualID visual = 0;
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceXlibPresentationSupportKHR(bad_physical_dev, 0, nullptr, visual),
                 "vkGetPhysicalDeviceXlibPresentationSupportKHR: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-physicalDevice-parameter\\]");
}
#endif  // VK_USE_PLATFORM_XLIB_KHR

InstWrapper setup_BadPhysDev_env(FrameworkEnvironment& env, std::vector<const char*> exts) {
    std::vector<Extension> ext_modified;
    for (const auto& ext : exts) {
        ext_modified.push_back(Extension{ext});
    }
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
        .add_instance_extensions(ext_modified)
        .setup_WSI()
        .add_physical_device("physical_device_0");

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.add_extensions(exts);
    instance.CheckCreate();
    return instance;
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPropsKHR) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_display"});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    uint32_t count = 0;
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceDisplayPropertiesKHR(bad_physical_dev, &count, nullptr),
                 "vkGetPhysicalDeviceDisplayPropertiesKHR: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPlanePropsKHR) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_display"});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    uint32_t count = 0;
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceDisplayPlanePropertiesKHR(bad_physical_dev, &count, nullptr),
                 "vkGetPhysicalDeviceDisplayPlanePropertiesKHR: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneSupportedDisplaysKHR) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_display"});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    uint32_t count = 0;
    ASSERT_DEATH(env.vulkan_functions.vkGetDisplayPlaneSupportedDisplaysKHR(bad_physical_dev, 0, &count, nullptr),
                 "vkGetDisplayPlaneSupportedDisplaysKHR: Invalid physicalDevice "
                 "\\[VUID-vkGetDisplayPlaneSupportedDisplaysKHR-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetDisplayModePropsKHR) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_display"});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    uint32_t count = 0;
    ASSERT_DEATH(
        env.vulkan_functions.vkGetDisplayModePropertiesKHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
        "vkGetDisplayModePropertiesKHR: Invalid physicalDevice \\[VUID-vkGetDisplayModePropertiesKHR-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevCreateDisplayModeKHR) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_display"});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    VkDisplayModeCreateInfoKHR create_info = {};
    create_info.sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
    create_info.pNext = nullptr;
    VkDisplayModeKHR display_mode;
    ASSERT_DEATH(
        env.vulkan_functions.vkCreateDisplayModeKHR(bad_physical_dev, VK_NULL_HANDLE, &create_info, nullptr, &display_mode),
        "vkCreateDisplayModeKHR: Invalid physicalDevice \\[VUID-vkCreateDisplayModeKHR-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneCapsKHR) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_display"});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    VkDisplayPlaneCapabilitiesKHR caps = {};
    ASSERT_DEATH(env.vulkan_functions.vkGetDisplayPlaneCapabilitiesKHR(bad_physical_dev, VK_NULL_HANDLE, 0, &caps),
                 "vkGetDisplayPlaneCapabilitiesKHR: Invalid physicalDevice "
                 "\\[VUID-vkGetDisplayPlaneCapabilitiesKHR-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevPresentRectsKHR) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_display"});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    uint32_t count = 0;
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDevicePresentRectanglesKHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
                 "vkGetPhysicalDevicePresentRectanglesKHR: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDevicePresentRectanglesKHR-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayProps2KHR) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_get_display_properties2"});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    uint32_t count = 0;
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceDisplayProperties2KHR(bad_physical_dev, &count, nullptr),
                 "vkGetPhysicalDeviceDisplayProperties2KHR: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceDisplayProperties2KHR-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPlaneProps2KHR) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_get_display_properties2"});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    uint32_t count = 0;
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceDisplayPlaneProperties2KHR(bad_physical_dev, &count, nullptr),
                 "vkGetPhysicalDeviceDisplayPlaneProperties2KHR: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceDisplayPlaneProperties2KHR-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetDisplayModeProps2KHR) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_get_display_properties2"});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    uint32_t count = 0;
    ASSERT_DEATH(env.vulkan_functions.vkGetDisplayModeProperties2KHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
                 "vkGetDisplayModeProperties2KHR: Invalid physicalDevice "
                 "\\[VUID-vkGetDisplayModeProperties2KHR-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneCaps2KHR) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_get_display_properties2"});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    VkDisplayPlaneInfo2KHR disp_plane_info = {};
    disp_plane_info.sType = VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR;
    disp_plane_info.pNext = nullptr;
    VkDisplayPlaneCapabilities2KHR caps = {};
    ASSERT_DEATH(env.vulkan_functions.vkGetDisplayPlaneCapabilities2KHR(bad_physical_dev, &disp_plane_info, &caps),
                 "vkGetDisplayPlaneCapabilities2KHR: Invalid physicalDevice "
                 "\\[VUID-vkGetDisplayPlaneCapabilities2KHR-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceCaps2KHR) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_get_surface_capabilities2"});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    VkPhysicalDeviceSurfaceInfo2KHR phys_dev_surf_info = {};
    phys_dev_surf_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
    phys_dev_surf_info.pNext = nullptr;
    VkSurfaceCapabilities2KHR caps = {};
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfaceCapabilities2KHR(bad_physical_dev, &phys_dev_surf_info, &caps),
                 "vkGetPhysicalDeviceSurfaceCapabilities2KHR: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceFormats2KHR) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_KHR_get_surface_capabilities2"});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    VkPhysicalDeviceSurfaceInfo2KHR phys_dev_surf_info = {};
    phys_dev_surf_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
    phys_dev_surf_info.pNext = nullptr;
    uint32_t count = 0;
    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfaceFormats2KHR(bad_physical_dev, &phys_dev_surf_info, &count, nullptr),
                 "vkGetPhysicalDeviceSurfaceFormats2KHR: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevEnumPhysDevQueueFamilyPerfQueryCountersKHR) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    uint32_t count = 0;
    PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR pfn =
        instance.load("vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR");
    ASSERT_NE(pfn, nullptr);
    ASSERT_DEATH(pfn(bad_physical_dev, 0, &count, nullptr, nullptr),
                 "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR: Invalid physicalDevice "
                 "\\[VUID-vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamilyPerfQueryPassesKHR) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    VkQueryPoolPerformanceCreateInfoKHR create_info = {};
    create_info.sType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR;
    create_info.pNext = nullptr;
    uint32_t count = 0;
    PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR pfn =
        instance.load("vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR");
    ASSERT_NE(pfn, nullptr);
    ASSERT_DEATH(pfn(bad_physical_dev, &create_info, &count),
                 "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFragmentShadingRatesKHR) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    uint32_t count = 0;
    PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR pfn = instance.load("vkGetPhysicalDeviceFragmentShadingRatesKHR");
    ASSERT_NE(pfn, nullptr);
    ASSERT_DEATH(pfn(bad_physical_dev, &count, nullptr),
                 "vkGetPhysicalDeviceFragmentShadingRatesKHR: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceFragmentShadingRatesKHR-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevMSPropsEXT) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    VkMultisamplePropertiesEXT props = {};
    PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT pfn = instance.load("vkGetPhysicalDeviceMultisamplePropertiesEXT");
    ASSERT_NE(pfn, nullptr);
    ASSERT_DEATH(pfn(bad_physical_dev, VK_SAMPLE_COUNT_1_BIT, &props),
                 "vkGetPhysicalDeviceMultisamplePropertiesEXT: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevAcquireDrmDisplayEXT) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_EXT_acquire_drm_display"});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    PFN_vkAcquireDrmDisplayEXT pfn = instance.load("vkAcquireDrmDisplayEXT");
    ASSERT_NE(pfn, nullptr);
    ASSERT_DEATH(pfn(bad_physical_dev, 0, VK_NULL_HANDLE),
                 "vkAcquireDrmDisplayEXT: Invalid physicalDevice \\[VUID-vkAcquireDrmDisplayEXT-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetDrmDisplayEXT) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_EXT_acquire_drm_display"});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    PFN_vkGetDrmDisplayEXT pfn = instance.load("vkGetDrmDisplayEXT");
    ASSERT_NE(pfn, nullptr);
    ASSERT_DEATH(pfn(bad_physical_dev, 0, 0, VK_NULL_HANDLE),
                 "vkGetDrmDisplayEXT: Invalid physicalDevice "
                 "\\[VUID-vkGetDrmDisplayEXT-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevReleaseDisplayEXT) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_EXT_direct_mode_display"});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    PFN_vkReleaseDisplayEXT pfn = instance.load("vkReleaseDisplayEXT");
    ASSERT_NE(pfn, nullptr);
    ASSERT_DEATH(pfn(bad_physical_dev, VK_NULL_HANDLE),
                 "vkReleaseDisplayEXT: Invalid physicalDevice \\[VUID-vkReleaseDisplayEXT-physicalDevice-parameter\\]");
}

#if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT)
TEST(LoaderHandleValidTests, BadPhysDevAcquireXlibDisplayEXT) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_EXT_acquire_xlib_display"});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    PFN_vkAcquireXlibDisplayEXT pfn = instance.load("vkAcquireXlibDisplayEXT");
    ASSERT_NE(pfn, nullptr);
    ASSERT_DEATH(pfn(bad_physical_dev, nullptr, VK_NULL_HANDLE),
                 "vkAcquireXlibDisplayEXT: Invalid physicalDevice \\[VUID-vkAcquireXlibDisplayEXT-physicalDevice-parameter\\]");
}

TEST(LoaderHandleValidTests, BadPhysDevGetRandROutputDisplayEXT) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {"VK_KHR_surface", "VK_EXT_acquire_xlib_display"});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    RROutput rrout = {};
    VkDisplayKHR disp;
    PFN_vkGetRandROutputDisplayEXT pfn = instance.load("vkGetRandROutputDisplayEXT");
    ASSERT_NE(pfn, nullptr);
    ASSERT_DEATH(
        pfn(bad_physical_dev, nullptr, rrout, &disp),
        "vkGetRandROutputDisplayEXT: Invalid physicalDevice \\[VUID-vkGetRandROutputDisplayEXT-physicalDevice-parameter\\]");
}
#endif  // VK_USE_PLATFORM_XLIB_XRANDR_EXT

#if defined(VK_USE_PLATFORM_WIN32_KHR)
TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfacePresentModes2EXT) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    InstWrapper instance(env.vulkan_functions);
    instance.CheckCreate();

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    VkPhysicalDeviceSurfaceInfo2KHR phys_dev_surf_info = {};
    phys_dev_surf_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
    phys_dev_surf_info.pNext = nullptr;
    uint32_t count = 0;
    PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT pfn = instance.load("vkGetPhysicalDeviceSurfacePresentModes2EXT");
    ASSERT_NE(pfn, nullptr);
    ASSERT_DEATH(pfn(bad_physical_dev, &phys_dev_surf_info, &count, nullptr),
                 "vkGetPhysicalDeviceSurfacePresentModes2EXT: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceSurfacePresentModes2EXT-physicalDevice-parameter\\]");
}
#endif  // VK_USE_PLATFORM_WIN32_KHR

TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevToolPropertiesEXT) {
    FrameworkEnvironment env{};
    auto instance = setup_BadPhysDev_env(env, {});

    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
    PFN_vkGetPhysicalDeviceToolPropertiesEXT pfn = instance.load("vkGetPhysicalDeviceToolPropertiesEXT");
    ASSERT_NE(pfn, nullptr);
    uint32_t count = 0;
    ASSERT_DEATH(pfn(bad_physical_dev, &count, nullptr),
                 "vkGetPhysicalDeviceToolPropertiesEXT: Invalid physicalDevice "
                 "\\[VUID-vkGetPhysicalDeviceToolPropertiesEXT-physicalDevice-parameter\\]");
}

#if defined(VK_USE_PLATFORM_ANDROID_KHR)
TEST(LoaderHandleValidTests, VerifyHandleWrappingAndroidSurface) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    const char* wrap_objects_name = "WrapObjectsLayer";
    env.add_explicit_layer(ManifestLayer{}.add_layer(
                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
                           "wrap_objects_layer.json");

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.create_info.add_layer(wrap_objects_name);
    instance.CheckCreate();

    VkAndroidSurfaceCreateInfoKHR surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    PFN_vkCreateAndroidSurfaceKHR pfn_CreateSurface = instance.load("vkCreateAndroidSurfaceKHR");
    ASSERT_NE(pfn_CreateSurface, nullptr);
    PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
    ASSERT_NE(pfn_DestroySurface, nullptr);
    ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
    pfn_DestroySurface(instance, created_surface, nullptr);
}
#endif  // VK_USE_PLATFORM_ANDROID_KHR

#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
TEST(LoaderHandleValidTests, VerifyHandleWrappingDirectFBSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    const char* wrap_objects_name = "WrapObjectsLayer";
    env.add_explicit_layer(ManifestLayer{}.add_layer(
                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
                           "wrap_objects_layer.json");

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.create_info.add_layer(wrap_objects_name);
    instance.CheckCreate();

    VkDirectFBSurfaceCreateInfoEXT surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    PFN_vkCreateDirectFBSurfaceEXT pfn_CreateSurface = instance.load("vkCreateDirectFBSurfaceEXT");
    ASSERT_NE(pfn_CreateSurface, nullptr);
    PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
    ASSERT_NE(pfn_DestroySurface, nullptr);
    ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
    pfn_DestroySurface(instance, created_surface, nullptr);
}
#endif  // VK_USE_PLATFORM_DIRECTFB_EXT

#if defined(VK_USE_PLATFORM_FUCHSIA)
TEST(LoaderHandleValidTests, VerifyHandleWrappingFuchsiaSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    const char* wrap_objects_name = "WrapObjectsLayer";
    env.add_explicit_layer(ManifestLayer{}.add_layer(
                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
                           "wrap_objects_layer.json");

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.create_info.add_layer(wrap_objects_name);
    instance.CheckCreate();

    VkImagePipeSurfaceCreateInfoFUCHSIA surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    PFN_vkCreateImagePipeSurfaceFUCHSIA pfn_CreateSurface = instance.load("vkCreateImagePipeSurfaceFUCHSIA");
    ASSERT_NE(pfn_CreateSurface, nullptr);
    PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
    ASSERT_NE(pfn_DestroySurface, nullptr);
    ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
    pfn_DestroySurface(instance, created_surface, nullptr);
}
#endif  // VK_USE_PLATFORM_FUCHSIA

#if defined(VK_USE_PLATFORM_GGP)
TEST(LoaderHandleValidTests, VerifyHandleWrappingGGPSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    const char* wrap_objects_name = "WrapObjectsLayer";
    env.add_explicit_layer(ManifestLayer{}.add_layer(
                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
                           "wrap_objects_layer.json");

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.create_info.add_layer(wrap_objects_name);
    instance.CheckCreate();

    VkStreamDescriptorSurfaceCreateInfoGGP surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    PFN_vkCreateStreamDescriptorSurfaceGGP pfn_CreateSurface = instance.load("vkCreateStreamDescriptorSurfaceGGP");
    ASSERT_NE(pfn_CreateSurface, nullptr);
    PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
    ASSERT_NE(pfn_DestroySurface, nullptr);
    ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
    pfn_DestroySurface(instance, created_surface, nullptr);
}
#endif  // VK_USE_PLATFORM_GGP

#if defined(VK_USE_PLATFORM_IOS_MVK)
TEST(LoaderHandleValidTests, VerifyHandleWrappingIOSSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    const char* wrap_objects_name = "WrapObjectsLayer";
    env.add_explicit_layer(ManifestLayer{}.add_layer(
                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
                           "wrap_objects_layer.json");

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.create_info.add_layer(wrap_objects_name);
    instance.CheckCreate();

    VkIOSSurfaceCreateInfoMVK surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    PFN_vkCreateIOSSurfaceMVK pfn_CreateSurface = instance.load("vkCreateIOSSurfaceMVK");
    ASSERT_NE(pfn_CreateSurface, nullptr);
    PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
    ASSERT_NE(pfn_DestroySurface, nullptr);
    ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
    pfn_DestroySurface(instance, created_surface, nullptr);
}
#endif  // VK_USE_PLATFORM_IOS_MVK

#if defined(VK_USE_PLATFORM_MACOS_MVK)
TEST(LoaderHandleValidTests, VerifyHandleWrappingMacOSSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI("VK_USE_PLATFORM_MACOS_MVK");

    const char* wrap_objects_name = "WrapObjectsLayer";
    env.add_explicit_layer(ManifestLayer{}.add_layer(
                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
                           "wrap_objects_layer.json");

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI("VK_USE_PLATFORM_MACOS_MVK");
    instance.create_info.add_layer(wrap_objects_name);
    instance.CheckCreate();

    VkMacOSSurfaceCreateInfoMVK surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    PFN_vkCreateMacOSSurfaceMVK pfn_CreateSurface = instance.load("vkCreateMacOSSurfaceMVK");
    ASSERT_NE(pfn_CreateSurface, nullptr);
    PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
    ASSERT_NE(pfn_DestroySurface, nullptr);
    ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
    pfn_DestroySurface(instance, created_surface, nullptr);
}
#endif  // VK_USE_PLATFORM_MACOS_MVK

#if defined(VK_USE_PLATFORM_METAL_EXT)
TEST(LoaderHandleValidTests, VerifyHandleWrappingMetalSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI("VK_USE_PLATFORM_METAL_EXT");

    const char* wrap_objects_name = "WrapObjectsLayer";
    env.add_explicit_layer(ManifestLayer{}.add_layer(
                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
                           "wrap_objects_layer.json");

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI("VK_USE_PLATFORM_METAL_EXT");
    instance.create_info.add_layer(wrap_objects_name);
    instance.CheckCreate();

    VkMetalSurfaceCreateInfoEXT surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    PFN_vkCreateMetalSurfaceEXT pfn_CreateSurface = instance.load("vkCreateMetalSurfaceEXT");
    ASSERT_NE(pfn_CreateSurface, nullptr);
    PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
    ASSERT_NE(pfn_DestroySurface, nullptr);
    ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
    pfn_DestroySurface(instance, created_surface, nullptr);
}
#endif  // VK_USE_PLATFORM_METAL_EXT

#if defined(VK_USE_PLATFORM_SCREEN_QNX)
TEST(LoaderHandleValidTests, VerifyHandleWrappingQNXSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    const char* wrap_objects_name = "WrapObjectsLayer";
    env.add_explicit_layer(ManifestLayer{}.add_layer(
                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
                           "wrap_objects_layer.json");

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.create_info.add_layer(wrap_objects_name);
    instance.CheckCreate();

    VkScreenSurfaceCreateInfoQNX surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    PFN_vkCreateScreenSurfaceQNX pfn_CreateSurface = instance.load("vkCreateScreenSurfaceQNX");
    ASSERT_NE(pfn_CreateSurface, nullptr);
    PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
    ASSERT_NE(pfn_DestroySurface, nullptr);
    ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
    pfn_DestroySurface(instance, created_surface, nullptr);
}
#endif  // VK_USE_PLATFORM_SCREEN_QNX

#if defined(VK_USE_PLATFORM_VI_NN)
TEST(LoaderHandleValidTests, VerifyHandleWrappingViNNSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    const char* wrap_objects_name = "WrapObjectsLayer";
    env.add_explicit_layer(ManifestLayer{}.add_layer(
                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
                           "wrap_objects_layer.json");

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.create_info.add_layer(wrap_objects_name);
    instance.CheckCreate();

    VkViSurfaceCreateInfoNN surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    PFN_vkCreateViSurfaceNN pfn_CreateSurface = instance.load("vkCreateViSurfaceNN");
    ASSERT_NE(pfn_CreateSurface, nullptr);
    PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
    ASSERT_NE(pfn_DestroySurface, nullptr);
    ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
    pfn_DestroySurface(instance, created_surface, nullptr);
}
#endif  // VK_USE_PLATFORM_VI_NN

#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
TEST(LoaderHandleValidTests, VerifyHandleWrappingWaylandSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI("VK_USE_PLATFORM_WAYLAND_KHR");

    const char* wrap_objects_name = "WrapObjectsLayer";
    env.add_explicit_layer(ManifestLayer{}.add_layer(
                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
                           "wrap_objects_layer.json");

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI("VK_USE_PLATFORM_WAYLAND_KHR");
    instance.create_info.add_layer(wrap_objects_name);
    instance.CheckCreate();

    VkWaylandSurfaceCreateInfoKHR surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    PFN_vkCreateWaylandSurfaceKHR pfn_CreateSurface = instance.load("vkCreateWaylandSurfaceKHR");
    ASSERT_NE(pfn_CreateSurface, nullptr);
    PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
    ASSERT_NE(pfn_DestroySurface, nullptr);
    ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
    pfn_DestroySurface(instance, created_surface, nullptr);
}
#endif  // VK_USE_PLATFORM_WAYLAND_KHR

#if defined(VK_USE_PLATFORM_WIN32_KHR)
TEST(LoaderHandleValidTests, VerifyHandleWrappingWin32Surf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    const char* wrap_objects_name = "WrapObjectsLayer";
    env.add_explicit_layer(ManifestLayer{}.add_layer(
                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
                           "wrap_objects_layer.json");

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.create_info.add_layer(wrap_objects_name);
    instance.CheckCreate();

    VkWin32SurfaceCreateInfoKHR surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    PFN_vkCreateWin32SurfaceKHR pfn_CreateSurface = instance.load("vkCreateWin32SurfaceKHR");
    ASSERT_NE(pfn_CreateSurface, nullptr);
    PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
    ASSERT_NE(pfn_DestroySurface, nullptr);
    ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
    pfn_DestroySurface(instance, created_surface, nullptr);
}
#endif  // VK_USE_PLATFORM_WIN32_KHR

#if defined(VK_USE_PLATFORM_XCB_KHR)
TEST(LoaderHandleValidTests, VerifyHandleWrappingXCBSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI();

    const char* wrap_objects_name = "WrapObjectsLayer";
    env.add_explicit_layer(ManifestLayer{}.add_layer(
                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
                           "wrap_objects_layer.json");

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI();
    instance.create_info.add_layer(wrap_objects_name);
    instance.CheckCreate();

    VkXcbSurfaceCreateInfoKHR surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    PFN_vkCreateXcbSurfaceKHR pfn_CreateSurface = instance.load("vkCreateXcbSurfaceKHR");
    ASSERT_NE(pfn_CreateSurface, nullptr);
    PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
    ASSERT_NE(pfn_DestroySurface, nullptr);
    ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
    pfn_DestroySurface(instance, created_surface, nullptr);
}
#endif  // VK_USE_PLATFORM_XCB_KHR

#if defined(VK_USE_PLATFORM_XLIB_KHR)
TEST(LoaderHandleValidTests, VerifyHandleWrappingXlibSurf) {
    FrameworkEnvironment env{};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).setup_WSI("VK_USE_PLATFORM_XLIB_KHR");

    const char* wrap_objects_name = "WrapObjectsLayer";
    env.add_explicit_layer(ManifestLayer{}.add_layer(
                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
                           "wrap_objects_layer.json");

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.setup_WSI("VK_USE_PLATFORM_XLIB_KHR");
    //
    for (auto& ext : instance.create_info.enabled_extensions) {
        std::cout << ext << "\n";
    }
    instance.create_info.add_layer(wrap_objects_name);
    instance.CheckCreate();

    VkXlibSurfaceCreateInfoKHR surf_create_info = {};
    surf_create_info.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
    surf_create_info.pNext = nullptr;
    VkSurfaceKHR created_surface = VK_NULL_HANDLE;
    PFN_vkCreateXlibSurfaceKHR pfn_CreateSurface = instance.load("vkCreateXlibSurfaceKHR");
    ASSERT_NE(pfn_CreateSurface, nullptr);
    PFN_vkDestroySurfaceKHR pfn_DestroySurface = instance.load("vkDestroySurfaceKHR");
    ASSERT_NE(pfn_DestroySurface, nullptr);
    ASSERT_EQ(VK_SUCCESS, pfn_CreateSurface(instance, &surf_create_info, nullptr, &created_surface));
    pfn_DestroySurface(instance, created_surface, nullptr);
}
#endif  // VK_USE_PLATFORM_XLIB_KHR

VKAPI_ATTR VkBool32 VKAPI_CALL JunkDebugUtilsCallback([[maybe_unused]] VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
                                                      [[maybe_unused]] VkDebugUtilsMessageTypeFlagsEXT messageTypes,
                                                      [[maybe_unused]] const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
                                                      [[maybe_unused]] void* pUserData) {
    // This is just a stub callback in case the loader or any other layer triggers it.
    return VK_FALSE;
}

TEST(LoaderHandleValidTests, VerifyHandleWrappingDebugUtilsMessenger) {
    FrameworkEnvironment env{};
    Extension ext{"VK_EXT_debug_utils"};
    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2)).add_instance_extensions({ext});

    const char* wrap_objects_name = "WrapObjectsLayer";
    env.add_explicit_layer(ManifestLayer{}.add_layer(
                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
                           "wrap_objects_layer.json");

    InstWrapper instance(env.vulkan_functions);
    instance.create_info.add_extension("VK_EXT_debug_utils");
    instance.create_info.add_layer(wrap_objects_name);
    instance.CheckCreate();

    VkDebugUtilsMessengerCreateInfoEXT debug_messenger_create_info = {};
    debug_messenger_create_info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
    debug_messenger_create_info.pNext = nullptr;
    debug_messenger_create_info.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
    debug_messenger_create_info.messageType =
        VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT;
    debug_messenger_create_info.pfnUserCallback = reinterpret_cast<PFN_vkDebugUtilsMessengerCallbackEXT>(JunkDebugUtilsCallback);
    VkDebugUtilsMessengerEXT messenger = VK_NULL_HANDLE;
    PFN_vkCreateDebugUtilsMessengerEXT pfn_CreateMessenger = instance.load("vkCreateDebugUtilsMessengerEXT");
    ASSERT_NE(pfn_CreateMessenger, nullptr);
    PFN_vkDestroyDebugUtilsMessengerEXT pfn_DestroyMessenger = instance.load("vkDestroyDebugUtilsMessengerEXT");
    ASSERT_NE(pfn_DestroyMessenger, nullptr);
    ASSERT_EQ(VK_SUCCESS, pfn_CreateMessenger(instance, &debug_messenger_create_info, nullptr, &messenger));
    pfn_DestroyMessenger(instance, messenger, nullptr);
}