Replace TEST_F with TEST in most tests

Test fixturing (TEST_F) is useful when there is a lot of common code that needs
to be run for a suite of tests. However, the FrameworkEnvironment encapsulates
almost all of the setup work all tests needs, and so doesn't need to be in a
fixture. Making the add_icd call inside the tests makes it clear which binary
is being used.

This commit also uses the corrent signed/unsigned constants in tests, as was
warned by compilers when enhanced warnings were enabled (/W4 in msvc).

10 files changed, 2280 insertions, 1978 deletions

diff --git a/tests/loader_alloc_callback_tests.cpp b/tests/loader_alloc_callback_tests.cpp
index c16bfca6a..e48a1d18b 100644
--- a/tests/loader_alloc_callback_tests.cpp
+++ b/tests/loader_alloc_callback_tests.cpp
@@ -199,8 +199,8 @@ class MemoryTracker {
 class Allocation : public ::testing::Test {
    protected:
     virtual void SetUp() {
-        env = std::unique_ptr<FrameworkEnvironment>(new FrameworkEnvironment());
-        env->add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+        FrameworkEnvironment env{};
+        env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     }
 
     virtual void TearDown() { env.reset(); }
@@ -209,10 +209,13 @@ class Allocation : public ::testing::Test {
 
 // Test making sure the allocation functions are called to allocate and cleanup everything during
 // a CreateInstance/DestroyInstance call pair.
-TEST_F(Allocation, Instance) {
+TEST(Allocation, Instance) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
     MemoryTracker tracker;
     {
-        InstWrapper inst{env->vulkan_functions, tracker.get()};
+        InstWrapper inst{env.vulkan_functions, tracker.get()};
         inst.CheckCreate();
     }
     ASSERT_TRUE(tracker.empty());
@@ -220,10 +223,13 @@ TEST_F(Allocation, Instance) {
 
 // Test making sure the allocation functions are called to allocate and cleanup everything during
 // a CreateInstance/DestroyInstance call pair with a call to GetInstanceProcAddr.
-TEST_F(Allocation, GetInstanceProcAddr) {
+TEST(Allocation, GetInstanceProcAddr) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
     MemoryTracker tracker;
     {
-        InstWrapper inst{env->vulkan_functions, tracker.get()};
+        InstWrapper inst{env.vulkan_functions, tracker.get()};
         inst.CheckCreate();
 
         auto* pfnCreateDevice = inst->vkGetInstanceProcAddr(inst, "vkCreateDevice");
@@ -235,12 +241,15 @@ TEST_F(Allocation, GetInstanceProcAddr) {
 
 // Test making sure the allocation functions are called to allocate and cleanup everything during
 // a vkEnumeratePhysicalDevices call pair.
-TEST_F(Allocation, EnumeratePhysicalDevices) {
+TEST(Allocation, EnumeratePhysicalDevices) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
     MemoryTracker tracker;
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
     {
-        InstWrapper inst{env->vulkan_functions, tracker.get()};
+        InstWrapper inst{env.vulkan_functions, tracker.get()};
         inst.CheckCreate();
         uint32_t physical_count = 1;
         uint32_t returned_physical_count = 0;
@@ -257,13 +266,16 @@ TEST_F(Allocation, EnumeratePhysicalDevices) {
 // Test making sure the allocation functions are called to allocate and cleanup everything from
 // vkCreateInstance, to vkCreateDevicce, and then through their destructors.  With special
 // allocators used on both the instance and device.
-TEST_F(Allocation, InstanceAndDevice) {
+TEST(Allocation, InstanceAndDevice) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
     MemoryTracker tracker;
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices[0].add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false});
     {
-        InstWrapper inst{env->vulkan_functions, tracker.get()};
+        InstWrapper inst{env.vulkan_functions, tracker.get()};
         inst.CheckCreate();
 
         uint32_t physical_count = 1;
@@ -277,15 +289,15 @@ TEST_F(Allocation, InstanceAndDevice) {
 
         uint32_t family_count = 1;
         uint32_t returned_family_count = 0;
-        env->vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &returned_family_count, nullptr);
+        env.vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &returned_family_count, nullptr);
         ASSERT_EQ(returned_family_count, family_count);
 
         VkQueueFamilyProperties family;
-        env->vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &returned_family_count, &family);
+        env.vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &returned_family_count, &family);
         ASSERT_EQ(returned_family_count, family_count);
-        ASSERT_EQ(family.queueFlags, VK_QUEUE_GRAPHICS_BIT);
+        ASSERT_EQ(family.queueFlags, static_cast<VkQueueFlags>(VK_QUEUE_GRAPHICS_BIT));
         ASSERT_EQ(family.queueCount, family_count);
-        ASSERT_EQ(family.timestampValidBits, 0);
+        ASSERT_EQ(family.timestampValidBits, 0U);
 
         DeviceCreateInfo dev_create_info;
         DeviceQueueCreateInfo queue_info;
@@ -301,14 +313,17 @@ TEST_F(Allocation, InstanceAndDevice) {
 // Test making sure the allocation functions are called to allocate and cleanup everything from
 // vkCreateInstance, to vkCreateDevicce, and then through their destructors.  With special
 // allocators used on only the instance and not the device.
-TEST_F(Allocation, InstanceButNotDevice) {
+TEST(Allocation, InstanceButNotDevice) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
     MemoryTracker tracker;
     {
-        auto& driver = env->get_test_icd();
+        auto& driver = env.get_test_icd();
         driver.physical_devices.emplace_back("physical_device_0");
         driver.physical_devices[0].add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false});
 
-        InstWrapper inst{env->vulkan_functions, tracker.get()};
+        InstWrapper inst{env.vulkan_functions, tracker.get()};
         inst.CheckCreate();
 
         uint32_t physical_count = 1;
@@ -322,15 +337,15 @@ TEST_F(Allocation, InstanceButNotDevice) {
 
         uint32_t family_count = 1;
         uint32_t returned_family_count = 0;
-        env->vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &returned_family_count, nullptr);
+        env.vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &returned_family_count, nullptr);
         ASSERT_EQ(returned_family_count, family_count);
 
         VkQueueFamilyProperties family;
-        env->vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &returned_family_count, &family);
+        env.vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &returned_family_count, &family);
         ASSERT_EQ(returned_family_count, family_count);
-        ASSERT_EQ(family.queueFlags, VK_QUEUE_GRAPHICS_BIT);
+        ASSERT_EQ(family.queueFlags, static_cast<VkQueueFlags>(VK_QUEUE_GRAPHICS_BIT));
         ASSERT_EQ(family.queueCount, family_count);
-        ASSERT_EQ(family.timestampValidBits, 0);
+        ASSERT_EQ(family.timestampValidBits, 0U);
 
         DeviceCreateInfo dev_create_info;
         DeviceQueueCreateInfo queue_info;
@@ -347,14 +362,17 @@ TEST_F(Allocation, InstanceButNotDevice) {
 // Test making sure the allocation functions are called to allocate and cleanup everything from
 // vkCreateInstance, to vkCreateDevicce, and then through their destructors.  With special
 // allocators used on only the device and not the instance.
-TEST_F(Allocation, DeviceButNotInstance) {
+TEST(Allocation, DeviceButNotInstance) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
     MemoryTracker tracker;
     {
-        auto& driver = env->get_test_icd();
+        auto& driver = env.get_test_icd();
         driver.physical_devices.emplace_back("physical_device_0");
         driver.physical_devices[0].add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false});
 
-        InstWrapper inst{env->vulkan_functions};
+        InstWrapper inst{env.vulkan_functions};
         inst.CheckCreate();
 
         uint32_t physical_count = 1;
@@ -368,15 +386,15 @@ TEST_F(Allocation, DeviceButNotInstance) {
 
         uint32_t family_count = 1;
         uint32_t returned_family_count = 0;
-        env->vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &returned_family_count, nullptr);
+        env.vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &returned_family_count, nullptr);
         ASSERT_EQ(returned_family_count, family_count);
 
         VkQueueFamilyProperties family;
-        env->vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &returned_family_count, &family);
+        env.vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &returned_family_count, &family);
         ASSERT_EQ(returned_family_count, family_count);
-        ASSERT_EQ(family.queueFlags, VK_QUEUE_GRAPHICS_BIT);
+        ASSERT_EQ(family.queueFlags, static_cast<VkQueueFlags>(VK_QUEUE_GRAPHICS_BIT));
         ASSERT_EQ(family.queueCount, family_count);
-        ASSERT_EQ(family.timestampValidBits, 0);
+        ASSERT_EQ(family.timestampValidBits, 0U);
 
         DeviceCreateInfo dev_create_info;
         DeviceQueueCreateInfo queue_info;
@@ -392,7 +410,10 @@ TEST_F(Allocation, DeviceButNotInstance) {
 
 // Test failure during vkCreateInstance to make sure we don't leak memory if
 // one of the out-of-memory conditions trigger.
-TEST_F(Allocation, CreateInstanceIntentionalAllocFail) {
+TEST(Allocation, CreateInstanceIntentionalAllocFail) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
     size_t fail_index = 0;
     VkResult result = VK_ERROR_OUT_OF_HOST_MEMORY;
     while (result == VK_ERROR_OUT_OF_HOST_MEMORY && fail_index <= 10000) {
@@ -400,9 +421,9 @@ TEST_F(Allocation, CreateInstanceIntentionalAllocFail) {
 
         VkInstance instance;
         InstanceCreateInfo inst_create_info{};
-        result = env->vulkan_functions.vkCreateInstance(inst_create_info.get(), tracker.get(), &instance);
+        result = env.vulkan_functions.vkCreateInstance(inst_create_info.get(), tracker.get(), &instance);
         if (result == VK_SUCCESS) {
-            env->vulkan_functions.vkDestroyInstance(instance, tracker.get());
+            env.vulkan_functions.vkDestroyInstance(instance, tracker.get());
         }
         ASSERT_TRUE(tracker.empty());
         fail_index++;
@@ -413,14 +434,17 @@ TEST_F(Allocation, CreateInstanceIntentionalAllocFail) {
 // one of the out-of-memory conditions trigger.
 // Use 2 physical devices so that anything which copies a list of devices item by item
 // may fail.
-TEST_F(Allocation, CreateDeviceIntentionalAllocFail) {
-    auto& driver = env->get_test_icd();
+TEST(Allocation, CreateDeviceIntentionalAllocFail) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices[0].add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false});
     driver.physical_devices.emplace_back("physical_device_1");
     driver.physical_devices[1].add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false});
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     uint32_t physical_count = 2;
@@ -434,15 +458,15 @@ TEST_F(Allocation, CreateDeviceIntentionalAllocFail) {
 
     uint32_t family_count = 1;
     uint32_t returned_family_count = 0;
-    env->vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(physical_devices[0], &returned_family_count, nullptr);
+    env.vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(physical_devices[0], &returned_family_count, nullptr);
     ASSERT_EQ(returned_family_count, family_count);
 
     VkQueueFamilyProperties family;
-    env->vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(physical_devices[0], &returned_family_count, &family);
+    env.vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(physical_devices[0], &returned_family_count, &family);
     ASSERT_EQ(returned_family_count, family_count);
-    ASSERT_EQ(family.queueFlags, VK_QUEUE_GRAPHICS_BIT);
+    ASSERT_EQ(family.queueFlags, static_cast<VkQueueFlags>(VK_QUEUE_GRAPHICS_BIT));
     ASSERT_EQ(family.queueCount, family_count);
-    ASSERT_EQ(family.timestampValidBits, 0);
+    ASSERT_EQ(family.timestampValidBits, 0U);
 
     size_t fail_index = 0;
     VkResult result = VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -467,8 +491,11 @@ TEST_F(Allocation, CreateDeviceIntentionalAllocFail) {
 
 // Test failure during vkCreateInstance and vkCreateDevice to make sure we don't
 // leak memory if one of the out-of-memory conditions trigger.
-TEST_F(Allocation, CreateInstanceDeviceIntentionalAllocFail) {
-    auto& driver = env->get_test_icd();
+TEST(Allocation, CreateInstanceDeviceIntentionalAllocFail) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices[0].add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false});
 
@@ -480,7 +507,7 @@ TEST_F(Allocation, CreateInstanceDeviceIntentionalAllocFail) {
 
         VkInstance instance;
         InstanceCreateInfo inst_create_info{};
-        result = env->vulkan_functions.vkCreateInstance(inst_create_info.get(), tracker.get(), &instance);
+        result = env.vulkan_functions.vkCreateInstance(inst_create_info.get(), tracker.get(), &instance);
         if (result == VK_ERROR_OUT_OF_HOST_MEMORY) {
             ASSERT_TRUE(tracker.empty());
             continue;
@@ -488,18 +515,18 @@ TEST_F(Allocation, CreateInstanceDeviceIntentionalAllocFail) {
 
         uint32_t physical_count = 1;
         uint32_t returned_physical_count = 0;
-        result = env->vulkan_functions.vkEnumeratePhysicalDevices(instance, &returned_physical_count, nullptr);
+        result = env.vulkan_functions.vkEnumeratePhysicalDevices(instance, &returned_physical_count, nullptr);
         if (result == VK_ERROR_OUT_OF_HOST_MEMORY) {
-            env->vulkan_functions.vkDestroyInstance(instance, tracker.get());
+            env.vulkan_functions.vkDestroyInstance(instance, tracker.get());
             ASSERT_TRUE(tracker.empty());
             continue;
         }
         ASSERT_EQ(physical_count, returned_physical_count);
 
         VkPhysicalDevice physical_device;
-        result = env->vulkan_functions.vkEnumeratePhysicalDevices(instance, &returned_physical_count, &physical_device);
+        result = env.vulkan_functions.vkEnumeratePhysicalDevices(instance, &returned_physical_count, &physical_device);
         if (result == VK_ERROR_OUT_OF_HOST_MEMORY) {
-            env->vulkan_functions.vkDestroyInstance(instance, tracker.get());
+            env.vulkan_functions.vkDestroyInstance(instance, tracker.get());
             ASSERT_TRUE(tracker.empty());
             continue;
         }
@@ -507,15 +534,15 @@ TEST_F(Allocation, CreateInstanceDeviceIntentionalAllocFail) {
 
         uint32_t family_count = 1;
         uint32_t returned_family_count = 0;
-        env->vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &returned_family_count, nullptr);
+        env.vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &returned_family_count, nullptr);
         ASSERT_EQ(returned_family_count, family_count);
 
         VkQueueFamilyProperties family;
-        env->vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &returned_family_count, &family);
+        env.vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &returned_family_count, &family);
         ASSERT_EQ(returned_family_count, family_count);
-        ASSERT_EQ(family.queueFlags, VK_QUEUE_GRAPHICS_BIT);
+        ASSERT_EQ(family.queueFlags, static_cast<VkQueueFlags>(VK_QUEUE_GRAPHICS_BIT));
         ASSERT_EQ(family.queueCount, family_count);
-        ASSERT_EQ(family.timestampValidBits, 0);
+        ASSERT_EQ(family.timestampValidBits, 0U);
 
         DeviceCreateInfo dev_create_info;
         DeviceQueueCreateInfo queue_info;
@@ -523,11 +550,11 @@ TEST_F(Allocation, CreateInstanceDeviceIntentionalAllocFail) {
         dev_create_info.add_device_queue(queue_info);
 
         VkDevice device;
-        result = env->vulkan_functions.vkCreateDevice(physical_device, dev_create_info.get(), tracker.get(), &device);
+        result = env.vulkan_functions.vkCreateDevice(physical_device, dev_create_info.get(), tracker.get(), &device);
         if (result == VK_SUCCESS) {
-            env->vulkan_functions.vkDestroyDevice(device, tracker.get());
+            env.vulkan_functions.vkDestroyDevice(device, tracker.get());
         }
-        env->vulkan_functions.vkDestroyInstance(instance, tracker.get());
+        env.vulkan_functions.vkDestroyInstance(instance, tracker.get());
 
         ASSERT_TRUE(tracker.empty());
     }
@@ -559,7 +586,10 @@ TEST(TryLoadWrongBinaries, CreateInstanceIntentionalAllocFail) {
 
 // Test failure during vkCreateInstance and vkCreateDevice to make sure we don't
 // leak memory if one of the out-of-memory conditions trigger.
-TEST_F(Allocation, EnumeratePhysicalDevicesIntentionalAllocFail) {
+TEST(Allocation, EnumeratePhysicalDevicesIntentionalAllocFail) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
     size_t fail_index = 0;
     bool reached_the_end = false;
     uint32_t starting_physical_dev_count = 3;
@@ -567,7 +597,7 @@ TEST_F(Allocation, EnumeratePhysicalDevicesIntentionalAllocFail) {
         fail_index++;  // applies to the next loop
         uint32_t physical_dev_count = starting_physical_dev_count;
         VkResult result = VK_ERROR_OUT_OF_HOST_MEMORY;
-        auto& driver = env->reset_icd();
+        auto& driver = env.reset_icd();
 
         for (uint32_t i = 0; i < physical_dev_count; i++) {
             driver.physical_devices.emplace_back(std::string("physical_device_") + std::to_string(i));
@@ -576,16 +606,16 @@ TEST_F(Allocation, EnumeratePhysicalDevicesIntentionalAllocFail) {
         MemoryTracker tracker{MemoryTrackerSettings{false, 0, true, fail_index}};
         InstanceCreateInfo inst_create_info;
         VkInstance instance;
-        result = env->vulkan_functions.vkCreateInstance(inst_create_info.get(), tracker.get(), &instance);
+        result = env.vulkan_functions.vkCreateInstance(inst_create_info.get(), tracker.get(), &instance);
         if (result == VK_ERROR_OUT_OF_HOST_MEMORY) {
             ASSERT_TRUE(tracker.empty());
             continue;
         }
 
         uint32_t returned_physical_count = 0;
-        result = env->vulkan_functions.vkEnumeratePhysicalDevices(instance, &returned_physical_count, nullptr);
+        result = env.vulkan_functions.vkEnumeratePhysicalDevices(instance, &returned_physical_count, nullptr);
         if (result == VK_ERROR_OUT_OF_HOST_MEMORY) {
-            env->vulkan_functions.vkDestroyInstance(instance, tracker.get());
+            env.vulkan_functions.vkDestroyInstance(instance, tracker.get());
             ASSERT_TRUE(tracker.empty());
             continue;
         }
@@ -597,23 +627,23 @@ TEST_F(Allocation, EnumeratePhysicalDevicesIntentionalAllocFail) {
         }
 
         std::vector<VkPhysicalDevice> physical_devices{physical_dev_count, VK_NULL_HANDLE};
-        result = env->vulkan_functions.vkEnumeratePhysicalDevices(instance, &returned_physical_count, physical_devices.data());
+        result = env.vulkan_functions.vkEnumeratePhysicalDevices(instance, &returned_physical_count, physical_devices.data());
         if (result == VK_ERROR_OUT_OF_HOST_MEMORY) {
-            env->vulkan_functions.vkDestroyInstance(instance, tracker.get());
+            env.vulkan_functions.vkDestroyInstance(instance, tracker.get());
             ASSERT_TRUE(tracker.empty());
             continue;
         }
         if (result == VK_INCOMPLETE) {
-            result = env->vulkan_functions.vkEnumeratePhysicalDevices(instance, &returned_physical_count, nullptr);
+            result = env.vulkan_functions.vkEnumeratePhysicalDevices(instance, &returned_physical_count, nullptr);
             if (result == VK_ERROR_OUT_OF_HOST_MEMORY) {
-                env->vulkan_functions.vkDestroyInstance(instance, tracker.get());
+                env.vulkan_functions.vkDestroyInstance(instance, tracker.get());
                 ASSERT_TRUE(tracker.empty());
                 continue;
             }
             physical_devices.resize(returned_physical_count);
-            result = env->vulkan_functions.vkEnumeratePhysicalDevices(instance, &returned_physical_count, physical_devices.data());
+            result = env.vulkan_functions.vkEnumeratePhysicalDevices(instance, &returned_physical_count, physical_devices.data());
             if (result == VK_ERROR_OUT_OF_HOST_MEMORY) {
-                env->vulkan_functions.vkDestroyInstance(instance, tracker.get());
+                env.vulkan_functions.vkDestroyInstance(instance, tracker.get());
                 ASSERT_TRUE(tracker.empty());
                 continue;
             }
@@ -621,7 +651,7 @@ TEST_F(Allocation, EnumeratePhysicalDevicesIntentionalAllocFail) {
         ASSERT_EQ(physical_dev_count, returned_physical_count);
 
         std::cout << "fail count " << fail_index << "\n";
-        env->vulkan_functions.vkDestroyInstance(instance, tracker.get());
+        env.vulkan_functions.vkDestroyInstance(instance, tracker.get());
         ASSERT_TRUE(tracker.empty());
         reached_the_end = true;
     }
diff --git a/tests/loader_envvar_tests.cpp b/tests/loader_envvar_tests.cpp
index f15b5c443..bd7b513cb 100644
--- a/tests/loader_envvar_tests.cpp
+++ b/tests/loader_envvar_tests.cpp
@@ -104,7 +104,7 @@ TEST(EnvVarICDOverrideSetup, TestOnlyDriverEnvVar) {
     std::array<VkPhysicalDevice, 5> phys_devs_array;
     uint32_t phys_dev_count = 1;
     ASSERT_EQ(inst1->vkEnumeratePhysicalDevices(inst1.inst, &phys_dev_count, phys_devs_array.data()), VK_SUCCESS);
-    ASSERT_EQ(phys_dev_count, 1);
+    ASSERT_EQ(phys_dev_count, 1U);
 
     for (uint32_t add = 0; add < 2; ++add) {
         env.add_icd(TestICDDetails(TEST_ICD_PATH_EXPORT_NONE).set_use_env_var_icd_filenames(true));
@@ -120,7 +120,7 @@ TEST(EnvVarICDOverrideSetup, TestOnlyDriverEnvVar) {
 
     phys_dev_count = 5;
     ASSERT_EQ(inst2->vkEnumeratePhysicalDevices(inst2.inst, &phys_dev_count, phys_devs_array.data()), VK_SUCCESS);
-    ASSERT_EQ(phys_dev_count, 5);
+    ASSERT_EQ(phys_dev_count, 5U);
 
     env.debug_log.clear();
 
@@ -201,7 +201,7 @@ TEST(EnvVarICDOverrideSetup, TestOnlyAddDriverEnvVar) {
     std::array<VkPhysicalDevice, 1> phys_devs_array;
     uint32_t phys_dev_count = 1;
     ASSERT_EQ(inst1->vkEnumeratePhysicalDevices(inst1.inst, &phys_dev_count, phys_devs_array.data()), VK_SUCCESS);
-    ASSERT_EQ(phys_dev_count, 1);
+    ASSERT_EQ(phys_dev_count, 1U);
 
     env.platform_shim->set_elevated_privilege(true);
 
@@ -235,7 +235,7 @@ TEST(EnvVarICDOverrideSetup, TestBothDriverEnvVars) {
     std::array<VkPhysicalDevice, 3> phys_devs_array;
     uint32_t phys_dev_count = 3;
     ASSERT_EQ(inst->vkEnumeratePhysicalDevices(inst.inst, &phys_dev_count, phys_devs_array.data()), VK_SUCCESS);
-    ASSERT_EQ(phys_dev_count, 3);
+    ASSERT_EQ(phys_dev_count, 3U);
 
     remove_env_var("VK_DRIVER_FILES");
     remove_env_var("VK_ADD_DRIVER_FILES");
diff --git a/tests/loader_handle_validation_tests.cpp b/tests/loader_handle_validation_tests.cpp
index 56e79c7bd..a812a5b58 100644
--- a/tests/loader_handle_validation_tests.cpp
+++ b/tests/loader_handle_validation_tests.cpp
@@ -28,23 +28,15 @@
 
 #include "test_environment.h"
 
-class LoaderHandleValidTests : public ::testing::Test {
-   protected:
-    virtual void SetUp() {
-        env = std::unique_ptr<FrameworkEnvironment>(new FrameworkEnvironment());
-        env->add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    }
-    virtual void TearDown() { env.reset(); }
-    std::unique_ptr<FrameworkEnvironment> env;
-};
-
 // ---- Invalid Instance tests
 
-TEST_F(LoaderHandleValidTests, BadInstEnumPhysDevices) {
-    auto& driver = env->get_test_icd();
+TEST(LoaderHandleValidTests, BadInstEnumPhysDevices) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.CheckCreate();
 
     struct BadData {
@@ -53,15 +45,17 @@ TEST_F(LoaderHandleValidTests, BadInstEnumPhysDevices) {
     VkInstance bad_instance = (VkInstance)(&my_bad_data);
     uint32_t returned_physical_count = 0;
 
-    ASSERT_DEATH(env->vulkan_functions.vkEnumeratePhysicalDevices(bad_instance, &returned_physical_count, nullptr),
+    ASSERT_DEATH(env.vulkan_functions.vkEnumeratePhysicalDevices(bad_instance, &returned_physical_count, nullptr),
                  "vkEnumeratePhysicalDevices: Invalid instance \\[VUID-vkEnumeratePhysicalDevices-instance-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadInstGetInstProcAddr) {
-    auto& driver = env->get_test_icd();
+TEST(LoaderHandleValidTests, BadInstGetInstProcAddr) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.CheckCreate();
 
     struct BadData {
@@ -69,15 +63,17 @@ TEST_F(LoaderHandleValidTests, BadInstGetInstProcAddr) {
     } my_bad_data;
     VkInstance bad_instance = (VkInstance)(&my_bad_data);
 
-    ASSERT_DEATH(env->vulkan_functions.vkGetInstanceProcAddr(bad_instance, "vkGetBufferDeviceAddress"),
+    ASSERT_DEATH(env.vulkan_functions.vkGetInstanceProcAddr(bad_instance, "vkGetBufferDeviceAddress"),
                  "vkGetInstanceProcAddr: Invalid instance \\[VUID-vkGetInstanceProcAddr-instance-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadInstDestroyInstance) {
-    auto& driver = env->get_test_icd();
+TEST(LoaderHandleValidTests, BadInstDestroyInstance) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.CheckCreate();
 
     struct BadData {
@@ -85,18 +81,20 @@ TEST_F(LoaderHandleValidTests, BadInstDestroyInstance) {
     } my_bad_data;
     VkInstance bad_instance = (VkInstance)(&my_bad_data);
 
-    ASSERT_DEATH(env->vulkan_functions.vkDestroyInstance(bad_instance, nullptr),
+    ASSERT_DEATH(env.vulkan_functions.vkDestroyInstance(bad_instance, nullptr),
                  "vkDestroyInstance: Invalid instance \\[VUID-vkDestroyInstance-instance-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadInstDestroySurface) {
+TEST(LoaderHandleValidTests, BadInstDestroySurface) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_EXT_headless_surface"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.CheckCreate();
 
@@ -105,18 +103,20 @@ TEST_F(LoaderHandleValidTests, BadInstDestroySurface) {
     } my_bad_data;
     VkInstance bad_instance = (VkInstance)(&my_bad_data);
 
-    ASSERT_DEATH(env->vulkan_functions.vkDestroySurfaceKHR(bad_instance, VK_NULL_HANDLE, nullptr),
+    ASSERT_DEATH(env.vulkan_functions.vkDestroySurfaceKHR(bad_instance, VK_NULL_HANDLE, nullptr),
                  "vkDestroySurfaceKHR: Invalid instance \\[VUID-vkDestroySurfaceKHR-instance-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadInstCreateHeadlessSurf) {
+TEST(LoaderHandleValidTests, BadInstCreateHeadlessSurf) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_EXT_headless_surface"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_EXT_headless_surface");
     instance.CheckCreate();
@@ -130,18 +130,20 @@ TEST_F(LoaderHandleValidTests, BadInstCreateHeadlessSurf) {
     surf_create_info.sType = VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT;
     surf_create_info.pNext = nullptr;
     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
-    ASSERT_DEATH(env->vulkan_functions.vkCreateHeadlessSurfaceEXT(bad_instance, &surf_create_info, nullptr, &created_surface),
+    ASSERT_DEATH(env.vulkan_functions.vkCreateHeadlessSurfaceEXT(bad_instance, &surf_create_info, nullptr, &created_surface),
                  "vkCreateHeadlessSurfaceEXT: Invalid instance \\[VUID-vkCreateHeadlessSurfaceEXT-instance-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadInstCreateDisplayPlaneSurf) {
+TEST(LoaderHandleValidTests, BadInstCreateDisplayPlaneSurf) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_KHR_display"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_KHR_display");
     instance.CheckCreate();
@@ -155,19 +157,21 @@ TEST_F(LoaderHandleValidTests, BadInstCreateDisplayPlaneSurf) {
     surf_create_info.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
     surf_create_info.pNext = nullptr;
     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
-    ASSERT_DEATH(env->vulkan_functions.vkCreateDisplayPlaneSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
+    ASSERT_DEATH(env.vulkan_functions.vkCreateDisplayPlaneSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
                  "vkCreateDisplayPlaneSurfaceKHR: Invalid instance \\[VUID-vkCreateDisplayPlaneSurfaceKHR-instance-parameter\\]");
 }
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
-TEST_F(LoaderHandleValidTests, BadInstCreateAndroidSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_KHR_android_surface");
     instance.CheckCreate();
@@ -181,20 +185,22 @@ TEST_F(LoaderHandleValidTests, BadInstCreateAndroidSurf) {
     surf_create_info.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
     surf_create_info.pNext = nullptr;
     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
-    ASSERT_DEATH(env->vulkan_functions.vkCreateAndroidSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
+    ASSERT_DEATH(env.vulkan_functions.vkCreateAndroidSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
                  "vkCreateAndroidSurfaceKHR: Invalid instance \\[VUID-vkCreateAndroidSurfaceKHR-instance-parameter\\]");
 }
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
 
 #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
-TEST_F(LoaderHandleValidTests, BadInstCreateDirectFBSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_EXT_directfb_surface");
     instance.CheckCreate();
@@ -208,20 +214,22 @@ TEST_F(LoaderHandleValidTests, BadInstCreateDirectFBSurf) {
     surf_create_info.sType = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT;
     surf_create_info.pNext = nullptr;
     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
-    ASSERT_DEATH(env->vulkan_functions.vkCreateDirectFBSurfaceEXT(bad_instance, &surf_create_info, nullptr, &created_surface),
+    ASSERT_DEATH(env.vulkan_functions.vkCreateDirectFBSurfaceEXT(bad_instance, &surf_create_info, nullptr, &created_surface),
                  "vkCreateDirectFBSurfaceEXT: Invalid instance \\[VUID-vkCreateDirectFBSurfaceEXT-instance-parameter\\]");
 }
 #endif  // VK_USE_PLATFORM_DIRECTFB_EXT
 
 #ifdef VK_USE_PLATFORM_FUCHSIA
-TEST_F(LoaderHandleValidTests, BadInstCreateFuchsiaSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_FUCHSIA_imagepipe_surface");
     instance.CheckCreate();
@@ -235,20 +243,22 @@ TEST_F(LoaderHandleValidTests, BadInstCreateFuchsiaSurf) {
     surf_create_info.sType = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA;
     surf_create_info.pNext = nullptr;
     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
-    ASSERT_DEATH(env->vulkan_functions.vkCreateImagePipeSurfaceFUCHSIA(bad_instance, &surf_create_info, nullptr, &created_surface),
+    ASSERT_DEATH(env.vulkan_functions.vkCreateImagePipeSurfaceFUCHSIA(bad_instance, &surf_create_info, nullptr, &created_surface),
                  "vkCreateImagePipeSurfaceFUCHSIA: Invalid instance \\[VUID-vkCreateImagePipeSurfaceFUCHSIA-instance-parameter\\]");
 }
 #endif  // VK_USE_PLATFORM_FUCHSIA
 
 #ifdef VK_USE_PLATFORM_GGP
-TEST_F(LoaderHandleValidTests, BadInstCreateGGPSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_GGP_stream_descriptor_surface");
     instance.CheckCreate();
@@ -263,20 +273,22 @@ TEST_F(LoaderHandleValidTests, BadInstCreateGGPSurf) {
     surf_create_info.pNext = nullptr;
     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
     ASSERT_DEATH(
-        env->vulkan_functions.vkCreateStreamDescriptorSurfaceGGP(bad_instance, &surf_create_info, nullptr, &created_surface),
+        env.vulkan_functions.vkCreateStreamDescriptorSurfaceGGP(bad_instance, &surf_create_info, nullptr, &created_surface),
         "vkCreateStreamDescriptorSurfaceGGP: Invalid instance \\[VUID-vkCreateStreamDescriptorSurfaceGGP-instance-parameter\\]");
 }
 #endif  // VK_USE_PLATFORM_GGP
 
 #ifdef VK_USE_PLATFORM_IOS_MVK
-TEST_F(LoaderHandleValidTests, BadInstCreateIOSSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_MVK_ios_surface");
     instance.CheckCreate();
@@ -290,20 +302,22 @@ TEST_F(LoaderHandleValidTests, BadInstCreateIOSSurf) {
     surf_create_info.sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK;
     surf_create_info.pNext = nullptr;
     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
-    ASSERT_DEATH(env->vulkan_functions.vkCreateIOSSurfaceMVK(bad_instance, &surf_create_info, nullptr, &created_surface),
+    ASSERT_DEATH(env.vulkan_functions.vkCreateIOSSurfaceMVK(bad_instance, &surf_create_info, nullptr, &created_surface),
                  "vkCreateIOSSurfaceMVK: Invalid instance \\[VUID-vkCreateIOSSurfaceMVK-instance-parameter\\]");
 }
 #endif  // VK_USE_PLATFORM_IOS_MVK
 
 #ifdef VK_USE_PLATFORM_MACOS_MVK
-TEST_F(LoaderHandleValidTests, BadInstCreateMacOSSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_MVK_macos_surface");
     instance.CheckCreate();
@@ -317,20 +331,22 @@ TEST_F(LoaderHandleValidTests, BadInstCreateMacOSSurf) {
     surf_create_info.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
     surf_create_info.pNext = nullptr;
     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
-    ASSERT_DEATH(env->vulkan_functions.vkCreateMacOSSurfaceMVK(bad_instance, &surf_create_info, nullptr, &created_surface),
+    ASSERT_DEATH(env.vulkan_functions.vkCreateMacOSSurfaceMVK(bad_instance, &surf_create_info, nullptr, &created_surface),
                  "vkCreateMacOSSurfaceMVK: Invalid instance \\[VUID-vkCreateMacOSSurfaceMVK-instance-parameter\\]");
 }
 #endif  // VK_USE_PLATFORM_MACOS_MVK
 
 #if defined(VK_USE_PLATFORM_METAL_EXT)
-TEST_F(LoaderHandleValidTests, BadInstCreateMetalSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_EXT_metal_surface");
     instance.CheckCreate();
@@ -344,20 +360,22 @@ TEST_F(LoaderHandleValidTests, BadInstCreateMetalSurf) {
     surf_create_info.sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT;
     surf_create_info.pNext = nullptr;
     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
-    ASSERT_DEATH(env->vulkan_functions.vkCreateMetalSurfaceEXT(bad_instance, &surf_create_info, nullptr, &created_surface),
+    ASSERT_DEATH(env.vulkan_functions.vkCreateMetalSurfaceEXT(bad_instance, &surf_create_info, nullptr, &created_surface),
                  "vkCreateMetalSurfaceEXT: Invalid instance \\[VUID-vkCreateMetalSurfaceEXT-instance-parameter\\]");
 }
 #endif  // VK_USE_PLATFORM_METAL_EXT
 
 #ifdef VK_USE_PLATFORM_SCREEN_QNX
-TEST_F(LoaderHandleValidTests, BadInstCreateQNXSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_QNX_screen_surface");
     instance.CheckCreate();
@@ -371,21 +389,25 @@ TEST_F(LoaderHandleValidTests, BadInstCreateQNXSurf) {
     surf_create_info.sType = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX;
     surf_create_info.pNext = nullptr;
     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
-    ASSERT_DEATH(env->vulkan_functions.vkCreateScreenSurfaceQNX(bad_instance, &surf_create_info, nullptr, &created_surface),
+    ASSERT_DEATH(env.vulkan_functions.vkCreateScreenSurfaceQNX(bad_instance, &surf_create_info, nullptr, &created_surface),
                  "vkCreateScreenSurfaceQNX: Invalid instance \\[VUID-vkCreateScreenSurfaceQNX-instance-parameter\\]");
     // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
 }
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
 
 #ifdef VK_USE_PLATFORM_VI_NN
-TEST_F(LoaderHandleValidTests, BadInstCreateViNNSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_NN_vi_surface");
     instance.CheckCreate();
@@ -399,21 +421,23 @@ TEST_F(LoaderHandleValidTests, BadInstCreateViNNSurf) {
     surf_create_info.sType = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN;
     surf_create_info.pNext = nullptr;
     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
-    ASSERT_DEATH(env->vulkan_functions.vkCreateViSurfaceNN(bad_instance, &surf_create_info, nullptr, &created_surface),
+    ASSERT_DEATH(env.vulkan_functions.vkCreateViSurfaceNN(bad_instance, &surf_create_info, nullptr, &created_surface),
                  "vkCreateViSurfaceNN: Invalid instance \\[VUID-vkCreateViSurfaceNN-instance-parameter\\]");
     // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
 }
 #endif  // VK_USE_PLATFORM_VI_NN
 
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
-TEST_F(LoaderHandleValidTests, BadInstCreateWaylandSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_KHR_wayland_surface");
     instance.CheckCreate();
@@ -427,21 +451,23 @@ TEST_F(LoaderHandleValidTests, BadInstCreateWaylandSurf) {
     surf_create_info.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
     surf_create_info.pNext = nullptr;
     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
-    ASSERT_DEATH(env->vulkan_functions.vkCreateWaylandSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
+    ASSERT_DEATH(env.vulkan_functions.vkCreateWaylandSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
                  "vkCreateWaylandSurfaceKHR: Invalid instance \\[VUID-vkCreateWaylandSurfaceKHR-instance-parameter\\]");
     // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
 }
 #endif  // VK_USE_PLATFORM_WAYLAND_KHR
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-TEST_F(LoaderHandleValidTests, BadInstCreateWin32Surf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_KHR_win32_surface");
     instance.CheckCreate();
@@ -455,21 +481,23 @@ TEST_F(LoaderHandleValidTests, BadInstCreateWin32Surf) {
     surf_create_info.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
     surf_create_info.pNext = nullptr;
     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
-    ASSERT_DEATH(env->vulkan_functions.vkCreateWin32SurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
+    ASSERT_DEATH(env.vulkan_functions.vkCreateWin32SurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
                  "vkCreateWin32SurfaceKHR: Invalid instance \\[VUID-vkCreateWin32SurfaceKHR-instance-parameter\\]");
     // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
 }
 #endif  // VK_USE_PLATFORM_WIN32_KHR
 
 #ifdef VK_USE_PLATFORM_XCB_KHR
-TEST_F(LoaderHandleValidTests, BadInstCreateXCBSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_KHR_xcb_surface");
     instance.CheckCreate();
@@ -483,21 +511,23 @@ TEST_F(LoaderHandleValidTests, BadInstCreateXCBSurf) {
     surf_create_info.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
     surf_create_info.pNext = nullptr;
     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
-    ASSERT_DEATH(env->vulkan_functions.vkCreateXcbSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
+    ASSERT_DEATH(env.vulkan_functions.vkCreateXcbSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
                  "vkCreateXcbSurfaceKHR: Invalid instance \\[VUID-vkCreateXcbSurfaceKHR-instance-parameter\\]");
     // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
 }
 #endif  // VK_USE_PLATFORM_XCB_KHR
 
 #ifdef VK_USE_PLATFORM_XLIB_KHR
-TEST_F(LoaderHandleValidTests, BadInstCreateXlibSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_KHR_xlib_surface");
     instance.CheckCreate();
@@ -511,7 +541,7 @@ TEST_F(LoaderHandleValidTests, BadInstCreateXlibSurf) {
     surf_create_info.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
     surf_create_info.pNext = nullptr;
     VkSurfaceKHR created_surface = VK_NULL_HANDLE;
-    ASSERT_DEATH(env->vulkan_functions.vkCreateXlibSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
+    ASSERT_DEATH(env.vulkan_functions.vkCreateXlibSurfaceKHR(bad_instance, &surf_create_info, nullptr, &created_surface),
                  "vkCreateXlibSurfaceKHR: Invalid instance \\[VUID-vkCreateXlibSurfaceKHR-instance-parameter\\]");
     // TODO: Look for "invalid instance" in stderr log to make sure correct error is thrown
 }
@@ -519,11 +549,13 @@ TEST_F(LoaderHandleValidTests, BadInstCreateXlibSurf) {
 
 // ---- Invalid Physical Device tests
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevFeature) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFeature) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
@@ -534,15 +566,17 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevFeature) {
 
     VkPhysicalDeviceFeatures features = {};
     ASSERT_DEATH(
-        env->vulkan_functions.vkGetPhysicalDeviceFeatures(bad_physical_dev, &features),
+        env.vulkan_functions.vkGetPhysicalDeviceFeatures(bad_physical_dev, &features),
         "vkGetPhysicalDeviceFeatures: Invalid physicalDevice \\[VUID-vkGetPhysicalDeviceFeatures-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevFormatProps) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFormatProps) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
@@ -552,17 +586,18 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevFormatProps) {
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
 
     VkFormatProperties format_info = {};
-    ASSERT_DEATH(
-        env->vulkan_functions.vkGetPhysicalDeviceFormatProperties(bad_physical_dev, VK_FORMAT_R8G8B8A8_UNORM, &format_info),
-        "vkGetPhysicalDeviceFormatProperties: Invalid physicalDevice "
-        "\\[VUID-vkGetPhysicalDeviceFormatProperties-physicalDevice-parameter\\]");
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceFormatProperties(bad_physical_dev, VK_FORMAT_R8G8B8A8_UNORM, &format_info),
+                 "vkGetPhysicalDeviceFormatProperties: Invalid physicalDevice "
+                 "\\[VUID-vkGetPhysicalDeviceFormatProperties-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevImgFormatProps) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevImgFormatProps) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
@@ -572,18 +607,20 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevImgFormatProps) {
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
 
     VkImageFormatProperties format_info = {};
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceImageFormatProperties(bad_physical_dev, VK_FORMAT_R8G8B8A8_UNORM,
-                                                                                VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_LINEAR,
-                                                                                VK_IMAGE_USAGE_STORAGE_BIT, 0, &format_info),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceImageFormatProperties(bad_physical_dev, VK_FORMAT_R8G8B8A8_UNORM,
+                                                                               VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_LINEAR,
+                                                                               VK_IMAGE_USAGE_STORAGE_BIT, 0, &format_info),
                  "vkGetPhysicalDeviceImageFormatProperties: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceImageFormatProperties-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevProps) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevProps) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
@@ -594,15 +631,17 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevProps) {
 
     VkPhysicalDeviceProperties properties = {};
     ASSERT_DEATH(
-        env->vulkan_functions.vkGetPhysicalDeviceProperties(bad_physical_dev, &properties),
+        env.vulkan_functions.vkGetPhysicalDeviceProperties(bad_physical_dev, &properties),
         "vkGetPhysicalDeviceProperties: Invalid physicalDevice \\[VUID-vkGetPhysicalDeviceProperties-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamProps) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamProps) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
@@ -611,16 +650,18 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamProps) {
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     uint32_t count = 0;
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(bad_physical_dev, &count, nullptr),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties(bad_physical_dev, &count, nullptr),
                  "vkGetPhysicalDeviceQueueFamilyProperties: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceQueueFamilyProperties-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevDevMemProps) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDevMemProps) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
@@ -630,16 +671,18 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevDevMemProps) {
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
 
     VkPhysicalDeviceMemoryProperties properties = {};
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceMemoryProperties(bad_physical_dev, &properties),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceMemoryProperties(bad_physical_dev, &properties),
                  "vkGetPhysicalDeviceMemoryProperties: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceMemoryProperties-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevCreateDevice) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+TEST(LoaderHandleValidTests, BadPhysDevCreateDevice) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
@@ -668,15 +711,17 @@ TEST_F(LoaderHandleValidTests, BadPhysDevCreateDevice) {
     dev_create_info.ppEnabledExtensionNames = nullptr;
     dev_create_info.pEnabledFeatures = nullptr;
     VkDevice created_dev = VK_NULL_HANDLE;
-    ASSERT_DEATH(env->vulkan_functions.vkCreateDevice(bad_physical_dev, &dev_create_info, nullptr, &created_dev),
+    ASSERT_DEATH(env.vulkan_functions.vkCreateDevice(bad_physical_dev, &dev_create_info, nullptr, &created_dev),
                  "vkCreateDevice: Invalid physicalDevice \\[VUID-vkCreateDevice-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevEnumDevExtProps) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+TEST(LoaderHandleValidTests, BadPhysDevEnumDevExtProps) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
@@ -685,16 +730,18 @@ TEST_F(LoaderHandleValidTests, BadPhysDevEnumDevExtProps) {
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     uint32_t count = 0;
-    ASSERT_DEATH(env->vulkan_functions.vkEnumerateDeviceExtensionProperties(bad_physical_dev, nullptr, &count, nullptr),
+    ASSERT_DEATH(env.vulkan_functions.vkEnumerateDeviceExtensionProperties(bad_physical_dev, nullptr, &count, nullptr),
                  "vkEnumerateDeviceExtensionProperties: Invalid physicalDevice "
                  "\\[VUID-vkEnumerateDeviceExtensionProperties-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevEnumDevLayerProps) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+TEST(LoaderHandleValidTests, BadPhysDevEnumDevLayerProps) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
@@ -703,16 +750,18 @@ TEST_F(LoaderHandleValidTests, BadPhysDevEnumDevLayerProps) {
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     uint32_t count = 0;
-    ASSERT_DEATH(env->vulkan_functions.vkEnumerateDeviceLayerProperties(bad_physical_dev, &count, nullptr),
+    ASSERT_DEATH(env.vulkan_functions.vkEnumerateDeviceLayerProperties(bad_physical_dev, &count, nullptr),
                  "vkEnumerateDeviceLayerProperties: Invalid physicalDevice "
                  "\\[VUID-vkEnumerateDeviceLayerProperties-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevSparseImgFormatProps) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSparseImgFormatProps) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
@@ -722,18 +771,20 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevSparseImgFormatProps) {
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
 
     uint32_t count = 0;
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceSparseImageFormatProperties(
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSparseImageFormatProperties(
                      bad_physical_dev, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_TYPE_2D, VK_SAMPLE_COUNT_1_BIT,
                      VK_IMAGE_USAGE_STORAGE_BIT, VK_IMAGE_TILING_LINEAR, &count, nullptr),
                  "vkGetPhysicalDeviceSparseImageFormatProperties: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceSparseImageFormatProperties-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevFeature2) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFeature2) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
@@ -746,15 +797,17 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevFeature2) {
     features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
     features.pNext = nullptr;
     ASSERT_DEATH(
-        env->vulkan_functions.vkGetPhysicalDeviceFeatures2(bad_physical_dev, &features),
+        env.vulkan_functions.vkGetPhysicalDeviceFeatures2(bad_physical_dev, &features),
         "vkGetPhysicalDeviceFeatures2: Invalid physicalDevice \\[VUID-vkGetPhysicalDeviceFeatures2-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevFormatProps2) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFormatProps2) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
@@ -766,17 +819,18 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevFormatProps2) {
     VkFormatProperties2 properties = {};
     properties.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
     properties.pNext = nullptr;
-    ASSERT_DEATH(
-        env->vulkan_functions.vkGetPhysicalDeviceFormatProperties2(bad_physical_dev, VK_FORMAT_R8G8B8A8_UNORM, &properties),
-        "vkGetPhysicalDeviceFormatProperties2: Invalid physicalDevice "
-        "\\[VUID-vkGetPhysicalDeviceFormatProperties2-physicalDevice-parameter\\]");
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceFormatProperties2(bad_physical_dev, VK_FORMAT_R8G8B8A8_UNORM, &properties),
+                 "vkGetPhysicalDeviceFormatProperties2: Invalid physicalDevice "
+                 "\\[VUID-vkGetPhysicalDeviceFormatProperties2-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevImgFormatProps2) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevImgFormatProps2) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
@@ -791,16 +845,18 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevImgFormatProps2) {
     VkImageFormatProperties2 properties = {};
     properties.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
     properties.pNext = nullptr;
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceImageFormatProperties2(bad_physical_dev, &format_info, &properties),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceImageFormatProperties2(bad_physical_dev, &format_info, &properties),
                  "vkGetPhysicalDeviceImageFormatProperties2: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceImageFormatProperties2-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevProps2) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevProps2) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
@@ -812,16 +868,18 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevProps2) {
     VkPhysicalDeviceProperties2 properties = {};
     properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
     properties.pNext = nullptr;
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceProperties2(bad_physical_dev, &properties),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceProperties2(bad_physical_dev, &properties),
                  "vkGetPhysicalDeviceProperties2: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceProperties2-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamProps2) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamProps2) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
@@ -830,16 +888,18 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamProps2) {
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     uint32_t count = 0;
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties2(bad_physical_dev, &count, nullptr),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceQueueFamilyProperties2(bad_physical_dev, &count, nullptr),
                  "vkGetPhysicalDeviceQueueFamilyProperties2: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceQueueFamilyProperties2-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevDevMemProps2) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDevMemProps2) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
@@ -851,16 +911,18 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevDevMemProps2) {
     VkPhysicalDeviceMemoryProperties2 properties = {};
     properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
     properties.pNext = nullptr;
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceMemoryProperties2(bad_physical_dev, &properties),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceMemoryProperties2(bad_physical_dev, &properties),
                  "vkGetPhysicalDeviceMemoryProperties2: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceMemoryProperties2-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevSparseImgFormatProps2) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSparseImgFormatProps2) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
@@ -873,16 +935,18 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevSparseImgFormatProps2) {
     info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2;
     info.pNext = nullptr;
     uint32_t count = 0;
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceSparseImageFormatProperties2(bad_physical_dev, &info, &count, nullptr),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSparseImageFormatProperties2(bad_physical_dev, &info, &count, nullptr),
                  "vkGetPhysicalDeviceSparseImageFormatProperties2: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceSparseImageFormatProperties2-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevExternFenceProps) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevExternFenceProps) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
@@ -895,16 +959,18 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevExternFenceProps) {
     info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO;
     info.pNext = nullptr;
     VkExternalFenceProperties props = {};
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceExternalFenceProperties(bad_physical_dev, &info, &props),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceExternalFenceProperties(bad_physical_dev, &info, &props),
                  "vkGetPhysicalDeviceExternalFenceProperties: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceExternalFenceProperties-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevExternBufferProps) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevExternBufferProps) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
@@ -917,16 +983,18 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevExternBufferProps) {
     info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO;
     info.pNext = nullptr;
     VkExternalBufferProperties props = {};
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceExternalBufferProperties(bad_physical_dev, &info, &props),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceExternalBufferProperties(bad_physical_dev, &info, &props),
                  "vkGetPhysicalDeviceExternalBufferProperties: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceExternalBufferProperties-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevExternSemaphoreProps) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevExternSemaphoreProps) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.set_api_version(1, 1, 0);
     instance.CheckCreate();
 
@@ -939,19 +1007,21 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevExternSemaphoreProps) {
     info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO;
     info.pNext = nullptr;
     VkExternalSemaphoreProperties props = {};
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceExternalSemaphoreProperties(bad_physical_dev, &info, &props),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceExternalSemaphoreProperties(bad_physical_dev, &info, &props),
                  "vkGetPhysicalDeviceExternalSemaphoreProperties: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceSupportKHR) {
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceSupportKHR) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_EXT_headless_surface"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.CheckCreate();
 
@@ -961,19 +1031,21 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceSupportKHR) {
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     VkBool32 supported = VK_FALSE;
 
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceSurfaceSupportKHR(bad_physical_dev, 0, VK_NULL_HANDLE, &supported),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfaceSupportKHR(bad_physical_dev, 0, VK_NULL_HANDLE, &supported),
                  "vkGetPhysicalDeviceSurfaceSupportKHR: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceSurfaceSupportKHR-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceCapsKHR) {
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceCapsKHR) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_EXT_headless_surface"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.CheckCreate();
 
@@ -982,19 +1054,21 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceCapsKHR) {
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     VkSurfaceCapabilitiesKHR caps = {};
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(bad_physical_dev, VK_NULL_HANDLE, &caps),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(bad_physical_dev, VK_NULL_HANDLE, &caps),
                  "vkGetPhysicalDeviceSurfaceCapabilitiesKHR: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceSurfaceCapabilitiesKHR-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceFormatsKHR) {
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceFormatsKHR) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_EXT_headless_surface"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.CheckCreate();
 
@@ -1003,19 +1077,21 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceFormatsKHR) {
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     uint32_t count = 0;
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceSurfaceFormatsKHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfaceFormatsKHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
                  "vkGetPhysicalDeviceSurfaceFormatsKHR: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceSurfaceFormatsKHR-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfacePresentModesKHR) {
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfacePresentModesKHR) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_EXT_headless_surface"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.CheckCreate();
 
@@ -1024,20 +1100,22 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfacePresentModesKHR) {
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     uint32_t count = 0;
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceSurfacePresentModesKHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfacePresentModesKHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
                  "vkGetPhysicalDeviceSurfacePresentModesKHR: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceSurfacePresentModesKHR-physicalDevice-parameter\\]");
 }
 
 #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
-TEST_F(LoaderHandleValidTests, BadPhysDevGetDirectFBPresentSupportKHR) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_EXT_directfb_surface");
     instance.CheckCreate();
@@ -1047,21 +1125,23 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetDirectFBPresentSupportKHR) {
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     IDirectFB directfb;
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceDirectFBPresentationSupportEXT(bad_physical_dev, 0, &directfb),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceDirectFBPresentationSupportEXT(bad_physical_dev, 0, &directfb),
                  "vkGetPhysicalDeviceDirectFBPresentationSupportEXT: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceDirectFBPresentationSupportEXT-physicalDevice-parameter\\]");
 }
 #endif  // VK_USE_PLATFORM_DIRECTFB_EXT
 
 #ifdef VK_USE_PLATFORM_SCREEN_QNX
-TEST_F(LoaderHandleValidTests, BadPhysDevGetQNXPresentSupportKHR) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_QNX_screen_surface");
     instance.CheckCreate();
@@ -1070,21 +1150,23 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetQNXPresentSupportKHR) {
         uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
-    ASSERT_DEATH(env->vulkan_functions.PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX(bad_physical_dev, 0, nullptr),
+    ASSERT_DEATH(env.vulkan_functions.PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX(bad_physical_dev, 0, nullptr),
                  "vkGetPhysicalDeviceScreenPresentationSupportQNX: Invalid instance "
                  "\\[VUID-vkGetPhysicalDeviceScreenPresentationSupportQNX-instance-parameter\\]");
 }
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
 
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevWaylandPresentSupportKHR) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_KHR_wayland_surface");
     instance.CheckCreate();
@@ -1093,21 +1175,23 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevWaylandPresentSupportKHR) {
         uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceWaylandPresentationSupportKHR(bad_physical_dev, 0, nullptr),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceWaylandPresentationSupportKHR(bad_physical_dev, 0, nullptr),
                  "vkGetPhysicalDeviceWaylandPresentationSupportKHR: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceWaylandPresentationSupportKHR-physicalDevice-parameter\\]");
 }
 #endif  // VK_USE_PLATFORM_WAYLAND_KHR
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevWin32PresentSupportKHR) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_KHR_win32_surface");
     instance.CheckCreate();
@@ -1116,21 +1200,23 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevWin32PresentSupportKHR) {
         uint64_t bad_array[3] = {0x123456789AB, 0x23456789AB1, 0x9876543210AB};
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceWin32PresentationSupportKHR(bad_physical_dev, 0),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceWin32PresentationSupportKHR(bad_physical_dev, 0),
                  "vkGetPhysicalDeviceWin32PresentationSupportKHR: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceWin32PresentationSupportKHR-physicalDevice-parameter\\]");
 }
 #endif  // VK_USE_PLATFORM_WIN32_KHR
 
 #ifdef VK_USE_PLATFORM_XCB_KHR
-TEST_F(LoaderHandleValidTests, BadPhysDevGetXCBPresentSupportKHR) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_KHR_xcb_surface");
     instance.CheckCreate();
@@ -1141,21 +1227,23 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetXCBPresentSupportKHR) {
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
 
     xcb_visualid_t visual = 0;
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceXcbPresentationSupportKHR(bad_physical_dev, 0, nullptr, visual),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceXcbPresentationSupportKHR(bad_physical_dev, 0, nullptr, visual),
                  "vkGetPhysicalDeviceXcbPresentationSupportKHR: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceXcbPresentationSupportKHR-physicalDevice-parameter\\]");
 }
 #endif  // VK_USE_PLATFORM_XCB_KHR
 
 #ifdef VK_USE_PLATFORM_XLIB_KHR
-TEST_F(LoaderHandleValidTests, BadPhysDevGetXlibPresentSupportKHR) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_KHR_xlib_surface");
     instance.CheckCreate();
@@ -1166,20 +1254,22 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetXlibPresentSupportKHR) {
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
 
     VisualID visual = 0;
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceXlibPresentationSupportKHR(bad_physical_dev, 0, nullptr, visual),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceXlibPresentationSupportKHR(bad_physical_dev, 0, nullptr, visual),
                  "vkGetPhysicalDeviceXlibPresentationSupportKHR: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceXlibPresentationSupportKHR-physicalDevice-parameter\\]");
 }
 #endif  // VK_USE_PLATFORM_XLIB_KHR
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPropsKHR) {
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPropsKHR) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_KHR_display"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_KHR_display");
     instance.CheckCreate();
@@ -1189,19 +1279,21 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPropsKHR) {
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     uint32_t count = 0;
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceDisplayPropertiesKHR(bad_physical_dev, &count, nullptr),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceDisplayPropertiesKHR(bad_physical_dev, &count, nullptr),
                  "vkGetPhysicalDeviceDisplayPropertiesKHR: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPlanePropsKHR) {
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPlanePropsKHR) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_KHR_display"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_KHR_display");
     instance.CheckCreate();
@@ -1211,19 +1303,21 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPlanePropsKHR) {
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     uint32_t count = 0;
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceDisplayPlanePropertiesKHR(bad_physical_dev, &count, nullptr),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceDisplayPlanePropertiesKHR(bad_physical_dev, &count, nullptr),
                  "vkGetPhysicalDeviceDisplayPlanePropertiesKHR: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceDisplayPlanePropertiesKHR-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneSupportedDisplaysKHR) {
+TEST(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneSupportedDisplaysKHR) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_KHR_display"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_KHR_display");
     instance.CheckCreate();
@@ -1233,19 +1327,21 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneSupportedDisplaysKHR) {
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     uint32_t count = 0;
-    ASSERT_DEATH(env->vulkan_functions.vkGetDisplayPlaneSupportedDisplaysKHR(bad_physical_dev, 0, &count, nullptr),
+    ASSERT_DEATH(env.vulkan_functions.vkGetDisplayPlaneSupportedDisplaysKHR(bad_physical_dev, 0, &count, nullptr),
                  "vkGetDisplayPlaneSupportedDisplaysKHR: Invalid physicalDevice "
                  "\\[VUID-vkGetDisplayPlaneSupportedDisplaysKHR-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetDisplayModePropsKHR) {
+TEST(LoaderHandleValidTests, BadPhysDevGetDisplayModePropsKHR) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_KHR_display"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_KHR_display");
     instance.CheckCreate();
@@ -1256,18 +1352,20 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetDisplayModePropsKHR) {
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     uint32_t count = 0;
     ASSERT_DEATH(
-        env->vulkan_functions.vkGetDisplayModePropertiesKHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
+        env.vulkan_functions.vkGetDisplayModePropertiesKHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
         "vkGetDisplayModePropertiesKHR: Invalid physicalDevice \\[VUID-vkGetDisplayModePropertiesKHR-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevCreateDisplayModeKHR) {
+TEST(LoaderHandleValidTests, BadPhysDevCreateDisplayModeKHR) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_KHR_display"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_KHR_display");
     instance.CheckCreate();
@@ -1281,18 +1379,20 @@ TEST_F(LoaderHandleValidTests, BadPhysDevCreateDisplayModeKHR) {
     create_info.pNext = nullptr;
     VkDisplayModeKHR display_mode;
     ASSERT_DEATH(
-        env->vulkan_functions.vkCreateDisplayModeKHR(bad_physical_dev, VK_NULL_HANDLE, &create_info, nullptr, &display_mode),
+        env.vulkan_functions.vkCreateDisplayModeKHR(bad_physical_dev, VK_NULL_HANDLE, &create_info, nullptr, &display_mode),
         "vkCreateDisplayModeKHR: Invalid physicalDevice \\[VUID-vkCreateDisplayModeKHR-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneCapsKHR) {
+TEST(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneCapsKHR) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_KHR_display"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_KHR_display");
     instance.CheckCreate();
@@ -1302,19 +1402,21 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneCapsKHR) {
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     VkDisplayPlaneCapabilitiesKHR caps = {};
-    ASSERT_DEATH(env->vulkan_functions.vkGetDisplayPlaneCapabilitiesKHR(bad_physical_dev, VK_NULL_HANDLE, 0, &caps),
+    ASSERT_DEATH(env.vulkan_functions.vkGetDisplayPlaneCapabilitiesKHR(bad_physical_dev, VK_NULL_HANDLE, 0, &caps),
                  "vkGetDisplayPlaneCapabilitiesKHR: Invalid physicalDevice "
                  "\\[VUID-vkGetDisplayPlaneCapabilitiesKHR-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevPresentRectsKHR) {
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevPresentRectsKHR) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_KHR_display"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_KHR_display");
     instance.CheckCreate();
@@ -1324,19 +1426,21 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevPresentRectsKHR) {
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     uint32_t count = 0;
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDevicePresentRectanglesKHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDevicePresentRectanglesKHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
                  "vkGetPhysicalDevicePresentRectanglesKHR: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDevicePresentRectanglesKHR-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayProps2KHR) {
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayProps2KHR) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_KHR_get_display_properties2"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_KHR_get_display_properties2");
     instance.CheckCreate();
@@ -1346,19 +1450,21 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayProps2KHR) {
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     uint32_t count = 0;
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceDisplayProperties2KHR(bad_physical_dev, &count, nullptr),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceDisplayProperties2KHR(bad_physical_dev, &count, nullptr),
                  "vkGetPhysicalDeviceDisplayProperties2KHR: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceDisplayProperties2KHR-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPlaneProps2KHR) {
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPlaneProps2KHR) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_KHR_get_display_properties2"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_KHR_get_display_properties2");
     instance.CheckCreate();
@@ -1368,19 +1474,21 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevDisplayPlaneProps2KHR) {
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     uint32_t count = 0;
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceDisplayPlaneProperties2KHR(bad_physical_dev, &count, nullptr),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceDisplayPlaneProperties2KHR(bad_physical_dev, &count, nullptr),
                  "vkGetPhysicalDeviceDisplayPlaneProperties2KHR: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceDisplayPlaneProperties2KHR-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetDisplayModeProps2KHR) {
+TEST(LoaderHandleValidTests, BadPhysDevGetDisplayModeProps2KHR) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_KHR_get_display_properties2"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_KHR_get_display_properties2");
     instance.CheckCreate();
@@ -1390,19 +1498,21 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetDisplayModeProps2KHR) {
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     uint32_t count = 0;
-    ASSERT_DEATH(env->vulkan_functions.vkGetDisplayModeProperties2KHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
+    ASSERT_DEATH(env.vulkan_functions.vkGetDisplayModeProperties2KHR(bad_physical_dev, VK_NULL_HANDLE, &count, nullptr),
                  "vkGetDisplayModeProperties2KHR: Invalid physicalDevice "
                  "\\[VUID-vkGetDisplayModeProperties2KHR-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneCaps2KHR) {
+TEST(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneCaps2KHR) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_KHR_get_display_properties2"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_KHR_get_display_properties2");
     instance.CheckCreate();
@@ -1415,19 +1525,21 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetDisplayPlaneCaps2KHR) {
     disp_plane_info.sType = VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR;
     disp_plane_info.pNext = nullptr;
     VkDisplayPlaneCapabilities2KHR caps = {};
-    ASSERT_DEATH(env->vulkan_functions.vkGetDisplayPlaneCapabilities2KHR(bad_physical_dev, &disp_plane_info, &caps),
+    ASSERT_DEATH(env.vulkan_functions.vkGetDisplayPlaneCapabilities2KHR(bad_physical_dev, &disp_plane_info, &caps),
                  "vkGetDisplayPlaneCapabilities2KHR: Invalid physicalDevice "
                  "\\[VUID-vkGetDisplayPlaneCapabilities2KHR-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceCaps2KHR) {
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceCaps2KHR) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_KHR_get_surface_capabilities2"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_surface");
     instance.create_info.add_extension("VK_KHR_get_surface_capabilities2");
     instance.CheckCreate();
@@ -1440,19 +1552,21 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceCaps2KHR) {
     phys_dev_surf_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
     phys_dev_surf_info.pNext = nullptr;
     VkSurfaceCapabilities2KHR caps = {};
-    ASSERT_DEATH(env->vulkan_functions.vkGetPhysicalDeviceSurfaceCapabilities2KHR(bad_physical_dev, &phys_dev_surf_info, &caps),
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfaceCapabilities2KHR(bad_physical_dev, &phys_dev_surf_info, &caps),
                  "vkGetPhysicalDeviceSurfaceCapabilities2KHR: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceSurfaceCapabilities2KHR-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceFormats2KHR) {
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceFormats2KHR) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_KHR_get_surface_capabilities2"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_KHR_get_surface_capabilities2");
     instance.CheckCreate();
 
@@ -1464,17 +1578,18 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfaceFormats2KHR) {
     phys_dev_surf_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
     phys_dev_surf_info.pNext = nullptr;
     uint32_t count = 0;
-    ASSERT_DEATH(
-        env->vulkan_functions.vkGetPhysicalDeviceSurfaceFormats2KHR(bad_physical_dev, &phys_dev_surf_info, &count, nullptr),
-        "vkGetPhysicalDeviceSurfaceFormats2KHR: Invalid physicalDevice "
-        "\\[VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-physicalDevice-parameter\\]");
+    ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceSurfaceFormats2KHR(bad_physical_dev, &phys_dev_surf_info, &count, nullptr),
+                 "vkGetPhysicalDeviceSurfaceFormats2KHR: Invalid physicalDevice "
+                 "\\[VUID-vkGetPhysicalDeviceSurfaceFormats2KHR-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevEnumPhysDevQueueFamilyPerfQueryCountersKHR) {
-    auto& driver = env->get_test_icd();
+TEST(LoaderHandleValidTests, BadPhysDevEnumPhysDevQueueFamilyPerfQueryCountersKHR) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.CheckCreate();
 
     struct BadData {
@@ -1484,19 +1599,21 @@ TEST_F(LoaderHandleValidTests, BadPhysDevEnumPhysDevQueueFamilyPerfQueryCounters
     uint32_t count = 0;
     PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR pfn =
         reinterpret_cast<PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR>(
-            env->vulkan_functions.vkGetInstanceProcAddr(instance,
-                                                        "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR"));
+            env.vulkan_functions.vkGetInstanceProcAddr(instance,
+                                                       "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR"));
     ASSERT_NE(pfn, nullptr);
     ASSERT_DEATH(pfn(bad_physical_dev, 0, &count, nullptr, nullptr),
                  "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR: Invalid physicalDevice "
                  "\\[VUID-vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamilyPerfQueryPassesKHR) {
-    auto& driver = env->get_test_icd();
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamilyPerfQueryPassesKHR) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.CheckCreate();
 
     struct BadData {
@@ -1509,18 +1626,20 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevQueueFamilyPerfQueryPassesKHR
     uint32_t count = 0;
     PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR pfn =
         reinterpret_cast<PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR>(
-            env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR"));
+            env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR"));
     ASSERT_NE(pfn, nullptr);
     ASSERT_DEATH(pfn(bad_physical_dev, &create_info, &count),
                  "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevFragmentShadingRatesKHR) {
-    auto& driver = env->get_test_icd();
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevFragmentShadingRatesKHR) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.CheckCreate();
 
     struct BadData {
@@ -1529,18 +1648,20 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevFragmentShadingRatesKHR) {
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     uint32_t count = 0;
     PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR pfn = reinterpret_cast<PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR>(
-        env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR"));
+        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR"));
     ASSERT_NE(pfn, nullptr);
     ASSERT_DEATH(pfn(bad_physical_dev, &count, nullptr),
                  "vkGetPhysicalDeviceFragmentShadingRatesKHR: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceFragmentShadingRatesKHR-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevMSPropsEXT) {
-    auto& driver = env->get_test_icd();
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevMSPropsEXT) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.CheckCreate();
 
     struct BadData {
@@ -1549,21 +1670,23 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevMSPropsEXT) {
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     VkMultisamplePropertiesEXT props = {};
     PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT pfn = reinterpret_cast<PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT>(
-        env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT"));
+        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT"));
     ASSERT_NE(pfn, nullptr);
     ASSERT_DEATH(pfn(bad_physical_dev, VK_SAMPLE_COUNT_1_BIT, &props),
                  "vkGetPhysicalDeviceMultisamplePropertiesEXT: Invalid physicalDevice "
                  "\\[VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevAcquireDrmDisplayEXT) {
+TEST(LoaderHandleValidTests, BadPhysDevAcquireDrmDisplayEXT) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_EXT_acquire_drm_display"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_EXT_acquire_drm_display");
     instance.CheckCreate();
 
@@ -1572,20 +1695,22 @@ TEST_F(LoaderHandleValidTests, BadPhysDevAcquireDrmDisplayEXT) {
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     PFN_vkAcquireDrmDisplayEXT pfn = reinterpret_cast<PFN_vkAcquireDrmDisplayEXT>(
-        env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkAcquireDrmDisplayEXT"));
+        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkAcquireDrmDisplayEXT"));
     ASSERT_NE(pfn, nullptr);
     ASSERT_DEATH(pfn(bad_physical_dev, 0, VK_NULL_HANDLE),
                  "vkAcquireDrmDisplayEXT: Invalid physicalDevice \\[VUID-vkAcquireDrmDisplayEXT-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetDrmDisplayEXT) {
+TEST(LoaderHandleValidTests, BadPhysDevGetDrmDisplayEXT) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_EXT_acquire_drm_display"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_EXT_acquire_drm_display");
     instance.CheckCreate();
 
@@ -1594,21 +1719,23 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetDrmDisplayEXT) {
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     PFN_vkGetDrmDisplayEXT pfn =
-        reinterpret_cast<PFN_vkGetDrmDisplayEXT>(env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkGetDrmDisplayEXT"));
+        reinterpret_cast<PFN_vkGetDrmDisplayEXT>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkGetDrmDisplayEXT"));
     ASSERT_NE(pfn, nullptr);
     ASSERT_DEATH(pfn(bad_physical_dev, 0, 0, VK_NULL_HANDLE),
                  "vkGetDrmDisplayEXT: Invalid physicalDevice "
                  "\\[VUID-vkGetDrmDisplayEXT-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevReleaseDisplayEXT) {
+TEST(LoaderHandleValidTests, BadPhysDevReleaseDisplayEXT) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_EXT_direct_mode_display"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_EXT_direct_mode_display");
     instance.CheckCreate();
 
@@ -1617,21 +1744,23 @@ TEST_F(LoaderHandleValidTests, BadPhysDevReleaseDisplayEXT) {
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     PFN_vkReleaseDisplayEXT pfn =
-        reinterpret_cast<PFN_vkReleaseDisplayEXT>(env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkReleaseDisplayEXT"));
+        reinterpret_cast<PFN_vkReleaseDisplayEXT>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkReleaseDisplayEXT"));
     ASSERT_NE(pfn, nullptr);
     ASSERT_DEATH(pfn(bad_physical_dev, VK_NULL_HANDLE),
                  "vkReleaseDisplayEXT: Invalid physicalDevice \\[VUID-vkReleaseDisplayEXT-physicalDevice-parameter\\]");
 }
 
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-TEST_F(LoaderHandleValidTests, BadPhysDevAcquireXlibDisplayEXT) {
+TEST(LoaderHandleValidTests, BadPhysDevAcquireXlibDisplayEXT) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_EXT_acquire_xlib_display"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_EXT_acquire_xlib_display");
     instance.CheckCreate();
 
@@ -1640,20 +1769,22 @@ TEST_F(LoaderHandleValidTests, BadPhysDevAcquireXlibDisplayEXT) {
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     PFN_vkAcquireXlibDisplayEXT pfn = reinterpret_cast<PFN_vkAcquireXlibDisplayEXT>(
-        env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkAcquireXlibDisplayEXT"));
+        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkAcquireXlibDisplayEXT"));
     ASSERT_NE(pfn, nullptr);
     ASSERT_DEATH(pfn(bad_physical_dev, nullptr, VK_NULL_HANDLE),
                  "vkAcquireXlibDisplayEXT: Invalid physicalDevice \\[VUID-vkAcquireXlibDisplayEXT-physicalDevice-parameter\\]");
 }
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetRandROutputDisplayEXT) {
+TEST(LoaderHandleValidTests, BadPhysDevGetRandROutputDisplayEXT) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension first_ext{"VK_KHR_surface"};
     Extension second_ext{"VK_EXT_acquire_xlib_display"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_EXT_acquire_xlib_display");
     instance.CheckCreate();
 
@@ -1664,7 +1795,7 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetRandROutputDisplayEXT) {
     RROutput rrout = {};
     VkDisplayKHR disp;
     PFN_vkGetRandROutputDisplayEXT pfn = reinterpret_cast<PFN_vkGetRandROutputDisplayEXT>(
-        env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkGetRandROutputDisplayEXT"));
+        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkGetRandROutputDisplayEXT"));
     ASSERT_NE(pfn, nullptr);
     ASSERT_DEATH(
         pfn(bad_physical_dev, nullptr, rrout, &disp),
@@ -1673,11 +1804,13 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetRandROutputDisplayEXT) {
 #endif  // VK_USE_PLATFORM_XLIB_XRANDR_EXT
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfacePresentModes2EXT) {
-    auto& driver = env->get_test_icd();
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfacePresentModes2EXT) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.CheckCreate();
 
     struct BadData {
@@ -1689,7 +1822,7 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfacePresentModes2EXT) {
     phys_dev_surf_info.pNext = nullptr;
     uint32_t count = 0;
     PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT pfn = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT>(
-        env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT"));
+        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT"));
     ASSERT_NE(pfn, nullptr);
     ASSERT_DEATH(pfn(bad_physical_dev, &phys_dev_surf_info, &count, nullptr),
                  "vkGetPhysicalDeviceSurfacePresentModes2EXT: Invalid physicalDevice "
@@ -1697,11 +1830,13 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevSurfacePresentModes2EXT) {
 }
 #endif  // VK_USE_PLATFORM_WIN32_KHR
 
-TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevToolPropertiesEXT) {
-    auto& driver = env->get_test_icd();
+TEST(LoaderHandleValidTests, BadPhysDevGetPhysDevToolPropertiesEXT) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.CheckCreate();
 
     struct BadData {
@@ -1709,7 +1844,7 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevToolPropertiesEXT) {
     } my_bad_data;
     VkPhysicalDevice bad_physical_dev = (VkPhysicalDevice)(&my_bad_data);
     PFN_vkGetPhysicalDeviceToolPropertiesEXT pfn = reinterpret_cast<PFN_vkGetPhysicalDeviceToolPropertiesEXT>(
-        env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceToolPropertiesEXT"));
+        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceToolPropertiesEXT"));
     ASSERT_NE(pfn, nullptr);
     uint32_t count = 0;
     ASSERT_DEATH(pfn(bad_physical_dev, &count, nullptr),
@@ -1718,23 +1853,24 @@ TEST_F(LoaderHandleValidTests, BadPhysDevGetPhysDevToolPropertiesEXT) {
 }
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
-TEST_F(LoaderHandleValidTests, VerifyHandleWrappingAndroidSurface) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
 
     const char* wrap_objects_name = "WrapObjectsLayer";
-    env->add_explicit_layer(
-        ManifestLayer{}.add_layer(
-            ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
-        "wrap_objects_layer.json");
+    env.add_explicit_layer(ManifestLayer{}.add_layer(
+                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
+                           "wrap_objects_layer.json");
 
     driver.physical_devices.emplace_back("physical_device_0");
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
-    InstWrapper instance(env->vulkan_functions);
+    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);
@@ -1745,10 +1881,10 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingAndroidSurface) {
     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"));
+        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateAndroidSurfaceKHR"));
     ASSERT_NE(pfn_CreateSurface, nullptr);
     PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "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);
@@ -1756,23 +1892,24 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingAndroidSurface) {
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
 
 #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
-TEST_F(LoaderHandleValidTests, VerifyHandleWrappingDirectFBSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
 
     const char* wrap_objects_name = "WrapObjectsLayer";
-    env->add_explicit_layer(
-        ManifestLayer{}.add_layer(
-            ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
-        "wrap_objects_layer.json");
+    env.add_explicit_layer(ManifestLayer{}.add_layer(
+                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
+                           "wrap_objects_layer.json");
 
     driver.physical_devices.emplace_back("physical_device_0");
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
-    InstWrapper instance(env->vulkan_functions);
+    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);
@@ -1783,10 +1920,10 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingDirectFBSurf) {
     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"));
+        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateDirectFBSurfaceEXT"));
     ASSERT_NE(pfn_CreateSurface, nullptr);
     PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "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);
@@ -1794,23 +1931,24 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingDirectFBSurf) {
 #endif  // VK_USE_PLATFORM_DIRECTFB_EXT
 
 #ifdef VK_USE_PLATFORM_FUCHSIA
-TEST_F(LoaderHandleValidTests, VerifyHandleWrappingFuchsiaSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
 
     const char* wrap_objects_name = "WrapObjectsLayer";
-    env->add_explicit_layer(
-        ManifestLayer{}.add_layer(
-            ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
-        "wrap_objects_layer.json");
+    env.add_explicit_layer(ManifestLayer{}.add_layer(
+                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
+                           "wrap_objects_layer.json");
 
     driver.physical_devices.emplace_back("physical_device_0");
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
-    InstWrapper instance(env->vulkan_functions);
+    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);
@@ -1821,10 +1959,10 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingFuchsiaSurf) {
     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"));
+        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateImagePipeSurfaceFUCHSIA"));
     ASSERT_NE(pfn_CreateSurface, nullptr);
     PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "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);
@@ -1832,23 +1970,24 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingFuchsiaSurf) {
 #endif  // VK_USE_PLATFORM_FUCHSIA
 
 #ifdef VK_USE_PLATFORM_GGP
-TEST_F(LoaderHandleValidTests, VerifyHandleWrappingGGPSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
 
     const char* wrap_objects_name = "WrapObjectsLayer";
-    env->add_explicit_layer(
-        ManifestLayer{}.add_layer(
-            ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
-        "wrap_objects_layer.json");
+    env.add_explicit_layer(ManifestLayer{}.add_layer(
+                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
+                           "wrap_objects_layer.json");
 
     driver.physical_devices.emplace_back("physical_device_0");
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
-    InstWrapper instance(env->vulkan_functions);
+    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);
@@ -1859,10 +1998,10 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingGGPSurf) {
     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"));
+        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateStreamDescriptorSurfaceGGP"));
     ASSERT_NE(pfn_CreateSurface, nullptr);
     PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "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);
@@ -1870,23 +2009,24 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingGGPSurf) {
 #endif  // VK_USE_PLATFORM_GGP
 
 #ifdef VK_USE_PLATFORM_IOS_MVK
-TEST_F(LoaderHandleValidTests, VerifyHandleWrappingIOSSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
 
     const char* wrap_objects_name = "WrapObjectsLayer";
-    env->add_explicit_layer(
-        ManifestLayer{}.add_layer(
-            ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
-        "wrap_objects_layer.json");
+    env.add_explicit_layer(ManifestLayer{}.add_layer(
+                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
+                           "wrap_objects_layer.json");
 
     driver.physical_devices.emplace_back("physical_device_0");
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
-    InstWrapper instance(env->vulkan_functions);
+    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);
@@ -1897,10 +2037,10 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingIOSSurf) {
     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"));
+        reinterpret_cast<PFN_vkCreateIOSSurfaceMVK>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateIOSSurfaceMVK"));
     ASSERT_NE(pfn_CreateSurface, nullptr);
     PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "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);
@@ -1908,23 +2048,24 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingIOSSurf) {
 #endif  // VK_USE_PLATFORM_IOS_MVK
 
 #ifdef VK_USE_PLATFORM_MACOS_MVK
-TEST_F(LoaderHandleValidTests, VerifyHandleWrappingMacOSSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
 
     const char* wrap_objects_name = "WrapObjectsLayer";
-    env->add_explicit_layer(
-        ManifestLayer{}.add_layer(
-            ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
-        "wrap_objects_layer.json");
+    env.add_explicit_layer(ManifestLayer{}.add_layer(
+                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
+                           "wrap_objects_layer.json");
 
     driver.physical_devices.emplace_back("physical_device_0");
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
-    InstWrapper instance(env->vulkan_functions);
+    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);
@@ -1935,10 +2076,10 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingMacOSSurf) {
     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"));
+        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateMacOSSurfaceMVK"));
     ASSERT_NE(pfn_CreateSurface, nullptr);
     PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "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);
@@ -1946,23 +2087,24 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingMacOSSurf) {
 #endif  // VK_USE_PLATFORM_MACOS_MVK
 
 #if defined(VK_USE_PLATFORM_METAL_EXT)
-TEST_F(LoaderHandleValidTests, VerifyHandleWrappingMetalSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
 
     const char* wrap_objects_name = "WrapObjectsLayer";
-    env->add_explicit_layer(
-        ManifestLayer{}.add_layer(
-            ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
-        "wrap_objects_layer.json");
+    env.add_explicit_layer(ManifestLayer{}.add_layer(
+                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
+                           "wrap_objects_layer.json");
 
     driver.physical_devices.emplace_back("physical_device_0");
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
-    InstWrapper instance(env->vulkan_functions);
+    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);
@@ -1973,10 +2115,10 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingMetalSurf) {
     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"));
+        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateMetalSurfaceEXT"));
     ASSERT_NE(pfn_CreateSurface, nullptr);
     PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "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);
@@ -1984,23 +2126,24 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingMetalSurf) {
 #endif  // VK_USE_PLATFORM_METAL_EXT
 
 #ifdef VK_USE_PLATFORM_SCREEN_QNX
-TEST_F(LoaderHandleValidTests, VerifyHandleWrappingQNXSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
 
     const char* wrap_objects_name = "WrapObjectsLayer";
-    env->add_explicit_layer(
-        ManifestLayer{}.add_layer(
-            ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
-        "wrap_objects_layer.json");
+    env.add_explicit_layer(ManifestLayer{}.add_layer(
+                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
+                           "wrap_objects_layer.json");
 
     driver.physical_devices.emplace_back("physical_device_0");
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
-    InstWrapper instance(env->vulkan_functions);
+    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);
@@ -2011,10 +2154,10 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingQNXSurf) {
     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"));
+        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateScreenSurfaceQNX"));
     ASSERT_NE(pfn_CreateSurface, nullptr);
     PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "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);
@@ -2022,23 +2165,24 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingQNXSurf) {
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
 
 #ifdef VK_USE_PLATFORM_VI_NN
-TEST_F(LoaderHandleValidTests, VerifyHandleWrappingViNNSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
 
     const char* wrap_objects_name = "WrapObjectsLayer";
-    env->add_explicit_layer(
-        ManifestLayer{}.add_layer(
-            ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
-        "wrap_objects_layer.json");
+    env.add_explicit_layer(ManifestLayer{}.add_layer(
+                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
+                           "wrap_objects_layer.json");
 
     driver.physical_devices.emplace_back("physical_device_0");
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
-    InstWrapper instance(env->vulkan_functions);
+    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);
@@ -2049,10 +2193,10 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingViNNSurf) {
     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"));
+        reinterpret_cast<PFN_vkCreateViSurfaceNN>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateViSurfaceNN"));
     ASSERT_NE(pfn_CreateSurface, nullptr);
     PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "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);
@@ -2060,23 +2204,24 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingViNNSurf) {
 #endif  // VK_USE_PLATFORM_VI_NN
 
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
-TEST_F(LoaderHandleValidTests, VerifyHandleWrappingWaylandSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
 
     const char* wrap_objects_name = "WrapObjectsLayer";
-    env->add_explicit_layer(
-        ManifestLayer{}.add_layer(
-            ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
-        "wrap_objects_layer.json");
+    env.add_explicit_layer(ManifestLayer{}.add_layer(
+                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
+                           "wrap_objects_layer.json");
 
     driver.physical_devices.emplace_back("physical_device_0");
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
-    InstWrapper instance(env->vulkan_functions);
+    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);
@@ -2087,10 +2232,10 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingWaylandSurf) {
     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"));
+        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateWaylandSurfaceKHR"));
     ASSERT_NE(pfn_CreateSurface, nullptr);
     PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "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);
@@ -2098,23 +2243,24 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingWaylandSurf) {
 #endif  // VK_USE_PLATFORM_WAYLAND_KHR
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-TEST_F(LoaderHandleValidTests, VerifyHandleWrappingWin32Surf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
 
     const char* wrap_objects_name = "WrapObjectsLayer";
-    env->add_explicit_layer(
-        ManifestLayer{}.add_layer(
-            ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
-        "wrap_objects_layer.json");
+    env.add_explicit_layer(ManifestLayer{}.add_layer(
+                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
+                           "wrap_objects_layer.json");
 
     driver.physical_devices.emplace_back("physical_device_0");
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
-    InstWrapper instance(env->vulkan_functions);
+    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);
@@ -2125,10 +2271,10 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingWin32Surf) {
     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"));
+        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateWin32SurfaceKHR"));
     ASSERT_NE(pfn_CreateSurface, nullptr);
     PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "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);
@@ -2136,23 +2282,24 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingWin32Surf) {
 #endif  // VK_USE_PLATFORM_WIN32_KHR
 
 #ifdef VK_USE_PLATFORM_XCB_KHR
-TEST_F(LoaderHandleValidTests, VerifyHandleWrappingXCBSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
 
     const char* wrap_objects_name = "WrapObjectsLayer";
-    env->add_explicit_layer(
-        ManifestLayer{}.add_layer(
-            ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
-        "wrap_objects_layer.json");
+    env.add_explicit_layer(ManifestLayer{}.add_layer(
+                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
+                           "wrap_objects_layer.json");
 
     driver.physical_devices.emplace_back("physical_device_0");
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
-    InstWrapper instance(env->vulkan_functions);
+    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);
@@ -2163,10 +2310,10 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingXCBSurf) {
     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"));
+        reinterpret_cast<PFN_vkCreateXcbSurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateXcbSurfaceKHR"));
     ASSERT_NE(pfn_CreateSurface, nullptr);
     PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "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);
@@ -2174,23 +2321,24 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingXCBSurf) {
 #endif  // VK_USE_PLATFORM_XCB_KHR
 
 #ifdef VK_USE_PLATFORM_XLIB_KHR
-TEST_F(LoaderHandleValidTests, VerifyHandleWrappingXlibSurf) {
+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();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({first_ext, second_ext});
 
     const char* wrap_objects_name = "WrapObjectsLayer";
-    env->add_explicit_layer(
-        ManifestLayer{}.add_layer(
-            ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
-        "wrap_objects_layer.json");
+    env.add_explicit_layer(ManifestLayer{}.add_layer(
+                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
+                           "wrap_objects_layer.json");
 
     driver.physical_devices.emplace_back("physical_device_0");
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
-    InstWrapper instance(env->vulkan_functions);
+    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);
@@ -2201,10 +2349,10 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingXlibSurf) {
     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"));
+        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateXlibSurfaceKHR"));
     ASSERT_NE(pfn_CreateSurface, nullptr);
     PFN_vkDestroySurfaceKHR pfn_DestroySurface =
-        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR"));
+        reinterpret_cast<PFN_vkDestroySurfaceKHR>(env.vulkan_functions.vkGetInstanceProcAddr(instance, "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);
@@ -2222,22 +2370,23 @@ static VkBool32 JunkDebugUtilsCallback(VkDebugUtilsMessageSeverityFlagBitsEXT me
     return VK_FALSE;
 }
 
-TEST_F(LoaderHandleValidTests, VerifyHandleWrappingDebugUtilsMessenger) {
+TEST(LoaderHandleValidTests, VerifyHandleWrappingDebugUtilsMessenger) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     Extension ext{"VK_EXT_debug_utils"};
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.add_instance_extensions({ext});
 
     const char* wrap_objects_name = "WrapObjectsLayer";
-    env->add_explicit_layer(
-        ManifestLayer{}.add_layer(
-            ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
-        "wrap_objects_layer.json");
+    env.add_explicit_layer(ManifestLayer{}.add_layer(
+                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
+                           "wrap_objects_layer.json");
 
     driver.physical_devices.emplace_back("physical_device_0");
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
-    InstWrapper instance(env->vulkan_functions);
+    InstWrapper instance(env.vulkan_functions);
     instance.create_info.add_extension("VK_EXT_debug_utils");
     instance.create_info.add_layer(wrap_objects_name);
     instance.CheckCreate();
@@ -2251,10 +2400,10 @@ TEST_F(LoaderHandleValidTests, VerifyHandleWrappingDebugUtilsMessenger) {
     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"));
+        env.vulkan_functions.vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT"));
     ASSERT_NE(pfn_CreateMessenger, nullptr);
     PFN_vkDestroyDebugUtilsMessengerEXT pfn_DestroyMessenger = reinterpret_cast<PFN_vkDestroyDebugUtilsMessengerEXT>(
-        env->vulkan_functions.vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT"));
+        env.vulkan_functions.vkGetInstanceProcAddr(instance, "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 743e63bdf..407a15a23 100644
--- a/tests/loader_layer_tests.cpp
+++ b/tests/loader_layer_tests.cpp
@@ -27,26 +27,6 @@
 
 #include "test_environment.h"
 
-class LayerTests : public ::testing::Test {
-   protected:
-    virtual void SetUp() {
-        env = std::unique_ptr<FrameworkEnvironment>(new FrameworkEnvironment());
-        env->add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
-    }
-
-    virtual void TearDown() { env.reset(); }
-    std::unique_ptr<FrameworkEnvironment> env;
-};
-
-// Subtyping for organization
-class ExplicitLayers : public LayerTests {};
-class ImplicitLayers : public LayerTests {};
-class LayerExtensions : public LayerTests {};
-class MetaLayers : public LayerTests {};
-class OverrideMetaLayer : public LayerTests {};
-class LayerCreateInstance : public LayerTests {};
-class LayerPhysDeviceMod : public LayerTests {};
-
 void CheckLogForLayerString(FrameworkEnvironment& env, const char* implicit_layer_name, bool check_for_enable) {
     {
         InstWrapper inst{env.vulkan_functions};
@@ -63,92 +43,98 @@ void CheckLogForLayerString(FrameworkEnvironment& env, const char* implicit_laye
 
 const char* lunarg_meta_layer_name = "VK_LAYER_LUNARG_override";
 
-TEST_F(ImplicitLayers, WithEnableAndDisableEnvVar) {
+TEST(ImplicitLayers, WithEnableAndDisableEnvVar) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
     const char* implicit_layer_name = "VK_LAYER_ImplicitTestLayer";
     const char* enable_env_var = "ENABLE_ME";
     const char* disable_env_var = "DISABLE_ME";
 
-    env->add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name(implicit_layer_name)
-                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                                          .set_disable_environment(disable_env_var)
-                                                          .set_enable_environment(enable_env_var)),
-                            "implicit_test_layer.json");
+    env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name(implicit_layer_name)
+                                                         .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                                         .set_disable_environment(disable_env_var)
+                                                         .set_enable_environment(enable_env_var)),
+                           "implicit_test_layer.json");
 
     uint32_t count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
-    ASSERT_EQ(count, 1);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
+    ASSERT_EQ(count, 1U);
 
     // didn't set enable env-var, layer should not load
-    CheckLogForLayerString(*env, implicit_layer_name, false);
+    CheckLogForLayerString(env, implicit_layer_name, false);
 
     // set enable env-var to 0, no layer should be found
     set_env_var(enable_env_var, "0");
-    CheckLogForLayerString(*env, implicit_layer_name, false);
+    CheckLogForLayerString(env, implicit_layer_name, false);
 
     // // set enable env-var, layer should load
     set_env_var(enable_env_var, "1");
-    CheckLogForLayerString(*env, implicit_layer_name, true);
+    CheckLogForLayerString(env, implicit_layer_name, true);
 
     remove_env_var(enable_env_var);
 
     // set disable env-var to 0, layer should not load
     set_env_var(disable_env_var, "0");
-    CheckLogForLayerString(*env, implicit_layer_name, false);
+    CheckLogForLayerString(env, implicit_layer_name, false);
 
     // set disable env-var to 1, layer should not load
     set_env_var(disable_env_var, "1");
-    CheckLogForLayerString(*env, implicit_layer_name, false);
+    CheckLogForLayerString(env, implicit_layer_name, false);
 
     // set both enable and disable env-var, layer should not load
     set_env_var(enable_env_var, "1");
     set_env_var(disable_env_var, "1");
-    CheckLogForLayerString(*env, implicit_layer_name, false);
+    CheckLogForLayerString(env, implicit_layer_name, false);
 
     remove_env_var(enable_env_var);
     remove_env_var(disable_env_var);
 }
 
-TEST_F(ImplicitLayers, OnlyDisableEnvVar) {
+TEST(ImplicitLayers, OnlyDisableEnvVar) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
     const char* implicit_layer_name = "ImplicitTestLayer";
     const char* disable_env_var = "DISABLE_ME";
 
-    env->add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name(implicit_layer_name)
-                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                                          .set_disable_environment(disable_env_var)),
-                            "implicit_test_layer.json");
+    env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name(implicit_layer_name)
+                                                         .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                                         .set_disable_environment(disable_env_var)),
+                           "implicit_test_layer.json");
 
     uint32_t count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
-    ASSERT_EQ(count, 1);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
+    ASSERT_EQ(count, 1U);
 
     // don't set disable env-var, layer should load
-    CheckLogForLayerString(*env, implicit_layer_name, true);
+    CheckLogForLayerString(env, implicit_layer_name, true);
 
     // set disable env-var to 0, layer should load
     set_env_var(disable_env_var, "0");
-    CheckLogForLayerString(*env, implicit_layer_name, false);
+    CheckLogForLayerString(env, implicit_layer_name, false);
 
     // set disable env-var to 1, layer should not load
     set_env_var(disable_env_var, "1");
-    CheckLogForLayerString(*env, implicit_layer_name, false);
+    CheckLogForLayerString(env, implicit_layer_name, false);
 
     {
-        InstWrapper inst{env->vulkan_functions};
-        FillDebugUtilsCreateDetails(inst.create_info, env->debug_log);
+        InstWrapper inst{env.vulkan_functions};
+        FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
         inst.create_info.add_layer(implicit_layer_name);
         inst.CheckCreate(VK_SUCCESS);
-        ASSERT_TRUE(env->debug_log.find(std::string("Insert instance layer ") + implicit_layer_name));
+        ASSERT_TRUE(env.debug_log.find(std::string("Insert instance layer ") + implicit_layer_name));
     }
     remove_env_var(disable_env_var);
 }
 
-TEST_F(ImplicitLayers, PreInstanceEnumInstLayerProps) {
+TEST(ImplicitLayers, PreInstanceEnumInstLayerProps) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
     const char* implicit_layer_name = "ImplicitTestLayer";
     const char* disable_env_var = "DISABLE_ME";
 
-    env->add_implicit_layer(
+    env.add_implicit_layer(
         ManifestLayer{}
             .set_file_format_version(ManifestVersion(1, 1, 2))
             .add_layer(ManifestLayer::LayerDescription{}
@@ -161,67 +147,71 @@ TEST_F(ImplicitLayers, PreInstanceEnumInstLayerProps) {
         "implicit_test_layer.json");
 
     uint32_t layer_props = 43;
-    auto& layer = env->get_test_layer(0);
+    auto& layer = env.get_test_layer(0);
     layer.set_reported_layer_props(layer_props);
 
     uint32_t count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
     ASSERT_EQ(count, layer_props);
 
     // set disable env-var to 1, layer should not load
     set_env_var(disable_env_var, "1");
 
     count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
-    ASSERT_NE(count, 0);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
+    ASSERT_NE(count, 0U);
     ASSERT_NE(count, layer_props);
 
     remove_env_var(disable_env_var);
 }
 
-TEST_F(ImplicitLayers, PreInstanceEnumInstExtProps) {
+TEST(ImplicitLayers, PreInstanceEnumInstExtProps) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
     const char* implicit_layer_name = "ImplicitTestLayer";
     const char* disable_env_var = "DISABLE_ME";
 
-    env->add_implicit_layer(ManifestLayer{}
-                                .set_file_format_version(ManifestVersion(1, 1, 2))
-                                .add_layer(ManifestLayer::LayerDescription{}
-                                               .set_name(implicit_layer_name)
-                                               .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                               .set_disable_environment(disable_env_var)
-                                               .add_pre_instance_function(
-                                                   ManifestLayer::LayerDescription::FunctionOverride{}
-                                                       .set_vk_func("vkEnumerateInstanceExtensionProperties")
-                                                       .set_override_name("test_preinst_vkEnumerateInstanceExtensionProperties"))),
-                            "implicit_test_layer.json");
+    env.add_implicit_layer(ManifestLayer{}
+                               .set_file_format_version(ManifestVersion(1, 1, 2))
+                               .add_layer(ManifestLayer::LayerDescription{}
+                                              .set_name(implicit_layer_name)
+                                              .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                              .set_disable_environment(disable_env_var)
+                                              .add_pre_instance_function(
+                                                  ManifestLayer::LayerDescription::FunctionOverride{}
+                                                      .set_vk_func("vkEnumerateInstanceExtensionProperties")
+                                                      .set_override_name("test_preinst_vkEnumerateInstanceExtensionProperties"))),
+                           "implicit_test_layer.json");
 
     uint32_t ext_props = 52;
-    auto& layer = env->get_test_layer(0);
+    auto& layer = env.get_test_layer(0);
     layer.set_reported_extension_props(ext_props);
 
     uint32_t count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &count, nullptr));
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &count, nullptr));
     ASSERT_EQ(count, ext_props);
 
     // set disable env-var to 1, layer should not load
     set_env_var(disable_env_var, "1");
 
     count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &count, nullptr));
-    ASSERT_NE(count, 0);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &count, nullptr));
+    ASSERT_NE(count, 0U);
     ASSERT_NE(count, ext_props);
 
     remove_env_var(disable_env_var);
 }
 
-TEST_F(ImplicitLayers, PreInstanceVersion) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 3);
+TEST(ImplicitLayers, PreInstanceVersion) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 2, 3);
 
     const char* implicit_layer_name = "ImplicitTestLayer";
     const char* disable_env_var = "DISABLE_ME";
 
-    env->add_implicit_layer(
+    env.add_implicit_layer(
         ManifestLayer{}
             .set_file_format_version(ManifestVersion(1, 1, 2))
             .add_layer(ManifestLayer::LayerDescription{}
@@ -235,19 +225,19 @@ TEST_F(ImplicitLayers, PreInstanceVersion) {
         "implicit_test_layer.json");
 
     uint32_t layer_version = VK_MAKE_API_VERSION(1, 2, 3, 4);
-    auto& layer = env->get_test_layer(0);
+    auto& layer = env.get_test_layer(0);
     layer.set_reported_instance_version(layer_version);
 
     uint32_t version = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceVersion(&version));
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceVersion(&version));
     ASSERT_EQ(version, layer_version);
 
     // set disable env-var to 1, layer should not load
     set_env_var(disable_env_var, "1");
 
     version = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceVersion(&version));
-    ASSERT_NE(version, 0);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceVersion(&version));
+    ASSERT_NE(version, 0U);
     ASSERT_NE(version, layer_version);
 
     remove_env_var(disable_env_var);
@@ -257,32 +247,34 @@ TEST_F(ImplicitLayers, PreInstanceVersion) {
 // renamed vkGetInstanceProcAddr function which returns one that intentionally fails.  Then disable the
 // layer and verify it works.  The non-override version of vkCreateInstance in the layer also works (and is
 // tested through behavior above).
-TEST_F(ImplicitLayers, OverrideGetInstanceProcAddr) {
-    env->get_test_icd().physical_devices.push_back({});
+TEST(ImplicitLayers, OverrideGetInstanceProcAddr) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.get_test_icd().physical_devices.push_back({});
 
     const char* implicit_layer_name = "ImplicitTestLayer";
     const char* disable_env_var = "DISABLE_ME";
 
-    env->add_implicit_layer(ManifestLayer{}
-                                .set_file_format_version(ManifestVersion(1, 0, 0))
-                                .add_layer(ManifestLayer::LayerDescription{}
-                                               .set_name(implicit_layer_name)
-                                               .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_1)
-                                               .set_disable_environment(disable_env_var)
-                                               .add_function(ManifestLayer::LayerDescription::FunctionOverride{}
-                                                                 .set_vk_func("vkGetInstanceProcAddr")
-                                                                 .set_override_name("test_override_vkGetInstanceProcAddr"))),
-                            "implicit_test_layer.json");
+    env.add_implicit_layer(ManifestLayer{}
+                               .set_file_format_version(ManifestVersion(1, 0, 0))
+                               .add_layer(ManifestLayer::LayerDescription{}
+                                              .set_name(implicit_layer_name)
+                                              .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_1)
+                                              .set_disable_environment(disable_env_var)
+                                              .add_function(ManifestLayer::LayerDescription::FunctionOverride{}
+                                                                .set_vk_func("vkGetInstanceProcAddr")
+                                                                .set_override_name("test_override_vkGetInstanceProcAddr"))),
+                           "implicit_test_layer.json");
 
     {
-        InstWrapper inst1{env->vulkan_functions};
+        InstWrapper inst1{env.vulkan_functions};
         inst1.CheckCreate(VK_ERROR_INVALID_SHADER_NV);
     }
 
     {
         // set disable env-var to 1, layer should not load
         set_env_var(disable_env_var, "1");
-        InstWrapper inst2{env->vulkan_functions};
+        InstWrapper inst2{env.vulkan_functions};
         inst2.CheckCreate();
     }
 
@@ -290,215 +282,225 @@ TEST_F(ImplicitLayers, OverrideGetInstanceProcAddr) {
 }
 
 // Meta layer which contains component layers that do not exist.
-TEST_F(MetaLayers, InvalidComponentLayer) {
+TEST(MetaLayers, InvalidComponentLayer) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
     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";
-    env->add_implicit_layer(ManifestLayer{}
-                                .set_file_format_version(ManifestVersion(1, 1, 2))
-                                .add_layer(ManifestLayer::LayerDescription{}
-                                               .set_name(meta_layer_name)
-                                               .add_component_layers({invalid_layer_name_1, invalid_layer_name_2})
-                                               .set_disable_environment("NotGonnaWork")
-                                               .add_instance_extension({"NeverGonnaGiveYouUp"})
-                                               .add_device_extension({"NeverGonnaLetYouDown"})),
-                            "meta_test_layer.json");
+    env.add_implicit_layer(ManifestLayer{}
+                               .set_file_format_version(ManifestVersion(1, 1, 2))
+                               .add_layer(ManifestLayer::LayerDescription{}
+                                              .set_name(meta_layer_name)
+                                              .add_component_layers({invalid_layer_name_1, invalid_layer_name_2})
+                                              .set_disable_environment("NotGonnaWork")
+                                              .add_instance_extension({"NeverGonnaGiveYouUp"})
+                                              .add_device_extension({"NeverGonnaLetYouDown"})),
+                           "meta_test_layer.json");
 
     const char* regular_layer_name = "TestLayer";
-    env->add_explicit_layer(
+    env.add_explicit_layer(
         ManifestLayer{}.add_layer(
             ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
         "regular_test_layer.json");
 
     // should find 1, the 'regular' layer
     uint32_t layer_count = 1;
-    EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr));
-    EXPECT_EQ(layer_count, 1);
+    EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr));
+    EXPECT_EQ(layer_count, 1U);
 
     VkLayerProperties layer_props;
-    EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, &layer_props));
-    EXPECT_EQ(layer_count, 1);
+    EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, &layer_props));
+    EXPECT_EQ(layer_count, 1U);
     EXPECT_TRUE(string_eq(layer_props.layerName, regular_layer_name));
 
     uint32_t extension_count = 0;
     std::array<VkExtensionProperties, 2> extensions;
-    EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
-    EXPECT_EQ(extension_count, 2);  // return debug report & debug utils
+    EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
+    EXPECT_EQ(extension_count, 2U);  // return debug report & debug utils
 
     EXPECT_EQ(VK_SUCCESS,
-              env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extensions.data()));
-    EXPECT_EQ(extension_count, 2);
+              env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extensions.data()));
+    EXPECT_EQ(extension_count, 2U);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.add_layer(meta_layer_name);
-    FillDebugUtilsCreateDetails(inst.create_info, env->debug_log);
+    FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
     inst.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT);
-    ASSERT_TRUE(env->debug_log.find(std::string("verify_meta_layer_component_layers: Meta-layer ") + meta_layer_name +
-                                    " can't find component layer " + invalid_layer_name_1 + " at index 0.  Skipping this layer."));
+    ASSERT_TRUE(env.debug_log.find(std::string("verify_meta_layer_component_layers: Meta-layer ") + meta_layer_name +
+                                   " can't find component layer " + invalid_layer_name_1 + " at index 0.  Skipping this layer."));
 }
 
 // Meta layer that is an explicit layer
-TEST_F(MetaLayers, ExplicitMetaLayer) {
-    env->get_test_icd().add_physical_device({});
+TEST(MetaLayers, ExplicitMetaLayer) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.get_test_icd().add_physical_device({});
     const char* meta_layer_name = "VK_LAYER_MetaTestLayer";
     const char* regular_layer_name = "VK_LAYER_TestLayer";
-    env->add_explicit_layer(
+    env.add_explicit_layer(
         ManifestLayer{}
             .set_file_format_version(ManifestVersion(1, 1, 2))
             .add_layer(ManifestLayer::LayerDescription{}.set_name(meta_layer_name).add_component_layers({regular_layer_name})),
         "meta_test_layer.json");
 
-    env->add_explicit_layer(
+    env.add_explicit_layer(
         ManifestLayer{}.add_layer(
             ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
         "regular_test_layer.json");
     {  // global functions
         // should find 1, the 'regular' layer
         uint32_t layer_count = 0;
-        EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr));
-        EXPECT_EQ(layer_count, 2);
+        EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr));
+        EXPECT_EQ(layer_count, 2U);
 
         std::array<VkLayerProperties, 2> layer_props;
-        EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()));
-        EXPECT_EQ(layer_count, 2);
+        EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()));
+        EXPECT_EQ(layer_count, 2U);
         EXPECT_TRUE(check_permutation({regular_layer_name, meta_layer_name}, layer_props));
 
         uint32_t extension_count = 0;
         std::array<VkExtensionProperties, 2> extensions;
-        EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
-        EXPECT_EQ(extension_count, 2);  // return debug report & debug utils
+        EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
+        EXPECT_EQ(extension_count, 2U);  // return debug report & debug utils
 
         EXPECT_EQ(VK_SUCCESS,
-                  env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extensions.data()));
-        EXPECT_EQ(extension_count, 2);
+                  env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extensions.data()));
+        EXPECT_EQ(extension_count, 2U);
     }
     {  // don't enable the layer, shouldn't find any layers when calling vkEnumerateDeviceLayerProperties
-        InstWrapper inst{env->vulkan_functions};
+        InstWrapper inst{env.vulkan_functions};
         inst.CheckCreate(VK_SUCCESS);
         auto phys_dev = inst.GetPhysDev();
         uint32_t count = 0;
-        env->vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
-        ASSERT_EQ(count, 0);
+        env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
+        ASSERT_EQ(count, 0U);
     }
     {
-        InstWrapper inst{env->vulkan_functions};
+        InstWrapper inst{env.vulkan_functions};
         inst.create_info.add_layer(meta_layer_name);
         inst.CheckCreate(VK_SUCCESS);
         auto phys_dev = inst.GetPhysDev();
         uint32_t count = 0;
-        env->vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
-        ASSERT_EQ(count, 2);
+        env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
+        ASSERT_EQ(count, 2U);
         std::array<VkLayerProperties, 2> layer_props;
-        env->vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, layer_props.data());
-        ASSERT_EQ(count, 2);
+        env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, layer_props.data());
+        ASSERT_EQ(count, 2U);
         EXPECT_TRUE(check_permutation({regular_layer_name, meta_layer_name}, layer_props));
     }
 }
 
 // Meta layer which adds itself in its list of component layers
-TEST_F(MetaLayers, MetaLayerNameInComponentLayers) {
+TEST(MetaLayers, MetaLayerNameInComponentLayers) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
     const char* meta_layer_name = "VK_LAYER_MetaTestLayer";
     const char* regular_layer_name = "VK_LAYER_TestLayer";
-    env->add_implicit_layer(ManifestLayer{}
-                                .set_file_format_version(ManifestVersion(1, 1, 2))
-                                .add_layer(ManifestLayer::LayerDescription{}
-                                               .set_name(meta_layer_name)
-                                               .add_component_layers({meta_layer_name, regular_layer_name})
-                                               .set_disable_environment("NotGonnaWork")
-                                               .add_instance_extension({"NeverGonnaGiveYouUp"})
-                                               .add_device_extension({"NeverGonnaLetYouDown"})),
-                            "meta_test_layer.json");
-
-    env->add_explicit_layer(
+    env.add_implicit_layer(ManifestLayer{}
+                               .set_file_format_version(ManifestVersion(1, 1, 2))
+                               .add_layer(ManifestLayer::LayerDescription{}
+                                              .set_name(meta_layer_name)
+                                              .add_component_layers({meta_layer_name, regular_layer_name})
+                                              .set_disable_environment("NotGonnaWork")
+                                              .add_instance_extension({"NeverGonnaGiveYouUp"})
+                                              .add_device_extension({"NeverGonnaLetYouDown"})),
+                           "meta_test_layer.json");
+
+    env.add_explicit_layer(
         ManifestLayer{}.add_layer(
             ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
         "regular_test_layer.json");
 
     // should find 1, the 'regular' layer
     uint32_t layer_count = 1;
-    EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr));
-    EXPECT_EQ(layer_count, 1);
+    EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr));
+    EXPECT_EQ(layer_count, 1U);
 
     VkLayerProperties layer_props;
-    EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, &layer_props));
-    EXPECT_EQ(layer_count, 1);
+    EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, &layer_props));
+    EXPECT_EQ(layer_count, 1U);
     EXPECT_TRUE(string_eq(layer_props.layerName, regular_layer_name));
 
     uint32_t extension_count = 0;
     std::array<VkExtensionProperties, 2> extensions;
-    EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
-    EXPECT_EQ(extension_count, 2);  // return debug report & debug utils
+    EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
+    EXPECT_EQ(extension_count, 2U);  // return debug report & debug utils
 
     EXPECT_EQ(VK_SUCCESS,
-              env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extensions.data()));
-    EXPECT_EQ(extension_count, 2);
+              env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extensions.data()));
+    EXPECT_EQ(extension_count, 2U);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.add_layer(meta_layer_name);
-    FillDebugUtilsCreateDetails(inst.create_info, env->debug_log);
+    FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
     inst.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT);
-    ASSERT_TRUE(env->debug_log.find(std::string("verify_meta_layer_component_layers: Meta-layer ") + meta_layer_name +
-                                    " lists itself in its component layer " + "list at index 0.  Skipping this layer."));
+    ASSERT_TRUE(env.debug_log.find(std::string("verify_meta_layer_component_layers: Meta-layer ") + meta_layer_name +
+                                   " lists itself in its component layer " + "list at index 0.  Skipping this layer."));
 }
 
 // Meta layer which adds another meta layer as a component layer
-TEST_F(MetaLayers, MetaLayerWhichAddsMetaLayer) {
+TEST(MetaLayers, MetaLayerWhichAddsMetaLayer) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
     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";
-    env->add_explicit_layer(
+    env.add_explicit_layer(
         ManifestLayer{}.add_layer(
             ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
         "regular_test_layer.json");
-    env->add_explicit_layer(
+    env.add_explicit_layer(
         ManifestLayer{}
             .set_file_format_version(ManifestVersion(1, 1, 2))
             .add_layer(ManifestLayer::LayerDescription{}.set_name(meta_layer_name).add_component_layers({regular_layer_name})),
         "meta_test_layer.json");
-    env->add_explicit_layer(ManifestLayer{}
-                                .set_file_format_version(ManifestVersion(1, 1, 2))
-                                .add_layer(ManifestLayer::LayerDescription{}
-                                               .set_name(meta_meta_layer_name)
-                                               .add_component_layers({meta_layer_name, regular_layer_name})),
-                            "meta_meta_test_layer.json");
+    env.add_explicit_layer(ManifestLayer{}
+                               .set_file_format_version(ManifestVersion(1, 1, 2))
+                               .add_layer(ManifestLayer::LayerDescription{}
+                                              .set_name(meta_meta_layer_name)
+                                              .add_component_layers({meta_layer_name, regular_layer_name})),
+                           "meta_meta_test_layer.json");
 
     uint32_t layer_count = 3;
-    EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr));
-    EXPECT_EQ(layer_count, 3);
+    EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr));
+    EXPECT_EQ(layer_count, 3U);
 
     std::array<VkLayerProperties, 3> layer_props;
-    EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()));
-    EXPECT_EQ(layer_count, 3);
+    EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()));
+    EXPECT_EQ(layer_count, 3U);
     EXPECT_TRUE(check_permutation({regular_layer_name, meta_layer_name, meta_meta_layer_name}, layer_props));
 
     uint32_t extension_count = 0;
     std::array<VkExtensionProperties, 2> extensions;
-    EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
-    EXPECT_EQ(extension_count, 2);  // return debug report & debug utils
+    EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
+    EXPECT_EQ(extension_count, 2U);  // return debug report & debug utils
 
     EXPECT_EQ(VK_SUCCESS,
-              env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extensions.data()));
-    EXPECT_EQ(extension_count, 2);
+              env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extensions.data()));
+    EXPECT_EQ(extension_count, 2U);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.add_layer(meta_layer_name);
-    FillDebugUtilsCreateDetails(inst.create_info, env->debug_log);
+    FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
     inst.CheckCreate();
-    ASSERT_TRUE(env->debug_log.find(std::string("verify_meta_layer_component_layers: Adding meta-layer ") + meta_meta_layer_name +
-                                    " which also contains meta-layer " + meta_layer_name));
+    ASSERT_TRUE(env.debug_log.find(std::string("verify_meta_layer_component_layers: Adding meta-layer ") + meta_meta_layer_name +
+                                   " which also contains meta-layer " + meta_layer_name));
 }
 
-TEST_F(MetaLayers, InstanceExtensionInComponentLayer) {
-    env->get_test_icd().add_physical_device({});
+TEST(MetaLayers, InstanceExtensionInComponentLayer) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.get_test_icd().add_physical_device({});
     const char* meta_layer_name = "VK_LAYER_MetaTestLayer";
     const char* regular_layer_name = "VK_LAYER_TestLayer";
     const char* instance_ext_name = "VK_EXT_headless_surface";
-    env->add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name(regular_layer_name)
-                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                                          .add_instance_extension({instance_ext_name})),
-                            "regular_test_layer.json");
-    env->add_explicit_layer(
+    env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name(regular_layer_name)
+                                                         .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                                         .add_instance_extension({instance_ext_name})),
+                           "regular_test_layer.json");
+    env.add_explicit_layer(
         ManifestLayer{}
             .set_file_format_version(ManifestVersion(1, 1, 2))
             .add_layer(ManifestLayer::LayerDescription{}.set_name(meta_layer_name).add_component_layers({regular_layer_name})),
@@ -506,26 +508,28 @@ TEST_F(MetaLayers, InstanceExtensionInComponentLayer) {
 
     uint32_t extension_count = 0;
     std::array<VkExtensionProperties, 1> extensions;
-    EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties(meta_layer_name, &extension_count, nullptr));
-    EXPECT_EQ(extension_count, 1);  // return instance_ext_name
+    EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(meta_layer_name, &extension_count, nullptr));
+    EXPECT_EQ(extension_count, 1U);  // return instance_ext_name
 
     EXPECT_EQ(VK_SUCCESS,
-              env->vulkan_functions.vkEnumerateInstanceExtensionProperties(meta_layer_name, &extension_count, extensions.data()));
-    EXPECT_EQ(extension_count, 1);
+              env.vulkan_functions.vkEnumerateInstanceExtensionProperties(meta_layer_name, &extension_count, extensions.data()));
+    EXPECT_EQ(extension_count, 1U);
     EXPECT_TRUE(string_eq(extensions[0].extensionName, instance_ext_name));
 }
 
-TEST_F(MetaLayers, DeviceExtensionInComponentLayer) {
-    env->get_test_icd().add_physical_device({});
+TEST(MetaLayers, DeviceExtensionInComponentLayer) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.get_test_icd().add_physical_device({});
     const char* meta_layer_name = "VK_LAYER_MetaTestLayer";
     const char* regular_layer_name = "VK_LAYER_TestLayer";
     const char* device_ext_name = "VK_EXT_fake_dev_ext";
-    env->add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name(regular_layer_name)
-                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                                          .add_device_extension({device_ext_name})),
-                            "regular_test_layer.json");
-    env->add_explicit_layer(
+    env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name(regular_layer_name)
+                                                         .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                                         .add_device_extension({device_ext_name})),
+                           "regular_test_layer.json");
+    env.add_explicit_layer(
         ManifestLayer{}
             .set_file_format_version(ManifestVersion(1, 1, 2))
             .add_layer(ManifestLayer::LayerDescription{}.set_name(meta_layer_name).add_component_layers({regular_layer_name})),
@@ -533,402 +537,416 @@ TEST_F(MetaLayers, DeviceExtensionInComponentLayer) {
     {
         uint32_t extension_count = 0;
         EXPECT_EQ(VK_SUCCESS,
-                  env->vulkan_functions.vkEnumerateInstanceExtensionProperties(meta_layer_name, &extension_count, nullptr));
-        EXPECT_EQ(extension_count, 0);
+                  env.vulkan_functions.vkEnumerateInstanceExtensionProperties(meta_layer_name, &extension_count, nullptr));
+        EXPECT_EQ(extension_count, 0U);
     }
     {  // layer is not enabled
-        InstWrapper inst{env->vulkan_functions};
-        FillDebugUtilsCreateDetails(inst.create_info, env->debug_log);
+        InstWrapper inst{env.vulkan_functions};
+        FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
         inst.CheckCreate();
-        ASSERT_TRUE(env->debug_log.find(std::string("Meta-layer ") + meta_layer_name + " component layer " + regular_layer_name +
-                                        " adding device extension " + device_ext_name));
+        ASSERT_TRUE(env.debug_log.find(std::string("Meta-layer ") + meta_layer_name + " component layer " + regular_layer_name +
+                                       " adding device extension " + device_ext_name));
 
         auto phys_dev = inst.GetPhysDev();
         uint32_t extension_count = 0;
         std::array<VkExtensionProperties, 1> extensions;
         EXPECT_EQ(VK_SUCCESS,
-                  env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, meta_layer_name, &extension_count, nullptr));
-        EXPECT_EQ(extension_count, 1);  // return device_ext_name
+                  env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, meta_layer_name, &extension_count, nullptr));
+        EXPECT_EQ(extension_count, 1U);  // return device_ext_name
 
-        EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, meta_layer_name,
-                                                                                         &extension_count, extensions.data()));
-        EXPECT_EQ(extension_count, 1);
+        EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, meta_layer_name, &extension_count,
+                                                                                        extensions.data()));
+        EXPECT_EQ(extension_count, 1U);
         EXPECT_TRUE(string_eq(extensions[0].extensionName, device_ext_name));
     }
     {  // layer is enabled
-        InstWrapper inst{env->vulkan_functions};
+        InstWrapper inst{env.vulkan_functions};
         inst.create_info.add_layer(meta_layer_name);
-        FillDebugUtilsCreateDetails(inst.create_info, env->debug_log);
+        FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
         inst.CheckCreate();
-        ASSERT_TRUE(env->debug_log.find(std::string("Meta-layer ") + meta_layer_name + " component layer " + regular_layer_name +
-                                        " adding device extension " + device_ext_name));
+        ASSERT_TRUE(env.debug_log.find(std::string("Meta-layer ") + meta_layer_name + " component layer " + regular_layer_name +
+                                       " adding device extension " + device_ext_name));
         auto phys_dev = inst.GetPhysDev();
 
         uint32_t extension_count = 0;
         std::array<VkExtensionProperties, 1> extensions;
         EXPECT_EQ(VK_SUCCESS,
-                  env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, meta_layer_name, &extension_count, nullptr));
-        EXPECT_EQ(extension_count, 1);  // return device_ext_name
+                  env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, meta_layer_name, &extension_count, nullptr));
+        EXPECT_EQ(extension_count, 1U);  // return device_ext_name
 
-        EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, meta_layer_name,
-                                                                                         &extension_count, extensions.data()));
-        EXPECT_EQ(extension_count, 1);
+        EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, meta_layer_name, &extension_count,
+                                                                                        extensions.data()));
+        EXPECT_EQ(extension_count, 1U);
         EXPECT_TRUE(string_eq(extensions[0].extensionName, device_ext_name));
     }
 }
 // Override meta layer missing disable environment variable still enables the layer
-TEST_F(OverrideMetaLayer, InvalidDisableEnvironment) {
-    env->get_test_icd().add_physical_device({});
+TEST(OverrideMetaLayer, InvalidDisableEnvironment) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.get_test_icd().add_physical_device({});
     const char* regular_layer_name = "VK_LAYER_TestLayer";
-    env->add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name(regular_layer_name)
-                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                                          .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
-                                                          .add_device_extension({"NeverGonnaLetYouDown"})),
-                            "regular_test_layer.json");
-
-    env->add_implicit_layer(ManifestLayer{}
-                                .set_file_format_version(ManifestVersion(1, 1, 2))
-                                .add_layer(ManifestLayer::LayerDescription{}
-                                               .set_name(lunarg_meta_layer_name)
-                                               .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
-                                               .add_component_layers({regular_layer_name})),
-                            "meta_test_layer.json");
+    env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name(regular_layer_name)
+                                                         .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                                         .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
+                                                         .add_device_extension({"NeverGonnaLetYouDown"})),
+                           "regular_test_layer.json");
+
+    env.add_implicit_layer(ManifestLayer{}
+                               .set_file_format_version(ManifestVersion(1, 1, 2))
+                               .add_layer(ManifestLayer::LayerDescription{}
+                                              .set_name(lunarg_meta_layer_name)
+                                              .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
+                                              .add_component_layers({regular_layer_name})),
+                           "meta_test_layer.json");
 
     uint32_t layer_count = 0;
-    EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr));
-    EXPECT_EQ(layer_count, 1);
+    EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr));
+    EXPECT_EQ(layer_count, 1U);
 
     std::array<VkLayerProperties, 1> layer_props;
-    EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()));
-    EXPECT_EQ(layer_count, 1);
+    EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()));
+    EXPECT_EQ(layer_count, 1U);
     EXPECT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name));
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 }
 
 // Override meta layer whose version is less than the api version of the instance
-TEST_F(OverrideMetaLayer, OlderVersionThanInstance) {
-    env->get_test_icd().add_physical_device({});
+TEST(OverrideMetaLayer, OlderVersionThanInstance) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.get_test_icd().add_physical_device({});
     const char* regular_layer_name = "VK_LAYER_TestLayer";
-    env->add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name(regular_layer_name)
-                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                                          .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
-                                                          .add_device_extension({"NeverGonnaLetYouDown"})),
-                            "regular_test_layer.json");
-
-    env->add_implicit_layer(ManifestLayer{}
-                                .set_file_format_version(ManifestVersion(1, 1, 2))
-                                .add_layer(ManifestLayer::LayerDescription{}
-                                               .set_name(lunarg_meta_layer_name)
-                                               .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
-                                               .set_disable_environment("DisableMeIfYouCan")
-                                               .add_component_layers({regular_layer_name})),
-                            "meta_test_layer.json");
+    env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name(regular_layer_name)
+                                                         .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                                         .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
+                                                         .add_device_extension({"NeverGonnaLetYouDown"})),
+                           "regular_test_layer.json");
+
+    env.add_implicit_layer(ManifestLayer{}
+                               .set_file_format_version(ManifestVersion(1, 1, 2))
+                               .add_layer(ManifestLayer::LayerDescription{}
+                                              .set_name(lunarg_meta_layer_name)
+                                              .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
+                                              .set_disable_environment("DisableMeIfYouCan")
+                                              .add_component_layers({regular_layer_name})),
+                           "meta_test_layer.json");
     {  // global functions
         uint32_t layer_count = 0;
-        EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr));
-        EXPECT_EQ(layer_count, 2);
+        EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr));
+        EXPECT_EQ(layer_count, 2U);
 
         std::array<VkLayerProperties, 2> layer_props;
-        EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()));
-        EXPECT_EQ(layer_count, 2);
+        EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()));
+        EXPECT_EQ(layer_count, 2U);
         EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props));
     }
     {  // 1.1 instance
-        InstWrapper inst{env->vulkan_functions};
+        InstWrapper inst{env.vulkan_functions};
         inst.create_info.api_version = VK_API_VERSION_1_1;
         inst.CheckCreate();
         VkPhysicalDevice phys_dev = inst.GetPhysDev();
 
         uint32_t count = 0;
-        env->vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
-        ASSERT_EQ(2, count);
+        env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
+        ASSERT_EQ(2U, count);
         std::array<VkLayerProperties, 2> layer_props;
 
-        env->vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, layer_props.data());
-        ASSERT_EQ(2, count);
+        env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, layer_props.data());
+        ASSERT_EQ(2U, count);
         ASSERT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name));
         ASSERT_TRUE(string_eq(layer_props[1].layerName, lunarg_meta_layer_name));
     }
     {  // 1.2 instance
 
-        InstWrapper inst{env->vulkan_functions};
-        FillDebugUtilsCreateDetails(inst.create_info, env->debug_log);
+        InstWrapper inst{env.vulkan_functions};
+        FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
 
         inst.create_info.api_version = VK_API_VERSION_1_2;
         inst.CheckCreate();
-        ASSERT_TRUE(env->debug_log.find(std::string("loader_add_implicit_layer: Disabling implicit layer ") +
-                                        lunarg_meta_layer_name +
-                                        " for using an old API version 1.1 versus application requested 1.2"));
+        ASSERT_TRUE(env.debug_log.find(std::string("loader_add_implicit_layer: Disabling implicit layer ") +
+                                       lunarg_meta_layer_name +
+                                       " for using an old API version 1.1 versus application requested 1.2"));
     }
 }
 
-TEST_F(OverrideMetaLayer, OlderMetaLayerWithNewerInstanceVersion) {
-    env->get_test_icd().add_physical_device({});
+TEST(OverrideMetaLayer, OlderMetaLayerWithNewerInstanceVersion) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.get_test_icd().add_physical_device({});
 
     const char* regular_layer_name = "VK_LAYER_TestLayer";
-    env->add_explicit_layer(ManifestLayer{}
-                                .set_file_format_version(ManifestVersion(1, 2, 0))
-                                .add_layer(ManifestLayer::LayerDescription{}
-                                               .set_name(regular_layer_name)
-                                               .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                               .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))),
-                            "regular_test_layer.json");
-
-    env->add_implicit_layer(ManifestLayer{}
-                                .set_file_format_version(ManifestVersion(1, 2, 0))
-                                .add_layer(ManifestLayer::LayerDescription{}
-                                               .set_name(lunarg_meta_layer_name)
-                                               .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
-                                               .add_component_layers({regular_layer_name})
-                                               .set_disable_environment("DisableMeIfYouCan")),
-                            "meta_test_layer.json");
+    env.add_explicit_layer(ManifestLayer{}
+                               .set_file_format_version(ManifestVersion(1, 2, 0))
+                               .add_layer(ManifestLayer::LayerDescription{}
+                                              .set_name(regular_layer_name)
+                                              .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                              .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))),
+                           "regular_test_layer.json");
+
+    env.add_implicit_layer(ManifestLayer{}
+                               .set_file_format_version(ManifestVersion(1, 2, 0))
+                               .add_layer(ManifestLayer::LayerDescription{}
+                                              .set_name(lunarg_meta_layer_name)
+                                              .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
+                                              .add_component_layers({regular_layer_name})
+                                              .set_disable_environment("DisableMeIfYouCan")),
+                           "meta_test_layer.json");
     {  // global functions
         uint32_t layer_count = 2;
-        EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr));
-        EXPECT_EQ(layer_count, 2);
+        EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr));
+        EXPECT_EQ(layer_count, 2U);
 
         std::array<VkLayerProperties, 2> layer_props;
-        EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()));
-        EXPECT_EQ(layer_count, 2);
+        EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()));
+        EXPECT_EQ(layer_count, 2U);
         EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props));
     }
     {
         // 1.1 instance
-        InstWrapper inst{env->vulkan_functions};
+        InstWrapper inst{env.vulkan_functions};
         inst.create_info.set_api_version(1, 1, 0);
         inst.CheckCreate();
         VkPhysicalDevice phys_dev = inst.GetPhysDev();
 
         uint32_t count = 0;
-        env->vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
-        ASSERT_EQ(2, count);
+        env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
+        ASSERT_EQ(2U, count);
         std::array<VkLayerProperties, 2> layer_props;
 
-        env->vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, layer_props.data());
-        ASSERT_EQ(2, count);
+        env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, layer_props.data());
+        ASSERT_EQ(2U, count);
         ASSERT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name));
         ASSERT_TRUE(string_eq(layer_props[1].layerName, lunarg_meta_layer_name));
     }
 
     {
         // 1.2 instance
-        InstWrapper inst{env->vulkan_functions};
-        FillDebugUtilsCreateDetails(inst.create_info, env->debug_log);
+        InstWrapper inst{env.vulkan_functions};
+        FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
         inst.create_info.set_api_version(1, 2, 0);
         inst.CheckCreate();
         VkPhysicalDevice phys_dev = inst.GetPhysDev();
         ASSERT_TRUE(
-            env->debug_log.find("loader_add_implicit_layer: Disabling implicit layer VK_LAYER_LUNARG_override for using an old API "
-                                "version 1.1 versus application requested 1.2"));
+            env.debug_log.find("loader_add_implicit_layer: Disabling implicit layer VK_LAYER_LUNARG_override for using an old API "
+                               "version 1.1 versus application requested 1.2"));
         uint32_t count = 0;
-        env->vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
-        ASSERT_EQ(0, count);
+        env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
+        ASSERT_EQ(0U, count);
         std::array<VkLayerProperties, 2> layer_props;
-        env->vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, layer_props.data());
-        ASSERT_EQ(0, count);
+        env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, layer_props.data());
+        ASSERT_EQ(0U, count);
     }
 }
 
-TEST_F(OverrideMetaLayer, NewerComponentLayerInMetaLayer) {
-    env->get_test_icd().add_physical_device({});
+TEST(OverrideMetaLayer, NewerComponentLayerInMetaLayer) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.get_test_icd().add_physical_device({});
 
     const char* regular_layer_name = "VK_LAYER_TestLayer";
-    env->add_explicit_layer(ManifestLayer{}
-                                .set_file_format_version(ManifestVersion(1, 2, 0))
-                                .add_layer(ManifestLayer::LayerDescription{}
-                                               .set_name(regular_layer_name)
-                                               .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                               .set_api_version(VK_MAKE_API_VERSION(0, 1, 2, 0))),
-                            "regular_test_layer.json");
-
-    env->add_implicit_layer(ManifestLayer{}
-                                .set_file_format_version(ManifestVersion(1, 2, 0))
-                                .add_layer(ManifestLayer::LayerDescription{}
-                                               .set_name(lunarg_meta_layer_name)
-                                               .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
-                                               .add_component_layers({regular_layer_name})
-                                               .set_disable_environment("DisableMeIfYouCan")),
-                            "meta_test_layer.json");
+    env.add_explicit_layer(ManifestLayer{}
+                               .set_file_format_version(ManifestVersion(1, 2, 0))
+                               .add_layer(ManifestLayer::LayerDescription{}
+                                              .set_name(regular_layer_name)
+                                              .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                              .set_api_version(VK_MAKE_API_VERSION(0, 1, 2, 0))),
+                           "regular_test_layer.json");
+
+    env.add_implicit_layer(ManifestLayer{}
+                               .set_file_format_version(ManifestVersion(1, 2, 0))
+                               .add_layer(ManifestLayer::LayerDescription{}
+                                              .set_name(lunarg_meta_layer_name)
+                                              .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
+                                              .add_component_layers({regular_layer_name})
+                                              .set_disable_environment("DisableMeIfYouCan")),
+                           "meta_test_layer.json");
     {  // global functions
         uint32_t layer_count = 1;
-        EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr));
-        EXPECT_EQ(layer_count, 1);
+        EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr));
+        EXPECT_EQ(layer_count, 1U);
 
         std::array<VkLayerProperties, 1> layer_props;
-        EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()));
-        EXPECT_EQ(layer_count, 1);
+        EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()));
+        EXPECT_EQ(layer_count, 1U);
         // Expect the explicit layer to still be found
         EXPECT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name));
     }
     {
         // 1.1 instance
-        InstWrapper inst{env->vulkan_functions};
-        FillDebugUtilsCreateDetails(inst.create_info, env->debug_log);
+        InstWrapper inst{env.vulkan_functions};
+        FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
         inst.create_info.set_api_version(1, 1, 0);
         inst.CheckCreate();
         VkPhysicalDevice phys_dev = inst.GetPhysDev();
         ASSERT_TRUE(
-            env->debug_log.find("verify_meta_layer_component_layers: Meta-layer uses API version 1.1, but component layer 0 uses "
-                                "API version 1.2.  Skipping this layer."));
-        env->debug_log.clear();
+            env.debug_log.find("verify_meta_layer_component_layers: Meta-layer uses API version 1.1, but component layer 0 uses "
+                               "API version 1.2.  Skipping this layer."));
+        env.debug_log.clear();
         uint32_t count = 0;
-        env->vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
-        ASSERT_EQ(0, count);
+        env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
+        ASSERT_EQ(0U, count);
         std::array<VkLayerProperties, 1> layer_props;
 
-        env->vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, layer_props.data());
-        ASSERT_EQ(0, count);
+        env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, layer_props.data());
+        ASSERT_EQ(0U, count);
     }
 
     {
         // 1.2 instance
-        InstWrapper inst{env->vulkan_functions};
-        FillDebugUtilsCreateDetails(inst.create_info, env->debug_log);
+        InstWrapper inst{env.vulkan_functions};
+        FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
         inst.create_info.set_api_version(1, 2, 0);
         inst.CheckCreate();
         VkPhysicalDevice phys_dev = inst.GetPhysDev();
         ASSERT_TRUE(
-            env->debug_log.find("verify_meta_layer_component_layers: Meta-layer uses API version 1.1, but component layer 0 uses "
-                                "API version 1.2.  Skipping this layer."));
-        env->debug_log.clear();
+            env.debug_log.find("verify_meta_layer_component_layers: Meta-layer uses API version 1.1, but component layer 0 uses "
+                               "API version 1.2.  Skipping this layer."));
+        env.debug_log.clear();
         uint32_t count = 0;
-        env->vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
-        ASSERT_EQ(0, count);
+        env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
+        ASSERT_EQ(0U, count);
         std::array<VkLayerProperties, 2> layer_props;
-        env->vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, layer_props.data());
-        ASSERT_EQ(0, count);
+        env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, layer_props.data());
+        ASSERT_EQ(0U, count);
     }
 }
 
-TEST_F(OverrideMetaLayer, OlderComponentLayerInMetaLayer) {
-    env->get_test_icd().add_physical_device({});
+TEST(OverrideMetaLayer, OlderComponentLayerInMetaLayer) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.get_test_icd().add_physical_device({});
 
     const char* regular_layer_name = "VK_LAYER_TestLayer";
-    env->add_explicit_layer(ManifestLayer{}
-                                .set_file_format_version(ManifestVersion(1, 2, 0))
-                                .add_layer(ManifestLayer::LayerDescription{}
-                                               .set_name(regular_layer_name)
-                                               .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                               .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
-                            "regular_test_layer.json");
-
-    env->add_implicit_layer(ManifestLayer{}
-                                .set_file_format_version(ManifestVersion(1, 2, 0))
-                                .add_layer(ManifestLayer::LayerDescription{}
-                                               .set_name(lunarg_meta_layer_name)
-                                               .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
-                                               .add_component_layers({regular_layer_name})
-                                               .set_disable_environment("DisableMeIfYouCan")),
-                            "meta_test_layer.json");
+    env.add_explicit_layer(ManifestLayer{}
+                               .set_file_format_version(ManifestVersion(1, 2, 0))
+                               .add_layer(ManifestLayer::LayerDescription{}
+                                              .set_name(regular_layer_name)
+                                              .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                              .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
+                           "regular_test_layer.json");
+
+    env.add_implicit_layer(ManifestLayer{}
+                               .set_file_format_version(ManifestVersion(1, 2, 0))
+                               .add_layer(ManifestLayer::LayerDescription{}
+                                              .set_name(lunarg_meta_layer_name)
+                                              .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
+                                              .add_component_layers({regular_layer_name})
+                                              .set_disable_environment("DisableMeIfYouCan")),
+                           "meta_test_layer.json");
     {  // global functions
         uint32_t layer_count = 0;
-        EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr));
-        EXPECT_EQ(layer_count, 1);
+        EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr));
+        EXPECT_EQ(layer_count, 1U);
 
         std::array<VkLayerProperties, 1> layer_props;
-        EXPECT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()));
-        EXPECT_EQ(layer_count, 1);
+        EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()));
+        EXPECT_EQ(layer_count, 1U);
         EXPECT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name));
     }
     {
         // 1.1 instance
-        InstWrapper inst{env->vulkan_functions};
-        FillDebugUtilsCreateDetails(inst.create_info, env->debug_log);
+        InstWrapper inst{env.vulkan_functions};
+        FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
         inst.create_info.set_api_version(1, 1, 0);
         inst.CheckCreate();
         VkPhysicalDevice phys_dev = inst.GetPhysDev();
         ASSERT_TRUE(
-            env->debug_log.find("verify_meta_layer_component_layers: Meta-layer uses API version 1.1, but component layer 0 uses "
-                                "API version 1.0.  Skipping this layer."));
-        env->debug_log.clear();
+            env.debug_log.find("verify_meta_layer_component_layers: Meta-layer uses API version 1.1, but component layer 0 uses "
+                               "API version 1.0.  Skipping this layer."));
+        env.debug_log.clear();
         uint32_t count = 0;
-        env->vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
-        ASSERT_EQ(0, count);
+        env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
+        ASSERT_EQ(0U, count);
         std::array<VkLayerProperties, 2> layer_props;
-        env->vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, layer_props.data());
-        ASSERT_EQ(0, count);
+        env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, layer_props.data());
+        ASSERT_EQ(0U, count);
     }
 
     {
         // 1.2 instance
-        InstWrapper inst{env->vulkan_functions};
-        FillDebugUtilsCreateDetails(inst.create_info, env->debug_log);
+        InstWrapper inst{env.vulkan_functions};
+        FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
         inst.create_info.set_api_version(1, 2, 0);
         inst.CheckCreate();
         VkPhysicalDevice phys_dev = inst.GetPhysDev();
         ASSERT_TRUE(
-            env->debug_log.find("verify_meta_layer_component_layers: Meta-layer uses API version 1.1, but component layer 0 uses "
-                                "API version 1.0.  Skipping this layer."));
-        env->debug_log.clear();
+            env.debug_log.find("verify_meta_layer_component_layers: Meta-layer uses API version 1.1, but component layer 0 uses "
+                               "API version 1.0.  Skipping this layer."));
+        env.debug_log.clear();
         uint32_t count = 0;
-        env->vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
-        ASSERT_EQ(0, count);
+        env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
+        ASSERT_EQ(0U, count);
         std::array<VkLayerProperties, 2> layer_props;
-        env->vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, layer_props.data());
-        ASSERT_EQ(0, count);
+        env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, layer_props.data());
+        ASSERT_EQ(0U, count);
     }
 }
 
-TEST_F(OverrideMetaLayer, ApplicationEnabledLayerInBlacklist) {
-    env->get_test_icd().add_physical_device({});
+TEST(OverrideMetaLayer, ApplicationEnabledLayerInBlacklist) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.get_test_icd().add_physical_device({});
 
     const char* automatic_regular_layer_name = "VK_LAYER_TestLayer_1";
     const char* manual_regular_layer_name = "VK_LAYER_TestLayer_2";
-    env->add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name(automatic_regular_layer_name)
-                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                                          .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))),
-                            "regular_test_layer_1.json");
-    env->add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name(manual_regular_layer_name)
-                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                                          .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))),
-                            "regular_test_layer_2.json");
-    env->add_implicit_layer(ManifestLayer{}
-                                .set_file_format_version(ManifestVersion(1, 2, 0))
-                                .add_layer(ManifestLayer::LayerDescription{}
-                                               .set_name(lunarg_meta_layer_name)
-                                               .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
-                                               .add_component_layer(automatic_regular_layer_name)
-                                               .add_blacklisted_layer(manual_regular_layer_name)
-                                               .set_disable_environment("DisableMeIfYouCan")),
-                            "meta_test_layer.json");
+    env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name(automatic_regular_layer_name)
+                                                         .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                                         .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))),
+                           "regular_test_layer_1.json");
+    env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name(manual_regular_layer_name)
+                                                         .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                                         .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))),
+                           "regular_test_layer_2.json");
+    env.add_implicit_layer(ManifestLayer{}
+                               .set_file_format_version(ManifestVersion(1, 2, 0))
+                               .add_layer(ManifestLayer::LayerDescription{}
+                                              .set_name(lunarg_meta_layer_name)
+                                              .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
+                                              .add_component_layer(automatic_regular_layer_name)
+                                              .add_blacklisted_layer(manual_regular_layer_name)
+                                              .set_disable_environment("DisableMeIfYouCan")),
+                           "meta_test_layer.json");
 
     {  // enable the layer in the blacklist
-        InstWrapper inst{env->vulkan_functions};
-        FillDebugUtilsCreateDetails(inst.create_info, env->debug_log);
+        InstWrapper inst{env.vulkan_functions};
+        FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
         inst.create_info.add_layer(manual_regular_layer_name);
         inst.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT);
-        ASSERT_TRUE(env->debug_log.find(std::string("loader_remove_layers_in_blacklist: Override layer is active and layer ") +
-                                        manual_regular_layer_name +
-                                        " is in the blacklist inside of it. Removing that layer from current layer list."));
-        env->debug_log.clear();
+        ASSERT_TRUE(env.debug_log.find(std::string("loader_remove_layers_in_blacklist: Override layer is active and layer ") +
+                                       manual_regular_layer_name +
+                                       " is in the blacklist inside of it. Removing that layer from current layer list."));
+        env.debug_log.clear();
     }
     {  // dont enable the layer in the blacklist
-        InstWrapper inst{env->vulkan_functions};
-        FillDebugUtilsCreateDetails(inst.create_info, env->debug_log);
+        InstWrapper inst{env.vulkan_functions};
+        FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
         inst.CheckCreate();
         VkPhysicalDevice phys_dev = inst.GetPhysDev();
-        ASSERT_TRUE(env->debug_log.find(std::string("loader_remove_layers_in_blacklist: Override layer is active and layer ") +
-                                        manual_regular_layer_name +
-                                        " is in the blacklist inside of it. Removing that layer from current layer list."));
-        env->debug_log.clear();
+        ASSERT_TRUE(env.debug_log.find(std::string("loader_remove_layers_in_blacklist: Override layer is active and layer ") +
+                                       manual_regular_layer_name +
+                                       " is in the blacklist inside of it. Removing that layer from current layer list."));
+        env.debug_log.clear();
         uint32_t count = 0;
-        env->vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
-        ASSERT_EQ(2, count);
+        env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
+        ASSERT_EQ(2U, count);
         std::array<VkLayerProperties, 2> layer_props;
-        env->vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, layer_props.data());
-        ASSERT_EQ(2, count);
+        env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, layer_props.data());
+        ASSERT_EQ(2U, count);
         ASSERT_TRUE(check_permutation({automatic_regular_layer_name, lunarg_meta_layer_name}, layer_props));
     }
 }
 
-TEST_F(OverrideMetaLayer, BasicOverridePaths) {
-    env->get_test_icd().add_physical_device({});
+TEST(OverrideMetaLayer, BasicOverridePaths) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.get_test_icd().add_physical_device({});
     fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"};
 
     const char* regular_layer_name = "VK_LAYER_TestLayer_1";
@@ -940,36 +958,38 @@ TEST_F(OverrideMetaLayer, BasicOverridePaths) {
                                                             .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)))
                                              .get_manifest_str());
     auto override_folder_location = fs::make_native(override_layer_folder.location().str());
-    env->add_implicit_layer(ManifestLayer{}
-                                .set_file_format_version(ManifestVersion(1, 2, 0))
-                                .add_layer(ManifestLayer::LayerDescription{}
-                                               .set_name(lunarg_meta_layer_name)
-                                               .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
-                                               .add_component_layer(regular_layer_name)
-                                               .set_disable_environment("DisableMeIfYouCan")
-                                               .add_override_path(override_folder_location)),
-                            "meta_test_layer.json");
-
-    InstWrapper inst{env->vulkan_functions};
+    env.add_implicit_layer(ManifestLayer{}
+                               .set_file_format_version(ManifestVersion(1, 2, 0))
+                               .add_layer(ManifestLayer::LayerDescription{}
+                                              .set_name(lunarg_meta_layer_name)
+                                              .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
+                                              .add_component_layer(regular_layer_name)
+                                              .set_disable_environment("DisableMeIfYouCan")
+                                              .add_override_path(override_folder_location)),
+                           "meta_test_layer.json");
+
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.set_api_version(1, 1, 0);
-    FillDebugUtilsCreateDetails(inst.create_info, env->debug_log);
+    FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
     inst.CheckCreate();
-    ASSERT_TRUE(env->debug_log.find(std::string("Insert instance layer ") + regular_layer_name));
-    env->layers.clear();
+    ASSERT_TRUE(env.debug_log.find(std::string("Insert instance layer ") + regular_layer_name));
+    env.layers.clear();
 }
 
-TEST_F(OverrideMetaLayer, BasicOverridePathsIgnoreOtherLayers) {
-    env->get_test_icd().add_physical_device({});
+TEST(OverrideMetaLayer, BasicOverridePathsIgnoreOtherLayers) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.get_test_icd().add_physical_device({});
     fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"};
 
     const char* regular_layer_name = "VK_LAYER_TestLayer";
-    env->add_explicit_layer(ManifestLayer{}
-                                .set_file_format_version(ManifestVersion(1, 2, 0))
-                                .add_layer(ManifestLayer::LayerDescription{}
-                                               .set_name(regular_layer_name)
-                                               .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                               .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
-                            "regular_test_layer.json");
+    env.add_explicit_layer(ManifestLayer{}
+                               .set_file_format_version(ManifestVersion(1, 2, 0))
+                               .add_layer(ManifestLayer::LayerDescription{}
+                                              .set_name(regular_layer_name)
+                                              .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                              .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
+                           "regular_test_layer.json");
 
     const char* special_layer_name = "VK_LAYER_TestLayer_1";
     override_layer_folder.write_manifest("regular_test_layer.json",
@@ -980,27 +1000,29 @@ TEST_F(OverrideMetaLayer, BasicOverridePathsIgnoreOtherLayers) {
                                                             .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)))
                                              .get_manifest_str());
     auto override_folder_location = fs::make_native(override_layer_folder.location().str());
-    env->add_implicit_layer(ManifestLayer{}
-                                .set_file_format_version(ManifestVersion(1, 2, 0))
-                                .add_layer(ManifestLayer::LayerDescription{}
-                                               .set_name(lunarg_meta_layer_name)
-                                               .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
-                                               .add_component_layer(special_layer_name)
-                                               .set_disable_environment("DisableMeIfYouCan")
-                                               .add_override_path(override_folder_location)),
-                            "meta_test_layer.json");
-
-    InstWrapper inst{env->vulkan_functions};
+    env.add_implicit_layer(ManifestLayer{}
+                               .set_file_format_version(ManifestVersion(1, 2, 0))
+                               .add_layer(ManifestLayer::LayerDescription{}
+                                              .set_name(lunarg_meta_layer_name)
+                                              .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
+                                              .add_component_layer(special_layer_name)
+                                              .set_disable_environment("DisableMeIfYouCan")
+                                              .add_override_path(override_folder_location)),
+                           "meta_test_layer.json");
+
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.set_api_version(1, 1, 0);
     inst.create_info.add_layer(regular_layer_name);
-    FillDebugUtilsCreateDetails(inst.create_info, env->debug_log);
+    FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
     inst.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT);
-    ASSERT_FALSE(env->debug_log.find(std::string("Insert instance layer ") + regular_layer_name));
-    env->layers.clear();
+    ASSERT_FALSE(env.debug_log.find(std::string("Insert instance layer ") + regular_layer_name));
+    env.layers.clear();
 }
 
-TEST_F(OverrideMetaLayer, OverridePathsInteractionWithVK_LAYER_PATH) {
-    env->get_test_icd().add_physical_device({});
+TEST(OverrideMetaLayer, OverridePathsInteractionWithVK_LAYER_PATH) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.get_test_icd().add_physical_device({});
 
     fs::FolderManager vk_layer_path_folder{FRAMEWORK_BUILD_DIRECTORY, "vk_layer_folder"};
     set_env_var("VK_LAYER_PATH", vk_layer_path_folder.location().str());
@@ -1008,58 +1030,60 @@ TEST_F(OverrideMetaLayer, OverridePathsInteractionWithVK_LAYER_PATH) {
 
     // add explicit layer to VK_LAYER_PATH folder
     const char* env_var_layer_name = "VK_LAYER_env_var_set_path";
-    env->add_explicit_layer(TestLayerDetails{ManifestLayer{}
-                                                 .set_file_format_version(ManifestVersion(1, 2, 0))
-                                                 .add_layer(ManifestLayer::LayerDescription{}
-                                                                .set_name(env_var_layer_name)
-                                                                .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                                                .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
-                                             "regular_test_layer.json"}
-                                .set_destination_folder(&vk_layer_path_folder));
+    env.add_explicit_layer(TestLayerDetails{ManifestLayer{}
+                                                .set_file_format_version(ManifestVersion(1, 2, 0))
+                                                .add_layer(ManifestLayer::LayerDescription{}
+                                                               .set_name(env_var_layer_name)
+                                                               .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                                               .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
+                                            "regular_test_layer.json"}
+                               .set_destination_folder(&vk_layer_path_folder));
 
     // add layer to regular explicit layer folder
     const char* regular_layer_name = "VK_LAYER_regular_layer_path";
-    env->add_explicit_layer(TestLayerDetails{ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                                           .set_name(regular_layer_name)
-                                                                           .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                                                           .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))),
-                                             "regular_test_layer.json"}
-                                .set_destination_folder(&override_path_folder));
-
-    env->add_implicit_layer(ManifestLayer{}
-                                .set_file_format_version(ManifestVersion(1, 2, 0))
-                                .add_layer(ManifestLayer::LayerDescription{}
-                                               .set_name(lunarg_meta_layer_name)
-                                               .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
-                                               .add_component_layer(regular_layer_name)
-                                               .set_disable_environment("DisableMeIfYouCan")
-                                               .add_override_path(override_path_folder.location().str())),
-                            "meta_test_layer.json");
-
-    InstWrapper inst{env->vulkan_functions};
+    env.add_explicit_layer(TestLayerDetails{ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                                          .set_name(regular_layer_name)
+                                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                                                          .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))),
+                                            "regular_test_layer.json"}
+                               .set_destination_folder(&override_path_folder));
+
+    env.add_implicit_layer(ManifestLayer{}
+                               .set_file_format_version(ManifestVersion(1, 2, 0))
+                               .add_layer(ManifestLayer::LayerDescription{}
+                                              .set_name(lunarg_meta_layer_name)
+                                              .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
+                                              .add_component_layer(regular_layer_name)
+                                              .set_disable_environment("DisableMeIfYouCan")
+                                              .add_override_path(override_path_folder.location().str())),
+                           "meta_test_layer.json");
+
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.set_api_version(1, 1, 0);
     inst.create_info.add_layer(env_var_layer_name);
-    FillDebugUtilsCreateDetails(inst.create_info, env->debug_log);
+    FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
     inst.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT);
-    ASSERT_FALSE(env->debug_log.find(std::string("Insert instance layer ") + env_var_layer_name));
+    ASSERT_FALSE(env.debug_log.find(std::string("Insert instance layer ") + env_var_layer_name));
 
-    env->layers.clear();
+    env.layers.clear();
     remove_env_var("VK_LAYER_PATH");
 }
 
 // Make sure that implicit layers not in the override paths aren't found by mistake
-TEST_F(OverrideMetaLayer, OverridePathsEnableImplicitLayerInDefaultPaths) {
-    env->get_test_icd().add_physical_device({});
+TEST(OverrideMetaLayer, OverridePathsEnableImplicitLayerInDefaultPaths) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.get_test_icd().add_physical_device({});
     fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"};
 
     const char* implicit_layer_name = "VK_LAYER_ImplicitLayer";
-    env->add_implicit_layer(ManifestLayer{}
-                                .set_file_format_version(ManifestVersion(1, 2, 0))
-                                .add_layer(ManifestLayer::LayerDescription{}
-                                               .set_name(implicit_layer_name)
-                                               .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                               .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
-                            "implicit_test_layer.json");
+    env.add_implicit_layer(ManifestLayer{}
+                               .set_file_format_version(ManifestVersion(1, 2, 0))
+                               .add_layer(ManifestLayer::LayerDescription{}
+                                              .set_name(implicit_layer_name)
+                                              .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                              .set_api_version(VK_MAKE_API_VERSION(0, 1, 0, 0))),
+                           "implicit_test_layer.json");
 
     const char* regular_layer_name = "VK_LAYER_TestLayer_1";
     override_layer_folder.write_manifest("regular_test_layer.json",
@@ -1070,28 +1094,30 @@ TEST_F(OverrideMetaLayer, OverridePathsEnableImplicitLayerInDefaultPaths) {
                                                             .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)))
                                              .get_manifest_str());
     auto override_folder_location = fs::make_native(override_layer_folder.location().str());
-    env->add_implicit_layer(ManifestLayer{}
-                                .set_file_format_version(ManifestVersion(1, 2, 0))
-                                .add_layer(ManifestLayer::LayerDescription{}
-                                               .set_name(lunarg_meta_layer_name)
-                                               .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
-                                               .add_component_layers({regular_layer_name, implicit_layer_name})
-                                               .set_disable_environment("DisableMeIfYouCan")
-                                               .add_override_path(override_folder_location)),
-                            "meta_test_layer.json");
-
-    InstWrapper inst{env->vulkan_functions};
-    FillDebugUtilsCreateDetails(inst.create_info, env->debug_log);
+    env.add_implicit_layer(ManifestLayer{}
+                               .set_file_format_version(ManifestVersion(1, 2, 0))
+                               .add_layer(ManifestLayer::LayerDescription{}
+                                              .set_name(lunarg_meta_layer_name)
+                                              .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
+                                              .add_component_layers({regular_layer_name, implicit_layer_name})
+                                              .set_disable_environment("DisableMeIfYouCan")
+                                              .add_override_path(override_folder_location)),
+                           "meta_test_layer.json");
+
+    InstWrapper inst{env.vulkan_functions};
+    FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
     inst.create_info.set_api_version(1, 1, 0);
     inst.CheckCreate();
-    ASSERT_FALSE(env->debug_log.find(std::string("Insert instance layer ") + implicit_layer_name));
+    ASSERT_FALSE(env.debug_log.find(std::string("Insert instance layer ") + implicit_layer_name));
     ASSERT_TRUE(
-        env->debug_log.find("Removing meta-layer VK_LAYER_LUNARG_override from instance layer list since it appears invalid."));
-    env->layers.clear();
+        env.debug_log.find("Removing meta-layer VK_LAYER_LUNARG_override from instance layer list since it appears invalid."));
+    env.layers.clear();
 }
 
-TEST_F(OverrideMetaLayer, ManifestFileFormatVersionTooOld) {
-    env->get_test_icd().add_physical_device({});
+TEST(OverrideMetaLayer, ManifestFileFormatVersionTooOld) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.get_test_icd().add_physical_device({});
     fs::FolderManager override_layer_folder{FRAMEWORK_BUILD_DIRECTORY, "override_layer_folder"};
 
     const char* regular_layer_name = "VK_LAYER_TestLayer_1";
@@ -1103,40 +1129,42 @@ TEST_F(OverrideMetaLayer, ManifestFileFormatVersionTooOld) {
                                                             .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0)))
                                              .get_manifest_str());
     auto override_folder_location = fs::make_native(override_layer_folder.location().str());
-    env->add_implicit_layer(ManifestLayer{}
-                                .set_file_format_version(ManifestVersion(1, 0, 0))
-                                .add_layer(ManifestLayer::LayerDescription{}
-                                               .set_name(lunarg_meta_layer_name)
-                                               .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
-                                               .add_component_layer(regular_layer_name)
-                                               .set_disable_environment("DisableMeIfYouCan")
-                                               .add_override_path(override_folder_location)),
-                            "meta_test_layer.json");
-
-    InstWrapper inst{env->vulkan_functions};
+    env.add_implicit_layer(ManifestLayer{}
+                               .set_file_format_version(ManifestVersion(1, 0, 0))
+                               .add_layer(ManifestLayer::LayerDescription{}
+                                              .set_name(lunarg_meta_layer_name)
+                                              .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))
+                                              .add_component_layer(regular_layer_name)
+                                              .set_disable_environment("DisableMeIfYouCan")
+                                              .add_override_path(override_folder_location)),
+                           "meta_test_layer.json");
+
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.set_api_version(1, 1, 0);
-    FillDebugUtilsCreateDetails(inst.create_info, env->debug_log);
+    FillDebugUtilsCreateDetails(inst.create_info, env.debug_log);
     inst.CheckCreate();
-    ASSERT_TRUE(env->debug_log.find(std::string("Insert instance layer ") + regular_layer_name));
-    ASSERT_TRUE(env->debug_log.find("Indicating meta-layer-specific override paths, but using older JSON file version."));
-    env->layers.clear();
+    ASSERT_TRUE(env.debug_log.find(std::string("Insert instance layer ") + regular_layer_name));
+    ASSERT_TRUE(env.debug_log.find("Indicating meta-layer-specific override paths, but using older JSON file version."));
+    env.layers.clear();
 }
 
 // This test makes sure that any layer calling GetPhysicalDeviceProperties2 inside of CreateInstance
 // succeeds and doesn't crash.
-TEST_F(LayerCreateInstance, GetPhysicalDeviceProperties2) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
+TEST(LayerCreateInstance, GetPhysicalDeviceProperties2) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().icd_api_version = VK_MAKE_API_VERSION(0, 1, 1, 0);
 
     const char* regular_layer_name = "TestLayer";
-    env->add_explicit_layer(
+    env.add_explicit_layer(
         ManifestLayer{}
             .set_file_format_version(ManifestVersion(1, 1, 2))
             .add_layer(
                 ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
         "regular_test_layer.json");
 
-    auto& layer = env->get_test_layer(0);
+    auto& layer = env.get_test_layer(0);
     layer.set_create_instance_callback([](TestLayer& layer) -> VkResult {
         uint32_t phys_dev_count = 0;
         VkResult res = layer.instance_dispatch_table.EnumeratePhysicalDevices(layer.instance_handle, &phys_dev_count, nullptr);
@@ -1158,22 +1186,24 @@ TEST_F(LayerCreateInstance, GetPhysicalDeviceProperties2) {
         return VK_SUCCESS;
     });
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.add_layer(regular_layer_name).set_api_version(1, 1, 0);
     inst.CheckCreate();
 }
 
-TEST_F(LayerCreateInstance, GetPhysicalDeviceProperties2KHR) {
-    env->get_test_icd().physical_devices.push_back({});
-    env->get_test_icd().add_instance_extension({"VK_KHR_get_physical_device_properties2", 0});
+TEST(LayerCreateInstance, GetPhysicalDeviceProperties2KHR) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.get_test_icd().physical_devices.push_back({});
+    env.get_test_icd().add_instance_extension({"VK_KHR_get_physical_device_properties2", 0});
 
     const char* regular_layer_name = "VK_LAYER_TestLayer";
-    env->add_explicit_layer(
+    env.add_explicit_layer(
         ManifestLayer{}.add_layer(
             ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
         "regular_test_layer.json");
 
-    auto& layer = env->get_test_layer(0);
+    auto& layer = env.get_test_layer(0);
     layer.set_create_instance_callback([](TestLayer& layer) -> VkResult {
         uint32_t phys_dev_count = 1;
         VkPhysicalDevice phys_dev{};
@@ -1189,28 +1219,29 @@ TEST_F(LayerCreateInstance, GetPhysicalDeviceProperties2KHR) {
         return VK_SUCCESS;
     });
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.add_layer(regular_layer_name).add_extension("VK_KHR_get_physical_device_properties2");
     inst.CheckCreate();
 }
 
-TEST_F(ExplicitLayers, WrapObjects) {
-    auto& driver = env->get_test_icd();
+TEST(ExplicitLayers, WrapObjects) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    auto& driver = env.get_test_icd();
 
     const char* wrap_objects_name = "VK_LAYER_LUNARG_wrap_objects";
-    env->add_explicit_layer(
-        ManifestLayer{}.add_layer(
-            ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
-        "wrap_objects_layer.json");
+    env.add_explicit_layer(ManifestLayer{}.add_layer(
+                               ManifestLayer::LayerDescription{}.set_name(wrap_objects_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
+                           "wrap_objects_layer.json");
 
     const char* regular_layer_name_1 = "RegularLayer1";
-    env->add_explicit_layer(
+    env.add_explicit_layer(
         ManifestLayer{}.add_layer(
             ManifestLayer::LayerDescription{}.set_name(regular_layer_name_1).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
         "regular_layer_1.json");
 
     const char* regular_layer_name_2 = "RegularLayer2";
-    env->add_explicit_layer(
+    env.add_explicit_layer(
         ManifestLayer{}.add_layer(
             ManifestLayer::LayerDescription{}.set_name(regular_layer_name_2).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
         "regular_layer_2.json");
@@ -1220,7 +1251,7 @@ TEST_F(ExplicitLayers, WrapObjects) {
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
     {  // just the wrap layer
-        InstWrapper inst{env->vulkan_functions};
+        InstWrapper inst{env.vulkan_functions};
         inst.create_info.add_layer(wrap_objects_name);
         inst.CheckCreate();
         VkPhysicalDevice phys_dev = inst.GetPhysDev();
@@ -1230,7 +1261,7 @@ TEST_F(ExplicitLayers, WrapObjects) {
         dev.CheckCreate(phys_dev);
     }
     {  // wrap layer first
-        InstWrapper inst{env->vulkan_functions};
+        InstWrapper inst{env.vulkan_functions};
         inst.create_info.add_layer(wrap_objects_name).add_layer(regular_layer_name_1);
         inst.CheckCreate();
         VkPhysicalDevice phys_dev = inst.GetPhysDev();
@@ -1240,7 +1271,7 @@ TEST_F(ExplicitLayers, WrapObjects) {
         dev.CheckCreate(phys_dev);
     }
     {  // wrap layer last
-        InstWrapper inst{env->vulkan_functions};
+        InstWrapper inst{env.vulkan_functions};
         inst.create_info.add_layer(regular_layer_name_1).add_layer(wrap_objects_name);
         inst.CheckCreate();
         VkPhysicalDevice phys_dev = inst.GetPhysDev();
@@ -1250,7 +1281,7 @@ TEST_F(ExplicitLayers, WrapObjects) {
         dev.CheckCreate(phys_dev);
     }
     {  // wrap layer last
-        InstWrapper inst{env->vulkan_functions};
+        InstWrapper inst{env.vulkan_functions};
         inst.create_info.add_layer(regular_layer_name_1).add_layer(wrap_objects_name).add_layer(regular_layer_name_2);
         inst.CheckCreate();
         VkPhysicalDevice phys_dev = inst.GetPhysDev();
@@ -1261,8 +1292,10 @@ TEST_F(ExplicitLayers, WrapObjects) {
     }
 }
 
-TEST_F(LayerExtensions, ImplicitNoAdditionalInstanceExtension) {
-    auto& driver = env->get_test_icd();
+TEST(LayerExtensions, ImplicitNoAdditionalInstanceExtension) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
     driver.physical_devices.emplace_back("physical_device_0");
@@ -1272,28 +1305,28 @@ TEST_F(LayerExtensions, ImplicitNoAdditionalInstanceExtension) {
     const char* enable_env_var = "ENABLE_ME";
     const char* disable_env_var = "DISABLE_ME";
 
-    env->add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name(implicit_layer_name)
-                                                          .set_lib_path(TEST_LAYER_WRAP_OBJECTS)
-                                                          .set_disable_environment(disable_env_var)
-                                                          .set_enable_environment(enable_env_var)),
-                            "implicit_wrap_layer_no_ext.json");
+    env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name(implicit_layer_name)
+                                                         .set_lib_path(TEST_LAYER_WRAP_OBJECTS)
+                                                         .set_disable_environment(disable_env_var)
+                                                         .set_enable_environment(enable_env_var)),
+                           "implicit_wrap_layer_no_ext.json");
 
     uint32_t count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
-    ASSERT_EQ(count, 1);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
+    ASSERT_EQ(count, 1U);
 
     // // set enable env-var, layer should load
     set_env_var(enable_env_var, "1");
-    CheckLogForLayerString(*env, implicit_layer_name, true);
+    CheckLogForLayerString(env, implicit_layer_name, true);
 
     uint32_t extension_count = 0;
     std::vector<VkExtensionProperties> extension_props;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
     if (extension_count > 0) {
         extension_props.resize(extension_count);
         ASSERT_EQ(VK_SUCCESS,
-                  env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extension_props.data()));
+                  env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extension_props.data()));
 
         // Make sure the extensions that are implemented only in the test layers is not present.
         for (uint32_t ext = 0; ext < extension_count; ++ext) {
@@ -1302,18 +1335,20 @@ TEST_F(LayerExtensions, ImplicitNoAdditionalInstanceExtension) {
         }
     }
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     // Make sure all the function pointers are NULL as well
-    handle_assert_null(env->vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkReleaseDisplayEXT"));
-    handle_assert_null(env->vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
+    handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkReleaseDisplayEXT"));
+    handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
 
     remove_env_var(enable_env_var);
 }
 
-TEST_F(LayerExtensions, ImplicitDirDispModeInstanceExtension) {
-    auto& driver = env->get_test_icd();
+TEST(LayerExtensions, ImplicitDirDispModeInstanceExtension) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
     driver.physical_devices.emplace_back("physical_device_0");
@@ -1323,7 +1358,7 @@ TEST_F(LayerExtensions, ImplicitDirDispModeInstanceExtension) {
     const char* enable_env_var = "ENABLE_ME";
     const char* disable_env_var = "DISABLE_ME";
 
-    env->add_implicit_layer(
+    env.add_implicit_layer(
         ManifestLayer{}.add_layer(
             ManifestLayer::LayerDescription{}
                 .set_name(implicit_layer_name)
@@ -1334,20 +1369,20 @@ TEST_F(LayerExtensions, ImplicitDirDispModeInstanceExtension) {
         "implicit_wrap_layer_dir_disp_mode.json");
 
     uint32_t count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
-    ASSERT_EQ(count, 1);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
+    ASSERT_EQ(count, 1U);
 
     // // set enable env-var, layer should load
     set_env_var(enable_env_var, "1");
-    CheckLogForLayerString(*env, implicit_layer_name, true);
+    CheckLogForLayerString(env, implicit_layer_name, true);
 
     uint32_t extension_count = 0;
     std::vector<VkExtensionProperties> extension_props;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
-    ASSERT_EQ(extension_count, 3);  // the instance extension, debug_utils, and debug_report
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
+    ASSERT_EQ(extension_count, 3U);  // the instance extension, debug_utils, and debug_report
     extension_props.resize(extension_count);
     ASSERT_EQ(VK_SUCCESS,
-              env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extension_props.data()));
+              env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extension_props.data()));
 
     // Make sure the extensions that are implemented only in the test layers is not present.
     bool found = false;
@@ -1359,19 +1394,21 @@ TEST_F(LayerExtensions, ImplicitDirDispModeInstanceExtension) {
     }
     ASSERT_EQ(true, found);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.add_extension(VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME);
     inst.CheckCreate();
 
     // Make sure only the appropriate function pointers are NULL as well
-    handle_assert_has_value(env->vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkReleaseDisplayEXT"));
-    handle_assert_null(env->vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
+    handle_assert_has_value(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkReleaseDisplayEXT"));
+    handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
 
     remove_env_var(enable_env_var);
 }
 
-TEST_F(LayerExtensions, ImplicitDispSurfCountInstanceExtension) {
-    auto& driver = env->get_test_icd();
+TEST(LayerExtensions, ImplicitDispSurfCountInstanceExtension) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
     driver.physical_devices.emplace_back("physical_device_0");
@@ -1381,32 +1418,31 @@ TEST_F(LayerExtensions, ImplicitDispSurfCountInstanceExtension) {
     const char* enable_env_var = "ENABLE_ME";
     const char* disable_env_var = "DISABLE_ME";
 
-    env->add_implicit_layer(
-        ManifestLayer{}.add_layer(
-            ManifestLayer::LayerDescription{}
-                .set_name(implicit_layer_name)
-                .set_lib_path(TEST_LAYER_WRAP_OBJECTS_2)
-                .set_disable_environment(disable_env_var)
-                .set_enable_environment(enable_env_var)
-                .add_instance_extension(
-                    {VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME, 1, {"vkGetPhysicalDeviceSurfaceCapabilities2EXT"}})),
-        "implicit_wrap_layer_disp_surf_count.json");
+    env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name(implicit_layer_name)
+                                                         .set_lib_path(TEST_LAYER_WRAP_OBJECTS_2)
+                                                         .set_disable_environment(disable_env_var)
+                                                         .set_enable_environment(enable_env_var)
+                                                         .add_instance_extension({VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME,
+                                                                                  1,
+                                                                                  {"vkGetPhysicalDeviceSurfaceCapabilities2EXT"}})),
+                           "implicit_wrap_layer_disp_surf_count.json");
 
     uint32_t count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
-    ASSERT_EQ(count, 1);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
+    ASSERT_EQ(count, 1U);
 
     // // set enable env-var, layer should load
     set_env_var(enable_env_var, "1");
-    CheckLogForLayerString(*env, implicit_layer_name, true);
+    CheckLogForLayerString(env, implicit_layer_name, true);
 
     uint32_t extension_count = 0;
     std::vector<VkExtensionProperties> extension_props;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
-    ASSERT_EQ(extension_count, 3);  // the instance extension, debug_utils, and debug_report
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
+    ASSERT_EQ(extension_count, 3U);  // the instance extension, debug_utils, and debug_report
     extension_props.resize(extension_count);
     ASSERT_EQ(VK_SUCCESS,
-              env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extension_props.data()));
+              env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extension_props.data()));
 
     // Make sure the extensions that are implemented only in the test layers is not present.
     bool found = false;
@@ -1418,19 +1454,21 @@ TEST_F(LayerExtensions, ImplicitDispSurfCountInstanceExtension) {
     }
     ASSERT_EQ(true, found);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.add_extension(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME);
     inst.CheckCreate();
 
     // Make sure only the appropriate function pointers are NULL as well
-    handle_assert_null(env->vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkReleaseDisplayEXT"));
-    handle_assert_has_value(env->vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
+    handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkReleaseDisplayEXT"));
+    handle_assert_has_value(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
 
     remove_env_var(enable_env_var);
 }
 
-TEST_F(LayerExtensions, ImplicitBothInstanceExtensions) {
-    auto& driver = env->get_test_icd();
+TEST(LayerExtensions, ImplicitBothInstanceExtensions) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
     driver.physical_devices.emplace_back("physical_device_0");
@@ -1440,7 +1478,7 @@ TEST_F(LayerExtensions, ImplicitBothInstanceExtensions) {
     const char* enable_env_var = "ENABLE_ME";
     const char* disable_env_var = "DISABLE_ME";
 
-    env->add_implicit_layer(
+    env.add_implicit_layer(
         ManifestLayer{}.add_layer(
             ManifestLayer::LayerDescription{}
                 .set_name(implicit_layer_name)
@@ -1453,20 +1491,20 @@ TEST_F(LayerExtensions, ImplicitBothInstanceExtensions) {
         "implicit_wrap_layer_both_inst.json");
 
     uint32_t count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
-    ASSERT_EQ(count, 1);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
+    ASSERT_EQ(count, 1U);
 
     // // set enable env-var, layer should load
     set_env_var(enable_env_var, "1");
-    CheckLogForLayerString(*env, implicit_layer_name, true);
+    CheckLogForLayerString(env, implicit_layer_name, true);
 
     uint32_t extension_count = 0;
     std::vector<VkExtensionProperties> extension_props;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
-    ASSERT_EQ(extension_count, 4);  // the two instance extension plus debug_utils and debug_report
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
+    ASSERT_EQ(extension_count, 4U);  // the two instance extension plus debug_utils and debug_report
     extension_props.resize(extension_count);
     ASSERT_EQ(VK_SUCCESS,
-              env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extension_props.data()));
+              env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extension_props.data()));
 
     // Make sure the extensions that are implemented only in the test layers is not present.
     bool found[2] = {false, false};
@@ -1482,42 +1520,44 @@ TEST_F(LayerExtensions, ImplicitBothInstanceExtensions) {
         ASSERT_EQ(true, found[ext]);
     }
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.add_extension(VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME)
         .add_extension(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME);
     inst.CheckCreate();
 
     // Make sure only the appropriate function pointers are NULL as well
-    handle_assert_has_value(env->vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkReleaseDisplayEXT"));
-    handle_assert_has_value(env->vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
+    handle_assert_has_value(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkReleaseDisplayEXT"));
+    handle_assert_has_value(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
 
     remove_env_var(enable_env_var);
 }
 
-TEST_F(LayerExtensions, ExplicitNoAdditionalInstanceExtension) {
-    auto& driver = env->get_test_icd();
+TEST(LayerExtensions, ExplicitNoAdditionalInstanceExtension) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
     const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
-    env->add_explicit_layer(
+    env.add_explicit_layer(
         ManifestLayer{}.add_layer(
             ManifestLayer::LayerDescription{}.set_name(explicit_layer_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
         "explicit_wrap_layer_no_ext.json");
 
     uint32_t count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
-    ASSERT_EQ(count, 1);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
+    ASSERT_EQ(count, 1U);
 
     uint32_t extension_count = 0;
     std::vector<VkExtensionProperties> extension_props;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
     if (extension_count > 0) {
         extension_props.resize(extension_count);
         ASSERT_EQ(VK_SUCCESS,
-                  env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extension_props.data()));
+                  env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extension_props.data()));
 
         // Make sure the extensions are not present
         for (uint32_t ext = 0; ext < extension_count; ++ext) {
@@ -1530,11 +1570,11 @@ TEST_F(LayerExtensions, ExplicitNoAdditionalInstanceExtension) {
     extension_count = 0;
     extension_props.clear();
     ASSERT_EQ(VK_SUCCESS,
-              env->vulkan_functions.vkEnumerateInstanceExtensionProperties(explicit_layer_name, &extension_count, nullptr));
+              env.vulkan_functions.vkEnumerateInstanceExtensionProperties(explicit_layer_name, &extension_count, nullptr));
     if (extension_count > 0) {
         extension_props.resize(extension_count);
-        ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties(explicit_layer_name, &extension_count,
-                                                                                           extension_props.data()));
+        ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(explicit_layer_name, &extension_count,
+                                                                                          extension_props.data()));
 
         // Make sure the extensions still aren't present in this layer
         for (uint32_t ext = 0; ext < extension_count; ++ext) {
@@ -1543,23 +1583,25 @@ TEST_F(LayerExtensions, ExplicitNoAdditionalInstanceExtension) {
         }
     }
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     // Make sure all the function pointers are NULL as well
-    handle_assert_null(env->vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkReleaseDisplayEXT"));
-    handle_assert_null(env->vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
+    handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkReleaseDisplayEXT"));
+    handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
 }
 
-TEST_F(LayerExtensions, ExplicitDirDispModeInstanceExtension) {
-    auto& driver = env->get_test_icd();
+TEST(LayerExtensions, ExplicitDirDispModeInstanceExtension) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
     const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
-    env->add_explicit_layer(
+    env.add_explicit_layer(
         ManifestLayer{}.add_layer(
             ManifestLayer::LayerDescription{}
                 .set_name(explicit_layer_name)
@@ -1568,16 +1610,16 @@ TEST_F(LayerExtensions, ExplicitDirDispModeInstanceExtension) {
         "explicit_wrap_layer_dir_disp_mode.json");
 
     uint32_t count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
-    ASSERT_EQ(count, 1);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
+    ASSERT_EQ(count, 1U);
 
     uint32_t extension_count = 0;
     std::vector<VkExtensionProperties> extension_props;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
     if (extension_count > 0) {
         extension_props.resize(extension_count);
         ASSERT_EQ(VK_SUCCESS,
-                  env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extension_props.data()));
+                  env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extension_props.data()));
 
         // Make sure the extensions are not present
         for (uint32_t ext = 0; ext < extension_count; ++ext) {
@@ -1590,11 +1632,11 @@ TEST_F(LayerExtensions, ExplicitDirDispModeInstanceExtension) {
     extension_count = 0;
     extension_props.clear();
     ASSERT_EQ(VK_SUCCESS,
-              env->vulkan_functions.vkEnumerateInstanceExtensionProperties(explicit_layer_name, &extension_count, nullptr));
-    ASSERT_EQ(extension_count, 1);
+              env.vulkan_functions.vkEnumerateInstanceExtensionProperties(explicit_layer_name, &extension_count, nullptr));
+    ASSERT_EQ(extension_count, 1U);
     extension_props.resize(extension_count);
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties(explicit_layer_name, &extension_count,
-                                                                                       extension_props.data()));
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(explicit_layer_name, &extension_count,
+                                                                                      extension_props.data()));
 
     // Make sure the extensions still aren't present in this layer
     bool found = false;
@@ -1606,51 +1648,52 @@ TEST_F(LayerExtensions, ExplicitDirDispModeInstanceExtension) {
     }
     ASSERT_EQ(true, found);
 
-    InstWrapper inst1{env->vulkan_functions};
+    InstWrapper inst1{env.vulkan_functions};
     inst1.create_info.add_extension(VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME);
     inst1.CheckCreate(VK_ERROR_EXTENSION_NOT_PRESENT);
 
     // Make sure only the appropriate function pointers are NULL as well
-    handle_assert_null(env->vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkReleaseDisplayEXT"));
-    handle_assert_null(env->vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
+    handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkReleaseDisplayEXT"));
+    handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
 
-    InstWrapper inst2{env->vulkan_functions};
+    InstWrapper inst2{env.vulkan_functions};
     inst2.create_info.add_layer(explicit_layer_name).add_extension(VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME);
     inst2.CheckCreate();
 
     // Make sure only the appropriate function pointers are NULL as well
-    handle_assert_has_value(env->vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkReleaseDisplayEXT"));
-    handle_assert_null(env->vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
+    handle_assert_has_value(env.vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkReleaseDisplayEXT"));
+    handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
 }
 
-TEST_F(LayerExtensions, ExplicitDispSurfCountInstanceExtension) {
-    auto& driver = env->get_test_icd();
+TEST(LayerExtensions, ExplicitDispSurfCountInstanceExtension) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
     const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
-    env->add_explicit_layer(
-        ManifestLayer{}.add_layer(
-            ManifestLayer::LayerDescription{}
-                .set_name(explicit_layer_name)
-                .set_lib_path(TEST_LAYER_WRAP_OBJECTS_2)
-                .add_instance_extension(
-                    {VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME, 1, {"vkGetPhysicalDeviceSurfaceCapabilities2EXT"}})),
-        "explicit_wrap_layer_disp_surf_count.json");
+    env.add_explicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name(explicit_layer_name)
+                                                         .set_lib_path(TEST_LAYER_WRAP_OBJECTS_2)
+                                                         .add_instance_extension({VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME,
+                                                                                  1,
+                                                                                  {"vkGetPhysicalDeviceSurfaceCapabilities2EXT"}})),
+                           "explicit_wrap_layer_disp_surf_count.json");
 
     uint32_t count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
-    ASSERT_EQ(count, 1);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
+    ASSERT_EQ(count, 1U);
 
     uint32_t extension_count = 0;
     std::vector<VkExtensionProperties> extension_props;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
     if (extension_count > 0) {
         extension_props.resize(extension_count);
         ASSERT_EQ(VK_SUCCESS,
-                  env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extension_props.data()));
+                  env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extension_props.data()));
 
         // Make sure the extensions are not present
         for (uint32_t ext = 0; ext < extension_count; ++ext) {
@@ -1663,11 +1706,11 @@ TEST_F(LayerExtensions, ExplicitDispSurfCountInstanceExtension) {
     extension_count = 0;
     extension_props.clear();
     ASSERT_EQ(VK_SUCCESS,
-              env->vulkan_functions.vkEnumerateInstanceExtensionProperties(explicit_layer_name, &extension_count, nullptr));
-    ASSERT_EQ(extension_count, 1);
+              env.vulkan_functions.vkEnumerateInstanceExtensionProperties(explicit_layer_name, &extension_count, nullptr));
+    ASSERT_EQ(extension_count, 1U);
     extension_props.resize(extension_count);
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties(explicit_layer_name, &extension_count,
-                                                                                       extension_props.data()));
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(explicit_layer_name, &extension_count,
+                                                                                      extension_props.data()));
 
     // Make sure the extensions still aren't present in this layer
     bool found = false;
@@ -1679,32 +1722,34 @@ TEST_F(LayerExtensions, ExplicitDispSurfCountInstanceExtension) {
     }
     ASSERT_EQ(true, found);
 
-    InstWrapper inst1{env->vulkan_functions};
+    InstWrapper inst1{env.vulkan_functions};
     inst1.create_info.add_extension(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME);
     inst1.CheckCreate(VK_ERROR_EXTENSION_NOT_PRESENT);
 
     // Make sure only the appropriate function pointers are NULL as well
-    handle_assert_null(env->vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkReleaseDisplayEXT"));
-    handle_assert_null(env->vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
+    handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkReleaseDisplayEXT"));
+    handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
 
-    InstWrapper inst2{env->vulkan_functions};
+    InstWrapper inst2{env.vulkan_functions};
     inst2.create_info.add_layer(explicit_layer_name).add_extension(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME);
     inst2.CheckCreate();
 
     // Make sure only the appropriate function pointers are NULL as well
-    handle_assert_null(env->vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkReleaseDisplayEXT"));
-    handle_assert_has_value(env->vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
+    handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkReleaseDisplayEXT"));
+    handle_assert_has_value(env.vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
 }
 
-TEST_F(LayerExtensions, ExplicitBothInstanceExtensions) {
-    auto& driver = env->get_test_icd();
+TEST(LayerExtensions, ExplicitBothInstanceExtensions) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
     const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
-    env->add_explicit_layer(
+    env.add_explicit_layer(
         ManifestLayer{}.add_layer(
             ManifestLayer::LayerDescription{}
                 .set_name(explicit_layer_name)
@@ -1715,16 +1760,16 @@ TEST_F(LayerExtensions, ExplicitBothInstanceExtensions) {
         "explicit_wrap_layer_both_inst.json");
 
     uint32_t count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
-    ASSERT_EQ(count, 1);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
+    ASSERT_EQ(count, 1U);
 
     uint32_t extension_count = 0;
     std::vector<VkExtensionProperties> extension_props;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
     if (extension_count > 0) {
         extension_props.resize(extension_count);
         ASSERT_EQ(VK_SUCCESS,
-                  env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extension_props.data()));
+                  env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extension_props.data()));
 
         // Make sure the extensions are not present
         for (uint32_t ext = 0; ext < extension_count; ++ext) {
@@ -1737,11 +1782,11 @@ TEST_F(LayerExtensions, ExplicitBothInstanceExtensions) {
     extension_count = 0;
     extension_props.clear();
     ASSERT_EQ(VK_SUCCESS,
-              env->vulkan_functions.vkEnumerateInstanceExtensionProperties(explicit_layer_name, &extension_count, nullptr));
-    ASSERT_EQ(extension_count, 2);
+              env.vulkan_functions.vkEnumerateInstanceExtensionProperties(explicit_layer_name, &extension_count, nullptr));
+    ASSERT_EQ(extension_count, 2U);
     extension_props.resize(extension_count);
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties(explicit_layer_name, &extension_count,
-                                                                                       extension_props.data()));
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(explicit_layer_name, &extension_count,
+                                                                                      extension_props.data()));
 
     // Make sure the extensions still aren't present in this layer
     bool found[2] = {false, false};
@@ -1757,16 +1802,16 @@ TEST_F(LayerExtensions, ExplicitBothInstanceExtensions) {
         ASSERT_EQ(true, found[ext]);
     }
 
-    InstWrapper inst1{env->vulkan_functions};
+    InstWrapper inst1{env.vulkan_functions};
     inst1.create_info.add_extension(VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME)
         .add_extension(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME);
     inst1.CheckCreate(VK_ERROR_EXTENSION_NOT_PRESENT);
 
     // Make sure only the appropriate function pointers are NULL as well
-    handle_assert_null(env->vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkReleaseDisplayEXT"));
-    handle_assert_null(env->vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
+    handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkReleaseDisplayEXT"));
+    handle_assert_null(env.vulkan_functions.vkGetInstanceProcAddr(inst1.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
 
-    InstWrapper inst2{env->vulkan_functions};
+    InstWrapper inst2{env.vulkan_functions};
     inst2.create_info.add_layer(explicit_layer_name)
         .add_extension(VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME)
         .add_extension(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME);
@@ -1774,23 +1819,25 @@ TEST_F(LayerExtensions, ExplicitBothInstanceExtensions) {
     VkPhysicalDevice phys_dev = inst2.GetPhysDev();
 
     // Make sure only the appropriate function pointers are NULL as well
-    handle_assert_has_value(env->vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkReleaseDisplayEXT"));
+    handle_assert_has_value(env.vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkReleaseDisplayEXT"));
     PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT pfnGetPhysicalDeviceSurfaceCapabilities2EXT =
         reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT>(
-            env->vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
+            env.vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
     handle_assert_has_value(pfnGetPhysicalDeviceSurfaceCapabilities2EXT);
 
     VkSurfaceCapabilities2EXT surf_caps{VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT};
 
     // Call and then check a few things
     ASSERT_EQ(VK_SUCCESS, pfnGetPhysicalDeviceSurfaceCapabilities2EXT(phys_dev, VK_NULL_HANDLE, &surf_caps));
-    ASSERT_EQ(7, surf_caps.minImageCount);
-    ASSERT_EQ(12, surf_caps.maxImageCount);
-    ASSERT_EQ(365, surf_caps.maxImageArrayLayers);
+    ASSERT_EQ(7U, surf_caps.minImageCount);
+    ASSERT_EQ(12U, surf_caps.maxImageCount);
+    ASSERT_EQ(365U, surf_caps.maxImageArrayLayers);
 }
 
-TEST_F(LayerExtensions, ImplicitNoAdditionalDeviceExtension) {
-    auto& driver = env->get_test_icd();
+TEST(LayerExtensions, ImplicitNoAdditionalDeviceExtension) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
     driver.physical_devices.emplace_back("physical_device_0");
@@ -1800,32 +1847,32 @@ TEST_F(LayerExtensions, ImplicitNoAdditionalDeviceExtension) {
     const char* enable_env_var = "ENABLE_ME";
     const char* disable_env_var = "DISABLE_ME";
 
-    env->add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name(implicit_layer_name)
-                                                          .set_lib_path(TEST_LAYER_WRAP_OBJECTS)
-                                                          .set_disable_environment(disable_env_var)
-                                                          .set_enable_environment(enable_env_var)),
-                            "implicit_wrap_layer_no_ext.json");
+    env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name(implicit_layer_name)
+                                                         .set_lib_path(TEST_LAYER_WRAP_OBJECTS)
+                                                         .set_disable_environment(disable_env_var)
+                                                         .set_enable_environment(enable_env_var)),
+                           "implicit_wrap_layer_no_ext.json");
 
     uint32_t count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
-    ASSERT_EQ(count, 1);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
+    ASSERT_EQ(count, 1U);
 
     // // set enable env-var, layer should load
     set_env_var(enable_env_var, "1");
-    CheckLogForLayerString(*env, implicit_layer_name, true);
+    CheckLogForLayerString(env, implicit_layer_name, true);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
     VkPhysicalDevice phys_dev = inst.GetPhysDev();
 
     uint32_t extension_count = 0;
     std::vector<VkExtensionProperties> extension_props;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count, nullptr));
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count, nullptr));
     if (extension_count > 0) {
         extension_props.resize(extension_count);
-        ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count,
-                                                                                         extension_props.data()));
+        ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count,
+                                                                                        extension_props.data()));
 
         // Make sure the extensions that are implemented only in the test layers is not present.
         for (uint32_t ext = 0; ext < extension_count; ++ext) {
@@ -1874,8 +1921,10 @@ TEST_F(LayerExtensions, ImplicitNoAdditionalDeviceExtension) {
     remove_env_var(enable_env_var);
 }
 
-TEST_F(LayerExtensions, ImplicitMaintenanceDeviceExtension) {
-    auto& driver = env->get_test_icd();
+TEST(LayerExtensions, ImplicitMaintenanceDeviceExtension) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
     driver.physical_devices.emplace_back("physical_device_0");
@@ -1885,32 +1934,32 @@ TEST_F(LayerExtensions, ImplicitMaintenanceDeviceExtension) {
     const char* enable_env_var = "ENABLE_ME";
     const char* disable_env_var = "DISABLE_ME";
 
-    env->add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name(implicit_layer_name)
-                                                          .set_lib_path(TEST_LAYER_WRAP_OBJECTS_1)
-                                                          .set_disable_environment(disable_env_var)
-                                                          .set_enable_environment(enable_env_var)),
-                            "implicit_wrap_layer_maint.json");
+    env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name(implicit_layer_name)
+                                                         .set_lib_path(TEST_LAYER_WRAP_OBJECTS_1)
+                                                         .set_disable_environment(disable_env_var)
+                                                         .set_enable_environment(enable_env_var)),
+                           "implicit_wrap_layer_maint.json");
 
     uint32_t count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
-    ASSERT_EQ(count, 1);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
+    ASSERT_EQ(count, 1U);
 
     // // set enable env-var, layer should load
     set_env_var(enable_env_var, "1");
-    CheckLogForLayerString(*env, implicit_layer_name, true);
+    CheckLogForLayerString(env, implicit_layer_name, true);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
     VkPhysicalDevice phys_dev = inst.GetPhysDev();
 
     uint32_t extension_count = 0;
     std::vector<VkExtensionProperties> extension_props;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count, nullptr));
-    ASSERT_EQ(extension_count, 1);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count, nullptr));
+    ASSERT_EQ(extension_count, 1U);
     extension_props.resize(extension_count);
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count,
-                                                                                     extension_props.data()));
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count,
+                                                                                    extension_props.data()));
 
     // Make sure only the one extension implemented by the enabled implicit layer is present.
     bool found = false;
@@ -1933,8 +1982,10 @@ TEST_F(LayerExtensions, ImplicitMaintenanceDeviceExtension) {
     remove_env_var(enable_env_var);
 }
 
-TEST_F(LayerExtensions, ImplicitPresentImageDeviceExtension) {
-    auto& driver = env->get_test_icd();
+TEST(LayerExtensions, ImplicitPresentImageDeviceExtension) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
     driver.physical_devices.emplace_back("physical_device_0");
@@ -1944,32 +1995,32 @@ TEST_F(LayerExtensions, ImplicitPresentImageDeviceExtension) {
     const char* enable_env_var = "ENABLE_ME";
     const char* disable_env_var = "DISABLE_ME";
 
-    env->add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name(implicit_layer_name)
-                                                          .set_lib_path(TEST_LAYER_WRAP_OBJECTS_2)
-                                                          .set_disable_environment(disable_env_var)
-                                                          .set_enable_environment(enable_env_var)),
-                            "implicit_wrap_layer_pres.json");
+    env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name(implicit_layer_name)
+                                                         .set_lib_path(TEST_LAYER_WRAP_OBJECTS_2)
+                                                         .set_disable_environment(disable_env_var)
+                                                         .set_enable_environment(enable_env_var)),
+                           "implicit_wrap_layer_pres.json");
 
     uint32_t count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
-    ASSERT_EQ(count, 1);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
+    ASSERT_EQ(count, 1U);
 
     // // set enable env-var, layer should load
     set_env_var(enable_env_var, "1");
-    CheckLogForLayerString(*env, implicit_layer_name, true);
+    CheckLogForLayerString(env, implicit_layer_name, true);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
     VkPhysicalDevice phys_dev = inst.GetPhysDev();
 
     uint32_t extension_count = 0;
     std::vector<VkExtensionProperties> extension_props;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count, nullptr));
-    ASSERT_EQ(extension_count, 1);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count, nullptr));
+    ASSERT_EQ(extension_count, 1U);
     extension_props.resize(extension_count);
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count,
-                                                                                     extension_props.data()));
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count,
+                                                                                    extension_props.data()));
 
     // Make sure only the one extension implemented by the enabled implicit layer is present.
     bool found = false;
@@ -1993,8 +2044,10 @@ TEST_F(LayerExtensions, ImplicitPresentImageDeviceExtension) {
     remove_env_var(enable_env_var);
 }
 
-TEST_F(LayerExtensions, ImplicitBothDeviceExtensions) {
-    auto& driver = env->get_test_icd();
+TEST(LayerExtensions, ImplicitBothDeviceExtensions) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
     driver.physical_devices.emplace_back("physical_device_0");
@@ -2004,32 +2057,32 @@ TEST_F(LayerExtensions, ImplicitBothDeviceExtensions) {
     const char* enable_env_var = "ENABLE_ME";
     const char* disable_env_var = "DISABLE_ME";
 
-    env->add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name(implicit_layer_name)
-                                                          .set_lib_path(TEST_LAYER_WRAP_OBJECTS_3)
-                                                          .set_disable_environment(disable_env_var)
-                                                          .set_enable_environment(enable_env_var)),
-                            "implicit_wrap_layer_both_dev.json");
+    env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name(implicit_layer_name)
+                                                         .set_lib_path(TEST_LAYER_WRAP_OBJECTS_3)
+                                                         .set_disable_environment(disable_env_var)
+                                                         .set_enable_environment(enable_env_var)),
+                           "implicit_wrap_layer_both_dev.json");
 
     uint32_t count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
-    ASSERT_EQ(count, 1);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
+    ASSERT_EQ(count, 1U);
 
     // // set enable env-var, layer should load
     set_env_var(enable_env_var, "1");
-    CheckLogForLayerString(*env, implicit_layer_name, true);
+    CheckLogForLayerString(env, implicit_layer_name, true);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
     VkPhysicalDevice phys_dev = inst.GetPhysDev();
 
     uint32_t extension_count = 0;
     std::vector<VkExtensionProperties> extension_props;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count, nullptr));
-    ASSERT_EQ(extension_count, 2);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count, nullptr));
+    ASSERT_EQ(extension_count, 2U);
     extension_props.resize(extension_count);
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count,
-                                                                                     extension_props.data()));
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count,
+                                                                                    extension_props.data()));
 
     // Make sure only the one extension implemented by the enabled implicit layer is present.
     bool found[2] = {false, false};
@@ -2058,35 +2111,37 @@ TEST_F(LayerExtensions, ImplicitBothDeviceExtensions) {
     remove_env_var(enable_env_var);
 }
 
-TEST_F(LayerExtensions, ExplicitNoAdditionalDeviceExtension) {
-    auto& driver = env->get_test_icd();
+TEST(LayerExtensions, ExplicitNoAdditionalDeviceExtension) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
     const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
-    env->add_explicit_layer(
+    env.add_explicit_layer(
         ManifestLayer{}.add_layer(
             ManifestLayer::LayerDescription{}.set_name(explicit_layer_name).set_lib_path(TEST_LAYER_WRAP_OBJECTS)),
         "explicit_wrap_layer_no_ext.json");
 
     uint32_t count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
-    ASSERT_EQ(count, 1);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
+    ASSERT_EQ(count, 1U);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.add_layer(explicit_layer_name);
     inst.CheckCreate();
     VkPhysicalDevice phys_dev = inst.GetPhysDev();
 
     uint32_t extension_count = 0;
     std::vector<VkExtensionProperties> extension_props;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count, nullptr));
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count, nullptr));
     if (extension_count > 0) {
         extension_props.resize(extension_count);
-        ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count,
-                                                                                         extension_props.data()));
+        ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count,
+                                                                                        extension_props.data()));
 
         // Make sure the extensions are not present
         for (uint32_t ext = 0; ext < extension_count; ++ext) {
@@ -2099,11 +2154,11 @@ TEST_F(LayerExtensions, ExplicitNoAdditionalDeviceExtension) {
     extension_count = 0;
     extension_props.clear();
     ASSERT_EQ(VK_SUCCESS,
-              env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, explicit_layer_name, &extension_count, nullptr));
+              env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, explicit_layer_name, &extension_count, nullptr));
     if (extension_count > 0) {
         extension_props.resize(extension_count);
-        ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, explicit_layer_name,
-                                                                                         &extension_count, extension_props.data()));
+        ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, explicit_layer_name,
+                                                                                        &extension_count, extension_props.data()));
 
         // Make sure the extensions still aren't present in this layer
         for (uint32_t ext = 0; ext < extension_count; ++ext) {
@@ -2122,15 +2177,17 @@ TEST_F(LayerExtensions, ExplicitNoAdditionalDeviceExtension) {
     handle_assert_null(dev->vkGetDeviceProcAddr(dev.dev, "vkSetDeviceMemoryPriorityEXT"));
 }
 
-TEST_F(LayerExtensions, ExplicitMaintenanceDeviceExtension) {
-    auto& driver = env->get_test_icd();
+TEST(LayerExtensions, ExplicitMaintenanceDeviceExtension) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
     const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
-    env->add_explicit_layer(
+    env.add_explicit_layer(
         ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
                                       .set_name(explicit_layer_name)
                                       .set_lib_path(TEST_LAYER_WRAP_OBJECTS_1)
@@ -2139,21 +2196,21 @@ TEST_F(LayerExtensions, ExplicitMaintenanceDeviceExtension) {
         "explicit_wrap_layer_maint.json");
 
     uint32_t count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
-    ASSERT_EQ(count, 1);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
+    ASSERT_EQ(count, 1U);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.add_layer(explicit_layer_name);
     inst.CheckCreate();
     VkPhysicalDevice phys_dev = inst.GetPhysDev();
 
     uint32_t extension_count = 0;
     std::vector<VkExtensionProperties> extension_props;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count, nullptr));
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count, nullptr));
     if (extension_count > 0) {
         extension_props.resize(extension_count);
-        ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count,
-                                                                                         extension_props.data()));
+        ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count,
+                                                                                        extension_props.data()));
 
         // Make sure the extensions are not present
         for (uint32_t ext = 0; ext < extension_count; ++ext) {
@@ -2166,11 +2223,11 @@ TEST_F(LayerExtensions, ExplicitMaintenanceDeviceExtension) {
     extension_count = 0;
     extension_props.clear();
     ASSERT_EQ(VK_SUCCESS,
-              env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, explicit_layer_name, &extension_count, nullptr));
-    ASSERT_EQ(extension_count, 1);
+              env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, explicit_layer_name, &extension_count, nullptr));
+    ASSERT_EQ(extension_count, 1U);
     extension_props.resize(extension_count);
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, explicit_layer_name,
-                                                                                     &extension_count, extension_props.data()));
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, explicit_layer_name, &extension_count,
+                                                                                    extension_props.data()));
 
     // Make sure only the one extension implemented by the enabled implicit layer is present.
     bool found = true;
@@ -2191,15 +2248,17 @@ TEST_F(LayerExtensions, ExplicitMaintenanceDeviceExtension) {
     handle_assert_null(dev->vkGetDeviceProcAddr(dev.dev, "vkGetSwapchainStatusKHR"));
 }
 
-TEST_F(LayerExtensions, ExplicitPresentImageDeviceExtension) {
-    auto& driver = env->get_test_icd();
+TEST(LayerExtensions, ExplicitPresentImageDeviceExtension) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
     const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
-    env->add_explicit_layer(
+    env.add_explicit_layer(
         ManifestLayer{}.add_layer(
             ManifestLayer::LayerDescription{}
                 .set_name(explicit_layer_name)
@@ -2209,21 +2268,21 @@ TEST_F(LayerExtensions, ExplicitPresentImageDeviceExtension) {
         "explicit_wrap_layer_pres.json");
 
     uint32_t count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
-    ASSERT_EQ(count, 1);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
+    ASSERT_EQ(count, 1U);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.add_layer(explicit_layer_name);
     inst.CheckCreate();
     VkPhysicalDevice phys_dev = inst.GetPhysDev();
 
     uint32_t extension_count = 0;
     std::vector<VkExtensionProperties> extension_props;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count, nullptr));
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count, nullptr));
     if (extension_count > 0) {
         extension_props.resize(extension_count);
-        ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count,
-                                                                                         extension_props.data()));
+        ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count,
+                                                                                        extension_props.data()));
 
         // Make sure the extensions are not present
         for (uint32_t ext = 0; ext < extension_count; ++ext) {
@@ -2236,11 +2295,11 @@ TEST_F(LayerExtensions, ExplicitPresentImageDeviceExtension) {
     extension_count = 0;
     extension_props.clear();
     ASSERT_EQ(VK_SUCCESS,
-              env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, explicit_layer_name, &extension_count, nullptr));
-    ASSERT_EQ(extension_count, 1);
+              env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, explicit_layer_name, &extension_count, nullptr));
+    ASSERT_EQ(extension_count, 1U);
     extension_props.resize(extension_count);
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, explicit_layer_name,
-                                                                                     &extension_count, extension_props.data()));
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, explicit_layer_name, &extension_count,
+                                                                                    extension_props.data()));
 
     // Make sure only the one extension implemented by the enabled implicit layer is present.
     bool found = false;
@@ -2262,15 +2321,17 @@ TEST_F(LayerExtensions, ExplicitPresentImageDeviceExtension) {
     handle_assert_has_value(dev->vkGetDeviceProcAddr(dev.dev, "vkGetSwapchainStatusKHR"));
 }
 
-TEST_F(LayerExtensions, ExplicitBothDeviceExtensions) {
-    auto& driver = env->get_test_icd();
+TEST(LayerExtensions, ExplicitBothDeviceExtensions) {
+    FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    auto& driver = env.get_test_icd();
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
     const char* explicit_layer_name = "VK_LAYER_LUNARG_wrap_objects";
-    env->add_explicit_layer(
+    env.add_explicit_layer(
         ManifestLayer{}.add_layer(
             ManifestLayer::LayerDescription{}
                 .set_name(explicit_layer_name)
@@ -2281,10 +2342,10 @@ TEST_F(LayerExtensions, ExplicitBothDeviceExtensions) {
         "explicit_wrap_layer_both_dev.json");
 
     uint32_t count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
-    ASSERT_EQ(count, 1);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&count, nullptr));
+    ASSERT_EQ(count, 1U);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.add_layer(explicit_layer_name);
     inst.CheckCreate();
     VkPhysicalDevice phys_dev = inst.GetPhysDev();
@@ -2292,11 +2353,11 @@ TEST_F(LayerExtensions, ExplicitBothDeviceExtensions) {
 
     uint32_t extension_count = 0;
     std::vector<VkExtensionProperties> extension_props;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count, nullptr));
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count, nullptr));
     if (extension_count > 0) {
         extension_props.resize(extension_count);
-        ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count,
-                                                                                         extension_props.data()));
+        ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &extension_count,
+                                                                                        extension_props.data()));
 
         // Make sure the extensions are not present
         for (uint32_t ext = 0; ext < extension_count; ++ext) {
@@ -2309,11 +2370,11 @@ TEST_F(LayerExtensions, ExplicitBothDeviceExtensions) {
     extension_count = 0;
     extension_props.clear();
     ASSERT_EQ(VK_SUCCESS,
-              env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, explicit_layer_name, &extension_count, nullptr));
-    ASSERT_EQ(extension_count, 2);  // debug_utils, and debug_report
+              env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, explicit_layer_name, &extension_count, nullptr));
+    ASSERT_EQ(extension_count, 2U);  // debug_utils, and debug_report
     extension_props.resize(extension_count);
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, explicit_layer_name,
-                                                                                     &extension_count, extension_props.data()));
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, explicit_layer_name, &extension_count,
+                                                                                    extension_props.data()));
 
     // Make sure only the one extension implemented by the enabled implicit layer is present.
     bool found[2] = {false, false};
@@ -2375,10 +2436,10 @@ TEST(TestLayers, ExplicitlyEnableImplicitLayer) {
 
         uint32_t count = 0;
         env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
-        EXPECT_EQ(1, count);
+        EXPECT_EQ(1U, count);
         VkLayerProperties layer_props{};
         env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, &layer_props);
-        EXPECT_EQ(1, count);
+        EXPECT_EQ(1U, count);
         ASSERT_TRUE(string_eq(regular_layer_name, layer_props.layerName));
     }
     {  // 1.2 instance
@@ -2390,10 +2451,10 @@ TEST(TestLayers, ExplicitlyEnableImplicitLayer) {
 
         uint32_t count = 0;
         env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
-        ASSERT_EQ(1, count);
+        ASSERT_EQ(1U, count);
         VkLayerProperties layer_props{};
         env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, &layer_props);
-        ASSERT_EQ(1, count);
+        ASSERT_EQ(1U, count);
     }
 }
 
@@ -2416,11 +2477,11 @@ TEST(TestLayers, NewerInstanceVersionThanImplicitLayer) {
     {  // global functions
         uint32_t layer_count = 0;
         EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr));
-        EXPECT_EQ(layer_count, 1);
+        EXPECT_EQ(layer_count, 1U);
 
         std::array<VkLayerProperties, 1> layer_props;
         EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()));
-        EXPECT_EQ(layer_count, 1);
+        EXPECT_EQ(layer_count, 1U);
         EXPECT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name));
     }
     {  // 1.1 instance - should find the implicit layer
@@ -2431,10 +2492,10 @@ TEST(TestLayers, NewerInstanceVersionThanImplicitLayer) {
 
         uint32_t count = 0;
         env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
-        EXPECT_EQ(1, count);
+        EXPECT_EQ(1U, count);
         VkLayerProperties layer_props{};
         env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, &layer_props);
-        EXPECT_EQ(1, count);
+        EXPECT_EQ(1U, count);
         ASSERT_TRUE(string_eq(regular_layer_name, layer_props.layerName));
     }
     {  // 1.2 instance -- instance layer shouldn't be found
@@ -2450,10 +2511,10 @@ TEST(TestLayers, NewerInstanceVersionThanImplicitLayer) {
 
         uint32_t count = 0;
         env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
-        ASSERT_EQ(0, count);
+        ASSERT_EQ(0U, count);
         VkLayerProperties layer_props{};
         env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, &layer_props);
-        ASSERT_EQ(0, count);
+        ASSERT_EQ(0U, count);
     }
 }
 
@@ -2477,11 +2538,11 @@ TEST(TestLayers, ImplicitLayerPre10APIVersion) {
 
         uint32_t layer_count = 0;
         EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr));
-        EXPECT_EQ(layer_count, 1);
+        EXPECT_EQ(layer_count, 1U);
 
         std::array<VkLayerProperties, 1> layer_props;
         EXPECT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()));
-        EXPECT_EQ(layer_count, 1);
+        EXPECT_EQ(layer_count, 1U);
         EXPECT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name));
     }
     {  // 1.0 instance -- instance layer should be found
@@ -2496,10 +2557,10 @@ TEST(TestLayers, ImplicitLayerPre10APIVersion) {
 
         uint32_t count = 0;
         env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
-        ASSERT_EQ(0, count);
+        ASSERT_EQ(0U, count);
         VkLayerProperties layer_props{};
         env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, &layer_props);
-        ASSERT_EQ(0, count);
+        ASSERT_EQ(0U, count);
     }
     {  // 1.1 instance -- instance layer should be found
         DebugUtilsLogger log;
@@ -2512,10 +2573,10 @@ TEST(TestLayers, ImplicitLayerPre10APIVersion) {
         VkPhysicalDevice phys_dev = inst.GetPhysDev();
         uint32_t count = 0;
         env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
-        ASSERT_EQ(0, count);
+        ASSERT_EQ(0U, count);
         VkLayerProperties layer_props{};
         env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, &layer_props);
-        ASSERT_EQ(0, count);
+        ASSERT_EQ(0U, count);
     }
     {  // 1.2 instance -- instance layer shouldn't be found
         DebugUtilsLogger log;
@@ -2529,10 +2590,10 @@ TEST(TestLayers, ImplicitLayerPre10APIVersion) {
 
         uint32_t count = 0;
         env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
-        ASSERT_EQ(0, count);
+        ASSERT_EQ(0U, count);
         VkLayerProperties layer_props{};
         env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, &layer_props);
-        ASSERT_EQ(0, count);
+        ASSERT_EQ(0U, count);
     }
     {  // application doesn't state its API version
         DebugUtilsLogger log;
@@ -2546,10 +2607,10 @@ TEST(TestLayers, ImplicitLayerPre10APIVersion) {
 
         uint32_t count = 0;
         env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, nullptr);
-        ASSERT_EQ(0, count);
+        ASSERT_EQ(0U, count);
         VkLayerProperties layer_props{};
         env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &count, &layer_props);
-        ASSERT_EQ(0, count);
+        ASSERT_EQ(0U, count);
     }
 }
 
@@ -2788,8 +2849,9 @@ TEST(TestLayers, DeviceLayerNotPresent) {
     dev.CheckCreate(phys_dev);
 }
 
-TEST_F(LayerPhysDeviceMod, AddPhysicalDevices) {
+TEST(LayerPhysDeviceMod, AddPhysicalDevices) {
     FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
     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)
@@ -2807,15 +2869,10 @@ TEST_F(LayerPhysDeviceMod, AddPhysicalDevices) {
         VkPhysicalDeviceProperties properties{};
         properties.apiVersion = VK_API_VERSION_1_2;
         properties.vendorID = 0x11000000 + (icd << 6);
-        char vendor_char = 'a' + icd;
         for (uint32_t dev = 0; dev < 3; ++dev) {
             properties.deviceID = properties.vendorID + dev;
             properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
-            char dev_char = '0' + dev;
-            std::string dev_name = "physdev_";
-            dev_name += vendor_char;
-            dev_name += "_";
-            dev_name += dev_char;
+            auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev);
 #if defined(_WIN32)
             strncpy_s(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, dev_name.c_str(), dev_name.length() + 1);
 #else
@@ -2871,8 +2928,9 @@ TEST_F(LayerPhysDeviceMod, AddPhysicalDevices) {
     ASSERT_EQ(found_incomplete, icd_devices);
 }
 
-TEST_F(LayerPhysDeviceMod, RemovePhysicalDevices) {
+TEST(LayerPhysDeviceMod, RemovePhysicalDevices) {
     FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
     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)
@@ -2890,15 +2948,10 @@ TEST_F(LayerPhysDeviceMod, RemovePhysicalDevices) {
         VkPhysicalDeviceProperties properties{};
         properties.apiVersion = VK_API_VERSION_1_2;
         properties.vendorID = 0x11000000 + (icd << 6);
-        char vendor_char = 'a' + icd;
         for (uint32_t dev = 0; dev < 3; ++dev) {
             properties.deviceID = properties.vendorID + dev;
             properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
-            char dev_char = '0' + dev;
-            std::string dev_name = "physdev_";
-            dev_name += vendor_char;
-            dev_name += "_";
-            dev_name += dev_char;
+            auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev);
 #if defined(_WIN32)
             strncpy_s(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, dev_name.c_str(), dev_name.length() + 1);
 #else
@@ -2927,8 +2980,9 @@ TEST_F(LayerPhysDeviceMod, RemovePhysicalDevices) {
     ASSERT_EQ(dev_count, returned_phys_dev_count);
 }
 
-TEST_F(LayerPhysDeviceMod, ReorderPhysicalDevices) {
+TEST(LayerPhysDeviceMod, ReorderPhysicalDevices) {
     FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
     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)
@@ -2946,15 +3000,10 @@ TEST_F(LayerPhysDeviceMod, ReorderPhysicalDevices) {
         VkPhysicalDeviceProperties properties{};
         properties.apiVersion = VK_API_VERSION_1_2;
         properties.vendorID = 0x11000000 + (icd << 6);
-        char vendor_char = 'a' + icd;
         for (uint32_t dev = 0; dev < 3; ++dev) {
             properties.deviceID = properties.vendorID + dev;
             properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
-            char dev_char = '0' + dev;
-            std::string dev_name = "physdev_";
-            dev_name += vendor_char;
-            dev_name += "_";
-            dev_name += dev_char;
+            auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev);
 #if defined(_WIN32)
             strncpy_s(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, dev_name.c_str(), dev_name.length() + 1);
 #else
@@ -2983,8 +3032,9 @@ TEST_F(LayerPhysDeviceMod, ReorderPhysicalDevices) {
     ASSERT_EQ(dev_count, returned_phys_dev_count);
 }
 
-TEST_F(LayerPhysDeviceMod, AddRemoveAndReorderPhysicalDevices) {
+TEST(LayerPhysDeviceMod, AddRemoveAndReorderPhysicalDevices) {
     FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
     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)
@@ -3002,15 +3052,10 @@ TEST_F(LayerPhysDeviceMod, AddRemoveAndReorderPhysicalDevices) {
         VkPhysicalDeviceProperties properties{};
         properties.apiVersion = VK_API_VERSION_1_2;
         properties.vendorID = 0x11000000 + (icd << 6);
-        char vendor_char = 'a' + icd;
         for (uint32_t dev = 0; dev < 3; ++dev) {
             properties.deviceID = properties.vendorID + dev;
             properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
-            char dev_char = '0' + dev;
-            std::string dev_name = "physdev_";
-            dev_name += vendor_char;
-            dev_name += "_";
-            dev_name += dev_char;
+            auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev);
 #if defined(_WIN32)
             strncpy_s(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, dev_name.c_str(), dev_name.length() + 1);
 #else
@@ -3049,8 +3094,8 @@ TEST_F(LayerPhysDeviceMod, AddRemoveAndReorderPhysicalDevices) {
 
     // Should see 2 removed, but 3 added so a diff count of 1
     uint32_t diff_count = dev_count - icd_devices;
-    ASSERT_EQ(1, diff_count);
-    ASSERT_EQ(found_added_count, 3);
+    ASSERT_EQ(1U, diff_count);
+    ASSERT_EQ(found_added_count, 3U);
 }
 
 static bool GroupsAreTheSame(VkPhysicalDeviceGroupProperties a, VkPhysicalDeviceGroupProperties b) {
@@ -3065,8 +3110,9 @@ static bool GroupsAreTheSame(VkPhysicalDeviceGroupProperties a, VkPhysicalDevice
     return true;
 }
 
-TEST_F(LayerPhysDeviceMod, AddPhysicalDeviceGroups) {
+TEST(LayerPhysDeviceMod, AddPhysicalDeviceGroups) {
     FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
     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)
@@ -3084,15 +3130,10 @@ TEST_F(LayerPhysDeviceMod, AddPhysicalDeviceGroups) {
         VkPhysicalDeviceProperties properties{};
         properties.apiVersion = VK_API_VERSION_1_2;
         properties.vendorID = 0x11000000 + (icd << 6);
-        char vendor_char = 'a' + icd;
         for (uint32_t dev = 0; dev < 3; ++dev) {
             properties.deviceID = properties.vendorID + dev;
             properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
-            char dev_char = '0' + dev;
-            std::string dev_name = "physdev_";
-            dev_name += vendor_char;
-            dev_name += "_";
-            dev_name += dev_char;
+            auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev);
 #if defined(_WIN32)
             strncpy_s(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, dev_name.c_str(), dev_name.length() + 1);
 #else
@@ -3159,8 +3200,9 @@ TEST_F(LayerPhysDeviceMod, AddPhysicalDeviceGroups) {
     ASSERT_EQ(found_incomplete, icd_groups);
 }
 
-TEST_F(LayerPhysDeviceMod, RemovePhysicalDeviceGroups) {
+TEST(LayerPhysDeviceMod, RemovePhysicalDeviceGroups) {
     FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
     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)
@@ -3178,15 +3220,10 @@ TEST_F(LayerPhysDeviceMod, RemovePhysicalDeviceGroups) {
         VkPhysicalDeviceProperties properties{};
         properties.apiVersion = VK_API_VERSION_1_2;
         properties.vendorID = 0x11000000 + (icd << 6);
-        char vendor_char = 'a' + icd;
         for (uint32_t dev = 0; dev < 3; ++dev) {
             properties.deviceID = properties.vendorID + dev;
             properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
-            char dev_char = '0' + dev;
-            std::string dev_name = "physdev_";
-            dev_name += vendor_char;
-            dev_name += "_";
-            dev_name += dev_char;
+            auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev);
 #if defined(_WIN32)
             strncpy_s(properties.deviceName, dev_name.c_str(), VK_MAX_PHYSICAL_DEVICE_NAME_SIZE);
 #else
@@ -3218,8 +3255,9 @@ TEST_F(LayerPhysDeviceMod, RemovePhysicalDeviceGroups) {
     ASSERT_EQ(grp_count, returned_group_count);
 }
 
-TEST_F(LayerPhysDeviceMod, ReorderPhysicalDeviceGroups) {
+TEST(LayerPhysDeviceMod, ReorderPhysicalDeviceGroups) {
     FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
     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)
@@ -3237,15 +3275,10 @@ TEST_F(LayerPhysDeviceMod, ReorderPhysicalDeviceGroups) {
         VkPhysicalDeviceProperties properties{};
         properties.apiVersion = VK_API_VERSION_1_2;
         properties.vendorID = 0x11000000 + (icd << 6);
-        char vendor_char = 'a' + icd;
         for (uint32_t dev = 0; dev < 3; ++dev) {
             properties.deviceID = properties.vendorID + dev;
             properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
-            char dev_char = '0' + dev;
-            std::string dev_name = "physdev_";
-            dev_name += vendor_char;
-            dev_name += "_";
-            dev_name += dev_char;
+            auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev);
 #if defined(_WIN32)
             strncpy_s(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, dev_name.c_str(), dev_name.length() + 1);
 #else
@@ -3277,8 +3310,9 @@ TEST_F(LayerPhysDeviceMod, ReorderPhysicalDeviceGroups) {
     ASSERT_EQ(grp_count, returned_group_count);
 }
 
-TEST_F(LayerPhysDeviceMod, AddRemoveAndReorderPhysicalDeviceGroups) {
+TEST(LayerPhysDeviceMod, AddRemoveAndReorderPhysicalDeviceGroups) {
     FrameworkEnvironment env;
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
     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)
@@ -3296,15 +3330,10 @@ TEST_F(LayerPhysDeviceMod, AddRemoveAndReorderPhysicalDeviceGroups) {
         VkPhysicalDeviceProperties properties{};
         properties.apiVersion = VK_API_VERSION_1_2;
         properties.vendorID = 0x11000000 + (icd << 6);
-        char vendor_char = 'a' + icd;
         for (uint32_t dev = 0; dev < 3; ++dev) {
             properties.deviceID = properties.vendorID + dev;
             properties.deviceType = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
-            char dev_char = '0' + dev;
-            std::string dev_name = "physdev_";
-            dev_name += vendor_char;
-            dev_name += "_";
-            dev_name += dev_char;
+            auto dev_name = std::string("physdev_") + std::to_string(icd) + "_" + std::to_string(dev);
 #if defined(_WIN32)
             strncpy_s(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE, dev_name.c_str(), dev_name.length() + 1);
 #else
@@ -3353,6 +3382,6 @@ TEST_F(LayerPhysDeviceMod, AddRemoveAndReorderPhysicalDeviceGroups) {
     // Should see 2 devices removed which should result in 1 group removed and since 3
     // devices were added we should have 3 new groups.  So we should have a diff of 2
     // groups and 3 new groups
-    ASSERT_EQ(2, diff_count);
-    ASSERT_EQ(found_added_count, 3);
+    ASSERT_EQ(2U, diff_count);
+    ASSERT_EQ(found_added_count, 3U);
 }
diff --git a/tests/loader_phys_dev_inst_ext_tests.cpp b/tests/loader_phys_dev_inst_ext_tests.cpp
index 7e12af42f..8b3c20e3d 100644
--- a/tests/loader_phys_dev_inst_ext_tests.cpp
+++ b/tests/loader_phys_dev_inst_ext_tests.cpp
@@ -104,7 +104,7 @@ TEST(LoaderInstPhysDevExts, PhysDevProps2KHRInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkPhysicalDeviceProperties props{};
     instance->vkGetPhysicalDeviceProperties(physical_device, &props);
@@ -142,7 +142,7 @@ TEST(LoaderInstPhysDevExts, PhysDevProps2Simple) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkPhysicalDeviceProperties props{};
     instance->vkGetPhysicalDeviceProperties(physical_device, &props);
@@ -187,7 +187,7 @@ TEST(LoaderInstPhysDevExts, PhysDevProps2KHRInstanceSupports11) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkPhysicalDeviceProperties props{};
     instance->vkGetPhysicalDeviceProperties(physical_device, &props);
@@ -452,7 +452,7 @@ TEST(LoaderInstPhysDevExts, PhysDevFeats2KHRInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkPhysicalDeviceFeatures feats{};
     instance->vkGetPhysicalDeviceFeatures(physical_device, &feats);
@@ -483,7 +483,7 @@ TEST(LoaderInstPhysDevExts, PhysDevFeats2Simple) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkPhysicalDeviceFeatures feats{};
     instance->vkGetPhysicalDeviceFeatures(physical_device, &feats);
@@ -521,7 +521,7 @@ TEST(LoaderInstPhysDevExts, PhysDevFeats2KHRInstanceSupports11) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkPhysicalDeviceFeatures feats{};
     instance->vkGetPhysicalDeviceFeatures(physical_device, &feats);
@@ -672,7 +672,7 @@ TEST(LoaderInstPhysDevExts, PhysDevFormatProps2KHRInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkFormatProperties props{};
     instance->vkGetPhysicalDeviceFormatProperties(physical_device, VK_FORMAT_R4G4_UNORM_PACK8, &props);
@@ -706,7 +706,7 @@ TEST(LoaderInstPhysDevExts, PhysDevFormatProps2Simple) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkFormatProperties props{};
     instance->vkGetPhysicalDeviceFormatProperties(physical_device, VK_FORMAT_R4G4_UNORM_PACK8, &props);
@@ -747,7 +747,7 @@ TEST(LoaderInstPhysDevExts, PhysDevFormatProps2KHRInstanceSupports11) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkFormatProperties props{};
     instance->vkGetPhysicalDeviceFormatProperties(physical_device, VK_FORMAT_R4G4_UNORM_PACK8, &props);
@@ -904,7 +904,7 @@ TEST(LoaderInstPhysDevExts, PhysDevImageFormatProps2KHRInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkImageFormatProperties props{};
     ASSERT_EQ(VK_SUCCESS,
@@ -954,7 +954,7 @@ TEST(LoaderInstPhysDevExts, PhysDevImageFormatProps2Simple) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkImageFormatProperties props{};
     ASSERT_EQ(VK_SUCCESS,
@@ -1012,7 +1012,7 @@ TEST(LoaderInstPhysDevExts, PhysDevImageFormatProps2KHRInstanceSupports11) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkImageFormatProperties props{};
     ASSERT_EQ(VK_SUCCESS,
@@ -1225,7 +1225,7 @@ TEST(LoaderInstPhysDevExts, PhysDevMemoryProps2KHRInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkPhysicalDeviceMemoryProperties props{};
     instance->vkGetPhysicalDeviceMemoryProperties(physical_device, &props);
@@ -1257,7 +1257,7 @@ TEST(LoaderInstPhysDevExts, PhysDevMemoryProps2Simple) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkPhysicalDeviceMemoryProperties props{};
     instance->vkGetPhysicalDeviceMemoryProperties(physical_device, &props);
@@ -1296,7 +1296,7 @@ TEST(LoaderInstPhysDevExts, PhysDevMemoryProps2KHRInstanceSupports11) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkPhysicalDeviceMemoryProperties props{};
     instance->vkGetPhysicalDeviceMemoryProperties(physical_device, &props);
@@ -1468,7 +1468,7 @@ TEST(LoaderInstPhysDevExts, PhysDevQueueFamilyProps2KHRInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     uint32_t ret_fam_1 = 0;
     std::vector<VkQueueFamilyProperties> props{};
@@ -1509,7 +1509,7 @@ TEST(LoaderInstPhysDevExts, PhysDevQueueFamilyProps2Simple) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     uint32_t ret_fam_1 = 0;
     std::vector<VkQueueFamilyProperties> props{};
@@ -1557,7 +1557,7 @@ TEST(LoaderInstPhysDevExts, PhysDevQueueFamilyProps2KHRInstanceSupports11) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     uint32_t ret_fam_1 = 0;
     std::vector<VkQueueFamilyProperties> props{};
@@ -1742,19 +1742,19 @@ TEST(LoaderInstPhysDevExts, PhysDevSparseImageFormatProps2KHRInstanceAndICDSuppo
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     std::vector<VkSparseImageFormatProperties> props{};
     uint32_t sparse_count_1 = 0;
     instance->vkGetPhysicalDeviceSparseImageFormatProperties(physical_device, VK_FORMAT_R4G4_UNORM_PACK8, VK_IMAGE_TYPE_2D,
                                                              VK_SAMPLE_COUNT_4_BIT, VK_IMAGE_USAGE_STORAGE_BIT,
                                                              VK_IMAGE_TILING_OPTIMAL, &sparse_count_1, nullptr);
-    ASSERT_NE(sparse_count_1, 0);
+    ASSERT_NE(sparse_count_1, 0U);
     props.resize(sparse_count_1);
     instance->vkGetPhysicalDeviceSparseImageFormatProperties(physical_device, VK_FORMAT_R4G4_UNORM_PACK8, VK_IMAGE_TYPE_2D,
                                                              VK_SAMPLE_COUNT_4_BIT, VK_IMAGE_USAGE_STORAGE_BIT,
                                                              VK_IMAGE_TILING_OPTIMAL, &sparse_count_1, props.data());
-    ASSERT_NE(sparse_count_1, 0);
+    ASSERT_NE(sparse_count_1, 0U);
 
     VkPhysicalDeviceSparseImageFormatInfo2 info2{
         VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,  // sType
@@ -1797,19 +1797,19 @@ TEST(LoaderInstPhysDevExts, PhysDevSparseImageFormatProps2Simple) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     std::vector<VkSparseImageFormatProperties> props{};
     uint32_t sparse_count_1 = 0;
     instance->vkGetPhysicalDeviceSparseImageFormatProperties(physical_device, VK_FORMAT_R4G4_UNORM_PACK8, VK_IMAGE_TYPE_2D,
                                                              VK_SAMPLE_COUNT_4_BIT, VK_IMAGE_USAGE_STORAGE_BIT,
                                                              VK_IMAGE_TILING_OPTIMAL, &sparse_count_1, nullptr);
-    ASSERT_NE(sparse_count_1, 0);
+    ASSERT_NE(sparse_count_1, 0U);
     props.resize(sparse_count_1);
     instance->vkGetPhysicalDeviceSparseImageFormatProperties(physical_device, VK_FORMAT_R4G4_UNORM_PACK8, VK_IMAGE_TYPE_2D,
                                                              VK_SAMPLE_COUNT_4_BIT, VK_IMAGE_USAGE_STORAGE_BIT,
                                                              VK_IMAGE_TILING_OPTIMAL, &sparse_count_1, props.data());
-    ASSERT_NE(sparse_count_1, 0);
+    ASSERT_NE(sparse_count_1, 0U);
 
     VkPhysicalDeviceSparseImageFormatInfo2 info2{
         VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,  // sType
@@ -1859,19 +1859,19 @@ TEST(LoaderInstPhysDevExts, PhysDevSparseImageFormatProps2KHRInstanceSupports11)
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     std::vector<VkSparseImageFormatProperties> props{};
     uint32_t sparse_count_1 = 0;
     instance->vkGetPhysicalDeviceSparseImageFormatProperties(physical_device, VK_FORMAT_R4G4_UNORM_PACK8, VK_IMAGE_TYPE_2D,
                                                              VK_SAMPLE_COUNT_4_BIT, VK_IMAGE_USAGE_STORAGE_BIT,
                                                              VK_IMAGE_TILING_OPTIMAL, &sparse_count_1, nullptr);
-    ASSERT_NE(sparse_count_1, 0);
+    ASSERT_NE(sparse_count_1, 0U);
     props.resize(sparse_count_1);
     instance->vkGetPhysicalDeviceSparseImageFormatProperties(physical_device, VK_FORMAT_R4G4_UNORM_PACK8, VK_IMAGE_TYPE_2D,
                                                              VK_SAMPLE_COUNT_4_BIT, VK_IMAGE_USAGE_STORAGE_BIT,
                                                              VK_IMAGE_TILING_OPTIMAL, &sparse_count_1, props.data());
-    ASSERT_NE(sparse_count_1, 0);
+    ASSERT_NE(sparse_count_1, 0U);
 
     VkPhysicalDeviceSparseImageFormatInfo2 info2{
         VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,  // sType
@@ -1974,12 +1974,12 @@ TEST(LoaderInstPhysDevExts, PhysDevSparseImageFormatPropsMixed) {
         instance->vkGetPhysicalDeviceSparseImageFormatProperties(
             physical_devices[dev], VK_FORMAT_R4G4_UNORM_PACK8, VK_IMAGE_TYPE_2D, VK_SAMPLE_COUNT_4_BIT, VK_IMAGE_USAGE_STORAGE_BIT,
             VK_IMAGE_TILING_OPTIMAL, &sparse_count_1, nullptr);
-        ASSERT_NE(sparse_count_1, 0);
+        ASSERT_NE(sparse_count_1, 0U);
         props.resize(sparse_count_1);
         instance->vkGetPhysicalDeviceSparseImageFormatProperties(
             physical_devices[dev], VK_FORMAT_R4G4_UNORM_PACK8, VK_IMAGE_TYPE_2D, VK_SAMPLE_COUNT_4_BIT, VK_IMAGE_USAGE_STORAGE_BIT,
             VK_IMAGE_TILING_OPTIMAL, &sparse_count_1, props.data());
-        ASSERT_NE(sparse_count_1, 0);
+        ASSERT_NE(sparse_count_1, 0U);
 
         VkPhysicalDeviceSparseImageFormatInfo2 info2{
             VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,  // sType
@@ -2076,7 +2076,7 @@ TEST(LoaderInstPhysDevExts, PhysDevExtBufProps2KHRInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkPhysicalDeviceExternalBufferInfoKHR info{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR};
     VkExternalBufferPropertiesKHR props{VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR};
@@ -2107,7 +2107,7 @@ TEST(LoaderInstPhysDevExts, PhysDevExtBufProps2Simple) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkPhysicalDeviceExternalBufferInfo info{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO};
     VkExternalBufferProperties props{VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES};
@@ -2289,7 +2289,7 @@ TEST(LoaderInstPhysDevExts, PhysDevExtSemProps2KHRInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkPhysicalDeviceExternalSemaphoreInfoKHR info{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR};
     VkExternalSemaphorePropertiesKHR props{VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR};
@@ -2319,7 +2319,7 @@ TEST(LoaderInstPhysDevExts, PhysDevExtSemProps2Simple) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkPhysicalDeviceExternalSemaphoreInfo info{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO};
     VkExternalSemaphoreProperties props{VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES};
@@ -2500,7 +2500,7 @@ TEST(LoaderInstPhysDevExts, PhysDevExtFenceProps2KHRInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkPhysicalDeviceExternalFenceInfoKHR info{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR};
     VkExternalFencePropertiesKHR props{VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR};
@@ -2530,7 +2530,7 @@ TEST(LoaderInstPhysDevExts, PhysDevExtFenceProps2Simple) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkPhysicalDeviceExternalFenceInfo info{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO};
     VkExternalFenceProperties props{VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES};
@@ -2755,7 +2755,7 @@ TEST(LoaderInstPhysDevExts, PhysDevSurfaceCaps2KHRInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkSurfaceKHR surface;
     VkHeadlessSurfaceCreateInfoEXT create_info{VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT};
@@ -2961,7 +2961,7 @@ TEST(LoaderInstPhysDevExts, PhysDevSurfaceFormats2KHRInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkSurfaceKHR surface;
     VkHeadlessSurfaceCreateInfoEXT create_info{VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT};
@@ -3077,10 +3077,10 @@ TEST(LoaderInstPhysDevExts, PhysDevSurfaceFormats2KHRMixed) {
         std::vector<VkSurfaceFormatKHR> props{};
         uint32_t count_1 = 0;
         ASSERT_EQ(VK_SUCCESS, GetPhysicalDeviceSurfaceFormats(physical_devices[dev], surface, &count_1, nullptr));
-        ASSERT_NE(0, count_1);
+        ASSERT_NE(0U, count_1);
         props.resize(count_1);
         ASSERT_EQ(VK_SUCCESS, GetPhysicalDeviceSurfaceFormats(physical_devices[dev], surface, &count_1, props.data()));
-        ASSERT_NE(0, count_1);
+        ASSERT_NE(0U, count_1);
 
         VkPhysicalDeviceSurfaceInfo2KHR info{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, nullptr, surface};
         std::vector<VkSurfaceFormat2KHR> props2{};
@@ -3187,7 +3187,7 @@ TEST(LoaderInstPhysDevExts, PhysDevDispPropsKHRInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     std::vector<VkDisplayPropertiesKHR> props{};
     uint32_t prop_count = 0;
@@ -3285,7 +3285,7 @@ TEST(LoaderInstPhysDevExts, PhysDevDispPropsKHRMixed) {
                     if (icd == 1) {
                         // For this extension, if no support exists (like for ICD 1), the value of 0 should be returned by the
                         // loader.
-                        ASSERT_EQ(0, prop_count);
+                        ASSERT_EQ(0U, prop_count);
                     } else {
                         ASSERT_EQ(cur_dev.display_properties.size(), prop_count);
                         props.resize(prop_count);
@@ -3374,7 +3374,7 @@ TEST(LoaderInstPhysDevExts, PhysDevDispPlanePropsKHRInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     std::vector<VkDisplayPlanePropertiesKHR> props{};
     uint32_t prop_count = 0;
@@ -3472,7 +3472,7 @@ TEST(LoaderInstPhysDevExts, PhysDevDispPlanePropsKHRMixed) {
                     if (icd == 1) {
                         // For this extension, if no support exists (like for ICD 1), the value of 0 should be returned by the
                         // loader.
-                        ASSERT_EQ(0, prop_count);
+                        ASSERT_EQ(0U, prop_count);
                     } else {
                         ASSERT_EQ(cur_dev.display_plane_properties.size(), prop_count);
                         props.resize(prop_count);
@@ -3559,7 +3559,7 @@ TEST(LoaderInstPhysDevExts, GetDispPlaneSupDispsKHRInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     std::vector<VkDisplayKHR> disps{};
     uint32_t disp_count = 0;
@@ -3657,7 +3657,7 @@ TEST(LoaderInstPhysDevExts, GetDispPlaneSupDispsKHRMixed) {
                     if (icd == 1) {
                         // For this extension, if no support exists (like for ICD 1), the value of 0 should be returned by the
                         // loader.
-                        ASSERT_EQ(0, disp_count);
+                        ASSERT_EQ(0U, disp_count);
                     } else {
                         ASSERT_EQ(cur_dev.displays.size(), disp_count);
                         disps.resize(disp_count);
@@ -3751,7 +3751,7 @@ TEST(LoaderInstPhysDevExts, GetDispModePropsKHRInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     std::vector<VkDisplayModePropertiesKHR> props{};
     uint32_t props_count = 0;
@@ -3848,7 +3848,7 @@ TEST(LoaderInstPhysDevExts, GetDispModePropsKHRMixed) {
                     if (icd == 1) {
                         // For this extension, if no support exists (like for ICD 1), the value of 0 should be returned by the
                         // loader.
-                        ASSERT_EQ(0, props_count);
+                        ASSERT_EQ(0U, props_count);
                     } else {
                         std::vector<VkDisplayModePropertiesKHR> props{};
                         ASSERT_EQ(cur_dev.display_mode_properties.size(), props_count);
@@ -3921,7 +3921,7 @@ TEST(LoaderInstPhysDevExts, GetDispModesKHRInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkDisplayModeKHR mode{};
     VkDisplayModeCreateInfoKHR create_info{VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR};
@@ -4143,7 +4143,7 @@ TEST(LoaderInstPhysDevExts, GetDispPlaneCapsKHRInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkDisplayPlaneCapabilitiesKHR caps{};
     ASSERT_EQ(VK_SUCCESS, GetDisplayPlaneCapabilities(physical_device, 0, 0, &caps));
@@ -4318,12 +4318,12 @@ TEST(LoaderInstPhysDevExts, PhysDevDispProps2KHRInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     std::vector<VkDisplayPropertiesKHR> props{};
     uint32_t prop_count = 0;
     ASSERT_EQ(VK_SUCCESS, GetPhysicalDeviceDisplayProperties(physical_device, &prop_count, nullptr));
-    ASSERT_NE(0, prop_count);
+    ASSERT_NE(0U, prop_count);
     props.resize(prop_count);
     ASSERT_EQ(VK_SUCCESS, GetPhysicalDeviceDisplayProperties(physical_device, &prop_count, props.data()));
 
@@ -4411,7 +4411,7 @@ TEST(LoaderInstPhysDevExts, PhysDevDispProps2KHRMixed) {
         std::vector<VkDisplayPropertiesKHR> props{};
         uint32_t prop_count = 0;
         ASSERT_EQ(VK_SUCCESS, GetPhysicalDeviceDisplayProperties(physical_devices[dev], &prop_count, nullptr));
-        ASSERT_NE(0, prop_count);
+        ASSERT_NE(0U, prop_count);
         props.resize(prop_count);
         ASSERT_EQ(VK_SUCCESS, GetPhysicalDeviceDisplayProperties(physical_devices[dev], &prop_count, props.data()));
 
@@ -4492,12 +4492,12 @@ TEST(LoaderInstPhysDevExts, PhysDevDispPlaneProps2KHRInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     std::vector<VkDisplayPlanePropertiesKHR> props{};
     uint32_t prop_count = 0;
     ASSERT_EQ(VK_SUCCESS, GetPhysicalDeviceDisplayPlaneProperties(physical_device, &prop_count, nullptr));
-    ASSERT_NE(0, prop_count);
+    ASSERT_NE(0U, prop_count);
     props.resize(prop_count);
     ASSERT_EQ(VK_SUCCESS, GetPhysicalDeviceDisplayPlaneProperties(physical_device, &prop_count, props.data()));
 
@@ -4584,7 +4584,7 @@ TEST(LoaderInstPhysDevExts, PhysDevDispPlaneProps2KHRMixed) {
         std::vector<VkDisplayPlanePropertiesKHR> props{};
         uint32_t prop_count = 0;
         ASSERT_EQ(VK_SUCCESS, GetPhysicalDeviceDisplayPlaneProperties(physical_devices[dev], &prop_count, nullptr));
-        ASSERT_NE(0, prop_count);
+        ASSERT_NE(0U, prop_count);
         props.resize(prop_count);
         ASSERT_EQ(VK_SUCCESS, GetPhysicalDeviceDisplayPlaneProperties(physical_devices[dev], &prop_count, props.data()));
 
@@ -4668,12 +4668,12 @@ TEST(LoaderInstPhysDevExts, GetDispModeProps2KHRInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     std::vector<VkDisplayModePropertiesKHR> props{};
     uint32_t props_count1 = 0;
     ASSERT_EQ(VK_SUCCESS, GetDisplayModeProperties(physical_device, VK_NULL_HANDLE, &props_count1, nullptr));
-    ASSERT_NE(0, props_count1);
+    ASSERT_NE(0U, props_count1);
     props.resize(props_count1);
     ASSERT_EQ(VK_SUCCESS, GetDisplayModeProperties(physical_device, VK_NULL_HANDLE, &props_count1, props.data()));
 
@@ -4760,7 +4760,7 @@ TEST(LoaderInstPhysDevExts, GetDispModeProps2KHRMixed) {
         std::vector<VkDisplayModePropertiesKHR> props{};
         uint32_t props_count1 = 0;
         ASSERT_EQ(VK_SUCCESS, GetDisplayModeProperties(physical_devices[dev], VK_NULL_HANDLE, &props_count1, nullptr));
-        ASSERT_NE(0, props_count1);
+        ASSERT_NE(0U, props_count1);
         props.resize(props_count1);
         ASSERT_EQ(VK_SUCCESS, GetDisplayModeProperties(physical_devices[dev], VK_NULL_HANDLE, &props_count1, props.data()));
 
@@ -4851,7 +4851,7 @@ TEST(LoaderInstPhysDevExts, GetDispPlaneCaps2KHRInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkDisplayPlaneCapabilitiesKHR caps{};
     ASSERT_EQ(VK_SUCCESS, GetDisplayPlaneCapabilities(physical_device, 0, 0, &caps));
@@ -4994,7 +4994,7 @@ TEST(LoaderInstPhysDevExts, AcquireDrmDisplayEXTInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkDisplayKHR display = VK_NULL_HANDLE;
     ASSERT_EQ(VK_SUCCESS, AcquireDrmDisplay(physical_device, 0, display));
@@ -5150,7 +5150,7 @@ TEST(LoaderInstPhysDevExts, GetDrmDisplayEXTInstanceAndICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, instance->vkEnumeratePhysicalDevices(instance, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     VkDisplayKHR display = VK_NULL_HANDLE;
     ASSERT_EQ(VK_SUCCESS, GetDrmDisplay(physical_device, 0, 0, &display));
diff --git a/tests/loader_regression_tests.cpp b/tests/loader_regression_tests.cpp
index 838e9a286..338923b44 100644
--- a/tests/loader_regression_tests.cpp
+++ b/tests/loader_regression_tests.cpp
@@ -34,96 +34,98 @@
 // VL = Vulkan Loader github
 // VVL = Vulkan Validation Layers github
 
-class RegressionTests : public ::testing::Test {
-   protected:
-    virtual void SetUp() {
-        env = std::unique_ptr<FrameworkEnvironment>(new FrameworkEnvironment());
-        env->add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    }
-
-    virtual void TearDown() { env.reset(); }
-    std::unique_ptr<FrameworkEnvironment> env;
-};
-
-// Subtyping for organization
-class CreateInstance : public RegressionTests {};
-class EnumerateInstanceVersion : public RegressionTests {};
-class EnumerateInstanceLayerProperties : public RegressionTests {};
-class EnumerateInstanceExtensionProperties : public RegressionTests {};
-class EnumerateDeviceLayerProperties : public RegressionTests {};
-class EnumerateDeviceExtensionProperties : public RegressionTests {};
-class EnumeratePhysicalDevices : public RegressionTests {};
-class SortedPhysicalDevices : public RegressionTests {};
-class CreateDevice : public RegressionTests {};
-class EnumeratePhysicalDeviceGroups : public RegressionTests {};
-class WrapObjects : public RegressionTests {};
-
-TEST_F(CreateInstance, BasicRun) {
-    auto& driver = env->get_test_icd();
+TEST(CreateInstance, BasicRun) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
+    auto& driver = env.get_test_icd();
     driver.set_min_icd_interface_version(5);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 }
 
 // LX435
-TEST_F(CreateInstance, ConstInstanceInfo) {
+TEST(CreateInstance, ConstInstanceInfo) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     VkInstance inst = VK_NULL_HANDLE;
     VkInstanceCreateInfo const info = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, nullptr, 0, nullptr, 0, nullptr, 0, nullptr};
-    ASSERT_EQ(env->vulkan_functions.vkCreateInstance(&info, VK_NULL_HANDLE, &inst), VK_SUCCESS);
+    ASSERT_EQ(env.vulkan_functions.vkCreateInstance(&info, VK_NULL_HANDLE, &inst), VK_SUCCESS);
     // Must clean up
-    env->vulkan_functions.vkDestroyInstance(inst, nullptr);
+    env.vulkan_functions.vkDestroyInstance(inst, nullptr);
 }
 
 // VUID-vkDestroyInstance-instance-parameter, VUID-vkDestroyInstance-pAllocator-parameter
-TEST_F(CreateInstance, DestroyInstanceNullHandle) { env->vulkan_functions.vkDestroyInstance(VK_NULL_HANDLE, nullptr); }
+TEST(CreateInstance, DestroyInstanceNullHandle) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.vulkan_functions.vkDestroyInstance(VK_NULL_HANDLE, nullptr);
+}
 
 // VUID-vkDestroyDevice-device-parameter, VUID-vkDestroyDevice-pAllocator-parameter
-TEST_F(CreateInstance, DestroyDeviceNullHandle) { env->vulkan_functions.vkDestroyDevice(VK_NULL_HANDLE, nullptr); }
+TEST(CreateInstance, DestroyDeviceNullHandle) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    env.vulkan_functions.vkDestroyDevice(VK_NULL_HANDLE, nullptr);
+}
 
 // VUID-vkCreateInstance-ppEnabledExtensionNames-01388
-TEST_F(CreateInstance, ExtensionNotPresent) {
+TEST(CreateInstance, ExtensionNotPresent) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     {
-        InstWrapper inst{env->vulkan_functions};
+        InstWrapper inst{env.vulkan_functions};
         inst.create_info.add_extension("VK_EXT_validation_features");  // test icd won't report this as supported
         inst.CheckCreate(VK_ERROR_EXTENSION_NOT_PRESENT);
     }
     {
-        InstWrapper inst{env->vulkan_functions};
+        InstWrapper inst{env.vulkan_functions};
         inst.create_info.add_extension("Non_existant_extension");  // unknown instance extension
         inst.CheckCreate(VK_ERROR_EXTENSION_NOT_PRESENT);
     }
 }
 
-TEST_F(CreateInstance, LayerNotPresent) {
-    InstWrapper inst{env->vulkan_functions};
+TEST(CreateInstance, LayerNotPresent) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.add_layer("VK_NON_EXISTANT_LAYER");
     inst.CheckCreate(VK_ERROR_LAYER_NOT_PRESENT);
 }
 
-TEST_F(CreateInstance, LayerPresent) {
+TEST(CreateInstance, LayerPresent) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
     const char* layer_name = "TestLayer";
-    env->add_explicit_layer(
+    env.add_explicit_layer(
         ManifestLayer{}.add_layer(
             ManifestLayer::LayerDescription{}.set_name(layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
         "test_layer.json");
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.add_layer(layer_name);
     inst.CheckCreate();
 }
 
-TEST_F(CreateInstance, ConsecutiveCreate) {
+TEST(CreateInstance, ConsecutiveCreate) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
     for (uint32_t i = 0; i < 100; i++) {
-        InstWrapper inst{env->vulkan_functions};
+        InstWrapper inst{env.vulkan_functions};
         inst.CheckCreate();
     }
 }
 
-TEST_F(CreateInstance, ConsecutiveCreateWithoutDestruction) {
+TEST(CreateInstance, ConsecutiveCreateWithoutDestruction) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
     std::vector<InstWrapper> instances;
     for (uint32_t i = 0; i < 100; i++) {
-        instances.emplace_back(env->vulkan_functions);
+        instances.emplace_back(env.vulkan_functions);
         instances.back().CheckCreate();
     }
 }
@@ -134,16 +136,19 @@ TEST(NoDrivers, CreateInstance) {
     inst.CheckCreate(VK_ERROR_INCOMPATIBLE_DRIVER);
 }
 
-TEST_F(EnumerateInstanceLayerProperties, UsageChecks) {
+TEST(EnumerateInstanceLayerProperties, UsageChecks) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
     const char* layer_name_1 = "TestLayer1";
     const char* layer_name_2 = "TestLayer1";
 
-    env->add_explicit_layer(
+    env.add_explicit_layer(
         ManifestLayer{}.add_layer(
             ManifestLayer::LayerDescription{}.set_name(layer_name_1).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
         "test_layer_1.json");
 
-    env->add_explicit_layer(
+    env.add_explicit_layer(
         ManifestLayer{}.add_layer(
             ManifestLayer::LayerDescription{}.set_name(layer_name_2).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
         "test_layer_2.json");
@@ -151,41 +156,44 @@ TEST_F(EnumerateInstanceLayerProperties, UsageChecks) {
     {  // OnePass
         VkLayerProperties layer_props[2] = {};
         uint32_t layer_count = 2;
-        ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props));
-        ASSERT_EQ(layer_count, 2);
+        ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props));
+        ASSERT_EQ(layer_count, 2U);
         ASSERT_TRUE(string_eq(layer_name_1, layer_props[0].layerName));
         ASSERT_TRUE(string_eq(layer_name_2, layer_props[1].layerName));
     }
     {  // OnePass
         uint32_t layer_count = 0;
-        ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr));
-        ASSERT_EQ(layer_count, 2);
+        ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr));
+        ASSERT_EQ(layer_count, 2U);
 
         VkLayerProperties layer_props[2] = {};
-        ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props));
-        ASSERT_EQ(layer_count, 2);
+        ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props));
+        ASSERT_EQ(layer_count, 2U);
         ASSERT_TRUE(string_eq(layer_name_1, layer_props[0].layerName));
         ASSERT_TRUE(string_eq(layer_name_2, layer_props[1].layerName));
     }
     {  // PropertyCountLessThanAvailable
         VkLayerProperties layer_props{};
         uint32_t layer_count = 1;
-        ASSERT_EQ(VK_INCOMPLETE, env->vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, &layer_props));
+        ASSERT_EQ(VK_INCOMPLETE, env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, &layer_props));
         ASSERT_TRUE(string_eq(layer_name_1, layer_props.layerName));
     }
 }
 
-TEST_F(EnumerateInstanceExtensionProperties, UsageChecks) {
+TEST(EnumerateInstanceExtensionProperties, UsageChecks) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
     Extension first_ext{"VK_EXT_validation_features"};  // known instance extensions
     Extension second_ext{"VK_EXT_headless_surface"};
-    env->reset_icd().add_instance_extensions({first_ext, second_ext});
+    env.reset_icd().add_instance_extensions({first_ext, second_ext});
 
     {  // One Pass
         uint32_t extension_count = 4;
         std::array<VkExtensionProperties, 4> extensions;
         ASSERT_EQ(VK_SUCCESS,
-                  env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extensions.data()));
-        ASSERT_EQ(extension_count, 4);  // return debug report & debug utils + our two extensions
+                  env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extensions.data()));
+        ASSERT_EQ(extension_count, 4U);  // return debug report & debug utils + our two extensions
 
         // loader always adds the debug report & debug utils extensions
         ASSERT_TRUE(first_ext.extensionName == extensions[0].extensionName);
@@ -196,12 +204,12 @@ TEST_F(EnumerateInstanceExtensionProperties, UsageChecks) {
     {  // Two Pass
         uint32_t extension_count = 0;
         std::array<VkExtensionProperties, 4> extensions;
-        ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
-        ASSERT_EQ(extension_count, 4);  // return debug report & debug utils + our two extensions
+        ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
+        ASSERT_EQ(extension_count, 4U);  // return debug report & debug utils + our two extensions
 
         ASSERT_EQ(VK_SUCCESS,
-                  env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extensions.data()));
-        ASSERT_EQ(extension_count, 4);
+                  env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extensions.data()));
+        ASSERT_EQ(extension_count, 4U);
         // loader always adds the debug report & debug utils extensions
         ASSERT_TRUE(first_ext.extensionName == extensions[0].extensionName);
         ASSERT_TRUE(second_ext.extensionName == extensions[1].extensionName);
@@ -210,46 +218,51 @@ TEST_F(EnumerateInstanceExtensionProperties, UsageChecks) {
     }
 }
 
-TEST_F(EnumerateInstanceExtensionProperties, PropertyCountLessThanAvailable) {
+TEST(EnumerateInstanceExtensionProperties, PropertyCountLessThanAvailable) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
     uint32_t extension_count = 0;
     std::array<VkExtensionProperties, 2> extensions;
     {  // use nullptr for null string
-        ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
-        ASSERT_EQ(extension_count, 2);  // return debug report & debug utils
-        extension_count = 1;            // artificially remove one extension
+        ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, nullptr));
+        ASSERT_EQ(extension_count, 2U);  // return debug report & debug utils
+        extension_count = 1;             // artificially remove one extension
 
         ASSERT_EQ(VK_INCOMPLETE,
-                  env->vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extensions.data()));
-        ASSERT_EQ(extension_count, 1);
+                  env.vulkan_functions.vkEnumerateInstanceExtensionProperties(nullptr, &extension_count, extensions.data()));
+        ASSERT_EQ(extension_count, 1U);
         // loader always adds the debug report & debug utils extensions
         ASSERT_TRUE(string_eq(extensions[0].extensionName, "VK_EXT_debug_report"));
     }
     {  // use "" for null string
-        ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties("", &extension_count, nullptr));
-        ASSERT_EQ(extension_count, 2);  // return debug report & debug utils
-        extension_count = 1;            // artificially remove one extension
+        ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties("", &extension_count, nullptr));
+        ASSERT_EQ(extension_count, 2U);  // return debug report & debug utils
+        extension_count = 1;             // artificially remove one extension
 
         ASSERT_EQ(VK_INCOMPLETE,
-                  env->vulkan_functions.vkEnumerateInstanceExtensionProperties("", &extension_count, extensions.data()));
-        ASSERT_EQ(extension_count, 1);
+                  env.vulkan_functions.vkEnumerateInstanceExtensionProperties("", &extension_count, extensions.data()));
+        ASSERT_EQ(extension_count, 1U);
         // loader always adds the debug report & debug utils extensions
         ASSERT_TRUE(string_eq(extensions[0].extensionName, "VK_EXT_debug_report"));
     }
 }
 
-TEST_F(EnumerateInstanceExtensionProperties, FilterUnkownInstanceExtensions) {
+TEST(EnumerateInstanceExtensionProperties, FilterUnkownInstanceExtensions) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
     Extension first_ext{"FirstTestExtension"};  // unknown instance extensions
     Extension second_ext{"SecondTestExtension"};
-    env->reset_icd().add_instance_extensions({first_ext, second_ext});
+    env.reset_icd().add_instance_extensions({first_ext, second_ext});
     {
         uint32_t extension_count = 0;
-        ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties("", &extension_count, nullptr));
-        ASSERT_EQ(extension_count, 2);  // return debug report & debug utils
+        ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties("", &extension_count, nullptr));
+        ASSERT_EQ(extension_count, 2U);  // return debug report & debug utils
 
         std::array<VkExtensionProperties, 2> extensions;
-        ASSERT_EQ(VK_SUCCESS,
-                  env->vulkan_functions.vkEnumerateInstanceExtensionProperties("", &extension_count, extensions.data()));
-        ASSERT_EQ(extension_count, 2);
+        ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties("", &extension_count, extensions.data()));
+        ASSERT_EQ(extension_count, 2U);
         // loader always adds the debug report & debug utils extensions
         ASSERT_TRUE(string_eq(extensions[0].extensionName, "VK_EXT_debug_report"));
         ASSERT_TRUE(string_eq(extensions[1].extensionName, "VK_EXT_debug_utils"));
@@ -258,13 +271,12 @@ TEST_F(EnumerateInstanceExtensionProperties, FilterUnkownInstanceExtensions) {
         set_env_var("VK_LOADER_DISABLE_INST_EXT_FILTER", "1");
 
         uint32_t extension_count = 0;
-        ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateInstanceExtensionProperties("", &extension_count, nullptr));
-        ASSERT_EQ(extension_count, 4);
+        ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties("", &extension_count, nullptr));
+        ASSERT_EQ(extension_count, 4U);
 
         std::array<VkExtensionProperties, 4> extensions;
-        ASSERT_EQ(VK_SUCCESS,
-                  env->vulkan_functions.vkEnumerateInstanceExtensionProperties("", &extension_count, extensions.data()));
-        ASSERT_EQ(extension_count, 4);
+        ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateInstanceExtensionProperties("", &extension_count, extensions.data()));
+        ASSERT_EQ(extension_count, 4U);
 
         ASSERT_EQ(extensions[0], first_ext.get());
         ASSERT_EQ(extensions[1], second_ext.get());
@@ -274,17 +286,20 @@ TEST_F(EnumerateInstanceExtensionProperties, FilterUnkownInstanceExtensions) {
     }
 }
 
-TEST_F(EnumerateDeviceLayerProperties, LayersMatch) {
-    auto& driver = env->get_test_icd();
+TEST(EnumerateDeviceLayerProperties, LayersMatch) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
 
     const char* layer_name = "TestLayer";
-    env->add_explicit_layer(
+    env.add_explicit_layer(
         ManifestLayer{}.add_layer(
             ManifestLayer::LayerDescription{}.set_name(layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
         "test_layer.json");
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.add_layer(layer_name);
     inst.CheckCreate();
 
@@ -292,30 +307,33 @@ TEST_F(EnumerateDeviceLayerProperties, LayersMatch) {
     {  // LayersMatch
 
         uint32_t layer_count = 0;
-        ASSERT_EQ(env->vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &layer_count, nullptr), VK_SUCCESS);
-        ASSERT_EQ(layer_count, 1);
+        ASSERT_EQ(env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &layer_count, nullptr), VK_SUCCESS);
+        ASSERT_EQ(layer_count, 1U);
         VkLayerProperties layer_props;
-        ASSERT_EQ(env->vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &layer_count, &layer_props), VK_SUCCESS);
-        ASSERT_EQ(layer_count, 1);
+        ASSERT_EQ(env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &layer_count, &layer_props), VK_SUCCESS);
+        ASSERT_EQ(layer_count, 1U);
         ASSERT_TRUE(string_eq(layer_props.layerName, layer_name));
     }
     {  // Property count less than available
         VkLayerProperties layer_props;
         uint32_t layer_count = 0;
-        ASSERT_EQ(VK_INCOMPLETE, env->vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &layer_count, &layer_props));
-        ASSERT_EQ(layer_count, 0);
+        ASSERT_EQ(VK_INCOMPLETE, env.vulkan_functions.vkEnumerateDeviceLayerProperties(phys_dev, &layer_count, &layer_props));
+        ASSERT_EQ(layer_count, 0U);
     }
 }
 
-TEST_F(EnumerateDeviceExtensionProperties, DeviceExtensionEnumerated) {
-    auto& driver = env->get_test_icd();
+TEST(EnumerateDeviceExtensionProperties, DeviceExtensionEnumerated) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
 
     std::array<Extension, 2> device_extensions = {Extension{"MyExtension0", 4}, Extension{"MyExtension1", 7}};
     for (auto& ext : device_extensions) {
         driver.physical_devices.front().extensions.push_back(ext);
     }
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     uint32_t driver_count = 1;
@@ -334,15 +352,18 @@ TEST_F(EnumerateDeviceExtensionProperties, DeviceExtensionEnumerated) {
     ASSERT_TRUE(device_extensions[0].specVersion == enumerated_device_exts[0].specVersion);
 }
 
-TEST_F(EnumerateDeviceExtensionProperties, PropertyCountLessThanAvailable) {
-    auto& driver = env->get_test_icd();
+TEST(EnumerateDeviceExtensionProperties, PropertyCountLessThanAvailable) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
 
     std::array<Extension, 2> device_extensions = {Extension{"MyExtension0", 4}, Extension{"MyExtension1", 7}};
     for (auto& ext : device_extensions) {
         driver.physical_devices.front().extensions.push_back(ext);
     }
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     uint32_t driver_count = 1;
@@ -362,9 +383,12 @@ TEST_F(EnumerateDeviceExtensionProperties, PropertyCountLessThanAvailable) {
     ASSERT_TRUE(device_extensions[0].specVersion == enumerated_device_exts[0].specVersion);
 }
 
-TEST_F(EnumerateDeviceExtensionProperties, ZeroPhysicalDeviceExtensions) {
-    env->get_test_icd().add_physical_device({});
-    InstWrapper inst{env->vulkan_functions};
+TEST(EnumerateDeviceExtensionProperties, ZeroPhysicalDeviceExtensions) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
+    env.get_test_icd().add_physical_device({});
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
     inst.CheckCreate(VK_SUCCESS);
 
@@ -373,22 +397,25 @@ TEST_F(EnumerateDeviceExtensionProperties, ZeroPhysicalDeviceExtensions) {
     dev.CheckCreate(phys_dev);
 
     uint32_t ext_count = 0;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &ext_count, nullptr));
-    ASSERT_EQ(ext_count, 0);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &ext_count, nullptr));
+    ASSERT_EQ(ext_count, 0U);
     VkExtensionProperties ext_props{};
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &ext_count, &ext_props));
-    ASSERT_EQ(ext_count, 0);
+    ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumerateDeviceExtensionProperties(phys_dev, nullptr, &ext_count, &ext_props));
+    ASSERT_EQ(ext_count, 0U);
 }
 
-TEST_F(EnumeratePhysicalDevices, OneCall) {
-    auto& driver = env->get_test_icd().set_min_icd_interface_version(5);
+TEST(EnumeratePhysicalDevices, OneCall) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
+    auto& driver = env.get_test_icd().set_min_icd_interface_version(5);
 
     driver.physical_devices.emplace_back("physical_device_0", 1);
     driver.physical_devices.emplace_back("physical_device_1", 2);
     driver.physical_devices.emplace_back("physical_device_2", 3);
     driver.physical_devices.emplace_back("physical_device_3", 4);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     uint32_t physical_count = static_cast<uint32_t>(driver.physical_devices.size());
@@ -398,8 +425,11 @@ TEST_F(EnumeratePhysicalDevices, OneCall) {
     ASSERT_EQ(physical_count, returned_physical_count);
 }
 
-TEST_F(EnumeratePhysicalDevices, TwoCall) {
-    auto& driver = env->get_test_icd().set_min_icd_interface_version(5);
+TEST(EnumeratePhysicalDevices, TwoCall) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+
+    auto& driver = env.get_test_icd().set_min_icd_interface_version(5);
     driver.add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
 
     const uint32_t real_device_count = 2;
@@ -408,7 +438,7 @@ TEST_F(EnumeratePhysicalDevices, TwoCall) {
         driver.physical_devices.back().extensions.push_back({VK_EXT_PCI_BUS_INFO_EXTENSION_NAME, 0});
     }
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     uint32_t physical_count = static_cast<uint32_t>(driver.physical_devices.size());
@@ -417,13 +447,15 @@ TEST_F(EnumeratePhysicalDevices, TwoCall) {
     ASSERT_EQ(physical_count, returned_physical_count);
 
     std::array<VkPhysicalDevice, real_device_count> physical_device_handles;
-    ASSERT_EQ(VK_SUCCESS, env->vulkan_functions.vkEnumeratePhysicalDevices(inst.inst, &returned_physical_count,
-                                                                           physical_device_handles.data()));
+    ASSERT_EQ(VK_SUCCESS,
+              env.vulkan_functions.vkEnumeratePhysicalDevices(inst.inst, &returned_physical_count, physical_device_handles.data()));
     ASSERT_EQ(physical_count, returned_physical_count);
 }
 
-TEST_F(EnumeratePhysicalDevices, MatchOneAndTwoCallNumbers) {
-    auto& driver = env->get_test_icd();
+TEST(EnumeratePhysicalDevices, MatchOneAndTwoCallNumbers) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd();
     driver.set_min_icd_interface_version(5);
     driver.add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
 
@@ -433,7 +465,7 @@ TEST_F(EnumeratePhysicalDevices, MatchOneAndTwoCallNumbers) {
         driver.physical_devices.back().extensions.push_back({VK_EXT_PCI_BUS_INFO_EXTENSION_NAME, 0});
     }
 
-    InstWrapper inst1{env->vulkan_functions};
+    InstWrapper inst1{env.vulkan_functions};
     inst1.CheckCreate();
 
     uint32_t physical_count_one_call = static_cast<uint32_t>(driver.physical_devices.size());
@@ -442,7 +474,7 @@ TEST_F(EnumeratePhysicalDevices, MatchOneAndTwoCallNumbers) {
               inst1->vkEnumeratePhysicalDevices(inst1, &physical_count_one_call, physical_device_handles_one_call.data()));
     ASSERT_EQ(real_device_count, physical_count_one_call);
 
-    InstWrapper inst2{env->vulkan_functions};
+    InstWrapper inst2{env.vulkan_functions};
     inst2.CheckCreate();
 
     uint32_t physical_count = static_cast<uint32_t>(driver.physical_devices.size());
@@ -457,8 +489,10 @@ TEST_F(EnumeratePhysicalDevices, MatchOneAndTwoCallNumbers) {
     ASSERT_EQ(physical_count_one_call, returned_physical_count);
 }
 
-TEST_F(EnumeratePhysicalDevices, TwoCallIncomplete) {
-    auto& driver = env->get_test_icd().set_min_icd_interface_version(5);
+TEST(EnumeratePhysicalDevices, TwoCallIncomplete) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd().set_min_icd_interface_version(5);
     driver.add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
 
     const uint32_t real_device_count = 2;
@@ -467,7 +501,7 @@ TEST_F(EnumeratePhysicalDevices, TwoCallIncomplete) {
         driver.physical_devices.back().extensions.push_back({VK_EXT_PCI_BUS_INFO_EXTENSION_NAME, 0});
     }
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     uint32_t physical_count = 0;
@@ -483,14 +517,14 @@ TEST_F(EnumeratePhysicalDevices, TwoCallIncomplete) {
     // Use zero for the device count so we can get the VK_INCOMPLETE message and verify nothing was written into physical
     physical_count = 0;
     ASSERT_EQ(VK_INCOMPLETE, inst->vkEnumeratePhysicalDevices(inst, &physical_count, physical.data()));
-    ASSERT_EQ(physical_count, 0);
+    ASSERT_EQ(physical_count, 0U);
     ASSERT_EQ(static_cast<void*>(physical[0]), static_cast<void*>(temp_ptr.get()));
     ASSERT_EQ(static_cast<void*>(physical[1]), static_cast<void*>(temp_ptr.get()));
 
     // Remove one from the physical device count so we can get the VK_INCOMPLETE message
     physical_count = 1;
     ASSERT_EQ(VK_INCOMPLETE, inst->vkEnumeratePhysicalDevices(inst, &physical_count, physical.data()));
-    ASSERT_EQ(physical_count, 1);
+    ASSERT_EQ(physical_count, 1U);
     ASSERT_EQ(static_cast<void*>(physical[1]), static_cast<void*>(temp_ptr.get()));
 
     physical_count = 2;
@@ -501,19 +535,23 @@ TEST_F(EnumeratePhysicalDevices, TwoCallIncomplete) {
     ASSERT_TRUE(std::find(physical_2.begin(), physical_2.end(), physical[0]) != physical_2.end());
 }
 
-TEST_F(EnumeratePhysicalDevices, ZeroPhysicalDevices) {
-    InstWrapper inst{env->vulkan_functions};
+TEST(EnumeratePhysicalDevices, ZeroPhysicalDevices) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0));
     inst.CheckCreate(VK_SUCCESS);
 
     uint32_t count = 0;
-    ASSERT_EQ(VK_ERROR_INITIALIZATION_FAILED, env->vulkan_functions.vkEnumeratePhysicalDevices(inst, &count, nullptr));
-    ASSERT_EQ(count, 0);
+    ASSERT_EQ(VK_ERROR_INITIALIZATION_FAILED, env.vulkan_functions.vkEnumeratePhysicalDevices(inst, &count, nullptr));
+    ASSERT_EQ(count, 0U);
 }
 
-TEST_F(EnumeratePhysicalDevices, ZeroPhysicalDevicesAfterCreateInstance) {
-    auto& driver = env->get_test_icd().set_min_icd_interface_version(5);
-    InstWrapper inst{env->vulkan_functions};
+TEST(EnumeratePhysicalDevices, ZeroPhysicalDevicesAfterCreateInstance) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd().set_min_icd_interface_version(5);
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.set_api_version(VK_API_VERSION_1_1);
     inst.CheckCreate();
     driver.physical_devices.clear();
@@ -532,14 +570,16 @@ TEST_F(EnumeratePhysicalDevices, ZeroPhysicalDevicesAfterCreateInstance) {
               inst->vkEnumeratePhysicalDeviceGroups(inst, &physical_device_group_count, &physical_device_group_properties));
 }
 
-TEST_F(EnumeratePhysicalDevices, CallTwiceNormal) {
-    auto& driver = env->get_test_icd().set_min_icd_interface_version(5);
+TEST(EnumeratePhysicalDevices, CallTwiceNormal) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd().set_min_icd_interface_version(5);
 
     for (size_t i = 0; i < 4; i++) {
         driver.physical_devices.emplace_back(std::string("physical_device_") + std::to_string(i));
     }
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     // Call twice in a row and make sure nothing bad happened
@@ -557,14 +597,16 @@ TEST_F(EnumeratePhysicalDevices, CallTwiceNormal) {
     }
 }
 
-TEST_F(EnumeratePhysicalDevices, CallTwiceIncompleteOnceNormal) {
-    auto& driver = env->get_test_icd().set_min_icd_interface_version(5);
+TEST(EnumeratePhysicalDevices, CallTwiceIncompleteOnceNormal) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd().set_min_icd_interface_version(5);
 
     for (size_t i = 0; i < 8; i++) {
         driver.physical_devices.emplace_back(std::string("physical_device_") + std::to_string(i));
     }
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     // Query 3, then 5, then all
@@ -572,11 +614,11 @@ TEST_F(EnumeratePhysicalDevices, CallTwiceIncompleteOnceNormal) {
     uint32_t returned_physical_count = 3;
     std::vector<VkPhysicalDevice> physical_device_handles_1 = std::vector<VkPhysicalDevice>(returned_physical_count);
     ASSERT_EQ(VK_INCOMPLETE, inst->vkEnumeratePhysicalDevices(inst, &returned_physical_count, physical_device_handles_1.data()));
-    ASSERT_EQ(3, returned_physical_count);
+    ASSERT_EQ(3U, returned_physical_count);
     returned_physical_count = 5;
     std::vector<VkPhysicalDevice> physical_device_handles_2 = std::vector<VkPhysicalDevice>(returned_physical_count);
     ASSERT_EQ(VK_INCOMPLETE, inst->vkEnumeratePhysicalDevices(inst, &returned_physical_count, physical_device_handles_2.data()));
-    ASSERT_EQ(5, returned_physical_count);
+    ASSERT_EQ(5U, returned_physical_count);
     returned_physical_count = physical_count;
     std::vector<VkPhysicalDevice> physical_device_handles_3 = std::vector<VkPhysicalDevice>(returned_physical_count);
     ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &returned_physical_count, physical_device_handles_3.data()));
@@ -592,14 +634,16 @@ TEST_F(EnumeratePhysicalDevices, CallTwiceIncompleteOnceNormal) {
     }
 }
 
-TEST_F(EnumeratePhysicalDevices, CallThriceSuccessReduce) {
-    auto& driver = env->get_test_icd().set_min_icd_interface_version(5);
+TEST(EnumeratePhysicalDevices, CallThriceSuccessReduce) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd().set_min_icd_interface_version(5);
 
     for (size_t i = 0; i < 8; i++) {
         driver.physical_devices.emplace_back(std::string("physical_device_") + std::to_string(i));
     }
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     // Query all at first, then 5, then 3
@@ -611,11 +655,11 @@ TEST_F(EnumeratePhysicalDevices, CallThriceSuccessReduce) {
     returned_physical_count = 5;
     std::vector<VkPhysicalDevice> physical_device_handles_2 = std::vector<VkPhysicalDevice>(returned_physical_count);
     ASSERT_EQ(VK_INCOMPLETE, inst->vkEnumeratePhysicalDevices(inst, &returned_physical_count, physical_device_handles_2.data()));
-    ASSERT_EQ(5, returned_physical_count);
+    ASSERT_EQ(5U, returned_physical_count);
     returned_physical_count = 3;
     std::vector<VkPhysicalDevice> physical_device_handles_3 = std::vector<VkPhysicalDevice>(returned_physical_count);
     ASSERT_EQ(VK_INCOMPLETE, inst->vkEnumeratePhysicalDevices(inst, &returned_physical_count, physical_device_handles_3.data()));
-    ASSERT_EQ(3, returned_physical_count);
+    ASSERT_EQ(3U, returned_physical_count);
     // Make sure devices are same between the three
     for (uint32_t count = 0; count < driver.physical_devices.size(); ++count) {
         if (count < physical_device_handles_2.size()) {
@@ -627,13 +671,15 @@ TEST_F(EnumeratePhysicalDevices, CallThriceSuccessReduce) {
     }
 }
 
-TEST_F(EnumeratePhysicalDevices, CallThriceAddInBetween) {
-    auto& driver = env->get_test_icd().set_min_icd_interface_version(5);
+TEST(EnumeratePhysicalDevices, CallThriceAddInBetween) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd().set_min_icd_interface_version(5);
 
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices.emplace_back("physical_device_1");
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     uint32_t physical_count = static_cast<uint32_t>(driver.physical_devices.size());
@@ -665,14 +711,16 @@ TEST_F(EnumeratePhysicalDevices, CallThriceAddInBetween) {
     }
 }
 
-TEST_F(EnumeratePhysicalDevices, CallThriceRemoveInBetween) {
-    auto& driver = env->get_test_icd().set_min_icd_interface_version(5);
+TEST(EnumeratePhysicalDevices, CallThriceRemoveInBetween) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd().set_min_icd_interface_version(5);
 
     for (size_t i = 0; i < 4; i++) {
         driver.physical_devices.emplace_back(std::string("physical_device_") + std::to_string(i));
     }
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     uint32_t physical_count = static_cast<uint32_t>(driver.physical_devices.size());
@@ -720,15 +768,17 @@ TEST_F(EnumeratePhysicalDevices, CallThriceRemoveInBetween) {
     ASSERT_EQ(three_found, returned_physical_count);
 }
 
-TEST_F(EnumeratePhysicalDevices, MultipleAddRemoves) {
-    auto& driver = env->get_test_icd().set_min_icd_interface_version(5);
+TEST(EnumeratePhysicalDevices, MultipleAddRemoves) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd().set_min_icd_interface_version(5);
 
     for (size_t i = 0; i < 4; i++) {
         driver.physical_devices.emplace_back(std::string("physical_device_") + std::to_string(i));
     }
     std::array<std::vector<VkPhysicalDevice>, 8> physical_dev_handles;
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     uint32_t physical_count = static_cast<uint32_t>(driver.physical_devices.size());
@@ -799,14 +849,14 @@ TEST_F(EnumeratePhysicalDevices, MultipleAddRemoves) {
     // Six   [4] - A, B, 0, 2
     // Seven [4] - A, B, C, 0
     // Eight [5] - A, B, C, 0, 2
-    ASSERT_EQ(4, physical_dev_handles[0].size());
-    ASSERT_EQ(3, physical_dev_handles[1].size());
-    ASSERT_EQ(3, physical_dev_handles[2].size());
-    ASSERT_EQ(5, physical_dev_handles[3].size());
-    ASSERT_EQ(4, physical_dev_handles[4].size());
-    ASSERT_EQ(4, physical_dev_handles[5].size());
-    ASSERT_EQ(4, physical_dev_handles[6].size());
-    ASSERT_EQ(5, physical_dev_handles[7].size());
+    ASSERT_EQ(4U, physical_dev_handles[0].size());
+    ASSERT_EQ(3U, physical_dev_handles[1].size());
+    ASSERT_EQ(3U, physical_dev_handles[2].size());
+    ASSERT_EQ(5U, physical_dev_handles[3].size());
+    ASSERT_EQ(4U, physical_dev_handles[4].size());
+    ASSERT_EQ(4U, physical_dev_handles[5].size());
+    ASSERT_EQ(4U, physical_dev_handles[6].size());
+    ASSERT_EQ(5U, physical_dev_handles[7].size());
 
     // Make sure the devices in two and three are all found in one
     uint32_t found_items[8]{};
@@ -850,26 +900,28 @@ TEST_F(EnumeratePhysicalDevices, MultipleAddRemoves) {
     ASSERT_GE(found_items[6], 4U);
 }
 
-TEST_F(CreateDevice, ExtensionNotPresent) {
-    auto& driver = env->get_test_icd();
+TEST(CreateDevice, ExtensionNotPresent) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd();
 
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     VkPhysicalDevice phys_dev = inst.GetPhysDev();
 
     uint32_t familyCount = 0;
     inst->vkGetPhysicalDeviceQueueFamilyProperties(phys_dev, &familyCount, nullptr);
-    ASSERT_EQ(familyCount, 1);
+    ASSERT_EQ(familyCount, 1U);
 
     VkQueueFamilyProperties families;
     inst->vkGetPhysicalDeviceQueueFamilyProperties(phys_dev, &familyCount, &families);
-    ASSERT_EQ(familyCount, 1);
+    ASSERT_EQ(familyCount, 1U);
     ASSERT_EQ(families, family_props.properties);
 
     DeviceWrapper dev{inst};
@@ -881,26 +933,28 @@ TEST_F(CreateDevice, ExtensionNotPresent) {
 // LX535 / MI-76: Device layers are deprecated.
 // Ensure that no errors occur if a bogus device layer list is passed to vkCreateDevice.
 // https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#extendingvulkan-layers-devicelayerdeprecation
-TEST_F(CreateDevice, LayersNotPresent) {
-    auto& driver = env->get_test_icd();
+TEST(CreateDevice, LayersNotPresent) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd();
 
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
 
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices.back().queue_family_properties.push_back(family_props);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     VkPhysicalDevice phys_dev = inst.GetPhysDev();
 
     uint32_t familyCount = 0;
     inst->vkGetPhysicalDeviceQueueFamilyProperties(phys_dev, &familyCount, nullptr);
-    ASSERT_EQ(familyCount, 1);
+    ASSERT_EQ(familyCount, 1U);
 
     VkQueueFamilyProperties families;
     inst->vkGetPhysicalDeviceQueueFamilyProperties(phys_dev, &familyCount, &families);
-    ASSERT_EQ(familyCount, 1);
+    ASSERT_EQ(familyCount, 1U);
     ASSERT_EQ(families, family_props.properties);
 
     DeviceWrapper dev{inst};
@@ -909,15 +963,17 @@ TEST_F(CreateDevice, LayersNotPresent) {
     dev.CheckCreate(phys_dev);
 }
 
-TEST_F(CreateDevice, ConsecutiveCreate) {
-    auto& driver = env->get_test_icd();
+TEST(CreateDevice, ConsecutiveCreate) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd();
 
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
     for (uint32_t i = 0; i < 100; i++) {
         driver.physical_devices.emplace_back("physical_device_0");
         driver.physical_devices.back().queue_family_properties.push_back(family_props);
     }
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     auto phys_devs = inst.GetPhysDevs(100);
@@ -928,15 +984,17 @@ TEST_F(CreateDevice, ConsecutiveCreate) {
     }
 }
 
-TEST_F(CreateDevice, ConsecutiveCreateWithoutDestruction) {
-    auto& driver = env->get_test_icd();
+TEST(CreateDevice, ConsecutiveCreateWithoutDestruction) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd();
 
     MockQueueFamilyProperties family_props{{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true};
     for (uint32_t i = 0; i < 100; i++) {
         driver.physical_devices.emplace_back("physical_device_0");
         driver.physical_devices.back().queue_family_properties.push_back(family_props);
     }
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     auto phys_devs = inst.GetPhysDevs(100);
@@ -975,7 +1033,7 @@ TEST(TryLoadWrongBinaries, WrongICD) {
 
     uint32_t driver_count = 0;
     ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &driver_count, nullptr));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 }
 
 TEST(TryLoadWrongBinaries, WrongExplicit) {
@@ -991,11 +1049,11 @@ TEST(TryLoadWrongBinaries, WrongExplicit) {
 
     uint32_t layer_count = 0;
     ASSERT_EQ(env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr), VK_SUCCESS);
-    ASSERT_EQ(layer_count, 1);
+    ASSERT_EQ(layer_count, 1U);
 
     std::array<VkLayerProperties, 2> layer_props;
     ASSERT_EQ(env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()), VK_SUCCESS);
-    ASSERT_EQ(layer_count, 1);
+    ASSERT_EQ(layer_count, 1U);
 
     DebugUtilsLogger log{VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT};
     InstWrapper inst{env.vulkan_functions};
@@ -1028,11 +1086,11 @@ TEST(TryLoadWrongBinaries, WrongImplicit) {
 
     uint32_t layer_count = 0;
     ASSERT_EQ(env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr), VK_SUCCESS);
-    ASSERT_EQ(layer_count, 1);
+    ASSERT_EQ(layer_count, 1U);
 
     std::array<VkLayerProperties, 1> layer_props;
     ASSERT_EQ(env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()), VK_SUCCESS);
-    ASSERT_EQ(layer_count, 1);
+    ASSERT_EQ(layer_count, 1U);
 
     DebugUtilsLogger log{VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT};
     InstWrapper inst{env.vulkan_functions};
@@ -1070,11 +1128,11 @@ TEST(TryLoadWrongBinaries, WrongExplicitAndImplicit) {
 
     uint32_t layer_count = 0;
     ASSERT_EQ(env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr), VK_SUCCESS);
-    ASSERT_EQ(layer_count, 2);
+    ASSERT_EQ(layer_count, 2U);
 
     std::array<VkLayerProperties, 2> layer_props;
     ASSERT_EQ(env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()), VK_SUCCESS);
-    ASSERT_EQ(layer_count, 2);
+    ASSERT_EQ(layer_count, 2U);
 
     DebugUtilsLogger log{VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT};
     InstWrapper inst{env.vulkan_functions};
@@ -1115,11 +1173,11 @@ TEST(TryLoadWrongBinaries, WrongExplicitAndImplicitErrorOnly) {
 
     uint32_t layer_count = 0;
     ASSERT_EQ(env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr), VK_SUCCESS);
-    ASSERT_EQ(layer_count, 2);
+    ASSERT_EQ(layer_count, 2U);
 
     std::array<VkLayerProperties, 2> layer_props;
     ASSERT_EQ(env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()), VK_SUCCESS);
-    ASSERT_EQ(layer_count, 2);
+    ASSERT_EQ(layer_count, 2U);
 
     DebugUtilsLogger log{VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT};
     InstWrapper inst{env.vulkan_functions};
@@ -1153,11 +1211,11 @@ TEST(TryLoadWrongBinaries, BadExplicit) {
 
     uint32_t layer_count = 0;
     ASSERT_EQ(env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr), VK_SUCCESS);
-    ASSERT_EQ(layer_count, 1);
+    ASSERT_EQ(layer_count, 1U);
 
     std::array<VkLayerProperties, 2> layer_props;
     ASSERT_EQ(env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()), VK_SUCCESS);
-    ASSERT_EQ(layer_count, 1);
+    ASSERT_EQ(layer_count, 1U);
 
     DebugUtilsLogger log{VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT};
     InstWrapper inst{env.vulkan_functions};
@@ -1185,11 +1243,11 @@ TEST(TryLoadWrongBinaries, BadImplicit) {
 
     uint32_t layer_count = 0;
     ASSERT_EQ(env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr), VK_SUCCESS);
-    ASSERT_EQ(layer_count, 1);
+    ASSERT_EQ(layer_count, 1U);
 
     std::array<VkLayerProperties, 1> layer_props;
     ASSERT_EQ(env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()), VK_SUCCESS);
-    ASSERT_EQ(layer_count, 1);
+    ASSERT_EQ(layer_count, 1U);
 
     DebugUtilsLogger log{VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT};
     InstWrapper inst{env.vulkan_functions};
@@ -1222,11 +1280,11 @@ TEST(TryLoadWrongBinaries, BadExplicitAndImplicit) {
 
     uint32_t layer_count = 0;
     ASSERT_EQ(env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, nullptr), VK_SUCCESS);
-    ASSERT_EQ(layer_count, 2);
+    ASSERT_EQ(layer_count, 2U);
 
     std::array<VkLayerProperties, 2> layer_props;
     ASSERT_EQ(env.vulkan_functions.vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data()), VK_SUCCESS);
-    ASSERT_EQ(layer_count, 2);
+    ASSERT_EQ(layer_count, 2U);
 
     DebugUtilsLogger log{VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT};
     InstWrapper inst{env.vulkan_functions};
@@ -1241,8 +1299,10 @@ TEST(TryLoadWrongBinaries, BadExplicitAndImplicit) {
     ASSERT_TRUE(log.find(std::string("Requested layer ") + std::string(layer_name_1) + std::string(" failed to load.")));
 }
 
-TEST_F(EnumeratePhysicalDeviceGroups, OneCall) {
-    auto& driver = env->get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
+TEST(EnumeratePhysicalDeviceGroups, OneCall) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
     driver.add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
 
     // ICD contains 3 devices in two groups
@@ -1257,7 +1317,7 @@ TEST_F(EnumeratePhysicalDeviceGroups, OneCall) {
 
     // Core function
     {
-        InstWrapper inst{env->vulkan_functions};
+        InstWrapper inst{env.vulkan_functions};
         inst.create_info.set_api_version(VK_API_VERSION_1_1);
         inst.CheckCreate();
 
@@ -1293,12 +1353,12 @@ TEST_F(EnumeratePhysicalDeviceGroups, OneCall) {
     driver.add_instance_extension({VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME});
     // Extension
     {
-        InstWrapper inst{env->vulkan_functions};
+        InstWrapper inst{env.vulkan_functions};
         inst.create_info.add_extension(VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME);
         inst.CheckCreate();
 
         auto vkEnumeratePhysicalDeviceGroupsKHR = reinterpret_cast<PFN_vkEnumeratePhysicalDeviceGroupsKHR>(
-            env->vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkEnumeratePhysicalDeviceGroupsKHR"));
+            env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkEnumeratePhysicalDeviceGroupsKHR"));
 
         auto physical_devices = std::vector<VkPhysicalDevice>(max_physical_device_count);
         uint32_t returned_phys_dev_count = max_physical_device_count;
@@ -1331,8 +1391,10 @@ TEST_F(EnumeratePhysicalDeviceGroups, OneCall) {
     }
 }
 
-TEST_F(EnumeratePhysicalDeviceGroups, TwoCall) {
-    auto& driver = env->get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
+TEST(EnumeratePhysicalDeviceGroups, TwoCall) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
     driver.add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
 
     // ICD contains 3 devices in two groups
@@ -1347,7 +1409,7 @@ TEST_F(EnumeratePhysicalDeviceGroups, TwoCall) {
 
     // Core function
     {
-        InstWrapper inst{env->vulkan_functions};
+        InstWrapper inst{env.vulkan_functions};
         inst.create_info.set_api_version(VK_API_VERSION_1_1);
         inst.CheckCreate();
 
@@ -1386,7 +1448,7 @@ TEST_F(EnumeratePhysicalDeviceGroups, TwoCall) {
     driver.add_instance_extension({VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME});
     // Extension
     {
-        InstWrapper inst{env->vulkan_functions};
+        InstWrapper inst{env.vulkan_functions};
         inst.create_info.add_extension("VK_KHR_device_group_creation");
         inst.CheckCreate();
 
@@ -1396,7 +1458,7 @@ TEST_F(EnumeratePhysicalDeviceGroups, TwoCall) {
         handle_assert_has_values(physical_devices);
 
         auto vkEnumeratePhysicalDeviceGroupsKHR = reinterpret_cast<PFN_vkEnumeratePhysicalDeviceGroupsKHR>(
-            env->vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkEnumeratePhysicalDeviceGroupsKHR"));
+            env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkEnumeratePhysicalDeviceGroupsKHR"));
 
         uint32_t group_count = static_cast<uint32_t>(driver.physical_device_groups.size());
         uint32_t returned_group_count = 0;
@@ -1427,8 +1489,10 @@ TEST_F(EnumeratePhysicalDeviceGroups, TwoCall) {
     }
 }
 
-TEST_F(EnumeratePhysicalDeviceGroups, TwoCallIncomplete) {
-    auto& driver = env->get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
+TEST(EnumeratePhysicalDeviceGroups, TwoCallIncomplete) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
     driver.add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
 
     // ICD contains 3 devices in two groups
@@ -1442,7 +1506,7 @@ TEST_F(EnumeratePhysicalDeviceGroups, TwoCallIncomplete) {
 
     // Core function
     {
-        InstWrapper inst{env->vulkan_functions};
+        InstWrapper inst{env.vulkan_functions};
         inst.create_info.set_api_version(VK_API_VERSION_1_1);
         inst.CheckCreate();
 
@@ -1455,14 +1519,14 @@ TEST_F(EnumeratePhysicalDeviceGroups, TwoCallIncomplete) {
         std::array<VkPhysicalDeviceGroupProperties, 1> group_props{};
         group_props[0].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES;
         ASSERT_EQ(VK_INCOMPLETE, inst->vkEnumeratePhysicalDeviceGroups(inst, &returned_group_count, group_props.data()));
-        ASSERT_EQ(1, returned_group_count);
+        ASSERT_EQ(1U, returned_group_count);
 
         returned_group_count = 2;
         std::array<VkPhysicalDeviceGroupProperties, 2> group_props_2{};
         group_props_2[0].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES;
         group_props_2[1].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES;
         ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDeviceGroups(inst, &returned_group_count, group_props_2.data()));
-        ASSERT_EQ(2, returned_group_count);
+        ASSERT_EQ(2U, returned_group_count);
 
         // Make sure the incomplete group items appear in the complete group
         for (uint32_t inc_group = 0; inc_group < 1; ++inc_group) {
@@ -1481,12 +1545,12 @@ TEST_F(EnumeratePhysicalDeviceGroups, TwoCallIncomplete) {
     driver.add_instance_extension({VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME});
     // Extension
     {
-        InstWrapper inst{env->vulkan_functions};
+        InstWrapper inst{env.vulkan_functions};
         inst.create_info.add_extension("VK_KHR_device_group_creation");
         inst.CheckCreate();
 
         auto vkEnumeratePhysicalDeviceGroupsKHR = reinterpret_cast<PFN_vkEnumeratePhysicalDeviceGroupsKHR>(
-            env->vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkEnumeratePhysicalDeviceGroupsKHR"));
+            env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkEnumeratePhysicalDeviceGroupsKHR"));
 
         uint32_t group_count = static_cast<uint32_t>(driver.physical_device_groups.size());
         uint32_t returned_group_count = 0;
@@ -1497,14 +1561,14 @@ TEST_F(EnumeratePhysicalDeviceGroups, TwoCallIncomplete) {
         std::array<VkPhysicalDeviceGroupPropertiesKHR, 1> group_props{};
         group_props[0].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES;
         ASSERT_EQ(VK_INCOMPLETE, vkEnumeratePhysicalDeviceGroupsKHR(inst, &returned_group_count, group_props.data()));
-        ASSERT_EQ(1, returned_group_count);
+        ASSERT_EQ(1U, returned_group_count);
 
         returned_group_count = 2;
         std::array<VkPhysicalDeviceGroupPropertiesKHR, 2> group_props_2{};
         group_props_2[0].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES;
         group_props_2[1].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES;
         ASSERT_EQ(VK_SUCCESS, vkEnumeratePhysicalDeviceGroupsKHR(inst, &returned_group_count, group_props_2.data()));
-        ASSERT_EQ(2, returned_group_count);
+        ASSERT_EQ(2U, returned_group_count);
 
         // Make sure the incomplete group items appear in the complete group
         for (uint32_t inc_group = 0; inc_group < 1; ++inc_group) {
@@ -1524,8 +1588,10 @@ TEST_F(EnumeratePhysicalDeviceGroups, TwoCallIncomplete) {
 
 // Call the core vkEnumeratePhysicalDeviceGroups and the extension
 // vkEnumeratePhysicalDeviceGroupsKHR, and make sure they return the same info.
-TEST_F(EnumeratePhysicalDeviceGroups, TestCoreVersusExtensionSameReturns) {
-    auto& driver = env->get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
+TEST(EnumeratePhysicalDeviceGroups, TestCoreVersusExtensionSameReturns) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
     driver.add_instance_extension({VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME});
     driver.add_instance_extension({VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME});
 
@@ -1549,7 +1615,7 @@ TEST_F(EnumeratePhysicalDeviceGroups, TestCoreVersusExtensionSameReturns) {
     uint32_t ext_group_count = 0;
     std::vector<VkPhysicalDeviceGroupPropertiesKHR> ext_group_props{};
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.set_api_version(1, 1, 0);
     inst.create_info.add_extension("VK_KHR_device_group_creation");
     inst.CheckCreate();
@@ -1566,7 +1632,7 @@ TEST_F(EnumeratePhysicalDeviceGroups, TestCoreVersusExtensionSameReturns) {
     ASSERT_EQ(core_group_count, returned_group_count);
 
     auto vkEnumeratePhysicalDeviceGroupsKHR = reinterpret_cast<PFN_vkEnumeratePhysicalDeviceGroupsKHR>(
-        env->vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkEnumeratePhysicalDeviceGroupsKHR"));
+        env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkEnumeratePhysicalDeviceGroupsKHR"));
 
     ext_group_count = static_cast<uint32_t>(driver.physical_device_groups.size());
     returned_group_count = 0;
@@ -1579,8 +1645,8 @@ TEST_F(EnumeratePhysicalDeviceGroups, TestCoreVersusExtensionSameReturns) {
     ASSERT_EQ(ext_group_count, returned_group_count);
 
     // Make sure data from each matches
-    ASSERT_EQ(core_group_count, 3);
-    ASSERT_EQ(ext_group_count, 3);
+    ASSERT_EQ(core_group_count, 3U);
+    ASSERT_EQ(ext_group_count, 3U);
     for (uint32_t group = 0; group < core_group_count; ++group) {
         ASSERT_EQ(core_group_props[group].physicalDeviceCount, expected_counts[group]);
         ASSERT_EQ(ext_group_props[group].physicalDeviceCount, expected_counts[group]);
@@ -1602,8 +1668,10 @@ TEST_F(EnumeratePhysicalDeviceGroups, TestCoreVersusExtensionSameReturns) {
 
 // Start with 6 devices in 3 different groups, and then add a group,
 // querying vkEnumeratePhysicalDeviceGroups before and after the add.
-TEST_F(EnumeratePhysicalDeviceGroups, CallThriceAddGroupInBetween) {
-    auto& driver = env->get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
+TEST(EnumeratePhysicalDeviceGroups, CallThriceAddGroupInBetween) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
 
     // Generate the devices
     for (size_t i = 0; i < 7; i++) {
@@ -1625,7 +1693,7 @@ TEST_F(EnumeratePhysicalDeviceGroups, CallThriceAddGroupInBetween) {
     uint32_t after_group_count = 4;
     uint32_t returned_group_count = 0;
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.set_api_version(1, 1, 0);
     inst.CheckCreate();
 
@@ -1684,8 +1752,10 @@ TEST_F(EnumeratePhysicalDeviceGroups, CallThriceAddGroupInBetween) {
 
 // Start with 7 devices in 4 different groups, and then remove a group,
 // querying vkEnumeratePhysicalDeviceGroups before and after the remove.
-TEST_F(EnumeratePhysicalDeviceGroups, CallTwiceRemoveGroupInBetween) {
-    auto& driver = env->get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
+TEST(EnumeratePhysicalDeviceGroups, CallTwiceRemoveGroupInBetween) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
 
     // Generate the devices
     for (size_t i = 0; i < 7; i++) {
@@ -1708,7 +1778,7 @@ TEST_F(EnumeratePhysicalDeviceGroups, CallTwiceRemoveGroupInBetween) {
     uint32_t after_group_count = 3;
     uint32_t returned_group_count = 0;
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.set_api_version(1, 1, 0);
     inst.CheckCreate();
 
@@ -1758,8 +1828,10 @@ TEST_F(EnumeratePhysicalDeviceGroups, CallTwiceRemoveGroupInBetween) {
 
 // Start with 6 devices in 3 different groups, and then add a device to the middle group,
 // querying vkEnumeratePhysicalDeviceGroups before and after the add.
-TEST_F(EnumeratePhysicalDeviceGroups, CallTwiceAddDeviceInBetween) {
-    auto& driver = env->get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
+TEST(EnumeratePhysicalDeviceGroups, CallTwiceAddDeviceInBetween) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
 
     // Generate the devices
     for (size_t i = 0; i < 7; i++) {
@@ -1780,7 +1852,7 @@ TEST_F(EnumeratePhysicalDeviceGroups, CallTwiceAddDeviceInBetween) {
     uint32_t after_expected_counts[3] = {1, 4, 2};
     uint32_t returned_group_count = 0;
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.set_api_version(1, 1, 0);
     inst.CheckCreate();
 
@@ -1831,8 +1903,10 @@ TEST_F(EnumeratePhysicalDeviceGroups, CallTwiceAddDeviceInBetween) {
 
 // Start with 6 devices in 3 different groups, and then remove a device to the middle group,
 // querying vkEnumeratePhysicalDeviceGroups before and after the remove.
-TEST_F(EnumeratePhysicalDeviceGroups, CallTwiceRemoveDeviceInBetween) {
-    auto& driver = env->get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
+TEST(EnumeratePhysicalDeviceGroups, CallTwiceRemoveDeviceInBetween) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
 
     // Generate the devices
     for (size_t i = 0; i < 6; i++) {
@@ -1853,7 +1927,7 @@ TEST_F(EnumeratePhysicalDeviceGroups, CallTwiceRemoveDeviceInBetween) {
     uint32_t expected_group_count = 3;
     uint32_t returned_group_count = 0;
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.set_api_version(1, 1, 0);
     inst.CheckCreate();
 
@@ -1915,8 +1989,10 @@ TEST_F(EnumeratePhysicalDeviceGroups, CallTwiceRemoveDeviceInBetween) {
 
 // Start with 9 devices but only some in 3 different groups, add and remove
 // various devices and groups while querying in between.
-TEST_F(EnumeratePhysicalDeviceGroups, MultipleAddRemoves) {
-    auto& driver = env->get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
+TEST(EnumeratePhysicalDeviceGroups, MultipleAddRemoves) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd().set_min_icd_interface_version(5).set_icd_api_version(VK_API_VERSION_1_1);
 
     // Generate the devices
     for (size_t i = 0; i < 9; i++) {
@@ -1941,7 +2017,7 @@ TEST_F(EnumeratePhysicalDeviceGroups, MultipleAddRemoves) {
     uint32_t after_group_count = 4;
     uint32_t returned_group_count = 0;
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.create_info.set_api_version(1, 1, 0);
     inst.CheckCreate();
 
@@ -2031,7 +2107,7 @@ static void FillInRandomDeviceProps(VkPhysicalDeviceProperties& props, VkPhysica
 }
 
 // Pass in a PNext that the fake ICD will fill in some data for.
-TEST_F(EnumeratePhysicalDeviceGroups, FakePNext) {
+TEST(EnumeratePhysicalDeviceGroups, FakePNext) {
     FrameworkEnvironment env{};
 
     // ICD 0: Vulkan 1.1
@@ -2149,7 +2225,7 @@ TEST(ExtensionManual, ToolingProperties) {
 
         uint32_t tool_count = 0;
         ASSERT_EQ(VK_SUCCESS, getToolProperties(phys_dev, &tool_count, nullptr));
-        ASSERT_EQ(tool_count, 0);
+        ASSERT_EQ(tool_count, 0U);
     }
     {  // extension is supported in driver
         FrameworkEnvironment env{};
@@ -2169,10 +2245,10 @@ TEST(ExtensionManual, ToolingProperties) {
         handle_assert_has_value(getToolProperties);
         uint32_t tool_count = 0;
         ASSERT_EQ(VK_SUCCESS, getToolProperties(phys_dev, &tool_count, nullptr));
-        ASSERT_EQ(tool_count, 1);
+        ASSERT_EQ(tool_count, 1U);
         VkPhysicalDeviceToolPropertiesEXT props{};
         ASSERT_EQ(VK_SUCCESS, getToolProperties(phys_dev, &tool_count, &props));
-        ASSERT_EQ(tool_count, 1);
+        ASSERT_EQ(tool_count, 1U);
         string_eq(props.name, icd_tool_props.name);
     }
     {  // core
@@ -2193,28 +2269,32 @@ TEST(ExtensionManual, ToolingProperties) {
         handle_assert_has_value(getToolProperties);
         uint32_t tool_count = 0;
         ASSERT_EQ(VK_SUCCESS, getToolProperties(phys_dev, &tool_count, nullptr));
-        ASSERT_EQ(tool_count, 1);
+        ASSERT_EQ(tool_count, 1U);
         VkPhysicalDeviceToolProperties props{};
         ASSERT_EQ(VK_SUCCESS, getToolProperties(phys_dev, &tool_count, &props));
-        ASSERT_EQ(tool_count, 1);
+        ASSERT_EQ(tool_count, 1U);
         string_eq(props.name, icd_tool_props.name);
     }
 }
-TEST_F(CreateInstance, InstanceNullLayerPtr) {
+TEST(CreateInstance, InstanceNullLayerPtr) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     VkInstance inst = VK_NULL_HANDLE;
     VkInstanceCreateInfo info{};
     info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     info.enabledLayerCount = 1;
 
-    ASSERT_EQ(env->vulkan_functions.vkCreateInstance(&info, VK_NULL_HANDLE, &inst), VK_ERROR_LAYER_NOT_PRESENT);
+    ASSERT_EQ(env.vulkan_functions.vkCreateInstance(&info, VK_NULL_HANDLE, &inst), VK_ERROR_LAYER_NOT_PRESENT);
 }
-TEST_F(CreateInstance, InstanceNullExtensionPtr) {
+TEST(CreateInstance, InstanceNullExtensionPtr) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
     VkInstance inst = VK_NULL_HANDLE;
     VkInstanceCreateInfo info{};
     info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     info.enabledExtensionCount = 1;
 
-    ASSERT_EQ(env->vulkan_functions.vkCreateInstance(&info, VK_NULL_HANDLE, &inst), VK_ERROR_EXTENSION_NOT_PRESENT);
+    ASSERT_EQ(env.vulkan_functions.vkCreateInstance(&info, VK_NULL_HANDLE, &inst), VK_ERROR_EXTENSION_NOT_PRESENT);
 }
 
 #if defined(__linux__) || defined(__FreeBSD__)
@@ -2298,13 +2378,13 @@ TEST(SortedPhysicalDevices, DevicesSortEnabled10NoAppExt) {
             case 4:
                 ASSERT_EQ(props.deviceType, VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU);
                 ASSERT_EQ(true, !strcmp("pd5", props.deviceName));
-                ASSERT_EQ(props.vendorID, 6940);
+                ASSERT_EQ(props.vendorID, 6940U);
                 ASSERT_EQ(props.deviceID, 0xDDDD001);
                 break;
             case 5:
                 ASSERT_EQ(props.deviceType, VK_PHYSICAL_DEVICE_TYPE_CPU);
                 ASSERT_EQ(true, !strcmp("pd2", props.deviceName));
-                ASSERT_EQ(props.vendorID, 1);
+                ASSERT_EQ(props.vendorID, 1U);
                 ASSERT_EQ(props.deviceID, 0xBBBB001);
                 break;
             default:
@@ -2387,14 +2467,14 @@ TEST(SortedPhysicalDevices, DevicesSortEnabled10AppExt) {
                 ASSERT_EQ(true, !strcmp("pd3", props.deviceName));
                 ASSERT_EQ(props.vendorID, 75);
                 ASSERT_EQ(props.deviceID, 0xCCCC001);
-                ASSERT_EQ(pci_bus_info.pciBus, 1);
+                ASSERT_EQ(pci_bus_info.pciBus, 1U);
                 break;
             case 1:
                 ASSERT_EQ(props.deviceType, VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU);
                 ASSERT_EQ(true, !strcmp("pd4", props.deviceName));
                 ASSERT_EQ(props.vendorID, 75);
                 ASSERT_EQ(props.deviceID, 0xCCCC002);
-                ASSERT_EQ(pci_bus_info.pciBus, 4);
+                ASSERT_EQ(pci_bus_info.pciBus, 4U);
                 break;
             case 2:
                 ASSERT_EQ(props.deviceType, VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU);
@@ -2408,21 +2488,21 @@ TEST(SortedPhysicalDevices, DevicesSortEnabled10AppExt) {
                 ASSERT_EQ(true, !strcmp("pd1", props.deviceName));
                 ASSERT_EQ(props.vendorID, 888);
                 ASSERT_EQ(props.deviceID, 0xAAA002);
-                ASSERT_EQ(pci_bus_info.pciBus, 3);
+                ASSERT_EQ(pci_bus_info.pciBus, 3U);
                 break;
             case 4:
                 ASSERT_EQ(props.deviceType, VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU);
                 ASSERT_EQ(true, !strcmp("pd5", props.deviceName));
-                ASSERT_EQ(props.vendorID, 6940);
+                ASSERT_EQ(props.vendorID, 6940U);
                 ASSERT_EQ(props.deviceID, 0xDDDD001);
-                ASSERT_EQ(pci_bus_info.pciBus, 0);
+                ASSERT_EQ(pci_bus_info.pciBus, 0U);
                 break;
             case 5:
                 ASSERT_EQ(props.deviceType, VK_PHYSICAL_DEVICE_TYPE_CPU);
                 ASSERT_EQ(true, !strcmp("pd2", props.deviceName));
-                ASSERT_EQ(props.vendorID, 1);
+                ASSERT_EQ(props.vendorID, 1U);
                 ASSERT_EQ(props.deviceID, 0xBBBB001);
-                ASSERT_EQ(pci_bus_info.pciBus, 0);
+                ASSERT_EQ(pci_bus_info.pciBus, 0U);
                 break;
             default:
                 ASSERT_EQ(false, true);
@@ -2508,14 +2588,14 @@ TEST(SortedPhysicalDevices, DevicesSortEnabled11) {
                 ASSERT_EQ(true, !strcmp("pd3", props.deviceName));
                 ASSERT_EQ(props.vendorID, 75);
                 ASSERT_EQ(props.deviceID, 0xCCCC001);
-                ASSERT_EQ(pci_bus_info.pciBus, 1);
+                ASSERT_EQ(pci_bus_info.pciBus, 1U);
                 break;
             case 1:
                 ASSERT_EQ(props.deviceType, VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU);
                 ASSERT_EQ(true, !strcmp("pd4", props.deviceName));
                 ASSERT_EQ(props.vendorID, 75);
                 ASSERT_EQ(props.deviceID, 0xCCCC002);
-                ASSERT_EQ(pci_bus_info.pciBus, 4);
+                ASSERT_EQ(pci_bus_info.pciBus, 4U);
                 break;
             case 2:
                 ASSERT_EQ(props.deviceType, VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU);
@@ -2529,21 +2609,21 @@ TEST(SortedPhysicalDevices, DevicesSortEnabled11) {
                 ASSERT_EQ(true, !strcmp("pd1", props.deviceName));
                 ASSERT_EQ(props.vendorID, 888);
                 ASSERT_EQ(props.deviceID, 0xAAA002);
-                ASSERT_EQ(pci_bus_info.pciBus, 3);
+                ASSERT_EQ(pci_bus_info.pciBus, 3U);
                 break;
             case 4:
                 ASSERT_EQ(props.deviceType, VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU);
                 ASSERT_EQ(true, !strcmp("pd5", props.deviceName));
-                ASSERT_EQ(props.vendorID, 6940);
+                ASSERT_EQ(props.vendorID, 6940U);
                 ASSERT_EQ(props.deviceID, 0xDDDD001);
-                ASSERT_EQ(pci_bus_info.pciBus, 0);
+                ASSERT_EQ(pci_bus_info.pciBus, 0U);
                 break;
             case 5:
                 ASSERT_EQ(props.deviceType, VK_PHYSICAL_DEVICE_TYPE_CPU);
                 ASSERT_EQ(true, !strcmp("pd2", props.deviceName));
-                ASSERT_EQ(props.vendorID, 1);
+                ASSERT_EQ(props.vendorID, 1U);
                 ASSERT_EQ(props.deviceID, 0xBBBB001);
-                ASSERT_EQ(pci_bus_info.pciBus, 0);
+                ASSERT_EQ(pci_bus_info.pciBus, 0U);
                 break;
             default:
                 ASSERT_EQ(false, true);
@@ -2782,21 +2862,21 @@ TEST(SortedPhysicalDevices, DeviceGroupsSortedEnabled) {
                     ASSERT_EQ(true, !strcmp("pd4", props.deviceName));
                     ASSERT_EQ(props.vendorID, 75);
                     ASSERT_EQ(props.deviceID, 0xCCCC001);
-                    ASSERT_EQ(pci_bus_info.pciBus, 1);
+                    ASSERT_EQ(pci_bus_info.pciBus, 1U);
                     break;
                 case 1:
                     ASSERT_EQ(props.deviceType, VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU);
                     ASSERT_EQ(true, !strcmp("pd6", props.deviceName));
                     ASSERT_EQ(props.vendorID, 75);
                     ASSERT_EQ(props.deviceID, 0xCCCC003);
-                    ASSERT_EQ(pci_bus_info.pciBus, 2);
+                    ASSERT_EQ(pci_bus_info.pciBus, 2U);
                     break;
                 case 2:
                     ASSERT_EQ(props.deviceType, VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU);
                     ASSERT_EQ(true, !strcmp("pd5", props.deviceName));
                     ASSERT_EQ(props.vendorID, 75);
                     ASSERT_EQ(props.deviceID, 0xCCCC002);
-                    ASSERT_EQ(pci_bus_info.pciBus, 4);
+                    ASSERT_EQ(pci_bus_info.pciBus, 4U);
                     break;
                 case 3:
                     ASSERT_EQ(props.deviceType, VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU);
@@ -2817,21 +2897,21 @@ TEST(SortedPhysicalDevices, DeviceGroupsSortedEnabled) {
                     ASSERT_EQ(true, !strcmp("pd1", props.deviceName));
                     ASSERT_EQ(props.vendorID, 888);
                     ASSERT_EQ(props.deviceID, 0xAAA002);
-                    ASSERT_EQ(pci_bus_info.pciBus, 3);
+                    ASSERT_EQ(pci_bus_info.pciBus, 3U);
                     break;
                 case 6:
                     ASSERT_EQ(props.deviceType, VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU);
                     ASSERT_EQ(true, !strcmp("pd7", props.deviceName));
-                    ASSERT_EQ(props.vendorID, 6940);
+                    ASSERT_EQ(props.vendorID, 6940U);
                     ASSERT_EQ(props.deviceID, 0xDDDD001);
-                    ASSERT_EQ(pci_bus_info.pciBus, 0);
+                    ASSERT_EQ(pci_bus_info.pciBus, 0U);
                     break;
                 case 7:
                     ASSERT_EQ(props.deviceType, VK_PHYSICAL_DEVICE_TYPE_CPU);
                     ASSERT_EQ(true, !strcmp("pd3", props.deviceName));
-                    ASSERT_EQ(props.vendorID, 1);
+                    ASSERT_EQ(props.vendorID, 1U);
                     ASSERT_EQ(props.deviceID, 0xBBBB001);
-                    ASSERT_EQ(pci_bus_info.pciBus, 0);
+                    ASSERT_EQ(pci_bus_info.pciBus, 0U);
                     break;
                 default:
                     ASSERT_EQ(false, true);
diff --git a/tests/loader_threading_tests.cpp b/tests/loader_threading_tests.cpp
index 75619b497..9e5a5b226 100644
--- a/tests/loader_threading_tests.cpp
+++ b/tests/loader_threading_tests.cpp
@@ -30,17 +30,6 @@
 #include <mutex>
 #include <thread>
 
-class ThreadingTests : public ::testing::Test {
-   protected:
-    virtual void SetUp() {
-        env = std::unique_ptr<FrameworkEnvironment>(new FrameworkEnvironment());
-        env->add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
-    }
-
-    virtual void TearDown() { env.reset(); }
-    std::unique_ptr<FrameworkEnvironment> env;
-};
-
 void create_destroy_device_loop(uint32_t num_loops_create_destroy_device, uint32_t num_loops_try_get_proc_addr, InstWrapper* inst,
                                 VkPhysicalDevice phys_dev) {
     for (uint32_t i = 0; i < num_loops_create_destroy_device; i++) {
@@ -66,7 +55,6 @@ void create_destroy_device_loop(uint32_t num_loops_create_destroy_device, uint32
         }
     }
 }
-
 VKAPI_ATTR void VKAPI_CALL test_vkCmdBindPipeline(VkCommandBuffer cmd_buf, VkPipelineBindPoint pipelineBindPoint,
                                                   VkPipeline pipeline) {}
 VKAPI_ATTR void VKAPI_CALL test_vkCmdBindDescriptorSets(VkCommandBuffer cmd_buf, VkPipelineBindPoint pipelineBindPoint,
@@ -79,21 +67,26 @@ VKAPI_ATTR void VKAPI_CALL test_vkCmdBindIndexBuffer(VkCommandBuffer cmd_buf, ui
                                                      const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {}
 VKAPI_ATTR void VKAPI_CALL test_vkCmdDraw(VkCommandBuffer cmd_buf, uint32_t vertexCount, uint32_t instanceCount,
                                           uint32_t firstVertex, uint32_t firstInstance) {}
-TEST_F(ThreadingTests, ConcurentGetDeviceProcAddr) {
+TEST(ThreadingTests, ConcurentGetDeviceProcAddr) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
     uint32_t num_threads = 100;
     uint32_t num_loops_create_destroy_device = 10;
     uint32_t num_loops_try_get_proc_addr = 100;
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
 
     driver.physical_devices.emplace_back("physical_device_0");
-    driver.physical_devices.back().known_device_functions.push_back({"vkCmdBindPipeline", (void*)test_vkCmdBindPipeline});
     driver.physical_devices.back().known_device_functions.push_back(
-        {"vkCmdBindDescriptorSets", (void*)test_vkCmdBindDescriptorSets});
-    driver.physical_devices.back().known_device_functions.push_back({"vkCmdBindVertexBuffers", (void*)test_vkCmdBindVertexBuffers});
-    driver.physical_devices.back().known_device_functions.push_back({"vkCmdBindIndexBuffer", (void*)test_vkCmdBindIndexBuffer});
-    driver.physical_devices.back().known_device_functions.push_back({"vkCmdDraw", (void*)test_vkCmdDraw});
+        {"vkCmdBindPipeline", reinterpret_cast<void*>(test_vkCmdBindPipeline)});
+    driver.physical_devices.back().known_device_functions.push_back(
+        {"vkCmdBindDescriptorSets", reinterpret_cast<void*>(test_vkCmdBindDescriptorSets)});
+    driver.physical_devices.back().known_device_functions.push_back(
+        {"vkCmdBindVertexBuffers", reinterpret_cast<void*>(test_vkCmdBindVertexBuffers)});
+    driver.physical_devices.back().known_device_functions.push_back(
+        {"vkCmdBindIndexBuffer", reinterpret_cast<void*>(test_vkCmdBindIndexBuffer)});
+    driver.physical_devices.back().known_device_functions.push_back({"vkCmdDraw", reinterpret_cast<void*>(test_vkCmdDraw)});
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     VkPhysicalDevice phys_dev = inst.GetPhysDev();
@@ -110,4 +103,4 @@ TEST_F(ThreadingTests, ConcurentGetDeviceProcAddr) {
     for (uint32_t i = 0; i < num_threads; i++) {
         threads[i].join();
     }
-}
\ No newline at end of file
+}
diff --git a/tests/loader_unknown_ext_tests.cpp b/tests/loader_unknown_ext_tests.cpp
index 6c6814f8b..357892a66 100644
--- a/tests/loader_unknown_ext_tests.cpp
+++ b/tests/loader_unknown_ext_tests.cpp
@@ -28,17 +28,6 @@
 #include "test_environment.h"
 #include <functional>
 
-class UnknownFunction : public ::testing::Test {
-   protected:
-    virtual void SetUp() {
-        env = std::unique_ptr<FrameworkEnvironment>(new FrameworkEnvironment());
-        env->add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
-    }
-
-    virtual void TearDown() { env.reset(); }
-    std::unique_ptr<FrameworkEnvironment> env;
-};
-
 /*
  Creates a TestICD with a function unknown to the loader called vkNotRealFuncTEST. The TestICD, when vk_icdGetPhysicalDeviceProcAddr
  is called, will return the custom_physical_device_function if the function name matches vkNotRealFuncTEST. The test then calls the
@@ -109,32 +98,36 @@ void check_custom_functions(FunctionLoader& loader, ParentType parent, Dispatcha
 }
 using custom_physical_device_functions = custom_functions<VkPhysicalDevice>;
 
-TEST_F(UnknownFunction, PhysicalDeviceFunction) {
+TEST(UnknownFunction, PhysicalDeviceFunction) {
 #if defined(__APPLE__)
     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));
     uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     std::vector<std::string> fake_function_names;
 
     driver.physical_devices.emplace_back("physical_device_0");
     fill_custom_functions(driver.custom_physical_device_functions, fake_function_names, custom_physical_device_functions{},
                           function_count);
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     VkPhysicalDevice phys_dev = inst.GetPhysDev();
-    check_custom_functions(env->vulkan_functions, inst.inst, phys_dev, custom_physical_device_functions{}, fake_function_names,
+    check_custom_functions(env.vulkan_functions, inst.inst, phys_dev, custom_physical_device_functions{}, fake_function_names,
                            function_count);
 }
 
-TEST_F(UnknownFunction, PhysicalDeviceFunctionMultipleDriverSupport) {
+TEST(UnknownFunction, PhysicalDeviceFunctionMultipleDriverSupport) {
 #if defined(__APPLE__)
     GTEST_SKIP() << "Skip this test as currently macOS doesn't fully support unknown functions.";
 #endif
-    env->add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
-    auto& driver_0 = env->get_test_icd(0);
-    auto& driver_1 = env->get_test_icd(1);
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    auto& driver_0 = env.get_test_icd(0);
+    auto& driver_1 = env.get_test_icd(1);
     std::vector<std::string> fake_function_names;
 
     // used to identify the GPUs
@@ -152,22 +145,22 @@ TEST_F(UnknownFunction, PhysicalDeviceFunctionMultipleDriverSupport) {
         fill_custom_functions(driver_1.custom_physical_device_functions, fake_function_names, custom_physical_device_functions{}, 5,
                               i * 10 + 5);
     }
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     auto phys_devs = inst.GetPhysDevs(2);
     VkPhysicalDevice phys_dev_0 = phys_devs[0];
     VkPhysicalDevice phys_dev_1 = phys_devs[1];
-    env->vulkan_functions.vkGetPhysicalDeviceProperties(phys_devs[0], &props);
+    env.vulkan_functions.vkGetPhysicalDeviceProperties(phys_devs[0], &props);
     if (props.deviceType != VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) {
         phys_dev_0 = phys_devs[1];
         phys_dev_1 = phys_devs[0];
     }
     for (uint32_t i = 0; i < 25; i++) {
-        check_custom_functions(env->vulkan_functions, inst.inst, phys_dev_0, custom_physical_device_functions{},
-                               fake_function_names, 5, i * 10);
-        check_custom_functions(env->vulkan_functions, inst.inst, phys_dev_1, custom_physical_device_functions{},
-                               fake_function_names, 5, i * 10 + 5);
+        check_custom_functions(env.vulkan_functions, inst.inst, phys_dev_0, custom_physical_device_functions{}, fake_function_names,
+                               5, i * 10);
+        check_custom_functions(env.vulkan_functions, inst.inst, phys_dev_1, custom_physical_device_functions{}, fake_function_names,
+                               5, i * 10 + 5);
     }
 }
 
@@ -212,39 +205,43 @@ TEST(UnknownFunctionDeathTests, PhysicalDeviceFunctionErrorPath) {
     ASSERT_DEATH(returned_func_i(phys_dev_to_use, 0), "Extension vkNotIntRealFuncTEST_0 not supported for this physical device");
 }
 
-TEST_F(UnknownFunction, PhysicalDeviceFunctionWithImplicitLayer) {
+TEST(UnknownFunction, PhysicalDeviceFunctionWithImplicitLayer) {
 #if defined(__APPLE__)
     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));
     uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     std::vector<std::string> fake_function_names;
 
     driver.physical_devices.emplace_back("physical_device_0");
     fill_custom_functions(driver.custom_physical_device_functions, fake_function_names, custom_physical_device_functions{},
                           function_count);
 
-    env->add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name("VK_LAYER_implicit_layer_unknown_function_intercept")
-                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                                          .set_disable_environment("DISABLE_ME")),
-                            "implicit_layer_unknown_function_intercept.json");
+    env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name("VK_LAYER_implicit_layer_unknown_function_intercept")
+                                                         .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                                         .set_disable_environment("DISABLE_ME")),
+                           "implicit_layer_unknown_function_intercept.json");
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     VkPhysicalDevice phys_dev = inst.GetPhysDev();
-    check_custom_functions(env->vulkan_functions, inst.inst, phys_dev, custom_physical_device_functions{}, fake_function_names,
+    check_custom_functions(env.vulkan_functions, inst.inst, phys_dev, custom_physical_device_functions{}, fake_function_names,
                            function_count);
 }
 
-TEST_F(UnknownFunction, PhysicalDeviceFunctionMultipleDriverSupportWithImplicitLayer) {
+TEST(UnknownFunction, PhysicalDeviceFunctionMultipleDriverSupportWithImplicitLayer) {
 #if defined(__APPLE__)
     GTEST_SKIP() << "Skip this test as currently macOS doesn't fully support unknown functions.";
 #endif
-    env->add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
-    auto& driver_0 = env->get_test_icd(0);
-    auto& driver_1 = env->get_test_icd(1);
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    auto& driver_0 = env.get_test_icd(0);
+    auto& driver_1 = env.get_test_icd(1);
     std::vector<std::string> fake_function_names;
 
     // used to identify the GPUs
@@ -262,184 +259,197 @@ TEST_F(UnknownFunction, PhysicalDeviceFunctionMultipleDriverSupportWithImplicitL
                               i * 10 + 5);
     }
 
-    env->add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name("VK_LAYER_implicit_layer_unknown_function_intercept")
-                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                                          .set_disable_environment("DISABLE_ME")),
-                            "implicit_layer_unknown_function_intercept.json");
+    env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name("VK_LAYER_implicit_layer_unknown_function_intercept")
+                                                         .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                                         .set_disable_environment("DISABLE_ME")),
+                           "implicit_layer_unknown_function_intercept.json");
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     auto phys_devs = inst.GetPhysDevs(2);
     VkPhysicalDevice phys_dev_0 = phys_devs[0];
     VkPhysicalDevice phys_dev_1 = phys_devs[1];
-    env->vulkan_functions.vkGetPhysicalDeviceProperties(phys_devs[0], &props);
+    env.vulkan_functions.vkGetPhysicalDeviceProperties(phys_devs[0], &props);
     if (props.deviceType != VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) {
         phys_dev_0 = phys_devs[1];
         phys_dev_1 = phys_devs[0];
     }
     for (uint32_t i = 0; i < 25; i++) {
-        check_custom_functions(env->vulkan_functions, inst.inst, phys_dev_0, custom_physical_device_functions{},
-                               fake_function_names, 5, i * 10);
-        check_custom_functions(env->vulkan_functions, inst.inst, phys_dev_1, custom_physical_device_functions{},
-                               fake_function_names, 5, i * 10 + 5);
+        check_custom_functions(env.vulkan_functions, inst.inst, phys_dev_0, custom_physical_device_functions{}, fake_function_names,
+                               5, i * 10);
+        check_custom_functions(env.vulkan_functions, inst.inst, phys_dev_1, custom_physical_device_functions{}, fake_function_names,
+                               5, i * 10 + 5);
     }
 }
 
-TEST_F(UnknownFunction, PhysicalDeviceFunctionWithImplicitLayerInterception) {
+TEST(UnknownFunction, PhysicalDeviceFunctionWithImplicitLayerInterception) {
 #if defined(__APPLE__)
     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));
     uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     std::vector<std::string> fake_function_names;
 
     driver.physical_devices.emplace_back("physical_device_0");
 
-    env->add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name("VK_LAYER_implicit_layer_unknown_function_intercept")
-                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                                          .set_disable_environment("DISABLE_ME")),
-                            "implicit_layer_unknown_function_intercept.json");
-    auto& layer = env->get_test_layer();
+    env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name("VK_LAYER_implicit_layer_unknown_function_intercept")
+                                                         .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                                         .set_disable_environment("DISABLE_ME")),
+                           "implicit_layer_unknown_function_intercept.json");
+    auto& layer = env.get_test_layer();
     fill_custom_functions(layer.custom_physical_device_functions, fake_function_names, custom_physical_device_functions{},
                           function_count);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     VkPhysicalDevice phys_dev = inst.GetPhysDev();
-    check_custom_functions(env->vulkan_functions, inst.inst, phys_dev, custom_physical_device_functions{}, fake_function_names,
+    check_custom_functions(env.vulkan_functions, inst.inst, phys_dev, custom_physical_device_functions{}, fake_function_names,
                            function_count);
 }
 
-TEST_F(UnknownFunction, PhysicalDeviceFunctionWithMultipleImplicitLayersInterception) {
+TEST(UnknownFunction, PhysicalDeviceFunctionWithMultipleImplicitLayersInterception) {
 #if defined(__APPLE__)
     GTEST_SKIP() << "Skip this test as currently macOS doesn't fully support unknown functions.";
 #endif
-    auto& driver = env->get_test_icd();
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
+    auto& driver = env.get_test_icd();
     std::vector<std::string> fake_function_names;
 
     driver.physical_devices.emplace_back("physical_device_0");
 
-    env->add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name("VK_LAYER_implicit_layer_unknown_function_intercept_0")
-                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                                          .set_disable_environment("DISABLE_ME")),
-                            "implicit_layer_unknown_function_intercept_0.json");
-    auto& layer_0 = env->get_test_layer();
-    env->add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name("VK_LAYER_implicit_layer_unknown_function_intercept_1")
-                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                                          .set_disable_environment("DISABLE_ME")),
-                            "implicit_layer_unknown_function_intercept_1.json");
-    auto& layer_1 = env->get_test_layer();
+    env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name("VK_LAYER_implicit_layer_unknown_function_intercept_0")
+                                                         .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                                         .set_disable_environment("DISABLE_ME")),
+                           "implicit_layer_unknown_function_intercept_0.json");
+    auto& layer_0 = env.get_test_layer();
+    env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name("VK_LAYER_implicit_layer_unknown_function_intercept_1")
+                                                         .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                                         .set_disable_environment("DISABLE_ME")),
+                           "implicit_layer_unknown_function_intercept_1.json");
+    auto& layer_1 = env.get_test_layer();
     for (uint32_t i = 0; i < 25; i++) {
         fill_custom_functions(layer_0.custom_physical_device_functions, fake_function_names, custom_physical_device_functions{}, 5,
                               i * 10);
         fill_custom_functions(layer_1.custom_physical_device_functions, fake_function_names, custom_physical_device_functions{}, 5,
                               i * 10 + 5);
     }
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     VkPhysicalDevice phys_dev = inst.GetPhysDev();
-    check_custom_functions(env->vulkan_functions, inst.inst, phys_dev, custom_physical_device_functions{}, fake_function_names,
-                           250);
+    check_custom_functions(env.vulkan_functions, inst.inst, phys_dev, custom_physical_device_functions{}, fake_function_names, 250);
 }
 
 using custom_device_functions = custom_functions<VkDevice>;
 
-TEST_F(UnknownFunction, DeviceFunctionFromGetInstanceProcAddr) {
+TEST(UnknownFunction, DeviceFunctionFromGetInstanceProcAddr) {
 #if defined(__APPLE__)
     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));
     uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
     std::vector<std::string> fake_function_names;
 
     fill_custom_functions(driver.physical_devices.back().known_device_functions, fake_function_names, custom_device_functions{},
                           function_count);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     DeviceWrapper dev{inst};
     dev.CheckCreate(inst.GetPhysDev());
-    check_custom_functions(env->vulkan_functions, inst.inst, dev.dev, custom_device_functions{}, fake_function_names,
+    check_custom_functions(env.vulkan_functions, inst.inst, dev.dev, custom_device_functions{}, fake_function_names,
                            function_count);
 }
 
-TEST_F(UnknownFunction, DeviceFunctionFromGetInstanceProcAddrWithImplicitLayer) {
+TEST(UnknownFunction, DeviceFunctionFromGetInstanceProcAddrWithImplicitLayer) {
 #if defined(__APPLE__)
     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));
     uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
     std::vector<std::string> fake_function_names;
     fill_custom_functions(driver.physical_devices.back().known_device_functions, fake_function_names, custom_device_functions{},
                           function_count);
 
-    env->add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name("VK_LAYER_implicit_layer_unknown_function_intercept")
-                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                                          .set_disable_environment("DISABLE_ME")),
-                            "implicit_layer_unknown_function_intercept.json");
+    env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name("VK_LAYER_implicit_layer_unknown_function_intercept")
+                                                         .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                                         .set_disable_environment("DISABLE_ME")),
+                           "implicit_layer_unknown_function_intercept.json");
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     DeviceWrapper dev{inst};
     dev.CheckCreate(inst.GetPhysDev());
-    check_custom_functions(env->vulkan_functions, inst.inst, dev.dev, custom_device_functions{}, fake_function_names,
+    check_custom_functions(env.vulkan_functions, inst.inst, dev.dev, custom_device_functions{}, fake_function_names,
                            function_count);
 }
 
-TEST_F(UnknownFunction, DeviceFunctionFromGetDeviceProcAddr) {
+TEST(UnknownFunction, DeviceFunctionFromGetDeviceProcAddr) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
     uint32_t function_count = 1000;
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
     std::vector<std::string> fake_function_names;
     fill_custom_functions(driver.physical_devices.back().known_device_functions, fake_function_names, custom_device_functions{},
                           function_count);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     DeviceWrapper dev{inst};
     dev.CheckCreate(inst.GetPhysDev());
-    check_custom_functions(env->vulkan_functions, dev.dev, dev.dev, custom_device_functions{}, fake_function_names, function_count);
+    check_custom_functions(env.vulkan_functions, dev.dev, dev.dev, custom_device_functions{}, fake_function_names, function_count);
 }
 
-TEST_F(UnknownFunction, DeviceFunctionFromGetDeviceProcAddrWithImplicitLayer) {
+TEST(UnknownFunction, DeviceFunctionFromGetDeviceProcAddrWithImplicitLayer) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
     uint32_t function_count = 1000;
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
     std::vector<std::string> fake_function_names;
     fill_custom_functions(driver.physical_devices.back().known_device_functions, fake_function_names, custom_device_functions{},
                           function_count);
-    env->add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name("VK_LAYER_implicit_layer_unknown_function_intercept")
-                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                                          .set_disable_environment("DISABLE_ME")),
-                            "implicit_layer_unknown_function_intercept.json");
+    env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name("VK_LAYER_implicit_layer_unknown_function_intercept")
+                                                         .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                                         .set_disable_environment("DISABLE_ME")),
+                           "implicit_layer_unknown_function_intercept.json");
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     DeviceWrapper dev{inst};
     dev.CheckCreate(inst.GetPhysDev());
-    check_custom_functions(env->vulkan_functions, dev.dev, dev.dev, custom_device_functions{}, fake_function_names, function_count);
+    check_custom_functions(env.vulkan_functions, dev.dev, dev.dev, custom_device_functions{}, fake_function_names, function_count);
 }
 
 using custom_command_buffer_functions = custom_functions<VkCommandBuffer>;
 
-TEST_F(UnknownFunction, CommandBufferFunctionFromGetDeviceProcAddr) {
+TEST(UnknownFunction, CommandBufferFunctionFromGetDeviceProcAddr) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
     uint32_t function_count = 1000;
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices.back().add_queue_family_properties({});
     std::vector<std::string> fake_function_names;
@@ -447,13 +457,13 @@ TEST_F(UnknownFunction, CommandBufferFunctionFromGetDeviceProcAddr) {
     fill_custom_functions(driver.physical_devices.back().known_device_functions, fake_function_names,
                           custom_command_buffer_functions{}, function_count);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     DeviceWrapper dev{inst};
     dev.CheckCreate(inst.GetPhysDev());
 
-    DeviceFunctions funcs{env->vulkan_functions, dev};
+    DeviceFunctions funcs{env.vulkan_functions, dev};
     VkCommandPool command_pool;
     VkCommandPoolCreateInfo pool_create_info{};
     funcs.vkCreateCommandPool(dev, &pool_create_info, nullptr, &command_pool);
@@ -463,32 +473,34 @@ TEST_F(UnknownFunction, CommandBufferFunctionFromGetDeviceProcAddr) {
     alloc_info.commandPool = command_pool;
     funcs.vkAllocateCommandBuffers(dev, &alloc_info, &command_buffer);
 
-    check_custom_functions(env->vulkan_functions, dev.dev, command_buffer, custom_command_buffer_functions{}, fake_function_names,
+    check_custom_functions(env.vulkan_functions, dev.dev, command_buffer, custom_command_buffer_functions{}, fake_function_names,
                            function_count);
 }
 
-TEST_F(UnknownFunction, CommandBufferFunctionFromGetDeviceProcAddrWithImplicitLayer) {
+TEST(UnknownFunction, CommandBufferFunctionFromGetDeviceProcAddrWithImplicitLayer) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
     uint32_t function_count = 1000;
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices.back().add_queue_family_properties({});
     std::vector<std::string> fake_function_names;
     fill_custom_functions(driver.physical_devices.back().known_device_functions, fake_function_names,
                           custom_command_buffer_functions{}, function_count);
 
-    env->add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name("VK_LAYER_implicit_layer_unknown_function_intercept")
-                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                                          .set_disable_environment("DISABLE_ME")),
-                            "implicit_layer_unknown_function_intercept.json");
+    env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name("VK_LAYER_implicit_layer_unknown_function_intercept")
+                                                         .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                                         .set_disable_environment("DISABLE_ME")),
+                           "implicit_layer_unknown_function_intercept.json");
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     DeviceWrapper dev{inst};
     dev.CheckCreate(inst.GetPhysDev());
 
-    DeviceFunctions funcs{env->vulkan_functions, dev};
+    DeviceFunctions funcs{env.vulkan_functions, dev};
     VkCommandPool command_pool;
     VkCommandPoolCreateInfo pool_create_info{};
     funcs.vkCreateCommandPool(dev, &pool_create_info, nullptr, &command_pool);
@@ -498,29 +510,31 @@ TEST_F(UnknownFunction, CommandBufferFunctionFromGetDeviceProcAddrWithImplicitLa
     alloc_info.commandPool = command_pool;
     funcs.vkAllocateCommandBuffers(dev, &alloc_info, &command_buffer);
 
-    check_custom_functions(env->vulkan_functions, dev.dev, command_buffer, custom_command_buffer_functions{}, fake_function_names,
+    check_custom_functions(env.vulkan_functions, dev.dev, command_buffer, custom_command_buffer_functions{}, fake_function_names,
                            function_count);
 }
 
-TEST_F(UnknownFunction, CommandBufferFunctionFromGetInstanceProcAddr) {
+TEST(UnknownFunction, CommandBufferFunctionFromGetInstanceProcAddr) {
 #if defined(__APPLE__)
     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));
     uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices.back().add_queue_family_properties({});
     std::vector<std::string> fake_function_names;
     fill_custom_functions(driver.physical_devices.back().known_device_functions, fake_function_names,
                           custom_command_buffer_functions{}, function_count);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     DeviceWrapper dev{inst};
     dev.CheckCreate(inst.GetPhysDev());
 
-    DeviceFunctions funcs{env->vulkan_functions, dev};
+    DeviceFunctions funcs{env.vulkan_functions, dev};
     VkCommandPool command_pool;
     VkCommandPoolCreateInfo pool_create_info{};
     funcs.vkCreateCommandPool(dev, &pool_create_info, nullptr, &command_pool);
@@ -530,35 +544,37 @@ TEST_F(UnknownFunction, CommandBufferFunctionFromGetInstanceProcAddr) {
     alloc_info.commandPool = command_pool;
     funcs.vkAllocateCommandBuffers(dev, &alloc_info, &command_buffer);
 
-    check_custom_functions(env->vulkan_functions, inst.inst, command_buffer, custom_command_buffer_functions{}, fake_function_names,
+    check_custom_functions(env.vulkan_functions, inst.inst, command_buffer, custom_command_buffer_functions{}, fake_function_names,
                            function_count);
 }
 
-TEST_F(UnknownFunction, CommandBufferFunctionFromGetInstanceProcAddrWithImplicitLayer) {
+TEST(UnknownFunction, CommandBufferFunctionFromGetInstanceProcAddrWithImplicitLayer) {
 #if defined(__APPLE__)
     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));
     uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices.back().add_queue_family_properties({});
     std::vector<std::string> fake_function_names;
     fill_custom_functions(driver.physical_devices.back().known_device_functions, fake_function_names,
                           custom_command_buffer_functions{}, function_count);
 
-    env->add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name("VK_LAYER_implicit_layer_unknown_function_intercept")
-                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                                          .set_disable_environment("DISABLE_ME")),
-                            "implicit_layer_unknown_function_intercept.json");
+    env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name("VK_LAYER_implicit_layer_unknown_function_intercept")
+                                                         .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                                         .set_disable_environment("DISABLE_ME")),
+                           "implicit_layer_unknown_function_intercept.json");
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     DeviceWrapper dev{inst};
     dev.CheckCreate(inst.GetPhysDev());
 
-    DeviceFunctions funcs{env->vulkan_functions, dev};
+    DeviceFunctions funcs{env.vulkan_functions, dev};
     VkCommandPool command_pool;
     VkCommandPoolCreateInfo pool_create_info{};
     funcs.vkCreateCommandPool(dev, &pool_create_info, nullptr, &command_pool);
@@ -568,110 +584,118 @@ TEST_F(UnknownFunction, CommandBufferFunctionFromGetInstanceProcAddrWithImplicit
     alloc_info.commandPool = command_pool;
     funcs.vkAllocateCommandBuffers(dev, &alloc_info, &command_buffer);
 
-    check_custom_functions(env->vulkan_functions, inst.inst, command_buffer, custom_command_buffer_functions{}, fake_function_names,
+    check_custom_functions(env.vulkan_functions, inst.inst, command_buffer, custom_command_buffer_functions{}, fake_function_names,
                            function_count);
 }
 
 using custom_queue_functions = custom_functions<VkQueue>;
 
-TEST_F(UnknownFunction, QueueFunctionFromGetDeviceProcAddr) {
+TEST(UnknownFunction, QueueFunctionFromGetDeviceProcAddr) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
     uint32_t function_count = 1000;
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices.back().add_queue_family_properties({});
     std::vector<std::string> fake_function_names;
     fill_custom_functions(driver.physical_devices.back().known_device_functions, fake_function_names, custom_queue_functions{},
                           function_count);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     DeviceWrapper dev{inst};
     dev.create_info.add_device_queue({});
     dev.CheckCreate(inst.GetPhysDev());
     VkQueue queue{};
-    env->vulkan_functions.vkGetDeviceQueue(dev, 0, 0, &queue);
+    env.vulkan_functions.vkGetDeviceQueue(dev, 0, 0, &queue);
 
-    check_custom_functions(env->vulkan_functions, dev.dev, queue, custom_queue_functions{}, fake_function_names, function_count);
+    check_custom_functions(env.vulkan_functions, dev.dev, queue, custom_queue_functions{}, fake_function_names, function_count);
 }
 
-TEST_F(UnknownFunction, QueueFunctionFromGetDeviceProcAddrWithImplicitLayer) {
+TEST(UnknownFunction, QueueFunctionFromGetDeviceProcAddrWithImplicitLayer) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_6));
     uint32_t function_count = 1000;
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices.back().add_queue_family_properties({});
     std::vector<std::string> fake_function_names;
     fill_custom_functions(driver.physical_devices.back().known_device_functions, fake_function_names, custom_queue_functions{},
                           function_count);
 
-    env->add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name("VK_LAYER_implicit_layer_unknown_function_intercept")
-                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                                          .set_disable_environment("DISABLE_ME")),
-                            "implicit_layer_unknown_function_intercept.json");
+    env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name("VK_LAYER_implicit_layer_unknown_function_intercept")
+                                                         .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                                         .set_disable_environment("DISABLE_ME")),
+                           "implicit_layer_unknown_function_intercept.json");
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     DeviceWrapper dev{inst};
     dev.create_info.add_device_queue({});
     dev.CheckCreate(inst.GetPhysDev());
     VkQueue queue{};
-    env->vulkan_functions.vkGetDeviceQueue(dev, 0, 0, &queue);
+    env.vulkan_functions.vkGetDeviceQueue(dev, 0, 0, &queue);
 
-    check_custom_functions(env->vulkan_functions, dev.dev, queue, custom_queue_functions{}, fake_function_names, function_count);
+    check_custom_functions(env.vulkan_functions, dev.dev, queue, custom_queue_functions{}, fake_function_names, function_count);
 }
 
-TEST_F(UnknownFunction, QueueFunctionFromGetInstanceProcAddr) {
+TEST(UnknownFunction, QueueFunctionFromGetInstanceProcAddr) {
 #if defined(__APPLE__)
     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));
     uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices.back().add_queue_family_properties({});
     std::vector<std::string> fake_function_names;
     fill_custom_functions(driver.physical_devices.back().known_device_functions, fake_function_names, custom_queue_functions{},
                           function_count);
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     DeviceWrapper dev{inst};
     dev.create_info.add_device_queue({});
     dev.CheckCreate(inst.GetPhysDev());
     VkQueue queue{};
-    env->vulkan_functions.vkGetDeviceQueue(dev, 0, 0, &queue);
+    env.vulkan_functions.vkGetDeviceQueue(dev, 0, 0, &queue);
 
-    check_custom_functions(env->vulkan_functions, inst.inst, queue, custom_queue_functions{}, fake_function_names, function_count);
+    check_custom_functions(env.vulkan_functions, inst.inst, queue, custom_queue_functions{}, fake_function_names, function_count);
 }
 
-TEST_F(UnknownFunction, QueueFunctionFromGetInstanceProcAddrWithImplicitLayer) {
+TEST(UnknownFunction, QueueFunctionFromGetInstanceProcAddrWithImplicitLayer) {
 #if defined(__APPLE__)
     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));
     uint32_t function_count = MAX_NUM_UNKNOWN_EXTS;
-    auto& driver = env->get_test_icd();
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
     driver.physical_devices.back().add_queue_family_properties({});
     std::vector<std::string> fake_function_names;
     fill_custom_functions(driver.physical_devices.back().known_device_functions, fake_function_names, custom_queue_functions{},
                           function_count);
 
-    env->add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
-                                                          .set_name("VK_LAYER_implicit_layer_unknown_function_intercept")
-                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
-                                                          .set_disable_environment("DISABLE_ME")),
-                            "implicit_layer_unknown_function_intercept.json");
+    env.add_implicit_layer(ManifestLayer{}.add_layer(ManifestLayer::LayerDescription{}
+                                                         .set_name("VK_LAYER_implicit_layer_unknown_function_intercept")
+                                                         .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
+                                                         .set_disable_environment("DISABLE_ME")),
+                           "implicit_layer_unknown_function_intercept.json");
 
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 
     DeviceWrapper dev{inst};
     dev.create_info.add_device_queue({});
     dev.CheckCreate(inst.GetPhysDev());
     VkQueue queue{};
-    env->vulkan_functions.vkGetDeviceQueue(dev, 0, 0, &queue);
+    env.vulkan_functions.vkGetDeviceQueue(dev, 0, 0, &queue);
 
-    check_custom_functions(env->vulkan_functions, inst.inst, queue, custom_queue_functions{}, fake_function_names, function_count);
+    check_custom_functions(env.vulkan_functions, inst.inst, queue, custom_queue_functions{}, fake_function_names, function_count);
 }
diff --git a/tests/loader_version_tests.cpp b/tests/loader_version_tests.cpp
index d90f3d4c0..47c0de1e4 100644
--- a/tests/loader_version_tests.cpp
+++ b/tests/loader_version_tests.cpp
@@ -27,36 +27,30 @@
 
 #include "test_environment.h"
 
-class ICDInterfaceVersion2Plus : public ::testing::Test {
-   protected:
-    virtual void SetUp() {
-        env = std::unique_ptr<FrameworkEnvironment>(new FrameworkEnvironment());
-        env->add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
-    }
-    virtual void TearDown() { env.reset(); }
-    std::unique_ptr<FrameworkEnvironment> env;
-};
-
-TEST_F(ICDInterfaceVersion2Plus, vk_icdNegotiateLoaderICDInterfaceVersion) {
-    auto& driver = env->get_test_icd();
+TEST(ICDInterfaceVersion2Plus, vk_icdNegotiateLoaderICDInterfaceVersion) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd();
 
     for (uint32_t i = 0; i <= 6; i++) {
         for (uint32_t j = i; j <= 6; j++) {
             driver.min_icd_interface_version = i;
             driver.max_icd_interface_version = j;
-            InstWrapper inst{env->vulkan_functions};
+            InstWrapper inst{env.vulkan_functions};
             inst.CheckCreate();
         }
     }
 }
 
-TEST_F(ICDInterfaceVersion2Plus, version_3) {
-    auto& driver = env->get_test_icd();
+TEST(ICDInterfaceVersion2Plus, version_3) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
     {
         driver.min_icd_interface_version = 2;
         driver.enable_icd_wsi = true;
-        InstWrapper inst{env->vulkan_functions};
+        InstWrapper inst{env.vulkan_functions};
         inst.CheckCreate();
 
         ASSERT_EQ(driver.is_using_icd_wsi, UsingICDProvidedWSI::not_using);
@@ -64,7 +58,7 @@ TEST_F(ICDInterfaceVersion2Plus, version_3) {
     {
         driver.min_icd_interface_version = 3;
         driver.enable_icd_wsi = false;
-        InstWrapper inst{env->vulkan_functions};
+        InstWrapper inst{env.vulkan_functions};
         inst.CheckCreate();
 
         ASSERT_EQ(driver.is_using_icd_wsi, UsingICDProvidedWSI::not_using);
@@ -72,34 +66,36 @@ TEST_F(ICDInterfaceVersion2Plus, version_3) {
     {
         driver.min_icd_interface_version = 3;
         driver.enable_icd_wsi = true;
-        InstWrapper inst{env->vulkan_functions};
+        InstWrapper inst{env.vulkan_functions};
         inst.CheckCreate();
 
         ASSERT_EQ(driver.is_using_icd_wsi, UsingICDProvidedWSI::is_using);
     }
 }
 
-TEST_F(ICDInterfaceVersion2Plus, version_4) {
-    auto& driver = env->get_test_icd();
+TEST(ICDInterfaceVersion2Plus, version_4) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_0");
-    InstWrapper inst{env->vulkan_functions};
+    InstWrapper inst{env.vulkan_functions};
     inst.CheckCreate();
 }
 
-TEST_F(ICDInterfaceVersion2Plus, l4_icd4) {
+TEST(ICDInterfaceVersion2Plus, l4_icd4) {
     // ICD must fail with VK_ERROR_INCOMPATIBLE_DRIVER for all vkCreateInstance calls with apiVersion set to > Vulkan 1.0
     // because both the loader and ICD support interface version <= 4. Otherwise, the ICD should behave as normal.
 }
-TEST_F(ICDInterfaceVersion2Plus, l4_icd5) {
+TEST(ICDInterfaceVersion2Plus, l4_icd5) {
     // ICD must fail with VK_ERROR_INCOMPATIBLE_DRIVER for all vkCreateInstance calls with apiVersion set to > Vulkan 1.0
     // because the loader is still at interface version <= 4. Otherwise, the ICD should behave as normal.
 }
-TEST_F(ICDInterfaceVersion2Plus, l5_icd4) {
+TEST(ICDInterfaceVersion2Plus, l5_icd4) {
     // Loader will fail with VK_ERROR_INCOMPATIBLE_DRIVER if it can't handle the apiVersion. ICD may pass for all apiVersions,
     // but since its interface is <= 4, it is best if it assumes it needs to do the work of rejecting anything > Vulkan 1.0 and
     // fail with VK_ERROR_INCOMPATIBLE_DRIVER. Otherwise, the ICD should behave as normal.
 }
-TEST_F(ICDInterfaceVersion2Plus, l5_icd5) {
+TEST(ICDInterfaceVersion2Plus, l5_icd5) {
     // Loader will fail with VK_ERROR_INCOMPATIBLE_DRIVER if it can't handle the apiVersion, and ICDs should fail with
     // VK_ERROR_INCOMPATIBLE_DRIVER only if they can not support the specified apiVersion. Otherwise, the ICD should behave as
     // normal.
@@ -110,8 +106,10 @@ TEST_F(ICDInterfaceVersion2Plus, l5_icd5) {
 // 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_F(ICDInterfaceVersion2Plus, version_5) {
-    auto& driver = env->get_test_icd();
+TEST(ICDInterfaceVersion2Plus, version_5) {
+    FrameworkEnvironment env{};
+    env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
+    auto& driver = env.get_test_icd();
     driver.physical_devices.emplace_back("physical_device_1");
     driver.physical_devices.emplace_back("physical_device_0");
     uint32_t physical_count = static_cast<uint32_t>(driver.physical_devices.size());
@@ -120,11 +118,11 @@ TEST_F(ICDInterfaceVersion2Plus, version_5) {
 
     driver.min_icd_interface_version = 5;
 
-    InstWrapper inst{env->vulkan_functions};
+    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(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);
 }
@@ -174,7 +172,7 @@ TEST(ICDInterfaceVersion2PlusEnumerateAdapterPhysicalDevices, version_6) {
     returned_physical_count = 0;
     ASSERT_EQ(VK_INCOMPLETE,
               env.vulkan_functions.vkEnumeratePhysicalDevices(inst.inst, &returned_physical_count, physical_device_handles.data()));
-    ASSERT_EQ(0, returned_physical_count);
+    ASSERT_EQ(0U, returned_physical_count);
     for (auto& phys_dev : physical_device_handles) {
         ASSERT_EQ(phys_dev, reinterpret_cast<VkPhysicalDevice>(temp_ptr.get()));
     }
@@ -329,7 +327,7 @@ TEST(MultipleICDConfig, Basic) {
     std::array<VkPhysicalDevice, 3> phys_devs_array;
     uint32_t phys_dev_count = 3;
     ASSERT_EQ(env.vulkan_functions.vkEnumeratePhysicalDevices(inst, &phys_dev_count, phys_devs_array.data()), VK_SUCCESS);
-    ASSERT_EQ(phys_dev_count, 3);
+    ASSERT_EQ(phys_dev_count, 3U);
     ASSERT_EQ(env.get_test_icd(0).physical_devices.at(0).properties.deviceType, VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU);
     ASSERT_EQ(env.get_test_icd(1).physical_devices.at(0).properties.deviceType, VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU);
     ASSERT_EQ(env.get_test_icd(2).physical_devices.at(0).properties.deviceType, VK_PHYSICAL_DEVICE_TYPE_CPU);
@@ -356,7 +354,7 @@ TEST(MultipleDriverConfig, DifferentICDInterfaceVersions) {
     std::array<VkPhysicalDevice, 2> phys_devs_array;
     uint32_t phys_dev_count = 2;
     ASSERT_EQ(env.vulkan_functions.vkEnumeratePhysicalDevices(inst, &phys_dev_count, phys_devs_array.data()), VK_SUCCESS);
-    ASSERT_EQ(phys_dev_count, 2);
+    ASSERT_EQ(phys_dev_count, 2U);
 }
 
 TEST(MultipleDriverConfig, DifferentICDsWithDevices) {
@@ -390,7 +388,7 @@ TEST(MultipleDriverConfig, DifferentICDsWithDevices) {
     std::array<VkPhysicalDevice, 4> phys_devs_array;
     uint32_t phys_dev_count = 4;
     ASSERT_EQ(env.vulkan_functions.vkEnumeratePhysicalDevices(inst, &phys_dev_count, phys_devs_array.data()), VK_SUCCESS);
-    ASSERT_EQ(phys_dev_count, 4);
+    ASSERT_EQ(phys_dev_count, 4U);
 }
 
 TEST(MultipleDriverConfig, DifferentICDsWithDevicesAndGroups) {
@@ -561,7 +559,7 @@ TEST(MinorVersionUpdate, Version1_3) {
         inst.functions->vkGetInstanceProcAddr(inst, "vkGetPhysicalDeviceToolProperties"));
     uint32_t tool_count = 0;
     ASSERT_EQ(VK_SUCCESS, GetPhysicalDeviceToolProperties(phys_dev, &tool_count, nullptr));
-    ASSERT_EQ(tool_count, 0);
+    ASSERT_EQ(tool_count, 0U);
     VkPhysicalDeviceToolProperties props;
     ASSERT_EQ(VK_SUCCESS, GetPhysicalDeviceToolProperties(phys_dev, &tool_count, &props));
 
diff --git a/tests/loader_wsi_tests.cpp b/tests/loader_wsi_tests.cpp
index 1467ce6a5..548e1351a 100644
--- a/tests/loader_wsi_tests.cpp
+++ b/tests/loader_wsi_tests.cpp
@@ -144,7 +144,7 @@ TEST(WsiTests, GetPhysicalDeviceWin32PresentNoICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceWin32PresentationSupportKHR(physical_device, 0),
                  "ICD for selected physical device does not export vkGetPhysicalDeviceWin32PresentationSupportKHR!");
@@ -168,7 +168,7 @@ TEST(WsiTests, GetPhysicalDeviceWin32PresentICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     ASSERT_EQ(VK_TRUE, env.vulkan_functions.vkGetPhysicalDeviceWin32PresentationSupportKHR(physical_device, 0));
 }
@@ -184,7 +184,7 @@ TEST(WsiTests, Win32GetPhysicalDeviceSurfaceSupportKHR) {
         cur_icd.icd_api_version = VK_API_VERSION_1_0;
         cur_icd.set_min_icd_interface_version(5);
         cur_icd.add_instance_extensions({first_ext, second_ext});
-        std::string dev_name = "phys_dev_" + icd;
+        std::string dev_name = "phys_dev_" + std::to_string(icd);
         cur_icd.physical_devices.emplace_back(dev_name.c_str());
         cur_icd.physical_devices.back().add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true});
         cur_icd.enable_icd_wsi = true;
@@ -329,7 +329,7 @@ TEST(WsiTests, GetPhysicalDeviceXcbPresentNoICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceXcbPresentationSupportKHR(physical_device, 0, nullptr, 0),
                  "ICD for selected physical device does not export vkGetPhysicalDeviceXcbPresentationSupportKHR!");
@@ -353,7 +353,7 @@ TEST(WsiTests, GetPhysicalDeviceXcbPresentICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     ASSERT_EQ(VK_TRUE, env.vulkan_functions.vkGetPhysicalDeviceXcbPresentationSupportKHR(physical_device, 0, nullptr, 0));
 }
@@ -369,7 +369,7 @@ TEST(WsiTests, XcbGetPhysicalDeviceSurfaceSupportKHR) {
         cur_icd.icd_api_version = VK_API_VERSION_1_0;
         cur_icd.set_min_icd_interface_version(5);
         cur_icd.add_instance_extensions({first_ext, second_ext});
-        std::string dev_name = "phys_dev_" + icd;
+        std::string dev_name = "phys_dev_" + std::to_string(icd);
         cur_icd.physical_devices.emplace_back(dev_name.c_str());
         cur_icd.physical_devices.back().add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true});
         cur_icd.enable_icd_wsi = true;
@@ -514,7 +514,7 @@ TEST(WsiTests, GetPhysicalDeviceXlibPresentNoICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceXlibPresentationSupportKHR(physical_device, 0, nullptr, 0),
                  "ICD for selected physical device does not export vkGetPhysicalDeviceXlibPresentationSupportKHR!");
@@ -538,7 +538,7 @@ TEST(WsiTests, GetPhysicalDeviceXlibPresentICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     ASSERT_EQ(VK_TRUE, env.vulkan_functions.vkGetPhysicalDeviceXlibPresentationSupportKHR(physical_device, 0, nullptr, 0));
 }
@@ -554,7 +554,7 @@ TEST(WsiTests, XlibGetPhysicalDeviceSurfaceSupportKHR) {
         cur_icd.icd_api_version = VK_API_VERSION_1_0;
         cur_icd.set_min_icd_interface_version(5);
         cur_icd.add_instance_extensions({first_ext, second_ext});
-        std::string dev_name = "phys_dev_" + icd;
+        std::string dev_name = "phys_dev_" + std::to_string(icd);
         cur_icd.physical_devices.emplace_back(dev_name.c_str());
         cur_icd.physical_devices.back().add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true});
         cur_icd.enable_icd_wsi = true;
@@ -699,7 +699,7 @@ TEST(WsiTests, GetPhysicalDeviceWaylandPresentNoICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     ASSERT_DEATH(env.vulkan_functions.vkGetPhysicalDeviceWaylandPresentationSupportKHR(physical_device, 0, nullptr),
                  "ICD for selected physical device does not export vkGetPhysicalDeviceWaylandPresentationSupportKHR!");
@@ -723,7 +723,7 @@ TEST(WsiTests, GetPhysicalDeviceWaylandPresentICDSupport) {
     uint32_t driver_count = 1;
     VkPhysicalDevice physical_device;
     ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &driver_count, &physical_device));
-    ASSERT_EQ(driver_count, 1);
+    ASSERT_EQ(driver_count, 1U);
 
     ASSERT_EQ(VK_TRUE, env.vulkan_functions.vkGetPhysicalDeviceWaylandPresentationSupportKHR(physical_device, 0, nullptr));
 }
@@ -739,7 +739,7 @@ TEST(WsiTests, WaylandGetPhysicalDeviceSurfaceSupportKHR) {
         cur_icd.icd_api_version = VK_API_VERSION_1_0;
         cur_icd.set_min_icd_interface_version(5);
         cur_icd.add_instance_extensions({first_ext, second_ext});
-        std::string dev_name = "phys_dev_" + icd;
+        std::string dev_name = "phys_dev_" + std::to_string(icd);
         cur_icd.physical_devices.emplace_back(dev_name.c_str());
         cur_icd.physical_devices.back().add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true});
         cur_icd.enable_icd_wsi = true;
@@ -768,4 +768,3 @@ TEST(WsiTests, WaylandGetPhysicalDeviceSurfaceSupportKHR) {
     env.vulkan_functions.vkDestroySurfaceKHR(instance.inst, surface, nullptr);
 }
 #endif
-