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

src/tests/test_s21_queue.cpp
547 строк15 KB
moshedur
master: release 1.0
04 янв 2025, 23:35
04 янв 2025, 23:351c45f0a
#include <queue>

#include "test_s21.h"

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

TEST(s21_queue, def_constructor_2) {
  s21::s21_queue<int> our_queue;
  std::queue<int> std_queue;
  EXPECT_EQ(our_queue.empty(), std_queue.empty());
}

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

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

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

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

TEST(s21_queue, init_list_constructor_5) {
  s21::s21_queue<int> our_queue = {1, 2, 3};
  std::queue<int> std_queue;
  std_queue.push(1);
  std_queue.push(2);
  std_queue.push(3);
  EXPECT_EQ(our_queue.front(), std_queue.front());
  EXPECT_EQ(our_queue.back(), std_queue.back());
}

TEST(s21_queue, copy_constructor_1) {
  s21::s21_queue<int> our_queue = {1, 2, 3};
  s21::s21_queue<int> our_copy(our_queue);
  std::queue<int> std_queue;
  std_queue.push(1);
  std_queue.push(2);
  std_queue.push(3);
  std::queue<int> std_copy(std_queue);
  EXPECT_EQ(our_copy.front(), std_copy.front());
  EXPECT_EQ(our_copy.back(), std_copy.back());
  EXPECT_EQ(our_queue.empty(), std_queue.empty());
}

TEST(s21_queue, move_constructor_1) {
  s21::s21_queue<int> our_queue = {1, 2, 3};
  s21::s21_queue<int> our_move(std::move(our_queue));
  std::queue<int> std_queue;
  std_queue.push(1);
  std_queue.push(2);
  std_queue.push(3);
  std::queue<int> std_move(std::move(std_queue));
  EXPECT_EQ(our_move.front(), std_move.front());
  EXPECT_EQ(our_move.back(), std_move.back());
  EXPECT_EQ(our_queue.empty(), std_queue.empty());
}

TEST(s21_queue, Size) {
  s21::s21_queue<int> our_queue = {1, 2, 3};
  std::queue<int> std_queue;
  std_queue.push(1);
  std_queue.push(2);
  std_queue.push(3);
  EXPECT_EQ(our_queue.size(), std_queue.size());
  s21::s21_queue<int> our_queue_empty;
  std::queue<int> std_queue_empty;
  EXPECT_EQ(our_queue_empty.size(), std_queue_empty.size());
}

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

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

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

TEST(s21_queue, push_4) {
  s21::s21_queue<int> our_queue;
  our_queue.push(1);
  our_queue.push(2);
  our_queue.push(3);
  std::queue<int> std_queue;
  std_queue.push(1);
  std_queue.push(2);
  std_queue.push(3);
  EXPECT_EQ(our_queue.front(), std_queue.front());
  EXPECT_EQ(our_queue.back(), std_queue.back());
}

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

TEST(s21_queue, pop_2) {
  s21::s21_queue<int> our_queue;
  our_queue.push(1);
  our_queue.push(2);
  our_queue.push(3);
  our_queue.pop();
  std::queue<int> std_queue;
  std_queue.push(1);
  std_queue.push(2);
  std_queue.push(3);
  std_queue.pop();
  EXPECT_EQ(our_queue.front(), std_queue.front());
  EXPECT_EQ(our_queue.back(), std_queue.back());
  our_queue.pop();
  our_queue.pop();
  std_queue.pop();
  std_queue.pop();
  EXPECT_EQ(our_queue.empty(), std_queue.empty());
}

TEST(s21_queue, swap_1) {
  s21::s21_queue<int> a{1, 1};
  EXPECT_EQ(2, a.size());
  s21::s21_queue<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_queue, swap_2) {
  s21::s21_queue<int> our_queue = {1, 2, 3};
  std::queue<int> std_queue;
  std_queue.push(1);
  std_queue.push(2);
  std_queue.push(3);
  s21::s21_queue<int> our_queue_empty;
  std::queue<int> std_queue_empty;
  our_queue_empty.swap(our_queue);
  std_queue_empty.swap(std_queue);
  EXPECT_EQ(our_queue_empty.front(), std_queue_empty.front());
  EXPECT_EQ(our_queue_empty.back(), std_queue_empty.back());
  EXPECT_EQ(our_queue.empty(), std_queue.empty());
}

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

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

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

TEST(s21_queue, empty_4) {
  s21::s21_queue<int> our_queue = {1, 2, 3};
  std::queue<int> std_queue;
  std_queue.push(1);
  std_queue.push(2);
  std_queue.push(3);
  EXPECT_EQ(our_queue.empty(), std_queue.empty());
  s21::s21_queue<int> our_queue_empty;
  std::queue<int> std_queue_empty;
  EXPECT_EQ(our_queue_empty.empty(), std_queue_empty.empty());
}

TEST(s21_queue, front_1) {
  s21::s21_queue<int> our_queue = {1};
  std::queue<int> std_queue;
  std_queue.push(1);
  EXPECT_EQ(our_queue.front(), std_queue.front());
}

TEST(s21_queue, front_2) {
  s21::s21_queue<int> our_queue = {1, 2};
  std::queue<int> std_queue;
  std_queue.push(1);
  std_queue.push(2);
  EXPECT_EQ(our_queue.front(), std_queue.front());
}

TEST(s21_queue, front_3) {
  s21::s21_queue<int> our_queue = {1, 2, 3};
  std::queue<int> std_queue;
  std_queue.push(1);
  std_queue.push(2);
  std_queue.push(3);
  EXPECT_EQ(our_queue.front(), std_queue.front());
}

TEST(s21_queue, back_1) {
  s21::s21_queue<int> our_queue = {1};
  std::queue<int> std_queue;
  std_queue.push(1);
  EXPECT_EQ(our_queue.back(), std_queue.back());
}

TEST(s21_queue, back_2) {
  s21::s21_queue<int> our_queue = {1, 2};
  std::queue<int> std_queue;
  std_queue.push(1);
  std_queue.push(2);
  EXPECT_EQ(our_queue.back(), std_queue.back());
}

TEST(s21_queue, back_3) {
  s21::s21_queue<int> our_queue = {1, 2, 3};
  std::queue<int> std_queue;
  std_queue.push(1);
  std_queue.push(2);
  std_queue.push(3);
  EXPECT_EQ(our_queue.back(), std_queue.back());
}

TEST(s21_queue, copy_operator_1) {
  s21::s21_queue<int> our_queue = {1, 2, 3};
  std::queue<int> std_queue;
  std_queue.push(1);
  std_queue.push(2);
  std_queue.push(3);
  s21::s21_queue<int> our_queue_empty;
  std::queue<int> std_queue_empty;
  our_queue_empty = our_queue;
  std_queue_empty = std_queue;
  EXPECT_EQ(our_queue_empty.front(), std_queue_empty.front());
  EXPECT_EQ(our_queue_empty.back(), std_queue_empty.back());
  EXPECT_EQ(our_queue.empty(), std_queue.empty());
}

TEST(s21_queue, copy_operator_2) {
  s21::s21_queue<int> our_queue = {1, 2, 3};
  std::queue<int> std_queue;
  std_queue.push(1);
  std_queue.push(2);
  std_queue.push(3);
  our_queue = our_queue;
  std_queue = std_queue;
  EXPECT_EQ(our_queue.front(), std_queue.front());
  EXPECT_EQ(our_queue.back(), std_queue.back());
  EXPECT_EQ(our_queue.empty(), std_queue.empty());
}

TEST(s21_queue, copy_operator_3) {
  s21::s21_queue<int> our_queue = {1};
  std::queue<int> std_queue;
  std_queue.push(1);
  s21::s21_queue<int> our_queue_src = {2};
  std::queue<int> std_queue_src;
  std_queue_src.push(2);
  our_queue = our_queue_src;
  std_queue = std_queue_src;
  EXPECT_EQ(our_queue.front(), std_queue.front());
  EXPECT_EQ(our_queue.back(), std_queue.back());
  EXPECT_EQ(our_queue.empty(), std_queue.empty());
}

TEST(s21_queue, move_operator_1) {
  s21::s21_queue<int> our_queue = {1, 2, 3};
  std::queue<int> std_queue;
  std_queue.push(1);
  std_queue.push(2);
  std_queue.push(3);
  s21::s21_queue<int> our_queue_empty;
  std::queue<int> std_queue_empty;
  our_queue_empty = std::move(our_queue);
  std_queue_empty = std::move(std_queue);
  EXPECT_EQ(our_queue_empty.front(), std_queue_empty.front());
  EXPECT_EQ(our_queue_empty.back(), std_queue_empty.back());
  EXPECT_EQ(our_queue.empty(), std_queue.empty());
}

TEST(s21_queue, move_operator_2) {
  s21::s21_queue<int> our_queue = {1, 2, 3};
  std::queue<int> std_queue;
  std_queue.push(1);
  std_queue.push(2);
  std_queue.push(3);
  our_queue = std::move(our_queue);
  std_queue = std::move(std_queue);
  EXPECT_EQ(our_queue.front(), std_queue.front());
}

template <typename value_type>
bool compare_queues(s21::s21_queue<value_type> my_queue,
                    std::queue<value_type> std_queue) {
  bool result = true;
  if (my_queue.size() == std_queue.size()) {
    while (!my_queue.empty() && !std_queue.empty()) {
      if (my_queue.front() != std_queue.front()) {
        result = false;
        break;
      }
      my_queue.pop();
      std_queue.pop();
    }
  } else {
    result = false;
  }
  return result;
}

TEST(QueueTest, CompareQueues) {
  s21::s21_queue<int> my_queue{1, 3, 10, -5, 20};
  std::queue<int> std_queue;
  std_queue.push(1);
  std_queue.push(3);
  std_queue.push(10);
  std_queue.push(-5);
  std_queue.push(20);
  EXPECT_TRUE(compare_queues(my_queue, std_queue));
  std_queue.push(20);
  EXPECT_FALSE(compare_queues(my_queue, std_queue));
}

TEST(QueueTest, CompareQueues_2) {
  s21::s21_queue<int> my_queue{1, 3, 10, -5, 20};
  std::queue<int> std_queue;
  std_queue.push(1);
  std_queue.push(3);
  std_queue.push(10);
  std_queue.push(-5);
  std_queue.push(100);
  EXPECT_FALSE(compare_queues(my_queue, std_queue));
}

TEST(QueueTest, DefaultConstructor) {
  s21::s21_queue<int> my_queue;
  std::queue<int> std_queue;
  EXPECT_EQ(my_queue.size(), 0);
  EXPECT_TRUE(my_queue.empty());
  EXPECT_TRUE(compare_queues(my_queue, std_queue));
}

TEST(QueueTest, InitializerqueueConstructor) {
  s21::s21_queue<int> my_queue{1, 2, 3, 7, 9};
  std::initializer_list<int> il = {1, 2, 3, 7, 9};
  std::queue<int> std_queue{il};
  EXPECT_TRUE(compare_queues(my_queue, std_queue));
}

TEST(QueueTest, InitializerqueueConstructor_2) {
  std::initializer_list<int> b;
  s21::s21_queue<int> my_queue{b};
  std::queue<int> std_queue{b};
  EXPECT_TRUE(compare_queues(my_queue, std_queue));
}

TEST(QueueTest, CopyConstructor) {
  s21::s21_queue<int> my_queue{1, 2, 3, 7, 9};
  s21::s21_queue<int> my_queue_copy(my_queue);
  std::initializer_list<int> il = {1, 2, 3, 7, 9};
  std::queue<int> std_queue{il};
  std::queue<int> std_queue_copy(std_queue);
  EXPECT_TRUE(compare_queues(my_queue_copy, std_queue_copy));
}

TEST(QueueTest, CopyConstructorEmpty) {
  s21::s21_queue<int> my_queue;
  s21::s21_queue<int> my_queue_copy(my_queue);
  std::queue<int> std_queue;
  std::queue<int> std_queue_copy(std_queue);
  EXPECT_TRUE(compare_queues(my_queue_copy, std_queue_copy));
}

TEST(QueueTest, MoveConstructor) {
  s21::s21_queue<int> my_queue{1, 2, 3, 7, 20};
  s21::s21_queue<int> my_queue_copy(my_queue);
  s21::s21_queue<int> my_queue_move(std::move(my_queue));
  std::initializer_list<int> il = {1, 2, 3, 7, 20};
  std::queue<int> std_queue{il};
  std::queue<int> std_queue_copy(std_queue);
  std::queue<int> std_queue_move(std::move(std_queue));
  EXPECT_TRUE(compare_queues(my_queue_copy, std_queue_copy));
}

TEST(QueueTest, MoveConstructorEmpty) {
  s21::s21_queue<int> my_queue;
  s21::s21_queue<int> my_queue_copy(my_queue);
  s21::s21_queue<int> my_queue_move(std::move(my_queue));
  std::queue<int> std_queue;
  std::queue<int> std_queue_copy(std_queue);
  std::queue<int> std_queue_move(std::move(std_queue));
  EXPECT_TRUE(compare_queues(my_queue_copy, std_queue_copy));
}

TEST(QueueTest, MoveAssignmentOperator) {
  s21::s21_queue<int> my_queue{1, 2, 3, 7, 20};
  s21::s21_queue<int> my_queue_copy(my_queue);
  s21::s21_queue<int> my_queue_move = std::move(my_queue);
  std::initializer_list<int> il = {1, 2, 3, 7, 20};
  std::queue<int> std_queue{il};
  std::queue<int> std_queue_copy(std_queue);
  std::queue<int> std_queue_move = std::move(std_queue);
  EXPECT_TRUE(compare_queues(my_queue_move, std_queue_move));
}

TEST(QueueTest, MoveAssignmentOperatorEmpty) {
  s21::s21_queue<int> my_queue;
  s21::s21_queue<int> my_queue_copy(my_queue);
  s21::s21_queue<int> my_queue_move = std::move(my_queue);
  std::queue<int> std_queue;
  std::queue<int> std_queue_copy(std_queue);
  std::queue<int> std_queue_move = std::move(std_queue);
  EXPECT_TRUE(compare_queues(my_queue_move, std_queue_move));
}

TEST(QueueTest, Front) {
  s21::s21_queue<int> my_queue{99, 2, 3, 4, 5};
  std::initializer_list<int> il = {99, 1, 3, 7, 20};
  std::queue<int> std_queue{il};
  EXPECT_EQ(my_queue.front(), std_queue.front());
}

TEST(QueueTest, Back) {
  s21::s21_queue<int> my_queue{1, 2, 3, 3, 4, 99};
  std::initializer_list<int> il = {99, 1, 3, 5, 4, 7, 99};
  std::queue<int> std_queue{il};
  EXPECT_EQ(my_queue.back(), std_queue.back());
}

TEST(QueueTest, Empty) {
  s21::s21_queue<int> my_queue;
  std::queue<int> std_queue;
  EXPECT_EQ(my_queue.empty(), std_queue.empty());
  my_queue.push(2354);
  std_queue.push(2354);
  EXPECT_EQ(my_queue.empty(), std_queue.empty());
}

TEST(QueueTest, Size) {
  s21::s21_queue<int> my_queue{1, 2, 3, 4, 5, 6, 7, 8};
  std::initializer_list<int> il = {1, 2, 3, 4, 5, 6, 7, 8};
  std::queue<int> std_queue{il};
  EXPECT_EQ(my_queue.size(), std_queue.size());
}

TEST(QueueTest, Push) {
  s21::s21_queue<int> my_queue;
  std::queue<int> std_queue;
  my_queue.push(627);
  std_queue.push(627);
  my_queue.push(2354);
  std_queue.push(2354);
  EXPECT_TRUE(compare_queues(my_queue, std_queue));
}

TEST(QueueTest, Pop) {
  s21::s21_queue<int> my_queue{1, 2, 3, 4, 5, 6, 7, 8};
  std::initializer_list<int> il = {1, 2, 3, 4, 5, 6, 7, 8};
  std::queue<int> std_queue{il};
  my_queue.pop();
  my_queue.pop();
  std_queue.pop();
  std_queue.pop();
  EXPECT_TRUE(compare_queues(my_queue, std_queue));
  EXPECT_EQ(my_queue.front(), 3);
}

TEST(QueueTest, Swap) {
  s21::s21_queue<int> my_queue1{1, 2, 3, 4, 5};
  s21::s21_queue<int> my_queue2{6, 7, 8, 9, 10, 11};
  my_queue1.swap(my_queue2);

  std::initializer_list<int> il1 = {1, 2, 3, 4, 5};
  std::initializer_list<int> il2 = {6, 7, 8, 9, 10, 11};
  std::queue<int> std_queue1{il1};
  std::queue<int> std_queue2{il2};
  std_queue1.swap(std_queue2);

  EXPECT_TRUE(compare_queues(my_queue1, std_queue1));
  EXPECT_TRUE(compare_queues(my_queue2, std_queue2));
}

TEST(QueueTest, Swap_2) {
  s21::s21_queue<int> my_queue1{1, 2, 99, 4, 242};
  s21::s21_queue<int> my_queue2;
  my_queue1.swap(my_queue2);

  std::initializer_list<int> il = {1, 2, 99, 4, 242};
  std::queue<int> std_queue1{il};
  std::queue<int> std_queue2;
  std_queue1.swap(std_queue2);

  EXPECT_TRUE(compare_queues(my_queue1, std_queue1));
  EXPECT_TRUE(compare_queues(my_queue2, std_queue2));
}

TEST(s21_queue, insert_many_back_1) {
  s21::s21_queue<int> a({1, 2, 3, 4, 5});
  a.insert_many_back(7, 8, 9);
  EXPECT_EQ(8, a.size());
  EXPECT_EQ(1, a.front());
  EXPECT_EQ(9, a.back());
}

TEST(s21_queue, insert_many_back_2) {
  s21::s21_queue<int> a({1});
  a.insert_many_back(2, 3);
  EXPECT_EQ(3, a.size());
  EXPECT_EQ(1, a.front());
  EXPECT_EQ(3, a.back());
}
TEST(s21_queue, insert_many_back_3) {
  s21::s21_queue<int> a({1});
  a.insert_many_back(2, 3, 3, 2);
  EXPECT_EQ(5, a.size());
  EXPECT_EQ(1, a.front());
  EXPECT_EQ(2, a.back());
}
TEST(s21_queue, insert_many_back_4) {
  s21::s21_queue<int> a({1, 3, 2});
  a.insert_many_back(2, 3, 3, 2);
  EXPECT_EQ(7, a.size());
  EXPECT_EQ(1, a.front());
  EXPECT_EQ(2, a.back());
}