Update and clean up HK and Local Pool Modules

unittests/serialize/CMakeLists.txt

@@ -1,3 +1,4 @@
 target_sources(
-  ${FSFW_TEST_TGT} PRIVATE testSerialBufferAdapter.cpp testSerializeAdapter.cpp
-                           testSerialLinkedPacket.cpp testSerializeIF.cpp)
+  ${FSFW_TEST_TGT}
+  PRIVATE testSerialBufferAdapter.cpp testSerializeAdapter.cpp
+          testSerialLinkedPacket.cpp testSerializeIF.cpp testList.cpp)

unittests/serialize/testList.cpp

@@ -0,0 +1,94 @@
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/serialize/SerializableList.h"
+#include "fsfw/serialize/SerializableListElement.h"
+
+using namespace serialize;
+
+class ExampleSet0 : public List {
+ public:
+  LVar<uint8_t> val0{*this};
+  LVar<uint32_t> val1{*this};
+  LVec<uint16_t, 3> val2{*this};
+};
+
+using namespace returnvalue;
+
+TEST_CASE("Serial List", "[serialize]") {
+  ExampleSet0 set0;
+  uint8_t buf[1024]{};
+  size_t serSize = 0;
+  size_t dummy = 0;
+  SECTION("serialization default") {
+    uint8_t* ptr = buf;
+    CHECK(set0.getSerializedSize() == 11);
+    const ReturnValue_t result =
+        set0.serialize(&ptr, &serSize, sizeof(buf), SerializeIF::Endianness::NETWORK);
+    CHECK(result == returnvalue::OK);
+    CHECK(ptr == buf + 11);
+    CHECK(buf[0] == 0);
+    uint32_t u32Val = 0;
+    CHECK(SerializeAdapter::deSerialize(&u32Val, buf + 1, &dummy,
+                                        SerializeIF::Endianness::NETWORK) == OK);
+    CHECK(u32Val == 0);
+    uint16_t u16Val = 0;
+    for (uint32_t i = 0; i < 3; i++) {
+      CHECK(SerializeAdapter::deSerialize(&u16Val, buf + 5, &dummy,
+                                          SerializeIF::Endianness::NETWORK) == OK);
+      CHECK(u16Val == 0);
+    }
+  }
+
+  SECTION("serialization with values") {
+    uint8_t* ptr = buf;
+    set0.val0 = 240;
+    set0.val1 = 0x1f1f1f1f;
+    set0.val2[0] = 0x1f1f;
+    set0.val2[1] = 0xf1f1;
+    set0.val2[2] = 0x4242;
+    const ReturnValue_t result =
+        set0.serialize(&ptr, &serSize, sizeof(buf), SerializeIF::Endianness::NETWORK);
+    CHECK(result == returnvalue::OK);
+    dummy = set0.getSerializedSize();
+    CHECK(ptr == buf + 11);
+    CHECK(buf[0] == 240);
+    const uint8_t* cPtr = buf + 1;
+    uint32_t u32Val = 0;
+    CHECK(SerializeAdapter::deSerialize(&u32Val, &cPtr, &dummy, SerializeIF::Endianness::NETWORK) ==
+          OK);
+    CHECK(u32Val == 0x1f1f1f1f);
+    uint16_t u16Val = 0;
+    CHECK(SerializeAdapter::deSerialize(&u16Val, &cPtr, &dummy, SerializeIF::Endianness::NETWORK) ==
+          OK);
+    CHECK(u16Val == 0x1f1f);
+    CHECK(SerializeAdapter::deSerialize(&u16Val, &cPtr, &dummy, SerializeIF::Endianness::NETWORK) ==
+          OK);
+    CHECK(u16Val == 0xf1f1);
+    CHECK(SerializeAdapter::deSerialize(&u16Val, &cPtr, &dummy, SerializeIF::Endianness::NETWORK) ==
+          OK);
+    CHECK(u16Val == 0x4242);
+  }
+
+  SECTION("deserialization with values") {
+    uint8_t* ptr = buf;
+    set0.val0 = 240;
+    set0.val1 = 0x1f1f1f1f;
+    set0.val2[0] = 0x1f1f;
+    set0.val2[1] = 0xf1f1;
+    set0.val2[2] = 0x4242;
+    const ReturnValue_t result =
+        set0.serialize(&ptr, &serSize, sizeof(buf), SerializeIF::Endianness::NETWORK);
+    CHECK(result == returnvalue::OK);
+    const uint8_t* cPtr = buf;
+    dummy = set0.getSerializedSize();
+    ExampleSet0 deserSet;
+    CHECK(deserSet.deSerialize(&cPtr, &dummy, SerializeIF::Endianness::NETWORK) == returnvalue::OK);
+
+    CHECK(deserSet.val0.get() == 240);
+    CHECK(deserSet.val1.get() == 0x1f1f1f1f);
+    CHECK(deserSet.val2[0] == 0x1f1f);
+    CHECK(deserSet.val2[1] == 0xf1f1);
+    CHECK(deserSet.val2[2] == 0x4242);
+    CHECK(dummy == 0);
+  }
+}

unittests/serialize/testSerializeIF.cpp

@@ -2,7 +2,7 @@
 #include <array>
 #include <catch2/catch_test_macros.hpp>
 
-#include "mocks/SimpleSerializable.h"
+#include "mock/SimpleSerializable.h"
 
 using namespace std;