begriffs open source - libtap/blob - tap.c

   1 /*
   2 libtap - Write tests in C
   3 Copyright 2012 Jake Gelbman <gelbman@gmail.com>
   4 This file is licensed under the GPLv2 or any later version
   5 */
   6
   7 #define _BSD_SOURCE 1
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <stdarg.h>
  12 #include <string.h>
  13 #include "tap.h"
  14
  15 static int expected_tests = NO_PLAN;
  16 static int failed_tests;
  17 static int current_test;
  18 static char *todo_mesg;
  19
  20 static char *
  21 vstrdupf (const char *fmt, va_list args) {
  22     char *str;
  23     int size;
  24     va_list args2;
  25     va_copy(args2, args);
  26     if (!fmt)
  27         fmt = "";
  28     size = vsnprintf(NULL, 0, fmt, args2) + 2;
  29     str = malloc(size);
  30     if (!str) {
  31         perror("malloc error");
  32         exit(1);
  33     }
  34     vsprintf(str, fmt, args);
  35     va_end(args2);
  36     return str;
  37 }
  38
  39 void
  40 tap_plan (int tests, const char *fmt, ...) {
  41     expected_tests = tests;
  42     if (tests == SKIP_ALL) {
  43         char *why;
  44         va_list args;
  45         va_start(args, fmt);
  46         why = vstrdupf(fmt, args);
  47         va_end(args);
  48         printf("1..0 ");
  49         note("SKIP %s\n", why);
  50         exit(0);
  51     }
  52     if (tests != NO_PLAN) {
  53         printf("1..%d\n", tests);
  54     }
  55 }
  56
  57 int
  58 vok_at_loc (const char *file, int line, int test, const char *fmt,
  59             va_list args)
  60 {
  61     char *name = vstrdupf(fmt, args);
  62     if (!test)
  63         printf("not ");
  64     printf("ok %d", ++current_test);
  65     if (*name)
  66         printf(" - %s", name);
  67     if (todo_mesg) {
  68         printf(" # TODO");
  69         if (*todo_mesg)
  70             printf(" %s", todo_mesg);
  71     }
  72     printf("\n");
  73     if (!test) {
  74         fprintf(stderr, "#   Failed ");
  75         if (todo_mesg)
  76             fprintf(stderr, "(TODO) ");
  77         fprintf(stderr, "test ");
  78         if (*name)
  79             fprintf(stderr, "'%s'\n#   ", name);
  80         fprintf(stderr, "at %s line %d.\n", file, line);
  81         if (!todo_mesg)
  82             failed_tests++;
  83     }
  84     free(name);
  85     return test;
  86 }
  87
  88 int
  89 ok_at_loc (const char *file, int line, int test, const char *fmt, ...) {
  90     va_list args;
  91     va_start(args, fmt);
  92     vok_at_loc(file, line, test, fmt, args);
  93     va_end(args);
  94     return test;
  95 }
  96
  97 static int
  98 mystrcmp (const char *a, const char *b) {
  99     return a == b ? 0 : !a ? -1 : !b ? 1 : strcmp(a, b);
 100 }
 101
 102 #define eq(a, b) (!mystrcmp(a, b))
 103 #define ne(a, b) (mystrcmp(a, b))
 104
 105 int
 106 is_at_loc (const char *file, int line, const char *got, const char *expected,
 107            const char *fmt, ...)
 108 {
 109     int test = eq(got, expected);
 110     va_list args;
 111     va_start(args, fmt);
 112     vok_at_loc(file, line, test, fmt, args);
 113     va_end(args);
 114     if (!test) {
 115         diag("         got: '%s'", got);
 116         diag("    expected: '%s'", expected);
 117     }
 118     return test;
 119 }
 120
 121 int
 122 isnt_at_loc (const char *file, int line, const char *got, const char *expected,
 123              const char *fmt, ...)
 124 {
 125     int test = ne(got, expected);
 126     va_list args;
 127     va_start(args, fmt);
 128     vok_at_loc(file, line, test, fmt, args);
 129     va_end(args);
 130     if (!test) {
 131         diag("         got: '%s'", got);
 132         diag("    expected: anything else");
 133     }
 134     return test;
 135 }
 136
 137 int
 138 cmp_ok_at_loc (const char *file, int line, int a, const char *op, int b,
 139                const char *fmt, ...)
 140 {
 141     int test = eq(op, "||") ? a || b
 142              : eq(op, "&&") ? a && b
 143              : eq(op, "|")  ? a |  b
 144              : eq(op, "^")  ? a ^  b
 145              : eq(op, "&")  ? a &  b
 146              : eq(op, "==") ? a == b
 147              : eq(op, "!=") ? a != b
 148              : eq(op, "<")  ? a <  b
 149              : eq(op, ">")  ? a >  b
 150              : eq(op, "<=") ? a <= b
 151              : eq(op, ">=") ? a >= b
 152              : eq(op, "<<") ? a << b
 153              : eq(op, ">>") ? a >> b
 154              : eq(op, "+")  ? a +  b
 155              : eq(op, "-")  ? a -  b
 156              : eq(op, "*")  ? a *  b
 157              : eq(op, "/")  ? a /  b
 158              : eq(op, "%")  ? a %  b
 159              : diag("unrecognized operator '%s'", op);
 160     va_list args;
 161     va_start(args, fmt);
 162     vok_at_loc(file, line, test, fmt, args);
 163     va_end(args);
 164     if (!test) {
 165         diag("    %d", a);
 166         diag("        %s", op);
 167         diag("    %d", b);
 168     }
 169     return test;
 170 }
 171
 172 int
 173 cmp_mem_at_loc (const char *file, int line, const void *got,
 174                 const void *expected, size_t n, const char *fmt, ...)
 175 {
 176     int test = !memcmp(got, expected, n);
 177     va_list args;
 178     va_start(args, fmt);
 179     vok_at_loc(file, line, test, fmt, args);
 180     va_end(args);
 181     if (!test) {
 182         const unsigned char *a = got;
 183         const unsigned char *b = expected;
 184         int i = 0;
 185
 186         while (*(a++) == *(b++))
 187             ++i;
 188
 189         /* a and b point to 1 position after first different value */
 190         diag("    Difference starts at offset %d", i);
 191         diag("         got: '0x%x'", *(--a));
 192         diag("    expected: '0x%x'", *(--b));
 193     }
 194     return test;
 195 }
 196
 197 static void
 198 vdiag_to_fh (FILE *fh, const char *fmt, va_list args) {
 199     char *mesg, *line;
 200     int i;
 201     if (!fmt)
 202         return;
 203     mesg = vstrdupf(fmt, args);
 204     line = mesg;
 205     for (i = 0; *line; i++) {
 206         char c = mesg[i];
 207         if (!c || c == '\n') {
 208             mesg[i] = '\0';
 209             fprintf(fh, "# %s\n", line);
 210             if (!c)
 211                 break;
 212             mesg[i] = c;
 213             line = mesg + i + 1;
 214         }
 215     }
 216     free(mesg);
 217     return;
 218 }
 219
 220 int
 221 diag (const char *fmt, ...) {
 222     va_list args;
 223     va_start(args, fmt);
 224     vdiag_to_fh(stderr, fmt, args);
 225     va_end(args);
 226     return 0;
 227 }
 228
 229 int
 230 note (const char *fmt, ...) {
 231     va_list args;
 232     va_start(args, fmt);
 233     vdiag_to_fh(stdout, fmt, args);
 234     va_end(args);
 235     return 0;
 236 }
 237
 238 int
 239 exit_status () {
 240     int retval = 0;
 241     if (expected_tests == NO_PLAN) {
 242         printf("1..%d\n", current_test);
 243     }
 244     else if (current_test != expected_tests) {
 245         diag("Looks like you planned %d test%s but ran %d.",
 246             expected_tests, expected_tests > 1 ? "s" : "", current_test);
 247         retval = 255;
 248     }
 249     if (failed_tests) {
 250         diag("Looks like you failed %d test%s of %d run.",
 251             failed_tests, failed_tests > 1 ? "s" : "", current_test);
 252         if (expected_tests == NO_PLAN)
 253             retval = failed_tests;
 254         else
 255             retval = expected_tests - current_test + failed_tests;
 256     }
 257     return retval;
 258 }
 259
 260 int
 261 bail_out (int ignore, const char *fmt, ...) {
 262     va_list args;
 263     va_start(args, fmt);
 264     printf("Bail out!  ");
 265     vprintf(fmt, args);
 266     printf("\n");
 267     va_end(args);
 268     exit(255);
 269     return 0;
 270 }
 271
 272 void
 273 tap_skip (int n, const char *fmt, ...) {
 274     char *why;
 275     va_list args;
 276     va_start(args, fmt);
 277     why = vstrdupf(fmt, args);
 278     va_end(args);
 279     while (n --> 0) {
 280         printf("ok %d ", ++current_test);
 281         note("skip %s\n", why);
 282     }
 283     free(why);
 284 }
 285
 286 void
 287 tap_todo (int ignore, const char *fmt, ...) {
 288     va_list args;
 289     va_start(args, fmt);
 290     todo_mesg = vstrdupf(fmt, args);
 291     va_end(args);
 292 }
 293
 294 void
 295 tap_end_todo () {
 296     free(todo_mesg);
 297     todo_mesg = NULL;
 298 }
 299
 300 #ifndef _WIN32
 301 #include <sys/mman.h>
 302 #include <sys/param.h>
 303 #include <regex.h>
 304
 305 #if defined __APPLE__ || defined BSD
 306 #define MAP_ANONYMOUS MAP_ANON
 307 #endif
 308
 309 /* Create a shared memory int to keep track of whether a piece of code executed
 310 dies. to be used in the dies_ok and lives_ok macros.  */
 311 int
 312 tap_test_died (int status) {
 313     static int *test_died = NULL;
 314     int prev;
 315     if (!test_died) {
 316         test_died = mmap(0, sizeof (int), PROT_READ | PROT_WRITE,
 317                          MAP_SHARED | MAP_ANONYMOUS, -1, 0);
 318         *test_died = 0;
 319     }
 320     prev = *test_died;
 321     *test_died = status;
 322     return prev;
 323 }
 324
 325 int
 326 like_at_loc (int for_match, const char *file, int line, const char *got,
 327              const char *expected, const char *fmt, ...)
 328 {
 329     int test;
 330     regex_t re;
 331     va_list args;
 332     int err = regcomp(&re, expected, REG_EXTENDED);
 333     if (err) {
 334         char errbuf[256];
 335         regerror(err, &re, errbuf, sizeof errbuf);
 336         fprintf(stderr, "Unable to compile regex '%s': %s at %s line %d\n",
 337                         expected, errbuf, file, line);
 338         exit(255);
 339     }
 340     err = regexec(&re, got, 0, NULL, 0);
 341     regfree(&re);
 342     test = for_match ? !err : err;
 343     va_start(args, fmt);
 344     vok_at_loc(file, line, test, fmt, args);
 345     va_end(args);
 346     if (!test) {
 347         if (for_match) {
 348             diag("                   '%s'", got);
 349             diag("    doesn't match: '%s'", expected);
 350         }
 351         else {
 352             diag("                   '%s'", got);
 353             diag("          matches: '%s'", expected);
 354         }
 355     }
 356     return test;
 357 }
 358 #endif
 359