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

src/tests/test_s21_stack.cpp
573 строки14 KB
moshedur
master: release 1.0
04 янв 2025, 23:35
04 янв 2025, 23:351c45f0a
#include <stack>

#include "test_s21.h"

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

TEST(s21_stack, def_constructor_2) {
  s21::s21_stack<int> our_stack;
  std::stack<int> std_stack;
  EXPECT_EQ(our_stack.empty(), std_stack.empty());
}

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

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

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

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

TEST(s21_stack, init_list_constructor_5) {
  s21::s21_stack<int> our_stack = {1, 2, 3};
  std::stack<int> std_stack;
  std_stack.push(1);
  std_stack.push(2);
  std_stack.push(3);
  EXPECT_EQ(our_stack.top(), std_stack.top());
}

TEST(s21_stack, copy_constructor_1) {
  s21::s21_stack<int> our_stack = {1, 2, 3};
  s21::s21_stack<int> our_copy(our_stack);
  std::stack<int> std_stack;
  std_stack.push(1);
  std_stack.push(2);
  std_stack.push(3);
  std::stack<int> std_copy(std_stack);
  EXPECT_EQ(our_copy.top(), std_copy.top());
  EXPECT_EQ(our_stack.empty(), std_stack.empty());
}

TEST(s21_stack, move_constructor_1) {
  s21::s21_stack<int> our_stack = {1, 2, 3};
  s21::s21_stack<int> our_move(std::move(our_stack));
  std::stack<int> std_stack;
  std_stack.push(1);
  std_stack.push(2);
  std_stack.push(3);
  std::stack<int> std_move(std::move(std_stack));
  EXPECT_EQ(our_move.top(), std_move.top());
  EXPECT_EQ(our_stack.empty(), std_stack.empty());
}

TEST(s21_stack, Size) {
  s21::s21_stack<int> our_stack = {1, 2, 3};
  std::stack<int> std_stack;
  std_stack.push(1);
  std_stack.push(2);
  std_stack.push(3);
  EXPECT_EQ(our_stack.size(), std_stack.size());
  s21::s21_stack<int> our_stack_empty;
  std::stack<int> std_stack_empty;
  EXPECT_EQ(our_stack_empty.size(), std_stack_empty.size());
}

TEST(s21_stack, push_1) {
  s21::s21_stack<int> a;
  a.push(4);
  EXPECT_EQ(1, a.size());
}

TEST(s21_stack, push_2) {
  s21::s21_stack<int> a;
  a.push(4);
  a.push(2);
  EXPECT_EQ(2, a.size());
}

TEST(s21_stack, push_3) {
  s21::s21_stack<int> a;
  a.push(4);
  a.push(2);
  a.push(3);
  EXPECT_EQ(3, a.size());
}

TEST(s21_stack, push_4) {
  s21::s21_stack<int> our_stack;
  our_stack.push(1);
  our_stack.push(2);
  our_stack.push(3);
  std::stack<int> std_stack;
  std_stack.push(1);
  std_stack.push(2);
  std_stack.push(3);
  EXPECT_EQ(our_stack.top(), std_stack.top());
  EXPECT_EQ(our_stack.empty(), our_stack.empty());
}

TEST(s21_stack, pop_1) {
  s21::s21_stack<int> a;
  EXPECT_EQ(0, a.size());
  EXPECT_THROW(a.pop(), std::out_of_range);
}

TEST(s21_stack, pop_2) {
  s21::s21_stack<int> our_stack;
  our_stack.push(1);
  our_stack.push(2);
  our_stack.push(3);
  our_stack.pop();
  std::stack<int> std_stack;
  std_stack.push(1);
  std_stack.push(2);
  std_stack.push(3);
  std_stack.pop();
  EXPECT_EQ(our_stack.top(), std_stack.top());
  our_stack.pop();
  our_stack.pop();
  std_stack.pop();
  std_stack.pop();
  EXPECT_EQ(our_stack.empty(), std_stack.empty());
}

TEST(s21_stack, swap_1) {
  s21::s21_stack<int> a{1, 1};
  EXPECT_EQ(2, a.size());
  s21::s21_stack<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_stack, swap_2) {
  s21::s21_stack<int> our_stack = {1, 2, 3};
  std::stack<int> std_stack;
  std_stack.push(1);
  std_stack.push(2);
  std_stack.push(3);
  s21::s21_stack<int> our_stack_empty;
  std::stack<int> std_stack_empty;
  our_stack_empty.swap(our_stack);
  std_stack_empty.swap(std_stack);
  EXPECT_EQ(our_stack_empty.top(), std_stack_empty.top());
  EXPECT_EQ(our_stack.empty(), std_stack.empty());
}

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

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

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

TEST(s21_stack, empty_4) {
  s21::s21_stack<int> our_stack = {1, 2, 3};
  std::stack<int> std_stack;
  std_stack.push(1);
  std_stack.push(2);
  std_stack.push(3);
  EXPECT_EQ(our_stack.empty(), std_stack.empty());
  s21::s21_stack<int> our_stack_empty;
  std::stack<int> std_stack_empty;
  EXPECT_EQ(our_stack_empty.empty(), std_stack_empty.empty());
}

TEST(s21_stack, front_1) {
  s21::s21_stack<int> our_stack = {1};
  std::stack<int> std_stack;
  std_stack.push(1);
  EXPECT_EQ(our_stack.top(), std_stack.top());
}

TEST(s21_stack, front_2) {
  s21::s21_stack<int> our_stack = {1, 2};
  std::stack<int> std_stack;
  std_stack.push(1);
  std_stack.push(2);
  EXPECT_EQ(our_stack.top(), std_stack.top());
}

TEST(s21_stack, front_3) {
  s21::s21_stack<int> our_stack = {1, 2, 3};
  std::stack<int> std_stack;
  std_stack.push(1);
  std_stack.push(2);
  std_stack.push(3);
  EXPECT_EQ(our_stack.top(), std_stack.top());
}

TEST(s21_stack, back_1) {
  s21::s21_stack<int> our_stack = {1};
  std::stack<int> std_stack;
  std_stack.push(1);
  EXPECT_EQ(our_stack.top(), std_stack.top());
}

TEST(s21_stack, back_2) {
  s21::s21_stack<int> our_stack = {1, 2};
  std::stack<int> std_stack;
  std_stack.push(1);
  std_stack.push(2);
  EXPECT_EQ(our_stack.top(), std_stack.top());
}

TEST(s21_stack, back_3) {
  s21::s21_stack<int> our_stack = {1, 2, 3};
  std::stack<int> std_stack;
  std_stack.push(1);
  std_stack.push(2);
  std_stack.push(3);
  EXPECT_EQ(our_stack.top(), std_stack.top());
}

TEST(s21_stack, copy_operator_1) {
  s21::s21_stack<int> our_stack = {1, 2, 3};
  std::stack<int> std_stack;
  std_stack.push(1);
  std_stack.push(2);
  std_stack.push(3);
  s21::s21_stack<int> our_stack_empty;
  std::stack<int> std_stack_empty;
  our_stack_empty = our_stack;
  std_stack_empty = std_stack;
  EXPECT_EQ(our_stack_empty.top(), std_stack_empty.top());
  EXPECT_EQ(our_stack.empty(), std_stack.empty());
}

TEST(s21_stack, copy_operator_2) {
  s21::s21_stack<int> our_stack = {1, 2, 3};
  std::stack<int> std_stack;
  std_stack.push(1);
  std_stack.push(2);
  std_stack.push(3);
  our_stack = our_stack;
  std_stack = std_stack;
  EXPECT_EQ(our_stack.top(), std_stack.top());
  EXPECT_EQ(our_stack.empty(), std_stack.empty());
}

TEST(s21_stack, copy_operator_3) {
  s21::s21_stack<int> our_stack = {1};
  std::stack<int> std_stack;
  std_stack.push(1);
  s21::s21_stack<int> our_stack_src = {2};
  std::stack<int> std_stack_src;
  std_stack_src.push(2);
  our_stack = our_stack_src;
  std_stack = std_stack_src;
  EXPECT_EQ(our_stack.top(), std_stack.top());
  EXPECT_EQ(our_stack.empty(), std_stack.empty());
}

TEST(s21_stack, move_operator_1) {
  s21::s21_stack<int> our_stack = {1, 2, 3};
  std::stack<int> std_stack;
  std_stack.push(1);
  std_stack.push(2);
  std_stack.push(3);
  s21::s21_stack<int> our_stack_empty;
  std::stack<int> std_stack_empty;
  our_stack_empty = std::move(our_stack);
  std_stack_empty = std::move(std_stack);
  EXPECT_EQ(our_stack_empty.top(), std_stack_empty.top());
  EXPECT_EQ(our_stack.empty(), std_stack.empty());
}

TEST(s21_stack, move_operator_2) {
  s21::s21_stack<int> our_stack = {1, 2, 3};
  std::stack<int> std_stack;
  std_stack.push(1);
  std_stack.push(2);
  std_stack.push(3);
  our_stack = std::move(our_stack);
  std_stack = std::move(std_stack);
}

TEST(StackTest, Constructor_default) {
  s21::s21_stack<int> s21_stack;
  std::stack<int> std_stack;
  EXPECT_EQ(s21_stack.size(), std_stack.size());
}

TEST(StackTest, Constructor_initializer_list_1) {
  s21::s21_stack<int> s21_stack{1, 2, 4};
  EXPECT_EQ(s21_stack.size(), 3);
  EXPECT_EQ(s21_stack.top(), 4);
}

TEST(StackTest, Constructor_initializer_list_2) {
  std::initializer_list<int> b;
  s21::s21_stack<int> s21_stack{b};
  std::stack<int> std_stack{b};
  EXPECT_EQ(s21_stack.size(), std_stack.size());
}

TEST(StackTest, Constructor_copy_1) {
  std::initializer_list<int> il1 = {1, 2, 3};

  s21::s21_stack<int> s21_stack{il1};
  s21::s21_stack<int> s21_stack_copy{s21_stack};
  std::stack<int> std_stack{il1};
  std::stack<int> std_stack_copy{std_stack};
  EXPECT_EQ(s21_stack_copy.size(), std_stack_copy.size());
  EXPECT_EQ(s21_stack_copy.top(), std_stack_copy.top());
}

TEST(StackTest, Constructor_move_1) {
  std::initializer_list<int> il1 = {1, 2, 3};

  s21::s21_stack<int> s21_stack{il1};
  s21::s21_stack<int> s21_stack_move{s21_stack};
  std::stack<int> std_stack{il1};
  std::stack<int> std_stack_move{std_stack};
  EXPECT_EQ(s21_stack_move.size(), std_stack_move.size());
  EXPECT_EQ(s21_stack_move.top(), std_stack_move.top());
}

TEST(StackTest, Opertator_move_3) {
  std::initializer_list<int> il1;
  std::initializer_list<int> il2 = {4, 5, 6, 7};

  s21::s21_stack<int> s21_stack{il1};
  s21::s21_stack<int> s21_stack_move{il2};
  s21_stack = std::move(s21_stack_move);

  std::stack<int> std_stack{il1};
  std::stack<int> std_stack_move{il2};
  std_stack = std::move(std_stack_move);

  EXPECT_EQ(s21_stack.size(), std_stack.size());
  EXPECT_EQ(s21_stack.top(), std_stack.top());
}

TEST(StackTest, Top_1) {
  std::initializer_list<int> il1 = {4, 5, 6, 7};

  s21::s21_stack<int> s21_stack{il1};

  std::stack<int> std_stack{il1};

  EXPECT_EQ(s21_stack.top(), std_stack.top());
}

TEST(StackTest, Top_2_throw) {
  std::initializer_list<int> il1;

  s21::s21_stack<int> s21_stack{il1};

  EXPECT_THROW(s21_stack.top(), std::out_of_range);
}

TEST(StackTest, Empty_1) {
  std::initializer_list<int> il1 = {4, 5, 6, 7};

  s21::s21_stack<int> s21_stack{il1};
  std::stack<int> std_stack{il1};

  EXPECT_EQ(s21_stack.empty(), std_stack.empty());
}

TEST(StackTest, Empty_2) {
  std::initializer_list<int> il1;

  s21::s21_stack<int> s21_stack{il1};
  std::stack<int> std_stack{il1};

  EXPECT_EQ(s21_stack.empty(), std_stack.empty());
}

TEST(StackTest, Size_1) {
  std::initializer_list<int> il1 = {4, 5, 6, 7};

  s21::s21_stack<int> s21_stack{il1};
  std::stack<int> std_stack{il1};

  EXPECT_EQ(s21_stack.size(), std_stack.size());
}

TEST(StackTest, Size_2) {
  std::initializer_list<int> il1 = {4, 5, 6, 7};

  s21::s21_stack<int> s21_stack{il1};
  std::stack<int> std_stack{il1};

  EXPECT_EQ(s21_stack.size(), std_stack.size());
}

TEST(StackTest, Push_1) {
  std::initializer_list<int> il1 = {4, 5, 6, 7};

  s21::s21_stack<int> s21_stack{il1};
  std::stack<int> std_stack{il1};
  s21_stack.push(1);
  std_stack.push(1);
  EXPECT_EQ(s21_stack.size(), std_stack.size());
  EXPECT_EQ(s21_stack.top(), std_stack.top());
}

TEST(StackTest, Push_2) {
  std::initializer_list<int> il1;

  s21::s21_stack<int> s21_stack{il1};
  std::stack<int> std_stack{il1};
  s21_stack.push(1);
  std_stack.push(1);
  EXPECT_EQ(s21_stack.size(), std_stack.size());
  EXPECT_EQ(s21_stack.top(), std_stack.top());
}

TEST(StackTest, Pop_1) {
  std::initializer_list<int> il1 = {4, 5, 6, 7};

  s21::s21_stack<int> s21_stack{il1};
  std::stack<int> std_stack{il1};
  s21_stack.pop();
  std_stack.pop();
  EXPECT_EQ(s21_stack.size(), std_stack.size());
  EXPECT_EQ(s21_stack.top(), std_stack.top());
}

TEST(StackTest, Swap_1) {
  std::initializer_list<int> il1 = {4, 5, 6, 7};
  std::initializer_list<int> il2 = {1, 2, 3};

  s21::s21_stack<int> s21_stack{il1};
  s21::s21_stack<int> s21_stack_swap{il2};
  std::stack<int> std_stack{il1};
  std::stack<int> std_stack_swap{il2};
  s21_stack.swap(s21_stack_swap);
  std_stack.swap(std_stack_swap);

  EXPECT_EQ(s21_stack.size(), std_stack.size());
  EXPECT_EQ(s21_stack.top(), std_stack.top());

  EXPECT_EQ(s21_stack_swap.size(), std_stack_swap.size());
  EXPECT_EQ(s21_stack_swap.top(), std_stack_swap.top());
}

TEST(StackTest, Swap_2) {
  std::initializer_list<int> il1 = {1, 2, 3};
  std::initializer_list<int> il2 = {4, 5, 6, 7};

  s21::s21_stack<int> s21_stack{il1};
  s21::s21_stack<int> s21_stack_swap{il2};
  std::stack<int> std_stack{il1};
  std::stack<int> std_stack_swap{il2};
  s21_stack.swap(s21_stack_swap);
  std_stack.swap(std_stack_swap);

  EXPECT_EQ(s21_stack.size(), std_stack.size());
  EXPECT_EQ(s21_stack.top(), std_stack.top());

  EXPECT_EQ(s21_stack_swap.size(), std_stack_swap.size());
  EXPECT_EQ(s21_stack_swap.top(), std_stack_swap.top());
}

TEST(StackTest, Swap_3) {
  std::initializer_list<int> il1 = {4, 5, 6, 7};
  std::initializer_list<int> il2;

  s21::s21_stack<int> s21_stack{il1};
  s21::s21_stack<int> s21_stack_swap{il2};
  std::stack<int> std_stack{il1};
  std::stack<int> std_stack_swap{il2};
  s21_stack.swap(s21_stack_swap);
  std_stack.swap(std_stack_swap);

  EXPECT_EQ(s21_stack.size(), std_stack.size());

  EXPECT_EQ(s21_stack_swap.size(), std_stack_swap.size());
}

TEST(StackTest, Swap_4) {
  std::initializer_list<int> il1;
  std::initializer_list<int> il2 = {4, 5, 6, 7};

  s21::s21_stack<int> s21_stack{il1};
  s21::s21_stack<int> s21_stack_swap{il2};
  std::stack<int> std_stack{il1};
  std::stack<int> std_stack_swap{il2};
  s21_stack.swap(s21_stack_swap);
  std_stack.swap(std_stack_swap);

  EXPECT_EQ(s21_stack.size(), std_stack.size());

  EXPECT_EQ(s21_stack_swap.size(), std_stack_swap.size());
}

TEST(StackTest, Swap_5) {
  std::initializer_list<int> il1;
  std::initializer_list<int> il2;

  s21::s21_stack<int> s21_stack{il1};
  s21::s21_stack<int> s21_stack_swap{il2};
  std::stack<int> std_stack{il1};
  std::stack<int> std_stack_swap{il2};
  s21_stack.swap(s21_stack_swap);
  std_stack.swap(std_stack_swap);

  EXPECT_EQ(s21_stack.size(), std_stack.size());

  EXPECT_EQ(s21_stack_swap.size(), std_stack_swap.size());
}

TEST(StackTest, Swap_6) {
  std::initializer_list<int> il1 = {4, 5, 6, 7};
  std::initializer_list<int> il2 = {4, 5, 6, 7};

  s21::s21_stack<int> s21_stack{il1};
  s21::s21_stack<int> s21_stack_swap{il2};
  std::stack<int> std_stack{il1};
  std::stack<int> std_stack_swap{il2};
  s21_stack.swap(s21_stack_swap);
  std_stack.swap(std_stack_swap);

  EXPECT_EQ(s21_stack.size(), std_stack.size());
  EXPECT_EQ(s21_stack.top(), std_stack.top());

  EXPECT_EQ(s21_stack_swap.size(), std_stack_swap.size());
  EXPECT_EQ(s21_stack_swap.top(), std_stack_swap.top());
}

TEST(s21_stack, insert_many_front_1) {
  s21::s21_stack<int> a({1, 2, 3, 4, 5});
  a.insert_many_front(7, 8, 9);
  EXPECT_EQ(8, a.size());
  EXPECT_EQ(9, a.top());
}

TEST(s21_stack, insert_many_front_2) {
  s21::s21_stack<int> a({1});
  a.insert_many_front(2, 3);
  EXPECT_EQ(3, a.size());
  EXPECT_EQ(3, a.top());
}
TEST(s21_stack, insert_many_front_3) {
  s21::s21_stack<int> a({1});
  a.insert_many_front(2, 3, 3, 2);
  EXPECT_EQ(5, a.size());
  EXPECT_EQ(2, a.top());
}
TEST(s21_stack, insert_many_front_4) {
  s21::s21_stack<int> a({1, 3, 2});
  a.insert_many_front(2, 3, 3, 2);
  EXPECT_EQ(2, a.top());
}