stack_base_prj/stack_base_test.cpp - main - dolpement/OOP

stack_base_prj/stack_base_test.cpp
179 строк4 KB
dolpement
OOP
16 июл 2025, 15:40
16 июл 2025, 15:40d149512
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "doctest.h"
#include <sstream>
#include "stack_arr_t.hpp"
#include "stack_lst_t.hpp"

template <typename T>
void test_stack_implementation() {
    SUBCASE("Default constructor creates empty stack") {
        T stack;
        CHECK(stack.empty());
        CHECK(stack.size() == 0);
    }

    SUBCASE("Push increases size and top returns pushed value") {
        T stack;
        stack.push(42);
        CHECK_FALSE(stack.empty());
        CHECK(stack.size() == 1);
        CHECK(stack.top() == 42);

        stack.push(100);
        CHECK(stack.size() == 2);
        CHECK(stack.top() == 100);
    }

    SUBCASE("Pop decreases size") {
        T stack;
        stack.push(1);
        stack.push(2);
        
        stack.pop();
        CHECK(stack.size() == 1);
        CHECK(stack.top() == 1);

        stack.pop();
        CHECK(stack.empty());
        CHECK(stack.size() == 0);
    }

    SUBCASE("Top throws when stack is empty") {
        T stack;
        CHECK_THROWS_AS(stack.top(), std::out_of_range);
    }

    SUBCASE("Pop throws when stack is empty") {
        T stack;
        CHECK_THROWS_AS(stack.pop(), std::out_of_range);
    }

    SUBCASE("Initializer list constructor") {
        T stack{1, 2, 3, 4, 5};
        CHECK(stack.size() == 5);
        CHECK(stack.top() == 5);

        stack.pop();
        CHECK(stack.top() == 4);
    }

    SUBCASE("Copy constructor") {
        T original{1, 2, 3};
        T copy(original);

        CHECK(original.size() == 3);
        CHECK(copy.size() == 3);

        original.pop();
        CHECK(original.size() == 2);
        CHECK(copy.size() == 3);
    }

    SUBCASE("Move constructor") {
        T original{1, 2, 3};
        T moved(std::move(original));

        CHECK(moved.size() == 3);
        CHECK(original.empty());
    }

    SUBCASE("Copy assignment") {
        T original{1, 2, 3};
        T copy;
        copy = original;

        CHECK(original.size() == 3);
        CHECK(copy.size() == 3);

        original.pop();
        CHECK(original.size() == 2);
        CHECK(copy.size() == 3);
    }

    SUBCASE("Move assignment") {
        T original{1, 2, 3};
        T moved;
        moved = std::move(original);

        CHECK(moved.size() == 3);
        CHECK(original.empty());
    }

    SUBCASE("Swap") {
        T stack1{1, 2, 3};
        T stack2{4, 5, 6, 7};

        stack1.swap(stack2);

        CHECK(stack1.size() == 4);
        CHECK(stack1.top() == 7);
        CHECK(stack2.size() == 3);
        CHECK(stack2.top() == 3);
    }

    SUBCASE("Merge") {
        T stack1{1, 2, 3};
        T stack2{4, 5, 6};

        stack1.merge(stack2);

        CHECK(stack1.size() == 6);
        CHECK(stack1.top() == 6);
        CHECK(stack2.empty());
    }

    SUBCASE("Equality comparison") {
        T stack1{1, 2, 3};
        T stack2{1, 2, 3};
        T stack3{1, 2};

        CHECK(stack1 == stack2);
        CHECK_FALSE(stack1 == stack3);
    }

    SUBCASE("Inequality comparison") {
        T stack1{1, 2, 3};
        T stack2{1, 2, 3};
        T stack3{1, 2};

        CHECK(stack1 != stack3);
        CHECK_FALSE(stack1 != stack2);
    }

    SUBCASE("Output stream operator") {
        T stack{1, 2, 3};
        std::ostringstream oss;
        oss << stack;
        
        CHECK(oss.str() == "{ 1, 2, 3 }");
    }
}

TEST_CASE("Testing StackArrT<int>") {
    test_stack_implementation<StackArrT<int>>();
}

TEST_CASE("Testing StackLstT<int>") {
    test_stack_implementation<StackLstT<int>>();
}

TEST_CASE("Polymorphic behavior") {
    SUBCASE("Can use derived classes through base pointer") {
        IStackBase<int>* stack1 = new StackArrT<int>{1, 2, 3};
        IStackBase<int>* stack2 = new StackLstT<int>{4, 5, 6};

        CHECK(stack1->size() == 3);
        CHECK(stack2->size() == 3);

        stack1->push(100);
        CHECK(stack1->size() == 4);
        CHECK(stack1->top() == 100);

        stack2->pop();
        CHECK(stack2->size() == 2);
        CHECK(stack2->top() == 5);

        delete stack1;
        delete stack2;
    }
}