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