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 /* 165 * Note: tests below use kunit_alloc_and_get_resource(), so as a consequence 166 * they have a reference to the associated resource that they must release 167 * via kunit_put_resource(). In normal operation, users will only 168 * have to do this for cases where they use kunit_find_resource(), and the 169 * kunit_alloc_resource() function will be used (which does not take a 170 * resource reference). 171 */ 172 static void kunit_resource_test_destroy_resource(struct kunit *test) 173 { 174 struct kunit_test_resource_context *ctx = test->priv; 175 struct kunit_resource *res = kunit_alloc_and_get_resource( 176 &ctx->test, 177 fake_resource_init, 178 fake_resource_free, 179 GFP_KERNEL, 180 ctx); 181 182 kunit_put_resource(res); 183 184 KUNIT_ASSERT_FALSE(test, 185 kunit_destroy_resource(&ctx->test, 186 kunit_resource_instance_match, 187 res->data)); 188 189 KUNIT_EXPECT_FALSE(test, ctx->is_resource_initialized); 190 KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); 191 } 192 193 static void kunit_resource_test_remove_resource(struct kunit *test) 194 { 195 struct kunit_test_resource_context *ctx = test->priv; 196 struct kunit_resource *res = kunit_alloc_and_get_resource( 197 &ctx->test, 198 fake_resource_init, 199 fake_resource_free, 200 GFP_KERNEL, 201 ctx); 202 203 /* The resource is in the list */ 204 KUNIT_EXPECT_FALSE(test, list_empty(&ctx->test.resources)); 205 206 /* Remove the resource. The pointer is still valid, but it can't be 207 * found. 208 */ 209 kunit_remove_resource(test, res); 210 KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); 211 /* We haven't been freed yet. */ 212 KUNIT_EXPECT_TRUE(test, ctx->is_resource_initialized); 213 214 /* Removing the resource multiple times is valid. */ 215 kunit_remove_resource(test, res); 216 KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); 217 /* Despite having been removed twice (from only one reference), the 218 * resource still has not been freed. 219 */ 220 KUNIT_EXPECT_TRUE(test, ctx->is_resource_initialized); 221 222 /* Free the resource. */ 223 kunit_put_resource(res); 224 KUNIT_EXPECT_FALSE(test, ctx->is_resource_initialized); 225 } 226 227 static void kunit_resource_test_cleanup_resources(struct kunit *test) 228 { 229 int i; 230 struct kunit_test_resource_context *ctx = test->priv; 231 struct kunit_resource *resources[5]; 232 233 for (i = 0; i < ARRAY_SIZE(resources); i++) { 234 resources[i] = kunit_alloc_and_get_resource(&ctx->test, 235 fake_resource_init, 236 fake_resource_free, 237 GFP_KERNEL, 238 ctx); 239 kunit_put_resource(resources[i]); 240 } 241 242 kunit_cleanup(&ctx->test); 243 244 KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); 245 } 246 247 static void kunit_resource_test_mark_order(int order_array[], 248 size_t order_size, 249 int key) 250 { 251 int i; 252 253 for (i = 0; i < order_size && order_array[i]; i++) 254 ; 255 256 order_array[i] = key; 257 } 258 259 #define KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, order_field, key) \ 260 kunit_resource_test_mark_order(ctx->order_field, \ 261 ARRAY_SIZE(ctx->order_field), \ 262 key) 263 264 static int fake_resource_2_init(struct kunit_resource *res, void *context) 265 { 266 struct kunit_test_resource_context *ctx = context; 267 268 KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, allocate_order, 2); 269 270 res->data = ctx; 271 272 return 0; 273 } 274 275 static void fake_resource_2_free(struct kunit_resource *res) 276 { 277 struct kunit_test_resource_context *ctx = res->data; 278 279 KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, free_order, 2); 280 } 281 282 static int fake_resource_1_init(struct kunit_resource *res, void *context) 283 { 284 struct kunit_test_resource_context *ctx = context; 285 struct kunit_resource *res2; 286 287 res2 = kunit_alloc_and_get_resource(&ctx->test, 288 fake_resource_2_init, 289 fake_resource_2_free, 290 GFP_KERNEL, 291 ctx); 292 293 KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, allocate_order, 1); 294 295 res->data = ctx; 296 297 kunit_put_resource(res2); 298 299 return 0; 300 } 301 302 static void fake_resource_1_free(struct kunit_resource *res) 303 { 304 struct kunit_test_resource_context *ctx = res->data; 305 306 KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, free_order, 1); 307 } 308 309 /* 310 * TODO(brendanhiggins@google.com): replace the arrays that keep track of the 311 * order of allocation and freeing with strict mocks using the IN_SEQUENCE macro 312 * to assert allocation and freeing order when the feature becomes available. 313 */ 314 static void kunit_resource_test_proper_free_ordering(struct kunit *test) 315 { 316 struct kunit_test_resource_context *ctx = test->priv; 317 struct kunit_resource *res; 318 319 /* fake_resource_1 allocates a fake_resource_2 in its init. */ 320 res = kunit_alloc_and_get_resource(&ctx->test, 321 fake_resource_1_init, 322 fake_resource_1_free, 323 GFP_KERNEL, 324 ctx); 325 326 /* 327 * Since fake_resource_2_init calls KUNIT_RESOURCE_TEST_MARK_ORDER 328 * before returning to fake_resource_1_init, it should be the first to 329 * put its key in the allocate_order array. 330 */ 331 KUNIT_EXPECT_EQ(test, ctx->allocate_order[0], 2); 332 KUNIT_EXPECT_EQ(test, ctx->allocate_order[1], 1); 333 334 kunit_put_resource(res); 335 336 kunit_cleanup(&ctx->test); 337 338 /* 339 * Because fake_resource_2 finishes allocation before fake_resource_1, 340 * fake_resource_1 should be freed first since it could depend on 341 * fake_resource_2. 342 */ 343 KUNIT_EXPECT_EQ(test, ctx->free_order[0], 1); 344 KUNIT_EXPECT_EQ(test, ctx->free_order[1], 2); 345 } 346 347 static void kunit_resource_test_static(struct kunit *test) 348 { 349 struct kunit_test_resource_context ctx; 350 struct kunit_resource res; 351 352 KUNIT_EXPECT_EQ(test, kunit_add_resource(test, NULL, NULL, &res, &ctx), 353 0); 354 355 KUNIT_EXPECT_PTR_EQ(test, res.data, (void *)&ctx); 356 357 kunit_cleanup(test); 358 359 KUNIT_EXPECT_TRUE(test, list_empty(&test->resources)); 360 } 361 362 static void kunit_resource_test_named(struct kunit *test) 363 { 364 struct kunit_resource res1, res2, *found = NULL; 365 struct kunit_test_resource_context ctx; 366 367 KUNIT_EXPECT_EQ(test, 368 kunit_add_named_resource(test, NULL, NULL, &res1, 369 "resource_1", &ctx), 370 0); 371 KUNIT_EXPECT_PTR_EQ(test, res1.data, (void *)&ctx); 372 373 KUNIT_EXPECT_EQ(test, 374 kunit_add_named_resource(test, NULL, NULL, &res1, 375 "resource_1", &ctx), 376 -EEXIST); 377 378 KUNIT_EXPECT_EQ(test, 379 kunit_add_named_resource(test, NULL, NULL, &res2, 380 "resource_2", &ctx), 381 0); 382 383 found = kunit_find_named_resource(test, "resource_1"); 384 385 KUNIT_EXPECT_PTR_EQ(test, found, &res1); 386 387 if (found) 388 kunit_put_resource(&res1); 389 390 KUNIT_EXPECT_EQ(test, kunit_destroy_named_resource(test, "resource_2"), 391 0); 392 393 kunit_cleanup(test); 394 395 KUNIT_EXPECT_TRUE(test, list_empty(&test->resources)); 396 } 397 398 static int kunit_resource_test_init(struct kunit *test) 399 { 400 struct kunit_test_resource_context *ctx = 401 kzalloc(sizeof(*ctx), GFP_KERNEL); 402 403 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 404 405 test->priv = ctx; 406 407 kunit_init_test(&ctx->test, "test_test_context", NULL); 408 409 return 0; 410 } 411 412 static void kunit_resource_test_exit(struct kunit *test) 413 { 414 struct kunit_test_resource_context *ctx = test->priv; 415 416 kunit_cleanup(&ctx->test); 417 kfree(ctx); 418 } 419 420 static struct kunit_case kunit_resource_test_cases[] = { 421 KUNIT_CASE(kunit_resource_test_init_resources), 422 KUNIT_CASE(kunit_resource_test_alloc_resource), 423 KUNIT_CASE(kunit_resource_test_destroy_resource), 424 KUNIT_CASE(kunit_resource_test_remove_resource), 425 KUNIT_CASE(kunit_resource_test_cleanup_resources), 426 KUNIT_CASE(kunit_resource_test_proper_free_ordering), 427 KUNIT_CASE(kunit_resource_test_static), 428 KUNIT_CASE(kunit_resource_test_named), 429 {} 430 }; 431 432 static struct kunit_suite kunit_resource_test_suite = { 433 .name = "kunit-resource-test", 434 .init = kunit_resource_test_init, 435 .exit = kunit_resource_test_exit, 436 .test_cases = kunit_resource_test_cases, 437 }; 438 439 static void kunit_log_test(struct kunit *test); 440 441 static struct kunit_case kunit_log_test_cases[] = { 442 KUNIT_CASE(kunit_log_test), 443 {} 444 }; 445 446 static struct kunit_suite kunit_log_test_suite = { 447 .name = "kunit-log-test", 448 .test_cases = kunit_log_test_cases, 449 }; 450 451 static void kunit_log_test(struct kunit *test) 452 { 453 struct kunit_suite suite; 454 455 suite.log = kunit_kzalloc(test, KUNIT_LOG_SIZE, GFP_KERNEL); 456 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, suite.log); 457 458 kunit_log(KERN_INFO, test, "put this in log."); 459 kunit_log(KERN_INFO, test, "this too."); 460 kunit_log(KERN_INFO, &suite, "add to suite log."); 461 kunit_log(KERN_INFO, &suite, "along with this."); 462 463 #ifdef CONFIG_KUNIT_DEBUGFS 464 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, 465 strstr(test->log, "put this in log.")); 466 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, 467 strstr(test->log, "this too.")); 468 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, 469 strstr(suite.log, "add to suite log.")); 470 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, 471 strstr(suite.log, "along with this.")); 472 #else 473 KUNIT_EXPECT_NULL(test, test->log); 474 #endif 475 } 476 477 static void kunit_status_set_failure_test(struct kunit *test) 478 { 479 struct kunit fake; 480 481 kunit_init_test(&fake, "fake test", NULL); 482 483 KUNIT_EXPECT_EQ(test, fake.status, (enum kunit_status)KUNIT_SUCCESS); 484 kunit_set_failure(&fake); 485 KUNIT_EXPECT_EQ(test, fake.status, (enum kunit_status)KUNIT_FAILURE); 486 } 487 488 static void kunit_status_mark_skipped_test(struct kunit *test) 489 { 490 struct kunit fake; 491 492 kunit_init_test(&fake, "fake test", NULL); 493 494 /* Before: Should be SUCCESS with no comment. */ 495 KUNIT_EXPECT_EQ(test, fake.status, KUNIT_SUCCESS); 496 KUNIT_EXPECT_STREQ(test, fake.status_comment, ""); 497 498 /* Mark the test as skipped. */ 499 kunit_mark_skipped(&fake, "Accepts format string: %s", "YES"); 500 501 /* After: Should be SKIPPED with our comment. */ 502 KUNIT_EXPECT_EQ(test, fake.status, (enum kunit_status)KUNIT_SKIPPED); 503 KUNIT_EXPECT_STREQ(test, fake.status_comment, "Accepts format string: YES"); 504 } 505 506 static struct kunit_case kunit_status_test_cases[] = { 507 KUNIT_CASE(kunit_status_set_failure_test), 508 KUNIT_CASE(kunit_status_mark_skipped_test), 509 {} 510 }; 511 512 static struct kunit_suite kunit_status_test_suite = { 513 .name = "kunit_status", 514 .test_cases = kunit_status_test_cases, 515 }; 516 517 kunit_test_suites(&kunit_try_catch_test_suite, &kunit_resource_test_suite, 518 &kunit_log_test_suite, &kunit_status_test_suite); 519 520 MODULE_LICENSE("GPL v2"); 521