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