Added Unit Test for Serialization

Author: Divya Kamath

.gitignore

@@ -42,10 +42,13 @@ graphitti
 ggraphitti
 cgraphitti
 tests
-serialTest
-deserialTest
-serialFileAccessTest
-#recorderTest
+serialFullTest
+serialFirstHalfTest
+serialSecondHalfTest
+core 
+# core is generated by GDB during debugging 
+
+# Recorder Test
 *.exe
 *.out
 *.app

CMakeLists.txt

@@ -53,7 +53,7 @@ else()
         project(Graphitti LANGUAGES CXX C)
 endif()
 
-#Setting the base version to C++ 11
+#Setting the base version to C++ 17
 set(CMAKE_CXX_STANDARD 17)
 
 #set(DEBUG_MODE YES) for debugging, no optimization
@@ -372,35 +372,37 @@ target_link_libraries(tests gtest gtest_main)
 # Link the combined library into the 'tests' executable.
 target_link_libraries(tests combinedLib)
 
-# add_executable(serialTest
-#         Testing/RunTests.cpp
-#         Testing/UnitTesting/SerializationTests.cpp)
+#------- SERIALIZATION TESTS --------------------
+# Serialization tests must be executed separately, as each test requires the 
+# simulation to run from start to finish. Running multiple simulations with 
+# the same singleton instance results in a segmentation fault (SEG FAULT).
 
-# # Links the Googletest framework with the serialTest executable
-# target_link_libraries(serialTest gtest gtest_main)
-
-# # Link the combined library into the 'serialTest' executable.
-# target_link_libraries(serialTest combinedLib)
+add_executable(serialFullTest
+        Testing/RunTests.cpp
+        Testing/UnitTesting/SerializationFullTest.cpp)
 
-# add_executable(deserialTest
-#         Testing/RunTests.cpp
-#         Testing/UnitTesting/DeserializationTests.cpp)
+add_executable(serialFirstHalfTest
+        Testing/RunTests.cpp
+        Testing/UnitTesting/SerializationFirstHalfTest.cpp)
 
-# # Links the Googletest framework with the deserialTest executable
-# target_link_libraries(deserialTest gtest gtest_main)
+add_executable(serialSecondHalfTest
+        Testing/RunTests.cpp
+        Testing/UnitTesting/SerializationSecondHalfTest.cpp)
 
-# # Link the combined library into the 'deserialTest' executable.
-# target_link_libraries(deserialTest combinedLib)
+# Link the GoogleTest framework to each of the serial test executables.
+target_link_libraries(serialFullTest gtest gtest_main)
+target_link_libraries(serialFirstHalfTest gtest gtest_main)
+target_link_libraries(serialSecondHalfTest gtest gtest_main)
 
-# add_executable(serialFileAccessTest
-#         Testing/RunTests.cpp
-#         Testing/UnitTesting/SerializationFileAccessTest.cpp)
+# Link the combined library and filesystem support to the respective serial test executables.
+target_link_libraries(serialFullTest stdc++fs)
+target_link_libraries(serialFullTest combinedLib)
 
-# # Links the Googletest framework with the serialFileAccessTest executable
-# target_link_libraries(serialFileAccessTest gtest gtest_main)
+target_link_libraries(serialFirstHalfTest stdc++fs)
+target_link_libraries(serialFirstHalfTest combinedLib)
 
-# # Link the combined library into the 'serialFileAccessTest' executable.
-# target_link_libraries(serialFileAccessTest combinedLib)
+target_link_libraries(serialSecondHalfTest stdc++fs)
+target_link_libraries(serialSecondHalfTest combinedLib)
 
 # Clear ENABLE_CUDA, PERFORMANCE_METRICS and GPROF from the cache so it's reset for subsequent builds
 unset(ENABLE_CUDA CACHE)

Testing/UnitTesting/DeserializationTests.cpp

@@ -0,0 +1,49 @@
+/**
+ * @file SerializationFirstHalfTest.cpp
+ *
+ * @brief The serialization test verifies correctness through a series of steps performed across three files:
+ *    SerializeFullFileTest.cpp, SerializationFirstHalfTest.cpp, and SerializationSecondHalfTest.cpp.
+ *    
+ *    STEP 1: Run a full simulation (e.g., 10 epochs) and save its serialized output.
+ *    STEP 2: Split the full simulation's input configuration file into two halves based on the epoch count 
+ *            (e.g., 10 epochs → 5 + 5 epochs).
+ *            Reference file: /configfiles/test-small-long-half.xml
+ *    STEP 3: Run the first half of the simulation (e.g., 5 epochs) and save its serialized output.
+ *    STEP 4: Run the second half of the simulation (e.g., the remaining 5 epochs) using the serialized output 
+ *            from the first half as the starting point.
+ *    STEP 5: Compare the serialized output of the second half with the full simulation's serialized output.
+ *            If they match, the final result files should also be identical, confirming successful serialization.
+ *
+ * @note This specific test, SerializationFirstHalfTest, covers the third step: first half of the simulation and saving its serialized output
+ * 
+ * To run the serialization tests, execute the script `run_serial_test.sh` located in the `build` directory.
+ * 
+ * @ingroup Testing/UnitTesting
+ */
+
+
+#include "SerializationHelper.cpp"
+#include "gtest/gtest.h"
+
+using namespace std;
+
+// Test serialization by running full and half simulations, and comparing serialized files
+TEST(SerializationTest, SerializeFirstHalfTest)
+{
+   string executable = "./cgraphitti";
+
+   // Configuration file for the half simulation
+   string configFileHalf = "../configfiles/test-small-long-half.xml";
+
+   // Path to save the serialized output file
+   string serialFirstHalf = "../Testing/UnitTesting/TestOutput/First-half-serialized-file.xml";
+
+   // Command-line arguments for the simulation
+   string argumentFirstHalf = "-c " + configFileHalf + " -s " + serialFirstHalf;
+
+   // Run simulations
+   ASSERT_TRUE(runSimulation(executable, argumentFirstHalf)) << "First half simulation failed.";
+
+   // Check that the serialized file was created
+   ASSERT_TRUE(fileExists(serialFirstHalf)) << "Serialized first half file does not exist.";
+}

Testing/UnitTesting/SerializationFileAccessTest.cpp

@@ -0,0 +1,48 @@
+/**
+ * @file SerializationFullTest.cpp
+ *
+ * @brief The serialization test verifies correctness through a series of steps performed across three files:
+ *    SerializeFullFileTest.cpp, SerializationFirstHalfTest.cpp, and SerializationSecondHalfTest.cpp.
+ *    
+ *    STEP 1: Run a full simulation (e.g., 10 epochs) and save its serialized output.
+ *    STEP 2: Split the full simulation's input configuration file into two halves based on the epoch count 
+ *            (e.g., 10 epochs → 5 + 5 epochs).
+ *            Reference file: /configfiles/test-small-long-half.xml
+ *    STEP 3: Run the first half of the simulation (e.g., 5 epochs) and save its serialized output.
+ *    STEP 4: Run the second half of the simulation (e.g., the remaining 5 epochs) using the serialized output 
+ *            from the first half as the starting point.
+ *    STEP 5: Compare the serialized output of the second half with the full simulation's serialized output.
+ *            If they match, the final result files should also be identical, confirming successful serialization.
+ * 
+ * @note This specific test, SerializeFullFileTest, covers the first step: running the full simulation and saving the serialized file.
+ * 
+ * To run the serialization tests, execute the script `run_serial_test.sh` located in the `build` directory.
+ * 
+ * @ingroup Testing/UnitTesting
+ */
+
+#include "SerializationHelper.cpp"
+#include "gtest/gtest.h"
+
+using namespace std;
+
+// Test to ensure the full simulation runs, serializes correctly, and the serialized file is created.
+TEST(SerializationFull, SerializeFullFileTest)
+{
+   string executable = "./cgraphitti";
+
+   // Configuration file for the full simulation
+   string configFileFull = "../configfiles/test-small-long.xml";
+
+   // Path to save the serialized output file
+   string serialFull = "../Testing/UnitTesting/TestOutput/Full-serialized-file.xml";
+
+   // Command-line arguments for the simulation
+   string argumentFull = "-c " + configFileFull + " -s " + serialFull;
+
+   // Run the full simulation
+   ASSERT_TRUE(runSimulation(executable, argumentFull)) << "Full simulation failed.";
+
+   // Check that the serialized file was created
+   ASSERT_TRUE(fileExists(serialFull)) << "Serialized full simulation file does not exist.";
+}

Testing/UnitTesting/SerializationFirstHalfTest.cpp

@@ -0,0 +1,108 @@
+/**
+ * @file SerializationHelper.cpp
+ *
+ * @brief Helper class that contains utility functions for serialization testing.
+ *  
+ * @ingroup Testing/UnitTesting
+ */
+
+#include "Core.h"
+#include <filesystem>
+#include <fstream>
+#include <tinyxml.h>
+
+using namespace std;
+namespace fs = std::filesystem;
+
+// Helper function to run the simulation
+bool runSimulation(const string &executable, const string &arguments)
+{
+   Core core;
+   return core.runSimulation(executable, arguments) == 0 ? true : false;
+}
+
+// Helper function to check if a file exists
+bool fileExists(const string &filePath)
+{
+   return fs::exists(filePath);
+}
+
+// Helper function to compare two XML elements recursively
+bool compareXmlElements(TiXmlElement *elem1, TiXmlElement *elem2)
+{
+   if (!elem1 || !elem2) {
+      return false;
+   }
+
+   // Compare element names
+   if (std::string(elem1->Value()) != std::string(elem2->Value())) {
+      return false;
+   }
+
+   // Compare attributes
+   TiXmlAttribute *attr1 = elem1->FirstAttribute();
+   TiXmlAttribute *attr2 = elem2->FirstAttribute();
+
+   while (attr1 && attr2) {
+      if (std::string(attr1->Name()) != std::string(attr2->Name())
+          || std::string(attr1->Value()) != std::string(attr2->Value())) {
+         return false;
+      }
+      attr1 = attr1->Next();
+      attr2 = attr2->Next();
+   }
+
+   // Check if one element has more attributes than the other
+   if (attr1 || attr2) {
+      return false;
+   }
+
+   // Compare child elements
+   TiXmlElement *child1 = elem1->FirstChildElement();
+   TiXmlElement *child2 = elem2->FirstChildElement();
+
+   while (child1 && child2) {
+      if (!compareXmlElements(child1, child2)) {
+         return false;
+      }
+      child1 = child1->NextSiblingElement();
+      child2 = child2->NextSiblingElement();
+   }
+
+   // Check if one element has more children than the other
+   if (child1 || child2) {
+      return false;
+   }
+
+   return true;
+}
+
+// Helper function to compare XML files
+bool compareXmlFiles(const std::string &filePath1, const std::string &filePath2)
+{
+   TiXmlDocument doc1, doc2;
+
+   // Load the first XML file
+   if (!doc1.LoadFile(filePath1.c_str())) {
+      std::cerr << "Failed to load XML file: " << filePath1 << std::endl;
+      return false;
+   }
+
+   // Load the second XML file
+   if (!doc2.LoadFile(filePath2.c_str())) {
+      std::cerr << "Failed to load XML file: " << filePath2 << std::endl;
+      return false;
+   }
+
+   // Compare the root elements of both XML documents
+   TiXmlElement *root1 = doc1.RootElement();
+   TiXmlElement *root2 = doc2.RootElement();
+
+   if (!root1 || !root2) {
+      std::cerr << "One of the XML files has no root element." << std::endl;
+      return false;
+   }
+
+   // Recursively compare the XML structures
+   return compareXmlElements(root1, root2);
+}