Return to minicheck.c CVS log

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

Annotation of embedaddon/expat/tests/minicheck.c, revision 1.1

1.1     ! misho       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: }