KSat/fsfw
19
6
Fork 0
forked from fsfw/fsfw
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'mueller/refactor-tmtc-stack' into mueller/cfdp-routers

Browse Source
This commit is contained in:
Robin Müller
2022-08-22 16:21:41 +02:00
parent 3b33b429e6 10f34e5a48
commit 52f8c5038b
435 changed files with 2880 additions and 3066 deletions
Download Patch File Download Diff File Expand all files Collapse all files

148
unittests/container/RingBufferTest.cpp
View File

@ -12,42 +12,42 @@ TEST_CASE("Ring Buffer Test", "[containers]") {
SECTION("Simple Test") {
REQUIRE(ringBuffer.availableWriteSpace() == 9);
REQUIRE(ringBuffer.writeData(testData, 9) == result::OK);
REQUIRE(ringBuffer.writeData(testData, 3) == result::FAILED);
REQUIRE(ringBuffer.readData(readBuffer, 5, true) == result::OK);
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) == result::OK);
REQUIRE(ringBuffer.readData(readBuffer, 4, true) == result::OK);
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) == result::OK);
REQUIRE(ringBuffer.readData(readBuffer, 9, true) == result::OK);
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) == result::FAILED);
REQUIRE(ringBuffer.writeData(nullptr, 5) == result::FAILED);
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) == result::OK);
REQUIRE(ringBuffer.writeData(testData, 8) == returnvalue::OK);
REQUIRE(ringBuffer.availableWriteSpace() == 1);
REQUIRE(ringBuffer.readData(readBuffer, 8, true) == result::OK);
REQUIRE(ringBuffer.readData(readBuffer, 8, true) == returnvalue::OK);
REQUIRE(ringBuffer.availableWriteSpace() == 9);
uint8_t *testPtr = nullptr;
REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) == result::FAILED);
REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) == returnvalue::FAILED);
REQUIRE(ringBuffer.writeTillWrap() == 2);
// too many excess bytes.
REQUIRE(ringBuffer.getFreeElement(&testPtr, 8) == result::FAILED);
REQUIRE(ringBuffer.getFreeElement(&testPtr, 5) == result::OK);
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);
@ -59,19 +59,19 @@ TEST_CASE("Ring Buffer Test", "[containers]") {
}
SECTION("Read Remaining Test") {
REQUIRE(ringBuffer.writeData(testData, 3) == result::OK);
REQUIRE(ringBuffer.writeData(testData, 3) == returnvalue::OK);
REQUIRE(ringBuffer.getAvailableReadData() == 3);
REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) == result::FAILED);
REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) == returnvalue::FAILED);
size_t trueSize = 0;
REQUIRE(ringBuffer.readData(readBuffer, 5, false, true, &trueSize) == result::OK);
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) == result::FAILED);
REQUIRE(ringBuffer.deleteData(5, false, &trueSize) == returnvalue::FAILED);
REQUIRE(trueSize == 0);
REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == result::OK);
REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == returnvalue::OK);
REQUIRE(trueSize == 3);
}
}
@ -84,21 +84,21 @@ TEST_CASE("Ring Buffer Test2", "[RingBufferTest2]") {
SECTION("Simple Test") {
REQUIRE(ringBuffer.availableWriteSpace() == 9);
REQUIRE(ringBuffer.writeData(testData, 9) == result::OK);
REQUIRE(ringBuffer.readData(readBuffer, 5, true) == result::OK);
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) == result::OK);
REQUIRE(ringBuffer.readData(readBuffer, 4, true) == result::OK);
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) == result::OK);
REQUIRE(ringBuffer.readData(readBuffer, 9, true) == result::OK);
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);
}
@ -106,17 +106,17 @@ TEST_CASE("Ring Buffer Test2", "[RingBufferTest2]") {
SECTION("Get Free Element Test") {
REQUIRE(ringBuffer.availableWriteSpace() == 9);
REQUIRE(ringBuffer.writeData(testData, 8) == result::OK);
REQUIRE(ringBuffer.writeData(testData, 8) == returnvalue::OK);
REQUIRE(ringBuffer.availableWriteSpace() == 1);
REQUIRE(ringBuffer.readData(readBuffer, 8, true) == result::OK);
REQUIRE(ringBuffer.readData(readBuffer, 8, true) == returnvalue::OK);
REQUIRE(ringBuffer.availableWriteSpace() == 9);
uint8_t *testPtr = nullptr;
REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) == result::FAILED);
REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) == returnvalue::FAILED);
REQUIRE(ringBuffer.writeTillWrap() == 2);
// too many excess bytes.
REQUIRE(ringBuffer.getFreeElement(&testPtr, 8) == result::FAILED);
REQUIRE(ringBuffer.getFreeElement(&testPtr, 5) == result::OK);
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);
@ -128,19 +128,19 @@ TEST_CASE("Ring Buffer Test2", "[RingBufferTest2]") {
}
SECTION("Read Remaining Test") {
REQUIRE(ringBuffer.writeData(testData, 3) == result::OK);
REQUIRE(ringBuffer.writeData(testData, 3) == returnvalue::OK);
REQUIRE(ringBuffer.getAvailableReadData() == 3);
REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) == result::FAILED);
REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) == returnvalue::FAILED);
size_t trueSize = 0;
REQUIRE(ringBuffer.readData(readBuffer, 5, false, true, &trueSize) == result::OK);
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) == result::FAILED);
REQUIRE(ringBuffer.deleteData(5, false, &trueSize) == returnvalue::FAILED);
REQUIRE(trueSize == 0);
REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == result::OK);
REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == returnvalue::OK);
REQUIRE(trueSize == 3);
}
@ -148,17 +148,17 @@ TEST_CASE("Ring Buffer Test2", "[RingBufferTest2]") {
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) == result::FAILED);
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) == result::OK);
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) == result::OK);
REQUIRE(ringBuffer.readData(readBuffer, 3, true) == returnvalue::OK);
for (auto i = 0; i < 3; i++) {
REQUIRE(readBuffer[i] == testData[i + 10]);
}
@ -173,21 +173,21 @@ TEST_CASE("Ring Buffer Test3", "[RingBufferTest3]") {
SECTION("Simple Test") {
REQUIRE(ringBuffer.availableWriteSpace() == 9);
REQUIRE(ringBuffer.writeData(testData, 9) == result::OK);
REQUIRE(ringBuffer.readData(readBuffer, 5, true) == result::OK);
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) == result::OK);
REQUIRE(ringBuffer.readData(readBuffer, 4, true) == result::OK);
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) == result::OK);
REQUIRE(ringBuffer.readData(readBuffer, 9, true) == result::OK);
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);
}
@ -195,19 +195,19 @@ TEST_CASE("Ring Buffer Test3", "[RingBufferTest3]") {
SECTION("Get Free Element Test") {
REQUIRE(ringBuffer.availableWriteSpace() == 9);
REQUIRE(ringBuffer.writeData(testData, 8) == result::OK);
REQUIRE(ringBuffer.writeData(testData, 8) == returnvalue::OK);
REQUIRE(ringBuffer.availableWriteSpace() == 1);
REQUIRE(ringBuffer.readData(readBuffer, 8, true) == result::OK);
REQUIRE(ringBuffer.readData(readBuffer, 8, true) == returnvalue::OK);
REQUIRE(ringBuffer.availableWriteSpace() == 9);
uint8_t *testPtr = nullptr;
REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) == result::OK);
REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) == returnvalue::OK);
REQUIRE(ringBuffer.getExcessBytes() == 8);
REQUIRE(ringBuffer.writeTillWrap() == 2);
// too many excess bytes.
REQUIRE(ringBuffer.getFreeElement(&testPtr, 8) == result::FAILED);
REQUIRE(ringBuffer.getFreeElement(&testPtr, 8) == returnvalue::FAILED);
// Less Execss bytes overwrites before
REQUIRE(ringBuffer.getFreeElement(&testPtr, 3) == result::OK);
REQUIRE(ringBuffer.getFreeElement(&testPtr, 3) == returnvalue::OK);
REQUIRE(ringBuffer.getExcessBytes() == 1);
std::memcpy(testPtr, testData, 3);
ringBuffer.confirmBytesWritten(3);
@ -219,19 +219,19 @@ TEST_CASE("Ring Buffer Test3", "[RingBufferTest3]") {
}
SECTION("Read Remaining Test") {
REQUIRE(ringBuffer.writeData(testData, 3) == result::OK);
REQUIRE(ringBuffer.writeData(testData, 3) == returnvalue::OK);
REQUIRE(ringBuffer.getAvailableReadData() == 3);
REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) == result::FAILED);
REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) == returnvalue::FAILED);
size_t trueSize = 0;
REQUIRE(ringBuffer.readData(readBuffer, 5, false, true, &trueSize) == result::OK);
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) == result::FAILED);
REQUIRE(ringBuffer.deleteData(5, false, &trueSize) == returnvalue::FAILED);
REQUIRE(trueSize == 0);
REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == result::OK);
REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == returnvalue::OK);
REQUIRE(trueSize == 3);
}
@ -239,18 +239,18 @@ TEST_CASE("Ring Buffer Test3", "[RingBufferTest3]") {
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) == result::FAILED);
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) == result::OK);
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) == result::OK);
REQUIRE(ringBuffer.readData(readBuffer, 3, true) == returnvalue::OK);
for (auto i = 0; i < 3; i++) {
REQUIRE(readBuffer[i] == testData[i + 10]);
}
@ -264,22 +264,22 @@ TEST_CASE("Ring Buffer Test4", "[RingBufferTest4]") {
SECTION("Simple Test") {
REQUIRE(ringBuffer.availableWriteSpace() == 9);
REQUIRE(ringBuffer.writeData(testData, 9) == result::OK);
REQUIRE(ringBuffer.writeData(testData, 3) == result::FAILED);
REQUIRE(ringBuffer.readData(readBuffer, 5, true) == result::OK);
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) == result::OK);
REQUIRE(ringBuffer.readData(readBuffer, 4, true) == result::OK);
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) == result::OK);
REQUIRE(ringBuffer.readData(readBuffer, 9, true) == result::OK);
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);
}
@ -287,16 +287,16 @@ TEST_CASE("Ring Buffer Test4", "[RingBufferTest4]") {
SECTION("Get Free Element Test") {
REQUIRE(ringBuffer.availableWriteSpace() == 9);
REQUIRE(ringBuffer.writeData(testData, 8) == result::OK);
REQUIRE(ringBuffer.writeData(testData, 8) == returnvalue::OK);
REQUIRE(ringBuffer.availableWriteSpace() == 1);
REQUIRE(ringBuffer.readData(readBuffer, 8, true) == result::OK);
REQUIRE(ringBuffer.readData(readBuffer, 8, true) == returnvalue::OK);
REQUIRE(ringBuffer.availableWriteSpace() == 9);
uint8_t *testPtr = nullptr;
REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) == result::FAILED);
REQUIRE(ringBuffer.getFreeElement(&testPtr, 10) == returnvalue::FAILED);
REQUIRE(ringBuffer.writeTillWrap() == 2);
REQUIRE(ringBuffer.getFreeElement(&testPtr, 8) == result::OK);
REQUIRE(ringBuffer.getFreeElement(&testPtr, 5) == result::OK);
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);
@ -308,19 +308,19 @@ TEST_CASE("Ring Buffer Test4", "[RingBufferTest4]") {
}
SECTION("Read Remaining Test") {
REQUIRE(ringBuffer.writeData(testData, 3) == result::OK);
REQUIRE(ringBuffer.writeData(testData, 3) == returnvalue::OK);
REQUIRE(ringBuffer.getAvailableReadData() == 3);
REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) == result::FAILED);
REQUIRE(ringBuffer.readData(readBuffer, 5, false, false, nullptr) == returnvalue::FAILED);
size_t trueSize = 0;
REQUIRE(ringBuffer.readData(readBuffer, 5, false, true, &trueSize) == result::OK);
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) == result::FAILED);
REQUIRE(ringBuffer.deleteData(5, false, &trueSize) == returnvalue::FAILED);
REQUIRE(trueSize == 0);
REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == result::OK);
REQUIRE(ringBuffer.deleteData(5, true, &trueSize) == returnvalue::OK);
REQUIRE(trueSize == 3);
}
}

11
unittests/container/TestArrayList.cpp
View File

@ -1,5 +1,5 @@
#include <fsfw/container/ArrayList.h>
#include <fsfw/returnvalues/HasReturnvaluesIF.h>
#include <fsfw/returnvalues/returnvalue.h>
#include <catch2/catch_test_macros.hpp>
@ -25,7 +25,7 @@ TEST_CASE("Array List", "[containers]") {
SECTION("SimpleTest") {
REQUIRE(list.maxSize() == 20);
REQUIRE(list.size == 0);
REQUIRE(list.insert(10) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(list.insert(10) == static_cast<int>(returnvalue::OK));
REQUIRE(list[0] == 10);
REQUIRE(list.front() != nullptr);
REQUIRE((*list.front()) == 10);
@ -41,7 +41,7 @@ TEST_CASE("Array List", "[containers]") {
// 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>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(list.insert(i) == static_cast<int>(returnvalue::OK));
}
REQUIRE(list.insert(20) == static_cast<int>(ArrayList<uint16_t>::FULL));
ArrayList<uint16_t>::Iterator it = list.begin();
@ -64,7 +64,7 @@ TEST_CASE("Array List", "[containers]") {
SECTION("Const Iterator") {
ArrayList<uint16_t>::Iterator it = list.begin();
for (auto i = 0; i < 10; i++) {
REQUIRE(list.insert(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(list.insert(i) == static_cast<int>(returnvalue::OK));
}
it++;
const uint16_t* number = it.value;
@ -74,8 +74,7 @@ TEST_CASE("Array List", "[containers]") {
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>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(complexList.insert(TestClass(i, i + 1)) == static_cast<int>(returnvalue::OK));
}
it++;
const TestClass* secondTest = it.value;

47
unittests/container/TestDynamicFifo.cpp
View File

@ -1,6 +1,6 @@
#include <fsfw/container/DynamicFIFO.h>
#include <fsfw/container/FIFO.h>
#include <fsfw/returnvalues/HasReturnvaluesIF.h>
#include <fsfw/returnvalues/returnvalue.h>
#include <catch2/catch_test_macros.hpp>
@ -35,13 +35,13 @@ TEST_CASE("Dynamic Fifo Tests", "[containers]") {
REQUIRE(fifo.empty());
REQUIRE(not fifo.full());
REQUIRE(fifo.insert(structOne) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.insert(structTwo) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.insert(structThree) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
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>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.peek(&testptr) == static_cast<int>(returnvalue::OK));
bool equal = testptr == structOne;
REQUIRE(equal);
REQUIRE(fifo.size() == 3);
@ -52,7 +52,7 @@ TEST_CASE("Dynamic Fifo Tests", "[containers]") {
testptr.number1 = 0;
testptr.number2 = 0;
testptr.number3 = 0;
REQUIRE(fifo.retrieve(&testptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.retrieve(&testptr) == static_cast<int>(returnvalue::OK));
equal = testptr == list[i];
REQUIRE(equal);
REQUIRE(fifo.size() == i);
@ -66,29 +66,26 @@ TEST_CASE("Dynamic Fifo Tests", "[containers]") {
REQUIRE(fifo.empty());
REQUIRE(fifo.pop() == static_cast<int>(FIFOBase<Test>::EMPTY));
REQUIRE(fifo.insert(structOne) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.insert(structOne) == static_cast<int>(returnvalue::OK));
REQUIRE(fifo.size() == 1);
REQUIRE(fifo.insert(structTwo) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.insert(structTwo) == static_cast<int>(returnvalue::OK));
REQUIRE(fifo.size() == 2);
REQUIRE(fifo.pop() == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
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>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.peek(&testptr) == static_cast<int>(returnvalue::OK));
equal = testptr == structTwo;
REQUIRE(equal);
REQUIRE(fifo.pop() == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.pop() == static_cast<int>(returnvalue::OK));
REQUIRE(fifo.size() == 0);
REQUIRE(fifo.empty());
// struct Test* ptr = nullptr;
// REQUIRE(fifo.retrieve(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
// REQUIRE(fifo.peek(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
};
SECTION("Copy Test") {
REQUIRE(fifo.insert(structOne) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.insert(structTwo) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.insert(structThree) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
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());
@ -100,9 +97,9 @@ TEST_CASE("Dynamic Fifo Tests", "[containers]") {
};
SECTION("Assignment Test") {
REQUIRE(fifo.insert(structOne) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.insert(structTwo) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.insert(structThree) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
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());
@ -114,7 +111,7 @@ TEST_CASE("Dynamic Fifo Tests", "[containers]") {
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>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo2.retrieve(&testptr) == static_cast<int>(returnvalue::OK));
bool equal = testptr == list[i];
REQUIRE(equal);
REQUIRE(fifo2.size() == i);
@ -122,9 +119,9 @@ TEST_CASE("Dynamic Fifo Tests", "[containers]") {
};
SECTION("Assignment Test Smaller") {
REQUIRE(fifo.insert(structOne) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.insert(structTwo) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.insert(structThree) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
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());
@ -136,7 +133,7 @@ TEST_CASE("Dynamic Fifo Tests", "[containers]") {
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>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo2.retrieve(&testptr) == static_cast<int>(returnvalue::OK));
bool equal = testptr == list[i];
REQUIRE(equal);
REQUIRE(fifo2.size() == i);

42
unittests/container/TestFifo.cpp
View File

@ -1,6 +1,6 @@
#include <fsfw/container/DynamicFIFO.h>
#include <fsfw/container/FIFO.h>
#include <fsfw/returnvalues/HasReturnvaluesIF.h>
#include <fsfw/returnvalues/returnvalue.h>
#include <catch2/catch_test_macros.hpp>
@ -35,13 +35,13 @@ TEST_CASE("Static Fifo Tests", "[containers]") {
REQUIRE(fifo.empty());
REQUIRE(not fifo.full());
REQUIRE(fifo.insert(structOne) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.insert(structTwo) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.insert(structThree) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
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>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.peek(&testptr) == static_cast<int>(returnvalue::OK));
bool equal = testptr == structOne;
REQUIRE(equal);
REQUIRE(fifo.size() == 3);
@ -52,7 +52,7 @@ TEST_CASE("Static Fifo Tests", "[containers]") {
testptr.number1 = 0;
testptr.number2 = 0;
testptr.number3 = 0;
REQUIRE(fifo.retrieve(&testptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.retrieve(&testptr) == static_cast<int>(returnvalue::OK));
equal = testptr == list[i];
REQUIRE(equal);
REQUIRE(fifo.size() == i);
@ -66,11 +66,11 @@ TEST_CASE("Static Fifo Tests", "[containers]") {
REQUIRE(fifo.empty());
REQUIRE(fifo.pop() == static_cast<int>(FIFOBase<Test>::EMPTY));
REQUIRE(fifo.insert(structOne) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.insert(structOne) == static_cast<int>(returnvalue::OK));
REQUIRE(fifo.size() == 1);
REQUIRE(fifo.insert(structTwo) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.insert(structTwo) == static_cast<int>(returnvalue::OK));
REQUIRE(fifo.size() == 2);
REQUIRE(fifo.pop() == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.pop() == static_cast<int>(returnvalue::OK));
REQUIRE(fifo.size() == 1);
testptr.number1 = 0;
testptr.number2 = 0;
@ -78,20 +78,20 @@ TEST_CASE("Static Fifo Tests", "[containers]") {
// Test that retrieve and peek will not cause a nullptr dereference
struct Test* ptr = nullptr;
REQUIRE(fifo.retrieve(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
REQUIRE(fifo.peek(ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_FAILED));
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>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.peek(&testptr) == static_cast<int>(returnvalue::OK));
equal = testptr == structTwo;
REQUIRE(equal);
REQUIRE(fifo.pop() == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
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>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.insert(structTwo) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.insert(structThree) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
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());
@ -102,7 +102,7 @@ TEST_CASE("Static Fifo Tests", "[containers]") {
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>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo2.retrieve(&testptr) == static_cast<int>(returnvalue::OK));
bool equal = testptr == list[i];
REQUIRE(equal);
REQUIRE(fifo2.size() == i);
@ -110,9 +110,9 @@ TEST_CASE("Static Fifo Tests", "[containers]") {
};
SECTION("Assignment Test") {
REQUIRE(fifo.insert(structOne) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.insert(structTwo) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo.insert(structThree) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
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());
@ -124,7 +124,7 @@ TEST_CASE("Static Fifo Tests", "[containers]") {
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>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(fifo2.retrieve(&testptr) == static_cast<int>(returnvalue::OK));
bool equal = testptr == list[i];
REQUIRE(equal);
REQUIRE(fifo2.size() == i);

6
unittests/container/TestFixedArrayList.cpp
View File

@ -1,5 +1,5 @@
#include <fsfw/container/FixedArrayList.h>
#include <fsfw/returnvalues/HasReturnvaluesIF.h>
#include <fsfw/returnvalues/returnvalue.h>
#include <catch2/catch_test_macros.hpp>
@ -10,7 +10,7 @@ TEST_CASE("FixedArrayList Tests", "[containers]") {
using testList = FixedArrayList<uint32_t, 260, uint16_t>;
testList list;
REQUIRE(list.size == 0);
REQUIRE(list.insert(10) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(list.insert(10) == static_cast<int>(returnvalue::OK));
REQUIRE(list.size == 1);
REQUIRE(list.maxSize() == 260);
SECTION("Copy Constructor") {
@ -29,7 +29,7 @@ TEST_CASE("FixedArrayList Tests", "[containers]") {
};
SECTION("Fill") {
for (auto i = 1; i < 260; i++) {
REQUIRE(list.insert(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(list.insert(i) == static_cast<int>(returnvalue::OK));
}
REQUIRE(list.insert(260) == static_cast<int>(ArrayList<uint32_t, uint16_t>::FULL));
list.clear();

39
unittests/container/TestFixedMap.cpp
View File

@ -1,5 +1,5 @@
#include <fsfw/container/FixedMap.h>
#include <fsfw/returnvalues/HasReturnvaluesIF.h>
#include <fsfw/returnvalues/returnvalue.h>
#include <catch2/catch_test_macros.hpp>
@ -19,9 +19,8 @@ TEST_CASE("FixedMap Tests", "[containers]") {
SECTION("Fill and erase") {
for (uint16_t i = 0; i < 30; i++) {
REQUIRE(map.insert(std::make_pair(i, i + 1)) ==
static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(map.exists(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
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());
}
@ -32,7 +31,7 @@ TEST_CASE("FixedMap Tests", "[containers]") {
REQUIRE(map.full());
{
uint16_t* ptr;
REQUIRE(map.find(5, &ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(map.find(5, &ptr) == static_cast<int>(returnvalue::OK));
REQUIRE(*ptr == 6);
REQUIRE(*(map.findValue(6)) == 7);
REQUIRE(map.find(31, &ptr) ==
@ -41,7 +40,7 @@ TEST_CASE("FixedMap Tests", "[containers]") {
REQUIRE(map.getSerializedSize() ==
(sizeof(uint32_t) + 30 * (sizeof(uint32_t) + sizeof(uint16_t))));
REQUIRE(map.erase(2) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(map.erase(2) == static_cast<int>(returnvalue::OK));
REQUIRE(map.erase(31) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
REQUIRE(map.exists(2) == static_cast<int>(FixedMap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
REQUIRE(map.size() == 29);
@ -60,7 +59,7 @@ TEST_CASE("FixedMap Tests", "[containers]") {
}
for (FixedMap<uint32_t, uint16_t>::Iterator it = map.begin(); it != map.end(); it++) {
REQUIRE(map.erase(&it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(map.erase(&it) == static_cast<int>(returnvalue::OK));
}
REQUIRE(map.size() == 0);
@ -73,11 +72,11 @@ TEST_CASE("FixedMap Tests", "[containers]") {
SECTION("Insert variants") {
FixedMap<uint32_t, uint16_t>::Iterator it = map.end();
REQUIRE(map.insert(36, 37, &it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
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>(HasReturnvaluesIF::RETURN_OK));
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) ==
@ -86,8 +85,8 @@ TEST_CASE("FixedMap Tests", "[containers]") {
REQUIRE(map.size() == 2);
};
SECTION("Serialize and DeSerialize") {
REQUIRE(map.insert(36, 37, nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(map.insert(37, 38, nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
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))));
@ -97,27 +96,27 @@ TEST_CASE("FixedMap Tests", "[containers]") {
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>(HasReturnvaluesIF::RETURN_OK));
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>(HasReturnvaluesIF::RETURN_OK));
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>(HasReturnvaluesIF::RETURN_OK));
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>(HasReturnvaluesIF::RETURN_OK));
static_cast<int>(returnvalue::OK));
REQUIRE(second_element == i + 1);
}
REQUIRE(size == 0);
@ -126,7 +125,7 @@ TEST_CASE("FixedMap Tests", "[containers]") {
size = 16;
REQUIRE(map.size() == 0);
REQUIRE(map.deSerialize(&constPtr, &size, SerializeIF::Endianness::BIG) ==
static_cast<int>(HasReturnvaluesIF::RETURN_OK));
static_cast<int>(returnvalue::OK));
REQUIRE(map.size() == 2);
REQUIRE(map.find(36)->second == 37);
for (auto& element : map) {
@ -154,12 +153,12 @@ TEST_CASE("FixedMap Tests", "[containers]") {
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>(HasReturnvaluesIF::RETURN_OK));
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>(HasReturnvaluesIF::RETURN_OK));
static_cast<int>(returnvalue::OK));
REQUIRE(map.size() == 1);
REQUIRE(map.find(10)->second == 20);
};

43
unittests/container/TestFixedOrderedMultimap.cpp
View File

@ -1,5 +1,5 @@
#include <fsfw/container/FixedOrderedMultimap.h>
#include <fsfw/returnvalues/HasReturnvaluesIF.h>
#include <fsfw/returnvalues/returnvalue.h>
#include <catch2/catch_test_macros.hpp>
@ -14,9 +14,8 @@ TEST_CASE("FixedOrderedMultimap Tests", "[containers]") {
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>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(map.exists(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
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) ==
@ -26,12 +25,12 @@ TEST_CASE("FixedOrderedMultimap Tests", "[containers]") {
REQUIRE(map.size() == 30);
{
uint16_t* ptr;
REQUIRE(map.find(5, &ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
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>(HasReturnvaluesIF::RETURN_OK));
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) ==
@ -55,7 +54,7 @@ TEST_CASE("FixedOrderedMultimap Tests", "[containers]") {
{
FixedOrderedMultimap<uint32_t, uint16_t>::Iterator it = map.begin();
while (it != map.end()) {
REQUIRE(map.erase(&it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(map.erase(&it) == static_cast<int>(returnvalue::OK));
}
REQUIRE(map.size() == 0);
}
@ -69,16 +68,16 @@ TEST_CASE("FixedOrderedMultimap Tests", "[containers]") {
SECTION("Test different insert variants") {
FixedOrderedMultimap<uint32_t, uint16_t>::Iterator it = map.end();
REQUIRE(map.insert(36, 37, &it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
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>(HasReturnvaluesIF::RETURN_OK));
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>(HasReturnvaluesIF::RETURN_OK));
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>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(map.insert(0, 1, nullptr) == static_cast<int>(returnvalue::OK));
REQUIRE(map.find(0)->second == 1);
REQUIRE(map.size() == 4);
map.clear();
@ -128,8 +127,8 @@ TEST_CASE("FixedOrderedMultimap Non Trivial Type", "[TestFixedOrderedMultimapNon
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>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(map.exists(i) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
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);
}
@ -140,13 +139,13 @@ TEST_CASE("FixedOrderedMultimap Non Trivial Type", "[TestFixedOrderedMultimapNon
REQUIRE(map.size() == 30);
{
TestClass* ptr = nullptr;
REQUIRE(map.find(5, &ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
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>(HasReturnvaluesIF::RETURN_OK));
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) ==
@ -174,7 +173,7 @@ TEST_CASE("FixedOrderedMultimap Non Trivial Type", "[TestFixedOrderedMultimapNon
{
FixedOrderedMultimap<uint32_t, TestClass>::Iterator it = map.begin();
while (it != map.end()) {
REQUIRE(map.erase(&it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(map.erase(&it) == static_cast<int>(returnvalue::OK));
}
REQUIRE(map.size() == 0);
}
@ -188,23 +187,19 @@ TEST_CASE("FixedOrderedMultimap Non Trivial Type", "[TestFixedOrderedMultimapNon
SECTION("Test different insert variants") {
FixedOrderedMultimap<uint32_t, TestClass>::Iterator it = map.end();
REQUIRE(map.insert(36, TestClass(37, 36), &it) ==
static_cast<int>(HasReturnvaluesIF::RETURN_OK));
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>(HasReturnvaluesIF::RETURN_OK));
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>(HasReturnvaluesIF::RETURN_OK));
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>(HasReturnvaluesIF::RETURN_OK));
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);

10
unittests/container/TestPlacementFactory.cpp
View File

@ -1,6 +1,6 @@
#include <fsfw/container/ArrayList.h>
#include <fsfw/container/PlacementFactory.h>
#include <fsfw/returnvalues/HasReturnvaluesIF.h>
#include <fsfw/returnvalues/returnvalue.h>
#include <fsfw/storagemanager/LocalPool.h>
#include <catch2/catch_test_macros.hpp>
@ -36,13 +36,13 @@ TEST_CASE("PlacementFactory Tests", "[containers]") {
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>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(factory.destroy(number) == static_cast<int>(returnvalue::OK));
REQUIRE(storagePool.getFreeElement(&address, sizeof(uint64_t), &ptr) ==
static_cast<int>(HasReturnvaluesIF::RETURN_OK));
REQUIRE(storagePool.deleteData(address) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
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>(HasReturnvaluesIF::RETURN_FAILED));
REQUIRE(factory.destroy(ptr) == static_cast<int>(returnvalue::FAILED));
}
}