Annotation of embedaddon/bird2/test/birdtest.c, revision 1.1.1.1
1.1 misho 1: /*
2: * BIRD -- Unit Test Framework (BIRD Test)
3: *
4: * Can be freely distributed and used under the terms of the GNU GPL.
5: */
6:
7: #include <inttypes.h>
8: #include <stdarg.h>
9: #include <stdint.h>
10: #include <stdio.h>
11: #include <stdlib.h>
12: #include <string.h>
13: #include <signal.h>
14: #include <time.h>
15: #include <unistd.h>
16:
17: #include <sys/ioctl.h>
18: #include <sys/resource.h>
19: #include <sys/wait.h>
20:
21: #include "test/birdtest.h"
22: #include "lib/string.h"
23:
24: #ifdef HAVE_EXECINFO_H
25: #include <execinfo.h>
26: #endif
27:
28: #define BACKTRACE_MAX_LINES 100
29:
30: #define sprintf_concat(s, format, ...) \
31: snprintf(s + strlen(s), sizeof(s) - strlen(s), format, ##__VA_ARGS__)
32:
33: static const char *request;
34: static int list_tests;
35: static int do_core;
36: static int do_die;
37: static int no_fork;
38: static int no_timeout;
39: static int is_terminal; /* Whether stdout is a live terminal or pipe redirect */
40:
41: volatile sig_atomic_t async_config_flag; /* Asynchronous reconfiguration/dump scheduled */
42: volatile sig_atomic_t async_dump_flag;
43: volatile sig_atomic_t async_shutdown_flag;
44:
45:
46: uint bt_verbose;
47: const char *bt_filename;
48: const char *bt_test_id;
49:
50: int bt_result; /* Overall program run result */
51: int bt_suite_result; /* One suit result */
52: char bt_out_fmt_buf[1024]; /* Temporary memory buffer for output of testing function */
53:
54: struct timespec bt_begin, bt_suite_begin, bt_suite_case_begin;
55:
56: u64 bt_random_state[] = {
57: 0x80241f302bd4d95d, 0xd10ba2e910f772b, 0xea188c9046f507c5, 0x4c4c581f04e6da05,
58: 0x53d9772877c1b647, 0xab8ce3eb466de6c5, 0xad02844c8a8e865f, 0xe8cc78080295065d
59: };
60:
61: void
62: bt_init(int argc, char *argv[])
63: {
64: int c;
65:
66: initstate(BT_RANDOM_SEED, (char *) bt_random_state, sizeof(bt_random_state));
67:
68: bt_verbose = 0;
69: bt_filename = argv[0];
70: bt_result = 1;
71: bt_test_id = NULL;
72: is_terminal = isatty(fileno(stdout));
73:
74: while ((c = getopt(argc, argv, "lcdftv")) >= 0)
75: switch (c)
76: {
77: case 'l':
78: list_tests = 1;
79: break;
80:
81: case 'c':
82: do_core = 1;
83: break;
84:
85: case 'd':
86: do_die = 1;
87: break;
88:
89: case 'f':
90: no_fork = 1;
91: break;
92:
93: case 't':
94: no_timeout = 1;
95: break;
96:
97: case 'v':
98: bt_verbose++;
99: break;
100:
101: default:
102: goto usage;
103: }
104:
105: /* Optional requested test_id */
106: if ((optind + 1) == argc)
107: request = argv[optind++];
108:
109: if (optind != argc)
110: goto usage;
111:
112: if (do_core)
113: {
114: struct rlimit rl = {RLIM_INFINITY, RLIM_INFINITY};
115: int rv = setrlimit(RLIMIT_CORE, &rl);
116: bt_syscall(rv < 0, "setrlimit RLIMIT_CORE");
117: }
118:
119: clock_gettime(CLOCK_MONOTONIC, &bt_begin);
120:
121: return;
122:
123: usage:
124: printf("Usage: %s [-l] [-c] [-d] [-f] [-t] [-vvv] [<test_suit_name>]\n", argv[0]);
125: printf("Options: \n");
126: printf(" -l List all test suite names and descriptions \n");
127: printf(" -c Force unlimit core dumps (needs root privileges) \n");
128: printf(" -d Die on first failed test case \n");
129: printf(" -f No forking \n");
130: printf(" -t No timeout limit \n");
131: printf(" -v More verbosity, maximum is 3 -vvv \n");
132: exit(3);
133: }
134:
135: static void
136: bt_dump_backtrace(void)
137: {
138: #ifdef HAVE_EXECINFO_H
139: void *buf[BACKTRACE_MAX_LINES];
140: char **pp_backtrace;
141: int lines, j;
142:
143: if (!bt_verbose)
144: return;
145:
146: lines = backtrace(buf, BACKTRACE_MAX_LINES);
147: bt_log("backtrace() returned %d addresses", lines);
148:
149: pp_backtrace = backtrace_symbols(buf, lines);
150: if (pp_backtrace == NULL)
151: {
152: perror("backtrace_symbols");
153: exit(EXIT_FAILURE);
154: }
155:
156: for (j = 0; j < lines; j++)
157: bt_log("%s", pp_backtrace[j]);
158:
159: free(pp_backtrace);
160: #endif /* HAVE_EXECINFO_H */
161: }
162:
163: static
164: int bt_run_test_fn(int (*fn)(const void *), const void *fn_arg, int timeout)
165: {
166: int result;
167: alarm(timeout);
168:
169: result = fn(fn_arg);
170:
171: if (!bt_suite_result)
172: result = 0;
173:
174: return result;
175: }
176:
177: static uint
178: get_num_terminal_cols(void)
179: {
180: struct winsize w = {};
181: ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
182: uint cols = w.ws_col;
183: return (cols > 0 ? cols : 80);
184: }
185:
186: /**
187: * bt_log_result - pretty print of test result
188: * @result: 1 or 0
189: * @fmt: a description message (could be long, over more lines)
190: * @argptr: variable argument list
191: *
192: * This function is used for pretty printing of test results on all verbose
193: * levels.
194: */
195: static void
196: bt_log_result(int result, u64 time, const char *fmt, va_list argptr)
197: {
198: static char msg_buf[BT_BUFFER_SIZE];
199: char *pos;
200:
201: snprintf(msg_buf, sizeof(msg_buf), "%s%s%s%s %" PRIu64 ".%09" PRIu64 "s",
202: bt_filename,
203: bt_test_id ? ": " : "",
204: bt_test_id ? bt_test_id : "",
205: (fmt && strlen(fmt) > 0) ? ": " : "",
206: time / 1000000000,
207: time % 1000000000
208: );
209: pos = msg_buf + strlen(msg_buf);
210:
211: if (fmt)
212: vsnprintf(pos, sizeof(msg_buf) - (pos - msg_buf), fmt, argptr);
213:
214: int chrs = 0;
215: for (uint i = 0; i < strlen(msg_buf); i += get_num_terminal_cols())
216: {
217: if (i)
218: printf("\n");
219: char *stop = msg_buf + i + get_num_terminal_cols();
220: char backup = *stop;
221: *stop = 0;
222: chrs = printf("%s", msg_buf + i);
223: *stop = backup;
224: }
225:
226: int offset = get_num_terminal_cols() - chrs - BT_PROMPT_OK_FAIL_STRLEN;
227: if (offset < 0)
228: {
229: printf("\n");
230: offset = get_num_terminal_cols() - BT_PROMPT_OK_FAIL_STRLEN;
231: }
232:
233: for (int i = 0; i < offset; i++)
234: putchar(' ');
235:
236: const char *result_str = is_terminal ? BT_PROMPT_OK : BT_PROMPT_OK_NO_COLOR;
237: if (!result)
238: result_str = is_terminal ? BT_PROMPT_FAIL : BT_PROMPT_FAIL_NO_COLOR;
239:
240: printf("%s\n", result_str);
241:
242: if (do_die && !result)
243: abort();
244: }
245:
246: static u64
247: get_time_diff(struct timespec *begin)
248: {
249: struct timespec end;
250: clock_gettime(CLOCK_MONOTONIC, &end);
251: return (end.tv_sec - begin->tv_sec) * 1000000000ULL
252: + end.tv_nsec - begin->tv_nsec;
253: }
254:
255: /**
256: * bt_log_overall_result - pretty print of suite case result
257: * @result: 1 or 0
258: * @fmt: a description message (could be long, over more lines)
259: * ...: variable argument list
260: *
261: * This function is used for pretty printing of test suite case result.
262: */
263: static void
264: bt_log_overall_result(int result, const char *fmt, ...)
265: {
266: va_list argptr;
267: va_start(argptr, fmt);
268: bt_log_result(result, get_time_diff(&bt_begin), fmt, argptr);
269: va_end(argptr);
270: }
271:
272: /**
273: * bt_log_suite_result - pretty print of suite case result
274: * @result: 1 or 0
275: * @fmt: a description message (could be long, over more lines)
276: * ...: variable argument list
277: *
278: * This function is used for pretty printing of test suite case result.
279: */
280: void
281: bt_log_suite_result(int result, const char *fmt, ...)
282: {
283: if (bt_verbose >= BT_VERBOSE_SUITE || !result)
284: {
285: va_list argptr;
286: va_start(argptr, fmt);
287: bt_log_result(result, get_time_diff(&bt_suite_begin), fmt, argptr);
288: va_end(argptr);
289: }
290: }
291:
292: /**
293: * bt_log_suite_case_result - pretty print of suite result
294: * @result: 1 or 0
295: * @fmt: a description message (could be long, over more lines)
296: * ...: variable argument list
297: *
298: * This function is used for pretty printing of test suite result.
299: */
300: void
301: bt_log_suite_case_result(int result, const char *fmt, ...)
302: {
303: if(bt_verbose >= BT_VERBOSE_SUITE_CASE)
304: {
305: va_list argptr;
306: va_start(argptr, fmt);
307: bt_log_result(result, get_time_diff(&bt_suite_case_begin), fmt, argptr);
308: va_end(argptr);
309: }
310: }
311:
312: int
313: bt_test_suite_base(int (*fn)(const void *), const char *id, const void *fn_arg, int forked, int timeout, const char *dsc, ...)
314: {
315: if (list_tests)
316: {
317: printf("%28s - ", id);
318: va_list args;
319: va_start(args, dsc);
320: vprintf(dsc, args);
321: va_end(args);
322: printf("\n");
323: return 1;
324: }
325:
326: if (no_fork)
327: forked = 0;
328:
329: if (no_timeout)
330: timeout = 0;
331:
332: if (request && strcmp(id, request))
333: return 1;
334:
335: bt_suite_result = 1;
336: bt_test_id = id;
337:
338: if (bt_verbose >= BT_VERBOSE_ABSOLUTELY_ALL)
339: bt_log("Starting");
340:
341: clock_gettime(CLOCK_MONOTONIC, &bt_suite_begin);
342:
343: if (!forked)
344: {
345: bt_suite_result = bt_run_test_fn(fn, fn_arg, timeout);
346: }
347: else
348: {
349: pid_t pid = fork();
350: bt_syscall(pid < 0, "fork");
351:
352: if (pid == 0)
353: {
354: /* child of fork */
355: _exit(bt_run_test_fn(fn, fn_arg, timeout));
356: }
357:
358: int s;
359: int rv = waitpid(pid, &s, 0);
360: bt_syscall(rv < 0, "waitpid");
361:
362: if (WIFEXITED(s))
363: {
364: /* Normal exit */
365: bt_suite_result = WEXITSTATUS(s);
366: }
367: else if (WIFSIGNALED(s))
368: {
369: /* Stopped by signal */
370: bt_suite_result = 0;
371:
372: int sn = WTERMSIG(s);
373: if (sn == SIGALRM)
374: {
375: bt_log("Timeout expired");
376: }
377: else if (sn == SIGSEGV)
378: {
379: bt_log("Segmentation fault");
380: bt_dump_backtrace();
381: }
382: else if (sn != SIGABRT)
383: bt_log("Signal %d received", sn);
384: }
385:
386: if (WCOREDUMP(s) && bt_verbose)
387: bt_log("Core dumped");
388: }
389:
390: if (!bt_suite_result)
391: bt_result = 0;
392:
393: bt_log_suite_result(bt_suite_result, NULL);
394: bt_test_id = NULL;
395:
396: return bt_suite_result;
397: }
398:
399: int
400: bt_exit_value(void)
401: {
402: if (!list_tests || (list_tests && !bt_result))
403: bt_log_overall_result(bt_result, "");
404: return bt_result ? EXIT_SUCCESS : EXIT_FAILURE;
405: }
406:
407: /**
408: * bt_assert_batch__ - test a batch of inputs/outputs tests
409: * @opts: includes all necessary data
410: *
411: * Should be called using macro bt_assert_batch().
412: * Returns 1 or 0.
413: */
414: int
415: bt_assert_batch__(struct bt_batch *opts)
416: {
417: int i;
418: for (i = 0; i < opts->ndata; i++)
419: {
420: if (bt_verbose >= BT_VERBOSE_SUITE)
421: clock_gettime(CLOCK_MONOTONIC, &bt_suite_case_begin);
422:
423: int bt_suit_case_result = opts->test_fn(opts->out_buf, opts->data[i].in, opts->data[i].out);
424:
425: if (bt_suit_case_result == 0)
426: bt_suite_result = 0;
427:
428: char b[BT_BUFFER_SIZE];
429: snprintf(b, sizeof(b), "%s(", opts->test_fn_name);
430:
431: opts->in_fmt(b+strlen(b), sizeof(b)-strlen(b), opts->data[i].in);
432: sprintf_concat(b, ") gives ");
433: opts->out_fmt(b+strlen(b), sizeof(b)-strlen(b), opts->out_buf);
434:
435: if (bt_suit_case_result == 0)
436: {
437: sprintf_concat(b, ", but expecting is ");
438: opts->out_fmt(b+strlen(b), sizeof(b)-strlen(b), opts->data[i].out);
439: }
440:
441: bt_log_suite_case_result(bt_suit_case_result, "%s", b);
442: }
443:
444: return bt_suite_result;
445: }
446:
447: /**
448: * bt_fmt_str - formating string into output buffer
449: * @buf: buffer for write
450: * @size: empty size in @buf
451: * @data: null-byte terminated string
452: *
453: * This function can be used with bt_assert_batch() function.
454: * Input @data should be const char * string.
455: */
456: void
457: bt_fmt_str(char *buf, size_t size, const void *data)
458: {
459: const byte *s = data;
460:
461: snprintf(buf, size, "\"");
462: while (*s)
463: {
464: snprintf(buf+strlen(buf), size-strlen(buf), bt_is_char(*s) ? "%c" : "\\%03u", *s);
465: s++;
466: }
467: snprintf(buf+strlen(buf), size-strlen(buf), "\"");
468: }
469:
470: /**
471: * bt_fmt_unsigned - formating unsigned int into output buffer
472: * @buf: buffer for write
473: * @size: empty size in @buf
474: * @data: unsigned number
475: *
476: * This function can be used with bt_assert_batch() function.
477: */
478: void
479: bt_fmt_unsigned(char *buf, size_t size, const void *data)
480: {
481: const uint *n = data;
482: snprintf(buf, size, "0x%x (%u)", *n, *n);
483: }
484:
485: /**
486: * bt_fmt_ipa - formating ip_addr into output buffer
487: * @buf: buffer for write
488: * @size: empty size in @buf
489: * @data: should be struct ip_addr *
490: *
491: * This function can be used with bt_assert_batch() function.
492: */
493: void
494: bt_fmt_ipa(char *buf, size_t size, const void *data)
495: {
496: const ip_addr *ip = data;
497: bsnprintf(buf, size, "%I", *ip);
498: }
499:
500: int
501: bt_is_char(byte c)
502: {
503: return (c >= (byte) 32 && c <= (byte) 126);
504: }
505:
506: /*
507: * Mock-ups of all necessary public functions in main.c
508: */
509:
510: char *bird_name;
511: void async_config(void) {}
512: void async_dump(void) {}
513: void async_shutdown(void) {}
514: void cmd_check_config(char *name UNUSED) {}
515: void cmd_reconfig(char *name UNUSED, int type UNUSED, int timeout UNUSED) {}
516: void cmd_reconfig_confirm(void) {}
517: void cmd_reconfig_undo(void) {}
518: void cmd_reconfig_status(void) {}
519: void cmd_graceful_restart(void) {}
520: void cmd_shutdown(void) {}
521: void cmd_reconfig_undo_notify(void) {}
522:
523: #include "nest/bird.h"
524: #include "lib/net.h"
525: #include "conf/conf.h"
526: void sysdep_preconfig(struct config *c UNUSED) {}
527: int sysdep_commit(struct config *new UNUSED, struct config *old UNUSED) { return 0; }
528: void sysdep_shutdown_done(void) {}
529:
530: #include "nest/cli.h"
531: int cli_get_command(cli *c UNUSED) { return 0; }
532: void cli_write_trigger(cli *c UNUSED) {}
533: cli *cmd_reconfig_stored_cli;
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to birdtest.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird2 / test