Add testing support to the LLServer & Fix Sequencemanager bug (#7)

Adds testing support and refactors file I/O to enable unit tests for the LLServer’s SequenceManager, fixes the “start” bug, and ensures the “END” field is executed.
- Introduce JSON test data and GoogleTest cases for SequenceManager behavior
- Replace direct filesystem calls with a FileSystemAbstraction singleton for mocking
- Update SequenceManager to use the new abstraction, add interpolation helpers, and correct timing

Author: raffael0

.github/workflows/gtest.yml

@@ -0,0 +1,31 @@
+name: Run GTests
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+jobs:
+  build-and-test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          submodules: 'true'
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y cmake ninja-build g++ 
+
+      - name: Configure with CMake Preset
+        run: cmake --preset=local-dev
+
+      - name: Build
+        run: cmake --build build
+
+      - name: Run tests
+        run: |
+          cd build
+          ctest --output-on-failure

CMakeLists.txt

@@ -9,7 +9,8 @@ set(CMAKE_CXX_FLAGS  "${CMAKE_CXX_FLAGS} -Wall")
 
 include_directories(include include/can_houbolt)
 
-file(GLOB_RECURSE sources main.cpp src/*.cpp src/*.c include/*.h)
+file(GLOB_RECURSE sources src/*.cpp src/*.c include/*.h)
+
 
 if(NO_PYTHON)
   MESSAGE(STATUS "Python features are not used")
@@ -20,10 +21,17 @@ else()
   include_directories(${Python3_INCLUDE_DIRS})
 endif()
 
-add_executable(${PROJECT_NAME} ${sources})
+# Define a library for the main project
+add_library(${PROJECT_NAME}_lib STATIC ${sources})
 
-option(TEST "test with simple CAN Driver simulation" OFF)
-if(TEST)
+# Create an executable that links to this library
+add_executable(${PROJECT_NAME} main.cpp)
+target_link_libraries(${PROJECT_NAME} PRIVATE ${PROJECT_NAME}_lib)
+option(E2E_TEST  "test with simple CAN Driver simulation" OFF)
+option(NO_INFLUX "Disable influxdb logging" OFF)
+option(NO_CANLIB "Disable Kvaser CANLIB" OFF)
+option(NO_PYTHON "Disable Python" OFF)
+if(E2E_TEST)
    add_compile_definitions(TEST_LLSERVER)
 endif()
 
@@ -42,7 +50,7 @@ if(UNIX AND NOT APPLE)
 endif()
 
 if(LINUX)
-   target_link_libraries(${PROJECT_NAME} PRIVATE Threads::Threads -lstdc++fs -latomic)
+   target_link_libraries(${PROJECT_NAME} PRIVATE Threads::Threads -latomic)
 
    if(NOT NO_CANLIB)
       target_link_libraries(${PROJECT_NAME} PRIVATE -lcanlib)
@@ -53,3 +61,8 @@ if(LINUX)
 else()
    target_link_libraries(${PROJECT_NAME} PRIVATE Threads::Threads)
 endif()
+
+if(TEST)
+    enable_testing()
+    add_subdirectory(tests)
+endif ()

CMakePresets.json

@@ -18,6 +18,19 @@
         "NO_INFLUX": "ON",
         "CMAKE_BUILD_TYPE": "Debug"
       }
+    },
+    {
+      "name": "release",
+      "displayName": "Release",
+      "description": "Release build ",
+      "generator": "Ninja",
+      "binaryDir": "${sourceDir}/releaseBuild",
+      "cacheVariables": {
+        "NO_PYTHON": "OFF",
+        "NO_CANLIB": "OFF",
+        "NO_INFLUX": "OFF",
+        "CMAKE_BUILD_TYPE": "Release"
+      }
     }
   ]
 }

include/EventManager.h

@@ -51,26 +51,28 @@ class EventManager : public Singleton<EventManager>
     double GetArgument(const std::string &stateName, nlohmann::json& param, double& newValue);
     void GetArgumentList(const std::string &stateName, nlohmann::json& event, std::vector<double>& argumentList, double& newValue);
 
-    ~EventManager();
 public:
-
-    void Init(Config &config);
+    virtual void Init(Config &config);
 
     /**
      * this is used, so mapping and command loading don't need to be done at the same time,
      * this way, the event manager doesn't need to call any classes below the llinterface
      */
-    void Start();
+    virtual void Start();
+
+    virtual void AddChannelTypes(std::map<std::string, std::string>& channelTypes);
+
+    virtual void AddCommands(std::map<std::string, command_t> commands);
+
+    virtual std::map<std::string, command_t> GetCommands();
 
-    void AddChannelTypes(std::map<std::string, std::string>& channelTypes);
-    void AddCommands(std::map<std::string, command_t> commands);
-    std::map<std::string, command_t> GetCommands();
-    void OnStateChange(const std::string& stateName, double oldValue, double newValue);
+    virtual void OnStateChange(const std::string& stateName, double oldValue, double newValue);
 
-    void ExecuteRegexCommandOrState(const std::string &regexKey, nlohmann::json &events, const std::string &stateName, double oldValue, double newValue, bool testOnly);
-    void ExecuteCommandOrState(const std::string &stateName, double oldValue, double newValue, bool useDefaultMapping, bool testOnly);
-    void ExecuteCommand(const std::string &commandName, std::vector<double> &params, bool testOnly);
+    virtual void ExecuteRegexCommandOrState(const std::string &regexKey, nlohmann::json &events, const std::string &stateName, double oldValue, double newValue, bool testOnly);
+    virtual void ExecuteCommandOrState(const std::string &stateName, double oldValue, double newValue, bool useDefaultMapping, bool testOnly);
+    virtual void ExecuteCommand(const std::string &commandName, std::vector<double> &params, bool testOnly);
 
+    virtual ~EventManager();
 
 };
 #endif //LLSERVER_ECUI_HOUBOLT_EVENTMANAGER_H

include/LLInterface.h

@@ -46,26 +46,26 @@ class LLInterface : public Singleton<LLInterface>
 		static nlohmann::json StatesToJson(std::map<std::string, std::tuple<double, uint64_t>> &states);
 		static nlohmann::json StatesToJson(std::map<std::string, std::tuple<double, uint64_t, bool>> &states);
 
-		~LLInterface();
+public:
+		virtual ~LLInterface();
 
-	public:
-		void Init(Config &config);
+		virtual void Init(Config &config);
 
-		nlohmann::json GetGUIMapping();
+		virtual nlohmann::json GetGUIMapping();
 
-		void TransmitStates(int64_t microTime, std::map<std::string, std::tuple<double, uint64_t>> &states);
+		virtual void TransmitStates(int64_t microTime, std::map<std::string, std::tuple<double, uint64_t>> &states);
 
-		void StartStateTransmission(Config &config);
-		void StopStateTransmission();
+		virtual void StartStateTransmission(Config &config);
+		virtual void StopStateTransmission();
 
-		nlohmann::json GetAllStates();
-		nlohmann::json GetAllStateLabels();
+		virtual nlohmann::json GetAllStates();
+		virtual nlohmann::json GetAllStateLabels();
 
-		nlohmann::json GetStates(nlohmann::json &stateNames);
-		void SetState(std::string stateName, double value, uint64_t timestamp);
+		virtual nlohmann::json GetStates(nlohmann::json &stateNames);
+		virtual void SetState(std::string stateName, double value, uint64_t timestamp);
 
-		void ExecuteCommand(std::string &commandName, std::vector<double> &params, bool testOnly);
-		std::map<std::string, command_t> GetCommands();
+		virtual void ExecuteCommand(std::string &commandName, std::vector<double> &params, bool testOnly);
+		virtual std::map<std::string, command_t> GetCommands();
 
-		std::map<std::string, std::tuple<double, uint64_t>> GetLatestSensorData();
+		virtual std::map<std::string, std::tuple<double, uint64_t>> GetLatestSensorData();
 };

include/SequenceManager.h

@@ -2,6 +2,8 @@
 
 #include "common.h"
 #include <atomic>
+#include <optional>
+#include <utility/FileSystemAbstraction.h>
 
 #include "utility/json.hpp"
 #include "utility/Logging.h"
@@ -59,6 +61,36 @@ class SequenceManager : public Singleton<SequenceManager>
 
 		void plotMaps(uint8_t option);
 
+		/**
+		 * Interpolate linearly between start and end values.
+		 *
+		 * @param startTimeAndValues A tuple containing the start time and values.
+		 *                           The first element is the start time,
+		 *                           and the second element is a vector of values.
+		 * @param endTimeAndValues   An optional tuple containing the end time and values.
+		 *                           The first element is the end time,
+		 *                           and the second element is a vector of values.
+		 * @param currentTime        The current time.
+		 * @return A tuple containing:
+		 *         - A vector of interpolated values, if one could be computed.
+		 *         - A boolean indicating whether the interpolation is complete. If true,
+		 *           the end value should be used as the new start value for the next interpolation.
+		 */
+		static std::tuple<std::optional<std::vector<double>>, bool> interpolateLinear(
+			const std::tuple<int64_t, std::vector<double>> &startTimeAndValues,
+			const std::optional<std::tuple<int64_t, std::vector<double>>>& endTimeAndValues,
+			int64_t currentTime
+		);
+
+		/**
+		 * No interpolation. Conforms to the api of interpolateLinear.
+		 */
+		static std::tuple<std::optional<std::vector<double>>, bool> interpolateNone(
+			const std::tuple<int64_t, std::vector<double>> &startTimeAndValues,
+			const std::optional<std::tuple<int64_t, std::vector<double>>>& endTimeAndValues,
+			int64_t currentTime
+		);
+
 		bool sequenceRunning = false;
 		bool sequenceToStop = false;
 
@@ -76,10 +108,10 @@ class SequenceManager : public Singleton<SequenceManager>
 		nlohmann::json jsonSequence = nlohmann::json::object();
 		nlohmann::json jsonAbortSequence = nlohmann::json::object();
 
-		std::string comments = "";
-		std::string currentDirPath = "";
-		std::string logFileName = "";
-		std::string lastDir = "";
+		std::string comments;
+		std::string currentDirPath;
+		std::string logFileName;
+		std::string lastDir;
 
 		std::atomic_bool isInitialized = false;
 
@@ -95,6 +127,7 @@ class SequenceManager : public Singleton<SequenceManager>
 
 		LLInterface *llInterface = nullptr;
 		EventManager *eventManager = nullptr;
-		
+		FileSystemAbstraction *fileSystem = nullptr;
+
 		std::thread sequenceThread;
 };

include/driver/Socket.h

@@ -31,7 +31,7 @@ class Socket
 
     ~Socket();
 
-    void Send(std::string msg);
+    void Send(const std::string &msg);
     std::string Recv();
     // std::vector<uint8_t> RecvBytes();
     bool isConnectionActive();

include/utility/Config.h

@@ -11,7 +11,7 @@
 
 class Config
 {
-	private:
+	protected:
 	    static const std::string CONFIG_FILE_NAME;
     	static const std::string MAPPING_FILE_NAME;
 

include/utility/Debug.h

@@ -5,15 +5,14 @@
 #ifndef TXV_ECUI_LLSERVER_DEBUG_H
 #define TXV_ECUI_LLSERVER_DEBUG_H
 
+#include <cstdint>
+#include <cstdio>
+#include <fstream>
 #include <mutex>
+#include <sstream>
 #include <string>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdarg.h>
-#include <unistd.h>
 #include <thread>
-#include <fstream>
-#include <sstream>
+#include <unistd.h>
 
 #include "common.h"
 #include "utility/Config.h"
@@ -47,14 +46,14 @@ class Debug {
 
     static void close();
     static void flush();
-    static void changeOutputFile(std::string outFilePath);
-    static void log(std::string msg);
+    static void changeOutputFile(const std::string &outFilePath);
+    static void log(const std::string &msg);
 
-    static int32_t print(std::string fmt, ...);
+    static int32_t print(const std::string &fmt, ...);
     static int32_t printNoTime(std::string fmt, ...);
-    static int32_t error(std::string fmt, ...);
-    static int32_t info(std::string fmt, ...);
-    static int32_t warning(std::string fmt, ...);
+    static int32_t error(const std::string &fmt, ...);
+    static int32_t info(const std::string &fmt, ...);
+    static int32_t warning(const std::string& fmt, ...);
 
 };
 

include/utility/FileSystemAbstraction.h

@@ -0,0 +1,27 @@
+#ifndef FILESYSTEM_H
+#define FILESYSTEM_H
+
+#include <string>
+
+#include "utility/Singleton.h"
+
+class FileSystemAbstraction : public  Singleton<FileSystemAbstraction> {
+ friend class Singleton;
+
+public:
+ virtual ~FileSystemAbstraction() = default;
+
+ virtual std::string LoadFile(const std::string &filePath);
+
+ virtual void SaveFile(const std::string &filePath, const std::string &content);
+
+ virtual void CopyFile(const std::string &src, const std::string &dst);
+
+ virtual void CreateDirectory(const std::string &dirPath);
+
+};
+
+
+
+
+#endif //FILESYSTEM_H