LCOV - code coverage report
Current view: top level - third_party/cmocka - cmocka.c (source / functions) Hit Total Coverage
Test: coverage report for master 6248eab5 Lines: 511 1420 36.0 %
Date: 2021-08-25 13:27:56 Functions: 74 128 57.8 %

          Line data    Source code
       1             : /*
       2             :  * Copyright 2008 Google Inc.
       3             :  * Copyright 2014-2018 Andreas Schneider <asn@cryptomilk.org>
       4             :  * Copyright 2015      Jakub Hrozek <jakub.hrozek@posteo.se>
       5             :  *
       6             :  * Licensed under the Apache License, Version 2.0 (the "License");
       7             :  * you may not use this file except in compliance with the License.
       8             :  * You may obtain a copy of the License at
       9             :  *
      10             :  * http://www.apache.org/licenses/LICENSE-2.0
      11             :  *
      12             :  * Unless required by applicable law or agreed to in writing, software
      13             :  * distributed under the License is distributed on an "AS IS" BASIS,
      14             :  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      15             :  * See the License for the specific language governing permissions and
      16             :  * limitations under the License.
      17             :  */
      18             : #ifdef HAVE_CONFIG_H
      19             : #include "config.h"
      20             : #endif
      21             : 
      22             : #ifdef HAVE_MALLOC_H
      23             : #include <malloc.h>
      24             : #endif
      25             : 
      26             : #ifdef HAVE_INTTYPES_H
      27             : #include <inttypes.h>
      28             : #endif
      29             : 
      30             : #ifdef HAVE_SIGNAL_H
      31             : #include <signal.h>
      32             : #endif
      33             : 
      34             : #ifdef HAVE_STRINGS_H
      35             : #include <strings.h>
      36             : #endif
      37             : 
      38             : #include <stdint.h>
      39             : #include <setjmp.h>
      40             : #include <stdarg.h>
      41             : #include <stddef.h>
      42             : #include <stdio.h>
      43             : #include <stdlib.h>
      44             : #include <string.h>
      45             : #include <time.h>
      46             : 
      47             : /*
      48             :  * This allows to add a platform specific header file. Some embedded platforms
      49             :  * sometimes miss certain types and definitions.
      50             :  *
      51             :  * Example:
      52             :  *
      53             :  * typedef unsigned long int uintptr_t
      54             :  * #define _UINTPTR_T 1
      55             :  * #define _UINTPTR_T_DEFINED 1
      56             :  */
      57             : #ifdef CMOCKA_PLATFORM_INCLUDE
      58             : # include "cmocka_platform.h"
      59             : #endif /* CMOCKA_PLATFORM_INCLUDE */
      60             : 
      61             : #include <cmocka.h>
      62             : #include <cmocka_private.h>
      63             : 
      64             : /* Size of guard bytes around dynamically allocated blocks. */
      65             : #define MALLOC_GUARD_SIZE 16
      66             : /* Pattern used to initialize guard blocks. */
      67             : #define MALLOC_GUARD_PATTERN 0xEF
      68             : /* Pattern used to initialize memory allocated with test_malloc(). */
      69             : #define MALLOC_ALLOC_PATTERN 0xBA
      70             : #define MALLOC_FREE_PATTERN 0xCD
      71             : /* Alignment of allocated blocks.  NOTE: This must be base2. */
      72             : #define MALLOC_ALIGNMENT sizeof(size_t)
      73             : 
      74             : /* Printf formatting for source code locations. */
      75             : #define SOURCE_LOCATION_FORMAT "%s:%u"
      76             : 
      77             : #if defined(HAVE_GCC_THREAD_LOCAL_STORAGE)
      78             : # define CMOCKA_THREAD __thread
      79             : #elif defined(HAVE_MSVC_THREAD_LOCAL_STORAGE)
      80             : # define CMOCKA_THREAD __declspec(thread)
      81             : #else
      82             : # define CMOCKA_THREAD
      83             : #endif
      84             : 
      85             : #ifdef HAVE_CLOCK_REALTIME
      86             : #define CMOCKA_CLOCK_GETTIME(clock_id, ts) clock_gettime((clock_id), (ts))
      87             : #else
      88             : #define CMOCKA_CLOCK_GETTIME(clock_id, ts)
      89             : #endif
      90             : 
      91             : #ifndef MAX
      92             : #define MAX(a,b) ((a) < (b) ? (b) : (a))
      93             : #endif
      94             : 
      95             : /**
      96             :  * POSIX has sigsetjmp/siglongjmp, while Windows only has setjmp/longjmp.
      97             :  */
      98             : #ifdef HAVE_SIGLONGJMP
      99             : # define cm_jmp_buf             sigjmp_buf
     100             : # define cm_setjmp(env)         sigsetjmp(env, 1)
     101             : # define cm_longjmp(env, val)   siglongjmp(env, val)
     102             : #else
     103             : # define cm_jmp_buf             jmp_buf
     104             : # define cm_setjmp(env)         setjmp(env)
     105             : # define cm_longjmp(env, val)   longjmp(env, val)
     106             : #endif
     107             : 
     108             : 
     109             : /*
     110             :  * Declare and initialize the pointer member of ValuePointer variable name
     111             :  * with ptr.
     112             :  */
     113             : #define declare_initialize_value_pointer_pointer(name, ptr) \
     114             :     ValuePointer name ; \
     115             :     name.value = 0; \
     116             :     name.x.pointer = (void*)(ptr)
     117             : 
     118             : /*
     119             :  * Declare and initialize the value member of ValuePointer variable name
     120             :  * with val.
     121             :  */
     122             : #define declare_initialize_value_pointer_value(name, val) \
     123             :     ValuePointer name ; \
     124             :     name.value = val
     125             : 
     126             : /* Cast a LargestIntegralType to pointer_type via a ValuePointer. */
     127             : #define cast_largest_integral_type_to_pointer( \
     128             :     pointer_type, largest_integral_type) \
     129             :     ((pointer_type)((ValuePointer*)&(largest_integral_type))->x.pointer)
     130             : 
     131             : /* Used to cast LargetIntegralType to void* and vice versa. */
     132             : typedef union ValuePointer {
     133             :     LargestIntegralType value;
     134             :     struct {
     135             : #if defined(WORDS_BIGENDIAN) && (WORDS_SIZEOF_VOID_P == 4)
     136             :         unsigned int padding;
     137             : #endif
     138             :         void *pointer;
     139             :     } x;
     140             : } ValuePointer;
     141             : 
     142             : /* Doubly linked list node. */
     143             : typedef struct ListNode {
     144             :     const void *value;
     145             :     int refcount;
     146             :     struct ListNode *next;
     147             :     struct ListNode *prev;
     148             : } ListNode;
     149             : 
     150             : /* Debug information for malloc(). */
     151             : struct MallocBlockInfoData {
     152             :     void* block;              /* Address of the block returned by malloc(). */
     153             :     size_t allocated_size;    /* Total size of the allocated block. */
     154             :     size_t size;              /* Request block size. */
     155             :     SourceLocation location;  /* Where the block was allocated. */
     156             :     ListNode node;            /* Node within list of all allocated blocks. */
     157             : };
     158             : 
     159             : typedef union {
     160             :     struct MallocBlockInfoData *data;
     161             :     char *ptr;
     162             : } MallocBlockInfo;
     163             : 
     164             : /* State of each test. */
     165             : typedef struct TestState {
     166             :     const ListNode *check_point; /* Check point of the test if there's a */
     167             :                                  /* setup function. */
     168             :     void *state;                 /* State associated with the test. */
     169             : } TestState;
     170             : 
     171             : /* Determines whether two values are the same. */
     172             : typedef int (*EqualityFunction)(const void *left, const void *right);
     173             : 
     174             : /* Value of a symbol and the place it was declared. */
     175             : typedef struct SymbolValue {
     176             :     SourceLocation location;
     177             :     LargestIntegralType value;
     178             : } SymbolValue;
     179             : 
     180             : /*
     181             :  * Contains a list of values for a symbol.
     182             :  * NOTE: Each structure referenced by symbol_values_list_head must have a
     183             :  * SourceLocation as its' first member.
     184             :  */
     185             : typedef struct SymbolMapValue {
     186             :     const char *symbol_name;
     187             :     ListNode symbol_values_list_head;
     188             : } SymbolMapValue;
     189             : 
     190             : /* Where a particular ordering was located and its symbol name */
     191             : typedef struct FuncOrderingValue {
     192             :     SourceLocation location;
     193             :     const char * function;
     194             : } FuncOrderingValue;
     195             : 
     196             : /* Used by list_free() to deallocate values referenced by list nodes. */
     197             : typedef void (*CleanupListValue)(const void *value, void *cleanup_value_data);
     198             : 
     199             : /* Structure used to check the range of integer types.a */
     200             : typedef struct CheckIntegerRange {
     201             :     CheckParameterEvent event;
     202             :     LargestIntegralType minimum;
     203             :     LargestIntegralType maximum;
     204             : } CheckIntegerRange;
     205             : 
     206             : /* Structure used to check whether an integer value is in a set. */
     207             : typedef struct CheckIntegerSet {
     208             :     CheckParameterEvent event;
     209             :     const LargestIntegralType *set;
     210             :     size_t size_of_set;
     211             : } CheckIntegerSet;
     212             : 
     213             : /* Used to check whether a parameter matches the area of memory referenced by
     214             :  * this structure.  */
     215             : typedef struct CheckMemoryData {
     216             :     CheckParameterEvent event;
     217             :     const void *memory;
     218             :     size_t size;
     219             : } CheckMemoryData;
     220             : 
     221             : static ListNode* list_initialize(ListNode * const node);
     222             : static ListNode* list_add(ListNode * const head, ListNode *new_node);
     223             : static ListNode* list_add_value(ListNode * const head, const void *value,
     224             :                                      const int count);
     225             : static ListNode* list_remove(
     226             :     ListNode * const node, const CleanupListValue cleanup_value,
     227             :     void * const cleanup_value_data);
     228             : static void list_remove_free(
     229             :     ListNode * const node, const CleanupListValue cleanup_value,
     230             :     void * const cleanup_value_data);
     231             : static int list_empty(const ListNode * const head);
     232             : static int list_find(
     233             :     ListNode * const head, const void *value,
     234             :     const EqualityFunction equal_func, ListNode **output);
     235             : static int list_first(ListNode * const head, ListNode **output);
     236             : static ListNode* list_free(
     237             :     ListNode * const head, const CleanupListValue cleanup_value,
     238             :     void * const cleanup_value_data);
     239             : 
     240             : static void add_symbol_value(
     241             :     ListNode * const symbol_map_head, const char * const symbol_names[],
     242             :     const size_t number_of_symbol_names, const void* value, const int count);
     243             : static int get_symbol_value(
     244             :     ListNode * const symbol_map_head, const char * const symbol_names[],
     245             :     const size_t number_of_symbol_names, void **output);
     246             : static void free_value(const void *value, void *cleanup_value_data);
     247             : static void free_symbol_map_value(
     248             :     const void *value, void *cleanup_value_data);
     249             : static void remove_always_return_values(ListNode * const map_head,
     250             :                                         const size_t number_of_symbol_names);
     251             : 
     252             : static size_t check_for_leftover_values_list(const ListNode * head,
     253             :                                              const char * const error_message);
     254             : 
     255             : static size_t check_for_leftover_values(
     256             :     const ListNode * const map_head, const char * const error_message,
     257             :     const size_t number_of_symbol_names);
     258             : 
     259             : static void remove_always_return_values_from_list(ListNode * const map_head);
     260             : 
     261             : /*
     262             :  * This must be called at the beginning of a test to initialize some data
     263             :  * structures.
     264             :  */
     265             : static void initialize_testing(const char *test_name);
     266             : 
     267             : /* This must be called at the end of a test to free() allocated structures. */
     268             : static void teardown_testing(const char *test_name);
     269             : 
     270             : static enum cm_message_output cm_get_output(void);
     271             : 
     272             : static int cm_error_message_enabled = 1;
     273             : static CMOCKA_THREAD char *cm_error_message;
     274             : 
     275             : void cm_print_error(const char * const format, ...) CMOCKA_PRINTF_ATTRIBUTE(1, 2);
     276             : 
     277             : /*
     278             :  * Keeps track of the calling context returned by setenv() so that the fail()
     279             :  * method can jump out of a test.
     280             :  */
     281             : static CMOCKA_THREAD cm_jmp_buf global_run_test_env;
     282             : static CMOCKA_THREAD int global_running_test = 0;
     283             : 
     284             : /* Keeps track of the calling context returned by setenv() so that */
     285             : /* mock_assert() can optionally jump back to expect_assert_failure(). */
     286             : jmp_buf global_expect_assert_env;
     287             : int global_expecting_assert = 0;
     288             : const char *global_last_failed_assert = NULL;
     289             : static int global_skip_test;
     290             : 
     291             : /* Keeps a map of the values that functions will have to return to provide */
     292             : /* mocked interfaces. */
     293             : static CMOCKA_THREAD ListNode global_function_result_map_head;
     294             : /* Location of the last mock value returned was declared. */
     295             : static CMOCKA_THREAD SourceLocation global_last_mock_value_location;
     296             : 
     297             : /* Keeps a map of the values that functions expect as parameters to their
     298             :  * mocked interfaces. */
     299             : static CMOCKA_THREAD ListNode global_function_parameter_map_head;
     300             : /* Location of last parameter value checked was declared. */
     301             : static CMOCKA_THREAD SourceLocation global_last_parameter_location;
     302             : 
     303             : /* List (acting as FIFO) of call ordering. */
     304             : static CMOCKA_THREAD ListNode global_call_ordering_head;
     305             : /* Location of last call ordering that was declared. */
     306             : static CMOCKA_THREAD SourceLocation global_last_call_ordering_location;
     307             : 
     308             : /* List of all currently allocated blocks. */
     309             : static CMOCKA_THREAD ListNode global_allocated_blocks;
     310             : 
     311             : static enum cm_message_output global_msg_output = CM_OUTPUT_STDOUT;
     312             : 
     313             : static const char *global_test_filter_pattern;
     314             : 
     315             : #ifndef _WIN32
     316             : /* Signals caught by exception_handler(). */
     317             : static const int exception_signals[] = {
     318             :     SIGFPE,
     319             :     SIGILL,
     320             :     SIGSEGV,
     321             : #ifdef SIGBUS
     322             :     SIGBUS,
     323             : #endif
     324             : #ifdef SIGSYS
     325             :     SIGSYS,
     326             : #endif
     327             : };
     328             : 
     329             : /* Default signal functions that should be restored after a test is complete. */
     330             : typedef void (*SignalFunction)(int signal);
     331             : static SignalFunction default_signal_functions[
     332             :     ARRAY_SIZE(exception_signals)];
     333             : 
     334             : #else /* _WIN32 */
     335             : 
     336             : /* The default exception filter. */
     337             : static LPTOP_LEVEL_EXCEPTION_FILTER previous_exception_filter;
     338             : 
     339             : /* Fatal exceptions. */
     340             : typedef struct ExceptionCodeInfo {
     341             :     DWORD code;
     342             :     const char* description;
     343             : } ExceptionCodeInfo;
     344             : 
     345             : #define EXCEPTION_CODE_INFO(exception_code) {exception_code, #exception_code}
     346             : 
     347             : static const ExceptionCodeInfo exception_codes[] = {
     348             :     EXCEPTION_CODE_INFO(EXCEPTION_ACCESS_VIOLATION),
     349             :     EXCEPTION_CODE_INFO(EXCEPTION_ARRAY_BOUNDS_EXCEEDED),
     350             :     EXCEPTION_CODE_INFO(EXCEPTION_DATATYPE_MISALIGNMENT),
     351             :     EXCEPTION_CODE_INFO(EXCEPTION_FLT_DENORMAL_OPERAND),
     352             :     EXCEPTION_CODE_INFO(EXCEPTION_FLT_DIVIDE_BY_ZERO),
     353             :     EXCEPTION_CODE_INFO(EXCEPTION_FLT_INEXACT_RESULT),
     354             :     EXCEPTION_CODE_INFO(EXCEPTION_FLT_INVALID_OPERATION),
     355             :     EXCEPTION_CODE_INFO(EXCEPTION_FLT_OVERFLOW),
     356             :     EXCEPTION_CODE_INFO(EXCEPTION_FLT_STACK_CHECK),
     357             :     EXCEPTION_CODE_INFO(EXCEPTION_FLT_UNDERFLOW),
     358             :     EXCEPTION_CODE_INFO(EXCEPTION_GUARD_PAGE),
     359             :     EXCEPTION_CODE_INFO(EXCEPTION_ILLEGAL_INSTRUCTION),
     360             :     EXCEPTION_CODE_INFO(EXCEPTION_INT_DIVIDE_BY_ZERO),
     361             :     EXCEPTION_CODE_INFO(EXCEPTION_INT_OVERFLOW),
     362             :     EXCEPTION_CODE_INFO(EXCEPTION_INVALID_DISPOSITION),
     363             :     EXCEPTION_CODE_INFO(EXCEPTION_INVALID_HANDLE),
     364             :     EXCEPTION_CODE_INFO(EXCEPTION_IN_PAGE_ERROR),
     365             :     EXCEPTION_CODE_INFO(EXCEPTION_NONCONTINUABLE_EXCEPTION),
     366             :     EXCEPTION_CODE_INFO(EXCEPTION_PRIV_INSTRUCTION),
     367             :     EXCEPTION_CODE_INFO(EXCEPTION_STACK_OVERFLOW),
     368             : };
     369             : #endif /* !_WIN32 */
     370             : 
     371             : enum CMUnitTestStatus {
     372             :     CM_TEST_NOT_STARTED,
     373             :     CM_TEST_PASSED,
     374             :     CM_TEST_FAILED,
     375             :     CM_TEST_ERROR,
     376             :     CM_TEST_SKIPPED,
     377             : };
     378             : 
     379             : struct CMUnitTestState {
     380             :     const ListNode *check_point; /* Check point of the test if there's a setup function. */
     381             :     const struct CMUnitTest *test; /* Point to array element in the tests we get passed */
     382             :     void *state; /* State associated with the test */
     383             :     const char *error_message; /* The error messages by the test */
     384             :     enum CMUnitTestStatus status; /* PASSED, FAILED, ABORT ... */
     385             :     double runtime; /* Time calculations */
     386             : };
     387             : 
     388             : /* Exit the currently executing test. */
     389           0 : static void exit_test(const int quit_application)
     390             : {
     391           0 :     const char *env = getenv("CMOCKA_TEST_ABORT");
     392           0 :     int abort_test = 0;
     393             : 
     394           0 :     if (env != NULL && strlen(env) == 1) {
     395           0 :         abort_test = (env[0] == '1');
     396             :     }
     397             : 
     398           0 :     if (global_skip_test == 0 &&
     399             :         abort_test == 1) {
     400           0 :         print_error("%s", cm_error_message);
     401           0 :         abort();
     402           0 :     } else if (global_running_test) {
     403           0 :         cm_longjmp(global_run_test_env, 1);
     404           0 :     } else if (quit_application) {
     405           0 :         exit(-1);
     406             :     }
     407           0 : }
     408             : 
     409           0 : void _skip(const char * const file, const int line)
     410             : {
     411           0 :     cm_print_error(SOURCE_LOCATION_FORMAT ": Skipped!\n", file, line);
     412           0 :     global_skip_test = 1;
     413           0 :     exit_test(1);
     414           0 : }
     415             : 
     416             : /* Initialize a SourceLocation structure. */
     417        3204 : static void initialize_source_location(SourceLocation * const location) {
     418        5892 :     assert_non_null(location);
     419        5892 :     location->file = NULL;
     420        5892 :     location->line = 0;
     421        3204 : }
     422             : 
     423             : 
     424             : /* Determine whether a source location is currently set. */
     425           0 : static int source_location_is_set(const SourceLocation * const location) {
     426           0 :     assert_non_null(location);
     427           0 :     return location->file && location->line;
     428             : }
     429             : 
     430             : 
     431             : /* Set a source location. */
     432           0 : static void set_source_location(
     433             :     SourceLocation * const location, const char * const file,
     434             :     const int line) {
     435         193 :     assert_non_null(location);
     436         193 :     location->file = file;
     437         193 :     location->line = line;
     438           0 : }
     439             : 
     440             : 
     441           0 : static int c_strreplace(char *src,
     442             :                         size_t src_len,
     443             :                         const char *pattern,
     444             :                         const char *repl,
     445             :                         int *str_replaced)
     446             : {
     447           0 :     char *p = NULL;
     448             : 
     449           0 :     p = strstr(src, pattern);
     450           0 :     if (p == NULL) {
     451           0 :         return -1;
     452             :     }
     453             : 
     454             :     do {
     455           0 :         size_t of = p - src;
     456           0 :         size_t l  = strlen(src);
     457           0 :         size_t pl = strlen(pattern);
     458           0 :         size_t rl = strlen(repl);
     459             : 
     460             :         /* overflow check */
     461           0 :         if (src_len <= l + MAX(pl, rl) + 1) {
     462           0 :             return -1;
     463             :         }
     464             : 
     465           0 :         if (rl != pl) {
     466           0 :             memmove(src + of + rl, src + of + pl, l - of - pl + 1);
     467             :         }
     468             : 
     469           0 :         memcpy(src + of, repl, rl);
     470             : 
     471           0 :         if (str_replaced != NULL) {
     472           0 :             *str_replaced = 1;
     473             :         }
     474           0 :         p = strstr(src, pattern);
     475           0 :     } while (p != NULL);
     476             : 
     477           0 :     return 0;
     478             : }
     479             : 
     480           0 : static int c_strmatch(const char *str, const char *pattern)
     481             : {
     482             :     int ok;
     483             : 
     484           0 :     if (str == NULL || pattern == NULL) {
     485           0 :         return 0;
     486             :     }
     487             : 
     488             :     for (;;) {
     489             :         /* Check if pattern is done */
     490           0 :         if (*pattern == '\0') {
     491             :             /* If string is at the end, we're good */
     492           0 :             if (*str == '\0') {
     493           0 :                 return 1;
     494             :             }
     495             : 
     496           0 :             return 0;
     497             :         }
     498             : 
     499           0 :         if (*pattern == '*') {
     500             :             /* Move on */
     501           0 :             pattern++;
     502             : 
     503             :             /* If we are at the end, everything is fine */
     504           0 :             if (*pattern == '\0') {
     505           0 :                 return 1;
     506             :             }
     507             : 
     508             :             /* Try to match each position */
     509           0 :             for (; *str != '\0'; str++) {
     510           0 :                 ok = c_strmatch(str, pattern);
     511           0 :                 if (ok) {
     512           0 :                     return 1;
     513             :                 }
     514             :             }
     515             : 
     516             :             /* No match */
     517           0 :             return 0;
     518             :         }
     519             : 
     520             :         /* If we are at the end, leave */
     521           0 :         if (*str == '\0') {
     522           0 :             return 0;
     523             :         }
     524             : 
     525             :         /* Check if we have a single wildcard or matching char */
     526           0 :         if (*pattern != '?' && *str != *pattern) {
     527           0 :             return 0;
     528             :         }
     529             : 
     530             :         /* Move string and pattern */
     531           0 :         str++;
     532           0 :         pattern++;
     533             :     }
     534             : 
     535             :     return 0;
     536             : }
     537             : 
     538             : /* Create function results and expected parameter lists. */
     539         982 : void initialize_testing(const char *test_name) {
     540             :     (void)test_name;
     541         982 :     list_initialize(&global_function_result_map_head);
     542         982 :     initialize_source_location(&global_last_mock_value_location);
     543         982 :     list_initialize(&global_function_parameter_map_head);
     544         982 :     initialize_source_location(&global_last_parameter_location);
     545         982 :     list_initialize(&global_call_ordering_head);
     546         982 :     initialize_source_location(&global_last_parameter_location);
     547         982 : }
     548             : 
     549             : 
     550         982 : static void fail_if_leftover_values(const char *test_name) {
     551         982 :     int error_occurred = 0;
     552             :     (void)test_name;
     553         982 :     remove_always_return_values(&global_function_result_map_head, 1);
     554         982 :     if (check_for_leftover_values(
     555             :             &global_function_result_map_head,
     556             :             "%s() has remaining non-returned values.\n", 1)) {
     557           0 :         error_occurred = 1;
     558             :     }
     559             : 
     560         982 :     remove_always_return_values(&global_function_parameter_map_head, 2);
     561         982 :     if (check_for_leftover_values(
     562             :             &global_function_parameter_map_head,
     563             :             "'%s' parameter still has values that haven't been checked.\n",
     564             :             2)) {
     565           0 :         error_occurred = 1;
     566             :     }
     567             : 
     568         982 :     remove_always_return_values_from_list(&global_call_ordering_head);
     569         982 :     if (check_for_leftover_values_list(&global_call_ordering_head,
     570             :         "%s function was expected to be called but was not not.\n")) {
     571           0 :         error_occurred = 1;
     572             :     }
     573         982 :     if (error_occurred) {
     574           0 :         exit_test(1);
     575             :     }
     576         982 : }
     577             : 
     578             : 
     579         982 : static void teardown_testing(const char *test_name) {
     580             :     (void)test_name;
     581         982 :     list_free(&global_function_result_map_head, free_symbol_map_value,
     582             :               (void*)0);
     583         982 :     initialize_source_location(&global_last_mock_value_location);
     584         982 :     list_free(&global_function_parameter_map_head, free_symbol_map_value,
     585             :               (void*)1);
     586         982 :     initialize_source_location(&global_last_parameter_location);
     587         982 :     list_free(&global_call_ordering_head, free_value,
     588             :               (void*)0);
     589         982 :     initialize_source_location(&global_last_call_ordering_location);
     590         982 : }
     591             : 
     592             : /* Initialize a list node. */
     593        1617 : static ListNode* list_initialize(ListNode * const node) {
     594        3124 :     node->value = NULL;
     595        3171 :     node->next = node;
     596        3171 :     node->prev = node;
     597        3171 :     node->refcount = 1;
     598        1617 :     return node;
     599             : }
     600             : 
     601             : 
     602             : /*
     603             :  * Adds a value at the tail of a given list.
     604             :  * The node referencing the value is allocated from the heap.
     605             :  */
     606         356 : static ListNode* list_add_value(ListNode * const head, const void *value,
     607             :                                      const int refcount) {
     608         356 :     ListNode * const new_node = (ListNode*)malloc(sizeof(ListNode));
     609         356 :     assert_non_null(head);
     610         356 :     assert_non_null(value);
     611         356 :     new_node->value = value;
     612         356 :     new_node->refcount = refcount;
     613         356 :     return list_add(head, new_node);
     614             : }
     615             : 
     616             : 
     617             : /* Add new_node to the end of the list. */
     618         356 : static ListNode* list_add(ListNode * const head, ListNode *new_node) {
     619         356 :     assert_non_null(head);
     620         356 :     assert_non_null(new_node);
     621         356 :     new_node->next = head;
     622         356 :     new_node->prev = head->prev;
     623         356 :     head->prev->next = new_node;
     624         356 :     head->prev = new_node;
     625         356 :     return new_node;
     626             : }
     627             : 
     628             : 
     629             : /* Remove a node from a list. */
     630         356 : static ListNode* list_remove(
     631             :         ListNode * const node, const CleanupListValue cleanup_value,
     632             :         void * const cleanup_value_data) {
     633         356 :     assert_non_null(node);
     634         356 :     node->prev->next = node->next;
     635         356 :     node->next->prev = node->prev;
     636         356 :     if (cleanup_value) {
     637         163 :         cleanup_value(node->value, cleanup_value_data);
     638             :     }
     639         356 :     return node;
     640             : }
     641             : 
     642             : 
     643             : /* Remove a list node from a list and free the node. */
     644         356 : static void list_remove_free(
     645             :         ListNode * const node, const CleanupListValue cleanup_value,
     646             :         void * const cleanup_value_data) {
     647         356 :     assert_non_null(node);
     648         356 :     free(list_remove(node, cleanup_value, cleanup_value_data));
     649         356 : }
     650             : 
     651             : 
     652             : /*
     653             :  * Frees memory kept by a linked list The cleanup_value function is called for
     654             :  * every "value" field of nodes in the list, except for the head.  In addition
     655             :  * to each list value, cleanup_value_data is passed to each call to
     656             :  * cleanup_value.  The head of the list is not deallocated.
     657             :  */
     658        3109 : static ListNode* list_free(
     659             :         ListNode * const head, const CleanupListValue cleanup_value,
     660             :         void * const cleanup_value_data) {
     661        3109 :     assert_non_null(head);
     662        6218 :     while (!list_empty(head)) {
     663           0 :         list_remove_free(head->next, cleanup_value, cleanup_value_data);
     664             :     }
     665        3109 :     return head;
     666             : }
     667             : 
     668             : 
     669             : /* Determine whether a list is empty. */
     670        2136 : static int list_empty(const ListNode * const head) {
     671        4485 :     assert_non_null(head);
     672        4485 :     return head->next == head;
     673             : }
     674             : 
     675             : 
     676             : /*
     677             :  * Find a value in the list using the equal_func to compare each node with the
     678             :  * value.
     679             :  */
     680         402 : static int list_find(ListNode * const head, const void *value,
     681             :                      const EqualityFunction equal_func, ListNode **output) {
     682             :     ListNode *current;
     683         402 :     assert_non_null(head);
     684         523 :     for (current = head->next; current != head; current = current->next) {
     685         360 :         if (equal_func(current->value, value)) {
     686         239 :             *output = current;
     687         239 :             return 1;
     688             :         }
     689             :     }
     690           0 :     return 0;
     691             : }
     692             : 
     693             : /* Returns the first node of a list */
     694         193 : static int list_first(ListNode * const head, ListNode **output) {
     695         193 :     ListNode *target_node = NULL;
     696         193 :     assert_non_null(head);
     697         193 :     if (list_empty(head)) {
     698           0 :         return 0;
     699             :     }
     700         193 :     target_node = head->next;
     701         193 :     *output = target_node;
     702         193 :     return 1;
     703             : }
     704             : 
     705             : 
     706             : /* Deallocate a value referenced by a list. */
     707           0 : static void free_value(const void *value, void *cleanup_value_data) {
     708             :     (void)cleanup_value_data;
     709           0 :     assert_non_null(value);
     710           0 :     free((void*)value);
     711           0 : }
     712             : 
     713             : 
     714             : /* Releases memory associated to a symbol_map_value. */
     715         163 : static void free_symbol_map_value(const void *value,
     716             :                                   void *cleanup_value_data) {
     717         163 :     SymbolMapValue * const map_value = (SymbolMapValue*)value;
     718         163 :     const LargestIntegralType children = cast_ptr_to_largest_integral_type(cleanup_value_data);
     719         163 :     assert_non_null(value);
     720         163 :     list_free(&map_value->symbol_values_list_head,
     721             :               children ? free_symbol_map_value : free_value,
     722         163 :               (void *) ((uintptr_t)children - 1));
     723         163 :     free(map_value);
     724         163 : }
     725             : 
     726             : 
     727             : /*
     728             :  * Determine whether a symbol name referenced by a symbol_map_value matches the
     729             :  * specified function name.
     730             :  */
     731         360 : static int symbol_names_match(const void *map_value, const void *symbol) {
     732         360 :     return !strcmp(((SymbolMapValue*)map_value)->symbol_name,
     733             :                    (const char*)symbol);
     734             : }
     735             : 
     736             : /*
     737             :  * Adds a value to the queue of values associated with the given hierarchy of
     738             :  * symbols.  It's assumed value is allocated from the heap.
     739             :  */
     740         201 : static void add_symbol_value(ListNode * const symbol_map_head,
     741             :                              const char * const symbol_names[],
     742             :                              const size_t number_of_symbol_names,
     743             :                              const void* value, const int refcount) {
     744             :     const char* symbol_name;
     745             :     ListNode *target_node;
     746             :     SymbolMapValue *target_map_value;
     747         201 :     assert_non_null(symbol_map_head);
     748         201 :     assert_non_null(symbol_names);
     749         201 :     assert_true(number_of_symbol_names);
     750         201 :     symbol_name = symbol_names[0];
     751             : 
     752         201 :     if (!list_find(symbol_map_head, symbol_name, symbol_names_match,
     753             :                    &target_node)) {
     754         163 :         SymbolMapValue * const new_symbol_map_value =
     755             :             (SymbolMapValue*)malloc(sizeof(*new_symbol_map_value));
     756         163 :         new_symbol_map_value->symbol_name = symbol_name;
     757         326 :         list_initialize(&new_symbol_map_value->symbol_values_list_head);
     758         163 :         target_node = list_add_value(symbol_map_head, new_symbol_map_value,
     759             :                                           1);
     760             :     }
     761             : 
     762         201 :     target_map_value = (SymbolMapValue*)target_node->value;
     763         201 :     if (number_of_symbol_names == 1) {
     764         193 :             list_add_value(&target_map_value->symbol_values_list_head,
     765             :                                 value, refcount);
     766             :     } else {
     767           8 :         add_symbol_value(&target_map_value->symbol_values_list_head,
     768             :                          &symbol_names[1], number_of_symbol_names - 1, value,
     769             :                          refcount);
     770             :     }
     771         201 : }
     772             : 
     773             : 
     774             : /*
     775             :  * Gets the next value associated with the given hierarchy of symbols.
     776             :  * The value is returned as an output parameter with the function returning the
     777             :  * node's old refcount value if a value is found, 0 otherwise.  This means that
     778             :  * a return value of 1 indicates the node was just removed from the list.
     779             :  */
     780         201 : static int get_symbol_value(
     781             :         ListNode * const head, const char * const symbol_names[],
     782             :         const size_t number_of_symbol_names, void **output) {
     783         201 :     const char* symbol_name = NULL;
     784         201 :     ListNode *target_node = NULL;
     785         201 :     assert_non_null(head);
     786         201 :     assert_non_null(symbol_names);
     787         201 :     assert_true(number_of_symbol_names);
     788         201 :     assert_non_null(output);
     789         201 :     symbol_name = symbol_names[0];
     790             : 
     791         201 :     if (list_find(head, symbol_name, symbol_names_match, &target_node)) {
     792         201 :         SymbolMapValue *map_value = NULL;
     793         201 :         ListNode *child_list = NULL;
     794         201 :         int return_value = 0;
     795         201 :         assert_non_null(target_node);
     796         201 :         assert_non_null(target_node->value);
     797             : 
     798         201 :         map_value = (SymbolMapValue*)target_node->value;
     799         201 :         child_list = &map_value->symbol_values_list_head;
     800             : 
     801         201 :         if (number_of_symbol_names == 1) {
     802         193 :             ListNode *value_node = NULL;
     803         193 :             return_value = list_first(child_list, &value_node);
     804         193 :             assert_true(return_value);
     805             :             /* Add a check to silence clang analyzer */
     806         193 :             if (return_value == 0) {
     807           0 :                 goto out;
     808             :             }
     809         193 :             *output = (void*) value_node->value;
     810         193 :             return_value = value_node->refcount;
     811         193 :             if (value_node->refcount - 1 == 0) {
     812         193 :                 list_remove_free(value_node, NULL, NULL);
     813           0 :             } else if (value_node->refcount > WILL_RETURN_ONCE) {
     814           0 :                 --value_node->refcount;
     815             :             }
     816             :         } else {
     817           8 :             return_value = get_symbol_value(
     818             :                 child_list, &symbol_names[1], number_of_symbol_names - 1,
     819             :                 output);
     820             :         }
     821         201 :         if (list_empty(child_list)) {
     822         163 :             list_remove_free(target_node, free_symbol_map_value, (void*)0);
     823             :         }
     824           0 :         return return_value;
     825             :     }
     826           0 : out:
     827           0 :     cm_print_error("No entries for symbol %s.\n", symbol_name);
     828           0 :     return 0;
     829             : }
     830             : 
     831             : /**
     832             :  * Taverse a list of nodes and remove first symbol value in list that has a
     833             :  * refcount < -1 (i.e. should always be returned and has been returned at
     834             :  * least once).
     835             :  */
     836             : 
     837         982 : static void remove_always_return_values_from_list(ListNode * const map_head)
     838             : {
     839         982 :     ListNode * current = NULL;
     840         982 :     ListNode * next = NULL;
     841         982 :     assert_non_null(map_head);
     842             : 
     843        1964 :     for (current = map_head->next, next = current->next;
     844             :             current != map_head;
     845           0 :             current = next, next = current->next) {
     846           0 :         if (current->refcount < -1) {
     847           0 :             list_remove_free(current, free_value, NULL);
     848             :         }
     849             :     }
     850         982 : }
     851             : 
     852             : /*
     853             :  * Traverse down a tree of symbol values and remove the first symbol value
     854             :  * in each branch that has a refcount < -1 (i.e should always be returned
     855             :  * and has been returned at least once).
     856             :  */
     857        1964 : static void remove_always_return_values(ListNode * const map_head,
     858             :                                         const size_t number_of_symbol_names) {
     859             :     ListNode *current;
     860        1964 :     assert_non_null(map_head);
     861        1964 :     assert_true(number_of_symbol_names);
     862        1964 :     current = map_head->next;
     863        3928 :     while (current != map_head) {
     864           0 :         SymbolMapValue * const value = (SymbolMapValue*)current->value;
     865           0 :         ListNode * const next = current->next;
     866             :         ListNode *child_list;
     867           0 :         assert_non_null(value);
     868           0 :         child_list = &value->symbol_values_list_head;
     869             : 
     870           0 :         if (!list_empty(child_list)) {
     871           0 :             if (number_of_symbol_names == 1) {
     872           0 :                 ListNode * const child_node = child_list->next;
     873             :                 /* If this item has been returned more than once, free it. */
     874           0 :                 if (child_node->refcount < -1) {
     875           0 :                     list_remove_free(child_node, free_value, NULL);
     876             :                 }
     877             :             } else {
     878           0 :                 remove_always_return_values(child_list,
     879             :                                             number_of_symbol_names - 1);
     880             :             }
     881             :         }
     882             : 
     883           0 :         if (list_empty(child_list)) {
     884           0 :             list_remove_free(current, free_value, NULL);
     885             :         }
     886           0 :         current = next;
     887             :     }
     888        1964 : }
     889             : 
     890         982 : static size_t check_for_leftover_values_list(const ListNode * head,
     891             :                                              const char * const error_message)
     892             : {
     893             :     ListNode *child_node;
     894         982 :     size_t leftover_count = 0;
     895         982 :     if (!list_empty(head))
     896             :     {
     897           0 :         for (child_node = head->next; child_node != head;
     898           0 :                  child_node = child_node->next, ++leftover_count) {
     899           0 :             const FuncOrderingValue *const o =
     900             :                     (const FuncOrderingValue*) child_node->value;
     901           0 :             cm_print_error(error_message, o->function);
     902           0 :             cm_print_error(SOURCE_LOCATION_FORMAT
     903             :                     ": note: remaining item was declared here\n",
     904             :                     o->location.file, o->location.line);
     905             :         }
     906             :     }
     907         982 :     return leftover_count;
     908             : }
     909             : 
     910             : /*
     911             :  * Checks if there are any leftover values set up by the test that were never
     912             :  * retrieved through execution, and fail the test if that is the case.
     913             :  */
     914        1964 : static size_t check_for_leftover_values(
     915             :         const ListNode * const map_head, const char * const error_message,
     916             :         const size_t number_of_symbol_names) {
     917             :     const ListNode *current;
     918        1964 :     size_t symbols_with_leftover_values = 0;
     919        1964 :     assert_non_null(map_head);
     920        1964 :     assert_true(number_of_symbol_names);
     921             : 
     922        3928 :     for (current = map_head->next; current != map_head;
     923           0 :          current = current->next) {
     924           0 :         const SymbolMapValue * const value =
     925             :             (SymbolMapValue*)current->value;
     926             :         const ListNode *child_list;
     927           0 :         assert_non_null(value);
     928           0 :         child_list = &value->symbol_values_list_head;
     929             : 
     930           0 :         if (!list_empty(child_list)) {
     931           0 :             if (number_of_symbol_names == 1) {
     932             :                 const ListNode *child_node;
     933           0 :                 cm_print_error(error_message, value->symbol_name);
     934             : 
     935           0 :                 for (child_node = child_list->next; child_node != child_list;
     936           0 :                      child_node = child_node->next) {
     937           0 :                     const SourceLocation * const location =
     938             :                         (const SourceLocation*)child_node->value;
     939           0 :                     cm_print_error(SOURCE_LOCATION_FORMAT
     940             :                                    ": note: remaining item was declared here\n",
     941             :                                    location->file, location->line);
     942             :                 }
     943             :             } else {
     944           0 :                 cm_print_error("%s: ", value->symbol_name);
     945           0 :                 check_for_leftover_values(child_list, error_message,
     946             :                                           number_of_symbol_names - 1);
     947             :             }
     948           0 :             symbols_with_leftover_values ++;
     949             :         }
     950             :     }
     951        1964 :     return symbols_with_leftover_values;
     952             : }
     953             : 
     954             : 
     955             : /* Get the next return value for the specified mock function. */
     956         185 : LargestIntegralType _mock(const char * const function, const char* const file,
     957             :                           const int line) {
     958             :     void *result;
     959         185 :     const int rc = get_symbol_value(&global_function_result_map_head,
     960             :                                     &function, 1, &result);
     961         185 :     if (rc) {
     962         185 :         SymbolValue * const symbol = (SymbolValue*)result;
     963         185 :         const LargestIntegralType value = symbol->value;
     964         185 :         global_last_mock_value_location = symbol->location;
     965         185 :         if (rc == 1) {
     966         185 :             free(symbol);
     967             :         }
     968           0 :         return value;
     969             :     } else {
     970           0 :         cm_print_error(SOURCE_LOCATION_FORMAT ": error: Could not get value "
     971             :                        "to mock function %s\n", file, line, function);
     972           0 :         if (source_location_is_set(&global_last_mock_value_location)) {
     973           0 :             cm_print_error(SOURCE_LOCATION_FORMAT
     974             :                            ": note: Previously returned mock value was declared here\n",
     975             :                            global_last_mock_value_location.file,
     976             :                            global_last_mock_value_location.line);
     977             :         } else {
     978           0 :             cm_print_error("There were no previously returned mock values for "
     979             :                            "this test.\n");
     980             :         }
     981           0 :         exit_test(1);
     982             :     }
     983           0 :     return 0;
     984             : }
     985             : 
     986             : /* Ensure that function is being called in proper order */
     987           0 : void _function_called(const char *const function,
     988             :                       const char *const file,
     989             :                       const int line)
     990             : {
     991           0 :     ListNode *first_value_node = NULL;
     992           0 :     ListNode *value_node = NULL;
     993             :     int rc;
     994             : 
     995           0 :     rc = list_first(&global_call_ordering_head, &value_node);
     996           0 :     first_value_node = value_node;
     997           0 :     if (rc) {
     998             :         FuncOrderingValue *expected_call;
     999             :         int cmp;
    1000             : 
    1001           0 :         expected_call = (FuncOrderingValue *)value_node->value;
    1002             : 
    1003           0 :         cmp = strcmp(expected_call->function, function);
    1004           0 :         if (value_node->refcount < -1) {
    1005             :             /*
    1006             :              * Search through value nodes until either function is found or
    1007             :              * encounter a non-zero refcount greater than -2
    1008             :              */
    1009           0 :             if (cmp != 0) {
    1010           0 :                 value_node = value_node->next;
    1011           0 :                 expected_call = (FuncOrderingValue *)value_node->value;
    1012             : 
    1013           0 :                 cmp = strcmp(expected_call->function, function);
    1014           0 :                 while (value_node->refcount < -1 &&
    1015           0 :                        cmp != 0 &&
    1016           0 :                        value_node != first_value_node->prev) {
    1017           0 :                     value_node = value_node->next;
    1018           0 :                     if (value_node == NULL) {
    1019           0 :                         break;
    1020             :                     }
    1021           0 :                     expected_call = (FuncOrderingValue *)value_node->value;
    1022           0 :                     if (expected_call == NULL) {
    1023           0 :                         continue;
    1024             :                     }
    1025           0 :                     cmp = strcmp(expected_call->function, function);
    1026             :                 }
    1027             : 
    1028           0 :                 if (expected_call == NULL || value_node == first_value_node->prev) {
    1029           0 :                     cm_print_error(SOURCE_LOCATION_FORMAT
    1030             :                                    ": error: No expected mock calls matching "
    1031             :                                    "called() invocation in %s",
    1032             :                                    file, line,
    1033             :                                    function);
    1034           0 :                     exit_test(1);
    1035             :                 }
    1036             :             }
    1037             :         }
    1038             : 
    1039           0 :         if (cmp == 0) {
    1040           0 :             if (value_node->refcount > -2 && --value_node->refcount == 0) {
    1041           0 :                 list_remove_free(value_node, free_value, NULL);
    1042             :             }
    1043             :         } else {
    1044           0 :             cm_print_error(SOURCE_LOCATION_FORMAT
    1045             :                            ": error: Expected call to %s but received called() "
    1046             :                            "in %s\n",
    1047             :                            file, line,
    1048             :                            expected_call->function,
    1049             :                            function);
    1050           0 :             exit_test(1);
    1051             :         }
    1052             :     } else {
    1053           0 :         cm_print_error(SOURCE_LOCATION_FORMAT
    1054             :                        ": error: No mock calls expected but called() was "
    1055             :                        "invoked in %s\n",
    1056             :                        file, line,
    1057             :                        function);
    1058           0 :         exit_test(1);
    1059             :     }
    1060           0 : }
    1061             : 
    1062             : /* Add a return value for the specified mock function name. */
    1063         185 : void _will_return(const char * const function_name, const char * const file,
    1064             :                   const int line, const LargestIntegralType value,
    1065             :                   const int count) {
    1066         185 :     SymbolValue * const return_value =
    1067             :         (SymbolValue*)malloc(sizeof(*return_value));
    1068         185 :     assert_true(count != 0);
    1069         185 :     return_value->value = value;
    1070         370 :     set_source_location(&return_value->location, file, line);
    1071         185 :     add_symbol_value(&global_function_result_map_head, &function_name, 1,
    1072             :                      return_value, count);
    1073         185 : }
    1074             : 
    1075             : 
    1076             : /*
    1077             :  * Add a custom parameter checking function.  If the event parameter is NULL
    1078             :  * the event structure is allocated internally by this function.  If event
    1079             :  * parameter is provided it must be allocated on the heap and doesn't need to
    1080             :  * be deallocated by the caller.
    1081             :  */
    1082           8 : void _expect_check(
    1083             :         const char* const function, const char* const parameter,
    1084             :         const char* const file, const int line,
    1085             :         const CheckParameterValue check_function,
    1086             :         const LargestIntegralType check_data,
    1087             :         CheckParameterEvent * const event, const int count) {
    1088           8 :     CheckParameterEvent * const check =
    1089           8 :         event ? event : (CheckParameterEvent*)malloc(sizeof(*check));
    1090           8 :     const char* symbols[] = {function, parameter};
    1091           8 :     check->parameter_name = parameter;
    1092           8 :     check->check_value = check_function;
    1093           8 :     check->check_value_data = check_data;
    1094          16 :     set_source_location(&check->location, file, line);
    1095           8 :     add_symbol_value(&global_function_parameter_map_head, symbols, 2, check,
    1096             :                      count);
    1097           8 : }
    1098             : 
    1099             : /*
    1100             :  * Add an call expectations that a particular function is called correctly.
    1101             :  * This is used for code under test that makes calls to several functions
    1102             :  * in depended upon components (mocks).
    1103             :  */
    1104             : 
    1105           0 : void _expect_function_call(
    1106             :     const char * const function_name,
    1107             :     const char * const file,
    1108             :     const int line,
    1109             :     const int count)
    1110             : {
    1111             :     FuncOrderingValue *ordering;
    1112             : 
    1113           0 :     assert_non_null(function_name);
    1114           0 :     assert_non_null(file);
    1115           0 :     assert_true(count != 0);
    1116             : 
    1117           0 :     ordering = (FuncOrderingValue *)malloc(sizeof(*ordering));
    1118             : 
    1119           0 :     set_source_location(&ordering->location, file, line);
    1120           0 :     ordering->function = function_name;
    1121             : 
    1122           0 :     list_add_value(&global_call_ordering_head, ordering, count);
    1123           0 : }
    1124             : 
    1125             : /* Returns 1 if the specified values are equal.  If the values are not equal
    1126             :  * an error is displayed and 0 is returned. */
    1127        7220 : static int values_equal_display_error(const LargestIntegralType left,
    1128             :                                       const LargestIntegralType right) {
    1129        9182 :     const int equal = left == right;
    1130        9182 :     if (!equal) {
    1131           0 :         cm_print_error(LargestIntegralTypePrintfFormat " != "
    1132             :                        LargestIntegralTypePrintfFormat "\n", left, right);
    1133             :     }
    1134        7220 :     return equal;
    1135             : }
    1136             : 
    1137             : /*
    1138             :  * Returns 1 if the specified values are not equal.  If the values are equal
    1139             :  * an error is displayed and 0 is returned. */
    1140          64 : static int values_not_equal_display_error(const LargestIntegralType left,
    1141             :                                           const LargestIntegralType right) {
    1142          80 :     const int not_equal = left != right;
    1143          80 :     if (!not_equal) {
    1144           0 :         cm_print_error(LargestIntegralTypePrintfFormat " == "
    1145             :                        LargestIntegralTypePrintfFormat "\n", left, right);
    1146             :     }
    1147          64 :     return not_equal;
    1148             : }
    1149             : 
    1150             : 
    1151             : /*
    1152             :  * Determine whether value is contained within check_integer_set.
    1153             :  * If invert is 0 and the value is in the set 1 is returned, otherwise 0 is
    1154             :  * returned and an error is displayed.  If invert is 1 and the value is not
    1155             :  * in the set 1 is returned, otherwise 0 is returned and an error is
    1156             :  * displayed.
    1157             :  */
    1158           0 : static int value_in_set_display_error(
    1159             :         const LargestIntegralType value,
    1160             :         const CheckIntegerSet * const check_integer_set, const int invert) {
    1161           0 :     int succeeded = invert;
    1162           0 :     assert_non_null(check_integer_set);
    1163             :     {
    1164           0 :         const LargestIntegralType * const set = check_integer_set->set;
    1165           0 :         const size_t size_of_set = check_integer_set->size_of_set;
    1166             :         size_t i;
    1167           0 :         for (i = 0; i < size_of_set; i++) {
    1168           0 :             if (set[i] == value) {
    1169             :                 /* If invert = 0 and item is found, succeeded = 1. */
    1170             :                 /* If invert = 1 and item is found, succeeded = 0. */
    1171           0 :                 succeeded = !succeeded;
    1172           0 :                 break;
    1173             :             }
    1174             :         }
    1175           0 :         if (succeeded) {
    1176           0 :             return 1;
    1177             :         }
    1178           0 :         cm_print_error(LargestIntegralTypePrintfFormatDecimal
    1179             :                        " is %sin the set (",
    1180             :                        value, invert ? "" : "not ");
    1181           0 :         for (i = 0; i < size_of_set; i++) {
    1182           0 :             cm_print_error(LargestIntegralTypePrintfFormat ", ", set[i]);
    1183             :         }
    1184           0 :         cm_print_error(")\n");
    1185             :     }
    1186           0 :     return 0;
    1187             : }
    1188             : 
    1189             : 
    1190             : /*
    1191             :  * Determine whether a value is within the specified range.  If the value is
    1192             :  * within the specified range 1 is returned.  If the value isn't within the
    1193             :  * specified range an error is displayed and 0 is returned.
    1194             :  */
    1195           2 : static int integer_in_range_display_error(
    1196             :         const LargestIntegralType value, const LargestIntegralType range_min,
    1197             :         const LargestIntegralType range_max) {
    1198           6 :     if (value >= range_min && value <= range_max) {
    1199           2 :         return 1;
    1200             :     }
    1201           0 :     cm_print_error(LargestIntegralTypePrintfFormatDecimal
    1202             :                    " is not within the range "
    1203             :                    LargestIntegralTypePrintfFormatDecimal "-"
    1204             :                    LargestIntegralTypePrintfFormatDecimal "\n",
    1205             :                    value, range_min, range_max);
    1206           0 :     return 0;
    1207             : }
    1208             : 
    1209             : 
    1210             : /*
    1211             :  * Determine whether a value is within the specified range.  If the value
    1212             :  * is not within the range 1 is returned.  If the value is within the
    1213             :  * specified range an error is displayed and zero is returned.
    1214             :  */
    1215           0 : static int integer_not_in_range_display_error(
    1216             :         const LargestIntegralType value, const LargestIntegralType range_min,
    1217             :         const LargestIntegralType range_max) {
    1218           0 :     if (value < range_min || value > range_max) {
    1219           0 :         return 1;
    1220             :     }
    1221           0 :     cm_print_error(LargestIntegralTypePrintfFormatDecimal
    1222             :                    " is within the range "
    1223             :                    LargestIntegralTypePrintfFormatDecimal "-"
    1224             :                    LargestIntegralTypePrintfFormatDecimal "\n",
    1225             :                    value, range_min, range_max);
    1226           0 :     return 0;
    1227             : }
    1228             : 
    1229             : 
    1230             : /*
    1231             :  * Determine whether the specified strings are equal.  If the strings are equal
    1232             :  * 1 is returned.  If they're not equal an error is displayed and 0 is
    1233             :  * returned.
    1234             :  */
    1235         498 : static int string_equal_display_error(
    1236             :         const char * const left, const char * const right) {
    1237         498 :     if (strcmp(left, right) == 0) {
    1238         232 :         return 1;
    1239             :     }
    1240           0 :     cm_print_error("\"%s\" != \"%s\"\n", left, right);
    1241           0 :     return 0;
    1242             : }
    1243             : 
    1244             : 
    1245             : /*
    1246             :  * Determine whether the specified strings are equal.  If the strings are not
    1247             :  * equal 1 is returned.  If they're not equal an error is displayed and 0 is
    1248             :  * returned
    1249             :  */
    1250           6 : static int string_not_equal_display_error(
    1251             :         const char * const left, const char * const right) {
    1252           6 :     if (strcmp(left, right) != 0) {
    1253           0 :         return 1;
    1254             :     }
    1255           0 :     cm_print_error("\"%s\" == \"%s\"\n", left, right);
    1256           0 :     return 0;
    1257             : }
    1258             : 
    1259             : 
    1260             : /*
    1261             :  * Determine whether the specified areas of memory are equal.  If they're equal
    1262             :  * 1 is returned otherwise an error is displayed and 0 is returned.
    1263             :  */
    1264         546 : static int memory_equal_display_error(const char* const a, const char* const b,
    1265             :                                       const size_t size) {
    1266         546 :     size_t differences = 0;
    1267             :     size_t i;
    1268        8006 :     for (i = 0; i < size; i++) {
    1269        7460 :         const char l = a[i];
    1270        7460 :         const char r = b[i];
    1271        7460 :         if (l != r) {
    1272           0 :             if (differences < 16) {
    1273           0 :                 cm_print_error("difference at offset %" PRIdS " 0x%02x 0x%02x\n",
    1274             :                                i, l, r);
    1275             :             }
    1276           0 :             differences ++;
    1277             :         }
    1278             :     }
    1279         546 :     if (differences > 0) {
    1280           0 :         if (differences >= 16) {
    1281           0 :             cm_print_error("...\n");
    1282             :         }
    1283           0 :         cm_print_error("%"PRIdS " bytes of %p and %p differ\n",
    1284             :                        differences, (void *)a, (void *)b);
    1285           0 :         return 0;
    1286             :     }
    1287         339 :     return 1;
    1288             : }
    1289             : 
    1290             : 
    1291             : /*
    1292             :  * Determine whether the specified areas of memory are not equal.  If they're
    1293             :  * not equal 1 is returned otherwise an error is displayed and 0 is
    1294             :  * returned.
    1295             :  */
    1296           6 : static int memory_not_equal_display_error(
    1297             :         const char* const a, const char* const b, const size_t size) {
    1298           6 :     size_t same = 0;
    1299             :     size_t i;
    1300         102 :     for (i = 0; i < size; i++) {
    1301          96 :         const char l = a[i];
    1302          96 :         const char r = b[i];
    1303          96 :         if (l == r) {
    1304           0 :             same ++;
    1305             :         }
    1306             :     }
    1307           6 :     if (same == size) {
    1308           0 :         cm_print_error("%"PRIdS "bytes of %p and %p the same\n",
    1309             :                        same, (void *)a, (void *)b);
    1310           0 :         return 0;
    1311             :     }
    1312           0 :     return 1;
    1313             : }
    1314             : 
    1315             : 
    1316             : /* CheckParameterValue callback to check whether a value is within a set. */
    1317           0 : static int check_in_set(const LargestIntegralType value,
    1318             :                         const LargestIntegralType check_value_data) {
    1319           0 :     return value_in_set_display_error(value,
    1320           0 :         cast_largest_integral_type_to_pointer(CheckIntegerSet*,
    1321             :                                               check_value_data), 0);
    1322             : }
    1323             : 
    1324             : 
    1325             : /* CheckParameterValue callback to check whether a value isn't within a set. */
    1326           0 : static int check_not_in_set(const LargestIntegralType value,
    1327             :                             const LargestIntegralType check_value_data) {
    1328           0 :     return value_in_set_display_error(value,
    1329           0 :         cast_largest_integral_type_to_pointer(CheckIntegerSet*,
    1330             :                                               check_value_data), 1);
    1331             : }
    1332             : 
    1333             : 
    1334             : /* Create the callback data for check_in_set() or check_not_in_set() and
    1335             :  * register a check event. */
    1336           0 : static void expect_set(
    1337             :         const char* const function, const char* const parameter,
    1338             :         const char* const file, const int line,
    1339             :         const LargestIntegralType values[], const size_t number_of_values,
    1340             :         const CheckParameterValue check_function, const int count) {
    1341           0 :     CheckIntegerSet * const check_integer_set =
    1342           0 :         (CheckIntegerSet*)malloc(sizeof(*check_integer_set) +
    1343             :                (sizeof(values[0]) * number_of_values));
    1344           0 :     LargestIntegralType * const set = (LargestIntegralType*)(
    1345             :         check_integer_set + 1);
    1346           0 :     declare_initialize_value_pointer_pointer(check_data, check_integer_set);
    1347           0 :     assert_non_null(values);
    1348           0 :     assert_true(number_of_values);
    1349           0 :     memcpy(set, values, number_of_values * sizeof(values[0]));
    1350           0 :     check_integer_set->set = set;
    1351           0 :     check_integer_set->size_of_set = number_of_values;
    1352           0 :     _expect_check(
    1353             :         function, parameter, file, line, check_function,
    1354             :         check_data.value, &check_integer_set->event, count);
    1355           0 : }
    1356             : 
    1357             : 
    1358             : /* Add an event to check whether a value is in a set. */
    1359           0 : void _expect_in_set(
    1360             :         const char* const function, const char* const parameter,
    1361             :         const char* const file, const int line,
    1362             :         const LargestIntegralType values[], const size_t number_of_values,
    1363             :         const int count) {
    1364           0 :     expect_set(function, parameter, file, line, values, number_of_values,
    1365             :                check_in_set, count);
    1366           0 : }
    1367             : 
    1368             : 
    1369             : /* Add an event to check whether a value isn't in a set. */
    1370           0 : void _expect_not_in_set(
    1371             :         const char* const function, const char* const parameter,
    1372             :         const char* const file, const int line,
    1373             :         const LargestIntegralType values[], const size_t number_of_values,
    1374             :         const int count) {
    1375           0 :     expect_set(function, parameter, file, line, values, number_of_values,
    1376             :                check_not_in_set, count);
    1377           0 : }
    1378             : 
    1379             : 
    1380             : /* CheckParameterValue callback to check whether a value is within a range. */
    1381           0 : static int check_in_range(const LargestIntegralType value,
    1382             :                           const LargestIntegralType check_value_data) {
    1383           0 :     CheckIntegerRange * const check_integer_range =
    1384           0 :         cast_largest_integral_type_to_pointer(CheckIntegerRange*,
    1385             :                                               check_value_data);
    1386           0 :     assert_non_null(check_integer_range);
    1387           0 :     return integer_in_range_display_error(value, check_integer_range->minimum,
    1388             :                                           check_integer_range->maximum);
    1389             : }
    1390             : 
    1391             : 
    1392             : /* CheckParameterValue callback to check whether a value is not within a range. */
    1393           0 : static int check_not_in_range(const LargestIntegralType value,
    1394             :                               const LargestIntegralType check_value_data) {
    1395           0 :     CheckIntegerRange * const check_integer_range =
    1396           0 :         cast_largest_integral_type_to_pointer(CheckIntegerRange*,
    1397             :                                               check_value_data);
    1398           0 :     assert_non_null(check_integer_range);
    1399           0 :     return integer_not_in_range_display_error(
    1400             :         value, check_integer_range->minimum, check_integer_range->maximum);
    1401             : }
    1402             : 
    1403             : 
    1404             : /* Create the callback data for check_in_range() or check_not_in_range() and
    1405             :  * register a check event. */
    1406           0 : static void expect_range(
    1407             :         const char* const function, const char* const parameter,
    1408             :         const char* const file, const int line,
    1409             :         const LargestIntegralType minimum, const LargestIntegralType maximum,
    1410             :         const CheckParameterValue check_function, const int count) {
    1411           0 :     CheckIntegerRange * const check_integer_range =
    1412             :         (CheckIntegerRange*)malloc(sizeof(*check_integer_range));
    1413           0 :     declare_initialize_value_pointer_pointer(check_data, check_integer_range);
    1414           0 :     check_integer_range->minimum = minimum;
    1415           0 :     check_integer_range->maximum = maximum;
    1416           0 :     _expect_check(function, parameter, file, line, check_function,
    1417             :                   check_data.value, &check_integer_range->event, count);
    1418           0 : }
    1419             : 
    1420             : 
    1421             : /* Add an event to determine whether a parameter is within a range. */
    1422           0 : void _expect_in_range(
    1423             :         const char* const function, const char* const parameter,
    1424             :         const char* const file, const int line,
    1425             :         const LargestIntegralType minimum, const LargestIntegralType maximum,
    1426             :         const int count) {
    1427           0 :     expect_range(function, parameter, file, line, minimum, maximum,
    1428             :                  check_in_range, count);
    1429           0 : }
    1430             : 
    1431             : 
    1432             : /* Add an event to determine whether a parameter is not within a range. */
    1433           0 : void _expect_not_in_range(
    1434             :         const char* const function, const char* const parameter,
    1435             :         const char* const file, const int line,
    1436             :         const LargestIntegralType minimum, const LargestIntegralType maximum,
    1437             :         const int count) {
    1438           0 :     expect_range(function, parameter, file, line, minimum, maximum,
    1439             :                  check_not_in_range, count);
    1440           0 : }
    1441             : 
    1442             : 
    1443             : /* CheckParameterValue callback to check whether a value is equal to an
    1444             :  * expected value. */
    1445           6 : static int check_value(const LargestIntegralType value,
    1446             :                        const LargestIntegralType check_value_data) {
    1447           6 :     return values_equal_display_error(value, check_value_data);
    1448             : }
    1449             : 
    1450             : 
    1451             : /* Add an event to check a parameter equals an expected value. */
    1452           6 : void _expect_value(
    1453             :         const char* const function, const char* const parameter,
    1454             :         const char* const file, const int line,
    1455             :         const LargestIntegralType value, const int count) {
    1456           6 :     _expect_check(function, parameter, file, line, check_value, value, NULL,
    1457             :                   count);
    1458           6 : }
    1459             : 
    1460             : 
    1461             : /* CheckParameterValue callback to check whether a value is not equal to an
    1462             :  * expected value. */
    1463           0 : static int check_not_value(const LargestIntegralType value,
    1464             :                            const LargestIntegralType check_value_data) {
    1465           0 :     return values_not_equal_display_error(value, check_value_data);
    1466             : }
    1467             : 
    1468             : 
    1469             : /* Add an event to check a parameter is not equal to an expected value. */
    1470           0 : void _expect_not_value(
    1471             :         const char* const function, const char* const parameter,
    1472             :         const char* const file, const int line,
    1473             :         const LargestIntegralType value, const int count) {
    1474           0 :     _expect_check(function, parameter, file, line, check_not_value, value,
    1475             :                   NULL, count);
    1476           0 : }
    1477             : 
    1478             : 
    1479             : /* CheckParameterValue callback to check whether a parameter equals a string. */
    1480           2 : static int check_string(const LargestIntegralType value,
    1481             :                         const LargestIntegralType check_value_data) {
    1482           2 :     return string_equal_display_error(
    1483           2 :         cast_largest_integral_type_to_pointer(char*, value),
    1484           2 :         cast_largest_integral_type_to_pointer(char*, check_value_data));
    1485             : }
    1486             : 
    1487             : 
    1488             : /* Add an event to check whether a parameter is equal to a string. */
    1489           2 : void _expect_string(
    1490             :         const char* const function, const char* const parameter,
    1491             :         const char* const file, const int line, const char* string,
    1492             :         const int count) {
    1493           2 :     declare_initialize_value_pointer_pointer(string_pointer,
    1494             :                                              discard_const(string));
    1495           2 :     _expect_check(function, parameter, file, line, check_string,
    1496             :                   string_pointer.value, NULL, count);
    1497           2 : }
    1498             : 
    1499             : 
    1500             : /* CheckParameterValue callback to check whether a parameter is not equals to
    1501             :  * a string. */
    1502           0 : static int check_not_string(const LargestIntegralType value,
    1503             :                             const LargestIntegralType check_value_data) {
    1504           0 :     return string_not_equal_display_error(
    1505           0 :         cast_largest_integral_type_to_pointer(char*, value),
    1506           0 :         cast_largest_integral_type_to_pointer(char*, check_value_data));
    1507             : }
    1508             : 
    1509             : 
    1510             : /* Add an event to check whether a parameter is not equal to a string. */
    1511           0 : void _expect_not_string(
    1512             :         const char* const function, const char* const parameter,
    1513             :         const char* const file, const int line, const char* string,
    1514             :         const int count) {
    1515           0 :     declare_initialize_value_pointer_pointer(string_pointer,
    1516             :                                              discard_const(string));
    1517           0 :     _expect_check(function, parameter, file, line, check_not_string,
    1518             :                   string_pointer.value, NULL, count);
    1519           0 : }
    1520             : 
    1521             : /* CheckParameterValue callback to check whether a parameter equals an area of
    1522             :  * memory. */
    1523           0 : static int check_memory(const LargestIntegralType value,
    1524             :                         const LargestIntegralType check_value_data) {
    1525           0 :     CheckMemoryData * const check = cast_largest_integral_type_to_pointer(
    1526             :         CheckMemoryData*, check_value_data);
    1527           0 :     assert_non_null(check);
    1528           0 :     return memory_equal_display_error(
    1529           0 :         cast_largest_integral_type_to_pointer(const char*, value),
    1530           0 :         (const char*)check->memory, check->size);
    1531             : }
    1532             : 
    1533             : 
    1534             : /* Create the callback data for check_memory() or check_not_memory() and
    1535             :  * register a check event. */
    1536           0 : static void expect_memory_setup(
    1537             :         const char* const function, const char* const parameter,
    1538             :         const char* const file, const int line,
    1539             :         const void * const memory, const size_t size,
    1540             :         const CheckParameterValue check_function, const int count) {
    1541           0 :     CheckMemoryData * const check_data =
    1542           0 :         (CheckMemoryData*)malloc(sizeof(*check_data) + size);
    1543           0 :     void * const mem = (void*)(check_data + 1);
    1544           0 :     declare_initialize_value_pointer_pointer(check_data_pointer, check_data);
    1545           0 :     assert_non_null(memory);
    1546           0 :     assert_true(size);
    1547           0 :     memcpy(mem, memory, size);
    1548           0 :     check_data->memory = mem;
    1549           0 :     check_data->size = size;
    1550           0 :     _expect_check(function, parameter, file, line, check_function,
    1551             :                   check_data_pointer.value, &check_data->event, count);
    1552           0 : }
    1553             : 
    1554             : 
    1555             : /* Add an event to check whether a parameter matches an area of memory. */
    1556           0 : void _expect_memory(
    1557             :         const char* const function, const char* const parameter,
    1558             :         const char* const file, const int line, const void* const memory,
    1559             :         const size_t size, const int count) {
    1560           0 :     expect_memory_setup(function, parameter, file, line, memory, size,
    1561             :                         check_memory, count);
    1562           0 : }
    1563             : 
    1564             : 
    1565             : /* CheckParameterValue callback to check whether a parameter is not equal to
    1566             :  * an area of memory. */
    1567           0 : static int check_not_memory(const LargestIntegralType value,
    1568             :                             const LargestIntegralType check_value_data) {
    1569           0 :     CheckMemoryData * const check = cast_largest_integral_type_to_pointer(
    1570             :         CheckMemoryData*, check_value_data);
    1571           0 :     assert_non_null(check);
    1572           0 :     return memory_not_equal_display_error(
    1573           0 :         cast_largest_integral_type_to_pointer(const char*, value),
    1574           0 :         (const char*)check->memory,
    1575             :         check->size);
    1576             : }
    1577             : 
    1578             : 
    1579             : /* Add an event to check whether a parameter doesn't match an area of memory. */
    1580           0 : void _expect_not_memory(
    1581             :         const char* const function, const char* const parameter,
    1582             :         const char* const file, const int line, const void* const memory,
    1583             :         const size_t size, const int count) {
    1584           0 :     expect_memory_setup(function, parameter, file, line, memory, size,
    1585             :                         check_not_memory, count);
    1586           0 : }
    1587             : 
    1588             : 
    1589             : /* CheckParameterValue callback that always returns 1. */
    1590           0 : static int check_any(const LargestIntegralType value,
    1591             :                      const LargestIntegralType check_value_data) {
    1592             :     (void)value;
    1593             :     (void)check_value_data;
    1594           0 :     return 1;
    1595             : }
    1596             : 
    1597             : 
    1598             : /* Add an event to allow any value for a parameter. */
    1599           0 : void _expect_any(
    1600             :         const char* const function, const char* const parameter,
    1601             :         const char* const file, const int line, const int count) {
    1602           0 :     _expect_check(function, parameter, file, line, check_any, 0, NULL,
    1603             :                   count);
    1604           0 : }
    1605             : 
    1606             : 
    1607           8 : void _check_expected(
    1608             :         const char * const function_name, const char * const parameter_name,
    1609             :         const char* file, const int line, const LargestIntegralType value) {
    1610           8 :     void *result = NULL;
    1611           8 :     const char* symbols[] = {function_name, parameter_name};
    1612           8 :     const int rc = get_symbol_value(&global_function_parameter_map_head,
    1613             :                                     symbols, 2, &result);
    1614           8 :     if (rc) {
    1615           8 :         CheckParameterEvent * const check = (CheckParameterEvent*)result;
    1616             :         int check_succeeded;
    1617           8 :         global_last_parameter_location = check->location;
    1618           8 :         check_succeeded = check->check_value(value, check->check_value_data);
    1619           8 :         if (rc == 1) {
    1620           8 :             free(check);
    1621             :         }
    1622           8 :         if (!check_succeeded) {
    1623           0 :             cm_print_error(SOURCE_LOCATION_FORMAT
    1624             :                            ": error: Check of parameter %s, function %s failed\n"
    1625             :                            SOURCE_LOCATION_FORMAT
    1626             :                            ": note: Expected parameter declared here\n",
    1627             :                            file, line,
    1628             :                            parameter_name, function_name,
    1629             :                            global_last_parameter_location.file,
    1630             :                            global_last_parameter_location.line);
    1631           0 :             _fail(file, line);
    1632             :         }
    1633             :     } else {
    1634           0 :         cm_print_error(SOURCE_LOCATION_FORMAT ": error: Could not get value "
    1635             :                     "to check parameter %s of function %s\n", file, line,
    1636             :                     parameter_name, function_name);
    1637           0 :         if (source_location_is_set(&global_last_parameter_location)) {
    1638           0 :             cm_print_error(SOURCE_LOCATION_FORMAT
    1639             :                         ": note: Previously declared parameter value was declared here\n",
    1640             :                         global_last_parameter_location.file,
    1641             :                         global_last_parameter_location.line);
    1642             :         } else {
    1643           0 :             cm_print_error("There were no previously declared parameter values "
    1644             :                         "for this test.\n");
    1645             :         }
    1646           0 :         exit_test(1);
    1647             :     }
    1648           8 : }
    1649             : 
    1650             : 
    1651             : /* Replacement for assert. */
    1652           0 : void mock_assert(const int result, const char* const expression,
    1653             :                  const char* const file, const int line) {
    1654           0 :     if (!result) {
    1655           0 :         if (global_expecting_assert) {
    1656           0 :             global_last_failed_assert = expression;
    1657           0 :             longjmp(global_expect_assert_env, result);
    1658             :         } else {
    1659           0 :             cm_print_error("ASSERT: %s\n", expression);
    1660           0 :             _fail(file, line);
    1661             :         }
    1662             :     }
    1663           0 : }
    1664             : 
    1665             : 
    1666       37781 : void _assert_true(const LargestIntegralType result,
    1667             :                   const char * const expression,
    1668             :                   const char * const file, const int line) {
    1669       37781 :     if (!result) {
    1670           0 :         cm_print_error("%s\n", expression);
    1671           0 :         _fail(file, line);
    1672             :     }
    1673       37781 : }
    1674             : 
    1675          26 : void _assert_return_code(const LargestIntegralType result,
    1676             :                          size_t rlen,
    1677             :                          const LargestIntegralType error,
    1678             :                          const char * const expression,
    1679             :                          const char * const file,
    1680             :                          const int line)
    1681             : {
    1682             :     LargestIntegralType valmax;
    1683             : 
    1684             : 
    1685          26 :     switch (rlen) {
    1686           0 :     case 1:
    1687           0 :         valmax = 255;
    1688           0 :         break;
    1689           0 :     case 2:
    1690           0 :         valmax = 32767;
    1691           0 :         break;
    1692          26 :     case 4:
    1693          26 :         valmax = 2147483647;
    1694          26 :         break;
    1695           0 :     case 8:
    1696             :     default:
    1697           0 :         if (rlen > sizeof(valmax)) {
    1698           0 :             valmax = 2147483647;
    1699             :         } else {
    1700           0 :             valmax = 9223372036854775807L;
    1701             :         }
    1702           0 :         break;
    1703             :     }
    1704             : 
    1705          26 :     if (result > valmax - 1) {
    1706           0 :         if (error > 0) {
    1707           0 :             cm_print_error("%s < 0, errno("
    1708             :                            LargestIntegralTypePrintfFormatDecimal "): %s\n",
    1709             :                            expression, error, strerror((int)error));
    1710             :         } else {
    1711           0 :             cm_print_error("%s < 0\n", expression);
    1712             :         }
    1713           0 :         _fail(file, line);
    1714             :     }
    1715          26 : }
    1716             : 
    1717        9176 : void _assert_int_equal(
    1718             :         const LargestIntegralType a, const LargestIntegralType b,
    1719             :         const char * const file, const int line) {
    1720        9176 :     if (!values_equal_display_error(a, b)) {
    1721           0 :         _fail(file, line);
    1722             :     }
    1723        9176 : }
    1724             : 
    1725             : 
    1726          80 : void _assert_int_not_equal(
    1727             :         const LargestIntegralType a, const LargestIntegralType b,
    1728             :         const char * const file, const int line) {
    1729          80 :     if (!values_not_equal_display_error(a, b)) {
    1730           0 :         _fail(file, line);
    1731             :     }
    1732          80 : }
    1733             : 
    1734             : 
    1735         496 : void _assert_string_equal(const char * const a, const char * const b,
    1736             :                           const char * const file, const int line) {
    1737         496 :     if (!string_equal_display_error(a, b)) {
    1738           0 :         _fail(file, line);
    1739             :     }
    1740         496 : }
    1741             : 
    1742             : 
    1743           6 : void _assert_string_not_equal(const char * const a, const char * const b,
    1744             :                               const char *file, const int line) {
    1745           6 :     if (!string_not_equal_display_error(a, b)) {
    1746           0 :         _fail(file, line);
    1747             :     }
    1748           6 : }
    1749             : 
    1750             : 
    1751         546 : void _assert_memory_equal(const void * const a, const void * const b,
    1752             :                           const size_t size, const char* const file,
    1753             :                           const int line) {
    1754         546 :     if (!memory_equal_display_error((const char*)a, (const char*)b, size)) {
    1755           0 :         _fail(file, line);
    1756             :     }
    1757         546 : }
    1758             : 
    1759             : 
    1760           6 : void _assert_memory_not_equal(const void * const a, const void * const b,
    1761             :                               const size_t size, const char* const file,
    1762             :                               const int line) {
    1763           6 :     if (!memory_not_equal_display_error((const char*)a, (const char*)b,
    1764             :                                         size)) {
    1765           0 :         _fail(file, line);
    1766             :     }
    1767           6 : }
    1768             : 
    1769             : 
    1770           6 : void _assert_in_range(
    1771             :         const LargestIntegralType value, const LargestIntegralType minimum,
    1772             :         const LargestIntegralType maximum, const char* const file,
    1773             :         const int line) {
    1774           2 :     if (!integer_in_range_display_error(value, minimum, maximum)) {
    1775           0 :         _fail(file, line);
    1776             :     }
    1777           6 : }
    1778             : 
    1779           0 : void _assert_not_in_range(
    1780             :         const LargestIntegralType value, const LargestIntegralType minimum,
    1781             :         const LargestIntegralType maximum, const char* const file,
    1782             :         const int line) {
    1783           0 :     if (!integer_not_in_range_display_error(value, minimum, maximum)) {
    1784           0 :         _fail(file, line);
    1785             :     }
    1786           0 : }
    1787             : 
    1788           0 : void _assert_in_set(const LargestIntegralType value,
    1789             :                     const LargestIntegralType values[],
    1790             :                     const size_t number_of_values, const char* const file,
    1791             :                     const int line) {
    1792             :     CheckIntegerSet check_integer_set;
    1793           0 :     check_integer_set.set = values;
    1794           0 :     check_integer_set.size_of_set = number_of_values;
    1795           0 :     if (!value_in_set_display_error(value, &check_integer_set, 0)) {
    1796           0 :         _fail(file, line);
    1797             :     }
    1798           0 : }
    1799             : 
    1800           0 : void _assert_not_in_set(const LargestIntegralType value,
    1801             :                         const LargestIntegralType values[],
    1802             :                         const size_t number_of_values, const char* const file,
    1803             :                         const int line) {
    1804             :     CheckIntegerSet check_integer_set;
    1805           0 :     check_integer_set.set = values;
    1806           0 :     check_integer_set.size_of_set = number_of_values;
    1807           0 :     if (!value_in_set_display_error(value, &check_integer_set, 1)) {
    1808           0 :         _fail(file, line);
    1809             :     }
    1810           0 : }
    1811             : 
    1812             : 
    1813             : /* Get the list of allocated blocks. */
    1814         746 : static ListNode* get_allocated_blocks_list(void) {
    1815             :     /* If it initialized, initialize the list of allocated blocks. */
    1816        1595 :     if (!global_allocated_blocks.value) {
    1817          62 :         list_initialize(&global_allocated_blocks);
    1818          62 :         global_allocated_blocks.value = (void*)1;
    1819             :     }
    1820         746 :     return &global_allocated_blocks;
    1821             : }
    1822             : 
    1823          15 : static void *libc_malloc(size_t size)
    1824             : {
    1825             : #undef malloc
    1826          62 :     return malloc(size);
    1827             : #define malloc test_malloc
    1828             : }
    1829             : 
    1830         197 : static void libc_free(void *ptr)
    1831             : {
    1832             : #undef free
    1833         553 :     free(ptr);
    1834             : #define free test_free
    1835         197 : }
    1836             : 
    1837           0 : static void *libc_realloc(void *ptr, size_t size)
    1838             : {
    1839             : #undef realloc
    1840           0 :     return realloc(ptr, size);
    1841             : #define realloc test_realloc
    1842             : }
    1843             : 
    1844             : static void vcm_print_error(const char* const format,
    1845             :                             va_list args) CMOCKA_PRINTF_ATTRIBUTE(1, 0);
    1846             : 
    1847             : /* It's important to use the libc malloc and free here otherwise
    1848             :  * the automatic free of leaked blocks can reap the error messages
    1849             :  */
    1850           0 : static void vcm_print_error(const char* const format, va_list args)
    1851             : {
    1852             :     char buffer[1024];
    1853           0 :     size_t msg_len = 0;
    1854             :     va_list ap;
    1855             :     int len;
    1856           0 :     va_copy(ap, args);
    1857             : 
    1858           0 :     len = vsnprintf(buffer, sizeof(buffer), format, args);
    1859           0 :     if (len < 0) {
    1860             :         /* TODO */
    1861           0 :         goto end;
    1862             :     }
    1863             : 
    1864           0 :     if (cm_error_message == NULL) {
    1865             :         /* CREATE MESSAGE */
    1866             : 
    1867           0 :         cm_error_message = libc_malloc(len + 1);
    1868           0 :         if (cm_error_message == NULL) {
    1869             :             /* TODO */
    1870           0 :             goto end;
    1871             :         }
    1872             :     } else {
    1873             :         /* APPEND MESSAGE */
    1874             :         char *tmp;
    1875             : 
    1876           0 :         msg_len = strlen(cm_error_message);
    1877           0 :         tmp = libc_realloc(cm_error_message, msg_len + len + 1);
    1878           0 :         if (tmp == NULL) {
    1879           0 :             goto end;
    1880             :         }
    1881           0 :         cm_error_message = tmp;
    1882             :     }
    1883             : 
    1884           0 :     if (((size_t)len) < sizeof(buffer)) {
    1885             :         /* Use len + 1 to also copy '\0' */
    1886           0 :         memcpy(cm_error_message + msg_len, buffer, len + 1);
    1887             :     } else {
    1888           0 :         vsnprintf(cm_error_message + msg_len, len, format, ap);
    1889             :     }
    1890           0 : end:
    1891           0 :     va_end(ap);
    1892             : 
    1893           0 : }
    1894             : 
    1895         182 : static void vcm_free_error(char *err_msg)
    1896             : {
    1897         491 :     libc_free(err_msg);
    1898         182 : }
    1899             : 
    1900             : /* Use the real malloc in this function. */
    1901             : #undef malloc
    1902           0 : void* _test_malloc(const size_t size, const char* file, const int line) {
    1903           0 :     char *ptr = NULL;
    1904             :     MallocBlockInfo block_info;
    1905           0 :     ListNode * const block_list = get_allocated_blocks_list();
    1906             :     size_t allocate_size;
    1907           0 :     char *block = NULL;
    1908             : 
    1909           0 :     allocate_size = size + (MALLOC_GUARD_SIZE * 2) +
    1910             :                     sizeof(struct MallocBlockInfoData) + MALLOC_ALIGNMENT;
    1911           0 :     assert_true(allocate_size > size);
    1912             : 
    1913           0 :     block = (char *)malloc(allocate_size);
    1914           0 :     assert_non_null(block);
    1915             : 
    1916             :     /* Calculate the returned address. */
    1917           0 :     ptr = (char*)(((size_t)block + MALLOC_GUARD_SIZE +
    1918           0 :                   sizeof(struct MallocBlockInfoData) +
    1919           0 :                   MALLOC_ALIGNMENT) & ~(MALLOC_ALIGNMENT - 1));
    1920             : 
    1921             :     /* Initialize the guard blocks. */
    1922           0 :     memset(ptr - MALLOC_GUARD_SIZE, MALLOC_GUARD_PATTERN, MALLOC_GUARD_SIZE);
    1923           0 :     memset(ptr + size, MALLOC_GUARD_PATTERN, MALLOC_GUARD_SIZE);
    1924           0 :     memset(ptr, MALLOC_ALLOC_PATTERN, size);
    1925             : 
    1926           0 :     block_info.ptr = ptr - (MALLOC_GUARD_SIZE +
    1927             :                             sizeof(struct MallocBlockInfoData));
    1928           0 :     set_source_location(&block_info.data->location, file, line);
    1929           0 :     block_info.data->allocated_size = allocate_size;
    1930           0 :     block_info.data->size = size;
    1931           0 :     block_info.data->block = block;
    1932           0 :     block_info.data->node.value = block_info.ptr;
    1933           0 :     list_add(block_list, &block_info.data->node);
    1934           0 :     return ptr;
    1935             : }
    1936             : #define malloc test_malloc
    1937             : 
    1938             : 
    1939           0 : void* _test_calloc(const size_t number_of_elements, const size_t size,
    1940             :                    const char* file, const int line) {
    1941           0 :     void* const ptr = _test_malloc(number_of_elements * size, file, line);
    1942           0 :     if (ptr) {
    1943           0 :         memset(ptr, 0, number_of_elements * size);
    1944             :     }
    1945           0 :     return ptr;
    1946             : }
    1947             : 
    1948             : 
    1949             : /* Use the real free in this function. */
    1950             : #undef free
    1951           0 : void _test_free(void* const ptr, const char* file, const int line) {
    1952             :     unsigned int i;
    1953           0 :     char *block = discard_const_p(char, ptr);
    1954             :     MallocBlockInfo block_info;
    1955             : 
    1956           0 :     if (ptr == NULL) {
    1957           0 :         return;
    1958             :     }
    1959             : 
    1960           0 :     _assert_true(cast_ptr_to_largest_integral_type(ptr), "ptr", file, line);
    1961           0 :     block_info.ptr = block - (MALLOC_GUARD_SIZE +
    1962             :                               sizeof(struct MallocBlockInfoData));
    1963             :     /* Check the guard blocks. */
    1964             :     {
    1965           0 :         char *guards[2] = {block - MALLOC_GUARD_SIZE,
    1966           0 :                            block + block_info.data->size};
    1967           0 :         for (i = 0; i < ARRAY_SIZE(guards); i++) {
    1968             :             unsigned int j;
    1969           0 :             char * const guard = guards[i];
    1970           0 :             for (j = 0; j < MALLOC_GUARD_SIZE; j++) {
    1971           0 :                 const char diff = guard[j] - MALLOC_GUARD_PATTERN;
    1972           0 :                 if (diff) {
    1973           0 :                     cm_print_error(SOURCE_LOCATION_FORMAT
    1974             :                                    ": error: Guard block of %p size=%lu is corrupt\n"
    1975             :                                    SOURCE_LOCATION_FORMAT ": note: allocated here at %p\n",
    1976             :                                    file,
    1977             :                                    line,
    1978             :                                    ptr,
    1979           0 :                                    (unsigned long)block_info.data->size,
    1980           0 :                                    block_info.data->location.file,
    1981           0 :                                    block_info.data->location.line,
    1982           0 :                                    (void *)&guard[j]);
    1983           0 :                     _fail(file, line);
    1984             :                 }
    1985             :             }
    1986             :         }
    1987             :     }
    1988           0 :     list_remove(&block_info.data->node, NULL, NULL);
    1989             : 
    1990           0 :     block = discard_const_p(char, block_info.data->block);
    1991           0 :     memset(block, MALLOC_FREE_PATTERN, block_info.data->allocated_size);
    1992           0 :     free(block);
    1993             : }
    1994             : #define free test_free
    1995             : 
    1996             : #undef realloc
    1997           0 : void *_test_realloc(void *ptr,
    1998             :                    const size_t size,
    1999             :                    const char *file,
    2000             :                    const int line)
    2001             : {
    2002             :     MallocBlockInfo block_info;
    2003           0 :     char *block = ptr;
    2004           0 :     size_t block_size = size;
    2005             :     void *new_block;
    2006             : 
    2007           0 :     if (ptr == NULL) {
    2008           0 :         return _test_malloc(size, file, line);
    2009             :     }
    2010             : 
    2011           0 :     if (size == 0) {
    2012           0 :         _test_free(ptr, file, line);
    2013           0 :         return NULL;
    2014             :     }
    2015             : 
    2016           0 :     block_info.ptr = block - (MALLOC_GUARD_SIZE +
    2017             :                               sizeof(struct MallocBlockInfoData));
    2018             : 
    2019           0 :     new_block = _test_malloc(size, file, line);
    2020           0 :     if (new_block == NULL) {
    2021           0 :         return NULL;
    2022             :     }
    2023             : 
    2024           0 :     if (block_info.data->size < size) {
    2025           0 :         block_size = block_info.data->size;
    2026             :     }
    2027             : 
    2028           0 :     memcpy(new_block, ptr, block_size);
    2029             : 
    2030             :     /* Free previous memory */
    2031           0 :     _test_free(ptr, file, line);
    2032             : 
    2033           0 :     return new_block;
    2034             : }
    2035             : #define realloc test_realloc
    2036             : 
    2037             : /* Crudely checkpoint the current heap state. */
    2038         373 : static const ListNode* check_point_allocated_blocks(void) {
    2039         795 :     return get_allocated_blocks_list()->prev;
    2040             : }
    2041             : 
    2042             : 
    2043             : /* Display the blocks allocated after the specified check point.  This
    2044             :  * function returns the number of blocks displayed. */
    2045         800 : static size_t display_allocated_blocks(const ListNode * const check_point) {
    2046         800 :     const ListNode * const head = get_allocated_blocks_list();
    2047             :     const ListNode *node;
    2048         800 :     size_t allocated_blocks = 0;
    2049         800 :     assert_non_null(check_point);
    2050         800 :     assert_non_null(check_point->next);
    2051             : 
    2052         800 :     for (node = check_point->next; node != head; node = node->next) {
    2053           0 :         const MallocBlockInfo block_info = {
    2054           0 :             .ptr = discard_const(node->value),
    2055             :         };
    2056           0 :         assert_non_null(block_info.ptr);
    2057             : 
    2058           0 :         if (allocated_blocks == 0) {
    2059           0 :             cm_print_error("Blocks allocated...\n");
    2060             :         }
    2061           0 :         cm_print_error(SOURCE_LOCATION_FORMAT ": note: block %p allocated here\n",
    2062           0 :                        block_info.data->location.file,
    2063           0 :                        block_info.data->location.line,
    2064           0 :                        block_info.data->block);
    2065           0 :         allocated_blocks++;
    2066             :     }
    2067         800 :     return allocated_blocks;
    2068             : }
    2069             : 
    2070             : 
    2071             : /* Free all blocks allocated after the specified check point. */
    2072           0 : static void free_allocated_blocks(const ListNode * const check_point) {
    2073           0 :     const ListNode * const head = get_allocated_blocks_list();
    2074             :     const ListNode *node;
    2075           0 :     assert_non_null(check_point);
    2076             : 
    2077           0 :     node = check_point->next;
    2078           0 :     assert_non_null(node);
    2079             : 
    2080           0 :     while (node != head) {
    2081           0 :         const MallocBlockInfo block_info = {
    2082           0 :             .ptr = discard_const(node->value),
    2083             :         };
    2084           0 :         node = node->next;
    2085           0 :         free(discard_const_p(char, block_info.data) +
    2086             :              sizeof(struct MallocBlockInfoData) +
    2087             :              MALLOC_GUARD_SIZE);
    2088             :     }
    2089           0 : }
    2090             : 
    2091             : 
    2092             : /* Fail if any any blocks are allocated after the specified check point. */
    2093         800 : static void fail_if_blocks_allocated(const ListNode * const check_point,
    2094             :                                      const char * const test_name) {
    2095         800 :     const size_t allocated_blocks = display_allocated_blocks(check_point);
    2096         800 :     if (allocated_blocks > 0) {
    2097           0 :         free_allocated_blocks(check_point);
    2098           0 :         cm_print_error("ERROR: %s leaked %zu block(s)\n", test_name,
    2099             :                        allocated_blocks);
    2100           0 :         exit_test(1);
    2101             :     }
    2102         800 : }
    2103             : 
    2104             : 
    2105           0 : void _fail(const char * const file, const int line) {
    2106           0 :     enum cm_message_output output = cm_get_output();
    2107             : 
    2108           0 :     switch(output) {
    2109           0 :         case CM_OUTPUT_STDOUT:
    2110           0 :             cm_print_error("[   LINE   ] --- " SOURCE_LOCATION_FORMAT ": error: Failure!", file, line);
    2111           0 :             break;
    2112           0 :         default:
    2113           0 :             cm_print_error(SOURCE_LOCATION_FORMAT ": error: Failure!", file, line);
    2114           0 :             break;
    2115             :     }
    2116           0 :     exit_test(1);
    2117           0 : }
    2118             : 
    2119             : 
    2120             : #ifndef _WIN32
    2121           0 : static void exception_handler(int sig) {
    2122           0 :     const char *sig_strerror = "";
    2123             : 
    2124             : #ifdef HAVE_STRSIGNAL
    2125           0 :     sig_strerror = strsignal(sig);
    2126             : #endif
    2127             : 
    2128           0 :     cm_print_error("Test failed with exception: %s(%d)",
    2129             :                    sig_strerror, sig);
    2130           0 :     exit_test(1);
    2131           0 : }
    2132             : 
    2133             : #else /* _WIN32 */
    2134             : 
    2135             : static LONG WINAPI exception_filter(EXCEPTION_POINTERS *exception_pointers) {
    2136             :     EXCEPTION_RECORD * const exception_record =
    2137             :         exception_pointers->ExceptionRecord;
    2138             :     const DWORD code = exception_record->ExceptionCode;
    2139             :     unsigned int i;
    2140             :     for (i = 0; i < ARRAY_SIZE(exception_codes); i++) {
    2141             :         const ExceptionCodeInfo * const code_info = &exception_codes[i];
    2142             :         if (code == code_info->code) {
    2143             :             static int shown_debug_message = 0;
    2144             :             fflush(stdout);
    2145             :             cm_print_error("%s occurred at %p.\n", code_info->description,
    2146             :                         exception_record->ExceptionAddress);
    2147             :             if (!shown_debug_message) {
    2148             :                 cm_print_error(
    2149             :                     "\n"
    2150             :                     "To debug in Visual Studio...\n"
    2151             :                     "1. Select menu item File->Open Project\n"
    2152             :                     "2. Change 'Files of type' to 'Executable Files'\n"
    2153             :                     "3. Open this executable.\n"
    2154             :                     "4. Select menu item Debug->Start\n"
    2155             :                     "\n"
    2156             :                     "Alternatively, set the environment variable \n"
    2157             :                     "UNIT_TESTING_DEBUG to 1 and rebuild this executable, \n"
    2158             :                     "then click 'Debug' in the popup dialog box.\n"
    2159             :                     "\n");
    2160             :                 shown_debug_message = 1;
    2161             :             }
    2162             :             exit_test(0);
    2163             :             return EXCEPTION_EXECUTE_HANDLER;
    2164             :         }
    2165             :     }
    2166             :     return EXCEPTION_CONTINUE_SEARCH;
    2167             : }
    2168             : #endif /* !_WIN32 */
    2169             : 
    2170           0 : void cm_print_error(const char * const format, ...)
    2171             : {
    2172             :     va_list args;
    2173           0 :     va_start(args, format);
    2174           0 :     if (cm_error_message_enabled) {
    2175           0 :         vcm_print_error(format, args);
    2176             :     } else {
    2177           0 :         vprint_error(format, args);
    2178             :     }
    2179           0 :     va_end(args);
    2180           0 : }
    2181             : 
    2182             : /* Standard output and error print methods. */
    2183        1006 : void vprint_message(const char* const format, va_list args) {
    2184             :     char buffer[1024];
    2185        1006 :     vsnprintf(buffer, sizeof(buffer), format, args);
    2186        1006 :     printf("%s", buffer);
    2187        1006 :     fflush(stdout);
    2188             : #ifdef _WIN32
    2189             :     OutputDebugString(buffer);
    2190             : #endif /* _WIN32 */
    2191        1006 : }
    2192             : 
    2193             : 
    2194          26 : void vprint_error(const char* const format, va_list args) {
    2195             :     char buffer[1024];
    2196          26 :     vsnprintf(buffer, sizeof(buffer), format, args);
    2197          26 :     fprintf(stderr, "%s", buffer);
    2198          26 :     fflush(stderr);
    2199             : #ifdef _WIN32
    2200             :     OutputDebugString(buffer);
    2201             : #endif /* _WIN32 */
    2202          26 : }
    2203             : 
    2204             : 
    2205        1006 : void print_message(const char* const format, ...) {
    2206             :     va_list args;
    2207        1006 :     va_start(args, format);
    2208        1006 :     vprint_message(format, args);
    2209        1006 :     va_end(args);
    2210        1006 : }
    2211             : 
    2212             : 
    2213          26 : void print_error(const char* const format, ...) {
    2214             :     va_list args;
    2215          26 :     va_start(args, format);
    2216          26 :     vprint_error(format, args);
    2217          26 :     va_end(args);
    2218          26 : }
    2219             : 
    2220             : /* New formatter */
    2221        1106 : static enum cm_message_output cm_get_output(void)
    2222             : {
    2223        1106 :     enum cm_message_output output = global_msg_output;
    2224             :     char *env;
    2225             : 
    2226        1106 :     env = getenv("CMOCKA_MESSAGE_OUTPUT");
    2227        1106 :     if (env != NULL) {
    2228           0 :         if (strcasecmp(env, "STDOUT") == 0) {
    2229           0 :             output = CM_OUTPUT_STDOUT;
    2230           0 :         } else if (strcasecmp(env, "SUBUNIT") == 0) {
    2231           0 :             output = CM_OUTPUT_SUBUNIT;
    2232           0 :         } else if (strcasecmp(env, "TAP") == 0) {
    2233           0 :             output = CM_OUTPUT_TAP;
    2234           0 :         } else if (strcasecmp(env, "XML") == 0) {
    2235           0 :             output = CM_OUTPUT_XML;
    2236             :         }
    2237             :     }
    2238             : 
    2239        1106 :     return output;
    2240             : }
    2241             : 
    2242             : enum cm_printf_type {
    2243             :     PRINTF_TEST_START,
    2244             :     PRINTF_TEST_SUCCESS,
    2245             :     PRINTF_TEST_FAILURE,
    2246             :     PRINTF_TEST_ERROR,
    2247             :     PRINTF_TEST_SKIPPED,
    2248             : };
    2249             : 
    2250             : static int xml_printed;
    2251             : static int file_append;
    2252             : 
    2253           0 : static void cmprintf_group_finish_xml(const char *group_name,
    2254             :                                       size_t total_executed,
    2255             :                                       size_t total_failed,
    2256             :                                       size_t total_errors,
    2257             :                                       size_t total_skipped,
    2258             :                                       double total_runtime,
    2259             :                                       struct CMUnitTestState *cm_tests)
    2260             : {
    2261           0 :     FILE *fp = stdout;
    2262           0 :     int file_opened = 0;
    2263           0 :     int multiple_files = 0;
    2264             :     char *env;
    2265             :     size_t i;
    2266             : 
    2267           0 :     env = getenv("CMOCKA_XML_FILE");
    2268           0 :     if (env != NULL) {
    2269             :         char buf[1024];
    2270             :         int rc;
    2271             : 
    2272           0 :         snprintf(buf, sizeof(buf), "%s", env);
    2273             : 
    2274           0 :         rc = c_strreplace(buf, sizeof(buf), "%g", group_name, &multiple_files);
    2275           0 :         if (rc < 0) {
    2276           0 :             snprintf(buf, sizeof(buf), "%s", env);
    2277             :         }
    2278             : 
    2279           0 :         fp = fopen(buf, "r");
    2280           0 :         if (fp == NULL) {
    2281           0 :             fp = fopen(buf, "w");
    2282           0 :             if (fp != NULL) {
    2283           0 :                 file_append = 1;
    2284           0 :                 file_opened = 1;
    2285             :             } else {
    2286           0 :                 fp = stderr;
    2287             :             }
    2288             :         } else {
    2289           0 :             fclose(fp);
    2290           0 :             if (file_append) {
    2291           0 :                 fp = fopen(buf, "a");
    2292           0 :                 if (fp != NULL) {
    2293           0 :                     file_opened = 1;
    2294           0 :                     xml_printed = 1;
    2295             :                 } else {
    2296           0 :                     fp = stderr;
    2297             :                 }
    2298             :             } else {
    2299           0 :                 fp = stderr;
    2300             :             }
    2301             :         }
    2302             :     }
    2303             : 
    2304           0 :     if (!xml_printed || (file_opened && !file_append)) {
    2305           0 :         fprintf(fp, "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n");
    2306           0 :         if (!file_opened) {
    2307           0 :             xml_printed = 1;
    2308             :         }
    2309             :     }
    2310             : 
    2311           0 :     fprintf(fp, "<testsuites>\n");
    2312           0 :     fprintf(fp, "  <testsuite name=\"%s\" time=\"%.3f\" "
    2313             :                 "tests=\"%u\" failures=\"%u\" errors=\"%u\" skipped=\"%u\" >\n",
    2314             :                 group_name,
    2315             :                 total_runtime, /* seconds */
    2316             :                 (unsigned)total_executed,
    2317             :                 (unsigned)total_failed,
    2318             :                 (unsigned)total_errors,
    2319             :                 (unsigned)total_skipped);
    2320             : 
    2321           0 :     for (i = 0; i < total_executed; i++) {
    2322           0 :         struct CMUnitTestState *cmtest = &cm_tests[i];
    2323             : 
    2324           0 :         fprintf(fp, "    <testcase name=\"%s\" time=\"%.3f\" >\n",
    2325           0 :                 cmtest->test->name, cmtest->runtime);
    2326             : 
    2327           0 :         switch (cmtest->status) {
    2328           0 :         case CM_TEST_ERROR:
    2329             :         case CM_TEST_FAILED:
    2330           0 :             if (cmtest->error_message != NULL) {
    2331           0 :                 fprintf(fp, "      <failure><![CDATA[%s]]></failure>\n",
    2332             :                         cmtest->error_message);
    2333             :             } else {
    2334           0 :                 fprintf(fp, "      <failure message=\"Unknown error\" />\n");
    2335             :             }
    2336           0 :             break;
    2337           0 :         case CM_TEST_SKIPPED:
    2338           0 :             fprintf(fp, "      <skipped/>\n");
    2339           0 :             break;
    2340             : 
    2341           0 :         case CM_TEST_PASSED:
    2342             :         case CM_TEST_NOT_STARTED:
    2343           0 :             break;
    2344             :         }
    2345             : 
    2346           0 :         fprintf(fp, "    </testcase>\n");
    2347             :     }
    2348             : 
    2349           0 :     fprintf(fp, "  </testsuite>\n");
    2350           0 :     fprintf(fp, "</testsuites>\n");
    2351             : 
    2352           0 :     if (file_opened) {
    2353           0 :         fclose(fp);
    2354             :     }
    2355           0 : }
    2356             : 
    2357          12 : static void cmprintf_group_start_standard(const size_t num_tests)
    2358             : {
    2359          12 :     print_message("[==========] Running %u test(s).\n",
    2360             :                   (unsigned)num_tests);
    2361          12 : }
    2362             : 
    2363          12 : static void cmprintf_group_finish_standard(size_t total_executed,
    2364             :                                            size_t total_passed,
    2365             :                                            size_t total_failed,
    2366             :                                            size_t total_errors,
    2367             :                                            size_t total_skipped,
    2368             :                                            struct CMUnitTestState *cm_tests)
    2369             : {
    2370             :     size_t i;
    2371             : 
    2372          12 :     print_message("[==========] %u test(s) run.\n", (unsigned)total_executed);
    2373          12 :     print_error("[  PASSED  ] %u test(s).\n",
    2374             :                 (unsigned)(total_passed));
    2375             : 
    2376          12 :     if (total_skipped) {
    2377           0 :         print_error("[  SKIPPED ] %"PRIdS " test(s), listed below:\n", total_skipped);
    2378           0 :         for (i = 0; i < total_executed; i++) {
    2379           0 :             struct CMUnitTestState *cmtest = &cm_tests[i];
    2380             : 
    2381           0 :             if (cmtest->status == CM_TEST_SKIPPED) {
    2382           0 :                 print_error("[  SKIPPED ] %s\n", cmtest->test->name);
    2383             :             }
    2384             :         }
    2385           0 :         print_error("\n %u SKIPPED TEST(S)\n", (unsigned)(total_skipped));
    2386             :     }
    2387             : 
    2388          12 :     if (total_failed) {
    2389           0 :         print_error("[  FAILED  ] %"PRIdS " test(s), listed below:\n", total_failed);
    2390           0 :         for (i = 0; i < total_executed; i++) {
    2391           0 :             struct CMUnitTestState *cmtest = &cm_tests[i];
    2392             : 
    2393           0 :             if (cmtest->status == CM_TEST_FAILED) {
    2394           0 :                 print_error("[  FAILED  ] %s\n", cmtest->test->name);
    2395             :             }
    2396             :         }
    2397           0 :         print_error("\n %u FAILED TEST(S)\n",
    2398             :                     (unsigned)(total_failed + total_errors));
    2399             :     }
    2400          12 : }
    2401             : 
    2402         308 : static void cmprintf_standard(enum cm_printf_type type,
    2403             :                               const char *test_name,
    2404             :                               const char *error_message)
    2405             : {
    2406         308 :     switch (type) {
    2407         154 :     case PRINTF_TEST_START:
    2408         154 :         print_message("[ RUN      ] %s\n", test_name);
    2409         154 :         break;
    2410         154 :     case PRINTF_TEST_SUCCESS:
    2411         154 :         print_message("[       OK ] %s\n", test_name);
    2412         154 :         break;
    2413           0 :     case PRINTF_TEST_FAILURE:
    2414           0 :         if (error_message != NULL) {
    2415           0 :             print_error("[  ERROR   ] --- %s\n", error_message);
    2416             :         }
    2417           0 :         print_message("[  FAILED  ] %s\n", test_name);
    2418           0 :         break;
    2419           0 :     case PRINTF_TEST_SKIPPED:
    2420           0 :         print_message("[  SKIPPED ] %s\n", test_name);
    2421           0 :         break;
    2422           0 :     case PRINTF_TEST_ERROR:
    2423           0 :         if (error_message != NULL) {
    2424           0 :             print_error("%s\n", error_message);
    2425             :         }
    2426           0 :         print_error("[  ERROR   ] %s\n", test_name);
    2427           0 :         break;
    2428             :     }
    2429         308 : }
    2430             : 
    2431           0 : static void cmprintf_group_start_tap(const size_t num_tests)
    2432             : {
    2433           0 :     print_message("1..%u\n", (unsigned)num_tests);
    2434           0 : }
    2435             : 
    2436           0 : static void cmprintf_group_finish_tap(const char *group_name,
    2437             :                                       size_t total_executed,
    2438             :                                       size_t total_passed,
    2439             :                                       size_t total_skipped)
    2440             : {
    2441           0 :     const char *status = "not ok";
    2442           0 :     if (total_passed + total_skipped == total_executed) {
    2443           0 :         status = "ok";
    2444             :     }
    2445           0 :     print_message("# %s - %s\n", status, group_name);
    2446           0 : }
    2447             : 
    2448           0 : static void cmprintf_tap(enum cm_printf_type type,
    2449             :                          uint32_t test_number,
    2450             :                          const char *test_name,
    2451             :                          const char *error_message)
    2452             : {
    2453           0 :     switch (type) {
    2454           0 :     case PRINTF_TEST_START:
    2455           0 :         break;
    2456           0 :     case PRINTF_TEST_SUCCESS:
    2457           0 :         print_message("ok %u - %s\n", (unsigned)test_number, test_name);
    2458           0 :         break;
    2459           0 :     case PRINTF_TEST_FAILURE:
    2460           0 :         print_message("not ok %u - %s\n", (unsigned)test_number, test_name);
    2461           0 :         if (error_message != NULL) {
    2462             :             char *msg;
    2463             :             char *p;
    2464             : 
    2465           0 :             msg = strdup(error_message);
    2466           0 :             if (msg == NULL) {
    2467           0 :                 return;
    2468             :             }
    2469           0 :             p = msg;
    2470             : 
    2471           0 :             while (p[0] != '\0') {
    2472           0 :                 char *q = p;
    2473             : 
    2474           0 :                 p = strchr(q, '\n');
    2475           0 :                 if (p != NULL) {
    2476           0 :                     p[0] = '\0';
    2477             :                 }
    2478             : 
    2479           0 :                 print_message("# %s\n", q);
    2480             : 
    2481           0 :                 if (p == NULL) {
    2482           0 :                     break;
    2483             :                 }
    2484           0 :                 p++;
    2485             :             }
    2486           0 :             libc_free(msg);
    2487             :         }
    2488           0 :         break;
    2489           0 :     case PRINTF_TEST_SKIPPED:
    2490           0 :         print_message("not ok %u # SKIP %s\n", (unsigned)test_number, test_name);
    2491           0 :         break;
    2492           0 :     case PRINTF_TEST_ERROR:
    2493           0 :         print_message("not ok %u - %s %s\n",
    2494             :                       (unsigned)test_number, test_name, error_message);
    2495           0 :         break;
    2496             :     }
    2497             : }
    2498             : 
    2499         674 : static void cmprintf_subunit(enum cm_printf_type type,
    2500             :                              const char *test_name,
    2501             :                              const char *error_message)
    2502             : {
    2503         674 :     switch (type) {
    2504         337 :     case PRINTF_TEST_START:
    2505         337 :         print_message("test: %s\n", test_name);
    2506         337 :         break;
    2507         337 :     case PRINTF_TEST_SUCCESS:
    2508         337 :         print_message("success: %s\n", test_name);
    2509         337 :         break;
    2510           0 :     case PRINTF_TEST_FAILURE:
    2511           0 :         print_message("failure: %s", test_name);
    2512           0 :         if (error_message != NULL) {
    2513           0 :             print_message(" [\n%s\n]\n", error_message);
    2514             :         }
    2515           0 :         break;
    2516           0 :     case PRINTF_TEST_SKIPPED:
    2517           0 :         print_message("skip: %s\n", test_name);
    2518           0 :         break;
    2519           0 :     case PRINTF_TEST_ERROR:
    2520           0 :         print_message("error: %s [ %s ]\n", test_name, error_message);
    2521           0 :         break;
    2522             :     }
    2523         674 : }
    2524             : 
    2525          62 : static void cmprintf_group_start(const size_t num_tests)
    2526             : {
    2527             :     enum cm_message_output output;
    2528             : 
    2529          62 :     output = cm_get_output();
    2530             : 
    2531          62 :     switch (output) {
    2532          12 :     case CM_OUTPUT_STDOUT:
    2533          12 :         cmprintf_group_start_standard(num_tests);
    2534          12 :         break;
    2535           3 :     case CM_OUTPUT_SUBUNIT:
    2536           3 :         break;
    2537           0 :     case CM_OUTPUT_TAP:
    2538           0 :         cmprintf_group_start_tap(num_tests);
    2539           0 :         break;
    2540           0 :     case CM_OUTPUT_XML:
    2541           0 :         break;
    2542             :     }
    2543          62 : }
    2544             : 
    2545          62 : static void cmprintf_group_finish(const char *group_name,
    2546             :                                   size_t total_executed,
    2547             :                                   size_t total_passed,
    2548             :                                   size_t total_failed,
    2549             :                                   size_t total_errors,
    2550             :                                   size_t total_skipped,
    2551             :                                   double total_runtime,
    2552             :                                   struct CMUnitTestState *cm_tests)
    2553             : {
    2554             :     enum cm_message_output output;
    2555             : 
    2556          62 :     output = cm_get_output();
    2557             : 
    2558          62 :     switch (output) {
    2559          12 :     case CM_OUTPUT_STDOUT:
    2560          12 :         cmprintf_group_finish_standard(total_executed,
    2561             :                                     total_passed,
    2562             :                                     total_failed,
    2563             :                                     total_errors,
    2564             :                                     total_skipped,
    2565             :                                     cm_tests);
    2566          12 :         break;
    2567           3 :     case CM_OUTPUT_SUBUNIT:
    2568           3 :         break;
    2569           0 :     case CM_OUTPUT_TAP:
    2570           0 :         cmprintf_group_finish_tap(group_name, total_executed, total_passed, total_skipped);
    2571           0 :         break;
    2572           0 :     case CM_OUTPUT_XML:
    2573           0 :         cmprintf_group_finish_xml(group_name,
    2574             :                                   total_executed,
    2575             :                                   total_failed,
    2576             :                                   total_errors,
    2577             :                                   total_skipped,
    2578             :                                   total_runtime,
    2579             :                                   cm_tests);
    2580           0 :         break;
    2581             :     }
    2582          62 : }
    2583             : 
    2584         982 : static void cmprintf(enum cm_printf_type type,
    2585             :                      size_t test_number,
    2586             :                      const char *test_name,
    2587             :                      const char *error_message)
    2588             : {
    2589             :     enum cm_message_output output;
    2590             : 
    2591         982 :     output = cm_get_output();
    2592             : 
    2593         982 :     switch (output) {
    2594         308 :     case CM_OUTPUT_STDOUT:
    2595         308 :         cmprintf_standard(type, test_name, error_message);
    2596         308 :         break;
    2597         674 :     case CM_OUTPUT_SUBUNIT:
    2598         674 :         cmprintf_subunit(type, test_name, error_message);
    2599         674 :         break;
    2600           0 :     case CM_OUTPUT_TAP:
    2601           0 :         cmprintf_tap(type, test_number, test_name, error_message);
    2602           0 :         break;
    2603           0 :     case CM_OUTPUT_XML:
    2604           0 :         break;
    2605             :     }
    2606         982 : }
    2607             : 
    2608          50 : void cmocka_set_message_output(enum cm_message_output output)
    2609             : {
    2610          50 :     global_msg_output = output;
    2611          50 : }
    2612             : 
    2613           0 : void cmocka_set_test_filter(const char *pattern)
    2614             : {
    2615           0 :     global_test_filter_pattern = pattern;
    2616           0 : }
    2617             : 
    2618             : /****************************************************************************
    2619             :  * TIME CALCULATIONS
    2620             :  ****************************************************************************/
    2621             : 
    2622             : #ifdef HAVE_STRUCT_TIMESPEC
    2623         491 : static struct timespec cm_tspecdiff(struct timespec time1,
    2624             :                                     struct timespec time0)
    2625             : {
    2626             :     struct timespec ret;
    2627         491 :     int xsec = 0;
    2628         491 :     int sign = 1;
    2629             : 
    2630         491 :     if (time0.tv_nsec > time1.tv_nsec) {
    2631           1 :         xsec = (int) ((time0.tv_nsec - time1.tv_nsec) / (1E9 + 1));
    2632           1 :         time0.tv_nsec -= (long int) (1E9 * xsec);
    2633           1 :         time0.tv_sec += xsec;
    2634             :     }
    2635             : 
    2636         491 :     if ((time1.tv_nsec - time0.tv_nsec) > 1E9) {
    2637           0 :         xsec = (int) ((time1.tv_nsec - time0.tv_nsec) / 1E9);
    2638           0 :         time0.tv_nsec += (long int) (1E9 * xsec);
    2639           0 :         time0.tv_sec -= xsec;
    2640             :     }
    2641             : 
    2642         491 :     ret.tv_sec = time1.tv_sec - time0.tv_sec;
    2643         491 :     ret.tv_nsec = time1.tv_nsec - time0.tv_nsec;
    2644             : 
    2645         491 :     if (time1.tv_sec < time0.tv_sec) {
    2646           0 :         sign = -1;
    2647             :     }
    2648             : 
    2649         491 :     ret.tv_sec = ret.tv_sec * sign;
    2650             : 
    2651         491 :     return ret;
    2652             : }
    2653             : 
    2654         182 : static double cm_secdiff(struct timespec clock1, struct timespec clock0)
    2655             : {
    2656             :     double ret;
    2657             :     struct timespec diff;
    2658             : 
    2659         491 :     diff = cm_tspecdiff(clock1, clock0);
    2660             : 
    2661         491 :     ret = diff.tv_sec;
    2662         491 :     ret += (double) diff.tv_nsec / (double) 1E9;
    2663             : 
    2664         182 :     return ret;
    2665             : }
    2666             : #endif /* HAVE_STRUCT_TIMESPEC */
    2667             : 
    2668             : /****************************************************************************
    2669             :  * CMOCKA TEST RUNNER
    2670             :  ****************************************************************************/
    2671         982 : static int cmocka_run_one_test_or_fixture(const char *function_name,
    2672             :                                           CMUnitTestFunction test_func,
    2673             :                                           CMFixtureFunction setup_func,
    2674             :                                           CMFixtureFunction teardown_func,
    2675             :                                           void ** const volatile state,
    2676             :                                           const void *const heap_check_point)
    2677             : {
    2678        1430 :     const ListNode * const volatile check_point = (const ListNode*)
    2679             :         (heap_check_point != NULL ?
    2680             :          heap_check_point : check_point_allocated_blocks());
    2681         982 :     int handle_exceptions = 1;
    2682         982 :     void *current_state = NULL;
    2683         982 :     int rc = 0;
    2684             : 
    2685             :     /* FIXME check only one test or fixture is set */
    2686             : 
    2687             :     /* Detect if we should handle exceptions */
    2688             : #ifdef _WIN32
    2689             :     handle_exceptions = !IsDebuggerPresent();
    2690             : #endif /* _WIN32 */
    2691             : #ifdef UNIT_TESTING_DEBUG
    2692             :     handle_exceptions = 0;
    2693             : #endif /* UNIT_TESTING_DEBUG */
    2694             : 
    2695             : 
    2696         534 :     if (handle_exceptions) {
    2697             : #ifndef _WIN32
    2698             :         unsigned int i;
    2699        5892 :         for (i = 0; i < ARRAY_SIZE(exception_signals); i++) {
    2700        4910 :             default_signal_functions[i] = signal(
    2701             :                     exception_signals[i], exception_handler);
    2702             :         }
    2703             : #else /* _WIN32 */
    2704             :         previous_exception_filter = SetUnhandledExceptionFilter(
    2705             :                 exception_filter);
    2706             : #endif /* !_WIN32 */
    2707             :     }
    2708             : 
    2709             :     /* Init the test structure */
    2710         982 :     initialize_testing(function_name);
    2711             : 
    2712         982 :     global_running_test = 1;
    2713             : 
    2714         982 :     if (cm_setjmp(global_run_test_env) == 0) {
    2715         982 :         if (test_func != NULL) {
    2716         491 :             test_func(state != NULL ? state : &current_state);
    2717             : 
    2718         491 :             fail_if_blocks_allocated(check_point, function_name);
    2719         182 :             rc = 0;
    2720         491 :         } else if (setup_func != NULL) {
    2721         244 :             rc = setup_func(state != NULL ? state : &current_state);
    2722             : 
    2723             :             /*
    2724             :              * For setup we can ignore any allocated blocks. We just need to
    2725             :              * ensure they're deallocated on tear down.
    2726             :              */
    2727         247 :         } else if (teardown_func != NULL) {
    2728         247 :             rc = teardown_func(state != NULL ? state : &current_state);
    2729             : 
    2730         247 :             fail_if_blocks_allocated(check_point, function_name);
    2731             :         } else {
    2732             :             /* ERROR */
    2733             :         }
    2734         982 :         fail_if_leftover_values(function_name);
    2735         982 :         global_running_test = 0;
    2736             :     } else {
    2737             :         /* TEST FAILED */
    2738           0 :         global_running_test = 0;
    2739           0 :         rc = -1;
    2740             :     }
    2741         982 :     teardown_testing(function_name);
    2742             : 
    2743         534 :     if (handle_exceptions) {
    2744             : #ifndef _WIN32
    2745             :         unsigned int i;
    2746        5444 :         for (i = 0; i < ARRAY_SIZE(exception_signals); i++) {
    2747        4910 :             signal(exception_signals[i], default_signal_functions[i]);
    2748             :         }
    2749             : #else /* _WIN32 */
    2750             :         if (previous_exception_filter) {
    2751             :             SetUnhandledExceptionFilter(previous_exception_filter);
    2752             :             previous_exception_filter = NULL;
    2753             :         }
    2754             : #endif /* !_WIN32 */
    2755             :     }
    2756             : 
    2757         982 :     return rc;
    2758             : }
    2759             : 
    2760           5 : static int cmocka_run_group_fixture(const char *function_name,
    2761             :                                     CMFixtureFunction setup_func,
    2762             :                                     CMFixtureFunction teardown_func,
    2763             :                                     void **state,
    2764             :                                     const void *const heap_check_point)
    2765             : {
    2766             :     int rc;
    2767             : 
    2768           5 :     if (setup_func != NULL) {
    2769           5 :         rc = cmocka_run_one_test_or_fixture(function_name,
    2770             :                                         NULL,
    2771             :                                         setup_func,
    2772             :                                         NULL,
    2773             :                                         state,
    2774             :                                         heap_check_point);
    2775             :     } else {
    2776           5 :         rc = cmocka_run_one_test_or_fixture(function_name,
    2777             :                                         NULL,
    2778             :                                         NULL,
    2779             :                                         teardown_func,
    2780             :                                         state,
    2781             :                                         heap_check_point);
    2782             :     }
    2783             : 
    2784           5 :     return rc;
    2785             : }
    2786             : 
    2787         491 : static int cmocka_run_one_tests(struct CMUnitTestState *test_state)
    2788             : {
    2789             : #ifdef HAVE_STRUCT_TIMESPEC
    2790         491 :     struct timespec start = {
    2791             :         .tv_sec = 0,
    2792             :         .tv_nsec = 0,
    2793             :     };
    2794         491 :     struct timespec finish = {
    2795             :         .tv_sec = 0,
    2796             :         .tv_nsec = 0,
    2797             :     };
    2798             : #endif
    2799         491 :     int rc = 0;
    2800             : 
    2801             :     /* Run setup */
    2802         491 :     if (test_state->test->setup_func != NULL) {
    2803             :         /* Setup the memory check point, it will be evaluated on teardown */
    2804         239 :         test_state->check_point = check_point_allocated_blocks();
    2805             : 
    2806         415 :         rc = cmocka_run_one_test_or_fixture(test_state->test->name,
    2807             :                                             NULL,
    2808         176 :                                             test_state->test->setup_func,
    2809             :                                             NULL,
    2810             :                                             &test_state->state,
    2811         176 :                                             test_state->check_point);
    2812         239 :         if (rc != 0) {
    2813           0 :             test_state->status = CM_TEST_ERROR;
    2814           0 :             cm_print_error("Test setup failed");
    2815             :         }
    2816             :     }
    2817             : 
    2818             :     /* Run test */
    2819             : #ifdef HAVE_STRUCT_TIMESPEC
    2820         491 :     CMOCKA_CLOCK_GETTIME(CLOCK_REALTIME, &start);
    2821             : #endif
    2822             : 
    2823         491 :     if (rc == 0) {
    2824         982 :         rc = cmocka_run_one_test_or_fixture(test_state->test->name,
    2825         491 :                                             test_state->test->test_func,
    2826             :                                             NULL,
    2827             :                                             NULL,
    2828             :                                             &test_state->state,
    2829             :                                             NULL);
    2830         491 :         if (rc == 0) {
    2831         491 :             test_state->status = CM_TEST_PASSED;
    2832             :         } else {
    2833           0 :             if (global_skip_test) {
    2834           0 :                 test_state->status = CM_TEST_SKIPPED;
    2835           0 :                 global_skip_test = 0; /* Do not skip the next test */
    2836             :             } else {
    2837           0 :                 test_state->status = CM_TEST_FAILED;
    2838             :             }
    2839             :         }
    2840         182 :         rc = 0;
    2841             :     }
    2842             : 
    2843         491 :     test_state->runtime = 0.0;
    2844             : 
    2845             : #ifdef HAVE_STRUCT_TIMESPEC
    2846         491 :     CMOCKA_CLOCK_GETTIME(CLOCK_REALTIME, &finish);
    2847         491 :     test_state->runtime = cm_secdiff(finish, start);
    2848             : #endif
    2849             : 
    2850             :     /* Run teardown */
    2851         491 :     if (rc == 0 && test_state->test->teardown_func != NULL) {
    2852         418 :         rc = cmocka_run_one_test_or_fixture(test_state->test->name,
    2853             :                                             NULL,
    2854             :                                             NULL,
    2855         176 :                                             test_state->test->teardown_func,
    2856             :                                             &test_state->state,
    2857         242 :                                             test_state->check_point);
    2858         242 :         if (rc != 0) {
    2859           0 :             test_state->status = CM_TEST_ERROR;
    2860           0 :             cm_print_error("Test teardown failed");
    2861             :         }
    2862             :     }
    2863             : 
    2864         491 :     test_state->error_message = cm_error_message;
    2865         491 :     cm_error_message = NULL;
    2866             : 
    2867         491 :     return rc;
    2868             : }
    2869             : 
    2870          62 : int _cmocka_run_group_tests(const char *group_name,
    2871             :                             const struct CMUnitTest * const tests,
    2872             :                             const size_t num_tests,
    2873             :                             CMFixtureFunction group_setup,
    2874             :                             CMFixtureFunction group_teardown)
    2875             : {
    2876             :     struct CMUnitTestState *cm_tests;
    2877          62 :     const ListNode *group_check_point = check_point_allocated_blocks();
    2878          62 :     void *group_state = NULL;
    2879          62 :     size_t total_tests = 0;
    2880          62 :     size_t total_failed = 0;
    2881          62 :     size_t total_passed = 0;
    2882          62 :     size_t total_executed = 0;
    2883          62 :     size_t total_errors = 0;
    2884          62 :     size_t total_skipped = 0;
    2885          62 :     double total_runtime = 0;
    2886             :     size_t i;
    2887             :     int rc;
    2888             : 
    2889             :     /* Make sure LargestIntegralType is at least the size of a pointer. */
    2890          62 :     assert_true(sizeof(LargestIntegralType) >= sizeof(void*));
    2891             : 
    2892         109 :     cm_tests = (struct CMUnitTestState *)libc_malloc(sizeof(struct CMUnitTestState) * num_tests);
    2893          62 :     if (cm_tests == NULL) {
    2894           0 :         return -1;
    2895             :     }
    2896             : 
    2897             :     /* Setup cmocka test array */
    2898         506 :     for (i = 0; i < num_tests; i++) {
    2899         982 :         if (tests[i].name != NULL &&
    2900         491 :             (tests[i].test_func != NULL
    2901           0 :              || tests[i].setup_func != NULL
    2902           0 :              || tests[i].teardown_func != NULL)) {
    2903         491 :             if (global_test_filter_pattern != NULL) {
    2904             :                 int ok;
    2905             : 
    2906           0 :                 ok = c_strmatch(tests[i].name, global_test_filter_pattern);
    2907           0 :                 if (!ok) {
    2908           0 :                     continue;
    2909             :                 }
    2910             :             }
    2911         673 :             cm_tests[total_tests] = (struct CMUnitTestState) {
    2912         182 :                 .test = &tests[i],
    2913             :                 .status = CM_TEST_NOT_STARTED,
    2914             :                 .state = NULL,
    2915             :             };
    2916         491 :             total_tests++;
    2917             :         }
    2918             :     }
    2919             : 
    2920          62 :     cmprintf_group_start(total_tests);
    2921             : 
    2922          62 :     rc = 0;
    2923             : 
    2924             :     /* Run group setup */
    2925          62 :     if (group_setup != NULL) {
    2926           5 :         rc = cmocka_run_group_fixture("cmocka_group_setup",
    2927             :                                       group_setup,
    2928             :                                       NULL,
    2929             :                                       &group_state,
    2930             :                                       group_check_point);
    2931             :     }
    2932             : 
    2933          20 :     if (rc == 0) {
    2934             :         /* Execute tests */
    2935         553 :         for (i = 0; i < total_tests; i++) {
    2936         491 :             struct CMUnitTestState *cmtest = &cm_tests[i];
    2937         491 :             size_t test_number = i + 1;
    2938             : 
    2939         491 :             cmprintf(PRINTF_TEST_START, test_number, cmtest->test->name, NULL);
    2940             : 
    2941         491 :             if (group_state != NULL) {
    2942          40 :                 cmtest->state = group_state;
    2943         451 :             } else if (cmtest->test->initial_state  != NULL) {
    2944           0 :                 cmtest->state = cmtest->test->initial_state;
    2945             :             }
    2946             : 
    2947         491 :             rc = cmocka_run_one_tests(cmtest);
    2948         491 :             total_executed++;
    2949         491 :             total_runtime += cmtest->runtime;
    2950         491 :             if (rc == 0) {
    2951         491 :                 switch (cmtest->status) {
    2952         491 :                     case CM_TEST_PASSED:
    2953         982 :                         cmprintf(PRINTF_TEST_SUCCESS,
    2954             :                                  test_number,
    2955         491 :                                  cmtest->test->name,
    2956             :                                  cmtest->error_message);
    2957         491 :                         total_passed++;
    2958         491 :                         break;
    2959           0 :                     case CM_TEST_SKIPPED:
    2960           0 :                         cmprintf(PRINTF_TEST_SKIPPED,
    2961             :                                  test_number,
    2962           0 :                                  cmtest->test->name,
    2963             :                                  cmtest->error_message);
    2964           0 :                         total_skipped++;
    2965           0 :                         break;
    2966           0 :                     case CM_TEST_FAILED:
    2967           0 :                         cmprintf(PRINTF_TEST_FAILURE,
    2968             :                                  test_number,
    2969           0 :                                  cmtest->test->name,
    2970             :                                  cmtest->error_message);
    2971           0 :                         total_failed++;
    2972           0 :                         break;
    2973           0 :                     default:
    2974           0 :                         cmprintf(PRINTF_TEST_ERROR,
    2975             :                                  test_number,
    2976           0 :                                  cmtest->test->name,
    2977             :                                  "Internal cmocka error");
    2978           0 :                         total_errors++;
    2979           0 :                         break;
    2980             :                 }
    2981             :             } else {
    2982           0 :                 char err_msg[2048] = {0};
    2983             : 
    2984           0 :                 snprintf(err_msg, sizeof(err_msg),
    2985             :                          "Could not run test: %s",
    2986             :                          cmtest->error_message);
    2987             : 
    2988           0 :                 cmprintf(PRINTF_TEST_ERROR,
    2989             :                          test_number,
    2990           0 :                          cmtest->test->name,
    2991             :                          err_msg);
    2992           0 :                 total_errors++;
    2993             :             }
    2994             :         }
    2995             :     } else {
    2996           0 :         if (cm_error_message != NULL) {
    2997           0 :             print_error("[  ERROR   ] --- %s\n", cm_error_message);
    2998           0 :             vcm_free_error(cm_error_message);
    2999           0 :             cm_error_message = NULL;
    3000             :         }
    3001           0 :         cmprintf(PRINTF_TEST_ERROR, 0,
    3002             :                  group_name, "[  FAILED  ] GROUP SETUP");
    3003           0 :         total_errors++;
    3004             :     }
    3005             : 
    3006             :     /* Run group teardown */
    3007          62 :     if (group_teardown != NULL) {
    3008           5 :         rc = cmocka_run_group_fixture("cmocka_group_teardown",
    3009             :                                       NULL,
    3010             :                                       group_teardown,
    3011             :                                       &group_state,
    3012             :                                       group_check_point);
    3013           5 :         if (rc != 0) {
    3014           0 :             if (cm_error_message != NULL) {
    3015           0 :                 print_error("[  ERROR   ] --- %s\n", cm_error_message);
    3016           0 :                 vcm_free_error(cm_error_message);
    3017           0 :                 cm_error_message = NULL;
    3018             :             }
    3019           0 :             cmprintf(PRINTF_TEST_ERROR, 0,
    3020             :                      group_name, "[  FAILED  ] GROUP TEARDOWN");
    3021             :         }
    3022             :     }
    3023             : 
    3024          62 :     cmprintf_group_finish(group_name,
    3025             :                           total_executed,
    3026             :                           total_passed,
    3027             :                           total_failed,
    3028             :                           total_errors,
    3029             :                           total_skipped,
    3030             :                           total_runtime,
    3031             :                           cm_tests);
    3032             : 
    3033         553 :     for (i = 0; i < total_tests; i++) {
    3034         800 :         vcm_free_error(discard_const_p(char, cm_tests[i].error_message));
    3035             :     }
    3036          62 :     libc_free(cm_tests);
    3037          62 :     fail_if_blocks_allocated(group_check_point, "cmocka_group_tests");
    3038             : 
    3039          62 :     return total_failed + total_errors;
    3040             : }
    3041             : 
    3042             : /****************************************************************************
    3043             :  * DEPRECATED TEST RUNNER
    3044             :  ****************************************************************************/
    3045             : 
    3046           0 : int _run_test(
    3047             :         const char * const function_name,  const UnitTestFunction Function,
    3048             :         void ** const volatile state, const UnitTestFunctionType function_type,
    3049             :         const void* const heap_check_point) {
    3050           0 :     const ListNode * const volatile check_point = (const ListNode*)
    3051             :         (heap_check_point ?
    3052             :          heap_check_point : check_point_allocated_blocks());
    3053           0 :     void *current_state = NULL;
    3054           0 :     volatile int rc = 1;
    3055           0 :     int handle_exceptions = 1;
    3056             : #ifdef _WIN32
    3057             :     handle_exceptions = !IsDebuggerPresent();
    3058             : #endif /* _WIN32 */
    3059             : #ifdef UNIT_TESTING_DEBUG
    3060             :     handle_exceptions = 0;
    3061             : #endif /* UNIT_TESTING_DEBUG */
    3062             : 
    3063           0 :     cm_error_message_enabled = 0;
    3064             : 
    3065           0 :     if (handle_exceptions) {
    3066             : #ifndef _WIN32
    3067             :         unsigned int i;
    3068           0 :         for (i = 0; i < ARRAY_SIZE(exception_signals); i++) {
    3069           0 :             default_signal_functions[i] = signal(
    3070             :                 exception_signals[i], exception_handler);
    3071             :         }
    3072             : #else /* _WIN32 */
    3073             :         previous_exception_filter = SetUnhandledExceptionFilter(
    3074             :             exception_filter);
    3075             : #endif /* !_WIN32 */
    3076             :     }
    3077             : 
    3078           0 :     if (function_type == UNIT_TEST_FUNCTION_TYPE_TEST) {
    3079           0 :         print_message("[ RUN      ] %s\n", function_name);
    3080             :     }
    3081           0 :     initialize_testing(function_name);
    3082           0 :     global_running_test = 1;
    3083           0 :     if (cm_setjmp(global_run_test_env) == 0) {
    3084           0 :         Function(state ? state : &current_state);
    3085           0 :         fail_if_leftover_values(function_name);
    3086             : 
    3087             :         /* If this is a setup function then ignore any allocated blocks
    3088             :          * only ensure they're deallocated on tear down. */
    3089           0 :         if (function_type != UNIT_TEST_FUNCTION_TYPE_SETUP) {
    3090           0 :             fail_if_blocks_allocated(check_point, function_name);
    3091             :         }
    3092             : 
    3093           0 :         global_running_test = 0;
    3094             : 
    3095           0 :         if (function_type == UNIT_TEST_FUNCTION_TYPE_TEST) {
    3096           0 :             print_message("[       OK ] %s\n", function_name);
    3097             :         }
    3098           0 :         rc = 0;
    3099             :     } else {
    3100           0 :         global_running_test = 0;
    3101           0 :         print_message("[  FAILED  ] %s\n", function_name);
    3102             :     }
    3103           0 :     teardown_testing(function_name);
    3104             : 
    3105           0 :     if (handle_exceptions) {
    3106             : #ifndef _WIN32
    3107             :         unsigned int i;
    3108           0 :         for (i = 0; i < ARRAY_SIZE(exception_signals); i++) {
    3109           0 :             signal(exception_signals[i], default_signal_functions[i]);
    3110             :         }
    3111             : #else /* _WIN32 */
    3112             :         if (previous_exception_filter) {
    3113             :             SetUnhandledExceptionFilter(previous_exception_filter);
    3114             :             previous_exception_filter = NULL;
    3115             :         }
    3116             : #endif /* !_WIN32 */
    3117             :     }
    3118             : 
    3119           0 :     return rc;
    3120             : }
    3121             : 
    3122             : 
    3123           0 : int _run_tests(const UnitTest * const tests, const size_t number_of_tests) {
    3124             :     /* Whether to execute the next test. */
    3125           0 :     int run_next_test = 1;
    3126             :     /* Whether the previous test failed. */
    3127           0 :     int previous_test_failed = 0;
    3128             :     /* Whether the previous setup failed. */
    3129           0 :     int previous_setup_failed = 0;
    3130             :     /* Check point of the heap state. */
    3131           0 :     const ListNode * const check_point = check_point_allocated_blocks();
    3132             :     /* Current test being executed. */
    3133           0 :     size_t current_test = 0;
    3134             :     /* Number of tests executed. */
    3135           0 :     size_t tests_executed = 0;
    3136             :     /* Number of failed tests. */
    3137           0 :     size_t total_failed = 0;
    3138             :     /* Number of setup functions. */
    3139           0 :     size_t setups = 0;
    3140             :     /* Number of teardown functions. */
    3141           0 :     size_t teardowns = 0;
    3142             :     size_t i;
    3143             :     /*
    3144             :      * A stack of test states.  A state is pushed on the stack
    3145             :      * when a test setup occurs and popped on tear down.
    3146             :      */
    3147           0 :     TestState* test_states =
    3148           0 :        (TestState*)malloc(number_of_tests * sizeof(*test_states));
    3149             :     /* The number of test states which should be 0 at the end */
    3150           0 :     long number_of_test_states = 0;
    3151             :     /* Names of the tests that failed. */
    3152           0 :     const char** failed_names = (const char**)malloc(number_of_tests *
    3153             :                                        sizeof(*failed_names));
    3154           0 :     void **current_state = NULL;
    3155             : 
    3156             :     /* Count setup and teardown functions */
    3157           0 :     for (i = 0; i < number_of_tests; i++) {
    3158           0 :         const UnitTest * const test = &tests[i];
    3159             : 
    3160           0 :         if (test->function_type == UNIT_TEST_FUNCTION_TYPE_SETUP) {
    3161           0 :             setups++;
    3162             :         }
    3163             : 
    3164           0 :         if (test->function_type == UNIT_TEST_FUNCTION_TYPE_TEARDOWN) {
    3165           0 :             teardowns++;
    3166             :         }
    3167             :     }
    3168             : 
    3169           0 :     print_message("[==========] Running %"PRIdS " test(s).\n",
    3170           0 :                   number_of_tests - setups - teardowns);
    3171             : 
    3172             :     /* Make sure LargestIntegralType is at least the size of a pointer. */
    3173           0 :     assert_true(sizeof(LargestIntegralType) >= sizeof(void*));
    3174             : 
    3175           0 :     while (current_test < number_of_tests) {
    3176           0 :         const ListNode *test_check_point = NULL;
    3177             :         TestState *current_TestState;
    3178           0 :         const UnitTest * const test = &tests[current_test++];
    3179           0 :         if (!test->function) {
    3180           0 :             continue;
    3181             :         }
    3182             : 
    3183           0 :         switch (test->function_type) {
    3184           0 :         case UNIT_TEST_FUNCTION_TYPE_TEST:
    3185           0 :             if (! previous_setup_failed) {
    3186           0 :                 run_next_test = 1;
    3187             :             }
    3188           0 :             break;
    3189           0 :         case UNIT_TEST_FUNCTION_TYPE_SETUP: {
    3190             :             /* Checkpoint the heap before the setup. */
    3191           0 :             current_TestState = &test_states[number_of_test_states++];
    3192           0 :             current_TestState->check_point = check_point_allocated_blocks();
    3193           0 :             test_check_point = current_TestState->check_point;
    3194           0 :             current_state = &current_TestState->state;
    3195           0 :             *current_state = NULL;
    3196           0 :             run_next_test = 1;
    3197           0 :             break;
    3198             :         }
    3199           0 :         case UNIT_TEST_FUNCTION_TYPE_TEARDOWN:
    3200             :             /* Check the heap based on the last setup checkpoint. */
    3201           0 :             assert_true(number_of_test_states);
    3202           0 :             current_TestState = &test_states[--number_of_test_states];
    3203           0 :             test_check_point = current_TestState->check_point;
    3204           0 :             current_state = &current_TestState->state;
    3205           0 :             break;
    3206           0 :         default:
    3207           0 :             print_error("Invalid unit test function type %d\n",
    3208           0 :                         test->function_type);
    3209           0 :             exit_test(1);
    3210           0 :             break;
    3211             :         }
    3212             : 
    3213           0 :         if (run_next_test) {
    3214           0 :             int failed = _run_test(test->name, test->function, current_state,
    3215             :                                    test->function_type, test_check_point);
    3216           0 :             if (failed) {
    3217           0 :                 failed_names[total_failed] = test->name;
    3218             :             }
    3219             : 
    3220           0 :             switch (test->function_type) {
    3221           0 :             case UNIT_TEST_FUNCTION_TYPE_TEST:
    3222           0 :                 previous_test_failed = failed;
    3223           0 :                 total_failed += failed;
    3224           0 :                 tests_executed ++;
    3225           0 :                 break;
    3226             : 
    3227           0 :             case UNIT_TEST_FUNCTION_TYPE_SETUP:
    3228           0 :                 if (failed) {
    3229           0 :                     total_failed ++;
    3230           0 :                     tests_executed ++;
    3231             :                     /* Skip forward until the next test or setup function. */
    3232           0 :                     run_next_test = 0;
    3233           0 :                     previous_setup_failed = 1;
    3234             :                 }
    3235           0 :                 previous_test_failed = 0;
    3236           0 :                 break;
    3237             : 
    3238           0 :             case UNIT_TEST_FUNCTION_TYPE_TEARDOWN:
    3239             :                 /* If this test failed. */
    3240           0 :                 if (failed && !previous_test_failed) {
    3241           0 :                     total_failed ++;
    3242             :                 }
    3243           0 :                 break;
    3244           0 :             default:
    3245             : #ifndef _HPUX
    3246           0 :                 assert_null("BUG: shouldn't be here!");
    3247             : #endif
    3248           0 :                 break;
    3249             :             }
    3250           0 :         }
    3251             :     }
    3252             : 
    3253           0 :     print_message("[==========] %"PRIdS " test(s) run.\n", tests_executed);
    3254           0 :     print_error("[  PASSED  ] %"PRIdS " test(s).\n", tests_executed - total_failed);
    3255             : 
    3256           0 :     if (total_failed > 0) {
    3257           0 :         print_error("[  FAILED  ] %"PRIdS " test(s), listed below:\n", total_failed);
    3258           0 :         for (i = 0; i < total_failed; i++) {
    3259           0 :             print_error("[  FAILED  ] %s\n", failed_names[i]);
    3260             :         }
    3261             :     } else {
    3262           0 :         print_error("\n %"PRIdS " FAILED TEST(S)\n", total_failed);
    3263             :     }
    3264             : 
    3265           0 :     if (number_of_test_states != 0) {
    3266           0 :         print_error("[  ERROR   ] Mismatched number of setup %"PRIdS " and "
    3267             :                     "teardown %"PRIdS " functions\n", setups, teardowns);
    3268           0 :         total_failed = (size_t)-1;
    3269             :     }
    3270             : 
    3271           0 :     free(test_states);
    3272           0 :     free((void*)failed_names);
    3273             : 
    3274           0 :     fail_if_blocks_allocated(check_point, "run_tests");
    3275           0 :     return (int)total_failed;
    3276             : }
    3277             : 
    3278           0 : int _run_group_tests(const UnitTest * const tests, const size_t number_of_tests)
    3279             : {
    3280           0 :     UnitTestFunction setup = NULL;
    3281             :     const char *setup_name;
    3282           0 :     size_t num_setups = 0;
    3283           0 :     UnitTestFunction teardown = NULL;
    3284           0 :     const char *teardown_name = NULL;
    3285           0 :     size_t num_teardowns = 0;
    3286           0 :     size_t current_test = 0;
    3287             :     size_t i;
    3288             : 
    3289             :     /* Number of tests executed. */
    3290           0 :     size_t tests_executed = 0;
    3291             :     /* Number of failed tests. */
    3292           0 :     size_t total_failed = 0;
    3293             :     /* Check point of the heap state. */
    3294           0 :     const ListNode * const check_point = check_point_allocated_blocks();
    3295           0 :     const char **failed_names = NULL;
    3296           0 :     void **current_state = NULL;
    3297           0 :     TestState group_state = {
    3298             :         .check_point = NULL,
    3299             :     };
    3300             : 
    3301           0 :     if (number_of_tests == 0) {
    3302           0 :         return -1;
    3303             :     }
    3304             : 
    3305           0 :     failed_names = (const char **)malloc(number_of_tests *
    3306             :                                          sizeof(*failed_names));
    3307           0 :     if (failed_names == NULL) {
    3308           0 :         return -2;
    3309             :     }
    3310             : 
    3311             :     /* Find setup and teardown function */
    3312           0 :     for (i = 0; i < number_of_tests; i++) {
    3313           0 :         const UnitTest * const test = &tests[i];
    3314             : 
    3315           0 :         if (test->function_type == UNIT_TEST_FUNCTION_TYPE_GROUP_SETUP) {
    3316           0 :             if (setup == NULL) {
    3317           0 :                 setup = test->function;
    3318           0 :                 setup_name = test->name;
    3319           0 :                 num_setups = 1;
    3320             :             } else {
    3321           0 :                 print_error("[  ERROR   ] More than one group setup function detected\n");
    3322           0 :                 exit_test(1);
    3323             :             }
    3324             :         }
    3325             : 
    3326           0 :         if (test->function_type == UNIT_TEST_FUNCTION_TYPE_GROUP_TEARDOWN) {
    3327           0 :             if (teardown == NULL) {
    3328           0 :                 teardown = test->function;
    3329           0 :                 teardown_name = test->name;
    3330           0 :                 num_teardowns = 1;
    3331             :             } else {
    3332           0 :                 print_error("[  ERROR   ] More than one group teardown function detected\n");
    3333           0 :                 exit_test(1);
    3334             :             }
    3335             :         }
    3336             :     }
    3337             : 
    3338           0 :     print_message("[==========] Running %"PRIdS " test(s).\n",
    3339           0 :                   number_of_tests - num_setups - num_teardowns);
    3340             : 
    3341           0 :     if (setup != NULL) {
    3342             :         int failed;
    3343             : 
    3344           0 :         group_state.check_point = check_point_allocated_blocks();
    3345           0 :         current_state = &group_state.state;
    3346           0 :         *current_state = NULL;
    3347           0 :         failed = _run_test(setup_name,
    3348             :                            setup,
    3349             :                            current_state,
    3350             :                            UNIT_TEST_FUNCTION_TYPE_SETUP,
    3351           0 :                            group_state.check_point);
    3352           0 :         if (failed) {
    3353           0 :             failed_names[total_failed] = setup_name;
    3354             :         }
    3355             : 
    3356           0 :         total_failed += failed;
    3357           0 :         tests_executed++;
    3358             :     }
    3359             : 
    3360           0 :     while (current_test < number_of_tests) {
    3361           0 :         int run_test = 0;
    3362           0 :         const UnitTest * const test = &tests[current_test++];
    3363           0 :         if (test->function == NULL) {
    3364           0 :             continue;
    3365             :         }
    3366             : 
    3367           0 :         switch (test->function_type) {
    3368           0 :         case UNIT_TEST_FUNCTION_TYPE_TEST:
    3369           0 :             run_test = 1;
    3370           0 :             break;
    3371           0 :         case UNIT_TEST_FUNCTION_TYPE_SETUP:
    3372             :         case UNIT_TEST_FUNCTION_TYPE_TEARDOWN:
    3373             :         case UNIT_TEST_FUNCTION_TYPE_GROUP_SETUP:
    3374             :         case UNIT_TEST_FUNCTION_TYPE_GROUP_TEARDOWN:
    3375           0 :             break;
    3376           0 :         default:
    3377           0 :             print_error("Invalid unit test function type %d\n",
    3378           0 :                         test->function_type);
    3379           0 :             break;
    3380             :         }
    3381             : 
    3382           0 :         if (run_test) {
    3383             :             int failed;
    3384             : 
    3385           0 :             failed = _run_test(test->name,
    3386             :                                test->function,
    3387             :                                current_state,
    3388             :                                test->function_type,
    3389             :                                NULL);
    3390           0 :             if (failed) {
    3391           0 :                 failed_names[total_failed] = test->name;
    3392             :             }
    3393             : 
    3394           0 :             total_failed += failed;
    3395           0 :             tests_executed++;
    3396             :         }
    3397             :     }
    3398             : 
    3399           0 :     if (teardown != NULL) {
    3400             :         int failed;
    3401             : 
    3402           0 :         failed = _run_test(teardown_name,
    3403             :                            teardown,
    3404             :                            current_state,
    3405             :                            UNIT_TEST_FUNCTION_TYPE_GROUP_TEARDOWN,
    3406           0 :                            group_state.check_point);
    3407           0 :         if (failed) {
    3408           0 :             failed_names[total_failed] = teardown_name;
    3409             :         }
    3410             : 
    3411           0 :         total_failed += failed;
    3412           0 :         tests_executed++;
    3413             :     }
    3414             : 
    3415           0 :     print_message("[==========] %"PRIdS " test(s) run.\n", tests_executed);
    3416           0 :     print_error("[  PASSED  ] %"PRIdS " test(s).\n", tests_executed - total_failed);
    3417             : 
    3418           0 :     if (total_failed) {
    3419           0 :         print_error("[  FAILED  ] %"PRIdS " test(s), listed below:\n", total_failed);
    3420           0 :         for (i = 0; i < total_failed; i++) {
    3421           0 :             print_error("[  FAILED  ] %s\n", failed_names[i]);
    3422             :         }
    3423             :     } else {
    3424           0 :         print_error("\n %"PRIdS " FAILED TEST(S)\n", total_failed);
    3425             :     }
    3426             : 
    3427           0 :     free((void*)failed_names);
    3428           0 :     fail_if_blocks_allocated(check_point, "run_group_tests");
    3429             : 
    3430           0 :     return (int)total_failed;
    3431             : }

Generated by: LCOV version 1.13