Precommit (#1)

* first commit

* cleanup

tests/component_tests/vss_util/CMakeLists.txt

@@ -0,0 +1,34 @@
+# Define project
+project (VSSUtilTests VERSION 1.0 LANGUAGES CXX)
+
+file (COPY ${PROJECT_SOURCE_DIR}/vss_multiple_names.csv DESTINATION ${CMAKE_BINARY_DIR}/bin/)
+file (COPY ${PROJECT_SOURCE_DIR}/vss_unique_names.csv DESTINATION ${CMAKE_BINARY_DIR}/bin/)
+
+# VSS util component test executable
+add_executable(ComponentTest_VSSUtil vss_util_test.cpp)
+
+if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    set(THREADS_PREFER_PTHREAD_FLAG ON)
+    target_link_libraries(ComponentTest_VSSUtil ${CMAKE_THREAD_LIBS_INIT} GTest::GTest)
+    if (WIN32)
+        target_link_libraries(ComponentTest_VSSUtil Ws2_32 Winmm Rpcrt4.lib)
+    else()
+        target_link_libraries(ComponentTest_VSSUtil ${CMAKE_DL_LIBS} rt)
+    endif()
+else()
+    target_link_libraries(ComponentTest_VSSUtil GTest::GTest Rpcrt4.lib)
+endif()
+
+# Add the VSS utility component test
+add_test(NAME ComponentTest_VSSUtil COMMAND ComponentTest_VSSUtil WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
+
+# Execute the test
+add_custom_command(TARGET ComponentTest_VSSUtil POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E env TEST_EXECUTION_MODE=CMake "$<TARGET_FILE:ComponentTest_VSSUtil>" --gtest_output=xml:${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/ComponentTest_VSSUtil.xml
+    VERBATIM
+)
+
+# Build dependencies
+add_dependencies(ComponentTest_VSSUtil  sdv_vss_util) 
+
+

tests/component_tests/vss_util/vss_multiple_names.csv

@@ -0,0 +1,18 @@
+;Class name;Function name;Signal name;vss;Signal direction;type;DBC CAN name includes CAN message name
+;;;;;;;
+VD;SteeringWheel;SteeringWheelAngle_VD;angle_VD;Vehicle.ChassisVD.SteeringWheel.Angle;RX;float;CAN_Input.SteeringWheel
+VD;SteeringWheel;VehicleSpeed_VD;speed_VD;Vehicle.ChassisVD.SteeringWheel.Angle;RX;float;CAN_Input.Speed
+VD;SteeringWheel;VehicleDoor_VD;doorStatus_VD;Vehicle.ChassisVD.SteeringWheel.Angle;RX;uint8;CAN_Input.Door
+VD;SteeringWheel;VehicleWeight_VD;weight_VD;Vehicle.ChassisVD.SteeringWheel.Angle;RX;float;CAN_Input.Weight
+VD;VehicleChassisAxle;RearAxleAngle_VD;rearAngle_VD;Vehicle.ChassisVD.RearAxle.Row.Wheel;TX;float;CAN_Output.RearAngle
+VD;VehicleChassisAxle;ApplicationCounter_VD;liveCounter_VD;Vehicle.ChassisVD.RearAxle.Row.Wheel;TX;uint8;CAN_Output.IsActiveCounter
+VD;VehicleChassisAxle;VehicleFrontLight_VD;frontLightStatus_VD;Vehicle.ChassisVD.RearAxle.Row.Wheel;TX;boolean;CAN_Output.FrontLight
+VD;VehicleChassisAxle;VehicleBackLight_VD;backLightStatus_VD;Vehicle.ChassisVD.RearAxle.Row.Wheel;TX;boolean;CAN_Output.BackLight
+BS;SteeringWheel;SteeringWheelAngle_BS;angle_BS;Vehicle.ChassisBS.SteeringWheel.Angle;RX;float;Vehicle.ChassisVD.SteeringWheel.Angle
+BS;SteeringWheel;VehicleSpeed_BS;speed_BS;Vehicle.ChassisBS.SteeringWheel.Angle;RX;float;Vehicle.ChassisVD.SteeringWheel.Angle
+BS;SteeringWheel;VehicleDoor_BS;doorStatus_BS;Vehicle.ChassisBS.SteeringWheel.Angle;RX;uint8;Vehicle.ChassisVD.SteeringWheel.Angle
+BS;SteeringWheel;VehicleWeight_BS;weight_BS;Vehicle.ChassisBS.SteeringWheel.Angle;RX;float;Vehicle.ChassisVD.SteeringWheel.Angle
+BS;VehicleChassisAxle;RearAxleAngle_BS;rearAngle_BS;Vehicle.ChassisBS.RearAxle.Row.Wheel;TX;float;Vehicle.ChassisVD.RearAxle.Row.Wheel
+BS;VehicleChassisAxle;ApplicationCounter_BS;liveCounter_BS;Vehicle.ChassisBS.RearAxle.Row.Wheel;TX;uint8;Vehicle.ChassisVD.RearAxle.Row.Wheel
+BS;VehicleChassisAxle;VehicleFrontLight_BS;frontLightStatus_BS;Vehicle.ChassisBS.RearAxle.Row.Wheel;TX;boolean;Vehicle.ChassisVD.RearAxle.Row.Wheel
+BS;VehicleChassisAxle;VehicleBackLight_BS;backLightStatus_BS;Vehicle.ChassisBS.RearAxle.Row.Wheel;TX;boolean;Vehicle.ChassisVD.RearAxle.Row.Wheel

tests/component_tests/vss_util/vss_unique_names.csv

@@ -0,0 +1,10 @@
+;Class name;Function name;Signal name;vss;Signal direction;type;DBC CAN name includes CAN message name
+;;;;;;;
+VD;SteeringWheel;SteeringWheelAngle_VD;angle_VD;Vehicle.ChassisVD.SteeringWheel.Angle;RX;float;CAN_Input.SteeringWheel
+VD;Vehicle;VehicleSpeed_VD;speed_VD;Vehicle.ChassisVD.Vehicle.Speed;RX;float;CAN_Input.Speed
+VD;VehicleChassisAxle;RearAxleAngle_VD;rearAngle_VD;Vehicle.ChassisVD.RearAxle.Row.Wheel;TX;float;CAN_Output.RearAngle
+VD;VehicleApplication;ApplicationCounter_VD;liveCounter_VD;Vehicle.SoftwareVD.Application.SystemCounter;TX;uint8;CAN_Output.IsActiveCounter
+BS;SteeringWheel;SteeringWheelAngle_BS;angle_BS;Vehicle.ChassisBS.SteeringWheel.Angle;RX;float;Vehicle.ChassisVD.SteeringWheel.Angle
+BS;Vehicle;VehicleSpeed_BS;speed_BS;Vehicle.ChassisBS.Vehicle.Speed;RX;float;Vehicle.ChassisVD.Vehicle.Speed
+BS;VehicleChassisAxle;RearAxleAngle_BS;rearAngle_BS;Vehicle.ChassisBS.RearAxle.Row.Wheel;TX;float;Vehicle.ChassisVD.RearAxle.Row.Wheel
+BS;VehicleApplication;ApplicationCounter_BS;liveCounter_BS;Vehicle.SoftwareBS.Application.SystemCounter;TX;uint8;Vehicle.SoftwareVD.Application.SystemCounter

tests/component_tests/vss_util/vss_util_test.cpp

@@ -0,0 +1,348 @@
+#include <gtest/gtest.h>
+#include <fstream>
+#include <sstream>
+#include <algorithm>
+#include "../../../global/process_watchdog.h"
+#include "../global/exec_dir_helper.h"
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+class VSSUtilTest : public ::testing::Test
+{
+public:
+    virtual void SetUp() override {}
+
+    virtual void TearDown() override {}
+
+    static void SetUpTestCase()
+    {
+        std::cout << "SetUpTestCase()" << std::endl;
+
+        std::vector<std::string> subFolders = { "generated0", "generated1", "generated2" };
+        for (auto subFolder : subFolders)
+        {
+            auto generatedPath = GetExecDirectory() / subFolder;
+            try
+            {
+                if (std::filesystem::is_directory(generatedPath))
+                {
+                    for (const auto& entry : std::filesystem::directory_iterator(generatedPath))
+                    {
+                        std::filesystem::remove_all(entry.path());
+                    }
+                }
+            }
+            catch (const std::filesystem::filesystem_error& e)
+            {
+                std::cout << "catch (const std::filesystem::filesystem_error& e)" << std::endl;
+                std::cout << "Error removing directory: " << e.what() << '\n';
+            }
+        }
+    }
+
+    static void TearDownTestSuite() {}
+};
+
+
+std::uintmax_t CountNumberOfFiles(const std::filesystem::path allFilesPath)
+{
+    std::uintmax_t allFilesCount = 0;
+    for (const auto& entry : std::filesystem::recursive_directory_iterator(allFilesPath))
+    {
+        if (std::filesystem::is_regular_file(entry.status()))
+        {
+            ++allFilesCount;
+        }
+    }
+    return allFilesCount;
+}
+
+void  DeleteExistingHeaderFiles(const std::filesystem::path allFilesPath)
+{
+    std::string doNotDeleteSignalIdentifier = "signal_identifier.h";
+
+    if (std::filesystem::is_directory(allFilesPath))
+    {
+        for (const auto& entry : std::filesystem::directory_iterator(allFilesPath))
+        {
+            if (entry.path().extension() == ".h")
+            {
+                if (entry.path().filename() != doNotDeleteSignalIdentifier)
+                {
+                    try
+                    {
+                        std::filesystem::remove(entry.path());
+                        std::cout << "File deleted: " << entry.path().filename().string() << std::endl;
+                    } catch (const std::filesystem::filesystem_error&)
+                    {
+                        std::cout << "Failed to delete: " << entry.path().filename().string() << std::endl;
+                    }
+                }
+            }
+        }
+    }
+}
+
+void DeletePSAndSerdesFolder(const std::filesystem::path allFilesPath)
+{
+    auto psFolder = allFilesPath / "ps";
+    auto serdesolder = allFilesPath / "serdes";
+    if (std::filesystem::is_directory(psFolder))
+    {
+        try
+        {
+            std::filesystem::remove_all(psFolder);
+        }
+        catch (const std::filesystem::filesystem_error& e)
+        {
+            std::cout << "catch (const std::filesystem::filesystem_error& e)" << std::endl;
+            std::cout << "Error removing directory: " << e.what() << '\n';
+        }
+    }
+    if (std::filesystem::is_directory(serdesolder))
+    {
+        try
+        {
+            std::filesystem::remove_all(serdesolder);
+        }
+        catch (const std::filesystem::filesystem_error& e)
+        {
+            std::cout << "catch (const std::filesystem::filesystem_error& e)" << std::endl;
+            std::cout << "Error removing directory: " << e.what() << '\n';
+        }
+    }
+}
+
+std::filesystem::path GetExportFolder(std::filesystem::path folder)
+{
+    while (!folder.empty())
+    {
+        auto exportFolder = folder / "export";
+        if (std::filesystem::is_directory(exportFolder))
+            return exportFolder;
+        folder = folder.parent_path();
+    }
+
+    return {};
+}
+
+/**
+ * @brief Build the command line by quoting all arguments. This is the one argument function.
+ * @param[in] rssArg The argument to quote.
+ * @return The quoted argument.
+ */
+inline std::string BuildCommandLine(const std::string& rssArg)
+{
+    return std::string("\"") + rssArg + std::string("\"");
+}
+
+/**
+ * @brief Build the command line by quoting all arguments. This is the multiple argument function.
+ * @tparam ...TArgs Argument types. Needs to be implicitly convertable to std::string.
+ * @param[in] rssArg The one argument to quote.
+ * @param[in] rgtArgs The other arguments to quote.
+ * @return The command line with the quoted arguments.
+ */
+template <typename... TArgs>
+inline std::string BuildCommandLine(const std::string& rssArg, const TArgs&... rgtArgs)
+{
+    return std::string("\"") + rssArg + std::string("\" ") + BuildCommandLine(rgtArgs...);
+}
+
+/**
+ * @brief Platform specific implementation for executing command having space in the command path and in the parameters.
+ * @tparam ...TArgs
+ * @param[in] rssCommand The command line string.
+ * @param[in] rgtArgs List of string arguments.
+ * @return The result of the application or -1 when the application could not be started.
+ */
+template <typename... TArgs>
+inline int ExecuteCommand(const std::string& rssCommand, const TArgs&... rgtArgs)
+{
+    // Build the command line by quoting each argument.
+    std::string ssFullCommand = BuildCommandLine(rssCommand, rgtArgs...);
+
+    // NOTE: The std::system command is a bit peculiar when dealing with spaces int he path name under Windows. Even though each
+    // command line argument is quoted, the quotes are removed before the command line is supplied to CMD /C. To solve this issue
+    // add additional quotes at the beginning and end of the complete command line: \"app arg1 arg2 arg3\". See also:
+    // https://stackoverflow.com/questions/27975969/how-to-run-an-executable-with-spaces-using-stdsystem-on-windows
+    // --> This seems to work with the std::system of MSVC, not not of MINGW!
+    // --> For MINGW there is no solution... use platform specific solution is the advice.
+
+#ifdef _WIN32
+    STARTUPINFOA si{};
+    PROCESS_INFORMATION pi{};
+    si.cb = sizeof(si);
+
+    // Convert std::string to LPSTR
+    LPSTR szCommand = const_cast<char*>(ssFullCommand.c_str());
+
+    // Start the child process
+    if (!CreateProcessA(NULL, szCommand, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
+    {
+        std::cerr << "CreateProcess failed (" << GetLastError() << ")." << std::endl;
+        return -1;
+    }
+
+    // Wait until child process exits
+    WaitForSingleObject(pi.hProcess, INFINITE);
+
+    // Get the exit code
+    int iRet = 0;
+    GetExitCodeProcess(pi.hProcess, reinterpret_cast<DWORD*>(&iRet));
+
+    // Close process and thread handles
+    CloseHandle(pi.hProcess);
+    CloseHandle(pi.hThread);
+
+    return iRet;
+#elif defined __unix__
+    return std::system(ssFullCommand.c_str());
+#else
+#error The OS is not supported!
+#endif
+}
+
+int CreateCode(const std::string& document, const std::string& subfolder, const bool bCreateComponents)
+{
+    auto vssUtility = (GetExecDirectory() / "../../bin/sdv_vss_util").lexically_normal();
+    auto documentPath = (GetExecDirectory() / "../../bin" / document).lexically_normal();
+    auto outputFolder = (GetExecDirectory() / subfolder).lexically_normal();
+
+    // VSS_Sheet_Single.csv -O${VSSUTIL_OUTPUT_DIRECTORY}/generated/  --version1.0.0.2  --prefixdemo  --enable_components
+    if (bCreateComponents)
+    {
+        return ExecuteCommand(vssUtility.generic_string(), documentPath.generic_string(), std::string("-O") + outputFolder.generic_string(),
+            std::string("--enable_components"), std::string("--prefixdemo"), std::string("--version1.2.3.4"), std::string("--silent"));//
+    }
+
+
+    return ExecuteCommand(vssUtility.generic_string(), documentPath.generic_string(), std::string("-O") + outputFolder.generic_string(),
+        std::string("--prefixdemo"),  std::string("--version1.2.3.4"), std::string("--silent"));
+}
+
+int CompileIDLFiles(const std::filesystem::path allFilesPath)
+{
+    bool noFilesFound = true;
+    int result = 0;
+    auto idlCompiler = GetExecDirectory() / "../../bin/sdv_idl_compiler";
+    auto idlFiles = allFilesPath / "vss_files";
+
+    for (const auto& entry : std::filesystem::directory_iterator(idlFiles))
+    {
+        if (!entry.is_regular_file() || entry.path().extension() != ".idl") continue;
+        noFilesFound = false;
+
+        std::cout << "Call IDL Compiler for file " << entry.path().filename().string() << std::endl;
+
+        // C:/Data/out/build/x64-Debug/tests/bin/../../bin/sdv_idl_compiler "../tests/bin/generated2/vss_files/VSS_VehicleVehicleDrivetrainTransmissionIsParkLockEngaged_tx.idl"
+        // -O../tests/bin/generated2/vss_files -I../tests/bin/generated2/vss_files -I../../../../export
+        result += ExecuteCommand(idlCompiler.lexically_normal().generic_string(),
+            (idlFiles.lexically_normal() / entry.path().filename()).generic_string(),
+            std::string("-O") + idlFiles.lexically_normal().generic_string(),
+            std::string("-I") + idlFiles.lexically_normal().generic_string(),
+            std::string("-I") + GetExportFolder(allFilesPath).lexically_normal().generic_string());
+    }
+    if (noFilesFound)
+    {
+        return 1;
+    }
+    return result;
+}
+
+TEST_F(VSSUtilTest, CreateCodeValidateGeneratedFilesUniqueSignalNamesNoComponents)
+{
+    EXPECT_EQ(0, CreateCode("vss_unique_names.csv", "generated0", false));
+
+    // files created by VSS_DifferentVDandBSSingleSignals.csv
+    // find expected IDL files and check number of files in folder 'generated0'
+    std::filesystem::path allFilesPath = GetExecDirectory() / "generated0";
+    std::filesystem::path vssFilePath = allFilesPath / "vss_files";
+    std::filesystem::path signalIdentifierVDFilePath = vssFilePath / "signal_identifier.h";
+    std::filesystem::path summaryVDFilePath = vssFilePath / "summary.txt";
+
+    EXPECT_TRUE(std::filesystem::exists(summaryVDFilePath));
+    EXPECT_TRUE(std::filesystem::exists(signalIdentifierVDFilePath));
+
+    std::uintmax_t allFilesCount = CountNumberOfFiles(allFilesPath);
+
+    // 4 signals, but they are combined in the same vss definition so we have 1 rx and 1 tx
+    uint32_t signals = 4; // 8 header files *.h + 0 cpp files *.cpp  + 0 cmake files + 8 *.idl + 2 * identifier.h + 2 * summary.txt
+    uint32_t expected = 2 * signals + 2;
+    EXPECT_EQ(allFilesCount, expected);
+
+    auto result = CompileIDLFiles(allFilesPath);
+    EXPECT_EQ(0, result);
+
+    DeletePSAndSerdesFolder(vssFilePath); // created by the idl compiler
+    allFilesCount = CountNumberOfFiles(allFilesPath);
+    EXPECT_EQ(allFilesCount, expected + (2 * signals)); // + compiled header files
+}
+
+TEST_F(VSSUtilTest, ValidateGeneratedFilesUniqueSignalNames)
+{
+    EXPECT_EQ(0, CreateCode("vss_unique_names.csv", "generated1", true));
+
+    // files created by VSS_DifferentVDandBSSingleSignals.csv
+    // find expected IDL files and check number of files in folder 'generated1'
+    std::filesystem::path allFilesPath = GetExecDirectory() / "generated1";
+    std::filesystem::path vssFilePath = allFilesPath / "vss_files";
+    std::filesystem::path signalIdentifierVDFilePath = vssFilePath / "signal_identifier.h";
+    std::filesystem::path summaryVDFilePath = vssFilePath / "summary.txt";
+
+    EXPECT_TRUE(std::filesystem::exists(summaryVDFilePath));
+    EXPECT_TRUE(std::filesystem::exists(signalIdentifierVDFilePath));
+
+    std::uintmax_t allFilesCount = CountNumberOfFiles(allFilesPath);
+
+    // 4 signals, but they are combined in the same vss definition so we have 1 rx and 1 tx
+    uint32_t signals = 4; // 2 header files *.h + 2 cpp files *.cpp  + 2 cmake files + 2 *.idl + 2 * identifier.h + 2 * summary.txt
+    uint32_t expected =      2 * signals        + 2 * signals        + 2 *signals       + (2 * signals) + 2;
+    EXPECT_EQ(allFilesCount, expected);
+
+    auto result = CompileIDLFiles(allFilesPath);
+    EXPECT_EQ(0, result);
+
+    DeletePSAndSerdesFolder(vssFilePath); // created by the idl compiler
+    allFilesCount = CountNumberOfFiles(allFilesPath);
+    EXPECT_EQ(allFilesCount, expected + (2 * signals)); // + compiled header files
+}
+
+TEST_F(VSSUtilTest, ValidateGeneratedFilesCombinedSignalNames)
+{
+    EXPECT_EQ(0, CreateCode("vss_multiple_names.csv", "generated2", true));
+
+    // files created by VSS_DifferentVDandBSMultipleSignals.csv
+    // find expected IDL files and check number of files in folder 'generated2'
+    std::filesystem::path allFilesPath = GetExecDirectory() / "generated2";
+    std::filesystem::path vssFilePath = allFilesPath / "vss_files";
+    std::filesystem::path signalIdentifierVDFilePath = vssFilePath / "signal_identifier.h";
+    std::filesystem::path summaryVDFilePath = vssFilePath / "summary.txt";
+
+    EXPECT_TRUE(std::filesystem::exists(summaryVDFilePath));
+    EXPECT_TRUE(std::filesystem::exists(signalIdentifierVDFilePath));
+
+    std::uintmax_t allFilesCount = CountNumberOfFiles(allFilesPath);
+
+    // 4 signals, but they are combined in the same vss definition so we have 1 rx and 1 tx
+    uint32_t signals = 2; // 2 signals = 4 *.h + 4 *.cpp + 4 cmakelists + 4 *.idl + 2 * identifier.h + 2 * summary.txt
+    uint32_t expected = (2 * signals) + (2 * signals) + (2 * signals) + (2 * signals) + 2;
+    EXPECT_EQ(allFilesCount, expected);
+
+    EXPECT_EQ(0, CompileIDLFiles(allFilesPath));
+
+    DeletePSAndSerdesFolder(vssFilePath); // created by the idl compiler
+    allFilesCount = CountNumberOfFiles(allFilesPath);
+    EXPECT_EQ(allFilesCount, expected + (2 * signals));
+}
+
+extern "C" int main(int argc, char* argv[])
+{
+    CProcessWatchdog watchdog;
+
+    ::testing::InitGoogleTest(&argc, argv);
+    int result = RUN_ALL_TESTS();
+
+    return result;
+}