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