acutest.h

Go to the documentation of this file.

/*
 * Acutest -- Another C/C++ Unit Test facility
 * <https://github.com/mity/acutest>
 *
 * Copyright 2013-2023 Martin Mitáš
 * Copyright 2019 Garrett D'Amore
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * 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 OR COPYRIGHT HOLDERS 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.
 */
 
#ifndef ACUTEST_H
#define ACUTEST_H
 
 
/* Try to auto-detect whether we need to disable C++ exception handling.
 * If the detection fails, you may always define TEST_NO_EXCEPTIONS before
 * including "acutest.h" manually. */
#ifdef __cplusplus
    #if (__cplusplus >= 199711L && !defined __cpp_exceptions)  ||            \
        ((defined(__GNUC__) || defined(__clang__)) && !defined __EXCEPTIONS)
        #ifndef TEST_NO_EXCEPTIONS
            #define TEST_NO_EXCEPTIONS
        #endif
    #endif
#endif
 
 
/************************
 *** Public interface ***
 ************************/
 
/* By default, "acutest.h" provides the main program entry point (function
 * main()). However, if the test suite is composed of multiple source files
 * which include "acutest.h", then this causes a problem of multiple main()
 * definitions. To avoid this problem, #define macro TEST_NO_MAIN in all
 * compilation units but one.
 */
 
/* Macro to specify list of unit tests in the suite.
 * The unit test implementation MUST provide list of unit tests it implements
 * with this macro:
 *
 *   TEST_LIST = {
 *       { "test1_name", test1_func_ptr },
 *       { "test2_name", test2_func_ptr },
 *       ...
 *       { NULL, NULL }     // zeroed record marking the end of the list
 *   };
 *
 * The list specifies names of each test (must be unique) and pointer to
 * a function implementing it. The function does not take any arguments
 * and has no return values, i.e. every test function has to be compatible
 * with this prototype:
 *
 *   void test_func(void);
 *
 * Note the list has to be ended with a zeroed record.
 */
#define TEST_LIST               const struct acutest_test_ acutest_list_[]
 
#define TEST_TERMINATOR { .name = NULL }
 
 
/* Macros for testing whether an unit test succeeds or fails. These macros
 * can be used arbitrarily in functions implementing the unit tests.
 *
 * If any condition fails throughout execution of a test, the test fails.
 *
 * TEST_CHECK takes only one argument (the condition), TEST_CHECK_ allows
 * also to specify an error message to print out if the condition fails.
 * (It expects printf-like format string and its parameters). The macros
 * return non-zero (condition passes) or 0 (condition fails).
 *
 * That can be useful when more conditions should be checked only if some
 * preceding condition passes, as illustrated in this code snippet:
 *
 *   SomeStruct* ptr = allocate_some_struct();
 *   if(TEST_CHECK(ptr != NULL)) {
 *       TEST_CHECK(ptr->member1 < 100);
 *       TEST_CHECK(ptr->member2 > 200);
 *   }
 */
#define TEST_CHECK_(cond,...)                                                  \
    acutest_check_(!!(cond), __FILE__, __LINE__, __VA_ARGS__)
#define TEST_CHECK(cond)                                                       \
    acutest_check_(!!(cond), __FILE__, __LINE__, "%s", #cond)
 
 
/* These macros are the same as TEST_CHECK_ and TEST_CHECK except that if the
 * condition fails, the currently executed unit test is immediately aborted.
 *
 * That is done either by calling abort() if the unit test is executed as a
 * child process; or via longjmp() if the unit test is executed within the
 * main Acutest process.
 *
 * As a side effect of such abortion, your unit tests may cause memory leaks,
 * unflushed file descriptors, and other phenomena caused by the abortion.
 *
 * Therefore you should not use these as a general replacement for TEST_CHECK.
 * Use it with some caution, especially if your test causes some other side
 * effects to the outside world (e.g. communicating with some server, inserting
 * into a database etc.).
 */
#define TEST_ASSERT_(cond,...)                                                 \
    do {                                                                       \
        if(!acutest_check_(!!(cond), __FILE__, __LINE__, __VA_ARGS__))         \
            acutest_abort_();                                                  \
    } while(0)
#define TEST_ASSERT(cond)                                                      \
    do {                                                                       \
        if(!acutest_check_(!!(cond), __FILE__, __LINE__, "%s", #cond))         \
            acutest_abort_();                                                  \
    } while(0)
 
 
#ifdef __cplusplus
#ifndef TEST_NO_EXCEPTIONS
/* Macros to verify that the code (the 1st argument) throws exception of given
 * type (the 2nd argument). (Note these macros are only available in C++.)
 *
 * TEST_EXCEPTION_ is like TEST_EXCEPTION but accepts custom printf-like
 * message.
 *
 * For example:
 *
 *   TEST_EXCEPTION(function_that_throw(), ExpectedExceptionType);
 *
 * If the function_that_throw() throws ExpectedExceptionType, the check passes.
 * If the function throws anything incompatible with ExpectedExceptionType
 * (or if it does not thrown an exception at all), the check fails.
 */
#define TEST_EXCEPTION(code, exctype)                                          \
    do {                                                                       \
        bool exc_ok_ = false;                                                  \
        const char *msg_ = NULL;                                               \
        try {                                                                  \
            code;                                                              \
            msg_ = "No exception thrown.";                                     \
        } catch(exctype const&) {                                              \
            exc_ok_= true;                                                     \
        } catch(...) {                                                         \
            msg_ = "Unexpected exception thrown.";                             \
        }                                                                      \
        acutest_check_(exc_ok_, __FILE__, __LINE__, #code " throws " #exctype);\
        if(msg_ != NULL)                                                       \
            acutest_message_(false, "%s", msg_);                                      \
    } while(0)
#define TEST_EXCEPTION_(code, exctype, ...)                                    \
    do {                                                                       \
        bool exc_ok_ = false;                                                  \
        const char *msg_ = NULL;                                               \
        try {                                                                  \
            code;                                                              \
            msg_ = "No exception thrown.";                                     \
        } catch(exctype const&) {                                              \
            exc_ok_= true;                                                     \
        } catch(...) {                                                         \
            msg_ = "Unexpected exception thrown.";                             \
        }                                                                      \
        acutest_check_(exc_ok_, __FILE__, __LINE__, __VA_ARGS__);              \
        if(msg_ != NULL)                                                       \
            acutest_message_(false, "%s", msg_);                                      \
    } while(0)
#endif  /* #ifndef TEST_NO_EXCEPTIONS */
#endif  /* #ifdef __cplusplus */
 
 
/* Sometimes it is useful to split execution of more complex unit tests to some
 * smaller parts and associate those parts with some names.
 *
 * This is especially handy if the given unit test is implemented as a loop
 * over some vector of multiple testing inputs. Using these macros allow to use
 * sort of subtitle for each iteration of the loop (e.g. outputting the input
 * itself or a name associated to it), so that if any TEST_CHECK condition
 * fails in the loop, it can be easily seen which iteration triggers the
 * failure, without the need to manually output the iteration-specific data in
 * every single TEST_CHECK inside the loop body.
 *
 * TEST_CASE allows to specify only single string as the name of the case,
 * TEST_CASE_ provides all the power of printf-like string formatting.
 *
 * Note that the test cases cannot be nested. Starting a new test case ends
 * implicitly the previous one. To end the test case explicitly (e.g. to end
 * the last test case after exiting the loop), you may use TEST_CASE(NULL).
 */
#define TEST_CASE_(...)         acutest_case_(__VA_ARGS__)
#define TEST_CASE(name)         acutest_case_("%s", name)
 
 
/* Maximal output per TEST_CASE call. Longer messages are cut.
 * You may define another limit prior including "acutest.h"
 */
#ifndef TEST_CASE_MAXSIZE
    #define TEST_CASE_MAXSIZE    64
#endif
 
/* printf-like macro for outputting an extra information about a failure.
 *
 * Intended use is to output some computed output versus the expected value,
 * e.g. like this:
 *
 *   if(!TEST_CHECK(produced == expected)) {
 *       TEST_MSG("Expected: %d", expected);
 *       TEST_MSG("Produced: %d", produced);
 *   }
 *
 * Note the message is only written down if the most recent use of any checking
 * macro (like e.g. TEST_CHECK or TEST_EXCEPTION) in the current test failed.
 * This means the above is equivalent to just this:
 *
 *   TEST_CHECK(produced == expected);
 *   TEST_MSG("Expected: %d", expected);
 *   TEST_MSG("Produced: %d", produced);
 *
 * The macro can deal with multi-line output fairly well. It also automatically
 * adds a final new-line if there is none present.
 */
#define TEST_MSG(...)           TEST_MSG_FAIL(__VA_ARGS__)
#define TEST_MSG_FAIL(...)      acutest_message_(false, __VA_ARGS__)
 
 
/* Alternative version of TEST_MSG which outputs regardless of the
 * failure status of the current test.
 */
#define TEST_MSG_ALWAYS(...)    acutest_message_(true, __VA_ARGS__)
 
/* Maximal output per TEST_MSG call. Longer messages are cut.
 * You may define another limit prior including "acutest.h"
 */
#ifndef TEST_MSG_MAXSIZE
    #define TEST_MSG_MAXSIZE    1024
#endif
 
 
/* Macro for dumping a block of memory.
 *
 * Its intended use is very similar to what TEST_MSG is for, but instead of
 * generating any printf-like message, this is for dumping raw block of a
 * memory in a hexadecimal form:
 *
 *   TEST_CHECK(size_produced == size_expected &&
 *              memcmp(addr_produced, addr_expected, size_produced) == 0);
 *   TEST_DUMP("Expected:", addr_expected, size_expected);
 *   TEST_DUMP("Produced:", addr_produced, size_produced);
 */
#define TEST_DUMP(title, addr, size)        TEST_DUMP_FAIL(title, addr, size)
#define TEST_DUMP_FAIL(title, addr, size)   acutest_dump_(false, title, addr, size);
 
/* Alternative version of TEST_DUMP which outputs regardless of the
 * failure status of the current test
 */
#define TEST_DUMP_ALWAYS(title, addr, size) acutest_dump_(true, title, addr, size);
 
/* Maximal output per TEST_DUMP call (in bytes to dump). Longer blocks are cut.
 * You may define another limit prior including "acutest.h"
 */
#ifndef TEST_DUMP_MAXSIZE
    #define TEST_DUMP_MAXSIZE   1024
#endif
 
/* Maximal size of log entries passed between child test processes and parent
 * process.  This allows for a memory block dump with a title up to TEST_MSG_MAXSIZE
 * in length, plus ": " separator and NULL terminator.  Longer messages cause an error.
 */
#define TEST_LOG_MAXSIZE ((TEST_DUMP_MAXSIZE * 3) + TEST_MSG_MAXSIZE + 3)
 
/* Macros for marking the test as SKIPPED.
 * Note it can only be used at the beginning of a test, before any other
 * checking.
 *
 * Once used, the best practice is to return from the test routine as soon
 * as possible.
 */
#define TEST_SKIP(...)         acutest_skip_(__FILE__, __LINE__, __VA_ARGS__)
 
 
/* Common test initialisation/clean-up
 *
 * In some test suites, it may be needed to perform some sort of the same
 * initialization and/or clean-up in all the tests.
 *
 * Such test suites may use macros TEST_INIT and/or TEST_FINI prior including
 * this header. The expansion of the macro is then used as a body of helper
 * function called just before executing every single (TEST_INIT) or just after
 * it ends (TEST_FINI).
 *
 * Examples of various ways how to use the macro TEST_INIT:
 *
 *   #define TEST_INIT      my_init_func();
 *   #define TEST_INIT      my_init_func()      // Works even without the semicolon
 *   #define TEST_INIT      setlocale(LC_ALL, NULL);
 *   #define TEST_INIT      { setlocale(LC_ALL, NULL); my_init_func(); }
 *
 * TEST_FINI is to be used in the same way.
 *
 * TEST_GLOBAL_INIT and TEST_GLOBAL_FINI (a FreeRADIUS addition) are used in
 * the same way, but each expands once per run, not once per test.
 * TEST_GLOBAL_INIT runs before the first test, in the process which forks the
 * tests, and every test inherits the state which TEST_GLOBAL_INIT sets up.
 * TEST_GLOBAL_FINI runs after the last test ends.
 */
 
 
/**********************
 *** Implementation ***
 **********************/
 
/* The unit test files should not rely on anything below. */
 
#include <stdbool.h>
#include <stdlib.h>
 
/* Enable the use of the non-standard keyword __attribute__ to silence warnings under some compilers */
#if defined(__GNUC__) || defined(__clang__)
    #define ACUTEST_ATTRIBUTE_(attr)    __attribute__((attr))
#else
    #define ACUTEST_ATTRIBUTE_(attr)
#endif
 
#ifdef __cplusplus
    extern "C" {
#endif
 
enum acutest_state_ : int8_t {
    ACUTEST_STATE_INITIAL = -4,
    ACUTEST_STATE_SELECTED = -3,
    ACUTEST_STATE_NEEDTORUN = -2,
 
    /* By the end all tests should be in one of the following: */
    ACUTEST_STATE_EXCLUDED = -1,
    ACUTEST_STATE_SUCCESS = 0,
    ACUTEST_STATE_FAILED = 1,
    ACUTEST_STATE_SKIPPED = 2
};
 
int acutest_check_(int cond, const char* file, int line, const char* fmt, ...);
void acutest_case_(const char* fmt, ...);
void acutest_skip_(const char* file, int line, const char* fmt, ...);
void acutest_log_(const char* fmt, ...);
void acutest_message_(bool always, const char* fmt, ...);
void acutest_dump_(bool always, const char* title, const void* addr, size_t size);
void acutest_abort_(void) ACUTEST_ATTRIBUTE_(noreturn);
#ifdef __cplusplus
    }  /* extern "C" */
#endif
 
#ifndef TEST_NO_MAIN
 
#include <ctype.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <setjmp.h>
 
#if defined(unix) || defined(__unix__) || defined(__unix) || defined(__APPLE__)
    #define ACUTEST_UNIX_       1
    #include <errno.h>
    #include <libgen.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <signal.h>
    #include <time.h>
 
    #if defined CLOCK_PROCESS_CPUTIME_ID  &&  defined CLOCK_MONOTONIC
        #define ACUTEST_HAS_POSIX_TIMER_    1
    #endif
#endif
 
#if defined(_gnu_linux_) || defined(__linux__)
    #define ACUTEST_LINUX_      1
    #include <fcntl.h>
    #include <sys/stat.h>
#endif
 
#if defined(_WIN32) || defined(__WIN32__) || defined(__WINDOWS__)
    #define ACUTEST_WIN_        1
    #include <windows.h>
    #include <io.h>
#endif
 
#if defined(__APPLE__)
    #define ACUTEST_MACOS_
    #include <assert.h>
    #include <stdbool.h>
    #include <sys/types.h>
    #include <unistd.h>
    #include <sys/sysctl.h>
#endif
 
#ifdef __cplusplus
#ifndef TEST_NO_EXCEPTIONS
    #include <exception>
#endif
#endif
 
#ifdef __has_include
    #if __has_include(<valgrind.h>)
        #include <valgrind.h>
    #endif
#endif
 
/* Note our global private identifiers end with '_' to mitigate risk of clash
 * with the unit tests implementation. */
 
#ifdef __cplusplus
    extern "C" {
#endif
 
#ifdef _MSC_VER
    /* In the multi-platform code like ours, we cannot use the non-standard
     * "safe" functions from Microsoft C lib like e.g. sprintf_s() instead of
     * standard sprintf(). Hence, lets disable the warning C4996. */
    #pragma warning(push)
    #pragma warning(disable: 4996)
#endif
 
 
struct acutest_test_ {
    const char* name;
    void (*func)(void);
};
 
typedef struct acutest_data_log_s_ acutest_data_log_;
 
struct acutest_data_log_s_ {
    char* msg;
    acutest_data_log_* next;
};
 
struct acutest_test_data_ {
    enum acutest_state_ state;
    double duration;
    acutest_data_log_* log_head;
    acutest_data_log_* log_tail;
};
 
 
extern const struct acutest_test_ acutest_list_[];
 
 
static char* acutest_argv0_ = NULL;
static int acutest_list_size_ = 0;
static struct acutest_test_data_* acutest_test_data_ = NULL;
static int acutest_no_exec_ = -1;
static int acutest_no_summary_ = 0;
static int acutest_tap_ = 0;
static int acutest_exclude_mode_ = 0;
static int acutest_worker_ = 0;
static int acutest_worker_index_ = 0;
static int acutest_cond_failed_ = 0;
static FILE *acutest_xml_output_ = NULL;
 
static const struct acutest_test_* acutest_current_test_ = NULL;
static int acutest_current_index_ = 0;
static char acutest_case_name_[TEST_CASE_MAXSIZE] = "";
static int acutest_test_check_count_ = 0;
static int acutest_test_skip_count_ = 0;
static char acutest_test_skip_reason_[256] = "";
static int acutest_test_already_logged_ = 0;
static int acutest_case_already_logged_ = 0;
static int acutest_verbose_level_ = 2;
static int acutest_test_failures_ = 0;
static int acutest_colorize_ = 0;
static int acutest_timer_ = 0;
 
static int acutest_abort_has_jmp_buf_ = 0;
static jmp_buf acutest_abort_jmp_buf_;
 
static int
acutest_count_(enum acutest_state_ state)
{
    int i, n;
 
    for(i = 0, n = 0; i < acutest_list_size_; i++) {
        if(acutest_test_data_[i].state == state)
            n++;
    }
 
    return n;
}
 
#if defined ACUTEST_WIN_
HANDLE hChildWrite = NULL;
#endif
 
static void
acutest_cleanup_(void)
{
    int i;
    acutest_data_log_* log_entry;
    acutest_data_log_* next;
 
    for (i = 0; i < acutest_list_size_; i++) {
        log_entry = acutest_test_data_[i].log_head;
        while (log_entry) {
            next = log_entry->next;
#if defined ACUTEST_WIN_
            if (hChildWrite) {
                if (!WriteFile(hChildWrite, log_entry->msg, (strlen(log_entry->msg) + 1) * sizeof(char), NULL, NULL))
                    fprintf(stderr, "Upable to write to pipe");
            }
#endif
            free(log_entry->msg);
            free(log_entry);
                log_entry = next;
        }
    }
    free((void*) acutest_test_data_);
}
 
static void ACUTEST_ATTRIBUTE_(noreturn)
acutest_exit_(int exit_code)
{
    acutest_cleanup_();
    exit(exit_code);
}
 
 
#if defined ACUTEST_WIN_
    typedef LARGE_INTEGER acutest_timer_type_;
    static LARGE_INTEGER acutest_timer_freq_;
    static acutest_timer_type_ acutest_timer_start_;
    static acutest_timer_type_ acutest_timer_end_;
 
    static void
    acutest_timer_init_(void)
    {
        QueryPerformanceFrequency(&acutest_timer_freq_);
    }
 
    static void
    acutest_timer_get_time_(LARGE_INTEGER* ts)
    {
        QueryPerformanceCounter(ts);
    }
 
    static double
    acutest_timer_diff_(LARGE_INTEGER start, LARGE_INTEGER end)
    {
        double duration = (double)(end.QuadPart - start.QuadPart);
        duration /= (double)acutest_timer_freq_.QuadPart;
        return duration;
    }
 
    static void
    acutest_timer_print_diff_(void)
    {
        printf("%.6lf secs", acutest_timer_diff_(acutest_timer_start_, acutest_timer_end_));
    }
#elif defined ACUTEST_HAS_POSIX_TIMER_
    static clockid_t acutest_timer_id_;
    typedef struct timespec acutest_timer_type_;
    static acutest_timer_type_ acutest_timer_start_;
    static acutest_timer_type_ acutest_timer_end_;
 
    static void
    acutest_timer_init_(void)
    {
        if(acutest_timer_ == 1)
            acutest_timer_id_ = CLOCK_MONOTONIC;
        else if(acutest_timer_ == 2)
            acutest_timer_id_ = CLOCK_PROCESS_CPUTIME_ID;
    }
 
    static void
    acutest_timer_get_time_(struct timespec* ts)
    {
        clock_gettime(acutest_timer_id_, ts);
    }
 
    static double
    acutest_timer_diff_(struct timespec start, struct timespec end)
    {
        return (double)(end.tv_sec - start.tv_sec) + (double)(end.tv_nsec - start.tv_nsec) / 1e9;
    }
 
    static void
    acutest_timer_print_diff_(void)
    {
        printf("%.6lf secs",
            acutest_timer_diff_(acutest_timer_start_, acutest_timer_end_));
    }
#else
    typedef int acutest_timer_type_;
    static acutest_timer_type_ acutest_timer_start_;
    static acutest_timer_type_ acutest_timer_end_;
 
    void
    acutest_timer_init_(void)
    {}
 
    static void
    acutest_timer_get_time_(int* ts)
    {
        (void) ts;
    }
 
    static double
    acutest_timer_diff_(int start, int end)
    {
        (void) start;
        (void) end;
        return 0.0;
    }
 
    static void
    acutest_timer_print_diff_(void)
    {}
#endif
 
#define ACUTEST_COLOR_DEFAULT_              0
#define ACUTEST_COLOR_RED_                  1
#define ACUTEST_COLOR_GREEN_                2
#define ACUTEST_COLOR_YELLOW_               3
#define ACUTEST_COLOR_DEFAULT_INTENSIVE_    10
#define ACUTEST_COLOR_RED_INTENSIVE_        11
#define ACUTEST_COLOR_GREEN_INTENSIVE_      12
#define ACUTEST_COLOR_YELLOW_INTENSIVE_     13
 
static int ACUTEST_ATTRIBUTE_(format (printf, 2, 3))
acutest_colored_printf_(int color, const char* fmt, ...)
{
    va_list args;
    char buffer[256];
    int n;
 
    va_start(args, fmt);
    vsnprintf(buffer, sizeof(buffer), fmt, args);
    va_end(args);
    buffer[sizeof(buffer)-1] = '\0';
 
    if(!acutest_colorize_) {
        return printf("%s", buffer);
    }
 
#if defined ACUTEST_UNIX_
    {
        const char* col_str;
        switch(color) {
            case ACUTEST_COLOR_RED_:                col_str = "\033[0;31m"; break;
            case ACUTEST_COLOR_GREEN_:              col_str = "\033[0;32m"; break;
            case ACUTEST_COLOR_YELLOW_:             col_str = "\033[0;33m"; break;
            case ACUTEST_COLOR_RED_INTENSIVE_:      col_str = "\033[1;31m"; break;
            case ACUTEST_COLOR_GREEN_INTENSIVE_:    col_str = "\033[1;32m"; break;
            case ACUTEST_COLOR_YELLOW_INTENSIVE_:   col_str = "\033[1;33m"; break;
            case ACUTEST_COLOR_DEFAULT_INTENSIVE_:  col_str = "\033[1m"; break;
            default:                                col_str = "\033[0m"; break;
        }
        printf("%s", col_str);
        n = printf("%s", buffer);
        printf("\033[0m");
        return n;
    }
#elif defined ACUTEST_WIN_
    {
        HANDLE h;
        CONSOLE_SCREEN_BUFFER_INFO info;
        WORD attr;
 
        h = GetStdHandle(STD_OUTPUT_HANDLE);
        GetConsoleScreenBufferInfo(h, &info);
 
        switch(color) {
            case ACUTEST_COLOR_RED_:                attr = FOREGROUND_RED; break;
            case ACUTEST_COLOR_GREEN_:              attr = FOREGROUND_GREEN; break;
            case ACUTEST_COLOR_YELLOW_:             attr = FOREGROUND_RED | FOREGROUND_GREEN; break;
            case ACUTEST_COLOR_RED_INTENSIVE_:      attr = FOREGROUND_RED | FOREGROUND_INTENSITY; break;
            case ACUTEST_COLOR_GREEN_INTENSIVE_:    attr = FOREGROUND_GREEN | FOREGROUND_INTENSITY; break;
            case ACUTEST_COLOR_DEFAULT_INTENSIVE_:  attr = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY; break;
            case ACUTEST_COLOR_YELLOW_INTENSIVE_:   attr = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY; break;
            default:                                attr = 0; break;
        }
        if(attr != 0)
            SetConsoleTextAttribute(h, attr);
        n = printf("%s", buffer);
        SetConsoleTextAttribute(h, info.wAttributes);
        return n;
    }
#else
    n = printf("%s", buffer);
    return n;
#endif
}
 
static const char*
acutest_basename_(const char* path)
{
    const char* name;
 
    name = strrchr(path, '/');
    if(name != NULL)
        name++;
    else
        name = path;
 
#ifdef ACUTEST_WIN_
    {
        const char* alt_name;
 
        alt_name = strrchr(path, '\\');
        if(alt_name != NULL)
            alt_name++;
        else
            alt_name = path;
 
        if(alt_name > name)
            name = alt_name;
    }
#endif
 
    return name;
}
 
static void
acutest_begin_test_line_(const struct acutest_test_* test)
{
    if(!acutest_tap_) {
        if(acutest_verbose_level_ >= 3) {
            acutest_colored_printf_(ACUTEST_COLOR_DEFAULT_INTENSIVE_, "Test %s:\n", test->name);
            acutest_test_already_logged_++;
        } else if(acutest_verbose_level_ >= 1) {
            int n;
            char spaces[48];
 
            n = acutest_colored_printf_(ACUTEST_COLOR_DEFAULT_INTENSIVE_, "Test %s... ", test->name);
            memset(spaces, ' ', sizeof(spaces));
            if(n < (int) sizeof(spaces))
                printf("%.*s", (int) sizeof(spaces) - n, spaces);
        } else {
            acutest_test_already_logged_ = 1;
        }
    }
}
 
static void
acutest_finish_test_line_(enum acutest_state_ state)
{
    if(acutest_tap_) {
        printf("%s %d - %s%s\n",
                (state == ACUTEST_STATE_SUCCESS || state == ACUTEST_STATE_SKIPPED) ? "ok" : "not ok",
                acutest_current_index_ + 1,
                acutest_current_test_->name,
                (state == ACUTEST_STATE_SKIPPED) ? " # SKIP" : "");
 
        if(state == ACUTEST_STATE_SUCCESS  &&  acutest_timer_) {
            printf("# Duration: ");
            acutest_timer_print_diff_();
            printf("\n");
        }
    } else {
        int color;
        const char* str;
 
        switch(state) {
            case ACUTEST_STATE_SUCCESS: color = ACUTEST_COLOR_GREEN_INTENSIVE_; str = "OK"; break;
            case ACUTEST_STATE_SKIPPED: color = ACUTEST_COLOR_YELLOW_INTENSIVE_; str = "SKIPPED"; break;
            case ACUTEST_STATE_FAILED:  /* Fall through. */
            default:                    color = ACUTEST_COLOR_RED_INTENSIVE_; str = "FAILED"; break;
        }
 
        printf("[ ");
        acutest_colored_printf_(color, "%s", str);
        printf(" ]");
 
        if(state == ACUTEST_STATE_SUCCESS  &&  acutest_timer_) {
            printf("  ");
            acutest_timer_print_diff_();
        }
 
        printf("\n");
    }
}
 
static void
acutest_line_indent_(int level)
{
    static const char spaces[] = "                ";
    int n = level * 2;
 
    if(acutest_tap_  &&  n > 0) {
        n--;
        printf("#");
    }
 
    while(n > 16) {
        printf("%s", spaces);
        n -= 16;
    }
    printf("%.*s", n, spaces);
}
 
void ACUTEST_ATTRIBUTE_(format (printf, 3, 4))
acutest_skip_(const char* file, int line, const char* fmt, ...)
{
    va_list args;
    size_t reason_len;
 
    va_start(args, fmt);
    vsnprintf(acutest_test_skip_reason_, sizeof(acutest_test_skip_reason_), fmt, args);
    va_end(args);
    acutest_test_skip_reason_[sizeof(acutest_test_skip_reason_)-1] = '\0';
 
    /* Remove final dot, if provided; that collides with our other logic. */
    reason_len = strlen(acutest_test_skip_reason_);
    if(acutest_test_skip_reason_[reason_len-1] == '.')
        acutest_test_skip_reason_[reason_len-1] = '\0';
 
    if(acutest_test_check_count_ > 0) {
        acutest_check_(0, file, line, "Cannot skip, already performed some checks");
        return;
    }
 
    if(acutest_verbose_level_ >= 2) {
        const char *result_str = "skipped";
        int result_color = ACUTEST_COLOR_YELLOW_;
 
        if(!acutest_test_already_logged_  &&  acutest_current_test_ != NULL)
            acutest_finish_test_line_(ACUTEST_STATE_SKIPPED);
        acutest_test_already_logged_++;
 
        acutest_line_indent_(1);
 
        if(file != NULL) {
            file = acutest_basename_(file);
            printf("%s:%d: ", file, line);
        }
 
        printf("%s... ", acutest_test_skip_reason_);
        acutest_colored_printf_(result_color, "%s", result_str);
        printf("\n");
        acutest_test_already_logged_++;
    }
 
    acutest_test_skip_count_++;
}
 
int ACUTEST_ATTRIBUTE_(format (printf, 4, 5))
acutest_check_(int cond, const char* file, int line, const char* fmt, ...)
{
    const char *result_str;
    int result_color;
    int verbose_level;
 
    if(acutest_test_skip_count_) {
        /* We've skipped the test. We shouldn't be here: The test implementation
         * should have already return before. So lets suppress the following
         * output. */
        cond = 1;
        goto skip_check;
    }
 
    if(cond) {
        result_str = "ok";
        result_color = ACUTEST_COLOR_GREEN_;
        verbose_level = 3;
    } else {
        if(!acutest_test_already_logged_  &&  acutest_current_test_ != NULL)
            acutest_finish_test_line_(ACUTEST_STATE_FAILED);
 
        acutest_test_failures_++;
        acutest_test_already_logged_++;
 
        result_str = "failed";
        result_color = ACUTEST_COLOR_RED_;
        verbose_level = 2;
    }
 
    if(acutest_verbose_level_ >= verbose_level) {
        va_list args;
 
        if(!acutest_case_already_logged_  &&  acutest_case_name_[0]) {
            acutest_line_indent_(1);
            acutest_colored_printf_(ACUTEST_COLOR_DEFAULT_INTENSIVE_, "Case %s:\n", acutest_case_name_);
            acutest_test_already_logged_++;
            acutest_case_already_logged_++;
        }
 
        acutest_line_indent_(acutest_case_name_[0] ? 2 : 1);
        if(file != NULL) {
            file = acutest_basename_(file);
            printf("%s:%d: ", file, line);
        }
 
        va_start(args, fmt);
        vprintf(fmt, args);
        va_end(args);
 
        printf("... ");
        acutest_colored_printf_(result_color, "%s", result_str);
        printf("\n");
        acutest_test_already_logged_++;
    }
 
    acutest_test_check_count_++;
 
skip_check:
    acutest_cond_failed_ = (cond == 0);
    return !acutest_cond_failed_;
}
 
void ACUTEST_ATTRIBUTE_(format (printf, 1, 2))
acutest_log_(const char* fmt, ...)
{
    char buffer[TEST_LOG_MAXSIZE];
    acutest_data_log_* log_entry;
    va_list args;
 
    log_entry = (acutest_data_log_*)calloc(1, sizeof(acutest_data_log_));
    if (log_entry == NULL) {
        fprintf(stderr, "Out of memory.\n");
        acutest_exit_(2);
    }
 
    /* This is the first log entry for the current test, set the head */
    if (!acutest_test_data_[acutest_current_index_].log_head)
        acutest_test_data_[acutest_current_index_].log_head = log_entry;
 
    /* There is something already at the tail of the list - append our new entry */
    if (acutest_test_data_[acutest_current_index_].log_tail)
        acutest_test_data_[acutest_current_index_].log_tail->next = log_entry;
 
    /* Set the tail of the list ready for the next append */
    acutest_test_data_[acutest_current_index_].log_tail = log_entry;
 
    va_start(args, fmt);
    vsnprintf(buffer, TEST_LOG_MAXSIZE - 1, fmt, args);
    va_end(args);
    buffer[TEST_LOG_MAXSIZE - 1] = '\0';
 
    log_entry->msg = (char *)calloc(strlen(buffer) + 1, sizeof(char));
    if (log_entry->msg == NULL) {
        fprintf(stderr, "Out of memory.\n");
        acutest_exit_(2);
 
    }
    strcpy(log_entry->msg, buffer);
}
 
void ACUTEST_ATTRIBUTE_(format (printf, 1, 2))
acutest_case_(const char* fmt, ...)
{
    va_list args;
 
    if(acutest_verbose_level_ < 2)
        return;
 
    if(acutest_case_name_[0]) {
        acutest_case_already_logged_ = 0;
        acutest_case_name_[0] = '\0';
    }
 
    if(fmt == NULL)
        return;
 
    va_start(args, fmt);
    vsnprintf(acutest_case_name_, sizeof(acutest_case_name_) - 1, fmt, args);
    va_end(args);
    acutest_case_name_[sizeof(acutest_case_name_) - 1] = '\0';
 
    if(acutest_verbose_level_ >= 3) {
        acutest_line_indent_(1);
        acutest_colored_printf_(ACUTEST_COLOR_DEFAULT_INTENSIVE_, "Case %s:\n", acutest_case_name_);
        acutest_test_already_logged_++;
        acutest_case_already_logged_++;
    }
}
 
void ACUTEST_ATTRIBUTE_(format (printf, 2, 3))
acutest_message_(bool always, const char* fmt, ...)
{
    char buffer[TEST_MSG_MAXSIZE];
    char* line_beg;
    char* line_end;
    va_list args;
 
    if(acutest_verbose_level_ < 2)
        return;
 
    /* We allow extra message only when something is already wrong in the
     * current test or always is true. */
    if((acutest_current_test_ == NULL  ||  !acutest_cond_failed_) && !always)
        return;
 
    va_start(args, fmt);
    vsnprintf(buffer, TEST_MSG_MAXSIZE, fmt, args);
    va_end(args);
    buffer[TEST_MSG_MAXSIZE-1] = '\0';
 
    acutest_log_("%s", buffer); /* Add the message to the log */
 
    line_beg = buffer;
    while(1) {
        line_end = strchr(line_beg, '\n');
        if(line_end == NULL)
            break;
        acutest_line_indent_(acutest_case_name_[0] ? 3 : 2);
        printf("%.*s\n", (int)(line_end - line_beg), line_beg);
        line_beg = line_end + 1;
    }
    if(line_beg[0] != '\0') {
        acutest_line_indent_(acutest_case_name_[0] ? 3 : 2);
        printf("%s\n", line_beg);
    }
}
 
void
acutest_dump_(bool always, const char* title, const void* addr, size_t size)
{
    static const size_t BYTES_PER_LINE = 16;
    size_t line_beg;
    size_t truncate = 0;
    size_t buflen = (size * 3) + strlen(title) + 2;
    char* buffer;
    char* p;
    char* end;
 
    if(acutest_verbose_level_ < 2)
        return;
 
    /* We allow extra message only when something is already wrong in the
     * current test or always is true. */
    if((acutest_current_test_ == NULL  ||  !acutest_cond_failed_) && !always)
        return;
 
    if(size > TEST_DUMP_MAXSIZE) {
        truncate = size - TEST_DUMP_MAXSIZE;
        size = TEST_DUMP_MAXSIZE;
    }
 
    /* Allocate space for log copy of dump */
    buffer = (char *)calloc(buflen, sizeof(char));
    end = buffer + buflen;
 
    acutest_line_indent_(acutest_case_name_[0] ? 3 : 2);
    printf((title[strlen(title)-1] == ':') ? "%s\n" : "%s:\n", title);
 
    strcpy(buffer, title);
    p = buffer + strlen(title);
    if (title[strlen(title) - 1] != ':') {
        *p = ':';
        p++;
    }
 
    for(line_beg = 0; line_beg < size; line_beg += BYTES_PER_LINE) {
        size_t line_end = line_beg + BYTES_PER_LINE;
        size_t off;
 
        acutest_line_indent_(acutest_case_name_[0] ? 4 : 3);
        printf("%08lx: ", (unsigned long)line_beg);
        for(off = line_beg; off < line_end; off++) {
            if(off < size) {
                printf(" %02x", ((const unsigned char*)addr)[off]);
                snprintf(p, end - p, " %02x", ((const unsigned char*)addr)[off]);
                p += 3;
            } else
                printf("   ");
        }
 
        printf("  ");
        for(off = line_beg; off < line_end; off++) {
            unsigned char byte = ((const unsigned char*)addr)[off];
            if(off < size)
                printf("%c", (iscntrl(byte) ? '.' : byte));
            else
                break;
        }
 
        printf("\n");
    }
 
    if(truncate > 0) {
        acutest_line_indent_(acutest_case_name_[0] ? 4 : 3);
        printf("           ... (and more %u bytes)\n", (unsigned) truncate);
    }
 
    acutest_log_("%s", buffer);
    free(buffer);
}
 
/* This is called just before each test */
static void
acutest_init_(const char *test_name)
{
#ifdef TEST_INIT
    TEST_INIT
    ; /* Allow for a single unterminated function call */
#endif
 
    /* Suppress any warnings about unused variable. */
    (void) test_name;
}
 
/* This is called after each test */
static void
acutest_fini_(const char *test_name)
{
#ifdef TEST_FINI
    TEST_FINI
    ; /* Allow for a single unterminated function call */
#endif
 
    /* Suppress any warnings about unused variable. */
    (void) test_name;
}
 
void
acutest_abort_(void)
{
    if(acutest_abort_has_jmp_buf_) {
        longjmp(acutest_abort_jmp_buf_, 1);
    } else {
        if(acutest_current_test_ != NULL)
            acutest_fini_(acutest_current_test_->name);
        fflush(stdout);
        fflush(stderr);
        acutest_exit_(ACUTEST_STATE_FAILED);
    }
}
 
static void
acutest_list_names_(void)
{
    const struct acutest_test_* test;
 
    printf("Unit tests:\n");
    for(test = &acutest_list_[0]; test->func != NULL; test++)
        printf("  %s\n", test->name);
}
 
static int
acutest_name_contains_word_(const char* name, const char* pattern)
{
    static const char word_delim[] = " \t-_/.,:;";
    const char* substr;
    size_t pattern_len;
 
    pattern_len = strlen(pattern);
 
    substr = strstr(name, pattern);
    while(substr != NULL) {
        int starts_on_word_boundary = (substr == name || strchr(word_delim, substr[-1]) != NULL);
        int ends_on_word_boundary = (substr[pattern_len] == '\0' || strchr(word_delim, substr[pattern_len]) != NULL);
 
        if(starts_on_word_boundary && ends_on_word_boundary)
            return 1;
 
        substr = strstr(substr+1, pattern);
    }
 
    return 0;
}
 
static int
acutest_select_(const char* pattern)
{
    int i;
    int n = 0;
 
    /* Try exact match. */
    for(i = 0; i < acutest_list_size_; i++) {
        if(strcmp(acutest_list_[i].name, pattern) == 0) {
            acutest_test_data_[i].state = ACUTEST_STATE_SELECTED;
            n++;
            break;
        }
    }
    if(n > 0)
        return n;
 
    /* Try word match. */
    for(i = 0; i < acutest_list_size_; i++) {
        if(acutest_name_contains_word_(acutest_list_[i].name, pattern)) {
            acutest_test_data_[i].state = ACUTEST_STATE_SELECTED;
            n++;
        }
    }
    if(n > 0)
        return n;
 
    /* Try relaxed match. */
    for(i = 0; i < acutest_list_size_; i++) {
        if(strstr(acutest_list_[i].name, pattern) != NULL) {
            acutest_test_data_[i].state = ACUTEST_STATE_SELECTED;
            n++;
        }
    }
 
    return n;
}
 
 
/* Called if anything goes bad in Acutest, or if the unit test ends in other
 * way then by normal returning from its function (e.g. exception or some
 * abnormal child process termination). */
static void ACUTEST_ATTRIBUTE_(format (printf, 1, 2))
acutest_error_(const char* fmt, ...)
{
    if(acutest_verbose_level_ == 0)
        return;
 
    if(acutest_verbose_level_ >= 2) {
        va_list args;
 
        acutest_line_indent_(1);
        if(acutest_verbose_level_ >= 3)
            acutest_colored_printf_(ACUTEST_COLOR_RED_INTENSIVE_, "ERROR: ");
        va_start(args, fmt);
        vprintf(fmt, args);
        va_end(args);
        printf("\n");
    }
 
    if(acutest_verbose_level_ >= 3) {
        printf("\n");
    }
}
 
/* Call directly the given test unit function. */
static enum acutest_state_
acutest_do_run_(const struct acutest_test_* test, int index)
{
    enum acutest_state_ state = ACUTEST_STATE_FAILED;
 
    acutest_current_test_ = test;
    acutest_current_index_ = index;
    acutest_test_failures_ = 0;
    acutest_test_already_logged_ = 0;
    acutest_test_check_count_ = 0;
    acutest_test_skip_count_ = 0;
    acutest_cond_failed_ = 0;
 
#ifdef __cplusplus
#ifndef TEST_NO_EXCEPTIONS
    try {
#endif
#endif
        acutest_init_(test->name);
        acutest_begin_test_line_(test);
 
        /* This is good to do in case the test unit crashes. */
        fflush(stdout);
        fflush(stderr);
 
        if(!acutest_worker_) {
            acutest_abort_has_jmp_buf_ = 1;
            if(setjmp(acutest_abort_jmp_buf_) != 0)
                goto aborted;
        }
 
        acutest_timer_get_time_(&acutest_timer_start_);
        test->func();
 
aborted:
        acutest_abort_has_jmp_buf_ = 0;
        acutest_timer_get_time_(&acutest_timer_end_);
 
        if(acutest_test_failures_ > 0)
            state = ACUTEST_STATE_FAILED;
        else if(acutest_test_skip_count_ > 0)
            state = ACUTEST_STATE_SKIPPED;
        else
            state = ACUTEST_STATE_SUCCESS;
 
        if(!acutest_test_already_logged_)
            acutest_finish_test_line_(state);
 
        if(acutest_verbose_level_ >= 3) {
            acutest_line_indent_(1);
            switch(state) {
                case ACUTEST_STATE_SUCCESS:
                    acutest_colored_printf_(ACUTEST_COLOR_GREEN_INTENSIVE_, "SUCCESS: ");
                    printf("All conditions have passed.\n");
 
                    if(acutest_timer_) {
                        acutest_line_indent_(1);
                        printf("Duration: ");
                        acutest_timer_print_diff_();
                        printf("\n");
                    }
                    break;
 
                case ACUTEST_STATE_SKIPPED:
                    acutest_colored_printf_(ACUTEST_COLOR_YELLOW_INTENSIVE_, "SKIPPED: ");
                    printf("%s.\n", acutest_test_skip_reason_);
                    break;
 
                default:
                    acutest_colored_printf_(ACUTEST_COLOR_RED_INTENSIVE_, "FAILED: ");
                    printf("%d condition%s %s failed.\n",
                            acutest_test_failures_,
                            (acutest_test_failures_ == 1) ? "" : "s",
                            (acutest_test_failures_ == 1) ? "has" : "have");
                    break;
            }
            printf("\n");
        }
 
#ifdef __cplusplus
#ifndef TEST_NO_EXCEPTIONS
    } catch(std::exception& e) {
        const char* what = e.what();
        acutest_check_(0, NULL, 0, "Threw std::exception");
        if(what != NULL)
            acutest_message_(false, "std::exception::what(): %s", what);
 
        if(acutest_verbose_level_ >= 3) {
            acutest_line_indent_(1);
            acutest_colored_printf_(ACUTEST_COLOR_RED_INTENSIVE_, "FAILED: ");
            printf("C++ exception.\n\n");
        }
    } catch(...) {
        acutest_check_(0, NULL, 0, "Threw an exception");
 
        if(acutest_verbose_level_ >= 3) {
            acutest_line_indent_(1);
            acutest_colored_printf_(ACUTEST_COLOR_RED_INTENSIVE_, "FAILED: ");
            printf("C++ exception.\n\n");
        }
    }
#endif
#endif
 
    acutest_fini_(test->name);
    acutest_case_(NULL);
    acutest_current_test_ = NULL;
 
    return state;
}
 
/* Trigger the unit test. If possible (and not suppressed) it starts a child
 * process who calls acutest_do_run_(), otherwise it calls acutest_do_run_()
 * directly. */
static void
acutest_run_(const struct acutest_test_* test, int index, int master_index)
{
    enum acutest_state_ state = ACUTEST_STATE_FAILED;
    acutest_timer_type_ start, end;
 
    acutest_current_test_ = test;
    acutest_test_already_logged_ = 0;
    acutest_timer_get_time_(&start);
 
    if(!acutest_no_exec_) {
 
#if defined(ACUTEST_UNIX_)
 
        pid_t pid;
        int exit_code;
        int fd[2];
        char msg[TEST_LOG_MAXSIZE];
        char *p;
        size_t count;
 
        /* Make sure the child starts with empty I/O buffers. */
        fflush(stdout);
        fflush(stderr);
 
        if (pipe(fd) == -1) {
            fprintf(stderr, "Unable to create pipe.\n");
            acutest_exit_(2);
        }
 
        pid = fork();
        if(pid == (pid_t)-1) {
            acutest_error_("Cannot fork. %s [%d]", strerror(errno), errno);
        } else if(pid == 0) {
            /* Child: Do the test. */
            acutest_data_log_* log_entry;
            close(fd[0]);  /* Child only uses the write pipe, close the read one */
            acutest_worker_ = 1;
            state = acutest_do_run_(test, index);
 
            /* Write any log messages to the pipe.
             * Send each log entry as a null terminated string */
            log_entry = acutest_test_data_[index].log_head;
            while (log_entry) {
                if (write(fd[1], log_entry->msg, (strlen(log_entry->msg) + 1) * sizeof(char)) == -1) {
                    fprintf(stderr, "Unable to write to pipe\n");
                    acutest_exit_(2);
                }
                log_entry = log_entry->next;
            }
            close(fd[1]);
            acutest_exit_((int) state);
        } else {
            close(fd[1]); /* Parent only uses the read pipe, close the write one */
            /* Parent: Wait until child terminates and analyze its exit code. */
            waitpid(pid, &exit_code, 0);
            if(WIFEXITED(exit_code)) {
                state = (enum acutest_state_) WEXITSTATUS(exit_code);
            } else if(WIFSIGNALED(exit_code)) {
                char tmp[32];
                const char* signame;
                switch(WTERMSIG(exit_code)) {
                    case SIGINT:  signame = "SIGINT"; break;
                    case SIGHUP:  signame = "SIGHUP"; break;
                    case SIGQUIT: signame = "SIGQUIT"; break;
                    case SIGABRT: signame = "SIGABRT"; break;
                    case SIGKILL: signame = "SIGKILL"; break;
                    case SIGSEGV: signame = "SIGSEGV"; break;
                    case SIGILL:  signame = "SIGILL"; break;
                    case SIGTERM: signame = "SIGTERM"; break;
                    default:      snprintf(tmp, sizeof(tmp), "signal %d", WTERMSIG(exit_code)); signame = tmp; break;
                }
                acutest_error_("Test interrupted by %s.", signame);
            } else {
                acutest_error_("Test ended in an unexpected way [%d].", exit_code);
            }
 
            /* Read log messages from the child, one character at a time to
             * find the NULLs, then re-create the log entries in the parent */
            p = msg;
            count = 0;
            acutest_current_index_ = index; /* acutest_log_() needs this set to know which entry to populate */
            while (read(fd[0], p, sizeof(char))) {
                if (*p == '\0') { /* Found a NULL terminator */
                    acutest_log_("%s", msg); /* Create parent log entry */
                    p = msg; /* reset pointer */
                    count = 0;
                } else {
                    p++;
                    count++;
                }
                if (count >= TEST_LOG_MAXSIZE) {
                    fprintf(stderr, "Log message from child too large");
                    acutest_exit_(2);
                }
            }
            close(fd[0]);
        }
 
#elif defined(ACUTEST_WIN_)
 
        char buffer[512] = {0};
        STARTUPINFOA startupInfo;
        PROCESS_INFORMATION processInfo;
        DWORD exitCode;
        HANDLE hRead = NULL;
        HANDLE hWrite = NULL;
        SECURITY_ATTRIBUTES lpPipeAttribute;
        lpPipeAttribute.nLength = sizeof(lpPipeAttribute);
        lpPipeAttribute.lpSecurityDescriptor = NULL;
        lpPipeAttribute.bInheritHandle = TRUE;
        char* p;
        char msg[TEST_LOG_MAXSIZE];
        size_t count;
 
        /* Create pipe for receiving log entries */
        if (!CreatePipe(&hRead, &hWrite, &lpPipeAttribute, 0)) {
            fprintf(stderr, "Error creating pipe\n");
            acutest_exit_(2);
        }
 
        /* Windows has no fork(). So we propagate all info into the child
         * through a command line arguments. */
        snprintf(buffer, sizeof(buffer),
                 "%s --worker=%d %s --no-exec --no-summary %s --verbose=%d --color=%s --pipe=%I64d -- \"%s\"",
                 acutest_argv0_, index, acutest_timer_ ? "--time" : "",
                 acutest_tap_ ? "--tap" : "", acutest_verbose_level_,
                 acutest_colorize_ ? "always" : "never", (ULONG64)(ULONG_PTR)hWrite,
                 test->name);
        memset(&startupInfo, 0, sizeof(startupInfo));
        startupInfo.cb = sizeof(STARTUPINFO);
        if(CreateProcessA(NULL, buffer, NULL, NULL, TRUE, 0, NULL, NULL, &startupInfo, &processInfo)) {
            WaitForSingleObject(processInfo.hProcess, INFINITE);
            GetExitCodeProcess(processInfo.hProcess, &exitCode);
            CloseHandle(processInfo.hThread);
            CloseHandle(processInfo.hProcess);
 
            /* Read log messages from the child, one character at a time to
             * find the NULLs, then re-create the log entries in the parent */
            p = msg;
            count = 0;
            acutest_current_index_ = index; /* acutest_log_() needs this set to know which entry to populate */
            while (ReadFile(hRead, p, sizeof(char), NULL, NULL)) {
                if (*p == '\0') { /* Found a NULL terminator */
                    acutest_log_("%s", msg); /* Create parent log entry */
                    p = msg; /* reset pointer */
                    count = 0;
                }
                else {
                    p++;
                    count++;
                }
                if (count >= TEST_LOG_MAXSIZE) {
                    fprintf(stderr, "Log message from child too large");
                    acutest_exit_(2);
                }
            }
 
            CloseHandle(hRead);
            CloseHandle(hWrite);
            switch(exitCode) {
                case 0:             state = ACUTEST_STATE_SUCCESS; break;
                case 1:             state = ACUTEST_STATE_FAILED; break;
                case 2:             state = ACUTEST_STATE_SKIPPED; break;
                case 3:             acutest_error_("Aborted."); break;
                case 0xC0000005:    acutest_error_("Access violation."); break;
                default:            acutest_error_("Test ended in an unexpected way [%lu].", exitCode); break;
            }
        } else {
            acutest_error_("Cannot create unit test subprocess [%ld].", GetLastError());
        }
 
#else
 
        /* A platform where we don't know how to run child process. */
        state = acutest_do_run_(test, index);
 
#endif
 
    } else {
        /* Child processes suppressed through --no-exec. */
        state = acutest_do_run_(test, index);
    }
    acutest_timer_get_time_(&end);
 
    acutest_current_test_ = NULL;
 
    acutest_test_data_[master_index].state = state;
    acutest_test_data_[master_index].duration = acutest_timer_diff_(start, end);
}
 
#if defined(ACUTEST_WIN_)
/* Callback for SEH events. */
static LONG CALLBACK
acutest_seh_exception_filter_(EXCEPTION_POINTERS *ptrs)
{
    acutest_check_(0, NULL, 0, "Unhandled SEH exception");
    acutest_message_(false, "Exception code:    0x%08lx", ptrs->ExceptionRecord->ExceptionCode);
    acutest_message_(false, "Exception address: 0x%p", ptrs->ExceptionRecord->ExceptionAddress);
 
    fflush(stdout);
    fflush(stderr);
 
    return EXCEPTION_EXECUTE_HANDLER;
}
#endif
 
 
#define ACUTEST_CMDLINE_OPTFLAG_OPTIONALARG_    0x0001
#define ACUTEST_CMDLINE_OPTFLAG_REQUIREDARG_    0x0002
 
#define ACUTEST_CMDLINE_OPTID_NONE_             0
#define ACUTEST_CMDLINE_OPTID_UNKNOWN_          (-0x7fffffff + 0)
#define ACUTEST_CMDLINE_OPTID_MISSINGARG_       (-0x7fffffff + 1)
#define ACUTEST_CMDLINE_OPTID_BOGUSARG_         (-0x7fffffff + 2)
 
typedef struct acutest_test_CMDLINE_OPTION_ {
    char shortname;
    const char* longname;
    int id;
    unsigned flags;
} ACUTEST_CMDLINE_OPTION_;
 
static int
acutest_cmdline_handle_short_opt_group_(const ACUTEST_CMDLINE_OPTION_* options,
                    const char* arggroup,
                    int (*callback)(int /*optval*/, const char* /*arg*/))
{
    const ACUTEST_CMDLINE_OPTION_* opt;
    int i;
    int ret = 0;
 
    for(i = 0; arggroup[i] != '\0'; i++) {
        for(opt = options; opt->id != 0; opt++) {
            if(arggroup[i] == opt->shortname)
                break;
        }
 
        if(opt->id != 0  &&  !(opt->flags & ACUTEST_CMDLINE_OPTFLAG_REQUIREDARG_)) {
            ret = callback(opt->id, NULL);
        } else {
            /* Unknown option. */
            char badoptname[3];
            badoptname[0] = '-';
            badoptname[1] = arggroup[i];
            badoptname[2] = '\0';
            ret = callback((opt->id != 0 ? ACUTEST_CMDLINE_OPTID_MISSINGARG_ : ACUTEST_CMDLINE_OPTID_UNKNOWN_),
                            badoptname);
        }
 
        if(ret != 0)
            break;
    }
 
    return ret;
}
 
#define ACUTEST_CMDLINE_AUXBUF_SIZE_  32
 
static int
acutest_cmdline_read_(const ACUTEST_CMDLINE_OPTION_* options, int argc, char** argv,
                      int (*callback)(int /*optval*/, const char* /*arg*/))
{
 
    const ACUTEST_CMDLINE_OPTION_* opt;
    char auxbuf[ACUTEST_CMDLINE_AUXBUF_SIZE_+1];
    int after_doubledash = 0;
    int i = 1;
    int ret = 0;
 
    auxbuf[ACUTEST_CMDLINE_AUXBUF_SIZE_] = '\0';
 
    while(i < argc) {
        if(after_doubledash  ||  strcmp(argv[i], "-") == 0) {
            /* Non-option argument. */
            ret = callback(ACUTEST_CMDLINE_OPTID_NONE_, argv[i]);
        } else if(strcmp(argv[i], "--") == 0) {
            /* End of options. All the remaining members are non-option arguments. */
            after_doubledash = 1;
        } else if(argv[i][0] != '-') {
            /* Non-option argument. */
            ret = callback(ACUTEST_CMDLINE_OPTID_NONE_, argv[i]);
        } else {
            for(opt = options; opt->id != 0; opt++) {
                if(opt->longname != NULL  &&  strncmp(argv[i], "--", 2) == 0) {
                    size_t len = strlen(opt->longname);
                    if(strncmp(argv[i]+2, opt->longname, len) == 0) {
                        /* Regular long option. */
                        if(argv[i][2+len] == '\0') {
                            /* with no argument provided. */
                            if(!(opt->flags & ACUTEST_CMDLINE_OPTFLAG_REQUIREDARG_))
                                ret = callback(opt->id, NULL);
                            else
                                ret = callback(ACUTEST_CMDLINE_OPTID_MISSINGARG_, argv[i]);
                            break;
                        } else if(argv[i][2+len] == '=') {
                            /* with an argument provided. */
                            if(opt->flags & (ACUTEST_CMDLINE_OPTFLAG_OPTIONALARG_ | ACUTEST_CMDLINE_OPTFLAG_REQUIREDARG_)) {
                                ret = callback(opt->id, argv[i]+2+len+1);
                            } else {
                                snprintf(auxbuf, sizeof(auxbuf), "--%s", opt->longname);
                                ret = callback(ACUTEST_CMDLINE_OPTID_BOGUSARG_, auxbuf);
                            }
                            break;
                        } else {
                            continue;
                        }
                    }
                } else if(opt->shortname != '\0'  &&  argv[i][0] == '-') {
                    if(argv[i][1] == opt->shortname) {
                        /* Regular short option. */
                        if(opt->flags & ACUTEST_CMDLINE_OPTFLAG_REQUIREDARG_) {
                            if(argv[i][2] != '\0')
                                ret = callback(opt->id, argv[i]+2);
                            else if(i+1 < argc)
                                ret = callback(opt->id, argv[++i]);
                            else
                                ret = callback(ACUTEST_CMDLINE_OPTID_MISSINGARG_, argv[i]);
                            break;
                        } else {
                            ret = callback(opt->id, NULL);
 
                            /* There might be more (argument-less) short options
                             * grouped together. */
                            if(ret == 0  &&  argv[i][2] != '\0')
                                ret = acutest_cmdline_handle_short_opt_group_(options, argv[i]+2, callback);
                            break;
                        }
                    }
                }
            }
 
            if(opt->id == 0) {  /* still not handled? */
                if(argv[i][0] != '-') {
                    /* Non-option argument. */
                    ret = callback(ACUTEST_CMDLINE_OPTID_NONE_, argv[i]);
                } else {
                    /* Unknown option. */
                    char* badoptname = argv[i];
 
                    if(strncmp(badoptname, "--", 2) == 0) {
                        /* Strip any argument from the long option. */
                        char* assignment = strchr(badoptname, '=');
                        if(assignment != NULL) {
                            size_t len = (size_t)(assignment - badoptname);
                            if(len > ACUTEST_CMDLINE_AUXBUF_SIZE_)
                                len = ACUTEST_CMDLINE_AUXBUF_SIZE_;
                            memcpy(auxbuf, badoptname, len);
                            auxbuf[len] = '\0';
                            badoptname = auxbuf;
                        }
                    }
 
                    ret = callback(ACUTEST_CMDLINE_OPTID_UNKNOWN_, badoptname);
                }
            }
        }
 
        if(ret != 0)
            return ret;
        i++;
    }
 
    return ret;
}
 
static void
acutest_help_(void)
{
    printf("Usage: %s [options] [test...]\n", acutest_argv0_);
    printf("\n");
    printf("Run the specified unit tests; or if the option '--exclude' is used, run all\n");
    printf("tests in the suite but those listed.  By default, if no tests are specified\n");
    printf("on the command line, all unit tests in the suite are run.\n");
    printf("\n");
    printf("Options:\n");
    printf("  -X, --exclude         Execute all unit tests but the listed ones\n");
    printf("      --exec[=WHEN]     If supported, execute unit tests as child processes\n");
    printf("                          (WHEN is one of 'auto', 'always', 'never')\n");
    printf("  -E, --no-exec         Same as --exec=never\n");
#if defined ACUTEST_WIN_
    printf("  -t, --time            Measure test duration\n");
#elif defined ACUTEST_HAS_POSIX_TIMER_
    printf("  -t, --time            Measure test duration (real time)\n");
    printf("      --time=TIMER      Measure test duration, using given timer\n");
    printf("                          (TIMER is one of 'real', 'cpu')\n");
#endif
    printf("      --no-summary      Suppress printing of test results summary\n");
    printf("      --tap             Produce TAP-compliant output\n");
    printf("                          (See https://testanything.org/)\n");
    printf("  -x, --xml-output=FILE Enable XUnit output to the given file\n");
    printf("  -l, --list            List unit tests in the suite and exit\n");
    printf("  -v, --verbose         Make output more verbose\n");
    printf("      --verbose=LEVEL   Set verbose level to LEVEL:\n");
    printf("                          0 ... Be silent\n");
    printf("                          1 ... Output one line per test (and summary)\n");
    printf("                          2 ... As 1 and failed conditions (this is default)\n");
    printf("                          3 ... As 1 and all conditions (and extended summary)\n");
    printf("  -q, --quiet           Same as --verbose=0\n");
    printf("      --color[=WHEN]    Enable colorized output\n");
    printf("                          (WHEN is one of 'auto', 'always', 'never')\n");
    printf("      --no-color        Same as --color=never\n");
    printf("  -h, --help            Display this help and exit\n");
 
    if(acutest_list_size_ < 16) {
        printf("\n");
        acutest_list_names_();
    }
}
 
static const ACUTEST_CMDLINE_OPTION_ acutest_cmdline_options_[] = {
    { 'X',  "exclude",      'X', 0 },
    { 's',  "skip",         'X', 0 },   /* kept for compatibility, use --exclude instead */
    {  0,   "exec",         'e', ACUTEST_CMDLINE_OPTFLAG_OPTIONALARG_ },
    { 'E',  "no-exec",      'E', 0 },
#if defined ACUTEST_WIN_
    { 't',  "time",         't', 0 },
    {  0,   "timer",        't', 0 },   /* kept for compatibility */
    {  0,   "pipe",         'p', ACUTEST_CMDLINE_OPTFLAG_REQUIREDARG_},  /* internal */
#elif defined ACUTEST_HAS_POSIX_TIMER_
    { 't',  "time",         't', ACUTEST_CMDLINE_OPTFLAG_OPTIONALARG_ },
    {  0,   "timer",        't', ACUTEST_CMDLINE_OPTFLAG_OPTIONALARG_ },  /* kept for compatibility */
#endif
    {  0,   "no-summary",   'S', 0 },
    {  0,   "tap",          'T', 0 },
    { 'l',  "list",         'l', 0 },
    { 'v',  "verbose",      'v', ACUTEST_CMDLINE_OPTFLAG_OPTIONALARG_ },
    { 'q',  "quiet",        'q', 0 },
    {  0,   "color",        'c', ACUTEST_CMDLINE_OPTFLAG_OPTIONALARG_ },
    {  0,   "no-color",     'C', 0 },
    { 'h',  "help",         'h', 0 },
    {  0,   "worker",       'w', ACUTEST_CMDLINE_OPTFLAG_REQUIREDARG_ },  /* internal */
    { 'x',  "xml-output",   'x', ACUTEST_CMDLINE_OPTFLAG_REQUIREDARG_ },
    {  0,   NULL,            0,  0 }
};
 
static int
acutest_cmdline_callback_(int id, const char* arg)
{
    switch(id) {
        case 'X':
            acutest_exclude_mode_ = 1;
            break;
 
        case 'e':
            if(arg == NULL || strcmp(arg, "always") == 0) {
                acutest_no_exec_ = 0;
            } else if(strcmp(arg, "never") == 0) {
                acutest_no_exec_ = 1;
            } else if(strcmp(arg, "auto") == 0) {
                /*noop*/
            } else {
                fprintf(stderr, "%s: Unrecognized argument '%s' for option --exec.\n", acutest_argv0_, arg);
                fprintf(stderr, "Try '%s --help' for more information.\n", acutest_argv0_);
                acutest_exit_(2);
            }
            break;
 
        case 'E':
            acutest_no_exec_ = 1;
            break;
 
        case 't':
#if defined ACUTEST_WIN_  ||  defined ACUTEST_HAS_POSIX_TIMER_
            if(arg == NULL || strcmp(arg, "real") == 0) {
                acutest_timer_ = 1;
    #ifndef ACUTEST_WIN_
            } else if(strcmp(arg, "cpu") == 0) {
                acutest_timer_ = 2;
    #endif
            } else {
                fprintf(stderr, "%s: Unrecognized argument '%s' for option --time.\n", acutest_argv0_, arg);
                fprintf(stderr, "Try '%s --help' for more information.\n", acutest_argv0_);
                acutest_exit_(2);
            }
#endif
            break;
 
        case 'S':
            acutest_no_summary_ = 1;
            break;
 
        case 'T':
            acutest_tap_ = 1;
            break;
 
        case 'l':
            acutest_list_names_();
            acutest_exit_(0);
            break;
 
        case 'v':
            acutest_verbose_level_ = (arg != NULL ? atoi(arg) : acutest_verbose_level_+1);
            break;
 
#if defined ACUTEST_WIN_
        case 'p':
            hChildWrite = (HANDLE)(ULONG_PTR)_atoi64(arg);
            break;
#endif
        case 'q':
            acutest_verbose_level_ = 0;
            break;
 
        case 'c':
            if(arg == NULL || strcmp(arg, "always") == 0) {
                acutest_colorize_ = 1;
            } else if(strcmp(arg, "never") == 0) {
                acutest_colorize_ = 0;
            } else if(strcmp(arg, "auto") == 0) {
                /*noop*/
            } else {
                fprintf(stderr, "%s: Unrecognized argument '%s' for option --color.\n", acutest_argv0_, arg);
                fprintf(stderr, "Try '%s --help' for more information.\n", acutest_argv0_);
                acutest_exit_(2);
            }
            break;
 
        case 'C':
            acutest_colorize_ = 0;
            break;
 
        case 'h':
            acutest_help_();
            acutest_exit_(0);
            break;
 
        case 'w':
            acutest_worker_ = 1;
            acutest_worker_index_ = atoi(arg);
            break;
        case 'x':
            acutest_xml_output_ = fopen(arg, "w");
            if (!acutest_xml_output_) {
                fprintf(stderr, "Unable to open '%s': %s\n", arg, strerror(errno));
                acutest_exit_(2);
            }
            break;
 
        case 0:
            if(acutest_select_(arg) == 0) {
                fprintf(stderr, "%s: Unrecognized unit test '%s'\n", acutest_argv0_, arg);
                fprintf(stderr, "Try '%s --list' for list of unit tests.\n", acutest_argv0_);
                acutest_exit_(2);
            }
            break;
 
        case ACUTEST_CMDLINE_OPTID_UNKNOWN_:
            fprintf(stderr, "Unrecognized command line option '%s'.\n", arg);
            fprintf(stderr, "Try '%s --help' for more information.\n", acutest_argv0_);
            acutest_exit_(2);
            break;
 
        case ACUTEST_CMDLINE_OPTID_MISSINGARG_:
            fprintf(stderr, "The command line option '%s' requires an argument.\n", arg);
            fprintf(stderr, "Try '%s --help' for more information.\n", acutest_argv0_);
            acutest_exit_(2);
            break;
 
        case ACUTEST_CMDLINE_OPTID_BOGUSARG_:
            fprintf(stderr, "The command line option '%s' does not expect an argument.\n", arg);
            fprintf(stderr, "Try '%s --help' for more information.\n", acutest_argv0_);
            acutest_exit_(2);
            break;
    }
 
    return 0;
}
 
static int
acutest_under_debugger_(void)
{
#ifdef ACUTEST_LINUX_
    /* Scan /proc/self/status for line "TracerPid: [PID]". If such line exists
     * and the PID is non-zero, we're being debugged. */
    {
        static const int OVERLAP = 32;
        int fd;
        char buf[512];
        size_t n_read;
        pid_t tracer_pid = 0;
 
        /* Little trick so that we can treat the 1st line the same as any other
         * and detect line start easily. */
        buf[0] = '\n';
        n_read = 1;
 
        fd = open("/proc/self/status", O_RDONLY);
        if(fd != -1) {
            while(1) {
                static const char pattern[] = "\nTracerPid:";
                const char* field;
 
                while(n_read < sizeof(buf) - 1) {
                    ssize_t n;
 
                    n = read(fd, buf + n_read, sizeof(buf) - 1 - n_read);
                    if(n <= 0)
                        break;
                    n_read += (size_t)n;
                }
                buf[n_read] = '\0';
 
                field = strstr(buf, pattern);
                if(field != NULL  &&  field < buf + sizeof(buf) - OVERLAP) {
                    tracer_pid = (pid_t) atoi(field + sizeof(pattern) - 1);
                    break;
                }
 
                if(n_read == sizeof(buf) - 1) {
                    /* Move the tail with the potentially incomplete line we're
                     * be looking for to the beginning of the buffer.
                     * (The OVERLAP must be large enough so the searched line
                     * can fit in completely.) */
                    memmove(buf, buf + sizeof(buf) - 1 - OVERLAP, OVERLAP);
                    n_read = OVERLAP;
                } else {
                    break;
                }
            }
 
            close(fd);
 
            if(tracer_pid != 0)
                return 1;
        }
    }
#endif
 
#ifdef ACUTEST_MACOS_
    /* See https://developer.apple.com/library/archive/qa/qa1361/_index.html */
    {
        int mib[4];
        struct kinfo_proc info;
        size_t size;
 
        mib[0] = CTL_KERN;
        mib[1] = KERN_PROC;
        mib[2] = KERN_PROC_PID;
        mib[3] = getpid();
 
        size = sizeof(info);
        info.kp_proc.p_flag = 0;
        sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, NULL, 0);
 
        if(info.kp_proc.p_flag & P_TRACED)
            return 1;
    }
#endif
 
#ifdef ACUTEST_WIN_
    if(IsDebuggerPresent())
        return 1;
#endif
 
#ifdef RUNNING_ON_VALGRIND
    /* We treat Valgrind as a debugger of sorts.
     * (Macro RUNNING_ON_VALGRIND is provided by <valgrind.h>, if available.) */
    if(RUNNING_ON_VALGRIND)
        return 1;
#endif
 
    return 0;
}
 
int
main(int argc, char** argv)
{
    int i, index;
    int exit_code = 1;
 
    acutest_argv0_ = argv[0];
 
#if defined ACUTEST_UNIX_
    acutest_colorize_ = isatty(STDOUT_FILENO);
#elif defined ACUTEST_WIN_
 #if defined _BORLANDC_
    acutest_colorize_ = isatty(_fileno(stdout));
 #else
    acutest_colorize_ = _isatty(_fileno(stdout));
 #endif
#else
    acutest_colorize_ = 0;
#endif
 
    /* Count all test units */
    acutest_list_size_ = 0;
    for(i = 0; acutest_list_[i].func != NULL; i++)
        acutest_list_size_++;
 
    acutest_test_data_ = (struct acutest_test_data_*)calloc(acutest_list_size_, sizeof(struct acutest_test_data_));
    if(acutest_test_data_ == NULL) {
        fprintf(stderr, "Out of memory.\n");
        acutest_exit_(2);
    }
 
    /* Parse options */
    acutest_cmdline_read_(acutest_cmdline_options_, argc, argv, acutest_cmdline_callback_);
 
    /* Initialize the proper timer. */
    acutest_timer_init_();
 
#if defined(ACUTEST_WIN_)
    SetUnhandledExceptionFilter(acutest_seh_exception_filter_);
#ifdef _MSC_VER
    _set_abort_behavior(0, _WRITE_ABORT_MSG);
#endif
#endif
 
    /* Determine what to run. */
    if(acutest_count_(ACUTEST_STATE_SELECTED) > 0) {
        enum acutest_state_ if_selected;
        enum acutest_state_ if_unselected;
 
        if(!acutest_exclude_mode_) {
            if_selected = ACUTEST_STATE_NEEDTORUN;
            if_unselected = ACUTEST_STATE_EXCLUDED;
        } else {
            if_selected = ACUTEST_STATE_EXCLUDED;
            if_unselected = ACUTEST_STATE_NEEDTORUN;
        }
 
        for(i = 0; acutest_list_[i].func != NULL; i++) {
            if(acutest_test_data_[i].state == ACUTEST_STATE_SELECTED)
                acutest_test_data_[i].state = if_selected;
            else
                acutest_test_data_[i].state = if_unselected;
        }
    } else {
        /* By default, we want to run all tests. */
        for(i = 0; acutest_list_[i].func != NULL; i++)
            acutest_test_data_[i].state = ACUTEST_STATE_NEEDTORUN;
    }
 
    /* By default, we want to suppress running tests as child processes if we
     * run just one test, or if we're under debugger: Debugging tests is then
     * so much easier. */
    if(acutest_no_exec_ < 0) {
        if(acutest_count_(ACUTEST_STATE_NEEDTORUN) <= 1  ||  acutest_under_debugger_())
            acutest_no_exec_ = 1;
        else
            acutest_no_exec_ = 0;
    }
 
    if(acutest_tap_) {
        /* TAP requires we know test result ("ok", "not ok") before we output
         * anything about the test, and this gets problematic for larger verbose
         * levels. */
        if(acutest_verbose_level_ > 2)
            acutest_verbose_level_ = 2;
 
        /* TAP harness should provide some summary. */
        acutest_no_summary_ = 1;
 
        if(!acutest_worker_)
            printf("1..%d\n", acutest_count_(ACUTEST_STATE_NEEDTORUN));
    }
 
#ifdef TEST_GLOBAL_INIT
    TEST_GLOBAL_INIT
    ; /* Allow for a single unterminated function call */
#endif
 
    index = acutest_worker_index_;
    for(i = 0; acutest_list_[i].func != NULL; i++) {
        if(acutest_test_data_[i].state == ACUTEST_STATE_NEEDTORUN)
            acutest_run_(&acutest_list_[i], index++, i);
    }
 
#ifdef TEST_GLOBAL_FINI
    TEST_GLOBAL_FINI
    ; /* Allow for a single unterminated function call */
#endif
 
    /* Write a summary */
    if(!acutest_no_summary_ && acutest_verbose_level_ >= 1) {
        int n_run, n_success, n_failed ;
 
        n_run = acutest_list_size_ - acutest_count_(ACUTEST_STATE_EXCLUDED);
        n_success = acutest_count_(ACUTEST_STATE_SUCCESS);
        n_failed = acutest_count_(ACUTEST_STATE_FAILED);
 
        if(acutest_verbose_level_ >= 3) {
            acutest_colored_printf_(ACUTEST_COLOR_DEFAULT_INTENSIVE_, "Summary:\n");
 
            printf("  Count of run unit tests:        %4d\n", n_run);
            printf("  Count of successful unit tests: %4d\n", n_success);
            printf("  Count of failed unit tests:     %4d\n", n_failed);
        }
 
        if(n_failed == 0) {
            acutest_colored_printf_(ACUTEST_COLOR_GREEN_INTENSIVE_, "SUCCESS:");
            printf(" No unit tests have failed.\n");
        } else {
            acutest_colored_printf_(ACUTEST_COLOR_RED_INTENSIVE_, "FAILED:");
            printf(" %d of %d unit tests %s failed.\n",
                    n_failed, n_run, (n_failed == 1) ? "has" : "have");
        }
 
        if(acutest_verbose_level_ >= 3)
            printf("\n");
    }
 
    if (acutest_xml_output_) {
        const char* suite_name = acutest_basename_(argv[0]);
        acutest_data_log_* log_entry;
        fprintf(acutest_xml_output_, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
        fprintf(acutest_xml_output_, "<testsuite name=\"%s\" tests=\"%d\" errors=\"0\" failures=\"%d\" skip=\"%d\">\n",
            suite_name,
            (int)acutest_list_size_,
            acutest_count_(ACUTEST_STATE_FAILED),
            acutest_count_(ACUTEST_STATE_SKIPPED) + acutest_count_(ACUTEST_STATE_EXCLUDED));
        for(i = 0; acutest_list_[i].func != NULL; i++) {
            struct acutest_test_data_ *details = &acutest_test_data_[i];
            const char* str_state;
            fprintf(acutest_xml_output_, "  <testcase name=\"%s\" time=\"%.2f\">\n", acutest_list_[i].name, details->duration);
 
            switch(details->state) {
                case ACUTEST_STATE_SUCCESS:     str_state = NULL; break;
                case ACUTEST_STATE_EXCLUDED:    /* Fall through. */
                case ACUTEST_STATE_SKIPPED:     str_state = "<skipped />"; break;
                case ACUTEST_STATE_FAILED:      /* Fall through. */
                default:                        str_state = "<failure />"; break;
            }
 
            if(str_state != NULL)
                fprintf(acutest_xml_output_, "    %s\n", str_state);
            log_entry = details->log_head;
            while (log_entry) {
                fprintf(acutest_xml_output_, "    <system-out>%s</system-out>\n", log_entry->msg);
                log_entry = log_entry->next;
            }
            fprintf(acutest_xml_output_, "  </testcase>\n");
        }
        fprintf(acutest_xml_output_, "</testsuite>\n");
        fclose(acutest_xml_output_);
    }
 
    if(acutest_worker_  &&  acutest_count_(ACUTEST_STATE_EXCLUDED)+1 == acutest_list_size_) {
        /* If we are the child process, we need to propagate the test state
         * without any moderation. */
        for(i = 0; acutest_list_[i].func != NULL; i++) {
            if(acutest_test_data_[i].state != ACUTEST_STATE_EXCLUDED) {
                exit_code = (int) acutest_test_data_[i].state;
                break;
            }
        }
    } else {
        if(acutest_count_(ACUTEST_STATE_FAILED) > 0)
            exit_code = 1;
        else
            exit_code = 0;
    }
 
    acutest_cleanup_();
    return exit_code;
}
 
 
#endif  /* #ifndef TEST_NO_MAIN */
 
#ifdef _MSC_VER
    #pragma warning(pop)
#endif
 
#ifdef __cplusplus
    }  /* extern "C" */
#endif
 
#endif  /* #ifndef ACUTEST_H */