test.h

Go to the documentation of this file.

 
#ifndef TEST_H
#define TEST_H
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
 
#if defined(_WIN32)
#   include <windows.h>
 
static int
_tr_enable_vt(HANDLE h)
{
    DWORD mode = 0;
    if (!GetConsoleMode(h, &mode)) {
        return 0;
    }
    return SetConsoleMode(h, mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING) != 0;
}
 
static int _tr_colors_enabled = -1;
 
static int
_tr_use_colors(void)
{
    if (_tr_colors_enabled < 0) {
        _tr_colors_enabled = _tr_enable_vt(GetStdHandle(STD_OUTPUT_HANDLE));
    }
    return _tr_colors_enabled;
}
#else
static int
_tr_use_colors(void)
{
    return 1;
}
#endif
 
#define TR_RESET  (_tr_use_colors() ? "\x1b[0m" : "")
#define TR_BOLD   (_tr_use_colors() ? "\x1b[1m" : "")
#define TR_DIM    (_tr_use_colors() ? "\x1b[2m" : "")
#define TR_GREEN  (_tr_use_colors() ? "\x1b[32m" : "")
#define TR_RED    (_tr_use_colors() ? "\x1b[31m" : "")
#define TR_YELLOW (_tr_use_colors() ? "\x1b[33m" : "")
#define TR_WHITE  (_tr_use_colors() ? "\x1b[97m" : "")
 
/*
 * Failure Capture Buffer
 *
 * EXPECT() fires inside the test function. Rather than printing immediately
 * (which interleaves with PASS/FAIL lines), failures are buffered and then
 * printed indented beneath the failing test name.
 */
 
#define TR_MAX_FAILURES_PER_TEST 16
#define TR_FAILURE_MSG_LEN   256
 
typedef struct {
    char msg[TR_FAILURE_MSG_LEN];
} _TrFailureMsg;
 
static _TrFailureMsg _tr_fail_buf[TR_MAX_FAILURES_PER_TEST];
static int       _tr_fail_count = 0;
 
static void
_tr_record_failure(const char *file, int line, const char *expr)
{
    if (TR_MAX_FAILURES_PER_TEST <= _tr_fail_count) {
        return;
    }
 
    /* Strip to filename only. */
    const char *p      = file;
    const char *slash  = strrchr(file, '/');
    const char *bslash = strrchr(file, '\\');
    if (slash && slash > p) {
        p = slash + 1;
    }
    if (bslash && bslash > p) {
        p = bslash + 1;
    }
 
    snprintf(_tr_fail_buf[_tr_fail_count].msg, TR_FAILURE_MSG_LEN, "%s:%d  %s", p, line, expr);
    _tr_fail_count++;
}
 
static int _tr_total        = 0;
static int _tr_passed       = 0;
static int _tr_failed       = 0;
static int _tr_suite_total  = 0;
static int _tr_suite_failed = 0;

#define EXPECT(cond)                                                                               \
    do {                                                                                       \
        if (!(cond)) {                                                                     \
            _tr_record_failure(__FILE__, __LINE__, #cond);                             \
            _tr_failed++;                                                              \
        }                                                                                  \
    } while (0)

#define EXPECT_FATAL(cond)                                                                         \
    do {                                                                                       \
        if (!(cond)) {                                                                     \
            _tr_record_failure(__FILE__, __LINE__, #cond);                             \
            _tr_failed++;                                                              \
            printf("    %s[FATAL]%s %s:%d: %s\n",                                      \
                   TR_RED,                                                             \
                   TR_RESET,                                                           \
                   __FILE__,                                                           \
                   __LINE__,                                                           \
                   #cond);                                                             \
            abort();                                                                   \
        }                                                                                  \
    } while (0)

#define EXPECT_STR8_EQ(a, b) EXPECT(str8_match((a), (b)))
 
/*
 * @defgroup test_framework Test Framework
 * @{
 */

#define TEST_CASE(name) static void test_##name(void)
 
typedef void (*_TrTestFn)(void);

static void
_tr_run_test(_TrTestFn fn, const char *name)
{
    _tr_fail_count   = 0;
    int fails_before = _tr_failed;
 
    clock_t t0 = clock();
    fn();
    clock_t t1 = clock();
    long    ms = (long)(((double)(t1 - t0) / CLOCKS_PER_SEC) * 1000.0);
 
    _tr_total++;
    _tr_suite_total++;
 
    if (_tr_failed == fails_before) {
        _tr_passed++;
        printf("    %sPASS%s  %-34s %s(%ldms)%s\n",
               TR_GREEN,
               TR_RESET,
               name,
               TR_DIM,
               ms,
               TR_RESET);
    } else {
        _tr_suite_failed++;
        printf("    %sFAIL%s  %-34s %s(%ldms)%s\n",
               TR_RED,
               TR_RESET,
               name,
               TR_DIM,
               ms,
               TR_RESET);
        for (int i = 0; i < _tr_fail_count; i++) {
            printf("          %s%s%s\n", TR_YELLOW, _tr_fail_buf[i].msg, TR_RESET);
        }
    }
}

static void
_tr_suite_begin(const char *name)
{
    _tr_suite_total  = 0;
    _tr_suite_failed = 0;
    printf("\n  %s%s%s\n", TR_BOLD, name, TR_RESET);
}

static void
_tr_suite_end(void)
{ /* reserved for future suite-level summary */
}

static void
tr_begin(const char *title)
{
    printf("\n%s %s%s\n", TR_BOLD, title, TR_RESET);
}

static int
tr_end(void)
{
    printf("\n%s Results%s\n", TR_BOLD, TR_RESET);
    printf(" %s----------------------------------------%s\n", TR_DIM, TR_RESET);
    printf("  %s%d tests%s    %s%d passed%s    %s%d failed%s\n\n",
           TR_BOLD,
           _tr_total,
           TR_RESET,
           TR_GREEN,
           _tr_passed,
           TR_RESET,
           _tr_failed > 0 ? TR_RED : TR_DIM,
           _tr_failed,
           TR_RESET);
    return (_tr_failed > 0) ? 1 : 0;
}

#define BEGIN_SUITE(name)                                                                          \
    do {                                                                                       \
        _tr_suite_begin(name);

#define END_SUITE                                                                                  \
    _tr_suite_end();                                                                           \
    }                                                                                          \
    while (0)

#define RUN_TEST(name) _tr_run_test(test_##name, #name)

 
#endif // TEST_H