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

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

using namespace s21;

TEST(List, Constructor_Default) {
  s21_list<int> s21_list;
  std::list<int> std_list;
  EXPECT_EQ(s21_list.empty(), std_list.empty());
  EXPECT_EQ(s21_list.size(), std_list.size());
}

TEST(List, Constructor_Size) {
  s21_list<int> s21_list(4);
  std::list<int> std_list(4);
  EXPECT_EQ(s21_list.size(), std_list.size());
}

TEST(List, Constructor_Copy) {
  s21_list<int> our_list({1, 2, 3});
  std::list<int> std_list({1, 2, 3});
  s21_list<int> our_copy(our_list);
  std::list<int> std_copy(std_list);
  EXPECT_EQ(our_copy.size(), std_copy.size());
  EXPECT_EQ(our_copy.front(), std_copy.front());
  EXPECT_EQ(our_copy.back(), std_copy.back());
}

TEST(List, Operator_Copy) {
  s21_list<int> our_list({1, 2, 3});
  std::list<int> std_list({1, 2, 3});
  s21_list<int> our_copy;
  our_copy = our_list;
  std::list<int> std_copy;
  std_copy = std_list;
  EXPECT_EQ(our_copy.front(), std_copy.front());
  EXPECT_EQ(our_copy.back(), std_copy.back());
}

TEST(List, Constructor_List) {
  s21_list<int> our_list({1, 2, 3});
  std::list<int> std_list({1, 2, 3});
  EXPECT_EQ(our_list.front(), std_list.front());
  EXPECT_EQ(our_list.back(), std_list.back());
}

TEST(List, Constructor_Move) {
  s21_list<int> our_list({1, 2, 3});
  std::list<int> std_list({1, 2, 3});
  s21_list<int> our_copy(std::move(our_list));
  std::list<int> std_copy(std::move(std_list));
  EXPECT_EQ(our_copy.front(), std_copy.front());
  EXPECT_EQ(our_copy.back(), std_copy.back());
  EXPECT_EQ(our_list.empty(), std_list.empty());
}

TEST(List, Operator_Move) {
  s21_list<int> our_list({1, 2, 3});
  std::list<int> std_list({1, 2, 3});
  s21_list<int> our_copy;
  our_copy = std::move(our_list);
  std::list<int> std_copy;
  std_copy = std::move(std_list);
  EXPECT_EQ(our_copy.front(), std_copy.front());
  EXPECT_EQ(our_copy.back(), std_copy.back());
  EXPECT_EQ(our_list.empty(), std_list.empty());
}

TEST(List, Size) {
  s21_list<int> our_list({1, 2, 3});
  std::list<int> std_list({1, 2, 3});
  EXPECT_EQ(our_list.size(), std_list.size());
}

TEST(List, Push_Front) {
  s21_list<int> our_list;
  std::list<int> std_list;
  our_list.push_front(1);
  std_list.push_front(1);
  EXPECT_EQ(our_list.front(), std_list.front());
  EXPECT_EQ(our_list.back(), std_list.back());
  our_list.push_front(2);
  std_list.push_front(2);
  EXPECT_EQ(our_list.front(), std_list.front());
  EXPECT_EQ(our_list.back(), std_list.back());
  our_list.push_front(3);
  std_list.push_front(3);
  EXPECT_EQ(our_list.front(), std_list.front());
  EXPECT_EQ(our_list.back(), std_list.back());
}

TEST(List, Push_Back) {
  s21_list<int> our_list;
  std::list<int> std_list;
  our_list.push_back(1);
  std_list.push_back(1);
  EXPECT_EQ(our_list.front(), std_list.front());
  EXPECT_EQ(our_list.back(), std_list.back());
  our_list.push_back(2);
  std_list.push_back(2);
  EXPECT_EQ(our_list.front(), std_list.front());
  EXPECT_EQ(our_list.back(), std_list.back());
  our_list.push_back(3);
  std_list.push_back(3);
  EXPECT_EQ(our_list.front(), std_list.front());
  EXPECT_EQ(our_list.back(), std_list.back());
}

TEST(List, Pop_Front) {
  s21_list<int> our_list;
  std::list<int> std_list;
  our_list.push_back(1);
  std_list.push_back(1);
  EXPECT_EQ(our_list.front(), std_list.front());
  EXPECT_EQ(our_list.back(), std_list.back());
  our_list.push_back(2);
  std_list.push_back(2);
  EXPECT_EQ(our_list.front(), std_list.front());
  EXPECT_EQ(our_list.back(), std_list.back());
  our_list.push_back(3);
  std_list.push_back(3);
  EXPECT_EQ(our_list.front(), std_list.front());
  EXPECT_EQ(our_list.back(), std_list.back());
  our_list.pop_front();
  std_list.pop_front();
  EXPECT_EQ(our_list.front(), std_list.front());
  EXPECT_EQ(our_list.back(), std_list.back());
}

TEST(List, Pop_Back) {
  s21_list<int> our_list;
  std::list<int> std_list;
  our_list.push_back(1);
  std_list.push_back(1);
  EXPECT_EQ(our_list.front(), std_list.front());
  EXPECT_EQ(our_list.back(), std_list.back());
  our_list.push_back(2);
  std_list.push_back(2);
  EXPECT_EQ(our_list.front(), std_list.front());
  EXPECT_EQ(our_list.back(), std_list.back());
  our_list.push_back(3);
  std_list.push_back(3);
  EXPECT_EQ(our_list.front(), std_list.front());
  EXPECT_EQ(our_list.back(), std_list.back());
  our_list.pop_back();
  std_list.pop_back();
  EXPECT_EQ(our_list.front(), std_list.front());
  EXPECT_EQ(our_list.back(), std_list.back());
}

TEST(List, MaxSize) {
  s21_list<int> l1({1, 2, 3, 4, 5});
  std::list<int> l2({1, 2, 3, 4, 5});
  EXPECT_EQ(l1.max_size(), l2.max_size());
}

TEST(List, Iterator_Begin) {
  s21_list<int> our_list({1, 2, 3});
  std::list<int> std_list({1, 2, 3});
  s21_list<int>::iterator our_it;
  our_it = our_list.begin();
  std::list<int>::iterator std_it;
  std_it = std_list.begin();
  EXPECT_EQ(*our_it, *std_it);
}

TEST(List, Iterator_BeginPlusAndMinus) {
  s21_list<int> our_list({1, 2, 3});
  std::list<int> std_list({1, 2, 3});
  s21_list<int>::iterator our_it;
  our_it = our_list.begin();
  ++our_it;
  std::list<int>::iterator std_it;
  std_it = std_list.begin();
  ++std_it;
  EXPECT_EQ(*our_it, *std_it);
  --our_it;
  --std_it;
  EXPECT_EQ(*our_it, *std_it);
}

TEST(List, Iterator_End_Last) {
  s21_list<int> our_list({1, 2, 3});
  std::list<int> std_list({1, 2, 3});
  s21_list<int>::iterator our_it;
  our_it = our_list.end();
  --our_it;
  std::list<int>::iterator std_it;
  std_it = std_list.end();
  --std_it;
  EXPECT_EQ(*our_it, *std_it);
}

TEST(List, Iterator_Equals) {
  s21_list<int> first_list({1, 2, 3});
  s21_list<int>::iterator our_it_first;
  our_it_first = first_list.begin();
  s21_list<int>::iterator our_it_second;
  our_it_second = first_list.begin();
  EXPECT_TRUE(our_it_first == our_it_second);
  ++our_it_second;
  EXPECT_TRUE(our_it_first != our_it_second);
}

TEST(List, Insert) {
  s21_list<int> our_list(1);
  std::list<int> std_list(1);
  s21_list<int>::iterator our_it;
  our_it = our_list.begin();
  std::list<int>::iterator std_it;
  std_it = std_list.begin();
  our_list.insert(our_it, 5);
  std_list.insert(std_it, 5);
  EXPECT_EQ(our_list.front(), std_list.front());
  EXPECT_EQ(our_list.back(), std_list.back());
  our_list.insert(our_it, 7);
  std_list.insert(std_it, 7);
  our_list.insert(our_it, 9);
  std_list.insert(std_it, 9);
  EXPECT_EQ(our_list.front(), std_list.front());
  EXPECT_EQ(our_list.back(), std_list.back());
}

TEST(List, Erase) {
  s21_list<int> our_list({1, 2, 3, 4, 5});
  std::list<int> std_list({1, 2, 3, 4, 5});
  our_list.erase(our_list.begin());
  std_list.erase(std_list.begin());
  EXPECT_EQ(our_list.front(), std_list.front());
  EXPECT_EQ(our_list.back(), std_list.back());
  s21_list<int>::iterator our_it;
  our_it = our_list.begin();
  ++our_it;
  std::list<int>::iterator std_it;
  std_it = std_list.begin();
  ++std_it;
  EXPECT_EQ(our_list.front(), std_list.front());
  EXPECT_EQ(our_list.back(), std_list.back());
}

TEST(List, SwapTest) {
  s21_list<double> list1{1.1, 2.2, 3.3};
  s21_list<double> list2{4.0, 5.5};

  s21_list<double> orig_list1 = list1;
  s21_list<double> orig_list2 = list2;

  list1.swap(list2);

  EXPECT_EQ(list1.size(), 2);
  EXPECT_EQ(list1.front(), 4.0);
  EXPECT_EQ(list1.back(), 5.5);

  EXPECT_EQ(list2.size(), 3);
  EXPECT_EQ(list2.front(), 1.1);
  EXPECT_EQ(list2.back(), 3.3);
}

TEST(List, Sort) {
  s21_list<int> our_list({2, 4, 1, 3, 5});
  std::list<int> std_list({2, 4, 1, 3, 5});
  s21_list<int>::iterator our_it;
  std::list<int>::iterator std_it;
  our_list.sort();
  std_list.sort();
  our_it = our_list.begin();
  std_it = std_list.begin();
  EXPECT_EQ(*our_it, *std_it);
  ++our_it;
  ++std_it;
  EXPECT_EQ(*our_it, *std_it);
  ++our_it;
  ++std_it;
  EXPECT_EQ(*our_it, *std_it);
  ++our_it;
  ++std_it;
  EXPECT_EQ(*our_it, *std_it);
  ++our_it;
  ++std_it;
  EXPECT_EQ(*our_it, *std_it);
}

TEST(List, Unique) {
  s21_list<int> our_list({1, 2, 2, 3, 3});
  std::list<int> std_list({1, 2, 2, 3, 3});
  s21_list<int>::iterator our_it;
  std::list<int>::iterator std_it;
  our_list.unique();
  std_list.unique();
  our_it = our_list.begin();
  std_it = std_list.begin();
  EXPECT_EQ(*our_it, *std_it);
  ++our_it;
  ++std_it;
  EXPECT_EQ(*our_it, *std_it);
  ++our_it;
  ++std_it;
  EXPECT_EQ(*our_it, *std_it);
}

TEST(List, Reverse) {
  s21_list<int> our_list({1, 2, 3, 4, 5});
  std::list<int> std_list({1, 2, 3, 4, 5});
  our_list.reverse();
  std_list.reverse();
  EXPECT_EQ(our_list.front(), std_list.front());
  EXPECT_EQ(our_list.back(), std_list.back());
}

TEST(List, Splice) {
  s21_list<int> our_list_first({1});
  s21_list<int> our_list_second({2, 3, 4, 5});

  std::list<int> std_list_first({1});
  std::list<int> std_list_second({2, 3, 4, 5});

  s21_list<int>::iterator our_it = our_list_first.begin();
  std::list<int>::iterator std_it = std_list_first.begin();

  our_list_first.splice(our_it, our_list_second);
  std_list_first.splice(std_it, std_list_second);
  EXPECT_EQ(our_list_first.front(), std_list_first.front());
  EXPECT_EQ(our_list_first.back(), std_list_first.back());
}

TEST(List, Insert_Many) {
  s21_list<int> our_list({1, 2, 3, 4, 5});
  s21_list<int>::const_iterator our_it = our_list.begin();
  ++our_it;
  our_list.insert_many(our_it, 7, 8, 9);
  s21_list<int>::iterator our_it2 = our_list.begin();
  EXPECT_EQ(*our_it2, 1);
  ++our_it2;
  EXPECT_EQ(*our_it2, 7);
  ++our_it2;
  EXPECT_EQ(*our_it2, 8);
  ++our_it2;
  EXPECT_EQ(*our_it2, 9);
  ++our_it2;
  EXPECT_EQ(*our_it2, 2);
}

TEST(List, Insert_Many_Back) {
  s21_list<int> our_list({1, 2, 3, 4, 5});
  s21_list<int>::iterator our_it;
  our_list.insert_many_back(7, 8, 9);
  our_it = our_list.end();
  --our_it;
  EXPECT_EQ(*our_it, 9);
  --our_it;
  EXPECT_EQ(*our_it, 8);
  --our_it;
  EXPECT_EQ(*our_it, 7);
  --our_it;
  EXPECT_EQ(*our_it, 5);
  --our_it;
  EXPECT_EQ(*our_it, 4);
}

TEST(List, Insert_Many_Front) {
  s21_list<int> our_list({1, 2, 3, 4, 5});
  s21_list<int>::iterator our_it;
  our_list.insert_many_front(7, 8, 9);
  our_it = our_list.begin();
  EXPECT_EQ(*our_it, 9);
  ++our_it;
  EXPECT_EQ(*our_it, 8);
  ++our_it;
  EXPECT_EQ(*our_it, 7);
  ++our_it;
  EXPECT_EQ(*our_it, 1);
  ++our_it;
  EXPECT_EQ(*our_it, 2);
}