1 /* Miniature re-implementation of the "check" library. 2 3 This is intended to support just enough of check to run the Expat 4 tests. This interface is based entirely on the portion of the 5 check library being used. 6 __ __ _ 7 ___\ \/ /_ __ __ _| |_ 8 / _ \\ /| '_ \ / _` | __| 9 | __// \| |_) | (_| | |_ 10 \___/_/\_\ .__/ \__,_|\__| 11 |_| XML parser 12 13 Copyright (c) 2004-2006 Fred L. Drake, Jr. <fdrake@users.sourceforge.net> 14 Copyright (c) 2016-2020 Sebastian Pipping <sebastian@pipping.org> 15 Copyright (c) 2017 Rhodri James <rhodri@wildebeest.org.uk> 16 Copyright (c) 2018 Marco Maggi <marco.maggi-ipsu@poste.it> 17 Copyright (c) 2019 David Loffredo <loffredo@steptools.com> 18 Licensed under the MIT license: 19 20 Permission is hereby granted, free of charge, to any person obtaining 21 a copy of this software and associated documentation files (the 22 "Software"), to deal in the Software without restriction, including 23 without limitation the rights to use, copy, modify, merge, publish, 24 distribute, sublicense, and/or sell copies of the Software, and to permit 25 persons to whom the Software is furnished to do so, subject to the 26 following conditions: 27 28 The above copyright notice and this permission notice shall be included 29 in all copies or substantial portions of the Software. 30 31 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 32 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 33 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN 34 NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 35 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 36 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 37 USE OR OTHER DEALINGS IN THE SOFTWARE. 38 */ 39 40 #include <stdio.h> 41 #include <stdlib.h> 42 #include <setjmp.h> 43 #include <assert.h> 44 #include <string.h> 45 46 #include "internal.h" /* for UNUSED_P only */ 47 #include "minicheck.h" 48 49 Suite * 50 suite_create(const char *name) { 51 Suite *suite = (Suite *)calloc(1, sizeof(Suite)); 52 if (suite != NULL) { 53 suite->name = name; 54 } 55 return suite; 56 } 57 58 TCase * 59 tcase_create(const char *name) { 60 TCase *tc = (TCase *)calloc(1, sizeof(TCase)); 61 if (tc != NULL) { 62 tc->name = name; 63 } 64 return tc; 65 } 66 67 void 68 suite_add_tcase(Suite *suite, TCase *tc) { 69 assert(suite != NULL); 70 assert(tc != NULL); 71 assert(tc->next_tcase == NULL); 72 73 tc->next_tcase = suite->tests; 74 suite->tests = tc; 75 } 76 77 void 78 tcase_add_checked_fixture(TCase *tc, tcase_setup_function setup, 79 tcase_teardown_function teardown) { 80 assert(tc != NULL); 81 tc->setup = setup; 82 tc->teardown = teardown; 83 } 84 85 void 86 tcase_add_test(TCase *tc, tcase_test_function test) { 87 assert(tc != NULL); 88 if (tc->allocated == tc->ntests) { 89 int nalloc = tc->allocated + 100; 90 size_t new_size = sizeof(tcase_test_function) * nalloc; 91 tcase_test_function *new_tests = realloc(tc->tests, new_size); 92 assert(new_tests != NULL); 93 tc->tests = new_tests; 94 tc->allocated = nalloc; 95 } 96 tc->tests[tc->ntests] = test; 97 tc->ntests++; 98 } 99 100 static void 101 tcase_free(TCase *tc) { 102 if (! tc) { 103 return; 104 } 105 106 free(tc->tests); 107 free(tc); 108 } 109 110 static void 111 suite_free(Suite *suite) { 112 if (! suite) { 113 return; 114 } 115 116 while (suite->tests != NULL) { 117 TCase *next = suite->tests->next_tcase; 118 tcase_free(suite->tests); 119 suite->tests = next; 120 } 121 free(suite); 122 } 123 124 SRunner * 125 srunner_create(Suite *suite) { 126 SRunner *runner = calloc(1, sizeof(SRunner)); 127 if (runner != NULL) { 128 runner->suite = suite; 129 } 130 return runner; 131 } 132 133 static jmp_buf env; 134 135 static char const *_check_current_function = NULL; 136 static int _check_current_lineno = -1; 137 static char const *_check_current_filename = NULL; 138 139 void 140 _check_set_test_info(char const *function, char const *filename, int lineno) { 141 _check_current_function = function; 142 _check_current_lineno = lineno; 143 _check_current_filename = filename; 144 } 145 146 static void 147 handle_success(int verbosity) { 148 if (verbosity >= CK_VERBOSE) { 149 printf("PASS: %s\n", _check_current_function); 150 } 151 } 152 153 static void 154 handle_failure(SRunner *runner, int verbosity, const char *phase_info) { 155 runner->nfailures++; 156 if (verbosity != CK_SILENT) { 157 printf("FAIL: %s (%s at %s:%d)\n", _check_current_function, phase_info, 158 _check_current_filename, _check_current_lineno); 159 } 160 } 161 162 void 163 srunner_run_all(SRunner *runner, int verbosity) { 164 Suite *suite; 165 TCase *volatile tc; 166 assert(runner != NULL); 167 suite = runner->suite; 168 tc = suite->tests; 169 while (tc != NULL) { 170 volatile int i; 171 for (i = 0; i < tc->ntests; ++i) { 172 runner->nchecks++; 173 174 if (tc->setup != NULL) { 175 /* setup */ 176 if (setjmp(env)) { 177 handle_failure(runner, verbosity, "during setup"); 178 continue; 179 } 180 tc->setup(); 181 } 182 /* test */ 183 if (setjmp(env)) { 184 handle_failure(runner, verbosity, "during actual test"); 185 continue; 186 } 187 (tc->tests[i])(); 188 189 /* teardown */ 190 if (tc->teardown != NULL) { 191 if (setjmp(env)) { 192 handle_failure(runner, verbosity, "during teardown"); 193 continue; 194 } 195 tc->teardown(); 196 } 197 198 handle_success(verbosity); 199 } 200 tc = tc->next_tcase; 201 } 202 if (verbosity != CK_SILENT) { 203 int passed = runner->nchecks - runner->nfailures; 204 double percentage = ((double)passed) / runner->nchecks; 205 int display = (int)(percentage * 100); 206 printf("%d%%: Checks: %d, Failed: %d\n", display, runner->nchecks, 207 runner->nfailures); 208 } 209 } 210 211 void 212 _fail_unless(int condition, const char *file, int line, const char *msg) { 213 /* Always print the error message so it isn't lost. In this case, 214 we have a failure, so there's no reason to be quiet about what 215 it is. 216 */ 217 UNUSED_P(condition); 218 _check_current_filename = file; 219 _check_current_lineno = line; 220 if (msg != NULL) { 221 const int has_newline = (msg[strlen(msg) - 1] == '\n'); 222 fprintf(stderr, "ERROR: %s%s", msg, has_newline ? "" : "\n"); 223 } 224 longjmp(env, 1); 225 } 226 227 int 228 srunner_ntests_failed(SRunner *runner) { 229 assert(runner != NULL); 230 return runner->nfailures; 231 } 232 233 void 234 srunner_free(SRunner *runner) { 235 if (! runner) { 236 return; 237 } 238 239 suite_free(runner->suite); 240 free(runner); 241 } 242