src/test/tap.c

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