fsfw/unittests/container/TestFixedOrderedMultimap.cpp

#include <fsfw/container/FixedOrderedMultimap.h>
#include <fsfw/returnvalues/HasReturnvaluesIF.h>

#include <catch2/catch_test_macros.hpp>

#include "fsfw_tests/unit/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());
  }
}