src/tests/test_s21_set.cpp - master - Xakka/CPP2

src/tests/test_s21_set.cpp
490 строк10 KB
moshedur
master: release 1.0
04 янв 2025, 23:35
04 янв 2025, 23:351c45f0a
#include "test_s21.h"

TEST(s21_set, def_constructor_1) {
  s21::s21_set<int> a;
  EXPECT_EQ(0, a.size());
}

TEST(s21_set, def_constructor_2) {
  s21::s21_set<int> a;
  std::set<int> b;
  EXPECT_EQ(b.empty(), a.empty());
}

TEST(s21_set, def_constructor_3) {
  s21::s21_set<int> s;
  EXPECT_TRUE(s.empty());
  EXPECT_EQ(s.size(), 0);
}

TEST(s21_set, init_list_constructor_1) {
  s21::s21_set<int> a{1};
  EXPECT_EQ(1, a.size());
}

TEST(s21_set, init_list_constructor_2) {
  s21::s21_set<int> a{1, 2};
  EXPECT_EQ(2, a.size());
}

TEST(s21_set, init_list_constructor_3) {
  s21::s21_set<int> a{1, 2, 1};
  EXPECT_EQ(2, a.size());
}

TEST(s21_set, init_list_constructor_4) {
  s21::s21_set<int> a{1, 2, 1, 2};
  EXPECT_EQ(2, a.size());
}

TEST(s21_set, init_list_constructor_5) {
  s21::s21_set<int> s = {1, 2, 3};
  EXPECT_EQ(s.size(), 3);
  EXPECT_TRUE(s.contains(1));
  EXPECT_TRUE(s.contains(2));
  EXPECT_TRUE(s.contains(3));
}

TEST(s21_set, copy_constructor_1) {
  s21::s21_set<int> s1 = {1, 2, 3};
  s21::s21_set<int> s2(s1);
  EXPECT_EQ(s1.size(), s2.size());
}

TEST(s21_set, move_constructor_1) {
  s21::s21_set<int> s1 = {1, 2, 3};
  s21::s21_set<int> s2(std::move(s1));
  EXPECT_EQ(s2.size(), 3);
  EXPECT_TRUE(s2.contains(1));
  EXPECT_TRUE(s2.contains(2));
  EXPECT_TRUE(s2.contains(3));
}

TEST(s21_set, insert_1) {
  s21::s21_set<int> a;
  EXPECT_EQ(true, a.insert(4).second);
  EXPECT_EQ(1, a.size());
}

TEST(s21_set, insert_2) {
  s21::s21_set<int> a;
  EXPECT_EQ(true, a.insert(4).second);
  EXPECT_EQ(1, a.size());
  EXPECT_EQ(true, a.insert(5).second);
  EXPECT_EQ(2, a.size());
}

TEST(s21_set, insert_3) {
  s21::s21_set<int> a;
  EXPECT_EQ(true, a.insert(4).second);
  EXPECT_EQ(1, a.size());
  EXPECT_EQ(true, a.insert(5).second);
  EXPECT_EQ(2, a.size());
  EXPECT_EQ(false, a.insert(4).second);
  EXPECT_EQ(2, a.size());
}

TEST(s21_set, insert_4) {
  s21::s21_set<int> a;
  EXPECT_EQ(true, a.insert(4).second);
  EXPECT_EQ(1, a.size());
  EXPECT_EQ(true, a.insert(5).second);
  EXPECT_EQ(2, a.size());
  EXPECT_EQ(false, a.insert(4).second);
  EXPECT_EQ(2, a.size());
  EXPECT_EQ(false, a.insert(5).second);
  EXPECT_EQ(2, a.size());
}

TEST(s21_set, insert_5) {
  s21::s21_set<int> a;
  EXPECT_EQ(true, a.insert(4).second);
  EXPECT_EQ(1, a.size());
  EXPECT_EQ(true, a.insert(3).second);
  EXPECT_EQ(2, a.size());
}

TEST(s21_set, clear_1) {
  s21::s21_set<int> a{1, 2, 1};
  a.clear();
  EXPECT_EQ(0, a.size());
}

TEST(s21_set, clear_2) {
  s21::s21_set<int> a;
  std::set<int> b;
  a.clear();
  b.clear();
  EXPECT_EQ(a.empty(), b.empty());
  EXPECT_EQ(a.size(), b.size());
  a.insert(1);
  b.insert(2);
  EXPECT_EQ(a.empty(), b.empty());
  EXPECT_EQ(a.size(), b.size());
  a.clear();
  b.clear();
  EXPECT_EQ(a.empty(), b.empty());
  EXPECT_EQ(a.size(), b.size());
}

TEST(s21_set, swap_1) {
  s21::s21_set<int> a{1, 2, 1};
  EXPECT_EQ(2, a.size());
  s21::s21_set<int> b{3, 4, 5};
  EXPECT_EQ(3, b.size());
  a.swap(b);
  EXPECT_EQ(3, a.size());
  EXPECT_EQ(2, b.size());
}

TEST(s21_set, swap_2) {
  s21::s21_set<int> s1{1, 2, 3};
  s21::s21_set<int> s2{4, 5, 6};
  s1.swap(s2);
  EXPECT_EQ(s1.size(), 3);
  EXPECT_EQ(s2.size(), 3);
  EXPECT_TRUE(s2.contains(1));
  EXPECT_TRUE(s1.contains(4));
}

TEST(s21_set, merge_1) {
  s21::s21_set<int> a{1};
  EXPECT_EQ(1, a.size());
  s21::s21_set<int> b{2};
  EXPECT_EQ(1, a.size());
  a.merge(b);
  EXPECT_EQ(2, a.size());
}

TEST(s21_set, merge_2) {
  s21::s21_set<int> a{1};
  EXPECT_EQ(1, a.size());
  s21::s21_set<int> b{1};
  EXPECT_EQ(1, a.size());
  a.merge(b);
  EXPECT_EQ(1, a.size());
}

TEST(s21_set, merge_3) {
  s21::s21_set<int> a{1, 2, 3};
  EXPECT_EQ(3, a.size());
  s21::s21_set<int> b{4, 5, 6};
  EXPECT_EQ(3, a.size());
  a.merge(b);
  EXPECT_EQ(6, a.size());
}

TEST(s21_set, merge_4) {
  s21::s21_set<int> a{1, 2, 1};
  EXPECT_EQ(2, a.size());
  s21::s21_set<int> b{3, 4, 5};
  EXPECT_EQ(3, b.size());
  a.merge(b);
  EXPECT_EQ(5, a.size());
}

TEST(s21_set, contains_1) {
  s21::s21_set<int> a{1};
  EXPECT_EQ(1, a.size());
  EXPECT_EQ(true, a.contains(1));
}

TEST(s21_set, contains_2) {
  s21::s21_set<int> a{1};
  EXPECT_EQ(1, a.size());
  EXPECT_EQ(false, a.contains(0));
  EXPECT_EQ(false, a.contains(2));
}

TEST(s21_set, contains_3) {
  s21::s21_set<int> a = {1, 2, 3, 4, 5, 6};
  s21::s21_set<int> b = {1, 2, 3, 4, 5, 6};
  EXPECT_EQ(a.contains(1), b.contains(1));
  EXPECT_EQ(a.contains(2), b.contains(2));
}

TEST(s21_set, empty_1) {
  s21::s21_set<int> a{1};
  EXPECT_EQ(false, a.empty());
}

TEST(s21_set, empty_2) {
  s21::s21_set<int> a;
  EXPECT_EQ(true, a.empty());
}

TEST(s21_set, empty_3) {
  s21::s21_set<int> a{1};
  EXPECT_EQ(false, a.empty());
  a.clear();
  EXPECT_EQ(true, a.empty());
}

TEST(s21_set, empty_4) {
  s21::s21_set<int> a;
  std::set<int> b;
  EXPECT_EQ(a.empty(), b.empty());
  EXPECT_EQ(a.size(), b.size());
  a.insert(1);
  b.insert(2);
  EXPECT_EQ(a.empty(), b.empty());
  EXPECT_EQ(a.size(), b.size());
}

TEST(s21_set, begin_1) {
  s21::s21_set<int> a{3, 5, 1, 4, 2};
  auto it1 = a.begin();
  auto it2 = a.end();
  EXPECT_EQ(*it1, 1);
  EXPECT_EQ(*it2, 5);
}

TEST(s21_set, size_1) {
  s21::s21_set<int> a{1};
  EXPECT_EQ(1, a.size());
  a.clear();
  ASSERT_EQ(0, a.size());
}

TEST(s21_set, size_2) {
  s21::s21_set<int> a{1, 2};
  EXPECT_EQ(2, a.size());
  a.clear();
  ASSERT_EQ(0, a.size());
}

TEST(s21_set, size_3) {
  s21::s21_set<int> a{1, 2, 3};
  EXPECT_EQ(3, a.size());
  a.clear();
  ASSERT_EQ(0, a.size());
}

TEST(s21_set, erase_1) {
  s21::s21_set<int> a{1, 2, 3, 4, 5};
  auto it = a.find(3);
  a.erase(it);
  EXPECT_EQ(a.size(), 4);
  EXPECT_FALSE(a.contains(3));
}

TEST(s21_set, erase_2) {
  s21::s21_set<int> a{3, 2, 4, 1, 5};
  auto it = a.find(3);
  a.erase(it);
  EXPECT_EQ(a.size(), 4);
  EXPECT_FALSE(a.contains(3));
}

TEST(s21_set, erase_3) {
  s21::s21_set<int> a{1, 2, 3, 4, 5};
  auto it = a.find(5);
  a.erase(it);
  EXPECT_EQ(a.size(), 4);
  EXPECT_FALSE(a.contains(5));
}

TEST(s21_set, erase_4) {
  s21::s21_set<int> a{1, 2, 3, 4, 5};
  auto it = a.find(1);
  a.erase(it);
  EXPECT_EQ(a.size(), 4);
  EXPECT_FALSE(a.contains(1));
}

TEST(s21_set, erase_5) {
  s21::s21_set<int> a{5, 4, 3, 2, 1};
  auto it = a.find(1);
  a.erase(it);
  EXPECT_EQ(a.size(), 4);
  EXPECT_FALSE(a.contains(1));
}

TEST(s21_set, erase_6) {
  s21::s21_set<int> a{5, 4, 3, 2, 1};
  auto it = a.find(5);
  a.erase(it);
  EXPECT_EQ(a.size(), 4);
  EXPECT_FALSE(a.contains(5));
}

TEST(s21_set, erase_7) {
  s21::s21_set<int> a{5, 4, 3, 2, 1};
  auto it = a.find(3);
  a.erase(it);
  EXPECT_EQ(a.size(), 4);
  EXPECT_FALSE(a.contains(3));
}

TEST(s21_set, erase_8) {
  s21::s21_set<int> a{3, 2, 4, 1, 5};
  auto it = a.find(1);
  a.erase(it);
  EXPECT_EQ(a.size(), 4);
  EXPECT_FALSE(a.contains(1));
}

TEST(s21_set, erase_9) {
  s21::s21_set<int> a{3, 2, 4, 1, 5};
  auto it = a.find(5);
  a.erase(it);
  EXPECT_EQ(a.size(), 4);
  EXPECT_FALSE(a.contains(5));
}

TEST(s21_set, find_1) {
  s21::s21_set<int> a{1, 2, 3};
  auto it1 = a.find(1);
  auto it2 = a.find(2);
  auto it3 = a.find(3);
  EXPECT_EQ(*it1, 1);
  EXPECT_EQ(*it2, 2);
  EXPECT_EQ(*it3, 3);
  EXPECT_EQ(true, it1 == a.begin());
  EXPECT_EQ(true, it3 == a.end());
}

TEST(s21_set, find_2) {
  s21::s21_set<int> a{1, 2, 3};
  auto it1 = a.find(1);
  auto it2 = a.find(2);
  auto it3 = a.find(3);
  EXPECT_EQ(*it1, 1);
  EXPECT_EQ(*it2, 2);
  EXPECT_EQ(*it3, 3);
}

TEST(s21_set, operator_copy_1) {
  s21::s21_set<int> a{4, 2, 6, 1, 3, 5, 7};
  s21::s21_set<int> b;
  b = a;
  EXPECT_EQ(4, *b.find(4));
  EXPECT_EQ(2, *b.find(2));
  EXPECT_EQ(6, *b.find(6));
  EXPECT_EQ(1, *b.find(1));
  EXPECT_EQ(3, *b.find(3));
  EXPECT_EQ(5, *b.find(5));
  EXPECT_EQ(7, *b.find(7));
}

TEST(s21_set, operator_copy_2) {
  s21::s21_set<int> a{1, 2, 3};
  a = a;
  EXPECT_EQ(3, a.size());
  EXPECT_EQ(1, *a.find(1));
  EXPECT_EQ(2, *a.find(2));
  EXPECT_EQ(3, *a.find(3));
}

TEST(s21_set, operator_move_1) {
  s21::s21_set<int> a{1, 2, 3};
  s21::s21_set<int> b;
  b = std::move(a);
  EXPECT_EQ(true, a.empty());
  EXPECT_EQ(3, b.size());
  EXPECT_EQ(1, *b.find(1));
  EXPECT_EQ(2, *b.find(2));
  EXPECT_EQ(3, *b.find(3));
}

TEST(s21_set, operator_move_2) {
  s21::s21_set<int> a{1, 2, 3};
  a = std::move(a);
  EXPECT_EQ(3, a.size());
  EXPECT_EQ(1, *a.find(1));
  EXPECT_EQ(2, *a.find(2));
  EXPECT_EQ(3, *a.find(3));
}

TEST(s21_set, max_size_1) {
  s21::s21_set<int> a{1, 2, 3};
  EXPECT_LE(3, a.max_size());
}

TEST(s21_set, operator_pp_1) {
  s21::s21_set<int> a;
  a.insert(1);
  a.insert(2);
  a.insert(3);
  auto it = a.begin();
  ++it;
  ++it;
  EXPECT_EQ(it.m_node->key, 3);
}

TEST(s21_set, operator_pp_2) {
  s21::s21_set<int> a;
  a.insert(2);
  a.insert(1);
  a.insert(3);
  auto it = a.begin();
  ++it;
  ++it;
  EXPECT_EQ(it.m_node->key, 3);
}

TEST(s21_set, operator_mm_1) {
  s21::s21_set<int> a;
  a.insert(1);
  a.insert(2);
  a.insert(3);
  auto it = a.begin();
  ++it;
  ++it;
  --it;
  EXPECT_EQ(it.m_node->key, 2);
}

TEST(s21_set, operator_mm_2) {
  s21::s21_set<int> a;
  a.insert(2);
  a.insert(1);
  a.insert(3);
  auto it = a.begin();
  ++it;
  ++it;
  --it;
  EXPECT_EQ(it.m_node->key, 2);
}

TEST(s21_set, operator_mm_3) {
  s21::s21_set<int> a;
  a.insert(2);
  a.insert(1);
  a.insert(3);
  auto it = a.begin();
  ++it;
  ++it;
  --it;
  --it;
  EXPECT_EQ(it.m_node->key, 1);
}

TEST(s21_set, insert_many_empty) {
  s21::s21_set<int> map;
  auto result = map.insert_many();
  EXPECT_EQ(result.size(), 0);
}
TEST(s21_set, insert_many_1) {
  s21::s21_set<int> a;
  auto result = a.insert_many(5);
  EXPECT_EQ(result.size(), 1);
  EXPECT_EQ(result[0].second, true);
  EXPECT_EQ(a.size(), 1);
}
TEST(s21_set, insert_many_2) {
  s21::s21_set<int> a;
  auto result = a.insert_many(5, 3);
  EXPECT_EQ(result.size(), 2);
  EXPECT_EQ(result[0].second, true);
  EXPECT_EQ(result[1].second, true);
  EXPECT_EQ(a.size(), 2);
}
TEST(s21_set, insert_many_3) {
  s21::s21_set<int> a;
  a.insert(5);
  auto result = a.insert_many(5);
  EXPECT_EQ(result.size(), 1);
  EXPECT_EQ(result[0].second, false);
  EXPECT_EQ(a.size(), 1);
}