core/test/modules/UtilityTests.cpp

#include <cstring>

#include "../../src/ErrorSimulator.hpp"
#include "../Tests.hpp"
#include "core/ToString.hpp"
#include "core/Utility.hpp"

static const float eps = 0.0001f;

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

static void testZeroRellocate() {
    void* buffer = coreReallocate(nullptr, 16);
    TEST_NOT_NULL(buffer);
    buffer = coreReallocate(buffer, 0);
    TEST_NULL(buffer);
}

static void testMemoryInfoList() {
    void* a = coreAllocate(8);
    void* b = coreAllocate(8);
    void* c = coreAllocate(8);
    void* d = coreAllocate(8);
    coreFree(b); // remove middle element
    coreFree(a); // remove first
    coreFree(d); // remove last
    coreFree(c); // remove single
    coreFree(nullptr);
}

static void testZeroAllocate() {
    constexpr size_t n = 1024 * 1024;
    void* a = coreAllocate(n);
    memset(a, 0, n);
    void* b = coreZeroAllocate(n);
    TEST_TRUE(memcmp(a, b, n) == 0);
    coreFree(a);
    coreFree(b);
}

static void testInterpolate() {
    TEST_FLOAT(7.5f, interpolate(5.0f, 10.0f, 0.5f), eps);
    TEST_FLOAT(-2.0, interpolate(-10.0f, 10.0f, 0.4f), eps);
    TEST_FLOAT(10.0f, interpolate(-3.0f, 10.0f, 1.0f), eps);
    TEST_FLOAT(7.0f, interpolate(7.0f, 10.0f, 0.0f), eps);
    TEST_FLOAT(6.0f, interpolate(0.0f, 10.0f, 0.6f), eps);
}

static void testRadianToDegree() {
    TEST_FLOAT(45.0f, radianToDegree(PI * 0.25f), eps);
    TEST_FLOAT(90.0f, radianToDegree(PI * 0.5f), eps);
    TEST_FLOAT(180.0f, radianToDegree(PI), eps);
    TEST_FLOAT(360.0f, radianToDegree(PI * 2.0f), eps);
}

static void testDegreeToRadian() {
    TEST_FLOAT(PI * 0.25f, degreeToRadian(45.0f), eps);
    TEST_FLOAT(PI * 0.5f, degreeToRadian(90.0f), eps);
    TEST_FLOAT(PI, degreeToRadian(180.0f), eps);
    TEST_FLOAT(PI * 2.0f, degreeToRadian(360.0f), eps);
}

static void testSleep(i64 nanos) {
    i64 time = -getNanos();
    TEST_FALSE(sleepNanos(nanos));
    time += getNanos();
    TEST_TRUE(time >= nanos && time <= (nanos * 13) / 10);
}

static void testSleepMillis(i64 millis) {
    i64 time = -getNanos();
    TEST_FALSE(sleepMillis(millis));
    time += getNanos();
    i64 nanos = millis * 1'000'000;
    TEST_TRUE(time >= nanos && time <= (nanos * 13) / 10);
}

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

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

static void testFail() {
#ifdef ERROR_SIMULATOR
    failStepThrow = 1;
    TEST(-1l, getNanos());
    failStepThrow = 1;
    TEST_TRUE(sleepMillis(5));
    failStepThrow = 0;
#endif
}

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

static void testMinMax() {
    TEST(5, min<int>(5, 7));
    TEST(7, max<int>(5, 7));
    TEST(5, clamp<int>(3, 5, 7));
    TEST(7, clamp<int>(9, 5, 7));
    TEST(6, clamp<int>(6, 5, 7));
}

static void testToString() {
    char buffer[512];
    formatBuffer(buffer, sizeof(buffer), "aa##a", 1, 2, 3);
    TEST_STRING("aa#a123", buffer);
}

void testUtility(bool light) {
    testPopCount();
    testZeroRellocate();
    testMemoryInfoList();
    testZeroAllocate();
    testInterpolate();
    testRadianToDegree();
    testDegreeToRadian();
    testSleep(light ? 5'000'000 : 50'000'000);
    testSleep(light ? 50'000'000 : 1'300'000'000);
    testSleepMillis(light ? 5 : 50);
    testSleepMillis(light ? 50 : 1300);
    testSwap();
    testFail();
    testSort();
    testMinMax();
    testToString();
}

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

void testInvalidAllocate(void) {
    setOutOfMemoryHandler(outOfMemory, nullptr);
    coreAllocate(0xFFF'FFFF'FFFF);
    TEST_TRUE(false);
    finalizeTests();
    EXIT(0);
}

void testInvalidReallocate(void) {
    setOutOfMemoryHandler(outOfMemory, nullptr);
    void* p = coreAllocate(0xFF);
    printMemoryReport();
    coreReallocate(p, 0xFFF'FFFF'FFFF);
    TEST_TRUE(false);
    finalizeTests();
    EXIT(0);
}

[[noreturn]] void testPreCanary(void) {
#ifdef CHECK_MEMORY
    char* p = static_cast<char*>(coreAllocate(16));
    p[-1] = 0;
    coreFree(p);
    TEST_TRUE(false);
#endif
    finalizeTests();
    EXIT(0);
}

[[noreturn]] void testPreCanaryNew(void) {
#ifdef CHECK_MEMORY
    volatile char* p2 = new char[3];
    volatile char* p = coreNewN(char, 16);
    delete[] p2;
    coreDeleteN(p);
    p = coreNewN(char, 16);
    p[-1] = 0;
    coreDeleteN(p);
    TEST_TRUE(false);
#endif
    finalizeTests();
    EXIT(0);
}

[[noreturn]] void testPreCanaryNewArray(void) {
#ifdef CHECK_MEMORY
    volatile char* p = coreNew(char);
    p[-1] = 0;
    coreDelete(p);
    TEST_TRUE(false);
#endif
    finalizeTests();
    EXIT(0);
}

[[noreturn]] void testPostCanary(void) {
#ifdef CHECK_MEMORY
    char* p = static_cast<char*>(coreAllocate(16));
    p[17] = 0;
    coreFree(p);
    TEST_TRUE(false);
#endif
    finalizeTests();
    EXIT(0);
}