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 #ifndef _GNU_SOURCE 54 #define _GNU_SOURCE 55 #endif 56 #include <asm/types.h> 57 #include <errno.h> 58 #include <stdbool.h> 59 #include <stdint.h> 60 #include <stdio.h> 61 #include <stdlib.h> 62 #include <string.h> 63 #include <sys/mman.h> 64 #include <sys/types.h> 65 #include <sys/wait.h> 66 #include <unistd.h> 67 68 #include "kselftest.h" 69 70 #define TEST_TIMEOUT_DEFAULT 30 71 72 /* Utilities exposed to the test definitions */ 73 #ifndef TH_LOG_STREAM 74 # define TH_LOG_STREAM stderr 75 #endif 76 77 #ifndef TH_LOG_ENABLED 78 # define TH_LOG_ENABLED 1 79 #endif 80 81 /** 82 * TH_LOG() 83 * 84 * @fmt: format string 85 * @...: optional arguments 86 * 87 * .. code-block:: c 88 * 89 * TH_LOG(format, ...) 90 * 91 * Optional debug logging function available for use in tests. 92 * Logging may be enabled or disabled by defining TH_LOG_ENABLED. 93 * E.g., #define TH_LOG_ENABLED 1 94 * 95 * If no definition is provided, logging is enabled by default. 96 * 97 * If there is no way to print an error message for the process running the 98 * test (e.g. not allowed to write to stderr), it is still possible to get the 99 * ASSERT_* number for which the test failed. This behavior can be enabled by 100 * writing `_metadata->no_print = true;` before the check sequence that is 101 * unable to print. When an error occur, instead of printing an error message 102 * and calling `abort(3)`, the test process call `_exit(2)` with the assert 103 * number as argument, which is then printed by the parent process. 104 */ 105 #define TH_LOG(fmt, ...) do { \ 106 if (TH_LOG_ENABLED) \ 107 __TH_LOG(fmt, ##__VA_ARGS__); \ 108 } while (0) 109 110 /* Unconditional logger for internal use. */ 111 #define __TH_LOG(fmt, ...) \ 112 fprintf(TH_LOG_STREAM, "# %s:%d:%s:" fmt "\n", \ 113 __FILE__, __LINE__, _metadata->name, ##__VA_ARGS__) 114 115 /** 116 * SKIP() 117 * 118 * @statement: statement to run after reporting SKIP 119 * @fmt: format string 120 * @...: optional arguments 121 * 122 * .. code-block:: c 123 * 124 * SKIP(statement, fmt, ...); 125 * 126 * This forces a "pass" after reporting why something is being skipped 127 * and runs "statement", which is usually "return" or "goto skip". 128 */ 129 #define SKIP(statement, fmt, ...) do { \ 130 snprintf(_metadata->results->reason, \ 131 sizeof(_metadata->results->reason), fmt, ##__VA_ARGS__); \ 132 if (TH_LOG_ENABLED) { \ 133 fprintf(TH_LOG_STREAM, "# SKIP %s\n", \ 134 _metadata->results->reason); \ 135 } \ 136 _metadata->passed = 1; \ 137 _metadata->skip = 1; \ 138 _metadata->trigger = 0; \ 139 statement; \ 140 } while (0) 141 142 /** 143 * TEST() - Defines the test function and creates the registration 144 * stub 145 * 146 * @test_name: test name 147 * 148 * .. code-block:: c 149 * 150 * TEST(name) { implementation } 151 * 152 * Defines a test by name. 153 * Names must be unique and tests must not be run in parallel. The 154 * implementation containing block is a function and scoping should be treated 155 * as such. Returning early may be performed with a bare "return;" statement. 156 * 157 * EXPECT_* and ASSERT_* are valid in a TEST() { } context. 158 */ 159 #define TEST(test_name) __TEST_IMPL(test_name, -1) 160 161 /** 162 * TEST_SIGNAL() 163 * 164 * @test_name: test name 165 * @signal: signal number 166 * 167 * .. code-block:: c 168 * 169 * TEST_SIGNAL(name, signal) { implementation } 170 * 171 * Defines a test by name and the expected term signal. 172 * Names must be unique and tests must not be run in parallel. The 173 * implementation containing block is a function and scoping should be treated 174 * as such. Returning early may be performed with a bare "return;" statement. 175 * 176 * EXPECT_* and ASSERT_* are valid in a TEST() { } context. 177 */ 178 #define TEST_SIGNAL(test_name, signal) __TEST_IMPL(test_name, signal) 179 180 #define __TEST_IMPL(test_name, _signal) \ 181 static void test_name(struct __test_metadata *_metadata); \ 182 static inline void wrapper_##test_name( \ 183 struct __test_metadata *_metadata, \ 184 struct __fixture_variant_metadata *variant) \ 185 { \ 186 test_name(_metadata); \ 187 } \ 188 static struct __test_metadata _##test_name##_object = \ 189 { .name = #test_name, \ 190 .fn = &wrapper_##test_name, \ 191 .fixture = &_fixture_global, \ 192 .termsig = _signal, \ 193 .timeout = TEST_TIMEOUT_DEFAULT, }; \ 194 static void __attribute__((constructor)) _register_##test_name(void) \ 195 { \ 196 __register_test(&_##test_name##_object); \ 197 } \ 198 static void test_name( \ 199 struct __test_metadata __attribute__((unused)) *_metadata) 200 201 /** 202 * FIXTURE_DATA() - Wraps the struct name so we have one less 203 * argument to pass around 204 * 205 * @datatype_name: datatype name 206 * 207 * .. code-block:: c 208 * 209 * FIXTURE_DATA(datatype_name) 210 * 211 * Almost always, you want just FIXTURE() instead (see below). 212 * This call may be used when the type of the fixture data 213 * is needed. In general, this should not be needed unless 214 * the *self* is being passed to a helper directly. 215 */ 216 #define FIXTURE_DATA(datatype_name) struct _test_data_##datatype_name 217 218 /** 219 * FIXTURE() - Called once per fixture to setup the data and 220 * register 221 * 222 * @fixture_name: fixture name 223 * 224 * .. code-block:: c 225 * 226 * FIXTURE(fixture_name) { 227 * type property1; 228 * ... 229 * }; 230 * 231 * Defines the data provided to TEST_F()-defined tests as *self*. It should be 232 * populated and cleaned up using FIXTURE_SETUP() and FIXTURE_TEARDOWN(). 233 */ 234 #define FIXTURE(fixture_name) \ 235 FIXTURE_VARIANT(fixture_name); \ 236 static struct __fixture_metadata _##fixture_name##_fixture_object = \ 237 { .name = #fixture_name, }; \ 238 static void __attribute__((constructor)) \ 239 _register_##fixture_name##_data(void) \ 240 { \ 241 __register_fixture(&_##fixture_name##_fixture_object); \ 242 } \ 243 FIXTURE_DATA(fixture_name) 244 245 /** 246 * FIXTURE_SETUP() - Prepares the setup function for the fixture. 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_SETUP(fixture_name) { implementation } 254 * 255 * Populates the required "setup" function for a fixture. An instance of the 256 * datatype defined with FIXTURE_DATA() will be exposed as *self* for the 257 * implementation. 258 * 259 * ASSERT_* are valid for use in this context and will prempt the execution 260 * of any dependent fixture tests. 261 * 262 * A bare "return;" statement may be used to return early. 263 */ 264 #define FIXTURE_SETUP(fixture_name) \ 265 void fixture_name##_setup( \ 266 struct __test_metadata __attribute__((unused)) *_metadata, \ 267 FIXTURE_DATA(fixture_name) __attribute__((unused)) *self, \ 268 const FIXTURE_VARIANT(fixture_name) \ 269 __attribute__((unused)) *variant) 270 271 /** 272 * FIXTURE_TEARDOWN() 273 * *_metadata* is included so that EXPECT_* and ASSERT_* work correctly. 274 * 275 * @fixture_name: fixture name 276 * 277 * .. code-block:: c 278 * 279 * FIXTURE_TEARDOWN(fixture_name) { implementation } 280 * 281 * Populates the required "teardown" function for a fixture. An instance of the 282 * datatype defined with FIXTURE_DATA() will be exposed as *self* for the 283 * implementation to clean up. 284 * 285 * A bare "return;" statement may be used to return early. 286 */ 287 #define FIXTURE_TEARDOWN(fixture_name) \ 288 void fixture_name##_teardown( \ 289 struct __test_metadata __attribute__((unused)) *_metadata, \ 290 FIXTURE_DATA(fixture_name) __attribute__((unused)) *self) 291 292 /** 293 * FIXTURE_VARIANT() - Optionally called once per fixture 294 * to declare fixture variant 295 * 296 * @fixture_name: fixture name 297 * 298 * .. code-block:: c 299 * 300 * FIXTURE_VARIANT(fixture_name) { 301 * type property1; 302 * ... 303 * }; 304 * 305 * Defines type of constant parameters provided to FIXTURE_SETUP() and TEST_F() 306 * as *variant*. Variants allow the same tests to be run with different 307 * arguments. 308 */ 309 #define FIXTURE_VARIANT(fixture_name) struct _fixture_variant_##fixture_name 310 311 /** 312 * FIXTURE_VARIANT_ADD() - Called once per fixture 313 * variant to setup and register the data 314 * 315 * @fixture_name: fixture name 316 * @variant_name: name of the parameter set 317 * 318 * .. code-block:: c 319 * 320 * FIXTURE_VARIANT_ADD(fixture_name, variant_name) { 321 * .property1 = val1, 322 * ... 323 * }; 324 * 325 * Defines a variant of the test fixture, provided to FIXTURE_SETUP() and 326 * TEST_F() as *variant*. Tests of each fixture will be run once for each 327 * variant. 328 */ 329 #define FIXTURE_VARIANT_ADD(fixture_name, variant_name) \ 330 extern FIXTURE_VARIANT(fixture_name) \ 331 _##fixture_name##_##variant_name##_variant; \ 332 static struct __fixture_variant_metadata \ 333 _##fixture_name##_##variant_name##_object = \ 334 { .name = #variant_name, \ 335 .data = &_##fixture_name##_##variant_name##_variant}; \ 336 static void __attribute__((constructor)) \ 337 _register_##fixture_name##_##variant_name(void) \ 338 { \ 339 __register_fixture_variant(&_##fixture_name##_fixture_object, \ 340 &_##fixture_name##_##variant_name##_object); \ 341 } \ 342 FIXTURE_VARIANT(fixture_name) \ 343 _##fixture_name##_##variant_name##_variant = 344 345 /** 346 * TEST_F() - Emits test registration and helpers for 347 * fixture-based test cases 348 * 349 * @fixture_name: fixture name 350 * @test_name: test name 351 * 352 * .. code-block:: c 353 * 354 * TEST_F(fixture, name) { implementation } 355 * 356 * Defines a test that depends on a fixture (e.g., is part of a test case). 357 * Very similar to TEST() except that *self* is the setup instance of fixture's 358 * datatype exposed for use by the implementation. 359 * 360 * Warning: use of ASSERT_* here will skip TEARDOWN. 361 */ 362 /* TODO(wad) register fixtures on dedicated test lists. */ 363 #define TEST_F(fixture_name, test_name) \ 364 __TEST_F_IMPL(fixture_name, test_name, -1, TEST_TIMEOUT_DEFAULT) 365 366 #define TEST_F_SIGNAL(fixture_name, test_name, signal) \ 367 __TEST_F_IMPL(fixture_name, test_name, signal, TEST_TIMEOUT_DEFAULT) 368 369 #define TEST_F_TIMEOUT(fixture_name, test_name, timeout) \ 370 __TEST_F_IMPL(fixture_name, test_name, -1, timeout) 371 372 #define __TEST_F_IMPL(fixture_name, test_name, signal, tmout) \ 373 static void fixture_name##_##test_name( \ 374 struct __test_metadata *_metadata, \ 375 FIXTURE_DATA(fixture_name) *self, \ 376 const FIXTURE_VARIANT(fixture_name) *variant); \ 377 static inline void wrapper_##fixture_name##_##test_name( \ 378 struct __test_metadata *_metadata, \ 379 struct __fixture_variant_metadata *variant) \ 380 { \ 381 /* fixture data is alloced, setup, and torn down per call. */ \ 382 FIXTURE_DATA(fixture_name) self; \ 383 memset(&self, 0, sizeof(FIXTURE_DATA(fixture_name))); \ 384 fixture_name##_setup(_metadata, &self, variant->data); \ 385 /* Let setup failure terminate early. */ \ 386 if (!_metadata->passed) \ 387 return; \ 388 fixture_name##_##test_name(_metadata, &self, variant->data); \ 389 fixture_name##_teardown(_metadata, &self); \ 390 } \ 391 static struct __test_metadata \ 392 _##fixture_name##_##test_name##_object = { \ 393 .name = #test_name, \ 394 .fn = &wrapper_##fixture_name##_##test_name, \ 395 .fixture = &_##fixture_name##_fixture_object, \ 396 .termsig = signal, \ 397 .timeout = tmout, \ 398 }; \ 399 static void __attribute__((constructor)) \ 400 _register_##fixture_name##_##test_name(void) \ 401 { \ 402 __register_test(&_##fixture_name##_##test_name##_object); \ 403 } \ 404 static void fixture_name##_##test_name( \ 405 struct __test_metadata __attribute__((unused)) *_metadata, \ 406 FIXTURE_DATA(fixture_name) __attribute__((unused)) *self, \ 407 const FIXTURE_VARIANT(fixture_name) \ 408 __attribute__((unused)) *variant) 409 410 /** 411 * TEST_HARNESS_MAIN - Simple wrapper to run the test harness 412 * 413 * .. code-block:: c 414 * 415 * TEST_HARNESS_MAIN 416 * 417 * Use once to append a main() to the test file. 418 */ 419 #define TEST_HARNESS_MAIN \ 420 static void __attribute__((constructor)) \ 421 __constructor_order_last(void) \ 422 { \ 423 if (!__constructor_order) \ 424 __constructor_order = _CONSTRUCTOR_ORDER_BACKWARD; \ 425 } \ 426 int main(int argc, char **argv) { \ 427 return test_harness_run(argc, argv); \ 428 } 429 430 /** 431 * DOC: operators 432 * 433 * Operators for use in TEST() and TEST_F(). 434 * ASSERT_* calls will stop test execution immediately. 435 * EXPECT_* calls will emit a failure warning, note it, and continue. 436 */ 437 438 /** 439 * ASSERT_EQ() 440 * 441 * @expected: expected value 442 * @seen: measured value 443 * 444 * ASSERT_EQ(expected, measured): expected == measured 445 */ 446 #define ASSERT_EQ(expected, seen) \ 447 __EXPECT(expected, #expected, seen, #seen, ==, 1) 448 449 /** 450 * ASSERT_NE() 451 * 452 * @expected: expected value 453 * @seen: measured value 454 * 455 * ASSERT_NE(expected, measured): expected != measured 456 */ 457 #define ASSERT_NE(expected, seen) \ 458 __EXPECT(expected, #expected, seen, #seen, !=, 1) 459 460 /** 461 * ASSERT_LT() 462 * 463 * @expected: expected value 464 * @seen: measured value 465 * 466 * ASSERT_LT(expected, measured): expected < measured 467 */ 468 #define ASSERT_LT(expected, seen) \ 469 __EXPECT(expected, #expected, seen, #seen, <, 1) 470 471 /** 472 * ASSERT_LE() 473 * 474 * @expected: expected value 475 * @seen: measured value 476 * 477 * ASSERT_LE(expected, measured): expected <= measured 478 */ 479 #define ASSERT_LE(expected, seen) \ 480 __EXPECT(expected, #expected, seen, #seen, <=, 1) 481 482 /** 483 * ASSERT_GT() 484 * 485 * @expected: expected value 486 * @seen: measured value 487 * 488 * ASSERT_GT(expected, measured): expected > measured 489 */ 490 #define ASSERT_GT(expected, seen) \ 491 __EXPECT(expected, #expected, seen, #seen, >, 1) 492 493 /** 494 * ASSERT_GE() 495 * 496 * @expected: expected value 497 * @seen: measured value 498 * 499 * ASSERT_GE(expected, measured): expected >= measured 500 */ 501 #define ASSERT_GE(expected, seen) \ 502 __EXPECT(expected, #expected, seen, #seen, >=, 1) 503 504 /** 505 * ASSERT_NULL() 506 * 507 * @seen: measured value 508 * 509 * ASSERT_NULL(measured): NULL == measured 510 */ 511 #define ASSERT_NULL(seen) \ 512 __EXPECT(NULL, "NULL", seen, #seen, ==, 1) 513 514 /** 515 * ASSERT_TRUE() 516 * 517 * @seen: measured value 518 * 519 * ASSERT_TRUE(measured): measured != 0 520 */ 521 #define ASSERT_TRUE(seen) \ 522 __EXPECT(0, "0", seen, #seen, !=, 1) 523 524 /** 525 * ASSERT_FALSE() 526 * 527 * @seen: measured value 528 * 529 * ASSERT_FALSE(measured): measured == 0 530 */ 531 #define ASSERT_FALSE(seen) \ 532 __EXPECT(0, "0", seen, #seen, ==, 1) 533 534 /** 535 * ASSERT_STREQ() 536 * 537 * @expected: expected value 538 * @seen: measured value 539 * 540 * ASSERT_STREQ(expected, measured): !strcmp(expected, measured) 541 */ 542 #define ASSERT_STREQ(expected, seen) \ 543 __EXPECT_STR(expected, seen, ==, 1) 544 545 /** 546 * ASSERT_STRNE() 547 * 548 * @expected: expected value 549 * @seen: measured value 550 * 551 * ASSERT_STRNE(expected, measured): strcmp(expected, measured) 552 */ 553 #define ASSERT_STRNE(expected, seen) \ 554 __EXPECT_STR(expected, seen, !=, 1) 555 556 /** 557 * EXPECT_EQ() 558 * 559 * @expected: expected value 560 * @seen: measured value 561 * 562 * EXPECT_EQ(expected, measured): expected == measured 563 */ 564 #define EXPECT_EQ(expected, seen) \ 565 __EXPECT(expected, #expected, seen, #seen, ==, 0) 566 567 /** 568 * EXPECT_NE() 569 * 570 * @expected: expected value 571 * @seen: measured value 572 * 573 * EXPECT_NE(expected, measured): expected != measured 574 */ 575 #define EXPECT_NE(expected, seen) \ 576 __EXPECT(expected, #expected, seen, #seen, !=, 0) 577 578 /** 579 * EXPECT_LT() 580 * 581 * @expected: expected value 582 * @seen: measured value 583 * 584 * EXPECT_LT(expected, measured): expected < measured 585 */ 586 #define EXPECT_LT(expected, seen) \ 587 __EXPECT(expected, #expected, seen, #seen, <, 0) 588 589 /** 590 * EXPECT_LE() 591 * 592 * @expected: expected value 593 * @seen: measured value 594 * 595 * EXPECT_LE(expected, measured): expected <= measured 596 */ 597 #define EXPECT_LE(expected, seen) \ 598 __EXPECT(expected, #expected, seen, #seen, <=, 0) 599 600 /** 601 * EXPECT_GT() 602 * 603 * @expected: expected value 604 * @seen: measured value 605 * 606 * EXPECT_GT(expected, measured): expected > measured 607 */ 608 #define EXPECT_GT(expected, seen) \ 609 __EXPECT(expected, #expected, seen, #seen, >, 0) 610 611 /** 612 * EXPECT_GE() 613 * 614 * @expected: expected value 615 * @seen: measured value 616 * 617 * EXPECT_GE(expected, measured): expected >= measured 618 */ 619 #define EXPECT_GE(expected, seen) \ 620 __EXPECT(expected, #expected, seen, #seen, >=, 0) 621 622 /** 623 * EXPECT_NULL() 624 * 625 * @seen: measured value 626 * 627 * EXPECT_NULL(measured): NULL == measured 628 */ 629 #define EXPECT_NULL(seen) \ 630 __EXPECT(NULL, "NULL", seen, #seen, ==, 0) 631 632 /** 633 * EXPECT_TRUE() 634 * 635 * @seen: measured value 636 * 637 * EXPECT_TRUE(measured): 0 != measured 638 */ 639 #define EXPECT_TRUE(seen) \ 640 __EXPECT(0, "0", seen, #seen, !=, 0) 641 642 /** 643 * EXPECT_FALSE() 644 * 645 * @seen: measured value 646 * 647 * EXPECT_FALSE(measured): 0 == measured 648 */ 649 #define EXPECT_FALSE(seen) \ 650 __EXPECT(0, "0", seen, #seen, ==, 0) 651 652 /** 653 * EXPECT_STREQ() 654 * 655 * @expected: expected value 656 * @seen: measured value 657 * 658 * EXPECT_STREQ(expected, measured): !strcmp(expected, measured) 659 */ 660 #define EXPECT_STREQ(expected, seen) \ 661 __EXPECT_STR(expected, seen, ==, 0) 662 663 /** 664 * EXPECT_STRNE() 665 * 666 * @expected: expected value 667 * @seen: measured value 668 * 669 * EXPECT_STRNE(expected, measured): strcmp(expected, measured) 670 */ 671 #define EXPECT_STRNE(expected, seen) \ 672 __EXPECT_STR(expected, seen, !=, 0) 673 674 #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) 675 676 /* Support an optional handler after and ASSERT_* or EXPECT_*. The approach is 677 * not thread-safe, but it should be fine in most sane test scenarios. 678 * 679 * Using __bail(), which optionally abort()s, is the easiest way to early 680 * return while still providing an optional block to the API consumer. 681 */ 682 #define OPTIONAL_HANDLER(_assert) \ 683 for (; _metadata->trigger; _metadata->trigger = \ 684 __bail(_assert, _metadata->no_print, _metadata->step)) 685 686 #define __INC_STEP(_metadata) \ 687 /* Keep "step" below 255 (which is used for "SKIP" reporting). */ \ 688 if (_metadata->passed && _metadata->step < 253) \ 689 _metadata->step++; 690 691 #define is_signed_type(var) (!!(((__typeof__(var))(-1)) < (__typeof__(var))1)) 692 693 #define __EXPECT(_expected, _expected_str, _seen, _seen_str, _t, _assert) do { \ 694 /* Avoid multiple evaluation of the cases */ \ 695 __typeof__(_expected) __exp = (_expected); \ 696 __typeof__(_seen) __seen = (_seen); \ 697 if (_assert) __INC_STEP(_metadata); \ 698 if (!(__exp _t __seen)) { \ 699 /* Report with actual signedness to avoid weird output. */ \ 700 switch (is_signed_type(__exp) * 2 + is_signed_type(__seen)) { \ 701 case 0: { \ 702 unsigned long long __exp_print = (uintptr_t)__exp; \ 703 unsigned long long __seen_print = (uintptr_t)__seen; \ 704 __TH_LOG("Expected %s (%llu) %s %s (%llu)", \ 705 _expected_str, __exp_print, #_t, \ 706 _seen_str, __seen_print); \ 707 break; \ 708 } \ 709 case 1: { \ 710 unsigned long long __exp_print = (uintptr_t)__exp; \ 711 long long __seen_print = (intptr_t)__seen; \ 712 __TH_LOG("Expected %s (%llu) %s %s (%lld)", \ 713 _expected_str, __exp_print, #_t, \ 714 _seen_str, __seen_print); \ 715 break; \ 716 } \ 717 case 2: { \ 718 long long __exp_print = (intptr_t)__exp; \ 719 unsigned long long __seen_print = (uintptr_t)__seen; \ 720 __TH_LOG("Expected %s (%lld) %s %s (%llu)", \ 721 _expected_str, __exp_print, #_t, \ 722 _seen_str, __seen_print); \ 723 break; \ 724 } \ 725 case 3: { \ 726 long long __exp_print = (intptr_t)__exp; \ 727 long long __seen_print = (intptr_t)__seen; \ 728 __TH_LOG("Expected %s (%lld) %s %s (%lld)", \ 729 _expected_str, __exp_print, #_t, \ 730 _seen_str, __seen_print); \ 731 break; \ 732 } \ 733 } \ 734 _metadata->passed = 0; \ 735 /* Ensure the optional handler is triggered */ \ 736 _metadata->trigger = 1; \ 737 } \ 738 } while (0); OPTIONAL_HANDLER(_assert) 739 740 #define __EXPECT_STR(_expected, _seen, _t, _assert) do { \ 741 const char *__exp = (_expected); \ 742 const char *__seen = (_seen); \ 743 if (_assert) __INC_STEP(_metadata); \ 744 if (!(strcmp(__exp, __seen) _t 0)) { \ 745 __TH_LOG("Expected '%s' %s '%s'.", __exp, #_t, __seen); \ 746 _metadata->passed = 0; \ 747 _metadata->trigger = 1; \ 748 } \ 749 } while (0); OPTIONAL_HANDLER(_assert) 750 751 /* List helpers */ 752 #define __LIST_APPEND(head, item) \ 753 { \ 754 /* Circular linked list where only prev is circular. */ \ 755 if (head == NULL) { \ 756 head = item; \ 757 item->next = NULL; \ 758 item->prev = item; \ 759 return; \ 760 } \ 761 if (__constructor_order == _CONSTRUCTOR_ORDER_FORWARD) { \ 762 item->next = NULL; \ 763 item->prev = head->prev; \ 764 item->prev->next = item; \ 765 head->prev = item; \ 766 } else { \ 767 item->next = head; \ 768 item->next->prev = item; \ 769 item->prev = item; \ 770 head = item; \ 771 } \ 772 } 773 774 struct __test_results { 775 char reason[1024]; /* Reason for test result */ 776 }; 777 778 struct __test_metadata; 779 struct __fixture_variant_metadata; 780 781 /* Contains all the information about a fixture. */ 782 struct __fixture_metadata { 783 const char *name; 784 struct __test_metadata *tests; 785 struct __fixture_variant_metadata *variant; 786 struct __fixture_metadata *prev, *next; 787 } _fixture_global __attribute__((unused)) = { 788 .name = "global", 789 .prev = &_fixture_global, 790 }; 791 792 static struct __fixture_metadata *__fixture_list = &_fixture_global; 793 static int __constructor_order; 794 795 #define _CONSTRUCTOR_ORDER_FORWARD 1 796 #define _CONSTRUCTOR_ORDER_BACKWARD -1 797 798 static inline void __register_fixture(struct __fixture_metadata *f) 799 { 800 __LIST_APPEND(__fixture_list, f); 801 } 802 803 struct __fixture_variant_metadata { 804 const char *name; 805 const void *data; 806 struct __fixture_variant_metadata *prev, *next; 807 }; 808 809 static inline void 810 __register_fixture_variant(struct __fixture_metadata *f, 811 struct __fixture_variant_metadata *variant) 812 { 813 __LIST_APPEND(f->variant, variant); 814 } 815 816 /* Contains all the information for test execution and status checking. */ 817 struct __test_metadata { 818 const char *name; 819 void (*fn)(struct __test_metadata *, 820 struct __fixture_variant_metadata *); 821 pid_t pid; /* pid of test when being run */ 822 struct __fixture_metadata *fixture; 823 int termsig; 824 int passed; 825 int skip; /* did SKIP get used? */ 826 int trigger; /* extra handler after the evaluation */ 827 int timeout; /* seconds to wait for test timeout */ 828 bool timed_out; /* did this test timeout instead of exiting? */ 829 __u8 step; 830 bool no_print; /* manual trigger when TH_LOG_STREAM is not available */ 831 struct __test_results *results; 832 struct __test_metadata *prev, *next; 833 }; 834 835 /* 836 * Since constructors are called in reverse order, reverse the test 837 * list so tests are run in source declaration order. 838 * https://gcc.gnu.org/onlinedocs/gccint/Initialization.html 839 * However, it seems not all toolchains do this correctly, so use 840 * __constructor_order to detect which direction is called first 841 * and adjust list building logic to get things running in the right 842 * direction. 843 */ 844 static inline void __register_test(struct __test_metadata *t) 845 { 846 __LIST_APPEND(t->fixture->tests, t); 847 } 848 849 static inline int __bail(int for_realz, bool no_print, __u8 step) 850 { 851 if (for_realz) { 852 if (no_print) 853 _exit(step); 854 abort(); 855 } 856 return 0; 857 } 858 859 struct __test_metadata *__active_test; 860 static void __timeout_handler(int sig, siginfo_t *info, void *ucontext) 861 { 862 struct __test_metadata *t = __active_test; 863 864 /* Sanity check handler execution environment. */ 865 if (!t) { 866 fprintf(TH_LOG_STREAM, 867 "# no active test in SIGALRM handler!?\n"); 868 abort(); 869 } 870 if (sig != SIGALRM || sig != info->si_signo) { 871 fprintf(TH_LOG_STREAM, 872 "# %s: SIGALRM handler caught signal %d!?\n", 873 t->name, sig != SIGALRM ? sig : info->si_signo); 874 abort(); 875 } 876 877 t->timed_out = true; 878 kill(t->pid, SIGKILL); 879 } 880 881 void __wait_for_test(struct __test_metadata *t) 882 { 883 struct sigaction action = { 884 .sa_sigaction = __timeout_handler, 885 .sa_flags = SA_SIGINFO, 886 }; 887 struct sigaction saved_action; 888 int status; 889 890 if (sigaction(SIGALRM, &action, &saved_action)) { 891 t->passed = 0; 892 fprintf(TH_LOG_STREAM, 893 "# %s: unable to install SIGALRM handler\n", 894 t->name); 895 return; 896 } 897 __active_test = t; 898 t->timed_out = false; 899 alarm(t->timeout); 900 waitpid(t->pid, &status, 0); 901 alarm(0); 902 if (sigaction(SIGALRM, &saved_action, NULL)) { 903 t->passed = 0; 904 fprintf(TH_LOG_STREAM, 905 "# %s: unable to uninstall SIGALRM handler\n", 906 t->name); 907 return; 908 } 909 __active_test = NULL; 910 911 if (t->timed_out) { 912 t->passed = 0; 913 fprintf(TH_LOG_STREAM, 914 "# %s: Test terminated by timeout\n", t->name); 915 } else if (WIFEXITED(status)) { 916 if (t->termsig != -1) { 917 t->passed = 0; 918 fprintf(TH_LOG_STREAM, 919 "# %s: Test exited normally instead of by signal (code: %d)\n", 920 t->name, 921 WEXITSTATUS(status)); 922 } else { 923 switch (WEXITSTATUS(status)) { 924 /* Success */ 925 case 0: 926 t->passed = 1; 927 break; 928 /* SKIP */ 929 case 255: 930 t->passed = 1; 931 t->skip = 1; 932 break; 933 /* Other failure, assume step report. */ 934 default: 935 t->passed = 0; 936 fprintf(TH_LOG_STREAM, 937 "# %s: Test failed at step #%d\n", 938 t->name, 939 WEXITSTATUS(status)); 940 } 941 } 942 } else if (WIFSIGNALED(status)) { 943 t->passed = 0; 944 if (WTERMSIG(status) == SIGABRT) { 945 fprintf(TH_LOG_STREAM, 946 "# %s: Test terminated by assertion\n", 947 t->name); 948 } else if (WTERMSIG(status) == t->termsig) { 949 t->passed = 1; 950 } else { 951 fprintf(TH_LOG_STREAM, 952 "# %s: Test terminated unexpectedly by signal %d\n", 953 t->name, 954 WTERMSIG(status)); 955 } 956 } else { 957 fprintf(TH_LOG_STREAM, 958 "# %s: Test ended in some other way [%u]\n", 959 t->name, 960 status); 961 } 962 } 963 964 void __run_test(struct __fixture_metadata *f, 965 struct __fixture_variant_metadata *variant, 966 struct __test_metadata *t) 967 { 968 /* reset test struct */ 969 t->passed = 1; 970 t->skip = 0; 971 t->trigger = 0; 972 t->step = 0; 973 t->no_print = 0; 974 memset(t->results->reason, 0, sizeof(t->results->reason)); 975 976 ksft_print_msg(" RUN %s%s%s.%s ...\n", 977 f->name, variant->name[0] ? "." : "", variant->name, t->name); 978 979 /* Make sure output buffers are flushed before fork */ 980 fflush(stdout); 981 fflush(stderr); 982 983 t->pid = fork(); 984 if (t->pid < 0) { 985 ksft_print_msg("ERROR SPAWNING TEST CHILD\n"); 986 t->passed = 0; 987 } else if (t->pid == 0) { 988 t->fn(t, variant); 989 if (t->skip) 990 _exit(255); 991 /* Pass is exit 0 */ 992 if (t->passed) 993 _exit(0); 994 /* Something else happened, report the step. */ 995 _exit(t->step); 996 } else { 997 __wait_for_test(t); 998 } 999 ksft_print_msg(" %4s %s%s%s.%s\n", t->passed ? "OK" : "FAIL", 1000 f->name, variant->name[0] ? "." : "", variant->name, t->name); 1001 1002 if (t->skip) 1003 ksft_test_result_skip("%s\n", t->results->reason[0] ? 1004 t->results->reason : "unknown"); 1005 else 1006 ksft_test_result(t->passed, "%s%s%s.%s\n", 1007 f->name, variant->name[0] ? "." : "", variant->name, t->name); 1008 } 1009 1010 static int test_harness_run(int __attribute__((unused)) argc, 1011 char __attribute__((unused)) **argv) 1012 { 1013 struct __fixture_variant_metadata no_variant = { .name = "", }; 1014 struct __fixture_variant_metadata *v; 1015 struct __fixture_metadata *f; 1016 struct __test_results *results; 1017 struct __test_metadata *t; 1018 int ret = 0; 1019 unsigned int case_count = 0, test_count = 0; 1020 unsigned int count = 0; 1021 unsigned int pass_count = 0; 1022 1023 for (f = __fixture_list; f; f = f->next) { 1024 for (v = f->variant ?: &no_variant; v; v = v->next) { 1025 case_count++; 1026 for (t = f->tests; t; t = t->next) 1027 test_count++; 1028 } 1029 } 1030 1031 results = mmap(NULL, sizeof(*results), PROT_READ | PROT_WRITE, 1032 MAP_SHARED | MAP_ANONYMOUS, -1, 0); 1033 1034 ksft_print_header(); 1035 ksft_set_plan(test_count); 1036 ksft_print_msg("Starting %u tests from %u test cases.\n", 1037 test_count, case_count); 1038 for (f = __fixture_list; f; f = f->next) { 1039 for (v = f->variant ?: &no_variant; v; v = v->next) { 1040 for (t = f->tests; t; t = t->next) { 1041 count++; 1042 t->results = results; 1043 __run_test(f, v, t); 1044 t->results = NULL; 1045 if (t->passed) 1046 pass_count++; 1047 else 1048 ret = 1; 1049 } 1050 } 1051 } 1052 munmap(results, sizeof(*results)); 1053 1054 ksft_print_msg("%s: %u / %u tests passed.\n", ret ? "FAILED" : "PASSED", 1055 pass_count, count); 1056 ksft_exit(ret == 0); 1057 1058 /* unreachable */ 1059 return KSFT_FAIL; 1060 } 1061 1062 static void __attribute__((constructor)) __constructor_order_first(void) 1063 { 1064 if (!__constructor_order) 1065 __constructor_order = _CONSTRUCTOR_ORDER_FORWARD; 1066 } 1067 1068 #endif /* __KSELFTEST_HARNESS_H */ 1069