Return to minicheck.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / expat / tests

expat

    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: }