src/expat/tests/minicheck.c

   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 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <setjmp.h>
  11 #include <assert.h>
  12
  13 #include "minicheck.h"
  14
  15 Suite *
  16 suite_create(char *name)
  17 {
  18     Suite *suite = (Suite *) calloc(1, sizeof(Suite));
  19     if (suite != NULL) {
  20         suite->name = name;
  21     }
  22     return suite;
  23 }
  24
  25 TCase *
  26 tcase_create(char *name)
  27 {
  28     TCase *tc = (TCase *) calloc(1, sizeof(TCase));
  29     if (tc != NULL) {
  30         tc->name = name;
  31     }
  32     return tc;
  33 }
  34
  35 void
  36 suite_add_tcase(Suite *suite, TCase *tc)
  37 {
  38     assert(suite != NULL);
  39     assert(tc != NULL);
  40     assert(tc->next_tcase == NULL);
  41
  42     tc->next_tcase = suite->tests;
  43     suite->tests = tc;
  44 }
  45
  46 void
  47 tcase_add_checked_fixture(TCase *tc,
  48                           tcase_setup_function setup,
  49                           tcase_teardown_function teardown)
  50 {
  51     assert(tc != NULL);
  52     tc->setup = setup;
  53     tc->teardown = teardown;
  54 }
  55
  56 void
  57 tcase_add_test(TCase *tc, tcase_test_function test)
  58 {
  59     assert(tc != NULL);
  60     if (tc->allocated == tc->ntests) {
  61         int nalloc = tc->allocated + 100;
  62         size_t new_size = sizeof(tcase_test_function) * nalloc;
  63         tcase_test_function *new_tests = realloc(tc->tests, new_size);
  64         assert(new_tests != NULL);
  65         if (new_tests != tc->tests) {
  66             free(tc->tests);
  67             tc->tests = new_tests;
  68         }
  69         tc->allocated = nalloc;
  70     }
  71     tc->tests[tc->ntests] = test;
  72     tc->ntests++;
  73 }
  74
  75 SRunner *
  76 srunner_create(Suite *suite)
  77 {
  78     SRunner *runner = calloc(1, sizeof(SRunner));
  79     if (runner != NULL) {
  80         runner->suite = suite;
  81     }
  82     return runner;
  83 }
  84
  85 static jmp_buf env;
  86
  87 static char const *_check_current_function = NULL;
  88 static int _check_current_lineno = -1;
  89 static char const *_check_current_filename = NULL;
  90
  91 void
  92 _check_set_test_info(char const *function, char const *filename, int lineno)
  93 {
  94     _check_current_function = function;
  95     _check_current_lineno = lineno;
  96     _check_current_filename = filename;
  97 }
  98
  99
 100 static void
 101 add_failure(SRunner *runner, int verbosity)
 102 {
 103     runner->nfailures++;
 104     if (verbosity >= CK_VERBOSE) {
 105         printf("%s:%d: %s\n", _check_current_filename,
 106                _check_current_lineno, _check_current_function);
 107     }
 108 }
 109
 110 void
 111 srunner_run_all(SRunner *runner, int verbosity)
 112 {
 113     Suite *suite;
 114     TCase *tc;
 115     assert(runner != NULL);
 116     suite = runner->suite;
 117     tc = suite->tests;
 118     while (tc != NULL) {
 119         int i;
 120         for (i = 0; i < tc->ntests; ++i) {
 121             runner->nchecks++;
 122
 123             if (tc->setup != NULL) {
 124                 /* setup */
 125                 if (setjmp(env)) {
 126                     add_failure(runner, verbosity);
 127                     continue;
 128                 }
 129                 tc->setup();
 130             }
 131             /* test */
 132             if (setjmp(env)) {
 133                 add_failure(runner, verbosity);
 134                 continue;
 135             }
 136             (tc->tests[i])();
 137
 138             /* teardown */
 139             if (tc->teardown != NULL) {
 140                 if (setjmp(env)) {
 141                     add_failure(runner, verbosity);
 142                     continue;
 143                 }
 144                 tc->teardown();
 145             }
 146         }
 147         tc = tc->next_tcase;
 148     }
 149     if (verbosity) {
 150         int passed = runner->nchecks - runner->nfailures;
 151         double percentage = ((double) passed) / runner->nchecks;
 152         int display = (int) (percentage * 100);
 153         printf("%d%%: Checks: %d, Failed: %d\n",
 154                display, runner->nchecks, runner->nfailures);
 155     }
 156 }
 157
 158 void
 159 _fail_unless(int condition, const char *file, int line, char *msg)
 160 {
 161     /* Always print the error message so it isn't lost.  In this case,
 162        we have a failure, so there's no reason to be quiet about what
 163        it is.
 164     */
 165     if (msg != NULL)
 166         printf("%s", msg);
 167     longjmp(env, 1);
 168 }
 169
 170 int
 171 srunner_ntests_failed(SRunner *runner)
 172 {
 173     assert(runner != NULL);
 174     return runner->nfailures;
 175 }
 176
 177 void
 178 srunner_free(SRunner *runner)
 179 {
 180     free(runner->suite);
 181     free(runner);
 182 }