move HAL and tests folder

src/fsfw_tests/internal/osal/CMakeLists.txt

@@ -0,0 +1,5 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE
+	testMq.cpp
+	testMutex.cpp
+	testSemaphore.cpp
+)

src/fsfw_tests/internal/osal/testMq.cpp

@@ -0,0 +1,50 @@
+#include "testMq.h"
+
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/ipc/QueueFactory.h>
+
+#include <array>
+
+#include "fsfw_tests/internal/UnittDefinitions.h"
+
+using retval = HasReturnvaluesIF;
+
+void testmq::testMq() {
+  std::string id = "[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);
+
+  auto result = testSenderMq->sendMessage(testReceiverMqId, &testMessage);
+  if (result != retval::RETURN_OK) {
+    unitt::put_error(id);
+  }
+  MessageQueueMessage recvMessage;
+  result = testReceiverMq->receiveMessage(&recvMessage);
+  if (result != retval::RETURN_OK or recvMessage.getData()[0] != 42) {
+    unitt::put_error(id);
+  }
+
+  result = testSenderMq->sendMessage(testReceiverMqId, &testMessage);
+  if (result != retval::RETURN_OK) {
+    unitt::put_error(id);
+  }
+  MessageQueueId_t senderId = 0;
+  result = testReceiverMq->receiveMessage(&recvMessage, &senderId);
+  if (result != retval::RETURN_OK or recvMessage.getData()[0] != 42) {
+    unitt::put_error(id);
+  }
+  if (senderId != testSenderMqId) {
+    unitt::put_error(id);
+  }
+  senderId = testReceiverMq->getLastPartner();
+  if (senderId != testSenderMqId) {
+    unitt::put_error(id);
+  }
+}

src/fsfw_tests/internal/osal/testMq.h

@@ -0,0 +1,8 @@
+#ifndef UNITTEST_INTERNAL_INTESTMQ_H_
+#define UNITTEST_INTERNAL_INTESTMQ_H_
+
+namespace testmq {
+void testMq();
+}
+
+#endif /* UNITTEST_INTERNAL_INTESTMQ_H_ */

src/fsfw_tests/internal/osal/testMutex.cpp

@@ -0,0 +1,48 @@
+#include "testMutex.h"
+
+#include <fsfw/ipc/MutexFactory.h>
+
+#include "fsfw/platform.h"
+#include "fsfw_tests/internal/UnittDefinitions.h"
+
+#if defined PLATFORM_WIN || defined PLATFORM_UNIX
+#include <future>
+#include <thread>
+
+#include "fsfw/osal/host/Mutex.h"
+#endif
+
+void testmutex::testMutex() {
+  std::string id = "[testMutex]";
+  MutexIF* mutex = MutexFactory::instance()->createMutex();
+  auto result = mutex->lockMutex(MutexIF::TimeoutType::POLLING);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    unitt::put_error(id);
+  }
+  // timed_mutex from the C++ library specifies undefined behaviour if
+  // the timed mutex is locked twice from the same thread.
+  // TODO: we should pass a define like FSFW_OSAL_HOST to the build.
+#if defined PLATFORM_WIN || defined PLATFORM_UNIX
+  // This calls the function from
+  // another thread and stores the returnvalue in a future.
+  auto future = std::async(&MutexIF::lockMutex, mutex, MutexIF::TimeoutType::WAITING, 1);
+  result = future.get();
+#else
+  result = mutex->lockMutex(MutexIF::TimeoutType::WAITING, 1);
+#endif
+  if (result != MutexIF::MUTEX_TIMEOUT) {
+    unitt::put_error(id);
+  }
+
+  result = mutex->unlockMutex();
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    unitt::put_error(id);
+  }
+
+#if !defined PLATFORM_WIN && !defined PLATFORM_UNIX
+  result = mutex->unlockMutex();
+  if (result != MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX) {
+    unitt::put_error(id);
+  }
+#endif
+}

src/fsfw_tests/internal/osal/testMutex.h

@@ -0,0 +1,8 @@
+#ifndef UNITTEST_INTERNAL_INTTESTMUTEX_H_
+#define UNITTEST_INTERNAL_INTTESTMUTEX_H_
+
+namespace testmutex {
+void testMutex();
+}
+
+#endif /* UNITTEST_INTERNAL_INTTESTMUTEX_H_ */

src/fsfw_tests/internal/osal/testSemaphore.cpp

@@ -0,0 +1,155 @@
+#include "testSemaphore.h"
+
+#include <cstdlib>
+
+#include "fsfw/FSFW.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/tasks/SemaphoreFactory.h"
+#include "fsfw/timemanager/Stopwatch.h"
+#include "fsfw_tests/internal/UnittDefinitions.h"
+
+void testsemaph::testBinSemaph() {
+  std::string id = "[BinSemaphore]";
+  SemaphoreIF* binSemaph = SemaphoreFactory::instance()->createBinarySemaphore();
+  if (binSemaph == nullptr) {
+    return;
+  }
+  testBinSemaphoreImplementation(binSemaph, id);
+  SemaphoreFactory::instance()->deleteSemaphore(binSemaph);
+#if defined FSFW_OSAL_FREERTOS
+  SemaphoreIF* binSemaphUsingTask = SemaphoreFactory::instance()->createBinarySemaphore(1);
+  testBinSemaphoreImplementation(binSemaphUsingTask, id);
+  SemaphoreFactory::instance()->deleteSemaphore(binSemaphUsingTask);
+#endif
+}
+
+void testsemaph::testCountingSemaph() {
+  std::string id = "[CountingSemaph]";
+  {
+    // First test: create a binary semaphore by using a counting semaphore.
+    SemaphoreIF* countingSemaph = SemaphoreFactory::instance()->createCountingSemaphore(1, 1);
+    if (countingSemaph == nullptr) {
+      return;
+    }
+    testBinSemaphoreImplementation(countingSemaph, id);
+    SemaphoreFactory::instance()->deleteSemaphore(countingSemaph);
+#if defined FSFW_OSAL_FREERTOS
+    countingSemaph = SemaphoreFactory::instance()->createCountingSemaphore(1, 1, 1);
+    testBinSemaphoreImplementation(countingSemaph, id);
+    SemaphoreFactory::instance()->deleteSemaphore(countingSemaph);
+#endif
+  }
+
+  {
+    // Second test: counting semaphore with count 3 and init count of 3.
+    SemaphoreIF* countingSemaph = SemaphoreFactory::instance()->createCountingSemaphore(3, 3);
+    testCountingSemaphImplementation(countingSemaph, id);
+    SemaphoreFactory::instance()->deleteSemaphore(countingSemaph);
+#if defined FSFW_OSAL_FREERTOS
+    countingSemaph = SemaphoreFactory::instance()->createCountingSemaphore(3, 0, 1);
+    uint8_t semaphCount = countingSemaph->getSemaphoreCounter();
+    if (semaphCount != 0) {
+      unitt::put_error(id);
+    }
+    // release 3 times in a row
+    for (int i = 0; i < 3; i++) {
+      auto result = countingSemaph->release();
+      if (result != HasReturnvaluesIF::RETURN_OK) {
+        unitt::put_error(id);
+      }
+    }
+    testCountingSemaphImplementation(countingSemaph, id);
+    SemaphoreFactory::instance()->deleteSemaphore(countingSemaph);
+#endif
+  }
+}
+
+void testsemaph::testBinSemaphoreImplementation(SemaphoreIF* binSemaph, std::string id) {
+  uint8_t semaphCount = binSemaph->getSemaphoreCounter();
+  if (semaphCount != 1) {
+    unitt::put_error(id);
+  }
+
+  ReturnValue_t result = binSemaph->release();
+  if (result != SemaphoreIF::SEMAPHORE_NOT_OWNED) {
+    unitt::put_error(id);
+  }
+  result = binSemaph->acquire(SemaphoreIF::BLOCKING);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    unitt::put_error(id);
+  }
+
+  // There is not really a point in testing time related, the task
+  // might get interrupted..
+  {
+    // Stopwatch stopwatch(false);
+    result = binSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 10);
+    // dur_millis_t time = stopwatch.stop();
+//		if(abs(time - 10) > 2) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+//		    sif::error << "UnitTester: Semaphore timeout measured incorrect."
+//		            << std::endl;
+#endif
+    //			unitt::put_error(id);
+    //		}
+  }
+
+  if (result != SemaphoreIF::SEMAPHORE_TIMEOUT) {
+    unitt::put_error(id);
+  }
+
+  semaphCount = binSemaph->getSemaphoreCounter();
+  if (semaphCount != 0) {
+    unitt::put_error(id);
+  }
+
+  result = binSemaph->release();
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    unitt::put_error(id);
+  }
+}
+
+void testsemaph::testCountingSemaphImplementation(SemaphoreIF* countingSemaph, std::string id) {
+  // check count getter function
+  uint8_t semaphCount = countingSemaph->getSemaphoreCounter();
+  if (semaphCount != 3) {
+    unitt::put_error(id);
+  }
+  ReturnValue_t result = countingSemaph->release();
+  if (result != SemaphoreIF::SEMAPHORE_NOT_OWNED) {
+    unitt::put_error(id);
+  }
+  // acquire 3 times in a row
+  for (int i = 0; i < 3; i++) {
+    result = countingSemaph->acquire(SemaphoreIF::BLOCKING);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      unitt::put_error(id);
+    }
+  }
+
+  {
+    Stopwatch stopwatch(false);
+    // attempt to take when count is 0, measure time
+    result = countingSemaph->acquire(SemaphoreIF::TimeoutType::WAITING, 10);
+    dur_millis_t time = stopwatch.stop();
+    if (std::abs(static_cast<int32_t>(time - 10)) > 1) {
+      unitt::put_error(id);
+    }
+  }
+
+  if (result != SemaphoreIF::SEMAPHORE_TIMEOUT) {
+    unitt::put_error(id);
+  }
+
+  // release 3 times in a row
+  for (int i = 0; i < 3; i++) {
+    result = countingSemaph->release();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      unitt::put_error(id);
+    }
+  }
+  // assert correct full count
+  if (countingSemaph->getSemaphoreCounter() != 3) {
+    unitt::put_error(id);
+  }
+}

src/fsfw_tests/internal/osal/testSemaphore.h

@@ -0,0 +1,13 @@
+#ifndef UNITTEST_INTERNAL_INTTESTSEMAPHORE_H_
+#define UNITTEST_INTERNAL_INTTESTSEMAPHORE_H_
+class SemaphoreIF;
+#include <string>
+
+namespace testsemaph {
+void testBinSemaph();
+void testBinSemaphoreImplementation(SemaphoreIF* binSemaph, std::string id);
+void testCountingSemaph();
+void testCountingSemaphImplementation(SemaphoreIF* countingSemaph, std::string id);
+}  // namespace testsemaph
+
+#endif /* UNITTEST_INTERNAL_INTTESTSEMAPHORE_H_ */