unit_testing.c

Go to the documentation of this file.

// Copyright (C) 2023 Ethan Uppal. All rights reserved.
 
#include <stdio.h>       // FILE, fopen, fprintf, fclose, fflush
#include <libgen.h>      // basename
#include <stdlib.h>      // exit
#include <stdarg.h>      // va_list, va_start, va_end
#include <string.h>      // snprintf
#include <stdbool.h>     // bool
#include "unit_testing.h"
#include "util/abort.h"  // ps_abort
 
// The name of the file being tested
STR _ps_this_file;
 
// The name of the file to write the report to
static char UNIT_TEST_RESULTS_FILE[100];
 
// Whether or not the output is surpressed
bool is_surpressed = false;
 
// Whether or not a test failed during surpression
bool surpressed_gave_error = false;
 
// The file to write the report to
static FILE* _ps_unit_test_file = NULL;
 
// The status of the unit tests
// 0 = successful
// 1 = failure
static int status = 0;
 
void _PS_BEGIN_UNIT_TESTS(STR file) {
    // Create the report filename
    _ps_this_file = basename((char*)file);  // idk if this cast is bad
    snprintf(UNIT_TEST_RESULTS_FILE, sizeof(UNIT_TEST_RESULTS_FILE),
        "tests/reports/%s report.txt", _ps_this_file);
 
    // Create the report file
    _ps_unit_test_file = fopen(UNIT_TEST_RESULTS_FILE, "w");
    if (!_ps_unit_test_file) {
        ps_abort("failed to create unit test report file.");
    }
 
    // Write the header
    if (fprintf(_ps_unit_test_file, "🤔 Unit test report for %s\n",
            _ps_this_file)
        < 0) {
        ps_abort("failed to write to unit test report file.");
    }
    fflush(_ps_unit_test_file);
 
    // Register the exit handler
    atexit(PS_END_UNIT_TESTS);
}
 
void PS_END_UNIT_TESTS(void) {
    // Write the footer
    fprintf(_ps_unit_test_file, "🫡 Unit test report for %s: %s\n",
        _ps_this_file, status ? "FAILED" : "PASSED");
 
    // Close the report file
    if (fclose(_ps_unit_test_file) != 0) {
        ps_abort("failed to close unit test report file.");
    }
 
    // Exit with the status
    ps_exit(status);
}
 
void _PS_UNIT_ASSERT(int result, STR expr, STR func, u64 line, STR msg, ...) {
    if (!is_surpressed) {
        // Print the result of the test
        fprintf(_ps_unit_test_file, "%s %s:%llu:%s: %s\n", result ? "✅" : "❌",
            _ps_this_file, line, func, expr);
 
        // Optionally print the message for the test
        if (*msg) {
            fputc('\t', _ps_unit_test_file);
            va_list args;
            va_start(args, msg);
            vfprintf(_ps_unit_test_file, msg, args);
            va_end(args);
            fputc('\n', _ps_unit_test_file);
        }
 
        // Force the report file to update
        fflush(_ps_unit_test_file);
    }
 
    if (!result) {
        status = 1;
 
        if (is_surpressed) {
            // Surpressed tests should only print their first error
            if (!surpressed_gave_error) {
                fprintf(_ps_unit_test_file,
                    "❌ %s:%llu:%s: %s\n\tAn error occured "
                    "while surpressed\n",
                    _ps_this_file, line, func, expr);
 
                // Force the report file to update
                fflush(_ps_unit_test_file);
            }
            surpressed_gave_error = true;
        }
    }
}
 
void _PS_UNIT_SUPPRESS(STR msg, STR func, u64 line) {
    if (!is_surpressed) {
        fprintf(_ps_unit_test_file, "🤫 %s:%llu:%s: Output surpressed:\n\t%s\n",
            _ps_this_file, line, func, msg);
        fflush(_ps_unit_test_file);
    }
    is_surpressed = true;
    surpressed_gave_error = false;
}
 
void PS_UNIT_UNSUPPRESS(void) {
    if (is_surpressed) {
        fprintf(_ps_unit_test_file, "🗣️ %s: Output unsurpressed: %s\n",
            _ps_this_file,
            surpressed_gave_error ? "A failure occured" : "No failure occured");
        fflush(_ps_unit_test_file);
    }
    is_surpressed = false;
}