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 10 #include "try-catch-impl.h" 11 12 struct kunit_try_catch_test_context { 13 struct kunit_try_catch *try_catch; 14 bool function_called; 15 }; 16 17 static void kunit_test_successful_try(void *data) 18 { 19 struct kunit *test = data; 20 struct kunit_try_catch_test_context *ctx = test->priv; 21 22 ctx->function_called = true; 23 } 24 25 static void kunit_test_no_catch(void *data) 26 { 27 struct kunit *test = data; 28 29 KUNIT_FAIL(test, "Catch should not be called\n"); 30 } 31 32 static void kunit_test_try_catch_successful_try_no_catch(struct kunit *test) 33 { 34 struct kunit_try_catch_test_context *ctx = test->priv; 35 struct kunit_try_catch *try_catch = ctx->try_catch; 36 37 kunit_try_catch_init(try_catch, 38 test, 39 kunit_test_successful_try, 40 kunit_test_no_catch); 41 kunit_try_catch_run(try_catch, test); 42 43 KUNIT_EXPECT_TRUE(test, ctx->function_called); 44 } 45 46 static void kunit_test_unsuccessful_try(void *data) 47 { 48 struct kunit *test = data; 49 struct kunit_try_catch_test_context *ctx = test->priv; 50 struct kunit_try_catch *try_catch = ctx->try_catch; 51 52 kunit_try_catch_throw(try_catch); 53 KUNIT_FAIL(test, "This line should never be reached\n"); 54 } 55 56 static void kunit_test_catch(void *data) 57 { 58 struct kunit *test = data; 59 struct kunit_try_catch_test_context *ctx = test->priv; 60 61 ctx->function_called = true; 62 } 63 64 static void kunit_test_try_catch_unsuccessful_try_does_catch(struct kunit *test) 65 { 66 struct kunit_try_catch_test_context *ctx = test->priv; 67 struct kunit_try_catch *try_catch = ctx->try_catch; 68 69 kunit_try_catch_init(try_catch, 70 test, 71 kunit_test_unsuccessful_try, 72 kunit_test_catch); 73 kunit_try_catch_run(try_catch, test); 74 75 KUNIT_EXPECT_TRUE(test, ctx->function_called); 76 } 77 78 static int kunit_try_catch_test_init(struct kunit *test) 79 { 80 struct kunit_try_catch_test_context *ctx; 81 82 ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL); 83 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 84 test->priv = ctx; 85 86 ctx->try_catch = kunit_kmalloc(test, 87 sizeof(*ctx->try_catch), 88 GFP_KERNEL); 89 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->try_catch); 90 91 return 0; 92 } 93 94 static struct kunit_case kunit_try_catch_test_cases[] = { 95 KUNIT_CASE(kunit_test_try_catch_successful_try_no_catch), 96 KUNIT_CASE(kunit_test_try_catch_unsuccessful_try_does_catch), 97 {} 98 }; 99 100 static struct kunit_suite kunit_try_catch_test_suite = { 101 .name = "kunit-try-catch-test", 102 .init = kunit_try_catch_test_init, 103 .test_cases = kunit_try_catch_test_cases, 104 }; 105 106 /* 107 * Context for testing test managed resources 108 * is_resource_initialized is used to test arbitrary resources 109 */ 110 struct kunit_test_resource_context { 111 struct kunit test; 112 bool is_resource_initialized; 113 int allocate_order[2]; 114 int free_order[2]; 115 }; 116 117 static int fake_resource_init(struct kunit_resource *res, void *context) 118 { 119 struct kunit_test_resource_context *ctx = context; 120 121 res->data = &ctx->is_resource_initialized; 122 ctx->is_resource_initialized = true; 123 return 0; 124 } 125 126 static void fake_resource_free(struct kunit_resource *res) 127 { 128 bool *is_resource_initialized = res->data; 129 130 *is_resource_initialized = false; 131 } 132 133 static void kunit_resource_test_init_resources(struct kunit *test) 134 { 135 struct kunit_test_resource_context *ctx = test->priv; 136 137 kunit_init_test(&ctx->test, "testing_test_init_test", NULL); 138 139 KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); 140 } 141 142 static void kunit_resource_test_alloc_resource(struct kunit *test) 143 { 144 struct kunit_test_resource_context *ctx = test->priv; 145 struct kunit_resource *res; 146 kunit_resource_free_t free = fake_resource_free; 147 148 res = kunit_alloc_and_get_resource(&ctx->test, 149 fake_resource_init, 150 fake_resource_free, 151 GFP_KERNEL, 152 ctx); 153 154 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, res); 155 KUNIT_EXPECT_PTR_EQ(test, 156 &ctx->is_resource_initialized, 157 (bool *)res->data); 158 KUNIT_EXPECT_TRUE(test, list_is_last(&res->node, &ctx->test.resources)); 159 KUNIT_EXPECT_PTR_EQ(test, free, res->free); 160 161 kunit_put_resource(res); 162 } 163 164 static inline bool kunit_resource_instance_match(struct kunit *test, 165 struct kunit_resource *res, 166 void *match_data) 167 { 168 return res->data == match_data; 169 } 170 171 /* 172 * Note: tests below use kunit_alloc_and_get_resource(), so as a consequence 173 * they have a reference to the associated resource that they must release 174 * via kunit_put_resource(). In normal operation, users will only 175 * have to do this for cases where they use kunit_find_resource(), and the 176 * kunit_alloc_resource() function will be used (which does not take a 177 * resource reference). 178 */ 179 static void kunit_resource_test_destroy_resource(struct kunit *test) 180 { 181 struct kunit_test_resource_context *ctx = test->priv; 182 struct kunit_resource *res = kunit_alloc_and_get_resource( 183 &ctx->test, 184 fake_resource_init, 185 fake_resource_free, 186 GFP_KERNEL, 187 ctx); 188 189 kunit_put_resource(res); 190 191 KUNIT_ASSERT_FALSE(test, 192 kunit_destroy_resource(&ctx->test, 193 kunit_resource_instance_match, 194 res->data)); 195 196 KUNIT_EXPECT_FALSE(test, ctx->is_resource_initialized); 197 KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); 198 } 199 200 static void kunit_resource_test_remove_resource(struct kunit *test) 201 { 202 struct kunit_test_resource_context *ctx = test->priv; 203 struct kunit_resource *res = kunit_alloc_and_get_resource( 204 &ctx->test, 205 fake_resource_init, 206 fake_resource_free, 207 GFP_KERNEL, 208 ctx); 209 210 /* The resource is in the list */ 211 KUNIT_EXPECT_FALSE(test, list_empty(&ctx->test.resources)); 212 213 /* Remove the resource. The pointer is still valid, but it can't be 214 * found. 215 */ 216 kunit_remove_resource(test, res); 217 KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); 218 /* We haven't been freed yet. */ 219 KUNIT_EXPECT_TRUE(test, ctx->is_resource_initialized); 220 221 /* Removing the resource multiple times is valid. */ 222 kunit_remove_resource(test, res); 223 KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); 224 /* Despite having been removed twice (from only one reference), the 225 * resource still has not been freed. 226 */ 227 KUNIT_EXPECT_TRUE(test, ctx->is_resource_initialized); 228 229 /* Free the resource. */ 230 kunit_put_resource(res); 231 KUNIT_EXPECT_FALSE(test, ctx->is_resource_initialized); 232 } 233 234 static void kunit_resource_test_cleanup_resources(struct kunit *test) 235 { 236 int i; 237 struct kunit_test_resource_context *ctx = test->priv; 238 struct kunit_resource *resources[5]; 239 240 for (i = 0; i < ARRAY_SIZE(resources); i++) { 241 resources[i] = kunit_alloc_and_get_resource(&ctx->test, 242 fake_resource_init, 243 fake_resource_free, 244 GFP_KERNEL, 245 ctx); 246 kunit_put_resource(resources[i]); 247 } 248 249 kunit_cleanup(&ctx->test); 250 251 KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); 252 } 253 254 static void kunit_resource_test_mark_order(int order_array[], 255 size_t order_size, 256 int key) 257 { 258 int i; 259 260 for (i = 0; i < order_size && order_array[i]; i++) 261 ; 262 263 order_array[i] = key; 264 } 265 266 #define KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, order_field, key) \ 267 kunit_resource_test_mark_order(ctx->order_field, \ 268 ARRAY_SIZE(ctx->order_field), \ 269 key) 270 271 static int fake_resource_2_init(struct kunit_resource *res, void *context) 272 { 273 struct kunit_test_resource_context *ctx = context; 274 275 KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, allocate_order, 2); 276 277 res->data = ctx; 278 279 return 0; 280 } 281 282 static void fake_resource_2_free(struct kunit_resource *res) 283 { 284 struct kunit_test_resource_context *ctx = res->data; 285 286 KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, free_order, 2); 287 } 288 289 static int fake_resource_1_init(struct kunit_resource *res, void *context) 290 { 291 struct kunit_test_resource_context *ctx = context; 292 struct kunit_resource *res2; 293 294 res2 = kunit_alloc_and_get_resource(&ctx->test, 295 fake_resource_2_init, 296 fake_resource_2_free, 297 GFP_KERNEL, 298 ctx); 299 300 KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, allocate_order, 1); 301 302 res->data = ctx; 303 304 kunit_put_resource(res2); 305 306 return 0; 307 } 308 309 static void fake_resource_1_free(struct kunit_resource *res) 310 { 311 struct kunit_test_resource_context *ctx = res->data; 312 313 KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, free_order, 1); 314 } 315 316 /* 317 * TODO(brendanhiggins@google.com): replace the arrays that keep track of the 318 * order of allocation and freeing with strict mocks using the IN_SEQUENCE macro 319 * to assert allocation and freeing order when the feature becomes available. 320 */ 321 static void kunit_resource_test_proper_free_ordering(struct kunit *test) 322 { 323 struct kunit_test_resource_context *ctx = test->priv; 324 struct kunit_resource *res; 325 326 /* fake_resource_1 allocates a fake_resource_2 in its init. */ 327 res = kunit_alloc_and_get_resource(&ctx->test, 328 fake_resource_1_init, 329 fake_resource_1_free, 330 GFP_KERNEL, 331 ctx); 332 333 /* 334 * Since fake_resource_2_init calls KUNIT_RESOURCE_TEST_MARK_ORDER 335 * before returning to fake_resource_1_init, it should be the first to 336 * put its key in the allocate_order array. 337 */ 338 KUNIT_EXPECT_EQ(test, ctx->allocate_order[0], 2); 339 KUNIT_EXPECT_EQ(test, ctx->allocate_order[1], 1); 340 341 kunit_put_resource(res); 342 343 kunit_cleanup(&ctx->test); 344 345 /* 346 * Because fake_resource_2 finishes allocation before fake_resource_1, 347 * fake_resource_1 should be freed first since it could depend on 348 * fake_resource_2. 349 */ 350 KUNIT_EXPECT_EQ(test, ctx->free_order[0], 1); 351 KUNIT_EXPECT_EQ(test, ctx->free_order[1], 2); 352 } 353 354 static void kunit_resource_test_static(struct kunit *test) 355 { 356 struct kunit_test_resource_context ctx; 357 struct kunit_resource res; 358 359 KUNIT_EXPECT_EQ(test, kunit_add_resource(test, NULL, NULL, &res, &ctx), 360 0); 361 362 KUNIT_EXPECT_PTR_EQ(test, res.data, (void *)&ctx); 363 364 kunit_cleanup(test); 365 366 KUNIT_EXPECT_TRUE(test, list_empty(&test->resources)); 367 } 368 369 static void kunit_resource_test_named(struct kunit *test) 370 { 371 struct kunit_resource res1, res2, *found = NULL; 372 struct kunit_test_resource_context ctx; 373 374 KUNIT_EXPECT_EQ(test, 375 kunit_add_named_resource(test, NULL, NULL, &res1, 376 "resource_1", &ctx), 377 0); 378 KUNIT_EXPECT_PTR_EQ(test, res1.data, (void *)&ctx); 379 380 KUNIT_EXPECT_EQ(test, 381 kunit_add_named_resource(test, NULL, NULL, &res1, 382 "resource_1", &ctx), 383 -EEXIST); 384 385 KUNIT_EXPECT_EQ(test, 386 kunit_add_named_resource(test, NULL, NULL, &res2, 387 "resource_2", &ctx), 388 0); 389 390 found = kunit_find_named_resource(test, "resource_1"); 391 392 KUNIT_EXPECT_PTR_EQ(test, found, &res1); 393 394 if (found) 395 kunit_put_resource(&res1); 396 397 KUNIT_EXPECT_EQ(test, kunit_destroy_named_resource(test, "resource_2"), 398 0); 399 400 kunit_cleanup(test); 401 402 KUNIT_EXPECT_TRUE(test, list_empty(&test->resources)); 403 } 404 405 static int kunit_resource_test_init(struct kunit *test) 406 { 407 struct kunit_test_resource_context *ctx = 408 kzalloc(sizeof(*ctx), GFP_KERNEL); 409 410 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 411 412 test->priv = ctx; 413 414 kunit_init_test(&ctx->test, "test_test_context", NULL); 415 416 return 0; 417 } 418 419 static void kunit_resource_test_exit(struct kunit *test) 420 { 421 struct kunit_test_resource_context *ctx = test->priv; 422 423 kunit_cleanup(&ctx->test); 424 kfree(ctx); 425 } 426 427 static struct kunit_case kunit_resource_test_cases[] = { 428 KUNIT_CASE(kunit_resource_test_init_resources), 429 KUNIT_CASE(kunit_resource_test_alloc_resource), 430 KUNIT_CASE(kunit_resource_test_destroy_resource), 431 KUNIT_CASE(kunit_resource_test_remove_resource), 432 KUNIT_CASE(kunit_resource_test_cleanup_resources), 433 KUNIT_CASE(kunit_resource_test_proper_free_ordering), 434 KUNIT_CASE(kunit_resource_test_static), 435 KUNIT_CASE(kunit_resource_test_named), 436 {} 437 }; 438 439 static struct kunit_suite kunit_resource_test_suite = { 440 .name = "kunit-resource-test", 441 .init = kunit_resource_test_init, 442 .exit = kunit_resource_test_exit, 443 .test_cases = kunit_resource_test_cases, 444 }; 445 446 static void kunit_log_test(struct kunit *test); 447 448 static struct kunit_case kunit_log_test_cases[] = { 449 KUNIT_CASE(kunit_log_test), 450 {} 451 }; 452 453 static struct kunit_suite kunit_log_test_suite = { 454 .name = "kunit-log-test", 455 .test_cases = kunit_log_test_cases, 456 }; 457 458 static void kunit_log_test(struct kunit *test) 459 { 460 struct kunit_suite suite; 461 462 suite.log = kunit_kzalloc(test, KUNIT_LOG_SIZE, GFP_KERNEL); 463 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, suite.log); 464 465 kunit_log(KERN_INFO, test, "put this in log."); 466 kunit_log(KERN_INFO, test, "this too."); 467 kunit_log(KERN_INFO, &suite, "add to suite log."); 468 kunit_log(KERN_INFO, &suite, "along with this."); 469 470 #ifdef CONFIG_KUNIT_DEBUGFS 471 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, 472 strstr(test->log, "put this in log.")); 473 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, 474 strstr(test->log, "this too.")); 475 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, 476 strstr(suite.log, "add to suite log.")); 477 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, 478 strstr(suite.log, "along with this.")); 479 #else 480 KUNIT_EXPECT_NULL(test, test->log); 481 #endif 482 } 483 484 static void kunit_status_set_failure_test(struct kunit *test) 485 { 486 struct kunit fake; 487 488 kunit_init_test(&fake, "fake test", NULL); 489 490 KUNIT_EXPECT_EQ(test, fake.status, (enum kunit_status)KUNIT_SUCCESS); 491 kunit_set_failure(&fake); 492 KUNIT_EXPECT_EQ(test, fake.status, (enum kunit_status)KUNIT_FAILURE); 493 } 494 495 static void kunit_status_mark_skipped_test(struct kunit *test) 496 { 497 struct kunit fake; 498 499 kunit_init_test(&fake, "fake test", NULL); 500 501 /* Before: Should be SUCCESS with no comment. */ 502 KUNIT_EXPECT_EQ(test, fake.status, KUNIT_SUCCESS); 503 KUNIT_EXPECT_STREQ(test, fake.status_comment, ""); 504 505 /* Mark the test as skipped. */ 506 kunit_mark_skipped(&fake, "Accepts format string: %s", "YES"); 507 508 /* After: Should be SKIPPED with our comment. */ 509 KUNIT_EXPECT_EQ(test, fake.status, (enum kunit_status)KUNIT_SKIPPED); 510 KUNIT_EXPECT_STREQ(test, fake.status_comment, "Accepts format string: YES"); 511 } 512 513 static struct kunit_case kunit_status_test_cases[] = { 514 KUNIT_CASE(kunit_status_set_failure_test), 515 KUNIT_CASE(kunit_status_mark_skipped_test), 516 {} 517 }; 518 519 static struct kunit_suite kunit_status_test_suite = { 520 .name = "kunit_status", 521 .test_cases = kunit_status_test_cases, 522 }; 523 524 kunit_test_suites(&kunit_try_catch_test_suite, &kunit_resource_test_suite, 525 &kunit_log_test_suite, &kunit_status_test_suite); 526 527 MODULE_LICENSE("GPL v2"); 528