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