pico_unit.h

Go to the documentation of this file.

 
#ifndef PICO_UNIT_H
#define PICO_UNIT_H
 
#include <stdbool.h> /* bool, true, false */
#include <stddef.h>  /* NULL */
#include <string.h>  /* strcmp */
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define TEST_CASE(name) static bool name(void)
 
#define REQUIRE(expr) \
    do { \
        if (!pu_require((expr) ? true : false, (#expr), __FILE__, __LINE__, \
                        NULL)) \
            return false; \
    } while(false)
 
#define RUN_TEST_CASE(test_fp) (pu_run_test(#test_fp, test_fp))
 
#define TEST_SUITE(name) void name(void)
 
#define RUN_TEST_SUITE(suite_fp) pu_run_suite(#suite_fp, suite_fp)
 
typedef void (*pu_setup_fn)(void);
 
void pu_setup(pu_setup_fn setup_fp, pu_setup_fn teardown_fp);
 
void pu_clear_setup(void);
 
void pu_display_colors(bool enabled);
 
void pu_display_time(bool enabled);
 
void pu_display_quiet(bool enabled);
 
bool pu_is_quiet(void);
 
void pu_print_stats(void);
 
bool pu_test_failed(void);
 
/*
 * WARNING: These functions are not meant to be called directly. Use the macros
 * instead.
 */
typedef bool (*pu_test_fn)(void);
typedef void (*pu_suite_fn)(void);
 
bool pu_require(bool passed,
                const char* const expr,
                const char* const file,
                int line,
                const char* const fmt, ...);
 
void pu_run_test(const char* const name, pu_test_fn test_fp);
 
void pu_run_suite(const char* const name, pu_suite_fn suite_fp);
 
#ifdef __cplusplus
}
#endif
 
#endif // PICO_UNIT_H
 
#ifdef PICO_UNIT_IMPLEMENTATION
 
#include <stdarg.h> /* va_list, va_start, va_end */
#include <stdio.h>  /* printf, fprintf, vfprintf */
 
#ifndef PICO_UNIT_NO_CLOCK
#include <time.h>  /* clock_t, clock */
#endif // PICO_UNIT_NO_CLOCK
 
#define TERM_COLOR_CODE   0x1B
#define TERM_COLOR_RED   "[1;31m"
#define TERM_COLOR_GREEN "[1;32m"
#define TERM_COLOR_BOLD  "[1m"
#define TERM_COLOR_RESET "[0m"
 
static unsigned pu_num_asserts  = 0;
static unsigned pu_num_passed   = 0;
static unsigned pu_num_failed   = 0;
static unsigned pu_num_suites   = 0;
static bool     pu_colors       = false;
static bool     pu_time         = false;
static bool     pu_quiet        = false;
 
static pu_setup_fn pu_setup_fp    = NULL;
static pu_setup_fn pu_teardown_fp = NULL;
 
#define pu_quiet_printf(...)      \
    do {                          \
        if (!pu_quiet)            \
        {                         \
            printf(__VA_ARGS__);  \
        }                         \
    } while(0)
 
void
pu_setup (pu_setup_fn fp_setup, pu_setup_fn fp_teardown)
{
    pu_setup_fp = fp_setup;
    pu_teardown_fp = fp_teardown;
}
 
void
pu_clear_setup (void)
{
    pu_setup_fp = NULL;
    pu_teardown_fp = NULL;
}
 
void
pu_display_colors (bool enabled)
{
    pu_colors = enabled;
}
 
void
pu_display_time (bool enabled)
{
    pu_time = enabled;
}
 
void
pu_display_quiet (bool enabled)
{
    pu_quiet = enabled;
}
 
bool
pu_is_quiet (void)
{
    return pu_quiet;
}
 
bool
pu_test_failed(void)
{
    return (pu_num_failed != 0);
}
 
bool
pu_require(bool passed, 
           const char* const expr, 
           const char* const file, 
           int line, 
           const char* const fmt, ...)
{
    pu_num_asserts++;
 
    if (passed)
    {
        return true;
    }
 
    if (pu_colors)
    {
        fprintf(stderr, "(%c%sFAILED%c%s: %s (%d): %s)\n",
                TERM_COLOR_CODE, TERM_COLOR_RED,
                TERM_COLOR_CODE, TERM_COLOR_RESET,
                file, line, expr);
    }
    else
    {
        fprintf(stderr, "(FAILED: %s (%d): %s)\n", file, line, expr);
    }
 
    if (fmt)
    {
        va_list args;
        va_start(args, fmt);
        fprintf(stderr, "  note: ");
        vfprintf(stderr, fmt, args);
        fprintf(stderr, "\n");
        va_end(args);
    }
 
    return false;
}
 
void
pu_run_test (const char* const name, pu_test_fn test_fp)
{
    if (NULL != pu_setup_fp)
    {
        pu_setup_fp();
    }
 
    pu_quiet_printf("Running: %s ", name);
 
    #ifndef PICO_UNIT_NO_CLOCK
 
    clock_t start_time = 0;
    clock_t end_time = 0;
 
    if (pu_time)
    {
        start_time = clock();
    }
 
    #endif // PICO_UNIT_NO_CLOCK
 
    if (!test_fp())
    {
        pu_num_failed++;
 
        pu_quiet_printf("\n");
 
        if (NULL != pu_teardown_fp)
        {
            pu_teardown_fp();
        }
 
        return;
    }
 
    #ifndef PICO_UNIT_NO_CLOCK
 
    if (pu_time)
    {
        end_time = clock();
    }
 
    #endif // PICO_UNIT_NO_CLOCK
 
    if (pu_colors)
    {
        pu_quiet_printf("(%c%sOK%c%s)", TERM_COLOR_CODE, TERM_COLOR_GREEN,
                                        TERM_COLOR_CODE, TERM_COLOR_RESET);
    }
    else
    {
        pu_quiet_printf("(OK)");
    }
 
    #ifndef PICO_UNIT_NO_CLOCK
 
    if (pu_time)
    {
        pu_quiet_printf(" (%f secs)", (double)(end_time - start_time) / CLOCKS_PER_SEC);
    }
 
    #endif // PICO_UNIT_NO_CLOCK
 
    pu_quiet_printf("\n");
 
    pu_num_passed++;
 
    if (NULL != pu_teardown_fp)
    {
        pu_teardown_fp();
    }
}
 
void
pu_run_suite (const char* const name, pu_suite_fn suite_fp)
{
    pu_quiet_printf("===============================================================\n");
 
    if (pu_colors)
    {
        pu_quiet_printf("%c%sRunning: %s%c%s\n", TERM_COLOR_CODE, TERM_COLOR_BOLD,
                                                 name,
                                                 TERM_COLOR_CODE, TERM_COLOR_RESET);
    }
    else
    {
        pu_quiet_printf("Running: %s\n", name);
    }
 
    pu_quiet_printf("---------------------------------------------------------------\n");
 
    suite_fp();
    pu_num_suites++;
}
 
void
pu_print_stats (void)
{
    pu_quiet_printf("===============================================================\n");
        
    if (pu_colors)
    {
        pu_quiet_printf("Summary: Passed: %c%s%u%c%s "
                        "Failed: %c%s%u%c%s "
                        "Total: %u Suites: %u "
                        "Asserts: %u\n",
                        TERM_COLOR_CODE, TERM_COLOR_GREEN, pu_num_passed,
                        TERM_COLOR_CODE, TERM_COLOR_RESET,
                        TERM_COLOR_CODE, TERM_COLOR_RED, pu_num_failed,
                        TERM_COLOR_CODE, TERM_COLOR_RESET,
                        pu_num_passed + pu_num_failed,
                        pu_num_suites,  pu_num_asserts);
    }
    else
    {
        pu_quiet_printf("Summary: Passed: %u "
                        "Failed: %u "
                        "Total: %u Suites: %u "
                        "Asserts: %u\n",
                        pu_num_passed,
                        pu_num_failed,
                        pu_num_passed + pu_num_failed,
                        pu_num_suites,  pu_num_asserts);
    }
}
 
 
#endif // PICO_UNIT_IMPLEMENTATION
 
/*
    ----------------------------------------------------------------------------
    This software is available under two licenses (A) or (B). You may choose
    either one as you wish:
    ----------------------------------------------------------------------------
 
    (A) The zlib License
 
    Copyright (c) 2021 James McLean
 
    This software is provided 'as-is', without any express or implied warranty.
    In no event will the authors be held liable for any damages arising from the
    use of this software.
 
    Permission is granted to anyone to use this software for any purpose,
    including commercial applications, and to alter it and redistribute it
    freely, subject to the following restrictions:
 
    1. The origin of this software must not be misrepresented; you must not
    claim that you wrote the original software. If you use this software in a
    product, an acknowledgment in the product documentation would be appreciated
    but is not required.
 
    2. Altered source versions must be plainly marked as such, and must not be
    misrepresented as being the original software.
 
    3. This notice may not be removed or altered from any source distribution.
 
    ----------------------------------------------------------------------------
 
    (B) Public Domain (www.unlicense.org)
 
    This is free and unencumbered software released into the public domain.
 
    Anyone is free to copy, modify, publish, use, compile, sell, or distribute
    this software, either in source code form or as a compiled binary, for any
    purpose, commercial or non-commercial, and by any means.
 
    In jurisdictions that recognize copyright laws, the author or authors of
    this software dedicate any and all copyright interest in the software to the
    public domain. We make this dedication for the benefit of the public at
    large and to the detriment of our heirs and successors. We intend this
    dedication to be an overt act of relinquishment in perpetuity of all present
    and future rights to this software under copyright law.
 
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
    ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
 
// EoF