Use correct TestICD in tests

Many tests were using the V6 TestICD, which means that it exports the
EnumerateAdapterPhysicalDevices. The loader then only looks for devices
using that functionality and if the test didn't set it up, the driver
won't have its devices found.

Also:
* Cleaned up handle_validation_tests
* Added WSI setup helpers, which put all the setup code for WSI in one place
* Created a to/from_nondispatch_handle function for TestICD, probably should
be in a more general location

14 files changed, 683 insertions, 916 deletions

diff --git a/tests/framework/icd/test_icd.cpp b/tests/framework/icd/test_icd.cpp
index 9c729e469..5f0bc44bc 100644
--- a/tests/framework/icd/test_icd.cpp
+++ b/tests/framework/icd/test_icd.cpp
@@ -406,20 +406,42 @@ VKAPI_ATTR VkResult VKAPI_CALL test_vkGetPhysicalDeviceToolProperties(VkPhysical
     return generic_tool_props_function(physicalDevice, pToolCount, pToolProperties);
 }
 
-//// WSI ////
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-VKAPI_ATTR VkResult VKAPI_CALL test_vkCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
-                                                              const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    if (nullptr != pSurface) {
-        uint64_t fake_surf_handle = reinterpret_cast<uint64_t>(new uint8_t);
-        icd.surface_handles.push_back(fake_surf_handle);
+template <typename T>
+T to_nondispatch_handle(uint64_t handle) {
 #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || \
     defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
-        *pSurface = reinterpret_cast<VkSurfaceKHR>(fake_surf_handle);
+    return reinterpret_cast<T>(handle);
 #else
-        *pSurface = fake_surf_handle;
+    return handle;
 #endif
+}
+
+template <typename T>
+uint64_t from_nondispatch_handle(T handle) {
+#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || \
+    defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
+    return reinterpret_cast<uint64_t>(handle);
+#else
+    return handle;
+#endif
+}
+
+//// WSI ////
+template <typename HandleType>
+void common_nondispatch_handle_creation(std::vector<uint64_t>& handles, HandleType* pHandle) {
+    if (nullptr != pHandle) {
+        if (handles.size() == 0)
+            handles.push_back(800851234);
+        else
+            handles.push_back(handles.back() + 102030);
+        *pHandle = to_nondispatch_handle<HandleType>(handles.back());
     }
+}
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+
+VKAPI_ATTR VkResult VKAPI_CALL test_vkCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+                                                              const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
+    common_nondispatch_handle_creation(icd.surface_handles, pSurface);
     return VK_SUCCESS;
 }
 #endif
@@ -427,16 +449,7 @@ VKAPI_ATTR VkResult VKAPI_CALL test_vkCreateAndroidSurfaceKHR(VkInstance instanc
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 VKAPI_ATTR VkResult VKAPI_CALL test_vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
                                                             const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    if (nullptr != pSurface) {
-        uint64_t fake_surf_handle = reinterpret_cast<uint64_t>(new uint8_t);
-        icd.surface_handles.push_back(fake_surf_handle);
-#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || \
-    defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
-        *pSurface = reinterpret_cast<VkSurfaceKHR>(fake_surf_handle);
-#else
-        *pSurface = fake_surf_handle;
-#endif
-    }
+    common_nondispatch_handle_creation(icd.surface_handles, pSurface);
     return VK_SUCCESS;
 }
 
@@ -449,16 +462,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL test_vkGetPhysicalDeviceWin32PresentationSupportK
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
 VKAPI_ATTR VkResult VKAPI_CALL test_vkCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
                                                               const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    if (nullptr != pSurface) {
-        uint64_t fake_surf_handle = reinterpret_cast<uint64_t>(new uint8_t);
-        icd.surface_handles.push_back(fake_surf_handle);
-#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || \
-    defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
-        *pSurface = reinterpret_cast<VkSurfaceKHR>(fake_surf_handle);
-#else
-        *pSurface = fake_surf_handle;
-#endif
-    }
+    common_nondispatch_handle_creation(icd.surface_handles, pSurface);
     return VK_SUCCESS;
 }
 
@@ -471,16 +475,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL test_vkGetPhysicalDeviceWaylandPresentationSuppor
 #ifdef VK_USE_PLATFORM_XCB_KHR
 VKAPI_ATTR VkResult VKAPI_CALL test_vkCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
                                                           const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    if (nullptr != pSurface) {
-        uint64_t fake_surf_handle = reinterpret_cast<uint64_t>(new uint8_t);
-        icd.surface_handles.push_back(fake_surf_handle);
-#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || \
-    defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
-        *pSurface = reinterpret_cast<VkSurfaceKHR>(fake_surf_handle);
-#else
-        *pSurface = fake_surf_handle;
-#endif
-    }
+    common_nondispatch_handle_creation(icd.surface_handles, pSurface);
     return VK_SUCCESS;
 }
 
@@ -495,16 +490,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL test_vkGetPhysicalDeviceXcbPresentationSupportKHR
 #ifdef VK_USE_PLATFORM_XLIB_KHR
 VKAPI_ATTR VkResult VKAPI_CALL test_vkCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
                                                            const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    if (nullptr != pSurface) {
-        uint64_t fake_surf_handle = reinterpret_cast<uint64_t>(new uint8_t);
-        icd.surface_handles.push_back(fake_surf_handle);
-#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || \
-    defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
-        *pSurface = reinterpret_cast<VkSurfaceKHR>(fake_surf_handle);
-#else
-        *pSurface = fake_surf_handle;
-#endif
-    }
+    common_nondispatch_handle_creation(icd.surface_handles, pSurface);
     return VK_SUCCESS;
 }
 
@@ -519,16 +505,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL test_vkGetPhysicalDeviceXlibPresentationSupportKH
 VKAPI_ATTR VkResult VKAPI_CALL test_vkCreateDirectFBSurfaceEXT(VkInstance instance,
                                                                const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo,
                                                                const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    if (nullptr != pSurface) {
-        uint64_t fake_surf_handle = reinterpret_cast<uint64_t>(new uint8_t);
-        icd.surface_handles.push_back(fake_surf_handle);
-#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || \
-    defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
-        *pSurface = reinterpret_cast<VkSurfaceKHR>(fake_surf_handle);
-#else
-        *pSurface = fake_surf_handle;
-#endif
-    }
+    common_nondispatch_handle_creation(icd.surface_handles, pSurface);
     return VK_SUCCESS;
 }
 
@@ -542,16 +519,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL test_vkGetPhysicalDeviceDirectFBPresentationSuppo
 #ifdef VK_USE_PLATFORM_MACOS_MVK
 VKAPI_ATTR VkResult VKAPI_CALL test_vkCreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
                                                             const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    if (nullptr != pSurface) {
-        uint64_t fake_surf_handle = reinterpret_cast<uint64_t>(new uint8_t);
-        icd.surface_handles.push_back(fake_surf_handle);
-#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || \
-    defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
-        *pSurface = reinterpret_cast<VkSurfaceKHR>(fake_surf_handle);
-#else
-        *pSurface = fake_surf_handle;
-#endif
-    }
+    common_nondispatch_handle_creation(icd.surface_handles, pSurface);
     return VK_SUCCESS;
 }
 #endif  // VK_USE_PLATFORM_MACOS_MVK
@@ -559,16 +527,7 @@ VKAPI_ATTR VkResult VKAPI_CALL test_vkCreateMacOSSurfaceMVK(VkInstance instance,
 #ifdef VK_USE_PLATFORM_IOS_MVK
 VKAPI_ATTR VkResult VKAPI_CALL test_vkCreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
                                                           const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    if (nullptr != pSurface) {
-        uint64_t fake_surf_handle = reinterpret_cast<uint64_t>(new uint8_t);
-        icd.surface_handles.push_back(fake_surf_handle);
-#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || \
-    defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
-        *pSurface = reinterpret_cast<VkSurfaceKHR>(fake_surf_handle);
-#else
-        *pSurface = fake_surf_handle;
-#endif
-    }
+    common_nondispatch_handle_creation(icd.surface_handles, pSurface);
     return VK_SUCCESS;
 }
 #endif  // VK_USE_PLATFORM_IOS_MVK
@@ -578,16 +537,7 @@ VKAPI_ATTR VkResult VKAPI_CALL test_vkCreateStreamDescriptorSurfaceGGP(VkInstanc
                                                                        const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
                                                                        const VkAllocationCallbacks* pAllocator,
                                                                        VkSurfaceKHR* pSurface) {
-    if (nullptr != pSurface) {
-        uint64_t fake_surf_handle = reinterpret_cast<uint64_t>(new uint8_t);
-        icd.surface_handles.push_back(fake_surf_handle);
-#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || \
-    defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
-        *pSurface = reinterpret_cast<VkSurfaceKHR>(fake_surf_handle);
-#else
-        *pSurface = fake_surf_handle;
-#endif
-    }
+    common_nondispatch_handle_creation(icd.surface_handles, pSurface);
     return VK_SUCCESS;
 }
 #endif  // VK_USE_PLATFORM_GGP
@@ -595,16 +545,7 @@ VKAPI_ATTR VkResult VKAPI_CALL test_vkCreateStreamDescriptorSurfaceGGP(VkInstanc
 #if defined(VK_USE_PLATFORM_METAL_EXT)
 VKAPI_ATTR VkResult VKAPI_CALL test_vkCreateMetalSurfaceEXT(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo,
                                                             const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    if (nullptr != pSurface) {
-        uint64_t fake_surf_handle = reinterpret_cast<uint64_t>(new uint8_t);
-        icd.surface_handles.push_back(fake_surf_handle);
-#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || \
-    defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
-        *pSurface = reinterpret_cast<VkSurfaceKHR>(fake_surf_handle);
-#else
-        *pSurface = fake_surf_handle;
-#endif
-    }
+    common_nondispatch_handle_creation(icd.surface_handles, pSurface);
     return VK_SUCCESS;
 }
 #endif  // VK_USE_PLATFORM_METAL_EXT
@@ -612,16 +553,7 @@ VKAPI_ATTR VkResult VKAPI_CALL test_vkCreateMetalSurfaceEXT(VkInstance instance,
 #ifdef VK_USE_PLATFORM_SCREEN_QNX
 VKAPI_ATTR VkResult VKAPI_CALL test_vkCreateScreenSurfaceQNX(VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo,
                                                              const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    if (nullptr != pSurface) {
-        uint64_t fake_surf_handle = reinterpret_cast<uint64_t>(new uint8_t);
-        icd.surface_handles.push_back(fake_surf_handle);
-#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || \
-    defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
-        *pSurface = reinterpret_cast<VkSurfaceKHR>(fake_surf_handle);
-#else
-        *pSurface = fake_surf_handle;
-#endif
-    }
+    common_nondispatch_handle_creation(icd.surface_handles, pSurface);
     return VK_SUCCESS;
 }
 
@@ -635,29 +567,18 @@ VKAPI_ATTR VkBool32 VKAPI_CALL test_vkGetPhysicalDeviceScreenPresentationSupport
 VKAPI_ATTR VkResult VKAPI_CALL test_vkCreateHeadlessSurfaceEXT(VkInstance instance,
                                                                const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,
                                                                const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {
-    if (nullptr != pSurface) {
-        uint64_t fake_surf_handle = reinterpret_cast<uint64_t>(new uint8_t);
-        icd.surface_handles.push_back(fake_surf_handle);
-#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || \
-    defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
-        *pSurface = reinterpret_cast<VkSurfaceKHR>(fake_surf_handle);
-#else
-        *pSurface = fake_surf_handle;
-#endif
-    }
+    common_nondispatch_handle_creation(icd.surface_handles, pSurface);
     return VK_SUCCESS;
 }
 
 VKAPI_ATTR void VKAPI_CALL test_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
                                                     const VkAllocationCallbacks* pAllocator) {
     if (surface != VK_NULL_HANDLE) {
-        uint64_t fake_surf_handle = (uint64_t)(surface);
+        uint64_t fake_surf_handle = from_nondispatch_handle(surface);
         auto found_iter = std::find(icd.surface_handles.begin(), icd.surface_handles.end(), fake_surf_handle);
         if (found_iter != icd.surface_handles.end()) {
             // Remove it from the list
             icd.surface_handles.erase(found_iter);
-            // Delete the handle
-            delete (uint8_t*)fake_surf_handle;
         } else {
             assert(false && "Surface not found during destroy!");
         }
@@ -666,23 +587,14 @@ VKAPI_ATTR void VKAPI_CALL test_vkDestroySurfaceKHR(VkInstance instance, VkSurfa
 
 VKAPI_ATTR VkResult VKAPI_CALL test_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo,
                                                          const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) {
-    if (nullptr != pSwapchain) {
-        uint64_t fake_swapchain_handle = reinterpret_cast<uint64_t>(new uint8_t);
-        icd.swapchain_handles.push_back(fake_swapchain_handle);
-#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || \
-    defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
-        *pSwapchain = reinterpret_cast<VkSwapchainKHR>(fake_swapchain_handle);
-#else
-        *pSwapchain = fake_swapchain_handle;
-#endif
-    }
+    common_nondispatch_handle_creation(icd.swapchain_handles, pSwapchain);
     return VK_SUCCESS;
 }
 
 VKAPI_ATTR void VKAPI_CALL test_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
                                                       const VkAllocationCallbacks* pAllocator) {
     if (swapchain != VK_NULL_HANDLE) {
-        uint64_t fake_swapchain_handle = (uint64_t)(swapchain);
+        uint64_t fake_swapchain_handle = from_nondispatch_handle(swapchain);
         auto found_iter = icd.swapchain_handles.erase(
             std::remove(icd.swapchain_handles.begin(), icd.swapchain_handles.end(), fake_swapchain_handle),
             icd.swapchain_handles.end());
diff --git a/tests/framework/test_environment.cpp b/tests/framework/test_environment.cpp
index f92f7e1d7..dadd73145 100644
--- a/tests/framework/test_environment.cpp
+++ b/tests/framework/test_environment.cpp
@@ -303,4 +303,169 @@ fs::path FrameworkEnvironment::get_icd_manifest_path(size_t index) noexcept { re
 TestLayer& FrameworkEnvironment::get_test_layer(size_t index) noexcept { return layers[index].get_test_layer(); }
 TestLayer& FrameworkEnvironment::reset_layer(size_t index) noexcept { return layers[index].reset_layer(); }
 fs::path FrameworkEnvironment::get_test_layer_path(size_t index) noexcept { return layers[index].get_layer_full_path(); }
-fs::path FrameworkEnvironment::get_layer_manifest_path(size_t index) noexcept { return layers[index].get_layer_manifest_path(); }
\ No newline at end of file
+fs::path FrameworkEnvironment::get_layer_manifest_path(size_t index) noexcept { return layers[index].get_layer_manifest_path(); }
+
+void setup_WSI_in_ICD(TestICD& icd) {
+    icd.enable_icd_wsi = true;
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    icd.add_instance_extensions({"VK_KHR_surface", "VK_KHR_android_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+    icd.add_instance_extensions({"VK_KHR_surface", "VK_EXT_directfb_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+    icd.add_instance_extensions({"VK_KHR_surface", "VK_FUCHSIA_imagepipe_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_GGP
+    icd.add_instance_extensions({"VK_KHR_surface", "VK_GGP_stream_descriptor_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_IOS_MVK
+    icd.add_instance_extensions({"VK_KHR_surface", "VK_MVK_ios_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+    icd.add_instance_extensions({"VK_KHR_surface", "VK_MVK_macos_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_METAL_EXT
+    icd.add_instance_extensions({"VK_KHR_surface", "VK_EXT_metal_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+    icd.add_instance_extensions({"VK_KHR_surface", "VK_QNX_screen_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_VI_NN
+    icd.add_instance_extensions({"VK_KHR_surface", "VK_NN_vi_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_XCB_KHR
+    icd.add_instance_extensions({"VK_KHR_surface", "VK_KHR_xcb_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+    icd.add_instance_extensions({"VK_KHR_surface", "VK_KHR_xlib_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+    icd.add_instance_extensions({"VK_KHR_surface", "VK_KHR_wayland_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    icd.add_instance_extensions({"VK_KHR_surface", "VK_KHR_win32_surface"});
+#endif
+}
+void setup_WSI_in_create_instance(InstWrapper& inst) {
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    inst.create_info.add_extensions({"VK_KHR_surface", "VK_KHR_android_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+    inst.create_info.add_extensions({"VK_KHR_surface", "VK_EXT_directfb_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+    inst.create_info.add_extensions({"VK_KHR_surface", "VK_FUCHSIA_imagepipe_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_GGP
+    inst.create_info.add_extensions({"VK_KHR_surface", "VK_GGP_stream_descriptor_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_IOS_MVK
+    inst.create_info.add_extensions({"VK_KHR_surface", "VK_MVK_ios_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+    inst.create_info.add_extensions({"VK_KHR_surface", "VK_MVK_macos_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_METAL_EXT
+    inst.create_info.add_extensions({"VK_KHR_surface", "VK_EXT_metal_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+    inst.create_info.add_extensions({"VK_KHR_surface", "VK_QNX_screen_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_VI_NN
+    inst.create_info.add_extensions({"VK_KHR_surface", "VK_NN_vi_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_XCB_KHR
+    inst.create_info.add_extensions({"VK_KHR_surface", "VK_KHR_xcb_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+    inst.create_info.add_extensions({"VK_KHR_surface", "VK_KHR_xlib_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+    inst.create_info.add_extensions({"VK_KHR_surface", "VK_KHR_wayland_surface"});
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    inst.create_info.add_extensions({"VK_KHR_surface", "VK_KHR_win32_surface"});
+#endif
+}
+VkSurfaceKHR create_surface(InstWrapper& inst, const char* api_selection) {
+    VkSurfaceKHR surface{};
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    PFN_vkCreateAndroidSurfaceKHR pfn_CreateSurface = inst.load("vkCreateAndroidSurfaceKHR");
+    VkAndroidSurfaceCreateInfoKHR surf_create_info{};
+    EXPECT_EQ(VK_SUCCESS, pfn_CreateSurface(inst, &surf_create_info, nullptr, &surface));
+#endif
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+    PFN_vkCreateDirectFBSurfaceEXT pfn_CreateSurface = inst.load("vkCreateDirectFBSurfaceEXT");
+    VkDirectFBSurfaceCreateInfoEXT surf_create_info{};
+    EXPECT_EQ(VK_SUCCESS, pfn_CreateSurface(inst, &surf_create_info, nullptr, &surface));
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
+    PFN_vkCreateImagePipeSurfaceFUCHSIA pfn_CreateSurface = inst.load("vkCreateImagePipeSurfaceFUCHSIA");
+    VkImagePipeSurfaceCreateInfoFUCHSIA surf_create_info{};
+    EXPECT_EQ(VK_SUCCESS, pfn_CreateSurface(inst, &surf_create_info, nullptr, &surface));
+#endif
+#ifdef VK_USE_PLATFORM_GGP
+    PFN__vkCreateStreamDescriptorSurfaceGGP pfn_CreateSurface = inst.load("vkCreateStreamDescriptorSurfaceGGP");
+    VkStreamDescriptorSurfaceCreateInfoGGP surf_create_info{};
+    EXPECT_EQ(VK_SUCCESS, pfn_CreateSurface(inst, &surf_create_info, nullptr, &surface));
+#endif
+#ifdef VK_USE_PLATFORM_IOS_MVK
+    PFN_vkCreateIOSSurfaceMVK pfn_CreateSurface = inst.load("vkCreateIOSSurfaceMVK");
+    VkIOSSurfaceCreateInfoMVK surf_create_info{};
+    EXPECT_EQ(VK_SUCCESS, pfn_CreateSurface(inst, &surf_create_info, nullptr, &surface));
+#endif
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+    if (string_eq(api_selection, "VK_USE_PLATFORM_MACOS_MVK")) {
+        PFN_vkCreateMacOSSurfaceMVK pfn_CreateSurface = inst.load("vkCreateMacOSSurfaceMVK");
+        VkMacOSSurfaceCreateInfoMVK surf_create_info{};
+        EXPECT_EQ(VK_SUCCESS, pfn_CreateSurface(inst, &surf_create_info, nullptr, &surface));
+    }
+#endif
+#ifdef VK_USE_PLATFORM_METAL_EXT
+    if (string_eq(api_selection, "VK_USE_PLATFORM_METAL_EXT")) {
+        PFN_vkCreateMetalSurfaceEXT pfn_CreateSurface = inst.load("vkCreateMetalSurfaceEXT");
+        VkMetalSurfaceCreateInfoEXT surf_create_info{};
+        EXPECT_EQ(VK_SUCCESS, pfn_CreateSurface(inst, &surf_create_info, nullptr, &surface));
+    }
+#endif
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+    PFN_vkCreateScreenSurfaceQNX pfn_CreateSurface = inst.load("vkCreateScreenSurfaceQNX");
+    VkScreenSurfaceCreateInfoQNX surf_create_info{};
+    EXPECT_EQ(VK_SUCCESS, pfn_CreateSurface(inst, &surf_create_info, nullptr, &surface));
+#endif
+#ifdef VK_USE_PLATFORM_VI_NN
+    PFN_vkCreateViSurfaceNN pfn_CreateSurface = inst.load("vkCreateViSurfaceNN");
+    VkViSurfaceCreateInfoNN surf_create_info{};
+    EXPECT_EQ(VK_SUCCESS, pfn_CreateSurface(inst, &surf_create_info, nullptr, &surface));
+#endif
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    PFN_vkCreateWin32SurfaceKHR pfn_CreateSurface = inst.load("vkCreateWin32SurfaceKHR");
+    VkWin32SurfaceCreateInfoKHR surf_create_info{};
+    EXPECT_EQ(VK_SUCCESS, pfn_CreateSurface(inst, &surf_create_info, nullptr, &surface));
+#endif
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+    if (string_eq(api_selection, "VK_USE_PLATFORM_XCB_KHR")) {
+        PFN_vkCreateXcbSurfaceKHR pfn_CreateSurface = inst.load("vkCreateXcbSurfaceKHR");
+        VkXcbSurfaceCreateInfoKHR surf_create_info{};
+        EXPECT_EQ(VK_SUCCESS, pfn_CreateSurface(inst, &surf_create_info, nullptr, &surface));
+    }
+#endif
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+    if (string_eq(api_selection, "VK_USE_PLATFORM_XLIB_KHR")) {
+        PFN_vkCreateXlibSurfaceKHR pfn_CreateSurface = inst.load("vkCreateXlibSurfaceKHR");
+        VkXlibSurfaceCreateInfoKHR surf_create_info{};
+        EXPECT_EQ(VK_SUCCESS, pfn_CreateSurface(inst, &surf_create_info, nullptr, &surface));
+    }
+#endif
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+    if (string_eq(api_selection, "VK_USE_PLATFORM_WAYLAND_KHR")) {
+        PFN_vkCreateWaylandSurfaceKHR pfn_CreateSurface = inst.load("vkCreateWaylandSurfaceKHR");
+        VkWaylandSurfaceCreateInfoKHR surf_create_info{};
+        EXPECT_EQ(VK_SUCCESS, pfn_CreateSurface(inst, &surf_create_info, nullptr, &surface));
+    }
+#endif
+
+    return surface;
+}
\ No newline at end of file
diff --git a/tests/framework/test_environment.h b/tests/framework/test_environment.h
index 0126418ca..be578d98e 100644
--- a/tests/framework/test_environment.h
+++ b/tests/framework/test_environment.h
@@ -363,3 +363,11 @@ struct FrameworkEnvironment {
    private:
     void add_layer_impl(TestLayerDetails layer_details, fs::FolderManager& folder_manager, ManifestCategory category);
 };
+
+// The following helpers setup an icd with the required extensions and setting to use with WSI
+// By default they use whatever the set VK_USE_PLATFORM_XXX macros define
+void setup_WSI_in_ICD(TestICD& icd);
+void setup_WSI_in_create_instance(InstWrapper& inst);
+// api_selection: optionally provide a VK_USE_PLATFORM_XXX string to select which API to create a surface with
+// Note: MUST provide api_selection on platforms with multiple viable API's, such as linux and MacOS
+VkSurfaceKHR create_surface(InstWrapper& inst, const char* api_selection = nullptr);
\ No newline at end of file
diff --git a/tests/framework/test_util.h b/tests/framework/test_util.h
index dcf00e41a..1e8d47baa 100644
--- a/tests/framework/test_util.h
+++ b/tests/framework/test_util.h
@@ -595,7 +595,9 @@ struct Extension {
     BUILDER_VALUE(Extension, std::string, extensionName, {})
     BUILDER_VALUE(Extension, uint32_t, specVersion, VK_API_VERSION_1_0)
 
-    Extension(std::string extensionName, uint32_t specVersion = VK_API_VERSION_1_0)
+    Extension(const char* name, uint32_t specVersion = VK_API_VERSION_1_0) noexcept
+        : extensionName(name), specVersion(specVersion) {}
+    Extension(std::string extensionName, uint32_t specVersion = VK_API_VERSION_1_0) noexcept
         : extensionName(extensionName), specVersion(specVersion) {}
 
     VkExtensionProperties get() const noexcept {
diff --git a/tests/loader_debug_ext_tests.cpp b/tests/loader_debug_ext_tests.cpp
index 5e9ce16c6..3dc905329 100644
--- a/tests/loader_debug_ext_tests.cpp
+++ b/tests/loader_debug_ext_tests.cpp
@@ -52,7 +52,7 @@ class DebugReportTest : public ::testing::Test {
     virtual void SetUp() {
         env = std::unique_ptr<FrameworkEnvironment>(new FrameworkEnvironment());
         for (uint32_t icd = 0; icd < 3; ++icd) {
-            env->add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6, VK_API_VERSION_1_0));
+            env->add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_0));
             env->get_test_icd(icd).physical_devices.push_back({});
             env->get_test_icd(icd).physical_devices.push_back({});
         }
@@ -413,7 +413,7 @@ class DebugUtilTest : public ::testing::Test {
     virtual void SetUp() {
         env = std::unique_ptr<FrameworkEnvironment>(new FrameworkEnvironment());
         for (uint32_t icd = 0; icd < 3; ++icd) {
-            env->add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6, VK_API_VERSION_1_0));
+            env->add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_0));
             env->get_test_icd(icd).physical_devices.push_back({});
             env->get_test_icd(icd).physical_devices.push_back({});
         }
diff --git a/tests/loader_envvar_tests.cpp b/tests/loader_envvar_tests.cpp
index bd7b513cb..8cdbb06f3 100644
--- a/tests/loader_envvar_tests.cpp
+++ b/tests/loader_envvar_tests.cpp
@@ -141,7 +141,7 @@ TEST(EnvVarICDOverrideSetup, TestOnlyDriverEnvVar) {
 // Make sure the loader reports the correct message based on if USE_UNSAFE_FILE_SEARCH is set or not
 TEST(EnvVarICDOverrideSetup, NonSecureEnvVarLookup) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().physical_devices.emplace_back("physical_device_0");
 
     DebugUtilsLogger log{VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT};
@@ -169,7 +169,7 @@ TEST(EnvVarICDOverrideSetup, XDG) {
     set_env_var("XDG_DATA_HOME", "::::/tmp/goober3:/tmp/goober4/with spaces:::");
 
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().physical_devices.push_back({});
 
     InstWrapper inst{env.vulkan_functions};
@@ -254,7 +254,7 @@ TEST(EnvVarICDOverrideSetup, TestOnlyLayerEnvVar) {
     set_env_var("VK_LAYER_PATH", vk_layer_path);
 
     FrameworkEnvironment env{DebugMode::none, false, true};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().physical_devices.push_back({});
     env.platform_shim->redirect_path("/tmp/carol", env.explicit_layer_folder.location());
 
@@ -302,7 +302,7 @@ TEST(EnvVarICDOverrideSetup, TestOnlyAddLayerEnvVar) {
     set_env_var("VK_ADD_LAYER_PATH", vk_layer_path);
 
     FrameworkEnvironment env{DebugMode::none, false, true};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().physical_devices.push_back({});
     env.platform_shim->redirect_path("/tmp/carol", env.explicit_layer_folder.location());
 
diff --git a/tests/loader_get_proc_addr_tests.cpp b/tests/loader_get_proc_addr_tests.cpp
index 9348c5451..64a3c74d5 100644
--- a/tests/loader_get_proc_addr_tests.cpp
+++ b/tests/loader_get_proc_addr_tests.cpp
@@ -30,7 +30,7 @@
 // Verify that the various ways to get vkGetInstanceProcAddr return the same value
 TEST(GetProcAddr, VerifyGetInstanceProcAddr) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().physical_devices.emplace_back("physical_device_0");
     {
         InstWrapper inst{env.vulkan_functions};
@@ -62,7 +62,7 @@ TEST(GetProcAddr, VerifyGetInstanceProcAddr) {
 // Verify that the various ways to get vkGetDeviceProcAddr return the same value
 TEST(GetProcAddr, VerifyGetDeviceProcAddr) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().physical_devices.emplace_back("physical_device_0");
 
     InstWrapper inst{env.vulkan_functions};
@@ -90,7 +90,7 @@ TEST(GetProcAddr, VerifyGetDeviceProcAddr) {
 // Call the function to make sure it is callable, don't care about what is returned.
 TEST(GetProcAddr, GlobalFunctions) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().physical_devices.emplace_back("physical_device_0");
 
     auto& gipa = env.vulkan_functions.vkGetInstanceProcAddr;
diff --git a/tests/loader_handle_validation_tests.cpp b/tests/loader_handle_validation_tests.cpp
index 1b255652e..614e4336f 100644
--- a/tests/loader_handle_validation_tests.cpp
+++ b/tests/loader_handle_validation_tests.cpp
@@ -30,6 +30,15 @@
 
 // ---- 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));
@@ -39,10 +48,7 @@ TEST(LoaderHandleValidTests, BadInstEnumPhysDevices) {
     InstWrapper instance(env.vulkan_functions);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkInstance bad_instance = (VkInstance)(&my_bad_data);
+    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),
@@ -58,11 +64,7 @@ TEST(LoaderHandleValidTests, BadInstGetInstProcAddr) {
     InstWrapper instance(env.vulkan_functions);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkInstance bad_instance = (VkInstance)(&my_bad_data);
-
+    auto bad_instance = get_bad_handle<VkInstance>();
     ASSERT_DEATH(env.vulkan_functions.vkGetInstanceProcAddr(bad_instance, "vkGetBufferDeviceAddress"),
                  "vkGetInstanceProcAddr: Invalid instance \\[VUID-vkGetInstanceProcAddr-instance-parameter\\]");
 }
@@ -76,10 +78,7 @@ TEST(LoaderHandleValidTests, BadInstDestroyInstance) {
     InstWrapper instance(env.vulkan_functions);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkInstance bad_instance = (VkInstance)(&my_bad_data);
+    auto bad_instance = get_bad_handle<VkInstance>();
 
     ASSERT_DEATH(env.vulkan_functions.vkDestroyInstance(bad_instance, nullptr),
                  "vkDestroyInstance: Invalid instance \\[VUID-vkDestroyInstance-instance-parameter\\]");
@@ -98,10 +97,7 @@ TEST(LoaderHandleValidTests, BadInstDestroySurface) {
     instance.create_info.add_extension("VK_KHR_surface");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkInstance bad_instance = (VkInstance)(&my_bad_data);
+    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\\]");
@@ -121,10 +117,7 @@ TEST(LoaderHandleValidTests, BadInstCreateHeadlessSurf) {
     instance.create_info.add_extension("VK_EXT_headless_surface");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkInstance bad_instance = (VkInstance)(&my_bad_data);
+    auto bad_instance = get_bad_handle<VkInstance>();
 
     VkHeadlessSurfaceCreateInfoEXT surf_create_info = {};
     surf_create_info.sType = VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT;
@@ -148,10 +141,7 @@ TEST(LoaderHandleValidTests, BadInstCreateDisplayPlaneSurf) {
     instance.create_info.add_extension("VK_KHR_display");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkInstance bad_instance = (VkInstance)(&my_bad_data);
+    auto bad_instance = get_bad_handle<VkInstance>();
 
     VkDisplaySurfaceCreateInfoKHR surf_create_info = {};
     surf_create_info.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
@@ -165,21 +155,15 @@ TEST(LoaderHandleValidTests, BadInstCreateDisplayPlaneSurf) {
 TEST(LoaderHandleValidTests, BadInstCreateAndroidSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_KHR_android_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
     driver.physical_devices.emplace_back("physical_device_0");
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_KHR_android_surface");
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkInstance bad_instance = (VkInstance)(&my_bad_data);
+    auto bad_instance = get_bad_handle<VkInstance>();
 
     VkAndroidSurfaceCreateInfoKHR surf_create_info = {};
     surf_create_info.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
@@ -194,21 +178,15 @@ TEST(LoaderHandleValidTests, BadInstCreateAndroidSurf) {
 TEST(LoaderHandleValidTests, BadInstCreateDirectFBSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_EXT_directfb_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
     driver.physical_devices.emplace_back("physical_device_0");
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_EXT_directfb_surface");
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkInstance bad_instance = (VkInstance)(&my_bad_data);
+    auto bad_instance = get_bad_handle<VkInstance>();
 
     VkDirectFBSurfaceCreateInfoEXT surf_create_info = {};
     surf_create_info.sType = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT;
@@ -223,21 +201,15 @@ TEST(LoaderHandleValidTests, BadInstCreateDirectFBSurf) {
 TEST(LoaderHandleValidTests, BadInstCreateFuchsiaSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_FUCHSIA_imagepipe_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
     driver.physical_devices.emplace_back("physical_device_0");
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_FUCHSIA_imagepipe_surface");
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkInstance bad_instance = (VkInstance)(&my_bad_data);
+    auto bad_instance = get_bad_handle<VkInstance>();
 
     VkImagePipeSurfaceCreateInfoFUCHSIA surf_create_info = {};
     surf_create_info.sType = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA;
@@ -252,21 +224,15 @@ TEST(LoaderHandleValidTests, BadInstCreateFuchsiaSurf) {
 TEST(LoaderHandleValidTests, BadInstCreateGGPSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_GGP_stream_descriptor_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
     driver.physical_devices.emplace_back("physical_device_0");
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_GGP_stream_descriptor_surface");
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkInstance bad_instance = (VkInstance)(&my_bad_data);
+    auto bad_instance = get_bad_handle<VkInstance>();
 
     VkStreamDescriptorSurfaceCreateInfoGGP surf_create_info = {};
     surf_create_info.sType = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP;
@@ -282,21 +248,15 @@ TEST(LoaderHandleValidTests, BadInstCreateGGPSurf) {
 TEST(LoaderHandleValidTests, BadInstCreateIOSSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_MVK_ios_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
     driver.physical_devices.emplace_back("physical_device_0");
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_MVK_ios_surface");
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkInstance bad_instance = (VkInstance)(&my_bad_data);
+    auto bad_instance = get_bad_handle<VkInstance>();
 
     VkIOSSurfaceCreateInfoMVK surf_create_info = {};
     surf_create_info.sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK;
@@ -311,21 +271,15 @@ TEST(LoaderHandleValidTests, BadInstCreateIOSSurf) {
 TEST(LoaderHandleValidTests, BadInstCreateMacOSSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_MVK_macos_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
     driver.physical_devices.emplace_back("physical_device_0");
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_MVK_macos_surface");
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkInstance bad_instance = (VkInstance)(&my_bad_data);
+    auto bad_instance = get_bad_handle<VkInstance>();
 
     VkMacOSSurfaceCreateInfoMVK surf_create_info = {};
     surf_create_info.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
@@ -340,21 +294,15 @@ TEST(LoaderHandleValidTests, BadInstCreateMacOSSurf) {
 TEST(LoaderHandleValidTests, BadInstCreateMetalSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_EXT_metal_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
     driver.physical_devices.emplace_back("physical_device_0");
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_EXT_metal_surface");
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkInstance bad_instance = (VkInstance)(&my_bad_data);
+    auto bad_instance = get_bad_handle<VkInstance>();
 
     VkMetalSurfaceCreateInfoEXT surf_create_info = {};
     surf_create_info.sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT;
@@ -369,21 +317,15 @@ TEST(LoaderHandleValidTests, BadInstCreateMetalSurf) {
 TEST(LoaderHandleValidTests, BadInstCreateQNXSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_QNX_screen_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
     driver.physical_devices.emplace_back("physical_device_0");
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_QNX_screen_surface");
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkInstance bad_instance = (VkInstance)(&my_bad_data);
+    auto bad_instance = get_bad_handle<VkInstance>();
 
     VkScreenSurfaceCreateInfoQNX surf_create_info = {};
     surf_create_info.sType = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX;
@@ -399,23 +341,15 @@ TEST(LoaderHandleValidTests, BadInstCreateQNXSurf) {
 TEST(LoaderHandleValidTests, BadInstCreateViNNSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_NN_vi_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
     driver.physical_devices.emplace_back("physical_device_0");
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_NN_vi_surface");
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkInstance bad_instance = (VkInstance)(&my_bad_data);
+    auto bad_instance = get_bad_handle<VkInstance>();
 
     VkViSurfaceCreateInfoNN surf_create_info = {};
     surf_create_info.sType = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN;
@@ -431,21 +365,15 @@ TEST(LoaderHandleValidTests, BadInstCreateViNNSurf) {
 TEST(LoaderHandleValidTests, BadInstCreateWaylandSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_KHR_wayland_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
     driver.physical_devices.emplace_back("physical_device_0");
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_KHR_wayland_surface");
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkInstance bad_instance = (VkInstance)(&my_bad_data);
+    auto bad_instance = get_bad_handle<VkInstance>();
 
     VkWaylandSurfaceCreateInfoKHR surf_create_info = {};
     surf_create_info.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
@@ -461,21 +389,15 @@ TEST(LoaderHandleValidTests, BadInstCreateWaylandSurf) {
 TEST(LoaderHandleValidTests, BadInstCreateWin32Surf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_KHR_win32_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
     driver.physical_devices.emplace_back("physical_device_0");
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_KHR_win32_surface");
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkInstance bad_instance = (VkInstance)(&my_bad_data);
+    auto bad_instance = get_bad_handle<VkInstance>();
 
     VkWin32SurfaceCreateInfoKHR surf_create_info = {};
     surf_create_info.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
@@ -491,21 +413,15 @@ TEST(LoaderHandleValidTests, BadInstCreateWin32Surf) {
 TEST(LoaderHandleValidTests, BadInstCreateXCBSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_KHR_xcb_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
     driver.physical_devices.emplace_back("physical_device_0");
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_KHR_xcb_surface");
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkInstance bad_instance = (VkInstance)(&my_bad_data);
+    auto bad_instance = get_bad_handle<VkInstance>();
 
     VkXcbSurfaceCreateInfoKHR surf_create_info = {};
     surf_create_info.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
@@ -521,21 +437,15 @@ TEST(LoaderHandleValidTests, BadInstCreateXCBSurf) {
 TEST(LoaderHandleValidTests, BadInstCreateXlibSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_KHR_xlib_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
     driver.physical_devices.emplace_back("physical_device_0");
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_KHR_xlib_surface");
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkInstance bad_instance = (VkInstance)(&my_bad_data);
+    auto bad_instance = get_bad_handle<VkInstance>();
 
     VkXlibSurfaceCreateInfoKHR surf_create_info = {};
     surf_create_info.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
@@ -559,10 +469,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFeature) {
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
 
     VkPhysicalDeviceFeatures features = {};
     ASSERT_DEATH(
@@ -580,10 +487,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFormatProps) {
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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),
@@ -601,10 +505,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevImgFormatProps) {
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
 
     VkImageFormatProperties format_info = {};
     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceImageFormatProperties(bad_physical_dev, VK_FORMAT_R8G8B8A8_UNORM,
@@ -624,10 +525,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevProps) {
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
 
     VkPhysicalDeviceProperties properties = {};
     ASSERT_DEATH(
@@ -645,10 +543,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamProps) {
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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 "
@@ -665,10 +560,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDevMemProps) {
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
 
     VkPhysicalDeviceMemoryProperties properties = {};
     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceMemoryProperties(bad_physical_dev, &properties),
@@ -686,10 +578,7 @@ TEST(LoaderHandleValidTests, BadPhysDevCreateDevice) {
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
 
     float queue_priorities[3] = {0.0f, 0.5f, 1.0f};
     VkDeviceQueueCreateInfo dev_queue_create_info = {};
@@ -725,10 +614,7 @@ TEST(LoaderHandleValidTests, BadPhysDevEnumDevExtProps) {
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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 "
@@ -745,10 +631,7 @@ TEST(LoaderHandleValidTests, BadPhysDevEnumDevLayerProps) {
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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 "
@@ -765,10 +648,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSparseImgFormatProps) {
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
 
     uint32_t count = 0;
     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSparseImageFormatProperties(
@@ -788,10 +668,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFeature2) {
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
 
     VkPhysicalDeviceFeatures2 features = {};
     features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
@@ -811,10 +688,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFormatProps2) {
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
 
     VkFormatProperties2 properties = {};
     properties.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
@@ -834,10 +708,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevImgFormatProps2) {
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
 
     VkPhysicalDeviceImageFormatInfo2 format_info = {};
     format_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2;
@@ -860,10 +731,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevProps2) {
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
 
     VkPhysicalDeviceProperties2 properties = {};
     properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
@@ -883,10 +751,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamProps2) {
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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 "
@@ -903,10 +768,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDevMemProps2) {
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
 
     VkPhysicalDeviceMemoryProperties2 properties = {};
     properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
@@ -926,10 +788,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSparseImgFormatProps2) {
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
 
     VkPhysicalDeviceSparseImageFormatInfo2 info = {};
     info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2;
@@ -950,10 +809,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevExternFenceProps) {
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
 
     VkPhysicalDeviceExternalFenceInfo info = {};
     info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO;
@@ -974,10 +830,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevExternBufferProps) {
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
 
     VkPhysicalDeviceExternalBufferInfo info = {};
     info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO;
@@ -998,10 +851,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevExternSemaphoreProps) {
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
 
     VkPhysicalDeviceExternalSemaphoreInfoKHR info = {};
     info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO;
@@ -1025,10 +875,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceSupportKHR) {
     instance.create_info.add_extension("VK_KHR_surface");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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),
@@ -1049,10 +896,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceCapsKHR) {
     instance.create_info.add_extension("VK_KHR_surface");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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 "
@@ -1072,10 +916,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceFormatsKHR) {
     instance.create_info.add_extension("VK_KHR_surface");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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 "
@@ -1095,10 +936,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfacePresentModesKHR) {
     instance.create_info.add_extension("VK_KHR_surface");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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 "
@@ -1109,21 +947,15 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfacePresentModesKHR) {
 TEST(LoaderHandleValidTests, BadPhysDevGetDirectFBPresentSupportKHR) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_EXT_directfb_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
     driver.physical_devices.emplace_back("physical_device_0");
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_EXT_directfb_surface");
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
     IDirectFB directfb;
     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceDirectFBPresentationSupportEXT(bad_physical_dev, 0, &directfb),
                  "vkGetPhysicalDeviceDirectFBPresentationSupportEXT: Invalid physicalDevice "
@@ -1135,21 +967,15 @@ TEST(LoaderHandleValidTests, BadPhysDevGetDirectFBPresentSupportKHR) {
 TEST(LoaderHandleValidTests, BadPhysDevGetQNXPresentSupportKHR) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_QNX_screen_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
     driver.physical_devices.emplace_back("physical_device_0");
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_QNX_screen_surface");
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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\\]");
@@ -1160,21 +986,15 @@ TEST(LoaderHandleValidTests, BadPhysDevGetQNXPresentSupportKHR) {
 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevWaylandPresentSupportKHR) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_KHR_wayland_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
     driver.physical_devices.emplace_back("physical_device_0");
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_KHR_wayland_surface");
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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\\]");
@@ -1185,21 +1005,15 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevWaylandPresentSupportKHR) {
 TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevWin32PresentSupportKHR) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_KHR_win32_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
     driver.physical_devices.emplace_back("physical_device_0");
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_KHR_win32_surface");
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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\\]");
@@ -1210,21 +1024,14 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevWin32PresentSupportKHR) {
 TEST(LoaderHandleValidTests, BadPhysDevGetXCBPresentSupportKHR) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_KHR_xcb_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
     driver.physical_devices.emplace_back("physical_device_0");
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_KHR_xcb_surface");
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
-
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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),
@@ -1237,21 +1044,15 @@ TEST(LoaderHandleValidTests, BadPhysDevGetXCBPresentSupportKHR) {
 TEST(LoaderHandleValidTests, BadPhysDevGetXlibPresentSupportKHR) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_KHR_xlib_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
     driver.physical_devices.emplace_back("physical_device_0");
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_KHR_xlib_surface");
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
 
     VisualID visual = 0;
     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceXlibPresentationSupportKHR(bad_physical_dev, 0, nullptr, visual),
@@ -1274,10 +1075,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPropsKHR) {
     instance.create_info.add_extension("VK_KHR_display");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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 "
@@ -1298,10 +1096,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPlanePropsKHR) {
     instance.create_info.add_extension("VK_KHR_display");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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 "
@@ -1322,10 +1117,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneSupportedDisplaysKHR) {
     instance.create_info.add_extension("VK_KHR_display");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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 "
@@ -1346,10 +1138,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetDisplayModePropsKHR) {
     instance.create_info.add_extension("VK_KHR_display");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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),
@@ -1370,10 +1159,7 @@ TEST(LoaderHandleValidTests, BadPhysDevCreateDisplayModeKHR) {
     instance.create_info.add_extension("VK_KHR_display");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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;
@@ -1397,10 +1183,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneCapsKHR) {
     instance.create_info.add_extension("VK_KHR_display");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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 "
@@ -1421,10 +1204,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevPresentRectsKHR) {
     instance.create_info.add_extension("VK_KHR_display");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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 "
@@ -1445,10 +1225,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayProps2KHR) {
     instance.create_info.add_extension("VK_KHR_get_display_properties2");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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 "
@@ -1469,10 +1246,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPlaneProps2KHR) {
     instance.create_info.add_extension("VK_KHR_get_display_properties2");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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 "
@@ -1493,10 +1267,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetDisplayModeProps2KHR) {
     instance.create_info.add_extension("VK_KHR_get_display_properties2");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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 "
@@ -1517,10 +1288,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneCaps2KHR) {
     instance.create_info.add_extension("VK_KHR_get_display_properties2");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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;
@@ -1544,10 +1312,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceCaps2KHR) {
     instance.create_info.add_extension("VK_KHR_get_surface_capabilities2");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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;
@@ -1570,10 +1335,7 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceFormats2KHR) {
     instance.create_info.add_extension("VK_KHR_get_surface_capabilities2");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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;
@@ -1592,15 +1354,10 @@ TEST(LoaderHandleValidTests, BadPhysDevEnumPhysDevQueueFamilyPerfQueryCountersKH
     InstWrapper instance(env.vulkan_functions);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
     uint32_t count = 0;
     PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR pfn =
-        reinterpret_cast<PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR>(
-            env.vulkan_functions.vkGetInstanceProcAddr(instance,
-                                                       "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR"));
+        instance.load("vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR");
     ASSERT_NE(pfn, nullptr);
     ASSERT_DEATH(pfn(bad_physical_dev, 0, &count, nullptr, nullptr),
                  "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR: Invalid physicalDevice "
@@ -1616,17 +1373,13 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamilyPerfQueryPassesKHR)
     InstWrapper instance(env.vulkan_functions);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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 =
-        reinterpret_cast<PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR>(
-            env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR"));
+        instance.load("vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR");
     ASSERT_NE(pfn, nullptr);
     ASSERT_DEATH(pfn(bad_physical_dev, &create_info, &count),
                  "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR: Invalid physicalDevice "
@@ -1642,13 +1395,9 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFragmentShadingRatesKHR) {
     InstWrapper instance(env.vulkan_functions);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
     uint32_t count = 0;
-    PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR pfn = reinterpret_cast<PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR>(
-        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR"));
+    PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR pfn = instance.load("vkGetPhysicalDeviceFragmentShadingRatesKHR");
     ASSERT_NE(pfn, nullptr);
     ASSERT_DEATH(pfn(bad_physical_dev, &count, nullptr),
                  "vkGetPhysicalDeviceFragmentShadingRatesKHR: Invalid physicalDevice "
@@ -1664,13 +1413,9 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevMSPropsEXT) {
     InstWrapper instance(env.vulkan_functions);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
     VkMultisamplePropertiesEXT props = {};
-    PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT pfn = reinterpret_cast<PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT>(
-        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT"));
+    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 "
@@ -1690,12 +1435,8 @@ TEST(LoaderHandleValidTests, BadPhysDevAcquireDrmDisplayEXT) {
     instance.create_info.add_extension("VK_EXT_acquire_drm_display");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
-    PFN_vkAcquireDrmDisplayEXT pfn = reinterpret_cast<PFN_vkAcquireDrmDisplayEXT>(
-        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkAcquireDrmDisplayEXT"));
+    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\\]");
@@ -1714,12 +1455,8 @@ TEST(LoaderHandleValidTests, BadPhysDevGetDrmDisplayEXT) {
     instance.create_info.add_extension("VK_EXT_acquire_drm_display");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
-    PFN_vkGetDrmDisplayEXT pfn =
-        reinterpret_cast<PFN_vkGetDrmDisplayEXT>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkGetDrmDisplayEXT"));
+    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 "
@@ -1739,12 +1476,8 @@ TEST(LoaderHandleValidTests, BadPhysDevReleaseDisplayEXT) {
     instance.create_info.add_extension("VK_EXT_direct_mode_display");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
-    PFN_vkReleaseDisplayEXT pfn =
-        reinterpret_cast<PFN_vkReleaseDisplayEXT>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkReleaseDisplayEXT"));
+    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\\]");
@@ -1764,12 +1497,8 @@ TEST(LoaderHandleValidTests, BadPhysDevAcquireXlibDisplayEXT) {
     instance.create_info.add_extension("VK_EXT_acquire_xlib_display");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
-    PFN_vkAcquireXlibDisplayEXT pfn = reinterpret_cast<PFN_vkAcquireXlibDisplayEXT>(
-        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkAcquireXlibDisplayEXT"));
+    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\\]");
@@ -1788,14 +1517,10 @@ TEST(LoaderHandleValidTests, BadPhysDevGetRandROutputDisplayEXT) {
     instance.create_info.add_extension("VK_EXT_acquire_xlib_display");
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    auto bad_physical_dev = get_bad_handle<VkPhysicalDevice>();
     RROutput rrout = {};
     VkDisplayKHR disp;
-    PFN_vkGetRandROutputDisplayEXT pfn = reinterpret_cast<PFN_vkGetRandROutputDisplayEXT>(
-        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkGetRandROutputDisplayEXT"));
+    PFN_vkGetRandROutputDisplayEXT pfn = instance.load("vkGetRandROutputDisplayEXT");
     ASSERT_NE(pfn, nullptr);
     ASSERT_DEATH(
         pfn(bad_physical_dev, nullptr, rrout, &disp),
@@ -1808,21 +1533,18 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfacePresentModes2EXT) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     auto& driver = env.get_test_icd();
+    setup_WSI_in_ICD(driver);
     driver.physical_devices.emplace_back("physical_device_0");
 
     InstWrapper instance(env.vulkan_functions);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
+    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 = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT>(
-        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT"));
+    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 "
@@ -1839,12 +1561,8 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevToolPropertiesEXT) {
     InstWrapper instance(env.vulkan_functions);
     instance.CheckCreate();
 
-    struct BadData {
-        uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
-    } my_bad_data;
-    VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
-    PFN_vkGetPhysicalDeviceToolPropertiesEXT pfn = reinterpret_cast<PFN_vkGetPhysicalDeviceToolPropertiesEXT>(
-        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceToolPropertiesEXT"));
+    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),
@@ -1856,10 +1574,8 @@ TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevToolPropertiesEXT) {
 TEST(LoaderHandleValidTests, VerifyHandleWrappingAndroidSurface) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_KHR_android_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
 
     const char* wrap_objects_name = "WrapObjectsLayer";
     env.add_explicit_layer(ManifestLayer{}.add_layer(
@@ -1871,20 +1587,17 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingAndroidSurface) {
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_KHR_android_surface");
-    instance.create_info.add_layer(wrap_objects_name);
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
+    instance.create_info.add_layer(wrap_objects_name);
 
     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 = reinterpret_cast<PFN_vkCreateAndroidSurfaceKHR>(
-        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateAndroidSurfaceKHR"));
+    PFN_vkCreateAndroidSurfaceKHR pfn_CreateSurface = instance.load("vkCreateAndroidSurfaceKHR");
     ASSERT_NE(pfn_CreateSurface, nullptr);
-    PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+    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);
@@ -1895,10 +1608,8 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingAndroidSurface) {
 TEST(LoaderHandleValidTests, VerifyHandleWrappingDirectFBSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_EXT_directfb_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
 
     const char* wrap_objects_name = "WrapObjectsLayer";
     env.add_explicit_layer(ManifestLayer{}.add_layer(
@@ -1910,20 +1621,17 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingDirectFBSurf) {
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_EXT_directfb_surface");
-    instance.create_info.add_layer(wrap_objects_name);
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
+    instance.create_info.add_layer(wrap_objects_name);
 
     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 = reinterpret_cast<PFN_vkCreateDirectFBSurfaceEXT>(
-        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateDirectFBSurfaceEXT"));
+    PFN_vkCreateDirectFBSurfaceEXT pfn_CreateSurface = instance.load("vkCreateDirectFBSurfaceEXT");
     ASSERT_NE(pfn_CreateSurface, nullptr);
-    PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+    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);
@@ -1934,10 +1642,8 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingDirectFBSurf) {
 TEST(LoaderHandleValidTests, VerifyHandleWrappingFuchsiaSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_FUCHSIA_imagepipe_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
 
     const char* wrap_objects_name = "WrapObjectsLayer";
     env.add_explicit_layer(ManifestLayer{}.add_layer(
@@ -1949,20 +1655,17 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingFuchsiaSurf) {
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_FUCHSIA_imagepipe_surface");
-    instance.create_info.add_layer(wrap_objects_name);
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
+    instance.create_info.add_layer(wrap_objects_name);
 
     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 = reinterpret_cast<PFN_vkCreateImagePipeSurfaceFUCHSIA>(
-        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateImagePipeSurfaceFUCHSIA"));
+    PFN_vkCreateImagePipeSurfaceFUCHSIA pfn_CreateSurface = instance.load("vkCreateImagePipeSurfaceFUCHSIA");
     ASSERT_NE(pfn_CreateSurface, nullptr);
-    PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+    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);
@@ -1973,10 +1676,8 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingFuchsiaSurf) {
 TEST(LoaderHandleValidTests, VerifyHandleWrappingGGPSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_GGP_stream_descriptor_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
 
     const char* wrap_objects_name = "WrapObjectsLayer";
     env.add_explicit_layer(ManifestLayer{}.add_layer(
@@ -1988,20 +1689,17 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingGGPSurf) {
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_GGP_stream_descriptor_surface");
-    instance.create_info.add_layer(wrap_objects_name);
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
+    instance.create_info.add_layer(wrap_objects_name);
 
     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 = reinterpret_cast<PFN_vkCreateStreamDescriptorSurfaceGGP>(
-        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateStreamDescriptorSurfaceGGP"));
+    PFN_vkCreateStreamDescriptorSurfaceGGP pfn_CreateSurface = instance.load("vkCreateStreamDescriptorSurfaceGGP");
     ASSERT_NE(pfn_CreateSurface, nullptr);
-    PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+    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);
@@ -2012,10 +1710,8 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingGGPSurf) {
 TEST(LoaderHandleValidTests, VerifyHandleWrappingIOSSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_MVK_ios_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
 
     const char* wrap_objects_name = "WrapObjectsLayer";
     env.add_explicit_layer(ManifestLayer{}.add_layer(
@@ -2027,20 +1723,17 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingIOSSurf) {
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_MVK_ios_surface");
-    instance.create_info.add_layer(wrap_objects_name);
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
+    instance.create_info.add_layer(wrap_objects_name);
 
     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 =
-        reinterpret_cast<PFN_vkCreateIOSSurfaceMVK>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateIOSSurfaceMVK"));
+    PFN_vkCreateIOSSurfaceMVK pfn_CreateSurface = instance.load("vkCreateIOSSurfaceMVK");
     ASSERT_NE(pfn_CreateSurface, nullptr);
-    PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+    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);
@@ -2051,10 +1744,8 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingIOSSurf) {
 TEST(LoaderHandleValidTests, VerifyHandleWrappingMacOSSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_MVK_macos_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
 
     const char* wrap_objects_name = "WrapObjectsLayer";
     env.add_explicit_layer(ManifestLayer{}.add_layer(
@@ -2066,20 +1757,17 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingMacOSSurf) {
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_MVK_macos_surface");
-    instance.create_info.add_layer(wrap_objects_name);
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
+    instance.create_info.add_layer(wrap_objects_name);
 
     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 = reinterpret_cast<PFN_vkCreateMacOSSurfaceMVK>(
-        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateMacOSSurfaceMVK"));
+    PFN_vkCreateMacOSSurfaceMVK pfn_CreateSurface = instance.load("vkCreateMacOSSurfaceMVK");
     ASSERT_NE(pfn_CreateSurface, nullptr);
-    PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+    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);
@@ -2090,10 +1778,8 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingMacOSSurf) {
 TEST(LoaderHandleValidTests, VerifyHandleWrappingMetalSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_EXT_metal_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
 
     const char* wrap_objects_name = "WrapObjectsLayer";
     env.add_explicit_layer(ManifestLayer{}.add_layer(
@@ -2105,20 +1791,17 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingMetalSurf) {
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_EXT_metal_surface");
-    instance.create_info.add_layer(wrap_objects_name);
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
+    instance.create_info.add_layer(wrap_objects_name);
 
     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 = reinterpret_cast<PFN_vkCreateMetalSurfaceEXT>(
-        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateMetalSurfaceEXT"));
+    PFN_vkCreateMetalSurfaceEXT pfn_CreateSurface = instance.load("vkCreateMetalSurfaceEXT");
     ASSERT_NE(pfn_CreateSurface, nullptr);
-    PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+    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);
@@ -2129,10 +1812,8 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingMetalSurf) {
 TEST(LoaderHandleValidTests, VerifyHandleWrappingQNXSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_QNX_screen_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
 
     const char* wrap_objects_name = "WrapObjectsLayer";
     env.add_explicit_layer(ManifestLayer{}.add_layer(
@@ -2144,20 +1825,17 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingQNXSurf) {
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_QNX_screen_surface");
-    instance.create_info.add_layer(wrap_objects_name);
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
+    instance.create_info.add_layer(wrap_objects_name);
 
     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 = reinterpret_cast<PFN_vkCreateScreenSurfaceQNX>(
-        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateScreenSurfaceQNX"));
+    PFN_vkCreateScreenSurfaceQNX pfn_CreateSurface = instance.load("vkCreateScreenSurfaceQNX");
     ASSERT_NE(pfn_CreateSurface, nullptr);
-    PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+    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);
@@ -2168,10 +1846,8 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingQNXSurf) {
 TEST(LoaderHandleValidTests, VerifyHandleWrappingViNNSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_NN_vi_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
 
     const char* wrap_objects_name = "WrapObjectsLayer";
     env.add_explicit_layer(ManifestLayer{}.add_layer(
@@ -2183,20 +1859,17 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingViNNSurf) {
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_NN_vi_surface");
-    instance.create_info.add_layer(wrap_objects_name);
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
+    instance.create_info.add_layer(wrap_objects_name);
 
     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 =
-        reinterpret_cast<PFN_vkCreateViSurfaceNN>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateViSurfaceNN"));
+    PFN_vkCreateViSurfaceNN pfn_CreateSurface = instance.load("vkCreateViSurfaceNN");
     ASSERT_NE(pfn_CreateSurface, nullptr);
-    PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+    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);
@@ -2207,10 +1880,8 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingViNNSurf) {
 TEST(LoaderHandleValidTests, VerifyHandleWrappingWaylandSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_KHR_wayland_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
 
     const char* wrap_objects_name = "WrapObjectsLayer";
     env.add_explicit_layer(ManifestLayer{}.add_layer(
@@ -2222,20 +1893,17 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingWaylandSurf) {
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_KHR_wayland_surface");
-    instance.create_info.add_layer(wrap_objects_name);
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
+    instance.create_info.add_layer(wrap_objects_name);
 
     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 = reinterpret_cast<PFN_vkCreateWaylandSurfaceKHR>(
-        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateWaylandSurfaceKHR"));
+    PFN_vkCreateWaylandSurfaceKHR pfn_CreateSurface = instance.load("vkCreateWaylandSurfaceKHR");
     ASSERT_NE(pfn_CreateSurface, nullptr);
-    PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+    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);
@@ -2246,10 +1914,8 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingWaylandSurf) {
 TEST(LoaderHandleValidTests, VerifyHandleWrappingWin32Surf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_KHR_win32_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
 
     const char* wrap_objects_name = "WrapObjectsLayer";
     env.add_explicit_layer(ManifestLayer{}.add_layer(
@@ -2261,20 +1927,17 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingWin32Surf) {
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_KHR_win32_surface");
-    instance.create_info.add_layer(wrap_objects_name);
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
+    instance.create_info.add_layer(wrap_objects_name);
 
     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 = reinterpret_cast<PFN_vkCreateWin32SurfaceKHR>(
-        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateWin32SurfaceKHR"));
+    PFN_vkCreateWin32SurfaceKHR pfn_CreateSurface = instance.load("vkCreateWin32SurfaceKHR");
     ASSERT_NE(pfn_CreateSurface, nullptr);
-    PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+    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);
@@ -2285,10 +1948,8 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingWin32Surf) {
 TEST(LoaderHandleValidTests, VerifyHandleWrappingXCBSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_KHR_xcb_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
 
     const char* wrap_objects_name = "WrapObjectsLayer";
     env.add_explicit_layer(ManifestLayer{}.add_layer(
@@ -2300,20 +1961,17 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingXCBSurf) {
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_KHR_xcb_surface");
-    instance.create_info.add_layer(wrap_objects_name);
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
+    instance.create_info.add_layer(wrap_objects_name);
 
     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 =
-        reinterpret_cast<PFN_vkCreateXcbSurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateXcbSurfaceKHR"));
+    PFN_vkCreateXcbSurfaceKHR pfn_CreateSurface = instance.load("vkCreateXcbSurfaceKHR");
     ASSERT_NE(pfn_CreateSurface, nullptr);
-    PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+    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);
@@ -2324,10 +1982,8 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingXCBSurf) {
 TEST(LoaderHandleValidTests, VerifyHandleWrappingXlibSurf) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    Extension first_ext{"VK_KHR_surface"};
-    Extension second_ext{"VK_KHR_xlib_surface"};
     auto& driver = env.get_test_icd();
-    driver.add_instance_extensions({first_ext, second_ext});
+    setup_WSI_in_ICD(driver);
 
     const char* wrap_objects_name = "WrapObjectsLayer";
     env.add_explicit_layer(ManifestLayer{}.add_layer(
@@ -2339,20 +1995,17 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingXlibSurf) {
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
     InstWrapper instance(env.vulkan_functions);
-    instance.create_info.add_extension("VK_KHR_surface");
-    instance.create_info.add_extension("VK_KHR_xlib_surface");
-    instance.create_info.add_layer(wrap_objects_name);
+    setup_WSI_in_create_instance(instance);
     instance.CheckCreate();
+    instance.create_info.add_layer(wrap_objects_name);
 
     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 = reinterpret_cast<PFN_vkCreateXlibSurfaceKHR>(
-        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateXlibSurfaceKHR"));
+    PFN_vkCreateXlibSurfaceKHR pfn_CreateSurface = instance.load("vkCreateXlibSurfaceKHR");
     ASSERT_NE(pfn_CreateSurface, nullptr);
-    PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+    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);
@@ -2400,11 +2053,9 @@ TEST(LoaderHandleValidTests, VerifyHandleWrappingDebugUtilsMessenger) {
         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 = reinterpret_cast<PFN_vkCreateDebugUtilsMessengerEXT>(
-        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT"));
+    PFN_vkCreateDebugUtilsMessengerEXT pfn_CreateMessenger = instance.load("vkCreateDebugUtilsMessengerEXT");
     ASSERT_NE(pfn_CreateMessenger, nullptr);
-    PFN_vkDestroyDebugUtilsMessengerEXT pfn_DestroyMessenger = reinterpret_cast<PFN_vkDestroyDebugUtilsMessengerEXT>(
-        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT"));
+    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);
diff --git a/tests/loader_layer_tests.cpp b/tests/loader_layer_tests.cpp
index 407a15a23..9d566394c 100644
--- a/tests/loader_layer_tests.cpp
+++ b/tests/loader_layer_tests.cpp
@@ -45,7 +45,7 @@ const char* lunarg_meta_layer_name = "VK_LAYER_LUNARG_override";
 
 TEST(ImplicitLayers, WithEnableAndDisableEnvVar) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     const char* implicit_layer_name = "VK_LAYER_ImplicitTestLayer";
     const char* enable_env_var = "ENABLE_ME";
     const char* disable_env_var = "DISABLE_ME";
@@ -93,7 +93,7 @@ TEST(ImplicitLayers, WithEnableAndDisableEnvVar) {
 
 TEST(ImplicitLayers, OnlyDisableEnvVar) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     const char* implicit_layer_name = "ImplicitTestLayer";
     const char* disable_env_var = "DISABLE_ME";
 
@@ -130,7 +130,7 @@ TEST(ImplicitLayers, OnlyDisableEnvVar) {
 
 TEST(ImplicitLayers, PreInstanceEnumInstLayerProps) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     const char* implicit_layer_name = "ImplicitTestLayer";
     const char* disable_env_var = "DISABLE_ME";
 
@@ -167,7 +167,7 @@ TEST(ImplicitLayers, PreInstanceEnumInstLayerProps) {
 
 TEST(ImplicitLayers, PreInstanceEnumInstExtProps) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     const char* implicit_layer_name = "ImplicitTestLayer";
     const char* disable_env_var = "DISABLE_ME";
 
@@ -204,7 +204,7 @@ TEST(ImplicitLayers, PreInstanceEnumInstExtProps) {
 
 TEST(ImplicitLayers, PreInstanceVersion) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().physical_devices.push_back({});
     env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 3);
 
@@ -249,7 +249,7 @@ TEST(ImplicitLayers, PreInstanceVersion) {
 // tested through behavior above).
 TEST(ImplicitLayers, OverrideGetInstanceProcAddr) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().physical_devices.push_back({});
 
     const char* implicit_layer_name = "ImplicitTestLayer";
@@ -284,7 +284,7 @@ TEST(ImplicitLayers, OverrideGetInstanceProcAddr) {
 // Meta layer which contains component layers that do not exist.
 TEST(MetaLayers, InvalidComponentLayer) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     const char* meta_layer_name = "VK_LAYER_MetaTestLayer";
     const char* invalid_layer_name_1 = "VK_LAYER_InvalidLayer1";
     const char* invalid_layer_name_2 = "VK_LAYER_InvalidLayer2";
@@ -334,7 +334,7 @@ TEST(MetaLayers, InvalidComponentLayer) {
 // Meta layer that is an explicit layer
 TEST(MetaLayers, ExplicitMetaLayer) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().add_physical_device({});
     const char* meta_layer_name = "VK_LAYER_MetaTestLayer";
     const char* regular_layer_name = "VK_LAYER_TestLayer";
@@ -394,7 +394,7 @@ TEST(MetaLayers, ExplicitMetaLayer) {
 // Meta layer which adds itself in its list of component layers
 TEST(MetaLayers, MetaLayerNameInComponentLayers) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     const char* meta_layer_name = "VK_LAYER_MetaTestLayer";
     const char* regular_layer_name = "VK_LAYER_TestLayer";
     env.add_implicit_layer(ManifestLayer{}
@@ -442,7 +442,7 @@ TEST(MetaLayers, MetaLayerNameInComponentLayers) {
 // Meta layer which adds another meta layer as a component layer
 TEST(MetaLayers, MetaLayerWhichAddsMetaLayer) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     const char* meta_layer_name = "VK_LAYER_MetaTestLayer";
     const char* meta_meta_layer_name = "VK_LAYER_MetaMetaTestLayer";
     const char* regular_layer_name = "VK_LAYER_TestLayer";
@@ -490,7 +490,7 @@ TEST(MetaLayers, MetaLayerWhichAddsMetaLayer) {
 
 TEST(MetaLayers, InstanceExtensionInComponentLayer) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().add_physical_device({});
     const char* meta_layer_name = "VK_LAYER_MetaTestLayer";
     const char* regular_layer_name = "VK_LAYER_TestLayer";
@@ -519,7 +519,7 @@ TEST(MetaLayers, InstanceExtensionInComponentLayer) {
 
 TEST(MetaLayers, DeviceExtensionInComponentLayer) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().add_physical_device({});
     const char* meta_layer_name = "VK_LAYER_MetaTestLayer";
     const char* regular_layer_name = "VK_LAYER_TestLayer";
@@ -583,7 +583,7 @@ TEST(MetaLayers, DeviceExtensionInComponentLayer) {
 // Override meta layer missing disable environment variable still enables the layer
 TEST(OverrideMetaLayer, InvalidDisableEnvironment) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().add_physical_device({});
     const char* regular_layer_name = "VK_LAYER_TestLayer";
     env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
@@ -617,7 +617,7 @@ TEST(OverrideMetaLayer, InvalidDisableEnvironment) {
 // Override meta layer whose version is less than the api version of the instance
 TEST(OverrideMetaLayer, OlderVersionThanInstance) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().add_physical_device({});
     const char* regular_layer_name = "VK_LAYER_TestLayer";
     env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
@@ -676,7 +676,7 @@ TEST(OverrideMetaLayer, OlderVersionThanInstance) {
 
 TEST(OverrideMetaLayer, OlderMetaLayerWithNewerInstanceVersion) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().add_physical_device({});
 
     const char* regular_layer_name = "VK_LAYER_TestLayer";
@@ -745,7 +745,7 @@ TEST(OverrideMetaLayer, OlderMetaLayerWithNewerInstanceVersion) {
 
 TEST(OverrideMetaLayer, NewerComponentLayerInMetaLayer) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().add_physical_device({});
 
     const char* regular_layer_name = "VK_LAYER_TestLayer";
@@ -818,7 +818,7 @@ TEST(OverrideMetaLayer, NewerComponentLayerInMetaLayer) {
 
 TEST(OverrideMetaLayer, OlderComponentLayerInMetaLayer) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().add_physical_device({});
 
     const char* regular_layer_name = "VK_LAYER_TestLayer";
@@ -889,7 +889,7 @@ TEST(OverrideMetaLayer, OlderComponentLayerInMetaLayer) {
 
 TEST(OverrideMetaLayer, ApplicationEnabledLayerInBlacklist) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().add_physical_device({});
 
     const char* automatic_regular_layer_name = "VK_LAYER_TestLayer_1";
@@ -945,7 +945,7 @@ TEST(OverrideMetaLayer, ApplicationEnabledLayerInBlacklist) {
 
 TEST(OverrideMetaLayer, BasicOverridePaths) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().add_physical_device({});
     fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"};
 
@@ -978,7 +978,7 @@ TEST(OverrideMetaLayer, BasicOverridePaths) {
 
 TEST(OverrideMetaLayer, BasicOverridePathsIgnoreOtherLayers) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().add_physical_device({});
     fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"};
 
@@ -1021,7 +1021,7 @@ TEST(OverrideMetaLayer, BasicOverridePathsIgnoreOtherLayers) {
 
 TEST(OverrideMetaLayer, OverridePathsInteractionWithVK_LAYER_PATH) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().add_physical_device({});
 
     fs::FolderManager vk_layer_path_folder{FRAMEWORK_BUILD_DIRECTORY, "vk_layer_folder"};
@@ -1072,7 +1072,7 @@ TEST(OverrideMetaLayer, OverridePathsInteractionWithVK_LAYER_PATH) {
 // Make sure that implicit layers not in the override paths aren't found by mistake
 TEST(OverrideMetaLayer, OverridePathsEnableImplicitLayerInDefaultPaths) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().add_physical_device({});
     fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"};
 
@@ -1116,7 +1116,7 @@ TEST(OverrideMetaLayer, OverridePathsEnableImplicitLayerInDefaultPaths) {
 
 TEST(OverrideMetaLayer, ManifestFileFormatVersionTooOld) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().add_physical_device({});
     fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"};
 
@@ -1152,7 +1152,7 @@ TEST(OverrideMetaLayer, ManifestFileFormatVersionTooOld) {
 // succeeds and doesn't crash.
 TEST(LayerCreateInstance, GetPhysicalDeviceProperties2) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().physical_devices.push_back({});
     env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
 
@@ -1193,7 +1193,7 @@ TEST(LayerCreateInstance, GetPhysicalDeviceProperties2) {
 
 TEST(LayerCreateInstance, GetPhysicalDeviceProperties2KHR) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().physical_devices.push_back({});
     env.get_test_icd().add_instance_extension({"VK_KHR_get_physical_device_properties2", 0});
 
@@ -1226,7 +1226,7 @@ TEST(LayerCreateInstance, GetPhysicalDeviceProperties2KHR) {
 
 TEST(ExplicitLayers, WrapObjects) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& driver = env.get_test_icd();
 
     const char* wrap_objects_name = "VK_LAYER_LUNARG_wrap_objects";
@@ -1294,7 +1294,7 @@ TEST(ExplicitLayers, WrapObjects) {
 
 TEST(LayerExtensions, ImplicitNoAdditionalInstanceExtension) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
@@ -1347,7 +1347,7 @@ TEST(LayerExtensions, ImplicitNoAdditionalInstanceExtension) {
 
 TEST(LayerExtensions, ImplicitDirDispModeInstanceExtension) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
@@ -1407,7 +1407,7 @@ TEST(LayerExtensions, ImplicitDirDispModeInstanceExtension) {
 
 TEST(LayerExtensions, ImplicitDispSurfCountInstanceExtension) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
@@ -1467,7 +1467,7 @@ TEST(LayerExtensions, ImplicitDispSurfCountInstanceExtension) {
 
 TEST(LayerExtensions, ImplicitBothInstanceExtensions) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
@@ -1534,7 +1534,7 @@ TEST(LayerExtensions, ImplicitBothInstanceExtensions) {
 
 TEST(LayerExtensions, ExplicitNoAdditionalInstanceExtension) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
@@ -1593,7 +1593,7 @@ TEST(LayerExtensions, ExplicitNoAdditionalInstanceExtension) {
 
 TEST(LayerExtensions, ExplicitDirDispModeInstanceExtension) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
@@ -1667,7 +1667,7 @@ TEST(LayerExtensions, ExplicitDirDispModeInstanceExtension) {
 
 TEST(LayerExtensions, ExplicitDispSurfCountInstanceExtension) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
@@ -1741,7 +1741,7 @@ TEST(LayerExtensions, ExplicitDispSurfCountInstanceExtension) {
 
 TEST(LayerExtensions, ExplicitBothInstanceExtensions) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
@@ -1836,7 +1836,7 @@ TEST(LayerExtensions, ExplicitBothInstanceExtensions) {
 
 TEST(LayerExtensions, ImplicitNoAdditionalDeviceExtension) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
@@ -1923,7 +1923,7 @@ TEST(LayerExtensions, ImplicitNoAdditionalDeviceExtension) {
 
 TEST(LayerExtensions, ImplicitMaintenanceDeviceExtension) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
@@ -1984,7 +1984,7 @@ TEST(LayerExtensions, ImplicitMaintenanceDeviceExtension) {
 
 TEST(LayerExtensions, ImplicitPresentImageDeviceExtension) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
@@ -2046,7 +2046,7 @@ TEST(LayerExtensions, ImplicitPresentImageDeviceExtension) {
 
 TEST(LayerExtensions, ImplicitBothDeviceExtensions) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
@@ -2113,7 +2113,7 @@ TEST(LayerExtensions, ImplicitBothDeviceExtensions) {
 
 TEST(LayerExtensions, ExplicitNoAdditionalDeviceExtension) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
@@ -2179,7 +2179,7 @@ TEST(LayerExtensions, ExplicitNoAdditionalDeviceExtension) {
 
 TEST(LayerExtensions, ExplicitMaintenanceDeviceExtension) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
@@ -2250,7 +2250,7 @@ TEST(LayerExtensions, ExplicitMaintenanceDeviceExtension) {
 
 TEST(LayerExtensions, ExplicitPresentImageDeviceExtension) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
@@ -2323,7 +2323,7 @@ TEST(LayerExtensions, ExplicitPresentImageDeviceExtension) {
 
 TEST(LayerExtensions, ExplicitBothDeviceExtensions) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
@@ -2413,7 +2413,7 @@ TEST(LayerExtensions, ExplicitBothDeviceExtensions) {
 
 TEST(TestLayers, ExplicitlyEnableImplicitLayer) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6, VK_MAKE_API_VERSION(0, 1, 2, 0)));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
     env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
     VkPhysicalDeviceProperties properties{};
     properties.apiVersion = VK_MAKE_API_VERSION(0, 1, 2, 0);
@@ -2460,7 +2460,7 @@ TEST(TestLayers, ExplicitlyEnableImplicitLayer) {
 
 TEST(TestLayers, NewerInstanceVersionThanImplicitLayer) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6, VK_MAKE_API_VERSION(0, 1, 2, 0)));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
     env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
     VkPhysicalDeviceProperties properties{};
     properties.apiVersion = VK_MAKE_API_VERSION(0, 1, 2, 0);
@@ -2520,7 +2520,7 @@ TEST(TestLayers, NewerInstanceVersionThanImplicitLayer) {
 
 TEST(TestLayers, ImplicitLayerPre10APIVersion) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6, VK_MAKE_API_VERSION(0, 1, 2, 0)));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
     env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
     VkPhysicalDeviceProperties properties{};
     properties.apiVersion = VK_MAKE_API_VERSION(0, 1, 2, 0);
@@ -2618,7 +2618,7 @@ TEST(TestLayers, ImplicitLayerPre10APIVersion) {
 // it is set with VK_INSTANCE_LAYERS
 TEST(TestLayers, EnvironEnableExplicitLayer) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6, VK_MAKE_API_VERSION(0, 1, 2, 0)));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
     env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
     VkPhysicalDeviceProperties properties{};
     properties.apiVersion = VK_MAKE_API_VERSION(0, 1, 2, 0);
@@ -2708,7 +2708,7 @@ TEST(TestLayers, EnvironEnableExplicitLayer) {
 // Add a device layer, should not work
 TEST(TestLayers, DoNotUseDeviceLayer) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6, VK_MAKE_API_VERSION(0, 1, 2, 0)));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
     env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
     VkPhysicalDeviceProperties properties{};
     properties.apiVersion = VK_MAKE_API_VERSION(0, 1, 2, 0);
@@ -2790,7 +2790,7 @@ TEST(TestLayers, DoNotUseDeviceLayer) {
 // Make sure that a layer enabled as both an instance and device layer works properly.
 TEST(TestLayers, InstanceAndDeviceLayer) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6, VK_MAKE_API_VERSION(0, 1, 2, 0)));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
     env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
     VkPhysicalDeviceProperties properties{};
     properties.apiVersion = VK_MAKE_API_VERSION(0, 1, 2, 0);
@@ -2831,7 +2831,7 @@ TEST(TestLayers, InstanceAndDeviceLayer) {
 // Make sure loader does not throw an error for a device layer  that is not present
 TEST(TestLayers, DeviceLayerNotPresent) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6, VK_MAKE_API_VERSION(0, 1, 2, 0)));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 2, 0)));
     env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 0);
     VkPhysicalDeviceProperties properties{};
     properties.apiVersion = VK_MAKE_API_VERSION(0, 1, 2, 0);
@@ -2851,7 +2851,7 @@ TEST(TestLayers, DeviceLayerNotPresent) {
 
 TEST(LayerPhysDeviceMod, AddPhysicalDevices) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
                                                          .set_name("VkLayer_LunarG_add_phys_dev")
                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
@@ -2930,7 +2930,7 @@ TEST(LayerPhysDeviceMod, AddPhysicalDevices) {
 
 TEST(LayerPhysDeviceMod, RemovePhysicalDevices) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
                                                          .set_name("VkLayer_LunarG_remove_phys_dev")
                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
@@ -2982,7 +2982,7 @@ TEST(LayerPhysDeviceMod, RemovePhysicalDevices) {
 
 TEST(LayerPhysDeviceMod, ReorderPhysicalDevices) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
                                                          .set_name("VkLayer_LunarG_reorder_phys_dev")
                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
@@ -3034,7 +3034,7 @@ TEST(LayerPhysDeviceMod, ReorderPhysicalDevices) {
 
 TEST(LayerPhysDeviceMod, AddRemoveAndReorderPhysicalDevices) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
                                                          .set_name("VkLayer_LunarG_all_phys_dev")
                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
@@ -3112,7 +3112,7 @@ static bool GroupsAreTheSame(VkPhysicalDeviceGroupProperties a, VkPhysicalDevice
 
 TEST(LayerPhysDeviceMod, AddPhysicalDeviceGroups) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
                                                          .set_name("VkLayer_LunarG_add_phys_dev")
                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
@@ -3202,7 +3202,7 @@ TEST(LayerPhysDeviceMod, AddPhysicalDeviceGroups) {
 
 TEST(LayerPhysDeviceMod, RemovePhysicalDeviceGroups) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
                                                          .set_name("VkLayer_LunarG_remove_phys_dev")
                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
@@ -3257,7 +3257,7 @@ TEST(LayerPhysDeviceMod, RemovePhysicalDeviceGroups) {
 
 TEST(LayerPhysDeviceMod, ReorderPhysicalDeviceGroups) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
                                                          .set_name("VkLayer_LunarG_reorder_phys_dev")
                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
@@ -3312,7 +3312,7 @@ TEST(LayerPhysDeviceMod, ReorderPhysicalDeviceGroups) {
 
 TEST(LayerPhysDeviceMod, AddRemoveAndReorderPhysicalDeviceGroups) {
     FrameworkEnvironment env;
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
                                                          .set_name("VkLayer_LunarG_all_phys_dev")
                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
diff --git a/tests/loader_phys_dev_inst_ext_tests.cpp b/tests/loader_phys_dev_inst_ext_tests.cpp
index 8b3c20e3d..14f4b5743 100644
--- a/tests/loader_phys_dev_inst_ext_tests.cpp
+++ b/tests/loader_phys_dev_inst_ext_tests.cpp
@@ -59,7 +59,7 @@ static void FillInRandomDeviceProps(VkPhysicalDeviceProperties& props, uint32_t
 // Test vkGetPhysicalDeviceProperties2KHR where nothing supports it.
 TEST(LoaderInstPhysDevExts, PhysDevProps2KHRNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -73,7 +73,7 @@ TEST(LoaderInstPhysDevExts, PhysDevProps2KHRNoSupport) {
 // Test vkGetPhysicalDeviceProperties2KHR where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, PhysDevProps2KHRNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -88,7 +88,7 @@ TEST(LoaderInstPhysDevExts, PhysDevProps2KHRNoICDSupport) {
 // Test vkGetPhysicalDeviceProperties2KHR where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, PhysDevProps2KHRInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     FillInRandomDeviceProps(env.get_test_icd(0).physical_devices.back().properties, VK_API_VERSION_1_0, 5, 123);
@@ -124,7 +124,7 @@ TEST(LoaderInstPhysDevExts, PhysDevProps2KHRInstanceAndICDSupport) {
 // also support, so everything should work and return properly.
 TEST(LoaderInstPhysDevExts, PhysDevProps2Simple) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).icd_api_version = VK_API_VERSION_1_1;
     env.get_test_icd(0).add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
@@ -162,7 +162,7 @@ TEST(LoaderInstPhysDevExts, PhysDevProps2Simple) {
 // extension but the instance supports 1.1 and the extension
 TEST(LoaderInstPhysDevExts, PhysDevProps2KHRInstanceSupports11) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6, VK_API_VERSION_1_0));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_0));
     env.get_test_icd(0).add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     env.get_test_icd(0).physical_devices.back().extensions.push_back({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 0});
@@ -236,7 +236,7 @@ TEST(LoaderInstPhysDevExts, PhysDevProps2Mixed) {
     const uint32_t max_phys_devs = 7;
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
 
         // ICD 1 should not have 1.1
@@ -407,7 +407,7 @@ static bool CompareFeatures(const VkPhysicalDeviceFeatures& feats1, const VkPhys
 // Test vkGetPhysicalDeviceFeatures2KHR where nothing supports it.
 TEST(LoaderInstPhysDevExts, PhysDevFeats2KHRNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -421,7 +421,7 @@ TEST(LoaderInstPhysDevExts, PhysDevFeats2KHRNoSupport) {
 // Test vkGetPhysicalDeviceFeatures2KHR where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, PhysDevFeatsKHRNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -436,7 +436,7 @@ TEST(LoaderInstPhysDevExts, PhysDevFeatsKHRNoICDSupport) {
 // Test vkGetPhysicalDeviceFeatures2KHR where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, PhysDevFeats2KHRInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     FillInRandomFeatures(env.get_test_icd(0).physical_devices.back().features);
@@ -465,7 +465,7 @@ TEST(LoaderInstPhysDevExts, PhysDevFeats2KHRInstanceAndICDSupport) {
 // also support, so everything should work and return properly.
 TEST(LoaderInstPhysDevExts, PhysDevFeats2Simple) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).icd_api_version = VK_API_VERSION_1_1;
     env.get_test_icd(0).add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
@@ -496,7 +496,7 @@ TEST(LoaderInstPhysDevExts, PhysDevFeats2Simple) {
 // extension but the instance supports 1.1 and the extension
 TEST(LoaderInstPhysDevExts, PhysDevFeats2KHRInstanceSupports11) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6, VK_API_VERSION_1_0));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_API_VERSION_1_0));
     env.get_test_icd(0).add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     env.get_test_icd(0).physical_devices.back().extensions.push_back({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 0});
@@ -557,7 +557,7 @@ TEST(LoaderInstPhysDevExts, PhysDevFeatsMixed) {
     const uint32_t max_phys_devs = 7;
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
 
         // ICD 1 should not have 1.1
@@ -624,7 +624,7 @@ static void FillInRandomFormatProperties(std::vector<VkFormatProperties>& props)
 // Test vkGetPhysicalDeviceFormatProperties2KHR where nothing supports it.
 TEST(LoaderInstPhysDevExts, PhysDevFormatProps2KHRNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -638,7 +638,7 @@ TEST(LoaderInstPhysDevExts, PhysDevFormatProps2KHRNoSupport) {
 // Test vkGetPhysicalDeviceFormatProperties2KHR where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, PhysDevFormatPropsKHRNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -653,7 +653,7 @@ TEST(LoaderInstPhysDevExts, PhysDevFormatPropsKHRNoICDSupport) {
 // Test vkGetPhysicalDeviceFormatProperties2KHR where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, PhysDevFormatProps2KHRInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     FillInRandomFormatProperties(env.get_test_icd(0).physical_devices.back().format_properties);
@@ -688,7 +688,7 @@ TEST(LoaderInstPhysDevExts, PhysDevFormatProps2KHRInstanceAndICDSupport) {
 // also support, so everything should work and return properly.
 TEST(LoaderInstPhysDevExts, PhysDevFormatProps2Simple) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).icd_api_version = VK_API_VERSION_1_1;
     env.get_test_icd(0).add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
@@ -722,7 +722,7 @@ TEST(LoaderInstPhysDevExts, PhysDevFormatProps2Simple) {
 // extension but the instance supports 1.1 and the extension
 TEST(LoaderInstPhysDevExts, PhysDevFormatProps2KHRInstanceSupports11) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     env.get_test_icd(0).physical_devices.back().extensions.push_back({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 0});
@@ -788,7 +788,7 @@ TEST(LoaderInstPhysDevExts, PhysDevFormatPropsMixed) {
     const uint32_t max_phys_devs = 7;
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
 
         // ICD 1 should not have 1.1
@@ -859,7 +859,7 @@ static void FillInRandomImageFormatData(VkImageFormatProperties& props) {
 // Test vkGetPhysicalDeviceImageFormatProperties2KHR where nothing supports it.
 TEST(LoaderInstPhysDevExts, PhysDevImageFormatProps2KHRNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -873,7 +873,7 @@ TEST(LoaderInstPhysDevExts, PhysDevImageFormatProps2KHRNoSupport) {
 // Test vkGetPhysicalDeviceImageFormatProperties2KHR where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, PhysDevImageFormatPropsKHRNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -888,7 +888,7 @@ TEST(LoaderInstPhysDevExts, PhysDevImageFormatPropsKHRNoICDSupport) {
 // Test vkGetPhysicalDeviceImageFormatProperties2KHR where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, PhysDevImageFormatProps2KHRInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     FillInRandomImageFormatData(env.get_test_icd(0).physical_devices.back().image_format_properties);
@@ -936,7 +936,7 @@ TEST(LoaderInstPhysDevExts, PhysDevImageFormatProps2KHRInstanceAndICDSupport) {
 // also support, so everything should work and return properly.
 TEST(LoaderInstPhysDevExts, PhysDevImageFormatProps2Simple) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).icd_api_version = VK_API_VERSION_1_1;
     env.get_test_icd(0).add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
@@ -987,7 +987,7 @@ TEST(LoaderInstPhysDevExts, PhysDevImageFormatProps2Simple) {
 // and a device under that ICD also support, so everything should work and return properly.
 TEST(LoaderInstPhysDevExts, PhysDevImageFormatProps2KHRInstanceSupports11) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     env.get_test_icd(0).physical_devices.back().extensions.push_back({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 0});
@@ -1074,7 +1074,7 @@ TEST(LoaderInstPhysDevExts, PhysDevImageFormatPropsMixed) {
     const uint32_t max_phys_devs = 7;
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
 
         // ICD 1 should not have 1.1
@@ -1150,7 +1150,7 @@ TEST(LoaderInstPhysDevExts, PhysDevImageFormatPropsMixed) {
 // Test vkGetPhysicalDeviceMemoryProperties2KHR where nothing supports it.
 TEST(LoaderInstPhysDevExts, PhysDevMemoryProps2KHRNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -1164,7 +1164,7 @@ TEST(LoaderInstPhysDevExts, PhysDevMemoryProps2KHRNoSupport) {
 // Test vkGetPhysicalDeviceMemoryProperties2KHR where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, PhysDevMemoryPropsKHRNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -1209,7 +1209,7 @@ static bool CompareMemoryData(const VkPhysicalDeviceMemoryProperties& props1, co
 // Test vkGetPhysicalDeviceMemoryProperties2KHR where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, PhysDevMemoryProps2KHRInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     FillInRandomMemoryData(env.get_test_icd(0).physical_devices.back().memory_properties);
@@ -1239,7 +1239,7 @@ TEST(LoaderInstPhysDevExts, PhysDevMemoryProps2KHRInstanceAndICDSupport) {
 // also support, so everything should work and return properly.
 TEST(LoaderInstPhysDevExts, PhysDevMemoryProps2Simple) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).icd_api_version = VK_API_VERSION_1_1;
     env.get_test_icd(0).add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
@@ -1271,7 +1271,7 @@ TEST(LoaderInstPhysDevExts, PhysDevMemoryProps2Simple) {
 // extension but the instance supports 1.1 and the extension
 TEST(LoaderInstPhysDevExts, PhysDevMemoryProps2KHRInstanceSupports11) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     env.get_test_icd(0).physical_devices.back().extensions.push_back({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 0});
@@ -1331,7 +1331,7 @@ TEST(LoaderInstPhysDevExts, PhysDevMemoryPropsMixed) {
     const uint32_t max_phys_devs = 7;
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
 
         // ICD 1 should not have 1.1
@@ -1389,7 +1389,7 @@ TEST(LoaderInstPhysDevExts, PhysDevMemoryPropsMixed) {
 // Test vkGetPhysicalDeviceQueueFamilyProperties2KHR where nothing supports it.
 TEST(LoaderInstPhysDevExts, PhysDevQueueFamilyProps2KHRNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -1403,7 +1403,7 @@ TEST(LoaderInstPhysDevExts, PhysDevQueueFamilyProps2KHRNoSupport) {
 // Test vkGetPhysicalDeviceQueueFamilyProperties2KHR where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, PhysDevQueueFamilyPropsKHRNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -1452,7 +1452,7 @@ static bool CompareQueueFamilyData(const std::vector<VkQueueFamilyProperties>& p
 // Test vkGetPhysicalDeviceQueueFamilyProperties2KHR where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, PhysDevQueueFamilyProps2KHRInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     uint32_t num_fam = FillInRandomQueueFamilyData(env.get_test_icd(0).physical_devices.back().queue_family_properties);
@@ -1491,7 +1491,7 @@ TEST(LoaderInstPhysDevExts, PhysDevQueueFamilyProps2KHRInstanceAndICDSupport) {
 // also support, so everything should work and return properly.
 TEST(LoaderInstPhysDevExts, PhysDevQueueFamilyProps2Simple) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).icd_api_version = VK_API_VERSION_1_1;
     env.get_test_icd(0).add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
@@ -1532,7 +1532,7 @@ TEST(LoaderInstPhysDevExts, PhysDevQueueFamilyProps2Simple) {
 // extension but the instance supports 1.1 and the extension
 TEST(LoaderInstPhysDevExts, PhysDevQueueFamilyProps2KHRInstanceSupports11) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     env.get_test_icd(0).physical_devices.back().extensions.push_back({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 0});
@@ -1606,7 +1606,7 @@ TEST(LoaderInstPhysDevExts, PhysDevQueueFamilyPropsMixed) {
     const uint32_t max_phys_devs = 7;
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
 
         // ICD 1 should not have 1.1
@@ -1671,7 +1671,7 @@ TEST(LoaderInstPhysDevExts, PhysDevQueueFamilyPropsMixed) {
 // Test vkGetPhysicalDeviceSparseImageFormatProperties2KHR where nothing supports it.
 TEST(LoaderInstPhysDevExts, PhysDevSparseImageFormatProps2KHRNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -1685,7 +1685,7 @@ TEST(LoaderInstPhysDevExts, PhysDevSparseImageFormatProps2KHRNoSupport) {
 // Test vkGetPhysicalDeviceSparseImageFormatProperties2KHR where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, PhysDevSparseImageFormatPropsKHRNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -1726,7 +1726,7 @@ static bool CompareSparseImageFormatData(const std::vector<VkSparseImageFormatPr
 // Test vkGetPhysicalDeviceSparseImageFormatProperties2KHR where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, PhysDevSparseImageFormatProps2KHRInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     FillInRandomSparseImageFormatData(env.get_test_icd(0).physical_devices.back().sparse_image_format_properties);
@@ -1779,7 +1779,7 @@ TEST(LoaderInstPhysDevExts, PhysDevSparseImageFormatProps2KHRInstanceAndICDSuppo
 // also support, so everything should work and return properly.
 TEST(LoaderInstPhysDevExts, PhysDevSparseImageFormatProps2Simple) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).icd_api_version = VK_API_VERSION_1_1;
     env.get_test_icd(0).add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
@@ -1834,7 +1834,7 @@ TEST(LoaderInstPhysDevExts, PhysDevSparseImageFormatProps2Simple) {
 // supports extension but the instance supports 1.1 and the extension
 TEST(LoaderInstPhysDevExts, PhysDevSparseImageFormatProps2KHRInstanceSupports11) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     env.get_test_icd(0).physical_devices.back().extensions.push_back({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 0});
@@ -1923,7 +1923,7 @@ TEST(LoaderInstPhysDevExts, PhysDevSparseImageFormatPropsMixed) {
     const uint32_t max_phys_devs = 7;
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
 
         // ICD 1 should not have 1.1
@@ -2008,7 +2008,7 @@ TEST(LoaderInstPhysDevExts, PhysDevSparseImageFormatPropsMixed) {
 // Test vkGetPhysicalDeviceExternalBufferPropertiesKHR where nothing supports it.
 TEST(LoaderInstPhysDevExts, PhysDevExtBufPropsKHRNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -2022,7 +2022,7 @@ TEST(LoaderInstPhysDevExts, PhysDevExtBufPropsKHRNoSupport) {
 // Test vkGetPhysicalDeviceExternalBufferPropertiesKHR where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, PhysDevExtBufPropsKHRNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -2060,7 +2060,7 @@ static bool CompareExtMemoryData(const VkExternalMemoryProperties& props1, const
 // Test vkGetPhysicalDeviceExternalBufferPropertiesKHR where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, PhysDevExtBufProps2KHRInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).add_instance_extension({VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     FillInRandomExtMemoryData(env.get_test_icd(0).physical_devices.back().external_memory_properties);
@@ -2089,7 +2089,7 @@ TEST(LoaderInstPhysDevExts, PhysDevExtBufProps2KHRInstanceAndICDSupport) {
 // also support, so everything should work and return properly.
 TEST(LoaderInstPhysDevExts, PhysDevExtBufProps2Simple) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).icd_api_version = VK_API_VERSION_1_1;
     env.get_test_icd(0).add_instance_extension({VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
@@ -2136,7 +2136,7 @@ TEST(LoaderInstPhysDevExts, PhysDevExtBufPropsMixed) {
     const uint32_t max_phys_devs = 7;
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
 
         // ICD 1 should not have 1.1
@@ -2219,7 +2219,7 @@ TEST(LoaderInstPhysDevExts, PhysDevExtBufPropsMixed) {
 // Test vkGetPhysicalDeviceExternalSemaphorePropertiesKHR where nothing supports it.
 TEST(LoaderInstPhysDevExts, PhysDevExtSemPropsKHRNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -2233,7 +2233,7 @@ TEST(LoaderInstPhysDevExts, PhysDevExtSemPropsKHRNoSupport) {
 // Test vkGetPhysicalDeviceExternalSemaphorePropertiesKHR where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, PhysDevExtSemPropsKHRNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -2273,7 +2273,7 @@ static bool CompareExtSemaphoreData(const VkExternalSemaphoreProperties& props1,
 // Test vkGetPhysicalDeviceExternalSemaphorePropertiesKHR where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, PhysDevExtSemProps2KHRInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).add_instance_extension({VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     FillInRandomExtSemData(env.get_test_icd(0).physical_devices.back().external_semaphore_properties);
@@ -2301,7 +2301,7 @@ TEST(LoaderInstPhysDevExts, PhysDevExtSemProps2KHRInstanceAndICDSupport) {
 // also support, so everything should work and return properly.
 TEST(LoaderInstPhysDevExts, PhysDevExtSemProps2Simple) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).icd_api_version = VK_API_VERSION_1_1;
     env.get_test_icd(0).add_instance_extension({VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
@@ -2347,7 +2347,7 @@ TEST(LoaderInstPhysDevExts, PhysDevExtSemPropsMixed) {
     const uint32_t max_phys_devs = 7;
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
 
         // ICD 1 should not have 1.1
@@ -2430,7 +2430,7 @@ TEST(LoaderInstPhysDevExts, PhysDevExtSemPropsMixed) {
 // Test vkGetPhysicalDeviceExternalFencePropertiesKHR where nothing supports it.
 TEST(LoaderInstPhysDevExts, PhysDevExtFencePropsKHRNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -2444,7 +2444,7 @@ TEST(LoaderInstPhysDevExts, PhysDevExtFencePropsKHRNoSupport) {
 // Test vkGetPhysicalDeviceExternalFencePropertiesKHR where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, PhysDevExtFencePropsKHRNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -2484,7 +2484,7 @@ static bool CompareExtFenceData(const VkExternalFenceProperties& props1, const V
 // Test vkGetPhysicalDeviceExternalFencePropertiesKHR where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, PhysDevExtFenceProps2KHRInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).add_instance_extension({VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     FillInRandomExtFenceData(env.get_test_icd(0).physical_devices.back().external_fence_properties);
@@ -2512,7 +2512,7 @@ TEST(LoaderInstPhysDevExts, PhysDevExtFenceProps2KHRInstanceAndICDSupport) {
 // also support, so everything should work and return properly.
 TEST(LoaderInstPhysDevExts, PhysDevExtFenceProps2Simple) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).icd_api_version = VK_API_VERSION_1_1;
     env.get_test_icd(0).add_instance_extension({VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
@@ -2558,7 +2558,7 @@ TEST(LoaderInstPhysDevExts, PhysDevExtFencePropsMixed) {
     const uint32_t max_phys_devs = 7;
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
 
         // ICD 1 should not have 1.1
@@ -2641,7 +2641,7 @@ TEST(LoaderInstPhysDevExts, PhysDevExtFencePropsMixed) {
 // Test vkGetPhysicalDeviceSurfaceCapabilities2KHR where nothing supports it.
 TEST(LoaderInstPhysDevExts, PhysDevSurfaceCaps2KHRNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -2655,7 +2655,7 @@ TEST(LoaderInstPhysDevExts, PhysDevSurfaceCaps2KHRNoSupport) {
 // Test vkGetPhysicalDeviceSurfaceCapabilities2KHR where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, PhysDevSurfaceCaps2KHRNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -2723,7 +2723,7 @@ static bool CompareSurfaceCapsData(const VkSurfaceCapabilitiesKHR& props1, const
 // Test vkGetPhysicalDeviceSurfaceCapabilities2KHR where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, PhysDevSurfaceCaps2KHRInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     Extension first_ext{VK_KHR_SURFACE_EXTENSION_NAME};
     Extension second_ext{VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME};
     Extension third_ext{VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME};
@@ -2795,7 +2795,7 @@ TEST(LoaderInstPhysDevExts, PhysDevSurfaceCaps2KHRMixed) {
     Extension third_ext{VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME};
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
         cur_icd.icd_api_version = VK_API_VERSION_1_0;
         cur_icd.min_icd_interface_version = 3;
@@ -2874,7 +2874,7 @@ TEST(LoaderInstPhysDevExts, PhysDevSurfaceCaps2KHRMixed) {
 // Test vkGetPhysicalDeviceSurfaceFormats2KHR where nothing supports it.
 TEST(LoaderInstPhysDevExts, PhysDevSurfaceFormats2KHRNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -2888,7 +2888,7 @@ TEST(LoaderInstPhysDevExts, PhysDevSurfaceFormats2KHRNoSupport) {
 // Test vkGetPhysicalDeviceSurfaceFormats2KHR where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, PhysDevSurfaceFormats2KHRNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -2929,7 +2929,7 @@ static bool CompareSurfaceFormatsData(const std::vector<VkSurfaceFormatKHR>& pro
 // Test vkGetPhysicalDeviceSurfaceFormats2KHR where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, PhysDevSurfaceFormats2KHRInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     Extension first_ext{VK_KHR_SURFACE_EXTENSION_NAME};
     Extension second_ext{VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME};
     Extension third_ext{VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME};
@@ -3010,7 +3010,7 @@ TEST(LoaderInstPhysDevExts, PhysDevSurfaceFormats2KHRMixed) {
     Extension third_ext{VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME};
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
         cur_icd.icd_api_version = VK_API_VERSION_1_0;
         cur_icd.enable_icd_wsi = true;
@@ -3103,7 +3103,7 @@ TEST(LoaderInstPhysDevExts, PhysDevSurfaceFormats2KHRMixed) {
 // Test vkGetPhysicalDeviceDisplayPropertiesKHR where nothing supports it.
 TEST(LoaderInstPhysDevExts, PhysDevDispPropsKHRNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -3117,7 +3117,7 @@ TEST(LoaderInstPhysDevExts, PhysDevDispPropsKHRNoSupport) {
 // Test vkGetPhysicalDeviceDisplayPropertiesKHR where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, PhysDevDispPropsKHRNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -3171,7 +3171,7 @@ static bool CompareDisplayPropData(const std::vector<VkDisplayPropertiesKHR>& pr
 // Test vGetPhysicalDeviceDisplayPropertiesKHR where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, PhysDevDispPropsKHRInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).add_instance_extension({VK_KHR_DISPLAY_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     FillInRandomDisplayPropData(env.get_test_icd(0).physical_devices.back().display_properties);
@@ -3220,7 +3220,7 @@ TEST(LoaderInstPhysDevExts, PhysDevDispPropsKHRMixed) {
     const uint32_t max_phys_devs = 7;
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
         cur_icd.icd_api_version = VK_API_VERSION_1_0;
 
@@ -3308,7 +3308,7 @@ TEST(LoaderInstPhysDevExts, PhysDevDispPropsKHRMixed) {
 // Test vkGetPhysicalDeviceDisplayPlanePropertiesKHR where nothing supports it.
 TEST(LoaderInstPhysDevExts, PhysDevDispPlanePropsKHRNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -3322,7 +3322,7 @@ TEST(LoaderInstPhysDevExts, PhysDevDispPlanePropsKHRNoSupport) {
 // Test vkGetPhysicalDeviceDisplayPlanePropertiesKHR where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, PhysDevDispPlanePropsKHRNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -3358,7 +3358,7 @@ static bool CompareDisplayPlanePropData(const std::vector<VkDisplayPlaneProperti
 // Test vGetPhysicalDeviceDisplayPlanePropertiesKHR where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, PhysDevDispPlanePropsKHRInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).add_instance_extension({VK_KHR_DISPLAY_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     FillInRandomDisplayPlanePropData(env.get_test_icd(0).physical_devices.back().display_plane_properties);
@@ -3407,7 +3407,7 @@ TEST(LoaderInstPhysDevExts, PhysDevDispPlanePropsKHRMixed) {
     const uint32_t max_phys_devs = 7;
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
         cur_icd.icd_api_version = VK_API_VERSION_1_0;
 
@@ -3496,7 +3496,7 @@ TEST(LoaderInstPhysDevExts, PhysDevDispPlanePropsKHRMixed) {
 // Test vkGetDisplayPlaneSupportedDisplaysKHR where nothing supports it.
 TEST(LoaderInstPhysDevExts, GetDispPlaneSupDispsKHRNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -3510,7 +3510,7 @@ TEST(LoaderInstPhysDevExts, GetDispPlaneSupDispsKHRNoSupport) {
 // Test vkGetDisplayPlaneSupportedDisplaysKHR where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, GetDispPlaneSupDispsKHRNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -3543,7 +3543,7 @@ static bool CompareDisplays(const std::vector<VkDisplayKHR>& disps1, const std::
 // Test vGetDisplayPlaneSupportedDisplaysKHR where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, GetDispPlaneSupDispsKHRInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).add_instance_extension({VK_KHR_DISPLAY_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     GenerateRandomDisplays(env.get_test_icd(0).physical_devices.back().displays);
@@ -3592,7 +3592,7 @@ TEST(LoaderInstPhysDevExts, GetDispPlaneSupDispsKHRMixed) {
     const uint32_t max_phys_devs = 7;
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
         cur_icd.icd_api_version = VK_API_VERSION_1_0;
 
@@ -3681,7 +3681,7 @@ TEST(LoaderInstPhysDevExts, GetDispPlaneSupDispsKHRMixed) {
 // Test vkGetDisplayModePropertiesKHR where nothing supports it.
 TEST(LoaderInstPhysDevExts, GetDispModePropsKHRNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -3695,7 +3695,7 @@ TEST(LoaderInstPhysDevExts, GetDispModePropsKHRNoSupport) {
 // Test vkGetDisplayModePropertiesKHR where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, GetDispModePropsKHRNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -3735,7 +3735,7 @@ static bool CompareDisplayModeProps(const std::vector<VkDisplayModePropertiesKHR
 // Test vGetDisplayModePropertiesKHR where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, GetDispModePropsKHRInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).add_instance_extension({VK_KHR_DISPLAY_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     GenerateRandomDisplayModeProps(env.get_test_icd(0).physical_devices.back().display_mode_properties);
@@ -3784,7 +3784,7 @@ TEST(LoaderInstPhysDevExts, GetDispModePropsKHRMixed) {
     const uint32_t max_phys_devs = 7;
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
         cur_icd.icd_api_version = VK_API_VERSION_1_0;
 
@@ -3873,7 +3873,7 @@ TEST(LoaderInstPhysDevExts, GetDispModePropsKHRMixed) {
 // Test vkCreateDisplayModeKHR where nothing supports it.
 TEST(LoaderInstPhysDevExts, GetDispModesKHRNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -3887,7 +3887,7 @@ TEST(LoaderInstPhysDevExts, GetDispModesKHRNoSupport) {
 // Test vkCreateDisplayModeKHR where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, GetDispModesKHRNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -3905,7 +3905,7 @@ static bool CompareDisplayModes(const VkDisplayModeKHR& disps1, VkDisplayModeKHR
 // Test vkCreateDisplayModeKHR where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, GetDispModesKHRInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).add_instance_extension({VK_KHR_DISPLAY_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     env.get_test_icd(0).physical_devices.back().display_mode = CreateRandomDisplayMode();
@@ -3949,7 +3949,7 @@ TEST(LoaderInstPhysDevExts, GetDispModesKHRMixed) {
     const uint32_t max_phys_devs = 7;
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
         cur_icd.icd_api_version = VK_API_VERSION_1_0;
 
@@ -4033,7 +4033,7 @@ TEST(LoaderInstPhysDevExts, GetDispModesKHRMixed) {
 // Test vkGetDisplayPlaneCapabilitiesKHR where nothing supports it.
 TEST(LoaderInstPhysDevExts, GetDispPlaneCapsKHRNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -4047,7 +4047,7 @@ TEST(LoaderInstPhysDevExts, GetDispPlaneCapsKHRNoSupport) {
 // Test vkGetDisplayPlaneCapabilitiesKHR where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, GetDispPlaneCapsKHRNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -4127,7 +4127,7 @@ static bool CompareDisplayPlaneCaps(const VkDisplayPlaneCapabilitiesKHR& caps1,
 // Test vkGetDisplayPlaneCapabilitiesKHR where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, GetDispPlaneCapsKHRInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).add_instance_extension({VK_KHR_DISPLAY_EXTENSION_NAME});
     env.get_test_icd(0).physical_devices.push_back({});
     GenerateRandomDisplayPlaneCaps(env.get_test_icd(0).physical_devices.back().display_plane_capabilities);
@@ -4170,7 +4170,7 @@ TEST(LoaderInstPhysDevExts, GetDispPlaneCapsKHRMixed) {
     const uint32_t max_phys_devs = 7;
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
         cur_icd.icd_api_version = VK_API_VERSION_1_0;
 
@@ -4250,7 +4250,7 @@ TEST(LoaderInstPhysDevExts, GetDispPlaneCapsKHRMixed) {
 // Test vkGetPhysicalDeviceDisplayProperties2KHR where nothing supports it.
 TEST(LoaderInstPhysDevExts, PhysDevDispProps2KHRNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -4264,7 +4264,7 @@ TEST(LoaderInstPhysDevExts, PhysDevDispProps2KHRNoSupport) {
 // Test vkGetPhysicalDeviceDisplayProperties2KHR where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, PhysDevDispProps2KHRNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -4297,7 +4297,7 @@ static bool CompareDisplayPropData(const std::vector<VkDisplayPropertiesKHR>& pr
 // Test vGetPhysicalDeviceDisplayProperties2KHR where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, PhysDevDispProps2KHRInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     Extension first_ext{VK_KHR_DISPLAY_EXTENSION_NAME};
     Extension second_ext{VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME};
     env.get_test_icd(0).add_instance_extensions({first_ext, second_ext});
@@ -4358,7 +4358,7 @@ TEST(LoaderInstPhysDevExts, PhysDevDispProps2KHRMixed) {
     const uint32_t max_phys_devs = 7;
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
         cur_icd.icd_api_version = VK_API_VERSION_1_0;
         cur_icd.add_instance_extension({VK_KHR_DISPLAY_EXTENSION_NAME});
@@ -4430,7 +4430,7 @@ TEST(LoaderInstPhysDevExts, PhysDevDispProps2KHRMixed) {
 // Test vkGetPhysicalDeviceDisplayPlaneProperties2KHR where nothing supports it.
 TEST(LoaderInstPhysDevExts, PhysDevDispPlaneProps2KHRNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -4444,7 +4444,7 @@ TEST(LoaderInstPhysDevExts, PhysDevDispPlaneProps2KHRNoSupport) {
 // Test vkGetPhysicalDeviceDisplayPlaneProperties2KHR where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, PhysDevDispPlaneProps2KHRNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -4471,7 +4471,7 @@ static bool CompareDisplayPlanePropData(const std::vector<VkDisplayPlaneProperti
 // Test vGetPhysicalDeviceDisplayPlaneProperties2KHR where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, PhysDevDispPlaneProps2KHRInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     Extension first_ext{VK_KHR_DISPLAY_EXTENSION_NAME};
     Extension second_ext{VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME};
     env.get_test_icd(0).add_instance_extensions({first_ext, second_ext});
@@ -4531,7 +4531,7 @@ TEST(LoaderInstPhysDevExts, PhysDevDispPlaneProps2KHRMixed) {
     const uint32_t max_phys_devs = 7;
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
         cur_icd.icd_api_version = VK_API_VERSION_1_0;
         cur_icd.add_instance_extension({VK_KHR_DISPLAY_EXTENSION_NAME});
@@ -4602,7 +4602,7 @@ TEST(LoaderInstPhysDevExts, PhysDevDispPlaneProps2KHRMixed) {
 // Test vkGetDisplayModeProperties2KHR where nothing supports it.
 TEST(LoaderInstPhysDevExts, GetDispModeProps2KHRNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -4616,7 +4616,7 @@ TEST(LoaderInstPhysDevExts, GetDispModeProps2KHRNoSupport) {
 // Test vkGetDisplayModeProperties2KHR where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, GetDispModeProps2KHRNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -4647,7 +4647,7 @@ static bool CompareDisplayModeProps(const std::vector<VkDisplayModePropertiesKHR
 // Test vGetDisplayModeProperties2KHR where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, GetDispModeProps2KHRInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     Extension first_ext{VK_KHR_DISPLAY_EXTENSION_NAME};
     Extension second_ext{VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME};
     env.get_test_icd(0).add_instance_extensions({first_ext, second_ext});
@@ -4707,7 +4707,7 @@ TEST(LoaderInstPhysDevExts, GetDispModeProps2KHRMixed) {
     const uint32_t max_phys_devs = 7;
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
         cur_icd.icd_api_version = VK_API_VERSION_1_0;
         cur_icd.add_instance_extension({VK_KHR_DISPLAY_EXTENSION_NAME});
@@ -4778,7 +4778,7 @@ TEST(LoaderInstPhysDevExts, GetDispModeProps2KHRMixed) {
 // Test vkGetDisplayPlaneCapabilities2KHR where nothing supports it.
 TEST(LoaderInstPhysDevExts, GetDispPlaneCaps2KHRNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -4792,7 +4792,7 @@ TEST(LoaderInstPhysDevExts, GetDispPlaneCaps2KHRNoSupport) {
 // Test vkGetDisplayPlaneCapabilities2KHR where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, GetDispPlaneCaps2KHRNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -4830,7 +4830,7 @@ static bool CompareDisplayPlaneCaps(const VkDisplayPlaneCapabilitiesKHR& caps1,
 // Test vkGetDisplayPlaneCapabilities2KHR where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, GetDispPlaneCaps2KHRInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     Extension first_ext{VK_KHR_DISPLAY_EXTENSION_NAME};
     Extension second_ext{VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME};
     env.get_test_icd(0).add_instance_extensions({first_ext, second_ext});
@@ -4881,7 +4881,7 @@ TEST(LoaderInstPhysDevExts, GetDispPlaneCaps2KHRMixed) {
     const uint32_t max_phys_devs = 7;
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
         cur_icd.icd_api_version = VK_API_VERSION_1_0;
         cur_icd.add_instance_extension({VK_KHR_DISPLAY_EXTENSION_NAME});
@@ -4947,7 +4947,7 @@ TEST(LoaderInstPhysDevExts, GetDispPlaneCaps2KHRMixed) {
 // Test vkAcquireDrmDisplayEXT where nothing supports it.
 TEST(LoaderInstPhysDevExts, AcquireDrmDisplayEXTNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -4961,7 +4961,7 @@ TEST(LoaderInstPhysDevExts, AcquireDrmDisplayEXTNoSupport) {
 // Test vkAcquireDrmDisplayEXT where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, AcquireDrmDisplayEXTNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -4976,7 +4976,7 @@ TEST(LoaderInstPhysDevExts, AcquireDrmDisplayEXTNoICDSupport) {
 // Test vkAcquireDrmDisplayEXT where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, AcquireDrmDisplayEXTInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     Extension first_ext{VK_KHR_DISPLAY_EXTENSION_NAME};
     Extension second_ext{VK_EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME};
     env.get_test_icd(0).add_instance_extensions({first_ext, second_ext});
@@ -5020,7 +5020,7 @@ TEST(LoaderInstPhysDevExts, AcquireDrmDisplayEXTMixed) {
     const uint32_t max_phys_devs = 7;
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
         cur_icd.icd_api_version = VK_API_VERSION_1_0;
         cur_icd.add_instance_extension({VK_KHR_DISPLAY_EXTENSION_NAME});
@@ -5103,7 +5103,7 @@ TEST(LoaderInstPhysDevExts, AcquireDrmDisplayEXTMixed) {
 // Test vkGetDrmDisplayEXT where nothing supports it.
 TEST(LoaderInstPhysDevExts, GetDrmDisplayEXTNoSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -5117,7 +5117,7 @@ TEST(LoaderInstPhysDevExts, GetDrmDisplayEXTNoSupport) {
 // Test vkGetDrmDisplayEXT where instance supports it, but nothing else.
 TEST(LoaderInstPhysDevExts, GetDrmDisplayEXTNoICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd(0).physical_devices.push_back({});
 
     InstWrapper instance(env.vulkan_functions);
@@ -5132,7 +5132,7 @@ TEST(LoaderInstPhysDevExts, GetDrmDisplayEXTNoICDSupport) {
 // Test vkGetDrmDisplayEXT where instance and ICD supports it, but device does not support it.
 TEST(LoaderInstPhysDevExts, GetDrmDisplayEXTInstanceAndICDSupport) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     Extension first_ext{VK_KHR_DISPLAY_EXTENSION_NAME};
     Extension second_ext{VK_EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME};
     env.get_test_icd(0).add_instance_extensions({first_ext, second_ext});
@@ -5177,7 +5177,7 @@ TEST(LoaderInstPhysDevExts, GetDrmDisplayEXTMixed) {
     const uint32_t max_phys_devs = 7;
 
     for (uint32_t icd = 0; icd < max_icd_count; ++icd) {
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         auto& cur_icd = env.get_test_icd(icd);
         cur_icd.icd_api_version = VK_API_VERSION_1_0;
         cur_icd.add_instance_extension({VK_KHR_DISPLAY_EXTENSION_NAME});
diff --git a/tests/loader_regression_tests.cpp b/tests/loader_regression_tests.cpp
index 338923b44..c5bc2080e 100644
--- a/tests/loader_regression_tests.cpp
+++ b/tests/loader_regression_tests.cpp
@@ -2122,7 +2122,7 @@ TEST(EnumeratePhysicalDeviceGroups, FakePNext) {
     //   PhysDev 6: pd6, Discrete, Vulkan 1.1, Bus 2
     //   Group 0: PhysDev 5, PhysDev 6
     //   Group 1: PhysDev 4
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& cur_icd_0 = env.get_test_icd(0);
     cur_icd_0.set_icd_api_version(VK_API_VERSION_1_1);
     cur_icd_0.physical_devices.push_back({"pd0", 7});
@@ -2143,7 +2143,7 @@ TEST(EnumeratePhysicalDeviceGroups, FakePNext) {
         .use_physical_device(cur_icd_0.physical_devices[2]);
     cur_icd_0.physical_device_groups.push_back({cur_icd_0.physical_devices[1]});
 
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& cur_icd_1 = env.get_test_icd(1);
     cur_icd_1.set_icd_api_version(VK_API_VERSION_1_1);
     cur_icd_1.physical_devices.push_back({"pd4", 1});
@@ -2211,7 +2211,7 @@ TEST(ExtensionManual, ToolingProperties) {
                                                      "No-Layer"};
     {  // No support in driver
         FrameworkEnvironment env{};
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         env.get_test_icd().physical_devices.push_back({});
 
         InstWrapper inst{env.vulkan_functions};
@@ -2229,7 +2229,7 @@ TEST(ExtensionManual, ToolingProperties) {
     }
     {  // extension is supported in driver
         FrameworkEnvironment env{};
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         env.get_test_icd().physical_devices.push_back({});
         env.get_test_icd().supports_tooling_info_ext = true;
         env.get_test_icd().tooling_properties.push_back(icd_tool_props);
@@ -2253,7 +2253,7 @@ TEST(ExtensionManual, ToolingProperties) {
     }
     {  // core
         FrameworkEnvironment env{};
-        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
         env.get_test_icd().physical_devices.push_back({});
         env.get_test_icd().physical_devices.back().properties.apiVersion = VK_MAKE_API_VERSION(0, 1, 3, 0);
         env.get_test_icd().supports_tooling_info_core = true;
diff --git a/tests/loader_threading_tests.cpp b/tests/loader_threading_tests.cpp
index 9e5a5b226..946944c63 100644
--- a/tests/loader_threading_tests.cpp
+++ b/tests/loader_threading_tests.cpp
@@ -69,7 +69,7 @@ VKAPI_ATTR void VKAPI_CALL test_vkCmdDraw(VkCommandBuffer cmd_buf, uint32_t vert
                                           uint32_t firstVertex, uint32_t firstInstance) {}
 TEST(ThreadingTests, ConcurentGetDeviceProcAddr) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     uint32_t num_threads = 100;
     uint32_t num_loops_create_destroy_device = 10;
     uint32_t num_loops_try_get_proc_addr = 100;
diff --git a/tests/loader_unknown_ext_tests.cpp b/tests/loader_unknown_ext_tests.cpp
index 357892a66..492eec393 100644
--- a/tests/loader_unknown_ext_tests.cpp
+++ b/tests/loader_unknown_ext_tests.cpp
@@ -103,7 +103,7 @@ TEST(UnknownFunction, PhysicalDeviceFunction) {
     GTEST_SKIP() << "Skip this test as currently macOS doesn't fully support unknown functions.";
 #endif
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
     auto& driver = env.get_test_icd();
     std::vector<std::string> fake_function_names;
@@ -124,8 +124,8 @@ TEST(UnknownFunction, PhysicalDeviceFunctionMultipleDriverSupport) {
     GTEST_SKIP() << "Skip this test as currently macOS doesn't fully support unknown functions.";
 #endif
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& driver_0 = env.get_test_icd(0);
     auto& driver_1 = env.get_test_icd(1);
     std::vector<std::string> fake_function_names;
@@ -170,8 +170,8 @@ TEST(UnknownFunctionDeathTests, PhysicalDeviceFunctionErrorPath) {
     GTEST_SKIP() << "Skip this test as currently macOS doesn't fully support unknown functions.";
 #endif
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& driver_0 = env.get_test_icd(0);
     auto& driver_1 = env.get_test_icd(1);
     std::vector<std::string> fake_function_names;
@@ -210,7 +210,7 @@ TEST(UnknownFunction, PhysicalDeviceFunctionWithImplicitLayer) {
     GTEST_SKIP() << "Skip this test as currently macOS doesn't fully support unknown functions.";
 #endif
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
     auto& driver = env.get_test_icd();
     std::vector<std::string> fake_function_names;
@@ -238,8 +238,8 @@ TEST(UnknownFunction, PhysicalDeviceFunctionMultipleDriverSupportWithImplicitLay
     GTEST_SKIP() << "Skip this test as currently macOS doesn't fully support unknown functions.";
 #endif
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& driver_0 = env.get_test_icd(0);
     auto& driver_1 = env.get_test_icd(1);
     std::vector<std::string> fake_function_names;
@@ -289,7 +289,7 @@ TEST(UnknownFunction, PhysicalDeviceFunctionWithImplicitLayerInterception) {
     GTEST_SKIP() << "Skip this test as currently macOS doesn't fully support unknown functions.";
 #endif
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
     auto& driver = env.get_test_icd();
     std::vector<std::string> fake_function_names;
@@ -318,7 +318,7 @@ TEST(UnknownFunction, PhysicalDeviceFunctionWithMultipleImplicitLayersIntercepti
     GTEST_SKIP() << "Skip this test as currently macOS doesn't fully support unknown functions.";
 #endif
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     auto& driver = env.get_test_icd();
     std::vector<std::string> fake_function_names;
 
@@ -356,7 +356,7 @@ TEST(UnknownFunction, DeviceFunctionFromGetInstanceProcAddr) {
     GTEST_SKIP() << "Skip this test as currently macOS doesn't fully support unknown functions.";
 #endif
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
     auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
@@ -379,7 +379,7 @@ TEST(UnknownFunction, DeviceFunctionFromGetInstanceProcAddrWithImplicitLayer) {
     GTEST_SKIP() << "Skip this test as currently macOS doesn't fully support unknown functions.";
 #endif
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
     auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
@@ -404,7 +404,7 @@ TEST(UnknownFunction, DeviceFunctionFromGetInstanceProcAddrWithImplicitLayer) {
 
 TEST(UnknownFunction, DeviceFunctionFromGetDeviceProcAddr) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     uint32_t function_count = 1000;
     auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
@@ -422,7 +422,7 @@ TEST(UnknownFunction, DeviceFunctionFromGetDeviceProcAddr) {
 
 TEST(UnknownFunction, DeviceFunctionFromGetDeviceProcAddrWithImplicitLayer) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     uint32_t function_count = 1000;
     auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
@@ -447,7 +447,7 @@ using custom_command_buffer_functions = custom_functions<VkCommandBuffer>;
 
 TEST(UnknownFunction, CommandBufferFunctionFromGetDeviceProcAddr) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     uint32_t function_count = 1000;
     auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
@@ -479,7 +479,7 @@ TEST(UnknownFunction, CommandBufferFunctionFromGetDeviceProcAddr) {
 
 TEST(UnknownFunction, CommandBufferFunctionFromGetDeviceProcAddrWithImplicitLayer) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     uint32_t function_count = 1000;
     auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
@@ -519,7 +519,7 @@ TEST(UnknownFunction, CommandBufferFunctionFromGetInstanceProcAddr) {
     GTEST_SKIP() << "Skip this test as currently macOS doesn't fully support unknown functions.";
 #endif
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
     auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
@@ -553,7 +553,7 @@ TEST(UnknownFunction, CommandBufferFunctionFromGetInstanceProcAddrWithImplicitLa
     GTEST_SKIP() << "Skip this test as currently macOS doesn't fully support unknown functions.";
 #endif
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
     auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
@@ -592,7 +592,7 @@ using custom_queue_functions = custom_functions<VkQueue>;
 
 TEST(UnknownFunction, QueueFunctionFromGetDeviceProcAddr) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     uint32_t function_count = 1000;
     auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
@@ -615,7 +615,7 @@ TEST(UnknownFunction, QueueFunctionFromGetDeviceProcAddr) {
 
 TEST(UnknownFunction, QueueFunctionFromGetDeviceProcAddrWithImplicitLayer) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     uint32_t function_count = 1000;
     auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
@@ -647,7 +647,7 @@ TEST(UnknownFunction, QueueFunctionFromGetInstanceProcAddr) {
     GTEST_SKIP() << "Skip this test as currently macOS doesn't fully support unknown functions.";
 #endif
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
     auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
@@ -673,7 +673,7 @@ TEST(UnknownFunction, QueueFunctionFromGetInstanceProcAddrWithImplicitLayer) {
     GTEST_SKIP() << "Skip this test as currently macOS doesn't fully support unknown functions.";
 #endif
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
     auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
diff --git a/tests/loader_version_tests.cpp b/tests/loader_version_tests.cpp
index c602ff77a..99645e6a1 100644
--- a/tests/loader_version_tests.cpp
+++ b/tests/loader_version_tests.cpp
@@ -101,14 +101,11 @@ TEST(ICDInterfaceVersion2Plus, l5_icd5) {
     // normal.
 }
 
-// Need more work to shim dxgi for this test to work
 #if defined(WIN32)
-// Version 6 provides a mechanism to allow the loader to sort physical devices.
-// The loader will only attempt to sort physical devices on an ICD if version 6 of the interface is supported.
-// This version provides the vk_icdEnumerateAdapterPhysicalDevices function.
-TEST(ICDInterfaceVersion2Plus, version_5) {
+// This test makes sure that EnumerateAdapterPhysicalDevices on drivers found in the Khronos/Vulkan/Drivers registry
+TEST(ICDInterfaceVersion2PlusEnumerateAdapterPhysicalDevices, version_6_in_drivers_registry) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_ENUMERATE_ADAPTER_PHYSICAL_DEVICES));
     auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_1");
     driver.physical_devices.emplace_back("physical_device_0");
@@ -118,18 +115,25 @@ TEST(ICDInterfaceVersion2Plus, version_5) {
 
     driver.min_icd_interface_version = 5;
 
+    auto& known_driver = known_driver_list.at(2);  // which drive this test pretends to be
+    DXGI_ADAPTER_DESC1 desc1{};
+    desc1.AdapterLuid = _LUID{10, 1000};
+    desc1.VendorId = known_driver.vendor_id;
+    env.platform_shim->add_dxgi_adapter(GpuType::discrete, desc1);
+    driver.set_adapterLUID(desc1.AdapterLuid);
+
     InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     ASSERT_EQ(VK_SUCCESS,
               env.vulkan_functions.vkEnumeratePhysicalDevices(inst.inst, &returned_physical_count, physical_device_handles.data()));
     ASSERT_EQ(physical_count, returned_physical_count);
-    ASSERT_FALSE(driver.called_enumerate_adapter_physical_devices);
+    ASSERT_TRUE(driver.called_enumerate_adapter_physical_devices);
 }
+// Make the version_6 driver found through the D3DKMT driver discovery mechanism of the loader
 TEST(ICDInterfaceVersion2PlusEnumerateAdapterPhysicalDevices, version_6) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails{TEST_ICD_PATH_VERSION_2_EXPORT_ICD_ENUMERATE_ADAPTER_PHYSICAL_DEVICES, VK_API_VERSION_1_3}
-                    .set_add_manifest_to_default_driver_location(false));
+    env.add_icd(TestICDDetails{TEST_ICD_PATH_VERSION_6, VK_API_VERSION_1_3}.set_add_manifest_to_default_driver_location(false));
     // Version 6 provides a mechanism to allow the loader to sort physical devices.
     // The loader will only attempt to sort physical devices on an ICD if version 6 of the interface is supported.
     // This version provides the vk_icdEnumerateAdapterPhysicalDevices function.
@@ -178,10 +182,11 @@ TEST(ICDInterfaceVersion2PlusEnumerateAdapterPhysicalDevices, version_6) {
     }
 }
 
-TEST(ICDInterfaceVersion2PlusEnumerateAdapterPhysicalDevices, EnumAdapters2) {
+// Declare drivers using the D3DKMT driver interface and make sure the loader can find them - but don't export
+// EnumerateAdapterPhysicalDevices
+TEST(ICDInterfaceVersion2, EnumAdapters2) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails{TEST_ICD_PATH_VERSION_2_EXPORT_ICD_ENUMERATE_ADAPTER_PHYSICAL_DEVICES}
-                    .set_add_manifest_to_default_driver_location(false));
+    env.add_icd(TestICDDetails{TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA}.set_add_manifest_to_default_driver_location(false));
     InstWrapper inst{env.vulkan_functions};
     auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_1");
@@ -189,7 +194,7 @@ TEST(ICDInterfaceVersion2PlusEnumerateAdapterPhysicalDevices, EnumAdapters2) {
     uint32_t physical_count = static_cast<uint32_t>(driver.physical_devices.size());
     uint32_t returned_physical_count = static_cast<uint32_t>(driver.physical_devices.size());
     std::vector<VkPhysicalDevice> physical_device_handles = std::vector<VkPhysicalDevice>(physical_count);
-
+    driver.adapterLUID = _LUID{10, 1000};
     env.platform_shim->add_d3dkmt_adapter(D3DKMT_Adapter{0, _LUID{10, 1000}}.add_driver_manifest_path(env.get_icd_manifest_path()));
 
     inst.CheckCreate();
@@ -202,6 +207,8 @@ TEST(ICDInterfaceVersion2PlusEnumerateAdapterPhysicalDevices, EnumAdapters2) {
     ASSERT_FALSE(driver.called_enumerate_adapter_physical_devices);
 }
 
+// Make sure that physical devices are found through EnumerateAdapterPhysicalDevices
+// Verify that the handles are correct by calling vkGetPhysicalDeviceProperties with them
 TEST(ICDInterfaceVersion2PlusEnumerateAdapterPhysicalDevices, VerifyPhysDevResults) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails{TEST_ICD_PATH_VERSION_2_EXPORT_ICD_ENUMERATE_ADAPTER_PHYSICAL_DEVICES}
@@ -245,6 +252,7 @@ TEST(ICDInterfaceVersion2PlusEnumerateAdapterPhysicalDevices, VerifyPhysDevResul
     }
 }
 
+// Make sure physical device groups enumerated through EnumerateAdapterPhysicalDevices are properly found
 TEST(ICDInterfaceVersion2PlusEnumerateAdapterPhysicalDevices, VerifyGroupResults) {
     FrameworkEnvironment env{};
     env.add_icd(TestICDDetails{TEST_ICD_PATH_VERSION_2_EXPORT_ICD_ENUMERATE_ADAPTER_PHYSICAL_DEVICES}
@@ -443,7 +451,10 @@ TEST(MultipleDriverConfig, DifferentICDsWithDevicesAndGroups) {
     ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDeviceGroups(inst, &returned_group_count, group_props.data()));
     ASSERT_EQ(group_count, returned_group_count);
 }
+
 #if defined(WIN32)
+// This is testing when there are drivers that support the Windows device adapter sorting mechanism by exporting
+// EnumerateAdapterPhysicalDevices and drivers that do not expose that functionality
 TEST(MultipleICDConfig, version_5_and_version_6) {
     FrameworkEnvironment env;
 
@@ -455,37 +466,47 @@ TEST(MultipleICDConfig, version_5_and_version_6) {
                                                          .set_disable_environment("DisableMeIfYouCan")),
                            "regular_test_layer.json");
 
+    MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
+
     uint32_t physical_count = 0;
     for (uint32_t i = 0; i < 3; i++) {
         env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_ENUMERATE_ADAPTER_PHYSICAL_DEVICES));
         env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
         auto& driver_5 = env.get_test_icd(i * 2 + 1);
         driver_5.set_max_icd_interface_version(5);
+        driver_5.set_min_icd_interface_version(5);
+        setup_WSI_in_ICD(driver_5);
         driver_5.physical_devices.push_back({});
+        driver_5.physical_devices.back().queue_family_properties.push_back(family_props);
         driver_5.physical_devices.push_back({});
+        driver_5.physical_devices.back().queue_family_properties.push_back(family_props);
         driver_5.physical_devices.push_back({});
+        driver_5.physical_devices.back().queue_family_properties.push_back(family_props);
         physical_count += static_cast<uint32_t>(driver_5.physical_devices.size());
 
         auto& driver_6 = env.get_test_icd(i * 2);
+        setup_WSI_in_ICD(driver_6);
         driver_6.physical_devices.emplace_back("physical_device_0");
+        driver_6.physical_devices.back().queue_family_properties.push_back(family_props);
         driver_6.physical_devices.emplace_back("physical_device_1");
+        driver_6.physical_devices.back().queue_family_properties.push_back(family_props);
         physical_count += static_cast<uint32_t>(driver_6.physical_devices.size());
 
         driver_6.set_max_icd_interface_version(6);
+        driver_6.set_min_icd_interface_version(5);
 
         uint32_t driver_index = i % 4;  // which drive this test pretends to be, must stay below 4
         auto& known_driver = known_driver_list.at(driver_index);
         DXGI_ADAPTER_DESC1 desc1{};
-        std::wstring str = L"TestDriver" + std::to_wstring(2);
-        wcsncpy_s(&desc1.Description[0], 128, str.c_str(), 128);
         desc1.VendorId = known_driver.vendor_id;
         desc1.AdapterLuid = LUID{100 + i, static_cast<LONG>(100 + i)};
         driver_6.set_adapterLUID(desc1.AdapterLuid);
-        desc1.Flags = DXGI_ADAPTER_FLAG_NONE;
-        env.platform_shim->add_dxgi_adapter(GpuType::discrete, driver_index, desc1);
+        env.platform_shim->add_dxgi_adapter(GpuType::discrete, desc1);
+        env.get_test_icd().set_adapterLUID(desc1.AdapterLuid);
     }
     uint32_t returned_physical_count = 0;
     InstWrapper inst{env.vulkan_functions};
+    setup_WSI_in_create_instance(inst);
     inst.CheckCreate();
 
     ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumeratePhysicalDevices(inst.inst, &returned_physical_count, nullptr));
@@ -494,12 +515,19 @@ TEST(MultipleICDConfig, version_5_and_version_6) {
     ASSERT_EQ(VK_SUCCESS,
               env.vulkan_functions.vkEnumeratePhysicalDevices(inst.inst, &returned_physical_count, physical_device_handles.data()));
     ASSERT_EQ(physical_count, returned_physical_count);
+
+    VkSurfaceKHR surface = create_surface(inst);
+    for (const auto& handle : physical_device_handles) {
+        handle_assert_has_value(handle);
+
+        VkBool32 supported = false;
+        EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkGetPhysicalDeviceSurfaceSupportKHR(handle, 0, surface, &supported));
+    }
     for (uint32_t i = 0; i < 3; i++) {
         auto& driver_6 = env.get_test_icd(i * 2);
-        ASSERT_EQ(driver_6.called_enumerate_adapter_physical_devices, CalledEnumerateAdapterPhysicalDevices::called);
+        EXPECT_EQ(driver_6.called_enumerate_adapter_physical_devices, true);
     }
 }
-
 #endif  // defined(WIN32)
 
 // shim function pointers for 1.3
@@ -561,7 +589,7 @@ VkResult test_vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_
 
 TEST(MinorVersionUpdate, Version1_3) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().physical_devices.push_back({});
     auto& icd_phys_dev = env.get_test_icd().physical_devices.back();
     icd_phys_dev.known_device_functions.insert(
@@ -781,7 +809,7 @@ TEST(MinorVersionUpdate, Version1_3) {
 
 TEST(ApplicationInfoVersion, NonVulkanVariant) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().physical_devices.push_back({});
 
     DebugUtilsLogger log;
@@ -796,7 +824,7 @@ TEST(ApplicationInfoVersion, NonVulkanVariant) {
 
 TEST(DriverManifest, NonVulkanVariant) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6, VK_MAKE_API_VERSION(1, 1, 0, 0)));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(1, 1, 0, 0)));
     env.get_test_icd().physical_devices.push_back({});
 
     DebugUtilsLogger log;
@@ -811,7 +839,7 @@ TEST(DriverManifest, NonVulkanVariant) {
 
 TEST(LayerManifest, ImplicitNonVulkanVariant) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6, VK_MAKE_API_VERSION(0, 1, 0, 0)));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 0, 0)));
     env.get_test_icd().physical_devices.push_back({});
 
     const char* implicit_layer_name = "ImplicitTestLayer";
@@ -833,7 +861,7 @@ TEST(LayerManifest, ImplicitNonVulkanVariant) {
 
 TEST(LayerManifest, ExplicitNonVulkanVariant) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6, VK_MAKE_API_VERSION(0, 1, 0, 0)));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA, VK_MAKE_API_VERSION(0, 1, 0, 0)));
     env.get_test_icd().physical_devices.push_back({});
 
     const char* explicit_layer_name = "ExplicitTestLayer";
@@ -854,7 +882,8 @@ TEST(LayerManifest, ExplicitNonVulkanVariant) {
 
 TEST(DriverManifest, UnknownManifestVersion) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(ManifestICD{}.set_lib_path(TEST_ICD_PATH_VERSION_6).set_file_format_version({3, 2, 1})));
+    env.add_icd(
+        TestICDDetails(ManifestICD{}.set_lib_path(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA).set_file_format_version({3, 2, 1})));
     env.get_test_icd().physical_devices.push_back({});
 
     DebugUtilsLogger log;
@@ -869,7 +898,7 @@ TEST(DriverManifest, UnknownManifestVersion) {
 
 TEST(LayerManifest, UnknownManifestVersion) {
     FrameworkEnvironment env{};
-    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     env.get_test_icd().physical_devices.push_back({});
 
     const char* implicit_layer_name = "ImplicitTestLayer";