core/test/modules/QueueTests.cpp

module;

#include <cstdio>

module Tests;

import Core.Std;
import Core.Queue;
import Core.Test;
import Core.Types;
import Core.Meta;

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;
    Core::testFalse(buffer.canRemove());
    Core::test(0, buffer.getLength());
    buffer.add(4);
    Core::test(1, buffer.getLength());
    Core::testTrue(buffer.canRemove());
    Core::test(4, buffer[0]);
    buffer.remove();
    Core::testFalse(buffer.canRemove());
    Core::test(0, buffer.getLength());
}

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

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

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

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

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

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

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

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

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

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

    buffer.remove();
    Core::testString("[2, 3]", buffer);
    Core::test(2, buffer.getLength());
    Core::test(5, Tester::sum);

    buffer.add();
    Core::testString("[2, 3, 4]", buffer);
    Core::test(3, buffer.getLength());
    Core::test(9, Tester::sum);

    buffer.remove();
    Core::testString("[3, 4]", buffer);
    Core::test(2, buffer.getLength());
    Core::test(7, Tester::sum);

    buffer.add();
    Core::testString("[3, 4, 5]", buffer);
    Core::test(3, buffer.getLength());
    Core::test(12, Tester::sum);

    buffer.remove();
    Core::testString("[4, 5]", buffer);
    Core::test(2, buffer.getLength());
    Core::test(9, Tester::sum);

    buffer.clear();
    Core::testString("[]", buffer);
    Core::test(0, buffer.getLength());
    Core::test(0, Tester::sum);
}

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