diff --git a/vkconfig_core/configuration_manager.cpp b/vkconfig_core/configuration_manager.cpp index 74507f29be..afc71a3e3f 100644 --- a/vkconfig_core/configuration_manager.cpp +++ b/vkconfig_core/configuration_manager.cpp @@ -213,7 +213,10 @@ void ConfigurationManager::SaveAllConfigurations() const { const ConfigurationInfo *ConfigurationManager::GetActiveConfigurationInfo() const { if (this->use_per_executable_configuration) { - return &this->configuration_infos.find(this->active_executable.c_str())->second; + if (this->active_executable.empty()) + return nullptr; + else + return &this->configuration_infos.find(this->active_executable.c_str())->second; } else { return &this->configuration_infos.find(GLOBAL_CONFIGURATION_TOKEN)->second; } @@ -237,10 +240,6 @@ const ConfigurationInfo *ConfigurationManager::FindConfigurationInfo(const std:: return nullptr; } -const std::map &ConfigurationManager::GetConfigurationInfos() const { - return this->configuration_infos; -} - bool ConfigurationManager::HasActiveConfiguration() const { if (this->GetActiveConfigurationInfo() == nullptr) { return false; @@ -255,6 +254,10 @@ bool ConfigurationManager::HasActiveConfiguration() const { return false; } +const std::map &ConfigurationManager::GetConfigurationInfos() const { + return this->configuration_infos; +} + Configuration &ConfigurationManager::CreateConfiguration(const LayerManager &layers, const std::string &configuration_name) { std::string configuration_key = MakeConfigurationName(available_configurations, configuration_name); @@ -359,7 +362,6 @@ int ConfigurationManager::GetConfigurationIndex(const std::string &configuration } } - assert(0); return -1; } @@ -446,54 +448,6 @@ void ConfigurationManager::ExportConfiguration(const LayerManager &layers, const } } -bool ConfigurationManager::CheckApiVersions(const std::vector &available_layers, Configuration *selected_configuration, - std::string &log_versions) const { - return this->CompareLayersVersions(available_layers, selected_configuration, Version::VKCONFIG, log_versions, true); -} - -bool ConfigurationManager::CheckLayersVersions(const std::vector &available_layers, Configuration *selected_configuration, - std::string &log_versions) const { - return this->CompareLayersVersions(available_layers, selected_configuration, Version::NONE, log_versions, false); -} - -bool ConfigurationManager::CompareLayersVersions(const std::vector &available_layers, Configuration *selected_configuration, - const Version &version, std::string &log_versions, bool is_less) const { - assert(selected_configuration != nullptr); - - Version current_version = version; - - bool result = true; - - for (std::size_t param_index = 0, param_count = selected_configuration->parameters.size(); param_index < param_count; - ++param_index) { - const Parameter ¶meter = selected_configuration->parameters[param_index]; - - if (parameter.control != LAYER_CONTROL_ON) { - continue; - } - - for (std::size_t layer_index = 0, layer_count = available_layers.size(); layer_index < layer_count; ++layer_index) { - const Layer &layer = available_layers[layer_index]; - - if (layer.key == parameter.key) { - if (current_version == Version::NONE) { - current_version = layer.api_version; - } - - if (is_less) { - if (layer.api_version.GetMinor() > version.GetMinor()) result = false; - } else { - if (layer.api_version.GetMinor() != current_version.GetMinor()) result = false; - } - - log_versions += format("%s - %s\n", layer.key.c_str(), layer.api_version.str().c_str()); - } - } - } - - return result; -} - bool ConfigurationManager::GetPerExecutableConfig() const { return this->use_per_executable_configuration; } void ConfigurationManager::SetPerExecutableConfig(bool enabled) { this->use_per_executable_configuration = enabled; } diff --git a/vkconfig_core/configuration_manager.h b/vkconfig_core/configuration_manager.h index 4cf63ab51c..258cc246bc 100644 --- a/vkconfig_core/configuration_manager.h +++ b/vkconfig_core/configuration_manager.h @@ -61,11 +61,6 @@ class ConfigurationManager : public Serialize { void SortConfigurations(); - bool CheckLayersVersions(const std::vector& available_layers, Configuration* selected_configuration, - std::string& log_versions) const; - bool CheckApiVersions(const std::vector& available_layers, Configuration* selected_configuration, - std::string& log_versions) const; - bool Empty() const { return available_configurations.empty(); } bool HasFile(const Configuration& configuration) const; @@ -82,9 +77,6 @@ class ConfigurationManager : public Serialize { Path last_path_export; private: - bool CompareLayersVersions(const std::vector& available_layers, Configuration* selected_configuration, - const Version& version, std::string& log_versions, bool is_less) const; - void RemoveConfigurationFiles(); void LoadConfigurationsPath(const LayerManager& layers); diff --git a/vkconfig_core/layer_manager.cpp b/vkconfig_core/layer_manager.cpp index d6c166b935..902001b114 100644 --- a/vkconfig_core/layer_manager.cpp +++ b/vkconfig_core/layer_manager.cpp @@ -140,7 +140,8 @@ bool LayerManager::Load(const QJsonObject &json_root_object) { // LAYERS_PATHS_ENV_ADD: VK_ADD_LAYER_PATH env variables { - const std::vector &VK_ADD_LAYER_PATH = UniqueStrings(Split(qgetenv("VK_ADD_LAYER_PATH").toStdString(), SEPARATOR)); + const std::vector &VK_ADD_LAYER_PATH = + UniqueStrings(Split(qgetenv("VK_ADD_LAYER_PATH").toStdString(), SEPARATOR)); this->paths[LAYERS_PATHS_ENV_ADD].resize(VK_ADD_LAYER_PATH.size()); for (std::size_t i = 0, n = VK_ADD_LAYER_PATH.size(); i < n; ++i) { this->paths[LAYERS_PATHS_ENV_ADD][i].path = VK_ADD_LAYER_PATH[i]; @@ -206,15 +207,9 @@ bool LayerManager::Save(QJsonObject &json_root_object) const { } } - QJsonArray json_removed_paths_array; - for (std::size_t i = 0, n = this->removed_paths.size(); i < n; ++i) { - json_removed_paths_array.append(this->removed_paths[i].RelativePath().c_str()); - } - QJsonObject json_layers_object; json_layers_object.insert("validated", json_layers_paths_object); json_layers_object.insert("paths", json_paths_object); - json_layers_object.insert("removed_paths", json_removed_paths_array); json_root_object.insert("layers", json_layers_object); @@ -363,8 +358,6 @@ void LayerManager::AppendPath(const LayersPathInfo &info) { } void LayerManager::RemovePath(const LayersPathInfo &path_info) { - this->removed_paths.push_back(path_info.path); - const std::vector &layers_paths = CollectFilePaths(path_info.path); for (std::size_t i = 0, n = layers_paths.size(); i < n; ++i) { diff --git a/vkconfig_core/layer_manager.h b/vkconfig_core/layer_manager.h index 063b18a6e9..f68b95bc74 100644 --- a/vkconfig_core/layer_manager.h +++ b/vkconfig_core/layer_manager.h @@ -70,7 +70,6 @@ class LayerManager : public Serialize { std::vector selected_layers; std::array, LAYERS_PATHS_COUNT> paths; - std::vector removed_paths; // TODO: Remove? private: std::map layers_validated; diff --git a/vkconfig_core/test/CMakeLists.txt b/vkconfig_core/test/CMakeLists.txt index 1b6369742f..457a5f25bf 100644 --- a/vkconfig_core/test/CMakeLists.txt +++ b/vkconfig_core/test/CMakeLists.txt @@ -63,6 +63,7 @@ vkConfigTest(test_path) vkConfigTest(test_configuration) vkConfigTest(test_configuration_built_in) vkConfigTest(test_configuration_manager) +vkConfigTest(test_configurator) vkConfigTest(test_executable_manager) vkConfigTest(test_override) vkConfigTest(test_application_singleton) diff --git a/vkconfig_core/test/test_configuration.cpp b/vkconfig_core/test/test_configuration.cpp index 4a36cc9c06..8ba4f74138 100644 --- a/vkconfig_core/test/test_configuration.cpp +++ b/vkconfig_core/test/test_configuration.cpp @@ -275,6 +275,150 @@ TEST(test_configuration, SwitchLayerVersion) { EXPECT_EQ(parameter_version_not_found->api_version, Version::LATEST); } +TEST(test_configuration, gather_parameters_exist) { + LayerManager layer_manager; + layer_manager.LoadLayersFromPath(":/layers"); + + Configuration configuration; + configuration.key = "New Configuration"; + + configuration.GatherParameters(layer_manager); + + EXPECT_STREQ(configuration.parameters[0].key.c_str(), "VK_LAYER_LUNARG_reference_1_1_0"); + EXPECT_STREQ(configuration.parameters[1].key.c_str(), "VK_LAYER_LUNARG_reference_1_2_0"); + EXPECT_STREQ(configuration.parameters[2].key.c_str(), "VK_LAYER_LUNARG_reference_1_2_1"); + + EXPECT_STREQ(configuration.parameters[3].key.c_str(), "VK_LAYER_LUNARG_test_00"); + EXPECT_STREQ(configuration.parameters[4].key.c_str(), "VK_LAYER_LUNARG_test_01"); + EXPECT_STREQ(configuration.parameters[5].key.c_str(), "VK_LAYER_LUNARG_test_02"); + EXPECT_STREQ(configuration.parameters[6].key.c_str(), "VK_LAYER_LUNARG_test_03"); + EXPECT_STREQ(configuration.parameters[7].key.c_str(), "VK_LAYER_LUNARG_test_04"); + EXPECT_STREQ(configuration.parameters[8].key.c_str(), "VK_LAYER_LUNARG_test_05"); + EXPECT_STREQ(configuration.parameters[9].key.c_str(), "VK_LAYER_LUNARG_test_06"); + + EXPECT_STREQ(configuration.parameters[10].key.c_str(), "VK_LAYER_LUNARG_version"); + + std::string missing_layer; + EXPECT_FALSE(HasMissingLayer(configuration.parameters, layer_manager, missing_layer)); + EXPECT_TRUE(missing_layer.empty()); +} + +TEST(test_configuration, gather_parameters_repeat) { + LayerManager layer_manager; + layer_manager.LoadLayersFromPath(":/layers"); + + Configuration configuration; + configuration.key = "New Configuration"; + + configuration.GatherParameters(layer_manager); + configuration.GatherParameters(layer_manager); // Again, check for no duplication! + + EXPECT_STREQ(configuration.parameters[0].key.c_str(), "VK_LAYER_LUNARG_reference_1_1_0"); + EXPECT_STREQ(configuration.parameters[1].key.c_str(), "VK_LAYER_LUNARG_reference_1_2_0"); + EXPECT_STREQ(configuration.parameters[2].key.c_str(), "VK_LAYER_LUNARG_reference_1_2_1"); + + EXPECT_STREQ(configuration.parameters[3].key.c_str(), "VK_LAYER_LUNARG_test_00"); + EXPECT_STREQ(configuration.parameters[4].key.c_str(), "VK_LAYER_LUNARG_test_01"); + EXPECT_STREQ(configuration.parameters[5].key.c_str(), "VK_LAYER_LUNARG_test_02"); + EXPECT_STREQ(configuration.parameters[6].key.c_str(), "VK_LAYER_LUNARG_test_03"); + EXPECT_STREQ(configuration.parameters[7].key.c_str(), "VK_LAYER_LUNARG_test_04"); + EXPECT_STREQ(configuration.parameters[8].key.c_str(), "VK_LAYER_LUNARG_test_05"); + EXPECT_STREQ(configuration.parameters[9].key.c_str(), "VK_LAYER_LUNARG_test_06"); + + EXPECT_STREQ(configuration.parameters[10].key.c_str(), "VK_LAYER_LUNARG_version"); +} + +TEST(test_configuration, gather_parameters_missing) { + LayerManager layer_manager; + + Configuration configuration; + configuration.key = "New Configuration"; + + layer_manager.LoadLayersFromPath(":/layers"); + configuration.GatherParameters(layer_manager); + + layer_manager.Clear(); + configuration.GatherParameters(layer_manager); + + EXPECT_STREQ(configuration.parameters[0].key.c_str(), "VK_LAYER_LUNARG_reference_1_1_0"); + EXPECT_STREQ(configuration.parameters[1].key.c_str(), "VK_LAYER_LUNARG_reference_1_2_0"); + EXPECT_STREQ(configuration.parameters[2].key.c_str(), "VK_LAYER_LUNARG_reference_1_2_1"); + + EXPECT_STREQ(configuration.parameters[3].key.c_str(), "VK_LAYER_LUNARG_test_00"); + EXPECT_STREQ(configuration.parameters[4].key.c_str(), "VK_LAYER_LUNARG_test_01"); + EXPECT_STREQ(configuration.parameters[5].key.c_str(), "VK_LAYER_LUNARG_test_02"); + EXPECT_STREQ(configuration.parameters[6].key.c_str(), "VK_LAYER_LUNARG_test_03"); + EXPECT_STREQ(configuration.parameters[7].key.c_str(), "VK_LAYER_LUNARG_test_04"); + EXPECT_STREQ(configuration.parameters[8].key.c_str(), "VK_LAYER_LUNARG_test_05"); + EXPECT_STREQ(configuration.parameters[9].key.c_str(), "VK_LAYER_LUNARG_test_06"); + + EXPECT_STREQ(configuration.parameters[10].key.c_str(), "VK_LAYER_LUNARG_version"); + + std::string missing_layer; + EXPECT_TRUE(HasMissingLayer(configuration.parameters, layer_manager, missing_layer)); + EXPECT_STREQ(missing_layer.c_str(), "VK_LAYER_LUNARG_reference_1_1_0"); +} + +TEST(test_configuration, HasMissingLayer_UnsupportPlatform) { + LayerManager layer_manager; + + Configuration configuration; + configuration.key = "New Configuration"; + + layer_manager.LoadLayersFromPath(":/layers"); + configuration.GatherParameters(layer_manager); + + layer_manager.Clear(); + + for (std::size_t i = 0, n = configuration.parameters.size(); i < n; ++i) { + configuration.parameters[i].platform_flags = 0; + } + + std::string missing_layer; + EXPECT_FALSE(HasMissingLayer(configuration.parameters, layer_manager, missing_layer)); + EXPECT_TRUE(missing_layer.empty()); +} + +TEST(test_configuration, HasMissingLayer_Off) { + LayerManager layer_manager; + + Configuration configuration; + configuration.key = "New Configuration"; + + layer_manager.LoadLayersFromPath(":/layers"); + configuration.GatherParameters(layer_manager); + + layer_manager.Clear(); + + for (std::size_t i = 0, n = configuration.parameters.size(); i < n; ++i) { + configuration.parameters[i].control = LAYER_CONTROL_OFF; + } + + std::string missing_layer; + EXPECT_FALSE(HasMissingLayer(configuration.parameters, layer_manager, missing_layer)); + EXPECT_TRUE(missing_layer.empty()); +} + +TEST(test_configuration, gather_parameters_missing_but_unsupported_platform) { + LayerManager layer_manager; + + Configuration configuration; + configuration.key = "New Configuration"; + + layer_manager.LoadLayersFromPath(":/layers"); + configuration.GatherParameters(layer_manager); + + layer_manager.Clear(); + + for (std::size_t i = 0, n = configuration.parameters.size(); i < n; ++i) { + configuration.parameters[i].platform_flags = 0; + } + + std::string missing_layer; + EXPECT_FALSE(HasMissingLayer(configuration.parameters, layer_manager, missing_layer)); + EXPECT_TRUE(missing_layer.empty()); +} + TEST(test_configuration, Reorder_full) { LayerManager layer_manager; layer_manager.LoadLayersFromPath(":/layers"); diff --git a/vkconfig_core/test/test_configuration_manager.cpp b/vkconfig_core/test/test_configuration_manager.cpp index 067210f934..5d14ba035d 100644 --- a/vkconfig_core/test/test_configuration_manager.cpp +++ b/vkconfig_core/test/test_configuration_manager.cpp @@ -22,6 +22,24 @@ #include +TEST(test_configuration_manager, init_default) { + ConfigurationManager configuration_manager; + + const ConfigurationInfo* info_global = configuration_manager.FindConfigurationInfo(GLOBAL_CONFIGURATION_TOKEN); + EXPECT_TRUE(info_global != nullptr); + const ConfigurationInfo* info_unknown = configuration_manager.FindConfigurationInfo("unknown"); + EXPECT_TRUE(info_unknown == nullptr); + const ConfigurationInfo* info_active = configuration_manager.GetActiveConfigurationInfo(); + EXPECT_EQ(info_active, info_global); + + EXPECT_FALSE(configuration_manager.GetUseSystemTray()); + EXPECT_FALSE(configuration_manager.GetPerExecutableConfig()); + EXPECT_TRUE(configuration_manager.HasActiveConfiguration()); + EXPECT_TRUE(configuration_manager.Empty()); + EXPECT_TRUE(configuration_manager.last_path_import.Empty()); + EXPECT_TRUE(configuration_manager.last_path_export.Empty()); +} + TEST(test_configuration_manager, create_remove) { LayerManager layer_manager; layer_manager.LoadLayersFromPath(":/layers"); @@ -53,3 +71,110 @@ TEST(test_configuration_manager, create_remove) { configuration_manager.RemoveConfiguration(configuration_duplicate_key.c_str()); EXPECT_EQ(true, configuration_manager.Empty()); } + +TEST(test_configuration_manager, duplicate_names) { + LayerManager layer_manager; + layer_manager.LoadLayersFromPath(":/layers"); + + ConfigurationManager configuration_manager; + + // Create configuration + configuration_manager.CreateConfiguration(layer_manager, "Configuration A"); + EXPECT_EQ(1, configuration_manager.available_configurations.size()); + + std::string dup2 = configuration_manager.DuplicateConfiguration(layer_manager, "Configuration A").key; + EXPECT_EQ(2, configuration_manager.available_configurations.size()); + Configuration* configuration2 = configuration_manager.FindConfiguration("Configuration A (2)"); + EXPECT_STREQ(configuration2->key.c_str(), dup2.c_str()); + + std::string dup3 = configuration_manager.DuplicateConfiguration(layer_manager, "Configuration A (2)").key; + EXPECT_EQ(3, configuration_manager.available_configurations.size()); + Configuration* configuration3 = configuration_manager.FindConfiguration("Configuration A (3)"); + EXPECT_STREQ(configuration3->key.c_str(), dup3.c_str()); + + std::string dup4 = configuration_manager.DuplicateConfiguration(layer_manager, "Configuration A").key; + EXPECT_EQ(4, configuration_manager.available_configurations.size()); + Configuration* configuration4 = configuration_manager.FindConfiguration("Configuration A (4)"); + EXPECT_STREQ(configuration4->key.c_str(), dup4.c_str()); +} + +TEST(test_configuration_manager, duplicate_object) { + LayerManager layer_manager; + layer_manager.LoadLayersFromPath(":/layers"); + + ConfigurationManager configuration_manager; + + // Create configuration + configuration_manager.CreateConfiguration(layer_manager, "Configuration A"); + EXPECT_EQ(1, configuration_manager.available_configurations.size()); + + std::string dup2 = configuration_manager.DuplicateConfiguration(layer_manager, "Configuration A").key; + EXPECT_EQ(2, configuration_manager.available_configurations.size()); + + Configuration* configuration_ori = configuration_manager.FindConfiguration("Configuration A"); + Configuration* configuration_dup = configuration_manager.FindConfiguration("Configuration A (2)"); + + EXPECT_EQ(configuration_ori->version, configuration_dup->version); + EXPECT_EQ(configuration_ori->platform_flags, configuration_dup->platform_flags); + EXPECT_EQ(configuration_ori->description, configuration_dup->description); + EXPECT_EQ(configuration_ori->view_advanced_settings, configuration_dup->view_advanced_settings); + EXPECT_EQ(configuration_ori->view_advanced_layers, configuration_dup->view_advanced_layers); + EXPECT_EQ(configuration_ori->loader_log_messages_flags, configuration_dup->loader_log_messages_flags); + EXPECT_EQ(configuration_ori->selected_layer_name, configuration_dup->selected_layer_name); + EXPECT_EQ(configuration_ori->parameters.size(), configuration_dup->parameters.size()); + EXPECT_EQ(configuration_ori->user_defined_paths, configuration_dup->user_defined_paths); + EXPECT_EQ(configuration_ori->IsBuiltIn(), configuration_dup->IsBuiltIn()); + EXPECT_EQ(configuration_ori->Size(), configuration_dup->Size()); +} + +TEST(test_configuration_manager, sort) { + LayerManager layer_manager; + layer_manager.LoadLayersFromPath(":/layers"); + + ConfigurationManager configuration_manager; + + configuration_manager.CreateConfiguration(layer_manager, "Configuration A"); + configuration_manager.CreateConfiguration(layer_manager, "Configuration 2"); + configuration_manager.CreateConfiguration(layer_manager, "Configuration 1"); + configuration_manager.CreateConfiguration(layer_manager, "Configuration B"); + configuration_manager.CreateConfiguration(layer_manager, "Configuration 3"); + + configuration_manager.SortConfigurations(); + + EXPECT_STREQ("Configuration 1", configuration_manager.available_configurations[0].key.c_str()); + EXPECT_STREQ("Configuration 2", configuration_manager.available_configurations[1].key.c_str()); + EXPECT_STREQ("Configuration 3", configuration_manager.available_configurations[2].key.c_str()); + EXPECT_STREQ("Configuration A", configuration_manager.available_configurations[3].key.c_str()); + EXPECT_STREQ("Configuration B", configuration_manager.available_configurations[4].key.c_str()); +} + +TEST(test_configuration_manager, get_index) { + LayerManager layer_manager; + layer_manager.LoadLayersFromPath(":/layers"); + + ConfigurationManager configuration_manager; + + configuration_manager.CreateConfiguration(layer_manager, "Configuration B"); + EXPECT_EQ(1, configuration_manager.available_configurations.size()); + EXPECT_EQ(0, configuration_manager.GetConfigurationIndex("Configuration B")); + + configuration_manager.CreateConfiguration(layer_manager, "Configuration A"); + EXPECT_EQ(2, configuration_manager.available_configurations.size()); + EXPECT_EQ(0, configuration_manager.GetConfigurationIndex("Configuration A")); + EXPECT_EQ(1, configuration_manager.GetConfigurationIndex("Configuration B")); + + configuration_manager.CreateConfiguration(layer_manager, "Configuration C"); + EXPECT_EQ(3, configuration_manager.available_configurations.size()); + EXPECT_EQ(0, configuration_manager.GetConfigurationIndex("Configuration A")); + EXPECT_EQ(1, configuration_manager.GetConfigurationIndex("Configuration B")); + EXPECT_EQ(2, configuration_manager.GetConfigurationIndex("Configuration C")); + + std::string configuration_a2_key = configuration_manager.CreateConfiguration(layer_manager, "Configuration A").key; + EXPECT_EQ(4, configuration_manager.available_configurations.size()); + EXPECT_EQ(0, configuration_manager.GetConfigurationIndex("Configuration A")); + EXPECT_EQ(1, configuration_manager.GetConfigurationIndex("Configuration A (2)")); + EXPECT_EQ(2, configuration_manager.GetConfigurationIndex("Configuration B")); + EXPECT_EQ(3, configuration_manager.GetConfigurationIndex("Configuration C")); + + EXPECT_EQ(-1, configuration_manager.GetConfigurationIndex("Configuration D")); +} diff --git a/vkconfig_core/test/test_configurator.cpp b/vkconfig_core/test/test_configurator.cpp new file mode 100644 index 0000000000..2b58a03152 --- /dev/null +++ b/vkconfig_core/test/test_configurator.cpp @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2020-2024 Valve Corporation + * Copyright (c) 2020-2024 LunarG, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Authors: + * - Christophe Riccio + */ + +#include "../configurator.h" + +#include + +TEST(test_configurator, init) { EXPECT_TRUE(true); } diff --git a/vkconfig_core/test/test_layer_manager.cpp b/vkconfig_core/test/test_layer_manager.cpp index 8abc82489d..06d9a65198 100644 --- a/vkconfig_core/test/test_layer_manager.cpp +++ b/vkconfig_core/test/test_layer_manager.cpp @@ -30,6 +30,31 @@ TEST(test_layer_manager, clear) { EXPECT_TRUE(layer_manager.Size() == 0); } +TEST(test_layer_manager, load_json) { + QJsonObject json_object; + + LayerManager layer_manager; + bool result = layer_manager.Load(json_object); + EXPECT_TRUE(result); +} + +TEST(test_layer_manager, save_json) { + QJsonObject json_root_object; + + LayerManager layer_manager; + bool result = layer_manager.Save(json_root_object); + EXPECT_TRUE(result); + + EXPECT_TRUE(json_root_object.value("layers") != QJsonValue::Undefined); + + if (json_root_object.value("layers") != QJsonValue::Undefined) { + const QJsonObject& json_layers_object = json_root_object.value("layers").toObject(); + + EXPECT_TRUE(json_layers_object.value("validated") != QJsonValue::Undefined); + EXPECT_TRUE(json_layers_object.value("paths") != QJsonValue::Undefined); + } +} + TEST(test_layer_manager, load_all) { LayerManager layer_manager; layer_manager.LoadLayersFromPath(":/layers"); diff --git a/vkconfig_core/test/test_parameter.cpp b/vkconfig_core/test/test_parameter.cpp index 0db2cca793..16d4ff5ec4 100644 --- a/vkconfig_core/test/test_parameter.cpp +++ b/vkconfig_core/test/test_parameter.cpp @@ -24,11 +24,11 @@ #include "../setting_string.h" #include -/* + inline SettingMetaString* InstantiateString(Layer& layer, const std::string& key) { return static_cast(layer.Instantiate(layer.settings, key, SETTING_STRING)); } - +/* static std::vector GenerateTestLayers() { std::vector layers; layers.push_back(Layer("Layer E0", LAYER_TYPE_EXPLICIT, Version(1, 0, 0), Version(1, 2, 148), "1", "layer.json")); @@ -42,7 +42,7 @@ static std::vector GenerateTestLayers() { layers.push_back(Layer("Layer C2", LAYER_TYPE_USER_DEFINED, Version(1, 0, 0), Version(1, 2, 148), "1", "layer.json")); return layers; } - +*/ static std::vector GenerateTestParametersExist() { std::vector parameters; parameters.push_back(Parameter("Layer E0", LAYER_CONTROL_ON)); @@ -53,10 +53,10 @@ static std::vector GenerateTestParametersExist() { static std::vector GenerateTestParametersImplicitOrdering() { std::vector parameters; - parameters.push_back(Parameter("Layer I0", LAYER_STATE_OVERRIDDEN)); - parameters.push_back(Parameter("Layer I1", LAYER_STATE_OVERRIDDEN)); - parameters.push_back(Parameter("Layer E0", LAYER_STATE_OVERRIDDEN)); - parameters.push_back(Parameter("Layer E1", LAYER_STATE_OVERRIDDEN)); + parameters.push_back(Parameter("Layer I0", LAYER_CONTROL_ON)); + parameters.push_back(Parameter("Layer I1", LAYER_CONTROL_ON)); + parameters.push_back(Parameter("Layer E0", LAYER_CONTROL_ON)); + parameters.push_back(Parameter("Layer E1", LAYER_CONTROL_ON)); return parameters; } @@ -93,14 +93,48 @@ static std::vector GenerateTestParametersAll() { return parameters; } -TEST(test_parameter, ordering_no_layers) { - std::vector layers; +TEST(test_parameter, apply_settings) { + Layer layer; + + SettingMetaString* metaA = InstantiateString(layer, "A"); + SettingMetaString* metaB = InstantiateString(layer, "B"); + + SettingDataString* preset_setting = Instantiate(metaA); + preset_setting->value = "preset value"; + + LayerPreset preset; + preset.settings.push_back(preset_setting); - EXPECT_EQ(PARAMETER_RANK_MISSING, GetParameterOrdering(layers, Parameter("Layer", LAYER_CONTROL_AUTO))); - EXPECT_EQ(PARAMETER_RANK_MISSING, GetParameterOrdering(layers, Parameter("Layer", LAYER_CONTROL_ON))); - EXPECT_EQ(PARAMETER_RANK_MISSING, GetParameterOrdering(layers, Parameter("Layer", LAYER_CONTROL_OFF))); + SettingDataString* layer_setting_a = Instantiate(metaA); + layer_setting_a->value = "setting value"; + + SettingDataString* layer_setting_b = Instantiate(metaB); + layer_setting_b->value = "setting value"; + + Parameter parameter; + parameter.settings.push_back(layer_setting_a); + parameter.settings.push_back(layer_setting_b); + + EXPECT_EQ(1, preset.settings.size()); + EXPECT_EQ(2, parameter.settings.size()); + + parameter.ApplyPresetSettings(preset); + + EXPECT_EQ(1, preset.settings.size()); + EXPECT_EQ(2, parameter.settings.size()); + + EXPECT_STREQ("preset value", static_cast(FindSetting(parameter.settings, "A"))->value.c_str()); + EXPECT_STREQ("setting value", static_cast(FindSetting(parameter.settings, "B"))->value.c_str()); } +TEST(test_parameter, ordering_no_layers) { + LayerManager layer_manager; + + EXPECT_EQ(PARAMETER_RANK_MISSING, GetParameterOrdering(layer_manager, Parameter("Layer", LAYER_CONTROL_AUTO))); + EXPECT_EQ(PARAMETER_RANK_MISSING, GetParameterOrdering(layer_manager, Parameter("Layer", LAYER_CONTROL_ON))); + EXPECT_EQ(PARAMETER_RANK_MISSING, GetParameterOrdering(layer_manager, Parameter("Layer", LAYER_CONTROL_OFF))); +} +/* TEST(test_parameter, ordering_found_custom_layers) { const std::vector& layers = GenerateTestLayers(); @@ -131,35 +165,6 @@ TEST(test_parameter, ordering_found_implicit_layers) { EXPECT_EQ(PARAMETER_RANK_MISSING, GetParameterOrdering(layers, Parameter("Layer I4", LAYER_CONTROL_OFF))); } -TEST(test_parameter, missing_layers) { - std::vector layers_empty; - std::vector layers = GenerateTestLayers(); - - std::string missing_layer; - - std::vector parameters_exist = GenerateTestParametersExist(); - EXPECT_EQ(true, HasMissingLayer(parameters_exist, layers_empty, missing_layer)); - EXPECT_EQ(false, HasMissingLayer(parameters_exist, layers, missing_layer)); - - std::vector parameters_missing = GenerateTestParametersMissing(); - EXPECT_EQ(true, HasMissingLayer(parameters_missing, layers_empty, missing_layer)); - EXPECT_EQ(true, HasMissingLayer(parameters_missing, layers, missing_layer)); -} - -TEST(test_parameter, filter) { - std::vector parameters_app_controlled = GenerateTestParametersExist(); - FilterParameters(parameters_app_controlled, LAYER_CONTROL_AUTO); - EXPECT_EQ(2, parameters_app_controlled.size()); - - std::vector parameters_overridden = GenerateTestParametersExist(); - FilterParameters(parameters_overridden, LAYER_CONTROL_ON); - EXPECT_EQ(2, parameters_overridden.size()); - - std::vector parameters_excluded = GenerateTestParametersExist(); - FilterParameters(parameters_excluded, LAYER_CONTROL_OFF); - EXPECT_EQ(2, parameters_excluded.size()); -} - TEST(test_parameter, order_automatic) { std::vector layers = GenerateTestLayers(); std::vector parameters = GenerateTestParametersAll(); @@ -240,201 +245,6 @@ TEST(test_parameter, order_manual) { EXPECT_STREQ("Layer E2", parameters[17].key.c_str()); } -TEST(test_parameter, apply_settings) { - Layer layer; - - SettingMetaString* metaA = InstantiateString(layer, "A"); - SettingMetaString* metaB = InstantiateString(layer, "B"); - - SettingDataString* preset_setting = Instantiate(metaA); - preset_setting->value = "preset value"; - - LayerPreset preset; - preset.settings.push_back(preset_setting); - - SettingDataString* layer_setting_a = Instantiate(metaA); - layer_setting_a->value = "setting value"; - - SettingDataString* layer_setting_b = Instantiate(metaB); - layer_setting_b->value = "setting value"; - - Parameter parameter; - parameter.settings.push_back(layer_setting_a); - parameter.settings.push_back(layer_setting_b); - - EXPECT_EQ(1, preset.settings.size()); - EXPECT_EQ(2, parameter.settings.size()); - - parameter.ApplyPresetSettings(preset); - - EXPECT_EQ(1, preset.settings.size()); - EXPECT_EQ(2, parameter.settings.size()); - - EXPECT_STREQ("preset value", static_cast(FindSetting(parameter.settings, "A"))->value.c_str()); - EXPECT_STREQ("setting value", static_cast(FindSetting(parameter.settings, "B"))->value.c_str()); -} - -TEST(test_parameter, gather_parameters_exist) { - std::vector parameters = GatherParameters(GenerateTestParametersExist(), GenerateTestLayers()); - - EXPECT_EQ(9, parameters.size()); - - EXPECT_STREQ("Layer E1", parameters[0].key.c_str()); - EXPECT_STREQ("Layer I0", parameters[1].key.c_str()); - EXPECT_STREQ("Layer I1", parameters[2].key.c_str()); - EXPECT_STREQ("Layer I2", parameters[3].key.c_str()); - EXPECT_STREQ("Layer E0", parameters[4].key.c_str()); - EXPECT_STREQ("Layer C0", parameters[5].key.c_str()); - EXPECT_STREQ("Layer C1", parameters[6].key.c_str()); - EXPECT_STREQ("Layer C2", parameters[7].key.c_str()); - EXPECT_STREQ("Layer E2", parameters[8].key.c_str()); -} - -TEST(test_parameter, gather_parameters_missing) { - std::vector parameters = GatherParameters(GenerateTestParametersMissing(), GenerateTestLayers()); - - EXPECT_EQ(10, parameters.size()); - - EXPECT_STREQ("Layer E3", parameters[0].key.c_str()); - EXPECT_STREQ("Layer E1", parameters[1].key.c_str()); - EXPECT_STREQ("Layer I0", parameters[2].key.c_str()); - EXPECT_STREQ("Layer I1", parameters[3].key.c_str()); - EXPECT_STREQ("Layer I2", parameters[4].key.c_str()); - EXPECT_STREQ("Layer C0", parameters[5].key.c_str()); - EXPECT_STREQ("Layer C1", parameters[6].key.c_str()); - EXPECT_STREQ("Layer C2", parameters[7].key.c_str()); - EXPECT_STREQ("Layer E0", parameters[8].key.c_str()); - EXPECT_STREQ("Layer E2", parameters[9].key.c_str()); -} - -TEST(test_parameter, gather_parameters_all) { - std::vector parameters = GatherParameters(GenerateTestParametersAll(), GenerateTestLayers()); - - EXPECT_EQ(18, parameters.size()); - - EXPECT_STREQ("Layer C3", parameters[0].key.c_str()); - EXPECT_STREQ("Layer C4", parameters[1].key.c_str()); - EXPECT_STREQ("Layer C5", parameters[2].key.c_str()); - EXPECT_STREQ("Layer E3", parameters[3].key.c_str()); - EXPECT_STREQ("Layer E4", parameters[4].key.c_str()); - EXPECT_STREQ("Layer E5", parameters[5].key.c_str()); - EXPECT_STREQ("Layer I3", parameters[6].key.c_str()); - EXPECT_STREQ("Layer I4", parameters[7].key.c_str()); - EXPECT_STREQ("Layer I5", parameters[8].key.c_str()); - EXPECT_STREQ("Layer C1", parameters[9].key.c_str()); - EXPECT_STREQ("Layer E1", parameters[10].key.c_str()); - EXPECT_STREQ("Layer I1", parameters[11].key.c_str()); - EXPECT_STREQ("Layer I2", parameters[12].key.c_str()); - EXPECT_STREQ("Layer I0", parameters[13].key.c_str()); - EXPECT_STREQ("Layer C0", parameters[14].key.c_str()); - EXPECT_STREQ("Layer E0", parameters[15].key.c_str()); - EXPECT_STREQ("Layer C2", parameters[16].key.c_str()); - EXPECT_STREQ("Layer E2", parameters[17].key.c_str()); -} - -TEST(test_parameter, compute_min_api_version) { - std::vector parameters = GenerateTestParametersExist(); - std::vector layers = GenerateTestLayers(); - - Version min_version = ComputeMinApiVersion(Version(1, 2, 170), parameters, layers); - EXPECT_EQ(Version(1, 2, 148), min_version); -} - -TEST(test_parameter, compute_min_api_version_exclude_middle) { - std::vector layers; - layers.push_back(Layer("Layer E0", LAYER_TYPE_EXPLICIT, Version(1, 0, 0), Version(1, 2, 148), "1", "layer.json")); - layers.push_back(Layer("Layer E1", LAYER_TYPE_EXPLICIT, Version(1, 0, 0), Version(1, 2, 162), "1", "layer.json")); - layers.push_back(Layer("Layer E2", LAYER_TYPE_EXPLICIT, Version(1, 0, 0), Version(1, 2, 176), "1", "layer.json")); - - std::vector parameters; - parameters.push_back(Parameter("Layer E0", LAYER_CONTROL_ON)); - parameters.push_back(Parameter("Layer E1", LAYER_CONTROL_OFF)); - parameters.push_back(Parameter("Layer E2", LAYER_CONTROL_AUTO)); - - Version min_version_A = ComputeMinApiVersion(Version(1, 2, 170), parameters, layers); - EXPECT_EQ(Version(1, 2, 148), min_version_A); - - Version min_version_B = ComputeMinApiVersion(Version(1, 2, 140), parameters, layers); - EXPECT_EQ(Version(1, 2, 140), min_version_B); -} - -TEST(test_parameter, compute_min_api_version_exclude_older) { - std::vector layers; - layers.push_back(Layer("Layer E0", LAYER_TYPE_EXPLICIT, Version(1, 0, 0), Version(1, 2, 148), "1", "layer.json")); - layers.push_back(Layer("Layer E1", LAYER_TYPE_EXPLICIT, Version(1, 0, 0), Version(1, 2, 162), "1", "layer.json")); - layers.push_back(Layer("Layer E2", LAYER_TYPE_EXPLICIT, Version(1, 0, 0), Version(1, 2, 176), "1", "layer.json")); - - std::vector parameters; - parameters.push_back(Parameter("Layer E0", LAYER_CONTROL_OFF)); - parameters.push_back(Parameter("Layer E1", LAYER_CONTROL_ON)); - parameters.push_back(Parameter("Layer E2", LAYER_CONTROL_AUTO)); - - Version min_version_A = ComputeMinApiVersion(Version(1, 2, 170), parameters, layers); - EXPECT_EQ(Version(1, 2, 162), min_version_A); - - Version min_version_B = ComputeMinApiVersion(Version(1, 2, 160), parameters, layers); - EXPECT_EQ(Version(1, 2, 160), min_version_B); -} - -TEST(test_parameter, compute_min_api_version_exclude_newer) { - std::vector layers; - layers.push_back(Layer("Layer E0", LAYER_TYPE_EXPLICIT, Version(1, 0, 0), Version(1, 2, 148), "1", "layer.json")); - layers.push_back(Layer("Layer E1", LAYER_TYPE_EXPLICIT, Version(1, 0, 0), Version(1, 2, 162), "1", "layer.json")); - layers.push_back(Layer("Layer E2", LAYER_TYPE_EXPLICIT, Version(1, 0, 0), Version(1, 2, 176), "1", "layer.json")); - - std::vector parameters; - parameters.push_back(Parameter("Layer E0", LAYER_CONTROL_AUTO)); - parameters.push_back(Parameter("Layer E1", LAYER_CONTROL_ON)); - parameters.push_back(Parameter("Layer E2", LAYER_CONTROL_OFF)); - - Version min_version_A = ComputeMinApiVersion(Version(1, 2, 170), parameters, layers); - EXPECT_EQ(Version(1, 2, 148), min_version_A); - - Version min_version_B = ComputeMinApiVersion(Version(1, 2, 140), parameters, layers); - EXPECT_EQ(Version(1, 2, 140), min_version_B); -} - -TEST(test_parameter, compute_min_api_version_exclude_all) { - std::vector layers; - layers.push_back(Layer("Layer E0", LAYER_TYPE_EXPLICIT, Version(1, 0, 0), Version(1, 2, 148), "1", "layer.json")); - layers.push_back(Layer("Layer E1", LAYER_TYPE_EXPLICIT, Version(1, 0, 0), Version(1, 2, 162), "1", "layer.json")); - layers.push_back(Layer("Layer E2", LAYER_TYPE_EXPLICIT, Version(1, 0, 0), Version(1, 2, 176), "1", "layer.json")); - - std::vector parameters; - parameters.push_back(Parameter("Layer E0", LAYER_CONTROL_OFF)); - parameters.push_back(Parameter("Layer E1", LAYER_CONTROL_OFF)); - parameters.push_back(Parameter("Layer E2", LAYER_CONTROL_OFF)); - - Version min_version_A = ComputeMinApiVersion(Version(1, 2, 170), parameters, layers); - EXPECT_EQ(Version(1, 2, 170), min_version_A); -} - -TEST(test_parameter, compute_min_api_version_missing_one) { - std::vector layers; - layers.push_back(Layer("Layer E0", LAYER_TYPE_EXPLICIT, Version(1, 0, 0), Version(1, 2, 148), "1", "layer.json")); - layers.push_back(Layer("Layer E2", LAYER_TYPE_EXPLICIT, Version(1, 0, 0), Version(1, 2, 176), "1", "layer.json")); - - std::vector parameters; - parameters.push_back(Parameter("Layer E0", LAYER_CONTROL_AUTO)); - parameters.push_back(Parameter("Layer E1", LAYER_CONTROL_ON)); - parameters.push_back(Parameter("Layer E2", LAYER_CONTROL_ON)); - - Version min_version_A = ComputeMinApiVersion(Version(1, 2, 170), parameters, layers); - EXPECT_EQ(Version(1, 2, 148), min_version_A); -} - -TEST(test_parameter, compute_min_api_version_missing_all) { - std::vector layers; - - std::vector parameters; - parameters.push_back(Parameter("Layer E0", LAYER_CONTROL_AUTO)); - parameters.push_back(Parameter("Layer E1", LAYER_CONTROL_ON)); - parameters.push_back(Parameter("Layer E2", LAYER_CONTROL_ON)); - - Version min_version_A = ComputeMinApiVersion(Version(1, 2, 170), parameters, layers); - EXPECT_EQ(Version(1, 2, 170), min_version_A); -} - TEST(test_parameter, OrderParameter_ImplicitLayer) { std::vector layers = GenerateTestLayers(); std::vector sources = GenerateTestParametersImplicitOrdering();