unittest folder added

unittest/internal/osal/IntTestMq.cpp

@@ -0,0 +1,52 @@
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/ipc/QueueFactory.h>
+#include <unittest/internal/IntTestMq.h>
+#include <unittest/internal/UnittDefinitions.h>
+
+#include <array>
+
+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);
+	}
+
+}

unittest/internal/osal/IntTestMq.h

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

unittest/internal/osal/IntTestMutex.cpp

@@ -0,0 +1,41 @@
+#include <unittest/internal/IntTestMutex.h>
+#include <fsfw/ipc/MutexFactory.h>
+#include <unittest/internal/UnittDefinitions.h>
+
+#if defined(hosted)
+#include <fsfw/osal/hosted/Mutex.h>
+#include <thread>
+#include <future>
+#endif
+
+
+void testmutex::testMutex() {
+	std::string id = "[testMutex]";
+	MutexIF* mutex = MutexFactory::instance()->createMutex();
+	auto result = mutex->lockMutex(MutexIF::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.
+#if defined(hosted)
+	// hold on, this actually worked ? :-D This calls the function from
+	// another thread and stores the returnvalue in a future.
+	auto future = std::async(&MutexIF::lockMutex, mutex, 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);
+	}
+	result = mutex->unlockMutex();
+	if(result != MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX) {
+		unitt::put_error(id);
+	}
+}

unittest/internal/osal/IntTestMutex.h

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

unittest/internal/osal/IntTestSemaphore.cpp

@@ -0,0 +1,159 @@
+#include <fsfw/tasks/SemaphoreFactory.h>
+#include <unittest/internal/UnittDefinitions.h>
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include <fsfw/timemanager/Stopwatch.h>
+#include <unittest/internal/IntTestSemaphore.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(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(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(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) {
+//		    sif::error << "UnitTester: Semaphore timeout measured incorrect."
+//		            << std::endl;
+//			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(abs(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);
+	}
+}

unittest/internal/osal/IntTestSemaphore.h

@@ -0,0 +1,15 @@
+#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);
+}
+
+
+#endif /* UNITTEST_INTERNAL_INTTESTSEMAPHORE_H_ */