Move modules to ccan/ tools to tools/
[ccan] / ccan / tap / 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 #define _GNU_SOURCE
27 #include <ctype.h>
28 #include <stdarg.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31
32 #include "tap.h"
33
34 static int no_plan = 0;
35 static int skip_all = 0;
36 static int have_plan = 0;
37 static unsigned int test_count = 0; /* Number of tests that have been run */
38 static unsigned int e_tests = 0; /* Expected number of tests to run */
39 static unsigned int failures = 0; /* Number of tests that failed */
40 static char *todo_msg = NULL;
41 static char *todo_msg_fixed = "libtap malloc issue";
42 static int todo = 0;
43 static int test_died = 0;
44
45 /* Encapsulate the pthread code in a conditional.  In the absence of
46    libpthread the code does nothing */
47 #ifdef HAVE_LIBPTHREAD
48 #include <pthread.h>
49 static pthread_mutex_t M = PTHREAD_MUTEX_INITIALIZER;
50 # define LOCK pthread_mutex_lock(&M)
51 # define UNLOCK pthread_mutex_unlock(&M)
52 #else
53 # define LOCK
54 # define UNLOCK
55 #endif
56
57 static void
58 _expected_tests(unsigned int tests)
59 {
60
61         printf("1..%d\n", tests);
62         e_tests = tests;
63 }
64
65 static void
66 diagv(char *fmt, va_list ap)
67 {
68         fputs("# ", stderr);
69         vfprintf(stderr, fmt, ap);
70         fputs("\n", stderr);
71 }
72
73 static void
74 _diag(char *fmt, ...)
75 {
76         va_list ap;
77         va_start(ap, fmt);
78         diagv(fmt, ap);
79         va_end(ap);
80 }
81
82 /*
83  * Generate a test result.
84  *
85  * ok -- boolean, indicates whether or not the test passed.
86  * test_name -- the name of the test, may be NULL
87  * test_comment -- a comment to print afterwards, may be NULL
88  */
89 unsigned int
90 _gen_result(int ok, const char *func, char *file, unsigned int line, 
91             char *test_name, ...)
92 {
93         va_list ap;
94         char *local_test_name = NULL;
95         char *c;
96         int name_is_digits;
97
98         LOCK;
99
100         test_count++;
101
102         /* Start by taking the test name and performing any printf()
103            expansions on it */
104         if(test_name != NULL) {
105                 va_start(ap, test_name);
106                 vasprintf(&local_test_name, test_name, ap);
107                 va_end(ap);
108
109                 /* Make sure the test name contains more than digits
110                    and spaces.  Emit an error message and exit if it
111                    does */
112                 if(local_test_name) {
113                         name_is_digits = 1;
114                         for(c = local_test_name; *c != '\0'; c++) {
115                                 if(!isdigit(*c) && !isspace(*c)) {
116                                         name_is_digits = 0;
117                                         break;
118                                 }
119                         }
120
121                         if(name_is_digits) {
122                                 _diag("    You named your test '%s'.  You shouldn't use numbers for your test names.", local_test_name);
123                                 _diag("    Very confusing.");
124                         }
125                 }
126         }
127
128         if(!ok) {
129                 printf("not ");
130                 failures++;
131         }
132
133         printf("ok %d", test_count);
134
135         if(test_name != NULL) {
136                 printf(" - ");
137
138                 /* Print the test name, escaping any '#' characters it
139                    might contain */
140                 if(local_test_name != NULL) {
141                         flockfile(stdout);
142                         for(c = local_test_name; *c != '\0'; c++) {
143                                 if(*c == '#')
144                                         fputc('\\', stdout);
145                                 fputc((int)*c, stdout);
146                         }
147                         funlockfile(stdout);
148                 } else {        /* vasprintf() failed, use a fixed message */
149                         printf("%s", todo_msg_fixed);
150                 }
151         }
152
153         /* If we're in a todo_start() block then flag the test as being
154            TODO.  todo_msg should contain the message to print at this
155            point.  If it's NULL then asprintf() failed, and we should
156            use the fixed message.
157
158            This is not counted as a failure, so decrement the counter if
159            the test failed. */
160         if(todo) {
161                 printf(" # TODO %s", todo_msg ? todo_msg : todo_msg_fixed);
162                 if(!ok)
163                         failures--;
164         }
165
166         printf("\n");
167
168         if(!ok)
169                 _diag("    Failed %stest (%s:%s() at line %d)", 
170                       todo ? "(TODO) " : "", file, func, line);
171
172         free(local_test_name);
173
174         UNLOCK;
175
176         /* We only care (when testing) that ok is positive, but here we
177            specifically only want to return 1 or 0 */
178         return ok ? 1 : 0;
179 }
180
181 /*
182  * Cleanup at the end of the run, produce any final output that might be
183  * required.
184  */
185 static void
186 _cleanup(void)
187 {
188
189         LOCK;
190
191         /* If plan_no_plan() wasn't called, and we don't have a plan,
192            and we're not skipping everything, then something happened
193            before we could produce any output */
194         if(!no_plan && !have_plan && !skip_all) {
195                 _diag("Looks like your test died before it could output anything.");
196                 UNLOCK;
197                 return;
198         }
199
200         if(test_died) {
201                 _diag("Looks like your test died just after %d.", test_count);
202                 UNLOCK;
203                 return;
204         }
205
206
207         /* No plan provided, but now we know how many tests were run, and can
208            print the header at the end */
209         if(!skip_all && (no_plan || !have_plan)) {
210                 printf("1..%d\n", test_count);
211         }
212
213         if((have_plan && !no_plan) && e_tests < test_count) {
214                 _diag("Looks like you planned %d tests but ran %d extra.",
215                       e_tests, test_count - e_tests);
216                 UNLOCK;
217                 return;
218         }
219
220         if((have_plan || !no_plan) && e_tests > test_count) {
221                 _diag("Looks like you planned %d tests but only ran %d.",
222                       e_tests, test_count);
223                 if(failures) {
224                         _diag("Looks like you failed %d tests of %d run.", 
225                               failures, test_count);
226                 }
227                 UNLOCK;
228                 return;
229         }
230
231         if(failures)
232                 _diag("Looks like you failed %d tests of %d.", 
233                       failures, test_count);
234
235         UNLOCK;
236 }
237
238 /*
239  * Initialise the TAP library.  Will only do so once, however many times it's
240  * called.
241  */
242 static void
243 _tap_init(void)
244 {
245         static int run_once = 0;
246
247         if(!run_once) {
248                 atexit(_cleanup);
249
250                 /* stdout needs to be unbuffered so that the output appears
251                    in the same place relative to stderr output as it does 
252                    with Test::Harness */
253                 setbuf(stdout, 0);
254                 run_once = 1;
255         }
256 }
257
258 /*
259  * Note that there's no plan.
260  */
261 void
262 plan_no_plan(void)
263 {
264
265         LOCK;
266
267         _tap_init();
268
269         if(have_plan != 0) {
270                 fprintf(stderr, "You tried to plan twice!\n");
271                 test_died = 1;
272                 UNLOCK;
273                 exit(255);
274         }
275
276         have_plan = 1;
277         no_plan = 1;
278
279         UNLOCK;
280 }
281
282 /*
283  * Note that the plan is to skip all tests
284  */
285 void
286 plan_skip_all(char *reason)
287 {
288
289         LOCK;
290
291         _tap_init();
292
293         skip_all = 1;
294
295         printf("1..0");
296
297         if(reason != NULL)
298                 printf(" # Skip %s", reason);
299
300         printf("\n");
301
302         UNLOCK;
303 }
304
305 /*
306  * Note the number of tests that will be run.
307  */
308 void
309 plan_tests(unsigned int tests)
310 {
311
312         LOCK;
313
314         _tap_init();
315
316         if(have_plan != 0) {
317                 fprintf(stderr, "You tried to plan twice!\n");
318                 test_died = 1;
319                 UNLOCK;
320                 exit(255);
321         }
322
323         if(tests == 0) {
324                 fprintf(stderr, "You said to run 0 tests!  You've got to run something.\n");
325                 test_died = 1;
326                 UNLOCK;
327                 exit(255);
328         }
329
330         have_plan = 1;
331
332         _expected_tests(tests);
333
334         UNLOCK;
335 }
336
337 void
338 diag(char *fmt, ...)
339 {
340         va_list ap;
341
342         LOCK;
343
344         va_start(ap, fmt);
345         diagv(fmt, ap);
346         va_end(ap);
347
348         UNLOCK;
349 }
350
351 void
352 skip(unsigned int n, char *fmt, ...)
353 {
354         va_list ap;
355         char *skip_msg;
356
357         LOCK;
358
359         va_start(ap, fmt);
360         vasprintf(&skip_msg, fmt, ap);
361         va_end(ap);
362
363         while(n-- > 0) {
364                 test_count++;
365                 printf("ok %d # skip %s\n", test_count, 
366                        skip_msg != NULL ? 
367                        skip_msg : "libtap():malloc() failed");
368         }
369
370         free(skip_msg);
371
372         UNLOCK;
373 }
374
375 void
376 todo_start(char *fmt, ...)
377 {
378         va_list ap;
379
380         LOCK;
381
382         va_start(ap, fmt);
383         vasprintf(&todo_msg, fmt, ap);
384         va_end(ap);
385
386         todo = 1;
387
388         UNLOCK;
389 }
390
391 void
392 todo_end(void)
393 {
394
395         LOCK;
396
397         todo = 0;
398         free(todo_msg);
399
400         UNLOCK;
401 }
402
403 int
404 exit_status(void)
405 {
406         int r;
407
408         LOCK;
409
410         /* If there's no plan, just return the number of failures */
411         if(no_plan || !have_plan) {
412                 UNLOCK;
413                 return failures;
414         }
415
416         /* Ran too many tests?  Return the number of tests that were run
417            that shouldn't have been */
418         if(e_tests < test_count) {
419                 r = test_count - e_tests;
420                 UNLOCK;
421                 return r;
422         }
423
424         /* Return the number of tests that failed + the number of tests 
425            that weren't run */
426         r = failures + e_tests - test_count;
427         UNLOCK;
428
429         return r;
430 }