ccore/test/Test.c

#include "Test.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "core/Logger.h"

typedef struct {
    char* file;
    int tests;
    int successTests;
} Result;

static Result* results = nullptr;
static size_t resultsIndex = 0;
static size_t resultsCapacity = 0;

static Result* getResult(const char* file) {
    for(size_t i = 0; i < resultsIndex; i++) {
        Result* r = results + i;
        if(strcmp(r->file, file) == 0) {
            return r;
        }
    }
    while(resultsIndex >= resultsCapacity) {
        size_t newCapacity = resultsCapacity == 0 ? 8 : resultsCapacity * 2;
        results = realloc(results, newCapacity * sizeof(Result));
        if(results == nullptr) {
            printf("realloc failure in '%s' at '%d'\n", __FILE__, __LINE__);
            exit(1);
        }
        resultsCapacity = newCapacity;
    }
    Result* r = results + (resultsIndex++);
    r->file = strdup(file);
    r->successTests = 0;
    r->tests = 0;
    return r;
}

void coreFinalizeTests(void) {
    for(size_t i = 0; i < resultsIndex; i++) {
        Result* r = results + i;
        bool c = r->successTests == r->tests;
        fputs(c ? CORE_TERMINAL_GREEN : CORE_TERMINAL_RED, stdout);
        printf("%s - %d / %d tests succeeded", r->file, r->successTests,
               r->tests);
        puts(CORE_TERMINAL_RESET);
        free(r->file);
    }
    free(results);
    results = nullptr;
    resultsIndex = 0;
    resultsCapacity = 0;
}

static bool addToResult(const char* file, bool comparison) {
    Result* r = getResult(file);
    r->tests++;
    if(comparison) {
        r->successTests++;
        return true;
    }
    return false;
}

#define CORE_TEST_SUCCESS(result)                                              \
    file = coreGetShortFileName(file);                                         \
    if(addToResult(file, result)) {                                            \
        return true;                                                           \
    }

#define CORE_TEST_NAMED_COMPARE(name, type, format)                            \
    bool coreTest##name(CORE_TEST_ARGS, type wanted, type actual) {            \
        CORE_TEST_SUCCESS(wanted == actual)                                    \
        fputs(CORE_TERMINAL_RED, stdout);                                      \
        printf("%s:%d - expected '" format "' got '" format "'", file, line,   \
               wanted, actual);                                                \
        puts(CORE_TERMINAL_RESET);                                             \
        return false;                                                          \
    }

CORE_TEST_NAMED_COMPARE(Int, int, "%d")
CORE_TEST_NAMED_COMPARE(I64, i64, "%ld")
CORE_TEST_NAMED_COMPARE(U64, u64, "%lu")
CORE_TEST_NAMED_COMPARE(Size, size_t, "%zu")
CORE_TEST_NAMED_COMPARE(Bool, bool, "%d")

bool coreTestString(CORE_TEST_ARGS, const char* wanted, const char* actual) {
    CORE_TEST_SUCCESS(strcmp(wanted, actual) == 0);
    fputs(CORE_TERMINAL_RED, stdout);
    printf("%s:%d - expected '%s' got '%s'", file, line, wanted, actual);
    puts(CORE_TERMINAL_RESET);
    return false;
}

bool coreTestFloat(CORE_TEST_ARGS, float wanted, float actual, float error) {
    float diff = wanted - actual;
    diff = diff < 0.0f ? -diff : diff;
    CORE_TEST_SUCCESS(diff <= error);
    fputs(CORE_TERMINAL_RED, stdout);
    printf("%s:%d - expected '%.3f' got '%.3f'", file, line, (double)wanted,
           (double)actual);
    puts(CORE_TERMINAL_RESET);
    return false;
}

bool coreTestNull(CORE_TEST_ARGS, const void* actual) {
    CORE_TEST_SUCCESS(actual == nullptr);
    fputs(CORE_TERMINAL_RED, stdout);
    printf("%s:%d - expected null", file, line);
    puts(CORE_TERMINAL_RESET);
    return false;
}

bool coreTestNotNull(CORE_TEST_ARGS, const void* actual) {
    CORE_TEST_SUCCESS(actual != nullptr);
    fputs(CORE_TERMINAL_RED, stdout);
    printf("%s:%d - expected valid pointer", file, line);
    puts(CORE_TERMINAL_RESET);
    return false;
}

bool coreTestVectorN(CORE_TEST_ARGS, const float* wanted, const float* actual,
                     size_t n) {
    for(size_t i = 0; i < n; i++) {
        if(!coreTestFloat(file, line, wanted[i], actual[i], 0.01f)) {
            return false;
        }
    }
    return true;
}

bool coreTestIntVectorN(CORE_TEST_ARGS, const int* wanted, const int* actual,
                        size_t n) {
    for(size_t i = 0; i < n; i++) {
        if(!coreTestInt(file, line, wanted[i], actual[i])) {
            return false;
        }
    }
    return true;
}