add unit tests for data sharing mechanisms

Joaopmoliveira · Joaopmoliveira · commit 71107a87209d · 2025-01-06T23:38:09.000Z
diff --git a/libraries/utils/include/utils/FileStructures.h b/libraries/utils/include/utils/FileStructures.h
@@ -17,6 +17,8 @@ namespace curan
             Eigen::Matrix<double, 4, 4> f_homogeneous_transformation;
             double f_optimization_error;
 
+            void decode(std::istream &instream);
+
         public:
             UltrasoundCalibrationData(const std::string &in_timestamp,
                                       const Eigen::Matrix<double, 4, 4> &in_homogeneous_transformation,
@@ -28,6 +30,8 @@ namespace curan
 
             UltrasoundCalibrationData(const std::string &path);
 
+            UltrasoundCalibrationData(std::istream &instream);
+
             std::string timestamp() const;
 
             Eigen::Matrix<double, 4, 4> homogeneous_transformation() const;
@@ -52,6 +56,8 @@ namespace curan
             double f_registration_error;
             Type f_registration_type = Type::LANDMARK;
 
+            void decode(std::istream &instream);
+
         public:
             RegistrationData(const std::string &in_timestamp,
                              const Eigen::Matrix<double, 4, 4> &in_moving_to_fixed_transform,
@@ -65,6 +71,8 @@ namespace curan
 
             RegistrationData(const std::string &path);
 
+            RegistrationData(std::istream &instream);
+
             std::string timestamp() const;
 
             Eigen::Matrix<double, 4, 4> moving_to_fixed_transform() const;
@@ -82,6 +90,8 @@ namespace curan
             Eigen::Matrix<double, 4, 4> f_needle_homogeneous_transformation;
             double f_optimization_error;
 
+            void decode(std::istream &instream);
+
         public:
             NeedleCalibrationData(const std::string &in_timestamp,
                                   const Eigen::Matrix<double, 4, 4> &in_needle_homogeneous_transformation,
@@ -93,6 +103,8 @@ namespace curan
 
             NeedleCalibrationData(const std::string &path);
 
+            NeedleCalibrationData(std::istream &instream);
+
             std::string timestamp() const;
 
             Eigen::Matrix<double, 4, 4> needle_calibration() const;
@@ -110,6 +122,8 @@ namespace curan
             Eigen::Matrix<double, 3, 3> f_desired_orientation;
             std::string f_path_to_image;
 
+            void decode(std::istream &instream);
+
         public:
             TrajectorySpecificationData(const std::string &in_timestamp,
                                         const Eigen::Matrix<double, 3, 1> &in_target,
@@ -125,6 +139,8 @@ namespace curan
 
             TrajectorySpecificationData(const std::string &path);
 
+            TrajectorySpecificationData(std::istream &instream);
+
             std::string timestamp() const;
 
             Eigen::Matrix<double, 3, 1> target() const;
diff --git a/libraries/utils/src/FileStructures.cpp b/libraries/utils/src/FileStructures.cpp
@@ -15,11 +15,18 @@ namespace curan
         {
             nlohmann::json calibration_data;
             std::ifstream in(path);
-
             if (!in.is_open())
                 throw std::runtime_error("failure to open configuration file");
+            decode(in);
+        }
+
+        UltrasoundCalibrationData::UltrasoundCalibrationData(std::istream &instream){
+            decode(instream);
+        }
 
-            in >> calibration_data;
+        void UltrasoundCalibrationData::decode(std::istream &instream){
+            nlohmann::json calibration_data;
+            instream >> calibration_data;
             f_timestamp = calibration_data["timestamp"];
             std::string homogenenous_transformation = calibration_data["homogeneous_transformation"];
             f_optimization_error = calibration_data["optimization_error"];
@@ -36,6 +43,8 @@ namespace curan
                     f_homogeneous_transformation(row, col) = calibration_matrix(row, col);
         }
 
+        
+
         std::string UltrasoundCalibrationData::timestamp() const
         {
             return f_timestamp;
@@ -78,7 +87,16 @@ namespace curan
             if (!in.is_open())
                 throw std::runtime_error("failure to open configuration file");
 
-            in >> registration_data;
+            decode(in);
+        }
+
+        RegistrationData::RegistrationData(std::istream &instream){
+            decode(instream);
+        }
+
+        void RegistrationData::decode(std::istream &instream){
+            nlohmann::json registration_data;
+            instream >> registration_data;
 
             if (auto search = conversion_to_type.find(registration_data["type"]); search != conversion_to_type.end())
                 f_registration_type = search->second;
@@ -144,7 +162,17 @@ namespace curan
             if (!in.is_open())
                 throw std::runtime_error("failure to open configuration file");
 
-            in >> needle_calibration_data;
+            decode(in);
+        }
+
+        NeedleCalibrationData::NeedleCalibrationData(std::istream &instream)
+        {
+            decode(instream);
+        }
+
+        void NeedleCalibrationData::decode(std::istream &instream){
+            nlohmann::json needle_calibration_data;
+            instream >> needle_calibration_data;
             f_timestamp = needle_calibration_data["timestamp"];
             std::string homogenenous_transformation = needle_calibration_data["needle_homogeneous_transformation"];
             f_optimization_error = needle_calibration_data["optimization_error"];
@@ -196,8 +224,17 @@ namespace curan
             std::ifstream in(path);
             if (!in.is_open())
                 throw std::runtime_error("failure to open configuration file");
+            decode(in);
+        }
 
-            in >> trajectory_data;
+        TrajectorySpecificationData::TrajectorySpecificationData(std::istream &instream)
+        {
+            decode(instream);
+        }
+
+        void TrajectorySpecificationData::decode(std::istream &instream){
+            nlohmann::json trajectory_data;
+            instream >> trajectory_data;
 
             std::stringstream ss;
             std::string target = trajectory_data["target"];
diff --git a/tests/utilities/testing_cpp_mechanics.cpp b/tests/utilities/testing_cpp_mechanics.cpp
@@ -2,134 +2,16 @@
 #include <string>
 #include <chrono>
 #include <thread>
+#include "utils/DateManipulation.h"
 
-class MemoryOwner // this is a naive implementation of a memory owner, simillar to a shared pointer
-{
-  struct ControlBlock
-  {
-    std::atomic<size_t> counter = 1;
-
-    void increment()
-    {
-      counter.fetch_add(1);
-    }
-
-    bool decrement()
-    {
-      return counter.fetch_sub(1)-1 == 0;
-    }
-  };
-  public:
-  void *pointer_to_data;
-  size_t block_of_memory;
-
-  MemoryOwner() : pointer_to_data{nullptr}, control_block{nullptr}
-  {
-    std::cout << "alocated MemoryOwner()" << std::endl;
-    control_block = new ControlBlock{};
-    print_addresses();
-  }
-
-  MemoryOwner(size_t block_size) : pointer_to_data{nullptr}, control_block{nullptr}
-  {
-    std::cout << "alocated MemoryOwner(size_t block_size)" << std::endl;
-    control_block = new ControlBlock{};
-    pointer_to_data = new unsigned char[block_size]{};
-    block_of_memory = block_size;
-    print_addresses();
-  }
-
-  MemoryOwner(const MemoryOwner &other) : pointer_to_data{nullptr}, control_block{nullptr}
-  {
-    std::cout << "alocated MemoryOwner(const MemoryOwner &other)" << std::endl;
-    control_block = other.control_block;
-    control_block->increment();
-    pointer_to_data = other.pointer_to_data;
-    print_addresses();
-  }
-
-  MemoryOwner &operator=(const MemoryOwner &other)
-  {
-    std::cout << "copied MemoryOwner &operator=(const MemoryOwner &other)" << std::endl;
-    decrement();
-    control_block = other.control_block;
-    control_block->increment();
-    pointer_to_data = other.pointer_to_data;
-    print_addresses();
-  }
-
-  MemoryOwner(MemoryOwner &&other) : pointer_to_data{nullptr}, control_block{nullptr}
-  {
-    std::cout << "alocated MemoryOwner(MemoryOwner &&other)" << std::endl;
-    control_block = other.control_block;
-    control_block->increment();
-    pointer_to_data = other.pointer_to_data;
-    print_addresses();
-  }
-
-  MemoryOwner &operator=(MemoryOwner &&other)
-  {
-    std::cout << "copied MemoryOwner &operator=(MemoryOwner &&other)" << std::endl;
-    decrement();
-    control_block = other.control_block;
-    control_block->increment();
-    pointer_to_data = other.pointer_to_data;
-    print_addresses();
-  }
-
-  ~MemoryOwner()
-  {
-    decrement();
-    std::cout << "destructor ~MemoryOwner()" << std::endl;
-  }
-
-  void Alloc(size_t size)
-  {
-    decrement();
-    control_block = new ControlBlock{};
-    pointer_to_data = new unsigned char[size]{};
-    block_of_memory = size;
-    std::cout << "raw Alloc(size_t size)" << std::endl;
-    print_addresses();
-  }
-
-  void* data(){
-    return pointer_to_data;
-  }
-
-  size_t size(){
-    return block_of_memory;
-  }
+int main(){
+    try{
+        std::cout << curan::utilities::formated_date<std::chrono::system_clock>(std::chrono::system_clock::time_point(std::chrono::system_clock::duration(0))) << std::endl;
 
-private:
-  void decrement()
-  {
-    if (control_block->decrement())
-    {
-      print_addresses();
-      if (pointer_to_data){
-        std::cout << "decrement(): deleting block of memory" << std::endl;
-        delete[] pointer_to_data;
-      }
-      std::cout << "decrement(): deleting control block" << std::endl;
-      delete control_block;
-    }
-    pointer_to_data = nullptr;
-    control_block = nullptr;
-  }
-  ControlBlock *control_block;
+        std::cout << curan::utilities::formated_date<std::chrono::system_clock>(std::chrono::system_clock::time_point(std::chrono::system_clock::duration(std::chrono::seconds(1000000000)))) << std::endl;
 
-  void print_addresses(){
-    std::printf("(this: %p) (pointer_to_data:%p) (control_block:%p)\n",this,pointer_to_data,control_block);
-  }
-};
+        std::cout << curan::utilities::formated_date<std::chrono::system_clock>(std::chrono::system_clock::time_point(std::chrono::system_clock::duration(1000000000))) << std::endl;
 
-int main(){
-    try{
-        MemoryOwner owner;
-        MemoryOwner owner2{10};
-        MemoryOwner copied_owner{owner};
-        MemoryOwner copied_owner2{owner2};
     } catch (std::runtime_error &e){
         std::cout << "exception: " << e.what() << std::endl;
         return 2;
diff --git a/unittests/utils/CMakeLists.txt b/unittests/utils/CMakeLists.txt
@@ -18,4 +18,8 @@ gtest_discover_tests(MemoryUtils)
 
 add_executable(DateFormater date_formater.cpp)
 target_link_libraries(DateFormater GTest::gtest_main utils)
-gtest_discover_tests(DateFormater)
+gtest_discover_tests(DateFormater)
+
+add_executable(FileSharing file_data.cpp)
+target_link_libraries(FileSharing GTest::gtest_main utils)
+gtest_discover_tests(FileSharing)
diff --git a/unittests/utils/date_formater.cpp b/unittests/utils/date_formater.cpp
@@ -2,6 +2,8 @@
 #include <gtest/gtest.h>
 
 TEST(UnitTestDateFormater, DateFormater){
-    auto current_date = curan::utilities::formated_date<std::chrono::system_clock>(std::chrono::system_clock::now());
-
+    const std::string expected{"1970-01-01 00:00:00"}; 
+    EXPECT_EQ(curan::utilities::formated_date<std::chrono::system_clock>(std::chrono::system_clock::time_point(std::chrono::system_clock::duration(0))), expected);
+    const std::string expected2{"2001-09-09 02:46:40"};
+    EXPECT_EQ(curan::utilities::formated_date<std::chrono::system_clock>(std::chrono::system_clock::time_point(std::chrono::system_clock::duration(std::chrono::seconds(1000000000)))), expected2);
 }
diff --git a/unittests/utils/file_data.cpp b/unittests/utils/file_data.cpp
@@ -0,0 +1,59 @@
+#include "utils/FileStructures.h"
+#include <gtest/gtest.h>
+
+const std::string date{"1970-01-01 00:00:00"};
+
+TEST(UnitTestFilePropagator, NeedleCalibrationData)
+{
+    for (size_t run_n_times = 0; run_n_times < 20; ++run_n_times)
+    {
+        Eigen::Matrix<double, 4, 4> transform = Eigen::Matrix<double, 4, 4>::Identity();
+        curan::utilities::NeedleCalibrationData source_needle_calib(date, transform, 1.0);
+        std::stringstream mock_file;
+        mock_file << source_needle_calib;
+        curan::utilities::NeedleCalibrationData target_needle_calib{mock_file};
+        ASSERT_EQ(source_needle_calib, target_needle_calib) << "the serialization deserealization process loses data";
+    }
+}
+
+TEST(UnitTestFilePropagator, RegistrationData)
+{
+    for (size_t run_n_times = 0; run_n_times < 20; ++run_n_times)
+    {
+        Eigen::Matrix<double, 4, 4> transform = Eigen::Matrix<double, 4, 4>::Random();
+        curan::utilities::RegistrationData source_registration_data(date, transform, 1.0, curan::utilities::SURFACE);
+        std::stringstream mock_file;
+        mock_file << source_registration_data;
+        curan::utilities::RegistrationData target_registration_data{mock_file};
+        ASSERT_EQ(source_registration_data, target_registration_data) << "the serialization deserealization process loses data";
+    }
+}
+
+TEST(UnitTestFilePropagator, TrajectorySpecificationData)
+{
+    for (size_t run_n_times = 0; run_n_times < 20; ++run_n_times)
+    {
+        Eigen::Matrix<double, 3, 1> target = Eigen::Matrix<double, 3, 1>::Random();
+        Eigen::Matrix<double, 3, 1> entrypoint = Eigen::Matrix<double, 3, 1>::Random();
+        Eigen::Matrix<double, 3, 3> orientation = Eigen::Matrix<double, 3, 3>::Random();
+        const std::string path_to_fixed_image{"blub/mock/not/real/path"};
+        curan::utilities::TrajectorySpecificationData source_trajectory_specification_data(date, target, entrypoint, orientation, path_to_fixed_image);
+        std::stringstream mock_file;
+        mock_file << source_trajectory_specification_data;
+        curan::utilities::TrajectorySpecificationData target_trajectory_specification_data{mock_file};
+        ASSERT_EQ(source_trajectory_specification_data, target_trajectory_specification_data) << "the serialization deserealization process loses data";
+    }
+}
+
+TEST(UnitTestFilePropagator, UltrasoundCalibrationData)
+{
+    for (size_t run_n_times = 0; run_n_times < 20; ++run_n_times)
+    {
+        Eigen::Matrix<double, 4, 4> homogeneous_transformation = Eigen::Matrix<double, 4, 4>::Random();
+        curan::utilities::UltrasoundCalibrationData source_ultrasound_data(date, homogeneous_transformation, 1.0);
+        std::stringstream mock_file;
+        mock_file << source_ultrasound_data;
+        curan::utilities::UltrasoundCalibrationData target_ultrasound_data{mock_file};
+        ASSERT_EQ(source_ultrasound_data, target_ultrasound_data) << "the serialization deserealization process loses data";
+    }
+}
