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 static void
 173 vdiag_to_fh (FILE *fh, const char *fmt, va_list args) {
 174     char *mesg, *line;
 175     int i;
 176     if (!fmt)
 177         return;
 178     mesg = vstrdupf(fmt, args);
 179     line = mesg;
 180     for (i = 0; *line; i++) {
 181         char c = mesg[i];
 182         if (!c || c == '\n') {
 183             mesg[i] = '\0';
 184             fprintf(fh, "# %s\n", line);
 185             if (!c)
 186                 break;
 187             mesg[i] = c;
 188             line = mesg + i + 1;
 189         }
 190     }
 191     free(mesg);
 192     return;
 193 }
 194
 195 int
 196 diag (const char *fmt, ...) {
 197     va_list args;
 198     va_start(args, fmt);
 199     vdiag_to_fh(stderr, fmt, args);
 200     va_end(args);
 201     return 0;
 202 }
 203
 204 int
 205 note (const char *fmt, ...) {
 206     va_list args;
 207     va_start(args, fmt);
 208     vdiag_to_fh(stdout, fmt, args);
 209     va_end(args);
 210     return 0;
 211 }
 212
 213 int
 214 exit_status () {
 215     int retval = 0;
 216     if (expected_tests == NO_PLAN) {
 217         printf("1..%d\n", current_test);
 218     }
 219     else if (current_test != expected_tests) {
 220         diag("Looks like you planned %d test%s but ran %d.",
 221             expected_tests, expected_tests > 1 ? "s" : "", current_test);
 222         retval = 255;
 223     }
 224     if (failed_tests) {
 225         diag("Looks like you failed %d test%s of %d run.",
 226             failed_tests, failed_tests > 1 ? "s" : "", current_test);
 227         if (expected_tests == NO_PLAN)
 228             retval = failed_tests;
 229         else
 230             retval = expected_tests - current_test + failed_tests;
 231     }
 232     return retval;
 233 }
 234
 235 int
 236 bail_out (int ignore, const char *fmt, ...) {
 237     va_list args;
 238     va_start(args, fmt);
 239     printf("Bail out!  ");
 240     vprintf(fmt, args);
 241     printf("\n");
 242     va_end(args);
 243     exit(255);
 244     return 0;
 245 }
 246
 247 void
 248 tap_skip (int n, const char *fmt, ...) {
 249     char *why;
 250     va_list args;
 251     va_start(args, fmt);
 252     why = vstrdupf(fmt, args);
 253     va_end(args);
 254     while (n --> 0) {
 255         printf("ok %d ", ++current_test);
 256         note("skip %s\n", why);
 257     }
 258     free(why);
 259 }
 260
 261 void
 262 tap_todo (int ignore, const char *fmt, ...) {
 263     va_list args;
 264     va_start(args, fmt);
 265     todo_mesg = vstrdupf(fmt, args);
 266     va_end(args);
 267 }
 268
 269 void
 270 tap_end_todo () {
 271     free(todo_mesg);
 272     todo_mesg = NULL;
 273 }
 274
 275 #ifndef _WIN32
 276 #include <sys/mman.h>
 277 #include <sys/param.h>
 278 #include <regex.h>
 279
 280 #if defined __APPLE__ || defined BSD
 281 #define MAP_ANONYMOUS MAP_ANON
 282 #endif
 283
 284 /* Create a shared memory int to keep track of whether a piece of code executed
 285 dies. to be used in the dies_ok and lives_ok macros.  */
 286 int
 287 tap_test_died (int status) {
 288     static int *test_died = NULL;
 289     int prev;
 290     if (!test_died) {
 291         test_died = mmap(0, sizeof (int), PROT_READ | PROT_WRITE,
 292                          MAP_SHARED | MAP_ANONYMOUS, -1, 0);
 293         *test_died = 0;
 294     }
 295     prev = *test_died;
 296     *test_died = status;
 297     return prev;
 298 }
 299
 300 int
 301 like_at_loc (int for_match, const char *file, int line, const char *got,
 302              const char *expected, const char *fmt, ...)
 303 {
 304     int test;
 305     regex_t re;
 306     va_list args;
 307     int err = regcomp(&re, expected, REG_EXTENDED);
 308     if (err) {
 309         char errbuf[256];
 310         regerror(err, &re, errbuf, sizeof errbuf);
 311         fprintf(stderr, "Unable to compile regex '%s': %s at %s line %d\n",
 312                         expected, errbuf, file, line);
 313         exit(255);
 314     }
 315     err = regexec(&re, got, 0, NULL, 0);
 316     regfree(&re);
 317     test = for_match ? !err : err;
 318     va_start(args, fmt);
 319     vok_at_loc(file, line, test, fmt, args);
 320     va_end(args);
 321     if (!test) {
 322         if (for_match) {
 323             diag("                   '%s'", got);
 324             diag("    doesn't match: '%s'", expected);
 325         }
 326         else {
 327             diag("                   '%s'", got);
 328             diag("          matches: '%s'", expected);
 329         }
 330     }
 331     return test;
 332 }
 333 #endif
 334