Merge remote-tracking branch 'upstream/development' into mueller/update-from-upstream

unittests/CMakeLists.txt

@@ -0,0 +1,31 @@
+target_sources(${FSFW_TEST_TGT} PRIVATE
+    CatchDefinitions.cpp
+    CatchFactory.cpp
+    printChar.cpp
+    testVersion.cpp
+)
+
+target_sources(${FSFW_TEST_TGT} PRIVATE
+    CatchRunner.cpp
+    CatchSetup.cpp
+)
+
+add_subdirectory(testcfg)
+add_subdirectory(mocks)
+
+add_subdirectory(action)
+add_subdirectory(power)
+add_subdirectory(container)
+add_subdirectory(osal)
+add_subdirectory(serialize)
+add_subdirectory(datapoollocal)
+add_subdirectory(storagemanager)
+add_subdirectory(globalfunctions)
+add_subdirectory(timemanager)
+add_subdirectory(tmtcpacket)
+add_subdirectory(cfdp)
+add_subdirectory(hal)
+add_subdirectory(internalerror)
+add_subdirectory(devicehandler)
+
+target_include_directories(${FSFW_TEST_TGT} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})

unittests/CatchDefinitions.cpp

@@ -0,0 +1,17 @@
+#include "CatchDefinitions.h"
+
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+
+StorageManagerIF* tglob::getIpcStoreHandle() {
+  if (ObjectManager::instance() != nullptr) {
+    return ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
+  } else {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "Global object manager uninitialized" << std::endl;
+#else
+    sif::printError("Global object manager uninitialized\n\r");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+    return nullptr;
+  }
+}

unittests/CatchDefinitions.h

@@ -0,0 +1,21 @@
+#ifndef FSFW_UNITTEST_CORE_CATCHDEFINITIONS_H_
+#define FSFW_UNITTEST_CORE_CATCHDEFINITIONS_H_
+
+#include <fsfw/ipc/messageQueueDefinitions.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/storagemanager/StorageManagerIF.h>
+
+namespace retval {
+static constexpr int CATCH_OK = static_cast<int>(HasReturnvaluesIF::RETURN_OK);
+static constexpr int CATCH_FAILED = static_cast<int>(HasReturnvaluesIF::RETURN_FAILED);
+}  // namespace retval
+
+namespace tconst {
+static constexpr MessageQueueId_t testQueueId = 42;
+}
+
+namespace tglob {
+StorageManagerIF* getIpcStoreHandle();
+}
+
+#endif /* FSFW_UNITTEST_CORE_CATCHDEFINITIONS_H_ */

unittests/CatchFactory.cpp

@@ -0,0 +1,77 @@
+#include "CatchFactory.h"
+
+#include <fsfw/datapoollocal/LocalDataPoolManager.h>
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include <fsfw/events/EventManager.h>
+#include <fsfw/health/HealthTable.h>
+#include <fsfw/internalerror/InternalErrorReporter.h>
+#include <fsfw/objectmanager/frameworkObjects.h>
+#include <fsfw/storagemanager/PoolManager.h>
+#include <fsfw/tmtcpacket/pus/tm/TmPacketStored.h>
+#include <fsfw/tmtcservices/CommandingServiceBase.h>
+#include <fsfw/tmtcservices/PusServiceBase.h>
+
+#include "datapoollocal/LocalPoolOwnerBase.h"
+#include "mocks/HkReceiverMock.h"
+#include "tests/TestsConfig.h"
+
+#if FSFW_ADD_DEFAULT_FACTORY_FUNCTIONS == 1
+
+/**
+ * @brief Produces system objects.
+ * @details
+ * Build tasks by using SystemObject Interface (Interface).
+ * Header files of all tasks must be included
+ * Please note that an object has to implement the system object interface
+ * if the interface validity is checked or retrieved later by using the
+ * get<TargetInterface>(object_id) function from the ObjectManagerIF.
+ *
+ * Framework objects are created first.
+ *
+ * @ingroup init
+ */
+void Factory::produceFrameworkObjects(void* args) {
+  setStaticFrameworkObjectIds();
+  new EventManager(objects::EVENT_MANAGER);
+  new HealthTable(objects::HEALTH_TABLE);
+  new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
+
+  new LocalPoolOwnerBase(objects::TEST_LOCAL_POOL_OWNER_BASE);
+  new HkReceiverMock(objects::HK_RECEIVER_MOCK);
+
+  {
+    PoolManager::LocalPoolConfig poolCfg = {{100, 16}, {50, 32}, {25, 64}, {15, 128}, {5, 1024}};
+    new PoolManager(objects::TC_STORE, poolCfg);
+  }
+
+  {
+    PoolManager::LocalPoolConfig poolCfg = {{100, 16}, {50, 32}, {25, 64}, {15, 128}, {5, 1024}};
+    new PoolManager(objects::TM_STORE, poolCfg);
+  }
+
+  {
+    PoolManager::LocalPoolConfig poolCfg = {{100, 16}, {50, 32}, {25, 64}, {15, 128}, {5, 1024}};
+    new PoolManager(objects::IPC_STORE, poolCfg);
+  }
+}
+
+void Factory::setStaticFrameworkObjectIds() {
+  PusServiceBase::packetSource = objects::NO_OBJECT;
+  PusServiceBase::packetDestination = objects::NO_OBJECT;
+
+  CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
+  CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
+
+  VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
+
+  DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
+  DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
+
+  LocalDataPoolManager::defaultHkDestination = objects::HK_RECEIVER_MOCK;
+
+  DeviceHandlerFailureIsolation::powerConfirmationId = objects::NO_OBJECT;
+
+  TmPacketBase::timeStamperId = objects::NO_OBJECT;
+}
+
+#endif

unittests/CatchFactory.h

@@ -0,0 +1,24 @@
+#ifndef FSFW_CATCHFACTORY_H_
+#define FSFW_CATCHFACTORY_H_
+
+#include "fsfw/objectmanager/ObjectManager.h"
+#include "fsfw/objectmanager/SystemObjectIF.h"
+#include "tests/TestsConfig.h"
+
+// TODO: It is possible to solve this more cleanly using a special class which
+// is allowed to set the object IDs and has virtual functions.
+#if FSFW_ADD_DEFAULT_FACTORY_FUNCTIONS == 1
+
+namespace Factory {
+/**
+ * @brief 	Creates all SystemObject elements which are persistent
+ * 			during execution.
+ */
+void produceFrameworkObjects(void* args);
+void setStaticFrameworkObjectIds();
+
+}  // namespace Factory
+
+#endif /* FSFW_ADD_DEFAULT_FSFW_FACTORY == 1 */
+
+#endif /* FSFW_CATCHFACTORY_H_ */

unittests/CatchRunner.cpp

@@ -0,0 +1,25 @@
+/**
+ * @file 	CatchRunner.cpp
+ * @brief 	Source file to compile catch framework.
+ * @details	All tests should be written in other files.
+ * For eclipse console output, install ANSI Escape in Console
+ * from the eclipse market place to get colored characters.
+ */
+
+#include "CatchRunner.h"
+
+#define CATCH_CONFIG_COLOUR_WINDOWS
+
+#include <catch2/catch_session.hpp>
+
+extern int customSetup();
+
+int main(int argc, char* argv[]) {
+  customSetup();
+
+  // Catch internal function call
+  int result = Catch::Session().run(argc, argv);
+
+  // global clean-up
+  return result;
+}

unittests/CatchRunner.h

@@ -0,0 +1,14 @@
+#ifndef FSFW_TESTS_USER_UNITTEST_CORE_CATCHRUNNER_H_
+#define FSFW_TESTS_USER_UNITTEST_CORE_CATCHRUNNER_H_
+
+namespace fsfwtest {
+
+/**
+ * Can be called by upper level main() if default Catch2 main is overriden
+ * @return
+ */
+// int customMain(int argc, char* argv[]);
+
+}  // namespace fsfwtest
+
+#endif /* FSFW_TESTS_USER_UNITTEST_CORE_CATCHRUNNER_H_ */

unittests/CatchSetup.cpp

@@ -0,0 +1,31 @@
+#include "CatchDefinitions.h"
+#include "CatchFactory.h"
+
+#ifdef GCOV
+#include <gcov.h>
+#endif
+
+#include "fsfw/objectmanager/ObjectManager.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/storagemanager/StorageManagerIF.h"
+
+/* Global instantiations normally done in main.cpp */
+/* Initialize Data Pool */
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+namespace sif {
+/* Set up output streams */
+ServiceInterfaceStream debug("DEBUG");
+ServiceInterfaceStream info("INFO");
+ServiceInterfaceStream error("ERROR");
+ServiceInterfaceStream warning("WARNING");
+}  // namespace sif
+#endif
+
+int customSetup() {
+  // global setup
+  ObjectManager* objMan = ObjectManager::instance();
+  objMan->setObjectFactoryFunction(Factory::produceFrameworkObjects, nullptr);
+  objMan->initialize();
+  return 0;
+}

unittests/action/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(${FSFW_TEST_TGT} PRIVATE
+	TestActionHelper.cpp
+)

unittests/action/TestActionHelper.cpp

@@ -0,0 +1,114 @@
+#include "TestActionHelper.h"
+
+#include <fsfw/action/ActionHelper.h>
+#include <fsfw/ipc/CommandMessage.h>
+
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "mocks/MessageQueueMockBase.h"
+
+TEST_CASE("Action Helper", "[ActionHelper]") {
+  ActionHelperOwnerMockBase testDhMock;
+  MessageQueueMockBase testMqMock;
+  ActionHelper actionHelper = ActionHelper(&testDhMock, dynamic_cast<MessageQueueIF*>(&testMqMock));
+  CommandMessage actionMessage;
+  ActionId_t testActionId = 777;
+  std::array<uint8_t, 3> testParams{1, 2, 3};
+  store_address_t paramAddress;
+  StorageManagerIF* ipcStore = tglob::getIpcStoreHandle();
+  REQUIRE(ipcStore != nullptr);
+  ipcStore->addData(&paramAddress, testParams.data(), 3);
+  REQUIRE(actionHelper.initialize() == retval::CATCH_OK);
+
+  SECTION("Simple tests") {
+    ActionMessage::setCommand(&actionMessage, testActionId, paramAddress);
+    CHECK(not testDhMock.executeActionCalled);
+    REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+    CHECK(testDhMock.executeActionCalled);
+    // No message is sent if everything is alright.
+    CHECK(not testMqMock.wasMessageSent());
+    store_address_t invalidAddress;
+    ActionMessage::setCommand(&actionMessage, testActionId, invalidAddress);
+    actionHelper.handleActionMessage(&actionMessage);
+    CHECK(testMqMock.wasMessageSent());
+    const uint8_t* ptr = nullptr;
+    size_t size = 0;
+    REQUIRE(ipcStore->getData(paramAddress, &ptr, &size) ==
+            static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
+    REQUIRE(ptr == nullptr);
+    REQUIRE(size == 0);
+    testDhMock.getBuffer(&ptr, &size);
+    REQUIRE(size == 3);
+    for (uint8_t i = 0; i < 3; i++) {
+      REQUIRE(ptr[i] == (i + 1));
+    }
+    testDhMock.clearBuffer();
+  }
+
+  SECTION("Handle failures") {
+    actionMessage.setCommand(1234);
+    REQUIRE(actionHelper.handleActionMessage(&actionMessage) ==
+            static_cast<uint32_t>(CommandMessage::UNKNOWN_COMMAND));
+    CHECK(not testMqMock.wasMessageSent());
+    uint16_t step = 5;
+    ReturnValue_t status = 0x1234;
+    actionHelper.step(step, testMqMock.getId(), testActionId, status);
+    step += 1;
+    CHECK(testMqMock.wasMessageSent());
+    CommandMessage testMessage;
+    REQUIRE(testMqMock.receiveMessage(&testMessage) ==
+            static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+    REQUIRE(testMessage.getParameter() == static_cast<uint32_t>(testActionId));
+    uint32_t parameter2 = ((uint32_t)step << 16) | (uint32_t)status;
+    REQUIRE(testMessage.getParameter2() == parameter2);
+    REQUIRE(ActionMessage::getStep(&testMessage) == step);
+  }
+
+  SECTION("Handle finish") {
+    CHECK(not testMqMock.wasMessageSent());
+    ReturnValue_t status = 0x9876;
+    actionHelper.finish(false, testMqMock.getId(), testActionId, status);
+    CHECK(testMqMock.wasMessageSent());
+    CommandMessage testMessage;
+    REQUIRE(testMqMock.receiveMessage(&testMessage) ==
+            static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::COMPLETION_FAILED));
+    REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
+    REQUIRE(ActionMessage::getReturnCode(&testMessage) == static_cast<uint32_t>(status));
+  }
+
+  SECTION("Handle failed") {
+    store_address_t toLongParamAddress = StorageManagerIF::INVALID_ADDRESS;
+    std::array<uint8_t, 5> toLongData = {5, 4, 3, 2, 1};
+    REQUIRE(ipcStore->addData(&toLongParamAddress, toLongData.data(), 5) == retval::CATCH_OK);
+    ActionMessage::setCommand(&actionMessage, testActionId, toLongParamAddress);
+    CHECK(not testDhMock.executeActionCalled);
+    REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+    REQUIRE(ipcStore->getData(toLongParamAddress).first ==
+            static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
+    CommandMessage testMessage;
+    REQUIRE(testMqMock.receiveMessage(&testMessage) ==
+            static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+    REQUIRE(ActionMessage::getReturnCode(&testMessage) == 0xAFFE);
+    REQUIRE(ActionMessage::getStep(&testMessage) == 0);
+    REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
+  }
+
+  SECTION("Missing IPC Data") {
+    ActionMessage::setCommand(&actionMessage, testActionId, StorageManagerIF::INVALID_ADDRESS);
+    CHECK(not testDhMock.executeActionCalled);
+    REQUIRE(actionHelper.handleActionMessage(&actionMessage) == retval::CATCH_OK);
+    CommandMessage testMessage;
+    REQUIRE(testMqMock.receiveMessage(&testMessage) ==
+            static_cast<uint32_t>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+    REQUIRE(ActionMessage::getReturnCode(&testMessage) ==
+            static_cast<uint32_t>(StorageManagerIF::ILLEGAL_STORAGE_ID));
+    REQUIRE(ActionMessage::getStep(&testMessage) == 0);
+  }
+
+  SECTION("Data Reply") {}
+}

unittests/action/TestActionHelper.h

@@ -0,0 +1,49 @@
+#ifndef UNITTEST_HOSTED_TESTACTIONHELPER_H_
+#define UNITTEST_HOSTED_TESTACTIONHELPER_H_
+
+#include <fsfw/action/HasActionsIF.h>
+#include <fsfw/ipc/MessageQueueIF.h>
+
+#include <cstring>
+
+#include "CatchDefinitions.h"
+
+class ActionHelperOwnerMockBase : public HasActionsIF {
+ public:
+  bool getCommandQueueCalled = false;
+  bool executeActionCalled = false;
+  static const size_t MAX_SIZE = 3;
+  uint8_t buffer[MAX_SIZE] = {0, 0, 0};
+  size_t size = 0;
+
+  MessageQueueId_t getCommandQueue() const override { return tconst::testQueueId; }
+
+  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+                              const uint8_t* data, size_t size) override {
+    executeActionCalled = true;
+    if (size > MAX_SIZE) {
+      return 0xAFFE;
+    }
+    this->size = size;
+    memcpy(buffer, data, size);
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+
+  void clearBuffer() {
+    this->size = 0;
+    for (size_t i = 0; i < MAX_SIZE; i++) {
+      buffer[i] = 0;
+    }
+  }
+
+  void getBuffer(const uint8_t** ptr, size_t* size) {
+    if (size != nullptr) {
+      *size = this->size;
+    }
+    if (ptr != nullptr) {
+      *ptr = buffer;
+    }
+  }
+};
+
+#endif /* UNITTEST_TESTFW_NEWTESTS_TESTACTIONHELPER_H_ */

unittests/cfdp/CMakeLists.txt

@@ -0,0 +1,12 @@
+target_sources(${FSFW_TEST_TGT} PRIVATE
+    testCfdp.cpp
+    testTlvsLvs.cpp
+    testAckPdu.cpp
+    testEofPdu.cpp
+    testNakPdu.cpp
+    testFinishedPdu.cpp
+    testPromptPdu.cpp
+    testKeepAlivePdu.cpp
+    testMetadataPdu.cpp
+    testFileData.cpp
+)

unittests/cfdp/testAckPdu.cpp

@@ -0,0 +1,100 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/cfdp/pdu/AckPduDeserializer.h"
+#include "fsfw/cfdp/pdu/AckPduSerializer.h"
+#include "fsfw/globalfunctions/arrayprinter.h"
+
+TEST_CASE("ACK PDU", "[AckPdu]") {
+  using namespace cfdp;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  std::array<uint8_t, 256> buf = {};
+  uint8_t* bufptr = buf.data();
+  size_t maxsz = buf.size();
+  size_t sz = 0;
+  auto seqNum = TransactionSeqNum(WidthInBytes::TWO_BYTES, 15);
+  auto sourceId = EntityId(WidthInBytes::TWO_BYTES, 1);
+  auto destId = EntityId(WidthInBytes::TWO_BYTES, 2);
+  auto pduConf = PduConfig(TransmissionModes::ACKNOWLEDGED, seqNum, sourceId, destId);
+  AckInfo ackInfo(FileDirectives::EOF_DIRECTIVE, ConditionCode::NO_ERROR,
+                  AckTransactionStatus::ACTIVE);
+  auto ackSerializer = AckPduSerializer(ackInfo, pduConf);
+  result = ackSerializer.serialize(&bufptr, &sz, maxsz, SerializeIF::Endianness::NETWORK);
+  REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+
+  SECTION("Serialize") {
+    REQUIRE(buf.data()[sz - 3] == cfdp::FileDirectives::ACK);
+    REQUIRE((buf.data()[sz - 2] >> 4) == FileDirectives::EOF_DIRECTIVE);
+    REQUIRE((buf.data()[sz - 2] & 0x0f) == 0);
+    REQUIRE(buf.data()[sz - 1] == AckTransactionStatus::ACTIVE);
+    ackInfo.setAckedDirective(FileDirectives::FINISH);
+    ackInfo.setAckedConditionCode(ConditionCode::FILESTORE_REJECTION);
+    ackInfo.setTransactionStatus(AckTransactionStatus::TERMINATED);
+    auto ackSerializer2 = AckPduSerializer(ackInfo, pduConf);
+    bufptr = buf.data();
+    sz = 0;
+    result = ackSerializer2.serialize(&bufptr, &sz, maxsz, SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(buf.data()[sz - 3] == cfdp::FileDirectives::ACK);
+    REQUIRE((buf.data()[sz - 2] >> 4) == FileDirectives::FINISH);
+    REQUIRE((buf.data()[sz - 2] & 0x0f) == 0b0001);
+    REQUIRE((buf.data()[sz - 1] >> 4) == ConditionCode::FILESTORE_REJECTION);
+    REQUIRE((buf.data()[sz - 1] & 0b11) == AckTransactionStatus::TERMINATED);
+
+    bufptr = buf.data();
+    sz = 0;
+    ackInfo.setAckedDirective(FileDirectives::KEEP_ALIVE);
+    auto ackSerializer3 = AckPduSerializer(ackInfo, pduConf);
+    result = ackSerializer3.serialize(&bufptr, &sz, maxsz, SerializeIF::Endianness::NETWORK);
+    // Invalid file directive
+    REQUIRE(result != HasReturnvaluesIF::RETURN_OK);
+
+    ackInfo.setAckedDirective(FileDirectives::FINISH);
+    // buffer too small
+    result = ackSerializer.serialize(&bufptr, &sz, 8, SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == SerializeIF::BUFFER_TOO_SHORT);
+  }
+
+  SECTION("Deserialize") {
+    AckInfo ackInfo;
+    auto reader = AckPduDeserializer(buf.data(), sz, ackInfo);
+    result = reader.parseData();
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(ackInfo.getAckedDirective() == FileDirectives::EOF_DIRECTIVE);
+    REQUIRE(ackInfo.getAckedConditionCode() == ConditionCode::NO_ERROR);
+    REQUIRE(ackInfo.getDirectiveSubtypeCode() == 0);
+    REQUIRE(ackInfo.getTransactionStatus() == AckTransactionStatus::ACTIVE);
+
+    AckInfo newInfo = AckInfo(FileDirectives::FINISH, ConditionCode::FILESTORE_REJECTION,
+                              AckTransactionStatus::TERMINATED);
+    auto ackSerializer2 = AckPduSerializer(newInfo, pduConf);
+    bufptr = buf.data();
+    sz = 0;
+    result = ackSerializer2.serialize(&bufptr, &sz, maxsz, SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+
+    auto reader2 = AckPduDeserializer(buf.data(), sz, ackInfo);
+    result = reader2.parseData();
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(ackInfo.getAckedDirective() == FileDirectives::FINISH);
+    REQUIRE(ackInfo.getAckedConditionCode() == ConditionCode::FILESTORE_REJECTION);
+    REQUIRE(ackInfo.getDirectiveSubtypeCode() == 0b0001);
+    REQUIRE(ackInfo.getTransactionStatus() == AckTransactionStatus::TERMINATED);
+
+    uint8_t prevVal = buf[sz - 2];
+    buf[sz - 2] = FileDirectives::INVALID_DIRECTIVE << 4;
+    result = reader2.parseData();
+    REQUIRE(result == cfdp::INVALID_ACK_DIRECTIVE_FIELDS);
+    buf[sz - 2] = FileDirectives::FINISH << 4 | 0b1111;
+    result = reader2.parseData();
+    REQUIRE(result == cfdp::INVALID_ACK_DIRECTIVE_FIELDS);
+    buf[sz - 2] = prevVal;
+    buf[sz - 3] = cfdp::FileDirectives::INVALID_DIRECTIVE;
+    result = reader2.parseData();
+    REQUIRE(result == cfdp::INVALID_DIRECTIVE_FIELDS);
+    buf[sz - 3] = cfdp::FileDirectives::ACK;
+    auto maxSizeTooSmall = AckPduDeserializer(buf.data(), sz - 2, ackInfo);
+    result = maxSizeTooSmall.parseData();
+    REQUIRE(result == SerializeIF::STREAM_TOO_SHORT);
+  }
+}

unittests/cfdp/testCfdp.cpp

@@ -0,0 +1,368 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+#include <cstring>
+
+#include "CatchDefinitions.h"
+#include "fsfw/cfdp/FileSize.h"
+#include "fsfw/cfdp/pdu/FileDirectiveDeserializer.h"
+#include "fsfw/cfdp/pdu/FileDirectiveSerializer.h"
+#include "fsfw/cfdp/pdu/HeaderDeserializer.h"
+#include "fsfw/cfdp/pdu/HeaderSerializer.h"
+#include "fsfw/globalfunctions/arrayprinter.h"
+#include "fsfw/serialize/SerializeAdapter.h"
+
+TEST_CASE("CFDP Base", "[CfdpBase]") {
+  using namespace cfdp;
+  std::array<uint8_t, 32> serBuf;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  cfdp::TransactionSeqNum seqNum = TransactionSeqNum(cfdp::WidthInBytes::ONE_BYTE, 2);
+  cfdp::EntityId sourceId = EntityId(cfdp::WidthInBytes::ONE_BYTE, 0);
+  cfdp::EntityId destId = EntityId(cfdp::WidthInBytes::ONE_BYTE, 1);
+  PduConfig pduConf =
+      PduConfig(cfdp::TransmissionModes::ACKNOWLEDGED, seqNum, sourceId, destId, false);
+  uint8_t* serTarget = serBuf.data();
+  const uint8_t* deserTarget = serTarget;
+  size_t serSize = 0;
+
+  SECTION("Header Serialization") {
+    auto headerSerializer = HeaderSerializer(pduConf, cfdp::PduType::FILE_DIRECTIVE, 0);
+    const uint8_t** dummyPtr = nullptr;
+    ReturnValue_t deserResult =
+        headerSerializer.deSerialize(dummyPtr, &serSize, SerializeIF::Endianness::NETWORK);
+    REQUIRE(deserResult == retval::CATCH_FAILED);
+    deserResult = headerSerializer.serialize(nullptr, &serSize, serBuf.size(),
+                                             SerializeIF::Endianness::NETWORK);
+    REQUIRE(deserResult == retval::CATCH_FAILED);
+    REQUIRE(seqNum.getSerializedSize() == 1);
+
+    REQUIRE(headerSerializer.getPduDataFieldLen() == 0);
+    REQUIRE(headerSerializer.getSerializedSize() == 7);
+    REQUIRE(headerSerializer.getWholePduSize() == 7);
+    REQUIRE(headerSerializer.getCrcFlag() == false);
+    REQUIRE(headerSerializer.getDirection() == cfdp::Direction::TOWARDS_RECEIVER);
+    REQUIRE(headerSerializer.getLargeFileFlag() == false);
+    REQUIRE(headerSerializer.getLenEntityIds() == 1);
+    REQUIRE(headerSerializer.getLenSeqNum() == 1);
+    REQUIRE(headerSerializer.getPduType() == cfdp::PduType::FILE_DIRECTIVE);
+    REQUIRE(headerSerializer.getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::NOT_PRESENT);
+    REQUIRE(headerSerializer.getSegmentationControl() == false);
+    REQUIRE(headerSerializer.getTransmissionMode() == cfdp::TransmissionModes::ACKNOWLEDGED);
+
+    cfdp::TransactionSeqNum seqNumLocal;
+    headerSerializer.getTransactionSeqNum(seqNumLocal);
+    REQUIRE(seqNumLocal.getWidth() == cfdp::WidthInBytes::ONE_BYTE);
+    REQUIRE(seqNumLocal.getValue() == 2);
+    cfdp::EntityId sourceDestId;
+    headerSerializer.getSourceId(sourceDestId);
+    REQUIRE(sourceDestId.getWidth() == cfdp::WidthInBytes::ONE_BYTE);
+    REQUIRE(sourceDestId.getValue() == 0);
+    headerSerializer.getDestId(sourceDestId);
+    REQUIRE(sourceDestId.getWidth() == cfdp::WidthInBytes::ONE_BYTE);
+    REQUIRE(sourceDestId.getValue() == 1);
+
+    result = headerSerializer.serialize(&serTarget, &serSize, serBuf.size(),
+                                        SerializeIF::Endianness::BIG);
+    REQUIRE(result == retval::CATCH_OK);
+    REQUIRE(serSize == 7);
+    // Only version bits are set
+    REQUIRE(serBuf[0] == 0b00100000);
+    // PDU data field length is 0
+    REQUIRE(serBuf[1] == 0);
+    REQUIRE(serBuf[2] == 0);
+    // Entity and Transaction Sequence number are 1 byte large
+    REQUIRE(serBuf[3] == 0b00010001);
+    // Source ID
+    REQUIRE(serBuf[4] == 0);
+    // Transaction Seq Number
+    REQUIRE(serBuf[5] == 2);
+    // Dest ID
+    REQUIRE(serBuf[6] == 1);
+
+    for (uint8_t idx = 0; idx < 7; idx++) {
+      ReturnValue_t result =
+          headerSerializer.serialize(&serTarget, &serSize, idx, SerializeIF::Endianness::BIG);
+      REQUIRE(result == static_cast<int>(SerializeIF::BUFFER_TOO_SHORT));
+    }
+
+    // Set PDU data field len
+    headerSerializer.setPduDataFieldLen(0x0ff0);
+    REQUIRE(headerSerializer.getPduDataFieldLen() == 0x0ff0);
+    REQUIRE(headerSerializer.getSerializedSize() == 7);
+    REQUIRE(headerSerializer.getWholePduSize() == 7 + 0x0ff0);
+    serTarget = serBuf.data();
+    serSize = 0;
+    result = headerSerializer.serialize(&serTarget, &serSize, serBuf.size(),
+                                        SerializeIF::Endianness::BIG);
+    REQUIRE(serBuf[1] == 0x0f);
+    REQUIRE(serBuf[2] == 0xf0);
+
+    pduConf.crcFlag = true;
+    pduConf.largeFile = true;
+    pduConf.direction = cfdp::Direction::TOWARDS_SENDER;
+    pduConf.mode = cfdp::TransmissionModes::UNACKNOWLEDGED;
+    headerSerializer.setSegmentationControl(
+        cfdp::SegmentationControl::RECORD_BOUNDARIES_PRESERVATION);
+    headerSerializer.setPduType(cfdp::PduType::FILE_DATA);
+    headerSerializer.setSegmentMetadataFlag(cfdp::SegmentMetadataFlag::PRESENT);
+    serTarget = serBuf.data();
+    serSize = 0;
+    result = headerSerializer.serialize(&serTarget, &serSize, serBuf.size(),
+                                        SerializeIF::Endianness::BIG);
+
+    // Everything except version bit flipped to one now
+    REQUIRE(serBuf[0] == 0x3f);
+    REQUIRE(serBuf[3] == 0x99);
+    pduConf.seqNum.setValue(cfdp::WidthInBytes::TWO_BYTES, 0x0fff);
+    pduConf.sourceId.setValue(cfdp::WidthInBytes::FOUR_BYTES, 0xff00ff00);
+    pduConf.destId.setValue(cfdp::WidthInBytes::FOUR_BYTES, 0x00ff00ff);
+    REQUIRE(pduConf.sourceId.getSerializedSize() == 4);
+    REQUIRE(headerSerializer.getSerializedSize() == 14);
+    serTarget = serBuf.data();
+    serSize = 0;
+    result = headerSerializer.serialize(&serTarget, &serSize, serBuf.size(),
+                                        SerializeIF::Endianness::BIG);
+
+    for (uint8_t idx = 0; idx < 14; idx++) {
+      ReturnValue_t result =
+          headerSerializer.serialize(&serTarget, &serSize, idx, SerializeIF::Endianness::BIG);
+      REQUIRE(result == static_cast<int>(SerializeIF::BUFFER_TOO_SHORT));
+    }
+    REQUIRE(headerSerializer.getCrcFlag() == true);
+    REQUIRE(headerSerializer.getDirection() == cfdp::Direction::TOWARDS_SENDER);
+    REQUIRE(headerSerializer.getLargeFileFlag() == true);
+    REQUIRE(headerSerializer.getLenEntityIds() == 4);
+    REQUIRE(headerSerializer.getLenSeqNum() == 2);
+    REQUIRE(headerSerializer.getPduType() == cfdp::PduType::FILE_DATA);
+    REQUIRE(headerSerializer.getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::PRESENT);
+    REQUIRE(headerSerializer.getTransmissionMode() == cfdp::TransmissionModes::UNACKNOWLEDGED);
+    REQUIRE(headerSerializer.getSegmentationControl() == true);
+    // Last three bits are 2 now (length of seq number) and bit 1 to bit 3 is 4 (len entity IDs)
+    REQUIRE(serBuf[3] == 0b11001010);
+    uint32_t entityId = 0;
+    size_t deSerSize = 0;
+    SerializeAdapter::deSerialize(&entityId, serBuf.data() + 4, &deSerSize,
+                                  SerializeIF::Endianness::NETWORK);
+    REQUIRE(deSerSize == 4);
+    REQUIRE(entityId == 0xff00ff00);
+    uint16_t seqNum = 0;
+    SerializeAdapter::deSerialize(&seqNum, serBuf.data() + 8, &deSerSize,
+                                  SerializeIF::Endianness::NETWORK);
+    REQUIRE(deSerSize == 2);
+    REQUIRE(seqNum == 0x0fff);
+    SerializeAdapter::deSerialize(&entityId, serBuf.data() + 10, &deSerSize,
+                                  SerializeIF::Endianness::NETWORK);
+    REQUIRE(deSerSize == 4);
+    REQUIRE(entityId == 0x00ff00ff);
+
+    result = pduConf.sourceId.setValue(cfdp::WidthInBytes::ONE_BYTE, 0xfff);
+    REQUIRE(result == retval::CATCH_FAILED);
+    result = pduConf.sourceId.setValue(cfdp::WidthInBytes::TWO_BYTES, 0xfffff);
+    REQUIRE(result == retval::CATCH_FAILED);
+    result = pduConf.sourceId.setValue(cfdp::WidthInBytes::FOUR_BYTES, 0xfffffffff);
+    REQUIRE(result == retval::CATCH_FAILED);
+    uint8_t oneByteSourceId = 32;
+    serTarget = &oneByteSourceId;
+    size_t deserLen = 1;
+    pduConf.sourceId.deSerialize(cfdp::WidthInBytes::ONE_BYTE,
+                                 const_cast<const uint8_t**>(&serTarget), &deserLen,
+                                 SerializeIF::Endianness::MACHINE);
+    REQUIRE(pduConf.sourceId.getValue() == 32);
+
+    uint16_t twoByteSourceId = 0xf0f0;
+    serTarget = reinterpret_cast<uint8_t*>(&twoByteSourceId);
+    deserLen = 2;
+    pduConf.sourceId.deSerialize(cfdp::WidthInBytes::TWO_BYTES,
+                                 const_cast<const uint8_t**>(&serTarget), &deserLen,
+                                 SerializeIF::Endianness::MACHINE);
+    REQUIRE(pduConf.sourceId.getValue() == 0xf0f0);
+
+    uint32_t fourByteSourceId = 0xf0f0f0f0;
+    serTarget = reinterpret_cast<uint8_t*>(&fourByteSourceId);
+    deserLen = 4;
+    pduConf.sourceId.deSerialize(cfdp::WidthInBytes::FOUR_BYTES,
+                                 const_cast<const uint8_t**>(&serTarget), &deserLen,
+                                 SerializeIF::Endianness::MACHINE);
+    REQUIRE(pduConf.sourceId.getValue() == 0xf0f0f0f0);
+
+    pduConf.sourceId.setValue(cfdp::WidthInBytes::ONE_BYTE, 1);
+    serTarget = serBuf.data();
+    serSize = 1;
+    result = pduConf.sourceId.serialize(&serTarget, &serSize, 1, SerializeIF::Endianness::MACHINE);
+    REQUIRE(result == static_cast<int>(SerializeIF::BUFFER_TOO_SHORT));
+  }
+
+  SECTION("Header Deserialization") {
+    // We unittested the serializer before, so we can use it now to generate valid raw  CFDP
+    // data
+    auto headerSerializer = HeaderSerializer(pduConf, cfdp::PduType::FILE_DIRECTIVE, 0);
+    ReturnValue_t result = headerSerializer.serialize(&serTarget, &serSize, serBuf.size(),
+                                                      SerializeIF::Endianness::BIG);
+    REQUIRE(result == retval::CATCH_OK);
+    REQUIRE(serBuf[1] == 0);
+    REQUIRE(serBuf[2] == 0);
+    // Entity and Transaction Sequence number are 1 byte large
+    REQUIRE(serBuf[3] == 0b00010001);
+    REQUIRE(serSize == 7);
+    // Deser call not strictly necessary
+    auto headerDeser = HeaderDeserializer(serBuf.data(), serBuf.size());
+
+    ReturnValue_t serResult = headerDeser.parseData();
+    REQUIRE(serResult == retval::CATCH_OK);
+    REQUIRE(headerDeser.getPduDataFieldLen() == 0);
+    REQUIRE(headerDeser.getHeaderSize() == 7);
+    REQUIRE(headerDeser.getWholePduSize() == 7);
+    REQUIRE(headerDeser.getCrcFlag() == false);
+    REQUIRE(headerDeser.getDirection() == cfdp::Direction::TOWARDS_RECEIVER);
+    REQUIRE(headerDeser.getLargeFileFlag() == false);
+    REQUIRE(headerDeser.getLenEntityIds() == 1);
+    REQUIRE(headerDeser.getLenSeqNum() == 1);
+    REQUIRE(headerDeser.getPduType() == cfdp::PduType::FILE_DIRECTIVE);
+    REQUIRE(headerDeser.getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::NOT_PRESENT);
+    REQUIRE(headerDeser.getSegmentationControl() == false);
+    REQUIRE(headerDeser.getTransmissionMode() == cfdp::TransmissionModes::ACKNOWLEDGED);
+
+    pduConf.crcFlag = true;
+    pduConf.largeFile = true;
+    pduConf.direction = cfdp::Direction::TOWARDS_SENDER;
+    pduConf.mode = cfdp::TransmissionModes::UNACKNOWLEDGED;
+    headerSerializer.setSegmentationControl(
+        cfdp::SegmentationControl::RECORD_BOUNDARIES_PRESERVATION);
+    headerSerializer.setPduType(cfdp::PduType::FILE_DATA);
+    headerSerializer.setSegmentMetadataFlag(cfdp::SegmentMetadataFlag::PRESENT);
+    result = pduConf.seqNum.setValue(cfdp::WidthInBytes::TWO_BYTES, 0x0fff);
+    REQUIRE(result == retval::CATCH_OK);
+    result = pduConf.sourceId.setValue(cfdp::WidthInBytes::FOUR_BYTES, 0xff00ff00);
+    REQUIRE(result == retval::CATCH_OK);
+    result = pduConf.destId.setValue(cfdp::WidthInBytes::FOUR_BYTES, 0x00ff00ff);
+    REQUIRE(result == retval::CATCH_OK);
+    serTarget = serBuf.data();
+    serSize = 0;
+    result = headerSerializer.serialize(&serTarget, &serSize, serBuf.size(),
+                                        SerializeIF::Endianness::BIG);
+    headerDeser = HeaderDeserializer(serBuf.data(), serBuf.size());
+
+    result = headerDeser.parseData();
+    REQUIRE(result == retval::CATCH_OK);
+    // Everything except version bit flipped to one now
+    REQUIRE(serBuf[0] == 0x3f);
+    REQUIRE(serBuf[3] == 0b11001010);
+    REQUIRE(headerDeser.getWholePduSize() == 14);
+
+    REQUIRE(headerDeser.getCrcFlag() == true);
+    REQUIRE(headerDeser.getDirection() == cfdp::Direction::TOWARDS_SENDER);
+    REQUIRE(headerDeser.getLargeFileFlag() == true);
+    REQUIRE(headerDeser.getLenEntityIds() == 4);
+    REQUIRE(headerDeser.getLenSeqNum() == 2);
+    REQUIRE(headerDeser.getPduType() == cfdp::PduType::FILE_DATA);
+    REQUIRE(headerDeser.getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::PRESENT);
+    REQUIRE(headerDeser.getSegmentationControl() == true);
+    REQUIRE(headerDeser.getTransmissionMode() == cfdp::TransmissionModes::UNACKNOWLEDGED);
+
+    cfdp::TransactionSeqNum seqNumLocal;
+    headerDeser.getTransactionSeqNum(seqNumLocal);
+    REQUIRE(seqNumLocal.getWidth() == cfdp::WidthInBytes::TWO_BYTES);
+    REQUIRE(seqNumLocal.getValue() == 0x0fff);
+    cfdp::EntityId sourceDestId;
+    headerDeser.getSourceId(sourceDestId);
+    REQUIRE(sourceDestId.getWidth() == cfdp::WidthInBytes::FOUR_BYTES);
+    REQUIRE(sourceDestId.getValue() == 0xff00ff00);
+    headerDeser.getDestId(sourceDestId);
+    REQUIRE(sourceDestId.getWidth() == cfdp::WidthInBytes::FOUR_BYTES);
+    REQUIRE(sourceDestId.getValue() == 0x00ff00ff);
+
+    size_t deSerSize = headerDeser.getWholePduSize();
+    serTarget = serBuf.data();
+    const uint8_t** serTargetConst = const_cast<const uint8_t**>(&serTarget);
+    result = headerDeser.parseData();
+    REQUIRE(result == retval::CATCH_OK);
+
+    headerDeser.setData(nullptr, -1);
+    REQUIRE(headerDeser.getHeaderSize() == 0);
+    headerDeser.setData(serBuf.data(), serBuf.size());
+
+    serTarget = serBuf.data();
+    serSize = 0;
+    pduConf.sourceId.setValue(cfdp::WidthInBytes::ONE_BYTE, 22);
+    pduConf.destId.setValue(cfdp::WidthInBytes::ONE_BYTE, 48);
+    result = headerSerializer.serialize(&serTarget, &serSize, serBuf.size(),
+                                        SerializeIF::Endianness::BIG);
+    REQUIRE(result == retval::CATCH_OK);
+    REQUIRE(headerDeser.getWholePduSize() == 8);
+    headerDeser.setData(serBuf.data(), serBuf.size());
+
+    headerDeser.getSourceId(sourceDestId);
+    REQUIRE(sourceDestId.getWidth() == cfdp::WidthInBytes::ONE_BYTE);
+    REQUIRE(sourceDestId.getValue() == 22);
+  }
+
+  SECTION("File Directive") {
+    auto fdSer = FileDirectiveSerializer(pduConf, FileDirectives::ACK, 4);
+    REQUIRE(fdSer.getSerializedSize() == 8);
+    serTarget = serBuf.data();
+    serSize = 0;
+    result = fdSer.serialize(&serTarget, &serSize, serBuf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    // Only version bits are set
+    REQUIRE(serBuf[0] == 0b00100000);
+    // PDU data field length is 5 (4 + Directive code octet)
+    REQUIRE(serBuf[1] == 0);
+    REQUIRE(serBuf[2] == 5);
+    // Entity and Transaction Sequence number are 1 byte large
+    REQUIRE(serBuf[3] == 0b00010001);
+    // Source ID
+    REQUIRE(serBuf[4] == 0);
+    // Transaction Seq Number
+    REQUIRE(serBuf[5] == 2);
+    // Dest ID
+    REQUIRE(serBuf[6] == 1);
+    REQUIRE(serBuf[7] == FileDirectives::ACK);
+
+    serTarget = serBuf.data();
+    size_t deserSize = 20;
+    serSize = 0;
+    REQUIRE(fdSer.deSerialize(&deserTarget, &deserSize, SerializeIF::Endianness::NETWORK) ==
+            HasReturnvaluesIF::RETURN_FAILED);
+    REQUIRE(fdSer.serialize(nullptr, nullptr, 85, SerializeIF::Endianness::NETWORK) ==
+            HasReturnvaluesIF::RETURN_FAILED);
+    for (uint8_t idx = 0; idx < 8; idx++) {
+      serTarget = serBuf.data();
+      serSize = 0;
+      REQUIRE(fdSer.serialize(&serTarget, &serSize, idx, SerializeIF::Endianness::NETWORK) ==
+              SerializeIF::BUFFER_TOO_SHORT);
+    }
+
+    deserTarget = serBuf.data();
+    deserSize = 0;
+    auto fdDeser = FileDirectiveDeserializer(deserTarget, serBuf.size());
+    REQUIRE(fdDeser.getEndianness() == SerializeIF::Endianness::NETWORK);
+    fdDeser.setEndianness(SerializeIF::Endianness::MACHINE);
+    REQUIRE(fdDeser.getEndianness() == SerializeIF::Endianness::MACHINE);
+    fdDeser.setEndianness(SerializeIF::Endianness::NETWORK);
+    REQUIRE(fdDeser.parseData() == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(fdDeser.getFileDirective() == FileDirectives::ACK);
+    REQUIRE(fdDeser.getPduDataFieldLen() == 5);
+    REQUIRE(fdDeser.getHeaderSize() == 8);
+    REQUIRE(fdDeser.getPduType() == cfdp::PduType::FILE_DIRECTIVE);
+
+    serBuf[7] = 0xff;
+    // Invalid file directive
+    REQUIRE(fdDeser.parseData() == cfdp::INVALID_DIRECTIVE_FIELDS);
+  }
+
+  SECTION("FileSize") {
+    std::array<uint8_t, 8> fssBuf = {};
+    uint8_t* buffer = fssBuf.data();
+    size_t size = 0;
+    cfdp::FileSize fss;
+    REQUIRE(fss.getSize() == 0);
+    fss.setFileSize(0x20, false);
+    ReturnValue_t result =
+        fss.serialize(&buffer, &size, fssBuf.size(), SerializeIF::Endianness::MACHINE);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    uint32_t fileSize = 0;
+    result = SerializeAdapter::deSerialize(&fileSize, fssBuf.data(), nullptr,
+                                           SerializeIF::Endianness::MACHINE);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(fileSize == 0x20);
+  }
+}

unittests/cfdp/testEofPdu.cpp

@@ -0,0 +1,118 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/cfdp/pdu/EofPduDeserializer.h"
+#include "fsfw/cfdp/pdu/EofPduSerializer.h"
+#include "fsfw/globalfunctions/arrayprinter.h"
+
+TEST_CASE("EOF PDU", "[EofPdu]") {
+  using namespace cfdp;
+
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  std::array<uint8_t, 128> buf = {};
+  uint8_t* bufPtr = buf.data();
+  size_t sz = 0;
+  EntityId destId(WidthInBytes::TWO_BYTES, 2);
+  EntityIdTlv faultLoc(destId);
+  FileSize fileSize(12);
+  // We can already set the fault location, it will be ignored
+  EofInfo eofInfo(cfdp::ConditionCode::NO_ERROR, 5, fileSize, &faultLoc);
+  TransactionSeqNum seqNum(WidthInBytes::TWO_BYTES, 15);
+  EntityId sourceId(WidthInBytes::TWO_BYTES, 1);
+
+  PduConfig pduConf(TransmissionModes::ACKNOWLEDGED, seqNum, sourceId, destId);
+
+  auto eofSerializer = EofPduSerializer(pduConf, eofInfo);
+  SECTION("Serialize") {
+    result = eofSerializer.serialize(&bufPtr, &sz, buf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(((buf[1] << 8) | buf[2]) == 10);
+    uint32_t checksum = 0;
+    result = SerializeAdapter::deSerialize(&checksum, buf.data() + sz - 8, nullptr,
+                                           SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(checksum == 5);
+    uint32_t fileSizeVal = 0;
+    result = SerializeAdapter::deSerialize(&fileSizeVal, buf.data() + sz - 4, nullptr,
+                                           SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(fileSizeVal == 12);
+    REQUIRE(buf[sz - 10] == cfdp::FileDirectives::EOF_DIRECTIVE);
+    REQUIRE(buf[sz - 9] == 0x00);
+    REQUIRE(sz == 20);
+
+    eofInfo.setConditionCode(cfdp::ConditionCode::FILESTORE_REJECTION);
+    eofInfo.setFileSize(0x10ffffff10, true);
+    pduConf.largeFile = true;
+    // Should serialize with fault location now
+    auto serializeWithFaultLocation = EofPduSerializer(pduConf, eofInfo);
+    bufPtr = buf.data();
+    sz = 0;
+    result = serializeWithFaultLocation.serialize(&bufPtr, &sz, buf.size(),
+                                                  SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(sz == 28);
+    REQUIRE(buf[10] == cfdp::FileDirectives::EOF_DIRECTIVE);
+    REQUIRE(buf[11] >> 4 == cfdp::ConditionCode::FILESTORE_REJECTION);
+    uint64_t fileSizeLarge = 0;
+    result = SerializeAdapter::deSerialize(&fileSizeLarge, buf.data() + 16, nullptr,
+                                           SerializeIF::Endianness::NETWORK);
+    REQUIRE(fileSizeLarge == 0x10ffffff10);
+    REQUIRE(buf[sz - 4] == cfdp::TlvTypes::ENTITY_ID);
+    // width of entity ID is 2
+    REQUIRE(buf[sz - 3] == 2);
+    uint16_t entityIdRaw = 0;
+    result = SerializeAdapter::deSerialize(&entityIdRaw, buf.data() + sz - 2, nullptr,
+                                           SerializeIF::Endianness::NETWORK);
+    REQUIRE(entityIdRaw == 2);
+    bufPtr = buf.data();
+    sz = 0;
+    for (size_t idx = 0; idx < 27; idx++) {
+      result =
+          serializeWithFaultLocation.serialize(&bufPtr, &sz, idx, SerializeIF::Endianness::NETWORK);
+      REQUIRE(result == SerializeIF::BUFFER_TOO_SHORT);
+      bufPtr = buf.data();
+      sz = 0;
+    }
+    eofInfo.setChecksum(16);
+    eofInfo.setFaultLoc(nullptr);
+  }
+
+  SECTION("Deserialize") {
+    result = eofSerializer.serialize(&bufPtr, &sz, buf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    EntityIdTlv tlv(destId);
+    EofInfo emptyInfo(&tlv);
+    auto deserializer = EofPduDeserializer(buf.data(), buf.size(), emptyInfo);
+    result = deserializer.parseData();
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(emptyInfo.getConditionCode() == cfdp::ConditionCode::NO_ERROR);
+    REQUIRE(emptyInfo.getChecksum() == 5);
+    REQUIRE(emptyInfo.getFileSize().getSize() == 12);
+
+    eofInfo.setConditionCode(cfdp::ConditionCode::FILESTORE_REJECTION);
+    eofInfo.setFileSize(0x10ffffff10, true);
+    pduConf.largeFile = true;
+    // Should serialize with fault location now
+    auto serializeWithFaultLocation = EofPduSerializer(pduConf, eofInfo);
+    bufPtr = buf.data();
+    sz = 0;
+    result = serializeWithFaultLocation.serialize(&bufPtr, &sz, buf.size(),
+                                                  SerializeIF::Endianness::NETWORK);
+    auto deserializer2 = EofPduDeserializer(buf.data(), buf.size(), emptyInfo);
+    result = deserializer2.parseData();
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(emptyInfo.getConditionCode() == cfdp::ConditionCode::FILESTORE_REJECTION);
+    REQUIRE(emptyInfo.getChecksum() == 5);
+    REQUIRE(emptyInfo.getFileSize().getSize() == 0x10ffffff10);
+    REQUIRE(emptyInfo.getFaultLoc()->getType() == cfdp::TlvTypes::ENTITY_ID);
+    REQUIRE(emptyInfo.getFaultLoc()->getSerializedSize() == 4);
+    uint16_t destId = emptyInfo.getFaultLoc()->getEntityId().getValue();
+    REQUIRE(destId == 2);
+    for (size_t maxSz = 0; maxSz < deserializer2.getWholePduSize() - 1; maxSz++) {
+      auto invalidDeser = EofPduDeserializer(buf.data(), maxSz, emptyInfo);
+      result = invalidDeser.parseData();
+      REQUIRE(result != HasReturnvaluesIF::RETURN_OK);
+    }
+  }
+}

unittests/cfdp/testFileData.cpp

@@ -0,0 +1,171 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/cfdp/pdu/FileDataDeserializer.h"
+#include "fsfw/cfdp/pdu/FileDataSerializer.h"
+#include "fsfw/globalfunctions/arrayprinter.h"
+#include "fsfw/serviceinterface.h"
+
+TEST_CASE("File Data PDU", "[FileDataPdu]") {
+  using namespace cfdp;
+
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  std::array<uint8_t, 128> fileBuffer = {};
+  std::array<uint8_t, 256> fileDataBuffer = {};
+  uint8_t* buffer = fileDataBuffer.data();
+  size_t sz = 0;
+  EntityId destId(WidthInBytes::TWO_BYTES, 2);
+  TransactionSeqNum seqNum(WidthInBytes::TWO_BYTES, 15);
+  EntityId sourceId(WidthInBytes::TWO_BYTES, 1);
+  PduConfig pduConf(TransmissionModes::ACKNOWLEDGED, seqNum, sourceId, destId);
+
+  for (uint8_t idx = 0; idx < 10; idx++) {
+    fileBuffer[idx] = idx;
+  }
+  FileSize offset(50);
+  FileDataInfo info(offset, fileBuffer.data(), 10);
+
+  SECTION("Serialization") {
+    FileDataSerializer serializer(pduConf, info);
+    result =
+        serializer.serialize(&buffer, &sz, fileDataBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(sz == 24);
+    // 10 file bytes plus 4 byte offset
+    REQUIRE(((fileDataBuffer[1] << 8) | fileDataBuffer[2]) == 14);
+    // File Data -> Fourth bit is one
+    REQUIRE(fileDataBuffer[0] == 0b00110000);
+    uint32_t offsetRaw = 0;
+    buffer = fileDataBuffer.data();
+    result = SerializeAdapter::deSerialize(&offsetRaw, buffer + 10, nullptr,
+                                           SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(offsetRaw == 50);
+    buffer = fileDataBuffer.data() + 14;
+    for (size_t idx = 0; idx < 10; idx++) {
+      REQUIRE(buffer[idx] == idx);
+    }
+
+    REQUIRE(info.hasSegmentMetadata() == false);
+    info.addSegmentMetadataInfo(cfdp::RecordContinuationState::CONTAINS_START_AND_END,
+                                fileBuffer.data(), 10);
+    REQUIRE(info.hasSegmentMetadata() == true);
+    REQUIRE(info.getSegmentationControl() ==
+            cfdp::SegmentationControl::NO_RECORD_BOUNDARIES_PRESERVATION);
+    info.setSegmentationControl(cfdp::SegmentationControl::RECORD_BOUNDARIES_PRESERVATION);
+    serializer.update();
+    REQUIRE(serializer.getSegmentationControl() ==
+            cfdp::SegmentationControl::RECORD_BOUNDARIES_PRESERVATION);
+    buffer = fileDataBuffer.data();
+    sz = 0;
+    serializer.setSegmentationControl(cfdp::SegmentationControl::RECORD_BOUNDARIES_PRESERVATION);
+
+    result =
+        serializer.serialize(&buffer, &sz, fileDataBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(((fileDataBuffer[1] << 8) | fileDataBuffer[2]) == 25);
+    // First bit: Seg Ctrl is set
+    // Bits 1 to 3 length of enitity IDs is 2
+    // Bit 4: Segment metadata flag is set
+    // Bit 5 to seven: length of transaction seq num is 2
+    REQUIRE(fileDataBuffer[3] == 0b10101010);
+    REQUIRE((fileDataBuffer[10] >> 6) &
+            0b11 == cfdp::RecordContinuationState::CONTAINS_START_AND_END);
+    // Segment metadata length
+    REQUIRE((fileDataBuffer[10] & 0x3f) == 10);
+    buffer = fileDataBuffer.data() + 11;
+    // Check segment metadata
+    for (size_t idx = 0; idx < 10; idx++) {
+      REQUIRE(buffer[idx] == idx);
+    }
+    // Check filedata
+    buffer = fileDataBuffer.data() + 25;
+    for (size_t idx = 0; idx < 10; idx++) {
+      REQUIRE(buffer[idx] == idx);
+    }
+
+    for (size_t invalidStartSz = 1; invalidStartSz < sz; invalidStartSz++) {
+      buffer = fileDataBuffer.data();
+      sz = 0;
+      result = serializer.serialize(&buffer, &invalidStartSz, sz, SerializeIF::Endianness::NETWORK);
+      REQUIRE(result != HasReturnvaluesIF::RETURN_OK);
+    }
+
+    info.setSegmentMetadataFlag(true);
+    REQUIRE(info.getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::PRESENT);
+    info.setSegmentMetadataFlag(false);
+    REQUIRE(info.getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::NOT_PRESENT);
+    info.setRecordContinuationState(cfdp::RecordContinuationState::CONTAINS_END_NO_START);
+    info.setSegmentMetadataLen(10);
+    info.setSegmentMetadata(nullptr);
+    info.setFileData(nullptr, 0);
+  }
+
+  SECTION("Deserialization") {
+    FileDataSerializer serializer(pduConf, info);
+    result =
+        serializer.serialize(&buffer, &sz, fileDataBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+
+    FileSize emptyOffset;
+    FileDataInfo emptyInfo(emptyOffset);
+    FileDataDeserializer deserializer(fileDataBuffer.data(), fileDataBuffer.size(), emptyInfo);
+    result = deserializer.parseData();
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(deserializer.getWholePduSize() == 24);
+    REQUIRE(deserializer.getPduDataFieldLen() == 14);
+    REQUIRE(deserializer.getSegmentationControl() ==
+            cfdp::SegmentationControl::NO_RECORD_BOUNDARIES_PRESERVATION);
+    REQUIRE(deserializer.getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::NOT_PRESENT);
+
+    REQUIRE(emptyInfo.getOffset().getSize() == 50);
+    REQUIRE(emptyInfo.hasSegmentMetadata() == false);
+    size_t emptyFileSize = 0;
+    const uint8_t* fileData = emptyInfo.getFileData(&emptyFileSize);
+    REQUIRE(emptyFileSize == 10);
+    for (size_t idx = 0; idx < 10; idx++) {
+      REQUIRE(fileData[idx] == idx);
+    }
+
+    deserializer.setEndianness(SerializeIF::Endianness::NETWORK);
+
+    info.addSegmentMetadataInfo(cfdp::RecordContinuationState::CONTAINS_START_AND_END,
+                                fileBuffer.data(), 10);
+    serializer.update();
+    buffer = fileDataBuffer.data();
+    sz = 0;
+    result =
+        serializer.serialize(&buffer, &sz, fileDataBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+
+    result = deserializer.parseData();
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+
+    REQUIRE(emptyInfo.getOffset().getSize() == 50);
+    REQUIRE(emptyInfo.hasSegmentMetadata() == true);
+    REQUIRE(emptyInfo.getRecordContinuationState() ==
+            cfdp::RecordContinuationState::CONTAINS_START_AND_END);
+    emptyFileSize = 0;
+    fileData = emptyInfo.getFileData(&emptyFileSize);
+    REQUIRE(emptyFileSize == 10);
+    for (size_t idx = 0; idx < 10; idx++) {
+      REQUIRE(fileData[idx] == idx);
+    }
+    size_t segmentMetadataLen = 0;
+    fileData = emptyInfo.getSegmentMetadata(&segmentMetadataLen);
+    REQUIRE(segmentMetadataLen == 10);
+    for (size_t idx = 0; idx < 10; idx++) {
+      REQUIRE(fileData[idx] == idx);
+    }
+    for (size_t invalidPduField = 0; invalidPduField < 24; invalidPduField++) {
+      fileDataBuffer[1] = (invalidPduField >> 8) & 0xff;
+      fileDataBuffer[2] = invalidPduField & 0xff;
+      result = deserializer.parseData();
+      // Starting at 15, the file data is parsed. There is not leading file data length
+      // field to the parser can't check whether the remaining length is valid
+      if (invalidPduField < 15) {
+        REQUIRE(result != HasReturnvaluesIF::RETURN_OK);
+      }
+    }
+  }
+}

unittests/cfdp/testFinishedPdu.cpp

@@ -0,0 +1,189 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/cfdp/pdu/FinishedPduDeserializer.h"
+#include "fsfw/cfdp/pdu/FinishedPduSerializer.h"
+#include "fsfw/globalfunctions/arrayprinter.h"
+
+TEST_CASE("Finished PDU", "[FinishedPdu]") {
+  using namespace cfdp;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  std::array<uint8_t, 256> fnBuffer = {};
+  uint8_t* buffer = fnBuffer.data();
+  size_t sz = 0;
+  EntityId destId(WidthInBytes::TWO_BYTES, 2);
+  TransactionSeqNum seqNum(WidthInBytes::TWO_BYTES, 15);
+  EntityId sourceId(WidthInBytes::TWO_BYTES, 1);
+  PduConfig pduConf(TransmissionModes::ACKNOWLEDGED, seqNum, sourceId, destId);
+
+  cfdp::Lv emptyFsMsg;
+  FinishedInfo info(cfdp::ConditionCode::INACTIVITY_DETECTED,
+                    cfdp::FinishedDeliveryCode::DATA_INCOMPLETE,
+                    cfdp::FinishedFileStatus::DISCARDED_DELIBERATELY);
+
+  SECTION("Serialize") {
+    FinishPduSerializer serializer(pduConf, info);
+    result = serializer.serialize(&buffer, &sz, fnBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(serializer.getSerializedSize() == 12);
+    REQUIRE(((fnBuffer[1] << 8) | fnBuffer[2]) == 2);
+    REQUIRE(fnBuffer[10] == cfdp::FileDirectives::FINISH);
+    REQUIRE(((fnBuffer[sz - 1] >> 4) & 0x0f) == cfdp::ConditionCode::INACTIVITY_DETECTED);
+    REQUIRE(((fnBuffer[sz - 1] >> 2) & 0x01) == cfdp::FinishedDeliveryCode::DATA_INCOMPLETE);
+    REQUIRE((fnBuffer[sz - 1] & 0b11) == cfdp::FinishedFileStatus::DISCARDED_DELIBERATELY);
+    REQUIRE(sz == 12);
+
+    // Add a filestore response
+    std::string firstName = "hello.txt";
+    cfdp::Lv firstNameLv(reinterpret_cast<const uint8_t*>(firstName.data()), firstName.size());
+    FilestoreResponseTlv response(cfdp::FilestoreActionCode::DELETE_FILE,
+                                  cfdp::FSR_APPEND_FILE_1_NOT_EXISTS, firstNameLv, nullptr);
+    FilestoreResponseTlv* responsePtr = &response;
+    REQUIRE(response.getSerializedSize() == 14);
+    size_t len = 1;
+    info.setFilestoreResponsesArray(&responsePtr, &len, &len);
+    serializer.updateDirectiveFieldLen();
+    REQUIRE(serializer.getSerializedSize() == 12 + 14);
+    sz = 0;
+    buffer = fnBuffer.data();
+    result = serializer.serialize(&buffer, &sz, fnBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(serializer.getSerializedSize() == 12 + 14);
+    REQUIRE(serializer.getPduDataFieldLen() == 16);
+
+    // Add two filestore responses and a fault location parameter
+    std::string secondName = "hello2.txt";
+    cfdp::Lv secondNameLv(reinterpret_cast<const uint8_t*>(secondName.data()), secondName.size());
+    FilestoreResponseTlv response2(cfdp::FilestoreActionCode::DENY_FILE, cfdp::FSR_SUCCESS,
+                                   secondNameLv, nullptr);
+    REQUIRE(response2.getSerializedSize() == 15);
+    len = 2;
+    std::array<FilestoreResponseTlv*, 2> responses{&response, &response2};
+    info.setFilestoreResponsesArray(responses.data(), &len, &len);
+    serializer.updateDirectiveFieldLen();
+
+    EntityIdTlv faultLoc(destId);
+    REQUIRE(faultLoc.getSerializedSize() == 4);
+    info.setFaultLocation(&faultLoc);
+    serializer.updateDirectiveFieldLen();
+    sz = 0;
+    buffer = fnBuffer.data();
+    result = serializer.serialize(&buffer, &sz, fnBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    info.setConditionCode(cfdp::ConditionCode::FILESTORE_REJECTION);
+    REQUIRE(serializer.getSerializedSize() == 12 + 14 + 15 + 4);
+    REQUIRE(sz == 12 + 14 + 15 + 4);
+    info.setFileStatus(cfdp::FinishedFileStatus::DISCARDED_FILESTORE_REJECTION);
+    REQUIRE(info.getFileStatus() == cfdp::FinishedFileStatus::DISCARDED_FILESTORE_REJECTION);
+    info.setDeliveryCode(cfdp::FinishedDeliveryCode::DATA_INCOMPLETE);
+    REQUIRE(info.getDeliveryCode() == cfdp::FinishedDeliveryCode::DATA_INCOMPLETE);
+    for (size_t maxSz = 0; maxSz < 45; maxSz++) {
+      sz = 0;
+      buffer = fnBuffer.data();
+      result = serializer.serialize(&buffer, &sz, maxSz, SerializeIF::Endianness::NETWORK);
+      REQUIRE(result != HasReturnvaluesIF::RETURN_OK);
+    }
+  }
+
+  SECTION("Deserialize") {
+    FinishedInfo emptyInfo;
+    FinishPduSerializer serializer(pduConf, info);
+    result = serializer.serialize(&buffer, &sz, fnBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    FinishPduDeserializer deserializer(fnBuffer.data(), fnBuffer.size(), emptyInfo);
+    result = deserializer.parseData();
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(emptyInfo.getFileStatus() == cfdp::FinishedFileStatus::DISCARDED_DELIBERATELY);
+    REQUIRE(emptyInfo.getConditionCode() == cfdp::ConditionCode::INACTIVITY_DETECTED);
+    REQUIRE(emptyInfo.getDeliveryCode() == cfdp::FinishedDeliveryCode::DATA_INCOMPLETE);
+
+    // Add a filestore response
+    sz = 0;
+    buffer = fnBuffer.data();
+    std::string firstName = "hello.txt";
+    cfdp::Lv firstNameLv(reinterpret_cast<const uint8_t*>(firstName.data()), firstName.size());
+    FilestoreResponseTlv response(cfdp::FilestoreActionCode::DELETE_FILE, cfdp::FSR_NOT_PERFORMED,
+                                  firstNameLv, nullptr);
+    FilestoreResponseTlv* responsePtr = &response;
+    size_t len = 1;
+    info.setFilestoreResponsesArray(&responsePtr, &len, &len);
+    serializer.updateDirectiveFieldLen();
+    REQUIRE(serializer.getPduDataFieldLen() == 16);
+    result = serializer.serialize(&buffer, &sz, fnBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    FilestoreResponseTlv emptyResponse(firstNameLv, nullptr);
+    responsePtr = &emptyResponse;
+    emptyInfo.setFilestoreResponsesArray(&responsePtr, nullptr, &len);
+    FinishPduDeserializer deserializer2(fnBuffer.data(), fnBuffer.size(), emptyInfo);
+    result = deserializer2.parseData();
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(emptyInfo.getFsResponsesLen() == 1);
+    FilestoreResponseTlv** responseArray = nullptr;
+    emptyInfo.getFilestoreResonses(&responseArray, nullptr, nullptr);
+    REQUIRE(responseArray[0]->getActionCode() == cfdp::FilestoreActionCode::DELETE_FILE);
+    REQUIRE(responseArray[0]->getStatusCode() == cfdp::FSR_NOT_PERFORMED);
+    auto& fileNameRef = responseArray[0]->getFirstFileName();
+    size_t stringSize = 0;
+    const char* string = reinterpret_cast<const char*>(fileNameRef.getValue(&stringSize));
+    std::string firstFileName(string, stringSize);
+    REQUIRE(firstFileName == "hello.txt");
+
+    // Add two filestore responses and a fault location parameter
+    std::string secondName = "hello2.txt";
+    cfdp::Lv secondNameLv(reinterpret_cast<const uint8_t*>(secondName.data()), secondName.size());
+    FilestoreResponseTlv response2(cfdp::FilestoreActionCode::DENY_FILE, cfdp::FSR_SUCCESS,
+                                   secondNameLv, nullptr);
+    REQUIRE(response2.getSerializedSize() == 15);
+    len = 2;
+    std::array<FilestoreResponseTlv*, 2> responses{&response, &response2};
+    info.setFilestoreResponsesArray(responses.data(), &len, &len);
+    serializer.updateDirectiveFieldLen();
+
+    EntityIdTlv faultLoc(destId);
+    info.setFaultLocation(&faultLoc);
+    serializer.updateDirectiveFieldLen();
+    sz = 0;
+    buffer = fnBuffer.data();
+    result = serializer.serialize(&buffer, &sz, fnBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    EntityId emptyId;
+    EntityIdTlv emptyFaultLoc(emptyId);
+    emptyInfo.setFaultLocation(&emptyFaultLoc);
+    response.setFilestoreMessage(&emptyFsMsg);
+    emptyInfo.setFilestoreResponsesArray(responses.data(), &len, &len);
+    response2.setFilestoreMessage(&emptyFsMsg);
+    FinishPduDeserializer deserializer3(fnBuffer.data(), fnBuffer.size(), emptyInfo);
+    result = deserializer3.parseData();
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    auto& infoRef = deserializer3.getInfo();
+    REQUIRE(deserializer3.getWholePduSize() == 45);
+
+    size_t invalidMaxLen = 1;
+    emptyInfo.setFilestoreResponsesArray(responses.data(), &len, &invalidMaxLen);
+    result = deserializer3.parseData();
+    REQUIRE(result == cfdp::FINISHED_CANT_PARSE_FS_RESPONSES);
+    emptyInfo.setFilestoreResponsesArray(nullptr, nullptr, nullptr);
+    result = deserializer3.parseData();
+    REQUIRE(result == cfdp::FINISHED_CANT_PARSE_FS_RESPONSES);
+
+    // Clear condition code
+    auto tmp = fnBuffer[11];
+    fnBuffer[11] = fnBuffer[11] & ~0xf0;
+    fnBuffer[11] = fnBuffer[11] | (cfdp::ConditionCode::NO_ERROR << 4);
+    emptyInfo.setFilestoreResponsesArray(responses.data(), &len, &len);
+    result = deserializer3.parseData();
+    REQUIRE(result == cfdp::INVALID_TLV_TYPE);
+
+    fnBuffer[11] = tmp;
+    // Invalid TLV type, should be entity ID
+    fnBuffer[sz - 4] = cfdp::TlvTypes::FILESTORE_REQUEST;
+    result = deserializer3.parseData();
+    REQUIRE(result == cfdp::INVALID_TLV_TYPE);
+
+    for (size_t maxSz = 0; maxSz < 45; maxSz++) {
+      FinishPduDeserializer faultyDeser(fnBuffer.data(), maxSz, emptyInfo);
+      result = faultyDeser.parseData();
+      REQUIRE(result != HasReturnvaluesIF::RETURN_OK);
+    }
+  }
+}

unittests/cfdp/testKeepAlivePdu.cpp

@@ -0,0 +1,79 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/cfdp/pdu/KeepAlivePduDeserializer.h"
+#include "fsfw/cfdp/pdu/KeepAlivePduSerializer.h"
+#include "fsfw/globalfunctions/arrayprinter.h"
+
+TEST_CASE("Keep Alive PDU", "[KeepAlivePdu]") {
+  using namespace cfdp;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  std::array<uint8_t, 256> kaBuffer = {};
+  uint8_t* buffer = kaBuffer.data();
+  size_t sz = 0;
+  EntityId destId(WidthInBytes::TWO_BYTES, 2);
+  TransactionSeqNum seqNum(WidthInBytes::TWO_BYTES, 15);
+  EntityId sourceId(WidthInBytes::TWO_BYTES, 1);
+  PduConfig pduConf(TransmissionModes::ACKNOWLEDGED, seqNum, sourceId, destId);
+
+  FileSize progress(0x50);
+
+  SECTION("Serialize") {
+    KeepAlivePduSerializer serializer(pduConf, progress);
+    result = serializer.serialize(&buffer, &sz, kaBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(kaBuffer[10] == cfdp::FileDirectives::KEEP_ALIVE);
+    uint32_t fsRaw = 0;
+    result = SerializeAdapter::deSerialize(&fsRaw, kaBuffer.data() + 11, nullptr,
+                                           SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(fsRaw == 0x50);
+    REQUIRE(sz == 15);
+    REQUIRE(serializer.getWholePduSize() == 15);
+    REQUIRE(serializer.getPduDataFieldLen() == 5);
+
+    pduConf.largeFile = true;
+    serializer.updateDirectiveFieldLen();
+    buffer = kaBuffer.data();
+    sz = 0;
+    result = serializer.serialize(&buffer, &sz, kaBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(serializer.getWholePduSize() == 19);
+    REQUIRE(serializer.getPduDataFieldLen() == 9);
+    uint64_t fsRawLarge = 0;
+    result = SerializeAdapter::deSerialize(&fsRawLarge, kaBuffer.data() + 11, nullptr,
+                                           SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(fsRawLarge == 0x50);
+
+    for (size_t invalidMaxSz = 0; invalidMaxSz < sz; invalidMaxSz++) {
+      buffer = kaBuffer.data();
+      sz = 0;
+      result = serializer.serialize(&buffer, &sz, invalidMaxSz, SerializeIF::Endianness::NETWORK);
+      REQUIRE(result != HasReturnvaluesIF::RETURN_OK);
+    }
+  }
+
+  SECTION("Deserialize") {
+    KeepAlivePduSerializer serializer(pduConf, progress);
+    result = serializer.serialize(&buffer, &sz, kaBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+
+    // Set another file size
+    progress.setFileSize(200, false);
+    KeepAlivePduDeserializer deserializer(kaBuffer.data(), kaBuffer.size(), progress);
+    result = deserializer.parseData();
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    auto& progRef = deserializer.getProgress();
+    // Should have been overwritten
+    REQUIRE(progRef.getSize() == 0x50);
+    sz = deserializer.getWholePduSize();
+
+    // invalid max size
+    for (size_t invalidMaxSz = 0; invalidMaxSz < sz; invalidMaxSz++) {
+      deserializer.setData(kaBuffer.data(), invalidMaxSz);
+      result = deserializer.parseData();
+      REQUIRE(result != HasReturnvaluesIF::RETURN_OK);
+    }
+  }
+}

unittests/cfdp/testMetadataPdu.cpp

@@ -0,0 +1,179 @@
+#include <fsfw/cfdp/tlv/MessageToUserTlv.h>
+
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/cfdp/pdu/MetadataPduDeserializer.h"
+#include "fsfw/cfdp/pdu/MetadataPduSerializer.h"
+#include "fsfw/cfdp/tlv/FilestoreResponseTlv.h"
+#include "fsfw/globalfunctions/arrayprinter.h"
+
+TEST_CASE("Metadata PDU", "[MetadataPdu]") {
+  using namespace cfdp;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  std::array<uint8_t, 256> mdBuffer = {};
+  uint8_t* buffer = mdBuffer.data();
+  size_t sz = 0;
+  EntityId destId(WidthInBytes::TWO_BYTES, 2);
+  TransactionSeqNum seqNum(WidthInBytes::TWO_BYTES, 15);
+  EntityId sourceId(WidthInBytes::TWO_BYTES, 1);
+  PduConfig pduConf(TransmissionModes::ACKNOWLEDGED, seqNum, sourceId, destId);
+
+  std::string firstFileName = "hello.txt";
+  cfdp::Lv sourceFileName(reinterpret_cast<const uint8_t*>(firstFileName.data()),
+                          firstFileName.size());
+  cfdp::Lv destFileName(nullptr, 0);
+  FileSize fileSize(35);
+  MetadataInfo info(false, ChecksumType::MODULAR, fileSize, sourceFileName, destFileName);
+
+  FilestoreResponseTlv response(FilestoreActionCode::CREATE_DIRECTORY, FSR_CREATE_NOT_ALLOWED,
+                                sourceFileName, nullptr);
+  std::array<uint8_t, 3> msg = {0x41, 0x42, 0x43};
+  cfdp::Tlv responseTlv;
+  std::array<uint8_t, 64> responseBuf = {};
+  uint8_t* responseBufPtr = responseBuf.data();
+  response.convertToTlv(responseTlv, buffer, responseBuf.size(), SerializeIF::Endianness::MACHINE);
+  MessageToUserTlv msgToUser(msg.data(), msg.size());
+  std::array<Tlv*, 2> options{&responseTlv, &msgToUser};
+  REQUIRE(options[0]->getSerializedSize() == 2 + 1 + 10 + 1);
+  REQUIRE(options[1]->getSerializedSize() == 5);
+
+  SECTION("Serialize") {
+    MetadataPduSerializer serializer(pduConf, info);
+    result = serializer.serialize(&buffer, &sz, mdBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(serializer.getWholePduSize() == 27);
+    REQUIRE(info.getSourceFileName().getSerializedSize() == 10);
+    REQUIRE(info.getDestFileName().getSerializedSize() == 1);
+    REQUIRE(info.getSerializedSize() == 16);
+    REQUIRE((mdBuffer[1] << 8 | mdBuffer[2]) == 17);
+    REQUIRE(mdBuffer[10] == FileDirectives::METADATA);
+    // no closure requested and checksum type is modular => 0x00
+    REQUIRE(mdBuffer[11] == 0x00);
+    uint32_t fileSizeRaw = 0;
+    result = SerializeAdapter::deSerialize(&fileSizeRaw, mdBuffer.data() + 12, nullptr,
+                                           SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(fileSizeRaw == 35);
+    REQUIRE(mdBuffer[16] == 9);
+    REQUIRE(mdBuffer[17] == 'h');
+    REQUIRE(mdBuffer[18] == 'e');
+    REQUIRE(mdBuffer[19] == 'l');
+    REQUIRE(mdBuffer[20] == 'l');
+    REQUIRE(mdBuffer[21] == 'o');
+    REQUIRE(mdBuffer[22] == '.');
+    REQUIRE(mdBuffer[23] == 't');
+    REQUIRE(mdBuffer[24] == 'x');
+    REQUIRE(mdBuffer[25] == 't');
+    REQUIRE(mdBuffer[26] == 0);
+
+    std::string otherFileName = "hello2.txt";
+    cfdp::Lv otherFileNameLv(reinterpret_cast<const uint8_t*>(otherFileName.data()),
+                             otherFileName.size());
+    info.setSourceFileName(otherFileNameLv);
+    size_t sizeOfOptions = options.size();
+    info.setOptionsArray(options.data(), &sizeOfOptions, &sizeOfOptions);
+    REQUIRE(info.getMaxOptionsLen() == 2);
+    info.setMaxOptionsLen(3);
+    REQUIRE(info.getMaxOptionsLen() == 3);
+    info.setChecksumType(cfdp::ChecksumType::CRC_32C);
+    info.setClosureRequested(true);
+    uint8_t* buffer = mdBuffer.data();
+    size_t sz = 0;
+    serializer.updateDirectiveFieldLen();
+
+    result = serializer.serialize(&buffer, &sz, mdBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE((mdBuffer[1] << 8 | mdBuffer[2]) == 37);
+    auto checksumType = static_cast<cfdp::ChecksumType>(mdBuffer[11] & 0x0f);
+    REQUIRE(checksumType == cfdp::ChecksumType::CRC_32C);
+    bool closureRequested = mdBuffer[11] >> 6 & 0x01;
+    REQUIRE(closureRequested == true);
+    // The size of the two options is 19. Summing up:
+    //  - 11 bytes of source file name
+    //  - 1 byte for dest file name
+    //  - 4 for FSS
+    //  - 1 leading byte.
+    //  - 1 byte for PDU type
+    // PDU header has 10 bytes.
+    // I am not going to check the options raw content, those are part of the dedicated
+    // TLV unittests
+    REQUIRE(sz == 10 + 37);
+    for (size_t maxSz = 0; maxSz < sz; maxSz++) {
+      uint8_t* buffer = mdBuffer.data();
+      size_t sz = 0;
+      result = serializer.serialize(&buffer, &sz, maxSz, SerializeIF::Endianness::NETWORK);
+      REQUIRE(result == SerializeIF::BUFFER_TOO_SHORT);
+    }
+    for (size_t initSz = 1; initSz < 47; initSz++) {
+      uint8_t* buffer = mdBuffer.data();
+      size_t sz = initSz;
+      result = serializer.serialize(&buffer, &sz, 46, SerializeIF::Endianness::NETWORK);
+      REQUIRE(result == SerializeIF::BUFFER_TOO_SHORT);
+    }
+    info.setDestFileName(destFileName);
+  }
+
+  SECTION("Deserialize") {
+    MetadataPduSerializer serializer(pduConf, info);
+    result = serializer.serialize(&buffer, &sz, mdBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+
+    MetadataPduDeserializer deserializer(mdBuffer.data(), mdBuffer.size(), info);
+    result = deserializer.parseData();
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    size_t fullSize = deserializer.getWholePduSize();
+    for (size_t maxSz = 0; maxSz < fullSize; maxSz++) {
+      MetadataPduDeserializer invalidSzDeser(mdBuffer.data(), maxSz, info);
+      result = invalidSzDeser.parseData();
+      REQUIRE(result != HasReturnvaluesIF::RETURN_OK);
+    }
+    size_t sizeOfOptions = options.size();
+    size_t maxSize = 4;
+    info.setOptionsArray(options.data(), &sizeOfOptions, &maxSize);
+    REQUIRE(info.getOptionsLen() == 2);
+    info.setChecksumType(cfdp::ChecksumType::CRC_32C);
+    info.setClosureRequested(true);
+    uint8_t* buffer = mdBuffer.data();
+    size_t sz = 0;
+    serializer.updateDirectiveFieldLen();
+
+    info.setSourceFileName(sourceFileName);
+    result = serializer.serialize(&buffer, &sz, mdBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+
+    MetadataPduDeserializer deserializer2(mdBuffer.data(), mdBuffer.size(), info);
+    result = deserializer2.parseData();
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(options[0]->getType() == cfdp::TlvTypes::FILESTORE_RESPONSE);
+    REQUIRE(options[0]->getSerializedSize() == 14);
+    REQUIRE(options[1]->getType() == cfdp::TlvTypes::MSG_TO_USER);
+    REQUIRE(options[1]->getSerializedSize() == 5);
+
+    for (size_t invalidFieldLen = 0; invalidFieldLen < 36; invalidFieldLen++) {
+      mdBuffer[1] = (invalidFieldLen >> 8) & 0xff;
+      mdBuffer[2] = invalidFieldLen & 0xff;
+      result = deserializer2.parseData();
+      if (invalidFieldLen == 17) {
+        REQUIRE(info.getOptionsLen() == 0);
+      }
+      if (invalidFieldLen == 31) {
+        REQUIRE(info.getOptionsLen() == 1);
+      }
+      // This is the precise length where there are no options or one option
+      if (invalidFieldLen != 17 and invalidFieldLen != 31) {
+        REQUIRE(result != HasReturnvaluesIF::RETURN_OK);
+      }
+    }
+    mdBuffer[1] = (36 >> 8) & 0xff;
+    mdBuffer[2] = 36 & 0xff;
+    info.setOptionsArray(nullptr, nullptr, nullptr);
+    REQUIRE(deserializer2.parseData() == cfdp::METADATA_CANT_PARSE_OPTIONS);
+    info.setOptionsArray(options.data(), &sizeOfOptions, nullptr);
+    for (size_t maxSz = 0; maxSz < 46; maxSz++) {
+      MetadataPduDeserializer invalidSzDeser(mdBuffer.data(), maxSz, info);
+      result = invalidSzDeser.parseData();
+      REQUIRE(result == SerializeIF::STREAM_TOO_SHORT);
+    }
+  }
+}

unittests/cfdp/testNakPdu.cpp

@@ -0,0 +1,152 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/cfdp/pdu/NakPduDeserializer.h"
+#include "fsfw/cfdp/pdu/NakPduSerializer.h"
+#include "fsfw/cfdp/pdu/PduConfig.h"
+#include "fsfw/globalfunctions/arrayprinter.h"
+
+TEST_CASE("NAK PDU", "[NakPdu]") {
+  using namespace cfdp;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  std::array<uint8_t, 256> nakBuffer = {};
+  uint8_t* buffer = nakBuffer.data();
+  size_t sz = 0;
+  EntityId destId(WidthInBytes::TWO_BYTES, 2);
+  TransactionSeqNum seqNum(WidthInBytes::TWO_BYTES, 15);
+  EntityId sourceId(WidthInBytes::TWO_BYTES, 1);
+  PduConfig pduConf(TransmissionModes::ACKNOWLEDGED, seqNum, sourceId, destId);
+
+  FileSize startOfScope(50);
+  FileSize endOfScope(1050);
+  NakInfo info(startOfScope, endOfScope);
+  SECTION("Serializer") {
+    NakPduSerializer serializer(pduConf, info);
+    result = serializer.serialize(&buffer, &sz, nakBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(serializer.getSerializedSize() == 19);
+    REQUIRE(serializer.FileDirectiveSerializer::getSerializedSize() == 11);
+    REQUIRE(sz == 19);
+    REQUIRE(serializer.getPduDataFieldLen() == 9);
+    REQUIRE(((nakBuffer[1] << 8) | nakBuffer[2]) == 0x09);
+    REQUIRE(nakBuffer[10] == cfdp::FileDirectives::NAK);
+    uint32_t scope = 0;
+    result = SerializeAdapter::deSerialize(&scope, nakBuffer.data() + 11, nullptr,
+                                           SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(scope == 50);
+    result = SerializeAdapter::deSerialize(&scope, nakBuffer.data() + 15, nullptr,
+                                           SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(scope == 1050);
+
+    NakInfo::SegmentRequest segReq0(cfdp::FileSize(2020), cfdp::FileSize(2520));
+    NakInfo::SegmentRequest segReq1(cfdp::FileSize(2932), cfdp::FileSize(3021));
+    // Now add 2 segment requests to NAK info and serialize them as well
+    std::array<NakInfo::SegmentRequest, 2> segReqs = {segReq0, segReq1};
+    size_t segReqsLen = segReqs.size();
+    info.setSegmentRequests(segReqs.data(), &segReqsLen, &segReqsLen);
+    uint8_t* buffer = nakBuffer.data();
+    size_t sz = 0;
+    serializer.updateDirectiveFieldLen();
+    result = serializer.serialize(&buffer, &sz, nakBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(serializer.getSerializedSize() == 35);
+    REQUIRE(serializer.getPduDataFieldLen() == 25);
+    REQUIRE(((nakBuffer[1] << 8) | nakBuffer[2]) == 25);
+    uint32_t segReqScopes = 0;
+    result = SerializeAdapter::deSerialize(&segReqScopes, nakBuffer.data() + 19, nullptr,
+                                           SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(segReqScopes == 2020);
+    result = SerializeAdapter::deSerialize(&segReqScopes, nakBuffer.data() + 23, nullptr,
+                                           SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(segReqScopes == 2520);
+    result = SerializeAdapter::deSerialize(&segReqScopes, nakBuffer.data() + 27, nullptr,
+                                           SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(segReqScopes == 2932);
+    result = SerializeAdapter::deSerialize(&segReqScopes, nakBuffer.data() + 31, nullptr,
+                                           SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(segReqScopes == 3021);
+
+    for (size_t maxSz = 0; maxSz < 35; maxSz++) {
+      uint8_t* buffer = nakBuffer.data();
+      size_t sz = 0;
+      result = serializer.serialize(&buffer, &sz, maxSz, SerializeIF::Endianness::NETWORK);
+      REQUIRE(result == SerializeIF::BUFFER_TOO_SHORT);
+    }
+    for (size_t sz = 35; sz > 0; sz--) {
+      uint8_t* buffer = nakBuffer.data();
+      size_t locSize = sz;
+      result = serializer.serialize(&buffer, &locSize, 35, SerializeIF::Endianness::NETWORK);
+      REQUIRE(result == SerializeIF::BUFFER_TOO_SHORT);
+    }
+  }
+
+  SECTION("Deserializer") {
+    NakPduSerializer serializer(pduConf, info);
+    result = serializer.serialize(&buffer, &sz, nakBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+
+    info.getStartOfScope().setFileSize(0, false);
+    info.getEndOfScope().setFileSize(0, false);
+    NakPduDeserializer deserializer(nakBuffer.data(), nakBuffer.size(), info);
+    result = deserializer.parseData();
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(deserializer.getWholePduSize() == 19);
+    REQUIRE(info.getStartOfScope().getSize() == 50);
+    REQUIRE(info.getEndOfScope().getSize() == 1050);
+
+    NakInfo::SegmentRequest segReq0(cfdp::FileSize(2020), cfdp::FileSize(2520));
+    NakInfo::SegmentRequest segReq1(cfdp::FileSize(2932), cfdp::FileSize(3021));
+    // Now add 2 segment requests to NAK info and serialize them as well
+    std::array<NakInfo::SegmentRequest, 2> segReqs = {segReq0, segReq1};
+    size_t segReqsLen = segReqs.size();
+    info.setSegmentRequests(segReqs.data(), &segReqsLen, &segReqsLen);
+    uint8_t* buffer = nakBuffer.data();
+    size_t sz = 0;
+    serializer.updateDirectiveFieldLen();
+    result = serializer.serialize(&buffer, &sz, nakBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+
+    NakPduDeserializer deserializeWithSegReqs(nakBuffer.data(), nakBuffer.size(), info);
+    result = deserializeWithSegReqs.parseData();
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    NakInfo::SegmentRequest* segReqsPtr = nullptr;
+    size_t readSegReqs = 0;
+    info.getSegmentRequests(&segReqsPtr, &readSegReqs, nullptr);
+    REQUIRE(readSegReqs == 2);
+    REQUIRE(segReqsPtr[0].first.getSize() == 2020);
+    REQUIRE(segReqsPtr[0].second.getSize() == 2520);
+    REQUIRE(segReqsPtr[1].first.getSize() == 2932);
+    REQUIRE(segReqsPtr[1].second.getSize() == 3021);
+    REQUIRE(deserializeWithSegReqs.getPduDataFieldLen() == 25);
+    REQUIRE(info.getSegmentRequestsLen() == 2);
+    for (size_t idx = 0; idx < 34; idx++) {
+      NakPduDeserializer faultyDeserializer(nakBuffer.data(), idx, info);
+      result = faultyDeserializer.parseData();
+      REQUIRE(result != HasReturnvaluesIF::RETURN_OK);
+    }
+    for (size_t pduFieldLen = 0; pduFieldLen < 25; pduFieldLen++) {
+      nakBuffer[1] = (pduFieldLen >> 8) & 0xff;
+      nakBuffer[2] = pduFieldLen & 0xff;
+      NakPduDeserializer faultyDeserializer(nakBuffer.data(), nakBuffer.size(), info);
+      result = faultyDeserializer.parseData();
+      if (pduFieldLen == 9) {
+        REQUIRE(info.getSegmentRequestsLen() == 0);
+      } else if (pduFieldLen == 17) {
+        REQUIRE(info.getSegmentRequestsLen() == 1);
+      } else if (pduFieldLen == 25) {
+        REQUIRE(info.getSegmentRequestsLen() == 2);
+      }
+      if (pduFieldLen != 9 and pduFieldLen != 17 and pduFieldLen != 25) {
+        REQUIRE(result != HasReturnvaluesIF::RETURN_OK);
+      }
+    }
+    info.setMaxSegmentRequestLen(5);
+    REQUIRE(info.getSegmentRequestsMaxLen() == 5);
+  }
+}

unittests/cfdp/testPromptPdu.cpp

@@ -0,0 +1,65 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/cfdp/pdu/PromptPduDeserializer.h"
+#include "fsfw/cfdp/pdu/PromptPduSerializer.h"
+#include "fsfw/globalfunctions/arrayprinter.h"
+
+TEST_CASE("Prompt PDU", "[PromptPdu]") {
+  using namespace cfdp;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  std::array<uint8_t, 256> rawBuf = {};
+  uint8_t* buffer = rawBuf.data();
+  size_t sz = 0;
+  EntityId destId(WidthInBytes::TWO_BYTES, 2);
+  TransactionSeqNum seqNum(WidthInBytes::TWO_BYTES, 15);
+  EntityId sourceId(WidthInBytes::TWO_BYTES, 1);
+  PduConfig pduConf(TransmissionModes::ACKNOWLEDGED, seqNum, sourceId, destId);
+
+  SECTION("Serialize") {
+    PromptPduSerializer serializer(pduConf, cfdp::PromptResponseRequired::PROMPT_KEEP_ALIVE);
+    result = serializer.serialize(&buffer, &sz, rawBuf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(serializer.getWholePduSize() == 12);
+    REQUIRE(sz == 12);
+    REQUIRE(serializer.getPduDataFieldLen() == 2);
+    REQUIRE(rawBuf[10] == FileDirectives::PROMPT);
+    REQUIRE((rawBuf[sz - 1] >> 7) & 0x01 == cfdp::PromptResponseRequired::PROMPT_KEEP_ALIVE);
+
+    for (size_t invalidMaxSz = 0; invalidMaxSz < sz; invalidMaxSz++) {
+      uint8_t* buffer = rawBuf.data();
+      size_t sz = 0;
+      result = serializer.serialize(&buffer, &sz, invalidMaxSz, SerializeIF::Endianness::NETWORK);
+      REQUIRE(result != HasReturnvaluesIF::RETURN_OK);
+    }
+    for (size_t invalidSz = 1; invalidSz < sz; invalidSz++) {
+      size_t locSz = invalidSz;
+      uint8_t* buffer = rawBuf.data();
+      result = serializer.serialize(&buffer, &locSz, sz, SerializeIF::Endianness::NETWORK);
+      REQUIRE(result != HasReturnvaluesIF::RETURN_OK);
+    }
+  }
+
+  SECTION("Deserialize") {
+    PromptPduSerializer serializer(pduConf, cfdp::PromptResponseRequired::PROMPT_KEEP_ALIVE);
+    result = serializer.serialize(&buffer, &sz, rawBuf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+
+    PromptPduDeserializer deserializer(rawBuf.data(), rawBuf.size());
+    result = deserializer.parseData();
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(deserializer.getPromptResponseRequired() ==
+            cfdp::PromptResponseRequired::PROMPT_KEEP_ALIVE);
+    sz = deserializer.getWholePduSize();
+    rawBuf[2] = 1;
+    result = deserializer.parseData();
+    REQUIRE(result == SerializeIF::STREAM_TOO_SHORT);
+    rawBuf[2] = 2;
+
+    for (size_t invalidMaxSz = 0; invalidMaxSz < sz; invalidMaxSz++) {
+      deserializer.setData(rawBuf.data(), invalidMaxSz);
+      result = deserializer.parseData();
+      REQUIRE(result != HasReturnvaluesIF::RETURN_OK);
+    }
+  }
+}

unittests/cfdp/testTlvsLvs.cpp

@@ -0,0 +1,330 @@
+#include <fsfw/cfdp/tlv/EntityIdTlv.h>
+#include <fsfw/cfdp/tlv/FaultHandlerOverrideTlv.h>
+#include <fsfw/cfdp/tlv/FilestoreRequestTlv.h>
+#include <fsfw/cfdp/tlv/FilestoreResponseTlv.h>
+#include <fsfw/cfdp/tlv/FlowLabelTlv.h>
+#include <fsfw/cfdp/tlv/MessageToUserTlv.h>
+
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+#include <string>
+
+#include "fsfw/cfdp/pdu/PduConfig.h"
+#include "fsfw/cfdp/tlv/Lv.h"
+#include "fsfw/cfdp/tlv/Tlv.h"
+#include "fsfw/globalfunctions/arrayprinter.h"
+
+TEST_CASE("CFDP TLV LV", "[CfdpTlvLv]") {
+  using namespace cfdp;
+  int result = HasReturnvaluesIF::RETURN_OK;
+  std::array<uint8_t, 255> rawBuf;
+  uint8_t* serPtr = rawBuf.data();
+  const uint8_t* deserPtr = rawBuf.data();
+  size_t deserSize = 0;
+  cfdp::EntityId sourceId = EntityId(cfdp::WidthInBytes::TWO_BYTES, 0x0ff0);
+
+  SECTION("TLV Serialization") {
+    std::array<uint8_t, 8> tlvRawBuf;
+    serPtr = tlvRawBuf.data();
+    result =
+        sourceId.serialize(&serPtr, &deserSize, tlvRawBuf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(deserSize == 2);
+    auto tlv = Tlv(TlvTypes::ENTITY_ID, tlvRawBuf.data(), deserSize);
+    REQUIRE(tlv.getSerializedSize() == 4);
+    REQUIRE(tlv.getLengthField() == 2);
+    serPtr = rawBuf.data();
+    deserSize = 0;
+    result = tlv.serialize(&serPtr, &deserSize, rawBuf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(deserSize == 4);
+    REQUIRE(rawBuf[0] == TlvTypes::ENTITY_ID);
+    REQUIRE(rawBuf[1] == 2);
+    uint16_t entityId = 0;
+    SerializeAdapter::deSerialize(&entityId, rawBuf.data() + 2, &deserSize,
+                                  SerializeIF::Endianness::NETWORK);
+    REQUIRE(entityId == 0x0ff0);
+
+    // Set new value
+    sourceId.setValue(cfdp::WidthInBytes::FOUR_BYTES, 12);
+    serPtr = tlvRawBuf.data();
+    deserSize = 0;
+    result =
+        sourceId.serialize(&serPtr, &deserSize, tlvRawBuf.size(), SerializeIF::Endianness::NETWORK);
+    tlv.setValue(tlvRawBuf.data(), cfdp::WidthInBytes::FOUR_BYTES);
+    serPtr = rawBuf.data();
+    deserSize = 0;
+    result = tlv.serialize(&serPtr, &deserSize, rawBuf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(rawBuf[0] == TlvTypes::ENTITY_ID);
+    REQUIRE(rawBuf[1] == 4);
+
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+
+    serPtr = rawBuf.data();
+    deserSize = 0;
+    auto tlvInvalid = Tlv(cfdp::TlvTypes::INVALID_TLV, tlvRawBuf.data(), 0);
+    REQUIRE(tlvInvalid.serialize(&serPtr, &deserSize, rawBuf.size(),
+                                 SerializeIF::Endianness::NETWORK) != HasReturnvaluesIF::RETURN_OK);
+    tlvInvalid = Tlv(cfdp::TlvTypes::ENTITY_ID, nullptr, 3);
+    REQUIRE(tlvInvalid.serialize(&serPtr, &deserSize, rawBuf.size(),
+                                 SerializeIF::Endianness::NETWORK) != HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(tlvInvalid.serialize(&serPtr, &deserSize, 0, SerializeIF::Endianness::NETWORK) !=
+            HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(tlvInvalid.getSerializedSize() == 0);
+    REQUIRE(tlvInvalid.serialize(nullptr, nullptr, 0, SerializeIF::Endianness::NETWORK) !=
+            HasReturnvaluesIF::RETURN_OK);
+
+    Tlv zeroLenField(TlvTypes::FAULT_HANDLER, nullptr, 0);
+    REQUIRE(zeroLenField.getSerializedSize() == 2);
+    serPtr = rawBuf.data();
+    deserSize = 0;
+    REQUIRE(zeroLenField.serialize(&serPtr, &deserSize, rawBuf.size(),
+                                   SerializeIF::Endianness::NETWORK) ==
+            HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(rawBuf[0] == TlvTypes::FAULT_HANDLER);
+    REQUIRE(rawBuf[1] == 0);
+  }
+
+  SECTION("TLV Deserialization") {
+    // Serialization was tested before, generate raw data now
+    std::array<uint8_t, 8> tlvRawBuf;
+    serPtr = tlvRawBuf.data();
+    result =
+        sourceId.serialize(&serPtr, &deserSize, tlvRawBuf.size(), SerializeIF::Endianness::NETWORK);
+    auto tlvSerialization = Tlv(TlvTypes::ENTITY_ID, tlvRawBuf.data(), deserSize);
+    serPtr = rawBuf.data();
+    deserSize = 0;
+    result = tlvSerialization.serialize(&serPtr, &deserSize, rawBuf.size(),
+                                        SerializeIF::Endianness::NETWORK);
+    Tlv tlv;
+    deserPtr = rawBuf.data();
+    result = tlv.deSerialize(&deserPtr, &deserSize, SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(tlv.getSerializedSize() == 4);
+    REQUIRE(tlv.getType() == TlvTypes::ENTITY_ID);
+    deserPtr = tlv.getValue();
+    uint16_t entityId = 0;
+    deserSize = 0;
+    SerializeAdapter::deSerialize(&entityId, deserPtr, &deserSize,
+                                  SerializeIF::Endianness::NETWORK);
+    REQUIRE(entityId == 0x0ff0);
+
+    REQUIRE(tlv.deSerialize(nullptr, nullptr, SerializeIF::Endianness::NETWORK) !=
+            HasReturnvaluesIF::RETURN_OK);
+    deserPtr = rawBuf.data();
+    deserSize = 0;
+    REQUIRE(tlv.deSerialize(&deserPtr, &deserSize, SerializeIF::Endianness::NETWORK) ==
+            SerializeIF::STREAM_TOO_SHORT);
+    // Set invalid TLV
+    rawBuf[0] = TlvTypes::INVALID_TLV;
+    deserSize = 4;
+    REQUIRE(tlv.deSerialize(&deserPtr, &deserSize, SerializeIF::Endianness::NETWORK) !=
+            HasReturnvaluesIF::RETURN_OK);
+
+    Tlv zeroLenField(TlvTypes::FAULT_HANDLER, nullptr, 0);
+    serPtr = rawBuf.data();
+    deserSize = 0;
+    REQUIRE(zeroLenField.serialize(&serPtr, &deserSize, rawBuf.size(),
+                                   SerializeIF::Endianness::NETWORK) ==
+            HasReturnvaluesIF::RETURN_OK);
+    deserPtr = rawBuf.data();
+    result = zeroLenField.deSerialize(&deserPtr, &deserSize, SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(zeroLenField.getSerializedSize() == 2);
+    REQUIRE(deserSize == 0);
+  }
+
+  SECTION("LV Serialization") {
+    std::array<uint8_t, 8> lvRawBuf;
+    serPtr = lvRawBuf.data();
+    result =
+        sourceId.serialize(&serPtr, &deserSize, lvRawBuf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(deserSize == 2);
+    auto lv = cfdp::Lv(lvRawBuf.data(), 2);
+    auto lvCopy = cfdp::Lv(lv);
+    REQUIRE(lv.getSerializedSize() == 3);
+    REQUIRE(lvCopy.getSerializedSize() == 3);
+    REQUIRE(lv.getValue(nullptr) == lvCopy.getValue(nullptr));
+    serPtr = rawBuf.data();
+    deserSize = 0;
+    result = lv.serialize(&serPtr, &deserSize, rawBuf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(deserSize == 3);
+    REQUIRE(rawBuf[0] == 2);
+    uint16_t sourceId = 0;
+    result = SerializeAdapter::deSerialize(&sourceId, rawBuf.data() + 1, &deserSize,
+                                           SerializeIF::Endianness::BIG);
+    REQUIRE(sourceId == 0x0ff0);
+
+    auto lvEmpty = Lv(nullptr, 0);
+    REQUIRE(lvEmpty.getSerializedSize() == 1);
+    serPtr = rawBuf.data();
+    deserSize = 0;
+    result =
+        lvEmpty.serialize(&serPtr, &deserSize, rawBuf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(deserSize == 1);
+  }
+
+  SECTION("LV Deserialization") {
+    std::array<uint8_t, 8> lvRawBuf;
+    serPtr = lvRawBuf.data();
+    result =
+        sourceId.serialize(&serPtr, &deserSize, lvRawBuf.size(), SerializeIF::Endianness::NETWORK);
+    auto lv = cfdp::Lv(lvRawBuf.data(), 2);
+    serPtr = rawBuf.data();
+    deserSize = 0;
+    result = lv.serialize(&serPtr, &deserSize, rawBuf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+
+    Lv uninitLv;
+    deserPtr = rawBuf.data();
+    deserSize = 3;
+    result = uninitLv.deSerialize(&deserPtr, &deserSize, SerializeIF::Endianness::BIG);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(uninitLv.getSerializedSize() == 3);
+    const uint8_t* storedValue = uninitLv.getValue(nullptr);
+    uint16_t sourceId = 0;
+    result = SerializeAdapter::deSerialize(&sourceId, storedValue, &deserSize,
+                                           SerializeIF::Endianness::BIG);
+    REQUIRE(sourceId == 0x0ff0);
+
+    auto lvEmpty = Lv(nullptr, 0);
+    REQUIRE(lvEmpty.getSerializedSize() == 1);
+    serPtr = rawBuf.data();
+    deserSize = 0;
+    result =
+        lvEmpty.serialize(&serPtr, &deserSize, rawBuf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(deserSize == 1);
+    deserPtr = rawBuf.data();
+    result = uninitLv.deSerialize(&deserPtr, &deserSize, SerializeIF::Endianness::BIG);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(uninitLv.getSerializedSize() == 1);
+
+    REQUIRE(uninitLv.deSerialize(nullptr, nullptr, SerializeIF::Endianness::BIG) ==
+            HasReturnvaluesIF::RETURN_FAILED);
+    serPtr = rawBuf.data();
+    deserSize = 0;
+    REQUIRE(uninitLv.serialize(&serPtr, &deserSize, 0, SerializeIF::Endianness::BIG) ==
+            SerializeIF::BUFFER_TOO_SHORT);
+    REQUIRE(uninitLv.serialize(nullptr, nullptr, 12, SerializeIF::Endianness::BIG));
+    deserSize = 0;
+    REQUIRE(uninitLv.deSerialize(&deserPtr, &deserSize, SerializeIF::Endianness::BIG) ==
+            SerializeIF::STREAM_TOO_SHORT);
+  }
+
+  SECTION("Filestore Response TLV") {
+    std::string name = "hello.txt";
+    cfdp::Lv firstName(reinterpret_cast<const uint8_t*>(name.data()), name.size());
+    std::string name2 = "hello2.txt";
+    cfdp::Lv secondName(reinterpret_cast<const uint8_t*>(name2.data()), name2.size());
+    std::string msg = "12345";
+    cfdp::Lv fsMsg(reinterpret_cast<const uint8_t*>(msg.data()), msg.size());
+    FilestoreResponseTlv response(cfdp::FilestoreActionCode::APPEND_FILE, cfdp::FSR_SUCCESS,
+                                  firstName, &fsMsg);
+    response.setSecondFileName(&secondName);
+    REQUIRE(response.getLengthField() == 10 + 11 + 6 + 1);
+    REQUIRE(response.getSerializedSize() == response.getLengthField() + 2);
+
+    cfdp::Tlv rawResponse;
+    std::array<uint8_t, 128> serBuf = {};
+    result = response.convertToTlv(rawResponse, serBuf.data(), serBuf.size(),
+                                   SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(rawResponse.getType() == cfdp::TlvTypes::FILESTORE_RESPONSE);
+    cfdp::Lv emptyMsg;
+    cfdp::Lv emptySecondName;
+    FilestoreResponseTlv emptyTlv(firstName, &emptyMsg);
+    emptyTlv.setSecondFileName(&emptySecondName);
+    result = emptyTlv.deSerialize(rawResponse, SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(emptyTlv.getActionCode() == cfdp::FilestoreActionCode::APPEND_FILE);
+    REQUIRE(emptyTlv.getStatusCode() == cfdp::FSR_SUCCESS);
+    size_t firstNameLen = 0;
+    const char* firstNamePtr =
+        reinterpret_cast<const char*>(emptyTlv.getFirstFileName().getValue(&firstNameLen));
+    auto helloString = std::string(firstNamePtr, firstNameLen);
+    REQUIRE(helloString == "hello.txt");
+  }
+
+  SECTION("Filestore Request TLV") {
+    std::string name = "hello.txt";
+    cfdp::Lv firstName(reinterpret_cast<const uint8_t*>(name.data()), name.size());
+    std::string name2 = "hello2.txt";
+    cfdp::Lv secondName(reinterpret_cast<const uint8_t*>(name2.data()), name2.size());
+    FilestoreRequestTlv request(cfdp::FilestoreActionCode::APPEND_FILE, firstName);
+
+    // second name not set yet
+    REQUIRE(request.getLengthField() == 10 + 1);
+    REQUIRE(request.getSerializedSize() == request.getLengthField() + 2);
+
+    std::array<uint8_t, 128> serBuf = {};
+    uint8_t* ptr = serBuf.data();
+    size_t sz = 0;
+    result = request.serialize(&ptr, &sz, serBuf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == cfdp::FILESTORE_REQUIRES_SECOND_FILE);
+
+    ptr = serBuf.data();
+    sz = 0;
+    request.setSecondFileName(&secondName);
+    size_t expectedSz = request.getLengthField();
+    REQUIRE(expectedSz == 10 + 11 + 1);
+    REQUIRE(request.getSerializedSize() == expectedSz + 2);
+    result = request.serialize(&ptr, &sz, serBuf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(sz == expectedSz + 2);
+
+    FilestoreRequestTlv emptyRequest(firstName);
+    emptyRequest.setSecondFileName(&secondName);
+    const uint8_t* constptr = serBuf.data();
+    result = emptyRequest.deSerialize(&constptr, &sz, SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+
+    cfdp::Tlv rawRequest;
+    ptr = serBuf.data();
+    sz = 0;
+    result = request.convertToTlv(rawRequest, serBuf.data(), serBuf.size(),
+                                  SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(rawRequest.getType() == cfdp::TlvTypes::FILESTORE_REQUEST);
+
+    emptyRequest.setActionCode(cfdp::FilestoreActionCode::DELETE_FILE);
+    result = emptyRequest.deSerialize(rawRequest, SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(emptyRequest.getType() == cfdp::TlvTypes::FILESTORE_REQUEST);
+    REQUIRE(emptyRequest.getActionCode() == cfdp::FilestoreActionCode::APPEND_FILE);
+  }
+
+  SECTION("Other") {
+    MessageToUserTlv emptyTlv;
+    uint8_t flowLabel = 1;
+    FlowLabelTlv flowLabelTlv(&flowLabel, 1);
+
+    FaultHandlerOverrideTlv faultOverrideTlv(cfdp::ConditionCode::FILESTORE_REJECTION,
+                                             cfdp::FaultHandlerCode::NOTICE_OF_CANCELLATION);
+    size_t sz = 0;
+    ReturnValue_t result =
+        faultOverrideTlv.serialize(&serPtr, &sz, rawBuf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(faultOverrideTlv.getSerializedSize() == 3);
+    REQUIRE(sz == 3);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+
+    FaultHandlerOverrideTlv emptyOverrideTlv;
+    result = emptyOverrideTlv.deSerialize(&deserPtr, &sz, SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+
+    EntityId entId(cfdp::WidthInBytes::TWO_BYTES, 0x42);
+    EntityId emptyId;
+    EntityIdTlv idTlv(emptyId);
+    serPtr = rawBuf.data();
+    result = idTlv.serialize(&serPtr, &deserSize, rawBuf.size(), SerializeIF::Endianness::NETWORK);
+    cfdp::Tlv rawTlv(cfdp::TlvTypes::ENTITY_ID, rawBuf.data() + 2, 2);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    deserPtr = rawBuf.data();
+    result = idTlv.deSerialize(rawTlv, SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+  }
+}

unittests/container/CMakeLists.txt

@@ -0,0 +1,10 @@
+target_sources(${FSFW_TEST_TGT} PRIVATE
+	RingBufferTest.cpp
+	TestArrayList.cpp
+	TestDynamicFifo.cpp
+	TestFifo.cpp
+	TestFixedArrayList.cpp
+	TestFixedMap.cpp
+	TestFixedOrderedMultimap.cpp
+	TestPlacementFactory.cpp
+)

unittests/container/RingBufferTest.cpp

@@ -0,0 +1,326 @@
+#include <fsfw/container/SimpleRingBuffer.h>
+
+#include <catch2/catch_test_macros.hpp>
+#include <cstring>
+
+#include "CatchDefinitions.h"
+
+TEST_CASE("Ring Buffer Test", "[RingBufferTest]") {
+  uint8_t testData[13] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+  uint8_t readBuffer[10] = {13, 13, 13, 13, 13, 13, 13, 13, 13, 13};
+  SimpleRingBuffer ringBuffer(10, false, 5);
+
+  SECTION("Simple Test") {
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.writeData(testData, 3) == retval::CATCH_FAILED);
+    REQUIRE(ringBuffer.readData(readBuffer, 5, true) == retval::CATCH_OK);
+    for (uint8_t i = 0; i < 5; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+    REQUIRE(ringBuffer.availableWriteSpace() == 5);
+    ringBuffer.clear();
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    REQUIRE(ringBuffer.writeData(testData, 4) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.readData(readBuffer, 4, true) == retval::CATCH_OK);
+    for (uint8_t i = 0; i < 4; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+    REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.readData(readBuffer, 9, true) == retval::CATCH_OK);
+    for (uint8_t i = 0; i < 9; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+    REQUIRE(ringBuffer.writeData(testData, 1024) == retval::CATCH_FAILED);
+    REQUIRE(ringBuffer.writeData(nullptr, 5) == retval::CATCH_FAILED);
+  }
+
+  SECTION("Get Free Element Test") {
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    REQUIRE(ringBuffer.writeData(testData, 8) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.availableWriteSpace() == 1);
+    REQUIRE(ringBuffer.readData(readBuffer, 8, true) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    uint8_t *testPtr = nullptr;
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) == retval::CATCH_FAILED);
+
+    REQUIRE(ringBuffer.writeTillWrap() == 2);
+    // too many excess bytes.
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 8) == retval::CATCH_FAILED);
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 5) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.getExcessBytes() == 3);
+    std::memcpy(testPtr, testData, 5);
+    ringBuffer.confirmBytesWritten(5);
+    REQUIRE(ringBuffer.getAvailableReadData() == 5);
+    ringBuffer.readData(readBuffer, 5, true);
+    for (uint8_t i = 0; i < 5; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+  }
+
+  SECTION("Read Remaining Test") {
+    REQUIRE(ringBuffer.writeData(testData, 3) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.getAvailableReadData() == 3);
+    REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) == retval::CATCH_FAILED);
+    size_t trueSize = 0;
+    REQUIRE(ringBuffer.readData(readBuffer, 5, false, true, &trueSize) == retval::CATCH_OK);
+    REQUIRE(trueSize == 3);
+    for (uint8_t i = 0; i < 3; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+    trueSize = 0;
+    REQUIRE(ringBuffer.deleteData(5, false, &trueSize) == retval::CATCH_FAILED);
+    REQUIRE(trueSize == 0);
+    REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == retval::CATCH_OK);
+    REQUIRE(trueSize == 3);
+  }
+}
+
+TEST_CASE("Ring Buffer Test2", "[RingBufferTest2]") {
+  uint8_t testData[13] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+  uint8_t readBuffer[10] = {13, 13, 13, 13, 13, 13, 13, 13, 13, 13};
+  uint8_t *newBuffer = new uint8_t[15];
+  SimpleRingBuffer ringBuffer(newBuffer, 10, true, 5);
+
+  SECTION("Simple Test") {
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.readData(readBuffer, 5, true) == retval::CATCH_OK);
+    for (uint8_t i = 0; i < 5; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+    REQUIRE(ringBuffer.availableWriteSpace() == 5);
+    ringBuffer.clear();
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    REQUIRE(ringBuffer.writeData(testData, 4) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.readData(readBuffer, 4, true) == retval::CATCH_OK);
+    for (uint8_t i = 0; i < 4; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+    REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.readData(readBuffer, 9, true) == retval::CATCH_OK);
+    for (uint8_t i = 0; i < 9; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+  }
+
+  SECTION("Get Free Element Test") {
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    REQUIRE(ringBuffer.writeData(testData, 8) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.availableWriteSpace() == 1);
+    REQUIRE(ringBuffer.readData(readBuffer, 8, true) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    uint8_t *testPtr = nullptr;
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) == retval::CATCH_FAILED);
+
+    REQUIRE(ringBuffer.writeTillWrap() == 2);
+    // too many excess bytes.
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 8) == retval::CATCH_FAILED);
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 5) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.getExcessBytes() == 3);
+    std::memcpy(testPtr, testData, 5);
+    ringBuffer.confirmBytesWritten(5);
+    REQUIRE(ringBuffer.getAvailableReadData() == 5);
+    ringBuffer.readData(readBuffer, 5, true);
+    for (uint8_t i = 0; i < 5; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+  }
+
+  SECTION("Read Remaining Test") {
+    REQUIRE(ringBuffer.writeData(testData, 3) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.getAvailableReadData() == 3);
+    REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) == retval::CATCH_FAILED);
+    size_t trueSize = 0;
+    REQUIRE(ringBuffer.readData(readBuffer, 5, false, true, &trueSize) == retval::CATCH_OK);
+    REQUIRE(trueSize == 3);
+    for (uint8_t i = 0; i < 3; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+    trueSize = 0;
+    REQUIRE(ringBuffer.deleteData(5, false, &trueSize) == retval::CATCH_FAILED);
+    REQUIRE(trueSize == 0);
+    REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == retval::CATCH_OK);
+    REQUIRE(trueSize == 3);
+  }
+
+  SECTION("Overflow") {
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    // We don't allow writing of Data that is larger than the ring buffer in total
+    REQUIRE(ringBuffer.getMaxSize() == 9);
+    REQUIRE(ringBuffer.writeData(testData, 13) == retval::CATCH_FAILED);
+    REQUIRE(ringBuffer.getAvailableReadData() == 0);
+    ringBuffer.clear();
+    uint8_t *ptr = nullptr;
+    // With excess Bytes 13 Bytes can be written to this Buffer
+    REQUIRE(ringBuffer.getFreeElement(&ptr, 13) == retval::CATCH_OK);
+    REQUIRE(ptr != nullptr);
+    memcpy(ptr, testData, 13);
+    ringBuffer.confirmBytesWritten(13);
+    REQUIRE(ringBuffer.getAvailableReadData() == 3);
+    REQUIRE(ringBuffer.readData(readBuffer, 3, true) == retval::CATCH_OK);
+    for (auto i = 0; i < 3; i++) {
+      REQUIRE(readBuffer[i] == testData[i + 10]);
+    }
+  }
+}
+
+TEST_CASE("Ring Buffer Test3", "[RingBufferTest3]") {
+  uint8_t testData[13] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+  uint8_t readBuffer[10] = {13, 13, 13, 13, 13, 13, 13, 13, 13, 13};
+  uint8_t *newBuffer = new uint8_t[25];
+  SimpleRingBuffer ringBuffer(newBuffer, 10, true, 15);
+
+  SECTION("Simple Test") {
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.readData(readBuffer, 5, true) == retval::CATCH_OK);
+    for (uint8_t i = 0; i < 5; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+    REQUIRE(ringBuffer.availableWriteSpace() == 5);
+    ringBuffer.clear();
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    REQUIRE(ringBuffer.writeData(testData, 4) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.readData(readBuffer, 4, true) == retval::CATCH_OK);
+    for (uint8_t i = 0; i < 4; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+    REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.readData(readBuffer, 9, true) == retval::CATCH_OK);
+    for (uint8_t i = 0; i < 9; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+  }
+
+  SECTION("Get Free Element Test") {
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    REQUIRE(ringBuffer.writeData(testData, 8) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.availableWriteSpace() == 1);
+    REQUIRE(ringBuffer.readData(readBuffer, 8, true) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    uint8_t *testPtr = nullptr;
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.getExcessBytes() == 8);
+
+    REQUIRE(ringBuffer.writeTillWrap() == 2);
+    // too many excess bytes.
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 8) == retval::CATCH_FAILED);
+    // Less Execss bytes overwrites before
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 3) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.getExcessBytes() == 1);
+    std::memcpy(testPtr, testData, 3);
+    ringBuffer.confirmBytesWritten(3);
+    REQUIRE(ringBuffer.getAvailableReadData() == 3);
+    ringBuffer.readData(readBuffer, 3, true);
+    for (uint8_t i = 0; i < 3; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+  }
+
+  SECTION("Read Remaining Test") {
+    REQUIRE(ringBuffer.writeData(testData, 3) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.getAvailableReadData() == 3);
+    REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) == retval::CATCH_FAILED);
+    size_t trueSize = 0;
+    REQUIRE(ringBuffer.readData(readBuffer, 5, false, true, &trueSize) == retval::CATCH_OK);
+    REQUIRE(trueSize == 3);
+    for (uint8_t i = 0; i < 3; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+    trueSize = 0;
+    REQUIRE(ringBuffer.deleteData(5, false, &trueSize) == retval::CATCH_FAILED);
+    REQUIRE(trueSize == 0);
+    REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == retval::CATCH_OK);
+    REQUIRE(trueSize == 3);
+  }
+
+  SECTION("Overflow") {
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    // Writing more than the buffer is large.
+    // This write will be rejected and is seen as a configuration mistake
+    REQUIRE(ringBuffer.writeData(testData, 13) == retval::CATCH_FAILED);
+    REQUIRE(ringBuffer.getAvailableReadData() == 0);
+    ringBuffer.clear();
+    // Using FreeElement allows the usage of excessBytes but
+    // should be used with caution
+    uint8_t *ptr = nullptr;
+    REQUIRE(ringBuffer.getFreeElement(&ptr, 13) == retval::CATCH_OK);
+    REQUIRE(ptr != nullptr);
+    memcpy(ptr, testData, 13);
+    ringBuffer.confirmBytesWritten(13);
+    REQUIRE(ringBuffer.getAvailableReadData() == 3);
+    REQUIRE(ringBuffer.readData(readBuffer, 3, true) == retval::CATCH_OK);
+    for (auto i = 0; i < 3; i++) {
+      REQUIRE(readBuffer[i] == testData[i + 10]);
+    }
+  }
+}
+
+TEST_CASE("Ring Buffer Test4", "[RingBufferTest4]") {
+  uint8_t testData[13] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+  uint8_t readBuffer[10] = {13, 13, 13, 13, 13, 13, 13, 13, 13, 13};
+  SimpleRingBuffer ringBuffer(10, false, 15);
+
+  SECTION("Simple Test") {
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.writeData(testData, 3) == retval::CATCH_FAILED);
+    REQUIRE(ringBuffer.readData(readBuffer, 5, true) == retval::CATCH_OK);
+    for (uint8_t i = 0; i < 5; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+    REQUIRE(ringBuffer.availableWriteSpace() == 5);
+    ringBuffer.clear();
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    REQUIRE(ringBuffer.writeData(testData, 4) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.readData(readBuffer, 4, true) == retval::CATCH_OK);
+    for (uint8_t i = 0; i < 4; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+    REQUIRE(ringBuffer.writeData(testData, 9) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.readData(readBuffer, 9, true) == retval::CATCH_OK);
+    for (uint8_t i = 0; i < 9; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+  }
+
+  SECTION("Get Free Element Test") {
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    REQUIRE(ringBuffer.writeData(testData, 8) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.availableWriteSpace() == 1);
+    REQUIRE(ringBuffer.readData(readBuffer, 8, true) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    uint8_t *testPtr = nullptr;
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) == retval::CATCH_FAILED);
+
+    REQUIRE(ringBuffer.writeTillWrap() == 2);
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 8) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 5) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.getExcessBytes() == 3);
+    std::memcpy(testPtr, testData, 5);
+    ringBuffer.confirmBytesWritten(5);
+    REQUIRE(ringBuffer.getAvailableReadData() == 5);
+    ringBuffer.readData(readBuffer, 5, true);
+    for (uint8_t i = 0; i < 5; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+  }
+
+  SECTION("Read Remaining Test") {
+    REQUIRE(ringBuffer.writeData(testData, 3) == retval::CATCH_OK);
+    REQUIRE(ringBuffer.getAvailableReadData() == 3);
+    REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) == retval::CATCH_FAILED);
+    size_t trueSize = 0;
+    REQUIRE(ringBuffer.readData(readBuffer, 5, false, true, &trueSize) == retval::CATCH_OK);
+    REQUIRE(trueSize == 3);
+    for (uint8_t i = 0; i < 3; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+    trueSize = 0;
+    REQUIRE(ringBuffer.deleteData(5, false, &trueSize) == retval::CATCH_FAILED);
+    REQUIRE(trueSize == 0);
+    REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == retval::CATCH_OK);
+    REQUIRE(trueSize == 3);
+  }
+}

unittests/container/TestArrayList.cpp

@@ -0,0 +1,92 @@
+#include <fsfw/container/ArrayList.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+
+/**
+ * @brief 	Array List test
+ */
+TEST_CASE("Array List", "[ArrayListTest]") {
+  // perform set-up here
+  ArrayList<uint16_t> list(20);
+  struct TestClass {
+   public:
+    TestClass(){};
+    TestClass(uint32_t number1, uint64_t number2) : number1(number1), number2(number2){};
+    uint32_t number1 = -1;
+    uint64_t number2 = -1;
+    bool operator==(const TestClass& other) {
+      return ((this->number1 == other.number1) and (this->number2 == other.number2));
+    };
+  };
+  ArrayList<TestClass> complexList(20);
+  SECTION("SimpleTest") {
+    REQUIRE(list.maxSize() == 20);
+    REQUIRE(list.size == 0);
+    REQUIRE(list.insert(10) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(list[0] == 10);
+    REQUIRE(list.front() != nullptr);
+    REQUIRE((*list.front()) == 10);
+    REQUIRE(list.back() != nullptr);
+    REQUIRE((*list.back()) == 10);
+    // Need to test the const version of back as well
+    const uint16_t* number = const_cast<const ArrayList<uint16_t>*>(&list)->back();
+    REQUIRE(*number == 10);
+    list.clear();
+    REQUIRE(list.size == 0);
+  }
+  SECTION("Fill and check") {
+    // This is an invalid element but its not a nullptr
+    REQUIRE(list.back() != nullptr);
+    for (auto i = 0; i < 20; i++) {
+      REQUIRE(list.insert(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    }
+    REQUIRE(list.insert(20) == static_cast<int>(ArrayList<uint16_t>::FULL));
+    ArrayList<uint16_t>::Iterator it = list.begin();
+    REQUIRE((*it) == 0);
+    it++;
+    REQUIRE((*it) == 1);
+    it--;
+    REQUIRE((*it) == 0);
+    it++;
+    for (auto it2 = list.begin(); it2 != list.end(); it2++) {
+      if (it == it2) {
+        REQUIRE((*it) == (*it2));
+        break;
+      } else {
+        REQUIRE((*it2) == 0);
+        REQUIRE(it2 != it);
+      }
+    }
+  }
+  SECTION("Const Iterator") {
+    ArrayList<uint16_t>::Iterator it = list.begin();
+    for (auto i = 0; i < 10; i++) {
+      REQUIRE(list.insert(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    }
+    it++;
+    const uint16_t* number = it.value;
+    REQUIRE(*number == 1);
+  }
+
+  SECTION("Const Iterator") {
+    ArrayList<TestClass>::Iterator it = complexList.begin();
+    for (auto i = 0; i < 10; i++) {
+      REQUIRE(complexList.insert(TestClass(i, i + 1)) ==
+              static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    }
+    it++;
+    const TestClass* secondTest = it.value;
+    bool compare = TestClass(1, 2) == *secondTest;
+    REQUIRE(compare);
+    it++;
+    REQUIRE(it->number1 == 2);
+    REQUIRE(it->number2 == 3);
+    const ArrayList<TestClass>::Iterator it4(&(complexList[2]));
+    REQUIRE(it4->number1 == 2);
+    REQUIRE((*it4).number2 == 3);
+    REQUIRE(complexList.remaining() == 10);
+  }
+}

unittests/container/TestDynamicFifo.cpp

@@ -0,0 +1,145 @@
+#include <fsfw/container/DynamicFIFO.h>
+#include <fsfw/container/FIFO.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+
+TEST_CASE("Dynamic Fifo Tests", "[TestDynamicFifo]") {
+  INFO("Dynamic Fifo Tests");
+  struct Test {
+    uint64_t number1;
+    uint32_t number2;
+    uint8_t number3;
+    bool operator==(struct Test& other) {
+      if ((other.number1 == this->number1) and (other.number1 == this->number1) and
+          (other.number1 == this->number1)) {
+        return true;
+      }
+      return false;
+    }
+  };
+  DynamicFIFO<Test> fifo(3);
+  std::vector<Test> list;
+
+  struct Test structOne({UINT64_MAX, UINT32_MAX, UINT8_MAX});
+  struct Test structTwo({0, 1, 2});
+  struct Test structThree({42, 43, 44});
+  list.push_back(structThree);
+  list.push_back(structTwo);
+  list.push_back(structOne);
+  SECTION("Insert, retrieval test") {
+    REQUIRE(fifo.getMaxCapacity() == 3);
+    REQUIRE(fifo.size() == 0);
+    REQUIRE(fifo.empty());
+    REQUIRE(not fifo.full());
+
+    REQUIRE(fifo.insert(structOne) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.insert(structTwo) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.insert(structThree) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.insert(structTwo) == static_cast<int>(FIFOBase<Test>::FULL));
+
+    struct Test testptr;
+    REQUIRE(fifo.peek(&testptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    bool equal = testptr == structOne;
+    REQUIRE(equal);
+    REQUIRE(fifo.size() == 3);
+    REQUIRE(fifo.full());
+    REQUIRE(not fifo.empty());
+
+    for (size_t i = 2; i < 3; i--) {
+      testptr.number1 = 0;
+      testptr.number2 = 0;
+      testptr.number3 = 0;
+      REQUIRE(fifo.retrieve(&testptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+      equal = testptr == list[i];
+      REQUIRE(equal);
+      REQUIRE(fifo.size() == i);
+    }
+    testptr.number1 = 0;
+    testptr.number2 = 0;
+    testptr.number3 = 0;
+    REQUIRE(fifo.retrieve(&testptr) == static_cast<int>(FIFOBase<Test>::EMPTY));
+    REQUIRE(fifo.peek(&testptr) == static_cast<int>(FIFOBase<Test>::EMPTY));
+    REQUIRE(not fifo.full());
+    REQUIRE(fifo.empty());
+    REQUIRE(fifo.pop() == static_cast<int>(FIFOBase<Test>::EMPTY));
+
+    REQUIRE(fifo.insert(structOne) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.size() == 1);
+    REQUIRE(fifo.insert(structTwo) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.size() == 2);
+    REQUIRE(fifo.pop() == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.size() == 1);
+    testptr.number1 = 0;
+    testptr.number2 = 0;
+    testptr.number3 = 0;
+    REQUIRE(fifo.peek(&testptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    equal = testptr == structTwo;
+    REQUIRE(equal);
+    REQUIRE(fifo.pop() == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.size() == 0);
+    REQUIRE(fifo.empty());
+    // struct Test* ptr = nullptr;
+    // REQUIRE(fifo.retrieve(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
+    // REQUIRE(fifo.peek(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
+  };
+  SECTION("Copy Test") {
+    REQUIRE(fifo.insert(structOne) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.insert(structTwo) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.insert(structThree) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.size() == 3);
+    REQUIRE(fifo.full());
+    REQUIRE(not fifo.empty());
+
+    DynamicFIFO<Test> fifo2(fifo);
+    REQUIRE(fifo2.size() == 3);
+    REQUIRE(fifo2.full());
+    REQUIRE(not fifo2.empty());
+  };
+
+  SECTION("Assignment Test") {
+    REQUIRE(fifo.insert(structOne) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.insert(structTwo) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.insert(structThree) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.size() == 3);
+    REQUIRE(fifo.full());
+    REQUIRE(not fifo.empty());
+
+    DynamicFIFO<Test> fifo2(6);
+    fifo2 = fifo;
+    REQUIRE(fifo2.size() == 3);
+    REQUIRE(fifo2.full());
+    REQUIRE(not fifo2.empty());
+    for (size_t i = 2; i < 3; i--) {
+      struct Test testptr = {0, 0, 0};
+      REQUIRE(fifo2.retrieve(&testptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+      bool equal = testptr == list[i];
+      REQUIRE(equal);
+      REQUIRE(fifo2.size() == i);
+    }
+  };
+
+  SECTION("Assignment Test Smaller") {
+    REQUIRE(fifo.insert(structOne) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.insert(structTwo) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.insert(structThree) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.size() == 3);
+    REQUIRE(fifo.full());
+    REQUIRE(not fifo.empty());
+
+    DynamicFIFO<Test> fifo2(2);
+    fifo2 = fifo;
+    REQUIRE(fifo2.size() == 3);
+    REQUIRE(fifo2.full());
+    REQUIRE(not fifo2.empty());
+    for (size_t i = 2; i < 3; i--) {
+      struct Test testptr = {0, 0, 0};
+      REQUIRE(fifo2.retrieve(&testptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+      bool equal = testptr == list[i];
+      REQUIRE(equal);
+      REQUIRE(fifo2.size() == i);
+    }
+  };
+};

unittests/container/TestFifo.cpp

@@ -0,0 +1,133 @@
+#include <fsfw/container/DynamicFIFO.h>
+#include <fsfw/container/FIFO.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+
+TEST_CASE("Static Fifo Tests", "[TestFifo]") {
+  INFO("Fifo Tests");
+  struct Test {
+    uint64_t number1;
+    uint32_t number2;
+    uint8_t number3;
+    bool operator==(struct Test& other) {
+      if ((other.number1 == this->number1) and (other.number1 == this->number1) and
+          (other.number1 == this->number1)) {
+        return true;
+      }
+      return false;
+    }
+  };
+  FIFO<Test, 3> fifo;
+  std::vector<Test> list;
+
+  struct Test structOne({UINT64_MAX, UINT32_MAX, UINT8_MAX});
+  struct Test structTwo({0, 1, 2});
+  struct Test structThree({42, 43, 44});
+  list.push_back(structThree);
+  list.push_back(structTwo);
+  list.push_back(structOne);
+  SECTION("Insert, retrieval test") {
+    REQUIRE(fifo.getMaxCapacity() == 3);
+    REQUIRE(fifo.size() == 0);
+    REQUIRE(fifo.empty());
+    REQUIRE(not fifo.full());
+
+    REQUIRE(fifo.insert(structOne) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.insert(structTwo) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.insert(structThree) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.insert(structTwo) == static_cast<int>(FIFOBase<Test>::FULL));
+
+    struct Test testptr;
+    REQUIRE(fifo.peek(&testptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    bool equal = testptr == structOne;
+    REQUIRE(equal);
+    REQUIRE(fifo.size() == 3);
+    REQUIRE(fifo.full());
+    REQUIRE(not fifo.empty());
+
+    for (size_t i = 2; i < 3; i--) {
+      testptr.number1 = 0;
+      testptr.number2 = 0;
+      testptr.number3 = 0;
+      REQUIRE(fifo.retrieve(&testptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+      equal = testptr == list[i];
+      REQUIRE(equal);
+      REQUIRE(fifo.size() == i);
+    }
+    testptr.number1 = 0;
+    testptr.number2 = 0;
+    testptr.number3 = 0;
+    REQUIRE(fifo.retrieve(&testptr) == static_cast<int>(FIFOBase<Test>::EMPTY));
+    REQUIRE(fifo.peek(&testptr) == static_cast<int>(FIFOBase<Test>::EMPTY));
+    REQUIRE(not fifo.full());
+    REQUIRE(fifo.empty());
+    REQUIRE(fifo.pop() == static_cast<int>(FIFOBase<Test>::EMPTY));
+
+    REQUIRE(fifo.insert(structOne) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.size() == 1);
+    REQUIRE(fifo.insert(structTwo) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.size() == 2);
+    REQUIRE(fifo.pop() == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.size() == 1);
+    testptr.number1 = 0;
+    testptr.number2 = 0;
+    testptr.number3 = 0;
+
+    // Test that retrieve and peek will not cause a nullptr dereference
+    struct Test* ptr = nullptr;
+    REQUIRE(fifo.retrieve(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
+    REQUIRE(fifo.peek(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
+
+    REQUIRE(fifo.peek(&testptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    equal = testptr == structTwo;
+    REQUIRE(equal);
+    REQUIRE(fifo.pop() == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.size() == 0);
+    REQUIRE(fifo.empty());
+  };
+  SECTION("Copy Test") {
+    REQUIRE(fifo.insert(structOne) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.insert(structTwo) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.insert(structThree) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.size() == 3);
+    REQUIRE(fifo.full());
+    REQUIRE(not fifo.empty());
+
+    FIFO<Test, 3> fifo2(fifo);
+    REQUIRE(fifo2.size() == 3);
+    REQUIRE(fifo2.full());
+    REQUIRE(not fifo2.empty());
+    for (size_t i = 2; i < 3; i--) {
+      struct Test testptr = {0, 0, 0};
+      REQUIRE(fifo2.retrieve(&testptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+      bool equal = testptr == list[i];
+      REQUIRE(equal);
+      REQUIRE(fifo2.size() == i);
+    }
+  };
+
+  SECTION("Assignment Test") {
+    REQUIRE(fifo.insert(structOne) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.insert(structTwo) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.insert(structThree) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(fifo.size() == 3);
+    REQUIRE(fifo.full());
+    REQUIRE(not fifo.empty());
+
+    FIFO<Test, 3> fifo2;
+    fifo2 = fifo;
+    REQUIRE(fifo2.size() == 3);
+    REQUIRE(fifo2.full());
+    REQUIRE(not fifo2.empty());
+    for (size_t i = 2; i < 3; i--) {
+      struct Test testptr = {0, 0, 0};
+      REQUIRE(fifo2.retrieve(&testptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+      bool equal = testptr == list[i];
+      REQUIRE(equal);
+      REQUIRE(fifo2.size() == i);
+    }
+  };
+};

unittests/container/TestFixedArrayList.cpp

@@ -0,0 +1,38 @@
+#include <fsfw/container/FixedArrayList.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+
+TEST_CASE("FixedArrayList Tests", "[TestFixedArrayList]") {
+  INFO("FixedArrayList Tests");
+  using testList = FixedArrayList<uint32_t, 260, uint16_t>;
+  testList list;
+  REQUIRE(list.size == 0);
+  REQUIRE(list.insert(10) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+  REQUIRE(list.size == 1);
+  REQUIRE(list.maxSize() == 260);
+  SECTION("Copy Constructor") {
+    testList list2(list);
+    REQUIRE(list2.size == 1);
+    REQUIRE(list2[0] == 10);
+    REQUIRE(list.maxSize() == 260);
+  };
+  SECTION("Assignment copy") {
+    testList list2;
+    REQUIRE(list2.size == 0);
+    list2 = list;
+    REQUIRE(list2.size == 1);
+    REQUIRE(list2[0] == 10);
+    REQUIRE(list.maxSize() == 260);
+  };
+  SECTION("Fill") {
+    for (auto i = 1; i < 260; i++) {
+      REQUIRE(list.insert(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    }
+    REQUIRE(list.insert(260) == static_cast<int>(ArrayList<uint32_t, uint16_t>::FULL));
+    list.clear();
+    REQUIRE(list.size == 0);
+  }
+}

unittests/container/TestFixedMap.cpp

@@ -0,0 +1,166 @@
+#include <fsfw/container/FixedMap.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+
+template class FixedMap<unsigned int, unsigned short>;
+
+TEST_CASE("FixedMap Tests", "[TestFixedMap]") {
+  INFO("FixedMap Tests");
+
+  FixedMap<unsigned int, unsigned short> map(30);
+  REQUIRE(map.size() == 0);
+  REQUIRE(map.maxSize() == 30);
+  REQUIRE(map.getSerializedSize() == sizeof(uint32_t));
+  REQUIRE(map.empty());
+  REQUIRE(not map.full());
+
+  SECTION("Fill and erase") {
+    for (uint16_t i = 0; i < 30; i++) {
+      REQUIRE(map.insert(std::make_pair(i, i + 1)) ==
+              static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+      REQUIRE(map.exists(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+      REQUIRE(map.find(i)->second == i + 1);
+      REQUIRE(not map.empty());
+    }
+    REQUIRE(map.insert(0, 0) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_ALREADY_EXISTS));
+    REQUIRE(map.insert(31, 0) == static_cast<int>(FixedMap<uint32_t, uint16_t>::MAP_FULL));
+    REQUIRE(map.exists(31) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+    REQUIRE(map.size() == 30);
+    REQUIRE(map.full());
+    {
+      uint16_t* ptr;
+      REQUIRE(map.find(5, &ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+      REQUIRE(*ptr == 6);
+      REQUIRE(*(map.findValue(6)) == 7);
+      REQUIRE(map.find(31, &ptr) ==
+              static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+    }
+
+    REQUIRE(map.getSerializedSize() ==
+            (sizeof(uint32_t) + 30 * (sizeof(uint32_t) + sizeof(uint16_t))));
+    REQUIRE(map.erase(2) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(map.erase(31) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+    REQUIRE(map.exists(2) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+    REQUIRE(map.size() == 29);
+
+    for (auto element : map) {
+      if (element.first == 5) {
+        REQUIRE(element.second == 6);
+      }
+    }
+
+    for (FixedMap<uint32_t, uint16_t>::Iterator it = map.begin(); it != map.end(); it++) {
+      REQUIRE(it->second == it->first + 1);
+      REQUIRE((*it).second == (*it).first + 1);
+      it->second = it->second + 1;
+      REQUIRE(it->second == it->first + 2);
+    }
+
+    for (FixedMap<uint32_t, uint16_t>::Iterator it = map.begin(); it != map.end(); it++) {
+      REQUIRE(map.erase(&it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    }
+
+    REQUIRE(map.size() == 0);
+
+    for (FixedMap<uint32_t, uint16_t>::Iterator it = map.begin(); it != map.end(); it++) {
+      // This line should never executed if begin and end is correct
+      FAIL("Should never be reached, Iterators invalid");
+    }
+  };
+
+  SECTION("Insert variants") {
+    FixedMap<uint32_t, uint16_t>::Iterator it = map.end();
+    REQUIRE(map.insert(36, 37, &it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(it->first == 36);
+    REQUIRE(it->second == 37);
+    REQUIRE(map.size() == 1);
+    REQUIRE(map.insert(37, 38, nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(map.find(37)->second == 38);
+    REQUIRE(map.size() == 2);
+    REQUIRE(map.insert(37, 24, nullptr) ==
+            static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_ALREADY_EXISTS));
+    REQUIRE(map.find(37)->second != 24);
+    REQUIRE(map.size() == 2);
+  };
+  SECTION("Serialize and DeSerialize") {
+    REQUIRE(map.insert(36, 37, nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(map.insert(37, 38, nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    uint8_t buffer[sizeof(uint32_t) + 2 * (sizeof(uint32_t) + sizeof(uint16_t))];
+    REQUIRE(map.getSerializedSize() ==
+            (sizeof(uint32_t) + 2 * (sizeof(uint32_t) + sizeof(uint16_t))));
+    uint8_t* loc_ptr = buffer;
+    size_t size = 0;
+    REQUIRE(map.serialize(&loc_ptr, &size, 10, SerializeIF::Endianness::BIG) ==
+            static_cast<int>(SerializeIF::BUFFER_TOO_SHORT));
+    loc_ptr = buffer;
+    size = 0;
+    REQUIRE(map.serialize(
+                &loc_ptr, &size, sizeof(uint32_t) + 2 * (sizeof(uint32_t) + sizeof(uint16_t)),
+                SerializeIF::Endianness::BIG) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(size == 16);
+
+    uint32_t internal_size = 0;
+    const uint8_t* ptr2 = buffer;
+    REQUIRE(
+        SerializeAdapter::deSerialize(&internal_size, &ptr2, &size, SerializeIF::Endianness::BIG) ==
+        static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(internal_size == 2);
+    for (uint8_t i = 36; i < 38; i++) {
+      uint32_t first_element = 0;
+      REQUIRE(SerializeAdapter::deSerialize(&first_element, &ptr2, &size,
+                                            SerializeIF::Endianness::BIG) ==
+              static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+      REQUIRE(first_element == i);
+      uint16_t second_element = 0;
+      REQUIRE(SerializeAdapter::deSerialize(&second_element, &ptr2, &size,
+                                            SerializeIF::Endianness::BIG) ==
+              static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+      REQUIRE(second_element == i + 1);
+    }
+    REQUIRE(size == 0);
+    map.clear();
+    const uint8_t* constPtr = buffer;
+    size = 16;
+    REQUIRE(map.size() == 0);
+    REQUIRE(map.deSerialize(&constPtr, &size, SerializeIF::Endianness::BIG) ==
+            static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(map.size() == 2);
+    REQUIRE(map.find(36)->second == 37);
+    for (auto& element : map) {
+      REQUIRE((element.first + 1) == element.second);
+    }
+  };
+
+  SECTION("Failed erase and deSerialize") {
+    FixedMap<uint32_t, uint16_t>::Iterator it;
+    std::pair<uint32_t, uint16_t> pair = std::make_pair(44, 43);
+    it = FixedMap<uint32_t, uint16_t>::Iterator(&pair);
+    REQUIRE(map.erase(&it) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+    REQUIRE(map.find(45) == map.end());
+    size_t toLargeMap = 100;
+    const uint8_t* ptr = reinterpret_cast<uint8_t*>(&toLargeMap);
+    size_t size = sizeof(size_t);
+    REQUIRE(map.deSerialize(&ptr, &size, SerializeIF::Endianness::BIG) ==
+            static_cast<int>(SerializeIF::TOO_MANY_ELEMENTS));
+  };
+  SECTION("Little Endianess") {
+    map.clear();
+    map.insert(10, 20, nullptr);
+    uint8_t newBuffer[sizeof(uint32_t) + 1 * (sizeof(uint32_t) + sizeof(uint16_t))];
+    uint8_t* ptr = newBuffer;
+    size_t size = 0;
+    size_t max_size = sizeof(uint32_t) + 1 * (sizeof(uint32_t) + sizeof(uint16_t));
+    REQUIRE(map.serialize(&ptr, &size, max_size, SerializeIF::Endianness::LITTLE) ==
+            static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    map.clear();
+    REQUIRE(map.size() == 0);
+    const uint8_t* ptr2 = newBuffer;
+    REQUIRE(map.deSerialize(&ptr2, &size, SerializeIF::Endianness::LITTLE) ==
+            static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(map.size() == 1);
+    REQUIRE(map.find(10)->second == 20);
+  };
+}

unittests/container/TestFixedOrderedMultimap.cpp

@@ -0,0 +1,221 @@
+#include <fsfw/container/FixedOrderedMultimap.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+
+TEST_CASE("FixedOrderedMultimap Tests", "[TestFixedOrderedMultimap]") {
+  INFO("FixedOrderedMultimap Tests");
+
+  FixedOrderedMultimap<unsigned int, unsigned short> map(30);
+  REQUIRE(map.size() == 0);
+  REQUIRE(map.maxSize() == 30);
+
+  SECTION("Test insert, find, exists") {
+    for (uint16_t i = 0; i < 30; i++) {
+      REQUIRE(map.insert(std::make_pair(i, i + 1)) ==
+              static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+      REQUIRE(map.exists(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+      REQUIRE(map.find(i)->second == i + 1);
+    }
+    REQUIRE(map.insert(0, 0) ==
+            static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::MAP_FULL));
+    REQUIRE(map.exists(31) ==
+            static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+    REQUIRE(map.size() == 30);
+    {
+      uint16_t* ptr;
+      REQUIRE(map.find(5, &ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+      REQUIRE(*ptr == 6);
+      REQUIRE(map.find(31, &ptr) ==
+              static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+    }
+    REQUIRE(map.erase(2) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(map.erase(31) ==
+            static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+    REQUIRE(map.exists(2) ==
+            static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+    REQUIRE(map.size() == 29);
+
+    for (auto element : map) {
+      if (element.first == 5) {
+        REQUIRE(element.second == 6);
+      }
+    }
+
+    for (FixedOrderedMultimap<uint32_t, uint16_t>::Iterator it = map.begin(); it != map.end();
+         it++) {
+      REQUIRE(it->second == it->first + 1);
+      REQUIRE((*it).second == (*it).first + 1);
+      it->second = it->second + 1;
+      REQUIRE(it->second == it->first + 2);
+    }
+
+    {
+      FixedOrderedMultimap<uint32_t, uint16_t>::Iterator it = map.begin();
+      while (it != map.end()) {
+        REQUIRE(map.erase(&it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+      }
+      REQUIRE(map.size() == 0);
+    }
+
+    for (FixedOrderedMultimap<uint32_t, uint16_t>::Iterator it = map.begin(); it != map.end();
+         it++) {
+      // This line should never executed if begin and end is correct
+      FAIL("Should never be reached, Iterators invalid");
+    }
+  };
+
+  SECTION("Test different insert variants") {
+    FixedOrderedMultimap<uint32_t, uint16_t>::Iterator it = map.end();
+    REQUIRE(map.insert(36, 37, &it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(it->first == 36);
+    REQUIRE(it->second == 37);
+    REQUIRE(map.size() == 1);
+    REQUIRE(map.insert(37, 38, nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(map.find(37)->second == 38);
+    REQUIRE(map.size() == 2);
+    REQUIRE(map.insert(37, 24, nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(map.find(37)->second == 38);
+    REQUIRE(map.insert(0, 1, nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(map.find(0)->second == 1);
+    REQUIRE(map.size() == 4);
+    map.clear();
+    REQUIRE(map.size() == 0);
+  }
+  SECTION("Test different erase and find with no entries") {
+    FixedOrderedMultimap<uint32_t, uint16_t>::Iterator it;
+    it = map.end();
+    REQUIRE(map.erase(&it) ==
+            static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+    REQUIRE(map.find(1) == map.end());
+  }
+}
+
+TEST_CASE("FixedOrderedMultimap Non Trivial Type", "[TestFixedOrderedMultimapNonTrivial]") {
+  INFO("FixedOrderedMultimap Non Trivial Type");
+
+  class TestClass {
+   public:
+    TestClass(){};
+    TestClass(uint32_t number1, uint64_t number2) : number1(number1), number2(number2){};
+    ~TestClass(){};
+
+    bool operator==(const TestClass& lhs) {
+      return ((this->number1 == lhs.number1) and (this->number2 == lhs.number2));
+    }
+    bool operator!=(const TestClass& lhs) { return not(this->operator==(lhs)); }
+
+    TestClass(const TestClass& other) {
+      this->number1 = other.number1;
+      this->number2 = other.number2;
+    };
+    TestClass& operator=(const TestClass& other) {
+      this->number1 = other.number1;
+      this->number2 = other.number2;
+      return *this;
+    };
+
+   private:
+    uint32_t number1 = 0;
+    uint64_t number2 = 5;
+  };
+  FixedOrderedMultimap<unsigned int, TestClass> map(30);
+  REQUIRE(map.size() == 0);
+  REQUIRE(map.maxSize() == 30);
+
+  SECTION("Test insert, find, exists") {
+    for (uint16_t i = 0; i < 30; i++) {
+      REQUIRE(map.insert(std::make_pair(i, TestClass(i + 1, i))) ==
+              static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+      REQUIRE(map.exists(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+      bool compare = map.find(i)->second == TestClass(i + 1, i);
+      REQUIRE(compare);
+    }
+    REQUIRE(map.insert(0, TestClass()) ==
+            static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::MAP_FULL));
+    REQUIRE(map.exists(31) ==
+            static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+    REQUIRE(map.size() == 30);
+    {
+      TestClass* ptr = nullptr;
+      REQUIRE(map.find(5, &ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+      bool compare = *ptr == TestClass(6, 5);
+      REQUIRE(compare);
+      REQUIRE(map.find(31, &ptr) ==
+              static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+    }
+    REQUIRE(map.erase(2) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(map.erase(31) ==
+            static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+    REQUIRE(map.exists(2) ==
+            static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
+    REQUIRE(map.size() == 29);
+
+    for (auto element : map) {
+      if (element.first == 5) {
+        bool compare = element.second == TestClass(6, 5);
+        REQUIRE(compare);
+      }
+    }
+
+    for (FixedOrderedMultimap<uint32_t, TestClass>::Iterator it = map.begin(); it != map.end();
+         it++) {
+      bool compare = it->second == TestClass(it->first + 1, it->first);
+      REQUIRE(compare);
+      compare = (*it).second == TestClass((*it).first + 1, (*it).first);
+      REQUIRE(compare);
+      it->second = TestClass(it->first + 2, it->first);
+      compare = it->second == TestClass(it->first + 2, it->first);
+      REQUIRE(compare);
+    }
+
+    {
+      FixedOrderedMultimap<uint32_t, TestClass>::Iterator it = map.begin();
+      while (it != map.end()) {
+        REQUIRE(map.erase(&it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+      }
+      REQUIRE(map.size() == 0);
+    }
+
+    for (FixedOrderedMultimap<uint32_t, TestClass>::Iterator it = map.begin(); it != map.end();
+         it++) {
+      // This line should never executed if begin and end is correct
+      FAIL("Should never be reached, Iterators invalid");
+    }
+  };
+
+  SECTION("Test different insert variants") {
+    FixedOrderedMultimap<uint32_t, TestClass>::Iterator it = map.end();
+    REQUIRE(map.insert(36, TestClass(37, 36), &it) ==
+            static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(it->first == 36);
+    bool compare = it->second == TestClass(37, 36);
+    REQUIRE(compare);
+    REQUIRE(map.size() == 1);
+    REQUIRE(map.insert(37, TestClass(38, 37), nullptr) ==
+            static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    compare = map.find(37)->second == TestClass(38, 37);
+    REQUIRE(compare);
+    REQUIRE(map.size() == 2);
+    REQUIRE(map.insert(37, TestClass(24, 37), nullptr) ==
+            static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    compare = map.find(37)->second == TestClass(38, 37);
+    REQUIRE(compare);
+    REQUIRE(map.insert(0, TestClass(1, 0), nullptr) ==
+            static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    compare = map.find(0)->second == TestClass(1, 0);
+    REQUIRE(compare);
+    REQUIRE(map.size() == 4);
+    map.clear();
+    REQUIRE(map.size() == 0);
+  }
+  SECTION("Test different erase and find with no entries") {
+    FixedOrderedMultimap<uint32_t, TestClass>::Iterator it;
+    it = map.end();
+    REQUIRE(map.erase(&it) ==
+            static_cast<int>(FixedOrderedMultimap<uint32_t, TestClass>::KEY_DOES_NOT_EXIST));
+    REQUIRE(map.find(1) == map.end());
+  }
+}

unittests/container/TestPlacementFactory.cpp

@@ -0,0 +1,48 @@
+#include <fsfw/container/ArrayList.h>
+#include <fsfw/container/PlacementFactory.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/storagemanager/LocalPool.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+
+TEST_CASE("PlacementFactory Tests", "[TestPlacementFactory]") {
+  INFO("PlacementFactory Tests");
+
+  LocalPool::LocalPoolConfig poolCfg = {
+      {1, sizeof(uint16_t)}, {1, sizeof(uint32_t)}, {1, sizeof(uint64_t)}};
+  // const uint16_t element_sizes[3] = {sizeof(uint16_t), sizeof(uint32_t), sizeof(uint64_t)};
+  // const uint16_t n_elements[3] = {1, 1, 1};
+  LocalPool storagePool(0x1, poolCfg, false, true);
+  PlacementFactory factory(&storagePool);
+
+  SECTION("Pool overload") {
+    store_address_t address;
+    uint8_t* ptr = nullptr;
+    REQUIRE(storagePool.getFreeElement(&address, sizeof(ArrayList<uint32_t, uint16_t>), &ptr) ==
+            static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
+    ArrayList<uint32_t, uint16_t>* list2 = factory.generate<ArrayList<uint32_t, uint16_t> >(80);
+    REQUIRE(list2 == nullptr);
+  }
+
+  SECTION("Test generate and destroy") {
+    uint64_t* number = factory.generate<uint64_t>(32000);
+    REQUIRE(number != nullptr);
+    REQUIRE(*number == 32000);
+    store_address_t address;
+    uint8_t* ptr = nullptr;
+    REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr) ==
+            static_cast<int>(StorageManagerIF::DATA_TOO_LARGE));
+    uint64_t* number2 = factory.generate<uint64_t>(12345);
+    REQUIRE(number2 == nullptr);
+    REQUIRE(factory.destroy(number) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr) ==
+            static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+    REQUIRE(storagePool.deleteData(address) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
+
+    // Check that PlacementFactory checks for nullptr
+    ptr = nullptr;
+    REQUIRE(factory.destroy(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
+  }
+}

unittests/datapoollocal/CMakeLists.txt

@@ -0,0 +1,7 @@
+target_sources(${FSFW_TEST_TGT} PRIVATE
+	LocalPoolVariableTest.cpp
+	LocalPoolVectorTest.cpp
+	DataSetTest.cpp
+	LocalPoolManagerTest.cpp
+	LocalPoolOwnerBase.cpp
+)

unittests/datapoollocal/DataSetTest.cpp

@@ -0,0 +1,286 @@
+#include <fsfw/datapool/PoolReadGuard.h>
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/datapoollocal/SharedLocalDataSet.h>
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/globalfunctions/bitutility.h>
+#include <fsfw/objectmanager/ObjectManager.h>
+
+#include <catch2/catch_approx.hpp>
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+#include "LocalPoolOwnerBase.h"
+#include "tests/TestsConfig.h"
+
+TEST_CASE("DataSetTest", "[DataSetTest]") {
+  LocalPoolOwnerBase* poolOwner =
+      ObjectManager::instance()->get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+  REQUIRE(poolOwner != nullptr);
+  REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+  REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation() == retval::CATCH_OK);
+  LocalPoolStaticTestDataSet localSet;
+
+  SECTION("BasicTest") {
+    /* Test some basic functions */
+    CHECK(localSet.getReportingEnabled() == false);
+    CHECK(localSet.getLocalPoolIdsSerializedSize(false) == 3 * sizeof(lp_id_t));
+    CHECK(localSet.getLocalPoolIdsSerializedSize(true) == 3 * sizeof(lp_id_t) + sizeof(uint8_t));
+    CHECK(localSet.getSid() == lpool::testSid);
+    CHECK(localSet.getCreatorObjectId() == objects::TEST_LOCAL_POOL_OWNER_BASE);
+    size_t maxSize = localSet.getLocalPoolIdsSerializedSize(true);
+    uint8_t localPoolIdBuff[maxSize];
+    /* Skip size field */
+    lp_id_t* lpIds = reinterpret_cast<lp_id_t*>(localPoolIdBuff + 1);
+    size_t serSize = 0;
+    uint8_t* localPoolIdBuffPtr = reinterpret_cast<uint8_t*>(localPoolIdBuff);
+
+    /* Test local pool ID serialization */
+    CHECK(localSet.serializeLocalPoolIds(&localPoolIdBuffPtr, &serSize, maxSize,
+                                         SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+    CHECK(serSize == maxSize);
+    CHECK(localPoolIdBuff[0] == 3);
+    CHECK(lpIds[0] == localSet.localPoolVarUint8.getDataPoolId());
+    CHECK(lpIds[1] == localSet.localPoolVarFloat.getDataPoolId());
+    CHECK(lpIds[2] == localSet.localPoolUint16Vec.getDataPoolId());
+    /* Now serialize without fill count */
+    lpIds = reinterpret_cast<lp_id_t*>(localPoolIdBuff);
+    localPoolIdBuffPtr = localPoolIdBuff;
+    serSize = 0;
+    CHECK(localSet.serializeLocalPoolIds(&localPoolIdBuffPtr, &serSize, maxSize,
+                                         SerializeIF::Endianness::MACHINE,
+                                         false) == retval::CATCH_OK);
+    CHECK(serSize == maxSize - sizeof(uint8_t));
+    CHECK(lpIds[0] == localSet.localPoolVarUint8.getDataPoolId());
+    CHECK(lpIds[1] == localSet.localPoolVarFloat.getDataPoolId());
+    CHECK(lpIds[2] == localSet.localPoolUint16Vec.getDataPoolId());
+
+    {
+      /* Test read operation. Values should be all zeros */
+      PoolReadGuard readHelper(&localSet);
+      REQUIRE(readHelper.getReadResult() == retval::CATCH_OK);
+      CHECK(not localSet.isValid());
+      CHECK(localSet.localPoolVarUint8.value == 0);
+      CHECK(not localSet.localPoolVarUint8.isValid());
+      CHECK(localSet.localPoolVarFloat.value == Catch::Approx(0.0));
+      CHECK(not localSet.localPoolVarUint8.isValid());
+      CHECK(localSet.localPoolUint16Vec.value[0] == 0);
+      CHECK(localSet.localPoolUint16Vec.value[1] == 0);
+      CHECK(localSet.localPoolUint16Vec.value[2] == 0);
+      CHECK(not localSet.localPoolVarUint8.isValid());
+
+      /* Now set new values, commit should be done by read helper automatically */
+      localSet.localPoolVarUint8 = 232;
+      localSet.localPoolVarFloat = -2324.322;
+      localSet.localPoolUint16Vec.value[0] = 232;
+      localSet.localPoolUint16Vec.value[1] = 23923;
+      localSet.localPoolUint16Vec.value[2] = 1;
+      localSet.setValidity(true, true);
+    }
+
+    /* Zero out some values for next test */
+    localSet.localPoolVarUint8 = 0;
+    localSet.localPoolVarFloat = 0;
+
+    localSet.setAllVariablesReadOnly();
+    CHECK(localSet.localPoolUint16Vec.getReadWriteMode() == pool_rwm_t::VAR_READ);
+    CHECK(localSet.localPoolVarUint8.getReadWriteMode() == pool_rwm_t::VAR_READ);
+    CHECK(localSet.localPoolVarFloat.getReadWriteMode() == pool_rwm_t::VAR_READ);
+
+    {
+      /* Now we read again and check whether our zeroed values were overwritten with
+      the values in the pool */
+      PoolReadGuard readHelper(&localSet);
+      REQUIRE(readHelper.getReadResult() == retval::CATCH_OK);
+      CHECK(localSet.isValid());
+      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 */
+      localSet.setValidityBufferGeneration(false);
+      maxSize = localSet.getSerializedSize();
+      CHECK(maxSize == sizeof(uint8_t) + sizeof(uint16_t) * 3 + sizeof(float));
+      serSize = 0;
+      /* Already reserve additional space for validity buffer, will be needed later */
+      uint8_t buffer[maxSize + 1];
+      uint8_t* buffPtr = buffer;
+      CHECK(localSet.serialize(&buffPtr, &serSize, maxSize, SerializeIF::Endianness::MACHINE) ==
+            retval::CATCH_OK);
+      uint8_t rawUint8 = buffer[0];
+      CHECK(rawUint8 == 232);
+      float rawFloat = 0.0;
+      std::memcpy(&rawFloat, buffer + sizeof(uint8_t), sizeof(float));
+      CHECK(rawFloat == Catch::Approx(-2324.322));
+
+      uint16_t rawUint16Vec[3];
+      std::memcpy(&rawUint16Vec, buffer + sizeof(uint8_t) + sizeof(float), 3 * sizeof(uint16_t));
+      CHECK(rawUint16Vec[0] == 232);
+      CHECK(rawUint16Vec[1] == 23923);
+      CHECK(rawUint16Vec[2] == 1);
+
+      size_t sizeToDeserialize = maxSize;
+      /* Now we zeros out the raw entries and deserialize back into the dataset */
+      std::memset(buffer, 0, sizeof(buffer));
+      const uint8_t* constBuffPtr = buffer;
+      CHECK(localSet.deSerialize(&constBuffPtr, &sizeToDeserialize,
+                                 SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+      /* Check whether deserialization was successfull */
+      CHECK(localSet.localPoolVarUint8.value == 0);
+      CHECK(localSet.localPoolVarFloat.value == Catch::Approx(0.0));
+      CHECK(localSet.localPoolVarUint8.value == 0);
+      CHECK(localSet.localPoolUint16Vec.value[0] == 0);
+      CHECK(localSet.localPoolUint16Vec.value[1] == 0);
+      CHECK(localSet.localPoolUint16Vec.value[2] == 0);
+      /* Validity should be unchanged */
+      CHECK(localSet.localPoolVarUint8.isValid());
+      CHECK(localSet.localPoolVarFloat.isValid());
+      CHECK(localSet.localPoolUint16Vec.isValid());
+
+      /* Now we do the same process but with the validity buffer */
+      localSet.localPoolVarUint8 = 232;
+      localSet.localPoolVarFloat = -2324.322;
+      localSet.localPoolUint16Vec.value[0] = 232;
+      localSet.localPoolUint16Vec.value[1] = 23923;
+      localSet.localPoolUint16Vec.value[2] = 1;
+      localSet.localPoolVarUint8.setValid(true);
+      localSet.localPoolVarFloat.setValid(false);
+      localSet.localPoolUint16Vec.setValid(true);
+      localSet.setValidityBufferGeneration(true);
+      maxSize = localSet.getSerializedSize();
+      CHECK(maxSize == sizeof(uint8_t) + sizeof(uint16_t) * 3 + sizeof(float) + 1);
+      serSize = 0;
+      buffPtr = buffer;
+      CHECK(localSet.serialize(&buffPtr, &serSize, maxSize, SerializeIF::Endianness::MACHINE) ==
+            retval::CATCH_OK);
+      CHECK(rawUint8 == 232);
+      std::memcpy(&rawFloat, buffer + sizeof(uint8_t), sizeof(float));
+      CHECK(rawFloat == Catch::Approx(-2324.322));
+
+      std::memcpy(&rawUint16Vec, buffer + sizeof(uint8_t) + sizeof(float), 3 * sizeof(uint16_t));
+      CHECK(rawUint16Vec[0] == 232);
+      CHECK(rawUint16Vec[1] == 23923);
+      CHECK(rawUint16Vec[2] == 1);
+      /* We can do it like this because the buffer only has one byte for
+      less than 8 variables */
+      uint8_t* validityByte = buffer + sizeof(buffer) - 1;
+      bool bitSet = false;
+      bitutil::get(validityByte, 0, bitSet);
+
+      CHECK(bitSet == true);
+      bitutil::get(validityByte, 1, bitSet);
+      CHECK(bitSet == false);
+      bitutil::get(validityByte, 2, bitSet);
+      CHECK(bitSet == true);
+
+      /* Now we manipulate the validity buffer for the deserialization */
+      bitutil::clear(validityByte, 0);
+      bitutil::set(validityByte, 1);
+      bitutil::clear(validityByte, 2);
+      /* Zero out everything except validity buffer */
+      std::memset(buffer, 0, sizeof(buffer) - 1);
+      sizeToDeserialize = maxSize;
+      constBuffPtr = buffer;
+      CHECK(localSet.deSerialize(&constBuffPtr, &sizeToDeserialize,
+                                 SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+      /* Check whether deserialization was successfull */
+      CHECK(localSet.localPoolVarUint8.value == 0);
+      CHECK(localSet.localPoolVarFloat.value == Catch::Approx(0.0));
+      CHECK(localSet.localPoolVarUint8.value == 0);
+      CHECK(localSet.localPoolUint16Vec.value[0] == 0);
+      CHECK(localSet.localPoolUint16Vec.value[1] == 0);
+      CHECK(localSet.localPoolUint16Vec.value[2] == 0);
+      CHECK(not localSet.localPoolVarUint8.isValid());
+      CHECK(localSet.localPoolVarFloat.isValid());
+      CHECK(not localSet.localPoolUint16Vec.isValid());
+    }
+
+    /* Common fault test cases */
+    LocalPoolObjectBase* variableHandle = poolOwner->getPoolObjectHandle(lpool::uint32VarId);
+    CHECK(variableHandle != nullptr);
+    CHECK(localSet.registerVariable(variableHandle) == static_cast<int>(DataSetIF::DATA_SET_FULL));
+    variableHandle = nullptr;
+    REQUIRE(localSet.registerVariable(variableHandle) ==
+            static_cast<int>(DataSetIF::POOL_VAR_NULL));
+  }
+
+  SECTION("MorePoolVariables") {
+    LocalDataSet set(poolOwner, 2, 10);
+
+    /* Register same variables again to get more than 8 registered variables */
+    for (uint8_t idx = 0; idx < 8; idx++) {
+      REQUIRE(set.registerVariable(&localSet.localPoolVarUint8) == retval::CATCH_OK);
+    }
+    REQUIRE(set.registerVariable(&localSet.localPoolVarUint8) == retval::CATCH_OK);
+    REQUIRE(set.registerVariable(&localSet.localPoolUint16Vec) == retval::CATCH_OK);
+
+    set.setValidityBufferGeneration(true);
+    {
+      PoolReadGuard readHelper(&localSet);
+      localSet.localPoolVarUint8.value = 42;
+      localSet.localPoolVarUint8.setValid(true);
+      localSet.localPoolUint16Vec.setValid(false);
+    }
+
+    size_t maxSize = set.getSerializedSize();
+    CHECK(maxSize == 9 + sizeof(uint16_t) * 3 + 2);
+    size_t serSize = 0;
+    /* Already reserve additional space for validity buffer, will be needed later */
+    uint8_t buffer[maxSize + 1];
+    uint8_t* buffPtr = buffer;
+    CHECK(set.serialize(&buffPtr, &serSize, maxSize, SerializeIF::Endianness::MACHINE) ==
+          retval::CATCH_OK);
+    std::array<uint8_t, 2> validityBuffer;
+    std::memcpy(validityBuffer.data(), buffer + 9 + sizeof(uint16_t) * 3, 2);
+    /* The first 9 variables should be valid */
+    CHECK(validityBuffer[0] == 0xff);
+    bool bitSet = false;
+    bitutil::get(validityBuffer.data() + 1, 0, bitSet);
+    CHECK(bitSet == true);
+    bitutil::get(validityBuffer.data() + 1, 1, bitSet);
+    CHECK(bitSet == false);
+
+    /* Now we invert the validity */
+    validityBuffer[0] = 0;
+    validityBuffer[1] = 0b0100'0000;
+    std::memcpy(buffer + 9 + sizeof(uint16_t) * 3, validityBuffer.data(), 2);
+    const uint8_t* constBuffPtr = buffer;
+    size_t sizeToDeSerialize = serSize;
+    CHECK(set.deSerialize(&constBuffPtr, &sizeToDeSerialize, SerializeIF::Endianness::MACHINE) ==
+          retval::CATCH_OK);
+    CHECK(localSet.localPoolVarUint8.isValid() == false);
+    CHECK(localSet.localPoolUint16Vec.isValid() == true);
+  }
+
+  SECTION("SharedDataSet") {
+    object_id_t sharedSetId = objects::SHARED_SET_ID;
+    SharedLocalDataSet sharedSet(sharedSetId, poolOwner, lpool::testSetId, 5);
+    localSet.localPoolVarUint8.setReadWriteMode(pool_rwm_t::VAR_WRITE);
+    localSet.localPoolUint16Vec.setReadWriteMode(pool_rwm_t::VAR_WRITE);
+    CHECK(sharedSet.registerVariable(&localSet.localPoolVarUint8) == retval::CATCH_OK);
+    CHECK(sharedSet.registerVariable(&localSet.localPoolUint16Vec) == retval::CATCH_OK);
+    CHECK(sharedSet.initialize() == retval::CATCH_OK);
+    CHECK(sharedSet.lockDataset() == retval::CATCH_OK);
+    CHECK(sharedSet.unlockDataset() == retval::CATCH_OK);
+
+    {
+      // PoolReadGuard rg(&sharedSet);
+      // CHECK(rg.getReadResult() == retval::CATCH_OK);
+      localSet.localPoolVarUint8.value = 5;
+      localSet.localPoolUint16Vec.value[0] = 1;
+      localSet.localPoolUint16Vec.value[1] = 2;
+      localSet.localPoolUint16Vec.value[2] = 3;
+      CHECK(sharedSet.commit() == retval::CATCH_OK);
+    }
+
+    sharedSet.setReadCommitProtectionBehaviour(true);
+  }
+
+  /* we need to reset the subscription list because the pool owner
+  is a global object. */
+  CHECK(poolOwner->reset() == retval::CATCH_OK);
+}

unittests/datapoollocal/LocalPoolManagerTest.cpp

@@ -0,0 +1,413 @@
+#include <fsfw/datapool/PoolReadGuard.h>
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/globalfunctions/timevalOperations.h>
+#include <fsfw/housekeeping/HousekeepingSnapshot.h>
+#include <fsfw/ipc/CommandMessageCleaner.h>
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/timemanager/CCSDSTime.h>
+
+#include <catch2/catch_approx.hpp>
+#include <catch2/catch_test_macros.hpp>
+#include <iostream>
+
+#include "CatchDefinitions.h"
+#include "LocalPoolOwnerBase.h"
+
+TEST_CASE("LocalPoolManagerTest", "[LocManTest]") {
+  LocalPoolOwnerBase* poolOwner =
+      ObjectManager::instance()->get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+  REQUIRE(poolOwner != nullptr);
+  REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+  REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation() == retval::CATCH_OK);
+
+  MessageQueueMockBase* poolOwnerMock = poolOwner->getMockQueueHandle();
+  REQUIRE(poolOwnerMock != nullptr);
+
+  // MessageQueueIF* hkCommander = QueueFactory::instance()->createMessageQueue();
+  CommandMessage messageSent;
+  uint8_t messagesSent = 0;
+
+  SECTION("BasicTest") {
+    {
+      /* For code coverage, should not crash */
+      LocalDataPoolManager manager(nullptr, nullptr);
+    }
+    auto owner = poolOwner->poolManager.getOwner();
+    REQUIRE(owner != nullptr);
+    CHECK(owner->getObjectId() == objects::TEST_LOCAL_POOL_OWNER_BASE);
+
+    /* Subscribe for message generation on update. */
+    REQUIRE(poolOwner->subscribeWrapperSetUpdate() == retval::CATCH_OK);
+    /* Subscribe for an update message. */
+    poolOwner->dataset.setChanged(true);
+    /* Now the update message should be generated. */
+    REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+    REQUIRE(poolOwnerMock->wasMessageSent() == true);
+
+    REQUIRE(poolOwnerMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+    CHECK(messageSent.getCommand() ==
+          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+
+    /* Should have been reset. */
+    CHECK(poolOwner->dataset.hasChanged() == false);
+    /* Set changed again, result should be the same. */
+    poolOwner->dataset.setChanged(true);
+    REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(messagesSent == 1);
+    REQUIRE(poolOwnerMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+    CHECK(messageSent.getCommand() ==
+          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+
+    /* Now subscribe for set update HK as well. */
+    REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
+    poolOwner->dataset.setChanged(true);
+    REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(messagesSent == 2);
+    /* first message sent should be the update notification, considering
+    the internal list is a vector checked in insertion order. */
+    REQUIRE(poolOwnerMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+    CHECK(messageSent.getCommand() ==
+          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+
+    REQUIRE(poolOwnerMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+    CHECK(messageSent.getCommand() == static_cast<int>(HousekeepingMessage::HK_REPORT));
+    /* Clear message to avoid memory leak, our mock won't do it for us (yet) */
+    CommandMessageCleaner::clearCommandMessage(&messageSent);
+  }
+
+  SECTION("SetSnapshotUpdateTest") {
+    /* Set the variables in the set to certain values. These are checked later. */
+    {
+      PoolReadGuard readHelper(&poolOwner->dataset);
+      REQUIRE(readHelper.getReadResult() == retval::CATCH_OK);
+      poolOwner->dataset.localPoolVarUint8.value = 5;
+      poolOwner->dataset.localPoolVarFloat.value = -12.242;
+      poolOwner->dataset.localPoolUint16Vec.value[0] = 2;
+      poolOwner->dataset.localPoolUint16Vec.value[1] = 32;
+      poolOwner->dataset.localPoolUint16Vec.value[2] = 42932;
+    }
+
+    /* Subscribe for snapshot generation on update. */
+    REQUIRE(poolOwner->subscribeWrapperSetUpdateSnapshot() == retval::CATCH_OK);
+    poolOwner->dataset.setChanged(true);
+
+    /* Store current time, we are going to check the (approximate) time equality later */
+    timeval now;
+    Clock::getClock_timeval(&now);
+
+    /* Trigger generation of snapshot */
+    REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(messagesSent == 1);
+    REQUIRE(poolOwnerMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+    /* Check that snapshot was generated */
+    CHECK(messageSent.getCommand() == static_cast<int>(HousekeepingMessage::UPDATE_SNAPSHOT_SET));
+    /* Now we deserialize the snapshot into a new dataset instance */
+    CCSDSTime::CDS_short cdsShort;
+    LocalPoolTestDataSet newSet;
+    HousekeepingSnapshot snapshot(&cdsShort, &newSet);
+    store_address_t storeId;
+    HousekeepingMessage::getUpdateSnapshotSetCommand(&messageSent, &storeId);
+    ConstAccessorPair accessorPair = tglob::getIpcStoreHandle()->getData(storeId);
+    REQUIRE(accessorPair.first == retval::CATCH_OK);
+    const uint8_t* readOnlyPtr = accessorPair.second.data();
+    size_t sizeToDeserialize = accessorPair.second.size();
+    CHECK(newSet.localPoolVarFloat.value == 0);
+    CHECK(newSet.localPoolVarUint8 == 0);
+    CHECK(newSet.localPoolUint16Vec.value[0] == 0);
+    CHECK(newSet.localPoolUint16Vec.value[1] == 0);
+    CHECK(newSet.localPoolUint16Vec.value[2] == 0);
+    /* Fill the dataset and timestamp */
+    REQUIRE(snapshot.deSerialize(&readOnlyPtr, &sizeToDeserialize,
+                                 SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+    /* Now we check that the snapshot is actually correct */
+    CHECK(newSet.localPoolVarFloat.value == Catch::Approx(-12.242));
+    CHECK(newSet.localPoolVarUint8 == 5);
+    CHECK(newSet.localPoolUint16Vec.value[0] == 2);
+    CHECK(newSet.localPoolUint16Vec.value[1] == 32);
+    CHECK(newSet.localPoolUint16Vec.value[2] == 42932);
+
+    /* Now we check that both times are equal */
+    timeval timeFromHK;
+    auto result = CCSDSTime::convertFromCDS(&timeFromHK, &cdsShort);
+    CHECK(result == HasReturnvaluesIF::RETURN_OK);
+    timeval difference = timeFromHK - now;
+    CHECK(timevalOperations::toDouble(difference) < 1.0);
+  }
+
+  SECTION("VariableSnapshotTest") {
+    /* Acquire subscription interface */
+    ProvidesDataPoolSubscriptionIF* subscriptionIF = poolOwner->getSubscriptionInterface();
+    REQUIRE(subscriptionIF != nullptr);
+
+    /* Subscribe for variable snapshot */
+    REQUIRE(poolOwner->subscribeWrapperVariableSnapshot(lpool::uint8VarId) == retval::CATCH_OK);
+    auto poolVar =
+        dynamic_cast<lp_var_t<uint8_t>*>(poolOwner->getPoolObjectHandle(lpool::uint8VarId));
+    REQUIRE(poolVar != nullptr);
+
+    {
+      PoolReadGuard rg(poolVar);
+      CHECK(rg.getReadResult() == retval::CATCH_OK);
+      poolVar->value = 25;
+    }
+
+    poolVar->setChanged(true);
+    /* Store current time, we are going to check the (approximate) time equality later */
+    CCSDSTime::CDS_short timeCdsNow;
+    timeval now;
+    Clock::getClock_timeval(&now);
+    REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+
+    /* Check update snapshot was sent. */
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(messagesSent == 1);
+
+    /* Should have been reset. */
+    CHECK(poolVar->hasChanged() == false);
+    REQUIRE(poolOwnerMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+    CHECK(messageSent.getCommand() ==
+          static_cast<int>(HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE));
+    /* Now we deserialize the snapshot into a new dataset instance */
+    CCSDSTime::CDS_short cdsShort;
+    lp_var_t<uint8_t> varCopy = lp_var_t<uint8_t>(lpool::uint8VarGpid);
+    HousekeepingSnapshot snapshot(&cdsShort, &varCopy);
+    store_address_t storeId;
+    HousekeepingMessage::getUpdateSnapshotVariableCommand(&messageSent, &storeId);
+    ConstAccessorPair accessorPair = tglob::getIpcStoreHandle()->getData(storeId);
+    REQUIRE(accessorPair.first == retval::CATCH_OK);
+    const uint8_t* readOnlyPtr = accessorPair.second.data();
+    size_t sizeToDeserialize = accessorPair.second.size();
+    CHECK(varCopy.value == 0);
+    /* Fill the dataset and timestamp */
+    REQUIRE(snapshot.deSerialize(&readOnlyPtr, &sizeToDeserialize,
+                                 SerializeIF::Endianness::MACHINE) == retval::CATCH_OK);
+    CHECK(varCopy.value == 25);
+
+    /* Now we check that both times are equal */
+    timeval timeFromHK;
+    auto result = CCSDSTime::convertFromCDS(&timeFromHK, &cdsShort);
+    CHECK(result == HasReturnvaluesIF::RETURN_OK);
+    timeval difference = timeFromHK - now;
+    CHECK(timevalOperations::toDouble(difference) < 1.0);
+  }
+
+  SECTION("VariableNotificationTest") {
+    /* Acquire subscription interface */
+    ProvidesDataPoolSubscriptionIF* subscriptionIF = poolOwner->getSubscriptionInterface();
+    REQUIRE(subscriptionIF != nullptr);
+
+    /* Subscribe for variable update */
+    REQUIRE(poolOwner->subscribeWrapperVariableUpdate(lpool::uint8VarId) == retval::CATCH_OK);
+    lp_var_t<uint8_t>* poolVar =
+        dynamic_cast<lp_var_t<uint8_t>*>(poolOwner->getPoolObjectHandle(lpool::uint8VarId));
+    REQUIRE(poolVar != nullptr);
+    poolVar->setChanged(true);
+    REQUIRE(poolVar->hasChanged() == true);
+    REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+
+    /* Check update notification was sent. */
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(messagesSent == 1);
+    /* Should have been reset. */
+    CHECK(poolVar->hasChanged() == false);
+    REQUIRE(poolOwnerMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+    CHECK(messageSent.getCommand() ==
+          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
+    /* Now subscribe for the dataset update (HK and update) again with subscription interface */
+    REQUIRE(subscriptionIF->subscribeForSetUpdateMessage(lpool::testSetId, objects::NO_OBJECT,
+                                                         objects::HK_RECEIVER_MOCK,
+                                                         false) == retval::CATCH_OK);
+    REQUIRE(poolOwner->subscribeWrapperSetUpdateHk() == retval::CATCH_OK);
+
+    poolOwner->dataset.setChanged(true);
+    REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+    /* Now two messages should be sent. */
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(messagesSent == 2);
+    poolOwnerMock->clearMessages(true);
+
+    poolOwner->dataset.setChanged(true);
+    poolVar->setChanged(true);
+    REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+    /* Now three messages should be sent. */
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(messagesSent == 3);
+    REQUIRE(poolOwnerMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+    CHECK(messageSent.getCommand() ==
+          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
+    REQUIRE(poolOwnerMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+    CHECK(messageSent.getCommand() ==
+          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+    REQUIRE(poolOwnerMock->receiveMessage(&messageSent) == retval::CATCH_OK);
+    CHECK(messageSent.getCommand() == static_cast<int>(HousekeepingMessage::HK_REPORT));
+    CommandMessageCleaner::clearCommandMessage(&messageSent);
+    REQUIRE(poolOwnerMock->receiveMessage(&messageSent) == static_cast<int>(MessageQueueIF::EMPTY));
+  }
+
+  SECTION("PeriodicHKAndMessaging") {
+    /* Now we subcribe for a HK periodic generation. Even when it's difficult to simulate
+    the temporal behaviour correctly the HK manager should generate a HK packet
+    immediately and the periodic helper depends on HK op function calls anyway instead of
+    using the clock, so we could also just call performHkOperation multiple times */
+    REQUIRE(poolOwner->subscribePeriodicHk(true) == retval::CATCH_OK);
+    REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+    /* Now HK packet should be sent as message immediately. */
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(messagesSent == 1);
+    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+
+    LocalPoolDataSetBase* setHandle = poolOwner->getDataSetHandle(lpool::testSid);
+    REQUIRE(setHandle != nullptr);
+    CHECK(poolOwner->poolManager.generateHousekeepingPacket(lpool::testSid, setHandle, false) ==
+          retval::CATCH_OK);
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(messagesSent == 1);
+    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+
+    CHECK(setHandle->getReportingEnabled() == true);
+    CommandMessage hkCmd;
+    HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, false, false);
+    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+    CHECK(setHandle->getReportingEnabled() == false);
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(messagesSent == 1);
+    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+
+    HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, true, false);
+    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+    CHECK(setHandle->getReportingEnabled() == true);
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+
+    HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, false, false);
+    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+    CHECK(setHandle->getReportingEnabled() == false);
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+
+    HousekeepingMessage::setCollectionIntervalModificationCommand(&hkCmd, lpool::testSid, 0.4,
+                                                                  false);
+    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+    /* For non-diagnostics and a specified minimum frequency of 0.2 seconds, the
+    resulting collection interval should be 1.0 second */
+    CHECK(poolOwner->dataset.getCollectionInterval() == 1.0);
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(messagesSent == 1);
+    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+
+    HousekeepingMessage::setStructureReportingCommand(&hkCmd, lpool::testSid, false);
+    REQUIRE(poolOwner->poolManager.performHkOperation() == retval::CATCH_OK);
+    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+    /* Now HK packet should be sent as message. */
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(messagesSent == 1);
+    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+
+    HousekeepingMessage::setOneShotReportCommand(&hkCmd, lpool::testSid, false);
+    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(messagesSent == 1);
+    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+
+    HousekeepingMessage::setUpdateNotificationSetCommand(&hkCmd, lpool::testSid);
+    sid_t sidToCheck;
+    store_address_t storeId;
+    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+    CHECK(poolOwner->changedDataSetCallbackWasCalled(sidToCheck, storeId) == true);
+    CHECK(sidToCheck == lpool::testSid);
+
+    /* Now we test the handling is the dataset is set to diagnostic */
+    poolOwner->dataset.setDiagnostic(true);
+
+    HousekeepingMessage::setStructureReportingCommand(&hkCmd, lpool::testSid, false);
+    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) ==
+          static_cast<int>(LocalDataPoolManager::WRONG_HK_PACKET_TYPE));
+    /* We still expect a failure message being sent */
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(messagesSent == 1);
+    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+
+    HousekeepingMessage::setCollectionIntervalModificationCommand(&hkCmd, lpool::testSid, 0.4,
+                                                                  false);
+    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) ==
+          static_cast<int>(LocalDataPoolManager::WRONG_HK_PACKET_TYPE));
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(messagesSent == 1);
+    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+
+    HousekeepingMessage::setStructureReportingCommand(&hkCmd, lpool::testSid, false);
+    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) ==
+          static_cast<int>(LocalDataPoolManager::WRONG_HK_PACKET_TYPE));
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(messagesSent == 1);
+    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+
+    HousekeepingMessage::setStructureReportingCommand(&hkCmd, lpool::testSid, true);
+    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(messagesSent == 1);
+    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+
+    HousekeepingMessage::setCollectionIntervalModificationCommand(&hkCmd, lpool::testSid, 0.4,
+                                                                  true);
+    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(messagesSent == 1);
+    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+
+    HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, true, true);
+    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(messagesSent == 1);
+    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+
+    HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, false, true);
+    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(messagesSent == 1);
+    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+
+    HousekeepingMessage::setOneShotReportCommand(&hkCmd, lpool::testSid, false);
+    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) ==
+          static_cast<int>(LocalDataPoolManager::WRONG_HK_PACKET_TYPE));
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(messagesSent == 1);
+    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+
+    HousekeepingMessage::setOneShotReportCommand(&hkCmd, lpool::testSid, true);
+    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+    REQUIRE(poolOwnerMock->wasMessageSent(&messagesSent) == true);
+    CHECK(messagesSent == 1);
+    CHECK(poolOwnerMock->popMessage() == retval::CATCH_OK);
+
+    HousekeepingMessage::setUpdateNotificationVariableCommand(&hkCmd, lpool::uint8VarGpid);
+    gp_id_t gpidToCheck;
+    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+    CHECK(poolOwner->changedVariableCallbackWasCalled(gpidToCheck, storeId) == true);
+    CHECK(gpidToCheck == lpool::uint8VarGpid);
+
+    HousekeepingMessage::setUpdateSnapshotSetCommand(&hkCmd, lpool::testSid,
+                                                     storeId::INVALID_STORE_ADDRESS);
+    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+    CHECK(poolOwner->changedDataSetCallbackWasCalled(sidToCheck, storeId) == true);
+    CHECK(sidToCheck == lpool::testSid);
+
+    HousekeepingMessage::setUpdateSnapshotVariableCommand(&hkCmd, lpool::uint8VarGpid,
+                                                          storeId::INVALID_STORE_ADDRESS);
+    CHECK(poolOwner->poolManager.handleHousekeepingMessage(&hkCmd) == retval::CATCH_OK);
+    CHECK(poolOwner->changedVariableCallbackWasCalled(gpidToCheck, storeId) == true);
+    CHECK(gpidToCheck == lpool::uint8VarGpid);
+
+    poolOwner->poolManager.printPoolEntry(lpool::uint8VarId);
+  }
+
+  /* we need to reset the subscription list because the pool owner
+  is a global object. */
+  CHECK(poolOwner->reset() == retval::CATCH_OK);
+  poolOwnerMock->clearMessages(true);
+}

unittests/datapoollocal/LocalPoolOwnerBase.cpp

@@ -0,0 +1,127 @@
+#include "LocalPoolOwnerBase.h"
+
+LocalPoolOwnerBase::LocalPoolOwnerBase(object_id_t objectId)
+    : SystemObject(objectId), poolManager(this, messageQueue), dataset(this, lpool::testSetId) {
+  messageQueue = new MessageQueueMockBase();
+}
+
+LocalPoolOwnerBase::~LocalPoolOwnerBase() {
+  QueueFactory::instance()->deleteMessageQueue(messageQueue);
+}
+
+ReturnValue_t LocalPoolOwnerBase::initializeHkManager() {
+  if (not initialized) {
+    initialized = true;
+    return poolManager.initialize(messageQueue);
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t LocalPoolOwnerBase::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                          LocalDataPoolManager &poolManager) {
+  // Default initialization empty for now.
+  localDataPoolMap.emplace(lpool::uint8VarId, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(lpool::floatVarId, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(lpool::uint32VarId, new PoolEntry<uint32_t>({0}));
+
+  localDataPoolMap.emplace(lpool::uint16Vec3Id, new PoolEntry<uint16_t>({0, 0, 0}));
+  localDataPoolMap.emplace(lpool::int64Vec2Id, new PoolEntry<int64_t>({0, 0}));
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+LocalPoolObjectBase *LocalPoolOwnerBase::getPoolObjectHandle(lp_id_t localPoolId) {
+  if (localPoolId == lpool::uint8VarId) {
+    return &testUint8;
+  } else if (localPoolId == lpool::uint16Vec3Id) {
+    return &testUint16Vec;
+  } else if (localPoolId == lpool::floatVarId) {
+    return &testFloat;
+  } else if (localPoolId == lpool::int64Vec2Id) {
+    return &testInt64Vec;
+  } else if (localPoolId == lpool::uint32VarId) {
+    return &testUint32;
+  } else {
+    return &testUint8;
+  }
+}
+
+ReturnValue_t LocalPoolOwnerBase::reset() {
+  resetSubscriptionList();
+  ReturnValue_t status = HasReturnvaluesIF::RETURN_OK;
+  {
+    PoolReadGuard readHelper(&dataset);
+    if (readHelper.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
+      status = readHelper.getReadResult();
+    }
+    dataset.localPoolVarUint8.value = 0;
+    dataset.localPoolVarFloat.value = 0.0;
+    dataset.localPoolUint16Vec.value[0] = 0;
+    dataset.localPoolUint16Vec.value[1] = 0;
+    dataset.localPoolUint16Vec.value[2] = 0;
+    dataset.setValidity(false, true);
+  }
+
+  {
+    PoolReadGuard readHelper(&testUint32);
+    if (readHelper.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
+      status = readHelper.getReadResult();
+    }
+    testUint32.value = 0;
+    testUint32.setValid(false);
+  }
+
+  {
+    PoolReadGuard readHelper(&testInt64Vec);
+    if (readHelper.getReadResult() != HasReturnvaluesIF::RETURN_OK) {
+      status = readHelper.getReadResult();
+    }
+    testInt64Vec.value[0] = 0;
+    testInt64Vec.value[1] = 0;
+    testInt64Vec.setValid(false);
+  }
+  return status;
+}
+
+bool LocalPoolOwnerBase::changedDataSetCallbackWasCalled(sid_t &sid, store_address_t &storeId) {
+  bool condition = false;
+  if (not this->changedDatasetSid.notSet()) {
+    condition = true;
+  }
+  sid = changedDatasetSid;
+  storeId = storeIdForChangedSet;
+  this->changedDatasetSid.raw = sid_t::INVALID_SID;
+  this->storeIdForChangedSet = storeId::INVALID_STORE_ADDRESS;
+  return condition;
+}
+
+void LocalPoolOwnerBase::handleChangedDataset(sid_t sid, store_address_t storeId,
+                                              bool *clearMessage) {
+  this->changedDatasetSid = sid;
+  this->storeIdForChangedSet = storeId;
+}
+
+bool LocalPoolOwnerBase::changedVariableCallbackWasCalled(gp_id_t &gpid, store_address_t &storeId) {
+  bool condition = false;
+  if (not this->changedPoolVariableGpid.notSet()) {
+    condition = true;
+  }
+  gpid = changedPoolVariableGpid;
+  storeId = storeIdForChangedVariable;
+  this->changedPoolVariableGpid.raw = gp_id_t::INVALID_GPID;
+  this->storeIdForChangedVariable = storeId::INVALID_STORE_ADDRESS;
+  return condition;
+}
+
+ReturnValue_t LocalPoolOwnerBase::initializeHkManagerAfterTaskCreation() {
+  if (not initializedAfterTaskCreation) {
+    initializedAfterTaskCreation = true;
+    return poolManager.initializeAfterTaskCreation();
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+void LocalPoolOwnerBase::handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId,
+                                                   bool *clearMessage) {
+  this->changedPoolVariableGpid = globPoolId;
+  this->storeIdForChangedVariable = storeId;
+}

unittests/datapoollocal/LocalPoolOwnerBase.h

@@ -0,0 +1,164 @@
+#ifndef FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_
+#define FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_
+
+#include <fsfw/datapool/PoolReadGuard.h>
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/datapoollocal/LocalDataSet.h>
+#include <fsfw/datapoollocal/LocalPoolVariable.h>
+#include <fsfw/datapoollocal/LocalPoolVector.h>
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/ipc/QueueFactory.h>
+#include <fsfw/objectmanager/SystemObject.h>
+
+#include "../mocks/MessageQueueMockBase.h"
+#include "tests/TestsConfig.h"
+
+namespace lpool {
+static constexpr lp_id_t uint8VarId = 0;
+static constexpr lp_id_t floatVarId = 1;
+static constexpr lp_id_t uint32VarId = 2;
+static constexpr lp_id_t uint16Vec3Id = 3;
+static constexpr lp_id_t int64Vec2Id = 4;
+
+static constexpr uint32_t testSetId = 0;
+static constexpr uint8_t dataSetMaxVariables = 10;
+
+static const sid_t testSid = sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE, testSetId);
+
+static const gp_id_t uint8VarGpid = gp_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, uint8VarId);
+static const gp_id_t floatVarGpid = gp_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, floatVarId);
+static const gp_id_t uint32Gpid = gp_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, uint32VarId);
+static const gp_id_t uint16Vec3Gpid = gp_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, uint16Vec3Id);
+static const gp_id_t uint64Vec2Id = gp_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, int64Vec2Id);
+}  // namespace lpool
+
+class LocalPoolStaticTestDataSet : public StaticLocalDataSet<3> {
+ public:
+  LocalPoolStaticTestDataSet() : StaticLocalDataSet(lpool::testSid) {}
+
+  LocalPoolStaticTestDataSet(HasLocalDataPoolIF* owner, uint32_t setId)
+      : StaticLocalDataSet(owner, setId) {}
+
+  lp_var_t<uint8_t> localPoolVarUint8 = lp_var_t<uint8_t>(lpool::uint8VarGpid, this);
+  lp_var_t<float> localPoolVarFloat = lp_var_t<float>(lpool::floatVarGpid, this);
+  lp_vec_t<uint16_t, 3> localPoolUint16Vec = lp_vec_t<uint16_t, 3>(lpool::uint16Vec3Gpid, this);
+
+ private:
+};
+
+class LocalPoolTestDataSet : public LocalDataSet {
+ public:
+  LocalPoolTestDataSet() : LocalDataSet(lpool::testSid, lpool::dataSetMaxVariables) {}
+
+  LocalPoolTestDataSet(HasLocalDataPoolIF* owner, uint32_t setId)
+      : LocalDataSet(owner, setId, lpool::dataSetMaxVariables) {}
+
+  lp_var_t<uint8_t> localPoolVarUint8 = lp_var_t<uint8_t>(lpool::uint8VarGpid, this);
+  lp_var_t<float> localPoolVarFloat = lp_var_t<float>(lpool::floatVarGpid, this);
+  lp_vec_t<uint16_t, 3> localPoolUint16Vec = lp_vec_t<uint16_t, 3>(lpool::uint16Vec3Gpid, this);
+
+  void setDiagnostic(bool isDiagnostic) { LocalPoolDataSetBase::setDiagnostic(isDiagnostic); }
+
+ private:
+};
+
+class LocalPoolOwnerBase : public SystemObject, public HasLocalDataPoolIF {
+ public:
+  LocalPoolOwnerBase(object_id_t objectId = objects::TEST_LOCAL_POOL_OWNER_BASE);
+
+  ~LocalPoolOwnerBase();
+
+  object_id_t getObjectId() const override { return SystemObject::getObjectId(); }
+
+  ReturnValue_t initializeHkManager();
+
+  ReturnValue_t initializeHkManagerAfterTaskCreation();
+
+  /** Command queue for housekeeping messages. */
+  MessageQueueId_t getCommandQueue() const override { return messageQueue->getId(); }
+
+  // This is called by initializeAfterTaskCreation of the HK manager.
+  virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                                LocalDataPoolManager& poolManager) override;
+
+  LocalDataPoolManager* getHkManagerHandle() override { return &poolManager; }
+
+  dur_millis_t getPeriodicOperationFrequency() const override { return 200; }
+
+  /**
+   * This function is used by the pool manager to get a valid dataset
+   * from a SID
+   * @param sid Corresponding structure ID
+   * @return
+   */
+  virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override { return &dataset; }
+
+  virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) override;
+
+  MessageQueueMockBase* getMockQueueHandle() const {
+    return dynamic_cast<MessageQueueMockBase*>(messageQueue);
+  }
+
+  ReturnValue_t subscribePeriodicHk(bool enableReporting) {
+    return poolManager.subscribeForPeriodicPacket(lpool::testSid, enableReporting, 0.2, false);
+  }
+
+  ReturnValue_t subscribeWrapperSetUpdate() {
+    return poolManager.subscribeForSetUpdateMessage(lpool::testSetId, objects::NO_OBJECT,
+                                                    objects::HK_RECEIVER_MOCK, false);
+  }
+
+  ReturnValue_t subscribeWrapperSetUpdateSnapshot() {
+    return poolManager.subscribeForSetUpdateMessage(lpool::testSetId, objects::NO_OBJECT,
+                                                    objects::HK_RECEIVER_MOCK, true);
+  }
+
+  ReturnValue_t subscribeWrapperSetUpdateHk(bool diagnostics = false) {
+    return poolManager.subscribeForUpdatePacket(lpool::testSid, diagnostics, false,
+                                                objects::HK_RECEIVER_MOCK);
+  }
+
+  ReturnValue_t subscribeWrapperVariableUpdate(lp_id_t localPoolId) {
+    return poolManager.subscribeForVariableUpdateMessage(localPoolId, MessageQueueIF::NO_QUEUE,
+                                                         objects::HK_RECEIVER_MOCK, false);
+  }
+
+  ReturnValue_t subscribeWrapperVariableSnapshot(lp_id_t localPoolId) {
+    return poolManager.subscribeForVariableUpdateMessage(localPoolId, MessageQueueIF::NO_QUEUE,
+                                                         objects::HK_RECEIVER_MOCK, true);
+  }
+
+  ReturnValue_t reset();
+
+  void resetSubscriptionList() { poolManager.clearReceiversList(); }
+
+  bool changedDataSetCallbackWasCalled(sid_t& sid, store_address_t& storeId);
+  bool changedVariableCallbackWasCalled(gp_id_t& gpid, store_address_t& storeId);
+
+  LocalDataPoolManager poolManager;
+  LocalPoolTestDataSet dataset;
+
+ private:
+  void handleChangedDataset(sid_t sid, store_address_t storeId, bool* clearMessage) override;
+  sid_t changedDatasetSid;
+  store_address_t storeIdForChangedSet;
+
+  void handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId,
+                                 bool* clearMessage) override;
+  gp_id_t changedPoolVariableGpid;
+  store_address_t storeIdForChangedVariable;
+
+  lp_var_t<uint8_t> testUint8 = lp_var_t<uint8_t>(this, lpool::uint8VarId);
+  lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId);
+  lp_var_t<uint32_t> testUint32 = lp_var_t<uint32_t>(this, lpool::uint32VarId);
+
+  lp_vec_t<uint16_t, 3> testUint16Vec = lp_vec_t<uint16_t, 3>(this, lpool::uint16Vec3Id);
+  lp_vec_t<int64_t, 2> testInt64Vec = lp_vec_t<int64_t, 2>(this, lpool::int64Vec2Id);
+
+  MessageQueueIF* messageQueue = nullptr;
+
+  bool initialized = false;
+  bool initializedAfterTaskCreation = false;
+};
+
+#endif /* FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_ */

unittests/datapoollocal/LocalPoolVariableTest.cpp

@@ -0,0 +1,111 @@
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/objectmanager/ObjectManager.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+#include "LocalPoolOwnerBase.h"
+#include "tests/TestsConfig.h"
+
+TEST_CASE("LocalPoolVariable", "[LocPoolVarTest]") {
+  auto* poolOwner =
+      ObjectManager::instance()->get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+  REQUIRE(poolOwner != nullptr);
+  REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+  REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation() == retval::CATCH_OK);
+
+  SECTION("Basic Tests") {
+    /* very basic test. */
+    lp_var_t<uint8_t> testVariable =
+        lp_var_t<uint8_t>(objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
+    REQUIRE(testVariable.read() == retval::CATCH_OK);
+    CHECK(testVariable.value == 0);
+    testVariable.value = 5;
+    REQUIRE(testVariable.commit() == retval::CATCH_OK);
+    REQUIRE(testVariable.read() == retval::CATCH_OK);
+    REQUIRE(testVariable.value == 5);
+    CHECK(not testVariable.isValid());
+    testVariable.setValid(true);
+    CHECK(testVariable.isValid());
+    CHECK(testVariable.commit(true) == retval::CATCH_OK);
+
+    testVariable.setReadWriteMode(pool_rwm_t::VAR_READ);
+    CHECK(testVariable.getReadWriteMode() == pool_rwm_t::VAR_READ);
+    testVariable.setReadWriteMode(pool_rwm_t::VAR_READ_WRITE);
+
+    testVariable.setDataPoolId(22);
+    CHECK(testVariable.getDataPoolId() == 22);
+    testVariable.setDataPoolId(lpool::uint8VarId);
+
+    testVariable.setChanged(true);
+    CHECK(testVariable.hasChanged());
+    testVariable.setChanged(false);
+
+    gp_id_t globPoolId(objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
+    lp_var_t<uint8_t> testVariable2 = lp_var_t<uint8_t>(globPoolId);
+    REQUIRE(testVariable2.read() == retval::CATCH_OK);
+    CHECK(testVariable2 == 5);
+    CHECK(testVariable == testVariable2);
+    testVariable = 10;
+    CHECK(testVariable != 5);
+    // CHECK(not testVariable != testVariable2);
+    uint8_t variableRaw = 0;
+    uint8_t* varPtr = &variableRaw;
+    size_t maxSize = testVariable.getSerializedSize();
+    CHECK(maxSize == 1);
+    size_t serSize = 0;
+    CHECK(testVariable.serialize(&varPtr, &serSize, maxSize, SerializeIF::Endianness::MACHINE) ==
+          retval::CATCH_OK);
+    CHECK(variableRaw == 10);
+    const uint8_t* varConstPtr = &variableRaw;
+    testVariable = 5;
+    CHECK(testVariable.deSerialize(&varConstPtr, &serSize, SerializeIF::Endianness::MACHINE) ==
+          retval::CATCH_OK);
+    CHECK(testVariable == 10);
+    CHECK(testVariable != testVariable2);
+    CHECK(testVariable2 < testVariable);
+    CHECK(testVariable2 < 10);
+    CHECK(testVariable > 5);
+    CHECK(testVariable > testVariable2);
+    variableRaw = static_cast<uint8_t>(testVariable2);
+    CHECK(variableRaw == 5);
+
+    CHECK(testVariable == 10);
+    testVariable = testVariable2;
+    CHECK(testVariable == 5);
+  }
+
+  SECTION("ErrorHandling") {
+    /* now try to use a local pool variable which does not exist */
+    lp_var_t<uint8_t> invalidVariable =
+        lp_var_t<uint8_t>(objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
+    REQUIRE(invalidVariable.read() == static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
+
+    REQUIRE(invalidVariable.commit() == static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
+    /* now try to access with wrong type */
+    lp_var_t<int8_t> invalidVariable2 =
+        lp_var_t<int8_t>(objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
+    REQUIRE(invalidVariable2.read() == static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
+
+    lp_var_t<uint8_t> readOnlyVar = lp_var_t<uint8_t>(
+        objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId, nullptr, pool_rwm_t::VAR_READ);
+    REQUIRE(readOnlyVar.commit() == static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
+    lp_var_t<uint8_t> writeOnlyVar = lp_var_t<uint8_t>(
+        objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId, nullptr, pool_rwm_t::VAR_WRITE);
+    REQUIRE(writeOnlyVar.read() == static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
+
+    lp_var_t<uint32_t> uint32tVar =
+        lp_var_t<uint32_t>(objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint32VarId);
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::info << "LocalPoolVariable printout: " << uint32tVar << std::endl;
+#endif
+
+    /* for code coverage. If program does not crash -> OK */
+    lp_var_t<uint8_t> invalidObjectVar = lp_var_t<uint8_t>(0xffffffff, lpool::uint8VarId);
+    gp_id_t globPoolId(0xffffffff, lpool::uint8VarId);
+    lp_var_t<uint8_t> invalidObjectVar2 = lp_var_t<uint8_t>(globPoolId);
+    lp_var_t<uint8_t> invalidObjectVar3 = lp_var_t<uint8_t>(nullptr, lpool::uint8VarId);
+  }
+
+  CHECK(poolOwner->reset() == retval::CATCH_OK);
+}

unittests/datapoollocal/LocalPoolVectorTest.cpp

@@ -0,0 +1,110 @@
+#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/objectmanager/ObjectManager.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+#include "LocalPoolOwnerBase.h"
+#include "tests/TestsConfig.h"
+
+TEST_CASE("LocalPoolVector", "[LocPoolVecTest]") {
+  LocalPoolOwnerBase* poolOwner =
+      ObjectManager::instance()->get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
+  REQUIRE(poolOwner != nullptr);
+  REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);
+  REQUIRE(poolOwner->initializeHkManagerAfterTaskCreation() == retval::CATCH_OK);
+
+  SECTION("BasicTest") {
+    // very basic test.
+    lp_vec_t<uint16_t, 3> testVector =
+        lp_vec_t<uint16_t, 3>(objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
+    REQUIRE(testVector.read() == retval::CATCH_OK);
+    testVector.value[0] = 5;
+    testVector.value[1] = 232;
+    testVector.value[2] = 32023;
+
+    REQUIRE(testVector.commit(true) == retval::CATCH_OK);
+    CHECK(testVector.isValid());
+
+    testVector.value[0] = 0;
+    testVector.value[1] = 0;
+    testVector.value[2] = 0;
+
+    CHECK(testVector.read() == retval::CATCH_OK);
+    CHECK(testVector.value[0] == 5);
+    CHECK(testVector.value[1] == 232);
+    CHECK(testVector.value[2] == 32023);
+
+    CHECK(testVector[0] == 5);
+
+    /* This is invalid access, so the last value will be set instead.
+    (we can't throw exceptions) */
+    testVector[4] = 12;
+    CHECK(testVector[2] == 12);
+    CHECK(testVector.commit() == retval::CATCH_OK);
+
+    /* Use read-only reference. */
+    const lp_vec_t<uint16_t, 3>& roTestVec = testVector;
+    uint16_t valueOne = roTestVec[0];
+    CHECK(valueOne == 5);
+
+    uint16_t lastVal = roTestVec[25];
+    CHECK(lastVal == 12);
+
+    size_t maxSize = testVector.getSerializedSize();
+    CHECK(maxSize == 6);
+
+    uint16_t serializedVector[3];
+    uint8_t* vecPtr = reinterpret_cast<uint8_t*>(serializedVector);
+    size_t serSize = 0;
+    REQUIRE(testVector.serialize(&vecPtr, &serSize, maxSize, SerializeIF::Endianness::MACHINE) ==
+            retval::CATCH_OK);
+
+    CHECK(serSize == 6);
+    CHECK(serializedVector[0] == 5);
+    CHECK(serializedVector[1] == 232);
+    CHECK(serializedVector[2] == 12);
+
+    maxSize = 1;
+    REQUIRE(testVector.serialize(&vecPtr, &serSize, maxSize, SerializeIF::Endianness::MACHINE) ==
+            static_cast<int>(SerializeIF::BUFFER_TOO_SHORT));
+
+    serializedVector[0] = 16;
+    serializedVector[1] = 7832;
+    serializedVector[2] = 39232;
+
+    const uint8_t* constVecPtr = reinterpret_cast<const uint8_t*>(serializedVector);
+    REQUIRE(testVector.deSerialize(&constVecPtr, &serSize, SerializeIF::Endianness::MACHINE) ==
+            retval::CATCH_OK);
+    CHECK(testVector[0] == 16);
+    CHECK(testVector[1] == 7832);
+    CHECK(testVector[2] == 39232);
+
+    serSize = 1;
+    REQUIRE(testVector.deSerialize(&constVecPtr, &serSize, SerializeIF::Endianness::MACHINE) ==
+            static_cast<int>(SerializeIF::STREAM_TOO_SHORT));
+  }
+
+  SECTION("ErrorHandling") {
+    /* Now try to use a local pool variable which does not exist */
+    lp_vec_t<uint16_t, 3> invalidVector =
+        lp_vec_t<uint16_t, 3>(objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
+    REQUIRE(invalidVector.read() == static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
+    REQUIRE(invalidVector.commit() == static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
+
+    /* Now try to access with wrong type */
+    lp_vec_t<uint32_t, 3> invalidVector2 =
+        lp_vec_t<uint32_t, 3>(objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
+    REQUIRE(invalidVector2.read() == static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
+    REQUIRE(invalidVector2.commit() == static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
+
+    lp_vec_t<uint16_t, 3> writeOnlyVec = lp_vec_t<uint16_t, 3>(
+        objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id, nullptr, pool_rwm_t::VAR_WRITE);
+    REQUIRE(writeOnlyVec.read() == static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
+
+    lp_vec_t<uint16_t, 3> readOnlyVec = lp_vec_t<uint16_t, 3>(
+        objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id, nullptr, pool_rwm_t::VAR_READ);
+    REQUIRE(readOnlyVec.commit() == static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
+  }
+  poolOwner->reset();
+}

unittests/devicehandler/CMakeLists.txt

@@ -0,0 +1,8 @@
+target_sources(${FSFW_TEST_TGT} PRIVATE
+	CookieIFMock.cpp
+	ComIFMock.cpp
+	DeviceHandlerCommander.cpp
+	DeviceHandlerMock.cpp
+	DeviceFdirMock.cpp
+	TestDeviceHandlerBase.cpp
+)

unittests/devicehandler/ComIFMock.cpp

@@ -0,0 +1,46 @@
+#include "ComIFMock.h"
+
+#include "DeviceHandlerMock.h"
+
+ComIFMock::ComIFMock(object_id_t objectId) : SystemObject(objectId) {}
+
+ComIFMock::~ComIFMock() {}
+
+ReturnValue_t ComIFMock::initializeInterface(CookieIF *cookie) { return RETURN_OK; }
+
+ReturnValue_t ComIFMock::sendMessage(CookieIF *cookie, const uint8_t *sendData, size_t sendLen) {
+  data = *sendData;
+  return RETURN_OK;
+}
+
+ReturnValue_t ComIFMock::getSendSuccess(CookieIF *cookie) { return RETURN_OK; }
+
+ReturnValue_t ComIFMock::requestReceiveMessage(CookieIF *cookie, size_t requestLen) {
+  return RETURN_OK;
+}
+
+ReturnValue_t ComIFMock::readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size) {
+  switch (testCase) {
+    case TestCase::MISSED_REPLY: {
+      *size = 0;
+      return RETURN_OK;
+    }
+    case TestCase::SIMPLE_COMMAND_NOMINAL: {
+      *size = 1;
+      data = DeviceHandlerMock::SIMPLE_COMMAND_DATA;
+      *buffer = &data;
+      break;
+    }
+    case TestCase::PERIODIC_REPLY_NOMINAL: {
+      *size = 1;
+      data = DeviceHandlerMock::PERIODIC_REPLY_DATA;
+      *buffer = &data;
+      break;
+    }
+    default:
+      break;
+  }
+  return RETURN_OK;
+}
+
+void ComIFMock::setTestCase(TestCase testCase_) { testCase = testCase_; }

unittests/devicehandler/ComIFMock.h

@@ -0,0 +1,37 @@
+#ifndef TESTS_SRC_FSFW_TESTS_UNIT_DEVICEHANDLER_COMIFMOCK_H_
+#define TESTS_SRC_FSFW_TESTS_UNIT_DEVICEHANDLER_COMIFMOCK_H_
+
+#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+
+/**
+ * @brief	The ComIFMock supports the simulation of various device communication error cases
+ * 			  like incomplete or wrong replies and can be used to test the
+ * DeviceHandlerBase.
+ */
+class ComIFMock : public DeviceCommunicationIF, public SystemObject {
+ public:
+  enum class TestCase { SIMPLE_COMMAND_NOMINAL, PERIODIC_REPLY_NOMINAL, MISSED_REPLY };
+
+  ComIFMock(object_id_t objectId);
+  virtual ~ComIFMock();
+
+  virtual ReturnValue_t initializeInterface(CookieIF *cookie) override;
+  virtual ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t *sendData,
+                                    size_t sendLen) override;
+  virtual ReturnValue_t getSendSuccess(CookieIF *cookie) override;
+  virtual ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) override;
+  virtual ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
+                                            size_t *size) override;
+  void setTestCase(TestCase testCase_);
+
+ private:
+  TestCase testCase = TestCase::SIMPLE_COMMAND_NOMINAL;
+
+  static const uint8_t SIMPLE_COMMAND_DATA = 1;
+  static const uint8_t PERIODIC_REPLY_DATA = 2;
+
+  uint8_t data = 0;
+};
+
+#endif /* TESTS_SRC_FSFW_TESTS_UNIT_DEVICEHANDLER_COMIFMOCK_H_ */

unittests/devicehandler/CookieIFMock.cpp

@@ -0,0 +1,5 @@
+#include "CookieIFMock.h"
+
+CookieIFMock::CookieIFMock() {}
+
+CookieIFMock::~CookieIFMock() {}

unittests/devicehandler/CookieIFMock.h

@@ -0,0 +1,12 @@
+#ifndef TESTS_SRC_FSFW_TESTS_UNIT_DEVICEHANDLER_COOKIEIFMOCK_H_
+#define TESTS_SRC_FSFW_TESTS_UNIT_DEVICEHANDLER_COOKIEIFMOCK_H_
+
+#include "fsfw/devicehandlers/CookieIF.h"
+
+class CookieIFMock : public CookieIF {
+ public:
+  CookieIFMock();
+  virtual ~CookieIFMock();
+};
+
+#endif /* TESTS_SRC_FSFW_TESTS_UNIT_DEVICEHANDLER_COOKIEIFMOCK_H_ */

unittests/devicehandler/DeviceFdirMock.cpp

@@ -0,0 +1,18 @@
+#include "DeviceFdirMock.h"
+
+#include "devicehandler/DeviceFdirMock.h"
+
+DeviceFdirMock::DeviceFdirMock(object_id_t owner, object_id_t parent)
+    : DeviceHandlerFailureIsolation(owner, parent) {}
+
+DeviceFdirMock::~DeviceFdirMock() {}
+
+uint32_t DeviceFdirMock::getMissedReplyCount() {
+  ParameterWrapper parameterWrapper;
+  this->getParameter(MISSED_REPLY_DOMAIN_ID,
+                     static_cast<uint8_t>(FaultCounter::ParameterIds::FAULT_COUNT),
+                     &parameterWrapper, nullptr, 0);
+  uint32_t missedReplyCount = 0;
+  parameterWrapper.getElement(&missedReplyCount);
+  return missedReplyCount;
+}

unittests/devicehandler/DeviceFdirMock.h

@@ -0,0 +1,18 @@
+#ifndef TESTS_SRC_FSFW_TESTS_UNIT_DEVICEHANDLER_DEVICEFDIRMOCK_H_
+#define TESTS_SRC_FSFW_TESTS_UNIT_DEVICEHANDLER_DEVICEFDIRMOCK_H_
+
+#include "fsfw/devicehandlers/DeviceHandlerFailureIsolation.h"
+
+class DeviceFdirMock : public DeviceHandlerFailureIsolation {
+ public:
+  DeviceFdirMock(object_id_t owner, object_id_t parent);
+  virtual ~DeviceFdirMock();
+
+  uint32_t getMissedReplyCount();
+
+ private:
+  static const uint8_t STRANGE_REPLY_DOMAIN_ID = 0xF0;
+  static const uint8_t MISSED_REPLY_DOMAIN_ID = 0xF1;
+};
+
+#endif /* TESTS_SRC_FSFW_TESTS_UNIT_DEVICEHANDLER_DEVICEFDIRMOCK_H_ */

unittests/devicehandler/DeviceHandlerCommander.cpp

@@ -0,0 +1,64 @@
+#include "DeviceHandlerCommander.h"
+
+#include <fsfw/ipc/QueueFactory.h>
+
+DeviceHandlerCommander::DeviceHandlerCommander(object_id_t objectId)
+    : SystemObject(objectId), commandActionHelper(this) {
+  auto mqArgs = MqArgs(this->getObjectId());
+  commandQueue = QueueFactory::instance()->createMessageQueue(
+      QUEUE_SIZE, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+}
+
+DeviceHandlerCommander::~DeviceHandlerCommander() {}
+
+ReturnValue_t DeviceHandlerCommander::performOperation(uint8_t operationCode) {
+  readCommandQueue();
+  return RETURN_OK;
+}
+
+ReturnValue_t DeviceHandlerCommander::initialize() {
+  ReturnValue_t result = commandActionHelper.initialize();
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueIF* DeviceHandlerCommander::getCommandQueuePtr() { return commandQueue; }
+
+void DeviceHandlerCommander::stepSuccessfulReceived(ActionId_t actionId, uint8_t step) {}
+
+void DeviceHandlerCommander::stepFailedReceived(ActionId_t actionId, uint8_t step,
+                                                ReturnValue_t returnCode) {}
+
+void DeviceHandlerCommander::dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) {
+}
+
+void DeviceHandlerCommander::completionSuccessfulReceived(ActionId_t actionId) {
+  lastReplyReturnCode = RETURN_OK;
+}
+
+void DeviceHandlerCommander::completionFailedReceived(ActionId_t actionId,
+                                                      ReturnValue_t returnCode) {
+  lastReplyReturnCode = returnCode;
+}
+
+void DeviceHandlerCommander::readCommandQueue() {
+  CommandMessage message;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  for (result = commandQueue->receiveMessage(&message); result == HasReturnvaluesIF::RETURN_OK;
+       result = commandQueue->receiveMessage(&message)) {
+    result = commandActionHelper.handleReply(&message);
+    if (result == HasReturnvaluesIF::RETURN_OK) {
+      continue;
+    }
+  }
+}
+
+ReturnValue_t DeviceHandlerCommander::sendCommand(object_id_t target, ActionId_t actionId) {
+  return commandActionHelper.commandAction(target, actionId, nullptr, 0);
+}
+
+ReturnValue_t DeviceHandlerCommander::getReplyReturnCode() { return lastReplyReturnCode; }
+
+void DeviceHandlerCommander::resetReplyReturnCode() { lastReplyReturnCode = RETURN_FAILED; }

unittests/devicehandler/DeviceHandlerCommander.h

@@ -0,0 +1,50 @@
+#ifndef TESTS_SRC_FSFW_TESTS_UNIT_DEVICEHANDLER_DEVICEHANDLERCOMMANDER_H_
+#define TESTS_SRC_FSFW_TESTS_UNIT_DEVICEHANDLER_DEVICEHANDLERCOMMANDER_H_
+
+#include "fsfw/action/CommandActionHelper.h"
+#include "fsfw/action/CommandsActionsIF.h"
+#include "fsfw/objectmanager/SystemObject.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/tasks/ExecutableObjectIF.h"
+
+class DeviceHandlerCommander : public ExecutableObjectIF,
+                               public SystemObject,
+                               public CommandsActionsIF,
+                               public HasReturnvaluesIF {
+ public:
+  DeviceHandlerCommander(object_id_t objectId);
+  virtual ~DeviceHandlerCommander();
+
+  ReturnValue_t performOperation(uint8_t operationCode = 0);
+  ReturnValue_t initialize() override;
+  MessageQueueIF* getCommandQueuePtr() override;
+  void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) override;
+  void stepFailedReceived(ActionId_t actionId, uint8_t step, ReturnValue_t returnCode) override;
+  void dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) override;
+  void completionSuccessfulReceived(ActionId_t actionId) override;
+  void completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) override;
+
+  /**
+   * @brief	Calling this function will send the command to the device handler object.
+   *
+   * @param target	Object ID of the device handler
+   * @param actionId	Action ID of the command to send
+   */
+  ReturnValue_t sendCommand(object_id_t target, ActionId_t actionId);
+
+  ReturnValue_t getReplyReturnCode();
+  void resetReplyReturnCode();
+
+ private:
+  static const uint32_t QUEUE_SIZE = 20;
+
+  MessageQueueIF* commandQueue = nullptr;
+
+  CommandActionHelper commandActionHelper;
+
+  ReturnValue_t lastReplyReturnCode = RETURN_FAILED;
+
+  void readCommandQueue();
+};
+
+#endif /* TESTS_SRC_FSFW_TESTS_UNIT_DEVICEHANDLER_DEVICEHANDLERCOMMANDER_H_ */

unittests/devicehandler/DeviceHandlerMock.cpp

@@ -0,0 +1,103 @@
+#include "DeviceHandlerMock.h"
+
+#include <catch2/catch_test_macros.hpp>
+
+DeviceHandlerMock::DeviceHandlerMock(object_id_t objectId, object_id_t deviceCommunication,
+                                     CookieIF *comCookie, FailureIsolationBase *fdirInstance)
+    : DeviceHandlerBase(objectId, deviceCommunication, comCookie, fdirInstance) {
+  mode = MODE_ON;
+}
+
+DeviceHandlerMock::~DeviceHandlerMock() {}
+
+void DeviceHandlerMock::doStartUp() { setMode(_MODE_TO_ON); }
+
+void DeviceHandlerMock::doShutDown() { setMode(_MODE_POWER_DOWN); }
+
+ReturnValue_t DeviceHandlerMock::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t DeviceHandlerMock::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t DeviceHandlerMock::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                         const uint8_t *commandData,
+                                                         size_t commandDataLen) {
+  switch (deviceCommand) {
+    case SIMPLE_COMMAND: {
+      commandBuffer[0] = SIMPLE_COMMAND_DATA;
+      rawPacket = commandBuffer;
+      rawPacketLen = sizeof(SIMPLE_COMMAND_DATA);
+      break;
+    }
+    default:
+      WARN("DeviceHandlerMock::buildCommandFromCommand: Invalid device command");
+      break;
+  }
+  return RETURN_OK;
+}
+
+ReturnValue_t DeviceHandlerMock::scanForReply(const uint8_t *start, size_t len,
+                                              DeviceCommandId_t *foundId, size_t *foundLen) {
+  switch (*start) {
+    case SIMPLE_COMMAND_DATA: {
+      *foundId = SIMPLE_COMMAND;
+      *foundLen = sizeof(SIMPLE_COMMAND_DATA);
+      return RETURN_OK;
+      break;
+    }
+    case PERIODIC_REPLY_DATA: {
+      *foundId = PERIODIC_REPLY;
+      *foundLen = sizeof(PERIODIC_REPLY_DATA);
+      return RETURN_OK;
+      break;
+    }
+    default:
+      break;
+  }
+  return RETURN_FAILED;
+}
+
+ReturnValue_t DeviceHandlerMock::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+  switch (id) {
+    case SIMPLE_COMMAND:
+    case PERIODIC_REPLY: {
+      periodicReplyReceived = true;
+      break;
+    }
+    default:
+      break;
+  }
+  return RETURN_OK;
+}
+
+void DeviceHandlerMock::fillCommandAndReplyMap() {
+  insertInCommandAndReplyMap(SIMPLE_COMMAND, 0, nullptr, 0, false, false, 0,
+                             &simpleCommandReplyTimeout);
+  insertInCommandAndReplyMap(PERIODIC_REPLY, 0, nullptr, 0, true, false, 0,
+                             &periodicReplyCountdown);
+}
+
+uint32_t DeviceHandlerMock::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+void DeviceHandlerMock::changePeriodicReplyCountdown(uint32_t timeout) {
+  periodicReplyCountdown.setTimeout(timeout);
+}
+
+void DeviceHandlerMock::changeSimpleCommandReplyCountdown(uint32_t timeout) {
+  simpleCommandReplyTimeout.setTimeout(timeout);
+}
+
+void DeviceHandlerMock::resetPeriodicReplyState() { periodicReplyReceived = false; }
+
+bool DeviceHandlerMock::getPeriodicReplyReceived() { return periodicReplyReceived; }
+
+ReturnValue_t DeviceHandlerMock::enablePeriodicReply(DeviceCommandId_t replyId) {
+  return updatePeriodicReply(true, replyId);
+}
+
+ReturnValue_t DeviceHandlerMock::disablePeriodicReply(DeviceCommandId_t replyId) {
+  return updatePeriodicReply(false, replyId);
+}

unittests/devicehandler/DeviceHandlerMock.h

@@ -0,0 +1,46 @@
+#ifndef TESTS_SRC_FSFW_TESTS_UNIT_DEVICEHANDLER_DEVICEHANDLERMOCK_H_
+#define TESTS_SRC_FSFW_TESTS_UNIT_DEVICEHANDLER_DEVICEHANDLERMOCK_H_
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+class DeviceHandlerMock : public DeviceHandlerBase {
+ public:
+  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
+  static const DeviceCommandId_t PERIODIC_REPLY = 2;
+
+  static const uint8_t SIMPLE_COMMAND_DATA = 1;
+  static const uint8_t PERIODIC_REPLY_DATA = 2;
+
+  DeviceHandlerMock(object_id_t objectId, object_id_t deviceCommunication, CookieIF *comCookie,
+                    FailureIsolationBase *fdirInstance);
+  virtual ~DeviceHandlerMock();
+  void changePeriodicReplyCountdown(uint32_t timeout);
+  void changeSimpleCommandReplyCountdown(uint32_t timeout);
+  void resetPeriodicReplyState();
+  bool getPeriodicReplyReceived();
+  ReturnValue_t enablePeriodicReply(DeviceCommandId_t replyId);
+  ReturnValue_t disablePeriodicReply(DeviceCommandId_t replyId);
+
+ protected:
+  void doStartUp() override;
+  void doShutDown() override;
+  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
+                                        size_t commandDataLen) override;
+  ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                             size_t *foundLen) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
+  void fillCommandAndReplyMap() override;
+  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+
+ private:
+  Countdown simpleCommandReplyTimeout = Countdown(1000);
+  Countdown periodicReplyCountdown = Countdown(1000);
+
+  uint8_t commandBuffer[1];
+
+  bool periodicReplyReceived = false;
+};
+
+#endif /* TESTS_SRC_FSFW_TESTS_UNIT_DEVICEHANDLER_DEVICEHANDLERMOCK_H_ */

unittests/devicehandler/TestDeviceHandlerBase.cpp

@@ -0,0 +1,95 @@
+#include <catch2/catch_test_macros.hpp>
+
+#include "ComIFMock.h"
+#include "DeviceFdirMock.h"
+#include "DeviceHandlerCommander.h"
+#include "DeviceHandlerMock.h"
+#include "devicehandler/CookieIFMock.h"
+#include "objects/systemObjectList.h"
+
+TEST_CASE("Device Handler Base", "[DeviceHandlerBase]") {
+  // Will be deleted with DHB destructor
+  auto* cookieIFMock = new CookieIFMock;
+  ComIFMock comIF(objects::COM_IF_MOCK);
+  DeviceFdirMock deviceFdirMock(objects::DEVICE_HANDLER_MOCK, objects::NO_OBJECT);
+  DeviceHandlerMock deviceHandlerMock(objects::DEVICE_HANDLER_MOCK, objects::COM_IF_MOCK,
+                                      cookieIFMock, &deviceFdirMock);
+  ReturnValue_t result = deviceHandlerMock.initialize();
+  REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+  DeviceHandlerCommander deviceHandlerCommander(objects::DEVICE_HANDLER_COMMANDER);
+  result = deviceHandlerCommander.initialize();
+  REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+
+  SECTION("Commanding nominal") {
+    comIF.setTestCase(ComIFMock::TestCase::SIMPLE_COMMAND_NOMINAL);
+    result = deviceHandlerCommander.sendCommand(objects::DEVICE_HANDLER_MOCK,
+                                                DeviceHandlerMock::SIMPLE_COMMAND);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::PERFORM_OPERATION);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::SEND_WRITE);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::GET_WRITE);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::SEND_READ);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::GET_READ);
+    deviceHandlerCommander.performOperation();
+    result = deviceHandlerCommander.getReplyReturnCode();
+    uint32_t missedReplies = deviceFdirMock.getMissedReplyCount();
+    REQUIRE(missedReplies == 0);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+  }
+
+  SECTION("Commanding missed reply") {
+    comIF.setTestCase(ComIFMock::TestCase::MISSED_REPLY);
+    deviceHandlerCommander.resetReplyReturnCode();
+    // Set the timeout to 0 to immediately timeout the reply
+    deviceHandlerMock.changeSimpleCommandReplyCountdown(0);
+    result = deviceHandlerCommander.sendCommand(objects::DEVICE_HANDLER_MOCK,
+                                                DeviceHandlerMock::SIMPLE_COMMAND);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::PERFORM_OPERATION);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::SEND_WRITE);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::GET_WRITE);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::SEND_READ);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::GET_READ);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::PERFORM_OPERATION);
+    deviceHandlerCommander.performOperation();
+    result = deviceHandlerCommander.getReplyReturnCode();
+    REQUIRE(result == DeviceHandlerIF::TIMEOUT);
+    uint32_t missedReplies = deviceFdirMock.getMissedReplyCount();
+    REQUIRE(missedReplies == 1);
+  }
+
+  SECTION("Periodic reply nominal") {
+    comIF.setTestCase(ComIFMock::TestCase::PERIODIC_REPLY_NOMINAL);
+    deviceHandlerMock.enablePeriodicReply(DeviceHandlerMock::PERIODIC_REPLY);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::PERFORM_OPERATION);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::SEND_WRITE);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::GET_WRITE);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::SEND_READ);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::GET_READ);
+    REQUIRE(deviceHandlerMock.getPeriodicReplyReceived() == true);
+  }
+
+  SECTION("Missed periodic reply") {
+    comIF.setTestCase(ComIFMock::TestCase::MISSED_REPLY);
+    // Set the timeout to 0 to immediately timeout the reply
+    deviceHandlerMock.changePeriodicReplyCountdown(0);
+    deviceHandlerMock.enablePeriodicReply(DeviceHandlerMock::PERIODIC_REPLY);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::PERFORM_OPERATION);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::SEND_WRITE);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::GET_WRITE);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::SEND_READ);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::GET_READ);
+    uint32_t missedReplies = deviceFdirMock.getMissedReplyCount();
+    REQUIRE(missedReplies == 1);
+    // Test if disabling of periodic reply
+    deviceHandlerMock.disablePeriodicReply(DeviceHandlerMock::PERIODIC_REPLY);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::PERFORM_OPERATION);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::SEND_WRITE);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::GET_WRITE);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::SEND_READ);
+    deviceHandlerMock.performOperation(DeviceHandlerIF::GET_READ);
+    missedReplies = deviceFdirMock.getMissedReplyCount();
+    // Should still be 1 because periodic reply is now disabled
+    REQUIRE(missedReplies == 1);
+  }
+}

unittests/globalfunctions/CMakeLists.txt

@@ -0,0 +1,7 @@
+target_sources(${FSFW_TEST_TGT} PRIVATE
+    testDleEncoder.cpp
+    testOpDivider.cpp
+    testBitutil.cpp
+    testCRC.cpp
+    testTimevalOperations.cpp
+)

unittests/globalfunctions/testBitutil.cpp

@@ -0,0 +1,61 @@
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/globalfunctions/bitutility.h"
+
+TEST_CASE("Bitutility", "[Bitutility]") {
+  uint8_t dummyByte = 0;
+  bool bitSet = false;
+  for (uint8_t pos = 0; pos < 8; pos++) {
+    bitutil::set(&dummyByte, pos);
+    REQUIRE(dummyByte == (1 << (7 - pos)));
+    bitutil::get(&dummyByte, pos, bitSet);
+    REQUIRE(bitSet == 1);
+    dummyByte = 0;
+  }
+
+  dummyByte = 0xff;
+  for (uint8_t pos = 0; pos < 8; pos++) {
+    bitutil::get(&dummyByte, pos, bitSet);
+    REQUIRE(bitSet == 1);
+    bitutil::clear(&dummyByte, pos);
+    bitutil::get(&dummyByte, pos, bitSet);
+    REQUIRE(bitSet == 0);
+    dummyByte = 0xff;
+  }
+
+  dummyByte = 0xf0;
+  for (uint8_t pos = 0; pos < 8; pos++) {
+    if (pos < 4) {
+      bitutil::get(&dummyByte, pos, bitSet);
+      REQUIRE(bitSet == 1);
+      bitutil::toggle(&dummyByte, pos);
+      bitutil::get(&dummyByte, pos, bitSet);
+      REQUIRE(bitSet == 0);
+    } else {
+      bitutil::get(&dummyByte, pos, bitSet);
+      REQUIRE(bitSet == false);
+      bitutil::toggle(&dummyByte, pos);
+      bitutil::get(&dummyByte, pos, bitSet);
+      REQUIRE(bitSet == true);
+    }
+  }
+  REQUIRE(dummyByte == 0x0f);
+
+  dummyByte = 0;
+  bitutil::set(&dummyByte, 8);
+  REQUIRE(dummyByte == 0);
+  bitutil::set(&dummyByte, -1);
+  REQUIRE(dummyByte == 0);
+  dummyByte = 0xff;
+  bitutil::clear(&dummyByte, 8);
+  REQUIRE(dummyByte == 0xff);
+  bitutil::clear(&dummyByte, -1);
+  REQUIRE(dummyByte == 0xff);
+  dummyByte = 0x00;
+  bitutil::toggle(&dummyByte, 8);
+  REQUIRE(dummyByte == 0x00);
+  bitutil::toggle(&dummyByte, -1);
+  REQUIRE(dummyByte == 0x00);
+
+  REQUIRE(bitutil::get(&dummyByte, 8, bitSet) == false);
+}

unittests/globalfunctions/testCRC.cpp

@@ -0,0 +1,14 @@
+#include <array>
+
+#include "CatchDefinitions.h"
+#include "catch2/catch_test_macros.hpp"
+#include "fsfw/globalfunctions/CRC.h"
+
+TEST_CASE("CRC", "[CRC]") {
+  std::array<uint8_t, 10> testData = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+  uint16_t crc = CRC::crc16ccitt(testData.data(), 10);
+  REQUIRE(crc == 49729);
+  for (uint8_t index = 0; index < testData.size(); index++) {
+    REQUIRE(testData[index] == index);
+  }
+}

unittests/globalfunctions/testDleEncoder.cpp

@@ -0,0 +1,212 @@
+#include <array>
+
+#include "CatchDefinitions.h"
+#include "catch2/catch_test_macros.hpp"
+#include "fsfw/globalfunctions/DleEncoder.h"
+
+const std::vector<uint8_t> TEST_ARRAY_0 = {0, 0, 0, 0, 0};
+const std::vector<uint8_t> TEST_ARRAY_1 = {0, DleEncoder::DLE_CHAR, 5};
+const std::vector<uint8_t> TEST_ARRAY_2 = {0, DleEncoder::STX_CHAR, 5};
+const std::vector<uint8_t> TEST_ARRAY_3 = {0, DleEncoder::CARRIAGE_RETURN, DleEncoder::ETX_CHAR};
+const std::vector<uint8_t> TEST_ARRAY_4 = {DleEncoder::DLE_CHAR, DleEncoder::ETX_CHAR,
+                                           DleEncoder::STX_CHAR};
+
+const std::vector<uint8_t> TEST_ARRAY_0_ENCODED_ESCAPED = {DleEncoder::STX_CHAR, 0, 0, 0, 0, 0,
+                                                           DleEncoder::ETX_CHAR};
+const std::vector<uint8_t> TEST_ARRAY_0_ENCODED_NON_ESCAPED = {
+    DleEncoder::DLE_CHAR, DleEncoder::STX_CHAR, 0, 0, 0, 0, 0,
+    DleEncoder::DLE_CHAR, DleEncoder::ETX_CHAR};
+
+const std::vector<uint8_t> TEST_ARRAY_1_ENCODED_ESCAPED = {
+    DleEncoder::STX_CHAR, 0, DleEncoder::DLE_CHAR, DleEncoder::DLE_CHAR, 5, DleEncoder::ETX_CHAR};
+const std::vector<uint8_t> TEST_ARRAY_1_ENCODED_NON_ESCAPED = {
+    DleEncoder::DLE_CHAR, DleEncoder::STX_CHAR, 0, DleEncoder::DLE_CHAR, DleEncoder::DLE_CHAR, 5,
+    DleEncoder::DLE_CHAR, DleEncoder::ETX_CHAR};
+
+const std::vector<uint8_t> TEST_ARRAY_2_ENCODED_ESCAPED = {
+    DleEncoder::STX_CHAR,        0, DleEncoder::DLE_CHAR,
+    DleEncoder::STX_CHAR + 0x40, 5, DleEncoder::ETX_CHAR};
+const std::vector<uint8_t> TEST_ARRAY_2_ENCODED_NON_ESCAPED = {
+    DleEncoder::DLE_CHAR, DleEncoder::STX_CHAR, 0, DleEncoder::STX_CHAR, 5,
+    DleEncoder::DLE_CHAR, DleEncoder::ETX_CHAR};
+
+const std::vector<uint8_t> TEST_ARRAY_3_ENCODED_ESCAPED = {
+    DleEncoder::STX_CHAR,        0,
+    DleEncoder::CARRIAGE_RETURN, DleEncoder::DLE_CHAR,
+    DleEncoder::ETX_CHAR + 0x40, DleEncoder::ETX_CHAR};
+const std::vector<uint8_t> TEST_ARRAY_3_ENCODED_NON_ESCAPED = {
+    DleEncoder::DLE_CHAR,        DleEncoder::STX_CHAR, 0,
+    DleEncoder::CARRIAGE_RETURN, DleEncoder::ETX_CHAR, DleEncoder::DLE_CHAR,
+    DleEncoder::ETX_CHAR};
+
+const std::vector<uint8_t> TEST_ARRAY_4_ENCODED_ESCAPED = {
+    DleEncoder::STX_CHAR,        DleEncoder::DLE_CHAR,        DleEncoder::DLE_CHAR,
+    DleEncoder::DLE_CHAR,        DleEncoder::ETX_CHAR + 0x40, DleEncoder::DLE_CHAR,
+    DleEncoder::STX_CHAR + 0x40, DleEncoder::ETX_CHAR};
+const std::vector<uint8_t> TEST_ARRAY_4_ENCODED_NON_ESCAPED = {
+    DleEncoder::DLE_CHAR, DleEncoder::STX_CHAR, DleEncoder::DLE_CHAR, DleEncoder::DLE_CHAR,
+    DleEncoder::ETX_CHAR, DleEncoder::STX_CHAR, DleEncoder::DLE_CHAR, DleEncoder::ETX_CHAR};
+
+TEST_CASE("DleEncoder", "[DleEncoder]") {
+  DleEncoder dleEncoder;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  std::array<uint8_t, 32> buffer;
+
+  size_t encodedLen = 0;
+  size_t readLen = 0;
+  size_t decodedLen = 0;
+
+  auto testLambdaEncode = [&](DleEncoder& encoder, const std::vector<uint8_t>& vecToEncode,
+                              const std::vector<uint8_t>& expectedVec) {
+    result = encoder.encode(vecToEncode.data(), vecToEncode.size(), buffer.data(), buffer.size(),
+                            &encodedLen);
+    REQUIRE(result == retval::CATCH_OK);
+    for (size_t idx = 0; idx < expectedVec.size(); idx++) {
+      REQUIRE(buffer[idx] == expectedVec[idx]);
+    }
+    REQUIRE(encodedLen == expectedVec.size());
+  };
+
+  auto testLambdaDecode = [&](DleEncoder& encoder, const std::vector<uint8_t>& testVecEncoded,
+                              const std::vector<uint8_t>& expectedVec) {
+    result = encoder.decode(testVecEncoded.data(), testVecEncoded.size(), &readLen, buffer.data(),
+                            buffer.size(), &decodedLen);
+    REQUIRE(result == retval::CATCH_OK);
+    REQUIRE(readLen == testVecEncoded.size());
+    REQUIRE(decodedLen == expectedVec.size());
+    for (size_t idx = 0; idx < decodedLen; idx++) {
+      REQUIRE(buffer[idx] == expectedVec[idx]);
+    }
+  };
+
+  SECTION("Encoding") {
+    testLambdaEncode(dleEncoder, TEST_ARRAY_0, TEST_ARRAY_0_ENCODED_ESCAPED);
+    testLambdaEncode(dleEncoder, TEST_ARRAY_1, TEST_ARRAY_1_ENCODED_ESCAPED);
+    testLambdaEncode(dleEncoder, TEST_ARRAY_2, TEST_ARRAY_2_ENCODED_ESCAPED);
+    testLambdaEncode(dleEncoder, TEST_ARRAY_3, TEST_ARRAY_3_ENCODED_ESCAPED);
+    testLambdaEncode(dleEncoder, TEST_ARRAY_4, TEST_ARRAY_4_ENCODED_ESCAPED);
+
+    auto testFaultyEncoding = [&](const std::vector<uint8_t>& vecToEncode,
+                                  const std::vector<uint8_t>& expectedVec) {
+      for (size_t faultyDestSize = 0; faultyDestSize < expectedVec.size(); faultyDestSize++) {
+        result = dleEncoder.encode(vecToEncode.data(), vecToEncode.size(), buffer.data(),
+                                   faultyDestSize, &encodedLen);
+        REQUIRE(result == static_cast<int>(DleEncoder::STREAM_TOO_SHORT));
+      }
+    };
+
+    testFaultyEncoding(TEST_ARRAY_0, TEST_ARRAY_0_ENCODED_ESCAPED);
+    testFaultyEncoding(TEST_ARRAY_1, TEST_ARRAY_1_ENCODED_ESCAPED);
+    testFaultyEncoding(TEST_ARRAY_2, TEST_ARRAY_2_ENCODED_ESCAPED);
+    testFaultyEncoding(TEST_ARRAY_3, TEST_ARRAY_3_ENCODED_ESCAPED);
+    testFaultyEncoding(TEST_ARRAY_4, TEST_ARRAY_4_ENCODED_ESCAPED);
+
+    dleEncoder.setEscapeMode(false);
+    testLambdaEncode(dleEncoder, TEST_ARRAY_0, TEST_ARRAY_0_ENCODED_NON_ESCAPED);
+    testLambdaEncode(dleEncoder, TEST_ARRAY_1, TEST_ARRAY_1_ENCODED_NON_ESCAPED);
+    testLambdaEncode(dleEncoder, TEST_ARRAY_2, TEST_ARRAY_2_ENCODED_NON_ESCAPED);
+    testLambdaEncode(dleEncoder, TEST_ARRAY_3, TEST_ARRAY_3_ENCODED_NON_ESCAPED);
+    testLambdaEncode(dleEncoder, TEST_ARRAY_4, TEST_ARRAY_4_ENCODED_NON_ESCAPED);
+
+    testFaultyEncoding(TEST_ARRAY_0, TEST_ARRAY_0_ENCODED_NON_ESCAPED);
+    testFaultyEncoding(TEST_ARRAY_1, TEST_ARRAY_1_ENCODED_NON_ESCAPED);
+    testFaultyEncoding(TEST_ARRAY_2, TEST_ARRAY_2_ENCODED_NON_ESCAPED);
+    testFaultyEncoding(TEST_ARRAY_3, TEST_ARRAY_3_ENCODED_NON_ESCAPED);
+    testFaultyEncoding(TEST_ARRAY_4, TEST_ARRAY_4_ENCODED_NON_ESCAPED);
+    dleEncoder.setEscapeMode(true);
+  }
+
+  SECTION("Decoding") {
+    testLambdaDecode(dleEncoder, TEST_ARRAY_0_ENCODED_ESCAPED, TEST_ARRAY_0);
+    testLambdaDecode(dleEncoder, TEST_ARRAY_1_ENCODED_ESCAPED, TEST_ARRAY_1);
+    testLambdaDecode(dleEncoder, TEST_ARRAY_2_ENCODED_ESCAPED, TEST_ARRAY_2);
+    testLambdaDecode(dleEncoder, TEST_ARRAY_3_ENCODED_ESCAPED, TEST_ARRAY_3);
+    testLambdaDecode(dleEncoder, TEST_ARRAY_4_ENCODED_ESCAPED, TEST_ARRAY_4);
+
+    // Faulty source data
+    auto testArray1EncodedFaulty = TEST_ARRAY_1_ENCODED_ESCAPED;
+    testArray1EncodedFaulty[3] = 0;
+    result = dleEncoder.decode(testArray1EncodedFaulty.data(), testArray1EncodedFaulty.size(),
+                               &readLen, buffer.data(), buffer.size(), &encodedLen);
+    REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
+    auto testArray2EncodedFaulty = TEST_ARRAY_2_ENCODED_ESCAPED;
+    testArray2EncodedFaulty[5] = 0;
+    result = dleEncoder.decode(testArray2EncodedFaulty.data(), testArray2EncodedFaulty.size(),
+                               &readLen, buffer.data(), buffer.size(), &encodedLen);
+    REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
+    auto testArray4EncodedFaulty = TEST_ARRAY_4_ENCODED_ESCAPED;
+    testArray4EncodedFaulty[2] = 0;
+    result = dleEncoder.decode(testArray4EncodedFaulty.data(), testArray4EncodedFaulty.size(),
+                               &readLen, buffer.data(), buffer.size(), &encodedLen);
+    REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
+    auto testArray4EncodedFaulty2 = TEST_ARRAY_4_ENCODED_ESCAPED;
+    testArray4EncodedFaulty2[4] = 0;
+    result = dleEncoder.decode(testArray4EncodedFaulty2.data(), testArray4EncodedFaulty2.size(),
+                               &readLen, buffer.data(), buffer.size(), &encodedLen);
+    REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
+
+    auto testFaultyDecoding = [&](const std::vector<uint8_t>& vecToDecode,
+                                  const std::vector<uint8_t>& expectedVec) {
+      for (size_t faultyDestSizes = 0; faultyDestSizes < expectedVec.size(); faultyDestSizes++) {
+        result = dleEncoder.decode(vecToDecode.data(), vecToDecode.size(), &readLen, buffer.data(),
+                                   faultyDestSizes, &decodedLen);
+        REQUIRE(result == static_cast<int>(DleEncoder::STREAM_TOO_SHORT));
+      }
+    };
+
+    testFaultyDecoding(TEST_ARRAY_0_ENCODED_ESCAPED, TEST_ARRAY_0);
+    testFaultyDecoding(TEST_ARRAY_1_ENCODED_ESCAPED, TEST_ARRAY_1);
+    testFaultyDecoding(TEST_ARRAY_2_ENCODED_ESCAPED, TEST_ARRAY_2);
+    testFaultyDecoding(TEST_ARRAY_3_ENCODED_ESCAPED, TEST_ARRAY_3);
+    testFaultyDecoding(TEST_ARRAY_4_ENCODED_ESCAPED, TEST_ARRAY_4);
+
+    dleEncoder.setEscapeMode(false);
+    testLambdaDecode(dleEncoder, TEST_ARRAY_0_ENCODED_NON_ESCAPED, TEST_ARRAY_0);
+    testLambdaDecode(dleEncoder, TEST_ARRAY_1_ENCODED_NON_ESCAPED, TEST_ARRAY_1);
+    testLambdaDecode(dleEncoder, TEST_ARRAY_2_ENCODED_NON_ESCAPED, TEST_ARRAY_2);
+    testLambdaDecode(dleEncoder, TEST_ARRAY_3_ENCODED_NON_ESCAPED, TEST_ARRAY_3);
+    testLambdaDecode(dleEncoder, TEST_ARRAY_4_ENCODED_NON_ESCAPED, TEST_ARRAY_4);
+
+    testFaultyDecoding(TEST_ARRAY_0_ENCODED_NON_ESCAPED, TEST_ARRAY_0);
+    testFaultyDecoding(TEST_ARRAY_1_ENCODED_NON_ESCAPED, TEST_ARRAY_1);
+    testFaultyDecoding(TEST_ARRAY_2_ENCODED_NON_ESCAPED, TEST_ARRAY_2);
+    testFaultyDecoding(TEST_ARRAY_3_ENCODED_NON_ESCAPED, TEST_ARRAY_3);
+    testFaultyDecoding(TEST_ARRAY_4_ENCODED_NON_ESCAPED, TEST_ARRAY_4);
+
+    // Faulty source data
+    testArray1EncodedFaulty = TEST_ARRAY_1_ENCODED_NON_ESCAPED;
+    auto prevVal = testArray1EncodedFaulty[0];
+    testArray1EncodedFaulty[0] = 0;
+    result = dleEncoder.decode(testArray1EncodedFaulty.data(), testArray1EncodedFaulty.size(),
+                               &readLen, buffer.data(), buffer.size(), &encodedLen);
+    REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
+    testArray1EncodedFaulty[0] = prevVal;
+    testArray1EncodedFaulty[1] = 0;
+    result = dleEncoder.decode(testArray1EncodedFaulty.data(), testArray1EncodedFaulty.size(),
+                               &readLen, buffer.data(), buffer.size(), &encodedLen);
+    REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
+
+    testArray1EncodedFaulty = TEST_ARRAY_1_ENCODED_NON_ESCAPED;
+    testArray1EncodedFaulty[6] = 0;
+    result = dleEncoder.decode(testArray1EncodedFaulty.data(), testArray1EncodedFaulty.size(),
+                               &readLen, buffer.data(), buffer.size(), &encodedLen);
+    REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
+    testArray1EncodedFaulty = TEST_ARRAY_1_ENCODED_NON_ESCAPED;
+    testArray1EncodedFaulty[7] = 0;
+    result = dleEncoder.decode(testArray1EncodedFaulty.data(), testArray1EncodedFaulty.size(),
+                               &readLen, buffer.data(), buffer.size(), &encodedLen);
+    REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
+    testArray4EncodedFaulty = TEST_ARRAY_4_ENCODED_NON_ESCAPED;
+    testArray4EncodedFaulty[3] = 0;
+    result = dleEncoder.decode(testArray4EncodedFaulty.data(), testArray4EncodedFaulty.size(),
+                               &readLen, buffer.data(), buffer.size(), &encodedLen);
+    REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
+
+    dleEncoder.setEscapeMode(true);
+    testArray1EncodedFaulty = TEST_ARRAY_1_ENCODED_ESCAPED;
+    testArray1EncodedFaulty[5] = 0;
+    result = dleEncoder.decode(testArray1EncodedFaulty.data(), testArray1EncodedFaulty.size(),
+                               &readLen, buffer.data(), buffer.size(), &encodedLen);
+    REQUIRE(result == static_cast<int>(DleEncoder::DECODING_ERROR));
+  }
+}

unittests/globalfunctions/testOpDivider.cpp

@@ -0,0 +1,65 @@
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/globalfunctions/PeriodicOperationDivider.h"
+
+TEST_CASE("OpDivider", "[OpDivider]") {
+  auto opDivider = PeriodicOperationDivider(1);
+  REQUIRE(opDivider.getDivider() == 1);
+  REQUIRE(opDivider.getCounter() == 1);
+  REQUIRE(opDivider.check() == true);
+  REQUIRE(opDivider.checkAndIncrement() == true);
+  REQUIRE(opDivider.getCounter() == 1);
+  REQUIRE(opDivider.check() == true);
+  REQUIRE(opDivider.checkAndIncrement() == true);
+  REQUIRE(opDivider.checkAndIncrement() == true);
+
+  opDivider.setDivider(0);
+  REQUIRE(opDivider.getCounter() == 1);
+  REQUIRE(opDivider.checkAndIncrement() == true);
+  REQUIRE(opDivider.getCounter() == 1);
+  REQUIRE(opDivider.checkAndIncrement() == true);
+  REQUIRE(opDivider.checkAndIncrement() == true);
+
+  opDivider.setDivider(2);
+  opDivider.resetCounter();
+  REQUIRE(opDivider.getDivider() == 2);
+  REQUIRE(opDivider.getCounter() == 1);
+  REQUIRE(opDivider.check() == false);
+  REQUIRE(opDivider.checkAndIncrement() == false);
+  REQUIRE(opDivider.getCounter() == 2);
+  REQUIRE(opDivider.check() == true);
+  REQUIRE(opDivider.checkAndIncrement() == true);
+  REQUIRE(opDivider.getCounter() == 1);
+  REQUIRE(opDivider.check() == false);
+  REQUIRE(opDivider.checkAndIncrement() == false);
+  REQUIRE(opDivider.getCounter() == 2);
+  REQUIRE(opDivider.checkAndIncrement() == true);
+  REQUIRE(opDivider.checkAndIncrement() == false);
+  REQUIRE(opDivider.checkAndIncrement() == true);
+  REQUIRE(opDivider.checkAndIncrement() == false);
+
+  opDivider.setDivider(3);
+  opDivider.resetCounter();
+  REQUIRE(opDivider.checkAndIncrement() == false);
+  REQUIRE(opDivider.checkAndIncrement() == false);
+  REQUIRE(opDivider.getCounter() == 3);
+  REQUIRE(opDivider.checkAndIncrement() == true);
+  REQUIRE(opDivider.getCounter() == 1);
+  REQUIRE(opDivider.checkAndIncrement() == false);
+
+  auto opDividerNonResetting = PeriodicOperationDivider(2, false);
+  REQUIRE(opDividerNonResetting.getCounter() == 1);
+  REQUIRE(opDividerNonResetting.check() == false);
+  REQUIRE(opDividerNonResetting.checkAndIncrement() == false);
+  REQUIRE(opDividerNonResetting.getCounter() == 2);
+  REQUIRE(opDividerNonResetting.check() == true);
+  REQUIRE(opDividerNonResetting.checkAndIncrement() == true);
+  REQUIRE(opDividerNonResetting.getCounter() == 3);
+  REQUIRE(opDividerNonResetting.checkAndIncrement() == true);
+  REQUIRE(opDividerNonResetting.getCounter() == 4);
+  opDividerNonResetting.resetCounter();
+  REQUIRE(opDividerNonResetting.getCounter() == 1);
+  REQUIRE(opDividerNonResetting.check() == false);
+  REQUIRE(opDividerNonResetting.checkAndIncrement() == false);
+  REQUIRE(opDividerNonResetting.getCounter() == 2);
+}

unittests/globalfunctions/testTimevalOperations.cpp

@@ -0,0 +1,124 @@
+#include <fsfw/globalfunctions/timevalOperations.h>
+
+#include <catch2/catch_approx.hpp>
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+
+TEST_CASE("TimevalTest", "[timevalOperations]") {
+  SECTION("Comparison") {
+    timeval t1;
+    t1.tv_sec = 1648227422;
+    t1.tv_usec = 123456;
+    timeval t2;
+    t2.tv_sec = 1648227422;
+    t2.tv_usec = 123456;
+    REQUIRE(t1 == t2);
+    REQUIRE(t2 == t1);
+    REQUIRE_FALSE(t1 != t2);
+    REQUIRE_FALSE(t2 != t1);
+    REQUIRE(t1 <= t2);
+    REQUIRE(t2 <= t1);
+    REQUIRE(t1 >= t2);
+    REQUIRE(t2 >= t1);
+    REQUIRE_FALSE(t1 < t2);
+    REQUIRE_FALSE(t2 < t1);
+    REQUIRE_FALSE(t1 > t2);
+    REQUIRE_FALSE(t2 > t1);
+
+    timeval t3;
+    t3.tv_sec = 1648227422;
+    t3.tv_usec = 123457;
+    REQUIRE_FALSE(t1 == t3);
+    REQUIRE(t1 != t3);
+    REQUIRE(t1 <= t3);
+    REQUIRE_FALSE(t3 <= t1);
+    REQUIRE_FALSE(t1 >= t3);
+    REQUIRE(t3 >= t1);
+    REQUIRE(t1 < t3);
+    REQUIRE_FALSE(t3 < t1);
+    REQUIRE_FALSE(t1 > t3);
+    REQUIRE(t3 > t1);
+
+    timeval t4;
+    t4.tv_sec = 1648227423;
+    t4.tv_usec = 123456;
+    REQUIRE_FALSE(t1 == t4);
+    REQUIRE(t1 != t4);
+    REQUIRE(t1 <= t4);
+    REQUIRE_FALSE(t4 <= t1);
+    REQUIRE_FALSE(t1 >= t4);
+    REQUIRE(t4 >= t1);
+    REQUIRE(t1 < t4);
+    REQUIRE_FALSE(t4 < t1);
+    REQUIRE_FALSE(t1 > t4);
+    REQUIRE(t4 > t1);
+  }
+  SECTION("Operators") {
+    timeval t1;
+    t1.tv_sec = 1648227422;
+    t1.tv_usec = 123456;
+    timeval t2;
+    t2.tv_sec = 1648227422;
+    t2.tv_usec = 123456;
+    timeval t3 = t1 - t2;
+    REQUIRE(t3.tv_sec == 0);
+    REQUIRE(t3.tv_usec == 0);
+    timeval t4 = t1 - t3;
+    REQUIRE(t4.tv_sec == 1648227422);
+    REQUIRE(t4.tv_usec == 123456);
+    timeval t5 = t3 - t1;
+    REQUIRE(t5.tv_sec == -1648227422);
+    REQUIRE(t5.tv_usec == -123456);
+
+    timeval t6;
+    t6.tv_sec = 1648227400;
+    t6.tv_usec = 999999;
+
+    timeval t7 = t6 + t1;
+    REQUIRE(t7.tv_sec == (1648227422ull + 1648227400ull + 1ull));
+    REQUIRE(t7.tv_usec == 123455);
+
+    timeval t8 = t1 - t6;
+    REQUIRE(t8.tv_sec == 1648227422 - 1648227400 - 1);
+    REQUIRE(t8.tv_usec == 123457);
+
+    double scalar = 2;
+    timeval t9 = t1 * scalar;
+    REQUIRE(t9.tv_sec == 3296454844);
+    REQUIRE(t9.tv_usec == 246912);
+    timeval t10 = scalar * t1;
+    REQUIRE(t10.tv_sec == 3296454844);
+    REQUIRE(t10.tv_usec == 246912);
+    timeval t11 = t6 * scalar;
+    REQUIRE(t11.tv_sec == (3296454800 + 1));
+    REQUIRE(t11.tv_usec == 999998);
+
+    timeval t12 = t1 / scalar;
+    REQUIRE(t12.tv_sec == 824113711);
+    REQUIRE(t12.tv_usec == 61728);
+
+    timeval t13 = t6 / scalar;
+    REQUIRE(t13.tv_sec == 824113700);
+    // Rounding issue
+    REQUIRE(t13.tv_usec == 499999);
+
+    double scalar2 = t9 / t1;
+    REQUIRE(scalar2 == Catch::Approx(2.0));
+    double scalar3 = t1 / t6;
+    REQUIRE(scalar3 == Catch::Approx(1.000000013));
+    double scalar4 = t3 / t1;
+    REQUIRE(scalar4 == Catch::Approx(0));
+    double scalar5 = t12 / t1;
+    REQUIRE(scalar5 == Catch::Approx(0.5));
+  }
+
+  SECTION("timevalOperations::toTimeval") {
+    double seconds = 1648227422.123456;
+    timeval t1 = timevalOperations::toTimeval(seconds);
+    REQUIRE(t1.tv_sec == 1648227422);
+    // Allow 1 usec rounding tolerance
+    REQUIRE(t1.tv_usec >= 123455);
+    REQUIRE(t1.tv_usec <= 123457);
+  }
+}

unittests/hal/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(${FSFW_TEST_TGT} PRIVATE
+	testCommandExecutor.cpp
+)

unittests/hal/testCommandExecutor.cpp

@@ -0,0 +1,129 @@
+#include <unistd.h>
+
+#include <catch2/catch_test_macros.hpp>
+#include <fstream>
+#include <iostream>
+
+#include "fsfw/container/DynamicFIFO.h"
+#include "fsfw/container/SimpleRingBuffer.h"
+#include "fsfw/platform.h"
+#include "fsfw/serviceinterface.h"
+#include "fsfw_hal/linux/CommandExecutor.h"
+#include "tests/TestsConfig.h"
+
+#ifdef PLATFORM_UNIX
+
+static const char TEST_FILE_NAME[] = "/tmp/fsfw-unittest-test.txt";
+
+TEST_CASE("Command Executor", "[cmd-exec]") {
+  // Check blocking mode first
+  CommandExecutor cmdExecutor(1024);
+  std::string cmd = "echo \"test\" >> " + std::string(TEST_FILE_NAME);
+  REQUIRE(cmdExecutor.getCurrentState() == CommandExecutor::States::IDLE);
+  ReturnValue_t result = cmdExecutor.load(cmd, true, true);
+  REQUIRE(cmdExecutor.getCurrentState() == CommandExecutor::States::COMMAND_LOADED);
+  REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+  REQUIRE(cmdExecutor.execute() == HasReturnvaluesIF::RETURN_OK);
+  // Check that file exists with contents
+  std::ifstream file(TEST_FILE_NAME);
+  std::string line;
+  std::getline(file, line);
+  CHECK(line == "test");
+  std::remove(TEST_FILE_NAME);
+  REQUIRE(cmdExecutor.getCurrentState() == CommandExecutor::States::IDLE);
+
+  // Now check non-blocking mode
+  SimpleRingBuffer outputBuffer(524, true);
+  DynamicFIFO<uint16_t> sizesFifo(12);
+  cmdExecutor.setRingBuffer(&outputBuffer, &sizesFifo);
+
+  result = cmdExecutor.load("echo \"Hello World\"", false, false);
+  REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+  cmdExecutor.execute();
+  bool bytesHaveBeenRead = false;
+  size_t limitIdx = 0;
+  while (result != CommandExecutor::EXECUTION_FINISHED) {
+    limitIdx++;
+    result = cmdExecutor.check(bytesHaveBeenRead);
+    REQUIRE(result != CommandExecutor::COMMAND_ERROR);
+    usleep(500);
+    REQUIRE(limitIdx < 500);
+  }
+
+  limitIdx = 0;
+  CHECK(bytesHaveBeenRead == true);
+  CHECK(result == CommandExecutor::EXECUTION_FINISHED);
+  uint16_t readBytes = 0;
+  sizesFifo.retrieve(&readBytes);
+  REQUIRE(readBytes == 12);
+  REQUIRE(outputBuffer.getAvailableReadData() == 12);
+  uint8_t readBuffer[32] = {};
+  REQUIRE(outputBuffer.readData(readBuffer, 12) == HasReturnvaluesIF::RETURN_OK);
+  std::string readString(reinterpret_cast<char*>(readBuffer));
+  std::string cmpString = "Hello World\n";
+  CHECK(readString == cmpString);
+  outputBuffer.deleteData(12, true);
+
+  // Issues with CI/CD
+#if FSFW_CICD_BUILD == 0
+  // Test more complex command
+  result = cmdExecutor.load("ping -c 1 localhost", false, false);
+  REQUIRE(cmdExecutor.getCurrentState() == CommandExecutor::States::COMMAND_LOADED);
+  REQUIRE(cmdExecutor.execute() == HasReturnvaluesIF::RETURN_OK);
+  REQUIRE(cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING);
+  limitIdx = 0;
+  while (result != CommandExecutor::EXECUTION_FINISHED) {
+    limitIdx++;
+    result = cmdExecutor.check(bytesHaveBeenRead);
+    REQUIRE(result != CommandExecutor::COMMAND_ERROR);
+    // This ensures that the tests do not block indefinitely
+    usleep(500);
+    REQUIRE(limitIdx < 50000);
+  }
+  limitIdx = 0;
+  CHECK(bytesHaveBeenRead == true);
+  CHECK(result == CommandExecutor::EXECUTION_FINISHED);
+  REQUIRE(cmdExecutor.getCurrentState() == CommandExecutor::States::IDLE);
+  readBytes = 0;
+  sizesFifo.retrieve(&readBytes);
+  uint8_t largerReadBuffer[1024] = {};
+  // That's about the size of the reply
+  bool beTrue = (readBytes > 100) and (readBytes < 400);
+  if (not beTrue) {
+    size_t readLen = outputBuffer.getAvailableReadData();
+    if (readLen > sizeof(largerReadBuffer) - 1) {
+      readLen = sizeof(largerReadBuffer) - 1;
+    }
+    outputBuffer.readData(largerReadBuffer, readLen);
+    std::string readString(reinterpret_cast<char*>(largerReadBuffer));
+    std::cerr << "Catch2 tag cmd-exec: Read " << readBytes << ": " << std::endl;
+    std::cerr << readString << std::endl;
+  }
+  REQUIRE(beTrue);
+  outputBuffer.readData(largerReadBuffer, readBytes);
+  // You can also check this output in the debugger
+  std::string allTheReply(reinterpret_cast<char*>(largerReadBuffer));
+  // I am just going to assume that this string is the same across ping implementations
+  // of different Linux systems
+  REQUIRE(allTheReply.find("PING localhost") != std::string::npos);
+#endif
+
+  // Now check failing command
+  result = cmdExecutor.load("false", false, false);
+  REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+  result = cmdExecutor.execute();
+  REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+  while (result != CommandExecutor::EXECUTION_FINISHED and
+         result != HasReturnvaluesIF::RETURN_FAILED) {
+    limitIdx++;
+    result = cmdExecutor.check(bytesHaveBeenRead);
+    REQUIRE(result != CommandExecutor::COMMAND_ERROR);
+    // This ensures that the tests do not block indefinitely
+    usleep(500);
+    REQUIRE(limitIdx < 500);
+  }
+  REQUIRE(result == HasReturnvaluesIF::RETURN_FAILED);
+  REQUIRE(cmdExecutor.getLastError() == 1);
+}
+
+#endif

unittests/internalerror/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(${FSFW_TEST_TGT} PRIVATE
+	TestInternalErrorReporter.cpp
+)

unittests/internalerror/TestInternalErrorReporter.cpp

@@ -0,0 +1,120 @@
+#include <fsfw/housekeeping/HousekeepingSnapshot.h>
+#include <fsfw/internalerror/InternalErrorReporter.h>
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/ipc/QueueFactory.h>
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/timemanager/CCSDSTime.h>
+
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+#include "fsfw/action/ActionMessage.h"
+#include "fsfw/ipc/CommandMessage.h"
+#include "fsfw/ipc/MessageQueueMessage.h"
+#include "fsfw/objectmanager/frameworkObjects.h"
+#include "mocks/PeriodicTaskIFMock.h"
+
+TEST_CASE("Internal Error Reporter", "[TestInternalError]") {
+  PeriodicTaskMock task(10, nullptr);
+  ObjectManagerIF* manager = ObjectManager::instance();
+  if (manager == nullptr) {
+    FAIL();
+  }
+  auto* internalErrorReporter = dynamic_cast<InternalErrorReporter*>(
+      ObjectManager::instance()->get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER));
+  if (internalErrorReporter == nullptr) {
+    FAIL();
+  }
+  task.addComponent(objects::INTERNAL_ERROR_REPORTER);
+  // This calls the initializeAfterTaskCreation function
+  task.startTask();
+  MessageQueueIF* testQueue = QueueFactory::instance()->createMessageQueue(1);
+  MessageQueueIF* hkQueue = QueueFactory::instance()->createMessageQueue(1);
+  internalErrorReporter->getSubscriptionInterface()->subscribeForSetUpdateMessage(
+      InternalErrorDataset::ERROR_SET_ID, objects::NO_OBJECT, hkQueue->getId(), true);
+  StorageManagerIF* ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
+  SECTION("MessageQueueFull") {
+    CommandMessage message;
+    ActionMessage::setCompletionReply(&message, 10, true);
+    auto result = hkQueue->sendMessage(testQueue->getId(), &message);
+    REQUIRE(result == retval::CATCH_OK);
+    uint32_t queueHits = 0;
+    uint32_t lostTm = 0;
+    uint32_t storeHits = 0;
+    /* We don't know if another test caused a queue Hit so we will enforce one,
+     then remeber the queueHit count and force another hit */
+    internalErrorReporter->queueMessageNotSent();
+    internalErrorReporter->performOperation(0);
+    {
+      CommandMessage hkMessage;
+      result = hkQueue->receiveMessage(&hkMessage);
+      REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+      REQUIRE(hkMessage.getCommand() == HousekeepingMessage::UPDATE_SNAPSHOT_SET);
+      store_address_t storeAddress;
+      gp_id_t gpid =
+          HousekeepingMessage::getUpdateSnapshotVariableCommand(&hkMessage, &storeAddress);
+      REQUIRE(gpid.objectId == objects::INTERNAL_ERROR_REPORTER);
+      // We need the object ID of the reporter here (NO_OBJECT)
+      InternalErrorDataset dataset(objects::INTERNAL_ERROR_REPORTER);
+      CCSDSTime::CDS_short time;
+      ConstAccessorPair data = ipcStore->getData(storeAddress);
+      REQUIRE(data.first == HasReturnvaluesIF::RETURN_OK);
+      HousekeepingSnapshot hkSnapshot(&time, &dataset);
+      const uint8_t* buffer = data.second.data();
+      size_t size = data.second.size();
+      result = hkSnapshot.deSerialize(&buffer, &size, SerializeIF::Endianness::MACHINE);
+      REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+      // Remember the amount of queueHits before to see the increase
+      queueHits = dataset.queueHits.value;
+      lostTm = dataset.tmHits.value;
+      storeHits = dataset.storeHits.value;
+    }
+    result = hkQueue->sendMessage(testQueue->getId(), &message);
+    REQUIRE(result == MessageQueueIF::FULL);
+    internalErrorReporter->lostTm();
+    internalErrorReporter->storeFull();
+    {
+      internalErrorReporter->performOperation(0);
+      CommandMessage hkMessage;
+      result = hkQueue->receiveMessage(&hkMessage);
+      REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+      REQUIRE(hkMessage.getCommand() == HousekeepingMessage::UPDATE_SNAPSHOT_SET);
+      store_address_t storeAddress;
+      gp_id_t gpid =
+          HousekeepingMessage::getUpdateSnapshotVariableCommand(&hkMessage, &storeAddress);
+      REQUIRE(gpid.objectId == objects::INTERNAL_ERROR_REPORTER);
+
+      ConstAccessorPair data = ipcStore->getData(storeAddress);
+      REQUIRE(data.first == HasReturnvaluesIF::RETURN_OK);
+      CCSDSTime::CDS_short time;
+      // We need the object ID of the reporter here (NO_OBJECT)
+      InternalErrorDataset dataset(objects::INTERNAL_ERROR_REPORTER);
+      HousekeepingSnapshot hkSnapshot(&time, &dataset);
+      const uint8_t* buffer = data.second.data();
+      size_t size = data.second.size();
+      result = hkSnapshot.deSerialize(&buffer, &size, SerializeIF::Endianness::MACHINE);
+      REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+      // Test that we had one more queueHit
+      REQUIRE(dataset.queueHits.value == (queueHits + 1));
+      REQUIRE(dataset.tmHits.value == (lostTm + 1));
+      REQUIRE(dataset.storeHits.value == (storeHits + 1));
+    }
+    // Complete Coverage
+    internalErrorReporter->setDiagnosticPrintout(true);
+    internalErrorReporter->setMutexTimeout(MutexIF::TimeoutType::BLOCKING, 0);
+    {
+      // Message Queue Id
+      MessageQueueId_t id = internalErrorReporter->getCommandQueue();
+      REQUIRE(id != MessageQueueIF::NO_QUEUE);
+      CommandMessage message;
+      sid_t sid(objects::INTERNAL_ERROR_REPORTER, InternalErrorDataset::ERROR_SET_ID);
+      HousekeepingMessage::setToggleReportingCommand(&message, sid, true, false);
+      result = hkQueue->sendMessage(id, &message);
+      REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+      internalErrorReporter->performOperation(0);
+    }
+  }
+  QueueFactory::instance()->deleteMessageQueue(testQueue);
+  QueueFactory::instance()->deleteMessageQueue(hkQueue);
+}

unittests/mocks/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(${FSFW_TEST_TGT} PRIVATE
+	PowerSwitcherMock.cpp
+)

unittests/mocks/HkReceiverMock.h

@@ -0,0 +1,14 @@
+#ifndef FSFW_UNITTEST_TESTS_MOCKS_HKRECEIVERMOCK_H_
+#define FSFW_UNITTEST_TESTS_MOCKS_HKRECEIVERMOCK_H_
+
+#include <fsfw/housekeeping/AcceptsHkPacketsIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+
+class HkReceiverMock : public SystemObject, public AcceptsHkPacketsIF {
+ public:
+  HkReceiverMock(object_id_t objectId) : SystemObject(objectId) {}
+
+  MessageQueueId_t getHkQueue() const { return MessageQueueIF::NO_QUEUE; }
+};
+
+#endif /* FSFW_UNITTEST_TESTS_MOCKS_HKRECEIVERMOCK_H_ */

unittests/mocks/MessageQueueMockBase.h

@@ -0,0 +1,84 @@
+#ifndef FSFW_UNITTEST_TESTS_MOCKS_MESSAGEQUEUEMOCKBASE_H_
+#define FSFW_UNITTEST_TESTS_MOCKS_MESSAGEQUEUEMOCKBASE_H_
+
+#include <cstring>
+#include <queue>
+
+#include "CatchDefinitions.h"
+#include "fsfw/ipc/CommandMessage.h"
+#include "fsfw/ipc/MessageQueueBase.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+#include "fsfw/ipc/MessageQueueMessage.h"
+
+class MessageQueueMockBase : public MessageQueueBase {
+ public:
+  MessageQueueMockBase()
+      : MessageQueueBase(MessageQueueIF::NO_QUEUE, MessageQueueIF::NO_QUEUE, nullptr) {}
+
+  uint8_t messageSentCounter = 0;
+  bool messageSent = false;
+
+  bool wasMessageSent(uint8_t* messageSentCounter = nullptr, bool resetCounter = true) {
+    bool tempMessageSent = messageSent;
+    messageSent = false;
+    if (messageSentCounter != nullptr) {
+      *messageSentCounter = this->messageSentCounter;
+    }
+    if (resetCounter) {
+      this->messageSentCounter = 0;
+    }
+    return tempMessageSent;
+  }
+
+  /**
+   * Pop a message, clearing it in the process.
+   * @return
+   */
+  ReturnValue_t popMessage() {
+    CommandMessage message;
+    message.clear();
+    return receiveMessage(&message);
+  }
+
+  virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override {
+    if (messagesSentQueue.empty()) {
+      return MessageQueueIF::EMPTY;
+    }
+    this->last = message->getSender();
+    std::memcpy(message->getBuffer(), messagesSentQueue.front().getBuffer(),
+                message->getMessageSize());
+    messagesSentQueue.pop();
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+  virtual ReturnValue_t flush(uint32_t* count) { return HasReturnvaluesIF::RETURN_OK; }
+  virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                                        MessageQueueId_t sentFrom,
+                                        bool ignoreFault = false) override {
+    messageSent = true;
+    messageSentCounter++;
+    MessageQueueMessage& messageRef = *(dynamic_cast<MessageQueueMessage*>(message));
+    messagesSentQueue.push(messageRef);
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+
+  virtual ReturnValue_t reply(MessageQueueMessageIF* message) override {
+    return sendMessageFrom(MessageQueueIF::NO_QUEUE, message, this->getId(), false);
+  }
+
+  void clearMessages(bool clearCommandMessages = true) {
+    while (not messagesSentQueue.empty()) {
+      if (clearCommandMessages) {
+        CommandMessage message;
+        std::memcpy(message.getBuffer(), messagesSentQueue.front().getBuffer(),
+                    message.getMessageSize());
+        message.clear();
+      }
+      messagesSentQueue.pop();
+    }
+  }
+
+ private:
+  std::queue<MessageQueueMessage> messagesSentQueue;
+};
+
+#endif /* FSFW_UNITTEST_TESTS_MOCKS_MESSAGEQUEUEMOCKBASE_H_ */

unittests/mocks/PeriodicTaskIFMock.h

@@ -0,0 +1,25 @@
+#ifndef FSFW_UNITTEST_TESTS_MOCKS_PERIODICTASKMOCK_H_
+#define FSFW_UNITTEST_TESTS_MOCKS_PERIODICTASKMOCK_H_
+
+#include <fsfw/tasks/ExecutableObjectIF.h>
+#include <fsfw/tasks/PeriodicTaskBase.h>
+
+class PeriodicTaskMock : public PeriodicTaskBase {
+ public:
+  PeriodicTaskMock(TaskPeriod period, TaskDeadlineMissedFunction dlmFunc)
+      : PeriodicTaskBase(period, dlmFunc) {}
+
+  virtual ~PeriodicTaskMock() {}
+  /**
+   * @brief	With the startTask method, a created task can be started
+   *          for the first time.
+   */
+  virtual ReturnValue_t startTask() override {
+    initObjsAfterTaskCreation();
+    return HasReturnvaluesIF::RETURN_OK;
+  };
+
+  virtual ReturnValue_t sleepFor(uint32_t ms) override { return HasReturnvaluesIF::RETURN_OK; };
+};
+
+#endif  // FSFW_UNITTEST_TESTS_MOCKS_PERIODICTASKMOCK_H_

unittests/mocks/PowerSwitcherMock.cpp

@@ -0,0 +1,77 @@
+#include "PowerSwitcherMock.h"
+
+static uint32_t SWITCH_REQUEST_UPDATE_VALUE = 0;
+
+PowerSwitcherMock::PowerSwitcherMock() {}
+
+ReturnValue_t PowerSwitcherMock::sendSwitchCommand(power::Switch_t switchNr, ReturnValue_t onOff) {
+  if (switchMap.count(switchNr) == 0) {
+    switchMap.emplace(switchNr, SwitchInfo(switchNr, onOff));
+  } else {
+    SwitchInfo& info = switchMap.at(switchNr);
+    info.currentState = onOff;
+    if (onOff == PowerSwitchIF::SWITCH_ON) {
+      info.timesCalledOn++;
+    } else {
+      info.timesCalledOff++;
+    }
+  }
+  return RETURN_OK;
+}
+
+ReturnValue_t PowerSwitcherMock::sendFuseOnCommand(uint8_t fuseNr) {
+  if (fuseMap.count(fuseNr) == 0) {
+    fuseMap.emplace(fuseNr, FuseInfo(fuseNr));
+  } else {
+    FuseInfo& info = fuseMap.at(fuseNr);
+    info.timesCalled++;
+  }
+  return RETURN_OK;
+}
+
+ReturnValue_t PowerSwitcherMock::getSwitchState(power::Switch_t switchNr) const {
+  if (switchMap.count(switchNr) == 1) {
+    auto& info = switchMap.at(switchNr);
+    SWITCH_REQUEST_UPDATE_VALUE++;
+    return info.currentState;
+  }
+  return RETURN_FAILED;
+}
+
+ReturnValue_t PowerSwitcherMock::getFuseState(uint8_t fuseNr) const {
+  if (fuseMap.count(fuseNr) == 1) {
+    return FUSE_ON;
+  } else {
+    return FUSE_OFF;
+  }
+  return RETURN_FAILED;
+}
+
+uint32_t PowerSwitcherMock::getSwitchDelayMs(void) const { return 5000; }
+
+SwitchInfo::SwitchInfo() : switcher(0) {}
+
+SwitchInfo::SwitchInfo(power::Switch_t switcher, ReturnValue_t initState)
+    : switcher(switcher), currentState(initState) {}
+
+FuseInfo::FuseInfo(uint8_t fuse) : fuse(fuse) {}
+
+void PowerSwitcherMock::getSwitchInfo(power::Switch_t switcher, SwitchInfo& info) {
+  if (switchMap.count(switcher) == 1) {
+    info = switchMap.at(switcher);
+  }
+}
+
+void PowerSwitcherMock::getFuseInfo(uint8_t fuse, FuseInfo& info) {
+  if (fuseMap.count(fuse) == 1) {
+    info = fuseMap.at(fuse);
+  }
+}
+
+uint32_t PowerSwitcherMock::getAmountSwitchStatWasRequested() {
+  return SWITCH_REQUEST_UPDATE_VALUE;
+}
+
+void PowerSwitcherMock::initSwitch(power::Switch_t switchNr) {
+  switchMap.emplace(switchNr, SwitchInfo(switchNr, PowerSwitchIF::SWITCH_OFF));
+}

unittests/mocks/PowerSwitcherMock.h

@@ -0,0 +1,52 @@
+#ifndef FSFW_TESTS_SRC_FSFW_TESTS_UNIT_MOCKS_POWERSWITCHERMOCK_H_
+#define FSFW_TESTS_SRC_FSFW_TESTS_UNIT_MOCKS_POWERSWITCHERMOCK_H_
+
+#include <fsfw/power/PowerSwitchIF.h>
+
+#include <map>
+#include <utility>
+
+struct SwitchInfo {
+ public:
+  SwitchInfo();
+  SwitchInfo(power::Switch_t switcher, ReturnValue_t initState);
+
+  power::Switch_t switcher;
+  ReturnValue_t currentState = PowerSwitchIF::SWITCH_OFF;
+  uint32_t timesCalledOn = 0;
+  uint32_t timesCalledOff = 0;
+  uint32_t timesStatusRequested = 0;
+};
+
+struct FuseInfo {
+ public:
+  FuseInfo(uint8_t fuse);
+  uint8_t fuse;
+  uint32_t timesCalled = 0;
+};
+
+class PowerSwitcherMock : public PowerSwitchIF {
+ public:
+  PowerSwitcherMock();
+
+  ReturnValue_t sendSwitchCommand(power::Switch_t switchNr, ReturnValue_t onOff) override;
+  ReturnValue_t sendFuseOnCommand(uint8_t fuseNr) override;
+  ReturnValue_t getSwitchState(power::Switch_t switchNr) const override;
+  ReturnValue_t getFuseState(uint8_t fuseNr) const override;
+  uint32_t getSwitchDelayMs(void) const override;
+
+  void getSwitchInfo(power::Switch_t switcher, SwitchInfo& info);
+  void getFuseInfo(uint8_t fuse, FuseInfo& info);
+
+  uint32_t getAmountSwitchStatWasRequested();
+
+  void initSwitch(power::Switch_t switchNr);
+
+ private:
+  using SwitchOnOffPair = std::pair<power::Switch_t, ReturnValue_t>;
+  using FuseOnOffPair = std::pair<uint8_t, ReturnValue_t>;
+  std::map<power::Switch_t, SwitchInfo> switchMap;
+  std::map<uint8_t, FuseInfo> fuseMap;
+};
+
+#endif /* FSFW_TESTS_SRC_FSFW_TESTS_UNIT_MOCKS_POWERSWITCHERMOCK_H_ */

unittests/osal/CMakeLists.txt

@@ -0,0 +1,5 @@
+target_sources(${FSFW_TEST_TGT} PRIVATE
+	TestMessageQueue.cpp
+	TestSemaphore.cpp
+	TestClock.cpp
+)

unittests/osal/TestClock.cpp

@@ -0,0 +1,86 @@
+#include <fsfw/globalfunctions/timevalOperations.h>
+#include <fsfw/timemanager/Clock.h>
+
+#include <array>
+#include <catch2/catch_approx.hpp>
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+
+TEST_CASE("OSAL::Clock Test", "[OSAL::Clock Test]") {
+  SECTION("Test getClock") {
+    timeval time;
+    ReturnValue_t result = Clock::getClock_timeval(&time);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    Clock::TimeOfDay_t timeOfDay;
+    result = Clock::getDateAndTime(&timeOfDay);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    timeval timeOfDayAsTimeval;
+    result = Clock::convertTimeOfDayToTimeval(&timeOfDay, &timeOfDayAsTimeval);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    // We require timeOfDayAsTimeval to be larger than time as it
+    // was request a few ns later
+    double difference = timevalOperations::toDouble(timeOfDayAsTimeval - time);
+    CHECK(difference >= 0.0);
+    CHECK(difference <= 0.005);
+
+    // Conversion in the other direction
+    Clock::TimeOfDay_t timevalAsTimeOfDay;
+    result = Clock::convertTimevalToTimeOfDay(&time, &timevalAsTimeOfDay);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    CHECK(timevalAsTimeOfDay.year <= timeOfDay.year);
+    // TODO We should write TimeOfDay operators!
+  }
+  SECTION("Leap seconds") {
+    uint16_t leapSeconds = 0;
+    ReturnValue_t result = Clock::getLeapSeconds(&leapSeconds);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_FAILED);
+    REQUIRE(leapSeconds == 0);
+    result = Clock::setLeapSeconds(18);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    result = Clock::getLeapSeconds(&leapSeconds);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(leapSeconds == 18);
+  }
+  SECTION("usec Test") {
+    timeval timeAsTimeval;
+    ReturnValue_t result = Clock::getClock_timeval(&timeAsTimeval);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    uint64_t timeAsUsec = 0;
+    result = Clock::getClock_usecs(&timeAsUsec);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    double timeAsUsecDouble = static_cast<double>(timeAsUsec) / 1000000.0;
+    timeval timeAsUsecTimeval = timevalOperations::toTimeval(timeAsUsecDouble);
+    double difference = timevalOperations::toDouble(timeAsUsecTimeval - timeAsTimeval);
+    // We accept 5 ms difference
+    CHECK(difference >= 0.0);
+    CHECK(difference <= 0.005);
+    uint64_t timevalAsUint64 = static_cast<uint64_t>(timeAsTimeval.tv_sec) * 1000000ull +
+                               static_cast<uint64_t>(timeAsTimeval.tv_usec);
+    CHECK((timeAsUsec - timevalAsUint64) >= 0);
+    CHECK((timeAsUsec - timevalAsUint64) <= (5 * 1000));
+  }
+  SECTION("Test j2000") {
+    double j2000;
+    timeval time;
+    time.tv_sec = 1648208539;
+    time.tv_usec = 0;
+    ReturnValue_t result = Clock::convertTimevalToJD2000(time, &j2000);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    double correctJ2000 = 2459663.98772 - 2451545.0;
+    CHECK(j2000 == Catch::Approx(correctJ2000).margin(1.2 * 1e-8));
+  }
+  SECTION("Convert to TT") {
+    timeval utcTime;
+    utcTime.tv_sec = 1648208539;
+    utcTime.tv_usec = 999000;
+    timeval tt;
+    ReturnValue_t result = Clock::setLeapSeconds(27);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    result = Clock::convertUTCToTT(utcTime, &tt);
+    REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+    CHECK(tt.tv_usec == 183000);
+    // The plus 1 is a own forced overflow of usecs
+    CHECK(tt.tv_sec == (1648208539 + 27 + 10 + 32 + 1));
+  }
+}

unittests/osal/TestMessageQueue.cpp

@@ -0,0 +1,59 @@
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/ipc/QueueFactory.h>
+
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+
+TEST_CASE("MessageQueue Basic Test", "[TestMq]") {
+  MessageQueueIF* testSenderMq = QueueFactory::instance()->createMessageQueue(1);
+  MessageQueueId_t testSenderMqId = testSenderMq->getId();
+
+  MessageQueueIF* testReceiverMq = QueueFactory::instance()->createMessageQueue(1);
+  MessageQueueId_t testReceiverMqId = testReceiverMq->getId();
+  std::array<uint8_t, 20> testData{0};
+  testData[0] = 42;
+  MessageQueueMessage testMessage(testData.data(), 1);
+  testSenderMq->setDefaultDestination(testReceiverMqId);
+
+  SECTION("Simple Tests") {
+    auto result = testSenderMq->sendMessage(testReceiverMqId, &testMessage);
+    REQUIRE(result == retval::CATCH_OK);
+    MessageQueueMessage recvMessage;
+    result = testReceiverMq->receiveMessage(&recvMessage);
+    REQUIRE(result == retval::CATCH_OK);
+    CHECK(recvMessage.getData()[0] == 42);
+
+    result = testSenderMq->sendMessage(testReceiverMqId, &testMessage);
+    REQUIRE(result == retval::CATCH_OK);
+    MessageQueueId_t senderId = 0;
+    result = testReceiverMq->receiveMessage(&recvMessage, &senderId);
+    REQUIRE(result == retval::CATCH_OK);
+    CHECK(recvMessage.getData()[0] == 42);
+    CHECK(senderId == testSenderMqId);
+    senderId = testReceiverMq->getLastPartner();
+    CHECK(senderId == testSenderMqId);
+  }
+  SECTION("Test Full") {
+    auto result = testSenderMq->sendMessage(testReceiverMqId, &testMessage);
+    REQUIRE(result == retval::CATCH_OK);
+    result = testSenderMq->sendMessage(testReceiverMqId, &testMessage);
+    REQUIRE(result == MessageQueueIF::FULL);
+    // We try another message
+    result = testSenderMq->sendMessage(testReceiverMqId, &testMessage);
+    REQUIRE(result == MessageQueueIF::FULL);
+    MessageQueueMessage recvMessage;
+    result = testReceiverMq->receiveMessage(&recvMessage);
+    REQUIRE(result == retval::CATCH_OK);
+    CHECK(recvMessage.getData()[0] == 42);
+    result = testSenderMq->sendMessage(testReceiverMqId, &testMessage);
+    REQUIRE(result == retval::CATCH_OK);
+    result = testReceiverMq->receiveMessage(&recvMessage);
+    REQUIRE(result == retval::CATCH_OK);
+    CHECK(recvMessage.getData()[0] == 42);
+  }
+  // We have to clear MQs ourself ATM
+  QueueFactory::instance()->deleteMessageQueue(testSenderMq);
+  QueueFactory::instance()->deleteMessageQueue(testReceiverMq);
+}

unittests/osal/TestSemaphore.cpp

@@ -0,0 +1,46 @@
+
+#ifdef LINUX
+
+/*
+#include <fsfw/tasks/SemaphoreFactory.h>
+#include <fsfw/timemanager/Stopwatch.h>
+
+#include "catch.hpp"
+#include "core/CatchDefinitions.h"
+
+TEST_CASE("Binary Semaphore Test" , "[BinSemaphore]") {
+        //perform set-up here
+        SemaphoreIF* binSemaph = SemaphoreFactory::instance()->
+                        createBinarySemaphore();
+        REQUIRE(binSemaph != nullptr);
+        SECTION("Simple Test") {
+                // set-up is run for each section
+                REQUIRE(binSemaph->getSemaphoreCounter() == 1);
+                REQUIRE(binSemaph->release() ==
+                                static_cast<int>(SemaphoreIF::SEMAPHORE_NOT_OWNED));
+                REQUIRE(binSemaph->acquire(SemaphoreIF::POLLING) ==
+                                retval::CATCH_OK);
+                {
+                        // not precise enough on linux.. should use clock instead..
+                        //Stopwatch stopwatch(false);
+                        //REQUIRE(binSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 5) ==
+                        //		SemaphoreIF::SEMAPHORE_TIMEOUT);
+                        //dur_millis_t time = stopwatch.stop();
+                        //CHECK(time == 5);
+                }
+                REQUIRE(binSemaph->getSemaphoreCounter() == 0);
+                REQUIRE(binSemaph->release() == retval::CATCH_OK);
+        }
+        SemaphoreFactory::instance()->deleteSemaphore(binSemaph);
+        // perform tear-down here
+}
+
+
+TEST_CASE("Counting Semaphore Test" , "[CountingSemaph]") {
+        SECTION("Simple Test") {
+
+        }
+}
+*/
+
+#endif

unittests/power/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(${FSFW_TEST_TGT} PRIVATE
+    testPowerSwitcher.cpp
+)

unittests/power/testPowerSwitcher.cpp

@@ -0,0 +1,71 @@
+#include <fsfw/power/DummyPowerSwitcher.h>
+#include <fsfw/power/PowerSwitcher.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "mocks/PowerSwitcherMock.h"
+#include "objects/systemObjectList.h"
+
+TEST_CASE("Power Switcher", "[power-switcher]") {
+  PowerSwitcherMock mock;
+  PowerSwitcher switcher(&mock, 1);
+  DummyPowerSwitcher dummySwitcher(objects::DUMMY_POWER_SWITCHER, 5, 5, false);
+  PowerSwitcher switcherUsingDummy(&dummySwitcher, 1);
+  SwitchInfo switchInfo;
+  mock.initSwitch(1);
+
+  SECTION("Basic Tests") {
+    REQUIRE(switcher.getFirstSwitch() == 1);
+    REQUIRE(switcher.getSecondSwitch() == power::NO_SWITCH);
+    // Default start state
+    REQUIRE(switcher.getState() == PowerSwitcher::SWITCH_IS_OFF);
+    switcher.turnOn(true);
+    REQUIRE(mock.getAmountSwitchStatWasRequested() == 1);
+    REQUIRE(switcher.getState() == PowerSwitcher::WAIT_ON);
+    REQUIRE(switcher.checkSwitchState() == PowerSwitcher::IN_POWER_TRANSITION);
+    REQUIRE(switcher.active());
+    switcher.doStateMachine();
+    REQUIRE(switcher.getState() == PowerSwitcher::SWITCH_IS_ON);
+    mock.getSwitchInfo(1, switchInfo);
+    REQUIRE(switchInfo.timesCalledOn == 1);
+    REQUIRE(not switcher.active());
+    REQUIRE(mock.getAmountSwitchStatWasRequested() == 2);
+    REQUIRE(switcher.checkSwitchState() == HasReturnvaluesIF::RETURN_OK);
+    REQUIRE(mock.getAmountSwitchStatWasRequested() == 3);
+    switcher.turnOff(false);
+    REQUIRE(mock.getAmountSwitchStatWasRequested() == 3);
+    REQUIRE(switcher.getState() == PowerSwitcher::WAIT_OFF);
+    REQUIRE(switcher.active());
+    REQUIRE(switcher.getState() == PowerSwitcher::WAIT_OFF);
+    switcher.doStateMachine();
+    mock.getSwitchInfo(1, switchInfo);
+    REQUIRE(switcher.getState() == PowerSwitcher::SWITCH_IS_OFF);
+    REQUIRE(switchInfo.timesCalledOn == 1);
+    REQUIRE(switchInfo.timesCalledOff == 1);
+    REQUIRE(not switcher.active());
+    REQUIRE(mock.getAmountSwitchStatWasRequested() == 4);
+  }
+
+  SECTION("Dummy Test") {
+    // Same tests, but we can't really check the dummy
+    REQUIRE(switcherUsingDummy.getFirstSwitch() == 1);
+    REQUIRE(switcherUsingDummy.getSecondSwitch() == power::NO_SWITCH);
+    REQUIRE(switcherUsingDummy.getState() == PowerSwitcher::SWITCH_IS_OFF);
+    switcherUsingDummy.turnOn(true);
+    REQUIRE(switcherUsingDummy.getState() == PowerSwitcher::WAIT_ON);
+    REQUIRE(switcherUsingDummy.active());
+    switcherUsingDummy.doStateMachine();
+    REQUIRE(switcherUsingDummy.getState() == PowerSwitcher::SWITCH_IS_ON);
+    REQUIRE(not switcherUsingDummy.active());
+
+    switcherUsingDummy.turnOff(false);
+    REQUIRE(switcherUsingDummy.getState() == PowerSwitcher::WAIT_OFF);
+    REQUIRE(switcherUsingDummy.active());
+    REQUIRE(switcherUsingDummy.getState() == PowerSwitcher::WAIT_OFF);
+    switcherUsingDummy.doStateMachine();
+    REQUIRE(switcherUsingDummy.getState() == PowerSwitcher::SWITCH_IS_OFF);
+    REQUIRE(not switcherUsingDummy.active());
+  }
+
+  SECTION("More Dummy Tests") {}
+}

unittests/printChar.cpp

@@ -0,0 +1,11 @@
+#include "printChar.h"
+
+#include <cstdio>
+
+void printChar(const char* character, bool errStream) {
+  if (errStream) {
+    std::putc(*character, stderr);
+    return;
+  }
+  std::putc(*character, stdout);
+}

unittests/printChar.h

@@ -0,0 +1,6 @@
+#ifndef FSFW_UNITTEST_CORE_PRINTCHAR_H_
+#define FSFW_UNITTEST_CORE_PRINTCHAR_H_
+
+extern "C" void printChar(const char*, bool errStream);
+
+#endif /* FSFW_UNITTEST_CORE_PRINTCHAR_H_ */

unittests/serialize/CMakeLists.txt

@@ -0,0 +1,5 @@
+target_sources(${FSFW_TEST_TGT} PRIVATE
+	TestSerialBufferAdapter.cpp
+	TestSerialization.cpp
+	TestSerialLinkedPacket.cpp
+)

unittests/serialize/TestSerialBufferAdapter.cpp

@@ -0,0 +1,134 @@
+#include <fsfw/serialize/SerialBufferAdapter.h>
+
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+
+static bool test_value_bool = true;
+static uint16_t tv_uint16{283};
+static std::array<uint8_t, 512> testArray;
+
+TEST_CASE("Serial Buffer Adapter", "[single-file]") {
+  size_t serialized_size = 0;
+  test_value_bool = true;
+  uint8_t* arrayPtr = testArray.data();
+  std::array<uint8_t, 5> test_serial_buffer{5, 4, 3, 2, 1};
+  SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter =
+      SerialBufferAdapter<uint8_t>(test_serial_buffer.data(), test_serial_buffer.size(), false);
+  tv_uint16 = 16;
+
+  SECTION("Serialize without size field") {
+    SerializeAdapter::serialize(&test_value_bool, &arrayPtr, &serialized_size, testArray.size(),
+                                SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::serialize(&tv_serial_buffer_adapter, &arrayPtr, &serialized_size,
+                                testArray.size(), SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::serialize(&tv_uint16, &arrayPtr, &serialized_size, testArray.size(),
+                                SerializeIF::Endianness::MACHINE);
+
+    REQUIRE(serialized_size == 8);
+    REQUIRE(testArray[0] == true);
+    REQUIRE(testArray[1] == 5);
+    REQUIRE(testArray[2] == 4);
+    REQUIRE(testArray[3] == 3);
+    REQUIRE(testArray[4] == 2);
+    REQUIRE(testArray[5] == 1);
+    memcpy(&tv_uint16, testArray.data() + 6, sizeof(tv_uint16));
+    REQUIRE(tv_uint16 == 16);
+  }
+
+  SECTION("Serialize with size field") {
+    SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter_loc =
+        SerialBufferAdapter<uint8_t>(test_serial_buffer.data(), test_serial_buffer.size(), true);
+    serialized_size = 0;
+    arrayPtr = testArray.data();
+    SerializeAdapter::serialize(&test_value_bool, &arrayPtr, &serialized_size, testArray.size(),
+                                SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::serialize(&tv_serial_buffer_adapter_loc, &arrayPtr, &serialized_size,
+                                testArray.size(), SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::serialize(&tv_uint16, &arrayPtr, &serialized_size, testArray.size(),
+                                SerializeIF::Endianness::MACHINE);
+
+    REQUIRE(serialized_size == 9);
+    REQUIRE(testArray[0] == true);
+    REQUIRE(testArray[1] == 5);
+    REQUIRE(testArray[2] == 5);
+    REQUIRE(testArray[3] == 4);
+    REQUIRE(testArray[4] == 3);
+    REQUIRE(testArray[5] == 2);
+    REQUIRE(testArray[6] == 1);
+    memcpy(&tv_uint16, testArray.data() + 7, sizeof(tv_uint16));
+    REQUIRE(tv_uint16 == 16);
+  }
+
+  SECTION("Test set buffer function") {
+    SerialBufferAdapter<uint8_t> tv_serial_buffer_adapter_loc =
+        SerialBufferAdapter<uint8_t>((uint8_t*)nullptr, 0, true);
+    tv_serial_buffer_adapter_loc.setBuffer(test_serial_buffer.data(), test_serial_buffer.size());
+    serialized_size = 0;
+    arrayPtr = testArray.data();
+    SerializeAdapter::serialize(&test_value_bool, &arrayPtr, &serialized_size, testArray.size(),
+                                SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::serialize(&tv_serial_buffer_adapter_loc, &arrayPtr, &serialized_size,
+                                testArray.size(), SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::serialize(&tv_uint16, &arrayPtr, &serialized_size, testArray.size(),
+                                SerializeIF::Endianness::MACHINE);
+    REQUIRE(serialized_size == 9);
+    REQUIRE(testArray[0] == true);
+    REQUIRE(testArray[1] == 5);
+    REQUIRE(testArray[2] == 5);
+    REQUIRE(testArray[3] == 4);
+    REQUIRE(testArray[4] == 3);
+    REQUIRE(testArray[5] == 2);
+    REQUIRE(testArray[6] == 1);
+    memcpy(&tv_uint16, testArray.data() + 7, sizeof(tv_uint16));
+    REQUIRE(tv_uint16 == 16);
+  }
+
+  SECTION("Deserialization with size field") {
+    size_t buffer_size = 4;
+    memcpy(testArray.data(), &buffer_size, sizeof(uint16_t));
+    testArray[2] = 1;
+    testArray[3] = 1;
+    testArray[4] = 1;
+    testArray[5] = 0;
+    std::array<uint8_t, 4> test_recv_array;
+    arrayPtr = testArray.data();
+    // copy testArray[1] to testArray[4] into receive buffer, skip
+    // size field (testArray[0]) for deSerialization.
+    SerialBufferAdapter<uint16_t> tv_serial_buffer_adapter3 =
+        SerialBufferAdapter<uint16_t>(test_recv_array.data(), 4, true);
+    // Deserialization
+    size_t size = 6;
+    auto result = tv_serial_buffer_adapter3.deSerialize(const_cast<const uint8_t**>(&arrayPtr),
+                                                        &size, SerializeIF::Endianness::MACHINE);
+    REQUIRE(result == retval::CATCH_OK);
+    CHECK(test_recv_array[0] == 1);
+    CHECK(test_recv_array[1] == 1);
+    CHECK(test_recv_array[2] == 1);
+    CHECK(test_recv_array[3] == 0);
+  }
+
+  SECTION("Deserialization without size field") {
+    size_t buffer_size = 4;
+    memcpy(testArray.data(), &buffer_size, sizeof(uint16_t));
+    testArray[2] = 1;
+    testArray[3] = 1;
+    testArray[4] = 1;
+    testArray[5] = 0;
+    std::array<uint8_t, 4> test_recv_array;
+    arrayPtr = testArray.data() + 2;
+    // copy testArray[1] to testArray[4] into receive buffer, skip
+    // size field (testArray[0])
+    SerialBufferAdapter<uint16_t> tv_serial_buffer_adapter3 =
+        SerialBufferAdapter<uint16_t>(test_recv_array.data(), 4, false);
+    // Deserialization
+    size_t size = 4;
+    tv_serial_buffer_adapter3.deSerialize(const_cast<const uint8_t**>(&arrayPtr), &size,
+                                          SerializeIF::Endianness::MACHINE);
+    CHECK(test_recv_array[0] == 1);
+    CHECK(test_recv_array[1] == 1);
+    CHECK(test_recv_array[2] == 1);
+    CHECK(test_recv_array[3] == 0);
+  }
+}

unittests/serialize/TestSerialLinkedPacket.cpp

@@ -0,0 +1,73 @@
+#include "TestSerialLinkedPacket.h"
+
+#include <fsfw/globalfunctions/arrayprinter.h>
+
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+
+TEST_CASE("Serial Linked Packet", "[SerLinkPacket]") {
+  // perform set-up here
+  uint32_t header = 42;
+  std::array<uint8_t, 3> testArray{1, 2, 3};
+  uint32_t tail = 96;
+  size_t packetMaxSize = 256;
+  uint8_t packet[packetMaxSize] = {};
+  size_t packetLen = 0;
+
+  SECTION("Test Deserialization with Serial Buffer Adapter.") {
+    // This is a serialization of a packet, made "manually".
+    // We generate a packet which store data big-endian by swapping some
+    // values. (like coming from ground).
+    header = EndianConverter::convertBigEndian(header);
+    std::memcpy(packet, &header, sizeof(header));
+    packetLen += sizeof(header);
+
+    std::copy(testArray.data(), testArray.data() + testArray.size(), packet + packetLen);
+    packetLen += testArray.size();
+
+    tail = EndianConverter::convertBigEndian(tail);
+    std::memcpy(packet + packetLen, &tail, sizeof(tail));
+    packetLen += sizeof(tail);
+
+    // arrayprinter::print(packet, packetLen, OutputType::DEC);
+
+    // This is the buffer which will be filled when testClass.deSerialize
+    // is called.
+    std::array<uint8_t, 3> bufferAdaptee = {};
+    TestPacket testClass(packet, packetLen, bufferAdaptee.data(), bufferAdaptee.size());
+    const uint8_t* readOnlyPointer = packet;
+    // Deserialize big endian packet by setting bigEndian to true.
+    ReturnValue_t result =
+        testClass.deSerialize(&readOnlyPointer, &packetLen, SerializeIF::Endianness::BIG);
+    REQUIRE(result == retval::CATCH_OK);
+    CHECK(testClass.getHeader() == 42);
+    // Equivalent check.
+    // CHECK(testClass.getBuffer()[0] == 1);
+    CHECK(bufferAdaptee[0] == 1);
+    CHECK(bufferAdaptee[1] == 2);
+    CHECK(bufferAdaptee[2] == 3);
+    CHECK(testClass.getTail() == 96);
+  }
+
+  SECTION("Test Serialization") {
+    // Same process as performed in setup, this time using the class
+    // instead of doing it manually.
+    TestPacket testClass(header, tail, testArray.data(), testArray.size());
+    size_t serializedSize = 0;
+    uint8_t* packetPointer = packet;
+    // serialize for ground: bigEndian = true.
+    ReturnValue_t result = testClass.serialize(&packetPointer, &serializedSize, packetMaxSize,
+                                               SerializeIF::Endianness::BIG);
+    REQUIRE(result == retval::CATCH_OK);
+    // Result should be big endian now.
+    CHECK(packet[3] == 42);
+    CHECK(packet[4] == 1);
+    CHECK(packet[5] == 2);
+    CHECK(packet[6] == 3);
+    CHECK(packet[10] == 96);
+  }
+
+  // perform tear-down here
+}

unittests/serialize/TestSerialLinkedPacket.h

@@ -0,0 +1,50 @@
+#ifndef UNITTEST_HOSTED_TESTSERIALLINKEDPACKET_H_
+#define UNITTEST_HOSTED_TESTSERIALLINKEDPACKET_H_
+
+#include <fsfw/objectmanager/SystemObjectIF.h>
+#include <fsfw/parameters/HasParametersIF.h>
+#include <fsfw/serialize/SerialBufferAdapter.h>
+#include <fsfw/serialize/SerialLinkedListAdapter.h>
+
+#include <cstdint>
+
+class TestPacket : public SerialLinkedListAdapter<SerializeIF> {
+ public:
+  /**
+   * For Deserialization
+   */
+  TestPacket(const uint8_t* somePacket, size_t size, uint8_t* storePointer, size_t storeSize)
+      : buffer(storePointer, storeSize) {
+    setLinks();
+  }
+
+  /**
+   * For Serialization
+   */
+  TestPacket(uint32_t header, uint32_t tail, const uint8_t* parameters, size_t paramSize)
+      : header(header), buffer(parameters, paramSize), tail(tail) {
+    setLinks();
+  }
+
+  uint32_t getHeader() const { return header.entry; }
+
+  const uint8_t* getBuffer() { return buffer.entry.getConstBuffer(); }
+
+  size_t getBufferLength() { return buffer.getSerializedSize(); }
+
+  uint16_t getTail() const { return tail.entry; }
+
+ private:
+  void setLinks() {
+    setStart(&header);
+    header.setNext(&buffer);
+    buffer.setNext(&tail);
+    tail.setEnd();
+  }
+
+  SerializeElement<uint32_t> header = 0;
+  SerializeElement<SerialBufferAdapter<uint8_t>> buffer;
+  SerializeElement<uint32_t> tail = 0;
+};
+
+#endif /* UNITTEST_TESTFW_NEWTESTS_TESTTEMPLATE_H_ */

unittests/serialize/TestSerialization.cpp

@@ -0,0 +1,202 @@
+#include <fsfw/serialize/SerialBufferAdapter.h>
+#include <fsfw/serialize/SerializeAdapter.h>
+
+#include <array>
+#include <catch2/catch_approx.hpp>
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+
+static bool testBool = true;
+static uint8_t tvUint8{5};
+static uint16_t tvUint16{283};
+static uint32_t tvUint32{929221};
+static uint64_t tvUint64{2929329429};
+
+static int8_t tvInt8{-16};
+static int16_t tvInt16{-829};
+static int32_t tvInt32{-2312};
+
+static float tvFloat{8.2149214};
+static float tvSfloat = {-922.2321321};
+static double tvDouble{9.2132142141e8};
+static double tvSdouble{-2.2421e19};
+
+static std::array<uint8_t, 512> TEST_ARRAY;
+
+TEST_CASE("Serialization size tests", "[SerSizeTest]") {
+  // REQUIRE(unitTestClass.test_autoserialization() == 0);
+  REQUIRE(SerializeAdapter::getSerializedSize(&testBool) == sizeof(testBool));
+  REQUIRE(SerializeAdapter::getSerializedSize(&tvUint8) == sizeof(tvUint8));
+  REQUIRE(SerializeAdapter::getSerializedSize(&tvUint16) == sizeof(tvUint16));
+  REQUIRE(SerializeAdapter::getSerializedSize(&tvUint32) == sizeof(tvUint32));
+  REQUIRE(SerializeAdapter::getSerializedSize(&tvUint64) == sizeof(tvUint64));
+  REQUIRE(SerializeAdapter::getSerializedSize(&tvInt8) == sizeof(tvInt8));
+  REQUIRE(SerializeAdapter::getSerializedSize(&tvInt16) == sizeof(tvInt16));
+  REQUIRE(SerializeAdapter::getSerializedSize(&tvInt32) == sizeof(tvInt32));
+  REQUIRE(SerializeAdapter::getSerializedSize(&tvFloat) == sizeof(tvFloat));
+  REQUIRE(SerializeAdapter::getSerializedSize(&tvSfloat) == sizeof(tvSfloat));
+  REQUIRE(SerializeAdapter::getSerializedSize(&tvDouble) == sizeof(tvDouble));
+  REQUIRE(SerializeAdapter::getSerializedSize(&tvSdouble) == sizeof(tvSdouble));
+}
+
+TEST_CASE("Auto Serialize Adapter", "[SerAdapter]") {
+  size_t serializedSize = 0;
+  uint8_t* pArray = TEST_ARRAY.data();
+
+  SECTION("SerDe") {
+    size_t deserSize = 0;
+    SerializeAdapter::serialize(&testBool, TEST_ARRAY.data(), &deserSize, TEST_ARRAY.size(),
+                                SerializeIF::Endianness::MACHINE);
+    REQUIRE(deserSize == 1);
+    REQUIRE(TEST_ARRAY[0] == true);
+    bool readBack = false;
+    SerializeAdapter::deSerialize(&readBack, TEST_ARRAY.data(), &deserSize,
+                                  SerializeIF::Endianness::MACHINE);
+    REQUIRE(deserSize == 1);
+    REQUIRE(readBack == true);
+    SerializeAdapter::serialize(&tvUint8, TEST_ARRAY.data(), &deserSize, TEST_ARRAY.size(),
+                                SerializeIF::Endianness::MACHINE);
+    REQUIRE(deserSize == 1);
+    REQUIRE(TEST_ARRAY[0] == 5);
+    uint8_t readBackUint8 = 0;
+    uint8_t* const testPtr = TEST_ARRAY.data();
+    uint8_t* const shouldStayConst = testPtr;
+    SerializeAdapter::deSerialize(&readBackUint8, testPtr, &deserSize,
+                                  SerializeIF::Endianness::MACHINE);
+    REQUIRE(testPtr == shouldStayConst);
+    REQUIRE(deserSize == 1);
+    REQUIRE(readBackUint8 == 5);
+    SerializeAdapter::serialize(&tvUint16, TEST_ARRAY.data(), &deserSize, TEST_ARRAY.size(),
+                                SerializeIF::Endianness::MACHINE);
+    REQUIRE(deserSize == 2);
+    deserSize = 0;
+    uint16_t readBackUint16 = 0;
+    SerializeAdapter::deSerialize(&readBackUint16, TEST_ARRAY.data(), &deserSize,
+                                  SerializeIF::Endianness::MACHINE);
+    REQUIRE(deserSize == 2);
+    REQUIRE(readBackUint16 == 283);
+
+    SerializeAdapter::serialize(&tvUint32, TEST_ARRAY.data(), &deserSize, TEST_ARRAY.size(),
+                                SerializeIF::Endianness::MACHINE);
+    REQUIRE(deserSize == 4);
+    uint32_t readBackUint32 = 0;
+    deserSize = 0;
+    SerializeAdapter::deSerialize(&readBackUint32, TEST_ARRAY.data(), &deserSize,
+                                  SerializeIF::Endianness::MACHINE);
+    REQUIRE(deserSize == 4);
+    REQUIRE(readBackUint32 == 929221);
+
+    SerializeAdapter::serialize(&tvInt16, TEST_ARRAY.data(), &deserSize, TEST_ARRAY.size(),
+                                SerializeIF::Endianness::MACHINE);
+    REQUIRE(deserSize == 2);
+    int16_t readBackInt16 = 0;
+    SerializeAdapter::deSerialize(&readBackInt16, TEST_ARRAY.data(), &deserSize,
+                                  SerializeIF::Endianness::MACHINE);
+    REQUIRE(readBackInt16 == -829);
+    REQUIRE(deserSize == 2);
+
+    SerializeAdapter::serialize(&tvFloat, TEST_ARRAY.data(), &deserSize, TEST_ARRAY.size(),
+                                SerializeIF::Endianness::MACHINE);
+    float readBackFloat = 0.0;
+    SerializeAdapter::deSerialize(&readBackFloat, TEST_ARRAY.data(), &deserSize,
+                                  SerializeIF::Endianness::MACHINE);
+    REQUIRE(readBackFloat == Catch::Approx(8.214921));
+
+    SerializeAdapter::serialize(&tvSdouble, TEST_ARRAY.data(), &deserSize, TEST_ARRAY.size(),
+                                SerializeIF::Endianness::MACHINE);
+    double readBackSignedDouble = 0.0;
+    SerializeAdapter::deSerialize(&readBackSignedDouble, TEST_ARRAY.data(), &deserSize,
+                                  SerializeIF::Endianness::MACHINE);
+    REQUIRE(readBackSignedDouble == Catch::Approx(-2.2421e19));
+
+    uint8_t testBuf[4] = {1, 2, 3, 4};
+    SerialBufferAdapter<uint8_t> bufferAdapter(testBuf, sizeof(testBuf));
+    SerializeAdapter::serialize(&bufferAdapter, TEST_ARRAY.data(), &deserSize, TEST_ARRAY.size(),
+                                SerializeIF::Endianness::MACHINE);
+    REQUIRE(deserSize == 4);
+    for (uint8_t idx = 0; idx < 4; idx++) {
+      REQUIRE(TEST_ARRAY[idx] == idx + 1);
+    }
+    deserSize = 0;
+    testBuf[0] = 0;
+    testBuf[1] = 12;
+    SerializeAdapter::deSerialize(&bufferAdapter, TEST_ARRAY.data(), &deserSize,
+                                  SerializeIF::Endianness::MACHINE);
+    REQUIRE(deserSize == 4);
+    for (uint8_t idx = 0; idx < 4; idx++) {
+      REQUIRE(testBuf[idx] == idx + 1);
+    }
+  }
+
+  SECTION("Serialize incrementing") {
+    SerializeAdapter::serialize(&testBool, &pArray, &serializedSize, TEST_ARRAY.size(),
+                                SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::serialize(&tvUint8, &pArray, &serializedSize, TEST_ARRAY.size(),
+                                SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::serialize(&tvUint16, &pArray, &serializedSize, TEST_ARRAY.size(),
+                                SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::serialize(&tvUint32, &pArray, &serializedSize, TEST_ARRAY.size(),
+                                SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::serialize(&tvInt8, &pArray, &serializedSize, TEST_ARRAY.size(),
+                                SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::serialize(&tvInt16, &pArray, &serializedSize, TEST_ARRAY.size(),
+                                SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::serialize(&tvInt32, &pArray, &serializedSize, TEST_ARRAY.size(),
+                                SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::serialize(&tvUint64, &pArray, &serializedSize, TEST_ARRAY.size(),
+                                SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::serialize(&tvFloat, &pArray, &serializedSize, TEST_ARRAY.size(),
+                                SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::serialize(&tvDouble, &pArray, &serializedSize, TEST_ARRAY.size(),
+                                SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::serialize(&tvSfloat, &pArray, &serializedSize, TEST_ARRAY.size(),
+                                SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::serialize(&tvSdouble, &pArray, &serializedSize, TEST_ARRAY.size(),
+                                SerializeIF::Endianness::MACHINE);
+    REQUIRE(serializedSize == 47);
+  }
+
+  SECTION("Deserialize decrementing") {
+    pArray = TEST_ARRAY.data();
+    size_t remaining_size = serializedSize;
+    SerializeAdapter::deSerialize(&testBool, const_cast<const uint8_t**>(&pArray), &remaining_size,
+                                  SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::deSerialize(&tvUint8, const_cast<const uint8_t**>(&pArray), &remaining_size,
+                                  SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::deSerialize(&tvUint16, const_cast<const uint8_t**>(&pArray), &remaining_size,
+                                  SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::deSerialize(&tvUint32, const_cast<const uint8_t**>(&pArray), &remaining_size,
+                                  SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::deSerialize(&tvInt8, const_cast<const uint8_t**>(&pArray), &remaining_size,
+                                  SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::deSerialize(&tvInt16, const_cast<const uint8_t**>(&pArray), &remaining_size,
+                                  SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::deSerialize(&tvInt32, const_cast<const uint8_t**>(&pArray), &remaining_size,
+                                  SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::deSerialize(&tvUint64, const_cast<const uint8_t**>(&pArray), &remaining_size,
+                                  SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::deSerialize(&tvFloat, const_cast<const uint8_t**>(&pArray), &remaining_size,
+                                  SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::deSerialize(&tvDouble, const_cast<const uint8_t**>(&pArray), &remaining_size,
+                                  SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::deSerialize(&tvSfloat, const_cast<const uint8_t**>(&pArray), &remaining_size,
+                                  SerializeIF::Endianness::MACHINE);
+    SerializeAdapter::deSerialize(&tvSdouble, const_cast<const uint8_t**>(&pArray), &remaining_size,
+                                  SerializeIF::Endianness::MACHINE);
+
+    REQUIRE(testBool == true);
+    REQUIRE(tvUint8 == 5);
+    REQUIRE(tvUint16 == 283);
+    REQUIRE(tvUint32 == 929221);
+    REQUIRE(tvUint64 == 2929329429);
+    REQUIRE(tvInt8 == -16);
+    REQUIRE(tvInt16 == -829);
+    REQUIRE(tvInt32 == -2312);
+
+    REQUIRE(tvFloat == Catch::Approx(8.214921));
+    REQUIRE(tvDouble == Catch::Approx(9.2132142141e8));
+    REQUIRE(tvSfloat == Catch::Approx(-922.2321321));
+    REQUIRE(tvSdouble == Catch::Approx(-2.2421e19));
+  }
+}

unittests/storagemanager/CMakeLists.txt

@@ -0,0 +1,4 @@
+target_sources(${FSFW_TEST_TGT} PRIVATE
+	TestNewAccessor.cpp
+	TestPool.cpp
+)

unittests/storagemanager/TestNewAccessor.cpp

@@ -0,0 +1,186 @@
+#include <fsfw/storagemanager/LocalPool.h>
+
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+#include <cstring>
+
+#include "CatchDefinitions.h"
+
+TEST_CASE("New Accessor", "[NewAccessor]") {
+  LocalPool::LocalPoolConfig poolCfg = {{1, 10}};
+  LocalPool SimplePool = LocalPool(0, poolCfg);
+  std::array<uint8_t, 20> testDataArray;
+  std::array<uint8_t, 20> receptionArray;
+  store_address_t testStoreId;
+  ReturnValue_t result = retval::CATCH_FAILED;
+
+  for (size_t i = 0; i < testDataArray.size(); i++) {
+    testDataArray[i] = i;
+  }
+  size_t size = 10;
+
+  SECTION("Simple tests getter functions") {
+    result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+    REQUIRE(result == retval::CATCH_OK);
+    auto resultPair = SimplePool.getData(testStoreId);
+    REQUIRE(resultPair.first == retval::CATCH_OK);
+    resultPair.second.getDataCopy(receptionArray.data(), 20);
+    CHECK(resultPair.second.getId() == testStoreId);
+    CHECK(resultPair.second.size() == 10);
+    for (size_t i = 0; i < size; i++) {
+      CHECK(receptionArray[i] == i);
+    }
+
+    std::copy(resultPair.second.data(), resultPair.second.data() + resultPair.second.size(),
+              receptionArray.data());
+    for (size_t i = 0; i < size; i++) {
+      CHECK(receptionArray[i] == i);
+    }
+
+    {
+      auto resultPairLoc = SimplePool.getData(testStoreId);
+      REQUIRE(resultPairLoc.first == retval::CATCH_OK);
+      // data should be deleted when accessor goes out of scope.
+    }
+    resultPair = SimplePool.getData(testStoreId);
+    REQUIRE(resultPair.first == (int)StorageManagerIF::DATA_DOES_NOT_EXIST);
+
+    result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+    REQUIRE(result == retval::CATCH_OK);
+    {
+      ConstStorageAccessor constAccessor(testStoreId);
+      result = SimplePool.getData(testStoreId, constAccessor);
+      REQUIRE(result == retval::CATCH_OK);
+      constAccessor.getDataCopy(receptionArray.data(), 20);
+      for (size_t i = 0; i < size; i++) {
+        CHECK(receptionArray[i] == i);
+      }
+      // likewise, data should be deleted when accessor gets out of scope.
+    }
+    resultPair = SimplePool.getData(testStoreId);
+    REQUIRE(resultPair.first == (int)StorageManagerIF::DATA_DOES_NOT_EXIST);
+
+    result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+    {
+      resultPair = SimplePool.getData(testStoreId);
+      REQUIRE(resultPair.first == retval::CATCH_OK);
+      resultPair.second.release();
+      // now data should not be deleted anymore
+    }
+    resultPair = SimplePool.getData(testStoreId);
+    REQUIRE(resultPair.first == retval::CATCH_OK);
+    resultPair.second.getDataCopy(receptionArray.data(), 20);
+    for (size_t i = 0; i < size; i++) {
+      CHECK(receptionArray[i] == i);
+    }
+  }
+
+  SECTION("Simple tests modify functions") {
+    result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+    REQUIRE(result == retval::CATCH_OK);
+    {
+      StorageAccessor accessor(testStoreId);
+      result = SimplePool.modifyData(testStoreId, accessor);
+      REQUIRE(result == retval::CATCH_OK);
+      CHECK(accessor.getId() == testStoreId);
+      CHECK(accessor.size() == 10);
+      accessor.getDataCopy(receptionArray.data(), 20);
+      for (size_t i = 0; i < size; i++) {
+        CHECK(receptionArray[i] == i);
+      }
+      std::copy(accessor.data(), accessor.data() + accessor.size(), receptionArray.data());
+      for (size_t i = 0; i < size; i++) {
+        CHECK(receptionArray[i] == i);
+      }
+      // data should be deleted when accessor goes out of scope
+    }
+    auto resultPair = SimplePool.getData(testStoreId);
+    REQUIRE(resultPair.first == (int)StorageManagerIF::DATA_DOES_NOT_EXIST);
+
+    result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+    REQUIRE(result == retval::CATCH_OK);
+    {
+      auto resultPairLoc = SimplePool.modifyData(testStoreId);
+      REQUIRE(resultPairLoc.first == retval::CATCH_OK);
+      CHECK(resultPairLoc.second.getId() == testStoreId);
+      CHECK(resultPairLoc.second.size() == 10);
+      resultPairLoc.second.getDataCopy(receptionArray.data(), 20);
+      for (size_t i = 0; i < size; i++) {
+        CHECK(receptionArray[i] == i);
+      }
+      std::copy(resultPairLoc.second.data(),
+                resultPairLoc.second.data() + resultPairLoc.second.size(), receptionArray.data());
+      for (size_t i = 0; i < size; i++) {
+        CHECK(receptionArray[i] == i);
+      }
+      resultPairLoc.second.release();
+      // data should not be deleted when accessor goes out of scope
+    }
+    resultPair = SimplePool.getData(testStoreId);
+    REQUIRE(resultPair.first == retval::CATCH_OK);
+  }
+
+  SECTION("Write tests") {
+    result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+    REQUIRE(result == retval::CATCH_OK);
+    {
+      auto resultPair = SimplePool.modifyData(testStoreId);
+      REQUIRE(resultPair.first == retval::CATCH_OK);
+      testDataArray[9] = 42;
+      resultPair.second.write(testDataArray.data(), 10, 0);
+      // now data should not be deleted
+      resultPair.second.release();
+    }
+    auto resultConstPair = SimplePool.getData(testStoreId);
+    REQUIRE(resultConstPair.first == retval::CATCH_OK);
+
+    resultConstPair.second.getDataCopy(receptionArray.data(), 10);
+    for (size_t i = 0; i < size - 1; i++) {
+      CHECK(receptionArray[i] == i);
+    }
+    CHECK(receptionArray[9] == 42);
+
+    auto resultPair = SimplePool.modifyData(testStoreId);
+    REQUIRE(resultPair.first == retval::CATCH_OK);
+    result = resultPair.second.write(testDataArray.data(), 20, 0);
+    REQUIRE(result == retval::CATCH_FAILED);
+    result = resultPair.second.write(testDataArray.data(), 10, 5);
+    REQUIRE(result == retval::CATCH_FAILED);
+
+    std::memset(testDataArray.data(), 42, 5);
+    result = resultPair.second.write(testDataArray.data(), 5, 5);
+    REQUIRE(result == retval::CATCH_OK);
+    resultConstPair = SimplePool.getData(testStoreId);
+    resultPair.second.getDataCopy(receptionArray.data(), 20);
+    for (size_t i = 5; i < 10; i++) {
+      CHECK(receptionArray[i] == 42);
+    }
+  }
+
+  SECTION("Operators") {
+    result = SimplePool.addData(&testStoreId, testDataArray.data(), size);
+    REQUIRE(result == retval::CATCH_OK);
+    {
+      StorageAccessor accessor(testStoreId);
+      StorageAccessor accessor2(0);
+      accessor2 = std::move(accessor);
+      REQUIRE(accessor.data() == nullptr);
+      std::array<uint8_t, 6> data;
+      size_t size = 6;
+      result = accessor.write(data.data(), data.size());
+      REQUIRE(result == HasReturnvaluesIF::RETURN_FAILED);
+      result = SimplePool.modifyData(testStoreId, accessor2);
+      REQUIRE(result == HasReturnvaluesIF::RETURN_OK);
+      CHECK(accessor2.getId() == testStoreId);
+      CHECK(accessor2.size() == 10);
+
+      std::array<uint8_t, 10> newData;
+      // Expect data to be invalid so this must return RETURN_FAILED
+      result = accessor.getDataCopy(newData.data(), newData.size());
+      REQUIRE(result == HasReturnvaluesIF::RETURN_FAILED);
+      // Expect data to be too small
+      result = accessor2.getDataCopy(data.data(), data.size());
+      REQUIRE(result == HasReturnvaluesIF::RETURN_FAILED);
+    }
+  }
+}

unittests/storagemanager/TestPool.cpp

@@ -0,0 +1,290 @@
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/storagemanager/LocalPool.h>
+
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+#include <cstring>
+
+#include "CatchDefinitions.h"
+
+TEST_CASE("Local Pool Simple Tests [1 Pool]", "[TestPool]") {
+  LocalPool::LocalPoolConfig config = {{1, 10}};
+  LocalPool simplePool(0, config);
+  std::array<uint8_t, 20> testDataArray;
+  std::array<uint8_t, 20> receptionArray;
+  store_address_t testStoreId;
+  ReturnValue_t result = retval::CATCH_FAILED;
+  uint8_t* pointer = nullptr;
+  const uint8_t* constPointer = nullptr;
+
+  for (size_t i = 0; i < testDataArray.size(); i++) {
+    testDataArray[i] = i;
+  }
+  size_t size = 10;
+
+  SECTION("Basic tests") {
+    result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+    REQUIRE(result == retval::CATCH_OK);
+    result = simplePool.getData(testStoreId, &constPointer, &size);
+    REQUIRE(result == retval::CATCH_OK);
+    memcpy(receptionArray.data(), constPointer, size);
+    for (size_t i = 0; i < size; i++) {
+      CHECK(receptionArray[i] == i);
+    }
+    memset(receptionArray.data(), 0, size);
+    result = simplePool.modifyData(testStoreId, &pointer, &size);
+    memcpy(receptionArray.data(), pointer, size);
+    REQUIRE(result == retval::CATCH_OK);
+    for (size_t i = 0; i < size; i++) {
+      CHECK(receptionArray[i] == i);
+    }
+    result = simplePool.deleteData(testStoreId);
+    REQUIRE(result == retval::CATCH_OK);
+    result = simplePool.addData(&testStoreId, testDataArray.data(), 15);
+    CHECK(result == (int)StorageManagerIF::DATA_TOO_LARGE);
+  }
+
+  SECTION("Reservation Tests ") {
+    pointer = nullptr;
+    result = simplePool.getFreeElement(&testStoreId, size, &pointer);
+    REQUIRE(result == retval::CATCH_OK);
+    memcpy(pointer, testDataArray.data(), size);
+    constPointer = nullptr;
+    result = simplePool.getData(testStoreId, &constPointer, &size);
+
+    REQUIRE(result == retval::CATCH_OK);
+    memcpy(receptionArray.data(), constPointer, size);
+    for (size_t i = 0; i < size; i++) {
+      CHECK(receptionArray[i] == i);
+    }
+  }
+
+  SECTION("Add, delete, add, add when full") {
+    result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+    REQUIRE(result == retval::CATCH_OK);
+    result = simplePool.getData(testStoreId, &constPointer, &size);
+    REQUIRE(result == retval::CATCH_OK);
+    memcpy(receptionArray.data(), constPointer, size);
+    for (size_t i = 0; i < size; i++) {
+      CHECK(receptionArray[i] == i);
+    }
+
+    result = simplePool.deleteData(testStoreId);
+    REQUIRE(result == retval::CATCH_OK);
+
+    result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+    REQUIRE(result == retval::CATCH_OK);
+    result = simplePool.getData(testStoreId, &constPointer, &size);
+    REQUIRE(result == retval::CATCH_OK);
+    memcpy(receptionArray.data(), constPointer, size);
+    for (size_t i = 0; i < size; i++) {
+      CHECK(receptionArray[i] == i);
+    }
+
+    store_address_t newAddress;
+    result = simplePool.addData(&newAddress, testDataArray.data(), size);
+    REQUIRE(result == (int)StorageManagerIF::DATA_STORAGE_FULL);
+
+    // Packet Index to high intentionally
+    newAddress.packetIndex = 2;
+    pointer = testDataArray.data();
+    result = simplePool.modifyData(newAddress, &pointer, &size);
+    REQUIRE(result == (int)StorageManagerIF::ILLEGAL_STORAGE_ID);
+
+    result = simplePool.deleteData(newAddress);
+    REQUIRE(result == (int)StorageManagerIF::ILLEGAL_STORAGE_ID);
+
+    newAddress.packetIndex = 0;
+    newAddress.poolIndex = 2;
+    result = simplePool.deleteData(newAddress);
+    REQUIRE(result == (int)StorageManagerIF::ILLEGAL_STORAGE_ID);
+  }
+
+  SECTION("Initialize and clear store, delete with pointer") {
+    result = simplePool.initialize();
+    REQUIRE(result == retval::CATCH_OK);
+    result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+    REQUIRE(result == retval::CATCH_OK);
+    simplePool.clearStore();
+    result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+    REQUIRE(result == retval::CATCH_OK);
+    result = simplePool.modifyData(testStoreId, &pointer, &size);
+    REQUIRE(result == retval::CATCH_OK);
+    store_address_t newId;
+    result = simplePool.deleteData(pointer, size, &testStoreId);
+    REQUIRE(result == retval::CATCH_OK);
+    REQUIRE(testStoreId.raw != (uint32_t)StorageManagerIF::INVALID_ADDRESS);
+    result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+    REQUIRE(result == retval::CATCH_OK);
+  }
+}
+
+int runIdx = 0;
+
+TEST_CASE("Local Pool Extended Tests [3 Pools]", "[TestPool2]") {
+  LocalPool::LocalPoolConfig* config;
+  if (runIdx == 0) {
+    config = new LocalPool::LocalPoolConfig{{10, 5}, {5, 10}, {2, 20}};
+  } else {
+    // shufle the order, they should be sort implictely so that the
+    // order is ascending for the page sizes.
+    config = new LocalPool::LocalPoolConfig{{5, 10}, {2, 20}, {10, 5}};
+    size_t lastSize = 0;
+    for (const auto& pair : *config) {
+      CHECK(pair.second > lastSize);
+      lastSize = pair.second;
+    }
+  }
+  runIdx++;
+
+  LocalPool simplePool(0, *config);
+  std::array<uint8_t, 20> testDataArray;
+  std::array<uint8_t, 20> receptionArray;
+  store_address_t testStoreId;
+  ReturnValue_t result = retval::CATCH_FAILED;
+  for (size_t i = 0; i < testDataArray.size(); i++) {
+    testDataArray[i] = i;
+  }
+  size_t size = 0;
+
+  SECTION("Basic tests") {
+    size = 8;
+    result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+    REQUIRE(result == retval::CATCH_OK);
+    // Should be on second page of the pool now for 8 bytes
+    CHECK(testStoreId.poolIndex == 1);
+    CHECK(testStoreId.packetIndex == 0);
+
+    size = 15;
+    result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+    REQUIRE(result == retval::CATCH_OK);
+    // Should be on third page of the pool now for 15 bytes
+    CHECK(testStoreId.poolIndex == 2);
+    CHECK(testStoreId.packetIndex == 0);
+
+    result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+    REQUIRE(result == retval::CATCH_OK);
+    // Should be on third page of the pool now for 15 bytes
+    CHECK(testStoreId.poolIndex == 2);
+    CHECK(testStoreId.packetIndex == 1);
+
+    result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+    // Should be on third page of the pool now for 15 bytes
+    REQUIRE(result == (int)LocalPool::DATA_STORAGE_FULL);
+
+    size = 8;
+    result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+    REQUIRE(result == retval::CATCH_OK);
+    // Should still work
+    CHECK(testStoreId.poolIndex == 1);
+    CHECK(testStoreId.packetIndex == 1);
+
+    // fill the rest of the pool
+    for (uint8_t idx = 2; idx < 5; idx++) {
+      result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+      REQUIRE(result == retval::CATCH_OK);
+      CHECK(testStoreId.poolIndex == 1);
+      CHECK(testStoreId.packetIndex == idx);
+    }
+  }
+
+  SECTION("Fill Count and Clearing") {
+    // SECTION("Basic tests");
+    uint8_t bytesWritten = 0;
+    simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+    // fill count should be all zeros now.
+    CHECK(bytesWritten == 4);
+    CHECK(receptionArray[0] == 0);
+    CHECK(receptionArray[1] == 0);
+    CHECK(receptionArray[2] == 0);
+    CHECK(receptionArray[3] == 0);
+
+    // now fill the store completely.
+    size = 5;
+    for (uint8_t idx = 0; idx < 10; idx++) {
+      result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+      REQUIRE(result == retval::CATCH_OK);
+      CHECK(testStoreId.poolIndex == 0);
+      CHECK(testStoreId.packetIndex == idx);
+    }
+    size = 10;
+    for (uint8_t idx = 0; idx < 5; idx++) {
+      result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+      REQUIRE(result == retval::CATCH_OK);
+      CHECK(testStoreId.poolIndex == 1);
+      CHECK(testStoreId.packetIndex == idx);
+    }
+    size = 20;
+    for (uint8_t idx = 0; idx < 2; idx++) {
+      result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+      REQUIRE(result == retval::CATCH_OK);
+      CHECK(testStoreId.poolIndex == 2);
+      CHECK(testStoreId.packetIndex == idx);
+    }
+    bytesWritten = 0;
+    simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+    // fill count should be all 100 now.
+    CHECK(bytesWritten == 4);
+    CHECK(receptionArray[0] == 100);
+    CHECK(receptionArray[1] == 100);
+    CHECK(receptionArray[2] == 100);
+    CHECK(receptionArray[3] == 100);
+
+    // now clear the store
+    simplePool.clearStore();
+    bytesWritten = 0;
+    simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+    CHECK(bytesWritten == 4);
+    CHECK(receptionArray[0] == 0);
+    CHECK(receptionArray[1] == 0);
+    CHECK(receptionArray[2] == 0);
+    CHECK(receptionArray[3] == 0);
+
+    // now fill one page
+    size = 5;
+    for (uint8_t idx = 0; idx < 10; idx++) {
+      result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+      REQUIRE(result == retval::CATCH_OK);
+      CHECK(testStoreId.poolIndex == 0);
+      CHECK(testStoreId.packetIndex == idx);
+    }
+    bytesWritten = 0;
+    simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+    // First page full, median fill count is 33 %
+    CHECK(bytesWritten == 4);
+    CHECK(receptionArray[0] == 100);
+    CHECK(receptionArray[1] == 0);
+    CHECK(receptionArray[2] == 0);
+    CHECK(receptionArray[3] == 33);
+
+    // now fill second page
+    size = 10;
+    for (uint8_t idx = 0; idx < 5; idx++) {
+      result = simplePool.addData(&testStoreId, testDataArray.data(), size);
+      REQUIRE(result == retval::CATCH_OK);
+      CHECK(testStoreId.poolIndex == 1);
+      CHECK(testStoreId.packetIndex == idx);
+    }
+    bytesWritten = 0;
+    simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+    // First and second page full, median fill count is 66 %
+    CHECK(bytesWritten == 4);
+    CHECK(receptionArray[0] == 100);
+    CHECK(receptionArray[1] == 100);
+    CHECK(receptionArray[2] == 0);
+    CHECK(receptionArray[3] == 66);
+
+    // now clear first page
+    simplePool.clearSubPool(0);
+    bytesWritten = 0;
+    simplePool.getFillCount(receptionArray.data(), &bytesWritten);
+    // Second page full, median fill count is 33 %
+    CHECK(bytesWritten == 4);
+    CHECK(receptionArray[0] == 0);
+    CHECK(receptionArray[1] == 100);
+    CHECK(receptionArray[2] == 0);
+    CHECK(receptionArray[3] == 33);
+  }
+
+  delete (config);
+}

unittests/testVersion.cpp

@@ -0,0 +1,91 @@
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+#include "fsfw/serviceinterface.h"
+#include "fsfw/version.h"
+
+TEST_CASE("Version API Tests", "[TestVersionAPI]") {
+  // Check that major version is non-zero
+  REQUIRE(fsfw::FSFW_VERSION.major > 0);
+  uint32_t fsfwMajor = fsfw::FSFW_VERSION.major;
+  REQUIRE(fsfw::Version(255, 0, 0) > fsfw::FSFW_VERSION);
+  REQUIRE(fsfw::Version(255, 0, 0) >= fsfw::FSFW_VERSION);
+  REQUIRE(fsfw::Version(0, 0, 0) < fsfw::FSFW_VERSION);
+  REQUIRE(fsfw::Version(0, 0, 0) <= fsfw::FSFW_VERSION);
+  auto v1 = fsfw::Version(1, 1, 1);
+  auto v2 = fsfw::Version(1, 1, 1);
+  REQUIRE(v1 == v2);
+  REQUIRE(not(v1 < v2));
+  REQUIRE(not(v1 > v2));
+  REQUIRE(v1 <= v2);
+  REQUIRE(v1 >= v2);
+  v1.revision -= 1;
+  REQUIRE(v1 != v2);
+  REQUIRE(not(v1 == v2));
+  REQUIRE(not(v1 > v2));
+  REQUIRE(not(v1 >= v2));
+  REQUIRE(v1 < v2);
+  REQUIRE(v1 <= v2);
+  v1.revision += 1;
+  v1.minor -= 1;
+  REQUIRE(v1 != v2);
+  REQUIRE(v1 < v2);
+  REQUIRE(v1 <= v2);
+  REQUIRE(not(v1 == v2));
+  REQUIRE(not(v1 > v2));
+  REQUIRE(not(v1 >= v2));
+  v1.minor += 1;
+  v1.major -= 1;
+  REQUIRE(v1 != v2);
+  REQUIRE(v1 < v2);
+  REQUIRE(v1 <= v2);
+  REQUIRE(not(v1 == v2));
+  REQUIRE(not(v1 > v2));
+  REQUIRE(not(v1 >= v2));
+  v1.major += 1;
+  REQUIRE(v1 == v2);
+  REQUIRE(v1 <= v2);
+  REQUIRE(v1 >= v2);
+  REQUIRE(not(v1 != v2));
+  REQUIRE(not(v1 > v2));
+  REQUIRE(not(v1 < v2));
+  v1.major += 1;
+  v1.minor -= 1;
+  REQUIRE(v1 != v2);
+  REQUIRE(v1 > v2);
+  REQUIRE(v1 >= v2);
+  REQUIRE(not(v1 == v2));
+  REQUIRE(not(v1 < v2));
+  REQUIRE(not(v1 <= v2));
+  v1.major -= 1;
+  v1.minor += 2;
+  v1.revision -= 1;
+  REQUIRE(v1 != v2);
+  REQUIRE(v1 > v2);
+  REQUIRE(v1 >= v2);
+  REQUIRE(not(v1 == v2));
+  REQUIRE(not(v1 < v2));
+  REQUIRE(not(v1 <= v2));
+  v1.minor -= 1;
+  v1.revision += 2;
+  REQUIRE(v1 != v2);
+  REQUIRE(v1 > v2);
+  REQUIRE(v1 >= v2);
+  REQUIRE(not(v1 == v2));
+  REQUIRE(not(v1 < v2));
+  REQUIRE(not(v1 <= v2));
+  v1.revision -= 1;
+  REQUIRE(v1 == v2);
+  REQUIRE(v1 <= v2);
+  REQUIRE(v1 >= v2);
+  REQUIRE(not(v1 != v2));
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::info << "v" << fsfw::FSFW_VERSION << std::endl;
+#endif
+  char verString[10] = {};
+  fsfw::FSFW_VERSION.getVersion(verString, sizeof(verString));
+#if FSFW_DISABLE_PRINTOUT == 0
+  printf("v%s\n", verString);
+#endif
+}

unittests/testcfg/CMakeLists.txt

@@ -0,0 +1,23 @@
+target_sources(${FSFW_TEST_TGT} PRIVATE
+    ipc/MissionMessageTypes.cpp
+    pollingsequence/PollingSequenceFactory.cpp
+)
+
+# Add include paths for the executable
+target_include_directories(${FSFW_TEST_TGT} PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+# If a special translation file for object IDs exists, compile it.
+if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/objects/translateObjects.cpp")
+    target_sources(${FSFW_TEST_TGT} PRIVATE
+        objects/translateObjects.cpp
+    )
+endif()
+
+# If a special translation file for events exists, compile it.
+if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/objects/translateObjects.cpp")
+    target_sources(${FSFW_TEST_TGT} PRIVATE
+        events/translateEvents.cpp
+    )
+endif()

unittests/testcfg/FSFWConfig.h.in

@@ -0,0 +1,77 @@
+#ifndef CONFIG_FSFWCONFIG_H_
+#define CONFIG_FSFWCONFIG_H_
+
+#include <cstddef>
+#include <cstdint>
+
+//! Used to determine whether C++ ostreams are used which can increase
+//! the binary size significantly. If this is disabled,
+//! the C stdio functions can be used alternatively
+#define FSFW_CPP_OSTREAM_ENABLED        0
+
+//! More FSFW related printouts depending on level. Useful for development.
+#define FSFW_VERBOSE_LEVEL              0
+           
+//! Can be used to completely disable printouts, even the C stdio ones.
+#if FSFW_CPP_OSTREAM_ENABLED == 0 && FSFW_VERBOSE_LEVEL == 0
+    #define FSFW_DISABLE_PRINTOUT       1
+#else
+    #define FSFW_DISABLE_PRINTOUT       0
+#endif
+
+#define FSFW_USE_PUS_C_TELEMETRY        1
+#define FSFW_USE_PUS_C_TELECOMMANDS     1
+
+//! Can be used to disable the ANSI color sequences for C stdio.
+#define FSFW_COLORED_OUTPUT             1
+
+//! If FSFW_OBJ_EVENT_TRANSLATION is set to one,
+//! additional output which requires the translation files translateObjects
+//! and translateEvents (and their compiled source files)
+#define FSFW_OBJ_EVENT_TRANSLATION      0
+
+#if FSFW_OBJ_EVENT_TRANSLATION == 1
+//! Specify whether info events are printed too.
+#define FSFW_DEBUG_INFO                 1
+#include "objects/translateObjects.h"
+#include "events/translateEvents.h"
+#else
+#endif
+
+//! When using the newlib nano library, C99 support for stdio facilities
+//! will not be provided. This define should be set to 1 if this is the case.
+#define FSFW_NO_C99_IO                  1
+
+//! Specify whether a special mode store is used for Subsystem components.
+#define FSFW_USE_MODESTORE              0
+
+//! Defines if the real time scheduler for linux should be used.
+//! If set to 0, this will also disable priority settings for linux
+//! as most systems will not allow to set nice values without privileges
+//! For embedded linux system set this to 1.
+//! If set to 1 the binary needs "cap_sys_nice=eip" privileges to run
+#define FSFW_USE_REALTIME_FOR_LINUX     1
+
+namespace fsfwconfig {
+
+//! Default timestamp size. The default timestamp will be an seven byte CDC short timestamp.
+static constexpr uint8_t FSFW_MISSION_TIMESTAMP_SIZE = 7;
+
+//! Configure the allocated pool sizes for the event manager.
+static constexpr size_t FSFW_EVENTMGMR_MATCHTREE_NODES = 240;
+static constexpr size_t FSFW_EVENTMGMT_EVENTIDMATCHERS = 120;
+static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
+
+//! Defines the FIFO depth of each commanding service base which
+//! also determines how many commands a CSB service can handle in one cycle
+//! simultaneously. This will increase the required RAM for
+//! each CSB service !
+static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 6;
+
+static constexpr size_t FSFW_PRINT_BUFFER_SIZE = 124;
+
+static constexpr size_t FSFW_MAX_TM_PACKET_SIZE = 2048;
+
+}
+
+#endif /* CONFIG_FSFWCONFIG_H_ */

unittests/testcfg/OBSWConfig.h.in

@@ -0,0 +1,15 @@
+#ifndef CONFIG_TMTC_TMTCSIZE_H_
+#define CONFIG_TMTC_TMTCSIZE_H_
+
+#include <cstdint>
+#include <cstddef>
+
+#define OBSW_PRINT_MISSED_DEADLINES             0
+#define OBSW_VERBOSE_LEVEL                      0
+#define OBSW_ADD_TEST_CODE                      1
+
+namespace config {
+static constexpr uint32_t MAX_STORED_TELECOMMANDS = 2000;
+}
+
+#endif /* CONFIG_TMTC_TMTCSIZE_H_ */

unittests/testcfg/TestsConfig.h.in

@@ -0,0 +1,23 @@
+#ifndef FSFW_UNITTEST_CONFIG_TESTSCONFIG_H_
+#define FSFW_UNITTEST_CONFIG_TESTSCONFIG_H_
+
+#cmakedefine01 FSFW_CICD_BUILD
+
+#define FSFW_ADD_DEFAULT_FACTORY_FUNCTIONS 1
+
+#ifdef __cplusplus
+
+#include "objects/systemObjectList.h"
+#include "events/subsystemIdRanges.h"
+#include "returnvalues/classIds.h"
+
+namespace config {
+#endif
+
+/* Add mission configuration flags here */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FSFW_UNITTEST_CONFIG_TESTSCONFIG_H_ */

unittests/testcfg/devices/logicalAddresses.cpp

@@ -0,0 +1 @@
+#include "logicalAddresses.h"

unittests/testcfg/devices/logicalAddresses.h

@@ -0,0 +1,13 @@
+#ifndef CONFIG_DEVICES_LOGICALADDRESSES_H_
+#define CONFIG_DEVICES_LOGICALADDRESSES_H_
+
+#include <fsfw/devicehandlers/CookieIF.h>
+
+#include <cstdint>
+
+namespace addresses {
+/* Logical addresses have uint32_t datatype */
+enum logicalAddresses : address_t {};
+}  // namespace addresses
+
+#endif /* CONFIG_DEVICES_LOGICALADDRESSES_H_ */

unittests/testcfg/devices/powerSwitcherList.cpp

@@ -0,0 +1 @@
+#include "powerSwitcherList.h"

unittests/testcfg/devices/powerSwitcherList.h

@@ -0,0 +1,10 @@
+#ifndef CONFIG_DEVICES_POWERSWITCHERLIST_H_
+#define CONFIG_DEVICES_POWERSWITCHERLIST_H_
+
+namespace switches {
+/* Switches are uint8_t datatype and go from 0 to 255 */
+enum switcherList {};
+
+}  // namespace switches
+
+#endif /* CONFIG_DEVICES_POWERSWITCHERLIST_H_ */

unittests/testcfg/events/subsystemIdRanges.h

@@ -0,0 +1,20 @@
+#ifndef CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_
+#define CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_
+
+#include <cstdint>
+
+#include "fsfw/events/fwSubsystemIdRanges.h"
+
+/**
+ * @brief	Custom subsystem IDs can be added here
+ * @details
+ * Subsystem IDs are used to create unique events.
+ */
+namespace SUBSYSTEM_ID {
+enum : uint8_t {
+  SUBSYSTEM_ID_START = FW_SUBSYSTEM_ID_RANGE,
+  SUBSYSTEM_ID_END  // [EXPORT] : [END]
+};
+}
+
+#endif /* CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_ */

unittests/testcfg/ipc/MissionMessageTypes.cpp

@@ -0,0 +1,10 @@
+#include "MissionMessageTypes.h"
+
+#include <fsfw/ipc/CommandMessage.h>
+
+void messagetypes::clearMissionMessage(CommandMessage* message) {
+  switch (message->getMessageType()) {
+    default:
+      break;
+  }
+}

unittests/testcfg/ipc/MissionMessageTypes.h

@@ -0,0 +1,22 @@
+#ifndef CONFIG_IPC_MISSIONMESSAGETYPES_H_
+#define CONFIG_IPC_MISSIONMESSAGETYPES_H_
+
+#include <fsfw/ipc/FwMessageTypes.h>
+
+class CommandMessage;
+
+/**
+ * Custom command messages are specified here.
+ * Most messages needed to use FSFW are already located in
+ * <fsfw/ipc/FwMessageTypes.h>
+ * @param message Generic Command Message
+ */
+namespace messagetypes {
+enum MESSAGE_TYPE {
+  MISSION_MESSAGE_TYPE_START = FW_MESSAGES_COUNT,
+};
+
+void clearMissionMessage(CommandMessage* message);
+}  // namespace messagetypes
+
+#endif /* CONFIG_IPC_MISSIONMESSAGETYPES_H_ */

unittests/testcfg/objects/systemObjectList.h

@@ -0,0 +1,34 @@
+#ifndef HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
+#define HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
+
+#include <cstdint>
+
+#include "fsfw/objectmanager/frameworkObjects.h"
+
+// The objects will be instantiated in the ID order
+namespace objects {
+enum sourceObjects : uint32_t {
+  /* All addresses between start and end are reserved for the FSFW */
+  FSFW_CONFIG_RESERVED_START = PUS_SERVICE_1_VERIFICATION,
+  FSFW_CONFIG_RESERVED_END = TM_STORE,
+
+  UDP_BRIDGE = 15,
+  UDP_POLLING_TASK = 16,
+
+  TEST_ECHO_COM_IF = 20,
+  TEST_DEVICE = 21,
+
+  HK_RECEIVER_MOCK = 22,
+  TEST_LOCAL_POOL_OWNER_BASE = 25,
+
+  SHARED_SET_ID = 26,
+
+  DUMMY_POWER_SWITCHER = 28,
+
+  DEVICE_HANDLER_MOCK = 29,
+  COM_IF_MOCK = 30,
+  DEVICE_HANDLER_COMMANDER = 40,
+};
+}
+
+#endif /* BSP_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_ */

unittests/testcfg/pollingsequence/PollingSequenceFactory.cpp

@@ -0,0 +1,30 @@
+#include "PollingSequenceFactory.h"
+
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+#include <fsfw/tasks/FixedTimeslotTaskIF.h>
+
+#include "tests/TestsConfig.h"
+
+ReturnValue_t pst::pollingSequenceInitDefault(FixedTimeslotTaskIF *thisSequence) {
+  /* Length of a communication cycle */
+  uint32_t length = thisSequence->getPeriodMs();
+
+  /* Add polling sequence table here */
+  thisSequence->addSlot(objects::TEST_DEVICE, 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::TEST_DEVICE, 0.3, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::TEST_DEVICE, 0.45 * length, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::TEST_DEVICE, 0.6 * length, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::TEST_DEVICE, 0.8 * length, DeviceHandlerIF::GET_READ);
+
+  if (thisSequence->checkSequence() == HasReturnvaluesIF::RETURN_OK) {
+    return HasReturnvaluesIF::RETURN_OK;
+  } else {
+#if FSFW_CPP_OSTREAM_ENABLED
+    sif::error << "pst::pollingSequenceInitDefault: Sequence invalid!" << std::endl;
+#else
+    sif::printError("pst::pollingSequenceInitDefault: Sequence invalid!");
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+}

unittests/testcfg/pollingsequence/PollingSequenceFactory.h

@@ -0,0 +1,32 @@
+#ifndef POLLINGSEQUENCEFACTORY_H_
+#define POLLINGSEQUENCEFACTORY_H_
+
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+
+class FixedTimeslotTaskIF;
+
+/**
+ * All device handlers are scheduled by adding them into  Polling Sequence Tables (PST)
+ * to satisfy stricter timing requirements of device communication,
+ * A device handler has four different communication steps:
+ *   1. DeviceHandlerIF::SEND_WRITE -> Send write via interface
+ *   2. DeviceHandlerIF::GET_WRITE -> Get confirmation for write
+ *   3. DeviceHandlerIF::SEND_READ -> Send read request
+ *   4. DeviceHandlerIF::GET_READ -> Read from interface
+ * The PST specifies precisely when the respective ComIF functions are called
+ * during the communication cycle time.
+ * The task is created using the FixedTimeslotTaskIF,
+ * which utilises the underlying Operating System Abstraction Layer (OSAL)
+ *
+ * @param thisSequence FixedTimeslotTaskIF * object is passed inside the Factory class when creating
+ * the PST
+ * @return
+ */
+namespace pst {
+
+/* Default PST */
+ReturnValue_t pollingSequenceInitDefault(FixedTimeslotTaskIF *thisSequence);
+
+}  // namespace pst
+
+#endif /* POLLINGSEQUENCEINIT_H_ */

unittests/testcfg/returnvalues/classIds.h

@@ -0,0 +1,15 @@
+#ifndef CONFIG_RETURNVALUES_CLASSIDS_H_
+#define CONFIG_RETURNVALUES_CLASSIDS_H_
+
+#include "fsfw/returnvalues/FwClassIds.h"
+
+/**
+ * @brief   CLASS_ID defintions which are required for custom returnvalues.
+ */
+namespace CLASS_ID {
+enum {
+  MISSION_CLASS_ID_START = FW_CLASS_ID_COUNT,
+};
+}
+
+#endif /* CONFIG_RETURNVALUES_CLASSIDS_H_ */

unittests/testcfg/tmtc/apid.h

@@ -0,0 +1,17 @@
+#ifndef CONFIG_TMTC_APID_H_
+#define CONFIG_TMTC_APID_H_
+
+#include <cstdint>
+
+/**
+ * Application Process Definition: entity, uniquely identified by an
+ * application process ID (APID), capable of generating telemetry source
+ * packets and receiving telecommand packets.
+ *
+ * Chose APID(s) for mission and define it here.
+ */
+namespace apid {
+static const uint16_t DEFAULT_APID = 0x00;
+}
+
+#endif /* CONFIG_TMTC_APID_H_ */

unittests/testcfg/tmtc/pusIds.h

@@ -0,0 +1,25 @@
+#ifndef CONFIG_TMTC_PUSIDS_HPP_
+#define CONFIG_TMTC_PUSIDS_HPP_
+
+#include <cstdint>
+
+namespace pus {
+enum Ids : uint8_t {
+  PUS_SERVICE_1 = 1,
+  PUS_SERVICE_2 = 2,
+  PUS_SERVICE_3 = 3,
+  PUS_SERVICE_5 = 5,
+  PUS_SERVICE_6 = 6,
+  PUS_SERVICE_8 = 8,
+  PUS_SERVICE_9 = 9,
+  PUS_SERVICE_11 = 11,
+  PUS_SERVICE_17 = 17,
+  PUS_SERVICE_19 = 19,
+  PUS_SERVICE_20 = 20,
+  PUS_SERVICE_23 = 23,
+  PUS_SERVICE_200 = 200,
+  PUS_SERVICE_201 = 201,
+};
+};
+
+#endif /* CONFIG_TMTC_PUSIDS_HPP_ */