core/test/modules/QueueTests.cpp

#include "../Tests.hpp"
#include "core/Queue.hpp"
#include "core/Test.hpp"

template class Core::Queue<int, 5>;

struct Tester final {
    static int ids;
    static int sum;
    int id;

    Tester() : id(++ids) {
        sum += id;
    }

    Tester(const Tester&) : id(++ids) {
        sum += id;
    }

    Tester(Tester&&) : id(++ids) {
        sum += id;
    }

    Tester& operator=(const Tester&) {
        return *this;
    }

    Tester& operator=(Tester&&) {
        return *this;
    }

    ~Tester() {
        sum -= id;
    }

    size_t toString(char* s, size_t n) const {
        int w = snprintf(s, n, "%d", id);
        return w >= 0 ? static_cast<size_t>(w) : 0;
    }
};

int Tester::ids = 0;
int Tester::sum = 0;

static void resetTester() {
    Tester::ids = 0;
    Tester::sum = 0;
}

static void testReadAndWrite() {
    Core::Queue<int, 5> buffer;
    TEST_FALSE(buffer.canRemove());
    TEST(0, buffer.getLength());
    buffer.add(4);
    TEST(1, buffer.getLength());
    TEST_TRUE(buffer.canRemove());
    TEST(4, buffer[0]);
    buffer.remove();
    TEST_FALSE(buffer.canRemove());
    TEST(0, buffer.getLength());
}

static void testOverflow() {
    Core::Queue<int, 3> buffer;
    buffer.add(1).add(2).add(3).add(4).add(5);
    TEST(3, buffer.getLength());
    TEST(1, buffer[0]);
    buffer.remove();
    TEST(2, buffer.getLength());
    TEST(2, buffer[0]);
    buffer.remove();
    TEST(1, buffer.getLength());
    TEST(3, buffer[0]);
    buffer.remove();
    TEST_FALSE(buffer.canRemove());
    TEST(0, buffer.getLength());
}

static void testRefill() {
    Core::Queue<int, 3> buffer;
    buffer.add(1).add(2).add(3).add(4);
    TEST(3, buffer.getLength());
    TEST_TRUE(buffer.canRemove());
    TEST(1, buffer[0]);
    buffer.remove();
    TEST(2, buffer[0]);
    buffer.remove();
    TEST(3, buffer[0]);
    buffer.remove();
    TEST(0, buffer.getLength());
    TEST_FALSE(buffer.canRemove());
    buffer.add(5).add(6);
    TEST(2, buffer.getLength());
    TEST_TRUE(buffer.canRemove());
    TEST(5, buffer[0]);
    buffer.remove();
    TEST(6, buffer[0]);
    buffer.remove();
    TEST_FALSE(buffer.canRemove());
    TEST(0, buffer.getLength());
}

static void testClear() {
    Core::Queue<int, 3> buffer;
    buffer.add(1).add(2);
    TEST(2, buffer.getLength());
    buffer.clear();
    TEST_FALSE(buffer.canRemove());
    TEST(0, buffer.getLength());
}

static void testConstructDestruct() {
    resetTester();
    Core::Queue<Tester, 3> buffer;
    buffer.add();
    TEST(1, Tester::sum);
    buffer.add();
    TEST(3, Tester::sum);
    buffer.add();
    TEST(6, Tester::sum);

    buffer.remove();
    TEST(5, Tester::sum);
    buffer.remove();
    TEST(3, Tester::sum);
    buffer.remove();
    TEST(0, Tester::sum);
}

static void testCopyDestruct() {
    resetTester();
    {
        Core::Queue<Tester, 3> buffer;
        buffer.add();
        TEST(1, Tester::sum);
        buffer.add();
        TEST(3, Tester::sum);
        buffer.add();
        TEST(6, Tester::sum);
        {
            Core::Queue<Tester, 3> copy = buffer;
            TEST(6 + 4 + 5 + 6, Tester::sum);
        }
        TEST(6, Tester::sum);
    }
    TEST(0, Tester::sum);
}

static void testCopyAssignmentDestruct() {
    resetTester();
    {
        Core::Queue<Tester, 3> buffer;
        buffer.add();
        TEST(1, Tester::sum);
        buffer.add();
        TEST(3, Tester::sum);
        buffer.add();
        TEST(6, Tester::sum);
        {
            Core::Queue<Tester, 3> copy;
            copy = buffer;
            TEST(6 + 4 + 5 + 6, Tester::sum);
        }
        TEST(6, Tester::sum);
    }
    TEST(0, Tester::sum);
}

static void testMoveDestruct() {
    resetTester();
    {
        Core::Queue<Tester, 3> buffer;
        buffer.add();
        TEST(1, Tester::sum);
        buffer.add();
        TEST(3, Tester::sum);
        buffer.add();
        TEST(6, Tester::sum);
        {
            Core::Queue<Tester, 3> move = Core::move(buffer);
            TEST(4 + 5 + 6, Tester::sum);
            TEST(0, buffer.getLength());
        }
        TEST(0, Tester::sum);
    }
    TEST(0, Tester::sum);
}

static void testMoveAssignmentDestruct() {
    resetTester();
    {
        Core::Queue<Tester, 3> buffer;
        buffer.add();
        TEST(1, Tester::sum);
        buffer.add();
        TEST(3, Tester::sum);
        buffer.add();
        TEST(6, Tester::sum);
        {
            Core::Queue<Tester, 3> move;
            move = Core::move(buffer);
            TEST(4 + 5 + 6, Tester::sum);
            TEST(0, buffer.getLength());
        }
        TEST(0, Tester::sum);
    }
    TEST(0, Tester::sum);
}

static void testOverall() {
    resetTester();
    Core::Queue<Tester, 3> buffer;
    buffer.add().add().add();
    TEST_STRING("[1, 2, 3]", buffer);
    TEST(3, buffer.getLength());
    TEST(6, Tester::sum);

    buffer.remove();
    TEST_STRING("[2, 3]", buffer);
    TEST(2, buffer.getLength());
    TEST(5, Tester::sum);

    buffer.add();
    TEST_STRING("[2, 3, 4]", buffer);
    TEST(3, buffer.getLength());
    TEST(9, Tester::sum);

    buffer.remove();
    TEST_STRING("[3, 4]", buffer);
    TEST(2, buffer.getLength());
    TEST(7, Tester::sum);

    buffer.add();
    TEST_STRING("[3, 4, 5]", buffer);
    TEST(3, buffer.getLength());
    TEST(12, Tester::sum);

    buffer.remove();
    TEST_STRING("[4, 5]", buffer);
    TEST(2, buffer.getLength());
    TEST(9, Tester::sum);

    buffer.clear();
    TEST_STRING("[]", buffer);
    TEST(0, buffer.getLength());
    TEST(0, Tester::sum);
}

void testQueue() {
    testReadAndWrite();
    testOverflow();
    testRefill();
    testClear();
    testConstructDestruct();
    testCopyDestruct();
    testCopyAssignmentDestruct();
    testMoveDestruct();
    testMoveAssignmentDestruct();
    testOverall();
}