tests/utils/tap.c

   1 /*-
   2  * Copyright (c) 2004 Nik Clayton
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #define _GNU_SOURCE
  28 #include <ctype.h>
  29 #include <stdarg.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32
  33 #include "tap.h"
  34
  35 static int no_plan = 0;
  36 static int skip_all = 0;
  37 static int have_plan = 0;
  38 static unsigned int test_count = 0; /* Number of tests that have been run */
  39 static unsigned int e_tests = 0; /* Expected number of tests to run */
  40 static unsigned int failures = 0; /* Number of tests that failed */
  41 static char *todo_msg = NULL;
  42 static char *todo_msg_fixed = "libtap malloc issue";
  43 static int todo = 0;
  44 static int test_died = 0;
  45 static int tap_is_disabled = 0;
  46
  47 /* Encapsulate the pthread code in a conditional.  In the absence of
  48    libpthread the code does nothing */
  49 #ifdef HAVE_LIBPTHREAD
  50 #include <pthread.h>
  51 static pthread_mutex_t M = PTHREAD_MUTEX_INITIALIZER;
  52 # define LOCK pthread_mutex_lock(&M);
  53 # define UNLOCK pthread_mutex_unlock(&M);
  54 #else
  55 # define LOCK
  56 # define UNLOCK
  57 #endif
  58
  59 static void _expected_tests(unsigned int);
  60 static void _tap_init(void);
  61 static void _cleanup(void);
  62
  63 /*
  64  * Generate a test result.
  65  *
  66  * ok -- boolean, indicates whether or not the test passed.
  67  * test_name -- the name of the test, may be NULL
  68  * test_comment -- a comment to print afterwards, may be NULL
  69  */
  70 unsigned int
  71 _gen_result(int ok, const char *func, char *file, unsigned int line,
  72             char *test_name, ...)
  73 {
  74         va_list ap;
  75         char *local_test_name = NULL;
  76         char *c;
  77         int name_is_digits;
  78
  79         LOCK;
  80
  81         test_count++;
  82
  83         /* Start by taking the test name and performing any printf()
  84            expansions on it */
  85         if(test_name != NULL) {
  86                 va_start(ap, test_name);
  87                 if (vasprintf(&local_test_name, test_name, ap) == -1) {
  88                         local_test_name = NULL;
  89                 }
  90                 va_end(ap);
  91
  92                 /* Make sure the test name contains more than digits
  93                    and spaces.  Emit an error message and exit if it
  94                    does */
  95                 if(local_test_name) {
  96                         name_is_digits = 1;
  97                         for(c = local_test_name; *c != '\0'; c++) {
  98                                 if(!isdigit(*c) && !isspace(*c)) {
  99                                         name_is_digits = 0;
 100                                         break;
 101                                 }
 102                         }
 103
 104                         if(name_is_digits) {
 105                                 diag("    You named your test '%s'.  You shouldn't use numbers for your test names.", local_test_name);
 106                                 diag("    Very confusing.");
 107                         }
 108                 }
 109         }
 110
 111         if(!ok) {
 112                 printf("not ");
 113                 failures++;
 114         }
 115
 116         printf("ok %d", test_count);
 117
 118         if(test_name != NULL) {
 119                 printf(" - ");
 120
 121                 /* Print the test name, escaping any '#' characters it
 122                    might contain */
 123                 if(local_test_name != NULL) {
 124                         flockfile(stdout);
 125                         for(c = local_test_name; *c != '\0'; c++) {
 126                                 if(*c == '#')
 127                                         fputc('\\', stdout);
 128                                 fputc((int)*c, stdout);
 129                         }
 130                         funlockfile(stdout);
 131                 } else {        /* vasprintf() failed, use a fixed message */
 132                         printf("%s", todo_msg_fixed);
 133                 }
 134         }
 135
 136         /* If we're in a todo_start() block then flag the test as being
 137            TODO.  todo_msg should contain the message to print at this
 138            point.  If it's NULL then asprintf() failed, and we should
 139            use the fixed message.
 140
 141            This is not counted as a failure, so decrement the counter if
 142            the test failed. */
 143         if(todo) {
 144                 printf(" # TODO %s", todo_msg ? todo_msg : todo_msg_fixed);
 145                 if(!ok)
 146                         failures--;
 147         }
 148
 149         printf("\n");
 150
 151         if(!ok) {
 152                 if(getenv("HARNESS_ACTIVE") != NULL)
 153                         fputs("\n", stderr);
 154
 155                 diag("    Failed %stest (%s:%s() at line %d)",
 156                      todo ? "(TODO) " : "", file, func, line);
 157         }
 158         free(local_test_name);
 159
 160         UNLOCK;
 161
 162         /* We only care (when testing) that ok is positive, but here we
 163            specifically only want to return 1 or 0 */
 164         return ok ? 1 : 0;
 165 }
 166
 167 /*
 168  * Initialise the TAP library.  Will only do so once, however many times it's
 169  * called.
 170  */
 171 void
 172 _tap_init(void)
 173 {
 174         static int run_once = 0;
 175
 176         if(!run_once) {
 177                 atexit(_cleanup);
 178
 179                 /* stdout needs to be unbuffered so that the output appears
 180                    in the same place relative to stderr output as it does
 181                    with Test::Harness */
 182                 setbuf(stdout, 0);
 183                 run_once = 1;
 184         }
 185 }
 186
 187 /*
 188  * Note that there's no plan.
 189  */
 190 int
 191 plan_no_plan(void)
 192 {
 193
 194         LOCK;
 195
 196         _tap_init();
 197
 198         if(have_plan != 0) {
 199                 fprintf(stderr, "You tried to plan twice!\n");
 200                 test_died = 1;
 201                 UNLOCK;
 202                 exit(255);
 203         }
 204
 205         have_plan = 1;
 206         no_plan = 1;
 207
 208         UNLOCK;
 209
 210         return 1;
 211 }
 212
 213 /*
 214  * Note that the plan is to skip all tests
 215  */
 216 int
 217 plan_skip_all(char *reason)
 218 {
 219
 220         LOCK;
 221
 222         _tap_init();
 223
 224         skip_all = 1;
 225
 226         printf("1..0");
 227
 228         if(reason != NULL)
 229                 printf(" # Skip %s", reason);
 230
 231         printf("\n");
 232
 233         UNLOCK;
 234
 235         exit(0);
 236 }
 237
 238 /*
 239  * Note the number of tests that will be run.
 240  */
 241 int
 242 plan_tests(unsigned int tests)
 243 {
 244
 245         LOCK;
 246
 247         _tap_init();
 248
 249         if(have_plan != 0) {
 250                 fprintf(stderr, "You tried to plan twice!\n");
 251                 test_died = 1;
 252                 UNLOCK;
 253                 exit(255);
 254         }
 255
 256         if(tests == 0) {
 257                 fprintf(stderr, "You said to run 0 tests!  You've got to run something.\n");
 258                 test_died = 1;
 259                 UNLOCK;
 260                 exit(255);
 261         }
 262
 263         have_plan = 1;
 264
 265         _expected_tests(tests);
 266
 267         UNLOCK;
 268
 269         return e_tests;
 270 }
 271
 272 unsigned int
 273 diag(char *fmt, ...)
 274 {
 275         va_list ap;
 276
 277         fputs("# ", stderr);
 278
 279         va_start(ap, fmt);
 280         vfprintf(stderr, fmt, ap);
 281         va_end(ap);
 282
 283         fputs("\n", stderr);
 284
 285         return 0;
 286 }
 287
 288 unsigned int
 289 rdiag_start(void)
 290 {
 291         fputs("# ", stderr);
 292         return 0;
 293 }
 294
 295 unsigned int
 296 rdiag(char *fmt, ...)
 297 {
 298         va_list ap;
 299
 300         va_start(ap, fmt);
 301         vfprintf(stderr, fmt, ap);
 302         va_end(ap);
 303
 304         return 0;
 305 }
 306
 307 unsigned int
 308 rdiag_end(void)
 309 {
 310         fputs("\n", stderr);
 311         return 0;
 312 }
 313
 314 void
 315 _expected_tests(unsigned int tests)
 316 {
 317
 318         printf("1..%d\n", tests);
 319         e_tests = tests;
 320 }
 321
 322 int
 323 skip(unsigned int n, char *fmt, ...)
 324 {
 325         va_list ap;
 326         char *skip_msg = NULL;
 327
 328         LOCK;
 329
 330         va_start(ap, fmt);
 331         if (asprintf(&skip_msg, fmt, ap) == -1) {
 332                 skip_msg = NULL;
 333         }
 334         va_end(ap);
 335
 336         while(n-- > 0) {
 337                 test_count++;
 338                 printf("ok %d # skip %s\n", test_count,
 339                        skip_msg != NULL ?
 340                        skip_msg : "libtap():malloc() failed");
 341         }
 342
 343         free(skip_msg);
 344
 345         UNLOCK;
 346
 347         return 1;
 348 }
 349
 350 void
 351 todo_start(char *fmt, ...)
 352 {
 353         va_list ap;
 354
 355         LOCK;
 356
 357         va_start(ap, fmt);
 358         if (vasprintf(&todo_msg, fmt, ap) == -1) {
 359                 todo_msg = NULL;
 360         }
 361         va_end(ap);
 362
 363         todo = 1;
 364
 365         UNLOCK;
 366 }
 367
 368 void
 369 todo_end(void)
 370 {
 371
 372         LOCK;
 373
 374         todo = 0;
 375         free(todo_msg);
 376
 377         UNLOCK;
 378 }
 379
 380 int
 381 exit_status(void)
 382 {
 383         int r;
 384
 385         LOCK;
 386
 387         /* If there's no plan, just return the number of failures */
 388         if(no_plan || !have_plan) {
 389                 UNLOCK;
 390                 return failures;
 391         }
 392
 393         /* Ran too many tests?  Return the number of tests that were run
 394            that shouldn't have been */
 395         if(e_tests < test_count) {
 396                 r = test_count - e_tests;
 397                 UNLOCK;
 398                 return r;
 399         }
 400
 401         /* Return the number of tests that failed + the number of tests
 402            that weren't run */
 403         r = failures + e_tests - test_count;
 404         UNLOCK;
 405
 406         return r;
 407 }
 408
 409 /*
 410  * Cleanup at the end of the run, produce any final output that might be
 411  * required.
 412  */
 413 void
 414 _cleanup(void)
 415 {
 416
 417         LOCK;
 418
 419         if (tap_is_disabled) {
 420                 UNLOCK;
 421                 return;
 422         }
 423
 424         /* If plan_no_plan() wasn't called, and we don't have a plan,
 425            and we're not skipping everything, then something happened
 426            before we could produce any output */
 427         if(!no_plan && !have_plan && !skip_all) {
 428                 diag("Looks like your test died before it could output anything.");
 429                 UNLOCK;
 430                 return;
 431         }
 432
 433         if(test_died) {
 434                 diag("Looks like your test died just after %d.", test_count);
 435                 UNLOCK;
 436                 return;
 437         }
 438
 439
 440         /* No plan provided, but now we know how many tests were run, and can
 441            print the header at the end */
 442         if(!skip_all && (no_plan || !have_plan)) {
 443                 printf("1..%d\n", test_count);
 444         }
 445
 446         if((have_plan && !no_plan) && e_tests < test_count) {
 447                 diag("Looks like you planned %d %s but ran %d extra.",
 448                      e_tests, e_tests == 1 ? "test" : "tests", test_count - e_tests);
 449                 UNLOCK;
 450                 return;
 451         }
 452
 453         if((have_plan || !no_plan) && e_tests > test_count) {
 454                 diag("Looks like you planned %d %s but only ran %d.",
 455                      e_tests, e_tests == 1 ? "test" : "tests", test_count);
 456                 UNLOCK;
 457                 return;
 458         }
 459
 460         if(failures)
 461                 diag("Looks like you failed %d %s of %d.",
 462                      failures, failures == 1 ? "test" : "tests", test_count);
 463
 464         UNLOCK;
 465 }
 466
 467 /* Disable tap for this process. */
 468 void
 469 tap_disable(void)
 470 {
 471         LOCK;
 472         tap_is_disabled = 1;
 473         UNLOCK;
 474 }