action
container
contrib
controller
coordinates
datalinklayer
datapool
datapoollocal
defaultcfg
devicehandlers
doc
events
fdir
globalfunctions
health
housekeeping
internalError
ipc
logo
memory
modes
monitoring
objectmanager
osal
parameters
power
pus
returnvalues
rmap
serialize
serviceinterface
storagemanager
subsystem
tasks
tcdistribution
thermal
timemanager
tmstorage
tmtcpacket
tmtcservices
unittest
internal
tests
action
container
CMakeLists.txt
RingBufferTest.cpp
TestArrayList.cpp
TestDynamicFifo.cpp
TestFifo.cpp
TestFixedArrayList.cpp
TestFixedMap.cpp
TestFixedOrderedMultimap.cpp
TestPlacementFactory.cpp
datapoollocal
globalfunctions
mocks
osal
serialize
storagemanager
CMakeLists.txt
tests.mk
user
CMakeLists.txt
README.md
lcov.sh
.gitignore
.gitmodules
CHANGELOG
CMakeLists.txt
FSFWVersion.h
LICENSE
NOTICE
README.md
fsfw.mk
204 lines
7.6 KiB
C++
204 lines
7.6 KiB
C++
#include <fsfw/container/FixedOrderedMultimap.h>
|
|
#include <fsfw/returnvalues/HasReturnvaluesIF.h>
|
|
|
|
#include <catch2/catch_test_macros.hpp>
|
|
#include <unittest/core/CatchDefinitions.h>
|
|
|
|
TEST_CASE( "FixedOrderedMultimap Tests", "[TestFixedOrderedMultimap]") {
|
|
INFO("FixedOrderedMultimap Tests");
|
|
|
|
FixedOrderedMultimap<unsigned int, unsigned short> map(30);
|
|
REQUIRE(map.size() == 0);
|
|
REQUIRE(map.maxSize() == 30);
|
|
|
|
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.find(i)->second==i+1);
|
|
}
|
|
REQUIRE(map.insert(0, 0) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::MAP_FULL));
|
|
REQUIRE(map.exists(31) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
|
|
REQUIRE(map.size() == 30);
|
|
{
|
|
uint16_t* ptr;
|
|
REQUIRE(map.find(5,&ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_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(31) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
|
|
REQUIRE(map.exists(2) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
|
|
REQUIRE(map.size() == 29);
|
|
|
|
for (auto element: map){
|
|
if (element.first == 5){
|
|
REQUIRE(element.second == 6);
|
|
}
|
|
}
|
|
|
|
for (FixedOrderedMultimap<uint32_t, uint16_t>::Iterator it = map.begin(); it != map.end(); it++){
|
|
REQUIRE(it->second == it->first + 1);
|
|
REQUIRE((*it).second == (*it).first + 1);
|
|
it->second = it->second + 1;
|
|
REQUIRE(it->second == it->first + 2);
|
|
}
|
|
|
|
{
|
|
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.size() == 0);
|
|
}
|
|
|
|
for (FixedOrderedMultimap<uint32_t, uint16_t>::Iterator it = map.begin(); it != map.end(); it++){
|
|
// This line should never executed if begin and end is correct
|
|
FAIL("Should never be reached, Iterators invalid");
|
|
}
|
|
};
|
|
|
|
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(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.find(37)->second == 38);
|
|
REQUIRE(map.size() == 2);
|
|
REQUIRE(map.insert(37, 24, nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
|
|
REQUIRE(map.find(37)->second == 38);
|
|
REQUIRE(map.insert(0, 1, nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
|
|
REQUIRE(map.find(0)->second == 1);
|
|
REQUIRE(map.size() == 4);
|
|
map.clear();
|
|
REQUIRE(map.size() == 0);
|
|
}
|
|
SECTION("Test different erase and find with no entries"){
|
|
FixedOrderedMultimap<uint32_t, uint16_t>::Iterator it;
|
|
it = map.end();
|
|
REQUIRE(map.erase(&it) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
|
|
REQUIRE(map.find(1)== map.end());
|
|
}
|
|
}
|
|
|
|
TEST_CASE( "FixedOrderedMultimap Non Trivial Type", "[TestFixedOrderedMultimapNonTrivial]") {
|
|
INFO("FixedOrderedMultimap Non Trivial Type");
|
|
|
|
class TestClass{
|
|
public:
|
|
TestClass(){};
|
|
TestClass(uint32_t number1, uint64_t number2):
|
|
number1(number1),number2(number2){};
|
|
~TestClass(){};
|
|
|
|
bool operator==(const TestClass& lhs){
|
|
return ((this->number1 == lhs.number1) and (this->number2 == lhs.number2));
|
|
}
|
|
bool operator!=(const TestClass& lhs){
|
|
return not(this->operator ==(lhs));
|
|
}
|
|
|
|
TestClass(const TestClass& other){
|
|
this->number1 = other.number1;
|
|
this->number2 = other.number2;
|
|
};
|
|
TestClass& operator=(const TestClass& other){
|
|
this->number1 = other.number1;
|
|
this->number2 = other.number2;
|
|
return *this;
|
|
};
|
|
|
|
private:
|
|
uint32_t number1 = 0;
|
|
uint64_t number2 = 5;
|
|
};
|
|
FixedOrderedMultimap<unsigned int, TestClass> map(30);
|
|
REQUIRE(map.size() == 0);
|
|
REQUIRE(map.maxSize() == 30);
|
|
|
|
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));
|
|
bool compare = map.find(i)->second == TestClass(i+1,i);
|
|
REQUIRE(compare);
|
|
}
|
|
REQUIRE(map.insert(0, TestClass()) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::MAP_FULL));
|
|
REQUIRE(map.exists(31) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
|
|
REQUIRE(map.size() == 30);
|
|
{
|
|
TestClass* ptr = nullptr;
|
|
REQUIRE(map.find(5,&ptr) == static_cast<int>(HasReturnvaluesIF::RETURN_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(31) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
|
|
REQUIRE(map.exists(2) == static_cast<int>(FixedOrderedMultimap<uint32_t, uint16_t>::KEY_DOES_NOT_EXIST));
|
|
REQUIRE(map.size() == 29);
|
|
|
|
for (auto element: map){
|
|
if (element.first == 5){
|
|
bool compare = element.second == TestClass(6, 5);
|
|
REQUIRE(compare);
|
|
}
|
|
}
|
|
|
|
for (FixedOrderedMultimap<uint32_t, TestClass>::Iterator it = map.begin(); it != map.end(); it++){
|
|
bool compare = it->second == TestClass(it->first + 1, it->first);
|
|
REQUIRE(compare);
|
|
compare = (*it).second == TestClass((*it).first + 1, (*it).first);
|
|
REQUIRE(compare);
|
|
it->second = TestClass(it->first + 2, it->first);
|
|
compare = it->second == TestClass(it->first + 2, it->first);
|
|
REQUIRE(compare);
|
|
}
|
|
|
|
{
|
|
FixedOrderedMultimap<uint32_t, TestClass>::Iterator it = map.begin();
|
|
while(it != map.end()){
|
|
REQUIRE(map.erase(&it) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
|
|
}
|
|
REQUIRE(map.size() == 0);
|
|
}
|
|
|
|
for (FixedOrderedMultimap<uint32_t, TestClass>::Iterator it = map.begin(); it != map.end(); it++){
|
|
// This line should never executed if begin and end is correct
|
|
FAIL("Should never be reached, Iterators invalid");
|
|
}
|
|
};
|
|
|
|
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(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));
|
|
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));
|
|
compare = map.find(37)->second == TestClass(38, 37);
|
|
REQUIRE(compare);
|
|
REQUIRE(map.insert(0, TestClass(1, 0), nullptr) == static_cast<int>(HasReturnvaluesIF::RETURN_OK));
|
|
compare = map.find(0)->second == TestClass(1, 0);
|
|
REQUIRE(compare);
|
|
REQUIRE(map.size() == 4);
|
|
map.clear();
|
|
REQUIRE(map.size() == 0);
|
|
}
|
|
SECTION("Test different erase and find with no entries"){
|
|
FixedOrderedMultimap<uint32_t, TestClass>::Iterator it;
|
|
it = map.end();
|
|
REQUIRE(map.erase(&it) == static_cast<int>(FixedOrderedMultimap<uint32_t, TestClass>::KEY_DOES_NOT_EXIST));
|
|
REQUIRE(map.find(1)== map.end());
|
|
}
|
|
}
|