separate unittest folder

unittests/mocks/CMakeLists.txt

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

unittests/mocks/HkReceiverMock.h

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

unittests/mocks/MessageQueueMockBase.h

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

unittests/mocks/PeriodicTaskIFMock.h

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

unittests/mocks/PowerSwitcherMock.cpp

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

unittests/mocks/PowerSwitcherMock.h

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