tests/runtests.c

   1 /*
   2  * Run a set of tests, reporting results.
   3  *
   4  * Usage:
   5  *
   6  *      runtests [-b <build-dir>] [-s <source-dir>] <test-list>
   7  *      runtests -o [-b <build-dir>] [-s <source-dir>] <test>
   8  *
   9  * In the first case, expects a list of executables located in the given file,
  10  * one line per executable.  For each one, runs it as part of a test suite,
  11  * reporting results.  Test output should start with a line containing the
  12  * number of tests (numbered from 1 to this number), optionally preceded by
  13  * "1..", although that line may be given anywhere in the output.  Each
  14  * additional line should be in the following format:
  15  *
  16  *      ok <number>
  17  *      not ok <number>
  18  *      ok <number> # skip
  19  *      not ok <number> # todo
  20  *
  21  * where <number> is the number of the test.  An optional comment is permitted
  22  * after the number if preceded by whitespace.  ok indicates success, not ok
  23  * indicates failure.  "# skip" and "# todo" are a special cases of a comment,
  24  * and must start with exactly that formatting.  They indicate the test was
  25  * skipped for some reason (maybe because it doesn't apply to this platform)
  26  * or is testing something known to currently fail.  The text following either
  27  * "# skip" or "# todo" and whitespace is the reason.
  28  *
  29  * As a special case, the first line of the output may be in the form:
  30  *
  31  *      1..0 # skip some reason
  32  *
  33  * which indicates that this entire test case should be skipped and gives a
  34  * reason.
  35  *
  36  * Any other lines are ignored, although for compliance with the TAP protocol
  37  * all lines other than the ones in the above format should be sent to
  38  * standard error rather than standard output and start with #.
  39  *
  40  * This is a subset of TAP as documented in Test::Harness::TAP or
  41  * TAP::Parser::Grammar, which comes with Perl.
  42  *
  43  * If the -o option is given, instead run a single test and display all of its
  44  * output.  This is intended for use with failing tests so that the person
  45  * running the test suite can get more details about what failed.
  46  *
  47  * If built with the C preprocessor symbols SOURCE and BUILD defined, C TAP
  48  * Harness will export those values in the environment so that tests can find
  49  * the source and build directory and will look for tests under both
  50  * directories.  These paths can also be set with the -b and -s command-line
  51  * options, which will override anything set at build time.
  52  *
  53  * Any bug reports, bug fixes, and improvements are very much welcome and
  54  * should be sent to the e-mail address below.  This program is part of C TAP
  55  * Harness <http://www.eyrie.org/~eagle/software/c-tap-harness/>.
  56  *
  57  * Copyright 2000, 2001, 2004, 2006, 2007, 2008, 2009, 2010, 2011
  58  *     Russ Allbery <rra@stanford.edu>
  59  *
  60  * Permission is hereby granted, free of charge, to any person obtaining a
  61  * copy of this software and associated documentation files (the "Software"),
  62  * to deal in the Software without restriction, including without limitation
  63  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  64  * and/or sell copies of the Software, and to permit persons to whom the
  65  * Software is furnished to do so, subject to the following conditions:
  66  *
  67  * The above copyright notice and this permission notice shall be included in
  68  * all copies or substantial portions of the Software.
  69  *
  70  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  71  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  72  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  73  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  74  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  75  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  76  * DEALINGS IN THE SOFTWARE.
  77 */
  78
  79 /* Required for fdopen(), getopt(), and putenv(). */
  80 #ifndef _XOPEN_SOURCE
  81 # define _XOPEN_SOURCE 500
  82 #endif
  83
  84 #include <ctype.h>
  85 #include <errno.h>
  86 #include <fcntl.h>
  87 #include <stdarg.h>
  88 #include <stdio.h>
  89 #include <stdlib.h>
  90 #include <string.h>
  91 #include <strings.h>
  92 #include <sys/stat.h>
  93 #include <sys/time.h>
  94 #include <sys/types.h>
  95 #include <sys/wait.h>
  96 #include <time.h>
  97 #include <unistd.h>
  98
  99 /* sys/time.h must be included before sys/resource.h on some platforms. */
 100 #include <sys/resource.h>
 101
 102 /* AIX doesn't have WCOREDUMP. */
 103 #ifndef WCOREDUMP
 104 # define WCOREDUMP(status)      ((unsigned)(status) & 0x80)
 105 #endif
 106
 107 /*
 108  * The source and build versions of the tests directory.  This is used to set
 109  * the SOURCE and BUILD environment variables and find test programs, if set.
 110  * Normally, this should be set as part of the build process to the test
 111  * subdirectories of $(abs_top_srcdir) and $(abs_top_builddir) respectively.
 112  */
 113 #ifndef SOURCE
 114 # define SOURCE NULL
 115 #endif
 116 #ifndef BUILD
 117 # define BUILD NULL
 118 #endif
 119
 120 /* Test status codes. */
 121 enum test_status {
 122     TEST_FAIL,
 123     TEST_PASS,
 124     TEST_SKIP,
 125     TEST_INVALID
 126 };
 127
 128 /* Indicates the state of our plan. */
 129 enum plan_status {
 130     PLAN_INIT,                  /* Nothing seen yet. */
 131     PLAN_FIRST,                 /* Plan seen before any tests. */
 132     PLAN_PENDING,               /* Test seen and no plan yet. */
 133     PLAN_FINAL                  /* Plan seen after some tests. */
 134 };
 135
 136 /* Error exit statuses for test processes. */
 137 #define CHILDERR_DUP    100     /* Couldn't redirect stderr or stdout. */
 138 #define CHILDERR_EXEC   101     /* Couldn't exec child process. */
 139 #define CHILDERR_STDERR 102     /* Couldn't open stderr file. */
 140
 141 /* Structure to hold data for a set of tests. */
 142 struct testset {
 143     char *file;                 /* The file name of the test. */
 144     char *path;                 /* The path to the test program. */
 145     enum plan_status plan;      /* The status of our plan. */
 146     unsigned long count;        /* Expected count of tests. */
 147     unsigned long current;      /* The last seen test number. */
 148     unsigned int length;        /* The length of the last status message. */
 149     unsigned long passed;       /* Count of passing tests. */
 150     unsigned long failed;       /* Count of failing lists. */
 151     unsigned long skipped;      /* Count of skipped tests (passed). */
 152     unsigned long allocated;    /* The size of the results table. */
 153     enum test_status *results;  /* Table of results by test number. */
 154     unsigned int aborted;       /* Whether the set as aborted. */
 155     int reported;               /* Whether the results were reported. */
 156     int status;                 /* The exit status of the test. */
 157     unsigned int all_skipped;   /* Whether all tests were skipped. */
 158     char *reason;               /* Why all tests were skipped. */
 159 };
 160
 161 /* Structure to hold a linked list of test sets. */
 162 struct testlist {
 163     struct testset *ts;
 164     struct testlist *next;
 165 };
 166
 167 /*
 168  * Usage message.  Should be used as a printf format with two arguments: the
 169  * path to runtests, given twice.
 170  */
 171 static const char usage_message[] = "\
 172 Usage: %s [-b <build-dir>] [-s <source-dir>] <test-list>\n\
 173        %s -o [-b <build-dir>] [-s <source-dir>] <test>\n\
 174 \n\
 175 Options:\n\
 176     -b <build-dir>      Set the build directory to <build-dir>\n\
 177     -o                  Run a single test rather than a list of tests\n\
 178     -s <source-dir>     Set the source directory to <source-dir>\n\
 179 \n\
 180 runtests normally runs each test listed in a file whose path is given as\n\
 181 its command-line argument.  With the -o option, it instead runs a single\n\
 182 test and shows its complete output.\n";
 183
 184 /*
 185  * Header used for test output.  %s is replaced by the file name of the list
 186  * of tests.
 187  */
 188 static const char banner[] = "\n\
 189 Running all tests listed in %s.  If any tests fail, run the failing\n\
 190 test program with runtests -o to see more details.\n\n";
 191
 192 /* Header for reports of failed tests. */
 193 static const char header[] = "\n\
 194 Failed Set                 Fail/Total (%) Skip Stat  Failing Tests\n\
 195 -------------------------- -------------- ---- ----  ------------------------";
 196
 197 /* Include the file name and line number in malloc failures. */
 198 #define xmalloc(size)     x_malloc((size), __FILE__, __LINE__)
 199 #define xrealloc(p, size) x_realloc((p), (size), __FILE__, __LINE__)
 200 #define xstrdup(p)        x_strdup((p), __FILE__, __LINE__)
 201
 202
 203 /*
 204  * Report a fatal error, including the results of strerror, and exit.
 205  */
 206 static void
 207 sysdie(const char *format, ...)
 208 {
 209     int oerrno;
 210     va_list args;
 211
 212     oerrno = errno;
 213     fflush(stdout);
 214     fprintf(stderr, "runtests: ");
 215     va_start(args, format);
 216     vfprintf(stderr, format, args);
 217     va_end(args);
 218     fprintf(stderr, ": %s\n", strerror(oerrno));
 219     exit(1);
 220 }
 221
 222
 223 /*
 224  * Allocate memory, reporting a fatal error and exiting on failure.
 225  */
 226 static void *
 227 x_malloc(size_t size, const char *file, int line)
 228 {
 229     void *p;
 230
 231     p = malloc(size);
 232     if (p == NULL)
 233         sysdie("failed to malloc %lu bytes at %s line %d",
 234                (unsigned long) size, file, line);
 235     return p;
 236 }
 237
 238
 239 /*
 240  * Reallocate memory, reporting a fatal error and exiting on failure.
 241  */
 242 static void *
 243 x_realloc(void *p, size_t size, const char *file, int line)
 244 {
 245     p = realloc(p, size);
 246     if (p == NULL)
 247         sysdie("failed to realloc %lu bytes at %s line %d",
 248                (unsigned long) size, file, line);
 249     return p;
 250 }
 251
 252
 253 /*
 254  * Copy a string, reporting a fatal error and exiting on failure.
 255  */
 256 static char *
 257 x_strdup(const char *s, const char *file, int line)
 258 {
 259     char *p;
 260     size_t len;
 261
 262     len = strlen(s) + 1;
 263     p = malloc(len);
 264     if (p == NULL)
 265         sysdie("failed to strdup %lu bytes at %s line %d",
 266                (unsigned long) len, file, line);
 267     memcpy(p, s, len);
 268     return p;
 269 }
 270
 271
 272 /*
 273  * Given a struct timeval, return the number of seconds it represents as a
 274  * double.  Use difftime() to convert a time_t to a double.
 275  */
 276 static double
 277 tv_seconds(const struct timeval *tv)
 278 {
 279     return difftime(tv->tv_sec, 0) + tv->tv_usec * 1e-6;
 280 }
 281
 282
 283 /*
 284  * Given two struct timevals, return the difference in seconds.
 285  */
 286 static double
 287 tv_diff(const struct timeval *tv1, const struct timeval *tv0)
 288 {
 289     return tv_seconds(tv1) - tv_seconds(tv0);
 290 }
 291
 292
 293 /*
 294  * Given two struct timevals, return the sum in seconds as a double.
 295  */
 296 static double
 297 tv_sum(const struct timeval *tv1, const struct timeval *tv2)
 298 {
 299     return tv_seconds(tv1) + tv_seconds(tv2);
 300 }
 301
 302
 303 /*
 304  * Given a pointer to a string, skip any leading whitespace and return a
 305  * pointer to the first non-whitespace character.
 306  */
 307 static const char *
 308 skip_whitespace(const char *p)
 309 {
 310     while (isspace((unsigned char)(*p)))
 311         p++;
 312     return p;
 313 }
 314
 315
 316 /*
 317  * Start a program, connecting its stdout to a pipe on our end and its stderr
 318  * to /dev/null, and storing the file descriptor to read from in the two
 319  * argument.  Returns the PID of the new process.  Errors are fatal.
 320  */
 321 static pid_t
 322 test_start(const char *path, int *fd)
 323 {
 324     int fds[2], errfd;
 325     pid_t child;
 326
 327     if (pipe(fds) == -1) {
 328         puts("ABORTED");
 329         fflush(stdout);
 330         sysdie("can't create pipe");
 331     }
 332     child = fork();
 333     if (child == (pid_t) -1) {
 334         puts("ABORTED");
 335         fflush(stdout);
 336         sysdie("can't fork");
 337     } else if (child == 0) {
 338         /* In child.  Set up our stdout and stderr. */
 339         errfd = open("/dev/null", O_WRONLY);
 340         if (errfd < 0)
 341             _exit(CHILDERR_STDERR);
 342         if (dup2(errfd, 2) == -1)
 343             _exit(CHILDERR_DUP);
 344         close(fds[0]);
 345         if (dup2(fds[1], 1) == -1)
 346             _exit(CHILDERR_DUP);
 347
 348         /* Now, exec our process. */
 349         if (execl(path, path, (char *) 0) == -1)
 350             _exit(CHILDERR_EXEC);
 351     } else {
 352         /* In parent.  Close the extra file descriptor. */
 353         close(fds[1]);
 354     }
 355     *fd = fds[0];
 356     return child;
 357 }
 358
 359
 360 /*
 361  * Back up over the output saying what test we were executing.
 362  */
 363 static void
 364 test_backspace(struct testset *ts)
 365 {
 366     unsigned int i;
 367
 368     if (!isatty(STDOUT_FILENO))
 369         return;
 370     for (i = 0; i < ts->length; i++)
 371         putchar('\b');
 372     for (i = 0; i < ts->length; i++)
 373         putchar(' ');
 374     for (i = 0; i < ts->length; i++)
 375         putchar('\b');
 376     ts->length = 0;
 377 }
 378
 379
 380 /*
 381  * Read the plan line of test output, which should contain the range of test
 382  * numbers.  We may initialize the testset structure here if we haven't yet
 383  * seen a test.  Return true if initialization succeeded and the test should
 384  * continue, false otherwise.
 385  */
 386 static int
 387 test_plan(const char *line, struct testset *ts)
 388 {
 389     unsigned long i;
 390     long n;
 391
 392     /*
 393      * Accept a plan without the leading 1.. for compatibility with older
 394      * versions of runtests.  This will only be allowed if we've not yet seen
 395      * a test result.
 396      */
 397     line = skip_whitespace(line);
 398     if (strncmp(line, "1..", 3) == 0)
 399         line += 3;
 400
 401     /*
 402      * Get the count, check it for validity, and initialize the struct.  If we
 403      * have something of the form "1..0 # skip foo", the whole file was
 404      * skipped; record that.  If we do skip the whole file, zero out all of
 405      * our statistics, since they're no longer relevant.  strtol is called
 406      * with a second argument to advance the line pointer past the count to
 407      * make it simpler to detect the # skip case.
 408      */
 409     n = strtol(line, (char **) &line, 10);
 410     if (n == 0) {
 411         line = skip_whitespace(line);
 412         if (*line == '#') {
 413             line = skip_whitespace(line + 1);
 414             if (strncasecmp(line, "skip", 4) == 0) {
 415                 line = skip_whitespace(line + 4);
 416                 if (*line != '\0') {
 417                     ts->reason = xstrdup(line);
 418                     ts->reason[strlen(ts->reason) - 1] = '\0';
 419                 }
 420                 ts->all_skipped = 1;
 421                 ts->aborted = 1;
 422                 ts->count = 0;
 423                 ts->passed = 0;
 424                 ts->skipped = 0;
 425                 ts->failed = 0;
 426                 return 0;
 427             }
 428         }
 429     }
 430     if (n <= 0) {
 431         puts("ABORTED (invalid test count)");
 432         ts->aborted = 1;
 433         ts->reported = 1;
 434         return 0;
 435     }
 436     if (ts->plan == PLAN_INIT && ts->allocated == 0) {
 437         ts->count = n;
 438         ts->allocated = n;
 439         ts->plan = PLAN_FIRST;
 440         ts->results = xmalloc(ts->count * sizeof(enum test_status));
 441         for (i = 0; i < ts->count; i++)
 442             ts->results[i] = TEST_INVALID;
 443     } else if (ts->plan == PLAN_PENDING) {
 444         if ((unsigned long) n < ts->count) {
 445             printf("ABORTED (invalid test number %lu)\n", ts->count);
 446             ts->aborted = 1;
 447             ts->reported = 1;
 448             return 0;
 449         }
 450         ts->count = n;
 451         if ((unsigned long) n > ts->allocated) {
 452             ts->results = xrealloc(ts->results, n * sizeof(enum test_status));
 453             for (i = ts->allocated; i < ts->count; i++)
 454                 ts->results[i] = TEST_INVALID;
 455             ts->allocated = n;
 456         }
 457         ts->plan = PLAN_FINAL;
 458     }
 459     return 1;
 460 }
 461
 462
 463 /*
 464  * Given a single line of output from a test, parse it and return the success
 465  * status of that test.  Anything printed to stdout not matching the form
 466  * /^(not )?ok \d+/ is ignored.  Sets ts->current to the test number that just
 467  * reported status.
 468  */
 469 static void
 470 test_checkline(const char *line, struct testset *ts)
 471 {
 472     enum test_status status = TEST_PASS;
 473     const char *bail;
 474     char *end;
 475     long number;
 476     unsigned long i, current;
 477     int outlen;
 478
 479     /* Before anything, check for a test abort. */
 480     bail = strstr(line, "Bail out!");
 481     if (bail != NULL) {
 482         bail = skip_whitespace(bail + strlen("Bail out!"));
 483         if (*bail != '\0') {
 484             size_t length;
 485
 486             length = strlen(bail);
 487             if (bail[length - 1] == '\n')
 488                 length--;
 489             test_backspace(ts);
 490             printf("ABORTED (%.*s)\n", (int) length, bail);
 491             ts->reported = 1;
 492         }
 493         ts->aborted = 1;
 494         return;
 495     }
 496
 497     /*
 498      * If the given line isn't newline-terminated, it was too big for an
 499      * fgets(), which means ignore it.
 500      */
 501     if (line[strlen(line) - 1] != '\n')
 502         return;
 503
 504     /* If the line begins with a hash mark, ignore it. */
 505     if (line[0] == '#')
 506         return;
 507
 508     /* If we haven't yet seen a plan, look for one. */
 509     if (ts->plan == PLAN_INIT && isdigit((unsigned char)(*line))) {
 510         if (!test_plan(line, ts))
 511             return;
 512     } else if (strncmp(line, "1..", 3) == 0) {
 513         if (ts->plan == PLAN_PENDING) {
 514             if (!test_plan(line, ts))
 515                 return;
 516         } else {
 517             puts("ABORTED (multiple plans)");
 518             ts->aborted = 1;
 519             ts->reported = 1;
 520             return;
 521         }
 522     }
 523
 524     /* Parse the line, ignoring something we can't parse. */
 525     if (strncmp(line, "not ", 4) == 0) {
 526         status = TEST_FAIL;
 527         line += 4;
 528     }
 529     if (strncmp(line, "ok", 2) != 0)
 530         return;
 531     line = skip_whitespace(line + 2);
 532     errno = 0;
 533     number = strtol(line, &end, 10);
 534     if (errno != 0 || end == line)
 535         number = ts->current + 1;
 536     current = number;
 537     if (number <= 0 || (current > ts->count && ts->plan == PLAN_FIRST)) {
 538         test_backspace(ts);
 539         printf("ABORTED (invalid test number %lu)\n", current);
 540         ts->aborted = 1;
 541         ts->reported = 1;
 542         return;
 543     }
 544
 545     /* We have a valid test result.  Tweak the results array if needed. */
 546     if (ts->plan == PLAN_INIT || ts->plan == PLAN_PENDING) {
 547         ts->plan = PLAN_PENDING;
 548         if (current > ts->count)
 549             ts->count = current;
 550         if (current > ts->allocated) {
 551             unsigned long n;
 552
 553             n = (ts->allocated == 0) ? 32 : ts->allocated * 2;
 554             if (n < current)
 555                 n = current;
 556             ts->results = xrealloc(ts->results, n * sizeof(enum test_status));
 557             for (i = ts->allocated; i < n; i++)
 558                 ts->results[i] = TEST_INVALID;
 559             ts->allocated = n;
 560         }
 561     }
 562
 563     /*
 564      * Handle directives.  We should probably do something more interesting
 565      * with unexpected passes of todo tests.
 566      */
 567     while (isdigit((unsigned char)(*line)))
 568         line++;
 569     line = skip_whitespace(line);
 570     if (*line == '#') {
 571         line = skip_whitespace(line + 1);
 572         if (strncasecmp(line, "skip", 4) == 0)
 573             status = TEST_SKIP;
 574         if (strncasecmp(line, "todo", 4) == 0)
 575             status = (status == TEST_FAIL) ? TEST_SKIP : TEST_FAIL;
 576     }
 577
 578     /* Make sure that the test number is in range and not a duplicate. */
 579     if (ts->results[current - 1] != TEST_INVALID) {
 580         test_backspace(ts);
 581         printf("ABORTED (duplicate test number %lu)\n", current);
 582         ts->aborted = 1;
 583         ts->reported = 1;
 584         return;
 585     }
 586
 587     /* Good results.  Increment our various counters. */
 588     switch (status) {
 589         case TEST_PASS: ts->passed++;   break;
 590         case TEST_FAIL: ts->failed++;   break;
 591         case TEST_SKIP: ts->skipped++;  break;
 592         case TEST_INVALID:              break;
 593     }
 594     ts->current = current;
 595     ts->results[current - 1] = status;
 596     test_backspace(ts);
 597     if (isatty(STDOUT_FILENO)) {
 598         outlen = printf("%lu/%lu", current, ts->count);
 599         ts->length = (outlen >= 0) ? outlen : 0;
 600         fflush(stdout);
 601     }
 602 }
 603
 604
 605 /*
 606  * Print out a range of test numbers, returning the number of characters it
 607  * took up.  Takes the first number, the last number, the number of characters
 608  * already printed on the line, and the limit of number of characters the line
 609  * can hold.  Add a comma and a space before the range if chars indicates that
 610  * something has already been printed on the line, and print ... instead if
 611  * chars plus the space needed would go over the limit (use a limit of 0 to
 612  * disable this).
 613  */
 614 static unsigned int
 615 test_print_range(unsigned long first, unsigned long last, unsigned int chars,
 616                  unsigned int limit)
 617 {
 618     unsigned int needed = 0;
 619     unsigned long n;
 620
 621     for (n = first; n > 0; n /= 10)
 622         needed++;
 623     if (last > first) {
 624         for (n = last; n > 0; n /= 10)
 625             needed++;
 626         needed++;
 627     }
 628     if (chars > 0)
 629         needed += 2;
 630     if (limit > 0 && chars + needed > limit) {
 631         needed = 0;
 632         if (chars <= limit) {
 633             if (chars > 0) {
 634                 printf(", ");
 635                 needed += 2;
 636             }
 637             printf("...");
 638             needed += 3;
 639         }
 640     } else {
 641         if (chars > 0)
 642             printf(", ");
 643         if (last > first)
 644             printf("%lu-", first);
 645         printf("%lu", last);
 646     }
 647     return needed;
 648 }
 649
 650
 651 /*
 652  * Summarize a single test set.  The second argument is 0 if the set exited
 653  * cleanly, a positive integer representing the exit status if it exited
 654  * with a non-zero status, and a negative integer representing the signal
 655  * that terminated it if it was killed by a signal.
 656  */
 657 static void
 658 test_summarize(struct testset *ts, int status)
 659 {
 660     unsigned long i;
 661     unsigned long missing = 0;
 662     unsigned long failed = 0;
 663     unsigned long first = 0;
 664     unsigned long last = 0;
 665
 666     if (ts->aborted) {
 667         fputs("ABORTED", stdout);
 668         if (ts->count > 0)
 669             printf(" (passed %lu/%lu)", ts->passed, ts->count - ts->skipped);
 670     } else {
 671         for (i = 0; i < ts->count; i++) {
 672             if (ts->results[i] == TEST_INVALID) {
 673                 if (missing == 0)
 674                     fputs("MISSED ", stdout);
 675                 if (first && i == last)
 676                     last = i + 1;
 677                 else {
 678                     if (first)
 679                         test_print_range(first, last, missing - 1, 0);
 680                     missing++;
 681                     first = i + 1;
 682                     last = i + 1;
 683                 }
 684             }
 685         }
 686         if (first)
 687             test_print_range(first, last, missing - 1, 0);
 688         first = 0;
 689         last = 0;
 690         for (i = 0; i < ts->count; i++) {
 691             if (ts->results[i] == TEST_FAIL) {
 692                 if (missing && !failed)
 693                     fputs("; ", stdout);
 694                 if (failed == 0)
 695                     fputs("FAILED ", stdout);
 696                 if (first && i == last)
 697                     last = i + 1;
 698                 else {
 699                     if (first)
 700                         test_print_range(first, last, failed - 1, 0);
 701                     failed++;
 702                     first = i + 1;
 703                     last = i + 1;
 704                 }
 705             }
 706         }
 707         if (first)
 708             test_print_range(first, last, failed - 1, 0);
 709         if (!missing && !failed) {
 710             fputs(!status ? "ok" : "dubious", stdout);
 711             if (ts->skipped > 0) {
 712                 if (ts->skipped == 1)
 713                     printf(" (skipped %lu test)", ts->skipped);
 714                 else
 715                     printf(" (skipped %lu tests)", ts->skipped);
 716             }
 717         }
 718     }
 719     if (status > 0)
 720         printf(" (exit status %d)", status);
 721     else if (status < 0)
 722         printf(" (killed by signal %d%s)", -status,
 723                WCOREDUMP(ts->status) ? ", core dumped" : "");
 724     putchar('\n');
 725 }
 726
 727
 728 /*
 729  * Given a test set, analyze the results, classify the exit status, handle a
 730  * few special error messages, and then pass it along to test_summarize() for
 731  * the regular output.  Returns true if the test set ran successfully and all
 732  * tests passed or were skipped, false otherwise.
 733  */
 734 static int
 735 test_analyze(struct testset *ts)
 736 {
 737     if (ts->reported)
 738         return 0;
 739     if (ts->all_skipped) {
 740         if (ts->reason == NULL)
 741             puts("skipped");
 742         else
 743             printf("skipped (%s)\n", ts->reason);
 744         return 1;
 745     } else if (WIFEXITED(ts->status) && WEXITSTATUS(ts->status) != 0) {
 746         switch (WEXITSTATUS(ts->status)) {
 747         case CHILDERR_DUP:
 748             if (!ts->reported)
 749                 puts("ABORTED (can't dup file descriptors)");
 750             break;
 751         case CHILDERR_EXEC:
 752             if (!ts->reported)
 753                 puts("ABORTED (execution failed -- not found?)");
 754             break;
 755         case CHILDERR_STDERR:
 756             if (!ts->reported)
 757                 puts("ABORTED (can't open /dev/null)");
 758             break;
 759         default:
 760             test_summarize(ts, WEXITSTATUS(ts->status));
 761             break;
 762         }
 763         return 0;
 764     } else if (WIFSIGNALED(ts->status)) {
 765         test_summarize(ts, -WTERMSIG(ts->status));
 766         return 0;
 767     } else if (ts->plan != PLAN_FIRST && ts->plan != PLAN_FINAL) {
 768         puts("ABORTED (no valid test plan)");
 769         ts->aborted = 1;
 770         return 0;
 771     } else {
 772         test_summarize(ts, 0);
 773         return (ts->failed == 0);
 774     }
 775 }
 776
 777
 778 /*
 779  * Runs a single test set, accumulating and then reporting the results.
 780  * Returns true if the test set was successfully run and all tests passed,
 781  * false otherwise.
 782  */
 783 static int
 784 test_run(struct testset *ts)
 785 {
 786     pid_t testpid, child;
 787     int outfd, status;
 788     unsigned long i;
 789     FILE *output;
 790     char buffer[BUFSIZ];
 791
 792     /* Run the test program. */
 793     testpid = test_start(ts->path, &outfd);
 794     output = fdopen(outfd, "r");
 795     if (!output) {
 796         puts("ABORTED");
 797         fflush(stdout);
 798         sysdie("fdopen failed");
 799     }
 800
 801     /* Pass each line of output to test_checkline(). */
 802     while (!ts->aborted && fgets(buffer, sizeof(buffer), output))
 803         test_checkline(buffer, ts);
 804     if (ferror(output) || ts->plan == PLAN_INIT)
 805         ts->aborted = 1;
 806     test_backspace(ts);
 807
 808     /*
 809      * Consume the rest of the test output, close the output descriptor,
 810      * retrieve the exit status, and pass that information to test_analyze()
 811      * for eventual output.
 812      */
 813     while (fgets(buffer, sizeof(buffer), output))
 814         ;
 815     fclose(output);
 816     child = waitpid(testpid, &ts->status, 0);
 817     if (child == (pid_t) -1) {
 818         if (!ts->reported) {
 819             puts("ABORTED");
 820             fflush(stdout);
 821         }
 822         sysdie("waitpid for %u failed", (unsigned int) testpid);
 823     }
 824     if (ts->all_skipped)
 825         ts->aborted = 0;
 826     status = test_analyze(ts);
 827
 828     /* Convert missing tests to failed tests. */
 829     for (i = 0; i < ts->count; i++) {
 830         if (ts->results[i] == TEST_INVALID) {
 831             ts->failed++;
 832             ts->results[i] = TEST_FAIL;
 833             status = 0;
 834         }
 835     }
 836     return status;
 837 }
 838
 839
 840 /* Summarize a list of test failures. */
 841 static void
 842 test_fail_summary(const struct testlist *fails)
 843 {
 844     struct testset *ts;
 845     unsigned int chars;
 846     unsigned long i, first, last, total;
 847
 848     puts(header);
 849
 850     /* Failed Set                 Fail/Total (%) Skip Stat  Failing (25)
 851        -------------------------- -------------- ---- ----  -------------- */
 852     for (; fails; fails = fails->next) {
 853         ts = fails->ts;
 854         total = ts->count - ts->skipped;
 855         printf("%-26.26s %4lu/%-4lu %3.0f%% %4lu ", ts->file, ts->failed,
 856                total, total ? (ts->failed * 100.0) / total : 0,
 857                ts->skipped);
 858         if (WIFEXITED(ts->status))
 859             printf("%4d  ", WEXITSTATUS(ts->status));
 860         else
 861             printf("  --  ");
 862         if (ts->aborted) {
 863             puts("aborted");
 864             continue;
 865         }
 866         chars = 0;
 867         first = 0;
 868         last = 0;
 869         for (i = 0; i < ts->count; i++) {
 870             if (ts->results[i] == TEST_FAIL) {
 871                 if (first != 0 && i == last)
 872                     last = i + 1;
 873                 else {
 874                     if (first != 0)
 875                         chars += test_print_range(first, last, chars, 19);
 876                     first = i + 1;
 877                     last = i + 1;
 878                 }
 879             }
 880         }
 881         if (first != 0)
 882             test_print_range(first, last, chars, 19);
 883         putchar('\n');
 884         free(ts->file);
 885         free(ts->path);
 886         free(ts->results);
 887         if (ts->reason != NULL)
 888             free(ts->reason);
 889         free(ts);
 890     }
 891 }
 892
 893
 894 /*
 895  * Given the name of a test, a pointer to the testset struct, and the source
 896  * and build directories, find the test.  We try first relative to the current
 897  * directory, then in the build directory (if not NULL), then in the source
 898  * directory.  In each of those directories, we first try a "-t" extension and
 899  * then a ".t" extension.  When we find an executable program, we fill in the
 900  * path member of the testset struct.  If none of those paths are executable,
 901  * just fill in the name of the test with "-t" appended.
 902  *
 903  * The caller is responsible for freeing the path member of the testset
 904  * struct.
 905  */
 906 static void
 907 find_test(const char *name, struct testset *ts, const char *source,
 908           const char *build)
 909 {
 910     char *path;
 911     const char *bases[4];
 912     unsigned int i;
 913
 914     bases[0] = ".";
 915     bases[1] = build;
 916     bases[2] = source;
 917     bases[3] = NULL;
 918
 919     for (i = 0; bases[i] != NULL; i++) {
 920         path = xmalloc(strlen(bases[i]) + strlen(name) + 4);
 921         sprintf(path, "%s/%s-t", bases[i], name);
 922         if (access(path, X_OK) != 0)
 923             path[strlen(path) - 2] = '.';
 924         if (access(path, X_OK) == 0)
 925             break;
 926         free(path);
 927         path = NULL;
 928     }
 929     if (path == NULL) {
 930         path = xmalloc(strlen(name) + 3);
 931         sprintf(path, "%s-t", name);
 932     }
 933     ts->path = path;
 934 }
 935
 936
 937 /*
 938  * Run a batch of tests from a given file listing each test on a line by
 939  * itself.  Takes two additional parameters: the root of the source directory
 940  * and the root of the build directory.  Test programs will be first searched
 941  * for in the current directory, then the build directory, then the source
 942  * directory.  The file must be rewindable.  Returns true iff all tests
 943  * passed.
 944  */
 945 static int
 946 test_batch(const char *testlist, const char *source, const char *build)
 947 {
 948     FILE *tests;
 949     unsigned int length, i;
 950     unsigned int longest = 0;
 951     char buffer[BUFSIZ];
 952     unsigned int line;
 953     struct testset ts, *tmp;
 954     struct timeval start, end;
 955     struct rusage stats;
 956     struct testlist *failhead = NULL;
 957     struct testlist *failtail = NULL;
 958     struct testlist *next;
 959     unsigned long total = 0;
 960     unsigned long passed = 0;
 961     unsigned long skipped = 0;
 962     unsigned long failed = 0;
 963     unsigned long aborted = 0;
 964
 965     /*
 966      * Open our file of tests to run and scan it, checking for lines that
 967      * are too long and searching for the longest line.
 968      */
 969     tests = fopen(testlist, "r");
 970     if (!tests)
 971         sysdie("can't open %s", testlist);
 972     line = 0;
 973     while (fgets(buffer, sizeof(buffer), tests)) {
 974         line++;
 975         length = strlen(buffer) - 1;
 976         if (buffer[length] != '\n') {
 977             fprintf(stderr, "%s:%u: line too long\n", testlist, line);
 978             exit(1);
 979         }
 980         if (length > longest)
 981             longest = length;
 982     }
 983     if (fseek(tests, 0, SEEK_SET) == -1)
 984         sysdie("can't rewind %s", testlist);
 985
 986     /*
 987      * Add two to longest and round up to the nearest tab stop.  This is how
 988      * wide the column for printing the current test name will be.
 989      */
 990     longest += 2;
 991     if (longest % 8)
 992         longest += 8 - (longest % 8);
 993
 994     /* Start the wall clock timer. */
 995     gettimeofday(&start, NULL);
 996
 997     /*
 998      * Now, plow through our tests again, running each one.  Check line
 999      * length again out of paranoia.
1000      */
1001     line = 0;
1002     while (fgets(buffer, sizeof(buffer), tests)) {
1003         line++;
1004         length = strlen(buffer) - 1;
1005         if (buffer[length] != '\n') {
1006             fprintf(stderr, "%s:%u: line too long\n", testlist, line);
1007             exit(1);
1008         }
1009         buffer[length] = '\0';
1010         fputs(buffer, stdout);
1011         for (i = length; i < longest; i++)
1012             putchar('.');
1013         if (isatty(STDOUT_FILENO))
1014             fflush(stdout);
1015         memset(&ts, 0, sizeof(ts));
1016         ts.plan = PLAN_INIT;
1017         ts.file = xstrdup(buffer);
1018         find_test(buffer, &ts, source, build);
1019         ts.reason = NULL;
1020         if (test_run(&ts)) {
1021             free(ts.file);
1022             free(ts.path);
1023             free(ts.results);
1024             if (ts.reason != NULL)
1025                 free(ts.reason);
1026         } else {
1027             tmp = xmalloc(sizeof(struct testset));
1028             memcpy(tmp, &ts, sizeof(struct testset));
1029             if (!failhead) {
1030                 failhead = xmalloc(sizeof(struct testset));
1031                 failhead->ts = tmp;
1032                 failhead->next = NULL;
1033                 failtail = failhead;
1034             } else {
1035                 failtail->next = xmalloc(sizeof(struct testset));
1036                 failtail = failtail->next;
1037                 failtail->ts = tmp;
1038                 failtail->next = NULL;
1039             }
1040         }
1041         aborted += ts.aborted;
1042         total += ts.count + ts.all_skipped;
1043         passed += ts.passed;
1044         skipped += ts.skipped + ts.all_skipped;
1045         failed += ts.failed;
1046     }
1047     total -= skipped;
1048
1049     /* Stop the timer and get our child resource statistics. */
1050     gettimeofday(&end, NULL);
1051     getrusage(RUSAGE_CHILDREN, &stats);
1052
1053     /* Print out our final results. */
1054     if (failhead != NULL) {
1055         test_fail_summary(failhead);
1056         while (failhead != NULL) {
1057             next = failhead->next;
1058             free(failhead);
1059             failhead = next;
1060         }
1061     }
1062     putchar('\n');
1063     if (aborted != 0) {
1064         if (aborted == 1)
1065             printf("Aborted %lu test set", aborted);
1066         else
1067             printf("Aborted %lu test sets", aborted);
1068         printf(", passed %lu/%lu tests", passed, total);
1069     }
1070     else if (failed == 0)
1071         fputs("All tests successful", stdout);
1072     else
1073         printf("Failed %lu/%lu tests, %.2f%% okay", failed, total,
1074                (total - failed) * 100.0 / total);
1075     if (skipped != 0) {
1076         if (skipped == 1)
1077             printf(", %lu test skipped", skipped);
1078         else
1079             printf(", %lu tests skipped", skipped);
1080     }
1081     puts(".");
1082     printf("Files=%u,  Tests=%lu", line, total);
1083     printf(",  %.2f seconds", tv_diff(&end, &start));
1084     printf(" (%.2f usr + %.2f sys = %.2f CPU)\n",
1085            tv_seconds(&stats.ru_utime), tv_seconds(&stats.ru_stime),
1086            tv_sum(&stats.ru_utime, &stats.ru_stime));
1087     return (failed == 0 && aborted == 0);
1088 }
1089
1090
1091 /*
1092  * Run a single test case.  This involves just running the test program after
1093  * having done the environment setup and finding the test program.
1094  */
1095 static void
1096 test_single(const char *program, const char *source, const char *build)
1097 {
1098     struct testset ts;
1099
1100     memset(&ts, 0, sizeof(ts));
1101     find_test(program, &ts, source, build);
1102     if (execl(ts.path, ts.path, (char *) 0) == -1)
1103         sysdie("cannot exec %s", ts.path);
1104 }
1105
1106
1107 /*
1108  * Main routine.  Set the SOURCE and BUILD environment variables and then,
1109  * given a file listing tests, run each test listed.
1110  */
1111 int
1112 main(int argc, char *argv[])
1113 {
1114     int option;
1115     int single = 0;
1116     char *setting;
1117     const char *list;
1118     const char *source = SOURCE;
1119     const char *build = BUILD;
1120
1121     while ((option = getopt(argc, argv, "b:hos:")) != EOF) {
1122         switch (option) {
1123         case 'b':
1124             build = optarg;
1125             break;
1126         case 'h':
1127             printf(usage_message, argv[0], argv[0]);
1128             exit(0);
1129             break;
1130         case 'o':
1131             single = 1;
1132             break;
1133         case 's':
1134             source = optarg;
1135             break;
1136         default:
1137             exit(1);
1138         }
1139     }
1140     if (argc - optind != 1) {
1141         fprintf(stderr, usage_message, argv[0], argv[0]);
1142         exit(1);
1143     }
1144     argc -= optind;
1145     argv += optind;
1146
1147     if (source != NULL) {
1148         setting = xmalloc(strlen("SOURCE=") + strlen(source) + 1);
1149         sprintf(setting, "SOURCE=%s", source);
1150         if (putenv(setting) != 0)
1151             sysdie("cannot set SOURCE in the environment");
1152     }
1153     if (build != NULL) {
1154         setting = xmalloc(strlen("BUILD=") + strlen(build) + 1);
1155         sprintf(setting, "BUILD=%s", build);
1156         if (putenv(setting) != 0)
1157             sysdie("cannot set BUILD in the environment");
1158     }
1159
1160     if (single) {
1161         test_single(argv[0], source, build);
1162         exit(0);
1163     } else {
1164         list = strrchr(argv[0], '/');
1165         if (list == NULL)
1166             list = argv[0];
1167         else
1168             list++;
1169         printf(banner, list);
1170         exit(test_batch(argv[0], source, build) ? 0 : 1);
1171     }
1172 }