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

Precommit (#1)

Browse Source 
* first commit

* cleanup
This commit is contained in:
tompzf
2025-11-04 13:28:06 +01:00
committed by GitHub
parent dba45dc636
commit 6ed4b1534e
898 changed files with 256340 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
tests/unit_tests/install_package_composer/CMakeLists.txt Normal file
View File

@@ -0,0 +1,76 @@
# Define project
project(InstallPackageComposerTests VERSION 1.0 LANGUAGES CXX)
# build component #1
add_library(UnitTest_InstallPackageComposer_Component1 SHARED
dummy_component1.cpp)
if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
target_link_options(UnitTest_InstallPackageComposer_Component1 PUBLIC -fPIC)
if (WIN32)
target_link_libraries(UnitTest_InstallPackageComposer_Component1 Ws2_32 Winmm Rpcrt4.lib)
else()
target_link_libraries(UnitTest_InstallPackageComposer_Component1 ${CMAKE_DL_LIBS} rt)
endif()
else()
target_link_libraries(UnitTest_InstallPackageComposer_Component1 Rpcrt4.lib)
endif()
set_target_properties(UnitTest_InstallPackageComposer_Component1 PROPERTIES PREFIX "")
set_target_properties(UnitTest_InstallPackageComposer_Component1 PROPERTIES SUFFIX ".sdv")
# build component #2
add_library(UnitTest_InstallPackageComposer_Component2 SHARED
dummy_component2.cpp)
if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
target_link_options(UnitTest_InstallPackageComposer_Component2 PUBLIC -fPIC)
if (WIN32)
target_link_libraries(UnitTest_InstallPackageComposer_Component2 Ws2_32 Winmm Rpcrt4.lib)
else()
target_link_libraries(UnitTest_InstallPackageComposer_Component2 ${CMAKE_DL_LIBS} rt)
endif()
else()
target_link_libraries(UnitTest_InstallPackageComposer_Component2 Rpcrt4.lib)
endif()
set_target_properties(UnitTest_InstallPackageComposer_Component2 PROPERTIES PREFIX "")
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
composer_tests.cpp
manifest_tests.cpp
environment_tests.cpp
package_version_tests.cpp
)
if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
target_link_libraries(UnitTest_InstallPackageComposer GTest::GTest)
if (WIN32)
target_link_libraries(UnitTest_InstallPackageComposer Ws2_32 Winmm Rpcrt4.lib)
else()
target_link_libraries(UnitTest_InstallPackageComposer ${CMAKE_DL_LIBS} rt)
endif()
else()
target_link_libraries(UnitTest_InstallPackageComposer GTest::GTest Rpcrt4.lib)
endif()
# Add the test
add_test(NAME UnitTest_InstallPackageComposer COMMAND UnitTest_InstallPackageComposer WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
# Execute the test
add_custom_command(TARGET UnitTest_InstallPackageComposer POST_BUILD
COMMAND ${CMAKE_COMMAND} -E env TEST_EXECUTION_MODE=CMake "$<TARGET_FILE:UnitTest_InstallPackageComposer>" --gtest_output=xml:${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/UnitTest_InstallPackageComposer.xml
VERBATIM
)
# TODO EVE
add_dependencies(UnitTest_InstallPackageComposer_Component1 dependency_sdv_components)
add_dependencies(UnitTest_InstallPackageComposer_Component2 dependency_sdv_components)
add_dependencies(UnitTest_InstallPackageComposer UnitTest_InstallPackageComposer_Component1)
add_dependencies(UnitTest_InstallPackageComposer UnitTest_InstallPackageComposer_Component2)
add_dependencies(UnitTest_InstallPackageComposer dependency_sdv_components)

537
tests/unit_tests/install_package_composer/composer_test_suite.cpp Normal file
View File

@@ -0,0 +1,537 @@
#include "composer_test_suite.h"
#include <filesystem>
#include <fstream>
#include <cstdlib>
#include <string>
#include "../../../global/process_watchdog.h"
#include "../../../global/exec_dir_helper.h"
#include "../../../sdv_services/core/installation_manifest.cpp"
#include "../../../sdv_services/core/installation_composer.cpp"
#include "../../../sdv_services/core/toml_parser/parser_toml.cpp"
#include "../../../sdv_services/core/toml_parser/lexer_toml.cpp"
#include "../../../sdv_services/core/toml_parser/parser_node_toml.cpp"
#include "../../../sdv_services/core/toml_parser/character_reader_utf_8.cpp"
#include <support/app_control.h>
#if defined(_WIN32) && defined(_UNICODE)
extern "C" int wmain(int argc, wchar_t* argv[])
#else
extern "C" int main(int argc, char* argv[])
#endif
{
CProcessWatchdog watchdog;
CLocalMemMgr memmgr;
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
void CInstallPackageComposerTest::SetUp()
{}
void CInstallPackageComposerTest::TearDown()
{
DeleteTargetTestDir();
}
void CInstallPackageComposerTest::SetUpTestCase()
{
DeleteTestDirs();
// Set the application installation directory
sdv::app::CAppControl::SetComponentInstallDirectory(GetExecDirectory() / "install_package_composer_targets");
// Make rand random
std::srand(static_cast<unsigned int>(std::time({})));
// Create test data
try
{
// Create a dummy file with at the given path.
auto fnCreateDummyFile = [](const std::filesystem::path& rpathFile, uint32_t uiMinSize = 0)
{
std::ofstream stream(rpathFile.native().c_str());
if (!stream.is_open())
{
std::cerr << "Could not open file '" << rpathFile.generic_u8string() << "'" << std::endl;
ASSERT_TRUE(false);
}
uint32_t uiTotalSize = 0;
do
{
uint32_t uiSize = std::rand() & 0x1ffff;
for (uint32_t uiVal = 0; uiVal < uiSize; uiVal++)
stream << uiVal;
uiTotalSize += uiSize * 4;
}
while (uiTotalSize < uiMinSize);
stream.close();
};
// The source directory
std::filesystem::path pathSrcDir = GetExecDirectory() / "install_package_composer_sources";
// Create dummy packages (one deliberately with a wrong extension)
std::filesystem::create_directories(pathSrcDir);
fnCreateDummyFile(pathSrcDir / "file1.sdv_package");
fnCreateDummyFile(pathSrcDir / "file2.sdv_package");
fnCreateDummyFile(pathSrcDir / "file3.sdvpackage");
fnCreateDummyFile(pathSrcDir / "config.toml");
// Create 10 dummy packages
std::filesystem::path pathSrcDummy = pathSrcDir / "dummy_package";
std::filesystem::create_directories(pathSrcDummy);
for (size_t n = 0; n < 10; n++)
fnCreateDummyFile(pathSrcDummy / (std::string("file") + std::to_string(n) + ".bin"));
// Create the following dummy packages:
// subdir1/file10.bin
// subdir1/file11.bin
// subdir2/file20.bin
// subdir2/file21.bin
// subdir2/file22.bia
// subdir3_xyz/file30.bin
// subdir3_xyz/file31.bin
// subdir3_xyz/file32a.bia
// subdir3_xyz/subdir4/file40a.bin
// subdir3_xyz/subdir4/subdir5/file50a.bin
std::filesystem::path pathSrcDummySubDir1 = pathSrcDummy / "subdir1";
std::filesystem::create_directories(pathSrcDummySubDir1);
fnCreateDummyFile(pathSrcDummySubDir1 / "file10.bin");
fnCreateDummyFile(pathSrcDummySubDir1 / "file11.bin");
std::filesystem::path pathSrcDummySubDir2 = pathSrcDummy / "subdir2";
std::filesystem::create_directories(pathSrcDummySubDir2);
fnCreateDummyFile(pathSrcDummySubDir2 / "file20.bin");
fnCreateDummyFile(pathSrcDummySubDir2 / "file21.bin");
fnCreateDummyFile(pathSrcDummySubDir2 / "file22.bia");
std::filesystem::path pathSrcDummySubDir3 = pathSrcDummy / "subdir3_xyz";
std::filesystem::create_directories(pathSrcDummySubDir3);
fnCreateDummyFile(pathSrcDummySubDir3 / "file30.bin");
fnCreateDummyFile(pathSrcDummySubDir3 / "file31.bin");
fnCreateDummyFile(pathSrcDummySubDir3 / "file32a.bia");
std::filesystem::path pathSrcDummySubDir4 = pathSrcDummySubDir3 / "subdir4";
std::filesystem::create_directories(pathSrcDummySubDir4);
fnCreateDummyFile(pathSrcDummySubDir4 / "file40a.bin");
std::filesystem::path pathSrcDummySubDir5 = pathSrcDummySubDir4 / "subdir5";
std::filesystem::create_directories(pathSrcDummySubDir5);
fnCreateDummyFile(pathSrcDummySubDir5 / "file50a.bin");
// Files for filename duplication test
std::filesystem::path pathSrcDummySubDir1b = pathSrcDummy / "subdir1b";
std::filesystem::create_directories(pathSrcDummySubDir1b);
fnCreateDummyFile(pathSrcDummySubDir1b / "file10.bin");
fnCreateDummyFile(pathSrcDummySubDir1b / "file11.bin");
// XXL-Files
std::filesystem::path pathSrcDummyXXL = pathSrcDummy / "xxl";
std::filesystem::create_directories(pathSrcDummyXXL);
fnCreateDummyFile(pathSrcDummyXXL / "fileXXLa.bin", 20*1024*1024);
fnCreateDummyFile(pathSrcDummyXXL / "fileXXLb.bin", 2*10124*1024);
// Files for file attribute and change time test
std::filesystem::path pathSrcDummyTimeAttr = pathSrcDummy / "time_attr";
std::filesystem::create_directories(pathSrcDummyTimeAttr);
// Create time (for Windows only)
#ifdef _WIN32
// Use the first presentation of the Comodore 64 (7th of January 1982)
std::tm sCreateTimeInfo{};
sCreateTimeInfo.tm_year = 82;
sCreateTimeInfo.tm_mon = 0;
sCreateTimeInfo.tm_mday = 7;
sCreateTimeInfo.tm_hour = 11;
sCreateTimeInfo.tm_min = 0;
sCreateTimeInfo.tm_sec = 0;
std::time_t tmCreateTime = _mkgmtime(&sCreateTimeInfo);
fnCreateDummyFile(pathSrcDummyTimeAttr / "create_time.bin");
SetCreateTime(pathSrcDummyTimeAttr / "create_time.bin", static_cast<uint64_t>(tmCreateTime) * 1000000ull);
#endif
// Change time
// Use the first presentation of the personal computer (12th of August 1981)
std::tm sChangeTimeInfo{};
sChangeTimeInfo.tm_year = 81;
sChangeTimeInfo.tm_mon = 7;
sChangeTimeInfo.tm_mday = 12;
sChangeTimeInfo.tm_hour = 9;
sChangeTimeInfo.tm_min = 0;
sChangeTimeInfo.tm_sec = 0;
#ifdef _WIN32
std::time_t tmChangeTime = _mkgmtime(&sChangeTimeInfo);
#else
std::time_t tmChangeTime = timegm(&sChangeTimeInfo);
#endif
fnCreateDummyFile(pathSrcDummyTimeAttr / "change_time.bin");
SetChangeTime(pathSrcDummyTimeAttr / "change_time.bin", static_cast<uint64_t>(tmChangeTime) * 1000000ull);
// Read only (for Windows and Linux only)
#if defined _WIN32 || (defined __linux__ && COMPOSER_SUPPORT_READONLY_LINUX)
fnCreateDummyFile(pathSrcDummyTimeAttr / "readonly.bin");
SetReadOnly(pathSrcDummyTimeAttr / "readonly.bin");
#endif
#ifdef __unix__
fnCreateDummyFile(pathSrcDummyTimeAttr / "executable.bin");
SetExecutable(pathSrcDummyTimeAttr / "executable.bin");
#endif
// Change times and attributes
fnCreateDummyFile(pathSrcDummyTimeAttr / "all.bin");
#ifdef _WIN32
SetCreateTime(pathSrcDummyTimeAttr / "all.bin", static_cast<uint64_t>(tmCreateTime) * 1000000ull);
#endif
SetChangeTime(pathSrcDummyTimeAttr / "all.bin", static_cast<uint64_t>(tmChangeTime) * 1000000ull);
#ifdef __unix__
SetExecutable(pathSrcDummyTimeAttr / "all.bin");
#endif
#if defined _WIN32 || (defined __linux__ && COMPOSER_SUPPORT_READONLY_LINUX)
SetReadOnly(pathSrcDummyTimeAttr / "all.bin");
#endif
}
catch (const std::filesystem::filesystem_error& rexception)
{
// Exception occurred.
std::cerr << "Filesystem exception occurred (create test data): " << rexception.what() << std::endl;
ASSERT_TRUE(false);
}
}
void CInstallPackageComposerTest::TearDownTestSuite()
{
DeleteTestDirs();
}
void CInstallPackageComposerTest::DeleteTargetTestDir()
{
try
{
std::filesystem::path pathTgtDir = GetExecDirectory() / "install_package_composer_targets";
if (!std::filesystem::exists(pathTgtDir)) return;
#if defined _WIN32 || (defined __linux__ && COMPOSER_SUPPORT_READONLY_LINUX)
auto vecFiles = CollectWildcardPath(pathTgtDir, "**/readonly.bin");
for (const auto& rpathFile : vecFiles)
ResetReadOnly(pathTgtDir / rpathFile);
vecFiles = CollectWildcardPath(pathTgtDir, "**/all.bin");
for (const auto& rpathFile : vecFiles)
ResetReadOnly(pathTgtDir / rpathFile);
#endif
std::filesystem::remove_all(pathTgtDir);
}
catch (const std::filesystem::filesystem_error& rexception)
{
// Exception occurred.
std::cerr << "Filesystem exception occurred (delete target test directories): " << rexception.what() << std::endl;
ASSERT_TRUE(false);
}
}
void CInstallPackageComposerTest::DeleteTestDirs()
{
try
{
std::filesystem::path pathSrcDir = GetExecDirectory() / "install_package_composer_sources/dummy_package";
if (!std::filesystem::exists(pathSrcDir)) return;
#if defined _WIN32 || (defined __linux__ && COMPOSER_SUPPORT_READONLY_LINUX)
if (std::filesystem::exists(pathSrcDir / "time_attr/readonly.bin"))
ResetReadOnly(pathSrcDir / "time_attr/readonly.bin");
if (std::filesystem::exists(pathSrcDir / "time_attr/all.bin"))
ResetReadOnly(pathSrcDir / "time_attr/all.bin");
#endif
std::filesystem::remove_all(pathSrcDir);
}
catch (const std::filesystem::filesystem_error& rexception)
{
// Exception occurred.
std::cerr << "Filesystem exception occurred (delete test directories): " << rexception.what() << std::endl;
ASSERT_TRUE(false);
}
DeleteTargetTestDir();
}
bool CInstallPackageComposerTest::AreFilesEqual(const std::filesystem::path& rpath1, const std::filesystem::path& rpath2,
bool bCheckTimes /*= false*/, bool bCheckAttributes /*= false*/)
{
std::ifstream stream1(rpath1.native().c_str());
if (!stream1.is_open()) return false;
std::ifstream stream2(rpath2.native().c_str());
if (!stream2.is_open()) return false;
sdv::pointer<uint8_t> ptrFile1 = sdv::from_stream(stream1.rdbuf());
sdv::pointer<uint8_t> ptrFile2 = sdv::from_stream(stream2.rdbuf());
if ((!ptrFile1 && ptrFile2) || (ptrFile1 && !ptrFile2)) return false;
if (ptrFile1.size() != ptrFile2.size()) return false;
if (!std::equal(ptrFile1.get(), ptrFile1.get() + ptrFile1.size(), ptrFile2.get())) return false;
// Check attributes
if (bCheckAttributes)
{
#if defined _WIN32 || (defined __linux__ && COMPOSER_SUPPORT_READONLY_LINUX)
if (IsReadOnly(rpath1) != IsReadOnly(rpath2)) return false;
#endif
#ifdef __unix__
if (IsExecutable(rpath1) != IsExecutable(rpath2)) return false;
#endif
}
// File time and attributes
if (bCheckTimes)
{
#ifdef _WIN32
if (GetCreateTime(rpath1) != GetCreateTime(rpath2)) return false;
#endif
if (GetChangeTime(rpath1) != GetChangeTime(rpath2)) return false;
}
// Content, times and attributes are equal.
return true;
}
#ifdef _WIN32
void CInstallPackageComposerTest::SetReadOnly(const std::filesystem::path& rpathFile)
{
// Get the file attributes
WIN32_FILE_ATTRIBUTE_DATA sFileAttr{};
if (!GetFileAttributesExW(rpathFile.native().c_str(), GetFileExInfoStandard, &sFileAttr))
return;
// Set the file attributes
SetFileAttributesW(rpathFile.native().c_str(), sFileAttr.dwFileAttributes | FILE_ATTRIBUTE_READONLY);
}
void CInstallPackageComposerTest::ResetReadOnly(const std::filesystem::path& rpathFile)
{
// Get the file attributes
WIN32_FILE_ATTRIBUTE_DATA sFileAttr{};
if (!GetFileAttributesExW(rpathFile.native().c_str(), GetFileExInfoStandard, &sFileAttr))
return;
// Set the file attributes
SetFileAttributesW(rpathFile.native().c_str(), sFileAttr.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY);
}
bool CInstallPackageComposerTest::IsReadOnly(const std::filesystem::path& rpathFile)
{
WIN32_FILE_ATTRIBUTE_DATA sFileAttr{};
if (!GetFileAttributesExW(rpathFile.native().c_str(), GetFileExInfoStandard, &sFileAttr))
return false;
return sFileAttr.dwFileAttributes & FILE_ATTRIBUTE_READONLY ? true : false;
}
#elif defined __linux__ && COMPOSER_SUPPORT_READONLY_LINUX
void CInstallPackageComposerTest::SetReadOnly(const std::filesystem::path& rpathFile)
{
// Enable the immutable capability
cap_t caps = cap_get_proc();
{
perror("cap_get_proc error");
sdv::XCannotChangeFileTimesOrAttributes exception;
exception.ssPath = pathFile.generic_u8string();
throw exception;
}
cap_value_t capList[1] = {CAP_LINUX_IMMUTABLE};
if (cap_set_flag(caps, CAP_EFFECTIVE, 1, capList, CAP_SET) == -1)
{
perror("cap_set_flag error");
cap_free(caps);
sdv::XCannotChangeFileTimesOrAttributes exception;
exception.ssPath = pathFile.generic_u8string();
throw exception;
}
// Set the immutable flag
int fd = open(pathFile.native().c_str(), O_RDONLY);
if (fd == -1)
{
cap_free(caps);
sdv::XCannotChangeFileTimesOrAttributes exception;
exception.ssPath = pathFile.generic_u8string();
throw exception;
}
int flags = 0;
if (ioctl(fd, FS_IOC_GETFLAGS, &flags) == -1)
{
perror("ioctl error");
cap_free(caps);
close(fd);
sdv::XCannotChangeFileTimesOrAttributes exception;
exception.ssPath = pathFile.generic_u8string();
throw exception;
}
flags |= FS_IMMUTABLE_FL;
if (ioctl(fd, FS_IOC_SETFLAGS, &flags) == -1)
{
cap_free(caps);
close(fd);
sdv::XCannotChangeFileTimesOrAttributes exception;
exception.ssPath = pathFile.generic_u8string();
throw exception;
}
close(fd);
cap_free(caps);
}
void CInstallPackageComposerTest::ResetReadOnly(const std::filesystem::path& rpathFile)
{
// Enable the immutable capability
cap_t caps = cap_get_proc();
{
perror("cap_get_proc error");
sdv::XCannotChangeFileTimesOrAttributes exception;
exception.ssPath = pathFile.generic_u8string();
throw exception;
}
cap_value_t capList[1] = {CAP_LINUX_IMMUTABLE};
if (cap_set_flag(caps, CAP_EFFECTIVE, 1, capList, CAP_SET) == -1)
{
perror("cap_set_flag error");
cap_free(caps);
sdv::XCannotChangeFileTimesOrAttributes exception;
exception.ssPath = pathFile.generic_u8string();
throw exception;
}
// Set the immutable flag
int fd = open(pathFile.native().c_str(), O_RDONLY);
if (fd == -1)
{
cap_free(caps);
sdv::XCannotChangeFileTimesOrAttributes exception;
exception.ssPath = pathFile.generic_u8string();
throw exception;
}
int flags = 0;
if (ioctl(fd, FS_IOC_GETFLAGS, &flags) == -1)
{
perror("ioctl error");
cap_free(caps);
close(fd);
sdv::XCannotChangeFileTimesOrAttributes exception;
exception.ssPath = pathFile.generic_u8string();
throw exception;
}
flags &= ~FS_IMMUTABLE_FL;
if (ioctl(fd, FS_IOC_SETFLAGS, &flags) == -1)
{
cap_free(caps);
close(fd);
sdv::XCannotChangeFileTimesOrAttributes exception;
exception.ssPath = pathFile.generic_u8string();
throw exception;
}
close(fd);
cap_free(caps);
}
bool CInstallPackageComposerTest::IsReadOnly(const std::filesystem::path& rpathFile)
{
struct statx sStat{};
sStat.stx_mask = STATX_BTIME | STATX_MTIME;
if (statx(0, rsModuleEntry.pathSrcModule.native().c_str(), 0, STATX_BTIME | STATX_MTIME, &sStat) ||
sStat.stx_btime.tv_sec > 2524608000 || sStat.stx_btime.tv_nsec > 999999999 || sStat.stx_mtime.tv_sec > 2524608000 ||
sStat.stx_mtime.tv_nsec > 999999999)
return false;
return sStat.stx_attributes_mask & STATX_ATTR_IMMUTABLE && sStat.stx_attributes & STATX_ATTR_IMMUTABLE;
}
#endif
#ifdef __unix__
void CInstallPackageComposerTest::SetExecutable(const std::filesystem::path& rpathFile)
{
chmod(rpathFile.native().c_str(), S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
}
bool CInstallPackageComposerTest::IsExecutable(const std::filesystem::path& rpathFile)
{
struct stat sStat{};
if (stat(rpathFile.native().c_str(), &sStat) == 0 && S_ISREG(sStat.st_mode))
{
// Check if any execute bit is set
return (sStat.st_mode & S_IXUSR) || (sStat.st_mode & S_IXGRP) || (sStat.st_mode & S_IXOTH);
}
return false;
}
#endif
#ifdef _WIN32
void CInstallPackageComposerTest::SetCreateTime(const std::filesystem::path& rpathFile, uint64_t uiTimeMicrosec)
{
// Get the file times
WIN32_FILE_ATTRIBUTE_DATA sFileAttr{};
if (!GetFileAttributesExW(rpathFile.native().c_str(), GetFileExInfoStandard, &sFileAttr))
return;
// Set file times
HANDLE hFile = CreateFile(rpathFile.native().c_str(), FILE_WRITE_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == INVALID_HANDLE_VALUE) return;
FILETIME sCreationTime = PosixTimeToWindowsTime(uiTimeMicrosec);
FILETIME sAccessTime = sFileAttr.ftLastAccessTime;
FILETIME sWriteTime = sFileAttr.ftLastWriteTime;
SetFileTime(hFile, &sCreationTime, &sAccessTime, &sWriteTime);
CloseHandle(hFile);
}
uint64_t CInstallPackageComposerTest::GetCreateTime(const std::filesystem::path& rpathFile)
{
WIN32_FILE_ATTRIBUTE_DATA sFileAttr{};
if (!GetFileAttributesExW(rpathFile.native().c_str(), GetFileExInfoStandard, &sFileAttr))
return 0ull;
return WindowsTimeToPosixTime(sFileAttr.ftCreationTime);
}
void CInstallPackageComposerTest::SetChangeTime(const std::filesystem::path& rpathFile, uint64_t uiTimeMicrosec)
{
// Get the file times
WIN32_FILE_ATTRIBUTE_DATA sFileAttr{};
if (!GetFileAttributesExW(rpathFile.native().c_str(), GetFileExInfoStandard, &sFileAttr))
return;
// Set file times
HANDLE hFile = CreateFile(rpathFile.native().c_str(), FILE_WRITE_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == INVALID_HANDLE_VALUE) return;
FILETIME sCreationTime = sFileAttr.ftCreationTime;
FILETIME sAccessTime = sFileAttr.ftLastAccessTime;
FILETIME sWriteTime = PosixTimeToWindowsTime(uiTimeMicrosec);
SetFileTime(hFile, &sCreationTime, &sAccessTime, &sWriteTime);
CloseHandle(hFile);
}
uint64_t CInstallPackageComposerTest::GetChangeTime(const std::filesystem::path& rpathFile)
{
WIN32_FILE_ATTRIBUTE_DATA sFileAttr{};
if (!GetFileAttributesExW(rpathFile.native().c_str(), GetFileExInfoStandard, &sFileAttr))
return 0ull;
return WindowsTimeToPosixTime(sFileAttr.ftLastWriteTime);
}
#else
void CInstallPackageComposerTest::SetChangeTime(const std::filesystem::path& rpathFile, uint64_t uiTimeMicrosec)
{
struct timespec sTimes[2] = {};
sTimes[0].tv_sec = static_cast<time_t>(uiTimeMicrosec / 1000000ull); // Set access to change time
sTimes[0].tv_nsec = uiTimeMicrosec % 1000000ull * 1000ull;
sTimes[1].tv_sec = static_cast<time_t>(uiTimeMicrosec / 1000000ull); // Set modification time to change time
sTimes[1].tv_nsec = uiTimeMicrosec % 1000000ull * 1000ull;
// Test for illegal time values... tv_sec should be below 1st of January 2050; tv_nsec should be below or equal to 999999999.
if (sTimes[0].tv_sec >= 2524608000 || sTimes[0].tv_nsec > 999999999)
return;
// Set the times
utimensat(AT_FDCWD, rpathFile.native().c_str(), sTimes, 0);
}
uint64_t CInstallPackageComposerTest::GetChangeTime(const std::filesystem::path& rpathFile)
{
// Test for illegal time values... tv_sec should be below 1st of January 2050; tv_nsec should be below or equal to 999999999.
struct stat sStat{};
if (stat(rpathFile.u8string().c_str(), &sStat) || sStat.st_mtim.tv_sec >= 2524608000 ||
sStat.st_mtim.tv_nsec > 999999999)
return 0;
return static_cast<uint64_t>(sStat.st_mtim.tv_sec) * 1000000ull + static_cast<uint64_t>(sStat.st_mtim.tv_nsec) / 1000ull;
}
#endif

135
tests/unit_tests/install_package_composer/composer_test_suite.h Normal file
View File

@@ -0,0 +1,135 @@
#ifndef COMPOSER_TEST_SUITE_H
#define COMPOSER_TEST_SUITE_H
#include <gtest/gtest.h>
#include <filesystem>
#include <regex>
#include <string>
#include "../../../global/localmemmgr.h"
namespace sdv
{
namespace core
{
using TModuleID = uint64_t;
}
}
/**
* @brief Install package composer test suite class.
*/
class CInstallPackageComposerTest : public ::testing::Test
{
public:
/**
* @brief Setup test test
*/
virtual void SetUp();
/**
* @brief Tear down test
*/
virtual void TearDown();
/**
* @brief Setup test case
*/
static void SetUpTestCase();
/**
* @brief Tear down test case
*/
static void TearDownTestSuite();
/**
* @brief Delete target test directory
*/
static void DeleteTargetTestDir();
/**
* @brief Delete all test directories
*/
static void DeleteTestDirs();
/**
* @brief Check whether the content of one file is identical to the content of the other file.
* @param[in] rpath1 Reference to the path of the first file.
* @param[in] rpath2 Reference to the path of the second file.
* @param[in] bCheckTimes Check creation and change times (if supported by OS).
* @param[in] bCheckAttributes Check file attributes (if asupported by OS).
* @return Returns wether the files are identical and if requested times and attributes fit.
*/
bool AreFilesEqual(const std::filesystem::path& rpath1, const std::filesystem::path& rpath2, bool bCheckTimes = false,
bool bCheckAttributes = false);
#if defined _WIN32 || (defined __linux__ && COMPOSER_SUPPORT_READONLY_LINUX)
/**
* @brief Set the file to read-only.
* @param[in] rpathFile Reference to the path of the file.
*/
static void SetReadOnly(const std::filesystem::path& rpathFile);
/**
* @brief Set the file to writable.
* @param[in] rpathFile Reference to the path of the file.
*/
static void ResetReadOnly(const std::filesystem::path& rpathFile);
/**
* @brief Get the file read-only-state.
* @param[in] rpathFile Reference to the path of the file.
*/
static bool IsReadOnly(const std::filesystem::path& rpathFile);
#endif
#ifdef __unix__
/**
* @brief Set the file to executable.
* @remarks Not available for Windows.
* @param[in] rpathFile Reference to the path of the file.
*/
static void SetExecutable(const std::filesystem::path& rpathFile);
/**
* @brief Get the file to executable state.
* @remarks Not available for WIndows.
* @param[in] rpathFile Reference to the path of the file.
*/
static bool IsExecutable(const std::filesystem::path& rpathFile);
#endif
#ifdef _WIN32
/**
* @brief Set the file creation time.
* @remarks Only available for Windows.
* @param[in] rpathFile Reference to the path of the file.
* @param[in] uiTimeMicrosec The unix epoch time in microseconds.
*/
static void SetCreateTime(const std::filesystem::path& rpathFile, uint64_t uiTimeMicrosec);
/**
* @brief Get the file creation time.
* @remarks Only available for Windows.
* @param[in] rpathFile Reference to the path of the file.
* @return Returns the unix epoch time in microseconds.
*/
static uint64_t GetCreateTime(const std::filesystem::path& rpathFile);
#endif
/**
* @brief Set the file change time.
* @param[in] rpathFile Reference to the path of the file.
* @param[in] uiTimeMicrosec The unix epoch time in microseconds.
*/
static void SetChangeTime(const std::filesystem::path& rpathFile, uint64_t uiTimeMicrosec);
/**
* @brief Get the file change time.
* @param[in] rpathFile Reference to the path of the file.
* @return Returns the unix epoch time in microseconds.
*/
static uint64_t GetChangeTime(const std::filesystem::path& rpathFile);
};
#endif // !defined COMPOSER_TEST_SUITE_H

3599
tests/unit_tests/install_package_composer/composer_tests.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

35
tests/unit_tests/install_package_composer/dummy_component1.cpp Normal file
View File

@@ -0,0 +1,35 @@
#include <support/component_impl.h>
/**
* @brief Dummy service class with loads of extra settings-
*/
class CDummyService1 : public sdv::CSdvObject
{
public:
BEGIN_SDV_INTERFACE_MAP()
END_SDV_INTERFACE_MAP()
DECLARE_OBJECT_CLASS_TYPE(sdv::EObjectType::ComplexService)
DECLARE_OBJECT_CLASS_NAME("DummyService #1")
DECLARE_OBJECT_CLASS_ALIAS("Dummy1", "DummySvc1")
DECLARE_DEFAULT_OBJECT_NAME("MyDummy")
DECLARE_OBJECT_SINGLETON()
DECLARE_OBJECT_DEPENDENCIES("DummyDevice", "DummyService #2")
};
DEFINE_SDV_OBJECT(CDummyService1)
/**
* @brief Dummy device class.
*/
class CDummyDevice : public sdv::CSdvObject
{
public:
BEGIN_SDV_INTERFACE_MAP()
END_SDV_INTERFACE_MAP()
DECLARE_OBJECT_CLASS_TYPE(sdv::EObjectType::Device)
DECLARE_OBJECT_CLASS_NAME("DummyDevice")
};
DEFINE_SDV_OBJECT(CDummyDevice)

14
tests/unit_tests/install_package_composer/dummy_component2.cpp Normal file
View File

@@ -0,0 +1,14 @@
#include <support/component_impl.h>
class CDummyService2 : public sdv::CSdvObject
{
public:
BEGIN_SDV_INTERFACE_MAP()
END_SDV_INTERFACE_MAP()
DECLARE_OBJECT_CLASS_TYPE(sdv::EObjectType::ComplexService)
DECLARE_OBJECT_CLASS_NAME("DummyService #2")
};
DEFINE_SDV_OBJECT(CDummyService2)

2023
tests/unit_tests/install_package_composer/environment_tests.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

585
tests/unit_tests/install_package_composer/manifest_tests.cpp Normal file
View File

@@ -0,0 +1,585 @@
#include <gtest/gtest.h>
#include "composer_test_suite.h"
#include "../../../global/exec_dir_helper.h"
#include "../../../sdv_services/core/installation_manifest.h"
using CInstallManifestTest = CInstallPackageComposerTest;
TEST_F(CInstallManifestTest, Create)
{
CInstallManifest manifest;
EXPECT_FALSE(manifest.IsValid());
manifest.Create("Hello");
EXPECT_TRUE(manifest.IsValid());
}
TEST_F(CInstallManifestTest, WriteReadEmpty)
{
CInstallManifest manifestWrite;
manifestWrite.Create("Hello");
EXPECT_TRUE(manifestWrite.IsValid());
std::string ssManifest = manifestWrite.Write();
EXPECT_FALSE(ssManifest.empty());
CInstallManifest manifestRead;
manifestRead.Read(ssManifest);
EXPECT_TRUE(manifestRead.IsValid());
EXPECT_EQ(manifestRead.InstallName(), "Hello");
}
TEST_F(CInstallManifestTest, WriteReadProperties)
{
CInstallManifest manifestWrite;
manifestWrite.Create("Hello");
EXPECT_TRUE(manifestWrite.IsValid());
for (size_t n = 0; n < 10; n++)
manifestWrite.Property(std::string("Property_") + std::to_string(n), std::to_string(n));
for (size_t n = 0; n < 10; n++)
EXPECT_EQ(*manifestWrite.Property(std::string("Property_") + std::to_string(n)), std::to_string(n));
EXPECT_FALSE(manifestWrite.Property("Property_10"));
manifestWrite.Property("Version", "1.2.3.4abc");
EXPECT_EQ(manifestWrite.Version().uiMajor, 1u);
EXPECT_EQ(manifestWrite.Version().uiMinor, 2u);
EXPECT_EQ(manifestWrite.Version().uiPatch, 3u);
std::string ssManifest = manifestWrite.Write();
EXPECT_FALSE(ssManifest.empty());
CInstallManifest manifestRead;
manifestRead.Read(ssManifest);
EXPECT_TRUE(manifestRead.IsValid());
for (size_t n = 0; n < 10; n++)
EXPECT_EQ(*manifestRead.Property(std::string("Property_") + std::to_string(n)), std::to_string(n));
auto vecProperties = manifestRead.PropertyList();
for (size_t n = 0; n < 10; n++)
{
auto itProperty = std::find_if(vecProperties.begin(),
vecProperties.end(),
[&](const auto& prProperty) { return prProperty.first == std::string("Property_") + std::to_string(n); });
EXPECT_NE(itProperty, vecProperties.end());
}
EXPECT_EQ(manifestRead.Version().uiMajor, 1u);
EXPECT_EQ(manifestRead.Version().uiMinor, 2u);
EXPECT_EQ(manifestRead.Version().uiPatch, 3u);
}
TEST_F(CInstallManifestTest, WriteReadModules)
{
// Source and target directories
std::filesystem::path pathSrcFileDir = GetExecDirectory() / "install_package_composer_sources" / "dummy_package";
CInstallManifest manifestWrite;
manifestWrite.Create("Hello");
EXPECT_TRUE(manifestWrite.IsValid());
for (size_t n = 0; n < 10; n++)
{
std::filesystem::path pathModule = std::string("file") + std::to_string(n) + ".bin";
EXPECT_TRUE(manifestWrite.AddModule(pathSrcFileDir / pathModule));
}
auto vecModules = manifestWrite.ModuleList();
EXPECT_EQ(vecModules.size(), 10);
for (size_t n = 0; n < 10; n++)
{
std::filesystem::path pathModule = std::string("file") + std::to_string(n) + ".bin";
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), pathModule), vecModules.end());
}
std::string ssManifest = manifestWrite.Write();
EXPECT_FALSE(ssManifest.empty());
CInstallManifest manifestRead;
manifestRead.Read(ssManifest);
EXPECT_TRUE(manifestRead.IsValid());
vecModules = manifestRead.ModuleList();
EXPECT_EQ(vecModules.size(), 10);
for (size_t n = 0; n < 10; n++)
{
std::filesystem::path pathModule = std::string("file") + std::to_string(n) + ".bin";
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), pathModule), vecModules.end());
}
}
TEST_F(CInstallManifestTest, WriteReadModulesSubdirs)
{
// Source and target directories
std::filesystem::path pathSrcFileDir = GetExecDirectory() / "install_package_composer_sources" / "dummy_package";
CInstallManifest manifestWrite;
manifestWrite.Create("Hello");
EXPECT_TRUE(manifestWrite.IsValid());
EXPECT_TRUE(manifestWrite.AddModule(pathSrcFileDir / "file0.bin"));
EXPECT_TRUE(manifestWrite.AddModule(pathSrcFileDir / "file1.bin", "subdir"));
EXPECT_TRUE(manifestWrite.AddModule(pathSrcFileDir / "subdir1/file10.bin", "subdir"));
EXPECT_TRUE(manifestWrite.AddModule(pathSrcFileDir / "subdir1/file11.bin", "subdir"));
EXPECT_TRUE(manifestWrite.AddModule(pathSrcFileDir / "subdir2/file20.bin", "subdir"));
auto vecModules = manifestWrite.ModuleList();
EXPECT_EQ(vecModules.size(), 5);
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "file0.bin"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "subdir/file1.bin"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "subdir/file10.bin"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "subdir/file11.bin"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "subdir/file20.bin"), vecModules.end());
std::string ssManifest = manifestWrite.Write();
EXPECT_FALSE(ssManifest.empty());
CInstallManifest manifestRead;
manifestRead.Read(ssManifest);
EXPECT_TRUE(manifestRead.IsValid());
vecModules = manifestRead.ModuleList();
EXPECT_EQ(vecModules.size(), 5);
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "file0.bin"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "subdir/file1.bin"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "subdir/file10.bin"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "subdir/file11.bin"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "subdir/file20.bin"), vecModules.end());
}
TEST_F(CInstallManifestTest, WriteReadComponents)
{
// Source and target directories
std::filesystem::path pathSrcFileDir = GetExecDirectory();
CInstallManifest manifestWrite;
manifestWrite.Create("Hello");
EXPECT_TRUE(manifestWrite.IsValid());
EXPECT_TRUE(manifestWrite.AddModule(pathSrcFileDir / "UnitTest_InstallPackageComposer_Component1.sdv"));
EXPECT_TRUE(manifestWrite.AddModule(pathSrcFileDir / "UnitTest_InstallPackageComposer_Component2.sdv"));
auto vecModules = manifestWrite.ModuleList();
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");
EXPECT_EQ(itDummyService1->ssDefaultObjectName, "MyDummy");
EXPECT_EQ(itDummyService1->eType, sdv::EObjectType::ComplexService);
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");
std::string ssManifest = manifestWrite.Write();
EXPECT_FALSE(ssManifest.empty());
CInstallManifest manifestRead;
manifestRead.Read(ssManifest);
EXPECT_TRUE(manifestRead.IsValid());
vecModules = manifestRead.ModuleList();
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");
EXPECT_EQ(itDummyService1->ssDefaultObjectName, "MyDummy");
EXPECT_EQ(itDummyService1->eType, sdv::EObjectType::ComplexService);
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");
}
TEST_F(CInstallManifestTest, WriteReadFindComponents)
{
// Source and target directories
std::filesystem::path pathSrcFileDir = GetExecDirectory();
CInstallManifest manifestWrite;
manifestWrite.Create("Hello");
EXPECT_TRUE(manifestWrite.IsValid());
EXPECT_TRUE(manifestWrite.AddModule(pathSrcFileDir / "UnitTest_InstallPackageComposer_Component1.sdv"));
EXPECT_TRUE(manifestWrite.AddModule(pathSrcFileDir / "UnitTest_InstallPackageComposer_Component2.sdv"));
auto vecModules = manifestWrite.ModuleList();
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");
EXPECT_EQ(itDummyService1->ssDefaultObjectName, "MyDummy");
EXPECT_EQ(itDummyService1->eType, sdv::EObjectType::ComplexService);
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");
std::string ssManifest = manifestWrite.Write();
EXPECT_FALSE(ssManifest.empty());
CInstallManifest manifestRead;
manifestRead.Read(ssManifest);
EXPECT_TRUE(manifestRead.IsValid());
EXPECT_TRUE(manifestRead.FindComponentByClass("DummyService #1"));
EXPECT_TRUE(manifestRead.FindComponentByClass("Dummy1"));
EXPECT_TRUE(manifestRead.FindComponentByClass("DummySvc1"));
EXPECT_TRUE(manifestRead.FindComponentByClass("DummyDevice"));
EXPECT_TRUE(manifestRead.FindComponentByClass("DummyService #2"));
EXPECT_FALSE(manifestRead.FindComponentByClass("DummyServer #3"));
}
TEST_F(CInstallManifestTest, SaveLoadEmpty)
{
// Target directory
std::filesystem::path pathTgtPckDir = GetExecDirectory() / "install_package_composer_targets";
std::filesystem::create_directories(pathTgtPckDir);
EXPECT_FALSE(std::filesystem::exists(pathTgtPckDir / "install_manifest.toml"));
CInstallManifest manifestWrite;
manifestWrite.Create("Hello");
EXPECT_TRUE(manifestWrite.IsValid());
EXPECT_TRUE(manifestWrite.Save(pathTgtPckDir));
EXPECT_TRUE(std::filesystem::exists(pathTgtPckDir / "install_manifest.toml"));
EXPECT_EQ(manifestWrite.InstallDir(), pathTgtPckDir);
CInstallManifest manifestRead;
manifestRead.Load(pathTgtPckDir);
EXPECT_TRUE(manifestRead.IsValid());
EXPECT_EQ(manifestRead.InstallName(), "Hello");
EXPECT_EQ(manifestRead.InstallDir(), pathTgtPckDir);
}
TEST_F(CInstallManifestTest, SaveLoadProperties)
{
// Target directory
std::filesystem::path pathTgtPckDir = GetExecDirectory() / "install_package_composer_targets";
std::filesystem::create_directories(pathTgtPckDir);
EXPECT_FALSE(std::filesystem::exists(pathTgtPckDir / "install_manifest.toml"));
CInstallManifest manifestWrite;
manifestWrite.Create("Hello");
EXPECT_TRUE(manifestWrite.IsValid());
for (size_t n = 0; n < 10; n++)
manifestWrite.Property(std::string("Property_") + std::to_string(n), std::to_string(n));
for (size_t n = 0; n < 10; n++)
EXPECT_EQ(*manifestWrite.Property(std::string("Property_") + std::to_string(n)), std::to_string(n));
EXPECT_FALSE(manifestWrite.Property("Property_10"));
manifestWrite.Property("Version", "1.2.3.4abc");
EXPECT_EQ(manifestWrite.Version().uiMajor, 1u);
EXPECT_EQ(manifestWrite.Version().uiMinor, 2u);
EXPECT_EQ(manifestWrite.Version().uiPatch, 3u);
EXPECT_TRUE(manifestWrite.Save(pathTgtPckDir));
EXPECT_TRUE(std::filesystem::exists(pathTgtPckDir / "install_manifest.toml"));
CInstallManifest manifestRead;
manifestRead.Load(pathTgtPckDir);
EXPECT_TRUE(manifestRead.IsValid());
for (size_t n = 0; n < 10; n++)
EXPECT_EQ(*manifestRead.Property(std::string("Property_") + std::to_string(n)), std::to_string(n));
auto vecProperties = manifestRead.PropertyList();
for (size_t n = 0; n < 10; n++)
{
auto itProperty = std::find_if(vecProperties.begin(),
vecProperties.end(),
[&](const auto& prProperty) { return prProperty.first == std::string("Property_") + std::to_string(n); });
EXPECT_NE(itProperty, vecProperties.end());
}
EXPECT_EQ(manifestRead.Version().uiMajor, 1u);
EXPECT_EQ(manifestRead.Version().uiMinor, 2u);
EXPECT_EQ(manifestRead.Version().uiPatch, 3u);
}
TEST_F(CInstallManifestTest, SaveLoadModules)
{
// Source and target directories
std::filesystem::path pathSrcFileDir = GetExecDirectory() / "install_package_composer_sources" / "dummy_package";
std::filesystem::path pathTgtPckDir = GetExecDirectory() / "install_package_composer_targets";
std::filesystem::create_directories(pathTgtPckDir);
EXPECT_FALSE(std::filesystem::exists(pathTgtPckDir / "install_manifest.toml"));
CInstallManifest manifestWrite;
manifestWrite.Create("Hello");
EXPECT_TRUE(manifestWrite.IsValid());
for (size_t n = 0; n < 10; n++)
{
std::filesystem::path pathModule = std::string("file") + std::to_string(n) + ".bin";
EXPECT_TRUE(manifestWrite.AddModule(pathSrcFileDir / pathModule));
}
auto vecModules = manifestWrite.ModuleList();
EXPECT_EQ(vecModules.size(), 10);
for (size_t n = 0; n < 10; n++)
{
std::filesystem::path pathModule = std::string("file") + std::to_string(n) + ".bin";
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), pathModule), vecModules.end());
}
EXPECT_TRUE(manifestWrite.Save(pathTgtPckDir));
EXPECT_TRUE(std::filesystem::exists(pathTgtPckDir / "install_manifest.toml"));
CInstallManifest manifestRead;
manifestRead.Load(pathTgtPckDir);
EXPECT_TRUE(manifestRead.IsValid());
vecModules = manifestRead.ModuleList();
EXPECT_EQ(vecModules.size(), 10);
for (size_t n = 0; n < 10; n++)
{
std::filesystem::path pathModule = std::string("file") + std::to_string(n) + ".bin";
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), pathModule), vecModules.end());
}
}
TEST_F(CInstallManifestTest, SaveLoadModulesSubdirs)
{
// Source and target directories
std::filesystem::path pathSrcFileDir = GetExecDirectory() / "install_package_composer_sources" / "dummy_package";
std::filesystem::path pathTgtPckDir = GetExecDirectory() / "install_package_composer_targets";
std::filesystem::create_directories(pathTgtPckDir);
EXPECT_FALSE(std::filesystem::exists(pathTgtPckDir / "install_manifest.toml"));
CInstallManifest manifestWrite;
manifestWrite.Create("Hello");
EXPECT_TRUE(manifestWrite.IsValid());
EXPECT_TRUE(manifestWrite.AddModule(pathSrcFileDir / "file0.bin"));
EXPECT_TRUE(manifestWrite.AddModule(pathSrcFileDir / "file1.bin", "subdir"));
EXPECT_TRUE(manifestWrite.AddModule(pathSrcFileDir / "subdir1/file10.bin", "subdir"));
EXPECT_TRUE(manifestWrite.AddModule(pathSrcFileDir / "subdir1/file11.bin", "subdir"));
EXPECT_TRUE(manifestWrite.AddModule(pathSrcFileDir / "subdir2/file20.bin", "subdir"));
auto vecModules = manifestWrite.ModuleList();
EXPECT_EQ(vecModules.size(), 5);
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "file0.bin"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "subdir/file1.bin"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "subdir/file10.bin"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "subdir/file11.bin"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "subdir/file20.bin"), vecModules.end());
EXPECT_TRUE(manifestWrite.Save(pathTgtPckDir));
EXPECT_TRUE(std::filesystem::exists(pathTgtPckDir / "install_manifest.toml"));
CInstallManifest manifestRead;
manifestRead.Load(pathTgtPckDir);
EXPECT_TRUE(manifestRead.IsValid());
vecModules = manifestRead.ModuleList();
EXPECT_EQ(vecModules.size(), 5);
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "file0.bin"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "subdir/file1.bin"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "subdir/file10.bin"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "subdir/file11.bin"), vecModules.end());
EXPECT_NE(std::find(vecModules.begin(), vecModules.end(), "subdir/file20.bin"), vecModules.end());
}
TEST_F(CInstallManifestTest, SaveLoadComponents)
{
// Source and target directories
std::filesystem::path pathSrcFileDir = GetExecDirectory();
std::filesystem::path pathTgtPckDir = GetExecDirectory() / "install_package_composer_targets";
std::filesystem::create_directories(pathTgtPckDir);
EXPECT_FALSE(std::filesystem::exists(pathTgtPckDir / "install_manifest.toml"));
CInstallManifest manifestWrite;
manifestWrite.Create("Hello");
EXPECT_TRUE(manifestWrite.IsValid());
EXPECT_TRUE(manifestWrite.AddModule(pathSrcFileDir / "UnitTest_InstallPackageComposer_Component1.sdv"));
EXPECT_TRUE(manifestWrite.AddModule(pathSrcFileDir / "UnitTest_InstallPackageComposer_Component2.sdv"));
auto vecModules = manifestWrite.ModuleList();
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");
EXPECT_EQ(itDummyService1->ssDefaultObjectName, "MyDummy");
EXPECT_EQ(itDummyService1->eType, sdv::EObjectType::ComplexService);
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");
EXPECT_TRUE(manifestWrite.Save(pathTgtPckDir));
EXPECT_TRUE(std::filesystem::exists(pathTgtPckDir / "install_manifest.toml"));
CInstallManifest manifestRead;
manifestRead.Load(pathTgtPckDir);
EXPECT_TRUE(manifestRead.IsValid());
vecModules = manifestRead.ModuleList();
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");
EXPECT_EQ(itDummyService1->ssDefaultObjectName, "MyDummy");
EXPECT_EQ(itDummyService1->eType, sdv::EObjectType::ComplexService);
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");
}
TEST_F(CInstallManifestTest, SaveLoadFindModules)
{
// Source and target directories
std::filesystem::path pathSrcFileDir = GetExecDirectory();
std::filesystem::path pathTgtPckDir = GetExecDirectory() / "install_package_composer_targets";
std::filesystem::create_directories(pathTgtPckDir);
EXPECT_FALSE(std::filesystem::exists(pathTgtPckDir / "install_manifest.toml"));
CInstallManifest manifestWrite;
manifestWrite.Create("Hello");
EXPECT_TRUE(manifestWrite.IsValid());
EXPECT_TRUE(manifestWrite.AddModule(pathSrcFileDir / "UnitTest_InstallPackageComposer_Component1.sdv"));
EXPECT_TRUE(manifestWrite.AddModule(pathSrcFileDir / "UnitTest_InstallPackageComposer_Component2.sdv"));
auto vecModules = manifestWrite.ModuleList();
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");
EXPECT_EQ(itDummyService1->ssDefaultObjectName, "MyDummy");
EXPECT_EQ(itDummyService1->eType, sdv::EObjectType::ComplexService);
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");
EXPECT_TRUE(manifestWrite.Save(pathTgtPckDir));
EXPECT_TRUE(std::filesystem::exists(pathTgtPckDir / "install_manifest.toml"));
CInstallManifest manifestRead;
manifestRead.Load(pathTgtPckDir);
EXPECT_TRUE(manifestRead.IsValid());
EXPECT_FALSE(manifestRead.FindModule("UnitTest_InstallPackageComposer_Component1.sdv").empty());
EXPECT_FALSE(manifestRead.FindModuleManifest("UnitTest_InstallPackageComposer_Component1.sdv").empty());
EXPECT_FALSE(manifestRead.FindModule("UnitTest_InstallPackageComposer_Component2.sdv").empty());
EXPECT_FALSE(manifestRead.FindModuleManifest("UnitTest_InstallPackageComposer_Component2.sdv").empty());
}
TEST_F(CInstallManifestTest, SaveLoadFindComponents)
{
// Source and target directories
std::filesystem::path pathSrcFileDir = GetExecDirectory();
std::filesystem::path pathTgtPckDir = GetExecDirectory() / "install_package_composer_targets";
std::filesystem::create_directories(pathTgtPckDir);
EXPECT_FALSE(std::filesystem::exists(pathTgtPckDir / "install_manifest.toml"));
CInstallManifest manifestWrite;
manifestWrite.Create("Hello");
EXPECT_TRUE(manifestWrite.IsValid());
EXPECT_TRUE(manifestWrite.AddModule(pathSrcFileDir / "UnitTest_InstallPackageComposer_Component1.sdv"));
EXPECT_TRUE(manifestWrite.AddModule(pathSrcFileDir / "UnitTest_InstallPackageComposer_Component2.sdv"));
auto vecModules = manifestWrite.ModuleList();
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");
EXPECT_EQ(itDummyService1->ssDefaultObjectName, "MyDummy");
EXPECT_EQ(itDummyService1->eType, sdv::EObjectType::ComplexService);
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");
EXPECT_TRUE(manifestWrite.Save(pathTgtPckDir));
EXPECT_TRUE(std::filesystem::exists(pathTgtPckDir / "install_manifest.toml"));
CInstallManifest manifestRead;
manifestRead.Load(pathTgtPckDir);
EXPECT_TRUE(manifestRead.IsValid());
EXPECT_TRUE(manifestRead.FindComponentByClass("DummyService #1"));
EXPECT_TRUE(manifestRead.FindComponentByClass("Dummy1"));
EXPECT_TRUE(manifestRead.FindComponentByClass("DummySvc1"));
EXPECT_TRUE(manifestRead.FindComponentByClass("DummyDevice"));
EXPECT_TRUE(manifestRead.FindComponentByClass("DummyService #2"));
EXPECT_FALSE(manifestRead.FindComponentByClass("DummyServer #3"));
}

574
tests/unit_tests/install_package_composer/package_version_tests.cpp Normal file
View File

@@ -0,0 +1,574 @@
#include <gtest/gtest.h>
#include "composer_test_suite.h"
#include "../../../sdv_services/core/installation_manifest.h"
using CPackageVersionTest = CInstallPackageComposerTest;
sdv::installation::SPackageVersion sVersion0 = {0, 0, 0};
sdv::installation::SPackageVersion sVersion0_9 = {0, 9, 0};
sdv::installation::SPackageVersion sVersion1 = {1, 0, 0};
sdv::installation::SPackageVersion sVersion1a = {1, 0, 1};
sdv::installation::SPackageVersion sVersion1b = {1, 0, 2};
sdv::installation::SPackageVersion sVersion1_1 = {1, 1, 0};
sdv::installation::SPackageVersion sVersion1_1a = {1, 1, 1};
sdv::installation::SPackageVersion sVersion1_2 = {1, 2, 0};
sdv::installation::SPackageVersion sVersion2 = {2, 0, 0};
TEST_F(CPackageVersionTest, PackageVersionEqual)
{
EXPECT_TRUE(sVersion0 == sVersion0);
EXPECT_FALSE(sVersion0_9 == sVersion0);
EXPECT_FALSE(sVersion1 == sVersion0);
EXPECT_FALSE(sVersion1a == sVersion0);
EXPECT_FALSE(sVersion1b == sVersion0);
EXPECT_FALSE(sVersion1_1 == sVersion0);
EXPECT_FALSE(sVersion1_1a == sVersion0);
EXPECT_FALSE(sVersion1_2 == sVersion0);
EXPECT_FALSE(sVersion2 == sVersion0);
EXPECT_FALSE(sVersion0 == sVersion0_9);
EXPECT_TRUE(sVersion0_9 == sVersion0_9);
EXPECT_FALSE(sVersion1 == sVersion0_9);
EXPECT_FALSE(sVersion1a == sVersion0_9);
EXPECT_FALSE(sVersion1b == sVersion0_9);
EXPECT_FALSE(sVersion1_1 == sVersion0_9);
EXPECT_FALSE(sVersion1_1a == sVersion0_9);
EXPECT_FALSE(sVersion1_2 == sVersion0_9);
EXPECT_FALSE(sVersion2 == sVersion0_9);
EXPECT_FALSE(sVersion0 == sVersion1);
EXPECT_FALSE(sVersion0_9 == sVersion1);
EXPECT_TRUE(sVersion1 == sVersion1);
EXPECT_FALSE(sVersion1a == sVersion1);
EXPECT_FALSE(sVersion1b == sVersion1);
EXPECT_FALSE(sVersion1_1 == sVersion1);
EXPECT_FALSE(sVersion1_1a == sVersion1);
EXPECT_FALSE(sVersion1_2 == sVersion1);
EXPECT_FALSE(sVersion2 == sVersion1);
EXPECT_FALSE(sVersion0 == sVersion1a);
EXPECT_FALSE(sVersion0_9 == sVersion1a);
EXPECT_FALSE(sVersion1 == sVersion1a);
EXPECT_TRUE(sVersion1a == sVersion1a);
EXPECT_FALSE(sVersion1b == sVersion1a);
EXPECT_FALSE(sVersion1_1 == sVersion1a);
EXPECT_FALSE(sVersion1_1a == sVersion1a);
EXPECT_FALSE(sVersion1_2 == sVersion1a);
EXPECT_FALSE(sVersion2 == sVersion1a);
EXPECT_FALSE(sVersion0 == sVersion1b);
EXPECT_FALSE(sVersion0_9 == sVersion1b);
EXPECT_FALSE(sVersion1 == sVersion1b);
EXPECT_FALSE(sVersion1a == sVersion1b);
EXPECT_TRUE(sVersion1b == sVersion1b);
EXPECT_FALSE(sVersion1_1 == sVersion1b);
EXPECT_FALSE(sVersion1_1a == sVersion1b);
EXPECT_FALSE(sVersion1_2 == sVersion1b);
EXPECT_FALSE(sVersion2 == sVersion1b);
EXPECT_FALSE(sVersion0 == sVersion1_1);
EXPECT_FALSE(sVersion0_9 == sVersion1_1);
EXPECT_FALSE(sVersion1 == sVersion1_1);
EXPECT_FALSE(sVersion1a == sVersion1_1);
EXPECT_FALSE(sVersion1b == sVersion1_1);
EXPECT_TRUE(sVersion1_1 == sVersion1_1);
EXPECT_FALSE(sVersion1_1a == sVersion1_1);
EXPECT_FALSE(sVersion1_2 == sVersion1_1);
EXPECT_FALSE(sVersion2 == sVersion1_1);
EXPECT_FALSE(sVersion0 == sVersion1_1a);
EXPECT_FALSE(sVersion0_9 == sVersion1_1a);
EXPECT_FALSE(sVersion1 == sVersion1_1a);
EXPECT_FALSE(sVersion1a == sVersion1_1a);
EXPECT_FALSE(sVersion1b == sVersion1_1a);
EXPECT_FALSE(sVersion1_1 == sVersion1_1a);
EXPECT_TRUE(sVersion1_1a == sVersion1_1a);
EXPECT_FALSE(sVersion1_2 == sVersion1_1a);
EXPECT_FALSE(sVersion2 == sVersion1_1a);
EXPECT_FALSE(sVersion0 == sVersion1_2);
EXPECT_FALSE(sVersion0_9 == sVersion1_2);
EXPECT_FALSE(sVersion1 == sVersion1_2);
EXPECT_FALSE(sVersion1a == sVersion1_2);
EXPECT_FALSE(sVersion1b == sVersion1_2);
EXPECT_FALSE(sVersion1_1 == sVersion1_2);
EXPECT_FALSE(sVersion1_1a == sVersion1_2);
EXPECT_TRUE(sVersion1_2 == sVersion1_2);
EXPECT_FALSE(sVersion2 == sVersion1_2);
EXPECT_FALSE(sVersion0 == sVersion2);
EXPECT_FALSE(sVersion0_9 == sVersion2);
EXPECT_FALSE(sVersion1 == sVersion2);
EXPECT_FALSE(sVersion1a == sVersion2);
EXPECT_FALSE(sVersion1b == sVersion2);
EXPECT_FALSE(sVersion1_1 == sVersion2);
EXPECT_FALSE(sVersion1_1a == sVersion2);
EXPECT_FALSE(sVersion1_2 == sVersion2);
EXPECT_TRUE(sVersion2 == sVersion2);
}
TEST_F(CPackageVersionTest, PackageVersionLargerThanOrEqual)
{
EXPECT_TRUE(sVersion0 >= sVersion0);
EXPECT_TRUE(sVersion0_9 >= sVersion0);
EXPECT_TRUE(sVersion1 >= sVersion0);
EXPECT_TRUE(sVersion1a >= sVersion0);
EXPECT_TRUE(sVersion1b >= sVersion0);
EXPECT_TRUE(sVersion1_1 >= sVersion0);
EXPECT_TRUE(sVersion1_1a >= sVersion0);
EXPECT_TRUE(sVersion1_2 >= sVersion0);
EXPECT_TRUE(sVersion2 >= sVersion0);
EXPECT_FALSE(sVersion0 >= sVersion0_9);
EXPECT_TRUE(sVersion0_9 >= sVersion0_9);
EXPECT_TRUE(sVersion1 >= sVersion0_9);
EXPECT_TRUE(sVersion1a >= sVersion0_9);
EXPECT_TRUE(sVersion1b >= sVersion0_9);
EXPECT_TRUE(sVersion1_1 >= sVersion0_9);
EXPECT_TRUE(sVersion1_1a >= sVersion0_9);
EXPECT_TRUE(sVersion1_2 >= sVersion0_9);
EXPECT_TRUE(sVersion2 >= sVersion0_9);
EXPECT_FALSE(sVersion0 >= sVersion1);
EXPECT_FALSE(sVersion0_9 >= sVersion1);
EXPECT_TRUE(sVersion1 >= sVersion1);
EXPECT_TRUE(sVersion1a >= sVersion1);
EXPECT_TRUE(sVersion1b >= sVersion1);
EXPECT_TRUE(sVersion1_1 >= sVersion1);
EXPECT_TRUE(sVersion1_1a >= sVersion1);
EXPECT_TRUE(sVersion1_2 >= sVersion1);
EXPECT_TRUE(sVersion2 >= sVersion1);
EXPECT_FALSE(sVersion0 >= sVersion1a);
EXPECT_FALSE(sVersion0_9 >= sVersion1a);
EXPECT_FALSE(sVersion1 >= sVersion1a);
EXPECT_TRUE(sVersion1a >= sVersion1a);
EXPECT_TRUE(sVersion1b >= sVersion1a);
EXPECT_TRUE(sVersion1_1 >= sVersion1a);
EXPECT_TRUE(sVersion1_1a >= sVersion1a);
EXPECT_TRUE(sVersion1_2 >= sVersion1a);
EXPECT_TRUE(sVersion2 >= sVersion1a);
EXPECT_FALSE(sVersion0 >= sVersion1b);
EXPECT_FALSE(sVersion0_9 >= sVersion1b);
EXPECT_FALSE(sVersion1 >= sVersion1b);
EXPECT_FALSE(sVersion1a >= sVersion1b);
EXPECT_TRUE(sVersion1b >= sVersion1b);
EXPECT_TRUE(sVersion1_1 >= sVersion1b);
EXPECT_TRUE(sVersion1_1a >= sVersion1b);
EXPECT_TRUE(sVersion1_2 >= sVersion1b);
EXPECT_TRUE(sVersion2 >= sVersion1b);
EXPECT_FALSE(sVersion0 >= sVersion1_1);
EXPECT_FALSE(sVersion0_9 >= sVersion1_1);
EXPECT_FALSE(sVersion1 >= sVersion1_1);
EXPECT_FALSE(sVersion1a >= sVersion1_1);
EXPECT_FALSE(sVersion1b >= sVersion1_1);
EXPECT_TRUE(sVersion1_1 >= sVersion1_1);
EXPECT_TRUE(sVersion1_1a >= sVersion1_1);
EXPECT_TRUE(sVersion1_2 >= sVersion1_1);
EXPECT_TRUE(sVersion2 >= sVersion1_1);
EXPECT_FALSE(sVersion0 >= sVersion1_1a);
EXPECT_FALSE(sVersion0_9 >= sVersion1_1a);
EXPECT_FALSE(sVersion1 >= sVersion1_1a);
EXPECT_FALSE(sVersion1a >= sVersion1_1a);
EXPECT_FALSE(sVersion1b >= sVersion1_1a);
EXPECT_FALSE(sVersion1_1 >= sVersion1_1a);
EXPECT_TRUE(sVersion1_1a >= sVersion1_1a);
EXPECT_TRUE(sVersion1_2 >= sVersion1_1a);
EXPECT_TRUE(sVersion2 >= sVersion1_1a);
EXPECT_FALSE(sVersion0 >= sVersion1_2);
EXPECT_FALSE(sVersion0_9 >= sVersion1_2);
EXPECT_FALSE(sVersion1 >= sVersion1_2);
EXPECT_FALSE(sVersion1a >= sVersion1_2);
EXPECT_FALSE(sVersion1b >= sVersion1_2);
EXPECT_FALSE(sVersion1_1 >= sVersion1_2);
EXPECT_FALSE(sVersion1_1a >= sVersion1_2);
EXPECT_TRUE(sVersion1_2 >= sVersion1_2);
EXPECT_TRUE(sVersion2 >= sVersion1_2);
EXPECT_FALSE(sVersion0 >= sVersion2);
EXPECT_FALSE(sVersion0_9 >= sVersion2);
EXPECT_FALSE(sVersion1 >= sVersion2);
EXPECT_FALSE(sVersion1a >= sVersion2);
EXPECT_FALSE(sVersion1b >= sVersion2);
EXPECT_FALSE(sVersion1_1 >= sVersion2);
EXPECT_FALSE(sVersion1_1a >= sVersion2);
EXPECT_FALSE(sVersion1_2 >= sVersion2);
EXPECT_TRUE(sVersion2 >= sVersion2);
}
TEST_F(CPackageVersionTest, PackageVersionLargerThan)
{
EXPECT_FALSE(sVersion0 > sVersion0);
EXPECT_TRUE(sVersion0_9 > sVersion0);
EXPECT_TRUE(sVersion1 > sVersion0);
EXPECT_TRUE(sVersion1a > sVersion0);
EXPECT_TRUE(sVersion1b > sVersion0);
EXPECT_TRUE(sVersion1_1 > sVersion0);
EXPECT_TRUE(sVersion1_1a > sVersion0);
EXPECT_TRUE(sVersion1_2 > sVersion0);
EXPECT_TRUE(sVersion2 > sVersion0);
EXPECT_FALSE(sVersion0 > sVersion0_9);
EXPECT_FALSE(sVersion0_9 > sVersion0_9);
EXPECT_TRUE(sVersion1 > sVersion0_9);
EXPECT_TRUE(sVersion1a > sVersion0_9);
EXPECT_TRUE(sVersion1b > sVersion0_9);
EXPECT_TRUE(sVersion1_1 > sVersion0_9);
EXPECT_TRUE(sVersion1_1a > sVersion0_9);
EXPECT_TRUE(sVersion1_2 > sVersion0_9);
EXPECT_TRUE(sVersion2 > sVersion0_9);
EXPECT_FALSE(sVersion0 > sVersion1);
EXPECT_FALSE(sVersion0_9 > sVersion1);
EXPECT_FALSE(sVersion1 > sVersion1);
EXPECT_TRUE(sVersion1a > sVersion1);
EXPECT_TRUE(sVersion1b > sVersion1);
EXPECT_TRUE(sVersion1_1 > sVersion1);
EXPECT_TRUE(sVersion1_1a > sVersion1);
EXPECT_TRUE(sVersion1_2 > sVersion1);
EXPECT_TRUE(sVersion2 > sVersion1);
EXPECT_FALSE(sVersion0 > sVersion1a);
EXPECT_FALSE(sVersion0_9 > sVersion1a);
EXPECT_FALSE(sVersion1 > sVersion1a);
EXPECT_FALSE(sVersion1a > sVersion1a);
EXPECT_TRUE(sVersion1b > sVersion1a);
EXPECT_TRUE(sVersion1_1 > sVersion1a);
EXPECT_TRUE(sVersion1_1a > sVersion1a);
EXPECT_TRUE(sVersion1_2 > sVersion1a);
EXPECT_TRUE(sVersion2 > sVersion1a);
EXPECT_FALSE(sVersion0 > sVersion1b);
EXPECT_FALSE(sVersion0_9 > sVersion1b);
EXPECT_FALSE(sVersion1 > sVersion1b);
EXPECT_FALSE(sVersion1a > sVersion1b);
EXPECT_FALSE(sVersion1b > sVersion1b);
EXPECT_TRUE(sVersion1_1 > sVersion1b);
EXPECT_TRUE(sVersion1_1a > sVersion1b);
EXPECT_TRUE(sVersion1_2 > sVersion1b);
EXPECT_TRUE(sVersion2 > sVersion1b);
EXPECT_FALSE(sVersion0 > sVersion1_1);
EXPECT_FALSE(sVersion0_9 > sVersion1_1);
EXPECT_FALSE(sVersion1 > sVersion1_1);
EXPECT_FALSE(sVersion1a > sVersion1_1);
EXPECT_FALSE(sVersion1b > sVersion1_1);
EXPECT_FALSE(sVersion1_1 > sVersion1_1);
EXPECT_TRUE(sVersion1_1a > sVersion1_1);
EXPECT_TRUE(sVersion1_2 > sVersion1_1);
EXPECT_TRUE(sVersion2 > sVersion1_1);
EXPECT_FALSE(sVersion0 > sVersion1_1a);
EXPECT_FALSE(sVersion0_9 > sVersion1_1a);
EXPECT_FALSE(sVersion1 > sVersion1_1a);
EXPECT_FALSE(sVersion1a > sVersion1_1a);
EXPECT_FALSE(sVersion1b > sVersion1_1a);
EXPECT_FALSE(sVersion1_1 > sVersion1_1a);
EXPECT_FALSE(sVersion1_1a > sVersion1_1a);
EXPECT_TRUE(sVersion1_2 > sVersion1_1a);
EXPECT_TRUE(sVersion2 > sVersion1_1a);
EXPECT_FALSE(sVersion0 > sVersion1_2);
EXPECT_FALSE(sVersion0_9 > sVersion1_2);
EXPECT_FALSE(sVersion1 > sVersion1_2);
EXPECT_FALSE(sVersion1a > sVersion1_2);
EXPECT_FALSE(sVersion1b > sVersion1_2);
EXPECT_FALSE(sVersion1_1 > sVersion1_2);
EXPECT_FALSE(sVersion1_1a > sVersion1_2);
EXPECT_FALSE(sVersion1_2 > sVersion1_2);
EXPECT_TRUE(sVersion2 > sVersion1_2);
EXPECT_FALSE(sVersion0 > sVersion2);
EXPECT_FALSE(sVersion0_9 > sVersion2);
EXPECT_FALSE(sVersion1 > sVersion2);
EXPECT_FALSE(sVersion1a > sVersion2);
EXPECT_FALSE(sVersion1b > sVersion2);
EXPECT_FALSE(sVersion1_1 > sVersion2);
EXPECT_FALSE(sVersion1_1a > sVersion2);
EXPECT_FALSE(sVersion1_2 > sVersion2);
EXPECT_FALSE(sVersion2 > sVersion2);
}
TEST_F(CPackageVersionTest, PackageVersionNotEqual)
{
EXPECT_FALSE(sVersion0 != sVersion0);
EXPECT_TRUE(sVersion0_9 != sVersion0);
EXPECT_TRUE(sVersion1 != sVersion0);
EXPECT_TRUE(sVersion1a != sVersion0);
EXPECT_TRUE(sVersion1b != sVersion0);
EXPECT_TRUE(sVersion1_1 != sVersion0);
EXPECT_TRUE(sVersion1_1a != sVersion0);
EXPECT_TRUE(sVersion1_2 != sVersion0);
EXPECT_TRUE(sVersion2 != sVersion0);
EXPECT_TRUE(sVersion0 != sVersion0_9);
EXPECT_FALSE(sVersion0_9 != sVersion0_9);
EXPECT_TRUE(sVersion1 != sVersion0_9);
EXPECT_TRUE(sVersion1a != sVersion0_9);
EXPECT_TRUE(sVersion1b != sVersion0_9);
EXPECT_TRUE(sVersion1_1 != sVersion0_9);
EXPECT_TRUE(sVersion1_1a != sVersion0_9);
EXPECT_TRUE(sVersion1_2 != sVersion0_9);
EXPECT_TRUE(sVersion2 != sVersion0_9);
EXPECT_TRUE(sVersion0 != sVersion1);
EXPECT_TRUE(sVersion0_9 != sVersion1);
EXPECT_FALSE(sVersion1 != sVersion1);
EXPECT_TRUE(sVersion1a != sVersion1);
EXPECT_TRUE(sVersion1b != sVersion1);
EXPECT_TRUE(sVersion1_1 != sVersion1);
EXPECT_TRUE(sVersion1_1a != sVersion1);
EXPECT_TRUE(sVersion1_2 != sVersion1);
EXPECT_TRUE(sVersion2 != sVersion1);
EXPECT_TRUE(sVersion0 != sVersion1a);
EXPECT_TRUE(sVersion0_9 != sVersion1a);
EXPECT_TRUE(sVersion1 != sVersion1a);
EXPECT_FALSE(sVersion1a != sVersion1a);
EXPECT_TRUE(sVersion1b != sVersion1a);
EXPECT_TRUE(sVersion1_1 != sVersion1a);
EXPECT_TRUE(sVersion1_1a != sVersion1a);
EXPECT_TRUE(sVersion1_2 != sVersion1a);
EXPECT_TRUE(sVersion2 != sVersion1a);
EXPECT_TRUE(sVersion0 != sVersion1b);
EXPECT_TRUE(sVersion0_9 != sVersion1b);
EXPECT_TRUE(sVersion1 != sVersion1b);
EXPECT_TRUE(sVersion1a != sVersion1b);
EXPECT_FALSE(sVersion1b != sVersion1b);
EXPECT_TRUE(sVersion1_1 != sVersion1b);
EXPECT_TRUE(sVersion1_1a != sVersion1b);
EXPECT_TRUE(sVersion1_2 != sVersion1b);
EXPECT_TRUE(sVersion2 != sVersion1b);
EXPECT_TRUE(sVersion0 != sVersion1_1);
EXPECT_TRUE(sVersion0_9 != sVersion1_1);
EXPECT_TRUE(sVersion1 != sVersion1_1);
EXPECT_TRUE(sVersion1a != sVersion1_1);
EXPECT_TRUE(sVersion1b != sVersion1_1);
EXPECT_FALSE(sVersion1_1 != sVersion1_1);
EXPECT_TRUE(sVersion1_1a != sVersion1_1);
EXPECT_TRUE(sVersion1_2 != sVersion1_1);
EXPECT_TRUE(sVersion2 != sVersion1_1);
EXPECT_TRUE(sVersion0 != sVersion1_1a);
EXPECT_TRUE(sVersion0_9 != sVersion1_1a);
EXPECT_TRUE(sVersion1 != sVersion1_1a);
EXPECT_TRUE(sVersion1a != sVersion1_1a);
EXPECT_TRUE(sVersion1b != sVersion1_1a);
EXPECT_TRUE(sVersion1_1 != sVersion1_1a);
EXPECT_FALSE(sVersion1_1a != sVersion1_1a);
EXPECT_TRUE(sVersion1_2 != sVersion1_1a);
EXPECT_TRUE(sVersion2 != sVersion1_1a);
EXPECT_TRUE(sVersion0 != sVersion1_2);
EXPECT_TRUE(sVersion0_9 != sVersion1_2);
EXPECT_TRUE(sVersion1 != sVersion1_2);
EXPECT_TRUE(sVersion1a != sVersion1_2);
EXPECT_TRUE(sVersion1b != sVersion1_2);
EXPECT_TRUE(sVersion1_1 != sVersion1_2);
EXPECT_TRUE(sVersion1_1a != sVersion1_2);
EXPECT_FALSE(sVersion1_2 != sVersion1_2);
EXPECT_TRUE(sVersion2 != sVersion1_2);
EXPECT_TRUE(sVersion0 != sVersion2);
EXPECT_TRUE(sVersion0_9 != sVersion2);
EXPECT_TRUE(sVersion1 != sVersion2);
EXPECT_TRUE(sVersion1a != sVersion2);
EXPECT_TRUE(sVersion1b != sVersion2);
EXPECT_TRUE(sVersion1_1 != sVersion2);
EXPECT_TRUE(sVersion1_1a != sVersion2);
EXPECT_TRUE(sVersion1_2 != sVersion2);
EXPECT_FALSE(sVersion2 != sVersion2);
}
TEST_F(CPackageVersionTest, PackageVersionSmallerThan)
{
EXPECT_FALSE(sVersion0 < sVersion0);
EXPECT_FALSE(sVersion0_9 < sVersion0);
EXPECT_FALSE(sVersion1 < sVersion0);
EXPECT_FALSE(sVersion1a < sVersion0);
EXPECT_FALSE(sVersion1b < sVersion0);
EXPECT_FALSE(sVersion1_1 < sVersion0);
EXPECT_FALSE(sVersion1_1a < sVersion0);
EXPECT_FALSE(sVersion1_2 < sVersion0);
EXPECT_FALSE(sVersion2 < sVersion0);
EXPECT_TRUE(sVersion0 < sVersion0_9);
EXPECT_FALSE(sVersion0_9 < sVersion0_9);
EXPECT_FALSE(sVersion1 < sVersion0_9);
EXPECT_FALSE(sVersion1a < sVersion0_9);
EXPECT_FALSE(sVersion1b < sVersion0_9);
EXPECT_FALSE(sVersion1_1 < sVersion0_9);
EXPECT_FALSE(sVersion1_1a < sVersion0_9);
EXPECT_FALSE(sVersion1_2 < sVersion0_9);
EXPECT_FALSE(sVersion2 < sVersion0_9);
EXPECT_TRUE(sVersion0 < sVersion1);
EXPECT_TRUE(sVersion0_9 < sVersion1);
EXPECT_FALSE(sVersion1 < sVersion1);
EXPECT_FALSE(sVersion1a < sVersion1);
EXPECT_FALSE(sVersion1b < sVersion1);
EXPECT_FALSE(sVersion1_1 < sVersion1);
EXPECT_FALSE(sVersion1_1a < sVersion1);
EXPECT_FALSE(sVersion1_2 < sVersion1);
EXPECT_FALSE(sVersion2 < sVersion1);
EXPECT_TRUE(sVersion0 < sVersion1a);
EXPECT_TRUE(sVersion0_9 < sVersion1a);
EXPECT_TRUE(sVersion1 < sVersion1a);
EXPECT_FALSE(sVersion1a < sVersion1a);
EXPECT_FALSE(sVersion1b < sVersion1a);
EXPECT_FALSE(sVersion1_1 < sVersion1a);
EXPECT_FALSE(sVersion1_1a < sVersion1a);
EXPECT_FALSE(sVersion1_2 < sVersion1a);
EXPECT_FALSE(sVersion2 < sVersion1a);
EXPECT_TRUE(sVersion0 < sVersion1b);
EXPECT_TRUE(sVersion0_9 < sVersion1b);
EXPECT_TRUE(sVersion1 < sVersion1b);
EXPECT_TRUE(sVersion1a < sVersion1b);
EXPECT_FALSE(sVersion1b < sVersion1b);
EXPECT_FALSE(sVersion1_1 < sVersion1b);
EXPECT_FALSE(sVersion1_1a < sVersion1b);
EXPECT_FALSE(sVersion1_2 < sVersion1b);
EXPECT_FALSE(sVersion2 < sVersion1b);
EXPECT_TRUE(sVersion0 < sVersion1_1);
EXPECT_TRUE(sVersion0_9 < sVersion1_1);
EXPECT_TRUE(sVersion1 < sVersion1_1);
EXPECT_TRUE(sVersion1a < sVersion1_1);
EXPECT_TRUE(sVersion1b < sVersion1_1);
EXPECT_FALSE(sVersion1_1 < sVersion1_1);
EXPECT_FALSE(sVersion1_1a < sVersion1_1);
EXPECT_FALSE(sVersion1_2 < sVersion1_1);
EXPECT_FALSE(sVersion2 < sVersion1_1);
EXPECT_TRUE(sVersion0 < sVersion1_1a);
EXPECT_TRUE(sVersion0_9 < sVersion1_1a);
EXPECT_TRUE(sVersion1 < sVersion1_1a);
EXPECT_TRUE(sVersion1a < sVersion1_1a);
EXPECT_TRUE(sVersion1b < sVersion1_1a);
EXPECT_TRUE(sVersion1_1 < sVersion1_1a);
EXPECT_FALSE(sVersion1_1a < sVersion1_1a);
EXPECT_FALSE(sVersion1_2 < sVersion1_1a);
EXPECT_FALSE(sVersion2 < sVersion1_1a);
EXPECT_TRUE(sVersion0 < sVersion1_2);
EXPECT_TRUE(sVersion0_9 < sVersion1_2);
EXPECT_TRUE(sVersion1 < sVersion1_2);
EXPECT_TRUE(sVersion1a < sVersion1_2);
EXPECT_TRUE(sVersion1b < sVersion1_2);
EXPECT_TRUE(sVersion1_1 < sVersion1_2);
EXPECT_TRUE(sVersion1_1a < sVersion1_2);
EXPECT_FALSE(sVersion1_2 < sVersion1_2);
EXPECT_FALSE(sVersion2 < sVersion1_2);
EXPECT_TRUE(sVersion0 < sVersion2);
EXPECT_TRUE(sVersion0_9 < sVersion2);
EXPECT_TRUE(sVersion1 < sVersion2);
EXPECT_TRUE(sVersion1a < sVersion2);
EXPECT_TRUE(sVersion1b < sVersion2);
EXPECT_TRUE(sVersion1_1 < sVersion2);
EXPECT_TRUE(sVersion1_1a < sVersion2);
EXPECT_TRUE(sVersion1_2 < sVersion2);
EXPECT_FALSE(sVersion2 < sVersion2);
}
TEST_F(CPackageVersionTest, PackageVersionSmallerThanOrEqual)
{
EXPECT_TRUE(sVersion0 <= sVersion0);
EXPECT_FALSE(sVersion0_9 <= sVersion0);
EXPECT_FALSE(sVersion1 <= sVersion0);
EXPECT_FALSE(sVersion1a <= sVersion0);
EXPECT_FALSE(sVersion1b <= sVersion0);
EXPECT_FALSE(sVersion1_1 <= sVersion0);
EXPECT_FALSE(sVersion1_1a <= sVersion0);
EXPECT_FALSE(sVersion1_2 <= sVersion0);
EXPECT_FALSE(sVersion2 <= sVersion0);
EXPECT_TRUE(sVersion0 <= sVersion0_9);
EXPECT_TRUE(sVersion0_9 <= sVersion0_9);
EXPECT_FALSE(sVersion1 <= sVersion0_9);
EXPECT_FALSE(sVersion1a <= sVersion0_9);
EXPECT_FALSE(sVersion1b <= sVersion0_9);
EXPECT_FALSE(sVersion1_1 <= sVersion0_9);
EXPECT_FALSE(sVersion1_1a <= sVersion0_9);
EXPECT_FALSE(sVersion1_2 <= sVersion0_9);
EXPECT_FALSE(sVersion2 <= sVersion0_9);
EXPECT_TRUE(sVersion0 <= sVersion1);
EXPECT_TRUE(sVersion0_9 <= sVersion1);
EXPECT_TRUE(sVersion1 <= sVersion1);
EXPECT_FALSE(sVersion1a <= sVersion1);
EXPECT_FALSE(sVersion1b <= sVersion1);
EXPECT_FALSE(sVersion1_1 <= sVersion1);
EXPECT_FALSE(sVersion1_1a <= sVersion1);
EXPECT_FALSE(sVersion1_2 <= sVersion1);
EXPECT_FALSE(sVersion2 <= sVersion1);
EXPECT_TRUE(sVersion0 <= sVersion1a);
EXPECT_TRUE(sVersion0_9 <= sVersion1a);
EXPECT_TRUE(sVersion1 <= sVersion1a);
EXPECT_TRUE(sVersion1a <= sVersion1a);
EXPECT_FALSE(sVersion1b <= sVersion1a);
EXPECT_FALSE(sVersion1_1 <= sVersion1a);
EXPECT_FALSE(sVersion1_1a <= sVersion1a);
EXPECT_FALSE(sVersion1_2 <= sVersion1a);
EXPECT_FALSE(sVersion2 <= sVersion1a);
EXPECT_TRUE(sVersion0 <= sVersion1b);
EXPECT_TRUE(sVersion0_9 <= sVersion1b);
EXPECT_TRUE(sVersion1 <= sVersion1b);
EXPECT_TRUE(sVersion1a <= sVersion1b);
EXPECT_TRUE(sVersion1b <= sVersion1b);
EXPECT_FALSE(sVersion1_1 <= sVersion1b);
EXPECT_FALSE(sVersion1_1a <= sVersion1b);
EXPECT_FALSE(sVersion1_2 <= sVersion1b);
EXPECT_FALSE(sVersion2 <= sVersion1b);
EXPECT_TRUE(sVersion0 <= sVersion1_1);
EXPECT_TRUE(sVersion0_9 <= sVersion1_1);
EXPECT_TRUE(sVersion1 <= sVersion1_1);
EXPECT_TRUE(sVersion1a <= sVersion1_1);
EXPECT_TRUE(sVersion1b <= sVersion1_1);
EXPECT_TRUE(sVersion1_1 <= sVersion1_1);
EXPECT_FALSE(sVersion1_1a <= sVersion1_1);
EXPECT_FALSE(sVersion1_2 <= sVersion1_1);
EXPECT_FALSE(sVersion2 <= sVersion1_1);
EXPECT_TRUE(sVersion0 <= sVersion1_1a);
EXPECT_TRUE(sVersion0_9 <= sVersion1_1a);
EXPECT_TRUE(sVersion1 <= sVersion1_1a);
EXPECT_TRUE(sVersion1a <= sVersion1_1a);
EXPECT_TRUE(sVersion1b <= sVersion1_1a);
EXPECT_TRUE(sVersion1_1 <= sVersion1_1a);
EXPECT_TRUE(sVersion1_1a <= sVersion1_1a);
EXPECT_FALSE(sVersion1_2 <= sVersion1_1a);
EXPECT_FALSE(sVersion2 <= sVersion1_1a);
EXPECT_TRUE(sVersion0 <= sVersion1_2);
EXPECT_TRUE(sVersion0_9 <= sVersion1_2);
EXPECT_TRUE(sVersion1 <= sVersion1_2);
EXPECT_TRUE(sVersion1a <= sVersion1_2);
EXPECT_TRUE(sVersion1b <= sVersion1_2);
EXPECT_TRUE(sVersion1_1 <= sVersion1_2);
EXPECT_TRUE(sVersion1_1a <= sVersion1_2);
EXPECT_TRUE(sVersion1_2 <= sVersion1_2);
EXPECT_FALSE(sVersion2 <= sVersion1_2);
EXPECT_TRUE(sVersion0 <= sVersion2);
EXPECT_TRUE(sVersion0_9 <= sVersion2);
EXPECT_TRUE(sVersion1 <= sVersion2);
EXPECT_TRUE(sVersion1a <= sVersion2);
EXPECT_TRUE(sVersion1b <= sVersion2);
EXPECT_TRUE(sVersion1_1 <= sVersion2);
EXPECT_TRUE(sVersion1_1a <= sVersion2);
EXPECT_TRUE(sVersion1_2 <= sVersion2);
EXPECT_TRUE(sVersion2 <= sVersion2);
}