Merge remote-tracking branch 'origin/development' into mohr_introspection

unittests/CMakeLists.txt

@@ -0,0 +1,28 @@
+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(tcdistributor)
+add_subdirectory(action)
+add_subdirectory(power)
+add_subdirectory(util)
+add_subdirectory(container)
+add_subdirectory(osal)
+add_subdirectory(pus)
+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)
+add_subdirectory(tmtcservices)
+
+target_include_directories(${FSFW_TEST_TGT} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})

unittests/CatchDefinitions.cpp

@@ -0,0 +1,19 @@
+#include "CatchDefinitions.h"
+
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+
+#include "fsfw/FSFW.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,18 @@
+#ifndef FSFW_UNITTEST_CORE_CATCHDEFINITIONS_H_
+#define FSFW_UNITTEST_CORE_CATCHDEFINITIONS_H_
+
+#include <fsfw/ipc/messageQueueDefinitions.h>
+#include <fsfw/returnvalues/returnvalue.h>
+#include <fsfw/storagemanager/StorageManagerIF.h>
+
+#include "fsfw/FSFW.h"
+
+namespace tconst {
+static constexpr MessageQueueId_t testQueueId = 42;
+}
+
+namespace tglob {
+StorageManagerIF* getIpcStoreHandle();
+}
+
+#endif /* FSFW_UNITTEST_CORE_CATCHDEFINITIONS_H_ */

unittests/CatchFactory.cpp

@@ -0,0 +1,64 @@
+#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/tmtcservices/CommandingServiceBase.h>
+#include <fsfw/tmtcservices/PusServiceBase.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, 80);
+  new HealthTable(objects::HEALTH_TABLE);
+  new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
+
+  {
+    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);
+  }
+}
+
+// TODO: Our tests, and the code base in general should really not depend on some arbitrary function
+//       like this. Instead, this should be more like a general struct containing all important
+//       object IDs which are then explicitely passed in the object constructor
+void Factory::setStaticFrameworkObjectIds() {
+  PusServiceBase::PACKET_DESTINATION = objects::NO_OBJECT;
+
+  CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
+  CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
+
+  DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
+  DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
+
+  LocalDataPoolManager::defaultHkDestination = objects::NO_OBJECT;
+  DeviceHandlerFailureIsolation::powerConfirmationId = 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,27 @@
+/**
+ * @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();
+extern int customTeardown();
+
+int main(int argc, char* argv[]) {
+  customSetup();
+
+  // Catch internal function call
+  int result = Catch::Session().run(argc, argv);
+
+  // global clean-up
+  customTeardown();
+  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,37 @@
+#include "CatchDefinitions.h"
+#include "CatchFactory.h"
+#include "fsfw/FSFW.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;
+}
+
+int customTeardown() {
+  ObjectManager::clear();
+  return 0;
+}

unittests/action/CMakeLists.txt

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

unittests/action/TestActionHelper.cpp

@@ -0,0 +1,108 @@
+#include "TestActionHelper.h"
+
+#include <fsfw/action/ActionHelper.h>
+#include <fsfw/ipc/CommandMessage.h>
+
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "mocks/MessageQueueMock.h"
+
+TEST_CASE("Action Helper", "[ActionHelper]") {
+
+  MessageQueueMockBase testMqMock;
+  ActionHelperOwnerMockBase testDhMock(&testMqMock);
+  CommandMessage actionMessage;
+  ActionId_t testActionId = (ActionId_t) TestActions::TEST_ACTION;
+  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(testDhMock.getActionHelper()->initialize() == returnvalue::OK);
+
+  SECTION("Simple tests") {
+    ActionMessage::setCommand(&actionMessage, testActionId, paramAddress);
+    CHECK(not testDhMock.executeActionCalled);
+    REQUIRE(testDhMock.getActionHelper()->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);
+    testDhMock.getActionHelper()->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);
+    testDhMock.getBuffer(&ptr);
+    for (uint8_t i = 0; i < 3; i++) {
+      REQUIRE(ptr[i] == (i + 1));
+    }
+    testDhMock.clearBuffer();
+  }
+
+  SECTION("Handle failures") {
+    actionMessage.setCommand(1234);
+    REQUIRE(testDhMock.getActionHelper()->handleActionMessage(&actionMessage) ==
+            static_cast<uint32_t>(CommandMessage::UNKNOWN_COMMAND));
+    CHECK(not testMqMock.wasMessageSent());
+    uint16_t step = 5;
+    ReturnValue_t status = 0x1234;
+    testDhMock.getActionHelper()->step(step, testMqMock.getId(), testActionId, status);
+    step += 1;
+    CHECK(testMqMock.wasMessageSent());
+    CommandMessage testMessage;
+    REQUIRE(testMqMock.getNextSentMessage(testMessage) == returnvalue::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;
+    testDhMock.getActionHelper()->finish(false, testMqMock.getId(), testActionId, status);
+    CHECK(testMqMock.wasMessageSent());
+    CommandMessage testMessage;
+    REQUIRE(testMqMock.getNextSentMessage(testMessage) == returnvalue::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 = store_address_t::invalid();
+    std::array<uint8_t, 5> toLongData = {5, 4, 3, 2, 1};
+    REQUIRE(ipcStore->addData(&toLongParamAddress, toLongData.data(), 5) == returnvalue::OK);
+    ActionMessage::setCommand(&actionMessage, testActionId, toLongParamAddress);
+    CHECK(not testDhMock.executeActionCalled);
+    REQUIRE(testDhMock.getActionHelper()->handleActionMessage(&actionMessage) == returnvalue::OK);
+    REQUIRE(ipcStore->getData(toLongParamAddress).first ==
+            static_cast<uint32_t>(StorageManagerIF::DATA_DOES_NOT_EXIST));
+    CommandMessage testMessage;
+    REQUIRE(testMqMock.getNextSentMessage(testMessage) == returnvalue::OK);
+    REQUIRE(testMessage.getCommand() == static_cast<uint32_t>(ActionMessage::STEP_FAILED));
+    REQUIRE(ActionMessage::getReturnCode(&testMessage) == HasActionsIF::INVALID_PARAMETERS);
+    REQUIRE(ActionMessage::getStep(&testMessage) == 0);
+    REQUIRE(ActionMessage::getActionId(&testMessage) == testActionId);
+  }
+
+  SECTION("Missing IPC Data") {
+    ActionMessage::setCommand(&actionMessage, testActionId, store_address_t::invalid());
+    CHECK(not testDhMock.executeActionCalled);
+    REQUIRE(testDhMock.getActionHelper()->handleActionMessage(&actionMessage) == returnvalue::OK);
+    CommandMessage testMessage;
+    REQUIRE(testMqMock.getNextSentMessage(testMessage) == returnvalue::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,75 @@
+#ifndef UNITTEST_HOSTED_TESTACTIONHELPER_H_
+#define UNITTEST_HOSTED_TESTACTIONHELPER_H_
+
+#include <fsfw/action/HasActionsIF.h>
+#include <fsfw/action/Parameter.h>
+#include <fsfw/action/TemplateAction.h>
+#include <fsfw/introspection/Enum.h>
+#include <fsfw/ipc/MessageQueueIF.h>
+
+#include <cstring>
+
+#include "CatchDefinitions.h"
+
+class ActionHelperOwnerMockBase;
+
+FSFW_ENUM(TestActions, ActionId_t, ((TEST_ACTION, "Test Action")))
+
+class TestAction : public TemplateAction < ActionHelperOwnerMockBase, TestAction, TestActions> {
+ public:
+  TestAction(ActionHelperOwnerMockBase* owner) : TemplateAction(owner, TestActions::TEST_ACTION) {}
+  Parameter<uint8_t> p1 = Parameter<uint8_t>::createParameter(this, "An uint8_t");
+  Parameter<uint8_t> p2 = Parameter<uint8_t>::createParameter(this, "An uint8_t");
+  Parameter<uint8_t> p3 = Parameter<uint8_t>::createParameter(this, "An uint8_t");
+};
+
+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;
+
+  ActionHelperOwnerMockBase(MessageQueueIF* useThisQueue) : actionHelper(this, useThisQueue) {}
+
+  MessageQueueId_t getCommandQueue() const override { return tconst::testQueueId; }
+
+  ActionHelper* getActionHelper() override { return &actionHelper; }
+
+  ReturnValue_t executeAction(Action* action) override {
+    executeActionCalled = true;
+    if (size > MAX_SIZE) {
+      return 0xAFFE;
+    }
+    this->size = size;
+    return action->handle();
+  }
+
+  ReturnValue_t handleAction(TestAction *action){
+    executeActionCalled = true;
+    buffer[0] = action->p1;
+    buffer[1] = action->p2;
+    buffer[2] = action->p3;
+    return returnvalue::OK;
+  }
+
+  void clearBuffer() {
+    this->size = 0;
+    for (size_t i = 0; i < MAX_SIZE; i++) {
+      buffer[i] = 0;
+    }
+  }
+
+  void getBuffer(const uint8_t** ptr) {
+    if (ptr != nullptr) {
+      *ptr = buffer;
+    }
+  }
+
+ private:
+  ActionHelper actionHelper;
+  TestAction testAction = TestAction(this);
+};
+
+#endif /* UNITTEST_TESTFW_NEWTESTS_TESTACTIONHELPER_H_ */

unittests/cfdp/CMakeLists.txt

@@ -0,0 +1,5 @@
+target_sources(${FSFW_TEST_TGT} PRIVATE testCfdp.cpp testOtherTlvs.cpp
+                                        testTlv.cpp testLvs.cpp)
+
+add_subdirectory(handler)
+add_subdirectory(pdu)

unittests/cfdp/handler/CMakeLists.txt

@@ -0,0 +1,2 @@
+target_sources(${FSFW_TEST_TGT} PRIVATE testDistributor.cpp
+                                        testFaultHandler.cpp)

unittests/cfdp/handler/testDistributor.cpp

@@ -0,0 +1,99 @@
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/cfdp/CfdpDistributor.h"
+#include "fsfw/cfdp/pdu/MetadataPduCreator.h"
+#include "fsfw/cfdp/tlv/StringLv.h"
+#include "fsfw/storagemanager/LocalPool.h"
+#include "fsfw/tcdistribution/definitions.h"
+#include "mocks/AcceptsTcMock.h"
+#include "mocks/MessageQueueMock.h"
+#include "mocks/StorageManagerMock.h"
+
+TEST_CASE("CFDP Distributor", "[cfdp][distributor]") {
+  LocalPool::LocalPoolConfig cfg = {{5, 32}, {2, 64}};
+  StorageManagerMock pool(objects::NO_OBJECT, cfg);
+  auto queue = MessageQueueMock(1);
+  CfdpDistribCfg distribCfg(1, pool, &queue);
+  auto distributor = CfdpDistributor(distribCfg);
+  auto obswEntityId = cfdp::EntityId(UnsignedByteField<uint16_t>(2));
+  auto groundEntityId = cfdp::EntityId(UnsignedByteField<uint16_t>(1));
+  MessageQueueId_t receiverQueueId = 3;
+  auto tcAcceptor = AcceptsTcMock("CFDP Receiver", 0, receiverQueueId);
+
+  // Set up Metadata PDU for generate test data.
+  cfdp::FileSize fileSize(12);
+  const cfdp::EntityId& sourceId(groundEntityId);
+  const cfdp::EntityId& destId(obswEntityId);
+  cfdp::TransactionSeqNum seqNum(UnsignedByteField<uint16_t>(12));
+  auto pduConf = PduConfig(sourceId, destId, cfdp::TransmissionMode::UNACKNOWLEDGED, seqNum);
+  std::string sourceFileString = "hello.txt";
+  cfdp::StringLv sourceFileName(sourceFileString);
+  std::string destFileString = "hello2.txt";
+  cfdp::StringLv destFileName(destFileString);
+  MetadataInfo metadataInfo(false, cfdp::ChecksumType::CRC_32, fileSize, sourceFileName,
+                            destFileName);
+  MetadataPduCreator creator(pduConf, metadataInfo);
+  uint8_t* dataPtr = nullptr;
+
+  SECTION("State") {
+    CHECK(distributor.initialize() == returnvalue::OK);
+    CHECK(std::strcmp(distributor.getName(), "CFDP Distributor") == 0);
+    CHECK(distributor.getIdentifier() == 0);
+    CHECK(distributor.getRequestQueue() == queue.getId());
+  }
+
+  SECTION("Packet Forwarding") {
+    CHECK(distributor.initialize() == returnvalue::OK);
+    CHECK(distributor.registerTcDestination(obswEntityId, tcAcceptor) == returnvalue::OK);
+    size_t serLen = 0;
+    store_address_t storeId;
+    CHECK(pool.LocalPool::getFreeElement(&storeId, creator.getSerializedSize(), &dataPtr) ==
+          returnvalue::OK);
+    REQUIRE(creator.SerializeIF::serializeBe(dataPtr, serLen, creator.getSerializedSize()) ==
+            returnvalue::OK);
+    TmTcMessage msg(storeId);
+    queue.addReceivedMessage(msg);
+    CHECK(distributor.performOperation(0) == returnvalue::OK);
+    CHECK(queue.wasMessageSent());
+    CHECK(queue.numberOfSentMessages() == 1);
+    // The packet is forwarded, with no need to delete the data
+    CHECK(pool.hasDataAtId(storeId));
+    TmTcMessage sentMsg;
+    CHECK(queue.getNextSentMessage(receiverQueueId, sentMsg) == returnvalue::OK);
+    CHECK(sentMsg.getStorageId() == storeId);
+  }
+
+  SECTION("No Destination found") {
+    CHECK(distributor.initialize() == returnvalue::OK);
+    size_t serLen = 0;
+    store_address_t storeId;
+    CHECK(pool.LocalPool::getFreeElement(&storeId, creator.getSerializedSize(), &dataPtr) ==
+          returnvalue::OK);
+    REQUIRE(creator.SerializeIF::serializeBe(dataPtr, serLen, creator.getSerializedSize()) ==
+            returnvalue::OK);
+    TmTcMessage msg(storeId);
+    queue.addReceivedMessage(msg);
+    CHECK(distributor.performOperation(0) == tmtcdistrib::NO_DESTINATION_FOUND);
+  }
+
+  SECTION("Getting data fails") {
+    pool.nextModifyDataCallFails.first = true;
+    pool.nextModifyDataCallFails.second = StorageManagerIF::DATA_DOES_NOT_EXIST;
+    size_t serLen = 0;
+    store_address_t storeId;
+    CHECK(distributor.registerTcDestination(obswEntityId, tcAcceptor) == returnvalue::OK);
+    CHECK(pool.LocalPool::getFreeElement(&storeId, creator.getSerializedSize(), &dataPtr) ==
+          returnvalue::OK);
+    REQUIRE(creator.SerializeIF::serializeBe(dataPtr, serLen, creator.getSerializedSize()) ==
+            returnvalue::OK);
+    TmTcMessage msg(storeId);
+    queue.addReceivedMessage(msg);
+    CHECK(distributor.performOperation(0) == StorageManagerIF::DATA_DOES_NOT_EXIST);
+  }
+
+  SECTION("Duplicate registration") {
+    CHECK(distributor.initialize() == returnvalue::OK);
+    CHECK(distributor.registerTcDestination(obswEntityId, tcAcceptor) == returnvalue::OK);
+    CHECK(distributor.registerTcDestination(obswEntityId, tcAcceptor) == returnvalue::FAILED);
+  }
+}

unittests/cfdp/handler/testFaultHandler.cpp

@@ -0,0 +1,89 @@
+#include <catch2/catch_test_macros.hpp>
+
+#include "mocks/cfdp/FaultHandlerMock.h"
+
+TEST_CASE("CFDP Fault Handler", "[cfdp]") {
+  using namespace cfdp;
+  auto fhMock = FaultHandlerMock();
+  cfdp::FaultHandlerCode fhCode;
+  cfdp::TransactionId id;
+
+  SECTION("State") {
+    // Verify initial condition
+    CHECK(fhMock.getFaultHandler(ConditionCode::UNSUPPORTED_CHECKSUM_TYPE, fhCode));
+    CHECK(fhCode == FaultHandlerCode::IGNORE_ERROR);
+    CHECK(fhMock.getFaultHandler(ConditionCode::POSITIVE_ACK_LIMIT_REACHED, fhCode));
+    CHECK(fhCode == FaultHandlerCode::IGNORE_ERROR);
+    CHECK(fhMock.getFaultHandler(ConditionCode::KEEP_ALIVE_LIMIT_REACHED, fhCode));
+    CHECK(fhCode == FaultHandlerCode::IGNORE_ERROR);
+    CHECK(fhMock.getFaultHandler(ConditionCode::INVALID_TRANSMISSION_MODE, fhCode));
+    CHECK(fhCode == FaultHandlerCode::IGNORE_ERROR);
+    CHECK(fhMock.getFaultHandler(ConditionCode::FILESTORE_REJECTION, fhCode));
+    CHECK(fhCode == FaultHandlerCode::IGNORE_ERROR);
+    CHECK(fhMock.getFaultHandler(ConditionCode::FILE_CHECKSUM_FAILURE, fhCode));
+    CHECK(fhCode == FaultHandlerCode::IGNORE_ERROR);
+    CHECK(fhMock.getFaultHandler(ConditionCode::FILE_SIZE_ERROR, fhCode));
+    CHECK(fhCode == FaultHandlerCode::IGNORE_ERROR);
+    CHECK(fhMock.getFaultHandler(ConditionCode::NAK_LIMIT_REACHED, fhCode));
+    CHECK(fhCode == FaultHandlerCode::IGNORE_ERROR);
+    CHECK(fhMock.getFaultHandler(ConditionCode::INACTIVITY_DETECTED, fhCode));
+    CHECK(fhCode == FaultHandlerCode::IGNORE_ERROR);
+    CHECK(fhMock.getFaultHandler(ConditionCode::CHECK_LIMIT_REACHED, fhCode));
+    CHECK(fhCode == FaultHandlerCode::IGNORE_ERROR);
+  }
+
+  SECTION("Call Handler, Ignore Fault") {
+    auto& info = fhMock.getFhInfo(FaultHandlerCode::IGNORE_ERROR);
+    CHECK(fhMock.reportFault(id, ConditionCode::CHECK_LIMIT_REACHED));
+    CHECK(info.callCount == 1);
+    CHECK(info.condCodes.back() == ConditionCode::CHECK_LIMIT_REACHED);
+    fhMock.reportFault(id, ConditionCode::FILE_CHECKSUM_FAILURE);
+    CHECK(info.callCount == 2);
+    CHECK(info.condCodes.back() == ConditionCode::FILE_CHECKSUM_FAILURE);
+  }
+
+  SECTION("Invalid Reported Code") { CHECK(not fhMock.reportFault(id, ConditionCode::NO_ERROR)); }
+
+  SECTION("Invalid FH code") {
+    CHECK(not fhMock.setFaultHandler(ConditionCode::KEEP_ALIVE_LIMIT_REACHED,
+                                     FaultHandlerCode::RESERVED));
+    CHECK(fhMock.getFaultHandler(ConditionCode::KEEP_ALIVE_LIMIT_REACHED, fhCode));
+    CHECK(fhCode == FaultHandlerCode::IGNORE_ERROR);
+    CHECK(not fhMock.setFaultHandler(ConditionCode::NO_ERROR, FaultHandlerCode::IGNORE_ERROR));
+    CHECK(not fhMock.getFaultHandler(ConditionCode::NO_ERROR, fhCode));
+  }
+
+  SECTION("Set Other Fault Handler") {
+    CHECK(fhMock.setFaultHandler(ConditionCode::FILE_CHECKSUM_FAILURE,
+                                 FaultHandlerCode::NOTICE_OF_CANCELLATION));
+    CHECK(fhMock.setFaultHandler(ConditionCode::INACTIVITY_DETECTED,
+                                 FaultHandlerCode::ABANDON_TRANSACTION));
+    CHECK(fhMock.setFaultHandler(ConditionCode::KEEP_ALIVE_LIMIT_REACHED,
+                                 FaultHandlerCode::NOTICE_OF_SUSPENSION));
+    auto& ignoreInfo = fhMock.getFhInfo(FaultHandlerCode::IGNORE_ERROR);
+    auto& cancellationInfo = fhMock.getFhInfo(FaultHandlerCode::NOTICE_OF_CANCELLATION);
+    auto& suspensionInfo = fhMock.getFhInfo(FaultHandlerCode::NOTICE_OF_SUSPENSION);
+    auto& abandonInfo = fhMock.getFhInfo(FaultHandlerCode::ABANDON_TRANSACTION);
+
+    CHECK(fhMock.reportFault(id, ConditionCode::FILE_CHECKSUM_FAILURE));
+    CHECK(cancellationInfo.callCount == 1);
+    CHECK(cancellationInfo.condCodes.back() == ConditionCode::FILE_CHECKSUM_FAILURE);
+    CHECK(ignoreInfo.callCount == 0);
+    CHECK(suspensionInfo.callCount == 0);
+    CHECK(abandonInfo.callCount == 0);
+
+    CHECK(fhMock.reportFault(id, ConditionCode::INACTIVITY_DETECTED));
+    CHECK(cancellationInfo.callCount == 1);
+    CHECK(ignoreInfo.callCount == 0);
+    CHECK(suspensionInfo.callCount == 0);
+    CHECK(abandonInfo.callCount == 1);
+    CHECK(abandonInfo.condCodes.back() == ConditionCode::INACTIVITY_DETECTED);
+
+    CHECK(fhMock.reportFault(id, ConditionCode::KEEP_ALIVE_LIMIT_REACHED));
+    CHECK(cancellationInfo.callCount == 1);
+    CHECK(ignoreInfo.callCount == 0);
+    CHECK(suspensionInfo.callCount == 1);
+    CHECK(suspensionInfo.condCodes.back() == ConditionCode::KEEP_ALIVE_LIMIT_REACHED);
+    CHECK(abandonInfo.callCount == 1);
+  }
+}

unittests/cfdp/pdu/CMakeLists.txt

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

unittests/cfdp/pdu/testAckPdu.cpp

@@ -0,0 +1,100 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/cfdp/pdu/AckPduCreator.h"
+#include "fsfw/cfdp/pdu/AckPduReader.h"
+#include "fsfw/globalfunctions/arrayprinter.h"
+
+TEST_CASE("ACK PDU", "[cfdp][pdu]") {
+  using namespace cfdp;
+  ReturnValue_t result;
+  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(sourceId, destId, TransmissionMode::ACKNOWLEDGED, seqNum);
+  AckInfo ackInfo(FileDirective::EOF_DIRECTIVE, ConditionCode::NO_ERROR,
+                  AckTransactionStatus::ACTIVE);
+  auto ackSerializer = AckPduCreator(ackInfo, pduConf);
+  result = ackSerializer.serialize(&bufptr, &sz, maxsz, SerializeIF::Endianness::NETWORK);
+  REQUIRE(result == returnvalue::OK);
+
+  SECTION("Serialize") {
+    REQUIRE(buf[sz - 3] == cfdp::FileDirective::ACK);
+    REQUIRE((buf[sz - 2] >> 4) == FileDirective::EOF_DIRECTIVE);
+    REQUIRE((buf[sz - 2] & 0x0f) == 0);
+    REQUIRE(buf[sz - 1] == AckTransactionStatus::ACTIVE);
+    ackInfo.setAckedDirective(FileDirective::FINISH);
+    ackInfo.setAckedConditionCode(ConditionCode::FILESTORE_REJECTION);
+    ackInfo.setTransactionStatus(AckTransactionStatus::TERMINATED);
+    auto ackSerializer2 = AckPduCreator(ackInfo, pduConf);
+    bufptr = buf.data();
+    sz = 0;
+    result = ackSerializer2.serialize(&bufptr, &sz, maxsz, SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(buf[sz - 3] == cfdp::FileDirective::ACK);
+    REQUIRE((buf[sz - 2] >> 4) == FileDirective::FINISH);
+    REQUIRE((buf[sz - 2] & 0x0f) == 0b0001);
+    REQUIRE((buf[sz - 1] >> 4) == ConditionCode::FILESTORE_REJECTION);
+    REQUIRE((buf[sz - 1] & 0b11) == AckTransactionStatus::TERMINATED);
+
+    bufptr = buf.data();
+    sz = 0;
+    ackInfo.setAckedDirective(FileDirective::KEEP_ALIVE);
+    auto ackSerializer3 = AckPduCreator(ackInfo, pduConf);
+    result = ackSerializer3.serialize(&bufptr, &sz, maxsz, SerializeIF::Endianness::NETWORK);
+    // Invalid file directive
+    REQUIRE(result != returnvalue::OK);
+
+    ackInfo.setAckedDirective(FileDirective::FINISH);
+    // buffer too small
+    result = ackSerializer.serialize(&bufptr, &sz, 8, SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == SerializeIF::BUFFER_TOO_SHORT);
+  }
+
+  SECTION("Deserialize") {
+    AckInfo ackInfo2;
+    auto reader = AckPduReader(buf.data(), sz, ackInfo2);
+    result = reader.parseData();
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(ackInfo2.getAckedDirective() == FileDirective::EOF_DIRECTIVE);
+    REQUIRE(ackInfo2.getAckedConditionCode() == ConditionCode::NO_ERROR);
+    REQUIRE(ackInfo2.getDirectiveSubtypeCode() == 0);
+    REQUIRE(ackInfo2.getTransactionStatus() == AckTransactionStatus::ACTIVE);
+
+    AckInfo newInfo = AckInfo(FileDirective::FINISH, ConditionCode::FILESTORE_REJECTION,
+                              AckTransactionStatus::TERMINATED);
+    auto ackSerializer2 = AckPduCreator(newInfo, pduConf);
+    bufptr = buf.data();
+    sz = 0;
+    result = ackSerializer2.serialize(&bufptr, &sz, maxsz, SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+
+    auto reader2 = AckPduReader(buf.data(), sz, ackInfo2);
+    result = reader2.parseData();
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(ackInfo2.getAckedDirective() == FileDirective::FINISH);
+    REQUIRE(ackInfo2.getAckedConditionCode() == ConditionCode::FILESTORE_REJECTION);
+    REQUIRE(ackInfo2.getDirectiveSubtypeCode() == 0b0001);
+    REQUIRE(ackInfo2.getTransactionStatus() == AckTransactionStatus::TERMINATED);
+
+    uint8_t prevVal = buf[sz - 2];
+    buf[sz - 2] = FileDirective::INVALID_DIRECTIVE << 4;
+    result = reader2.parseData();
+    REQUIRE(result == cfdp::INVALID_ACK_DIRECTIVE_FIELDS);
+    buf[sz - 2] = FileDirective::FINISH << 4 | 0b1111;
+    result = reader2.parseData();
+    REQUIRE(result == cfdp::INVALID_ACK_DIRECTIVE_FIELDS);
+    buf[sz - 2] = prevVal;
+    buf[sz - 3] = cfdp::FileDirective::INVALID_DIRECTIVE;
+    result = reader2.parseData();
+    REQUIRE(result == cfdp::INVALID_DIRECTIVE_FIELD);
+    buf[sz - 3] = cfdp::FileDirective::ACK;
+    auto maxSizeTooSmall = AckPduReader(buf.data(), sz - 2, ackInfo2);
+    result = maxSizeTooSmall.parseData();
+    REQUIRE(result == SerializeIF::STREAM_TOO_SHORT);
+  }
+}

unittests/cfdp/pdu/testCfdpHeader.cpp

@@ -0,0 +1,327 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/cfdp/pdu/FinishedInfo.h"
+#include "fsfw/cfdp/pdu/FinishedPduCreator.h"
+#include "fsfw/cfdp/pdu/HeaderCreator.h"
+#include "fsfw/cfdp/pdu/PduHeaderReader.h"
+#include "fsfw/returnvalues/returnvalue.h"
+
+using namespace returnvalue;
+
+TEST_CASE("CFDP Header", "[cfdp]") {
+  using namespace cfdp;
+  std::array<uint8_t, 32> serBuf{};
+  ReturnValue_t result;
+  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(sourceId, destId, cfdp::TransmissionMode::ACKNOWLEDGED, seqNum, false);
+  uint8_t* serTarget = serBuf.data();
+  const uint8_t* deserTarget = serTarget;
+  size_t serSize = 0;
+  auto creator = HeaderCreator(pduConf, cfdp::PduType::FILE_DIRECTIVE, 0);
+
+  SECTION("Header State") {
+    REQUIRE(seqNum.getSerializedSize() == 1);
+    REQUIRE(creator.getPduDataFieldLen() == 0);
+    REQUIRE(creator.getSerializedSize() == 7);
+    REQUIRE(creator.getWholePduSize() == 7);
+    REQUIRE(creator.getCrcFlag() == false);
+    REQUIRE(creator.getDirection() == cfdp::Direction::TOWARDS_RECEIVER);
+    REQUIRE(creator.getLargeFileFlag() == false);
+    REQUIRE(creator.getLenEntityIds() == 1);
+    REQUIRE(creator.getLenSeqNum() == 1);
+    REQUIRE(creator.getPduType() == cfdp::PduType::FILE_DIRECTIVE);
+    REQUIRE(creator.getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::NOT_PRESENT);
+    REQUIRE(creator.getSegmentationControl() == false);
+    REQUIRE(creator.getTransmissionMode() == cfdp::TransmissionMode::ACKNOWLEDGED);
+    cfdp::TransactionSeqNum seqNumLocal;
+    creator.getTransactionSeqNum(seqNumLocal);
+    REQUIRE(seqNumLocal.getWidth() == cfdp::WidthInBytes::ONE_BYTE);
+    REQUIRE(seqNumLocal.getValue() == 2);
+    cfdp::EntityId sourceDestId;
+    creator.getSourceId(sourceDestId);
+    REQUIRE(sourceDestId.getWidth() == cfdp::WidthInBytes::ONE_BYTE);
+    REQUIRE(sourceDestId.getValue() == 0);
+    creator.getDestId(sourceDestId);
+    REQUIRE(sourceDestId.getWidth() == cfdp::WidthInBytes::ONE_BYTE);
+    REQUIRE(sourceDestId.getValue() == 1);
+  }
+
+  SECTION("Deserialization fails") {
+    const uint8_t** dummyPtr = nullptr;
+    REQUIRE(creator.deSerialize(dummyPtr, &serSize, SerializeIF::Endianness::NETWORK) ==
+            returnvalue::FAILED);
+  }
+
+  SECTION("Serialization fails") {
+    REQUIRE(creator.serialize(nullptr, &serSize, serBuf.size(), SerializeIF::Endianness::NETWORK) ==
+            returnvalue::FAILED);
+  }
+
+  SECTION("Buffer Too Short") {
+    for (uint8_t idx = 0; idx < 7; idx++) {
+      result = creator.serialize(&serTarget, &serSize, idx, SerializeIF::Endianness::BIG);
+      REQUIRE(result == static_cast<int>(SerializeIF::BUFFER_TOO_SHORT));
+    }
+  }
+
+  SECTION("Set Data Field Len") {
+    // Set PDU data field len
+    creator.setPduDataFieldLen(0x0ff0);
+    REQUIRE(creator.getPduDataFieldLen() == 0x0ff0);
+    REQUIRE(creator.getSerializedSize() == 7);
+    REQUIRE(creator.getWholePduSize() == 7 + 0x0ff0);
+    serTarget = serBuf.data();
+    serSize = 0;
+    result = creator.serialize(&serTarget, &serSize, serBuf.size(), SerializeIF::Endianness::BIG);
+    REQUIRE(serBuf[1] == 0x0f);
+    REQUIRE(serBuf[2] == 0xf0);
+  }
+
+  SECTION("Serialize with Fields Flipped") {
+    pduConf.crcFlag = true;
+    pduConf.largeFile = true;
+    pduConf.direction = cfdp::Direction::TOWARDS_SENDER;
+    pduConf.mode = cfdp::TransmissionMode::UNACKNOWLEDGED;
+    creator.setSegmentationControl(cfdp::SegmentationControl::RECORD_BOUNDARIES_PRESERVATION);
+    creator.setPduType(cfdp::PduType::FILE_DATA);
+    creator.setSegmentMetadataFlag(cfdp::SegmentMetadataFlag::PRESENT);
+    serTarget = serBuf.data();
+    serSize = 0;
+
+    SECTION("Regular") {
+      // Everything except version bit flipped to one now
+      REQUIRE(creator.serialize(&serTarget, &serSize, serBuf.size(),
+                                SerializeIF::Endianness::BIG) == returnvalue::OK);
+      CHECK(serBuf[0] == 0x3f);
+      CHECK(serBuf[3] == 0x99);
+      REQUIRE(creator.getCrcFlag() == true);
+      REQUIRE(creator.getDirection() == cfdp::Direction::TOWARDS_SENDER);
+      REQUIRE(creator.getLargeFileFlag() == true);
+      REQUIRE(creator.getLenEntityIds() == 1);
+      REQUIRE(creator.getLenSeqNum() == 1);
+      REQUIRE(creator.getPduType() == cfdp::PduType::FILE_DATA);
+      REQUIRE(creator.getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::PRESENT);
+      REQUIRE(creator.getTransmissionMode() == cfdp::TransmissionMode::UNACKNOWLEDGED);
+      REQUIRE(creator.getSegmentationControl() == true);
+    }
+
+    SECTION("Other variable sized fields") {
+      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(creator.getSerializedSize() == 14);
+      REQUIRE(creator.serialize(&serTarget, &serSize, serBuf.size(),
+                                SerializeIF::Endianness::BIG) == returnvalue::OK);
+      REQUIRE(creator.getCrcFlag() == true);
+      REQUIRE(creator.getDirection() == cfdp::Direction::TOWARDS_SENDER);
+      REQUIRE(creator.getLargeFileFlag() == true);
+      REQUIRE(creator.getLenEntityIds() == 4);
+      REQUIRE(creator.getLenSeqNum() == 2);
+      REQUIRE(creator.getPduType() == cfdp::PduType::FILE_DATA);
+      REQUIRE(creator.getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::PRESENT);
+      REQUIRE(creator.getTransmissionMode() == cfdp::TransmissionMode::UNACKNOWLEDGED);
+      REQUIRE(creator.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);
+      CHECK(deSerSize == 4);
+      CHECK(entityId == 0xff00ff00);
+      uint16_t seqNumRaw = 0;
+      SerializeAdapter::deSerialize(&seqNumRaw, serBuf.data() + 8, &deSerSize,
+                                    SerializeIF::Endianness::NETWORK);
+      CHECK(deSerSize == 2);
+      CHECK(seqNumRaw == 0x0fff);
+      SerializeAdapter::deSerialize(&entityId, serBuf.data() + 10, &deSerSize,
+                                    SerializeIF::Endianness::NETWORK);
+      CHECK(deSerSize == 4);
+      CHECK(entityId == 0x00ff00ff);
+    }
+
+    SECTION("Buffer Too Short") {
+      pduConf.seqNum.setValue(cfdp::WidthInBytes::TWO_BYTES, 0x0fff);
+      pduConf.sourceId.setValue(cfdp::WidthInBytes::FOUR_BYTES, 0xff00ff00);
+      pduConf.destId.setValue(cfdp::WidthInBytes::FOUR_BYTES, 0x00ff00ff);
+      for (uint8_t idx = 0; idx < 14; idx++) {
+        REQUIRE(creator.serialize(&serTarget, &serSize, idx, SerializeIF::Endianness::BIG) ==
+                SerializeIF::BUFFER_TOO_SHORT);
+      }
+    }
+  }
+
+  SECTION("Invalid Variable Sized Fields") {
+    result = pduConf.sourceId.setValue(cfdp::WidthInBytes::ONE_BYTE, 0xfff);
+    REQUIRE(result == returnvalue::FAILED);
+    result = pduConf.sourceId.setValue(cfdp::WidthInBytes::TWO_BYTES, 0xfffff);
+    REQUIRE(result == returnvalue::FAILED);
+    result = pduConf.sourceId.setValue(cfdp::WidthInBytes::FOUR_BYTES, 0xfffffffff);
+    REQUIRE(result == returnvalue::FAILED);
+  }
+
+  SECTION("Header Serialization") {
+    result = creator.serialize(&serTarget, &serSize, serBuf.size(), SerializeIF::Endianness::BIG);
+    REQUIRE(result == returnvalue::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);
+
+    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 0") {
+    REQUIRE(creator.serialize(&serTarget, &serSize, serBuf.size(), SerializeIF::Endianness::BIG) ==
+            returnvalue::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 reader = PduHeaderReader(serBuf.data(), serBuf.size());
+
+    ReturnValue_t serResult = reader.parseData();
+    REQUIRE(serResult == returnvalue::OK);
+    REQUIRE(reader.getPduDataFieldLen() == 0);
+    REQUIRE(reader.getHeaderSize() == 7);
+    REQUIRE(reader.getWholePduSize() == 7);
+    REQUIRE(reader.getCrcFlag() == false);
+    REQUIRE(reader.getDirection() == cfdp::Direction::TOWARDS_RECEIVER);
+    REQUIRE(reader.getLargeFileFlag() == false);
+    REQUIRE(reader.getLenEntityIds() == 1);
+    REQUIRE(reader.getLenSeqNum() == 1);
+    REQUIRE(reader.getPduType() == cfdp::PduType::FILE_DIRECTIVE);
+    REQUIRE(reader.getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::NOT_PRESENT);
+    REQUIRE(reader.getSegmentationControl() == false);
+    REQUIRE(reader.getTransmissionMode() == cfdp::TransmissionMode::ACKNOWLEDGED);
+    // No PDU data contained, so the PDU data field is empty
+    REQUIRE(reader.getPduDataField() == nullptr);
+
+    size_t deSerSize = reader.getWholePduSize();
+    serTarget = serBuf.data();
+    const auto** serTargetConst = const_cast<const uint8_t**>(&serTarget);
+    result = reader.parseData();
+    REQUIRE(result == returnvalue::OK);
+  }
+
+  SECTION("Header Deserialization 1") {
+    pduConf.crcFlag = true;
+    pduConf.largeFile = true;
+    pduConf.direction = cfdp::Direction::TOWARDS_SENDER;
+    pduConf.mode = cfdp::TransmissionMode::UNACKNOWLEDGED;
+    creator.setSegmentationControl(cfdp::SegmentationControl::RECORD_BOUNDARIES_PRESERVATION);
+    creator.setPduType(cfdp::PduType::FILE_DATA);
+    creator.setSegmentMetadataFlag(cfdp::SegmentMetadataFlag::PRESENT);
+    result = pduConf.seqNum.setValue(cfdp::WidthInBytes::TWO_BYTES, 0x0fff);
+    REQUIRE(result == returnvalue::OK);
+    result = pduConf.sourceId.setValue(cfdp::WidthInBytes::FOUR_BYTES, 0xff00ff00);
+    REQUIRE(result == returnvalue::OK);
+    result = pduConf.destId.setValue(cfdp::WidthInBytes::FOUR_BYTES, 0x00ff00ff);
+    REQUIRE(result == returnvalue::OK);
+    serTarget = serBuf.data();
+    serSize = 0;
+    result = creator.serialize(&serTarget, &serSize, serBuf.size(), SerializeIF::Endianness::BIG);
+    PduHeaderReader reader(serBuf.data(), serBuf.size());
+    REQUIRE(reader.parseData() == returnvalue::OK);
+    // Everything except version bit flipped to one now
+    REQUIRE(serBuf[0] == 0x3f);
+    REQUIRE(serBuf[3] == 0b11001010);
+    REQUIRE(reader.getWholePduSize() == 14);
+
+    REQUIRE(reader.getCrcFlag() == true);
+    REQUIRE(reader.getDirection() == cfdp::Direction::TOWARDS_SENDER);
+    REQUIRE(reader.getLargeFileFlag() == true);
+    REQUIRE(reader.getLenEntityIds() == 4);
+    REQUIRE(reader.getLenSeqNum() == 2);
+    REQUIRE(reader.getPduType() == cfdp::PduType::FILE_DATA);
+    REQUIRE(reader.getSegmentMetadataFlag() == cfdp::SegmentMetadataFlag::PRESENT);
+    REQUIRE(reader.getSegmentationControl() == true);
+    REQUIRE(reader.getTransmissionMode() == cfdp::TransmissionMode::UNACKNOWLEDGED);
+    // Again, no data field set because this is a header only
+    REQUIRE(reader.getPduDataField() == nullptr);
+
+    cfdp::TransactionSeqNum seqNumLocal;
+    reader.getTransactionSeqNum(seqNumLocal);
+    REQUIRE(seqNumLocal.getWidth() == cfdp::WidthInBytes::TWO_BYTES);
+    REQUIRE(seqNumLocal.getValue() == 0x0fff);
+    cfdp::EntityId sourceDestId;
+    reader.getSourceId(sourceDestId);
+    REQUIRE(sourceDestId.getWidth() == cfdp::WidthInBytes::FOUR_BYTES);
+    REQUIRE(sourceDestId.getValue() == 0xff00ff00);
+    reader.getDestId(sourceDestId);
+    REQUIRE(sourceDestId.getWidth() == cfdp::WidthInBytes::FOUR_BYTES);
+    REQUIRE(sourceDestId.getValue() == 0x00ff00ff);
+    CHECK(reader.setReadOnlyData(nullptr, -1) != returnvalue::OK);
+    REQUIRE(reader.getHeaderSize() == 14);
+
+    SECTION("Manipulate Source Dest ID") {
+      serTarget = serBuf.data();
+      serSize = 0;
+      pduConf.sourceId.setValue(cfdp::WidthInBytes::ONE_BYTE, 22);
+      pduConf.destId.setValue(cfdp::WidthInBytes::ONE_BYTE, 48);
+      result = creator.serialize(&serTarget, &serSize, serBuf.size(), SerializeIF::Endianness::BIG);
+      reader.getSourceId(sourceDestId);
+      REQUIRE(sourceDestId.getWidth() == cfdp::WidthInBytes::ONE_BYTE);
+      REQUIRE(sourceDestId.getValue() == 22);
+    }
+  }
+
+  SECTION("Verify data field pointer") {
+    FinishedInfo info(cfdp::ConditionCode::INACTIVITY_DETECTED,
+                      cfdp::FileDeliveryCode::DATA_INCOMPLETE,
+                      cfdp::FileDeliveryStatus::DISCARDED_DELIBERATELY);
+    FinishPduCreator finishCreator(pduConf, info);
+    REQUIRE(finishCreator.serialize(serBuf.data(), serSize, serBuf.size()) == OK);
+    // This PDU contains the directive code and some finishes PDU properties packed into one byte
+    // in addition to the header
+    REQUIRE(finishCreator.getSerializedSize() == 9);
+    PduHeaderReader reader(serBuf.data(), serBuf.size());
+    REQUIRE(reader.parseData() == returnvalue::OK);
+    REQUIRE(reader.getPduDataField() == serBuf.data() + 7);
+  }
+}

unittests/cfdp/pdu/testEofPdu.cpp

@@ -0,0 +1,118 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/cfdp/pdu/EofPduCreator.h"
+#include "fsfw/cfdp/pdu/EofPduReader.h"
+#include "fsfw/globalfunctions/arrayprinter.h"
+
+TEST_CASE("EOF PDU", "[cfdp][pdu]") {
+  using namespace cfdp;
+
+  ReturnValue_t result = returnvalue::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(sourceId, destId, TransmissionMode::ACKNOWLEDGED, seqNum);
+
+  auto eofSerializer = EofPduCreator(pduConf, eofInfo);
+  SECTION("Serialize") {
+    result = eofSerializer.serialize(&bufPtr, &sz, buf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::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 == returnvalue::OK);
+    REQUIRE(checksum == 5);
+    uint32_t fileSizeVal = 0;
+    result = SerializeAdapter::deSerialize(&fileSizeVal, buf.data() + sz - 4, nullptr,
+                                           SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(fileSizeVal == 12);
+    REQUIRE(buf[sz - 10] == cfdp::FileDirective::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 = EofPduCreator(pduConf, eofInfo);
+    bufPtr = buf.data();
+    sz = 0;
+    result = serializeWithFaultLocation.serialize(&bufPtr, &sz, buf.size(),
+                                                  SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(sz == 28);
+    REQUIRE(buf[10] == cfdp::FileDirective::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::TlvType::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 == returnvalue::OK);
+    EntityIdTlv tlv(destId);
+    EofInfo emptyInfo(&tlv);
+    auto deserializer = EofPduReader(buf.data(), buf.size(), emptyInfo);
+    result = deserializer.parseData();
+    REQUIRE(result == returnvalue::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 = EofPduCreator(pduConf, eofInfo);
+    bufPtr = buf.data();
+    sz = 0;
+    result = serializeWithFaultLocation.serialize(&bufPtr, &sz, buf.size(),
+                                                  SerializeIF::Endianness::NETWORK);
+    auto deserializer2 = EofPduReader(buf.data(), buf.size(), emptyInfo);
+    result = deserializer2.parseData();
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(emptyInfo.getConditionCode() == cfdp::ConditionCode::FILESTORE_REJECTION);
+    REQUIRE(emptyInfo.getChecksum() == 5);
+    REQUIRE(emptyInfo.getFileSize().getSize() == 0x10ffffff10);
+    REQUIRE(emptyInfo.getFaultLoc()->getType() == cfdp::TlvType::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 = EofPduReader(buf.data(), maxSz, emptyInfo);
+      result = invalidDeser.parseData();
+      REQUIRE(result != returnvalue::OK);
+    }
+  }
+}

unittests/cfdp/pdu/testFileData.cpp

@@ -0,0 +1,171 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/cfdp/pdu/FileDataCreator.h"
+#include "fsfw/cfdp/pdu/FileDataReader.h"
+#include "fsfw/globalfunctions/arrayprinter.h"
+#include "fsfw/serviceinterface.h"
+
+TEST_CASE("File Data PDU", "[cfdp][pdu]") {
+  using namespace cfdp;
+
+  ReturnValue_t result = returnvalue::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(sourceId, destId, TransmissionMode::ACKNOWLEDGED, seqNum);
+
+  for (uint8_t idx = 0; idx < 10; idx++) {
+    fileBuffer[idx] = idx;
+  }
+  FileSize offset(50);
+  FileDataInfo info(offset, fileBuffer.data(), 10);
+
+  SECTION("Serialization") {
+    FileDataCreator serializer(pduConf, info);
+    result =
+        serializer.serialize(&buffer, &sz, fileDataBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::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 == returnvalue::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 == returnvalue::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 != returnvalue::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") {
+    FileDataCreator serializer(pduConf, info);
+    result =
+        serializer.serialize(&buffer, &sz, fileDataBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+
+    FileSize emptyOffset;
+    FileDataInfo emptyInfo(emptyOffset);
+    FileDataReader deserializer(fileDataBuffer.data(), fileDataBuffer.size(), emptyInfo);
+    result = deserializer.parseData();
+    REQUIRE(result == returnvalue::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 == returnvalue::OK);
+
+    result = deserializer.parseData();
+    REQUIRE(result == returnvalue::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 != returnvalue::OK);
+      }
+    }
+  }
+}

unittests/cfdp/pdu/testFileDirective.cpp

@@ -0,0 +1,85 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/cfdp/pdu/FileDirectiveCreator.h"
+#include "fsfw/cfdp/pdu/FileDirectiveReader.h"
+
+TEST_CASE("CFDP File Directive", "[cfdp][pdu]") {
+  using namespace cfdp;
+  std::array<uint8_t, 32> serBuf{};
+  ReturnValue_t result;
+  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(sourceId, destId, cfdp::TransmissionMode::ACKNOWLEDGED, seqNum, false);
+  uint8_t* serTarget = serBuf.data();
+  const uint8_t* deserTarget = serTarget;
+  size_t serSize = 0;
+  auto fdSer = FileDirectiveCreator(pduConf, FileDirective::ACK, 4);
+
+  SECTION("Serialization") {
+    REQUIRE(fdSer.getSerializedSize() == 8);
+    serTarget = serBuf.data();
+    serSize = 0;
+    result = fdSer.serialize(&serTarget, &serSize, serBuf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::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] == FileDirective::ACK);
+  }
+
+  SECTION("Serialization fails") {
+    REQUIRE(fdSer.serialize(nullptr, nullptr, 85, SerializeIF::Endianness::NETWORK) ==
+            returnvalue::FAILED);
+  }
+
+  SECTION("Buffer Too Short") {
+    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);
+    }
+  }
+
+  SECTION("Deserialize") {
+    CHECK(fdSer.serialize(&serTarget, &serSize, serBuf.size(), SerializeIF::Endianness::NETWORK) ==
+          returnvalue::OK);
+    serTarget = serBuf.data();
+
+    REQUIRE(fdSer.deSerialize(&deserTarget, &serSize, SerializeIF::Endianness::NETWORK) ==
+            returnvalue::FAILED);
+    deserTarget = serBuf.data();
+    CHECK(serSize == 8);
+    auto fdDeser = FileDirectiveReader(deserTarget, serBuf.size());
+    REQUIRE(fdDeser.isNull());
+    REQUIRE(not fdDeser);
+    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() == returnvalue::OK);
+    REQUIRE(not fdDeser.isNull());
+    REQUIRE(fdDeser);
+    REQUIRE(fdDeser.getFileDirective() == FileDirective::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_FIELD);
+  }
+}

unittests/cfdp/pdu/testFinishedPdu.cpp

@@ -0,0 +1,189 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/cfdp/pdu/FinishedPduCreator.h"
+#include "fsfw/cfdp/pdu/FinishedPduReader.h"
+#include "fsfw/globalfunctions/arrayprinter.h"
+
+TEST_CASE("Finished PDU", "[cfdp][pdu]") {
+  using namespace cfdp;
+  ReturnValue_t result = returnvalue::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(sourceId, destId, TransmissionMode::ACKNOWLEDGED, seqNum);
+
+  cfdp::Lv emptyFsMsg;
+  FinishedInfo info(cfdp::ConditionCode::INACTIVITY_DETECTED,
+                    cfdp::FileDeliveryCode::DATA_INCOMPLETE,
+                    cfdp::FileDeliveryStatus::DISCARDED_DELIBERATELY);
+
+  SECTION("Serialize") {
+    FinishPduCreator serializer(pduConf, info);
+    result = serializer.serialize(&buffer, &sz, fnBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(serializer.getSerializedSize() == 12);
+    REQUIRE(((fnBuffer[1] << 8) | fnBuffer[2]) == 2);
+    REQUIRE(fnBuffer[10] == cfdp::FileDirective::FINISH);
+    REQUIRE(((fnBuffer[sz - 1] >> 4) & 0x0f) == cfdp::ConditionCode::INACTIVITY_DETECTED);
+    REQUIRE(((fnBuffer[sz - 1] >> 2) & 0x01) == cfdp::FileDeliveryCode::DATA_INCOMPLETE);
+    REQUIRE((fnBuffer[sz - 1] & 0b11) == cfdp::FileDeliveryStatus::DISCARDED_DELIBERATELY);
+    REQUIRE(sz == 12);
+
+    // Add a filestore response
+    std::string firstName = "hello.txt";
+    cfdp::StringLv firstNameLv(firstName);
+    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 == returnvalue::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::StringLv secondNameLv(secondName);
+    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 == returnvalue::OK);
+    info.setConditionCode(cfdp::ConditionCode::FILESTORE_REJECTION);
+    REQUIRE(serializer.getSerializedSize() == 12 + 14 + 15 + 4);
+    REQUIRE(sz == 12 + 14 + 15 + 4);
+    info.setFileStatus(cfdp::FileDeliveryStatus::DISCARDED_FILESTORE_REJECTION);
+    REQUIRE(info.getFileStatus() == cfdp::FileDeliveryStatus::DISCARDED_FILESTORE_REJECTION);
+    info.setDeliveryCode(cfdp::FileDeliveryCode::DATA_INCOMPLETE);
+    REQUIRE(info.getDeliveryCode() == cfdp::FileDeliveryCode::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 != returnvalue::OK);
+    }
+  }
+
+  SECTION("Deserialize") {
+    FinishedInfo emptyInfo;
+    FinishPduCreator serializer(pduConf, info);
+    result = serializer.serialize(&buffer, &sz, fnBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+    FinishPduReader deserializer(fnBuffer.data(), fnBuffer.size(), emptyInfo);
+    result = deserializer.parseData();
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(emptyInfo.getFileStatus() == cfdp::FileDeliveryStatus::DISCARDED_DELIBERATELY);
+    REQUIRE(emptyInfo.getConditionCode() == cfdp::ConditionCode::INACTIVITY_DETECTED);
+    REQUIRE(emptyInfo.getDeliveryCode() == cfdp::FileDeliveryCode::DATA_INCOMPLETE);
+
+    // Add a filestore response
+    sz = 0;
+    buffer = fnBuffer.data();
+    std::string firstName = "hello.txt";
+    cfdp::StringLv firstNameLv(firstName);
+    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 == returnvalue::OK);
+    FilestoreResponseTlv emptyResponse(firstNameLv, nullptr);
+    responsePtr = &emptyResponse;
+    emptyInfo.setFilestoreResponsesArray(&responsePtr, nullptr, &len);
+    FinishPduReader deserializer2(fnBuffer.data(), fnBuffer.size(), emptyInfo);
+    result = deserializer2.parseData();
+    REQUIRE(result == returnvalue::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::StringLv secondNameLv(secondName);
+    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 == returnvalue::OK);
+    EntityId emptyId;
+    EntityIdTlv emptyFaultLoc(emptyId);
+    emptyInfo.setFaultLocation(&emptyFaultLoc);
+    response.setFilestoreMessage(&emptyFsMsg);
+    emptyInfo.setFilestoreResponsesArray(responses.data(), &len, &len);
+    response2.setFilestoreMessage(&emptyFsMsg);
+    FinishPduReader deserializer3(fnBuffer.data(), fnBuffer.size(), emptyInfo);
+    result = deserializer3.parseData();
+    REQUIRE(result == returnvalue::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::TlvType::FILESTORE_REQUEST;
+    result = deserializer3.parseData();
+    REQUIRE(result == cfdp::INVALID_TLV_TYPE);
+
+    for (size_t maxSz = 0; maxSz < 45; maxSz++) {
+      FinishPduReader faultyDeser(fnBuffer.data(), maxSz, emptyInfo);
+      result = faultyDeser.parseData();
+      REQUIRE(result != returnvalue::OK);
+    }
+  }
+}

unittests/cfdp/pdu/testKeepAlivePdu.cpp

@@ -0,0 +1,81 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/cfdp/pdu/KeepAlivePduCreator.h"
+#include "fsfw/cfdp/pdu/KeepAlivePduReader.h"
+#include "fsfw/globalfunctions/arrayprinter.h"
+
+TEST_CASE("Keep Alive PDU", "[cfdp][pdu]") {
+  using namespace cfdp;
+  ReturnValue_t result = returnvalue::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(sourceId, destId, TransmissionMode::ACKNOWLEDGED, seqNum);
+
+  FileSize progress(0x50);
+
+  SECTION("Serialize") {
+    KeepAlivePduCreator serializer(pduConf, progress);
+    result = serializer.serialize(&buffer, &sz, kaBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(kaBuffer[10] == cfdp::FileDirective::KEEP_ALIVE);
+    uint32_t fsRaw = 0;
+    result = SerializeAdapter::deSerialize(&fsRaw, kaBuffer.data() + 11, nullptr,
+                                           SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::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 == returnvalue::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 == returnvalue::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 != returnvalue::OK);
+    }
+  }
+
+  SECTION("Deserialize") {
+    KeepAlivePduCreator serializer(pduConf, progress);
+    result = serializer.serialize(&buffer, &sz, kaBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+
+    // Set another file size
+    progress.setFileSize(200, false);
+    KeepAlivePduReader reader(kaBuffer.data(), kaBuffer.size(), progress);
+    result = reader.parseData();
+    REQUIRE(result == returnvalue::OK);
+    auto& progRef = reader.getProgress();
+    // Should have been overwritten
+    REQUIRE(progRef.getSize() == 0x50);
+    sz = reader.getWholePduSize();
+
+    // invalid max size
+    for (size_t invalidMaxSz = 0; invalidMaxSz < sz; invalidMaxSz++) {
+      ReturnValue_t setResult = reader.setReadOnlyData(kaBuffer.data(), invalidMaxSz);
+      if (setResult == returnvalue::OK) {
+        result = reader.parseData();
+        REQUIRE(result != returnvalue::OK);
+      }
+    }
+  }
+}

unittests/cfdp/pdu/testMetadataPdu.cpp

@@ -0,0 +1,179 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+#include <iostream>
+
+#include "fsfw/cfdp/pdu/MetadataPduCreator.h"
+#include "fsfw/cfdp/pdu/MetadataPduReader.h"
+#include "fsfw/cfdp/tlv/FilestoreResponseTlv.h"
+#include "fsfw/cfdp/tlv/MessageToUserTlv.h"
+#include "fsfw/globalfunctions/arrayprinter.h"
+
+TEST_CASE("Metadata PDU", "[cfdp][pdu]") {
+  using namespace cfdp;
+  ReturnValue_t result = returnvalue::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(sourceId, destId, TransmissionMode::ACKNOWLEDGED, seqNum);
+
+  std::string firstFileName = "hello.txt";
+  cfdp::StringLv sourceFileName(firstFileName);
+  cfdp::StringLv destFileName;
+  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") {
+    MetadataPduCreator serializer(pduConf, info);
+    result = serializer.serialize(&buffer, &sz, mdBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::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] == FileDirective::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 == returnvalue::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::StringLv otherFileNameLv(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 == returnvalue::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") {
+    MetadataPduCreator serializer(pduConf, info);
+    result = serializer.serialize(&buffer, &sz, mdBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+
+    MetadataPduReader deserializer(mdBuffer.data(), mdBuffer.size(), info);
+    result = deserializer.parseData();
+    REQUIRE(result == returnvalue::OK);
+    size_t fullSize = deserializer.getWholePduSize();
+    for (size_t maxSz = 0; maxSz < fullSize; maxSz++) {
+      MetadataPduReader invalidSzDeser(mdBuffer.data(), maxSz, info);
+      result = invalidSzDeser.parseData();
+      REQUIRE(result != returnvalue::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 == returnvalue::OK);
+
+    MetadataPduReader deserializer2(mdBuffer.data(), mdBuffer.size(), info);
+    result = deserializer2.parseData();
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(options[0]->getType() == cfdp::TlvType::FILESTORE_RESPONSE);
+    REQUIRE(options[0]->getSerializedSize() == 14);
+    REQUIRE(options[1]->getType() == cfdp::TlvType::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 != returnvalue::OK);
+      }
+    }
+    mdBuffer[1] = (36 >> 8) & 0xff;
+    mdBuffer[2] = 36 & 0xff;
+    info.setOptionsArray(nullptr, std::nullopt, std::nullopt);
+    REQUIRE(deserializer2.parseData() == cfdp::METADATA_CANT_PARSE_OPTIONS);
+    info.setOptionsArray(options.data(), sizeOfOptions, std::nullopt);
+    for (size_t maxSz = 0; maxSz < 46; maxSz++) {
+      MetadataPduReader invalidSzDeser(mdBuffer.data(), maxSz, info);
+      if (not invalidSzDeser.isNull()) {
+        result = invalidSzDeser.parseData();
+        REQUIRE(result == SerializeIF::STREAM_TOO_SHORT);
+      }
+    }
+  }
+}

unittests/cfdp/pdu/testNakPdu.cpp

@@ -0,0 +1,152 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/cfdp/pdu/NakPduCreator.h"
+#include "fsfw/cfdp/pdu/NakPduReader.h"
+#include "fsfw/cfdp/pdu/PduConfig.h"
+#include "fsfw/globalfunctions/arrayprinter.h"
+
+TEST_CASE("NAK PDU", "[cfdp][pdu]") {
+  using namespace cfdp;
+  ReturnValue_t result = returnvalue::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(sourceId, destId, TransmissionMode::ACKNOWLEDGED, seqNum);
+
+  FileSize startOfScope(50);
+  FileSize endOfScope(1050);
+  NakInfo info(startOfScope, endOfScope);
+  SECTION("Serializer") {
+    NakPduCreator serializer(pduConf, info);
+    result = serializer.serialize(&buffer, &sz, nakBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(serializer.getSerializedSize() == 19);
+    REQUIRE(serializer.FileDirectiveCreator::getSerializedSize() == 11);
+    REQUIRE(sz == 19);
+    REQUIRE(serializer.getPduDataFieldLen() == 9);
+    REQUIRE(((nakBuffer[1] << 8) | nakBuffer[2]) == 0x09);
+    REQUIRE(nakBuffer[10] == cfdp::FileDirective::NAK);
+    uint32_t scope = 0;
+    result = SerializeAdapter::deSerialize(&scope, nakBuffer.data() + 11, nullptr,
+                                           SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(scope == 50);
+    result = SerializeAdapter::deSerialize(&scope, nakBuffer.data() + 15, nullptr,
+                                           SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::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 == returnvalue::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 == returnvalue::OK);
+    REQUIRE(segReqScopes == 2020);
+    result = SerializeAdapter::deSerialize(&segReqScopes, nakBuffer.data() + 23, nullptr,
+                                           SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(segReqScopes == 2520);
+    result = SerializeAdapter::deSerialize(&segReqScopes, nakBuffer.data() + 27, nullptr,
+                                           SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(segReqScopes == 2932);
+    result = SerializeAdapter::deSerialize(&segReqScopes, nakBuffer.data() + 31, nullptr,
+                                           SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::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") {
+    NakPduCreator serializer(pduConf, info);
+    result = serializer.serialize(&buffer, &sz, nakBuffer.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+
+    info.getStartOfScope().setFileSize(0, false);
+    info.getEndOfScope().setFileSize(0, false);
+    NakPduReader deserializer(nakBuffer.data(), nakBuffer.size(), info);
+    result = deserializer.parseData();
+    REQUIRE(result == returnvalue::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 == returnvalue::OK);
+
+    NakPduReader deserializeWithSegReqs(nakBuffer.data(), nakBuffer.size(), info);
+    result = deserializeWithSegReqs.parseData();
+    REQUIRE(result == returnvalue::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++) {
+      NakPduReader faultyDeserializer(nakBuffer.data(), idx, info);
+      result = faultyDeserializer.parseData();
+      REQUIRE(result != returnvalue::OK);
+    }
+    for (size_t pduFieldLen = 0; pduFieldLen < 25; pduFieldLen++) {
+      nakBuffer[1] = (pduFieldLen >> 8) & 0xff;
+      nakBuffer[2] = pduFieldLen & 0xff;
+      NakPduReader 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 != returnvalue::OK);
+      }
+    }
+    info.setMaxSegmentRequestLen(5);
+    REQUIRE(info.getSegmentRequestsMaxLen() == 5);
+  }
+}

unittests/cfdp/pdu/testPromptPdu.cpp

@@ -0,0 +1,69 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/cfdp/pdu/PromptPduCreator.h"
+#include "fsfw/cfdp/pdu/PromptPduReader.h"
+#include "fsfw/globalfunctions/arrayprinter.h"
+
+TEST_CASE("Prompt PDU", "[cfdp][pdu]") {
+  using namespace cfdp;
+  ReturnValue_t result = returnvalue::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(sourceId, destId, TransmissionMode::ACKNOWLEDGED, seqNum);
+
+  SECTION("Serialize") {
+    PromptPduCreator serializer(pduConf, cfdp::PromptResponseRequired::PROMPT_KEEP_ALIVE);
+    result = serializer.serialize(&buffer, &sz, rawBuf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(serializer.getWholePduSize() == 12);
+    REQUIRE(sz == 12);
+    REQUIRE(serializer.getPduDataFieldLen() == 2);
+    REQUIRE(rawBuf[10] == FileDirective::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 != returnvalue::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 != returnvalue::OK);
+    }
+  }
+
+  SECTION("Deserialize") {
+    PromptPduCreator serializer(pduConf, cfdp::PromptResponseRequired::PROMPT_KEEP_ALIVE);
+    result = serializer.serialize(&buffer, &sz, rawBuf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+
+    PromptPduReader deserializer(rawBuf.data(), rawBuf.size());
+    result = deserializer.parseData();
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(deserializer.getPromptResponseRequired() ==
+            cfdp::PromptResponseRequired::PROMPT_KEEP_ALIVE);
+    sz = deserializer.getWholePduSize();
+    // Set invalid size
+    rawBuf[2] = 1;
+    result = deserializer.parseData();
+    size_t sz2 = deserializer.getWholePduSize();
+    REQUIRE(result == SerializeIF::STREAM_TOO_SHORT);
+    rawBuf[2] = 2;
+
+    for (size_t invalidMaxSz = 0; invalidMaxSz < sz; invalidMaxSz++) {
+      ReturnValue_t setResult = deserializer.setReadOnlyData(rawBuf.data(), invalidMaxSz);
+      if (setResult == returnvalue::OK) {
+        result = deserializer.parseData();
+        REQUIRE(result != returnvalue::OK);
+      }
+    }
+  }
+}

unittests/cfdp/testCfdp.cpp

@@ -0,0 +1,105 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+#include <cstring>
+
+#include "fsfw/cfdp/FileSize.h"
+#include "fsfw/cfdp/pdu/FileDirectiveCreator.h"
+#include "fsfw/cfdp/pdu/FileDirectiveReader.h"
+#include "fsfw/globalfunctions/arrayprinter.h"
+#include "fsfw/serialize/SerializeAdapter.h"
+
+TEST_CASE("CFDP Base", "[cfdp]") {
+  using namespace cfdp;
+  std::array<uint8_t, 32> serBuf{};
+  ReturnValue_t result;
+  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(sourceId, destId, cfdp::TransmissionMode::ACKNOWLEDGED, seqNum, false);
+  uint8_t* serTarget = serBuf.data();
+  const uint8_t* deserTarget = serTarget;
+  size_t serSize = 0;
+
+  SECTION("File Directive") {
+    auto fdSer = FileDirectiveCreator(pduConf, FileDirective::ACK, 4);
+    REQUIRE(fdSer.getSerializedSize() == 8);
+    serTarget = serBuf.data();
+    serSize = 0;
+    result = fdSer.serialize(&serTarget, &serSize, serBuf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::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] == FileDirective::ACK);
+
+    serTarget = serBuf.data();
+    size_t deserSize = 20;
+    serSize = 0;
+    REQUIRE(fdSer.deSerialize(&deserTarget, &deserSize, SerializeIF::Endianness::NETWORK) ==
+            returnvalue::FAILED);
+    REQUIRE(fdSer.serialize(nullptr, nullptr, 85, SerializeIF::Endianness::NETWORK) ==
+            returnvalue::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 = FileDirectiveReader(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() == returnvalue::OK);
+    REQUIRE(fdDeser.getFileDirective() == FileDirective::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_FIELD);
+  }
+
+  SECTION("File Size") {
+    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);
+    result = fss.serialize(&buffer, &size, fssBuf.size(), SerializeIF::Endianness::MACHINE);
+    REQUIRE(result == returnvalue::OK);
+    uint32_t fileSize = 0;
+    result = SerializeAdapter::deSerialize(&fileSize, fssBuf.data(), nullptr,
+                                           SerializeIF::Endianness::MACHINE);
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(fileSize == 0x20);
+  }
+
+  SECTION("Var Length Field") {
+    VarLenField defaultField;
+    CHECK(defaultField.getValue() == 0);
+    CHECK(defaultField.getWidth() == WidthInBytes::ONE_BYTE);
+    VarLenField explicitField(WidthInBytes::FOUR_BYTES, 12);
+    CHECK(explicitField.getWidth() == WidthInBytes::FOUR_BYTES);
+    CHECK(explicitField.getValue() == 12);
+    VarLenField fromUnsignedByteField(UnsignedByteField<uint16_t>(12));
+    CHECK(fromUnsignedByteField.getWidth() == WidthInBytes::TWO_BYTES);
+    CHECK(fromUnsignedByteField.getValue() == 12);
+  }
+}

unittests/cfdp/testLvs.cpp

@@ -0,0 +1,116 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/cfdp.h"
+#include "fsfw/cfdp/VarLenFields.h"
+
+TEST_CASE("CFDP LV", "[cfdp][lv]") {
+  using namespace cfdp;
+  ReturnValue_t result = returnvalue::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("LV Serialization") {
+    std::array<uint8_t, 8> lvRawBuf{};
+    serPtr = lvRawBuf.data();
+    REQUIRE(sourceId.serialize(&serPtr, &deserSize, lvRawBuf.size(),
+                               SerializeIF::Endianness::NETWORK) == returnvalue::OK);
+    REQUIRE(deserSize == 2);
+
+    auto lv = cfdp::Lv(lvRawBuf.data(), 2);
+    REQUIRE(lv.getSerializedSize() == 3);
+
+    SECTION("Copy") {
+      auto lvCopy = cfdp::Lv(lv);
+      REQUIRE(lvCopy.getSerializedSize() == 3);
+      REQUIRE(lv.getValue(nullptr) == lvCopy.getValue(nullptr));
+    }
+
+    serPtr = rawBuf.data();
+    deserSize = 0;
+    REQUIRE(lv.serialize(&serPtr, &deserSize, rawBuf.size(), SerializeIF::Endianness::NETWORK) ==
+            returnvalue::OK);
+    REQUIRE(deserSize == 3);
+    REQUIRE(rawBuf[0] == 2);
+    uint16_t sourceIdRaw = 0;
+    REQUIRE(SerializeAdapter::deSerialize(&sourceIdRaw, rawBuf.data() + 1, &deserSize,
+                                          SerializeIF::Endianness::BIG) == returnvalue::OK);
+    REQUIRE(sourceIdRaw == 0x0ff0);
+  }
+
+  SECTION("Empty Serialization") {
+    auto lvEmpty = Lv();
+    REQUIRE(lvEmpty.getSerializedSize() == 1);
+    serPtr = rawBuf.data();
+    deserSize = 0;
+    result =
+        lvEmpty.serialize(&serPtr, &deserSize, rawBuf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(deserSize == 1);
+    deserPtr = rawBuf.data();
+    result = lvEmpty.deSerialize(&deserPtr, &deserSize, SerializeIF::Endianness::BIG);
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(lvEmpty.getSerializedSize() == 1);
+  }
+
+  SECTION("Uninit LV") {
+    std::array<uint8_t, 8> lvRawBuf{};
+    serPtr = lvRawBuf.data();
+    REQUIRE(sourceId.serialize(&serPtr, &deserSize, lvRawBuf.size(),
+                               SerializeIF::Endianness::NETWORK) == returnvalue::OK);
+    auto lv = cfdp::Lv(lvRawBuf.data(), 2);
+    serPtr = rawBuf.data();
+    deserSize = 0;
+    result = lv.serialize(&serPtr, &deserSize, rawBuf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+    Lv uninitLv;
+    deserPtr = rawBuf.data();
+    deserSize = 3;
+    result = uninitLv.deSerialize(&deserPtr, &deserSize, SerializeIF::Endianness::BIG);
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(uninitLv.getSerializedSize() == 3);
+    const uint8_t* storedValue = uninitLv.getValue(nullptr);
+    uint16_t sourceIdRaw = 0;
+    REQUIRE(SerializeAdapter::deSerialize(&sourceIdRaw, storedValue, &deserSize,
+                                          SerializeIF::Endianness::BIG) == returnvalue::OK);
+    REQUIRE(sourceIdRaw == 0x0ff0);
+  }
+
+  SECTION("Invalid Input") {
+    Lv uninitLv;
+    REQUIRE(uninitLv.deSerialize(nullptr, nullptr, SerializeIF::Endianness::BIG) ==
+            returnvalue::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("String LV String") {
+    std::string filename = "hello.txt";
+    StringLv sourceFileName(filename);
+    REQUIRE(sourceFileName.getSerializedSize() == 1 + filename.size());
+    REQUIRE(sourceFileName.serializeBe(rawBuf.data(), deserSize, rawBuf.size()) == returnvalue::OK);
+    REQUIRE(rawBuf[0] == filename.size());
+    std::string filenameFromRaw(reinterpret_cast<const char*>(rawBuf.data() + 1), filename.size());
+    REQUIRE(filenameFromRaw == filename);
+  }
+
+  SECTION("String LV Const Char") {
+    const char filename[] = "hello.txt";
+    StringLv sourceFileName(filename, sizeof(filename) - 1);
+    REQUIRE(sourceFileName.getSerializedSize() == 1 + sizeof(filename) - 1);
+    REQUIRE(sourceFileName.serializeBe(rawBuf.data(), deserSize, rawBuf.size()) == returnvalue::OK);
+    REQUIRE(rawBuf[0] == sizeof(filename) - 1);
+    rawBuf[deserSize] = '\0';
+    const char* filenameFromRaw = reinterpret_cast<const char*>(rawBuf.data() + 1);
+    REQUIRE(std::strcmp(filename, filenameFromRaw) == 0);
+  }
+}

unittests/cfdp/testOtherTlvs.cpp

@@ -0,0 +1,137 @@
+#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 Other TLVs", "[cfdp][tlv]") {
+  using namespace cfdp;
+  ReturnValue_t result;
+  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("Filestore Response TLV") {
+    std::string name = "hello.txt";
+    cfdp::StringLv firstName(name);
+    std::string name2 = "hello2.txt";
+    cfdp::StringLv secondName(name2);
+    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 == returnvalue::OK);
+    REQUIRE(rawResponse.getType() == cfdp::TlvType::FILESTORE_RESPONSE);
+    cfdp::StringLv emptyMsg;
+    cfdp::StringLv emptySecondName;
+    FilestoreResponseTlv emptyTlv(firstName, &emptyMsg);
+    emptyTlv.setSecondFileName(&emptySecondName);
+    result = emptyTlv.deSerialize(rawResponse, SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::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::StringLv firstName(name);
+    std::string name2 = "hello2.txt";
+    cfdp::StringLv secondName(name2);
+    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 == returnvalue::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 == returnvalue::OK);
+
+    cfdp::Tlv rawRequest;
+    ptr = serBuf.data();
+    sz = 0;
+    result = request.convertToTlv(rawRequest, serBuf.data(), serBuf.size(),
+                                  SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(rawRequest.getType() == cfdp::TlvType::FILESTORE_REQUEST);
+
+    emptyRequest.setActionCode(cfdp::FilestoreActionCode::DELETE_FILE);
+    result = emptyRequest.deSerialize(rawRequest, SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(emptyRequest.getType() == cfdp::TlvType::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;
+    result =
+        faultOverrideTlv.serialize(&serPtr, &sz, rawBuf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(faultOverrideTlv.getSerializedSize() == 3);
+    REQUIRE(sz == 3);
+    REQUIRE(result == returnvalue::OK);
+
+    FaultHandlerOverrideTlv emptyOverrideTlv;
+    result = emptyOverrideTlv.deSerialize(&deserPtr, &sz, SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::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::TlvType::ENTITY_ID, rawBuf.data() + 2, 2);
+    REQUIRE(result == returnvalue::OK);
+    deserPtr = rawBuf.data();
+    result = idTlv.deSerialize(rawTlv, SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+  }
+}

unittests/cfdp/testTlv.cpp

@@ -0,0 +1,128 @@
+#include <array>
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/cfdp.h"
+#include "fsfw/cfdp/VarLenFields.h"
+
+TEST_CASE("CFDP TLV", "[cfdp][tlv]") {
+  using namespace cfdp;
+  ReturnValue_t result;
+  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("Entity ID Serialization") {
+    REQUIRE(sourceId.serialize(&serPtr, &deserSize, rawBuf.size(),
+                               SerializeIF::Endianness::NETWORK) == returnvalue::OK);
+    REQUIRE(deserSize == 2);
+  }
+
+  SECTION("TLV Serialization") {
+    std::array<uint8_t, 8> tlvBuf{};
+    REQUIRE(sourceId.serializeBe(tlvBuf.data(), deserSize, tlvBuf.size()) == returnvalue::OK);
+    auto tlv = Tlv(TlvType::ENTITY_ID, tlvBuf.data(), deserSize);
+    REQUIRE(tlv.getSerializedSize() == 4);
+    REQUIRE(tlv.getLengthField() == 2);
+    deserSize = 0;
+    REQUIRE(tlv.serialize(&serPtr, &deserSize, rawBuf.size(), SerializeIF::Endianness::NETWORK) ==
+            returnvalue::OK);
+    REQUIRE(deserSize == 4);
+    REQUIRE(rawBuf[0] == TlvType::ENTITY_ID);
+    REQUIRE(rawBuf[1] == 2);
+    uint16_t entityId = 0;
+    REQUIRE(SerializeAdapter::deSerialize(&entityId, rawBuf.data() + 2, &deserSize,
+                                          SerializeIF::Endianness::NETWORK) == returnvalue::OK);
+    REQUIRE(entityId == 0x0ff0);
+  }
+
+  SECTION("TLV Other Value") {
+    auto tlv = Tlv(TlvType::ENTITY_ID, rawBuf.data(), deserSize);
+    // Set new value
+    sourceId.setValue(cfdp::WidthInBytes::FOUR_BYTES, 12);
+    REQUIRE(sourceId.serialize(&serPtr, &deserSize, rawBuf.size(),
+                               SerializeIF::Endianness::NETWORK) == returnvalue::OK);
+    tlv.setValue(rawBuf.data(), cfdp::WidthInBytes::FOUR_BYTES);
+    serPtr = rawBuf.data();
+    deserSize = 0;
+    result = tlv.serialize(&serPtr, &deserSize, rawBuf.size(), SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(rawBuf[0] == TlvType::ENTITY_ID);
+    REQUIRE(rawBuf[1] == 4);
+
+    REQUIRE(result == returnvalue::OK);
+  }
+
+  SECTION("TLV Invalid") {
+    auto tlvInvalid = Tlv(cfdp::TlvType::INVALID_TLV, rawBuf.data(), 0);
+    REQUIRE(tlvInvalid.serialize(&serPtr, &deserSize, rawBuf.size(),
+                                 SerializeIF::Endianness::NETWORK) != returnvalue::OK);
+    tlvInvalid = Tlv(cfdp::TlvType::ENTITY_ID, nullptr, 3);
+    REQUIRE(tlvInvalid.serialize(&serPtr, &deserSize, rawBuf.size(),
+                                 SerializeIF::Endianness::NETWORK) != returnvalue::OK);
+    REQUIRE(tlvInvalid.serialize(&serPtr, &deserSize, 0, SerializeIF::Endianness::NETWORK) !=
+            returnvalue::OK);
+    REQUIRE(tlvInvalid.getSerializedSize() == 0);
+    REQUIRE(tlvInvalid.serialize(nullptr, nullptr, 0, SerializeIF::Endianness::NETWORK) !=
+            returnvalue::OK);
+  }
+
+  SECTION("TLV Zero Length Field") {
+    Tlv zeroLenField(TlvType::FAULT_HANDLER, nullptr, 0);
+    REQUIRE(zeroLenField.getSerializedSize() == 2);
+    serPtr = rawBuf.data();
+    deserSize = 0;
+    REQUIRE(zeroLenField.serialize(&serPtr, &deserSize, rawBuf.size(),
+                                   SerializeIF::Endianness::NETWORK) == returnvalue::OK);
+    REQUIRE(rawBuf[0] == TlvType::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(TlvType::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 == returnvalue::OK);
+    REQUIRE(tlv.getSerializedSize() == 4);
+    REQUIRE(tlv.getType() == TlvType::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) != returnvalue::OK);
+    deserPtr = rawBuf.data();
+    deserSize = 0;
+    REQUIRE(tlv.deSerialize(&deserPtr, &deserSize, SerializeIF::Endianness::NETWORK) ==
+            SerializeIF::STREAM_TOO_SHORT);
+    // Set invalid TLV
+    rawBuf[0] = TlvType::INVALID_TLV;
+    deserSize = 4;
+    REQUIRE(tlv.deSerialize(&deserPtr, &deserSize, SerializeIF::Endianness::NETWORK) !=
+            returnvalue::OK);
+
+    Tlv zeroLenField(TlvType::FAULT_HANDLER, nullptr, 0);
+    serPtr = rawBuf.data();
+    deserSize = 0;
+    REQUIRE(zeroLenField.serialize(&serPtr, &deserSize, rawBuf.size(),
+                                   SerializeIF::Endianness::NETWORK) == returnvalue::OK);
+    deserPtr = rawBuf.data();
+    result = zeroLenField.deSerialize(&deserPtr, &deserSize, SerializeIF::Endianness::NETWORK);
+    REQUIRE(result == returnvalue::OK);
+    REQUIRE(zeroLenField.getSerializedSize() == 2);
+    REQUIRE(deserSize == 0);
+  }
+}

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", "[containers]") {
+  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) == returnvalue::OK);
+    REQUIRE(ringBuffer.writeData(testData, 3) == returnvalue::FAILED);
+    REQUIRE(ringBuffer.readData(readBuffer, 5, true) == returnvalue::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) == returnvalue::OK);
+    REQUIRE(ringBuffer.readData(readBuffer, 4, true) == returnvalue::OK);
+    for (uint8_t i = 0; i < 4; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+    REQUIRE(ringBuffer.writeData(testData, 9) == returnvalue::OK);
+    REQUIRE(ringBuffer.readData(readBuffer, 9, true) == returnvalue::OK);
+    for (uint8_t i = 0; i < 9; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+    REQUIRE(ringBuffer.writeData(testData, 1024) == returnvalue::FAILED);
+    REQUIRE(ringBuffer.writeData(nullptr, 5) == returnvalue::FAILED);
+  }
+
+  SECTION("Get Free Element Test") {
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    REQUIRE(ringBuffer.writeData(testData, 8) == returnvalue::OK);
+    REQUIRE(ringBuffer.availableWriteSpace() == 1);
+    REQUIRE(ringBuffer.readData(readBuffer, 8, true) == returnvalue::OK);
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    uint8_t *testPtr = nullptr;
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) == returnvalue::FAILED);
+
+    REQUIRE(ringBuffer.writeTillWrap() == 2);
+    // too many excess bytes.
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 8) == returnvalue::FAILED);
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 5) == returnvalue::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) == returnvalue::OK);
+    REQUIRE(ringBuffer.getAvailableReadData() == 3);
+    REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) == returnvalue::FAILED);
+    size_t trueSize = 0;
+    REQUIRE(ringBuffer.readData(readBuffer, 5, false, true, &trueSize) == returnvalue::OK);
+    REQUIRE(trueSize == 3);
+    for (uint8_t i = 0; i < 3; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+    trueSize = 0;
+    REQUIRE(ringBuffer.deleteData(5, false, &trueSize) == returnvalue::FAILED);
+    REQUIRE(trueSize == 0);
+    REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == returnvalue::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) == returnvalue::OK);
+    REQUIRE(ringBuffer.readData(readBuffer, 5, true) == returnvalue::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) == returnvalue::OK);
+    REQUIRE(ringBuffer.readData(readBuffer, 4, true) == returnvalue::OK);
+    for (uint8_t i = 0; i < 4; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+    REQUIRE(ringBuffer.writeData(testData, 9) == returnvalue::OK);
+    REQUIRE(ringBuffer.readData(readBuffer, 9, true) == returnvalue::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) == returnvalue::OK);
+    REQUIRE(ringBuffer.availableWriteSpace() == 1);
+    REQUIRE(ringBuffer.readData(readBuffer, 8, true) == returnvalue::OK);
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    uint8_t *testPtr = nullptr;
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) == returnvalue::FAILED);
+
+    REQUIRE(ringBuffer.writeTillWrap() == 2);
+    // too many excess bytes.
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 8) == returnvalue::FAILED);
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 5) == returnvalue::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) == returnvalue::OK);
+    REQUIRE(ringBuffer.getAvailableReadData() == 3);
+    REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) == returnvalue::FAILED);
+    size_t trueSize = 0;
+    REQUIRE(ringBuffer.readData(readBuffer, 5, false, true, &trueSize) == returnvalue::OK);
+    REQUIRE(trueSize == 3);
+    for (uint8_t i = 0; i < 3; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+    trueSize = 0;
+    REQUIRE(ringBuffer.deleteData(5, false, &trueSize) == returnvalue::FAILED);
+    REQUIRE(trueSize == 0);
+    REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == returnvalue::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) == returnvalue::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) == returnvalue::OK);
+    REQUIRE(ptr != nullptr);
+    memcpy(ptr, testData, 13);
+    ringBuffer.confirmBytesWritten(13);
+    REQUIRE(ringBuffer.getAvailableReadData() == 3);
+    REQUIRE(ringBuffer.readData(readBuffer, 3, true) == returnvalue::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) == returnvalue::OK);
+    REQUIRE(ringBuffer.readData(readBuffer, 5, true) == returnvalue::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) == returnvalue::OK);
+    REQUIRE(ringBuffer.readData(readBuffer, 4, true) == returnvalue::OK);
+    for (uint8_t i = 0; i < 4; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+    REQUIRE(ringBuffer.writeData(testData, 9) == returnvalue::OK);
+    REQUIRE(ringBuffer.readData(readBuffer, 9, true) == returnvalue::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) == returnvalue::OK);
+    REQUIRE(ringBuffer.availableWriteSpace() == 1);
+    REQUIRE(ringBuffer.readData(readBuffer, 8, true) == returnvalue::OK);
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    uint8_t *testPtr = nullptr;
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) == returnvalue::OK);
+    REQUIRE(ringBuffer.getExcessBytes() == 8);
+
+    REQUIRE(ringBuffer.writeTillWrap() == 2);
+    // too many excess bytes.
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 8) == returnvalue::FAILED);
+    // Less Execss bytes overwrites before
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 3) == returnvalue::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) == returnvalue::OK);
+    REQUIRE(ringBuffer.getAvailableReadData() == 3);
+    REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) == returnvalue::FAILED);
+    size_t trueSize = 0;
+    REQUIRE(ringBuffer.readData(readBuffer, 5, false, true, &trueSize) == returnvalue::OK);
+    REQUIRE(trueSize == 3);
+    for (uint8_t i = 0; i < 3; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+    trueSize = 0;
+    REQUIRE(ringBuffer.deleteData(5, false, &trueSize) == returnvalue::FAILED);
+    REQUIRE(trueSize == 0);
+    REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == returnvalue::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) == returnvalue::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) == returnvalue::OK);
+    REQUIRE(ptr != nullptr);
+    memcpy(ptr, testData, 13);
+    ringBuffer.confirmBytesWritten(13);
+    REQUIRE(ringBuffer.getAvailableReadData() == 3);
+    REQUIRE(ringBuffer.readData(readBuffer, 3, true) == returnvalue::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) == returnvalue::OK);
+    REQUIRE(ringBuffer.writeData(testData, 3) == returnvalue::FAILED);
+    REQUIRE(ringBuffer.readData(readBuffer, 5, true) == returnvalue::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) == returnvalue::OK);
+    REQUIRE(ringBuffer.readData(readBuffer, 4, true) == returnvalue::OK);
+    for (uint8_t i = 0; i < 4; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+    REQUIRE(ringBuffer.writeData(testData, 9) == returnvalue::OK);
+    REQUIRE(ringBuffer.readData(readBuffer, 9, true) == returnvalue::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) == returnvalue::OK);
+    REQUIRE(ringBuffer.availableWriteSpace() == 1);
+    REQUIRE(ringBuffer.readData(readBuffer, 8, true) == returnvalue::OK);
+    REQUIRE(ringBuffer.availableWriteSpace() == 9);
+    uint8_t *testPtr = nullptr;
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) == returnvalue::FAILED);
+
+    REQUIRE(ringBuffer.writeTillWrap() == 2);
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 8) == returnvalue::OK);
+    REQUIRE(ringBuffer.getFreeElement(&testPtr, 5) == returnvalue::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) == returnvalue::OK);
+    REQUIRE(ringBuffer.getAvailableReadData() == 3);
+    REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) == returnvalue::FAILED);
+    size_t trueSize = 0;
+    REQUIRE(ringBuffer.readData(readBuffer, 5, false, true, &trueSize) == returnvalue::OK);
+    REQUIRE(trueSize == 3);
+    for (uint8_t i = 0; i < 3; i++) {
+      CHECK(readBuffer[i] == i);
+    }
+    trueSize = 0;
+    REQUIRE(ringBuffer.deleteData(5, false, &trueSize) == returnvalue::FAILED);
+    REQUIRE(trueSize == 0);
+    REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == returnvalue::OK);
+    REQUIRE(trueSize == 3);
+  }
+}

unittests/container/TestArrayList.cpp

@@ -0,0 +1,91 @@
+#include <fsfw/container/ArrayList.h>
+#include <fsfw/returnvalues/returnvalue.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+
+/**
+ * @brief 	Array List test
+ */
+TEST_CASE("Array List", "[containers]") {
+  // 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>(returnvalue::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>(returnvalue::OK));
+    }
+    REQUIRE(list.insert(20) == static_cast<int>(containers::LIST_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>(returnvalue::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>(returnvalue::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,142 @@
+#include <fsfw/container/DynamicFIFO.h>
+#include <fsfw/container/FIFO.h>
+#include <fsfw/returnvalues/returnvalue.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+
+TEST_CASE("Dynamic Fifo Tests", "[containers]") {
+  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>(returnvalue::OK));
+    REQUIRE(fifo.insert(structTwo) == static_cast<int>(returnvalue::OK));
+    REQUIRE(fifo.insert(structThree) == static_cast<int>(returnvalue::OK));
+    REQUIRE(fifo.insert(structTwo) == static_cast<int>(FIFOBase<Test>::FULL));
+
+    struct Test testptr;
+    REQUIRE(fifo.peek(&testptr) == static_cast<int>(returnvalue::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>(returnvalue::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>(returnvalue::OK));
+    REQUIRE(fifo.size() == 1);
+    REQUIRE(fifo.insert(structTwo) == static_cast<int>(returnvalue::OK));
+    REQUIRE(fifo.size() == 2);
+    REQUIRE(fifo.pop() == static_cast<int>(returnvalue::OK));
+    REQUIRE(fifo.size() == 1);
+    testptr.number1 = 0;
+    testptr.number2 = 0;
+    testptr.number3 = 0;
+    REQUIRE(fifo.peek(&testptr) == static_cast<int>(returnvalue::OK));
+    equal = testptr == structTwo;
+    REQUIRE(equal);
+    REQUIRE(fifo.pop() == static_cast<int>(returnvalue::OK));
+    REQUIRE(fifo.size() == 0);
+    REQUIRE(fifo.empty());
+  };
+  SECTION("Copy Test") {
+    REQUIRE(fifo.insert(structOne) == static_cast<int>(returnvalue::OK));
+    REQUIRE(fifo.insert(structTwo) == static_cast<int>(returnvalue::OK));
+    REQUIRE(fifo.insert(structThree) == static_cast<int>(returnvalue::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>(returnvalue::OK));
+    REQUIRE(fifo.insert(structTwo) == static_cast<int>(returnvalue::OK));
+    REQUIRE(fifo.insert(structThree) == static_cast<int>(returnvalue::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>(returnvalue::OK));
+      bool equal = testptr == list[i];
+      REQUIRE(equal);
+      REQUIRE(fifo2.size() == i);
+    }
+  };
+
+  SECTION("Assignment Test Smaller") {
+    REQUIRE(fifo.insert(structOne) == static_cast<int>(returnvalue::OK));
+    REQUIRE(fifo.insert(structTwo) == static_cast<int>(returnvalue::OK));
+    REQUIRE(fifo.insert(structThree) == static_cast<int>(returnvalue::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>(returnvalue::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/returnvalue.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+
+TEST_CASE("Static Fifo Tests", "[containers]") {
+  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>(returnvalue::OK));
+    REQUIRE(fifo.insert(structTwo) == static_cast<int>(returnvalue::OK));
+    REQUIRE(fifo.insert(structThree) == static_cast<int>(returnvalue::OK));
+    REQUIRE(fifo.insert(structTwo) == static_cast<int>(FIFOBase<Test>::FULL));
+
+    struct Test testptr;
+    REQUIRE(fifo.peek(&testptr) == static_cast<int>(returnvalue::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>(returnvalue::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>(returnvalue::OK));
+    REQUIRE(fifo.size() == 1);
+    REQUIRE(fifo.insert(structTwo) == static_cast<int>(returnvalue::OK));
+    REQUIRE(fifo.size() == 2);
+    REQUIRE(fifo.pop() == static_cast<int>(returnvalue::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>(returnvalue::FAILED));
+    REQUIRE(fifo.peek(ptr) == static_cast<int>(returnvalue::FAILED));
+
+    REQUIRE(fifo.peek(&testptr) == static_cast<int>(returnvalue::OK));
+    equal = testptr == structTwo;
+    REQUIRE(equal);
+    REQUIRE(fifo.pop() == static_cast<int>(returnvalue::OK));
+    REQUIRE(fifo.size() == 0);
+    REQUIRE(fifo.empty());
+  };
+  SECTION("Copy Test") {
+    REQUIRE(fifo.insert(structOne) == static_cast<int>(returnvalue::OK));
+    REQUIRE(fifo.insert(structTwo) == static_cast<int>(returnvalue::OK));
+    REQUIRE(fifo.insert(structThree) == static_cast<int>(returnvalue::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>(returnvalue::OK));
+      bool equal = testptr == list[i];
+      REQUIRE(equal);
+      REQUIRE(fifo2.size() == i);
+    }
+  };
+
+  SECTION("Assignment Test") {
+    REQUIRE(fifo.insert(structOne) == static_cast<int>(returnvalue::OK));
+    REQUIRE(fifo.insert(structTwo) == static_cast<int>(returnvalue::OK));
+    REQUIRE(fifo.insert(structThree) == static_cast<int>(returnvalue::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>(returnvalue::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/returnvalue.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+
+TEST_CASE("FixedArrayList Tests", "[containers]") {
+  INFO("FixedArrayList Tests");
+  using testList = FixedArrayList<uint32_t, 260, uint16_t>;
+  testList list;
+  REQUIRE(list.size == 0);
+  REQUIRE(list.insert(10) == static_cast<int>(returnvalue::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>(returnvalue::OK));
+    }
+    REQUIRE(list.insert(260) == static_cast<int>(containers::LIST_FULL));
+    list.clear();
+    REQUIRE(list.size == 0);
+  }
+}

unittests/container/TestFixedMap.cpp

@@ -0,0 +1,165 @@
+#include <fsfw/container/FixedMap.h>
+#include <fsfw/returnvalues/returnvalue.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+
+template class FixedMap<unsigned int, unsigned short>;
+
+using namespace returnvalue;
+
+TEST_CASE("FixedMap Tests", "[containers]") {
+  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>(returnvalue::OK));
+      REQUIRE(map.exists(i) == static_cast<int>(returnvalue::OK));
+      REQUIRE(map.find(i)->second == i + 1);
+      REQUIRE(not map.empty());
+    }
+    REQUIRE(map.insert(0, 0) == static_cast<int>(containers::KEY_ALREADY_EXISTS));
+    REQUIRE(map.insert(31, 0) == static_cast<int>(containers::MAP_FULL));
+    REQUIRE(map.exists(31) == static_cast<int>(containers::KEY_DOES_NOT_EXIST));
+    REQUIRE(map.size() == 30);
+    REQUIRE(map.full());
+    {
+      uint16_t* ptr;
+      REQUIRE(map.find(5, &ptr) == static_cast<int>(returnvalue::OK));
+      REQUIRE(*ptr == 6);
+      REQUIRE(*(map.findValue(6)) == 7);
+      REQUIRE(map.find(31, &ptr) == static_cast<int>(containers::KEY_DOES_NOT_EXIST));
+    }
+
+    REQUIRE(map.getSerializedSize() ==
+            (sizeof(uint32_t) + 30 * (sizeof(uint32_t) + sizeof(uint16_t))));
+    REQUIRE(map.erase(2) == static_cast<int>(returnvalue::OK));
+    REQUIRE(map.erase(31) == static_cast<int>(containers::KEY_DOES_NOT_EXIST));
+    REQUIRE(map.exists(2) == static_cast<int>(containers::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>(returnvalue::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>(returnvalue::OK));
+    REQUIRE(it->first == 36);
+    REQUIRE(it->second == 37);
+    REQUIRE(map.size() == 1);
+    REQUIRE(map.insert(37, 38, nullptr) == static_cast<int>(returnvalue::OK));
+    REQUIRE(map.find(37)->second == 38);
+    REQUIRE(map.size() == 2);
+    REQUIRE(map.insert(37, 24, nullptr) == static_cast<int>(containers::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>(returnvalue::OK));
+    REQUIRE(map.insert(37, 38, nullptr) == static_cast<int>(returnvalue::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>(returnvalue::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>(returnvalue::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>(returnvalue::OK));
+      REQUIRE(first_element == i);
+      uint16_t second_element = 0;
+      REQUIRE(SerializeAdapter::deSerialize(&second_element, &ptr2, &size,
+                                            SerializeIF::Endianness::BIG) ==
+              static_cast<int>(returnvalue::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>(returnvalue::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>(containers::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>(returnvalue::OK));
+    map.clear();
+    REQUIRE(map.size() == 0);
+    const uint8_t* ptr2 = newBuffer;
+    REQUIRE(map.deSerialize(&ptr2, &size, SerializeIF::Endianness::LITTLE) ==
+            static_cast<int>(returnvalue::OK));
+    REQUIRE(map.size() == 1);
+    REQUIRE(map.find(10)->second == 20);
+  };
+}

unittests/container/TestFixedOrderedMultimap.cpp

@@ -0,0 +1,216 @@
+#include <fsfw/container/FixedOrderedMultimap.h>
+#include <fsfw/returnvalues/returnvalue.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+
+TEST_CASE("FixedOrderedMultimap Tests", "[containers]") {
+  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>(returnvalue::OK));
+      REQUIRE(map.exists(i) == static_cast<int>(returnvalue::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>(returnvalue::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>(returnvalue::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>(returnvalue::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>(returnvalue::OK));
+    REQUIRE(it->first == 36);
+    REQUIRE(it->second == 37);
+    REQUIRE(map.size() == 1);
+    REQUIRE(map.insert(37, 38, nullptr) == static_cast<int>(returnvalue::OK));
+    REQUIRE(map.find(37)->second == 38);
+    REQUIRE(map.size() == 2);
+    REQUIRE(map.insert(37, 24, nullptr) == static_cast<int>(returnvalue::OK));
+    REQUIRE(map.find(37)->second == 38);
+    REQUIRE(map.insert(0, 1, nullptr) == static_cast<int>(returnvalue::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>(returnvalue::OK));
+      REQUIRE(map.exists(i) == static_cast<int>(returnvalue::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>(returnvalue::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>(returnvalue::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>(returnvalue::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>(returnvalue::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>(returnvalue::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>(returnvalue::OK));
+    compare = map.find(37)->second == TestClass(38, 37);
+    REQUIRE(compare);
+    REQUIRE(map.insert(0, TestClass(1, 0), nullptr) == static_cast<int>(returnvalue::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/returnvalue.h>
+#include <fsfw/storagemanager/LocalPool.h>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+
+TEST_CASE("PlacementFactory Tests", "[containers]") {
+  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>(returnvalue::OK));
+    REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr) ==
+            static_cast<int>(returnvalue::OK));
+    REQUIRE(storagePool.deleteData(address) == static_cast<int>(returnvalue::OK));
+
+    // Check that PlacementFactory checks for nullptr
+    ptr = nullptr;
+    REQUIRE(factory.destroy(ptr) == static_cast<int>(returnvalue::FAILED));
+  }
+}

unittests/datapoollocal/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(
+  ${FSFW_TEST_TGT} PRIVATE testLocalPoolVariable.cpp testLocalPoolVector.cpp
+                           testDataSet.cpp testLocalPoolManager.cpp)

unittests/datapoollocal/testDataSet.cpp

@@ -0,0 +1,282 @@
+#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 "mocks/LocalPoolOwnerBase.h"
+#include "mocks/MessageQueueMock.h"
+#include "tests/TestsConfig.h"
+
+using namespace returnvalue;
+
+TEST_CASE("DataSetTest", "[DataSetTest]") {
+  auto queue = MessageQueueMock(1);
+  LocalPoolOwnerBase poolOwner(queue, objects::TEST_LOCAL_POOL_OWNER_BASE);
+  REQUIRE(poolOwner.initializeHkManager() == OK);
+  REQUIRE(poolOwner.initializeHkManagerAfterTaskCreation() == 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 */
+    auto* lpIds = reinterpret_cast<lp_id_t*>(localPoolIdBuff + 1);
+    size_t serSize = 0;
+    auto* localPoolIdBuffPtr = reinterpret_cast<uint8_t*>(localPoolIdBuff);
+
+    /* Test local pool ID serialization */
+    CHECK(localSet.serializeLocalPoolIds(&localPoolIdBuffPtr, &serSize, maxSize,
+                                         SerializeIF::Endianness::MACHINE) == returnvalue::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) == 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() == returnvalue::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() == returnvalue::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) ==
+            returnvalue::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) == returnvalue::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) ==
+            returnvalue::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) == returnvalue::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) == returnvalue::OK);
+    }
+    REQUIRE(set.registerVariable(&localSet.localPoolVarUint8) == returnvalue::OK);
+    REQUIRE(set.registerVariable(&localSet.localPoolUint16Vec) == returnvalue::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) == 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) ==
+          returnvalue::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) == returnvalue::OK);
+    CHECK(sharedSet.registerVariable(&localSet.localPoolUint16Vec) == returnvalue::OK);
+    CHECK(sharedSet.initialize() == returnvalue::OK);
+    CHECK(sharedSet.lockDataset() == returnvalue::OK);
+    CHECK(sharedSet.unlockDataset() == returnvalue::OK);
+
+    {
+      // PoolReadGuard rg(&sharedSet);
+      // CHECK(rg.getReadResult() == result::OK);
+      localSet.localPoolVarUint8.value = 5;
+      localSet.localPoolUint16Vec.value[0] = 1;
+      localSet.localPoolUint16Vec.value[1] = 2;
+      localSet.localPoolUint16Vec.value[2] = 3;
+      CHECK(sharedSet.commit() == returnvalue::OK);
+    }
+
+    sharedSet.setReadCommitProtectionBehaviour(true);
+  }
+}

unittests/datapoollocal/testLocalPoolManager.cpp

@@ -0,0 +1,429 @@
+#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 "mocks/HkReceiverMock.h"
+#include "mocks/LocalPoolOwnerBase.h"
+
+TEST_CASE("Local Pool Manager Tests", "[LocManTest]") {
+  const MessageQueueId_t defaultDestId = 1;
+  const MessageQueueId_t hkDest = defaultDestId;
+  const MessageQueueId_t subscriberId = 2;
+  auto hkReceiver = HkReceiverMock(hkDest);
+  auto queue = MessageQueueMock(3);
+  LocalPoolOwnerBase poolOwner(queue, objects::TEST_LOCAL_POOL_OWNER_BASE);
+  REQUIRE(poolOwner.initializeHkManager() == returnvalue::OK);
+  REQUIRE(poolOwner.initializeHkManagerAfterTaskCreation() == returnvalue::OK);
+
+  MessageQueueMock& poolOwnerMock = poolOwner.getMockQueueHandle();
+
+  // TODO: This is ugly. This should be an arbitrary ctor argument. Fix this in the pool
+  //       manager
+  poolOwnerMock.setDefaultDestination(defaultDestId);
+  poolOwner.setHkDestId(hkDest);
+
+  auto* hkMan = poolOwner.getHkManagerHandle();
+
+  CommandMessage messageSent;
+
+  SECTION("Basic Test") {
+    {
+      /* 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(subscriberId) == returnvalue::OK);
+    /* Subscribe for an update message. */
+    poolOwner.dataset.setChanged(true);
+    /* Now the update message should be generated. */
+    REQUIRE(poolOwner.poolManager.performHkOperation() == returnvalue::OK);
+    REQUIRE(poolOwnerMock.wasMessageSent());
+
+    REQUIRE(poolOwnerMock.getNextSentMessage(subscriberId, messageSent) == returnvalue::OK);
+    CHECK(messageSent.getCommand() ==
+          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+
+    /* Should have been reset. */
+    CHECK(poolOwner.dataset.hasChanged() == false);
+    poolOwnerMock.clearMessages(true);
+    /* Set changed again, result should be the same. */
+    poolOwner.dataset.setChanged(true);
+    REQUIRE(poolOwner.poolManager.performHkOperation() == returnvalue::OK);
+
+    REQUIRE(poolOwnerMock.wasMessageSent() == true);
+    CHECK(poolOwnerMock.numberOfSentMessages() == 1);
+    REQUIRE(poolOwnerMock.getNextSentMessage(subscriberId, messageSent) == returnvalue::OK);
+    CHECK(messageSent.getCommand() ==
+          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+
+    poolOwnerMock.clearMessages(true);
+    /* Now subscribe for set update HK as well. */
+    REQUIRE(poolOwner.subscribeWrapperSetUpdateHk(false, &hkReceiver) == returnvalue::OK);
+    poolOwner.dataset.setChanged(true);
+    REQUIRE(poolOwner.poolManager.performHkOperation() == returnvalue::OK);
+    REQUIRE(poolOwnerMock.wasMessageSent() == true);
+    CHECK(poolOwnerMock.numberOfSentMessages() == 2);
+    // first message sent should be the update notification
+    REQUIRE(poolOwnerMock.getNextSentMessage(subscriberId, messageSent) == returnvalue::OK);
+    CHECK(messageSent.getCommand() ==
+          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+    REQUIRE(poolOwnerMock.getNextSentMessage(messageSent) == returnvalue::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() == returnvalue::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(subscriberId) == returnvalue::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() == returnvalue::OK);
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    CHECK(poolOwnerMock.numberOfSentMessages() == 1);
+    REQUIRE(poolOwnerMock.getNextSentMessage(subscriberId, messageSent) == returnvalue::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 == returnvalue::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) == returnvalue::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 == returnvalue::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(subscriberId, lpool::uint8VarId) ==
+            returnvalue::OK);
+    auto poolVar =
+        dynamic_cast<lp_var_t<uint8_t>*>(poolOwner.getPoolObjectHandle(lpool::uint8VarId));
+    REQUIRE(poolVar != nullptr);
+
+    {
+      PoolReadGuard rg(poolVar);
+      CHECK(rg.getReadResult() == returnvalue::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() == returnvalue::OK);
+
+    /* Check update snapshot was sent. */
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    CHECK(poolOwnerMock.numberOfSentMessages() == 1);
+
+    /* Should have been reset. */
+    CHECK(poolVar->hasChanged() == false);
+    REQUIRE(poolOwnerMock.getNextSentMessage(subscriberId, messageSent) == returnvalue::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 == returnvalue::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) == returnvalue::OK);
+    CHECK(varCopy.value == 25);
+
+    /* Now we check that both times are equal */
+    timeval timeFromHK{};
+    auto result = CCSDSTime::convertFromCDS(&timeFromHK, &cdsShort);
+    CHECK(result == returnvalue::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(subscriberId, lpool::uint8VarId) ==
+            returnvalue::OK);
+    auto* 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() == returnvalue::OK);
+
+    /* Check update notification was sent. */
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    CHECK(poolOwnerMock.numberOfSentMessages() == 1);
+    /* Should have been reset. */
+    CHECK(poolVar->hasChanged() == false);
+    REQUIRE(poolOwnerMock.getNextSentMessage(subscriberId, messageSent) == returnvalue::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,
+                                                         subscriberId, false) == returnvalue::OK);
+    REQUIRE(poolOwner.subscribeWrapperSetUpdateHk(false, &hkReceiver) == returnvalue::OK);
+
+    poolOwner.dataset.setChanged(true);
+    poolOwnerMock.clearMessages();
+    REQUIRE(poolOwner.poolManager.performHkOperation() == returnvalue::OK);
+    /* Now two messages should be sent. */
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    CHECK(poolOwnerMock.numberOfSentMessages() == 2);
+    poolOwnerMock.clearMessages(true);
+
+    poolOwner.dataset.setChanged(true);
+    poolOwnerMock.clearMessages(true);
+    poolVar->setChanged(true);
+    REQUIRE(poolOwner.poolManager.performHkOperation() == returnvalue::OK);
+    /* Now three messages should be sent. */
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    CHECK(poolOwnerMock.numberOfSentMessages() == 3);
+    CHECK(poolOwnerMock.numberOfSentMessagesToDest(subscriberId) == 2);
+    CHECK(poolOwnerMock.numberOfSentMessagesToDest(hkDest) == 1);
+    REQUIRE(poolOwnerMock.getNextSentMessage(subscriberId, messageSent) == returnvalue::OK);
+    CHECK(messageSent.getCommand() ==
+          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
+    REQUIRE(poolOwnerMock.clearLastSentMessage(subscriberId) == returnvalue::OK);
+    REQUIRE(poolOwnerMock.getNextSentMessage(subscriberId, messageSent) == returnvalue::OK);
+    CHECK(messageSent.getCommand() ==
+          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_SET));
+    REQUIRE(poolOwnerMock.clearLastSentMessage(subscriberId) == returnvalue::OK);
+    REQUIRE(poolOwnerMock.getNextSentMessage(messageSent) == returnvalue::OK);
+    CHECK(messageSent.getCommand() == static_cast<int>(HousekeepingMessage::HK_REPORT));
+    REQUIRE(poolOwnerMock.clearLastSentMessage() == returnvalue::OK);
+    REQUIRE(poolOwnerMock.getNextSentMessage(subscriberId, messageSent) == MessageQueueIF::EMPTY);
+    REQUIRE(poolOwnerMock.getNextSentMessage(messageSent) == 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) == returnvalue::OK);
+    REQUIRE(poolOwner.poolManager.performHkOperation() == returnvalue::OK);
+    /* Now HK packet should be sent as message immediately. */
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    CHECK(poolOwnerMock.numberOfSentMessages() == 1);
+    CHECK(poolOwnerMock.clearLastSentMessage() == returnvalue::OK);
+
+    LocalPoolDataSetBase* setHandle = poolOwner.getDataSetHandle(lpool::testSid);
+    REQUIRE(setHandle != nullptr);
+    CHECK(poolOwner.poolManager.generateHousekeepingPacket(lpool::testSid, setHandle, false) ==
+          returnvalue::OK);
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    CHECK(poolOwnerMock.numberOfSentMessages() == 1);
+    CHECK(poolOwnerMock.clearLastSentMessage() == returnvalue::OK);
+
+    CHECK(setHandle->getReportingEnabled() == true);
+    CommandMessage hkCmd;
+    HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, false, false);
+    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
+    CHECK(setHandle->getReportingEnabled() == false);
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    CHECK(poolOwnerMock.numberOfSentMessages() == 1);
+    CHECK(poolOwnerMock.clearLastSentMessage() == returnvalue::OK);
+
+    HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, true, false);
+    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
+    CHECK(setHandle->getReportingEnabled() == true);
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    CHECK(poolOwnerMock.clearLastSentMessage() == returnvalue::OK);
+
+    HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, false, false);
+    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
+    CHECK(setHandle->getReportingEnabled() == false);
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    CHECK(poolOwnerMock.clearLastSentMessage() == returnvalue::OK);
+
+    HousekeepingMessage::setCollectionIntervalModificationCommand(&hkCmd, lpool::testSid, 0.4,
+                                                                  false);
+    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::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());
+    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
+    CHECK(poolOwnerMock.clearLastSentMessage() == returnvalue::OK);
+
+    HousekeepingMessage::setStructureReportingCommand(&hkCmd, lpool::testSid, false);
+    REQUIRE(poolOwner.poolManager.performHkOperation() == returnvalue::OK);
+    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
+    /* Now HK packet should be sent as message. */
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
+    poolOwnerMock.clearMessages();
+
+    HousekeepingMessage::setOneShotReportCommand(&hkCmd, lpool::testSid, false);
+    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
+    poolOwnerMock.clearMessages();
+
+    HousekeepingMessage::setUpdateNotificationSetCommand(&hkCmd, lpool::testSid);
+    sid_t sidToCheck;
+    store_address_t storeId;
+    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::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());
+    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
+    CHECK(poolOwnerMock.clearLastSentMessage() == returnvalue::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());
+    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
+    CHECK(poolOwnerMock.clearLastSentMessage() == returnvalue::OK);
+
+    HousekeepingMessage::setStructureReportingCommand(&hkCmd, lpool::testSid, false);
+    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) ==
+          static_cast<int>(LocalDataPoolManager::WRONG_HK_PACKET_TYPE));
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
+    CHECK(poolOwnerMock.clearLastSentMessage() == returnvalue::OK);
+
+    HousekeepingMessage::setStructureReportingCommand(&hkCmd, lpool::testSid, true);
+    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
+    poolOwnerMock.clearMessages();
+
+    HousekeepingMessage::setCollectionIntervalModificationCommand(&hkCmd, lpool::testSid, 0.4,
+                                                                  true);
+    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
+    poolOwnerMock.clearMessages();
+
+    HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, true, true);
+    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
+    poolOwnerMock.clearMessages();
+
+    HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, false, true);
+    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
+    poolOwnerMock.clearMessages();
+
+    HousekeepingMessage::setOneShotReportCommand(&hkCmd, lpool::testSid, false);
+    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) ==
+          static_cast<int>(LocalDataPoolManager::WRONG_HK_PACKET_TYPE));
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
+    poolOwnerMock.clearMessages();
+
+    HousekeepingMessage::setOneShotReportCommand(&hkCmd, lpool::testSid, true);
+    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
+    poolOwnerMock.clearMessages();
+
+    HousekeepingMessage::setUpdateNotificationVariableCommand(&hkCmd, lpool::uint8VarGpid);
+    gp_id_t gpidToCheck;
+    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
+    CHECK(poolOwner.changedVariableCallbackWasCalled(gpidToCheck, storeId) == true);
+    CHECK(gpidToCheck == lpool::uint8VarGpid);
+
+    HousekeepingMessage::setUpdateSnapshotSetCommand(&hkCmd, lpool::testSid,
+                                                     store_address_t::invalid());
+    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
+    CHECK(poolOwner.changedDataSetCallbackWasCalled(sidToCheck, storeId) == true);
+    CHECK(sidToCheck == lpool::testSid);
+
+    HousekeepingMessage::setUpdateSnapshotVariableCommand(&hkCmd, lpool::uint8VarGpid,
+                                                          store_address_t::invalid());
+    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::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() == returnvalue::OK);
+  poolOwnerMock.clearMessages(true);
+}

unittests/datapoollocal/testLocalPoolVariable.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 "mocks/LocalPoolOwnerBase.h"
+#include "tests/TestsConfig.h"
+
+using namespace returnvalue;
+
+TEST_CASE("LocalPoolVariable", "[LocPoolVarTest]") {
+  auto queue = MessageQueueMock(1);
+  LocalPoolOwnerBase poolOwner(queue, objects::TEST_LOCAL_POOL_OWNER_BASE);
+  REQUIRE(poolOwner.initializeHkManager() == OK);
+  REQUIRE(poolOwner.initializeHkManagerAfterTaskCreation() == 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() == returnvalue::OK);
+    CHECK(testVariable.value == 0);
+    testVariable.value = 5;
+    REQUIRE(testVariable.commit() == returnvalue::OK);
+    REQUIRE(testVariable.read() == returnvalue::OK);
+    REQUIRE(testVariable.value == 5);
+    CHECK(not testVariable.isValid());
+    testVariable.setValid(true);
+    CHECK(testVariable.isValid());
+    CHECK(testVariable.commit(true) == returnvalue::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() == returnvalue::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) ==
+          returnvalue::OK);
+    CHECK(variableRaw == 10);
+    const uint8_t* varConstPtr = &variableRaw;
+    testVariable = 5;
+    CHECK(testVariable.deSerialize(&varConstPtr, &serSize, SerializeIF::Endianness::MACHINE) ==
+          returnvalue::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);
+  }
+}

unittests/datapoollocal/testLocalPoolVector.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 "mocks/LocalPoolOwnerBase.h"
+#include "tests/TestsConfig.h"
+
+using namespace returnvalue;
+
+TEST_CASE("LocalPoolVector", "[LocPoolVecTest]") {
+  auto queue = MessageQueueMock(1);
+  LocalPoolOwnerBase poolOwner(queue, objects::TEST_LOCAL_POOL_OWNER_BASE);
+  REQUIRE(poolOwner.initializeHkManager() == OK);
+  REQUIRE(poolOwner.initializeHkManagerAfterTaskCreation() == 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() == returnvalue::OK);
+    testVector.value[0] = 5;
+    testVector.value[1] = 232;
+    testVector.value[2] = 32023;
+
+    REQUIRE(testVector.commit(true) == returnvalue::OK);
+    CHECK(testVector.isValid());
+
+    testVector.value[0] = 0;
+    testVector.value[1] = 0;
+    testVector.value[2] = 0;
+
+    CHECK(testVector.read() == returnvalue::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() == returnvalue::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) ==
+            returnvalue::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) ==
+            returnvalue::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));
+  }
+}

unittests/devicehandler/CMakeLists.txt

@@ -0,0 +1,2 @@
+target_sources(${FSFW_TEST_TGT} PRIVATE DeviceHandlerCommander.cpp
+                                        TestDeviceHandlerBase.cpp)

unittests/devicehandler/DeviceHandlerCommander.cpp

@@ -0,0 +1,66 @@
+#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() {
+  QueueFactory::instance()->deleteMessageQueue(commandQueue);
+}
+
+ReturnValue_t DeviceHandlerCommander::performOperation(uint8_t operationCode) {
+  readCommandQueue();
+  return returnvalue::OK;
+}
+
+ReturnValue_t DeviceHandlerCommander::initialize() {
+  ReturnValue_t result = commandActionHelper.initialize();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  return returnvalue::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 = returnvalue::OK;
+}
+
+void DeviceHandlerCommander::completionFailedReceived(ActionId_t actionId,
+                                                      ReturnValue_t returnCode) {
+  lastReplyReturnCode = returnCode;
+}
+
+void DeviceHandlerCommander::readCommandQueue() {
+  CommandMessage message;
+  ReturnValue_t result = returnvalue::OK;
+  for (result = commandQueue->receiveMessage(&message); result == returnvalue::OK;
+       result = commandQueue->receiveMessage(&message)) {
+    result = commandActionHelper.handleReply(&message);
+    if (result == returnvalue::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 = returnvalue::FAILED; }

unittests/devicehandler/DeviceHandlerCommander.h

@@ -0,0 +1,49 @@
+#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/returnvalue.h"
+#include "fsfw/tasks/ExecutableObjectIF.h"
+
+class DeviceHandlerCommander : public ExecutableObjectIF,
+                               public SystemObject,
+                               public CommandsActionsIF {
+ 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 = returnvalue::FAILED;
+
+  void readCommandQueue();
+};
+
+#endif /* TESTS_SRC_FSFW_TESTS_UNIT_DEVICEHANDLER_DEVICEHANDLERCOMMANDER_H_ */

unittests/devicehandler/TestDeviceHandlerBase.cpp

@@ -0,0 +1,95 @@
+#include <catch2/catch_test_macros.hpp>
+
+#include "DeviceHandlerCommander.h"
+#include "mocks/ComIFMock.h"
+#include "mocks/CookieIFMock.h"
+#include "mocks/DeviceFdirMock.h"
+#include "mocks/DeviceHandlerMock.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 == returnvalue::OK);
+  DeviceHandlerCommander deviceHandlerCommander(objects::DEVICE_HANDLER_COMMANDER);
+  result = deviceHandlerCommander.initialize();
+  REQUIRE(result == returnvalue::OK);
+
+  SECTION("Commanding nominal") {
+    comIF.setTestCase(ComIFMock::TestCase::SIMPLE_COMMAND_NOMINAL);
+    result = deviceHandlerCommander.sendCommand(objects::DEVICE_HANDLER_MOCK,
+                                                DeviceHandlerMock::SIMPLE_COMMAND);
+    REQUIRE(result == returnvalue::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 == returnvalue::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 == returnvalue::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,3 @@
+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 = returnvalue::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 == returnvalue::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 == returnvalue::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,128 @@
+#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;
+    if (sizeof(t1.tv_sec) == 8) {
+      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;
+      // Overflow test
+      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,5 @@
+target_sources(${FSFW_TEST_TGT} PRIVATE testHostFilesystem.cpp testFsMock.cpp)
+
+if(UNIX)
+  target_sources(${FSFW_TEST_TGT} PRIVATE testCommandExecutor.cpp)
+endif()

unittests/hal/testCommandExecutor.cpp

@@ -0,0 +1,128 @@
+#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", "[hal][linux]") {
+  // 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 == returnvalue::OK);
+  REQUIRE(cmdExecutor.execute() == returnvalue::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 == returnvalue::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) == returnvalue::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() == returnvalue::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 < 500);
+  }
+  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 == returnvalue::OK);
+  result = cmdExecutor.execute();
+  REQUIRE(result == returnvalue::OK);
+  while (result != CommandExecutor::EXECUTION_FINISHED and result != returnvalue::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 == returnvalue::FAILED);
+  REQUIRE(cmdExecutor.getLastError() == 1);
+}
+
+#endif

unittests/hal/testFsMock.cpp

@@ -0,0 +1,49 @@
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/serialize/SerializeIF.h"
+#include "mocks/FilesystemMock.h"
+
+using namespace std;
+
+TEST_CASE("Filesystem Mock", "[mocks]") {
+  auto fsMock = FilesystemMock();
+
+  SECTION("Create File") {
+    FilesystemParams params("hello.txt");
+    CHECK(fsMock.createFile(params) == returnvalue::OK);
+    auto iter = fsMock.fileMap.find("hello.txt");
+    REQUIRE(iter != fsMock.fileMap.end());
+    FilesystemMock::FileInfo &stats = iter->second;
+    CHECK(stats.fileSegQueue.empty());
+    CHECK(stats.fileRaw.empty());
+  }
+
+  SECTION("Write to File") {
+    std::string testData = "test data";
+    FileOpParams params("hello.txt", testData.size());
+    CHECK(fsMock.writeToFile(params, reinterpret_cast<const uint8_t *>(testData.data())) ==
+          returnvalue::OK);
+    auto iter = fsMock.fileMap.find("hello.txt");
+    REQUIRE(iter != fsMock.fileMap.end());
+    FilesystemMock::FileInfo &stats = iter->second;
+    CHECK(not stats.fileSegQueue.empty());
+    CHECK(not stats.fileRaw.empty());
+    auto &segment = stats.fileSegQueue.back();
+    CHECK(segment.offset == 0);
+    CHECK(std::string(reinterpret_cast<const char *>(segment.data.data()), segment.data.size()) ==
+          testData);
+    CHECK(std::string(reinterpret_cast<const char *>(stats.fileRaw.data()), segment.data.size()) ==
+          testData);
+  }
+
+  SECTION("Create Directory") {
+    FilesystemParams params("hello");
+    CHECK(fsMock.createDirectory(params) == returnvalue::OK);
+    REQUIRE(not fsMock.dirMap.empty());
+    auto iter = fsMock.dirMap.find("hello");
+    REQUIRE(iter != fsMock.dirMap.end());
+    auto &dirInfo = iter->second;
+    CHECK(dirInfo.createCallCount == 1);
+    CHECK(dirInfo.delCallCount == 0);
+  }
+}

unittests/hal/testHostFilesystem.cpp

@@ -0,0 +1,228 @@
+#include <etl/crc32.h>
+
+#include <catch2/catch_test_macros.hpp>
+#include <filesystem>
+#include <fstream>
+#include <random>
+
+#include "fsfw/serialize/SerializeIF.h"
+#include "fsfw_hal/host/HostFilesystem.h"
+
+using namespace std;
+
+TEST_CASE("Host Filesystem", "[hal][host]") {
+  namespace fs = filesystem;
+  auto hostFs = HostFilesystem();
+  auto tmpDir = fs::temp_directory_path();
+  fs::path file0 = tmpDir / "hello.txt";
+  fs::path file1 = tmpDir / "hello2.txt";
+  fs::path dir0 = tmpDir / "test_dir";
+  fs::path fileInDir0 = dir0 / "hello.txt";
+  fs::path dirWithParent = dir0 / "test_dir";
+
+  REQUIRE_NOTHROW(fs::remove(file0));
+  REQUIRE_NOTHROW(fs::remove(file1));
+  REQUIRE_NOTHROW(fs::remove_all(dir0));
+
+  SECTION("Create file") {
+    FilesystemParams params(file0.c_str());
+    REQUIRE(hostFs.createFile(params) == returnvalue::OK);
+    CHECK(fs::is_regular_file(file0));
+    REQUIRE(fs::exists(file0));
+  }
+
+  SECTION("Remove File") {
+    FilesystemParams params(file0.c_str());
+    REQUIRE(hostFs.createFile(params) == returnvalue::OK);
+    CHECK(fs::is_regular_file(file0));
+    REQUIRE(fs::exists(file0));
+    REQUIRE(hostFs.removeFile(file0.c_str()) == returnvalue::OK);
+    REQUIRE(not fs::exists(file0));
+  }
+
+  SECTION("Create Directory") {
+    FilesystemParams params(dir0.c_str());
+    REQUIRE(hostFs.createDirectory(params) == returnvalue::OK);
+    CHECK(fs::is_directory(dir0));
+    REQUIRE(fs::exists(dir0));
+  }
+
+  SECTION("Remove Directory") {
+    FilesystemParams params(dir0.c_str());
+    REQUIRE(hostFs.createDirectory(params) == returnvalue::OK);
+    REQUIRE(fs::exists(dir0));
+    REQUIRE(hostFs.removeDirectory(params) == returnvalue::OK);
+    REQUIRE(not fs::exists(dir0));
+  }
+
+  SECTION("Rename File") {
+    FilesystemParams params(file0.c_str());
+    REQUIRE(hostFs.createFile(params) == returnvalue::OK);
+    CHECK(fs::is_regular_file(file0));
+    REQUIRE(fs::exists(file0));
+    REQUIRE(hostFs.rename(file0.c_str(), file1.c_str()) == returnvalue::OK);
+  }
+
+  SECTION("Write To File") {
+    std::string data = "hello world!";
+    FileOpParams params(file0.c_str(), data.size());
+    REQUIRE(hostFs.createFile(params.fsParams) == returnvalue::OK);
+    CHECK(fs::is_regular_file(file0));
+    REQUIRE(fs::exists(file0));
+    CHECK(hostFs.writeToFile(params, reinterpret_cast<const uint8_t*>(data.c_str())) ==
+          returnvalue::OK);
+    CHECK(fs::file_size(file0) == data.size());
+    ifstream ifile(file0);
+    std::array<char, 524> readBuf{};
+    ifile.read(readBuf.data(), sizeof(readBuf));
+    std::string readBackString(readBuf.data());
+    CHECK(data == readBackString);
+  }
+
+  SECTION("Write To File, Check Not Truncated") {
+    std::random_device dev;
+    std::mt19937 rng(dev());
+    std::uniform_int_distribution<std::mt19937::result_type> distU8(1, 255);
+    std::array<uint8_t, 512> randData{};
+    for (uint8_t& byte : randData) {
+      byte = distU8(rng);
+    }
+    FileOpParams params(file0.c_str(), randData.size() - 256);
+    REQUIRE(hostFs.createFile(params.fsParams) == returnvalue::OK);
+    CHECK(fs::is_regular_file(file0));
+    REQUIRE(fs::exists(file0));
+    // Write first file chunk
+    CHECK(hostFs.writeToFile(params, randData.cbegin()) == returnvalue::OK);
+    params.offset = 256;
+    CHECK(hostFs.writeToFile(params, randData.cbegin() + 256) == returnvalue::OK);
+    std::ifstream rf(file0, ios::binary);
+    std::array<uint8_t, 512> readBack{};
+    REQUIRE(std::filesystem::file_size(file0) == 512);
+    rf.read(reinterpret_cast<char*>(readBack.data()), readBack.size());
+    for (size_t i = 0; i < 512; i++) {
+      CHECK(randData[i] == readBack[i]);
+    }
+  }
+
+  SECTION("Read From File") {
+    std::string data = "hello world!";
+    FileOpParams params(file0.c_str(), data.size());
+    REQUIRE(hostFs.createFile(params.fsParams) == returnvalue::OK);
+    CHECK(fs::is_regular_file(file0));
+    ofstream of(file0);
+    of.write(data.c_str(), static_cast<unsigned int>(data.size()));
+    of.close();
+    CHECK(fs::file_size(file0) == data.size());
+    REQUIRE(fs::exists(file0));
+    std::array<uint8_t, 256> readBuf{};
+    uint8_t* readPtr = readBuf.data();
+    size_t readSize = 0;
+    CHECK(hostFs.readFromFile(params, &readPtr, readSize, readBuf.size()) == returnvalue::OK);
+    std::string readBackString(reinterpret_cast<const char*>(readBuf.data()));
+    CHECK(readSize == data.size());
+    CHECK(data == readBackString);
+  }
+
+  SECTION("Invalid Input does not crash") {
+    FileOpParams params(nullptr, 10);
+    REQUIRE(hostFs.createFile(params.fsParams) != returnvalue::OK);
+    REQUIRE(hostFs.createDirectory(params.fsParams) != returnvalue::OK);
+    REQUIRE(hostFs.createFile(params.fsParams) != returnvalue::OK);
+    REQUIRE(hostFs.removeDirectory(params.fsParams) != returnvalue::OK);
+    REQUIRE(hostFs.removeFile(nullptr) != returnvalue::OK);
+    REQUIRE(hostFs.rename(nullptr, nullptr) != returnvalue::OK);
+    REQUIRE(hostFs.writeToFile(params, nullptr) != returnvalue::OK);
+    size_t readLen = 0;
+    REQUIRE(hostFs.readFromFile(params, nullptr, readLen, 20) != returnvalue::OK);
+  }
+
+  SECTION("Create File but already exists") {
+    FilesystemParams params(file0.c_str());
+    REQUIRE(hostFs.createFile(params) == returnvalue::OK);
+    REQUIRE(hostFs.createFile(params) == HasFileSystemIF::FILE_ALREADY_EXISTS);
+  }
+
+  SECTION("Remove File but does not exist") {
+    REQUIRE(hostFs.removeFile(file0.c_str()) == HasFileSystemIF::FILE_DOES_NOT_EXIST);
+  }
+
+  SECTION("Create Directory but already exists") {
+    FileOpParams params(file0.c_str(), 12);
+    REQUIRE(hostFs.createDirectory(params.fsParams) == returnvalue::OK);
+    REQUIRE(hostFs.createDirectory(params.fsParams) == HasFileSystemIF::DIRECTORY_ALREADY_EXISTS);
+  }
+
+  SECTION("Remove Directory but does not exist") {
+    FilesystemParams params(dir0.c_str());
+    REQUIRE(hostFs.removeDirectory(params) == HasFileSystemIF::DIRECTORY_DOES_NOT_EXIST);
+  }
+
+  SECTION("Remove Directory but is file") {
+    ofstream of(file0);
+    FilesystemParams params(file0.c_str());
+    REQUIRE(hostFs.removeDirectory(params) == HasFileSystemIF::NOT_A_DIRECTORY);
+  }
+
+  SECTION("Read from file but does not exist") {
+    std::string data = "hello world!";
+    FileOpParams params(file0.c_str(), data.size());
+    std::array<uint8_t, 10> readBuf{};
+    uint8_t* readPtr = readBuf.data();
+    size_t readSize = 0;
+    CHECK(hostFs.readFromFile(params, &readPtr, readSize, readBuf.size()) ==
+          HasFileSystemIF::FILE_DOES_NOT_EXIST);
+  }
+
+  SECTION("Write to file but does not exist") {
+    std::string data = "hello world!";
+    FileOpParams params(file0.c_str(), data.size());
+    CHECK(hostFs.writeToFile(params, reinterpret_cast<const uint8_t*>(data.c_str())) ==
+          HasFileSystemIF::FILE_DOES_NOT_EXIST);
+  }
+
+  SECTION("Remove recursively") {
+    fs::create_directory(dir0.c_str());
+    ofstream of(fileInDir0);
+    CHECK(fs::is_directory(dir0));
+    CHECK(fs::is_regular_file(fileInDir0));
+    REQUIRE(hostFs.removeDirectory(FilesystemParams(dir0.c_str()), true) == returnvalue::OK);
+    CHECK(not fs::is_directory(dir0));
+    CHECK(not fs::is_regular_file(fileInDir0));
+  }
+
+  SECTION("Non-Recursive Removal Fails") {
+    fs::create_directory(dir0.c_str());
+    ofstream of(fileInDir0);
+    CHECK(fs::is_directory(dir0));
+    CHECK(fs::is_regular_file(fileInDir0));
+    REQUIRE(hostFs.removeDirectory(FilesystemParams(dir0.c_str())) ==
+            HasFileSystemIF::DIRECTORY_NOT_EMPTY);
+  }
+
+  SECTION("Create directory with parent directory") {
+    CHECK(hostFs.createDirectory(FilesystemParams(dirWithParent.c_str()), true) == returnvalue::OK);
+    CHECK(fs::is_directory(dir0));
+    CHECK(fs::is_directory(dirWithParent));
+  }
+
+  SECTION("Read but provided buffer too small") {
+    std::string data = "hello world!";
+    FileOpParams params(file0.c_str(), data.size());
+    ofstream of(file0);
+    of.write(data.c_str(), static_cast<unsigned int>(data.size()));
+    of.close();
+    CHECK(fs::file_size(file0) == data.size());
+    REQUIRE(fs::exists(file0));
+    std::array<uint8_t, 15> readBuf{};
+    uint8_t* readPtr = readBuf.data();
+    size_t readSize = 0;
+    CHECK(hostFs.readFromFile(params, &readPtr, readSize, 5) == SerializeIF::BUFFER_TOO_SHORT);
+    readSize = 10;
+    CHECK(hostFs.readFromFile(params, &readPtr, readSize, readBuf.size()) ==
+          SerializeIF::BUFFER_TOO_SHORT);
+  }
+
+  REQUIRE_NOTHROW(fs::remove(file0));
+  REQUIRE_NOTHROW(fs::remove(file1));
+  REQUIRE_NOTHROW(fs::remove_all(dir0));
+}

unittests/internalerror/CMakeLists.txt

@@ -0,0 +1 @@
+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);
+  auto* 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 == returnvalue::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 == returnvalue::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 == returnvalue::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 == returnvalue::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 == returnvalue::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 == returnvalue::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 == returnvalue::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 message2;
+      sid_t sid(objects::INTERNAL_ERROR_REPORTER, InternalErrorDataset::ERROR_SET_ID);
+      HousekeepingMessage::setToggleReportingCommand(&message2, sid, true, false);
+      result = hkQueue->sendMessage(id, &message2);
+      REQUIRE(result == returnvalue::OK);
+      internalErrorReporter->performOperation(0);
+    }
+  }
+  QueueFactory::instance()->deleteMessageQueue(testQueue);
+  QueueFactory::instance()->deleteMessageQueue(hkQueue);
+}

unittests/lcov_epilog.html

@@ -0,0 +1,2 @@
+<center><a href='https://www.uni-stuttgart.de/impressum'>Impressum</a> <a href='https://info.irs.uni-stuttgart.de/datenschutz/datenschutzWebmit.html'>Datenschutz</a></center>
+</body>

unittests/mocks/AcceptsTcMock.cpp

@@ -0,0 +1,8 @@
+#include "AcceptsTcMock.h"
+
+AcceptsTcMock::AcceptsTcMock(const char* name, uint32_t id, MessageQueueId_t queueId)
+    : name(name), id(id), queueId(queueId) {}
+
+const char* AcceptsTcMock::getName() const { return name; }
+uint32_t AcceptsTcMock::getIdentifier() const { return id; }
+MessageQueueId_t AcceptsTcMock::getRequestQueue() const { return queueId; }

unittests/mocks/AcceptsTcMock.h

@@ -0,0 +1,20 @@
+#ifndef FSFW_TESTS_ACCEPTSTCMOCK_H
+#define FSFW_TESTS_ACCEPTSTCMOCK_H
+
+#include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"
+
+class AcceptsTcMock : public AcceptsTelecommandsIF {
+ public:
+  AcceptsTcMock(const char* name, uint32_t id, MessageQueueId_t queueId);
+  [[nodiscard]] const char* getName() const override;
+  [[nodiscard]] uint32_t getIdentifier() const override;
+  [[nodiscard]] MessageQueueId_t getRequestQueue() const override;
+
+  const char* name;
+  uint32_t id;
+  MessageQueueId_t queueId;
+
+ private:
+};
+
+#endif  // FSFW_TESTS_ACCEPTSTCMOCK_H

unittests/mocks/AcceptsTmMock.cpp

@@ -0,0 +1,13 @@
+#include "AcceptsTmMock.h"
+
+AcceptsTmMock::AcceptsTmMock(object_id_t registeredId, MessageQueueId_t queueToReturn)
+    : SystemObject(registeredId), returnedQueue(queueToReturn) {}
+
+AcceptsTmMock::AcceptsTmMock(MessageQueueId_t queueToReturn)
+    : SystemObject(objects::NO_OBJECT, false), returnedQueue(queueToReturn) {}
+
+MessageQueueId_t AcceptsTmMock::getReportReceptionQueue(uint8_t virtualChannel) const {
+  return returnedQueue;
+}
+
+const char* AcceptsTmMock::getName() const { return "TM Acceptor Mock"; }

unittests/mocks/AcceptsTmMock.h

@@ -0,0 +1,17 @@
+#ifndef FSFW_TESTS_ACCEPTSTMMOCK_H
+#define FSFW_TESTS_ACCEPTSTMMOCK_H
+
+#include "fsfw/objectmanager/SystemObject.h"
+#include "fsfw/tmtcservices/AcceptsTelemetryIF.h"
+
+class AcceptsTmMock : public SystemObject, public AcceptsTelemetryIF {
+ public:
+  AcceptsTmMock(object_id_t registeredId, MessageQueueId_t queueToReturn);
+  explicit AcceptsTmMock(MessageQueueId_t queueToReturn);
+
+  MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel) const override;
+  const char* getName() const override;
+
+  MessageQueueId_t returnedQueue;
+};
+#endif  // FSFW_TESTS_ACCEPTSTMMOCK_H

unittests/mocks/CMakeLists.txt

@@ -0,0 +1,21 @@
+target_sources(
+  ${FSFW_TEST_TGT}
+  PRIVATE PowerSwitcherMock.cpp
+          DeviceHandlerMock.cpp
+          DeviceFdirMock.cpp
+          CookieIFMock.cpp
+          ComIFMock.cpp
+          MessageQueueMock.cpp
+          InternalErrorReporterMock.cpp
+          LocalPoolOwnerBase.cpp
+          PusVerificationReporterMock.cpp
+          PusServiceBaseMock.cpp
+          AcceptsTmMock.cpp
+          PusDistributorMock.cpp
+          CcsdsCheckerMock.cpp
+          AcceptsTcMock.cpp
+          StorageManagerMock.cpp
+          FilesystemMock.cpp
+          EventReportingProxyMock.cpp)
+
+add_subdirectory(cfdp)

unittests/mocks/CcsdsCheckerMock.cpp

@@ -0,0 +1,10 @@
+#include "CcsdsCheckerMock.h"
+
+CcsdsCheckerMock::CcsdsCheckerMock() = default;
+
+ReturnValue_t CcsdsCheckerMock::checkPacket(const SpacePacketReader& currentPacket,
+                                            size_t packetLen) {
+  checkCallCount++;
+  checkedPacketLen = packetLen;
+  return nextResult;
+}

unittests/mocks/CcsdsCheckerMock.h

@@ -0,0 +1,16 @@
+#ifndef FSFW_TESTS_CCSDSCHECKERMOCK_H
+#define FSFW_TESTS_CCSDSCHECKERMOCK_H
+
+#include "fsfw/tcdistribution/CcsdsPacketCheckIF.h"
+class CcsdsCheckerMock : public CcsdsPacketCheckIF {
+ public:
+  CcsdsCheckerMock();
+  unsigned int checkCallCount = 0;
+  size_t checkedPacketLen = 0;
+  ReturnValue_t nextResult = returnvalue::OK;
+  ReturnValue_t checkPacket(const SpacePacketReader& currentPacket, size_t packetLen) override;
+
+ private:
+};
+
+#endif  // FSFW_TESTS_CCSDSCHECKERMOCK_H

unittests/mocks/CdsShortTimestamperMock.h

@@ -0,0 +1,82 @@
+#ifndef FSFW_TESTS_CDSSHORTTIMESTAMPERMOCK_H
+#define FSFW_TESTS_CDSSHORTTIMESTAMPERMOCK_H
+
+#include <array>
+
+#include "fsfw/timemanager/TimeReaderIF.h"
+#include "fsfw/timemanager/TimeWriterIF.h"
+
+class CdsShortTimestamperMock : public TimeWriterIF, public TimeReaderIF {
+ public:
+  unsigned int serializeCallCount = 0;
+  unsigned int deserializeCallCount = 0;
+  ReturnValue_t lastDeserializeResult = returnvalue::OK;
+  ReturnValue_t lastSerializeResult = returnvalue::OK;
+  unsigned int getSizeCallCount = 0;
+  bool nextSerFails = false;
+  ReturnValue_t serFailRetval = returnvalue::FAILED;
+  bool nextDeserFails = false;
+  ReturnValue_t deserFailRetval = returnvalue::FAILED;
+  std::array<uint8_t, 7> valueToStamp{};
+
+  CdsShortTimestamperMock() = default;
+
+  explicit CdsShortTimestamperMock(std::array<uint8_t, 7> valueToStamp)
+      : valueToStamp(valueToStamp) {}
+
+  ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                          Endianness streamEndianness) const override {
+    auto &thisNonConst = const_cast<CdsShortTimestamperMock &>(*this);
+    thisNonConst.serializeCallCount += 1;
+    if (nextSerFails) {
+      return serFailRetval;
+    }
+    if (*size + getSerializedSize() > maxSize) {
+      thisNonConst.lastSerializeResult = SerializeIF::BUFFER_TOO_SHORT;
+      return lastSerializeResult;
+    }
+    std::copy(valueToStamp.begin(), valueToStamp.end(), *buffer);
+    thisNonConst.lastSerializeResult = returnvalue::OK;
+    *buffer += getSerializedSize();
+    *size += getSerializedSize();
+    return lastSerializeResult;
+  }
+  [[nodiscard]] size_t getSerializedSize() const override {
+    auto &thisNonConst = const_cast<CdsShortTimestamperMock &>(*this);
+    thisNonConst.getSizeCallCount += 1;
+    return valueToStamp.size();
+  }
+  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+                            Endianness streamEndianness) override {
+    deserializeCallCount += 1;
+    if (nextDeserFails) {
+      return deserFailRetval;
+    }
+    if (*size < 7) {
+      lastDeserializeResult = SerializeIF::STREAM_TOO_SHORT;
+      return lastDeserializeResult;
+    }
+    std::copy(*buffer, *buffer + getSerializedSize(), valueToStamp.begin());
+    return lastDeserializeResult;
+  }
+
+  [[nodiscard]] size_t getTimestampSize() const override { return getSerializedSize(); }
+
+  void reset() {
+    serializeCallCount = 0;
+    getSizeCallCount = 0;
+    deserializeCallCount = 0;
+    nextSerFails = false;
+    nextDeserFails = false;
+    lastSerializeResult = returnvalue::OK;
+    lastDeserializeResult = returnvalue::OK;
+    deserFailRetval = returnvalue::FAILED;
+    serFailRetval = returnvalue::FAILED;
+  }
+
+  timeval &getTime() override { return dummyTime; }
+
+ private:
+  timeval dummyTime{};
+};
+#endif  // FSFW_TESTS_CDSSHORTTIMESTAMPERMOCK_H

unittests/mocks/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 returnvalue::OK; }
+
+ReturnValue_t ComIFMock::sendMessage(CookieIF *cookie, const uint8_t *sendData, size_t sendLen) {
+  data = *sendData;
+  return returnvalue::OK;
+}
+
+ReturnValue_t ComIFMock::getSendSuccess(CookieIF *cookie) { return returnvalue::OK; }
+
+ReturnValue_t ComIFMock::requestReceiveMessage(CookieIF *cookie, size_t requestLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t ComIFMock::readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size) {
+  switch (testCase) {
+    case TestCase::MISSED_REPLY: {
+      *size = 0;
+      return returnvalue::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 returnvalue::OK;
+}
+
+void ComIFMock::setTestCase(TestCase testCase_) { testCase = testCase_; }

unittests/mocks/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/mocks/CookieIFMock.cpp

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

unittests/mocks/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/mocks/DeviceFdirMock.cpp

@@ -0,0 +1,16 @@
+#include "DeviceFdirMock.h"
+
+DeviceFdirMock::DeviceFdirMock(object_id_t owner, object_id_t parent)
+    : DeviceHandlerFailureIsolation(owner, parent) {}
+
+DeviceFdirMock::~DeviceFdirMock() = default;
+
+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/mocks/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/mocks/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() = default;
+
+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 returnvalue::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 returnvalue::OK;
+      break;
+    }
+    case PERIODIC_REPLY_DATA: {
+      *foundId = PERIODIC_REPLY;
+      *foundLen = sizeof(PERIODIC_REPLY_DATA);
+      return returnvalue::OK;
+      break;
+    }
+    default:
+      break;
+  }
+  return returnvalue::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 returnvalue::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/mocks/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/mocks/EventReportingProxyMock.cpp

@@ -0,0 +1,6 @@
+#include "EventReportingProxyMock.h"
+
+void EventReportingProxyMock::forwardEvent(Event event, uint32_t parameter1,
+                                           uint32_t parameter2) const {
+  eventQueue.emplace(event, parameter1, parameter2);
+}

unittests/mocks/EventReportingProxyMock.h

@@ -0,0 +1,21 @@
+#ifndef FSFW_TESTS_EVENTREPORTPROXYMOCK_H
+#define FSFW_TESTS_EVENTREPORTPROXYMOCK_H
+
+#include <queue>
+
+#include "fsfw/events/EventReportingProxyIF.h"
+
+class EventReportingProxyMock : public EventReportingProxyIF {
+ public:
+  void forwardEvent(Event event, uint32_t parameter1, uint32_t parameter2) const override;
+
+  struct EventInfo {
+    EventInfo(Event event, uint32_t p1, uint32_t p2) : event(event), p1(p1), p2(p2) {}
+
+    Event event;
+    uint32_t p1;
+    uint32_t p2;
+  };
+  mutable std::queue<EventInfo> eventQueue;
+};
+#endif  // FSFW_TESTS_EVENTREPORTPROXYMOCK_H

unittests/mocks/FilesystemMock.cpp

@@ -0,0 +1,140 @@
+#include "FilesystemMock.h"
+
+#include <filesystem>
+
+#include "fsfw/serialize/SerializeIF.h"
+
+ReturnValue_t FilesystemMock::feedFile(const std::string &filename, std::ifstream &file) {
+  if (not std::filesystem::exists(filename)) {
+    return returnvalue::FAILED;
+  }
+  size_t fileSize = std::filesystem::file_size(filename);
+  FileOpParams params(filename.c_str(), fileSize);
+  std::vector<uint8_t> rawData(fileSize);
+  file.read(reinterpret_cast<char *>(rawData.data()), static_cast<unsigned int>(rawData.size()));
+  createOrAddToFile(params, rawData.data());
+  return returnvalue::OK;
+}
+
+ReturnValue_t FilesystemMock::writeToFile(FileOpParams params, const uint8_t *data) {
+  createOrAddToFile(params, data);
+  return returnvalue::OK;
+}
+
+ReturnValue_t FilesystemMock::readFromFile(FileOpParams params, uint8_t **buffer, size_t &readSize,
+                                           size_t maxSize) {
+  std::string filename(params.path());
+  auto iter = fileMap.find(filename);
+  if (iter == fileMap.end()) {
+    return HasFileSystemIF::FILE_DOES_NOT_EXIST;
+  } else {
+    FileInfo &info = iter->second;
+    size_t readLen = params.size;
+    if (params.offset + params.size > info.fileRaw.size()) {
+      if (params.offset > info.fileRaw.size()) {
+        return returnvalue::OK;
+      }
+      readLen = info.fileRaw.size() - params.offset;
+    }
+    if (readSize + readLen > maxSize) {
+      return SerializeIF::STREAM_TOO_SHORT;
+    }
+    std::copy(info.fileRaw.data() + params.offset, info.fileRaw.data() + readLen, *buffer);
+    *buffer += readLen;
+    readSize += readLen;
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t FilesystemMock::createFile(FilesystemParams params, const uint8_t *data,
+                                         size_t size) {
+  FileOpParams params2(params.path, size);
+  createOrAddToFile(params2, data);
+  return returnvalue::OK;
+}
+
+ReturnValue_t FilesystemMock::removeFile(const char *path, FileSystemArgsIF *args) {
+  std::string filename(path);
+  auto iter = fileMap.find(filename);
+  if (iter == fileMap.end()) {
+    return HasFileSystemIF::FILE_DOES_NOT_EXIST;
+  } else {
+    fileMap.erase(iter);
+    return returnvalue::OK;
+  }
+}
+
+ReturnValue_t FilesystemMock::createDirectory(FilesystemParams params, bool createParentDirs) {
+  std::string dirPath = params.path;
+  dirMap[dirPath].createCallCount++;
+  dirMap[dirPath].wihParentDir.push(createParentDirs);
+  return returnvalue::OK;
+}
+
+ReturnValue_t FilesystemMock::removeDirectory(FilesystemParams params, bool deleteRecurively) {
+  std::string dirPath = params.path;
+  dirMap[dirPath].delCallCount++;
+  dirMap[dirPath].recursiveDeletion.push(deleteRecurively);
+  return returnvalue::OK;
+}
+
+ReturnValue_t FilesystemMock::rename(const char *oldPath, const char *newPath,
+                                     FileSystemArgsIF *args) {
+  renameQueue.push(RenameInfo(oldPath, newPath));
+  return returnvalue::OK;
+}
+
+void FilesystemMock::createOrAddToFile(FileOpParams params, const uint8_t *data) {
+  std::string filename(params.path());
+  auto iter = fileMap.find(filename);
+  if (iter == fileMap.end()) {
+    FileSegmentQueue queue;
+    if (params.size > 0) {
+      queue.push(FileWriteInfo(filename, params.offset, data, params.size));
+    }
+    FileInfo info;
+    info.fileSegQueue = queue;
+    if (data != nullptr) {
+      info.fileRaw.insert(info.fileRaw.end(), data, data + params.size);
+    }
+    fileMap.emplace(filename, info);
+  } else {
+    FileInfo &info = iter->second;
+    info.fileSegQueue.push(FileWriteInfo(filename, params.offset, data, params.size));
+    if (data == nullptr) {
+      return;
+    }
+    // Easiest case: append data to the end
+    if (params.offset == info.fileRaw.size()) {
+      info.fileRaw.insert(info.fileRaw.end(), data, data + params.size);
+    } else {
+      size_t totalNewLen = params.offset + params.size;
+      if (totalNewLen > info.fileRaw.size()) {
+        info.fileRaw.resize(params.offset + params.size);
+      }
+      std::copy(data, data + params.size,
+                info.fileRaw.begin() + static_cast<unsigned int>(params.offset));
+    }
+  }
+}
+
+void FilesystemMock::reset() {
+  fileMap.clear();
+  dirMap.clear();
+  std::queue<RenameInfo> empty;
+  std::swap(renameQueue, empty);
+}
+
+bool FilesystemMock::fileExists(FilesystemParams params) {
+  std::string filename(params.path);
+  auto iter = fileMap.find(filename);
+  if (iter == fileMap.end()) {
+    return false;
+  }
+  return true;
+}
+
+ReturnValue_t FilesystemMock::truncateFile(FilesystemParams params) {
+  truncateCalledOnFile = params.path;
+  return returnvalue::OK;
+}

unittests/mocks/FilesystemMock.h

@@ -0,0 +1,81 @@
+#ifndef FSFW_MOCKS_FILESYSTEMMOCK_H
+#define FSFW_MOCKS_FILESYSTEMMOCK_H
+
+#include <fstream>
+#include <map>
+#include <queue>
+#include <string>
+#include <utility>
+
+#include "fsfw/filesystem.h"
+
+/**
+ * This mock models a filesystem in the RAM. It can be used to verify correct behaviour of
+ * a component using a filesystem without relying on an actual OS filesystem implementation.
+ *
+ * Please note that this object does not actually check paths for validity. The file API was
+ * built in a way to allow reading a file back after it was written while also remembering
+ * the specific file segments which were inserted in write calls.
+ */
+class FilesystemMock : public HasFileSystemIF {
+ public:
+  struct FileWriteInfo {
+    FileWriteInfo(std::string filename, size_t offset, const uint8_t *data, size_t len)
+        : filename(std::move(filename)), offset(offset) {
+      this->data.insert(this->data.end(), data, data + len);
+    }
+    std::string filename;
+    size_t offset;
+    std::vector<uint8_t> data;
+  };
+  using FileSegmentQueue = std::queue<FileWriteInfo>;
+
+  struct FileInfo {
+    FileSegmentQueue fileSegQueue;
+    std::vector<uint8_t> fileRaw;
+  };
+
+  std::map<std::string, FileInfo> fileMap;
+
+  struct DirInfo {
+    size_t createCallCount = 0;
+    size_t delCallCount = 0;
+    std::queue<bool> wihParentDir;
+    std::queue<bool> recursiveDeletion;
+  };
+  std::map<std::string, DirInfo> dirMap;
+
+  struct RenameInfo {
+    RenameInfo(std::string oldName, std::string newName)
+        : oldName(std::move(oldName)), newName(std::move(newName)) {}
+
+    std::string oldName;
+    std::string newName;
+  };
+  std::queue<RenameInfo> renameQueue;
+  std::string truncateCalledOnFile;
+  ReturnValue_t feedFile(const std::string &filename, std::ifstream &file);
+
+  bool fileExists(FilesystemParams params) override;
+  ReturnValue_t truncateFile(FilesystemParams params) override;
+
+  ReturnValue_t writeToFile(FileOpParams params, const uint8_t *data) override;
+  ReturnValue_t readFromFile(FileOpParams params, uint8_t **buffer, size_t &readSize,
+                             size_t maxSize) override;
+  ReturnValue_t createFile(FilesystemParams params, const uint8_t *data, size_t size) override;
+  ReturnValue_t removeFile(const char *path, FileSystemArgsIF *args) override;
+  ReturnValue_t createDirectory(FilesystemParams params, bool createParentDirs) override;
+  ReturnValue_t removeDirectory(FilesystemParams params, bool deleteRecurively) override;
+  ReturnValue_t rename(const char *oldPath, const char *newPath, FileSystemArgsIF *args) override;
+
+  void reset();
+
+  using HasFileSystemIF::createDirectory;
+  using HasFileSystemIF::createFile;
+  using HasFileSystemIF::readFromFile;
+
+ private:
+  void createOrAddToFile(FileOpParams params, const uint8_t *data);
+};
+
+#endif  // FSFW_MOCKS_FILESYSTEMMOCK_H

unittests/mocks/HkReceiverMock.h

@@ -0,0 +1,16 @@
+#ifndef FSFW_UNITTEST_TESTS_MOCKS_HKRECEIVERMOCK_H_
+#define FSFW_UNITTEST_TESTS_MOCKS_HKRECEIVERMOCK_H_
+
+#include <fsfw/housekeeping/AcceptsHkPacketsIF.h>
+
+class HkReceiverMock : public AcceptsHkPacketsIF {
+ public:
+  explicit HkReceiverMock(MessageQueueId_t queueId) : queueId(queueId) {}
+
+  [[nodiscard]] MessageQueueId_t getHkQueue() const override { return queueId; }
+
+ private:
+  MessageQueueId_t queueId;
+};
+
+#endif /* FSFW_UNITTEST_TESTS_MOCKS_HKRECEIVERMOCK_H_ */

unittests/mocks/InternalErrorReporterMock.cpp

@@ -0,0 +1,13 @@
+#include "InternalErrorReporterMock.h"
+
+InternalErrorReporterMock::InternalErrorReporterMock() = default;
+
+void InternalErrorReporterMock::queueMessageNotSent() { queueMsgNotSentCallCnt++; }
+void InternalErrorReporterMock::lostTm() { lostTmCallCnt++; }
+void InternalErrorReporterMock::storeFull() { storeFullCallCnt++; }
+
+void InternalErrorReporterMock::reset() {
+  queueMsgNotSentCallCnt = 0;
+  lostTmCallCnt = 0;
+  storeFullCallCnt = 0;
+}

unittests/mocks/InternalErrorReporterMock.h

@@ -0,0 +1,19 @@
+#ifndef FSFW_TESTS_INTERNALERRORREPORTERMOCK_H
+#define FSFW_TESTS_INTERNALERRORREPORTERMOCK_H
+
+#include "fsfw/internalerror/InternalErrorReporterIF.h"
+
+class InternalErrorReporterMock : public InternalErrorReporterIF {
+ public:
+  unsigned int queueMsgNotSentCallCnt = 0;
+  unsigned int lostTmCallCnt = 0;
+  unsigned int storeFullCallCnt = 0;
+  InternalErrorReporterMock();
+  void reset();
+
+ private:
+  void queueMessageNotSent() override;
+  void lostTm() override;
+  void storeFull() override;
+};
+#endif  // FSFW_TESTS_INTERNALERRORREPORTERMOCK_H

unittests/mocks/LocalPoolOwnerBase.cpp

@@ -0,0 +1,128 @@
+#include "LocalPoolOwnerBase.h"
+
+LocalPoolOwnerBase::LocalPoolOwnerBase(MessageQueueIF &queue, object_id_t objectId)
+    : SystemObject(objectId),
+      queue(queue),
+      poolManager(this, &queue),
+      dataset(this, lpool::testSetId) {}
+
+LocalPoolOwnerBase::~LocalPoolOwnerBase() = default;
+
+ReturnValue_t LocalPoolOwnerBase::initializeHkManager() {
+  if (not initialized) {
+    initialized = true;
+    return poolManager.initialize(&queue);
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t LocalPoolOwnerBase::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                          LocalDataPoolManager &poolManager) {
+  // Default initialization empty for now.
+  localDataPoolMap.emplace(lpool::uint8VarId, &u8PoolEntry);
+  localDataPoolMap.emplace(lpool::floatVarId, &floatPoolEntry);
+  localDataPoolMap.emplace(lpool::uint32VarId, &u32PoolEntry);
+
+  localDataPoolMap.emplace(lpool::uint16Vec3Id, &u16VecPoolEntry);
+  localDataPoolMap.emplace(lpool::int64Vec2Id, &i64VecPoolEntry);
+  return returnvalue::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 = returnvalue::OK;
+  {
+    PoolReadGuard readHelper(&dataset);
+    if (readHelper.getReadResult() != returnvalue::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() != returnvalue::OK) {
+      status = readHelper.getReadResult();
+    }
+    testUint32.value = 0;
+    testUint32.setValid(false);
+  }
+
+  {
+    PoolReadGuard readHelper(&testInt64Vec);
+    if (readHelper.getReadResult() != returnvalue::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 = store_address_t::invalid();
+  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 = store_address_t::invalid();
+  return condition;
+}
+
+ReturnValue_t LocalPoolOwnerBase::initializeHkManagerAfterTaskCreation() {
+  if (not initializedAfterTaskCreation) {
+    initializedAfterTaskCreation = true;
+    return poolManager.initializeAfterTaskCreation();
+  }
+  return returnvalue::OK;
+}
+
+void LocalPoolOwnerBase::handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId,
+                                                   bool *clearMessage) {
+  this->changedPoolVariableGpid = globPoolId;
+  this->storeIdForChangedVariable = storeId;
+}
+
+void LocalPoolOwnerBase::setHkDestId(MessageQueueId_t id) { poolManager.setHkDestinationId(id); }

unittests/mocks/LocalPoolOwnerBase.h

@@ -0,0 +1,186 @@
+#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 "fsfw/datapool/PoolEntry.h"
+#include "mocks/MessageQueueMock.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:
+  explicit LocalPoolOwnerBase(MessageQueueIF& queue,
+                              object_id_t objectId = objects::TEST_LOCAL_POOL_OWNER_BASE);
+
+  ~LocalPoolOwnerBase() override;
+
+  [[nodiscard]] object_id_t getObjectId() const override { return SystemObject::getObjectId(); }
+
+  ReturnValue_t initializeHkManager();
+
+  void setHkDestId(MessageQueueId_t id);
+
+  ReturnValue_t initializeHkManagerAfterTaskCreation();
+
+  /** Command queue for housekeeping messages. */
+  [[nodiscard]] MessageQueueId_t getCommandQueue() const override { return queue.getId(); }
+
+  // This is called by initializeAfterTaskCreation of the HK manager.
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                        LocalDataPoolManager& poolManager) override;
+
+  LocalDataPoolManager* getHkManagerHandle() override { return &poolManager; }
+
+  [[nodiscard]] 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
+   */
+  LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override { return &dataset; }
+
+  LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) override;
+
+  [[nodiscard]] MessageQueueMock& getMockQueueHandle() const {
+    return dynamic_cast<MessageQueueMock&>(queue);
+  }
+
+  ReturnValue_t subscribePeriodicHk(bool enableReporting) {
+    return poolManager.subscribeForRegularPeriodicPacket(
+        subdp::RegularHkPeriodicParams(lpool::testSid, enableReporting, 0.2));
+  }
+
+  ReturnValue_t subscribeWrapperSetUpdate(MessageQueueId_t receiverId) {
+    return poolManager.subscribeForSetUpdateMessage(lpool::testSetId, objects::NO_OBJECT,
+                                                    receiverId, false);
+  }
+
+  ReturnValue_t subscribeWrapperSetUpdateSnapshot(MessageQueueId_t receiverId) {
+    return poolManager.subscribeForSetUpdateMessage(lpool::testSetId, objects::NO_OBJECT,
+                                                    receiverId, true);
+  }
+
+  ReturnValue_t subscribeWrapperSetUpdateHk(bool diagnostics = false,
+                                            AcceptsHkPacketsIF* receiver = nullptr) {
+    if (diagnostics) {
+      auto params = subdp::DiagnosticsHkUpdateParams(lpool::testSid, true);
+      if (receiver != nullptr) {
+        params.receiver = receiver->getHkQueue();
+      }
+      return poolManager.subscribeForDiagUpdatePacket(params);
+    } else {
+      auto params = subdp::RegularHkUpdateParams(lpool::testSid, true);
+      if (receiver != nullptr) {
+        params.receiver = receiver->getHkQueue();
+      }
+      return poolManager.subscribeForRegularUpdatePacket(params);
+    }
+  }
+
+  ReturnValue_t subscribeWrapperVariableUpdate(MessageQueueId_t receiverId, lp_id_t localPoolId) {
+    return poolManager.subscribeForVariableUpdateMessage(localPoolId, MessageQueueIF::NO_QUEUE,
+                                                         receiverId, false);
+  }
+
+  ReturnValue_t subscribeWrapperVariableSnapshot(MessageQueueId_t receiverId, lp_id_t localPoolId) {
+    return poolManager.subscribeForVariableUpdateMessage(localPoolId, MessageQueueIF::NO_QUEUE,
+                                                         receiverId, 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;
+
+  PoolEntry<uint8_t> u8PoolEntry = PoolEntry<uint8_t>({0});
+  PoolEntry<float> floatPoolEntry = PoolEntry<float>({0});
+  PoolEntry<uint32_t> u32PoolEntry = PoolEntry<uint32_t>({0});
+  PoolEntry<uint16_t> u16VecPoolEntry = PoolEntry<uint16_t>({0, 0, 0});
+  PoolEntry<int64_t> i64VecPoolEntry = PoolEntry<int64_t>({0, 0});
+
+  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& queue;
+
+  bool initialized = false;
+  bool initializedAfterTaskCreation = false;
+};
+
+#endif /* FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_ */

unittests/mocks/MessageQueueMock.cpp

@@ -0,0 +1,173 @@
+#include "MessageQueueMock.h"
+
+#include <algorithm>
+#include <stdexcept>
+
+MessageQueueMock::MessageQueueMock(MessageQueueId_t queueId)
+    : MessageQueueBase(queueId, MessageQueueIF::NO_QUEUE, nullptr) {}
+
+bool MessageQueueMock::wasMessageSent() const {
+  return std::any_of(
+      sendMap.begin(), sendMap.end(),
+      [](const std::pair<MessageQueueId_t, SendInfo>& pair) { return pair.second.callCount > 0; });
+}
+
+size_t MessageQueueMock::numberOfSentMessages() const {
+  size_t callCount = 0;
+  for (auto& destInfo : sendMap) {
+    callCount += destInfo.second.callCount;
+  }
+  return callCount;
+}
+
+size_t MessageQueueMock::numberOfSentMessagesToDest(MessageQueueId_t id) const {
+  auto iter = sendMap.find(id);
+  if (iter == sendMap.end()) {
+    return 0;
+  }
+  return iter->second.callCount;
+}
+
+size_t MessageQueueMock::numberOfSentMessagesToDefault() const {
+  return numberOfSentMessagesToDest(MessageQueueBase::getDefaultDestination());
+}
+
+ReturnValue_t MessageQueueMock::clearLastReceivedMessage(bool clearCmdMsg) {
+  if (receivedMsgs.empty()) {
+    return MessageQueueIF::EMPTY;
+  }
+  if (clearCmdMsg) {
+    CommandMessage message;
+    std::memcpy(message.getBuffer(), receivedMsgs.front().getBuffer(), message.getMessageSize());
+    message.clearCommandMessage();
+  }
+  receivedMsgs.pop();
+  return returnvalue::OK;
+}
+
+ReturnValue_t MessageQueueMock::receiveMessage(MessageQueueMessageIF* message) {
+  if (receivedMsgs.empty()) {
+    return MessageQueueIF::EMPTY;
+  }
+  std::memcpy(message->getBuffer(), receivedMsgs.front().getBuffer(), message->getMessageSize());
+  receivedMsgs.pop();
+  return returnvalue::OK;
+}
+
+ReturnValue_t MessageQueueMock::flush(uint32_t* count) { return returnvalue::FAILED; }
+
+ReturnValue_t MessageQueueMock::sendMessageFrom(MessageQueueId_t sendTo,
+                                                MessageQueueMessageIF* message,
+                                                MessageQueueId_t sentFrom, bool ignoreFault) {
+  if (message == nullptr) {
+    return returnvalue::FAILED;
+  }
+  if (nextSendFailsPair.first) {
+    nextSendFailsPair.first = false;
+    return nextSendFailsPair.second;
+  }
+  auto iter = sendMap.find(sendTo);
+  MessageQueueMessage messageCopy;
+  if (iter == sendMap.end()) {
+    createMsgCopy(messageCopy, *message);
+    sendMap.emplace(sendTo, SendInfo(messageCopy, 1));
+  } else {
+    iter->second.callCount += 1;
+    createMsgCopy(messageCopy, *message);
+    iter->second.msgs.push(messageCopy);
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t MessageQueueMock::reply(MessageQueueMessageIF* message) {
+  return sendMessageFrom(MessageQueueIF::NO_QUEUE, message, this->getId(), false);
+}
+
+void MessageQueueMock::clearMessages(bool clearCommandMessages) {
+  if (not clearCommandMessages) {
+    sendMap.clear();
+    return;
+  }
+  for (auto& destInfo : sendMap) {
+    while (!destInfo.second.msgs.empty()) {
+      CommandMessage message;
+      std::memcpy(message.getBuffer(), destInfo.second.msgs.front().getBuffer(),
+                  message.getMessageSize());
+      message.clear();
+      destInfo.second.msgs.pop();
+      destInfo.second.callCount--;
+    }
+  }
+  sendMap.clear();
+}
+
+void MessageQueueMock::addReceivedMessage(MessageQueueMessageIF& msg) {
+  MessageQueueMessage messageCopy;
+  createMsgCopy(messageCopy, msg);
+  receivedMsgs.push(messageCopy);
+}
+
+void MessageQueueMock::createMsgCopy(MessageQueueMessageIF& into, MessageQueueMessageIF& from) {
+  if (from.getMessageSize() > into.getMaximumDataSize()) {
+    throw std::invalid_argument("Passed message does not fit into message copy");
+  }
+  std::memcpy(into.getBuffer(), from.getBuffer(), from.getMaximumDataSize());
+}
+
+ReturnValue_t MessageQueueMock::getNextSentMessage(MessageQueueId_t id,
+                                                   MessageQueueMessageIF& message) {
+  auto iter = sendMap.find(id);
+  if (iter == sendMap.end() or iter->second.callCount == 0) {
+    return MessageQueueIF::EMPTY;
+  }
+  createMsgCopy(message, iter->second.msgs.front());
+  return returnvalue::OK;
+}
+
+ReturnValue_t MessageQueueMock::getNextSentMessage(MessageQueueMessageIF& message) {
+  return getNextSentMessage(MessageQueueBase::getDefaultDestination(), message);
+}
+
+ReturnValue_t MessageQueueMock::clearLastSentMessage(MessageQueueId_t destId, bool clearCmdMsg) {
+  auto iter = sendMap.find(destId);
+  if (iter == sendMap.end()) {
+    return MessageQueueIF::EMPTY;
+  }
+  return clearLastSentMessage(iter, clearCmdMsg);
+}
+
+ReturnValue_t MessageQueueMock::clearLastSentMessage(bool clearCmdMsg) {
+  auto iter = sendMap.find(getDefaultDestination());
+  if (iter == sendMap.end()) {
+    return MessageQueueIF::EMPTY;
+  }
+  ReturnValue_t result = clearLastSentMessage(iter, clearCmdMsg);
+  clearEmptyEntries();
+  return result;
+}
+
+ReturnValue_t MessageQueueMock::clearLastSentMessage(
+    std::map<MessageQueueId_t, SendInfo>::iterator& iter, bool clearCmdMsg) {
+  if (clearCmdMsg) {
+    CommandMessage message;
+    std::memcpy(message.getBuffer(), iter->second.msgs.front().getBuffer(),
+                message.getMessageSize());
+    message.clear();
+  }
+  iter->second.msgs.pop();
+  iter->second.callCount--;
+  return returnvalue::OK;
+}
+void MessageQueueMock::clearEmptyEntries() {
+  for (auto it = sendMap.cbegin(); it != sendMap.cend();) {
+    if (it->second.callCount == 0) {
+      sendMap.erase(it++);
+    } else {
+      ++it;
+    }
+  }
+}
+void MessageQueueMock::makeNextSendFail(ReturnValue_t retval) {
+  nextSendFailsPair.first = true;
+  nextSendFailsPair.second = retval;
+}

unittests/mocks/MessageQueueMock.h

@@ -0,0 +1,64 @@
+#ifndef FSFW_UNITTEST_TESTS_MOCKS_MESSAGEQUEUEMOCKBASE_H_
+#define FSFW_UNITTEST_TESTS_MOCKS_MESSAGEQUEUEMOCKBASE_H_
+
+#include <cstring>
+#include <map>
+#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"
+
+struct SendInfo {
+  explicit SendInfo(MessageQueueMessage& initMsg, unsigned int initCallCnt = 1)
+      : callCount(initCallCnt) {
+    msgs.push(initMsg);
+  }
+  unsigned int callCount = 0;
+  std::queue<MessageQueueMessage> msgs;
+};
+
+class MessageQueueMock : public MessageQueueBase {
+ public:
+  void addReceivedMessage(MessageQueueMessageIF& msg);
+  explicit MessageQueueMock(MessageQueueId_t queueId);
+
+  //! Get next message which was sent to the default destination
+  ReturnValue_t getNextSentMessage(MessageQueueMessageIF& message);
+  //! Get message which was sent to a specific ID
+  ReturnValue_t getNextSentMessage(MessageQueueId_t id, MessageQueueMessageIF& message);
+  [[nodiscard]] bool wasMessageSent() const;
+  void makeNextSendFail(ReturnValue_t retval);
+  [[nodiscard]] size_t numberOfSentMessages() const;
+  [[nodiscard]] size_t numberOfSentMessagesToDefault() const;
+  [[nodiscard]] size_t numberOfSentMessagesToDest(MessageQueueId_t id) const;
+  /**
+   * Pop a message, clearing it in the process.
+   * @return
+   */
+  ReturnValue_t clearLastReceivedMessage(bool clearCmdMsg = true);
+
+  ReturnValue_t flush(uint32_t* count) override;
+  ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                                MessageQueueId_t sentFrom, bool ignoreFault = false) override;
+  ReturnValue_t reply(MessageQueueMessageIF* message) override;
+
+  ReturnValue_t clearLastSentMessage(MessageQueueId_t destId, bool clearCmdMsg = true);
+  ReturnValue_t clearLastSentMessage(bool clearCmdMsg = true);
+  void clearMessages(bool clearCmdMsg = true);
+
+ private:
+  using SendMap = std::map<MessageQueueId_t, SendInfo>;
+  SendMap sendMap;
+  std::queue<MessageQueueMessage> receivedMsgs;
+  std::pair<bool, ReturnValue_t> nextSendFailsPair;
+
+  void clearEmptyEntries();
+  ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override;
+  static ReturnValue_t clearLastSentMessage(SendMap::iterator& iter, bool clearCmdMsg = true);
+  static void createMsgCopy(MessageQueueMessageIF& into, MessageQueueMessageIF& from);
+};
+
+#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 returnvalue::OK;
+  };
+
+  virtual ReturnValue_t sleepFor(uint32_t ms) override { return returnvalue::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 returnvalue::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 returnvalue::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 returnvalue::FAILED;
+}
+
+ReturnValue_t PowerSwitcherMock::getFuseState(uint8_t fuseNr) const {
+  if (fuseMap.count(fuseNr) == 1) {
+    return FUSE_ON;
+  } else {
+    return FUSE_OFF;
+  }
+  return returnvalue::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/mocks/PusDistributorMock.cpp

@@ -0,0 +1,12 @@
+#include "PusDistributorMock.h"
+
+PusDistributorMock::PusDistributorMock() : SystemObject(objects::NO_OBJECT, false) {}
+
+PusDistributorMock::PusDistributorMock(object_id_t registeredId)
+    : SystemObject(registeredId, true) {}
+
+ReturnValue_t PusDistributorMock::registerService(const AcceptsTelecommandsIF& service) {
+  registerCallCount++;
+  registeredServies.push_back(&service);
+  return returnvalue::OK;
+}

unittests/mocks/PusDistributorMock.h

@@ -0,0 +1,18 @@
+#ifndef FSFW_TESTS_PUSDISTRIBUTORMOCK_H
+#define FSFW_TESTS_PUSDISTRIBUTORMOCK_H
+
+#include <vector>
+
+#include "fsfw/objectmanager/SystemObject.h"
+#include "fsfw/tcdistribution/PusDistributorIF.h"
+
+class PusDistributorMock : public SystemObject, public PusDistributorIF {
+ public:
+  PusDistributorMock();
+  explicit PusDistributorMock(object_id_t registeredId);
+  unsigned int registerCallCount = 0;
+  std::vector<const AcceptsTelecommandsIF*> registeredServies;
+  ReturnValue_t registerService(const AcceptsTelecommandsIF& service) override;
+};
+
+#endif  // FSFW_TESTS_PUSDISTRIBUTORMOCK_H

unittests/mocks/PusServiceBaseMock.cpp

@@ -0,0 +1,53 @@
+#include "PusServiceBaseMock.h"
+
+PsbMock::PsbMock(PsbParams params) : PusServiceBase(params) {}
+
+ReturnValue_t PsbMock::handleRequest(uint8_t subservice) {
+  handleRequestCallCnt++;
+  subserviceQueue.push(subservice);
+  if (handleReqFailPair.first) {
+    handleReqFailPair.first = false;
+    return handleReqFailPair.second;
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t PsbMock::performService() {
+  performServiceCallCnt++;
+  if (performServiceFailPair.first) {
+    performServiceFailPair.first = false;
+    return performServiceFailPair.second;
+  }
+  return returnvalue::OK;
+}
+
+void PsbMock::reset() {
+  handleRequestCallCnt = 0;
+  performServiceCallCnt = 0;
+  std::queue<uint8_t>().swap(subserviceQueue);
+}
+
+void PsbMock::makeNextHandleReqCallFail(ReturnValue_t retval) {
+  handleReqFailPair.first = true;
+  handleReqFailPair.second = retval;
+}
+bool PsbMock::getAndPopNextSubservice(uint8_t& subservice) {
+  if (subserviceQueue.empty()) {
+    return false;
+  }
+  subservice = subserviceQueue.front();
+  subserviceQueue.pop();
+  return true;
+}
+
+PsbParams& PsbMock::getParams() { return psbParams; }
+
+void PsbMock::setStaticPusDistributor(object_id_t pusDistributor) {
+  PUS_DISTRIBUTOR = pusDistributor;
+}
+
+object_id_t PsbMock::getStaticPusDistributor() { return PUS_DISTRIBUTOR; }
+
+void PsbMock::setStaticTmDest(object_id_t tmDest) { PACKET_DESTINATION = tmDest; }
+
+object_id_t PsbMock::getStaticTmDest() { return PACKET_DESTINATION; }

unittests/mocks/PusServiceBaseMock.h

@@ -0,0 +1,32 @@
+#ifndef FSFW_TESTS_PUSSERVICEBASEMOCK_H
+#define FSFW_TESTS_PUSSERVICEBASEMOCK_H
+
+#include <queue>
+
+#include "fsfw/tmtcservices/PusServiceBase.h"
+
+class PsbMock : public PusServiceBase {
+ public:
+  explicit PsbMock(PsbParams params);
+  unsigned int handleRequestCallCnt = 0;
+  std::queue<uint8_t> subserviceQueue;
+  unsigned int performServiceCallCnt = 0;
+
+  static void setStaticPusDistributor(object_id_t pusDistributor);
+  static object_id_t getStaticPusDistributor();
+  static void setStaticTmDest(object_id_t tmDest);
+  static object_id_t getStaticTmDest();
+
+  PsbParams& getParams();
+
+  std::pair<bool, ReturnValue_t> handleReqFailPair;
+  std::pair<bool, ReturnValue_t> performServiceFailPair;
+  ReturnValue_t handleRequest(uint8_t subservice) override;
+  ReturnValue_t performService() override;
+
+  void makeNextHandleReqCallFail(ReturnValue_t retval);
+  bool getAndPopNextSubservice(uint8_t& subservice);
+  void reset();
+};
+
+#endif  // FSFW_TESTS_PUSSERVICEBASEMOCK_H

unittests/mocks/PusVerificationReporterMock.cpp

@@ -0,0 +1,42 @@
+#include "PusVerificationReporterMock.h"
+
+#include "fsfw/objectmanager/frameworkObjects.h"
+
+PusVerificationReporterMock::PusVerificationReporterMock()
+    : SystemObject(objects::NO_OBJECT, false) {}
+
+PusVerificationReporterMock::PusVerificationReporterMock(object_id_t registeredId)
+    : SystemObject(registeredId) {}
+
+size_t PusVerificationReporterMock::successCallCount() const { return successParams.size(); }
+size_t PusVerificationReporterMock::failCallCount() const { return failParams.size(); }
+
+VerifSuccessParams& PusVerificationReporterMock::getNextSuccessCallParams() {
+  return successParams.front();
+}
+
+void PusVerificationReporterMock::popNextFailParams() {
+  if (not failParams.empty()) {
+    failParams.pop();
+  }
+}
+
+VerifFailureParams& PusVerificationReporterMock::getNextFailCallParams() {
+  return failParams.front();
+}
+
+void PusVerificationReporterMock::popNextSuccessParams() {
+  if (not successParams.empty()) {
+    successParams.pop();
+  }
+}
+
+ReturnValue_t PusVerificationReporterMock::sendSuccessReport(VerifSuccessParams params) {
+  successParams.push(params);
+  return returnvalue::OK;
+}
+
+ReturnValue_t PusVerificationReporterMock::sendFailureReport(VerifFailureParams params) {
+  failParams.push(params);
+  return returnvalue::OK;
+}

unittests/mocks/PusVerificationReporterMock.h

@@ -0,0 +1,25 @@
+#ifndef FSFW_TESTS_PUSVERIFICATIONREPORTERMOCK_H
+#define FSFW_TESTS_PUSVERIFICATIONREPORTERMOCK_H
+
+#include <queue>
+
+#include "fsfw/objectmanager/SystemObject.h"
+#include "fsfw/tmtcservices/VerificationReporterIF.h"
+
+class PusVerificationReporterMock : public SystemObject, public VerificationReporterIF {
+ public:
+  std::queue<VerifSuccessParams> successParams;
+  std::queue<VerifFailureParams> failParams;
+  PusVerificationReporterMock();
+  explicit PusVerificationReporterMock(object_id_t registeredId);
+  [[nodiscard]] size_t successCallCount() const;
+  VerifSuccessParams& getNextSuccessCallParams();
+  void popNextSuccessParams();
+  [[nodiscard]] size_t failCallCount() const;
+  VerifFailureParams& getNextFailCallParams();
+  void popNextFailParams();
+
+  ReturnValue_t sendSuccessReport(VerifSuccessParams params) override;
+  ReturnValue_t sendFailureReport(VerifFailureParams params) override;
+};
+#endif  // FSFW_TESTS_PUSVERIFICATIONREPORTERMOCK_H

unittests/mocks/SimpleSerializable.h

@@ -0,0 +1,40 @@
+#ifndef FSFW_TESTS_SIMPLESERIALIZABLE_H
+#define FSFW_TESTS_SIMPLESERIALIZABLE_H
+
+#include "fsfw/osal/Endiness.h"
+#include "fsfw/serialize.h"
+
+class SimpleSerializable : public SerializeIF {
+ public:
+  ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                          Endianness streamEndianness) const override {
+    if (*size + getSerializedSize() > maxSize) {
+      return SerializeIF::BUFFER_TOO_SHORT;
+    }
+    **buffer = someU8;
+    *buffer += 1;
+    *size += 1;
+    return SerializeAdapter::serialize(&someU16, buffer, size, maxSize, streamEndianness);
+  }
+
+  [[nodiscard]] size_t getSerializedSize() const override { return 3; }
+  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+                            Endianness streamEndianness) override {
+    if (*size < getSerializedSize()) {
+      return SerializeIF::STREAM_TOO_SHORT;
+    }
+    someU8 = **buffer;
+    *size -= 1;
+    *buffer += 1;
+    return SerializeAdapter::deSerialize(&someU16, buffer, size, streamEndianness);
+  }
+
+  [[nodiscard]] uint8_t getU8() const { return someU8; }
+  [[nodiscard]] uint16_t getU16() const { return someU16; }
+
+ private:
+  uint8_t someU8 = 1;
+  uint16_t someU16 = 0x0203;
+};
+
+#endif  // FSFW_TESTS_SIMPLESERIALIZABLE_H

unittests/mocks/StorageManagerMock.cpp

@@ -0,0 +1,81 @@
+#include "StorageManagerMock.h"
+
+ReturnValue_t StorageManagerMock::addData(store_address_t *storageId, const uint8_t *data,
+                                          size_t size) {
+  if (nextAddDataCallFails.first) {
+    return nextAddDataCallFails.second;
+  }
+  return LocalPool::addData(storageId, data, size);
+}
+ReturnValue_t StorageManagerMock::deleteData(store_address_t packet_id) {
+  if (nextDeleteDataCallFails.first) {
+    return nextDeleteDataCallFails.second;
+  }
+  return LocalPool::deleteData(packet_id);
+}
+
+ReturnValue_t StorageManagerMock::deleteData(uint8_t *buffer, size_t size,
+                                             store_address_t *storeId) {
+  if (nextDeleteDataCallFails.first) {
+    return nextDeleteDataCallFails.second;
+  }
+  return LocalPool::deleteData(buffer, size, storeId);
+}
+
+ReturnValue_t StorageManagerMock::getData(store_address_t packet_id, const uint8_t **packet_ptr,
+                                          size_t *size) {
+  return LocalPool::getData(packet_id, packet_ptr, size);
+}
+
+ReturnValue_t StorageManagerMock::modifyData(store_address_t packet_id, uint8_t **packet_ptr,
+                                             size_t *size) {
+  if (nextModifyDataCallFails.first) {
+    return nextModifyDataCallFails.second;
+  }
+  return LocalPool::modifyData(packet_id, packet_ptr, size);
+}
+
+ReturnValue_t StorageManagerMock::getFreeElement(store_address_t *storageId, size_t size,
+                                                 uint8_t **p_data) {
+  if (nextFreeElementCallFails.first) {
+    return nextFreeElementCallFails.second;
+  }
+  return LocalPool::getFreeElement(storageId, size, p_data);
+}
+
+bool StorageManagerMock::hasDataAtId(store_address_t storeId) const {
+  return LocalPool::hasDataAtId(storeId);
+}
+void StorageManagerMock::clearStore() { return LocalPool::clearStore(); }
+
+void StorageManagerMock::clearSubPool(uint8_t poolIndex) {
+  return LocalPool::clearSubPool(poolIndex);
+}
+
+void StorageManagerMock::getFillCount(uint8_t *buffer, uint8_t *bytesWritten) {
+  return LocalPool::getFillCount(buffer, bytesWritten);
+}
+
+size_t StorageManagerMock::getTotalSize(size_t *additionalSize) {
+  return LocalPool::getTotalSize(additionalSize);
+}
+
+StorageManagerIF::max_subpools_t StorageManagerMock::getNumberOfSubPools() const {
+  return LocalPool::getNumberOfSubPools();
+}
+
+void StorageManagerMock::reset() {
+  clearStore();
+  nextAddDataCallFails.first = false;
+  nextAddDataCallFails.second = returnvalue::OK;
+  nextModifyDataCallFails.first = false;
+  nextModifyDataCallFails.second = returnvalue::OK;
+  nextDeleteDataCallFails.first = false;
+  nextDeleteDataCallFails.second = returnvalue::OK;
+  nextFreeElementCallFails.first = false;
+  nextFreeElementCallFails.second = returnvalue::OK;
+}
+
+StorageManagerMock::StorageManagerMock(object_id_t setObjectId,
+                                       const LocalPool::LocalPoolConfig &poolConfig)
+    : LocalPool(setObjectId, poolConfig) {}

unittests/mocks/StorageManagerMock.h

@@ -0,0 +1,38 @@
+#ifndef FSFW_TESTS_STORAGEMANAGERMOCK_H
+#define FSFW_TESTS_STORAGEMANAGERMOCK_H
+
+#include "fsfw/storagemanager/LocalPool.h"
+#include "fsfw/storagemanager/StorageManagerIF.h"
+
+class StorageManagerMock : public LocalPool {
+ public:
+  StorageManagerMock(object_id_t setObjectId, const LocalPoolConfig &poolConfig);
+
+  ReturnValue_t addData(store_address_t *storageId, const uint8_t *data, size_t size) override;
+  ReturnValue_t deleteData(store_address_t packet_id) override;
+  ReturnValue_t deleteData(uint8_t *buffer, size_t size, store_address_t *storeId) override;
+  ReturnValue_t getData(store_address_t packet_id, const uint8_t **packet_ptr,
+                        size_t *size) override;
+  ReturnValue_t modifyData(store_address_t packet_id, uint8_t **packet_ptr, size_t *size) override;
+  ReturnValue_t getFreeElement(store_address_t *storageId, size_t size, uint8_t **p_data) override;
+  [[nodiscard]] bool hasDataAtId(store_address_t storeId) const override;
+  void clearStore() override;
+  void clearSubPool(uint8_t poolIndex) override;
+  void getFillCount(uint8_t *buffer, uint8_t *bytesWritten) override;
+  size_t getTotalSize(size_t *additionalSize) override;
+  [[nodiscard]] max_subpools_t getNumberOfSubPools() const override;
+
+  std::pair<bool, ReturnValue_t> nextAddDataCallFails;
+  /**
+   * This can be used to make both the modify and get API call fail. This is because generally,
+   * the pool implementation get functions will use the modify API internally.
+   */
+  std::pair<bool, ReturnValue_t> nextModifyDataCallFails;
+  std::pair<bool, ReturnValue_t> nextDeleteDataCallFails;
+  std::pair<bool, ReturnValue_t> nextFreeElementCallFails;
+
+  using LocalPool::getFreeElement;
+
+  void reset();
+};
+#endif  // FSFW_TESTS_STORAGEMANAGERMOCK_H