add tests

unittests/datapool/CMakeLists.txt

@@ -1,3 +1,4 @@
 target_sources(
-  ${FSFW_TEST_TGT} PRIVATE testLocalPoolVariable.cpp testLocalPoolVector.cpp
-                           testDataSet.cpp testPeriodicHkHelper.cpp)
+  ${FSFW_TEST_TGT}
+  PRIVATE testLocalPoolVariable.cpp testLocalPoolVector.cpp testSharedSet.cpp
+          testPeriodicHkHelper.cpp testDataset.cpp)

unittests/datapool/testDataset.cpp

@@ -0,0 +1,82 @@
+#include <fsfw/housekeeping/Dataset.h>
+#include <fsfw/housekeeping/DatasetElement.h>
+#include <fsfw/serialize/SerializeElement.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+constexpr auto TEST_ID = dp::structure_id_t(1, 2);
+
+class TestDatasetSmall : public hk::Dataset {
+ public:
+  TestDatasetSmall() : hk::Dataset(TEST_ID) {}
+
+  hk::lvar_u8 test0{*this};
+  hk::lvar_u32 test1{*this};
+};
+
+class TestDatasetLarger : public hk::Dataset {
+ public:
+  TestDatasetLarger() : hk::Dataset(TEST_ID) {}
+
+  hk::lvar_u8 test0{*this};
+  hk::lvar_u32 test1{*this};
+  hk::lvar_u16 test2{*this};
+  hk::lvar_i32 test3{*this};
+  hk::lvar_f32 test4{*this};
+  hk::lvar_f64 test5{*this};
+  hk::lvar_u8 test6{*this};
+  hk::lvar_i16 test7{*this};
+  hk::lvec_u16<2> test8{*this};
+};
+
+TEST_CASE("Pool Dataset Test", "[datapool]") {
+  TestDatasetSmall dataset;
+  CHECK(dataset.getStructureId() == TEST_ID);
+  CHECK(!dataset.test0.isValid());
+  dataset.test0.setValid(true);
+  CHECK(dataset.test0.isValid());
+
+  SECTION("Pool Dataset Serialization Test 1") {
+    uint8_t buf[64]{};
+    dataset.test0 = 55;
+    dataset.test1 = 502392;
+    size_t serLen = 0;
+    CHECK(dataset.serialize(buf, serLen, sizeof(buf), SerializeIF::Endianness::NETWORK) ==
+          returnvalue::OK);
+    CHECK(buf[0] == 55);
+    CHECK(serLen == 5);
+    uint32_t readBack = 0;
+    size_t dummy = 0;
+    CHECK(SerializeAdapter::deSerialize(&readBack, buf + 1, &dummy,
+                                        SerializeIF::Endianness::NETWORK) == returnvalue::OK);
+    CHECK(readBack == 502392);
+    CHECK(buf[5] == 0);
+  }
+
+  SECTION("Pool Dataset Serialization With Validity") {
+    uint8_t buf[64]{};
+    dataset.test0 = 55;
+    dataset.test1 = 502392;
+    dataset.test0.setValid(true);
+    dataset.test1.setValid(true);
+    size_t serLen = 0;
+    uint8_t* dataPtr = buf;
+    CHECK(dataset.serializeWithValidityBlob(&dataPtr, &serLen, sizeof(buf),
+                                            SerializeIF::Endianness::NETWORK) == returnvalue::OK);
+    CHECK(buf[5] == 0b11000000);
+  }
+
+  SECTION("Larger Pool Dataset Serialization With Validity") {
+    uint8_t buf[64]{};
+    TestDatasetLarger datasetLarge;
+    datasetLarge.setAllChildrenValidity(true);
+    size_t serLen = 0;
+    uint8_t* dataPtr = buf;
+    CHECK(datasetLarge.serializeWithValidityBlob(
+              &dataPtr, &serLen, sizeof(buf), SerializeIF::Endianness::NETWORK) == returnvalue::OK);
+    CHECK(serLen == 32);
+    CHECK(buf[30] == 0b11111111);
+    CHECK(buf[31] == 0b10000000);
+    CHECK(buf[32] == 0);
+  }
+}

unittests/datapool/testSharedSet.cpp

@@ -14,7 +14,7 @@
 using namespace returnvalue;
 using namespace lpool;
 
-TEST_CASE("DataSetTest", "[DataSetTest]") {
+TEST_CASE("DataSetTest", "[datapool]") {
   auto queue = MessageQueueMock(1, MessageQueueIF::NO_QUEUE);
   TestPoolOwner poolOwner(queue, objects::TEST_LOCAL_POOL_OWNER_BASE);
   poolOwner.initialize();
@@ -57,17 +57,23 @@ TEST_CASE("DataSetTest", "[DataSetTest]") {
       PoolReadGuard readHelper(&localSet);
       REQUIRE(readHelper.getReadResult() == returnvalue::OK);
       CHECK(localSet.localPoolVarUint8.value == 0);
+      CHECK(!localSet.localPoolVarUint8.isValid());
       CHECK(localSet.localPoolVarFloat.value == Catch::Approx(0.0));
+      CHECK(!localSet.localPoolVarFloat.isValid());
       CHECK(localSet.localPoolUint16Vec.value[0] == 0);
       CHECK(localSet.localPoolUint16Vec.value[1] == 0);
       CHECK(localSet.localPoolUint16Vec.value[2] == 0);
+      CHECK(!localSet.localPoolUint16Vec.isValid());
 
       // Now set new values, commit should be done by read helper automatically
       localSet.localPoolVarUint8 = 232;
+      localSet.localPoolVarUint8.setValid(true);
       localSet.localPoolVarFloat = -2324.322;
+      localSet.localPoolVarFloat.setValid(true);
       localSet.localPoolUint16Vec.value[0] = 232;
       localSet.localPoolUint16Vec.value[1] = 23923;
       localSet.localPoolUint16Vec.value[2] = 1;
+      localSet.localPoolUint16Vec.setValid(true);
     }
 
     // Zero out some values for next test
@@ -85,10 +91,13 @@ TEST_CASE("DataSetTest", "[DataSetTest]") {
       PoolReadGuard readHelper(&localSet);
       REQUIRE(readHelper.getReadResult() == returnvalue::OK);
       CHECK(localSet.localPoolVarUint8.value == 232);
+      CHECK(localSet.localPoolVarUint8.isValid());
       CHECK(localSet.localPoolVarFloat.value == Catch::Approx(-2324.322));
+      CHECK(localSet.localPoolVarFloat.isValid());
       CHECK(localSet.localPoolUint16Vec.value[0] == 232);
       CHECK(localSet.localPoolUint16Vec.value[1] == 23923);
       CHECK(localSet.localPoolUint16Vec.value[2] == 1);
+      CHECK(localSet.localPoolUint16Vec.isValid());
 
       // Now we serialize these values into a buffer without the validity buffer
       maxSize = localSet.getSerializedSize();
@@ -145,4 +154,8 @@ TEST_CASE("DataSetTest", "[DataSetTest]") {
       CHECK(sharedSet.commit() == returnvalue::OK);
     }
   }
+
+  SECTION("Serialize with Validity Blob") {
+    // TODO:  Write test.
+  }
 }

unittests/mock/TestPoolOwner.h

@@ -1,5 +1,6 @@
 #pragma once
 #include <fsfw/housekeeping/GeneratesPeriodicHkIF.h>
+#include <fsfw/housekeeping/PeriodicHkHelper.h>
 #include <fsfw/objectmanager/SystemObject.h>
 
 #include "poolDefinitions.h"