1 /* SPDX-License-Identifier: GPL-2.0-only */
2 /*
3 * Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
4 *
5 * kselftest_harness.h: simple C unit test helper.
6 *
7 * See documentation in Documentation/dev-tools/kselftest.rst
8 *
9 * API inspired by code.google.com/p/googletest
10 */
11
12 /**
13 * DOC: example
14 *
15 * .. code-block:: c
16 *
17 * #include "../kselftest_harness.h"
18 *
19 * TEST(standalone_test) {
20 * do_some_stuff;
21 * EXPECT_GT(10, stuff) {
22 * stuff_state_t state;
23 * enumerate_stuff_state(&state);
24 * TH_LOG("expectation failed with state: %s", state.msg);
25 * }
26 * more_stuff;
27 * ASSERT_NE(some_stuff, NULL) TH_LOG("how did it happen?!");
28 * last_stuff;
29 * EXPECT_EQ(0, last_stuff);
30 * }
31 *
32 * FIXTURE(my_fixture) {
33 * mytype_t *data;
34 * int awesomeness_level;
35 * };
36 * FIXTURE_SETUP(my_fixture) {
37 * self->data = mytype_new();
38 * ASSERT_NE(NULL, self->data);
39 * }
40 * FIXTURE_TEARDOWN(my_fixture) {
41 * mytype_free(self->data);
42 * }
43 * TEST_F(my_fixture, data_is_good) {
44 * EXPECT_EQ(1, is_my_data_good(self->data));
45 * }
46 *
47 * TEST_HARNESS_MAIN
48 */
49
50 #ifndef __KSELFTEST_HARNESS_H
51 #define __KSELFTEST_HARNESS_H
52
53 #define _GNU_SOURCE
54 #include <asm/types.h>
55 #include <errno.h>
56 #include <stdbool.h>
57 #include <stdint.h>
58 #include <stdio.h>
59 #include <stdlib.h>
60 #include <string.h>
61 #include <sys/types.h>
62 #include <sys/wait.h>
63 #include <unistd.h>
64
65 #define TEST_TIMEOUT_DEFAULT 30
66
67 /* Utilities exposed to the test definitions */
68 #ifndef TH_LOG_STREAM
69 # define TH_LOG_STREAM stderr
70 #endif
71
72 #ifndef TH_LOG_ENABLED
73 # define TH_LOG_ENABLED 1
74 #endif
75
76 /**
77 * TH_LOG(fmt, ...)
78 *
79 * @fmt: format string
80 * @...: optional arguments
81 *
82 * .. code-block:: c
83 *
84 * TH_LOG(format, ...)
85 *
86 * Optional debug logging function available for use in tests.
87 * Logging may be enabled or disabled by defining TH_LOG_ENABLED.
88 * E.g., #define TH_LOG_ENABLED 1
89 *
90 * If no definition is provided, logging is enabled by default.
91 *
92 * If there is no way to print an error message for the process running the
93 * test (e.g. not allowed to write to stderr), it is still possible to get the
94 * ASSERT_* number for which the test failed. This behavior can be enabled by
95 * writing `_metadata->no_print = true;` before the check sequence that is
96 * unable to print. When an error occur, instead of printing an error message
97 * and calling `abort(3)`, the test process call `_exit(2)` with the assert
98 * number as argument, which is then printed by the parent process.
99 */
100 #define TH_LOG(fmt, ...) do { \
101 if (TH_LOG_ENABLED) \
102 __TH_LOG(fmt, ##__VA_ARGS__); \
103 } while (0)
104
105 /* Unconditional logger for internal use. */
106 #define __TH_LOG(fmt, ...) \
107 fprintf(TH_LOG_STREAM, "%s:%d:%s:" fmt "\n", \
108 __FILE__, __LINE__, _metadata->name, ##__VA_ARGS__)
109
110 /**
111 * XFAIL(statement, fmt, ...)
112 *
113 * @statement: statement to run after reporting XFAIL
114 * @fmt: format string
115 * @...: optional arguments
116 *
117 * This forces a "pass" after reporting a failure with an XFAIL prefix,
118 * and runs "statement", which is usually "return" or "goto skip".
119 */
120 #define XFAIL(statement, fmt, ...) do { \
121 if (TH_LOG_ENABLED) { \
122 fprintf(TH_LOG_STREAM, "[ XFAIL! ] " fmt "\n", \
123 ##__VA_ARGS__); \
124 } \
125 /* TODO: find a way to pass xfail to test runner process. */ \
126 _metadata->passed = 1; \
127 _metadata->trigger = 0; \
128 statement; \
129 } while (0)
130
131 /**
132 * TEST(test_name) - Defines the test function and creates the registration
133 * stub
134 *
135 * @test_name: test name
136 *
137 * .. code-block:: c
138 *
139 * TEST(name) { implementation }
140 *
141 * Defines a test by name.
142 * Names must be unique and tests must not be run in parallel. The
143 * implementation containing block is a function and scoping should be treated
144 * as such. Returning early may be performed with a bare "return;" statement.
145 *
146 * EXPECT_* and ASSERT_* are valid in a TEST() { } context.
147 */
148 #define TEST(test_name) __TEST_IMPL(test_name, -1)
149
150 /**
151 * TEST_SIGNAL(test_name, signal)
152 *
153 * @test_name: test name
154 * @signal: signal number
155 *
156 * .. code-block:: c
157 *
158 * TEST_SIGNAL(name, signal) { implementation }
159 *
160 * Defines a test by name and the expected term signal.
161 * Names must be unique and tests must not be run in parallel. The
162 * implementation containing block is a function and scoping should be treated
163 * as such. Returning early may be performed with a bare "return;" statement.
164 *
165 * EXPECT_* and ASSERT_* are valid in a TEST() { } context.
166 */
167 #define TEST_SIGNAL(test_name, signal) __TEST_IMPL(test_name, signal)
168
169 #define __TEST_IMPL(test_name, _signal) \
170 static void test_name(struct __test_metadata *_metadata); \
171 static struct __test_metadata _##test_name##_object = \
172 { .name = "global." #test_name, \
173 .fn = &test_name, .termsig = _signal, \
174 .timeout = TEST_TIMEOUT_DEFAULT, }; \
175 static void __attribute__((constructor)) _register_##test_name(void) \
176 { \
177 __register_test(&_##test_name##_object); \
178 } \
179 static void test_name( \
180 struct __test_metadata __attribute__((unused)) *_metadata)
181
182 /**
183 * FIXTURE_DATA(datatype_name) - Wraps the struct name so we have one less
184 * argument to pass around
185 *
186 * @datatype_name: datatype name
187 *
188 * .. code-block:: c
189 *
190 * FIXTURE_DATA(datatype name)
191 *
192 * This call may be used when the type of the fixture data
193 * is needed. In general, this should not be needed unless
194 * the *self* is being passed to a helper directly.
195 */
196 #define FIXTURE_DATA(datatype_name) struct _test_data_##datatype_name
197
198 /**
199 * FIXTURE(fixture_name) - Called once per fixture to setup the data and
200 * register
201 *
202 * @fixture_name: fixture name
203 *
204 * .. code-block:: c
205 *
206 * FIXTURE(datatype name) {
207 * type property1;
208 * ...
209 * };
210 *
211 * Defines the data provided to TEST_F()-defined tests as *self*. It should be
212 * populated and cleaned up using FIXTURE_SETUP() and FIXTURE_TEARDOWN().
213 */
214 #define FIXTURE(fixture_name) \
215 static void __attribute__((constructor)) \
216 _register_##fixture_name##_data(void) \
217 { \
218 __fixture_count++; \
219 } \
220 FIXTURE_DATA(fixture_name)
221
222 /**
223 * FIXTURE_SETUP(fixture_name) - Prepares the setup function for the fixture.
224 * *_metadata* is included so that EXPECT_* and ASSERT_* work correctly.
225 *
226 * @fixture_name: fixture name
227 *
228 * .. code-block:: c
229 *
230 * FIXTURE_SETUP(fixture name) { implementation }
231 *
232 * Populates the required "setup" function for a fixture. An instance of the
233 * datatype defined with FIXTURE_DATA() will be exposed as *self* for the
234 * implementation.
235 *
236 * ASSERT_* are valid for use in this context and will prempt the execution
237 * of any dependent fixture tests.
238 *
239 * A bare "return;" statement may be used to return early.
240 */
241 #define FIXTURE_SETUP(fixture_name) \
242 void fixture_name##_setup( \
243 struct __test_metadata __attribute__((unused)) *_metadata, \
244 FIXTURE_DATA(fixture_name) __attribute__((unused)) *self)
245 /**
246 * FIXTURE_TEARDOWN(fixture_name)
247 * *_metadata* is included so that EXPECT_* and ASSERT_* work correctly.
248 *
249 * @fixture_name: fixture name
250 *
251 * .. code-block:: c
252 *
253 * FIXTURE_TEARDOWN(fixture name) { implementation }
254 *
255 * Populates the required "teardown" function for a fixture. An instance of the
256 * datatype defined with FIXTURE_DATA() will be exposed as *self* for the
257 * implementation to clean up.
258 *
259 * A bare "return;" statement may be used to return early.
260 */
261 #define FIXTURE_TEARDOWN(fixture_name) \
262 void fixture_name##_teardown( \
263 struct __test_metadata __attribute__((unused)) *_metadata, \
264 FIXTURE_DATA(fixture_name) __attribute__((unused)) *self)
265
266 /**
267 * TEST_F(fixture_name, test_name) - Emits test registration and helpers for
268 * fixture-based test cases
269 *
270 * @fixture_name: fixture name
271 * @test_name: test name
272 *
273 * .. code-block:: c
274 *
275 * TEST_F(fixture, name) { implementation }
276 *
277 * Defines a test that depends on a fixture (e.g., is part of a test case).
278 * Very similar to TEST() except that *self* is the setup instance of fixture's
279 * datatype exposed for use by the implementation.
280 *
281 * Warning: use of ASSERT_* here will skip TEARDOWN.
282 */
283 /* TODO(wad) register fixtures on dedicated test lists. */
284 #define TEST_F(fixture_name, test_name) \
285 __TEST_F_IMPL(fixture_name, test_name, -1, TEST_TIMEOUT_DEFAULT)
286
287 #define TEST_F_SIGNAL(fixture_name, test_name, signal) \
288 __TEST_F_IMPL(fixture_name, test_name, signal, TEST_TIMEOUT_DEFAULT)
289
290 #define TEST_F_TIMEOUT(fixture_name, test_name, timeout) \
291 __TEST_F_IMPL(fixture_name, test_name, -1, timeout)
292
293 #define __TEST_F_IMPL(fixture_name, test_name, signal, tmout) \
294 static void fixture_name##_##test_name( \
295 struct __test_metadata *_metadata, \
296 FIXTURE_DATA(fixture_name) *self); \
297 static inline void wrapper_##fixture_name##_##test_name( \
298 struct __test_metadata *_metadata) \
299 { \
300 /* fixture data is alloced, setup, and torn down per call. */ \
301 FIXTURE_DATA(fixture_name) self; \
302 memset(&self, 0, sizeof(FIXTURE_DATA(fixture_name))); \
303 fixture_name##_setup(_metadata, &self); \
304 /* Let setup failure terminate early. */ \
305 if (!_metadata->passed) \
306 return; \
307 fixture_name##_##test_name(_metadata, &self); \
308 fixture_name##_teardown(_metadata, &self); \
309 } \
310 static struct __test_metadata \
311 _##fixture_name##_##test_name##_object = { \
312 .name = #fixture_name "." #test_name, \
313 .fn = &wrapper_##fixture_name##_##test_name, \
314 .termsig = signal, \
315 .timeout = tmout, \
316 }; \
317 static void __attribute__((constructor)) \
318 _register_##fixture_name##_##test_name(void) \
319 { \
320 __register_test(&_##fixture_name##_##test_name##_object); \
321 } \
322 static void fixture_name##_##test_name( \
323 struct __test_metadata __attribute__((unused)) *_metadata, \
324 FIXTURE_DATA(fixture_name) __attribute__((unused)) *self)
325
326 /**
327 * TEST_HARNESS_MAIN - Simple wrapper to run the test harness
328 *
329 * .. code-block:: c
330 *
331 * TEST_HARNESS_MAIN
332 *
333 * Use once to append a main() to the test file.
334 */
335 #define TEST_HARNESS_MAIN \
336 static void __attribute__((constructor)) \
337 __constructor_order_last(void) \
338 { \
339 if (!__constructor_order) \
340 __constructor_order = _CONSTRUCTOR_ORDER_BACKWARD; \
341 } \
342 int main(int argc, char **argv) { \
343 return test_harness_run(argc, argv); \
344 }
345
346 /**
347 * DOC: operators
348 *
349 * Operators for use in TEST() and TEST_F().
350 * ASSERT_* calls will stop test execution immediately.
351 * EXPECT_* calls will emit a failure warning, note it, and continue.
352 */
353
354 /**
355 * ASSERT_EQ(expected, seen)
356 *
357 * @expected: expected value
358 * @seen: measured value
359 *
360 * ASSERT_EQ(expected, measured): expected == measured
361 */
362 #define ASSERT_EQ(expected, seen) \
363 __EXPECT(expected, #expected, seen, #seen, ==, 1)
364
365 /**
366 * ASSERT_NE(expected, seen)
367 *
368 * @expected: expected value
369 * @seen: measured value
370 *
371 * ASSERT_NE(expected, measured): expected != measured
372 */
373 #define ASSERT_NE(expected, seen) \
374 __EXPECT(expected, #expected, seen, #seen, !=, 1)
375
376 /**
377 * ASSERT_LT(expected, seen)
378 *
379 * @expected: expected value
380 * @seen: measured value
381 *
382 * ASSERT_LT(expected, measured): expected < measured
383 */
384 #define ASSERT_LT(expected, seen) \
385 __EXPECT(expected, #expected, seen, #seen, <, 1)
386
387 /**
388 * ASSERT_LE(expected, seen)
389 *
390 * @expected: expected value
391 * @seen: measured value
392 *
393 * ASSERT_LE(expected, measured): expected <= measured
394 */
395 #define ASSERT_LE(expected, seen) \
396 __EXPECT(expected, #expected, seen, #seen, <=, 1)
397
398 /**
399 * ASSERT_GT(expected, seen)
400 *
401 * @expected: expected value
402 * @seen: measured value
403 *
404 * ASSERT_GT(expected, measured): expected > measured
405 */
406 #define ASSERT_GT(expected, seen) \
407 __EXPECT(expected, #expected, seen, #seen, >, 1)
408
409 /**
410 * ASSERT_GE(expected, seen)
411 *
412 * @expected: expected value
413 * @seen: measured value
414 *
415 * ASSERT_GE(expected, measured): expected >= measured
416 */
417 #define ASSERT_GE(expected, seen) \
418 __EXPECT(expected, #expected, seen, #seen, >=, 1)
419
420 /**
421 * ASSERT_NULL(seen)
422 *
423 * @seen: measured value
424 *
425 * ASSERT_NULL(measured): NULL == measured
426 */
427 #define ASSERT_NULL(seen) \
428 __EXPECT(NULL, "NULL", seen, #seen, ==, 1)
429
430 /**
431 * ASSERT_TRUE(seen)
432 *
433 * @seen: measured value
434 *
435 * ASSERT_TRUE(measured): measured != 0
436 */
437 #define ASSERT_TRUE(seen) \
438 __EXPECT(0, "0", seen, #seen, !=, 1)
439
440 /**
441 * ASSERT_FALSE(seen)
442 *
443 * @seen: measured value
444 *
445 * ASSERT_FALSE(measured): measured == 0
446 */
447 #define ASSERT_FALSE(seen) \
448 __EXPECT(0, "0", seen, #seen, ==, 1)
449
450 /**
451 * ASSERT_STREQ(expected, seen)
452 *
453 * @expected: expected value
454 * @seen: measured value
455 *
456 * ASSERT_STREQ(expected, measured): !strcmp(expected, measured)
457 */
458 #define ASSERT_STREQ(expected, seen) \
459 __EXPECT_STR(expected, seen, ==, 1)
460
461 /**
462 * ASSERT_STRNE(expected, seen)
463 *
464 * @expected: expected value
465 * @seen: measured value
466 *
467 * ASSERT_STRNE(expected, measured): strcmp(expected, measured)
468 */
469 #define ASSERT_STRNE(expected, seen) \
470 __EXPECT_STR(expected, seen, !=, 1)
471
472 /**
473 * EXPECT_EQ(expected, seen)
474 *
475 * @expected: expected value
476 * @seen: measured value
477 *
478 * EXPECT_EQ(expected, measured): expected == measured
479 */
480 #define EXPECT_EQ(expected, seen) \
481 __EXPECT(expected, #expected, seen, #seen, ==, 0)
482
483 /**
484 * EXPECT_NE(expected, seen)
485 *
486 * @expected: expected value
487 * @seen: measured value
488 *
489 * EXPECT_NE(expected, measured): expected != measured
490 */
491 #define EXPECT_NE(expected, seen) \
492 __EXPECT(expected, #expected, seen, #seen, !=, 0)
493
494 /**
495 * EXPECT_LT(expected, seen)
496 *
497 * @expected: expected value
498 * @seen: measured value
499 *
500 * EXPECT_LT(expected, measured): expected < measured
501 */
502 #define EXPECT_LT(expected, seen) \
503 __EXPECT(expected, #expected, seen, #seen, <, 0)
504
505 /**
506 * EXPECT_LE(expected, seen)
507 *
508 * @expected: expected value
509 * @seen: measured value
510 *
511 * EXPECT_LE(expected, measured): expected <= measured
512 */
513 #define EXPECT_LE(expected, seen) \
514 __EXPECT(expected, #expected, seen, #seen, <=, 0)
515
516 /**
517 * EXPECT_GT(expected, seen)
518 *
519 * @expected: expected value
520 * @seen: measured value
521 *
522 * EXPECT_GT(expected, measured): expected > measured
523 */
524 #define EXPECT_GT(expected, seen) \
525 __EXPECT(expected, #expected, seen, #seen, >, 0)
526
527 /**
528 * EXPECT_GE(expected, seen)
529 *
530 * @expected: expected value
531 * @seen: measured value
532 *
533 * EXPECT_GE(expected, measured): expected >= measured
534 */
535 #define EXPECT_GE(expected, seen) \
536 __EXPECT(expected, #expected, seen, #seen, >=, 0)
537
538 /**
539 * EXPECT_NULL(seen)
540 *
541 * @seen: measured value
542 *
543 * EXPECT_NULL(measured): NULL == measured
544 */
545 #define EXPECT_NULL(seen) \
546 __EXPECT(NULL, "NULL", seen, #seen, ==, 0)
547
548 /**
549 * EXPECT_TRUE(seen)
550 *
551 * @seen: measured value
552 *
553 * EXPECT_TRUE(measured): 0 != measured
554 */
555 #define EXPECT_TRUE(seen) \
556 __EXPECT(0, "0", seen, #seen, !=, 0)
557
558 /**
559 * EXPECT_FALSE(seen)
560 *
561 * @seen: measured value
562 *
563 * EXPECT_FALSE(measured): 0 == measured
564 */
565 #define EXPECT_FALSE(seen) \
566 __EXPECT(0, "0", seen, #seen, ==, 0)
567
568 /**
569 * EXPECT_STREQ(expected, seen)
570 *
571 * @expected: expected value
572 * @seen: measured value
573 *
574 * EXPECT_STREQ(expected, measured): !strcmp(expected, measured)
575 */
576 #define EXPECT_STREQ(expected, seen) \
577 __EXPECT_STR(expected, seen, ==, 0)
578
579 /**
580 * EXPECT_STRNE(expected, seen)
581 *
582 * @expected: expected value
583 * @seen: measured value
584 *
585 * EXPECT_STRNE(expected, measured): strcmp(expected, measured)
586 */
587 #define EXPECT_STRNE(expected, seen) \
588 __EXPECT_STR(expected, seen, !=, 0)
589
590 #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
591
592 /* Support an optional handler after and ASSERT_* or EXPECT_*. The approach is
593 * not thread-safe, but it should be fine in most sane test scenarios.
594 *
595 * Using __bail(), which optionally abort()s, is the easiest way to early
596 * return while still providing an optional block to the API consumer.
597 */
598 #define OPTIONAL_HANDLER(_assert) \
599 for (; _metadata->trigger; _metadata->trigger = \
600 __bail(_assert, _metadata->no_print, _metadata->step))
601
602 #define __INC_STEP(_metadata) \
603 if (_metadata->passed && _metadata->step < 255) \
604 _metadata->step++;
605
606 #define __EXPECT(_expected, _expected_str, _seen, _seen_str, _t, _assert) do { \
607 /* Avoid multiple evaluation of the cases */ \
608 __typeof__(_expected) __exp = (_expected); \
609 __typeof__(_seen) __seen = (_seen); \
610 if (_assert) __INC_STEP(_metadata); \
611 if (!(__exp _t __seen)) { \
612 unsigned long long __exp_print = (uintptr_t)__exp; \
613 unsigned long long __seen_print = (uintptr_t)__seen; \
614 __TH_LOG("Expected %s (%llu) %s %s (%llu)", \
615 _expected_str, __exp_print, #_t, \
616 _seen_str, __seen_print); \
617 _metadata->passed = 0; \
618 /* Ensure the optional handler is triggered */ \
619 _metadata->trigger = 1; \
620 } \
621 } while (0); OPTIONAL_HANDLER(_assert)
622
623 #define __EXPECT_STR(_expected, _seen, _t, _assert) do { \
624 const char *__exp = (_expected); \
625 const char *__seen = (_seen); \
626 if (_assert) __INC_STEP(_metadata); \
627 if (!(strcmp(__exp, __seen) _t 0)) { \
628 __TH_LOG("Expected '%s' %s '%s'.", __exp, #_t, __seen); \
629 _metadata->passed = 0; \
630 _metadata->trigger = 1; \
631 } \
632 } while (0); OPTIONAL_HANDLER(_assert)
633
634 /* Contains all the information for test execution and status checking. */
635 struct __test_metadata {
636 const char *name;
637 void (*fn)(struct __test_metadata *);
638 int termsig;
639 int passed;
640 int trigger; /* extra handler after the evaluation */
641 int timeout;
642 __u8 step;
643 bool no_print; /* manual trigger when TH_LOG_STREAM is not available */
644 struct __test_metadata *prev, *next;
645 };
646
647 /* Storage for the (global) tests to be run. */
648 static struct __test_metadata *__test_list;
649 static unsigned int __test_count;
650 static unsigned int __fixture_count;
651 static int __constructor_order;
652
653 #define _CONSTRUCTOR_ORDER_FORWARD 1
654 #define _CONSTRUCTOR_ORDER_BACKWARD -1
655
656 /*
657 * Since constructors are called in reverse order, reverse the test
658 * list so tests are run in source declaration order.
659 * https://gcc.gnu.org/onlinedocs/gccint/Initialization.html
660 * However, it seems not all toolchains do this correctly, so use
661 * __constructor_order to detect which direction is called first
662 * and adjust list building logic to get things running in the right
663 * direction.
664 */
__register_test(struct __test_metadata * t)665 static inline void __register_test(struct __test_metadata *t)
666 {
667 __test_count++;
668 /* Circular linked list where only prev is circular. */
669 if (__test_list == NULL) {
670 __test_list = t;
671 t->next = NULL;
672 t->prev = t;
673 return;
674 }
675 if (__constructor_order == _CONSTRUCTOR_ORDER_FORWARD) {
676 t->next = NULL;
677 t->prev = __test_list->prev;
678 t->prev->next = t;
679 __test_list->prev = t;
680 } else {
681 t->next = __test_list;
682 t->next->prev = t;
683 t->prev = t;
684 __test_list = t;
685 }
686 }
687
__bail(int for_realz,bool no_print,__u8 step)688 static inline int __bail(int for_realz, bool no_print, __u8 step)
689 {
690 if (for_realz) {
691 if (no_print)
692 _exit(step);
693 abort();
694 }
695 return 0;
696 }
697
__run_test(struct __test_metadata * t)698 void __run_test(struct __test_metadata *t)
699 {
700 pid_t child_pid;
701 int status;
702
703 t->passed = 1;
704 t->trigger = 0;
705 printf("[ RUN ] %s\n", t->name);
706 alarm(t->timeout);
707 child_pid = fork();
708 if (child_pid < 0) {
709 printf("ERROR SPAWNING TEST CHILD\n");
710 t->passed = 0;
711 } else if (child_pid == 0) {
712 t->fn(t);
713 /* return the step that failed or 0 */
714 _exit(t->passed ? 0 : t->step);
715 } else {
716 /* TODO(wad) add timeout support. */
717 waitpid(child_pid, &status, 0);
718 if (WIFEXITED(status)) {
719 t->passed = t->termsig == -1 ? !WEXITSTATUS(status) : 0;
720 if (t->termsig != -1) {
721 fprintf(TH_LOG_STREAM,
722 "%s: Test exited normally "
723 "instead of by signal (code: %d)\n",
724 t->name,
725 WEXITSTATUS(status));
726 } else if (!t->passed) {
727 fprintf(TH_LOG_STREAM,
728 "%s: Test failed at step #%d\n",
729 t->name,
730 WEXITSTATUS(status));
731 }
732 } else if (WIFSIGNALED(status)) {
733 t->passed = 0;
734 if (WTERMSIG(status) == SIGABRT) {
735 fprintf(TH_LOG_STREAM,
736 "%s: Test terminated by assertion\n",
737 t->name);
738 } else if (WTERMSIG(status) == t->termsig) {
739 t->passed = 1;
740 } else {
741 fprintf(TH_LOG_STREAM,
742 "%s: Test terminated unexpectedly "
743 "by signal %d\n",
744 t->name,
745 WTERMSIG(status));
746 }
747 } else {
748 fprintf(TH_LOG_STREAM,
749 "%s: Test ended in some other way [%u]\n",
750 t->name,
751 status);
752 }
753 }
754 printf("[ %4s ] %s\n", (t->passed ? "OK" : "FAIL"), t->name);
755 alarm(0);
756 }
757
test_harness_run(int argc,char ** argv)758 static int test_harness_run(int __attribute__((unused)) argc,
759 char __attribute__((unused)) **argv)
760 {
761 struct __test_metadata *t;
762 int ret = 0;
763 unsigned int count = 0;
764 unsigned int pass_count = 0;
765
766 /* TODO(wad) add optional arguments similar to gtest. */
767 printf("[==========] Running %u tests from %u test cases.\n",
768 __test_count, __fixture_count + 1);
769 for (t = __test_list; t; t = t->next) {
770 count++;
771 __run_test(t);
772 if (t->passed)
773 pass_count++;
774 else
775 ret = 1;
776 }
777 printf("[==========] %u / %u tests passed.\n", pass_count, count);
778 printf("[ %s ]\n", (ret ? "FAILED" : "PASSED"));
779 return ret;
780 }
781
__constructor_order_first(void)782 static void __attribute__((constructor)) __constructor_order_first(void)
783 {
784 if (!__constructor_order)
785 __constructor_order = _CONSTRUCTOR_ORDER_FORWARD;
786 }
787
788 #endif /* __KSELFTEST_HARNESS_H */
789
