Remove unnecessary constructors in tests

C++11 does not allow aggregate initialization for types with default values.
Thus, many structs used in the tests had to have constructors written which only
filled in values. With C++17, these constructors can be removed and aggregate
initialization used in many places.

This commit also provides default values for previously undefined structs to
prevent any bugs deriving from uninitialized data.

diff --git a/tests/framework/layer/layer_util.h b/tests/framework/layer/layer_util.h
index b47add0..549bfa7 100644 (file)
--- a/tests/framework/layer/layer_util.h
+++ b/tests/framework/layer/layer_util.h
@@ -36,15 +36,6 @@ struct LayerDefinition {
     BUILDER_VALUE(LayerDefinition, std::string, description, {})
     BUILDER_VECTOR(LayerDefinition, Extension, extensions, extension)
 
-    LayerDefinition(std::string layerName, uint32_t specVersion = VK_API_VERSION_1_0,
-                    uint32_t implementationVersion = VK_API_VERSION_1_0, std::string description = "",
-                    std::vector<Extension> extensions = {})
-        : layerName(layerName),
-          specVersion(specVersion),
-          implementationVersion(implementationVersion),
-          description(description),
-          extensions(extensions) {}
-
     VkLayerProperties get() const noexcept {
         VkLayerProperties props{};
         copy_string_to_char_array(layerName, &props.layerName[0], VK_MAX_EXTENSION_NAME_SIZE);

diff --git a/tests/framework/shim/shim.h b/tests/framework/shim/shim.h
index e4e66d2..d989976 100644 (file)
--- a/tests/framework/shim/shim.h
+++ b/tests/framework/shim/shim.h
@@ -72,8 +72,8 @@ static const char* pnp_registry_path = "SYSTEM\\CurrentControlSet\\Control\\Clas
 
 // Needed for DXGI mocking
 struct KnownDriverData {
-    const char* filename;
-    int vendor_id;
+    const char* filename = nullptr;
+    int vendor_id = 0;
 };
 static std::array<KnownDriverData, 4> known_driver_list = {
 #if defined(_WIN64)
@@ -86,17 +86,12 @@ static std::array<KnownDriverData, 4> known_driver_list = {
 };
 
 struct DXGIAdapter {
-    DXGIAdapter(GpuType gpu_preference, DXGI_ADAPTER_DESC1 desc1, uint32_t adapter_index)
-        : gpu_preference(gpu_preference), desc1(desc1), adapter_index(adapter_index) {}
     GpuType gpu_preference = GpuType::unspecified;
     DXGI_ADAPTER_DESC1 desc1{};
     uint32_t adapter_index = 0;
 };
 
 struct D3DKMT_Adapter {
-    D3DKMT_Adapter() = default;
-    D3DKMT_Adapter(UINT hAdapter, LUID adapter_luid) noexcept : hAdapter(hAdapter), adapter_luid(adapter_luid) {}
-
     D3DKMT_Adapter& add_driver_manifest_path(fs::path const& src);
     D3DKMT_Adapter& add_implicit_layer_manifest_path(fs::path const& src);
     D3DKMT_Adapter& add_explicit_layer_manifest_path(fs::path const& src);
@@ -114,11 +109,12 @@ struct D3DKMT_Adapter {
 #elif COMMON_UNIX_PLATFORMS
 
 struct DirEntry {
-    DIR* directory;
+    DIR* directory = nullptr;
     std::string folder_path;
     std::vector<struct dirent*> contents;
-    size_t current_index;  // the current item being read by an app (incremented by readdir, reset to zero by opendir & closedir)
-    bool is_fake_path;     // true when this entry is for folder redirection
+    // the current item being read by an app (incremented by readdir, reset to zero by opendir & closedir)
+    size_t current_index = 0;
+    bool is_fake_path = false;  // true when this entry is for folder redirection
 };
 
 #endif

diff --git a/tests/framework/shim/shim_common.cpp b/tests/framework/shim/shim_common.cpp
index 721701a..17e3fab 100644 (file)
--- a/tests/framework/shim/shim_common.cpp
+++ b/tests/framework/shim/shim_common.cpp
@@ -134,7 +134,7 @@ void PlatformShim::add_unsecured_manifest(ManifestCategory category, fs::path co
 }
 
 void PlatformShim::add_dxgi_adapter(GpuType gpu_preference, DXGI_ADAPTER_DESC1 desc1) {
-    dxgi_adapters.push_back(DXGIAdapter(gpu_preference, desc1, next_adapter_handle++));
+    dxgi_adapters.push_back({gpu_preference, desc1, next_adapter_handle++});
 }
 
 void PlatformShim::add_d3dkmt_adapter(D3DKMT_Adapter const& adapter) { d3dkmt_adapters.push_back(adapter); }

diff --git a/tests/framework/test_environment.h b/tests/framework/test_environment.h
index bc52ef9..f8aad21 100644 (file)
--- a/tests/framework/test_environment.h
+++ b/tests/framework/test_environment.h
@@ -258,13 +258,13 @@ struct DeviceFunctions {
     }
 };
 
-// InstWrapper & DeviceWrapper - used to make creating instances & devices easier test writing
+// InstWrapper & DeviceWrapper - used to make creating instances & devices easier when writing tests
 struct InstWrapper {
     InstWrapper(VulkanFunctions& functions, VkAllocationCallbacks* callbacks = nullptr) noexcept;
     InstWrapper(VulkanFunctions& functions, VkInstance inst, VkAllocationCallbacks* callbacks = nullptr) noexcept;
     ~InstWrapper() noexcept;
 
-    // Move-nly object
+    // Move-only object
     InstWrapper(InstWrapper const&) = delete;
     InstWrapper& operator=(InstWrapper const&) = delete;
     InstWrapper(InstWrapper&& other) noexcept;
@@ -445,7 +445,7 @@ struct AppSpecificSettings {
 };
 
 struct LoaderSettings {
-    BUILDER_VALUE(LoaderSettings, ManifestVersion, file_format_version, ManifestVersion())
+    BUILDER_VALUE(LoaderSettings, ManifestVersion, file_format_version, {})
     BUILDER_VECTOR(LoaderSettings, AppSpecificSettings, app_specific_settings, app_specific_setting);
 };
 
@@ -461,7 +461,7 @@ struct PlatformShimWrapper {
     PlatformShim* operator->() { return platform_shim; }
 
     LibraryWrapper shim_library;
-    PlatformShim* platform_shim;
+    PlatformShim* platform_shim = nullptr;
     EnvVarWrapper loader_logging;
 };
 

diff --git a/tests/framework/test_util.h b/tests/framework/test_util.h
index bbe174c..2a2c09c 100644 (file)
--- a/tests/framework/test_util.h
+++ b/tests/framework/test_util.h
@@ -589,8 +589,6 @@ struct ManifestVersion {
     BUILDER_VALUE(ManifestVersion, uint32_t, major, 1)
     BUILDER_VALUE(ManifestVersion, uint32_t, minor, 0)
     BUILDER_VALUE(ManifestVersion, uint32_t, patch, 0)
-    ManifestVersion() noexcept {};
-    ManifestVersion(uint32_t major, uint32_t minor, uint32_t patch) noexcept : major(major), minor(minor), patch(patch){};
 
     std::string get_version_str() const noexcept {
         return std::to_string(major) + "." + std::to_string(minor) + "." + std::to_string(patch);
@@ -599,7 +597,7 @@ struct ManifestVersion {
 
 // ManifestICD builder
 struct ManifestICD {
-    BUILDER_VALUE(ManifestICD, ManifestVersion, file_format_version, ManifestVersion())
+    BUILDER_VALUE(ManifestICD, ManifestVersion, file_format_version, {})
     BUILDER_VALUE(ManifestICD, uint32_t, api_version, 0)
     BUILDER_VALUE(ManifestICD, std::string, lib_path, {})
     BUILDER_VALUE(ManifestICD, bool, is_portability_driver, false)
@@ -682,11 +680,6 @@ struct MockQueueFamilyProperties {
     BUILDER_VALUE(MockQueueFamilyProperties, VkQueueFamilyProperties, properties, {})
     BUILDER_VALUE(MockQueueFamilyProperties, bool, support_present, false)
 
-    MockQueueFamilyProperties() {}
-
-    MockQueueFamilyProperties(VkQueueFamilyProperties properties, bool support_present = false)
-        : properties(properties), support_present(support_present) {}
-
     VkQueueFamilyProperties get() const noexcept { return properties; }
 };
 
@@ -760,7 +753,7 @@ inline bool operator!=(const VkExtensionProperties& a, const VkExtensionProperti
 
 struct VulkanFunction {
     std::string name;
-    PFN_vkVoidFunction function;
+    PFN_vkVoidFunction function = nullptr;
 };
 
 template <typename T, size_t U>

diff --git a/tests/loader_alloc_callback_tests.cpp b/tests/loader_alloc_callback_tests.cpp
index fc9fb5a..fbe5994 100644 (file)
--- a/tests/loader_alloc_callback_tests.cpp
+++ b/tests/loader_alloc_callback_tests.cpp
@@ -30,13 +30,6 @@
 #include <mutex>
 
 struct MemoryTrackerSettings {
-    MemoryTrackerSettings() = default;
-    MemoryTrackerSettings(bool should_fail_on_allocation, size_t fail_after_allocations, bool should_fail_after_set_number_of_calls,
-                          size_t fail_after_calls)
-        : should_fail_on_allocation(should_fail_on_allocation),
-          fail_after_allocations(fail_after_allocations),
-          should_fail_after_set_number_of_calls(should_fail_after_set_number_of_calls),
-          fail_after_calls(fail_after_calls) {}
     bool should_fail_on_allocation = false;
     size_t fail_after_allocations = 0;  // fail after this number of allocations in total
     bool should_fail_after_set_number_of_calls = false;
@@ -414,7 +407,7 @@ TEST(Allocation, CreateInstanceIntentionalAllocFail) {
     size_t fail_index = 0;
     VkResult result = VK_ERROR_OUT_OF_HOST_MEMORY;
     while (result == VK_ERROR_OUT_OF_HOST_MEMORY && fail_index <= 10000) {
-        MemoryTracker tracker(MemoryTrackerSettings{false, 0, true, fail_index});
+        MemoryTracker tracker({false, 0, true, fail_index});
 
         VkInstance instance;
         InstanceCreateInfo inst_create_info{};
@@ -445,7 +438,7 @@ TEST(Allocation, CreateSurfaceIntentionalAllocFail) {
     size_t fail_index = 0;
     VkResult result = VK_ERROR_OUT_OF_HOST_MEMORY;
     while (result == VK_ERROR_OUT_OF_HOST_MEMORY && fail_index <= 10000) {
-        MemoryTracker tracker(MemoryTrackerSettings{false, 0, true, fail_index});
+        MemoryTracker tracker({false, 0, true, fail_index});
 
         VkInstance instance;
         InstanceCreateInfo inst_create_info{};
@@ -497,7 +490,7 @@ TEST(Allocation, CreateInstanceIntentionalAllocFailWithSettingsFilePresent) {
     size_t fail_index = 0;
     VkResult result = VK_ERROR_OUT_OF_HOST_MEMORY;
     while (result == VK_ERROR_OUT_OF_HOST_MEMORY && fail_index <= 10000) {
-        MemoryTracker tracker(MemoryTrackerSettings{false, 0, true, fail_index});
+        MemoryTracker tracker({false, 0, true, fail_index});
 
         VkInstance instance;
         InstanceCreateInfo inst_create_info{};
@@ -534,7 +527,7 @@ TEST(Allocation, CreateSurfaceIntentionalAllocFailWithSettingsFilePresent) {
     size_t fail_index = 0;
     VkResult result = VK_ERROR_OUT_OF_HOST_MEMORY;
     while (result == VK_ERROR_OUT_OF_HOST_MEMORY && fail_index <= 10000) {
-        MemoryTracker tracker(MemoryTrackerSettings{false, 0, true, fail_index});
+        MemoryTracker tracker({false, 0, true, fail_index});
 
         VkInstance instance;
         InstanceCreateInfo inst_create_info{};
@@ -580,7 +573,7 @@ TEST(Allocation, DriverEnvVarIntentionalAllocFail) {
     size_t fail_index = 0;
     VkResult result = VK_ERROR_OUT_OF_HOST_MEMORY;
     while (result == VK_ERROR_OUT_OF_HOST_MEMORY && fail_index <= 10000) {
-        MemoryTracker tracker(MemoryTrackerSettings{false, 0, true, fail_index});
+        MemoryTracker tracker({false, 0, true, fail_index});
 
         VkInstance instance;
         InstanceCreateInfo inst_create_info{};
@@ -642,7 +635,7 @@ TEST(Allocation, CreateDeviceIntentionalAllocFail) {
     size_t fail_index = 0;
     VkResult result = VK_ERROR_OUT_OF_HOST_MEMORY;
     while (result == VK_ERROR_OUT_OF_HOST_MEMORY) {
-        MemoryTracker tracker(MemoryTrackerSettings{false, 0, true, fail_index});
+        MemoryTracker tracker({false, 0, true, fail_index});
 
         DeviceCreateInfo dev_create_info;
         DeviceQueueCreateInfo queue_info;
@@ -719,7 +712,7 @@ TEST(Allocation, CreateInstanceDeviceIntentionalAllocFail) {
     size_t fail_index = 0;
     VkResult result = VK_ERROR_OUT_OF_HOST_MEMORY;
     while (result == VK_ERROR_OUT_OF_HOST_MEMORY && fail_index <= 10000) {
-        MemoryTracker tracker{MemoryTrackerSettings{false, 0, true, fail_index}};
+        MemoryTracker tracker{{false, 0, true, fail_index}};
         fail_index++;  // applies to the next loop
 
         VkInstance instance;
@@ -805,7 +798,7 @@ TEST(TryLoadWrongBinaries, CreateInstanceIntentionalAllocFail) {
     size_t fail_index = 0;
     VkResult result = VK_ERROR_OUT_OF_HOST_MEMORY;
     while (result == VK_ERROR_OUT_OF_HOST_MEMORY && fail_index <= 10000) {
-        MemoryTracker tracker(MemoryTrackerSettings{false, 0, true, fail_index});
+        MemoryTracker tracker({false, 0, true, fail_index});
 
         VkInstance instance;
         InstanceCreateInfo inst_create_info{};
@@ -846,7 +839,7 @@ TEST(Allocation, EnumeratePhysicalDevicesIntentionalAllocFail) {
             driver.physical_devices.emplace_back(std::string("physical_device_") + std::to_string(i));
             driver.physical_devices[i].add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, false});
         }
-        MemoryTracker tracker{MemoryTrackerSettings{false, 0, true, fail_index}};
+        MemoryTracker tracker{{false, 0, true, fail_index}};
         InstanceCreateInfo inst_create_info;
         VkInstance instance;
         result = env.vulkan_functions.vkCreateInstance(inst_create_info.get(), tracker.get(), &instance);
@@ -960,7 +953,7 @@ TEST(Allocation, CreateInstanceDeviceWithDXGIDriverIntentionalAllocFail) {
     size_t fail_index = 0;
     VkResult result = VK_ERROR_OUT_OF_HOST_MEMORY;
     while (result == VK_ERROR_OUT_OF_HOST_MEMORY && fail_index <= 10000) {
-        MemoryTracker tracker(MemoryTrackerSettings{false, 0, true, fail_index});
+        MemoryTracker tracker({false, 0, true, fail_index});
         fail_index++;  // applies to the next loop
 
         VkInstance instance;

diff --git a/tests/loader_layer_tests.cpp b/tests/loader_layer_tests.cpp
index f7940e8..408b078 100644 (file)
--- a/tests/loader_layer_tests.cpp
+++ b/tests/loader_layer_tests.cpp
@@ -131,15 +131,14 @@ TEST(ImplicitLayers, PreInstanceEnumInstLayerProps) {
     EnvVarWrapper 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.get())
-                           .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{}
-                                                          .set_vk_func("vkEnumerateInstanceLayerProperties")
-                                                          .set_override_name("test_preinst_vkEnumerateInstanceLayerProperties"))),
+        ManifestLayer{}.set_file_format_version({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.get())
+                .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{}
+                                               .set_vk_func("vkEnumerateInstanceLayerProperties")
+                                               .set_override_name("test_preinst_vkEnumerateInstanceLayerProperties"))),
         "implicit_test_layer.json");
 
     uint32_t layer_props = 43;
@@ -165,17 +164,16 @@ TEST(ImplicitLayers, PreInstanceEnumInstExtProps) {
     const char* implicit_layer_name = "ImplicitTestLayer";
     EnvVarWrapper 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.get())
-                                              .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({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.get())
+                .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);
@@ -203,18 +201,16 @@ TEST(ImplicitLayers, PreInstanceVersion) {
     const char* implicit_layer_name = "ImplicitTestLayer";
     EnvVarWrapper 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_api_version(VK_MAKE_API_VERSION(0, 1, 2, 3))
-                           .set_disable_environment(disable_env_var.get())
-                           .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{}
-                                                          .set_vk_func("vkEnumerateInstanceVersion")
-                                                          .set_override_name("test_preinst_vkEnumerateInstanceVersion"))),
-        "implicit_test_layer.json");
+    env.add_implicit_layer(ManifestLayer{}.set_file_format_version({1, 1, 2}).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, 2, 3))
+                                   .set_disable_environment(disable_env_var.get())
+                                   .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{}
+                                                                  .set_vk_func("vkEnumerateInstanceVersion")
+                                                                  .set_override_name("test_preinst_vkEnumerateInstanceVersion"))),
+                           "implicit_test_layer.json");
 
     uint32_t layer_version = VK_MAKE_API_VERSION(1, 2, 3, 4);
     auto& layer = env.get_test_layer(0);
@@ -245,15 +241,14 @@ TEST(ImplicitLayers, OverrideGetInstanceProcAddr) {
     const char* implicit_layer_name = "ImplicitTestLayer";
     EnvVarWrapper 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.get())
-                                              .add_function(ManifestLayer::LayerDescription::FunctionOverride{}
-                                                                .set_vk_func("vkGetInstanceProcAddr")
-                                                                .set_override_name("test_override_vkGetInstanceProcAddr"))),
+    env.add_implicit_layer(ManifestLayer{}.set_file_format_version({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.get())
+                                   .add_function(ManifestLayer::LayerDescription::FunctionOverride{}
+                                                     .set_vk_func("vkGetInstanceProcAddr")
+                                                     .set_override_name("test_override_vkGetInstanceProcAddr"))),
                            "implicit_test_layer.json");
 
     {
@@ -1020,14 +1015,13 @@ TEST(MetaLayers, InvalidComponentLayer) {
     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"})),
+    env.add_implicit_layer(ManifestLayer{}.set_file_format_version({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";
@@ -1062,9 +1056,8 @@ TEST(MetaLayers, ExplicitMetaLayer) {
     const char* meta_layer_name = "VK_LAYER_MetaTestLayer";
     const char* regular_layer_name = "VK_LAYER_TestLayer";
     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})),
+        ManifestLayer{}.set_file_format_version({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(
@@ -1103,14 +1096,13 @@ TEST(MetaLayers, MetaLayerNameInComponentLayers) {
     env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2_EXPORT_ICD_GPDPA));
     const char* meta_layer_name = "VK_LAYER_MetaTestLayer";
     const char* regular_layer_name = "VK_LAYER_TestLayer";
-    env.add_implicit_layer(ManifestLayer{}
-                               .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"})),
+    env.add_implicit_layer(ManifestLayer{}.set_file_format_version({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(
@@ -1148,15 +1140,13 @@ TEST(MetaLayers, MetaLayerWhichAddsMetaLayer) {
             ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
         "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})),
+        ManifestLayer{}.set_file_format_version({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})),
+    env.add_explicit_layer(ManifestLayer{}.set_file_format_version({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");
 
     auto layer_props = env.GetLayerProperties(3);
@@ -1189,9 +1179,8 @@ TEST(MetaLayers, InstanceExtensionInComponentLayer) {
                                                          .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})),
+        ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer(
+            ManifestLayer::LayerDescription{}.set_name(meta_layer_name).add_component_layers({regular_layer_name})),
         "meta_test_layer.json");
 
     auto extensions = env.GetInstanceExtensions(1, meta_layer_name);
@@ -1211,9 +1200,8 @@ TEST(MetaLayers, DeviceExtensionInComponentLayer) {
                                                          .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})),
+        ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer(
+            ManifestLayer::LayerDescription{}.set_name(meta_layer_name).add_component_layers({regular_layer_name})),
         "meta_test_layer.json");
 
     ASSERT_NO_FATAL_FAILURE(env.GetInstanceExtensions(0, meta_layer_name));
@@ -1272,13 +1260,12 @@ TEST(OverrideMetaLayer, InvalidDisableEnvironment) {
                                                          .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_implicit_layer(
+        ManifestLayer{}.set_file_format_version({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");
 
     auto layer_props = env.GetLayerProperties(1);
     EXPECT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name));
@@ -1300,14 +1287,13 @@ TEST(OverrideMetaLayer, OlderVersionThanInstance) {
                                                          .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_implicit_layer(
+        ManifestLayer{}.set_file_format_version({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
         auto layer_props = env.GetLayerProperties(2);
         EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props));
@@ -1338,22 +1324,20 @@ TEST(OverrideMetaLayer, OlderMetaLayerWithNewerInstanceVersion) {
     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_explicit_layer(
+        ManifestLayer{}.set_file_format_version({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_implicit_layer(
+        ManifestLayer{}.set_file_format_version({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
         auto layer_props = env.GetLayerProperties(2);
         EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props));
@@ -1385,22 +1369,20 @@ TEST(OverrideMetaLayer, NewerComponentLayerInMetaLayer) {
     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_explicit_layer(
+        ManifestLayer{}.set_file_format_version({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_API_VERSION_1_2)),
+        "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_implicit_layer(
+        ManifestLayer{}.set_file_format_version({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
         auto layer_props = env.GetLayerProperties(2);
         // Expect the explicit layer to still be found
@@ -1440,22 +1422,20 @@ TEST(OverrideMetaLayer, OlderComponentLayerInMetaLayer) {
     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_explicit_layer(
+        ManifestLayer{}.set_file_format_version({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_implicit_layer(
+        ManifestLayer{}.set_file_format_version({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
         auto layer_props = env.GetLayerProperties(1);
         EXPECT_TRUE(string_eq(layer_props[0].layerName, regular_layer_name));
@@ -1504,15 +1484,14 @@ TEST(OverrideMetaLayer, ApplicationEnabledLayerInBlacklist) {
                                                          .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_implicit_layer(
+        ManifestLayer{}.set_file_format_version({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");
     {  // Check that enumerating the layers returns only the non-blacklisted layers + override layer
         auto layer_props = env.GetLayerProperties(2);
         ASSERT_TRUE(check_permutation({automatic_regular_layer_name, lunarg_meta_layer_name}, layer_props));
@@ -1556,15 +1535,14 @@ TEST(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");
+    env.add_implicit_layer(
+        ManifestLayer{}.set_file_format_version({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);
@@ -1581,13 +1559,12 @@ TEST(OverrideMetaLayer, BasicOverridePathsIgnoreOtherLayers) {
     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({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",
@@ -1598,15 +1575,14 @@ TEST(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");
+    env.add_implicit_layer(
+        ManifestLayer{}.set_file_format_version({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);
@@ -1624,13 +1600,12 @@ TEST(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"}
+    env.add_explicit_layer(TestLayerDetails{
+        ManifestLayer{}.set_file_format_version({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_discovery_type(ManifestDiscoveryType::env_var));
 
     // add layer to regular explicit layer folder
@@ -1642,16 +1617,14 @@ TEST(OverrideMetaLayer, OverridePathsInteractionWithVK_LAYER_PATH) {
                                             "regular_test_layer.json"}
                                .set_discovery_type(ManifestDiscoveryType::override_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(env.get_folder(ManifestLocation::override_layer).location().str())),
-        "meta_test_layer.json");
+    env.add_implicit_layer(ManifestLayer{}.set_file_format_version({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(env.get_folder(ManifestLocation::override_layer).location().str())),
+                           "meta_test_layer.json");
 
     InstWrapper inst{env.vulkan_functions};
     inst.create_info.set_api_version(1, 1, 0);
@@ -1675,13 +1648,12 @@ TEST(OverrideMetaLayer, OverridePathsEnableImplicitLayerInDefaultPaths) {
     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({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",
@@ -1692,14 +1664,13 @@ TEST(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)),
+    env.add_implicit_layer(ManifestLayer{}.set_file_format_version({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};
@@ -1727,15 +1698,14 @@ TEST(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");
+    env.add_implicit_layer(
+        ManifestLayer{}.set_file_format_version({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);
@@ -1754,22 +1724,19 @@ TEST(OverrideMetaLayer, AppKeysDoesContainCurrentApplication) {
 
     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)),
+        ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(
+            ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
         "regular_test_layer.json");
 
     std::string cur_path = test_platform_executable_path();
 
-    env.add_implicit_layer(ManifestLayer{}
-                               .set_file_format_version(ManifestVersion(1, 2, 0))
-                               .add_layer(ManifestLayer::LayerDescription{}
-                                              .set_name(lunarg_meta_layer_name)
-                                              .add_component_layers({regular_layer_name})
-                                              .set_disable_environment("DisableMeIfYouCan")
-                                              .add_app_key(cur_path)),
-                           "meta_test_layer.json");
+    env.add_implicit_layer(
+        ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(ManifestLayer::LayerDescription{}
+                                                                         .set_name(lunarg_meta_layer_name)
+                                                                         .add_component_layers({regular_layer_name})
+                                                                         .set_disable_environment("DisableMeIfYouCan")
+                                                                         .add_app_key(cur_path)),
+        "meta_test_layer.json");
     {  // global functions
         auto layer_props = env.GetLayerProperties(2);
         EXPECT_TRUE(check_permutation({regular_layer_name, lunarg_meta_layer_name}, layer_props));
@@ -1791,19 +1758,16 @@ TEST(OverrideMetaLayer, AppKeysDoesNotContainCurrentApplication) {
 
     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)),
+        ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(
+            ManifestLayer::LayerDescription{}.set_name(regular_layer_name).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)),
         "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)
-                                              .add_component_layers({regular_layer_name})
-                                              .set_disable_environment("DisableMeIfYouCan")
-                                              .add_app_keys({"/Hello", "Hi", "./../Uh-oh", "C:/Windows/Only"})),
+    env.add_implicit_layer(ManifestLayer{}.set_file_format_version({1, 2, 0}).add_layer(
+                               ManifestLayer::LayerDescription{}
+                                   .set_name(lunarg_meta_layer_name)
+                                   .add_component_layers({regular_layer_name})
+                                   .set_disable_environment("DisableMeIfYouCan")
+                                   .add_app_keys({"/Hello", "Hi", "./../Uh-oh", "C:/Windows/Only"})),
                            "meta_test_layer.json");
     {  // global functions
         auto layer_props = env.GetLayerProperties(1);
@@ -1833,15 +1797,14 @@ TEST(OverrideMetaLayer, RunningWithElevatedPrivilegesFromSecureLocation) {
                                                             .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(TestLayerDetails{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"});
+    env.add_implicit_layer(TestLayerDetails{
+        ManifestLayer{}.set_file_format_version({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"});
 
     {  // try with no elevated privileges
         auto layer_props = env.GetLayerProperties(2);
@@ -1890,15 +1853,14 @@ TEST(OverrideMetaLayer, RunningWithElevatedPrivilegesFromUnsecureLocation) {
                                                             .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(TestLayerDetails{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"}
+    env.add_implicit_layer(TestLayerDetails{
+        ManifestLayer{}.set_file_format_version({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"}
                                .set_discovery_type(ManifestDiscoveryType::unsecured_generic));
 
     {  // try with no elevated privileges
@@ -1939,10 +1901,8 @@ TEST(LayerCreateInstance, GetPhysicalDeviceProperties2) {
 
     const char* regular_layer_name = "TestLayer";
     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)),
+        ManifestLayer{}.set_file_format_version({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_handle = env.get_test_layer(0);
@@ -2016,7 +1976,7 @@ TEST(ExplicitLayers, MultipleLayersInSingleManifest) {
     const char* regular_layer_name_3 = "VK_LAYER_RegularLayer3";
     env.add_explicit_layer(TestLayerDetails(
         ManifestLayer{}
-            .set_file_format_version(ManifestVersion{1, 0, 1})
+            .set_file_format_version({1, 0, 1})
             .add_layer(
                 ManifestLayer::LayerDescription{}.set_name(regular_layer_name_1).set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2))
             .add_layer(
@@ -4496,14 +4456,13 @@ TEST(TestLayers, OverrideEnabledExplicitLayerWithDisableFilter) {
                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
                                                          .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))),
                            explicit_json_name_1);
-    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(explicit_layer_name_1)
-                                              .set_disable_environment("DisableMeIfYouCan")),
-                           "meta_test_layer.json");
+    env.add_implicit_layer(
+        ManifestLayer{}.set_file_format_version({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(explicit_layer_name_1)
+                                                                         .set_disable_environment("DisableMeIfYouCan")),
+        "meta_test_layer.json");
 
     env.debug_log.clear();
     EnvVarWrapper layers_disable_env_var{"VK_LOADER_LAYERS_DISABLE", explicit_layer_name_1};
@@ -4547,14 +4506,13 @@ TEST(TestLayers, OverrideEnabledExplicitLayerWithDisableFilterForOverrideLayer)
                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
                                                          .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))),
                            explicit_json_name_1);
-    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(explicit_layer_name_1)
-                                              .set_disable_environment("DisableMeIfYouCan")),
-                           "meta_test_layer.json");
+    env.add_implicit_layer(
+        ManifestLayer{}.set_file_format_version({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(explicit_layer_name_1)
+                                                                         .set_disable_environment("DisableMeIfYouCan")),
+        "meta_test_layer.json");
 
     env.debug_log.clear();
     EnvVarWrapper layers_disable_env_var{"VK_LOADER_LAYERS_DISABLE", lunarg_meta_layer_name};
@@ -4598,14 +4556,13 @@ TEST(TestLayers, OverrideBlacklistedLayerWithEnableFilter) {
                                                          .set_lib_path(TEST_LAYER_PATH_EXPORT_VERSION_2)
                                                          .set_api_version(VK_MAKE_API_VERSION(0, 1, 1, 0))),
                            explicit_json_name_1);
-    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_blacklisted_layer(explicit_layer_name_1)
-                                              .set_disable_environment("DisableMeIfYouCan")),
-                           "meta_test_layer.json");
+    env.add_implicit_layer(
+        ManifestLayer{}.set_file_format_version({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_blacklisted_layer(explicit_layer_name_1)
+                                                                         .set_disable_environment("DisableMeIfYouCan")),
+        "meta_test_layer.json");
 
     env.debug_log.clear();
     EnvVarWrapper layers_enable_env_var{"VK_LOADER_LAYERS_ENABLE", explicit_layer_name_1};

diff --git a/tests/loader_settings_tests.cpp b/tests/loader_settings_tests.cpp
index 1aa21ce..be6d876 100644 (file)
--- a/tests/loader_settings_tests.cpp
+++ b/tests/loader_settings_tests.cpp
@@ -771,24 +771,22 @@ TEST(SettingsFile, MetaLayerAlsoActivates) {
                                             "component_test_layer2.json"));
 
     const char* meta_layer_name1 = "VK_LAYER_meta_layer1";
-    env.add_implicit_layer(ManifestLayer{}
-                               .set_file_format_version(ManifestVersion(1, 1, 2))
-                               .add_layer(ManifestLayer::LayerDescription{}
-                                              .set_name(meta_layer_name1)
-                                              .add_component_layer(component_explicit_layer_name2)
-                                              .add_component_layer(component_explicit_layer_name1)
-                                              .set_disable_environment("NotGonnaWork")),
-                           "meta_test_layer.json");
+    env.add_implicit_layer(
+        ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer(ManifestLayer::LayerDescription{}
+                                                                         .set_name(meta_layer_name1)
+                                                                         .add_component_layer(component_explicit_layer_name2)
+                                                                         .add_component_layer(component_explicit_layer_name1)
+                                                                         .set_disable_environment("NotGonnaWork")),
+        "meta_test_layer.json");
 
     const char* meta_layer_name2 = "VK_LAYER_meta_layer2";
-    env.add_implicit_layer(ManifestLayer{}
-                               .set_file_format_version(ManifestVersion(1, 1, 2))
-                               .add_layer(ManifestLayer::LayerDescription{}
-                                              .set_name(meta_layer_name2)
-                                              .add_component_layer(component_explicit_layer_name1)
-                                              .set_disable_environment("ILikeTrains")
-                                              .set_enable_environment("BakedBeans")),
-                           "not_automatic_meta_test_layer.json");
+    env.add_implicit_layer(
+        ManifestLayer{}.set_file_format_version({1, 1, 2}).add_layer(ManifestLayer::LayerDescription{}
+                                                                         .set_name(meta_layer_name2)
+                                                                         .add_component_layer(component_explicit_layer_name1)
+                                                                         .set_disable_environment("ILikeTrains")
+                                                                         .set_enable_environment("BakedBeans")),
+        "not_automatic_meta_test_layer.json");
 
     env.update_loader_settings(env.loader_settings.set_file_format_version({1, 0, 0}).add_app_specific_setting(
         AppSpecificSettings{}
@@ -1293,21 +1291,20 @@ TEST(SettingsFile, PreInstanceFunctions) {
     const char* implicit_layer_name = "VK_LAYER_ImplicitTestLayer";
 
     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_ME")
-                           .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{}
-                                                          .set_vk_func("vkEnumerateInstanceLayerProperties")
-                                                          .set_override_name("test_preinst_vkEnumerateInstanceLayerProperties"))
-                           .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{}
-                                                          .set_vk_func("vkEnumerateInstanceExtensionProperties")
-                                                          .set_override_name("test_preinst_vkEnumerateInstanceExtensionProperties"))
-                           .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{}
-                                                          .set_vk_func("vkEnumerateInstanceVersion")
-                                                          .set_override_name("test_preinst_vkEnumerateInstanceVersion"))),
+        ManifestLayer{}.set_file_format_version({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_ME")
+                .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{}
+                                               .set_vk_func("vkEnumerateInstanceLayerProperties")
+                                               .set_override_name("test_preinst_vkEnumerateInstanceLayerProperties"))
+                .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{}
+                                               .set_vk_func("vkEnumerateInstanceExtensionProperties")
+                                               .set_override_name("test_preinst_vkEnumerateInstanceExtensionProperties"))
+                .add_pre_instance_function(ManifestLayer::LayerDescription::FunctionOverride{}
+                                               .set_vk_func("vkEnumerateInstanceVersion")
+                                               .set_override_name("test_preinst_vkEnumerateInstanceVersion"))),
         "implicit_test_layer.json");
 
     env.loader_settings.add_app_specific_setting(AppSpecificSettings{}.add_stderr_log_filter("all").add_layer_configuration(