memgraph/tests/unit/rh_hashmultimap.cpp

#include "gtest/gtest.h"

#include "data_structures/map/rh_hashmultimap.hpp"

class Data {
 private:
  size_t data = 0;
  int key;

 public:
  Data(int key) : key(key) {}

  const int &get_key() { return key; }
};

void cross_validate(RhHashMultiMap<int, Data> &map,
                    std::multimap<int, Data *> &s_map);

void cross_validate_weak(RhHashMultiMap<int, Data> &map,
                         std::multimap<int, Data *> &s_map);

TEST(RobinHoodHashmultimap, BasicFunctionality) {
  RhHashMultiMap<int, Data> map;

  ASSERT_EQ(map.size(), 0);
  map.add(new Data(0));
  ASSERT_EQ(map.size(), 1);
}

TEST(RobinHoodHashmultimap, InsertGetCheck) {
  RhHashMultiMap<int, Data> map;

  ASSERT_EQ(map.find(0), map.end());
  auto ptr0 = new Data(0);
  map.add(ptr0);
  ASSERT_NE(map.find(0), map.end());
  ASSERT_EQ(*map.find(0), ptr0);
}

TEST(RobinHoodHashmultimap, ExtremeSameKeyValusFull) {
  RhHashMultiMap<int, Data> map;

  for (int i = 0; i < 128; i++) {
    map.add(new Data(7));
  }
  ASSERT_EQ(map.size(), 128);
  ASSERT_NE(map.find(7), map.end());
  ASSERT_EQ(map.find(0), map.end());
  auto ptr0 = new Data(0);
  map.add(ptr0);
  ASSERT_NE(map.find(0), map.end());
  ASSERT_EQ(*map.find(0), ptr0);
}

TEST(RobinHoodHashmultimap, ExtremeSameKeyValusFullWithRemove) {
  RhHashMultiMap<int, Data> map;

  for (int i = 0; i < 127; i++) {
    map.add(new Data(7));
  }
  auto ptr = new Data(7);
  map.add(ptr);
  ASSERT_EQ(map.size(), 128);
  ASSERT_EQ(!map.remove(new Data(0)), true);
  ASSERT_EQ(map.remove(ptr), true);
}

TEST(RobinHoodHasmultihmap, RemoveFunctionality) {
  RhHashMultiMap<int, Data> map;

  ASSERT_EQ(map.find(0), map.end());
  auto ptr0 = new Data(0);
  map.add(ptr0);
  ASSERT_NE(map.find(0), map.end());
  ASSERT_EQ(*map.find(0), ptr0);
  ASSERT_EQ(map.remove(ptr0), true);
  ASSERT_EQ(map.find(0), map.end());
}

TEST(RobinHoodHashmultimap, DoubleInsert) {
  RhHashMultiMap<int, Data> map;

  auto ptr0 = new Data(0);
  auto ptr1 = new Data(0);
  map.add(ptr0);
  map.add(ptr1);

  for (auto e : map) {
    if (ptr0 == e) {
      ptr0 = nullptr;
      continue;
    }
    if (ptr1 == e) {
      ptr1 = nullptr;
      continue;
    }
    ASSERT_EQ(true, false);
  }
}

TEST(RobinHoodHashmultimap, FindAddFind) {
  RhHashMultiMap<int, Data> map;

  for (int i = 0; i < 128; i++) {
    ASSERT_EQ(map.find(i), map.end());
    map.add(new Data(i));
    ASSERT_NE(map.find(i), map.end());
  }

  for (int i = 0; i < 128; i++) {
    ASSERT_NE(map.find(i), map.end());
    ASSERT_EQ(map.find(i)->get_key(), i);
  }
}

TEST(RobinHoodHashmultimap, Iterate) {
  RhHashMultiMap<int, Data> map;

  for (int i = 0; i < 128; i++) {
    ASSERT_EQ(map.find(i), map.end());
    map.add(new Data(i));
    ASSERT_NE(map.find(i), map.end());
  }

  bool seen[128] = {false};
  for (auto e : map) {
    auto key = e->get_key();
    ASSERT_EQ(!seen[key], true);
    seen[key] = true;
  }
  for (int i = 0; i < 128; i++) {
    ASSERT_EQ(seen[i], true);
  }
}

TEST(RobinHoodHashmultimap, Checked) {
  RhHashMultiMap<int, Data> map;
  std::multimap<int, Data *> s_map;

  for (int i = 0; i < 1638; i++) {
    int key = (std::rand() % 100) << 3;

    auto data = new Data(key);
    map.add(data);
    s_map.insert(std::pair<int, Data *>(key, data));
  }
  cross_validate(map, s_map);
}

TEST(RobinHoodHashmultimap, CheckedRand) {
  RhHashMultiMap<int, Data> map;
  std::multimap<int, Data *> s_map;
  std::srand(std::time(0));
  for (int i = 0; i < 164308; i++) {
    int key = (std::rand() % 10000) << 3;

    auto data = new Data(key);
    map.add(data);
    s_map.insert(std::pair<int, Data *>(key, data));
  }
  cross_validate(map, s_map);
}

TEST(RobinHoodHashmultimap, WithRemoveDataChecked) {
  RhHashMultiMap<int, Data> map;
  std::multimap<int, Data *> s_map;

  std::srand(std::time(0));
  for (int i = 0; i < 162638; i++) {
    int key = (std::rand() % 10000) << 3;
    if ((std::rand() % 2) == 0) {
      auto it = s_map.find(key);
      if (it == s_map.end()) {
        ASSERT_EQ(map.find(key), map.end());
      } else {
        s_map.erase(it);
        ASSERT_EQ(map.remove(it->second), true);
      }
    } else {
      auto data = new Data(key);
      map.add(data);
      s_map.insert(std::pair<int, Data *>(key, data));
    }
  }

  cross_validate(map, s_map);
}

void cross_validate(RhHashMultiMap<int, Data> &map,
                    std::multimap<int, Data *> &s_map) {
  for (auto e : map) {
    auto it = s_map.find(e->get_key());

    while (it != s_map.end() && it->second != e) {
      it++;
    }
    ASSERT_NE(it, s_map.end());
  }

  for (auto e : s_map) {
    auto it = map.find(e.first);

    while (it != map.end() && *it != e.second) {
      it++;
    }
    ASSERT_NE(it, map.end());
  }
}

void cross_validate_weak(RhHashMultiMap<int, Data> &map,
                         std::multimap<int, Data *> &s_map) {
  int count = 0;
  int key = 0;
  for (auto e : map) {
    if (e->get_key() == key) {
      count++;
    } else {
      auto it = s_map.find(key);

      while (it != s_map.end() && it->first == key) {
        it++;
        count--;
      }
      ASSERT_EQ(count, 0);
      key = e->get_key();
      count = 1;
    }
  }
  {
    auto it = s_map.find(key);

    while (it != s_map.end() && it->first == key) {
      it++;
      count--;
    }
    ASSERT_EQ(count, 0);
  }

  for (auto e : s_map) {
    if (e.first == key) {
      count++;
    } else {
      auto it = map.find(key);

      while (it != map.end() && it->get_key() == key) {
        it++;
        count--;
      }
      ASSERT_EQ(count, 0);
      key = e.first;
      count = 1;
    }
  }
  {
    auto it = map.find(key);

    while (it != map.end() && it->get_key() == key) {
      it++;
      count--;
    }
    ASSERT_EQ(count, 0);
  }
}