core/test/modules/UtilityTests.cpp

module Tests;

import Core.Test;
import Core.ToString;
import Core.Utility;
import Core.Meta;
import Core.Types;
import Core.Std;

static void testPopCount() {
    Core::test(4, Core::popCount(0xF));
    Core::test(0, Core::popCount(0x0));
    Core::test(2, Core::popCount(0x6));
    Core::test(7, Core::popCount(0x7F));
    Core::test(3, Core::popCount(0x2A));
    Core::test(32, Core::popCount(0xFFFF'FFFF));
    Core::test(64, Core::popCount(0xFFFF'FFFF'FFFF'FFFF));
    Core::test(44, Core::popCount(0xFFFF'0FFF'FFFF));
}

static void testIf() {
    Core::testTrue(Core::IsSame<Core::If<true, int, double>, int>);
    Core::testTrue(Core::IsSame<Core::If<false, int, double>, double>);
}

static void testZeroRellocate() {
    void* buffer = Core::reallocateRaw(nullptr, 16);
    Core::testNotNull(buffer);
    buffer = Core::reallocateRaw(buffer, 0);
    Core::testNull(buffer);
}

static void testMemoryInfoList() {
    void* a = Core::allocateRaw(8);
    void* b = Core::allocateRaw(8);
    void* c = Core::allocateRaw(8);
    void* d = Core::allocateRaw(8);
    Core::deallocateRaw(b); // remove middle element
    Core::deallocateRaw(a); // remove first
    Core::deallocateRaw(d); // remove last
    Core::deallocateRaw(c); // remove single
    Core::deallocateRaw(nullptr);
}

static void testZeroAllocate() {
    constexpr size_t n = 1024 * 1024;
    void* a = Core::allocateRaw(n);
    memset(a, 0, n);
    void* b = Core::zeroAllocateRaw(n);
    Core::testTrue(memcmp(a, b, n) == 0);
    Core::deallocateRaw(a);
    Core::deallocateRaw(b);
}

typedef struct {
    int i;
    i64 d;
} SwapTest;

static void testSwap() {
    SwapTest a = {3, 20};
    SwapTest b = {7, 30};
    Core::swap(a, b);
    Core::test(7, a.i);
    Core::test(3, b.i);
    Core::test(30l, a.d);
    Core::test(20l, b.d);
}

static void testSort() {
    size_t data[] = {9, 0, 3, 1, 8, 4, 6, 2, 5, 7};
    size_t n = 10;
    Core::bubbleSort(data, n);
    Core::bubbleSort(data, n);
    Core::bubbleSort(data, 0);
    for(size_t i = 0; i < n; i++) {
        Core::test(data[i], i);
    }
}

static void testToString() {
    char buffer[512];
    Core::StringBase b(buffer, sizeof(buffer));
    Core::test(10, b.format("a{}a#a", 1.0, 2, 3));
    Core::testString("a1.00a#a23", b);
    Core::test(5, b.format("aa#ab"));
    Core::testString("aa#ab", b);
    Core::test(7, b.format("{{a}{}{{b}", 1));
    Core::testString("{a}1{b}", b);

    b = Core::StringBase(buffer, 3);
    Core::test(6, b.format("aaaaaa"));
    Core::testString("aa", b);

    b = Core::StringBase(buffer, 4);
    Core::test(4, b.format("a{}", 456));
    Core::testString("a45", b);

    b = Core::StringBase(buffer, 4);
    Core::test(10, b.format("{} {} {}", 456, 567, 78));
    Core::testString("456", b);

    b = Core::StringBase(buffer, 1);
    Core::test(10, b.format("{} {} {}", 456, 567, 78));
    Core::testString("", b);

    b = Core::StringBase(nullptr, 0);
    Core::test(10, b.format("{} {} {}", 456ll, 567l, 78ull));

    char c = 'a';
    short s = 4;
    unsigned char cu = 'h';
    unsigned short su = 67;
    signed char cs = 'x';
    b = Core::StringBase(buffer, sizeof(buffer));
    Core::test(10, b.format("{} {} {} {} {}", c, s, cu, su, cs));
    Core::testString("a 4 h 67 x", b);

    unsigned char text[] = "fgsdf";
    b.clear();
    Core::test(5, b.add(text));
    Core::testString("fgsdf", buffer);
}

static void testStringFormat() {
    char buffer[256];
    Core::StringBase s(buffer, sizeof(buffer));
    Core::test(3, s.format("X{}X", 5));
    Core::testString("X5X", s);
    Core::test(7, s.format("X{5}X", 5));
    Core::testString("X    5X", s);
    Core::test(7, s.format("X{r5}X", 5));
    Core::testString("X    5X", s);
    Core::test(7, s.format("X{l5}X", 5));
    Core::testString("X5    X", s);

    s = Core::StringBase(buffer, 0);
    Core::test(3, s.format("X{}X", 5));
    Core::testString("", s);
    Core::test(7, s.format("X{5}X", 5));
    Core::testString("", s);
    Core::test(7, s.format("X{r5}X", 5));
    Core::testString("", s);
    Core::test(7, s.format("X{l5}X", 5));
    Core::testString("", s);
}

static void testDefaultString() {
    Core::StringBase s;
    Core::test(3, s.format("X{}X", 5));
    Core::test(0, s.getCapacity());
}

void testUtility() {
    testPopCount();
    testIf();
    testZeroRellocate();
    testMemoryInfoList();
    testZeroAllocate();
    testSwap();
    testSort();
    testToString();
    testStringFormat();
    testDefaultString();
}

static void outOfMemory(void*) {
    Core::setOutOfMemoryHandler(nullptr, nullptr);
}

[[noreturn]] void testInvalidAllocate() {
    Core::setOutOfMemoryHandler(outOfMemory, nullptr);
    Core::allocateRaw(0xFFF'FFFF'FFFF);
    Core::testTrue(false);
    Core::finalizeTests();
    Core::exitWithHandler(0);
}

[[noreturn]] void testInvalidReallocate() {
    Core::setOutOfMemoryHandler(outOfMemory, nullptr);
    void* p = Core::allocateRaw(0xFF);
    Core::printMemoryReport();
    Core::reallocateRaw(p, 0xFFF'FFFF'FFFF);
    Core::testTrue(false);
    Core::finalizeTests();
    Core::exitWithHandler(0);
}

[[noreturn]] void testInvalidNew() {
    Core::setOutOfMemoryHandler(outOfMemory, nullptr);
    volatile char* p2 = new char[0xFF];
    p2[2] = 3;
    Core::printMemoryReport();
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpragmas"
#pragma GCC diagnostic ignored "-Wunknown-warning-option"
#pragma GCC diagnostic error "-Wlarger-than=17592186044416"
    volatile char* p = Core::newWithSourceN<char>(0xFFF'FFFF'FFFF);
    p[3] = 3;
#pragma GCC diagnostic pop
    Core::testTrue(false);
    Core::finalizeTests();
    Core::exitWithHandler(0);
}

[[noreturn]] void testPreCanary() {
#ifdef CHECK_MEMORY
    char* p = static_cast<char*>(Core::allocateRaw(16));
    p[-1] = 0;
    Core::deallocateRaw(p);
    Core::testTrue(false);
#endif
    Core::finalizeTests();
    Core::exitWithHandler(0);
}

[[noreturn]] void testPreCanaryNew() {
#ifdef CHECK_MEMORY
    volatile char* p2 = new char[3];
    volatile char* p = Core::newWithSourceN<char>(16);
    delete[] p2;
    Core::deleteWithSourceN(p);
    p = Core::newWithSourceN<char>(16);
    p[-1] = 0;
    Core::deleteWithSourceN(p);
    Core::testTrue(false);
#endif
    Core::finalizeTests();
    Core::exitWithHandler(0);
}

[[noreturn]] void testPreCanaryNewArray() {
#ifdef CHECK_MEMORY
    volatile char* p = Core::newWithSource<char>();
    p[-1] = 0;
    Core::deleteWithSource(p);
    Core::testTrue(false);
#endif
    Core::finalizeTests();
    Core::exitWithHandler(0);
}

[[noreturn]] void testPostCanary() {
#ifdef CHECK_MEMORY
    char* p = static_cast<char*>(Core::allocateRaw(16));
    p[17] = 0;
    Core::deallocateRaw(p);
    Core::testTrue(false);
#endif
    Core::finalizeTests();
    Core::exitWithHandler(0);
}