test/abts.c

   1 /* Copyright 2000-2004 Ryan Bloom
   2  *
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  *
  15  * Portions of this file were taken from testall.c in the APR test suite,
  16  * written by members of the Apache Software Foundation.
  17  */
  18
  19 #include "abts.h"
  20 #include "abts_tests.h"
  21 #include "testutil.h"
  22
  23 #define ABTS_STAT_SIZE 6
  24 static char status[ABTS_STAT_SIZE] = {'|', '/', '-', '|', '\\', '-'};
  25 static int curr_char;
  26 static int verbose = 0;
  27 static int exclude = 0;
  28 static int quiet = 0;
  29 static int list_tests = 0;
  30
  31 const char **testlist = NULL;
  32
  33 static int find_test_name(const char *testname) {
  34     int i;
  35     for (i = 0; testlist[i] != NULL; i++) {
  36         if (!strcmp(testlist[i], testname)) {
  37             return 1;
  38         }
  39     }
  40     return 0;
  41 }
  42
  43 /* Determine if the test should be run at all */
  44 static int should_test_run(const char *testname) {
  45     int found = 0;
  46     if (list_tests == 1) {
  47         return 0;
  48     }
  49     if (testlist == NULL) {
  50         return 1;
  51     }
  52     found = find_test_name(testname);
  53     if ((found && !exclude) || (!found && exclude)) {
  54         return 1;
  55     }
  56     return 0;
  57 }
  58
  59 static void reset_status(void)
  60 {
  61     curr_char = 0;
  62 }
  63
  64 static void update_status(void)
  65 {
  66     if (!quiet) {
  67         curr_char = (curr_char + 1) % ABTS_STAT_SIZE;
  68         fprintf(stdout, "\b%c", status[curr_char]);
  69         fflush(stdout);
  70     }
  71 }
  72
  73 static void end_suite(abts_suite *suite)
  74 {
  75     if (suite != NULL) {
  76         sub_suite *last = suite->tail;
  77         if (!quiet) {
  78             fprintf(stdout, "\b");
  79             fflush(stdout);
  80         }
  81         if (last->failed == 0) {
  82             fprintf(stdout, "SUCCESS\n");
  83             fflush(stdout);
  84         }
  85         else {
  86             fprintf(stdout, "FAILED %d of %d\n", last->failed, last->num_test);
  87             fflush(stdout);
  88         }
  89     }
  90 }
  91
  92 abts_suite *abts_add_suite(abts_suite *suite, const char *suite_name_full)
  93 {
  94     sub_suite *subsuite;
  95     char *p;
  96     const char *suite_name;
  97     curr_char = 0;
  98
  99     /* Only end the suite if we actually ran it */
 100     if (suite && suite->tail &&!suite->tail->not_run) {
 101         end_suite(suite);
 102     }
 103
 104     subsuite = malloc(sizeof(*subsuite));
 105     subsuite->num_test = 0;
 106     subsuite->failed = 0;
 107     subsuite->next = NULL;
 108     /* suite_name_full may be an absolute path depending on __FILE__
 109      * expansion */
 110     suite_name = strrchr(suite_name_full, '/');
 111     if (suite_name) {
 112         suite_name++;
 113     } else {
 114         suite_name = suite_name_full;
 115     }
 116     p = strrchr(suite_name, '.');
 117     if (p) {
 118         subsuite->name = memcpy(calloc(p - suite_name + 1, 1),
 119                                 suite_name, p - suite_name);
 120     }
 121     else {
 122         subsuite->name = suite_name;
 123     }
 124
 125     if (list_tests) {
 126         fprintf(stdout, "%s\n", subsuite->name);
 127     }
 128
 129     subsuite->not_run = 0;
 130
 131     if (suite == NULL) {
 132         suite = malloc(sizeof(*suite));
 133         suite->head = subsuite;
 134         suite->tail = subsuite;
 135     }
 136     else {
 137         suite->tail->next = subsuite;
 138         suite->tail = subsuite;
 139     }
 140
 141     if (!should_test_run(subsuite->name)) {
 142         subsuite->not_run = 1;
 143         return suite;
 144     }
 145
 146     reset_status();
 147     fprintf(stdout, "%-20s:  ", subsuite->name);
 148     update_status();
 149     fflush(stdout);
 150
 151     return suite;
 152 }
 153
 154 void abts_run_test(abts_suite *ts, test_func f, void *value)
 155 {
 156     abts_case *tc;
 157     sub_suite *ss;
 158
 159     if (!should_test_run(ts->tail->name)) {
 160         return;
 161     }
 162     ss = ts->tail;
 163
 164     tc = malloc(sizeof(*tc));
 165     tc->failed = 0;
 166     tc->suite = ss;
 167
 168     ss->num_test++;
 169     update_status();
 170
 171     f(tc, value);
 172
 173     if (tc->failed) {
 174         ss->failed++;
 175     }
 176     free(tc);
 177 }
 178
 179 static int report(abts_suite *suite)
 180 {
 181     int count = 0;
 182     sub_suite *dptr;
 183
 184     if (suite && suite->tail &&!suite->tail->not_run) {
 185         end_suite(suite);
 186     }
 187
 188     for (dptr = suite->head; dptr; dptr = dptr->next) {
 189         count += dptr->failed;
 190     }
 191
 192     if (list_tests) {
 193         return 0;
 194     }
 195
 196     if (count == 0) {
 197         printf("All tests passed.\n");
 198         return 0;
 199     }
 200
 201     dptr = suite->head;
 202     fprintf(stdout, "%-15s\t\tTotal\tFail\tFailed %%\n", "Failed Tests");
 203     fprintf(stdout, "===================================================\n");
 204     while (dptr != NULL) {
 205         if (dptr->failed != 0) {
 206             float percent = ((float)dptr->failed / (float)dptr->num_test);
 207             fprintf(stdout, "%-15s\t\t%5d\t%4d\t%6.2f%%\n", dptr->name,
 208                     dptr->num_test, dptr->failed, percent * 100);
 209         }
 210         dptr = dptr->next;
 211     }
 212     return 1;
 213 }
 214
 215 void abts_log_message(const char *fmt, ...)
 216 {
 217     va_list args;
 218     update_status();
 219
 220     if (verbose) {
 221         va_start(args, fmt);
 222         vfprintf(stderr, fmt, args);
 223         va_end(args);
 224         fprintf(stderr, "\n");
 225         fflush(stderr);
 226     }
 227 }
 228
 229 void abts_int_equal(abts_case *tc, const int expected, const int actual, int lineno)
 230 {
 231     update_status();
 232     if (tc->failed) return;
 233
 234     if (expected == actual) return;
 235
 236     tc->failed = TRUE;
 237     if (verbose) {
 238         fprintf(stderr, "Line %d: expected <%d>, but saw <%d>\n", lineno, expected, actual);
 239         fflush(stderr);
 240     }
 241 }
 242
 243 void abts_int_nequal(abts_case *tc, const int expected, const int actual, int lineno)
 244 {
 245     update_status();
 246     if (tc->failed) return;
 247
 248     if (expected != actual) return;
 249
 250     tc->failed = TRUE;
 251     if (verbose) {
 252         fprintf(stderr, "Line %d: expected <%d>, but saw <%d>\n", lineno, expected, actual);
 253         fflush(stderr);
 254     }
 255 }
 256
 257 void abts_str_equal(abts_case *tc, const char *expected, const char *actual, int lineno)
 258 {
 259     update_status();
 260     if (tc->failed) return;
 261
 262     /* If both are NULL, match is good */
 263     if (!expected && !actual) return;
 264     if (expected && actual)
 265         if (!strcmp(expected, actual)) return;
 266
 267     tc->failed = TRUE;
 268     if (verbose) {
 269         fprintf(stderr, "Line %d: expected <%s>, but saw <%s>\n", lineno, expected, actual);
 270         fflush(stderr);
 271     }
 272 }
 273
 274 void abts_str_nequal(abts_case *tc, const char *expected, const char *actual,
 275                        size_t n, int lineno)
 276 {
 277     update_status();
 278     if (tc->failed) return;
 279
 280     if (!strncmp(expected, actual, n)) return;
 281
 282     tc->failed = TRUE;
 283     if (verbose) {
 284         fprintf(stderr, "Line %d: expected <%s>, but saw <%s>\n", lineno, expected, actual);
 285         fflush(stderr);
 286     }
 287 }
 288
 289 void abts_ptr_notnull(abts_case *tc, const void *ptr, int lineno)
 290 {
 291     update_status();
 292     if (tc->failed) return;
 293
 294     if (ptr != NULL) return;
 295
 296     tc->failed = TRUE;
 297     if (verbose) {
 298         fprintf(stderr, "Line %d: Expected NULL, but saw <%p>\n", lineno, ptr);
 299         fflush(stderr);
 300     }
 301 }
 302
 303 void abts_ptr_equal(abts_case *tc, const void *expected, const void *actual, int lineno)
 304 {
 305     update_status();
 306     if (tc->failed) return;
 307
 308     if (expected == actual) return;
 309
 310     tc->failed = TRUE;
 311     if (verbose) {
 312         fprintf(stderr, "Line %d: expected <%p>, but saw <%p>\n", lineno, expected, actual);
 313         fflush(stderr);
 314     }
 315 }
 316
 317 void abts_fail(abts_case *tc, const char *message, int lineno)
 318 {
 319     update_status();
 320     if (tc->failed) return;
 321
 322     tc->failed = TRUE;
 323     if (verbose) {
 324         fprintf(stderr, "Line %d: %s\n", lineno, message);
 325         fflush(stderr);
 326     }
 327 }
 328
 329 void abts_assert(abts_case *tc, const char *message, int condition, int lineno)
 330 {
 331     update_status();
 332     if (tc->failed) return;
 333
 334     if (condition) return;
 335
 336     tc->failed = TRUE;
 337     if (verbose) {
 338         fprintf(stderr, "Line %d: %s\n", lineno, message);
 339         fflush(stderr);
 340     }
 341 }
 342
 343 void abts_true(abts_case *tc, int condition, int lineno)
 344 {
 345     update_status();
 346     if (tc->failed) return;
 347
 348     if (condition) return;
 349
 350     tc->failed = TRUE;
 351     if (verbose) {
 352         fprintf(stderr, "Line %d: Condition is false, but expected true\n", lineno);
 353         fflush(stderr);
 354     }
 355 }
 356
 357 void abts_not_impl(abts_case *tc, const char *message, int lineno)
 358 {
 359     update_status();
 360
 361     tc->suite->not_impl++;
 362     if (verbose) {
 363         fprintf(stderr, "Line %d: %s\n", lineno, message);
 364         fflush(stderr);
 365     }
 366 }
 367
 368 int main(int argc, const char *const argv[]) {
 369     int i;
 370     int rv;
 371     int list_provided = 0;
 372     abts_suite *suite = NULL;
 373
 374     initialize();
 375     for (i = 1; i < argc; i++) {
 376         if (!strcmp(argv[i], "-v")) {
 377             verbose = 1;
 378             continue;
 379         }
 380         if (!strcmp(argv[i], "-x")) {
 381             exclude = 1;
 382             continue;
 383         }
 384         if (!strcmp(argv[i], "-l")) {
 385             list_tests = 1;
 386             continue;
 387         }
 388         if (!strcmp(argv[i], "-q")) {
 389             quiet = 1;
 390             continue;
 391         }
 392         if (argv[i][0] == '-') {
 393             fprintf(stderr, "Invalid option: `%s'\n", argv[i]);
 394             exit(1);
 395         }
 396         list_provided = 1;
 397     }
 398
 399     if (list_provided) {
 400         /* Waste a little space here, because it is easier than counting the
 401          * number of tests listed.  Besides it is at most three char *.
 402          */
 403         testlist = calloc(argc + 1, sizeof(char *));
 404         for (i = 1; i < argc; i++) {
 405             testlist[i - 1] = argv[i];
 406         }
 407     }
 408
 409     for (i = 0; i < (sizeof(alltests) / sizeof(struct testlist *)); i++) {
 410         suite = alltests[i].func(suite);
 411     }
 412
 413     rv = report(suite);
 414     return rv;
 415 }
 416