dynamic_array_prj/dynamic_array_test.cpp - main - dolpement/OOP

dynamic_array_prj/dynamic_array_test.cpp
336 строк8 KB
dolpement
OOP
16 июл 2025, 15:40
16 июл 2025, 15:40d149512
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include <dynamic_array.hpp>
#include "doctest.h"
#include <stdexcept>

TEST_CASE("Dinamic Array constructor") {
    DynamicArray arr(5, 10);
    CHECK(arr.Size() == 5);
    CHECK(arr.Capacity() == 5);
    for (int i = 0; i<arr.Size(); ++i) {
        CHECK(arr[i] == 10);
    }

}

TEST_CASE("Dinamic Array initializer list") {
    DynamicArray arr2 = {1, 2, 3, 4, 5};
    CHECK(arr2.Size() == 5);
    CHECK(arr2.Capacity() == 5);
    for (int i = 0; i < arr2.Size(); ++i) {
        CHECK (arr2[i] == i+1);
    }
}

TEST_CASE("Dinamic Array copy") {
    DynamicArray arr2 = {1, 2, 3, 4, 5};
    DynamicArray arr3 = arr2;
    CHECK (arr2.Size() == arr3.Size());
    CHECK (arr2.Capacity() == arr3.Capacity());
    for (int i = 0; i < arr2.Size(); i++) {
        CHECK (arr2[i] == arr3[i]);
    }
}

TEST_CASE("Dinamic Array empty") {
    DynamicArray arr = {1, 2, 3};
    DynamicArray arr2 = {};

    CHECK (arr.empty() == false);
    CHECK (arr2.empty() == true);
}

TEST_CASE("Dinamic Array push and pop back") {
    DynamicArray arr = {1, 2, 3, 4, 5};
    CHECK (arr.Size() == 5);
    arr.push_back(1);
    CHECK (arr.Size() == 6);
    arr.pop_back();
    CHECK (arr.Size() == 5);
    CHECK (arr[4] == 5);


    DynamicArray arr2 = {0};
    CHECK (arr2.Size() == 1);
    arr2.push_back (3);
    CHECK (arr2.Size() == 2);
    CHECK (arr2[1] == 3);
    arr2.pop_back();
    CHECK (arr2.Size() == 1);
    CHECK (arr2.empty() == false);
}

TEST_CASE("Dinamic Array clear") {
    DynamicArray arr1 = {1, 2, 3};
    DynamicArray arr2 = {};
    arr1.clear();
    CHECK (arr1.Size() == 0);
    arr2.clear();
    CHECK (arr2.Size() == 0);
}

TEST_CASE("Dinamic Array erase, resize, assign, insert") {
    DynamicArray arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
    arr.erase(3);
    CHECK (arr[3] == 5);
    CHECK (arr.Size() == 8);
    
    arr.resize(5);
    CHECK(arr.Size() == 5);
    
    arr.assign(7, 3);
    for (int i = 0; i<arr.Size(); i++) {
        CHECK (arr[i] == 3);
    }

    arr.insert(4, 6);
    CHECK (arr[4] == 6);
    CHECK (arr.Size() == 8);
    CHECK (arr[5] == 3);
}

TEST_CASE("Dinamic Array swap, operator=, operator==, operator!=") {
    DynamicArray arr1 = {1, 2, 3};
    DynamicArray arr2 = {4, 5, 6, 7};
    arr1.swap(arr2);
    CHECK (arr1.Size() == 4);
    CHECK (arr2.Size() == 3);
    for (int i = 0; i < arr1.Size(); i++) {
        CHECK (arr1[i] == i+4);
    }
    for (int i = 0; i < arr2.Size(); i++) {
        CHECK (arr2[i] == i+1);
    }

    arr1 = arr2;
    CHECK (arr1.Size() == arr2.Size());
    for (int i = 0; i<arr1.Size(); i++) {
        CHECK (arr1[i] == arr2[i]);
    }

    DynamicArray arr3 = {4, 5, 6};
    CHECK (arr1 == arr2);
    CHECK (arr1 != arr3);
    CHECK (arr2 != arr3);
}


TEST_CASE("Testing constructors") {
    SUBCASE("Default constructor") {
        DynamicArray arr;
        CHECK(arr.Size() == 0);
        CHECK(arr.Capacity() == 0);
        CHECK(arr.empty() == true);
    }

    SUBCASE("Constructor with size and value") {
        DynamicArray arr(5, 10);
        CHECK(arr.Size() == 5);
        CHECK(arr.Capacity() >= 5);
        CHECK(arr[0] == 10);
        CHECK(arr[4] == 10);
    }

    SUBCASE("Constructor with initializer list") {
        DynamicArray arr = {1, 2, 3, 4, 5};
        CHECK(arr.Size() == 5);
        CHECK(arr[0] == 1);
        CHECK(arr[4] == 5);
    }

    SUBCASE("Copy constructor") {
        DynamicArray arr1 = {1, 2, 3};
        DynamicArray arr2(arr1);
        CHECK(arr2.Size() == 3);
        CHECK(arr2[0] == 1);
        CHECK(arr2[2] == 3);
    }
}

TEST_CASE("Testing push_back and pop_back") {
    DynamicArray arr;

    SUBCASE("Push back elements") {
        arr.push_back(10);
        arr.push_back(20);
        arr.push_back(30);

        CHECK(arr.Size() == 3);
        CHECK(arr[0] == 10);
        CHECK(arr[2] == 30);
    }

    SUBCASE("Pop back elements") {
        arr.push_back(10);
        arr.push_back(20);
        arr.pop_back();

        CHECK(arr.Size() == 1);
        CHECK(arr[0] == 10);
    }

    SUBCASE("Pop back from empty array") {
        CHECK_THROWS_AS(arr.pop_back(), std::out_of_range);
    }
}

TEST_CASE("Testing size, capacity, and empty") {
    DynamicArray arr;

    SUBCASE("Empty array") {
        CHECK(arr.Size() == 0);
        CHECK(arr.Capacity() == 0);
        CHECK(arr.empty() == true);
    }

    SUBCASE("Non-empty array") {
        arr.push_back(10);
        arr.push_back(20);

        CHECK(arr.Size() == 2);
        CHECK(arr.Capacity() >= 2);
        CHECK(arr.empty() == false);
    }
}

TEST_CASE("Testing operator[] and at") {
    DynamicArray arr = {1, 2, 3};

    SUBCASE("Access elements with operator[]") {
        CHECK(arr[0] == 1);
        CHECK(arr[2] == 3);
    }

    SUBCASE("Access elements with at") {
        CHECK(arr.at(0) == 1);
        CHECK(arr.at(2) == 3);
    }

    SUBCASE("Out of bounds access with at") {
        CHECK_THROWS_AS(arr.at(3), std::out_of_range);
    }
}

TEST_CASE("Testing insert and erase") {
    DynamicArray arr = {1, 2, 3};

    SUBCASE("Insert element at position") {
        arr.insert(1, 10);
        CHECK(arr.Size() == 4);
        CHECK(arr[1] == 10);
        CHECK(arr[2] == 2);
    }

    SUBCASE("Erase element at position") {
        arr.erase(1);
        CHECK(arr.Size() == 2);
        CHECK(arr[1] == 3);
    }

    SUBCASE("Erase out of bounds") {
        CHECK_THROWS_AS(arr.erase(3), std::out_of_range);
    }
}

TEST_CASE("Testing resize and assign") {
    DynamicArray arr = {1, 2, 3};

    SUBCASE("Resize to larger size") {
        arr.resize(5);
        CHECK(arr.Size() == 5);
        CHECK(arr[3] == 0);
        CHECK(arr[4] == 0);
    }

    SUBCASE("Resize to smaller size") {
        arr.resize(1);
        CHECK(arr.Size() == 1);
        CHECK(arr[0] == 1);
    }

    SUBCASE("Assign new values") {
        arr.assign(5, 20);
        CHECK(arr.Size() == 5);
        CHECK(arr[0] == 20);
        CHECK(arr[4] == 20);
    }
}

TEST_CASE("Testing swap") {
    DynamicArray arr1 = {1, 2, 3};
    DynamicArray arr2 = {4, 5};

    arr1.swap(arr2);

    CHECK(arr1.Size() == 2);
    CHECK(arr1[0] == 4);
    CHECK(arr2.Size() == 3);
    CHECK(arr2[0] == 1);
}

TEST_CASE("Testing operators ==, !=, and =") {
    DynamicArray arr1 = {1, 2, 3};
    DynamicArray arr2 = {1, 2, 3};
    DynamicArray arr3 = {4, 5};

    SUBCASE("Operator ==") {
        CHECK(arr1 == arr2);
        CHECK_FALSE(arr1 == arr3);
    }

    SUBCASE("Operator !=") {
        CHECK(arr1 != arr3);
        CHECK_FALSE(arr1 != arr2);
    }

    SUBCASE("Operator =") {
        DynamicArray arr4;
        arr4 = arr1;
        CHECK(arr4 == arr1);
    }
}

TEST_CASE("Testing insert method") {
    DynamicArray arr = {1, 2, 3};

    SUBCASE("Insert element at position") {
        arr.insert(1, 10);
        CHECK(arr.Size() == 4);
        CHECK(arr[0] == 1);
        CHECK(arr[1] == 10);
        CHECK(arr[2] == 2);
        CHECK(arr[3] == 3);
    }

    SUBCASE("Insert at the beginning") {
        arr.insert(0, 0);
        CHECK(arr.Size() == 4);
        CHECK(arr[0] == 0);
        CHECK(arr[1] == 1);
        CHECK(arr[2] == 2);
        CHECK(arr[3] == 3);
    }

    SUBCASE("Insert at the end") {
        arr.insert(3, 4);
        CHECK(arr.Size() == 4);
        CHECK(arr[0] == 1);
        CHECK(arr[1] == 2);
        CHECK(arr[2] == 3);
        CHECK(arr[3] == 4);
    }

    SUBCASE("Insert with resize") {
        for (int i = 0; i < 10; ++i) {
            arr.push_back(i);
        }
        arr.insert(5, 100);
        CHECK(arr.Size() == 14);
        CHECK(arr[5] == 100);
    }

    SUBCASE("Insert out of bounds") {
        CHECK_THROWS_AS(arr.insert(-1, 10), std::out_of_range);
        CHECK_THROWS_AS(arr.insert(15, 10), std::out_of_range);
    }
}