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, 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, 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, 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, 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, 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, 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, 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 ASSERT_NE(0, seen) 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 ASSERT_EQ(0, seen) 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, 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, 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, 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, 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, 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, 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, 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_NE(0, seen) 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_EQ(0, seen) 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, _seen, _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, __exp_print, #_t, \ 586 #_seen, __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 */ 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 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 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 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 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