separate unittest folder

unittests/osal/CMakeLists.txt

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

unittests/osal/TestClock.cpp

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

unittests/osal/TestMessageQueue.cpp

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

unittests/osal/TestSemaphore.cpp

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