Tests for DoublyLinkedList

#include <iostream>
#include <unordered_set>
#include <vector>

using namespace std;

// -------- Шаблоны тестирующих функций ----------
#pragma region TEST_LIB

template<typename T, typename U>
void
AssertEqualImpl(const T &t, const U &u, const std::string &t_str, const std::string &u_str, const std::string &file,
                const std::string &func, unsigned line, const std::string &hint) {
    if (t != u) {
        std::cout << std::boolalpha;
        std::cout << file << "(" << line << "): " << func << ": ";
        std::cout << "ASSERT_EQUAL(" << t_str << ", " << u_str << ") failed: ";
        std::cout << t << " != " << u << ".";
        if (!hint.empty()) {
            std::cout << " Hint: " << hint;
        }
        std::cout << std::endl;
        abort();
    }
}

#define ASSERT_EQUAL(a, b) AssertEqualImpl((a), (b), #a, #b, __FILE__, __FUNCTION__, __LINE__, ""s)

#define ASSERT_EQUAL_HINT(a, b, hint) AssertEqualImpl((a), (b), #a, #b, __FILE__, __FUNCTION__, __LINE__, (hint))

void
AssertImpl(bool value, const std::string &expr_str, const std::string &file, const std::string &func, unsigned line,
           const std::string &hint) {
    if (!value) {
        cout << file << "("s << line << "): "s << func << ": "s;
        cout << "ASSERT("s << expr_str << ") failed."s;
        if (!hint.empty()) {
            cout << " Hint: "s << hint;
        }
        cout << endl;
        abort();
    }
}

#define ASSERT(expr) AssertImpl(!!(expr), #expr, __FILE__, __FUNCTION__, __LINE__, ""s)

#define ASSERT_HINT(expr, hint) AssertImpl(!!(expr), #expr, __FILE__, __FUNCTION__, __LINE__, (hint))

template<typename T, typename U>
void RunTestImpl(T &test, U &func) {
    test();
    std::cerr << func << " OK" << std::endl;
}

#define RUN_TEST(func)  RunTestImpl((func), #func)

#pragma endregion TEST_LIB
// -------- Конец шаблонов тестирующих функций ----------

// -------- DoublyLinkedList ----------

class DoublyLinkedListTester;

class DoublyLinkedList {
public:
    // ВАШИ МЕТОДЫ

    friend DoublyLinkedListTester;

private:
    // ВАШИ ПОЛЯ
};

class DoublyLinkedListTester {
private:

    static vector<int> ListToVector(const DoublyLinkedList &list) {
        vector<int> result;
        auto current = list.head;
        while (current) {
            result.push_back(current->data);
            current = current->next;
        }
        return result;
    }

    static bool CompareList(const DoublyLinkedList &list, vector<int> expected) {
        auto tmp = ListToVector(list);
        return tmp == expected;
    }

    // -------- Тестирующие функций ----------

#pragma region TESTS

    static void TestPushFront() {
        DoublyLinkedList list;

        // Тестируем вставку в пустой список
        list.pushFront(1);
        ASSERT_EQUAL(list.size, 1);
        list.popBack();
        ASSERT_EQUAL(list.size, 0);

        // Тестируем вставку нескольких элементов
        list.pushFront(2);
        list.pushFront(3);
        list.pushFront(4);
        ASSERT_EQUAL(list.size, 3);
        ASSERT(CompareList(list, {4, 3, 2}));

        // Проверяем порядок элементов
        list.reverse();
        ASSERT(CompareList(list, {2, 3, 4}));
    }

    static void TestPushBack() {
        DoublyLinkedList list;

        // Тестируем вставку в пустой список
        list.pushBack(1);
        ASSERT_EQUAL(list.size, 1);
        list.popFront();
        ASSERT_EQUAL(list.size, 0);

        // Тестируем вставку нескольких элементов
        list.pushBack(2);
        list.pushBack(3);
        list.pushBack(4);
        ASSERT_EQUAL(list.size, 3);
        ASSERT(CompareList(list, {2, 3, 4}));

        // Проверяем порядок элементов
        list.reverse();
        ASSERT(CompareList(list, {4, 3, 2}));
    }

    static void TestPopFront() {
        DoublyLinkedList list;
        list.pushBack(1);
        list.pushBack(2);
        list.pushBack(3);

        // Тестируем удаление из начала списка
        list.popFront();
        ASSERT_EQUAL(list.size, 2);
        ASSERT(CompareList(list, {2, 3}));

        list.popFront();
        list.popFront();
        ASSERT_EQUAL(list.size, 0);

        // Попытка удаления из пустого списка
        try {
            list.popFront();
            ASSERT(false); // Убедимся, что исключение не было брошено.
        } catch (const std::runtime_error &) {
            ASSERT(true); // Если исключение было брошено, то тест считается успешным.
        }
    }

    static void TestPopBack() {
        DoublyLinkedList list;
        list.pushBack(1);
        list.pushBack(2);
        list.pushBack(3);

        // Тестируем удаление из конца списка
        list.popBack();
        ASSERT_EQUAL(list.size, 2);
        ASSERT(CompareList(list, {1, 2}));

        list.popBack();
        list.popBack();
        ASSERT_EQUAL(list.size, 0);

        // Попытка удаления из пустого списка
        try {
            list.popBack();
            ASSERT(false); // Убедимся, что исключение не было брошено.
        } catch (const std::runtime_error &) {
            ASSERT(true); // Если исключение было брошено, то тест считается успешным.
        }
    }

    static void TestInsert() {
        DoublyLinkedList list;
        list.pushBack(1);
        list.pushBack(3);

        // Тестируем вставку в середину списка
        auto node1 = list.head;
        list.insert(node1, 2);
        ASSERT(CompareList(list, {1, 2, 3}));

        // Тестируем в конец
        auto node2 = list.tail;
        list.insert(node2, 4);
        ASSERT(CompareList(list, {1, 2, 3, 4}));

        // Попытка вставки после некорректной позиции
        DoublyLinkedList anotherList;
        try {
            anotherList.insert(nullptr, 42);
            ASSERT(false); // Убедимся, что исключение не было брошено.
        } catch (const std::runtime_error &) {
            ASSERT(true); // Если исключение было брошено, то тест считается успешным.
        }
        anotherList.pushBack(1);
        try {
            list.insert(anotherList.head, 43);
            ASSERT(false); // Убедимся, что исключение не было брошено.
        } catch (const std::runtime_error &) {
            ASSERT(true); // Если исключение было брошено, то тест считается успешным.
        }
    }

    static void TestPop() {
        DoublyLinkedList list;
        list.pushBack(1);
        list.pushBack(2);
        list.pushBack(3);

        // Тестируем удаление по указателю
        auto node2 = list.head->next;
        list.pop(node2);
        ASSERT_EQUAL(list.size, 2);
        ASSERT(CompareList(list, {1, 3}));

        auto node1 = list.head;
        list.pop(node1);
        ASSERT_EQUAL(list.size, 1);
        ASSERT(CompareList(list, {3}));

        auto node3 = list.head;
        list.pop(node3);
        ASSERT_EQUAL(list.size, 0);

        // Попытка удаления с некорректным указателем
        try {
            list.pop(nullptr);
            ASSERT(false); // Убедимся, что исключение не было брошено.
        } catch (const std::runtime_error &) {
            ASSERT(true); // Если исключение было брошено, то тест считается успешным.
        }

        DoublyLinkedList anotherList;
        try {
            list.pop(anotherList.head);
            ASSERT(false); // Убедимся, что исключение не было брошено.
        } catch (const std::runtime_error &) {
            ASSERT(true); // Если исключение было брошено, то тест считается успешным.
        }
    }

    static void TestErase() {
        DoublyLinkedList list;
        list.pushBack(1);
        list.pushBack(2);
        list.pushBack(3);

        // Тестируем полное удаление списка
        list.erase();
        ASSERT_EQUAL(list.size, 0);

        // Попытка удаления из пустого списка
        try {
            list.erase();
            ASSERT(true); // Убедимся, что исключение не было брошено.
        } catch (...) {
            ASSERT(false); // Если исключение было брошено, то тест считается успешным.
        }
    }

    static void TestReverse() {
        DoublyLinkedList list;
        list.pushBack(1);
        list.pushBack(2);
        list.pushBack(3);

        // Тестируем обращение порядка элементов
        list.reverse();
        ASSERT(CompareList(list, {3, 2, 1}));
    }

    static void TestRemoveDuplicates() {
        DoublyLinkedList list;
        list.pushBack(1);
        list.pushBack(2);
        list.pushBack(1);
        list.pushBack(1);
        list.pushBack(3);

        // Тестируем удаление дубликатов
        list.removeDuplicates();
        ASSERT(CompareList(list, {1, 2, 3}));
    }

    static void TestReplace() {
        DoublyLinkedList list;
        list.pushBack(1);
        list.pushBack(2);
        list.pushBack(3);

        // Тестируем замену элементов
        list.replace(2, 4);
        ASSERT(CompareList(list, {1, 4, 3}));

        // Попытка замены элемента, который не входит в список
        list.replace(5, 6);
        ASSERT(CompareList(list, {1, 4, 3}));
    }

#pragma endregion TESTS

    // -------- Конец тестирующих функций ----------

public:
    static void Test() {
        RUN_TEST(TestPushFront);
        RUN_TEST(TestPushBack);
        RUN_TEST(TestPopFront);
        RUN_TEST(TestPopBack);
        RUN_TEST(TestInsert);
        RUN_TEST(TestPop);
        RUN_TEST(TestErase);
        RUN_TEST(TestReverse);
        RUN_TEST(TestRemoveDuplicates);
        RUN_TEST(TestReplace);
    }
};

// -------- DoublyLinkedList ----------

int main() {
    DoublyLinkedListTester::Test();
    return 0;
}