stack_array_t_prj/stack_array_t_test.cpp - main - dolpement/OOP

stack_array_t_prj/stack_array_t_test.cpp
102 строки3 KB
dolpement
OOP
16 июл 2025, 15:40
16 июл 2025, 15:40d149512
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "doctest.h"
#include "stack_array_t.hpp"

TEST_CASE("Testing StackArrT") {
    SUBCASE("Default constructor") {
        StackArrT<int> stack;
        CHECK(stack.empty());
        CHECK(stack.size() == 0);
    }

    SUBCASE("Initializer list constructor") {
        StackArrT<int> stack = {1, 2, 3};
        CHECK(stack.size() == 3);
        CHECK(stack.top() == 3);
    }

    SUBCASE("Push and top") {
        StackArrT<int> stack;
        stack.push(10);
        CHECK(stack.top() == 10);
        stack.push(20);
        CHECK(stack.top() == 20);
    }

    SUBCASE("Pop") {
        StackArrT<int> stack = {1, 2, 3};
        stack.pop();
        CHECK(stack.top() == 2);
        stack.pop();
        CHECK(stack.top() == 1);
        stack.pop();
        CHECK(stack.empty());
    }

    SUBCASE("Copy constructor") {
        StackArrT<int> original = {1, 2, 3};
        StackArrT<int> copy = original;
        CHECK(copy == original);
    }

    SUBCASE("Move constructor") {
        StackArrT<int> original = {1, 2, 3};
        StackArrT<int> moved = std::move(original);
        CHECK(moved.size() == 3);
        CHECK(original.empty());
    }

    SUBCASE("Assignment operator") {
        StackArrT<int> original = {1, 2, 3};
        StackArrT<int> copy;
        copy = original;
        CHECK(copy == original);
    }

    SUBCASE("Move assignment operator") {
        StackArrT<int> original = {1, 2, 3};
        StackArrT<int> moved;
        moved = std::move(original);
        CHECK(moved.size() == 3);
        CHECK(original.empty());
    }

    SUBCASE("Swap") {
        StackArrT<int> first = {1, 2};
        StackArrT<int> second = {3, 4, 5};
        first.swap(second);
        CHECK(first.size() == 3);
        CHECK(second.size() == 2);
    }

    SUBCASE("Merge") {
        StackArrT<int> first = {1, 2, 3, 4, 5, 6};
        StackArrT<int> second = {7, 8, 9};
        first.merge(second);
        CHECK(first.size() == 9);
        CHECK(second.empty());
        for (int i=first.size(); i>0; i--) {
            CHECK(first.top() == i);
            first.pop();
        }
        StackArrT<int> st_ar3 = {1, 2, 6};
        first.merge(st_ar3);
        CHECK(first.size() == 3);
        StackArrT<double> st1 = {};
        StackArrT<double> st2 = {1, 2, 3};
        st1.merge(st2);
        CHECK(st1.size() == 3);
        CHECK(st2.empty());
        StackArrT<double> st3 = {};
        st1.merge(st3);
        CHECK(st1.size() == 3);
    }

    SUBCASE("Equality and inequality") {
        StackArrT<int> first = {1, 2, 3};
        StackArrT<int> second = {1, 2, 3};
        StackArrT<int> third = {1, 2};
        CHECK(first == second);
        CHECK(first != third);
    }
}