1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * KUnit test for core test infrastructure. 4 * 5 * Copyright (C) 2019, Google LLC. 6 * Author: Brendan Higgins <brendanhiggins@google.com> 7 */ 8 #include <kunit/test.h> 9 #include <kunit/test-bug.h> 10 11 #include "string-stream.h" 12 #include "try-catch-impl.h" 13 14 struct kunit_try_catch_test_context { 15 struct kunit_try_catch *try_catch; 16 bool function_called; 17 }; 18 19 static void kunit_test_successful_try(void *data) 20 { 21 struct kunit *test = data; 22 struct kunit_try_catch_test_context *ctx = test->priv; 23 24 ctx->function_called = true; 25 } 26 27 static void kunit_test_no_catch(void *data) 28 { 29 struct kunit *test = data; 30 31 KUNIT_FAIL(test, "Catch should not be called\n"); 32 } 33 34 static void kunit_test_try_catch_successful_try_no_catch(struct kunit *test) 35 { 36 struct kunit_try_catch_test_context *ctx = test->priv; 37 struct kunit_try_catch *try_catch = ctx->try_catch; 38 39 kunit_try_catch_init(try_catch, 40 test, 41 kunit_test_successful_try, 42 kunit_test_no_catch); 43 kunit_try_catch_run(try_catch, test); 44 45 KUNIT_EXPECT_TRUE(test, ctx->function_called); 46 } 47 48 static void kunit_test_unsuccessful_try(void *data) 49 { 50 struct kunit *test = data; 51 struct kunit_try_catch_test_context *ctx = test->priv; 52 struct kunit_try_catch *try_catch = ctx->try_catch; 53 54 kunit_try_catch_throw(try_catch); 55 KUNIT_FAIL(test, "This line should never be reached\n"); 56 } 57 58 static void kunit_test_catch(void *data) 59 { 60 struct kunit *test = data; 61 struct kunit_try_catch_test_context *ctx = test->priv; 62 63 ctx->function_called = true; 64 } 65 66 static void kunit_test_try_catch_unsuccessful_try_does_catch(struct kunit *test) 67 { 68 struct kunit_try_catch_test_context *ctx = test->priv; 69 struct kunit_try_catch *try_catch = ctx->try_catch; 70 71 kunit_try_catch_init(try_catch, 72 test, 73 kunit_test_unsuccessful_try, 74 kunit_test_catch); 75 kunit_try_catch_run(try_catch, test); 76 77 KUNIT_EXPECT_TRUE(test, ctx->function_called); 78 } 79 80 static int kunit_try_catch_test_init(struct kunit *test) 81 { 82 struct kunit_try_catch_test_context *ctx; 83 84 ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL); 85 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 86 test->priv = ctx; 87 88 ctx->try_catch = kunit_kmalloc(test, 89 sizeof(*ctx->try_catch), 90 GFP_KERNEL); 91 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->try_catch); 92 93 return 0; 94 } 95 96 static struct kunit_case kunit_try_catch_test_cases[] = { 97 KUNIT_CASE(kunit_test_try_catch_successful_try_no_catch), 98 KUNIT_CASE(kunit_test_try_catch_unsuccessful_try_does_catch), 99 {} 100 }; 101 102 static struct kunit_suite kunit_try_catch_test_suite = { 103 .name = "kunit-try-catch-test", 104 .init = kunit_try_catch_test_init, 105 .test_cases = kunit_try_catch_test_cases, 106 }; 107 108 /* 109 * Context for testing test managed resources 110 * is_resource_initialized is used to test arbitrary resources 111 */ 112 struct kunit_test_resource_context { 113 struct kunit test; 114 bool is_resource_initialized; 115 int allocate_order[2]; 116 int free_order[4]; 117 }; 118 119 static int fake_resource_init(struct kunit_resource *res, void *context) 120 { 121 struct kunit_test_resource_context *ctx = context; 122 123 res->data = &ctx->is_resource_initialized; 124 ctx->is_resource_initialized = true; 125 return 0; 126 } 127 128 static void fake_resource_free(struct kunit_resource *res) 129 { 130 bool *is_resource_initialized = res->data; 131 132 *is_resource_initialized = false; 133 } 134 135 static void kunit_resource_test_init_resources(struct kunit *test) 136 { 137 struct kunit_test_resource_context *ctx = test->priv; 138 139 kunit_init_test(&ctx->test, "testing_test_init_test", NULL); 140 141 KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); 142 } 143 144 static void kunit_resource_test_alloc_resource(struct kunit *test) 145 { 146 struct kunit_test_resource_context *ctx = test->priv; 147 struct kunit_resource *res; 148 kunit_resource_free_t free = fake_resource_free; 149 150 res = kunit_alloc_and_get_resource(&ctx->test, 151 fake_resource_init, 152 fake_resource_free, 153 GFP_KERNEL, 154 ctx); 155 156 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, res); 157 KUNIT_EXPECT_PTR_EQ(test, 158 &ctx->is_resource_initialized, 159 (bool *)res->data); 160 KUNIT_EXPECT_TRUE(test, list_is_last(&res->node, &ctx->test.resources)); 161 KUNIT_EXPECT_PTR_EQ(test, free, res->free); 162 163 kunit_put_resource(res); 164 } 165 166 static inline bool kunit_resource_instance_match(struct kunit *test, 167 struct kunit_resource *res, 168 void *match_data) 169 { 170 return res->data == match_data; 171 } 172 173 /* 174 * Note: tests below use kunit_alloc_and_get_resource(), so as a consequence 175 * they have a reference to the associated resource that they must release 176 * via kunit_put_resource(). In normal operation, users will only 177 * have to do this for cases where they use kunit_find_resource(), and the 178 * kunit_alloc_resource() function will be used (which does not take a 179 * resource reference). 180 */ 181 static void kunit_resource_test_destroy_resource(struct kunit *test) 182 { 183 struct kunit_test_resource_context *ctx = test->priv; 184 struct kunit_resource *res = kunit_alloc_and_get_resource( 185 &ctx->test, 186 fake_resource_init, 187 fake_resource_free, 188 GFP_KERNEL, 189 ctx); 190 191 kunit_put_resource(res); 192 193 KUNIT_ASSERT_FALSE(test, 194 kunit_destroy_resource(&ctx->test, 195 kunit_resource_instance_match, 196 res->data)); 197 198 KUNIT_EXPECT_FALSE(test, ctx->is_resource_initialized); 199 KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); 200 } 201 202 static void kunit_resource_test_remove_resource(struct kunit *test) 203 { 204 struct kunit_test_resource_context *ctx = test->priv; 205 struct kunit_resource *res = kunit_alloc_and_get_resource( 206 &ctx->test, 207 fake_resource_init, 208 fake_resource_free, 209 GFP_KERNEL, 210 ctx); 211 212 /* The resource is in the list */ 213 KUNIT_EXPECT_FALSE(test, list_empty(&ctx->test.resources)); 214 215 /* Remove the resource. The pointer is still valid, but it can't be 216 * found. 217 */ 218 kunit_remove_resource(test, res); 219 KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); 220 /* We haven't been freed yet. */ 221 KUNIT_EXPECT_TRUE(test, ctx->is_resource_initialized); 222 223 /* Removing the resource multiple times is valid. */ 224 kunit_remove_resource(test, res); 225 KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); 226 /* Despite having been removed twice (from only one reference), the 227 * resource still has not been freed. 228 */ 229 KUNIT_EXPECT_TRUE(test, ctx->is_resource_initialized); 230 231 /* Free the resource. */ 232 kunit_put_resource(res); 233 KUNIT_EXPECT_FALSE(test, ctx->is_resource_initialized); 234 } 235 236 static void kunit_resource_test_cleanup_resources(struct kunit *test) 237 { 238 int i; 239 struct kunit_test_resource_context *ctx = test->priv; 240 struct kunit_resource *resources[5]; 241 242 for (i = 0; i < ARRAY_SIZE(resources); i++) { 243 resources[i] = kunit_alloc_and_get_resource(&ctx->test, 244 fake_resource_init, 245 fake_resource_free, 246 GFP_KERNEL, 247 ctx); 248 kunit_put_resource(resources[i]); 249 } 250 251 kunit_cleanup(&ctx->test); 252 253 KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); 254 } 255 256 static void kunit_resource_test_mark_order(int order_array[], 257 size_t order_size, 258 int key) 259 { 260 int i; 261 262 for (i = 0; i < order_size && order_array[i]; i++) 263 ; 264 265 order_array[i] = key; 266 } 267 268 #define KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, order_field, key) \ 269 kunit_resource_test_mark_order(ctx->order_field, \ 270 ARRAY_SIZE(ctx->order_field), \ 271 key) 272 273 static int fake_resource_2_init(struct kunit_resource *res, void *context) 274 { 275 struct kunit_test_resource_context *ctx = context; 276 277 KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, allocate_order, 2); 278 279 res->data = ctx; 280 281 return 0; 282 } 283 284 static void fake_resource_2_free(struct kunit_resource *res) 285 { 286 struct kunit_test_resource_context *ctx = res->data; 287 288 KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, free_order, 2); 289 } 290 291 static int fake_resource_1_init(struct kunit_resource *res, void *context) 292 { 293 struct kunit_test_resource_context *ctx = context; 294 struct kunit_resource *res2; 295 296 res2 = kunit_alloc_and_get_resource(&ctx->test, 297 fake_resource_2_init, 298 fake_resource_2_free, 299 GFP_KERNEL, 300 ctx); 301 302 KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, allocate_order, 1); 303 304 res->data = ctx; 305 306 kunit_put_resource(res2); 307 308 return 0; 309 } 310 311 static void fake_resource_1_free(struct kunit_resource *res) 312 { 313 struct kunit_test_resource_context *ctx = res->data; 314 315 KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, free_order, 1); 316 } 317 318 /* 319 * TODO(brendanhiggins@google.com): replace the arrays that keep track of the 320 * order of allocation and freeing with strict mocks using the IN_SEQUENCE macro 321 * to assert allocation and freeing order when the feature becomes available. 322 */ 323 static void kunit_resource_test_proper_free_ordering(struct kunit *test) 324 { 325 struct kunit_test_resource_context *ctx = test->priv; 326 struct kunit_resource *res; 327 328 /* fake_resource_1 allocates a fake_resource_2 in its init. */ 329 res = kunit_alloc_and_get_resource(&ctx->test, 330 fake_resource_1_init, 331 fake_resource_1_free, 332 GFP_KERNEL, 333 ctx); 334 335 /* 336 * Since fake_resource_2_init calls KUNIT_RESOURCE_TEST_MARK_ORDER 337 * before returning to fake_resource_1_init, it should be the first to 338 * put its key in the allocate_order array. 339 */ 340 KUNIT_EXPECT_EQ(test, ctx->allocate_order[0], 2); 341 KUNIT_EXPECT_EQ(test, ctx->allocate_order[1], 1); 342 343 kunit_put_resource(res); 344 345 kunit_cleanup(&ctx->test); 346 347 /* 348 * Because fake_resource_2 finishes allocation before fake_resource_1, 349 * fake_resource_1 should be freed first since it could depend on 350 * fake_resource_2. 351 */ 352 KUNIT_EXPECT_EQ(test, ctx->free_order[0], 1); 353 KUNIT_EXPECT_EQ(test, ctx->free_order[1], 2); 354 } 355 356 static void kunit_resource_test_static(struct kunit *test) 357 { 358 struct kunit_test_resource_context ctx; 359 struct kunit_resource res; 360 361 KUNIT_EXPECT_EQ(test, kunit_add_resource(test, NULL, NULL, &res, &ctx), 362 0); 363 364 KUNIT_EXPECT_PTR_EQ(test, res.data, (void *)&ctx); 365 366 kunit_cleanup(test); 367 368 KUNIT_EXPECT_TRUE(test, list_empty(&test->resources)); 369 } 370 371 static void kunit_resource_test_named(struct kunit *test) 372 { 373 struct kunit_resource res1, res2, *found = NULL; 374 struct kunit_test_resource_context ctx; 375 376 KUNIT_EXPECT_EQ(test, 377 kunit_add_named_resource(test, NULL, NULL, &res1, 378 "resource_1", &ctx), 379 0); 380 KUNIT_EXPECT_PTR_EQ(test, res1.data, (void *)&ctx); 381 382 KUNIT_EXPECT_EQ(test, 383 kunit_add_named_resource(test, NULL, NULL, &res1, 384 "resource_1", &ctx), 385 -EEXIST); 386 387 KUNIT_EXPECT_EQ(test, 388 kunit_add_named_resource(test, NULL, NULL, &res2, 389 "resource_2", &ctx), 390 0); 391 392 found = kunit_find_named_resource(test, "resource_1"); 393 394 KUNIT_EXPECT_PTR_EQ(test, found, &res1); 395 396 if (found) 397 kunit_put_resource(&res1); 398 399 KUNIT_EXPECT_EQ(test, kunit_destroy_named_resource(test, "resource_2"), 400 0); 401 402 kunit_cleanup(test); 403 404 KUNIT_EXPECT_TRUE(test, list_empty(&test->resources)); 405 } 406 407 static void increment_int(void *ctx) 408 { 409 int *i = (int *)ctx; 410 (*i)++; 411 } 412 413 static void kunit_resource_test_action(struct kunit *test) 414 { 415 int num_actions = 0; 416 417 kunit_add_action(test, increment_int, &num_actions); 418 KUNIT_EXPECT_EQ(test, num_actions, 0); 419 kunit_cleanup(test); 420 KUNIT_EXPECT_EQ(test, num_actions, 1); 421 422 /* Once we've cleaned up, the action queue is empty. */ 423 kunit_cleanup(test); 424 KUNIT_EXPECT_EQ(test, num_actions, 1); 425 426 /* Check the same function can be deferred multiple times. */ 427 kunit_add_action(test, increment_int, &num_actions); 428 kunit_add_action(test, increment_int, &num_actions); 429 kunit_cleanup(test); 430 KUNIT_EXPECT_EQ(test, num_actions, 3); 431 } 432 static void kunit_resource_test_remove_action(struct kunit *test) 433 { 434 int num_actions = 0; 435 436 kunit_add_action(test, increment_int, &num_actions); 437 KUNIT_EXPECT_EQ(test, num_actions, 0); 438 439 kunit_remove_action(test, increment_int, &num_actions); 440 kunit_cleanup(test); 441 KUNIT_EXPECT_EQ(test, num_actions, 0); 442 } 443 static void kunit_resource_test_release_action(struct kunit *test) 444 { 445 int num_actions = 0; 446 447 kunit_add_action(test, increment_int, &num_actions); 448 KUNIT_EXPECT_EQ(test, num_actions, 0); 449 /* Runs immediately on trigger. */ 450 kunit_release_action(test, increment_int, &num_actions); 451 KUNIT_EXPECT_EQ(test, num_actions, 1); 452 453 /* Doesn't run again on test exit. */ 454 kunit_cleanup(test); 455 KUNIT_EXPECT_EQ(test, num_actions, 1); 456 } 457 static void action_order_1(void *ctx) 458 { 459 struct kunit_test_resource_context *res_ctx = (struct kunit_test_resource_context *)ctx; 460 461 KUNIT_RESOURCE_TEST_MARK_ORDER(res_ctx, free_order, 1); 462 kunit_log(KERN_INFO, current->kunit_test, "action_order_1"); 463 } 464 static void action_order_2(void *ctx) 465 { 466 struct kunit_test_resource_context *res_ctx = (struct kunit_test_resource_context *)ctx; 467 468 KUNIT_RESOURCE_TEST_MARK_ORDER(res_ctx, free_order, 2); 469 kunit_log(KERN_INFO, current->kunit_test, "action_order_2"); 470 } 471 static void kunit_resource_test_action_ordering(struct kunit *test) 472 { 473 struct kunit_test_resource_context *ctx = test->priv; 474 475 kunit_add_action(test, action_order_1, ctx); 476 kunit_add_action(test, action_order_2, ctx); 477 kunit_add_action(test, action_order_1, ctx); 478 kunit_add_action(test, action_order_2, ctx); 479 kunit_remove_action(test, action_order_1, ctx); 480 kunit_release_action(test, action_order_2, ctx); 481 kunit_cleanup(test); 482 483 /* [2 is triggered] [2], [(1 is cancelled)] [1] */ 484 KUNIT_EXPECT_EQ(test, ctx->free_order[0], 2); 485 KUNIT_EXPECT_EQ(test, ctx->free_order[1], 2); 486 KUNIT_EXPECT_EQ(test, ctx->free_order[2], 1); 487 } 488 489 static int kunit_resource_test_init(struct kunit *test) 490 { 491 struct kunit_test_resource_context *ctx = 492 kzalloc(sizeof(*ctx), GFP_KERNEL); 493 494 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 495 496 test->priv = ctx; 497 498 kunit_init_test(&ctx->test, "test_test_context", NULL); 499 500 return 0; 501 } 502 503 static void kunit_resource_test_exit(struct kunit *test) 504 { 505 struct kunit_test_resource_context *ctx = test->priv; 506 507 kunit_cleanup(&ctx->test); 508 kfree(ctx); 509 } 510 511 static struct kunit_case kunit_resource_test_cases[] = { 512 KUNIT_CASE(kunit_resource_test_init_resources), 513 KUNIT_CASE(kunit_resource_test_alloc_resource), 514 KUNIT_CASE(kunit_resource_test_destroy_resource), 515 KUNIT_CASE(kunit_resource_test_remove_resource), 516 KUNIT_CASE(kunit_resource_test_cleanup_resources), 517 KUNIT_CASE(kunit_resource_test_proper_free_ordering), 518 KUNIT_CASE(kunit_resource_test_static), 519 KUNIT_CASE(kunit_resource_test_named), 520 KUNIT_CASE(kunit_resource_test_action), 521 KUNIT_CASE(kunit_resource_test_remove_action), 522 KUNIT_CASE(kunit_resource_test_release_action), 523 KUNIT_CASE(kunit_resource_test_action_ordering), 524 {} 525 }; 526 527 static struct kunit_suite kunit_resource_test_suite = { 528 .name = "kunit-resource-test", 529 .init = kunit_resource_test_init, 530 .exit = kunit_resource_test_exit, 531 .test_cases = kunit_resource_test_cases, 532 }; 533 534 /* 535 * Log tests call string_stream functions, which aren't exported. So only 536 * build this code if this test is built-in. 537 */ 538 #if IS_BUILTIN(CONFIG_KUNIT_TEST) 539 540 /* This avoids a cast warning if kfree() is passed direct to kunit_add_action(). */ 541 static void kfree_wrapper(void *p) 542 { 543 kfree(p); 544 } 545 546 static void kunit_log_test(struct kunit *test) 547 { 548 struct kunit_suite suite; 549 #ifdef CONFIG_KUNIT_DEBUGFS 550 char *full_log; 551 #endif 552 suite.log = kunit_alloc_string_stream(test, GFP_KERNEL); 553 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, suite.log); 554 string_stream_set_append_newlines(suite.log, true); 555 556 kunit_log(KERN_INFO, test, "put this in log."); 557 kunit_log(KERN_INFO, test, "this too."); 558 kunit_log(KERN_INFO, &suite, "add to suite log."); 559 kunit_log(KERN_INFO, &suite, "along with this."); 560 561 #ifdef CONFIG_KUNIT_DEBUGFS 562 KUNIT_EXPECT_TRUE(test, test->log->append_newlines); 563 564 full_log = string_stream_get_string(test->log); 565 kunit_add_action(test, (kunit_action_t *)kfree, full_log); 566 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, 567 strstr(full_log, "put this in log.")); 568 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, 569 strstr(full_log, "this too.")); 570 571 full_log = string_stream_get_string(suite.log); 572 kunit_add_action(test, kfree_wrapper, full_log); 573 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, 574 strstr(full_log, "add to suite log.")); 575 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, 576 strstr(full_log, "along with this.")); 577 #else 578 KUNIT_EXPECT_NULL(test, test->log); 579 #endif 580 } 581 582 static void kunit_log_newline_test(struct kunit *test) 583 { 584 char *full_log; 585 586 kunit_info(test, "Add newline\n"); 587 if (test->log) { 588 full_log = string_stream_get_string(test->log); 589 kunit_add_action(test, kfree_wrapper, full_log); 590 KUNIT_ASSERT_NOT_NULL_MSG(test, strstr(full_log, "Add newline\n"), 591 "Missing log line, full log:\n%s", full_log); 592 KUNIT_EXPECT_NULL(test, strstr(full_log, "Add newline\n\n")); 593 } else { 594 kunit_skip(test, "only useful when debugfs is enabled"); 595 } 596 } 597 #else 598 static void kunit_log_test(struct kunit *test) 599 { 600 kunit_skip(test, "Log tests only run when built-in"); 601 } 602 603 static void kunit_log_newline_test(struct kunit *test) 604 { 605 kunit_skip(test, "Log tests only run when built-in"); 606 } 607 #endif /* IS_BUILTIN(CONFIG_KUNIT_TEST) */ 608 609 static struct kunit_case kunit_log_test_cases[] = { 610 KUNIT_CASE(kunit_log_test), 611 KUNIT_CASE(kunit_log_newline_test), 612 {} 613 }; 614 615 static struct kunit_suite kunit_log_test_suite = { 616 .name = "kunit-log-test", 617 .test_cases = kunit_log_test_cases, 618 }; 619 620 static void kunit_status_set_failure_test(struct kunit *test) 621 { 622 struct kunit fake; 623 624 kunit_init_test(&fake, "fake test", NULL); 625 626 KUNIT_EXPECT_EQ(test, fake.status, (enum kunit_status)KUNIT_SUCCESS); 627 kunit_set_failure(&fake); 628 KUNIT_EXPECT_EQ(test, fake.status, (enum kunit_status)KUNIT_FAILURE); 629 } 630 631 static void kunit_status_mark_skipped_test(struct kunit *test) 632 { 633 struct kunit fake; 634 635 kunit_init_test(&fake, "fake test", NULL); 636 637 /* Before: Should be SUCCESS with no comment. */ 638 KUNIT_EXPECT_EQ(test, fake.status, KUNIT_SUCCESS); 639 KUNIT_EXPECT_STREQ(test, fake.status_comment, ""); 640 641 /* Mark the test as skipped. */ 642 kunit_mark_skipped(&fake, "Accepts format string: %s", "YES"); 643 644 /* After: Should be SKIPPED with our comment. */ 645 KUNIT_EXPECT_EQ(test, fake.status, (enum kunit_status)KUNIT_SKIPPED); 646 KUNIT_EXPECT_STREQ(test, fake.status_comment, "Accepts format string: YES"); 647 } 648 649 static struct kunit_case kunit_status_test_cases[] = { 650 KUNIT_CASE(kunit_status_set_failure_test), 651 KUNIT_CASE(kunit_status_mark_skipped_test), 652 {} 653 }; 654 655 static struct kunit_suite kunit_status_test_suite = { 656 .name = "kunit_status", 657 .test_cases = kunit_status_test_cases, 658 }; 659 660 static void kunit_current_test(struct kunit *test) 661 { 662 /* Check results of both current->kunit_test and 663 * kunit_get_current_test() are equivalent to current test. 664 */ 665 KUNIT_EXPECT_PTR_EQ(test, test, current->kunit_test); 666 KUNIT_EXPECT_PTR_EQ(test, test, kunit_get_current_test()); 667 } 668 669 static void kunit_current_fail_test(struct kunit *test) 670 { 671 struct kunit fake; 672 673 kunit_init_test(&fake, "fake test", NULL); 674 KUNIT_EXPECT_EQ(test, fake.status, KUNIT_SUCCESS); 675 676 /* Set current->kunit_test to fake test. */ 677 current->kunit_test = &fake; 678 679 kunit_fail_current_test("This should make `fake` test fail."); 680 KUNIT_EXPECT_EQ(test, fake.status, (enum kunit_status)KUNIT_FAILURE); 681 kunit_cleanup(&fake); 682 683 /* Reset current->kunit_test to current test. */ 684 current->kunit_test = test; 685 } 686 687 static struct kunit_case kunit_current_test_cases[] = { 688 KUNIT_CASE(kunit_current_test), 689 KUNIT_CASE(kunit_current_fail_test), 690 {} 691 }; 692 693 static struct kunit_suite kunit_current_test_suite = { 694 .name = "kunit_current", 695 .test_cases = kunit_current_test_cases, 696 }; 697 698 kunit_test_suites(&kunit_try_catch_test_suite, &kunit_resource_test_suite, 699 &kunit_log_test_suite, &kunit_status_test_suite, 700 &kunit_current_test_suite); 701 702 MODULE_LICENSE("GPL v2"); 703