.idea
automation
cmake
contrib
docs
misc
scripts
src
unittests
action
cfdp
container
CMakeLists.txt
RingBufferTest.cpp
TestArrayList.cpp
TestDynamicFifo.cpp
TestFifo.cpp
TestFixedArrayList.cpp
TestFixedMap.cpp
TestFixedOrderedMultimap.cpp
TestPlacementFactory.cpp
datapoollocal
devicehandler
globalfunctions
hal
internalerror
mocks
osal
power
pus
serialize
storagemanager
tcdistributor
testcfg
testtemplate
timemanager
tmtcpacket
tmtcservices
util
CMakeLists.txt
CatchDefinitions.cpp
CatchDefinitions.h
CatchFactory.cpp
CatchFactory.h
CatchRunner.cpp
CatchRunner.h
CatchSetup.cpp
lcov_epilog.html
printChar.cpp
printChar.h
testVersion.cpp
.clang-format
.gitignore
.gitmodules
CHANGELOG.md
CMakeLists.txt
FSFWVersion.h.in
LICENSE
NOTICE
README.md
166 lines
6.5 KiB
C++
166 lines
6.5 KiB
C++
#include <fsfw/container/FixedMap.h>
|
|
#include <fsfw/returnvalues/returnvalue.h>
|
|
|
|
#include <catch2/catch_test_macros.hpp>
|
|
|
|
#include "CatchDefinitions.h"
|
|
|
|
template class FixedMap<unsigned int, unsigned short>;
|
|
|
|
using namespace returnvalue;
|
|
|
|
TEST_CASE("FixedMap Tests", "[containers]") {
|
|
INFO("FixedMap Tests");
|
|
|
|
FixedMap<unsigned int, unsigned short> map(30);
|
|
REQUIRE(map.size() == 0);
|
|
REQUIRE(map.maxSize() == 30);
|
|
REQUIRE(map.getSerializedSize() == sizeof(uint32_t));
|
|
REQUIRE(map.empty());
|
|
REQUIRE(not map.full());
|
|
|
|
SECTION("Fill and erase") {
|
|
for (uint16_t i = 0; i < 30; i++) {
|
|
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());
|
|
}
|
|
REQUIRE(map.insert(0, 0) == static_cast<int>(containers::KEY_ALREADY_EXISTS));
|
|
REQUIRE(map.insert(31, 0) == static_cast<int>(containers::MAP_FULL));
|
|
REQUIRE(map.exists(31) == static_cast<int>(containers::KEY_DOES_NOT_EXIST));
|
|
REQUIRE(map.size() == 30);
|
|
REQUIRE(map.full());
|
|
{
|
|
uint16_t* ptr;
|
|
REQUIRE(map.find(5, &ptr) == static_cast<int>(returnvalue::OK));
|
|
REQUIRE(*ptr == 6);
|
|
REQUIRE(*(map.findValue(6)) == 7);
|
|
REQUIRE(map.find(31, &ptr) == static_cast<int>(containers::KEY_DOES_NOT_EXIST));
|
|
}
|
|
|
|
REQUIRE(map.getSerializedSize() ==
|
|
(sizeof(uint32_t) + 30 * (sizeof(uint32_t) + sizeof(uint16_t))));
|
|
REQUIRE(map.erase(2) == static_cast<int>(returnvalue::OK));
|
|
REQUIRE(map.erase(31) == static_cast<int>(containers::KEY_DOES_NOT_EXIST));
|
|
REQUIRE(map.exists(2) == static_cast<int>(containers::KEY_DOES_NOT_EXIST));
|
|
REQUIRE(map.size() == 29);
|
|
|
|
for (auto element : map) {
|
|
if (element.first == 5) {
|
|
REQUIRE(element.second == 6);
|
|
}
|
|
}
|
|
|
|
for (FixedMap<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);
|
|
}
|
|
|
|
for (FixedMap<uint32_t, uint16_t>::Iterator it = map.begin(); it != map.end(); it++) {
|
|
REQUIRE(map.erase(&it) == static_cast<int>(returnvalue::OK));
|
|
}
|
|
|
|
REQUIRE(map.size() == 0);
|
|
|
|
for (FixedMap<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("Insert variants") {
|
|
FixedMap<uint32_t, uint16_t>::Iterator it = map.end();
|
|
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>(returnvalue::OK));
|
|
REQUIRE(map.find(37)->second == 38);
|
|
REQUIRE(map.size() == 2);
|
|
REQUIRE(map.insert(37, 24, nullptr) == static_cast<int>(containers::KEY_ALREADY_EXISTS));
|
|
REQUIRE(map.find(37)->second != 24);
|
|
REQUIRE(map.size() == 2);
|
|
};
|
|
SECTION("Serialize and DeSerialize") {
|
|
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))));
|
|
uint8_t* loc_ptr = buffer;
|
|
size_t size = 0;
|
|
REQUIRE(map.serialize(&loc_ptr, &size, 10, SerializeIF::Endianness::BIG) ==
|
|
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>(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>(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>(returnvalue::OK));
|
|
REQUIRE(first_element == i);
|
|
uint16_t second_element = 0;
|
|
REQUIRE(SerializeAdapter::deSerialize(&second_element, &ptr2, &size,
|
|
SerializeIF::Endianness::BIG) ==
|
|
static_cast<int>(returnvalue::OK));
|
|
REQUIRE(second_element == i + 1);
|
|
}
|
|
REQUIRE(size == 0);
|
|
map.clear();
|
|
const uint8_t* constPtr = buffer;
|
|
size = 16;
|
|
REQUIRE(map.size() == 0);
|
|
REQUIRE(map.deSerialize(&constPtr, &size, SerializeIF::Endianness::BIG) ==
|
|
static_cast<int>(returnvalue::OK));
|
|
REQUIRE(map.size() == 2);
|
|
REQUIRE(map.find(36)->second == 37);
|
|
for (auto& element : map) {
|
|
REQUIRE((element.first + 1) == element.second);
|
|
}
|
|
};
|
|
|
|
SECTION("Failed erase and deSerialize") {
|
|
FixedMap<uint32_t, uint16_t>::Iterator it;
|
|
std::pair<uint32_t, uint16_t> pair = std::make_pair(44, 43);
|
|
it = FixedMap<uint32_t, uint16_t>::Iterator(&pair);
|
|
REQUIRE(map.erase(&it) == static_cast<int>(containers::KEY_DOES_NOT_EXIST));
|
|
REQUIRE(map.find(45) == map.end());
|
|
size_t toLargeMap = 100;
|
|
const uint8_t* ptr = reinterpret_cast<uint8_t*>(&toLargeMap);
|
|
size_t size = sizeof(size_t);
|
|
REQUIRE(map.deSerialize(&ptr, &size, SerializeIF::Endianness::BIG) ==
|
|
static_cast<int>(SerializeIF::TOO_MANY_ELEMENTS));
|
|
};
|
|
SECTION("Little Endianess") {
|
|
map.clear();
|
|
map.insert(10, 20, nullptr);
|
|
uint8_t newBuffer[sizeof(uint32_t) + 1 * (sizeof(uint32_t) + sizeof(uint16_t))];
|
|
uint8_t* ptr = newBuffer;
|
|
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>(returnvalue::OK));
|
|
map.clear();
|
|
REQUIRE(map.size() == 0);
|
|
const uint8_t* ptr2 = newBuffer;
|
|
REQUIRE(map.deSerialize(&ptr2, &size, SerializeIF::Endianness::LITTLE) ==
|
|
static_cast<int>(returnvalue::OK));
|
|
REQUIRE(map.size() == 1);
|
|
REQUIRE(map.find(10)->second == 20);
|
|
};
|
|
}
|