/* * CUTest -- C/C++ Unit Test facility * <http://github.com/mity/cutest> * * Copyright (c) 2013-2017 Martin Mitas * * 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 CUTEST_H__ #define CUTEST_H__ /************************ *** Public interface *** ************************/ /* By default, <cutest.h> provides the main program entry point (function * main()). However, if the test suite is composed of multiple source files * which include <cutest.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 }, * ... * { 0 } * }; * * 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 tp be compatible * with this prototype: * * void test_func(void); */ #define TEST_LIST const struct test__ test_list__[] /* 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, ...) \ test_check__((cond), __FILE__, __LINE__, __VA_ARGS__) #define TEST_CHECK(cond) test_check__((cond), __FILE__, __LINE__, "%s", #cond) /********************** *** Implementation *** **********************/ /* The unit test files should not rely on anything below. */ #include <stdarg.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #if defined(unix) || defined(__unix__) || defined(__unix) || defined(__APPLE__) #define CUTEST_UNIX__ 1 #include <errno.h> #include <unistd.h> #include <sys/types.h> #include <sys/wait.h> #include <signal.h> #endif #if defined(_WIN32) || defined(__WIN32__) || defined(__WINDOWS__) #define CUTEST_WIN__ 1 #include <windows.h> #include <io.h> #endif #ifdef __cplusplus #include <exception> #endif /* Note our global private identifiers end with '__' to mitigate risk of clash * with the unit tests implementation. */ #ifdef __cplusplus extern "C" { #endif struct test__ { const char *name; void (*func)(void); }; extern const struct test__ test_list__[]; int test_check__(int cond, const char *file, int line, const char *fmt, ...); #ifndef TEST_NO_MAIN static char *test_argv0__ = NULL; static int test_count__ = 0; static int test_no_exec__ = 0; static int test_no_summary__ = 0; static int test_skip_mode__ = 0; static int test_stat_failed_units__ = 0; static int test_stat_run_units__ = 0; static const struct test__ *test_current_unit__ = NULL; static int test_current_already_logged__ = 0; static int test_verbose_level__ = 2; static int test_current_failures__ = 0; static int test_colorize__ = 0; #define CUTEST_COLOR_DEFAULT__ 0 #define CUTEST_COLOR_GREEN__ 1 #define CUTEST_COLOR_RED__ 2 #define CUTEST_COLOR_DEFAULT_INTENSIVE__ 3 #define CUTEST_COLOR_GREEN_INTENSIVE__ 4 #define CUTEST_COLOR_RED_INTENSIVE__ 5 static size_t test_print_in_color__(int color, const char *fmt, ...) { va_list args; char buffer[256]; size_t n; va_start(args, fmt); vsnprintf(buffer, sizeof(buffer), fmt, args); va_end(args); buffer[sizeof(buffer) - 1] = '\0'; if (!test_colorize__) { return printf("%s", buffer); } #if defined CUTEST_UNIX__ { const char *col_str; switch (color) { case CUTEST_COLOR_GREEN__: col_str = "\033[0;32m"; break; case CUTEST_COLOR_RED__: col_str = "\033[0;31m"; break; case CUTEST_COLOR_GREEN_INTENSIVE__: col_str = "\033[1;32m"; break; case CUTEST_COLOR_RED_INTENSIVE__: col_str = "\033[1;30m"; break; case CUTEST_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 CUTEST_WIN__ { HANDLE h; CONSOLE_SCREEN_BUFFER_INFO info; WORD attr; h = GetStdHandle(STD_OUTPUT_HANDLE); GetConsoleScreenBufferInfo(h, &info); switch (color) { case CUTEST_COLOR_GREEN__: attr = FOREGROUND_GREEN; break; case CUTEST_COLOR_RED__: attr = FOREGROUND_RED; break; case CUTEST_COLOR_GREEN_INTENSIVE__: attr = FOREGROUND_GREEN | FOREGROUND_INTENSITY; break; case CUTEST_COLOR_RED_INTENSIVE__: attr = FOREGROUND_RED | FOREGROUND_INTENSITY; break; case CUTEST_COLOR_DEFAULT_INTENSIVE__: attr = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | 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 } int test_check__(int cond, const char *file, int line, const char *fmt, ...) { const char *result_str; int result_color; int verbose_level; if (cond) { result_str = "ok"; result_color = CUTEST_COLOR_GREEN__; verbose_level = 3; } else { if (!test_current_already_logged__ && test_current_unit__ != NULL) { printf("[ "); test_print_in_color__(CUTEST_COLOR_RED_INTENSIVE__, "FAILED"); printf(" ]\n"); } result_str = "failed"; result_color = CUTEST_COLOR_RED__; verbose_level = 2; test_current_failures__++; test_current_already_logged__++; } if (test_verbose_level__ >= verbose_level) { size_t n = 0; va_list args; printf(" "); if (file != NULL) n += printf("%s:%d: Check ", file, line); va_start(args, fmt); n += vprintf(fmt, args); va_end(args); printf("... "); test_print_in_color__(result_color, result_str); printf("\n"); test_current_already_logged__++; } return (cond != 0); } static void test_list_names__(void) { const struct test__ *test; printf("Unit tests:\n"); for (test = &test_list__[0]; test->func != NULL; test++) printf(" %s\n", test->name); } static const struct test__ *test_by_name__(const char *name) { const struct test__ *test; for (test = &test_list__[0]; test->func != NULL; test++) { if (strcmp(test->name, name) == 0) return test; } return NULL; } /* Call directly the given test unit function. */ static int test_do_run__(const struct test__ *test) { test_current_unit__ = test; test_current_failures__ = 0; test_current_already_logged__ = 0; if (test_verbose_level__ >= 3) { test_print_in_color__(CUTEST_COLOR_DEFAULT_INTENSIVE__, "Test %s:\n", test->name); test_current_already_logged__++; } else if (test_verbose_level__ >= 1) { size_t n; char spaces[32]; n = test_print_in_color__(CUTEST_COLOR_DEFAULT_INTENSIVE__, "Test %s... ", test->name); memset(spaces, ' ', sizeof(spaces)); if (n < sizeof(spaces)) printf("%.*s", (int)(sizeof(spaces) - n), spaces); } else { test_current_already_logged__ = 1; } #ifdef __cplusplus try { #endif /* This is good to do for case the test unit e.g. crashes. */ fflush(stdout); fflush(stderr); test->func(); #ifdef __cplusplus } catch (std::exception &e) { const char *what = e.what(); if (what != NULL) test_check__(0, NULL, 0, "Threw std::exception: %s", what); else test_check__(0, NULL, 0, "Threw std::exception"); } catch (...) { test_check__(0, NULL, 0, "Threw an exception"); } #endif if (test_verbose_level__ >= 3) { switch (test_current_failures__) { case 0: test_print_in_color__(CUTEST_COLOR_GREEN_INTENSIVE__, " All conditions have passed.\n\n"); break; case 1: test_print_in_color__(CUTEST_COLOR_RED_INTENSIVE__, " One condition has FAILED.\n\n"); break; default: test_print_in_color__(CUTEST_COLOR_RED_INTENSIVE__, " %d conditions have FAILED.\n\n", test_current_failures__); break; } } else if (test_verbose_level__ >= 1 && test_current_failures__ == 0) { printf("[ "); test_print_in_color__(CUTEST_COLOR_GREEN_INTENSIVE__, "OK"); printf(" ]\n"); } test_current_unit__ = NULL; return (test_current_failures__ == 0) ? 0 : -1; } #if defined(CUTEST_UNIX__) || defined(CUTEST_WIN__) /* Called if anything goes bad in cutest, 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 test_error__(const char *fmt, ...) { va_list args; if (test_verbose_level__ == 0) return; if (test_verbose_level__ <= 2 && !test_current_already_logged__ && test_current_unit__ != NULL) { printf("[ "); test_print_in_color__(CUTEST_COLOR_RED_INTENSIVE__, "FAILED"); printf(" ]\n"); } if (test_verbose_level__ >= 2) { test_print_in_color__(CUTEST_COLOR_RED_INTENSIVE__, " Error: "); va_start(args, fmt); vprintf(fmt, args); va_end(args); printf("\n"); } } #endif /* Trigger the unit test. If possible (and not suppressed) it starts a child * process who calls test_do_run__(), otherwise it calls test_do_run__() * directly. */ static void test_run__(const struct test__ *test) { int failed = 1; test_current_unit__ = test; test_current_already_logged__ = 0; if (!test_no_exec__) { #if defined(CUTEST_UNIX__) pid_t pid; int exit_code; pid = fork(); if (pid == (pid_t)-1) { test_error__("Cannot fork. %s [%d]", strerror(errno), errno); failed = 1; } else if (pid == 0) { /* Child: Do the test. */ failed = (test_do_run__(test) != 0); exit(failed ? 1 : 0); } else { /* Parent: Wait until child terminates and analyze its exit code. */ waitpid(pid, &exit_code, 0); if (WIFEXITED(exit_code)) { switch (WEXITSTATUS(exit_code)) { case 0: failed = 0; break; /* test has passed. */ case 1: /* noop */ break; /* "normal" failure. */ default: test_error__("Unexpected exit code [%d]", 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: sprintf(tmp, "signal %d", WTERMSIG(exit_code)); signame = tmp; break; } test_error__("Test interrupted by %s", signame); } else { test_error__("Test ended in an unexpected way [%d]", exit_code); } } #elif defined(CUTEST_WIN__) char buffer[512] = { 0 }; STARTUPINFOA startupInfo = { 0 }; PROCESS_INFORMATION processInfo; DWORD exitCode; /* Windows has no fork(). So we propagate all info into the child * through a command line arguments. */ _snprintf(buffer, sizeof(buffer) - 1, "%s --no-exec --no-summary --verbose=%d --color=%s -- \"%s\"", test_argv0__, test_verbose_level__, test_colorize__ ? "always" : "never", test->name); startupInfo.cb = sizeof(STARTUPINFO); if (CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0, NULL, NULL, &startupInfo, &processInfo)) { WaitForSingleObject(processInfo.hProcess, INFINITE); GetExitCodeProcess(processInfo.hProcess, &exitCode); CloseHandle(processInfo.hThread); CloseHandle(processInfo.hProcess); failed = (exitCode != 0); } else { test_error__("Cannot create unit test subprocess [%ld].", GetLastError()); failed = 1; } #else /* A platform where we don't know how to run child process. */ failed = (test_do_run__(test) != 0); #endif } else { /* Child processes suppressed through --no-exec. */ failed = (test_do_run__(test) != 0); } test_current_unit__ = NULL; test_stat_run_units__++; if (failed) test_stat_failed_units__++; } #if defined(CUTEST_WIN__) /* Callback for SEH events. */ static LONG CALLBACK test_exception_filter__(EXCEPTION_POINTERS *ptrs) { test_error__("Unhandled SEH exception %08lx at %p.", ptrs->ExceptionRecord->ExceptionCode, ptrs->ExceptionRecord->ExceptionAddress); fflush(stdout); fflush(stderr); return EXCEPTION_EXECUTE_HANDLER; } #endif static void test_help__(void) { printf("Usage: %s [options] [test...]\n", test_argv0__); printf("Run the specified unit tests; or if the option '--skip' 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( " -s, --skip Execute all unit tests but the listed ones\n"); printf(" --no-exec Do not execute unit tests as child " "processes\n"); printf( " --no-summary Suppress printing of test results summary\n"); printf(" -l, --list List unit tests in the suite and exit\n"); printf(" -v, --verbose Enable more verbose output\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(" --color=WHEN Enable colorized output (WHEN is one of " "'auto', 'always', 'never')\n"); printf(" -h, --help Display this help and exit\n"); printf("\n"); test_list_names__(); } int main(int argc, char **argv) { const struct test__ **tests = NULL; int i, j, n = 0; int seen_double_dash = 0; test_argv0__ = argv[0]; #if defined CUTEST_UNIX__ test_colorize__ = isatty(STDOUT_FILENO); #elif defined CUTEST_WIN__ test_colorize__ = _isatty(_fileno(stdout)); #else test_colorize__ = 0; #endif /* Parse options */ for (i = 1; i < argc; i++) { if (seen_double_dash || argv[i][0] != '-') { tests = (const struct test__ **)realloc( (void *)tests, (n + 1) * sizeof(const struct test__ *)); if (tests == NULL) { fprintf(stderr, "Out of memory.\n"); exit(2); } tests[n] = test_by_name__(argv[i]); if (tests[n] == NULL) { fprintf(stderr, "%s: Unrecognized unit test '%s'\n", argv[0], argv[i]); fprintf(stderr, "Try '%s --list' for list of unit tests.\n", argv[0]); exit(2); } n++; } else if (strcmp(argv[i], "--") == 0) { seen_double_dash = 1; } else if (strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-h") == 0) { test_help__(); exit(0); } else if (strcmp(argv[i], "--verbose") == 0 || strcmp(argv[i], "-v") == 0) { test_verbose_level__++; } else if (strncmp(argv[i], "--verbose=", 10) == 0) { test_verbose_level__ = atoi(argv[i] + 10); } else if (strcmp(argv[i], "--color=auto") == 0) { /* noop (set from above) */ } else if (strcmp(argv[i], "--color=always") == 0 || strcmp(argv[i], "--color") == 0) { test_colorize__ = 1; } else if (strcmp(argv[i], "--color=never") == 0) { test_colorize__ = 0; } else if (strcmp(argv[i], "--skip") == 0 || strcmp(argv[i], "-s") == 0) { test_skip_mode__ = 1; } else if (strcmp(argv[i], "--no-exec") == 0) { test_no_exec__ = 1; } else if (strcmp(argv[i], "--no-summary") == 0) { test_no_summary__ = 1; } else if (strcmp(argv[i], "--list") == 0 || strcmp(argv[i], "-l") == 0) { test_list_names__(); exit(0); } else { fprintf(stderr, "%s: Unrecognized option '%s'\n", argv[0], argv[i]); fprintf(stderr, "Try '%s --help' for more information.\n", argv[0]); exit(2); } } #if defined(CUTEST_WIN__) SetUnhandledExceptionFilter(test_exception_filter__); #endif /* Count all test units */ test_count__ = 0; for (i = 0; test_list__[i].func != NULL; i++) test_count__++; /* Run the tests */ if (n == 0) { /* Run all tests */ for (i = 0; test_list__[i].func != NULL; i++) test_run__(&test_list__[i]); } else if (!test_skip_mode__) { /* Run the listed tests */ for (i = 0; i < n; i++) test_run__(tests[i]); } else { /* Run all tests except those listed */ for (i = 0; test_list__[i].func != NULL; i++) { int want_skip = 0; for (j = 0; j < n; j++) { if (tests[j] == &test_list__[i]) { want_skip = 1; break; } } if (!want_skip) test_run__(&test_list__[i]); } } /* Write a summary */ if (!test_no_summary__ && test_verbose_level__ >= 1) { test_print_in_color__(CUTEST_COLOR_DEFAULT_INTENSIVE__, "\nSummary:\n"); if (test_verbose_level__ >= 3) { printf(" Count of all unit tests: %4d\n", test_count__); printf(" Count of run unit tests: %4d\n", test_stat_run_units__); printf(" Count of failed unit tests: %4d\n", test_stat_failed_units__); printf(" Count of skipped unit tests: %4d\n", test_count__ - test_stat_run_units__); } if (test_stat_failed_units__ == 0) { test_print_in_color__(CUTEST_COLOR_GREEN_INTENSIVE__, " SUCCESS: All unit tests have passed.\n"); } else { test_print_in_color__( CUTEST_COLOR_RED_INTENSIVE__, " FAILED: %d of %d unit tests have failed.\n", test_stat_failed_units__, test_stat_run_units__); } } if (tests != NULL) free((void *)tests); return (test_stat_failed_units__ == 0) ? 0 : 1; } #endif /* #ifndef TEST_NO_MAIN */ #ifdef __cplusplus } /* extern "C" */ #endif #endif /* #ifndef CUTEST_H__ */