tuktest.h

Go to the documentation of this file.

// SPDX-License-Identifier: 0BSD
 
//
//
//  Author:    Lasse Collin
//
 
#ifndef TUKTEST_H
#define TUKTEST_H
 
#include <stddef.h>
 
// On some (too) old systems inttypes.h doesn't exist or isn't good enough.
// Include it conditionally so that any portability tricks can be done before
// tuktest.h is included. On any modern system inttypes.h is fine as is.
#ifndef PRIu64
#   include <inttypes.h>
#endif
 
#include <setjmp.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
 
 
#if defined(__GNUC__) && defined(__GNUC_MINOR__)
#   define TUKTEST_GNUC_REQ(major, minor) \
        ((__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)) \
            || __GNUC__ > (major))
#else
#   define TUKTEST_GNUC_REQ(major, minor) 0
#endif
 
 
// This is silencing warnings about unused functions. Not all test programs
// need all functions from this header.
#if TUKTEST_GNUC_REQ(3, 0) || defined(__clang__)
#   define tuktest_maybe_unused __attribute__((__unused__))
#else
#   define tuktest_maybe_unused
#endif
 
// We need printf("") so silence the warning about empty format string.
#if TUKTEST_GNUC_REQ(4, 2) || defined(__clang__)
#   pragma GCC diagnostic ignored "-Wformat-zero-length"
#endif
 
 
// Types and printf format macros to use in integer assertions and also for
// printing size_t values (C99's %zu isn't available on very old systems).
typedef int64_t tuktest_int;
typedef uint64_t tuktest_uint;
#define TUKTEST_PRId PRId64
#define TUKTEST_PRIu PRIu64
#define TUKTEST_PRIX PRIX64
 
 
// When TAP mode isn't used, Automake-compatible exit statuses are used.
#define TUKTEST_EXIT_PASS EXIT_SUCCESS
#define TUKTEST_EXIT_FAIL EXIT_FAILURE
#define TUKTEST_EXIT_SKIP 77
#define TUKTEST_EXIT_ERROR 99
 
 
enum tuktest_result {
    TUKTEST_PASS,
    TUKTEST_FAIL,
    TUKTEST_SKIP,
    TUKTEST_ERROR,
};
 
 
#ifdef TUKTEST_TAP
#   undef TUKTEST_QUIET
#   undef TUKTEST_COLOR
#   undef TUKTEST_TAP
#   define TUKTEST_TAP 1
#   define TUKTEST_STR_PASS  "ok -"
#   define TUKTEST_STR_FAIL  "not ok -"
#   define TUKTEST_STR_SKIP  "ok - # SKIP"
#   define TUKTEST_STR_ERROR "Bail out!"
#else
#   define TUKTEST_TAP 0
#   ifdef TUKTEST_COLOR
#       define TUKTEST_COLOR_PASS  "\x1B[0;32m"
#       define TUKTEST_COLOR_FAIL  "\x1B[0;31m"
#       define TUKTEST_COLOR_SKIP  "\x1B[1;34m"
#       define TUKTEST_COLOR_ERROR "\x1B[0;35m"
#       define TUKTEST_COLOR_TOTAL "\x1B[1m"
#       define TUKTEST_COLOR_OFF   "\x1B[m"
#       define TUKTEST_COLOR_IF(cond, color) ((cond) ? (color) : "" )
#   else
#       define TUKTEST_COLOR_PASS  ""
#       define TUKTEST_COLOR_FAIL  ""
#       define TUKTEST_COLOR_SKIP  ""
#       define TUKTEST_COLOR_ERROR ""
#       define TUKTEST_COLOR_TOTAL ""
#       define TUKTEST_COLOR_OFF   ""
#       define TUKTEST_COLOR_IF(cond, color) ""
#   endif
#   define TUKTEST_COLOR_ADD(str, color) color str TUKTEST_COLOR_OFF
#   define TUKTEST_STR_PASS \
        TUKTEST_COLOR_ADD("PASS:", TUKTEST_COLOR_PASS)
#   define TUKTEST_STR_FAIL \
        TUKTEST_COLOR_ADD("FAIL:", TUKTEST_COLOR_FAIL)
#   define TUKTEST_STR_SKIP \
        TUKTEST_COLOR_ADD("SKIP:", TUKTEST_COLOR_SKIP)
#   define TUKTEST_STR_ERROR \
        TUKTEST_COLOR_ADD("ERROR:", TUKTEST_COLOR_ERROR)
#endif
 
// NOTE: If TUKTEST_TAP is defined then TUKTEST_QUIET will get undefined above.
#ifndef TUKTEST_QUIET
#   define TUKTEST_QUIET 0
#else
#   undef TUKTEST_QUIET
#   define TUKTEST_QUIET 1
#endif
 
 
// Counts of the passed, failed, skipped, and hard-errored tests.
// This is indexed with the enumeration constants from enum tuktest_result.
static unsigned tuktest_stats[4] = { 0, 0, 0, 0 };
 
// Copy of argc and argv from main(). These are set by tuktest_start().
static int tuktest_argc = 0;
static char **tuktest_argv = NULL;
 
// Name of the currently-running test. This exists because it's nice
// to print the main test function name even if the failing test-assertion
// fails in a function called by the main test function.
static const char *tuktest_name = NULL;
 
// longjmp() target for when a test-assertion fails.
static jmp_buf tuktest_jmpenv;
 
 
// This declaration is needed for tuktest_malloc().
static int tuktest_end(void);
 
 
// Internal helper for handling hard errors both inside and
// outside tuktest_run().
#define tuktest_error_impl(filename, line, ...) \
do { \
    tuktest_print_result_prefix(TUKTEST_ERROR, filename, line); \
    printf(__VA_ARGS__); \
    printf("\n"); \
    ++tuktest_stats[TUKTEST_ERROR]; \
    exit(tuktest_end()); \
} while (0)
 
 
// printf() is without checking its return value in many places. This function
// is called before exiting to check the status of stdout and catch errors.
static void
tuktest_catch_stdout_errors(void)
{
    if (ferror(stdout) || fclose(stdout)) {
        fputs("Error while writing to stdout\n", stderr);
        exit(TUKTEST_EXIT_ERROR);
    }
}
 
 
// A simplified basename()-like function that is good enough for
// cleaning up __FILE__. This supports / and \ as path separator.
// If the path separator is wrong then the full path will be printed;
// it's a cosmetic problem only.
static const char *
tuktest_basename(const char *filename)
{
    for (const char *p = filename + strlen(filename); p > filename; --p)
        if (*p == '/' || *p == '\\')
            return p + 1;
 
    return filename;
}
 
 
// Internal helper that prints the prefix of the fail/skip/error message line.
static void
tuktest_print_result_prefix(enum tuktest_result result,
        const char *filename, unsigned line)
{
    // This is never called with TUKTEST_PASS but I kept it here anyway.
    const char *result_str
            = result == TUKTEST_PASS ? TUKTEST_STR_PASS
            : result == TUKTEST_FAIL ? TUKTEST_STR_FAIL
            : result == TUKTEST_SKIP ? TUKTEST_STR_SKIP
            : TUKTEST_STR_ERROR;
 
    const char *short_filename = tuktest_basename(filename);
 
    if (tuktest_name != NULL)
        printf("%s %s [%s:%u] ", result_str, tuktest_name,
                short_filename, line);
    else
        printf("%s [%s:%u] ", result_str, short_filename, line);
}
 
 
// An entry for linked list of memory allocations.
struct tuktest_malloc_record {
    struct tuktest_malloc_record *next;
    void *p;
};
 
// Linked list of per-test allocations. This is used when under tuktest_run().
// These allocations are freed in tuktest_run() and, in case of a hard error,
// also in tuktest_end().
static struct tuktest_malloc_record *tuktest_malloc_test = NULL;
 
// Linked list of global allocations. This is used allocations are made
// outside tuktest_run(). These are freed in tuktest_end().
static struct tuktest_malloc_record *tuktest_malloc_global = NULL;
 
 
#define tuktest_malloc(size) tuktest_malloc_impl(size, __FILE__, __LINE__)
 
static void *
tuktest_malloc_impl(size_t size, const char *filename, unsigned line)
{
    void *p = malloc(size == 0 ? 1 : size);
    struct tuktest_malloc_record *r = malloc(sizeof(*r));
 
    if (p == NULL || r == NULL) {
        free(r);
        free(p);
 
        // Avoid %zu for portability to very old systems that still
        // can compile C99 code.
        tuktest_error_impl(filename, line,
                "tuktest_malloc(%" TUKTEST_PRIu ") failed",
                (tuktest_uint)size);
    }
 
    r->p = p;
 
    if (tuktest_name == NULL) {
        // We were called outside tuktest_run().
        r->next = tuktest_malloc_global;
        tuktest_malloc_global = r;
    } else {
        // We were called under tuktest_run().
        r->next = tuktest_malloc_test;
        tuktest_malloc_test = r;
    }
 
    return p;
}
 
 
#define tuktest_free(ptr) tuktest_free_impl(ptr, __FILE__, __LINE__)
 
static void
tuktest_free_impl(void *p, const char *filename, unsigned line)
{
    if (p == NULL)
        return;
 
    struct tuktest_malloc_record **r = tuktest_name != NULL
            ? &tuktest_malloc_test : &tuktest_malloc_global;
 
    while (*r != NULL) {
        struct tuktest_malloc_record *tmp = *r;
 
        if (tmp->p == p) {
            *r = tmp->next;
            free(p);
            free(tmp);
            return;
        }
 
        r = &tmp->next;
    }
 
    tuktest_error_impl(filename, line, "tuktest_free: "
            "Allocation matching the pointer was not found");
}
 
 
// Frees all allocates in the given record list. The argument must be
// either &tuktest_malloc_test or &tuktest_malloc_global.
static void
tuktest_free_all(struct tuktest_malloc_record **r)
{
    while (*r != NULL) {
        struct tuktest_malloc_record *tmp = *r;
        *r = tmp->next;
        free(tmp->p);
        free(tmp);
    }
}
 
 
#define tuktest_start(argc, argv) \
do { \
    tuktest_argc = argc; \
    tuktest_argv = argv; \
    if (!TUKTEST_TAP && !TUKTEST_QUIET) \
        printf("=== %s ===\n", tuktest_basename(__FILE__)); \
} while (0)
 
 
#define tuktest_early_skip(...) \
do { \
    printf("%s [%s:%u] ", \
            TUKTEST_TAP ? "1..0 # SKIP" : TUKTEST_STR_SKIP, \
            tuktest_basename(__FILE__), __LINE__); \
    printf(__VA_ARGS__); \
    printf("\n"); \
    if (!TUKTEST_TAP && !TUKTEST_QUIET) \
        printf("=== END ===\n"); \
    tuktest_catch_stdout_errors(); \
    exit(TUKTEST_TAP ? EXIT_SUCCESS : TUKTEST_EXIT_SKIP); \
} while (0)
 
 
#define tuktest_error(...) tuktest_error_impl(__FILE__, __LINE__, __VA_ARGS__)
 
 
static int
tuktest_end(void)
{
    tuktest_free_all(&tuktest_malloc_test);
    tuktest_free_all(&tuktest_malloc_global);
 
    unsigned total_tests = 0;
    for (unsigned i = 0; i <= TUKTEST_ERROR; ++i)
        total_tests += tuktest_stats[i];
 
    if (tuktest_stats[TUKTEST_ERROR] == 0 && tuktest_argc > 1
            && (unsigned)(tuktest_argc - 1) > total_tests) {
        printf(TUKTEST_STR_ERROR " Fewer tests were run than "
                "specified on the command line. "
                "Was a test name mistyped?\n");
        ++tuktest_stats[TUKTEST_ERROR];
    }
 
#if TUKTEST_TAP
    // Print the plan only if no "Bail out!" has occurred.
    // Print the skip directive if no tests were run.
    // We cannot know the reason for the skip here though
    // (see tuktest_early_skip()).
    if (tuktest_stats[TUKTEST_ERROR] == 0)
        printf("1..%u%s\n", total_tests,
                total_tests == 0 ? " # SKIP" : "");
 
    tuktest_catch_stdout_errors();
    return EXIT_SUCCESS;
#else
    if (!TUKTEST_QUIET)
        printf("---\n"
                "%s# TOTAL: %u" TUKTEST_COLOR_OFF "\n"
                "%s# PASS:  %u" TUKTEST_COLOR_OFF "\n"
                "%s# SKIP:  %u" TUKTEST_COLOR_OFF "\n"
                "%s# FAIL:  %u" TUKTEST_COLOR_OFF "\n"
                "%s# ERROR: %u" TUKTEST_COLOR_OFF "\n"
                "=== END ===\n",
                TUKTEST_COLOR_TOTAL,
                total_tests,
                TUKTEST_COLOR_IF(
                    tuktest_stats[TUKTEST_PASS] > 0,
                    TUKTEST_COLOR_PASS),
                tuktest_stats[TUKTEST_PASS],
                TUKTEST_COLOR_IF(
                    tuktest_stats[TUKTEST_SKIP] > 0,
                    TUKTEST_COLOR_SKIP),
                tuktest_stats[TUKTEST_SKIP],
                TUKTEST_COLOR_IF(
                    tuktest_stats[TUKTEST_FAIL] > 0,
                    TUKTEST_COLOR_FAIL),
                tuktest_stats[TUKTEST_FAIL],
                TUKTEST_COLOR_IF(
                    tuktest_stats[TUKTEST_ERROR] > 0,
                    TUKTEST_COLOR_ERROR),
                tuktest_stats[TUKTEST_ERROR]);
 
    tuktest_catch_stdout_errors();
 
    if (tuktest_stats[TUKTEST_ERROR] > 0)
        return TUKTEST_EXIT_ERROR;
 
    if (tuktest_stats[TUKTEST_FAIL] > 0)
        return TUKTEST_EXIT_FAIL;
 
    if (tuktest_stats[TUKTEST_SKIP] > 0 || total_tests == 0)
        return TUKTEST_EXIT_SKIP;
 
    return TUKTEST_EXIT_PASS;
#endif
}
 
 
#define tuktest_run(testfunc) \
    tuktest_run_test(&(testfunc), #testfunc)
 
tuktest_maybe_unused
static void
tuktest_run_test(void (*testfunc)(void), const char *testfunc_str)
{
    // If any command line arguments were given, only the test functions
    // named on the command line will be run.
    if (tuktest_argc > 1) {
        int i = 1;
        while (strcmp(tuktest_argv[i], testfunc_str) != 0)
            if (++i == tuktest_argc)
                return;
    }
 
    // This is set so that failed assertions can print the correct
    // test name even when the assertion is in a helper function
    // called by the test function.
    tuktest_name = testfunc_str;
 
    // The way setjmp() may be called is very restrictive.
    // A switch statement is one of the few conforming ways
    // to get the value passed to longjmp(); doing something
    // like "int x = setjmp(env)" is NOT allowed (undefined behavior).
    switch (setjmp(tuktest_jmpenv)) {
        case 0:
            testfunc();
            ++tuktest_stats[TUKTEST_PASS];
            if (!TUKTEST_QUIET)
                printf(TUKTEST_STR_PASS " %s\n", tuktest_name);
            break;
 
        case TUKTEST_FAIL:
            ++tuktest_stats[TUKTEST_FAIL];
            break;
 
        case TUKTEST_SKIP:
            ++tuktest_stats[TUKTEST_SKIP];
            break;
 
        default:
            ++tuktest_stats[TUKTEST_ERROR];
            exit(tuktest_end());
    }
 
    tuktest_free_all(&tuktest_malloc_test);
    tuktest_name = NULL;
}
 
 
// Maximum allowed file size in tuktest_file_from_* macros and functions.
#ifndef TUKTEST_FILE_SIZE_MAX
#   define TUKTEST_FILE_SIZE_MAX (64L << 20)
#endif
 
#define tuktest_file_from_srcdir(filename, sizeptr) \
    tuktest_file_from_x(getenv("srcdir"), filename, sizeptr, \
            __FILE__, __LINE__)
 
#define tuktest_file_from_builddir(filename, sizeptr) \
    tuktest_file_from_x(NULL, filename, sizeptr, __FILE__, __LINE__)
 
// Internal helper for the macros above.
tuktest_maybe_unused
static void *
tuktest_file_from_x(const char *prefix, const char *filename, size_t *size,
        const char *prog_filename, unsigned prog_line)
{
    // If needed: buffer for holding prefix + '/' + filename + '\0'.
    char *alloc_name = NULL;
 
    // Buffer for the data read from the file.
    void *buf = NULL;
 
    // File being read
    FILE *f = NULL;
 
    // Error message to use under the "error:" label.
    const char *error_msg = NULL;
 
    if (filename == NULL) {
        error_msg = "Filename is NULL";
        filename = "(NULL)";
        goto error;
    }
 
    if (filename[0] == '\0') {
        error_msg = "Filename is an empty string";
        filename = "(empty string)";
        goto error;
    }
 
    if (size == NULL) {
        error_msg = "The size argument is NULL";
        goto error;
    }
 
    // If a prefix was given, construct the full filename.
    if (prefix != NULL && prefix[0] != '\0') {
        const size_t prefix_len = strlen(prefix);
        const size_t filename_len = strlen(filename);
 
        const size_t alloc_name_size
                = prefix_len + 1 + filename_len + 1;
        alloc_name = tuktest_malloc_impl(alloc_name_size,
                prog_filename, prog_line);
 
        memcpy(alloc_name, prefix, prefix_len);
        alloc_name[prefix_len] = '/';
        memcpy(alloc_name + prefix_len + 1, filename, filename_len);
        alloc_name[prefix_len + 1 + filename_len] = '\0';
 
        // Set filename to point to the new string. alloc_name
        // can be freed unconditionally as it is NULL if a prefix
        // wasn't specified.
        filename = alloc_name;
    }
 
    f = fopen(filename, "rb");
    if (f == NULL) {
        error_msg = "Failed to open the file";
        goto error;
    }
 
    // Get the size of the file and store it in *size.
    //
    // We assume that the file isn't big and even reject very big files.
    // There is no need to use fseeko/ftello from POSIX to support
    // large files. Using standard C functions is portable outside POSIX.
    if (fseek(f, 0, SEEK_END) != 0) {
        error_msg = "Seeking failed (fseek end)";
        goto error;
    }
 
    const long end = ftell(f);
    if (end < 0) {
        error_msg = "Seeking failed (ftell)";
        goto error;
    }
 
    if (end == 0) {
        error_msg = "File is empty";
        goto error;
    }
 
    if (end > TUKTEST_FILE_SIZE_MAX) {
        error_msg = "File size exceeds TUKTEST_FILE_SIZE_MAX";
        goto error;
    }
 
    *size = (size_t)end;
    rewind(f);
 
    buf = tuktest_malloc_impl(*size, prog_filename, prog_line);
 
    const size_t amount = fread(buf, 1, *size, f);
    if (ferror(f)) {
        error_msg = "Read error";
        goto error;
    }
 
    if (amount != *size) {
        error_msg = "File is smaller than indicated by ftell()";
        goto error;
    }
 
    const int fclose_ret = fclose(f);
    f = NULL;
    if (fclose_ret != 0) {
        error_msg = "Error closing the file";
        goto error;
    }
 
    tuktest_free(alloc_name);
    return buf;
 
error:
    if (f != NULL)
        (void)fclose(f);
 
    tuktest_error_impl(prog_filename, prog_line,
            "tuktest_file_from_x: %s: %s\n", filename, error_msg);
}
 
 
// Internal helper for assert_fail, assert_skip, and assert_error.
#define tuktest_print_and_jump(result, ...) \
do { \
    tuktest_print_result_prefix(result, __FILE__, __LINE__); \
    printf(__VA_ARGS__); \
    printf("\n"); \
    longjmp(tuktest_jmpenv, result); \
} while (0)
 
 
#define assert_fail(...) tuktest_print_and_jump(TUKTEST_FAIL, __VA_ARGS__)
 
 
#define assert_skip(...) tuktest_print_and_jump(TUKTEST_SKIP, __VA_ARGS__)
 
 
#define assert_error(...) tuktest_print_and_jump(TUKTEST_ERROR, __VA_ARGS__)
 
 
#define assert_false(test_expr) \
do { \
    if (test_expr) \
        assert_fail("assert_fail: '%s' is true but should be false", \
                #test_expr); \
} while (0)
 
 
#define assert_true(test_expr) \
do { \
    if (!(test_expr)) \
        assert_fail("assert_true: '%s' is false but should be true", \
                #test_expr); \
} while (0)
 
 
#define assert_int(test_expr, cmp_op, ref_value) \
do { \
    const tuktest_int v_test_ = (test_expr); \
    const tuktest_int v_ref_ = (ref_value); \
    if (!(v_test_ cmp_op v_ref_)) \
        assert_fail("assert_int: '%s == %" TUKTEST_PRId \
                "' but expected '... %s %" TUKTEST_PRId "'", \
                #test_expr, v_test_, #cmp_op, v_ref_); \
} while (0)
 
 
#define assert_uint(test_expr, cmp_op, ref_value) \
do { \
    const tuktest_uint v_test_ = (test_expr); \
    const tuktest_uint v_ref_ = (ref_value); \
    if (!(v_test_ cmp_op v_ref_)) \
        assert_fail("assert_uint: '%s == %" TUKTEST_PRIu \
                "' but expected '... %s %" TUKTEST_PRIu "'", \
                #test_expr, v_test_, #cmp_op, v_ref_); \
} while (0)
 
 
#define assert_int_eq(test_expr, ref_value) \
    assert_int(test_expr, ==, ref_value)
 
 
#define assert_uint_eq(test_expr, ref_value) \
    assert_uint(test_expr, ==, ref_value)
 
 
#define assert_enum_eq(test_expr, ref_value, enum_strings) \
do { \
    const tuktest_int v_test_ = (test_expr); \
    const tuktest_int v_ref_ = (ref_value); \
    if (v_test_ != v_ref_) { \
        const int array_len_ = (int)(sizeof(enum_strings) \
                / sizeof((enum_strings)[0])); \
        if (v_ref_ < 0 || v_ref_ >= array_len_) \
            assert_fail("assert_enum_eq: '%s == %" TUKTEST_PRId \
                    "' but expected " \
                    "'... == %" TUKTEST_PRId "'", \
                    #test_expr, v_test_, v_ref_); \
        else if (v_test_ < 0 || v_test_ >= array_len_) \
            assert_fail("assert_enum_eq: '%s == %" TUKTEST_PRId \
                    "' but expected '... == %s'", \
                    #test_expr, v_test_, \
                    (enum_strings)[v_ref_]); \
        else \
            assert_fail("assert_enum_eq: '%s == %s' " \
                    "but expected '... = %s'", \
                    #test_expr, (enum_strings)[v_test_], \
                    (enum_strings)[v_ref_]); \
    } \
} while (0)
 
 
#define assert_bit_set(test_expr, bit) \
do { \
    const tuktest_uint v_test_ = (test_expr); \
    const unsigned v_bit_ = (bit); \
    const tuktest_uint v_mask_ = (tuktest_uint)1 << v_bit_; \
    if (!(v_test_ & v_mask_)) \
        assert_fail("assert_bit_set: '%s == 0x%" TUKTEST_PRIX \
                "' but bit %u (0x%" TUKTEST_PRIX ") " \
                "is not set", \
                #test_expr, v_test_, v_bit_, v_mask_); \
} while (0)
 
 
#define assert_bit_not_set(test_expr, bit) \
do { \
    const tuktest_uint v_test_ = (test_expr); \
    const unsigned v_bit_ = (bit); \
    const tuktest_uint v_mask_ = (tuktest_uint)1 << v_bit_; \
    if (v_test_ & v_mask_) \
        assert_fail("assert_bit_not_set: '%s == 0x%" TUKTEST_PRIX \
                "' but bit %u (0x%" TUKTEST_PRIX ") is set", \
                #test_expr, v_test_, v_bit_, v_mask_); \
} while (0)
 
 
#define assert_bitmask_set(test_expr, mask) \
do { \
    const tuktest_uint v_mask_ = (mask); \
    const tuktest_uint v_test_ = (test_expr) & v_mask_; \
    if (v_test_ != v_mask_) \
        assert_fail("assert_bitmask_set: " \
                "'((%s) & 0x%" TUKTEST_PRIX ") == " \
                "0x%" TUKTEST_PRIX "' but expected " \
                "'... == 0x%" TUKTEST_PRIX "'", \
                #test_expr, v_mask_, v_test_, v_mask_); \
} while (0)
 
 
#define assert_bitmask_not_set(test_expr, mask) \
do { \
    const tuktest_uint v_mask_ = (mask); \
    const tuktest_uint v_test_ = (test_expr) & v_mask_; \
    if (v_test_ != 0) \
        assert_fail("assert_bitmask_not_set: "\
                "'((%s) & 0x%" TUKTEST_PRIX ") == " \
                "0x%" TUKTEST_PRIX "' but expected " \
                "'... == 0'", \
                #test_expr, v_mask_, v_test_); \
} while (0)
 
 
// Internal helper to add common code for string assertions.
#define tuktest_str_helper1(macro_name, test_expr, ref_value) \
    const char *v_test_ = (test_expr); \
    const char *v_ref_ = (ref_value); \
    if (v_test_ == NULL) \
        assert_fail(macro_name ": Test expression '%s' is NULL", \
                #test_expr); \
    if (v_ref_ == NULL) \
        assert_fail(macro_name ": Reference value '%s' is NULL", \
                #ref_value)
 
 
// Internal helper to add common code for string assertions and to check
// that the reference value isn't an empty string.
#define tuktest_str_helper2(macro_name, test_expr, ref_value) \
    tuktest_str_helper1(macro_name, test_expr, ref_value); \
    if (v_ref_[0] == '\0') \
        assert_fail(macro_name ": Reference value is an empty string")
 
 
#define assert_str_eq(test_expr, ref_value) \
do { \
    tuktest_str_helper1("assert_str_eq", test_expr, ref_value); \
    if (strcmp(v_ref_, v_test_) != 0) \
        assert_fail("assert_str_eq: '%s' evaluated to '%s' " \
                "but expected '%s'", \
                #test_expr, v_test_, v_ref_); \
} while (0)
 
 
#define assert_str_contains(test_expr, ref_value) \
do { \
    tuktest_str_helper2("assert_str_contains", test_expr, ref_value); \
    if (strstr(v_test_, v_ref_) == NULL) \
        assert_fail("assert_str_contains: '%s' evaluated to '%s' " \
                "which doesn't contain '%s'", \
                #test_expr, v_test_, v_ref_); \
} while (0)
 
 
#define assert_str_doesnt_contain(test_expr, ref_value) \
do { \
    tuktest_str_helper2("assert_str_doesnt_contain", \
            test_expr, ref_value); \
    if (strstr(v_test_, v_ref_) != NULL) \
        assert_fail("assert_str_doesnt_contain: " \
                "'%s' evaluated to '%s' which contains '%s'", \
                #test_expr, v_test_, v_ref_); \
} while (0)
 
 
#define assert_array_eq(test_array, correct_array, array_size) \
do { \
    for (size_t i_ = 0; i_ < (array_size); ++i_) \
        if ((test_array)[i_] != (correct_array)[i_]) \
            assert_fail("assert_array_eq: " \
                    "%s[%" TUKTEST_PRIu "] != "\
                    "%s[%" TUKTEST_PRIu "] " \
                    "but should be equal", \
                    #test_array, (tuktest_uint)i_, \
                    #correct_array, (tuktest_uint)i_); \
} while (0)
 
#endif