ros2/openvehicle-api
3
0
Fork 0
mirror of https://github.com/eclipse-openvehicle-api/openvehicle-api.git synced 2026-07-01 21:25:11 +00:00
Code Issues Packages Projects Releases 1 Wiki Activity

Update sdv_packager (#6)

Browse Source
This commit is contained in:
tompzf
2026-03-27 14:12:49 +01:00
committed by GitHub
parent 234be8917f
commit aefefd52f7
717 changed files with 42252 additions and 11334 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
tests/unit_tests/install_package_composer/CMakeLists.txt
View File

@@ -1,3 +1,16 @@
#*******************************************************************************
# Copyright (c) 2025-2026 ZF Friedrichshafen AG
#
# This program and the accompanying materials are made available under the
# terms of the Apache License Version 2.0 which is available at
# https://www.apache.org/licenses/LICENSE-2.0
#
# SPDX-License-Identifier: Apache-2.0
#
# Contributors:
# Erik Verhoeven - initial API and implementation
#*******************************************************************************
# Define project
project(InstallPackageComposerTests VERSION 1.0 LANGUAGES CXX)
@@ -38,7 +51,6 @@ set_target_properties(UnitTest_InstallPackageComposer_Component2 PROPERTIES PREF
set_target_properties(UnitTest_InstallPackageComposer_Component2 PROPERTIES SUFFIX ".sdv")
# Define target
# TODO EVE
add_executable(UnitTest_InstallPackageComposer
composer_test_suite.cpp
composer_test_suite.h

14
tests/unit_tests/install_package_composer/composer_test_suite.cpp
View File

@@ -1,3 +1,16 @@
/********************************************************************************
* Copyright (c) 2025-2026 ZF Friedrichshafen AG
*
* This program and the accompanying materials are made available under the
* terms of the Apache License Version 2.0 which is available at
* https://www.apache.org/licenses/LICENSE-2.0
*
* SPDX-License-Identifier: Apache-2.0
*
* Contributors:
* Erik Verhoeven - initial API and implementation
********************************************************************************/
#include "composer_test_suite.h"
#include <filesystem>
#include <fstream>
@@ -13,6 +26,7 @@
#include "../../../sdv_services/core/toml_parser/parser_node_toml.cpp"
#include "../../../sdv_services/core/toml_parser/character_reader_utf_8.cpp"
#include "../../../sdv_services/core/toml_parser/miscellaneous.cpp"
#include "../../../sdv_services/core/toml_parser/code_snippet.cpp"
#include <support/app_control.h>
#if defined(_WIN32) && defined(_UNICODE)

13
tests/unit_tests/install_package_composer/composer_test_suite.h
View File

@@ -1,3 +1,16 @@
/********************************************************************************
* Copyright (c) 2025-2026 ZF Friedrichshafen AG
*
* This program and the accompanying materials are made available under the
* terms of the Apache License Version 2.0 which is available at
* https://www.apache.org/licenses/LICENSE-2.0
*
* SPDX-License-Identifier: Apache-2.0
*
* Contributors:
* Erik Verhoeven - initial API and implementation
********************************************************************************/
#ifndef COMPOSER_TEST_SUITE_H
#define COMPOSER_TEST_SUITE_H

23
tests/unit_tests/install_package_composer/composer_tests.cpp
View File

@@ -1,3 +1,16 @@
/********************************************************************************
* Copyright (c) 2025-2026 ZF Friedrichshafen AG
*
* This program and the accompanying materials are made available under the
* terms of the Apache License Version 2.0 which is available at
* https://www.apache.org/licenses/LICENSE-2.0
*
* SPDX-License-Identifier: Apache-2.0
*
* Contributors:
* Erik Verhoeven - initial API and implementation
********************************************************************************/
#include "composer_test_suite.h"
#include "../../../sdv_services/core/installation_composer.h"
#include "../../../global/exec_dir_helper.h"
@@ -2412,17 +2425,17 @@ TEST_F(CInstallPackageComposerTest, ComposeSDVPackage)
// The amount of modules should be 2
auto vecModules = manifest.ModuleList();
EXPECT_EQ(vecModules.size(), 2);
auto vecComponents = manifest.ComponentList();
EXPECT_EQ(vecComponents.size(), 3);
auto vecClasses = manifest.ClassList();
EXPECT_EQ(vecClasses.size(), 3);
// The name of the module should fit to the expected file
std::string szssComponents[] = { "DummyService #1", "DummyDevice", "DummyService #2" };
for (auto& rssComponent : szssComponents)
{
EXPECT_NE(std::find_if(vecComponents.begin(), vecComponents.end(), [&](const CInstallManifest::SComponent& rsComponent)
EXPECT_NE(std::find_if(vecClasses.begin(), vecClasses.end(), [&](const sdv::SClassInfo& rsClass)
{
return rsComponent.ssClassName == rssComponent;
}), vecComponents.end());
return rsClass.ssName == rssComponent;
}), vecClasses.end());
}
}

17
tests/unit_tests/install_package_composer/dummy_component1.cpp
View File

@@ -1,3 +1,16 @@
/********************************************************************************
* Copyright (c) 2025-2026 ZF Friedrichshafen AG
*
* This program and the accompanying materials are made available under the
* terms of the Apache License Version 2.0 which is available at
* https://www.apache.org/licenses/LICENSE-2.0
*
* SPDX-License-Identifier: Apache-2.0
*
* Contributors:
* Erik Verhoeven - initial API and implementation
********************************************************************************/
#include <support/component_impl.h>
/**
@@ -10,7 +23,7 @@ public:
BEGIN_SDV_INTERFACE_MAP()
END_SDV_INTERFACE_MAP()
DECLARE_OBJECT_CLASS_TYPE(sdv::EObjectType::ComplexService)
DECLARE_OBJECT_CLASS_TYPE(sdv::EObjectType::complex_service)
DECLARE_OBJECT_CLASS_NAME("DummyService #1")
DECLARE_OBJECT_CLASS_ALIAS("Dummy1", "DummySvc1")
DECLARE_DEFAULT_OBJECT_NAME("MyDummy")
@@ -29,7 +42,7 @@ public:
BEGIN_SDV_INTERFACE_MAP()
END_SDV_INTERFACE_MAP()
DECLARE_OBJECT_CLASS_TYPE(sdv::EObjectType::Device)
DECLARE_OBJECT_CLASS_TYPE(sdv::EObjectType::device)
DECLARE_OBJECT_CLASS_NAME("DummyDevice")
};
DEFINE_SDV_OBJECT(CDummyDevice)

15
tests/unit_tests/install_package_composer/dummy_component2.cpp
View File

@@ -1,3 +1,16 @@
/********************************************************************************
* Copyright (c) 2025-2026 ZF Friedrichshafen AG
*
* This program and the accompanying materials are made available under the
* terms of the Apache License Version 2.0 which is available at
* https://www.apache.org/licenses/LICENSE-2.0
*
* SPDX-License-Identifier: Apache-2.0
*
* Contributors:
* Erik Verhoeven - initial API and implementation
********************************************************************************/
#include <support/component_impl.h>
class CDummyService2 : public sdv::CSdvObject
@@ -7,7 +20,7 @@ public:
BEGIN_SDV_INTERFACE_MAP()
END_SDV_INTERFACE_MAP()
DECLARE_OBJECT_CLASS_TYPE(sdv::EObjectType::ComplexService)
DECLARE_OBJECT_CLASS_TYPE(sdv::EObjectType::complex_service)
DECLARE_OBJECT_CLASS_NAME("DummyService #2")
};

376
tests/unit_tests/install_package_composer/environment_tests.cpp
View File

@@ -1,3 +1,16 @@
/********************************************************************************
* Copyright (c) 2025-2026 ZF Friedrichshafen AG
*
* This program and the accompanying materials are made available under the
* terms of the Apache License Version 2.0 which is available at
* https://www.apache.org/licenses/LICENSE-2.0
*
* SPDX-License-Identifier: Apache-2.0
*
* Contributors:
* Erik Verhoeven - initial API and implementation
********************************************************************************/
#ifdef _WIN32
#include <WinSock2.h>
#include <windows.h>
@@ -532,7 +545,7 @@ TEST_F(CEnvironmentTest, INSTALL_Directories)
std::filesystem::path pathTargetDir = GetExecDirectory() / "install_package_composer_targets";
CCmdlnStr cmdlnLocalMissingTarget(std::string("INSTALL \"") + pathPackage1.generic_u8string() + "\" --local");
CCmdlnStr cmdlnTargetMissingLocal(std::string("INSTALL \"") + pathPackage1.generic_u8string() + "\" \"-T" + pathTargetDir.generic_u8string() + "\"");
CCmdlnStr cmdlnAutomaticTargetServer(std::string("INSTALL \"") + pathPackage1.generic_u8string() + "\" \"-T" + pathTargetDir.generic_u8string() + "\"");
CCmdlnStr cmdlnAvailable(std::string("INSTALL \"") + pathPackage1.generic_u8string() + "\" --local \"-T" + pathTargetDir.generic_u8string() + "\"");
CSdvPackagerEnvironment environment;
@@ -542,11 +555,11 @@ TEST_F(CEnvironmentTest, INSTALL_Directories)
EXPECT_TRUE(environment.TargetLocation().empty());
EXPECT_EQ(environment.Error(), CMDLN_TARGET_LOCATION_ERROR);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnTargetMissingLocal));
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnAutomaticTargetServer));
EXPECT_EQ(environment.OperatingMode(), CSdvPackagerEnvironment::EOperatingMode::install);
EXPECT_FALSE(environment.Local());
EXPECT_EQ(environment.TargetLocation(), pathTargetDir);
EXPECT_EQ(environment.Error(), CMDLN_INCOMPATIBLE_ARGUMENTS);
EXPECT_EQ(environment.Error(), NO_ERROR);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnAvailable));
EXPECT_EQ(environment.OperatingMode(), CSdvPackagerEnvironment::EOperatingMode::install);
@@ -644,29 +657,24 @@ TEST_F(CEnvironmentTest, INSTALL_LocalConfig)
pathSrcDir.generic_u8string() + "," + pathTargetDir.generic_u8string() + "\" \"-T" + pathTargetDir.generic_u8string() + "\"");
CCmdlnStr cmdlnConfigFileMissingLocal(std::string("INSTALL \"") + pathPackage1.generic_u8string() + "\" \"--config_file" +
pathConfig.generic_u8string() + "\" \"-T" + pathTargetDir.generic_u8string() + "\"");
CCmdlnStr cmdlnConfigActivateConfigMissingLocal(std::string("INSTALL \"") + pathPackage1.generic_u8string() +
"\" \"--config_file" + pathConfig.generic_u8string() + "\" --activate_config \"-T" + pathTargetDir.generic_u8string() + "\"");
CCmdlnStr cmdlnConfigActivateConfigMissingConfig(std::string("INSTALL \"") + pathPackage1.generic_u8string() +
"\" --local --activate_config \"-T" + pathTargetDir.generic_u8string() + "\"");
CCmdlnStr cmdlnAvailable(std::string("INSTALL \"") + pathPackage1.generic_u8string() + "\" \"--config_dir" +
pathSrcDir.generic_u8string() + "," + pathTargetDir.generic_u8string() + "\" \"--config_file" +
pathConfig.filename().generic_u8string() + "\" --activate_config --local \"-T" + pathTargetDir.generic_u8string() + "\"");
pathConfig.filename().generic_u8string() + "\" --local \"-T" + pathTargetDir.generic_u8string() + "\"");
CCmdlnStr cmdlnAvailableExtendedPlus(std::string("INSTALL \"") + pathPackage1.generic_u8string() + "\" \"--config_dir" +
pathSrcDir.generic_u8string() + "," + pathTargetDir.generic_u8string() + "\" \"--config_file" +
pathConfig.filename().generic_u8string() + "+abc+def\" --activate_config --local \"-T" + pathTargetDir.generic_u8string() + "\"");
pathConfig.filename().generic_u8string() + "+abc+def\" --local \"-T" + pathTargetDir.generic_u8string() + "\"");
CCmdlnStr cmdlnAvailableExtendedComma(std::string("INSTALL \"") + pathPackage1.generic_u8string() + "\" \"--config_dir" +
pathSrcDir.generic_u8string() + "," + pathTargetDir.generic_u8string() + "\" \"--config_file" +
pathConfig.filename().generic_u8string() + "+abc,def\" --activate_config --local \"-T" + pathTargetDir.generic_u8string() + "\"");
pathConfig.filename().generic_u8string() + "+abc,def\" --local \"-T" + pathTargetDir.generic_u8string() + "\"");
CSdvPackagerEnvironment environment;
std::vector<std::string> vecComponents;
CSdvPackagerEnvironment::CComponentVector vecComponents;
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnConfigDirMissingLocal));
EXPECT_EQ(environment.OperatingMode(), CSdvPackagerEnvironment::EOperatingMode::install);
EXPECT_FALSE(environment.Local());
EXPECT_EQ(environment.LocalConfigLocations().size(), 2);
EXPECT_TRUE(environment.LocalConfigFile(vecComponents).empty());
EXPECT_TRUE(vecComponents.empty());
EXPECT_FALSE(environment.ActivateLocalConfig());
EXPECT_EQ(environment.Error(), CMDLN_INCOMPATIBLE_ARGUMENTS);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnConfigFileMissingLocal));
@@ -675,25 +683,6 @@ TEST_F(CEnvironmentTest, INSTALL_LocalConfig)
EXPECT_TRUE(environment.LocalConfigLocations().empty());
EXPECT_EQ(environment.LocalConfigFile(vecComponents), pathConfig);
EXPECT_TRUE(vecComponents.empty());
EXPECT_FALSE(environment.ActivateLocalConfig());
EXPECT_EQ(environment.Error(), CMDLN_INCOMPATIBLE_ARGUMENTS);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnConfigActivateConfigMissingLocal));
EXPECT_EQ(environment.OperatingMode(), CSdvPackagerEnvironment::EOperatingMode::install);
EXPECT_FALSE(environment.Local());
EXPECT_TRUE(environment.LocalConfigLocations().empty());
EXPECT_EQ(environment.LocalConfigFile(vecComponents), pathConfig);
EXPECT_TRUE(vecComponents.empty());
EXPECT_TRUE(environment.ActivateLocalConfig());
EXPECT_EQ(environment.Error(), CMDLN_INCOMPATIBLE_ARGUMENTS);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnConfigActivateConfigMissingConfig));
EXPECT_EQ(environment.OperatingMode(), CSdvPackagerEnvironment::EOperatingMode::install);
EXPECT_TRUE(environment.Local());
EXPECT_TRUE(environment.LocalConfigLocations().empty());
EXPECT_TRUE(environment.LocalConfigFile(vecComponents).empty());
EXPECT_TRUE(vecComponents.empty());
EXPECT_TRUE(environment.ActivateLocalConfig());
EXPECT_EQ(environment.Error(), CMDLN_INCOMPATIBLE_ARGUMENTS);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnAvailable));
@@ -702,7 +691,6 @@ TEST_F(CEnvironmentTest, INSTALL_LocalConfig)
EXPECT_EQ(environment.LocalConfigLocations().size(), 2);
EXPECT_EQ(environment.LocalConfigFile(vecComponents), "config.toml");
EXPECT_TRUE(vecComponents.empty());
EXPECT_TRUE(environment.ActivateLocalConfig());
EXPECT_EQ(environment.Error(), NO_ERROR);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnAvailableExtendedPlus));
@@ -711,7 +699,6 @@ TEST_F(CEnvironmentTest, INSTALL_LocalConfig)
EXPECT_EQ(environment.LocalConfigLocations().size(), 2);
EXPECT_EQ(environment.LocalConfigFile(vecComponents), "config.toml");
EXPECT_EQ(vecComponents.size(), 2);
EXPECT_TRUE(environment.ActivateLocalConfig());
EXPECT_EQ(environment.Error(), NO_ERROR);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnAvailableExtendedComma));
@@ -720,7 +707,6 @@ TEST_F(CEnvironmentTest, INSTALL_LocalConfig)
EXPECT_EQ(environment.LocalConfigLocations().size(), 2);
EXPECT_EQ(environment.LocalConfigFile(vecComponents), "config.toml");
EXPECT_EQ(vecComponents.size(), 2);
EXPECT_TRUE(environment.ActivateLocalConfig());
EXPECT_EQ(environment.Error(), NO_ERROR);
}
@@ -766,7 +752,7 @@ TEST_F(CEnvironmentTest, INSTALL_ServerConfig)
"\"");
CSdvPackagerEnvironment environment;
std::vector<std::string> vecComponents;
CSdvPackagerEnvironment::CComponentVector vecComponents;
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnMissing));
EXPECT_EQ(environment.OperatingMode(), CSdvPackagerEnvironment::EOperatingMode::install);
EXPECT_FALSE(environment.Local());
@@ -1230,7 +1216,7 @@ TEST_F(CEnvironmentTest, DIRECT_INSTALL_Directories)
CCmdlnStr cmdlnNoSourceDir("DIRECT_INSTALL abc file1.bin");
CCmdlnStr cmdlnAvailable(std::string("DIRECT_INSTALL abc file1.bin \"-I") + pathSrcDir.generic_u8string() + "\" ");
CCmdlnStr cmdlnLocalMissingTarget(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() + "\" --local");
CCmdlnStr cmdlnTargetMissingLocal(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() + "\" \"-T" + pathTargetDir.generic_u8string() + "\"");
CCmdlnStr cmdlnAutomaticTargetServer(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() + "\" \"-T" + pathTargetDir.generic_u8string() + "\"");
CCmdlnStr cmdlnLocalAvailable(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() + "\" --local \"-T" + pathTargetDir.generic_u8string() + "\"");
CSdvPackagerEnvironment environment;
@@ -1255,11 +1241,11 @@ TEST_F(CEnvironmentTest, DIRECT_INSTALL_Directories)
EXPECT_TRUE(environment.TargetLocation().empty());
EXPECT_EQ(environment.Error(), CMDLN_TARGET_LOCATION_ERROR);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnTargetMissingLocal));
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnAutomaticTargetServer));
EXPECT_EQ(environment.OperatingMode(), CSdvPackagerEnvironment::EOperatingMode::direct_install);
EXPECT_FALSE(environment.Local());
EXPECT_EQ(environment.TargetLocation(), pathTargetDir);
EXPECT_EQ(environment.Error(), CMDLN_INCOMPATIBLE_ARGUMENTS);
EXPECT_EQ(environment.Error(), NO_ERROR);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnLocalAvailable));
EXPECT_EQ(environment.OperatingMode(), CSdvPackagerEnvironment::EOperatingMode::direct_install);
@@ -1360,29 +1346,24 @@ TEST_F(CEnvironmentTest, DIRECT_INSTALL_LocalConfig)
pathSrcDir.generic_u8string() + "," + pathTargetDir.generic_u8string() + "\" \"-T" + pathTargetDir.generic_u8string() + "\"");
CCmdlnStr cmdlnConfigFileMissingLocal(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() + "\" \"--config_file" +
pathConfig.generic_u8string() + "\" \"-T" + pathTargetDir.generic_u8string() + "\"");
CCmdlnStr cmdlnConfigActivateConfigMissingLocal(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() +
"\" \"--config_file" + pathConfig.generic_u8string() + "\" --activate_config \"-T" + pathTargetDir.generic_u8string() + "\"");
CCmdlnStr cmdlnConfigActivateConfigMissingConfig(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() +
"\" --local --activate_config \"-T" + pathTargetDir.generic_u8string() + "\"");
CCmdlnStr cmdlnAvailable(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() + "\" \"--config_dir" +
pathSrcDir.generic_u8string() + "," + pathTargetDir.generic_u8string() + "\" \"--config_file" +
pathConfig.filename().generic_u8string() + "\" --activate_config --local \"-T" + pathTargetDir.generic_u8string() + "\"");
pathConfig.filename().generic_u8string() + "\" --local \"-T" + pathTargetDir.generic_u8string() + "\"");
CCmdlnStr cmdlnAvailableExtendedPlus(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() + "\" \"--config_dir" +
pathSrcDir.generic_u8string() + "," + pathTargetDir.generic_u8string() + "\" \"--config_file" +
pathConfig.filename().generic_u8string() + "+abc+def\" --activate_config --local \"-T" + pathTargetDir.generic_u8string() + "\"");
pathConfig.filename().generic_u8string() + "+abc+def\" --local \"-T" + pathTargetDir.generic_u8string() + "\"");
CCmdlnStr cmdlnAvailableExtendedComma(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() + "\" \"--config_dir" +
pathSrcDir.generic_u8string() + "," + pathTargetDir.generic_u8string() + "\" \"--config_file" +
pathConfig.filename().generic_u8string() + "+abc,def\" --activate_config --local \"-T" + pathTargetDir.generic_u8string() + "\"");
pathConfig.filename().generic_u8string() + "+abc,def\" --local \"-T" + pathTargetDir.generic_u8string() + "\"");
CSdvPackagerEnvironment environment;
std::vector<std::string> vecComponents;
CSdvPackagerEnvironment::CComponentVector vecComponents;
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnConfigDirMissingLocal));
EXPECT_EQ(environment.OperatingMode(), CSdvPackagerEnvironment::EOperatingMode::direct_install);
EXPECT_FALSE(environment.Local());
EXPECT_EQ(environment.LocalConfigLocations().size(), 2);
EXPECT_TRUE(environment.LocalConfigFile(vecComponents).empty());
EXPECT_TRUE(vecComponents.empty());
EXPECT_FALSE(environment.ActivateLocalConfig());
EXPECT_EQ(environment.Error(), CMDLN_INCOMPATIBLE_ARGUMENTS);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnConfigFileMissingLocal));
@@ -1391,25 +1372,6 @@ TEST_F(CEnvironmentTest, DIRECT_INSTALL_LocalConfig)
EXPECT_TRUE(environment.LocalConfigLocations().empty());
EXPECT_EQ(environment.LocalConfigFile(vecComponents), pathConfig);
EXPECT_TRUE(vecComponents.empty());
EXPECT_FALSE(environment.ActivateLocalConfig());
EXPECT_EQ(environment.Error(), CMDLN_INCOMPATIBLE_ARGUMENTS);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnConfigActivateConfigMissingLocal));
EXPECT_EQ(environment.OperatingMode(), CSdvPackagerEnvironment::EOperatingMode::direct_install);
EXPECT_FALSE(environment.Local());
EXPECT_TRUE(environment.LocalConfigLocations().empty());
EXPECT_EQ(environment.LocalConfigFile(vecComponents), pathConfig);
EXPECT_TRUE(vecComponents.empty());
EXPECT_TRUE(environment.ActivateLocalConfig());
EXPECT_EQ(environment.Error(), CMDLN_INCOMPATIBLE_ARGUMENTS);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnConfigActivateConfigMissingConfig));
EXPECT_EQ(environment.OperatingMode(), CSdvPackagerEnvironment::EOperatingMode::direct_install);
EXPECT_TRUE(environment.Local());
EXPECT_TRUE(environment.LocalConfigLocations().empty());
EXPECT_TRUE(environment.LocalConfigFile(vecComponents).empty());
EXPECT_TRUE(vecComponents.empty());
EXPECT_TRUE(environment.ActivateLocalConfig());
EXPECT_EQ(environment.Error(), CMDLN_INCOMPATIBLE_ARGUMENTS);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnAvailable));
@@ -1418,7 +1380,6 @@ TEST_F(CEnvironmentTest, DIRECT_INSTALL_LocalConfig)
EXPECT_EQ(environment.LocalConfigLocations().size(), 2);
EXPECT_EQ(environment.LocalConfigFile(vecComponents), "config.toml");
EXPECT_TRUE(vecComponents.empty());
EXPECT_TRUE(environment.ActivateLocalConfig());
EXPECT_EQ(environment.Error(), NO_ERROR);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnAvailableExtendedPlus));
@@ -1427,7 +1388,6 @@ TEST_F(CEnvironmentTest, DIRECT_INSTALL_LocalConfig)
EXPECT_EQ(environment.LocalConfigLocations().size(), 2);
EXPECT_EQ(environment.LocalConfigFile(vecComponents), "config.toml");
EXPECT_EQ(vecComponents.size(), 2);
EXPECT_TRUE(environment.ActivateLocalConfig());
EXPECT_EQ(environment.Error(), NO_ERROR);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnAvailableExtendedComma));
@@ -1436,7 +1396,6 @@ TEST_F(CEnvironmentTest, DIRECT_INSTALL_LocalConfig)
EXPECT_EQ(environment.LocalConfigLocations().size(), 2);
EXPECT_EQ(environment.LocalConfigFile(vecComponents), "config.toml");
EXPECT_EQ(vecComponents.size(), 2);
EXPECT_TRUE(environment.ActivateLocalConfig());
EXPECT_EQ(environment.Error(), NO_ERROR);
}
@@ -1467,7 +1426,7 @@ TEST_F(CEnvironmentTest, DIRECT_INSTALL_ServerConfig)
CCmdlnStr cmdlnAllLocal(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() + "\" --user_config --platform_config --interface_config --abstract_config --local \"-T" + pathTargetDir.generic_u8string() + "\"");
CSdvPackagerEnvironment environment;
std::vector<std::string> vecComponents;
CSdvPackagerEnvironment::CComponentVector vecComponents;
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnMissing));
EXPECT_EQ(environment.OperatingMode(), CSdvPackagerEnvironment::EOperatingMode::direct_install);
EXPECT_FALSE(environment.Local());
@@ -1716,6 +1675,270 @@ TEST_F(CEnvironmentTest, DIRECT_INSTALL_ServerConfig)
EXPECT_EQ(environment.Error(), CMDLN_INCOMPATIBLE_ARGUMENTS);
}
TEST_F(CEnvironmentTest, DIRECT_INSTALL_ConfigParameters)
{
std::filesystem::path pathSrcDir = GetExecDirectory() / "install_package_composer_sources";
std::filesystem::path pathSrcDir2 = GetExecDirectory() / "install_package_composer_sources" / "dummy_package";
std::filesystem::path pathSrcFile = pathSrcDir2 / "file1.bin";
std::filesystem::path pathConfig = pathSrcDir / "config.toml";
std::filesystem::path pathTargetDir = GetExecDirectory() / "install_package_composer_targets";
CCmdlnStr cmdlnConfigMissing(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() + "\"" +
" \"--parametersmy_component1:param1=10,param2=20,groupA.param3=string value\"" +
" \"--parametersmy_test21:param5=,groupB.param6=60\"");
CCmdlnStr cmdlnLocalConfig(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() + "\" \"--config_dir" +
pathSrcDir.generic_u8string() + "," + pathTargetDir.generic_u8string() + "\" \"--config_file" +
pathConfig.filename().generic_u8string() + "+my_component1+my_component2=mytest21\" --local \"-T" +
pathTargetDir.generic_u8string() + "\"" + " \"--parametersmy_component1:param1=10,param2=20,groupA.param3=string value\"" +
" \"--parametersmy_test21:param5=,groupB.param6=60\"");
CCmdlnStr cmdlnServerUserConfig(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() + "\" \"--user_config" +
"+my_component1+my_component2=mytest21\" \"-T" + pathTargetDir.generic_u8string() + "\"" +
" \"--parametersmy_component1:param1=10,param2=20,groupA.param3=string value\"" +
" \"--parametersmy_test21:param5=,groupB.param6=60\"");
CCmdlnStr cmdlnServerPlatformConfig(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() +
"\" \"--platform_config" + "+my_component1+my_component2=mytest21\" \"-T" + pathTargetDir.generic_u8string() + "\"" +
" \"--parametersmy_component1:param1=10,param2=20,groupA.param3=string value\"" +
" \"--parametersmy_test21:param5=,groupB.param6=60\"");
CCmdlnStr cmdlnServerInterfaceConfig(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() +
"\" \"--interface_config" + "+my_component1+my_component2=mytest21\" \"-T" + pathTargetDir.generic_u8string() + "\"" +
" \"--parametersmy_component1:param1=10,param2=20,groupA.param3=string value\"" +
" \"--parametersmy_test21:param5=,groupB.param6=60\"");
CCmdlnStr cmdlnServerAbstractConfig(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() +
"\" \"--abstract_config" + "+my_component1+my_component2=mytest21\" \"-T" + pathTargetDir.generic_u8string() + "\"" +
" \"--parametersmy_component1:param1=10,param2=20,groupA.param3=string value\"" +
" \"--parametersmy_test21:param5=,groupB.param6=60\"");
CSdvPackagerEnvironment environment;
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnConfigMissing));
EXPECT_EQ(environment.Error(), CMDLN_INCOMPATIBLE_ARGUMENTS);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnLocalConfig));
EXPECT_EQ(environment.Error(), NO_ERROR);
auto vecParameters = environment.ObjectParameters("my_component1");
ASSERT_EQ(vecParameters.size(), 3);
EXPECT_EQ(vecParameters[0].first, "param1");
EXPECT_EQ(static_cast<size_t>(vecParameters[0].second), 10);
EXPECT_EQ(vecParameters[1].first, "param2");
EXPECT_EQ(static_cast<size_t>(vecParameters[1].second), 20);
EXPECT_EQ(vecParameters[2].first, "groupA.param3");
EXPECT_EQ(static_cast<std::string>(vecParameters[2].second), "string value");
vecParameters = environment.ObjectParameters("my_test21");
ASSERT_EQ(vecParameters.size(), 2);
EXPECT_EQ(vecParameters[0].first, "param5");
EXPECT_TRUE(vecParameters[0].second.empty());
EXPECT_EQ(vecParameters[1].first, "groupB.param6");
EXPECT_EQ(static_cast<size_t>(vecParameters[1].second), 60);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnServerUserConfig));
EXPECT_EQ(environment.Error(), NO_ERROR);
vecParameters = environment.ObjectParameters("my_component1");
ASSERT_EQ(vecParameters.size(), 3);
EXPECT_EQ(vecParameters[0].first, "param1");
EXPECT_EQ(static_cast<size_t>(vecParameters[0].second), 10);
EXPECT_EQ(vecParameters[1].first, "param2");
EXPECT_EQ(static_cast<size_t>(vecParameters[1].second), 20);
EXPECT_EQ(vecParameters[2].first, "groupA.param3");
EXPECT_EQ(static_cast<std::string>(vecParameters[2].second), "string value");
vecParameters = environment.ObjectParameters("my_test21");
ASSERT_EQ(vecParameters.size(), 2);
EXPECT_EQ(vecParameters[0].first, "param5");
EXPECT_TRUE(vecParameters[0].second.empty());
EXPECT_EQ(vecParameters[1].first, "groupB.param6");
EXPECT_EQ(static_cast<size_t>(vecParameters[1].second), 60);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnServerPlatformConfig));
EXPECT_EQ(environment.Error(), NO_ERROR);
vecParameters = environment.ObjectParameters("my_component1");
ASSERT_EQ(vecParameters.size(), 3);
EXPECT_EQ(vecParameters[0].first, "param1");
EXPECT_EQ(static_cast<size_t>(vecParameters[0].second), 10);
EXPECT_EQ(vecParameters[1].first, "param2");
EXPECT_EQ(static_cast<size_t>(vecParameters[1].second), 20);
EXPECT_EQ(vecParameters[2].first, "groupA.param3");
EXPECT_EQ(static_cast<std::string>(vecParameters[2].second), "string value");
vecParameters = environment.ObjectParameters("my_test21");
ASSERT_EQ(vecParameters.size(), 2);
EXPECT_EQ(vecParameters[0].first, "param5");
EXPECT_TRUE(vecParameters[0].second.empty());
EXPECT_EQ(vecParameters[1].first, "groupB.param6");
EXPECT_EQ(static_cast<size_t>(vecParameters[1].second), 60);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnServerInterfaceConfig));
EXPECT_EQ(environment.Error(), NO_ERROR);
vecParameters = environment.ObjectParameters("my_component1");
ASSERT_EQ(vecParameters.size(), 3);
EXPECT_EQ(vecParameters[0].first, "param1");
EXPECT_EQ(static_cast<size_t>(vecParameters[0].second), 10);
EXPECT_EQ(vecParameters[1].first, "param2");
EXPECT_EQ(static_cast<size_t>(vecParameters[1].second), 20);
EXPECT_EQ(vecParameters[2].first, "groupA.param3");
EXPECT_EQ(static_cast<std::string>(vecParameters[2].second), "string value");
vecParameters = environment.ObjectParameters("my_test21");
ASSERT_EQ(vecParameters.size(), 2);
EXPECT_EQ(vecParameters[0].first, "param5");
EXPECT_TRUE(vecParameters[0].second.empty());
EXPECT_EQ(vecParameters[1].first, "groupB.param6");
EXPECT_EQ(static_cast<size_t>(vecParameters[1].second), 60);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnServerAbstractConfig));
EXPECT_EQ(environment.Error(), NO_ERROR);
vecParameters = environment.ObjectParameters("my_component1");
ASSERT_EQ(vecParameters.size(), 3);
EXPECT_EQ(vecParameters[0].first, "param1");
EXPECT_EQ(static_cast<size_t>(vecParameters[0].second), 10);
EXPECT_EQ(vecParameters[1].first, "param2");
EXPECT_EQ(static_cast<size_t>(vecParameters[1].second), 20);
EXPECT_EQ(vecParameters[2].first, "groupA.param3");
EXPECT_EQ(static_cast<std::string>(vecParameters[2].second), "string value");
vecParameters = environment.ObjectParameters("my_test21");
ASSERT_EQ(vecParameters.size(), 2);
EXPECT_EQ(vecParameters[0].first, "param5");
EXPECT_TRUE(vecParameters[0].second.empty());
EXPECT_EQ(vecParameters[1].first, "groupB.param6");
EXPECT_EQ(static_cast<size_t>(vecParameters[1].second), 60);
// TODO:
// - Check for invalid parameter string
// - Check for duplicate parameters (which is not an error).
}
TEST_F(CEnvironmentTest, DIRECT_INSTALL_ConfigParameterFile)
{
std::filesystem::path pathSrcDir = GetExecDirectory() / "install_package_composer_sources";
std::filesystem::path pathSrcDir2 = GetExecDirectory() / "install_package_composer_sources" / "dummy_package";
std::filesystem::path pathSrcFile = pathSrcDir2 / "file1.bin";
std::filesystem::path pathConfig = pathSrcDir / "config.toml";
std::filesystem::path pathTargetDir = GetExecDirectory() / "install_package_composer_targets";
std::ofstream fstream("param_test_file.toml");
ASSERT_TRUE(fstream.is_open());
fstream << R"toml(# Parameters for my_component1
[my_component1]
param1 = 10
param2 = 20
[my_component1.groupA] # Example with additional table for the GroupA parameters
param3 = "string value"
# Parameters for test21 (instance of my_component2)
[my_test21]
param5=50
groupB.param6=60 # Grouping using inline table for GroupB parameters
)toml";
fstream.close();
CCmdlnStr cmdlnConfigMissing(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() + "\"" +
" \"--param_fileparam_test_file.toml\"");
CCmdlnStr cmdlnLocalConfig(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() + "\" \"--config_dir" +
pathSrcDir.generic_u8string() + "," + pathTargetDir.generic_u8string() + "\" \"--config_file" +
pathConfig.filename().generic_u8string() + "+my_component1+my_component2=my_test21\" --local \"-T" +
pathTargetDir.generic_u8string() + "\"" + " \"--param_fileparam_test_file.toml\"");
CCmdlnStr cmdlnServerUserConfig(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() + "\" \"--user_config" +
"+my_component1+my_component2=my_test21\" \"-T" + pathTargetDir.generic_u8string() + "\"" +
" \"--param_fileparam_test_file.toml\"");
CCmdlnStr cmdlnServerPlatformConfig(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() +
"\" \"--platform_config" + "+my_component1+my_component2=my_test21\" \"-T" + pathTargetDir.generic_u8string() + "\"" +
" \"--param_fileparam_test_file.toml\"");
CCmdlnStr cmdlnServerInterfaceConfig(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() +
"\" \"--interface_config" + "+my_component1+my_component2=my_test21\" \"-T" + pathTargetDir.generic_u8string() + "\"" +
" \"--param_fileparam_test_file.toml\"");
CCmdlnStr cmdlnServerAbstractConfig(std::string("DIRECT_INSTALL abc \"") + pathSrcFile.generic_u8string() +
"\" \"--abstract_config" + "+my_component1+my_component2=my_test21\" \"-T" + pathTargetDir.generic_u8string() + "\"" +
" \"--param_fileparam_test_file.toml\"");
CSdvPackagerEnvironment environment;
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnConfigMissing));
EXPECT_EQ(environment.Error(), CMDLN_INCOMPATIBLE_ARGUMENTS);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnLocalConfig));
EXPECT_EQ(environment.Error(), NO_ERROR);
auto vecParameters = environment.ObjectParameters("my_component1");
ASSERT_EQ(vecParameters.size(), 3);
EXPECT_EQ(vecParameters[0].first, "param1");
EXPECT_EQ(static_cast<size_t>(vecParameters[0].second), 10);
EXPECT_EQ(vecParameters[1].first, "param2");
EXPECT_EQ(static_cast<size_t>(vecParameters[1].second), 20);
EXPECT_EQ(vecParameters[2].first, "groupA.param3");
EXPECT_EQ(static_cast<std::string>(vecParameters[2].second), "string value");
vecParameters = environment.ObjectParameters("my_test21");
ASSERT_EQ(vecParameters.size(), 2);
EXPECT_EQ(vecParameters[0].first, "param5");
EXPECT_EQ(static_cast<size_t>(vecParameters[0].second), 50);
EXPECT_EQ(vecParameters[1].first, "groupB.param6");
EXPECT_EQ(static_cast<size_t>(vecParameters[1].second), 60);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnServerUserConfig));
EXPECT_EQ(environment.Error(), NO_ERROR);
vecParameters = environment.ObjectParameters("my_component1");
ASSERT_EQ(vecParameters.size(), 3);
EXPECT_EQ(vecParameters[0].first, "param1");
EXPECT_EQ(static_cast<size_t>(vecParameters[0].second), 10);
EXPECT_EQ(vecParameters[1].first, "param2");
EXPECT_EQ(static_cast<size_t>(vecParameters[1].second), 20);
EXPECT_EQ(vecParameters[2].first, "groupA.param3");
EXPECT_EQ(static_cast<std::string>(vecParameters[2].second), "string value");
vecParameters = environment.ObjectParameters("my_test21");
ASSERT_EQ(vecParameters.size(), 2);
EXPECT_EQ(vecParameters[0].first, "param5");
EXPECT_EQ(static_cast<size_t>(vecParameters[0].second), 50);
EXPECT_EQ(vecParameters[1].first, "groupB.param6");
EXPECT_EQ(static_cast<size_t>(vecParameters[1].second), 60);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnServerPlatformConfig));
EXPECT_EQ(environment.Error(), NO_ERROR);
vecParameters = environment.ObjectParameters("my_component1");
ASSERT_EQ(vecParameters.size(), 3);
EXPECT_EQ(vecParameters[0].first, "param1");
EXPECT_EQ(static_cast<size_t>(vecParameters[0].second), 10);
EXPECT_EQ(vecParameters[1].first, "param2");
EXPECT_EQ(static_cast<size_t>(vecParameters[1].second), 20);
EXPECT_EQ(vecParameters[2].first, "groupA.param3");
EXPECT_EQ(static_cast<std::string>(vecParameters[2].second), "string value");
vecParameters = environment.ObjectParameters("my_test21");
ASSERT_EQ(vecParameters.size(), 2);
EXPECT_EQ(vecParameters[0].first, "param5");
EXPECT_EQ(static_cast<size_t>(vecParameters[0].second), 50);
EXPECT_EQ(vecParameters[1].first, "groupB.param6");
EXPECT_EQ(static_cast<size_t>(vecParameters[1].second), 60);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnServerInterfaceConfig));
EXPECT_EQ(environment.Error(), NO_ERROR);
vecParameters = environment.ObjectParameters("my_component1");
ASSERT_EQ(vecParameters.size(), 3);
EXPECT_EQ(vecParameters[0].first, "param1");
EXPECT_EQ(static_cast<size_t>(vecParameters[0].second), 10);
EXPECT_EQ(vecParameters[1].first, "param2");
EXPECT_EQ(static_cast<size_t>(vecParameters[1].second), 20);
EXPECT_EQ(vecParameters[2].first, "groupA.param3");
EXPECT_EQ(static_cast<std::string>(vecParameters[2].second), "string value");
vecParameters = environment.ObjectParameters("my_test21");
ASSERT_EQ(vecParameters.size(), 2);
EXPECT_EQ(vecParameters[0].first, "param5");
EXPECT_EQ(static_cast<size_t>(vecParameters[0].second), 50);
EXPECT_EQ(vecParameters[1].first, "groupB.param6");
EXPECT_EQ(static_cast<size_t>(vecParameters[1].second), 60);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnServerAbstractConfig));
EXPECT_EQ(environment.Error(), NO_ERROR);
vecParameters = environment.ObjectParameters("my_component1");
ASSERT_EQ(vecParameters.size(), 3);
EXPECT_EQ(vecParameters[0].first, "param1");
EXPECT_EQ(static_cast<size_t>(vecParameters[0].second), 10);
EXPECT_EQ(vecParameters[1].first, "param2");
EXPECT_EQ(static_cast<size_t>(vecParameters[1].second), 20);
EXPECT_EQ(vecParameters[2].first, "groupA.param3");
EXPECT_EQ(static_cast<std::string>(vecParameters[2].second), "string value");
vecParameters = environment.ObjectParameters("my_test21");
ASSERT_EQ(vecParameters.size(), 2);
EXPECT_EQ(vecParameters[0].first, "param5");
EXPECT_EQ(static_cast<size_t>(vecParameters[0].second), 50);
EXPECT_EQ(vecParameters[1].first, "groupB.param6");
EXPECT_EQ(static_cast<size_t>(vecParameters[1].second), 60);
// TODO:
// - Check for invalid parameter string
// - Check for duplicate parameters (which is not an error).
}
TEST_F(CEnvironmentTest, UNINSTALL_InstallName)
{
CCmdlnStr cmdlnMissing("UNINSTALL");
@@ -1781,22 +2004,29 @@ TEST_F(CEnvironmentTest, UNINSTALL_Directories)
{
std::filesystem::path pathTargetDir = GetExecDirectory() / "install_package_composer_targets";
CCmdlnStr cmdlnServerAutomaticTarget("UNINSTALL abc");
CCmdlnStr cmdlnLocalMissingTarget("UNINSTALL abc --local");
CCmdlnStr cmdlnTargetMissingLocal(std::string("UNINSTALL abc \"-T") + pathTargetDir.generic_u8string() + "\"");
CCmdlnStr cmdlnServerAvailable(std::string("UNINSTALL abc \"-T") + pathTargetDir.generic_u8string() + "\"");
CCmdlnStr cmdlnAvailable(std::string("UNINSTALL abc --local \"-T") + pathTargetDir.generic_u8string() + "\"");
CSdvPackagerEnvironment environment;
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnServerAutomaticTarget));
EXPECT_EQ(environment.OperatingMode(), CSdvPackagerEnvironment::EOperatingMode::uninstall);
EXPECT_FALSE(environment.Local());
EXPECT_FALSE(environment.TargetLocation().empty());
EXPECT_EQ(environment.Error(), NO_ERROR);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnLocalMissingTarget));
EXPECT_EQ(environment.OperatingMode(), CSdvPackagerEnvironment::EOperatingMode::uninstall);
EXPECT_TRUE(environment.Local());
EXPECT_TRUE(environment.TargetLocation().empty());
EXPECT_EQ(environment.Error(), CMDLN_TARGET_LOCATION_ERROR);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnTargetMissingLocal));
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnServerAvailable));
EXPECT_EQ(environment.OperatingMode(), CSdvPackagerEnvironment::EOperatingMode::uninstall);
EXPECT_FALSE(environment.Local());
EXPECT_EQ(environment.TargetLocation(), pathTargetDir);
EXPECT_EQ(environment.Error(), CMDLN_INCOMPATIBLE_ARGUMENTS);
EXPECT_EQ(environment.Error(), NO_ERROR);
EXPECT_NO_THROW(environment = CSdvPackagerEnvironment(cmdlnAvailable));
EXPECT_EQ(environment.OperatingMode(), CSdvPackagerEnvironment::EOperatingMode::uninstall);

277
tests/unit_tests/install_package_composer/manifest_tests.cpp
View File

@@ -1,3 +1,16 @@
/********************************************************************************
* Copyright (c) 2025-2026 ZF Friedrichshafen AG
*
* This program and the accompanying materials are made available under the
* terms of the Apache License Version 2.0 which is available at
* https://www.apache.org/licenses/LICENSE-2.0
*
* SPDX-License-Identifier: Apache-2.0
*
* Contributors:
* Erik Verhoeven - initial API and implementation
********************************************************************************/
#include <gtest/gtest.h>
#include "composer_test_suite.h"
#include "../../../global/exec_dir_helper.h"
@@ -146,27 +159,27 @@ TEST_F(CInstallManifestTest, WriteReadComponents)
EXPECT_EQ(vecModules.size(), 2);
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "UnitTest_InstallPackageComposer_Component1.sdv"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "UnitTest_InstallPackageComposer_Component2.sdv"), vecModules.end());
auto vecComponents = manifestWrite.ComponentList();
EXPECT_EQ(vecComponents.size(), 3);
auto itDummyService1 = std::find_if(vecComponents.begin(), vecComponents.end(), [](const auto& sComponent) { return sComponent.ssClassName == "DummyService #1"; });
ASSERT_NE(itDummyService1, vecComponents.end());
EXPECT_EQ(itDummyService1->pathRelModule, "UnitTest_InstallPackageComposer_Component1.sdv");
EXPECT_FALSE(itDummyService1->ssManifest.empty());
ASSERT_EQ(itDummyService1->seqAliases.size(), 2);
EXPECT_EQ(itDummyService1->seqAliases[0], "Dummy1");
EXPECT_EQ(itDummyService1->seqAliases[1], "DummySvc1");
auto vecClasses = manifestWrite.ClassList();
EXPECT_EQ(vecClasses.size(), 3);
auto itDummyService1 = std::find_if(vecClasses.begin(), vecClasses.end(), [](const auto& sComponent) { return sComponent.ssName == "DummyService #1"; });
ASSERT_NE(itDummyService1, vecClasses.end());
EXPECT_EQ(itDummyService1->ssModulePath, "UnitTest_InstallPackageComposer_Component1.sdv");
//EXPECT_FALSE(itDummyService1->ssManifest.empty());
ASSERT_EQ(itDummyService1->seqClassAliases.size(), 2);
EXPECT_EQ(itDummyService1->seqClassAliases[0], "Dummy1");
EXPECT_EQ(itDummyService1->seqClassAliases[1], "DummySvc1");
EXPECT_EQ(itDummyService1->ssDefaultObjectName, "MyDummy");
EXPECT_EQ(itDummyService1->eType, sdv::EObjectType::ComplexService);
EXPECT_EQ(itDummyService1->eType, sdv::EObjectType::complex_service);
EXPECT_EQ(itDummyService1->uiFlags, static_cast<uint32_t>(sdv::EObjectFlags::singleton));
ASSERT_EQ(itDummyService1->seqDependencies .size(), 2);
EXPECT_EQ(itDummyService1->seqDependencies[0], "DummyDevice");
EXPECT_EQ(itDummyService1->seqDependencies[1], "DummyService #2");
auto itDummyDevice = std::find_if(vecComponents.begin(), vecComponents.end(), [](const auto& sComponent) { return sComponent.ssClassName == "DummyDevice"; });
ASSERT_NE(itDummyDevice, vecComponents.end());
EXPECT_EQ(itDummyDevice->pathRelModule, "UnitTest_InstallPackageComposer_Component1.sdv");
auto itDummyService2 = std::find_if(vecComponents.begin(), vecComponents.end(), [](const auto& sComponent) { return sComponent.ssClassName == "DummyService #2"; });
ASSERT_NE(itDummyService2, vecComponents.end());
EXPECT_EQ(itDummyService2->pathRelModule, "UnitTest_InstallPackageComposer_Component2.sdv");
auto itDummyDevice = std::find_if(vecClasses.begin(), vecClasses.end(), [](const auto& sComponent) { return sComponent.ssName == "DummyDevice"; });
ASSERT_NE(itDummyDevice, vecClasses.end());
EXPECT_EQ(itDummyDevice->ssModulePath, "UnitTest_InstallPackageComposer_Component1.sdv");
auto itDummyService2 = std::find_if(vecClasses.begin(), vecClasses.end(), [](const auto& sComponent) { return sComponent.ssName == "DummyService #2"; });
ASSERT_NE(itDummyService2, vecClasses.end());
EXPECT_EQ(itDummyService2->ssModulePath, "UnitTest_InstallPackageComposer_Component2.sdv");
std::string ssManifest = manifestWrite.Write();
EXPECT_FALSE(ssManifest.empty());
@@ -177,27 +190,27 @@ TEST_F(CInstallManifestTest, WriteReadComponents)
EXPECT_EQ(vecModules.size(), 2);
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "UnitTest_InstallPackageComposer_Component1.sdv"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "UnitTest_InstallPackageComposer_Component2.sdv"), vecModules.end());
vecComponents = manifestRead.ComponentList();
EXPECT_EQ(vecComponents.size(), 3);
itDummyService1 = std::find_if(vecComponents.begin(), vecComponents.end(), [](const auto& sComponent) { return sComponent.ssClassName == "DummyService #1"; });
ASSERT_NE(itDummyService1, vecComponents.end());
EXPECT_EQ(itDummyService1->pathRelModule, "UnitTest_InstallPackageComposer_Component1.sdv");
EXPECT_FALSE(itDummyService1->ssManifest.empty());
ASSERT_EQ(itDummyService1->seqAliases.size(), 2);
EXPECT_EQ(itDummyService1->seqAliases[0], "Dummy1");
EXPECT_EQ(itDummyService1->seqAliases[1], "DummySvc1");
vecClasses = manifestRead.ClassList();
EXPECT_EQ(vecClasses.size(), 3);
itDummyService1 = std::find_if(vecClasses.begin(), vecClasses.end(), [](const auto& sComponent) { return sComponent.ssName == "DummyService #1"; });
ASSERT_NE(itDummyService1, vecClasses.end());
EXPECT_EQ(itDummyService1->ssModulePath, "UnitTest_InstallPackageComposer_Component1.sdv");
//EXPECT_FALSE(itDummyService1->ssManifest.empty());
ASSERT_EQ(itDummyService1->seqClassAliases.size(), 2);
EXPECT_EQ(itDummyService1->seqClassAliases[0], "Dummy1");
EXPECT_EQ(itDummyService1->seqClassAliases[1], "DummySvc1");
EXPECT_EQ(itDummyService1->ssDefaultObjectName, "MyDummy");
EXPECT_EQ(itDummyService1->eType, sdv::EObjectType::ComplexService);
EXPECT_EQ(itDummyService1->eType, sdv::EObjectType::complex_service);
EXPECT_EQ(itDummyService1->uiFlags, static_cast<uint32_t>(sdv::EObjectFlags::singleton));
ASSERT_EQ(itDummyService1->seqDependencies .size(), 2);
EXPECT_EQ(itDummyService1->seqDependencies[0], "DummyDevice");
EXPECT_EQ(itDummyService1->seqDependencies[1], "DummyService #2");
itDummyDevice = std::find_if(vecComponents.begin(), vecComponents.end(), [](const auto& sComponent) { return sComponent.ssClassName == "DummyDevice"; });
ASSERT_NE(itDummyDevice, vecComponents.end());
EXPECT_EQ(itDummyDevice->pathRelModule, "UnitTest_InstallPackageComposer_Component1.sdv");
itDummyService2 = std::find_if(vecComponents.begin(), vecComponents.end(), [](const auto& sComponent) { return sComponent.ssClassName == "DummyService #2"; });
ASSERT_NE(itDummyService2, vecComponents.end());
EXPECT_EQ(itDummyService2->pathRelModule, "UnitTest_InstallPackageComposer_Component2.sdv");
itDummyDevice = std::find_if(vecClasses.begin(), vecClasses.end(), [](const auto& sComponent) { return sComponent.ssName == "DummyDevice"; });
ASSERT_NE(itDummyDevice, vecClasses.end());
EXPECT_EQ(itDummyDevice->ssModulePath, "UnitTest_InstallPackageComposer_Component1.sdv");
itDummyService2 = std::find_if(vecClasses.begin(), vecClasses.end(), [](const auto& sComponent) { return sComponent.ssName == "DummyService #2"; });
ASSERT_NE(itDummyService2, vecClasses.end());
EXPECT_EQ(itDummyService2->ssModulePath, "UnitTest_InstallPackageComposer_Component2.sdv");
}
TEST_F(CInstallManifestTest, WriteReadFindComponents)
@@ -214,32 +227,32 @@ TEST_F(CInstallManifestTest, WriteReadFindComponents)
EXPECT_EQ(vecModules.size(), 2);
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "UnitTest_InstallPackageComposer_Component1.sdv"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "UnitTest_InstallPackageComposer_Component2.sdv"), vecModules.end());
auto vecComponents = manifestWrite.ComponentList();
EXPECT_EQ(vecComponents.size(), 3);
auto itDummyService1 = std::find_if(vecComponents.begin(),
vecComponents.end(),
[](const auto& sComponent) { return sComponent.ssClassName == "DummyService #1"; });
ASSERT_NE(itDummyService1, vecComponents.end());
EXPECT_EQ(itDummyService1->pathRelModule, "UnitTest_InstallPackageComposer_Component1.sdv");
EXPECT_FALSE(itDummyService1->ssManifest.empty());
ASSERT_EQ(itDummyService1->seqAliases.size(), 2);
EXPECT_EQ(itDummyService1->seqAliases[0], "Dummy1");
EXPECT_EQ(itDummyService1->seqAliases[1], "DummySvc1");
auto vecClasses = manifestWrite.ClassList();
EXPECT_EQ(vecClasses.size(), 3);
auto itDummyService1 = std::find_if(vecClasses.begin(),
vecClasses.end(),
[](const auto& sComponent) { return sComponent.ssName == "DummyService #1"; });
ASSERT_NE(itDummyService1, vecClasses.end());
EXPECT_EQ(itDummyService1->ssModulePath, "UnitTest_InstallPackageComposer_Component1.sdv");
//EXPECT_FALSE(itDummyService1->ssManifest.empty());
ASSERT_EQ(itDummyService1->seqClassAliases.size(), 2);
EXPECT_EQ(itDummyService1->seqClassAliases[0], "Dummy1");
EXPECT_EQ(itDummyService1->seqClassAliases[1], "DummySvc1");
EXPECT_EQ(itDummyService1->ssDefaultObjectName, "MyDummy");
EXPECT_EQ(itDummyService1->eType, sdv::EObjectType::ComplexService);
EXPECT_EQ(itDummyService1->eType, sdv::EObjectType::complex_service);
EXPECT_EQ(itDummyService1->uiFlags, static_cast<uint32_t>(sdv::EObjectFlags::singleton));
ASSERT_EQ(itDummyService1->seqDependencies.size(), 2);
EXPECT_EQ(itDummyService1->seqDependencies[0], "DummyDevice");
EXPECT_EQ(itDummyService1->seqDependencies[1], "DummyService #2");
auto itDummyDevice = std::find_if(
vecComponents.begin(), vecComponents.end(), [](const auto& sComponent) { return sComponent.ssClassName == "DummyDevice"; });
ASSERT_NE(itDummyDevice, vecComponents.end());
EXPECT_EQ(itDummyDevice->pathRelModule, "UnitTest_InstallPackageComposer_Component1.sdv");
auto itDummyService2 = std::find_if(vecComponents.begin(),
vecComponents.end(),
[](const auto& sComponent) { return sComponent.ssClassName == "DummyService #2"; });
ASSERT_NE(itDummyService2, vecComponents.end());
EXPECT_EQ(itDummyService2->pathRelModule, "UnitTest_InstallPackageComposer_Component2.sdv");
vecClasses.begin(), vecClasses.end(), [](const auto& sComponent) { return sComponent.ssName == "DummyDevice"; });
ASSERT_NE(itDummyDevice, vecClasses.end());
EXPECT_EQ(itDummyDevice->ssModulePath, "UnitTest_InstallPackageComposer_Component1.sdv");
auto itDummyService2 = std::find_if(vecClasses.begin(),
vecClasses.end(),
[](const auto& sComponent) { return sComponent.ssName == "DummyService #2"; });
ASSERT_NE(itDummyService2, vecClasses.end());
EXPECT_EQ(itDummyService2->ssModulePath, "UnitTest_InstallPackageComposer_Component2.sdv");
std::string ssManifest = manifestWrite.Write();
EXPECT_FALSE(ssManifest.empty());
@@ -408,32 +421,32 @@ TEST_F(CInstallManifestTest, SaveLoadComponents)
EXPECT_EQ(vecModules.size(), 2);
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "UnitTest_InstallPackageComposer_Component1.sdv"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "UnitTest_InstallPackageComposer_Component2.sdv"), vecModules.end());
auto vecComponents = manifestWrite.ComponentList();
EXPECT_EQ(vecComponents.size(), 3);
auto itDummyService1 = std::find_if(vecComponents.begin(),
vecComponents.end(),
[](const auto& sComponent) { return sComponent.ssClassName == "DummyService #1"; });
ASSERT_NE(itDummyService1, vecComponents.end());
EXPECT_EQ(itDummyService1->pathRelModule, "UnitTest_InstallPackageComposer_Component1.sdv");
EXPECT_FALSE(itDummyService1->ssManifest.empty());
ASSERT_EQ(itDummyService1->seqAliases.size(), 2);
EXPECT_EQ(itDummyService1->seqAliases[0], "Dummy1");
EXPECT_EQ(itDummyService1->seqAliases[1], "DummySvc1");
auto vecClasses = manifestWrite.ClassList();
EXPECT_EQ(vecClasses.size(), 3);
auto itDummyService1 = std::find_if(vecClasses.begin(),
vecClasses.end(),
[](const auto& sComponent) { return sComponent.ssName == "DummyService #1"; });
ASSERT_NE(itDummyService1, vecClasses.end());
EXPECT_EQ(itDummyService1->ssModulePath, "UnitTest_InstallPackageComposer_Component1.sdv");
//EXPECT_FALSE(itDummyService1->ssManifest.empty());
ASSERT_EQ(itDummyService1->seqClassAliases.size(), 2);
EXPECT_EQ(itDummyService1->seqClassAliases[0], "Dummy1");
EXPECT_EQ(itDummyService1->seqClassAliases[1], "DummySvc1");
EXPECT_EQ(itDummyService1->ssDefaultObjectName, "MyDummy");
EXPECT_EQ(itDummyService1->eType, sdv::EObjectType::ComplexService);
EXPECT_EQ(itDummyService1->eType, sdv::EObjectType::complex_service);
EXPECT_EQ(itDummyService1->uiFlags, static_cast<uint32_t>(sdv::EObjectFlags::singleton));
ASSERT_EQ(itDummyService1->seqDependencies.size(), 2);
EXPECT_EQ(itDummyService1->seqDependencies[0], "DummyDevice");
EXPECT_EQ(itDummyService1->seqDependencies[1], "DummyService #2");
auto itDummyDevice = std::find_if(
vecComponents.begin(), vecComponents.end(), [](const auto& sComponent) { return sComponent.ssClassName == "DummyDevice"; });
ASSERT_NE(itDummyDevice, vecComponents.end());
EXPECT_EQ(itDummyDevice->pathRelModule, "UnitTest_InstallPackageComposer_Component1.sdv");
auto itDummyService2 = std::find_if(vecComponents.begin(),
vecComponents.end(),
[](const auto& sComponent) { return sComponent.ssClassName == "DummyService #2"; });
ASSERT_NE(itDummyService2, vecComponents.end());
EXPECT_EQ(itDummyService2->pathRelModule, "UnitTest_InstallPackageComposer_Component2.sdv");
vecClasses.begin(), vecClasses.end(), [](const auto& sComponent) { return sComponent.ssName == "DummyDevice"; });
ASSERT_NE(itDummyDevice, vecClasses.end());
EXPECT_EQ(itDummyDevice->ssModulePath, "UnitTest_InstallPackageComposer_Component1.sdv");
auto itDummyService2 = std::find_if(vecClasses.begin(),
vecClasses.end(),
[](const auto& sComponent) { return sComponent.ssName == "DummyService #2"; });
ASSERT_NE(itDummyService2, vecClasses.end());
EXPECT_EQ(itDummyService2->ssModulePath, "UnitTest_InstallPackageComposer_Component2.sdv");
EXPECT_TRUE(manifestWrite.Save(pathTgtPckDir));
EXPECT_TRUE(std::filesystem::exists(pathTgtPckDir / "install_manifest.toml"));
@@ -444,32 +457,32 @@ TEST_F(CInstallManifestTest, SaveLoadComponents)
EXPECT_EQ(vecModules.size(), 2);
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "UnitTest_InstallPackageComposer_Component1.sdv"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "UnitTest_InstallPackageComposer_Component2.sdv"), vecModules.end());
vecComponents = manifestRead.ComponentList();
EXPECT_EQ(vecComponents.size(), 3);
itDummyService1 = std::find_if(vecComponents.begin(),
vecComponents.end(),
[](const auto& sComponent) { return sComponent.ssClassName == "DummyService #1"; });
ASSERT_NE(itDummyService1, vecComponents.end());
EXPECT_EQ(itDummyService1->pathRelModule, "UnitTest_InstallPackageComposer_Component1.sdv");
EXPECT_FALSE(itDummyService1->ssManifest.empty());
ASSERT_EQ(itDummyService1->seqAliases.size(), 2);
EXPECT_EQ(itDummyService1->seqAliases[0], "Dummy1");
EXPECT_EQ(itDummyService1->seqAliases[1], "DummySvc1");
vecClasses = manifestRead.ClassList();
EXPECT_EQ(vecClasses.size(), 3);
itDummyService1 = std::find_if(vecClasses.begin(),
vecClasses.end(),
[](const auto& sComponent) { return sComponent.ssName == "DummyService #1"; });
ASSERT_NE(itDummyService1, vecClasses.end());
EXPECT_EQ(itDummyService1->ssModulePath, "UnitTest_InstallPackageComposer_Component1.sdv");
//EXPECT_FALSE(itDummyService1->ssManifest.empty());
ASSERT_EQ(itDummyService1->seqClassAliases.size(), 2);
EXPECT_EQ(itDummyService1->seqClassAliases[0], "Dummy1");
EXPECT_EQ(itDummyService1->seqClassAliases[1], "DummySvc1");
EXPECT_EQ(itDummyService1->ssDefaultObjectName, "MyDummy");
EXPECT_EQ(itDummyService1->eType, sdv::EObjectType::ComplexService);
EXPECT_EQ(itDummyService1->eType, sdv::EObjectType::complex_service);
EXPECT_EQ(itDummyService1->uiFlags, static_cast<uint32_t>(sdv::EObjectFlags::singleton));
ASSERT_EQ(itDummyService1->seqDependencies.size(), 2);
EXPECT_EQ(itDummyService1->seqDependencies[0], "DummyDevice");
EXPECT_EQ(itDummyService1->seqDependencies[1], "DummyService #2");
itDummyDevice = std::find_if(
vecComponents.begin(), vecComponents.end(), [](const auto& sComponent) { return sComponent.ssClassName == "DummyDevice"; });
ASSERT_NE(itDummyDevice, vecComponents.end());
EXPECT_EQ(itDummyDevice->pathRelModule, "UnitTest_InstallPackageComposer_Component1.sdv");
itDummyService2 = std::find_if(vecComponents.begin(),
vecComponents.end(),
[](const auto& sComponent) { return sComponent.ssClassName == "DummyService #2"; });
ASSERT_NE(itDummyService2, vecComponents.end());
EXPECT_EQ(itDummyService2->pathRelModule, "UnitTest_InstallPackageComposer_Component2.sdv");
vecClasses.begin(), vecClasses.end(), [](const auto& sComponent) { return sComponent.ssName == "DummyDevice"; });
ASSERT_NE(itDummyDevice, vecClasses.end());
EXPECT_EQ(itDummyDevice->ssModulePath, "UnitTest_InstallPackageComposer_Component1.sdv");
itDummyService2 = std::find_if(vecClasses.begin(),
vecClasses.end(),
[](const auto& sComponent) { return sComponent.ssName == "DummyService #2"; });
ASSERT_NE(itDummyService2, vecClasses.end());
EXPECT_EQ(itDummyService2->ssModulePath, "UnitTest_InstallPackageComposer_Component2.sdv");
}
TEST_F(CInstallManifestTest, SaveLoadFindModules)
@@ -489,32 +502,32 @@ TEST_F(CInstallManifestTest, SaveLoadFindModules)
EXPECT_EQ(vecModules.size(), 2);
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "UnitTest_InstallPackageComposer_Component1.sdv"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "UnitTest_InstallPackageComposer_Component2.sdv"), vecModules.end());
auto vecComponents = manifestWrite.ComponentList();
EXPECT_EQ(vecComponents.size(), 3);
auto itDummyService1 = std::find_if(vecComponents.begin(),
vecComponents.end(),
[](const auto& sComponent) { return sComponent.ssClassName == "DummyService #1"; });
ASSERT_NE(itDummyService1, vecComponents.end());
EXPECT_EQ(itDummyService1->pathRelModule, "UnitTest_InstallPackageComposer_Component1.sdv");
EXPECT_FALSE(itDummyService1->ssManifest.empty());
ASSERT_EQ(itDummyService1->seqAliases.size(), 2);
EXPECT_EQ(itDummyService1->seqAliases[0], "Dummy1");
EXPECT_EQ(itDummyService1->seqAliases[1], "DummySvc1");
auto vecClasses = manifestWrite.ClassList();
EXPECT_EQ(vecClasses.size(), 3);
auto itDummyService1 = std::find_if(vecClasses.begin(),
vecClasses.end(),
[](const auto& sComponent) { return sComponent.ssName == "DummyService #1"; });
ASSERT_NE(itDummyService1, vecClasses.end());
EXPECT_EQ(itDummyService1->ssModulePath, "UnitTest_InstallPackageComposer_Component1.sdv");
//EXPECT_FALSE(itDummyService1->ssManifest.empty());
ASSERT_EQ(itDummyService1->seqClassAliases.size(), 2);
EXPECT_EQ(itDummyService1->seqClassAliases[0], "Dummy1");
EXPECT_EQ(itDummyService1->seqClassAliases[1], "DummySvc1");
EXPECT_EQ(itDummyService1->ssDefaultObjectName, "MyDummy");
EXPECT_EQ(itDummyService1->eType, sdv::EObjectType::ComplexService);
EXPECT_EQ(itDummyService1->eType, sdv::EObjectType::complex_service);
EXPECT_EQ(itDummyService1->uiFlags, static_cast<uint32_t>(sdv::EObjectFlags::singleton));
ASSERT_EQ(itDummyService1->seqDependencies.size(), 2);
EXPECT_EQ(itDummyService1->seqDependencies[0], "DummyDevice");
EXPECT_EQ(itDummyService1->seqDependencies[1], "DummyService #2");
auto itDummyDevice = std::find_if(
vecComponents.begin(), vecComponents.end(), [](const auto& sComponent) { return sComponent.ssClassName == "DummyDevice"; });
ASSERT_NE(itDummyDevice, vecComponents.end());
EXPECT_EQ(itDummyDevice->pathRelModule, "UnitTest_InstallPackageComposer_Component1.sdv");
auto itDummyService2 = std::find_if(vecComponents.begin(),
vecComponents.end(),
[](const auto& sComponent) { return sComponent.ssClassName == "DummyService #2"; });
ASSERT_NE(itDummyService2, vecComponents.end());
EXPECT_EQ(itDummyService2->pathRelModule, "UnitTest_InstallPackageComposer_Component2.sdv");
vecClasses.begin(), vecClasses.end(), [](const auto& sComponent) { return sComponent.ssName == "DummyDevice"; });
ASSERT_NE(itDummyDevice, vecClasses.end());
EXPECT_EQ(itDummyDevice->ssModulePath, "UnitTest_InstallPackageComposer_Component1.sdv");
auto itDummyService2 = std::find_if(vecClasses.begin(),
vecClasses.end(),
[](const auto& sComponent) { return sComponent.ssName == "DummyService #2"; });
ASSERT_NE(itDummyService2, vecClasses.end());
EXPECT_EQ(itDummyService2->ssModulePath, "UnitTest_InstallPackageComposer_Component2.sdv");
EXPECT_TRUE(manifestWrite.Save(pathTgtPckDir));
EXPECT_TRUE(std::filesystem::exists(pathTgtPckDir / "install_manifest.toml"));
@@ -544,32 +557,32 @@ TEST_F(CInstallManifestTest, SaveLoadFindComponents)
EXPECT_EQ(vecModules.size(), 2);
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "UnitTest_InstallPackageComposer_Component1.sdv"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "UnitTest_InstallPackageComposer_Component2.sdv"), vecModules.end());
auto vecComponents = manifestWrite.ComponentList();
EXPECT_EQ(vecComponents.size(), 3);
auto itDummyService1 = std::find_if(vecComponents.begin(),
vecComponents.end(),
[](const auto& sComponent) { return sComponent.ssClassName == "DummyService #1"; });
ASSERT_NE(itDummyService1, vecComponents.end());
EXPECT_EQ(itDummyService1->pathRelModule, "UnitTest_InstallPackageComposer_Component1.sdv");
EXPECT_FALSE(itDummyService1->ssManifest.empty());
ASSERT_EQ(itDummyService1->seqAliases.size(), 2);
EXPECT_EQ(itDummyService1->seqAliases[0], "Dummy1");
EXPECT_EQ(itDummyService1->seqAliases[1], "DummySvc1");
auto vecClasses = manifestWrite.ClassList();
EXPECT_EQ(vecClasses.size(), 3);
auto itDummyService1 = std::find_if(vecClasses.begin(),
vecClasses.end(),
[](const auto& sComponent) { return sComponent.ssName == "DummyService #1"; });
ASSERT_NE(itDummyService1, vecClasses.end());
EXPECT_EQ(itDummyService1->ssModulePath, "UnitTest_InstallPackageComposer_Component1.sdv");
//EXPECT_FALSE(itDummyService1->ssManifest.empty());
ASSERT_EQ(itDummyService1->seqClassAliases.size(), 2);
EXPECT_EQ(itDummyService1->seqClassAliases[0], "Dummy1");
EXPECT_EQ(itDummyService1->seqClassAliases[1], "DummySvc1");
EXPECT_EQ(itDummyService1->ssDefaultObjectName, "MyDummy");
EXPECT_EQ(itDummyService1->eType, sdv::EObjectType::ComplexService);
EXPECT_EQ(itDummyService1->eType, sdv::EObjectType::complex_service);
EXPECT_EQ(itDummyService1->uiFlags, static_cast<uint32_t>(sdv::EObjectFlags::singleton));
ASSERT_EQ(itDummyService1->seqDependencies.size(), 2);
EXPECT_EQ(itDummyService1->seqDependencies[0], "DummyDevice");
EXPECT_EQ(itDummyService1->seqDependencies[1], "DummyService #2");
auto itDummyDevice = std::find_if(
vecComponents.begin(), vecComponents.end(), [](const auto& sComponent) { return sComponent.ssClassName == "DummyDevice"; });
ASSERT_NE(itDummyDevice, vecComponents.end());
EXPECT_EQ(itDummyDevice->pathRelModule, "UnitTest_InstallPackageComposer_Component1.sdv");
auto itDummyService2 = std::find_if(vecComponents.begin(),
vecComponents.end(),
[](const auto& sComponent) { return sComponent.ssClassName == "DummyService #2"; });
ASSERT_NE(itDummyService2, vecComponents.end());
EXPECT_EQ(itDummyService2->pathRelModule, "UnitTest_InstallPackageComposer_Component2.sdv");
vecClasses.begin(), vecClasses.end(), [](const auto& sComponent) { return sComponent.ssName == "DummyDevice"; });
ASSERT_NE(itDummyDevice, vecClasses.end());
EXPECT_EQ(itDummyDevice->ssModulePath, "UnitTest_InstallPackageComposer_Component1.sdv");
auto itDummyService2 = std::find_if(vecClasses.begin(),
vecClasses.end(),
[](const auto& sComponent) { return sComponent.ssName == "DummyService #2"; });
ASSERT_NE(itDummyService2, vecClasses.end());
EXPECT_EQ(itDummyService2->ssModulePath, "UnitTest_InstallPackageComposer_Component2.sdv");
EXPECT_TRUE(manifestWrite.Save(pathTgtPckDir));
EXPECT_TRUE(std::filesystem::exists(pathTgtPckDir / "install_manifest.toml"));

13
tests/unit_tests/install_package_composer/package_version_tests.cpp
View File

@@ -1,3 +1,16 @@
/********************************************************************************
* Copyright (c) 2025-2026 ZF Friedrichshafen AG
*
* This program and the accompanying materials are made available under the
* terms of the Apache License Version 2.0 which is available at
* https://www.apache.org/licenses/LICENSE-2.0
*
* SPDX-License-Identifier: Apache-2.0
*
* Contributors:
* Erik Verhoeven - initial API and implementation
********************************************************************************/
#include <gtest/gtest.h>
#include "composer_test_suite.h"
#include "../../../sdv_services/core/installation_manifest.h"