1 // SPDX-License-Identifier: GPL-2.0 1
2 /*
3 * KUnit test for core test infrastructure.
4 *
5 * Copyright (C) 2019, Google LLC.
6 * Author: Brendan Higgins <brendanhiggins@goo
7 */
8 #include "linux/gfp_types.h"
9 #include <kunit/test.h>
10 #include <kunit/test-bug.h>
11
12 #include <linux/device.h>
13 #include <kunit/device.h>
14
15 #include "string-stream.h"
16 #include "try-catch-impl.h"
17
18 struct kunit_try_catch_test_context {
19 struct kunit_try_catch *try_catch;
20 bool function_called;
21 };
22
23 static void kunit_test_successful_try(void *da
24 {
25 struct kunit *test = data;
26 struct kunit_try_catch_test_context *c
27
28 ctx->function_called = true;
29 }
30
31 static void kunit_test_no_catch(void *data)
32 {
33 struct kunit *test = data;
34
35 KUNIT_FAIL(test, "Catch should not be
36 }
37
38 static void kunit_test_try_catch_successful_tr
39 {
40 struct kunit_try_catch_test_context *c
41 struct kunit_try_catch *try_catch = ct
42
43 kunit_try_catch_init(try_catch,
44 test,
45 kunit_test_succes
46 kunit_test_no_cat
47 kunit_try_catch_run(try_catch, test);
48
49 KUNIT_EXPECT_TRUE(test, ctx->function_
50 }
51
52 static void kunit_test_unsuccessful_try(void *
53 {
54 struct kunit *test = data;
55 struct kunit_try_catch_test_context *c
56 struct kunit_try_catch *try_catch = ct
57
58 kunit_try_catch_throw(try_catch);
59 KUNIT_FAIL(test, "This line should nev
60 }
61
62 static void kunit_test_catch(void *data)
63 {
64 struct kunit *test = data;
65 struct kunit_try_catch_test_context *c
66
67 ctx->function_called = true;
68 }
69
70 static void kunit_test_try_catch_unsuccessful_
71 {
72 struct kunit_try_catch_test_context *c
73 struct kunit_try_catch *try_catch = ct
74
75 kunit_try_catch_init(try_catch,
76 test,
77 kunit_test_unsucc
78 kunit_test_catch)
79 kunit_try_catch_run(try_catch, test);
80
81 KUNIT_EXPECT_TRUE(test, ctx->function_
82 }
83
84 static int kunit_try_catch_test_init(struct ku
85 {
86 struct kunit_try_catch_test_context *c
87
88 ctx = kunit_kzalloc(test, sizeof(*ctx)
89 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx
90 test->priv = ctx;
91
92 ctx->try_catch = kunit_kmalloc(test,
93 sizeof(
94 GFP_KER
95 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx
96
97 return 0;
98 }
99
100 static struct kunit_case kunit_try_catch_test_
101 KUNIT_CASE(kunit_test_try_catch_succes
102 KUNIT_CASE(kunit_test_try_catch_unsucc
103 {}
104 };
105
106 static struct kunit_suite kunit_try_catch_test
107 .name = "kunit-try-catch-test",
108 .init = kunit_try_catch_test_init,
109 .test_cases = kunit_try_catch_test_cas
110 };
111
112 #if IS_ENABLED(CONFIG_KUNIT_FAULT_TEST)
113
114 static void kunit_test_null_dereference(void *
115 {
116 struct kunit *test = data;
117 int *null = NULL;
118
119 *null = 0;
120
121 KUNIT_FAIL(test, "This line should nev
122 }
123
124 static void kunit_test_fault_null_dereference(
125 {
126 struct kunit_try_catch_test_context *c
127 struct kunit_try_catch *try_catch = ct
128
129 kunit_try_catch_init(try_catch,
130 test,
131 kunit_test_null_d
132 kunit_test_catch)
133 kunit_try_catch_run(try_catch, test);
134
135 KUNIT_EXPECT_EQ(test, try_catch->try_r
136 KUNIT_EXPECT_TRUE(test, ctx->function_
137 }
138
139 #endif /* CONFIG_KUNIT_FAULT_TEST */
140
141 static struct kunit_case kunit_fault_test_case
142 #if IS_ENABLED(CONFIG_KUNIT_FAULT_TEST)
143 KUNIT_CASE(kunit_test_fault_null_deref
144 #endif /* CONFIG_KUNIT_FAULT_TEST */
145 {}
146 };
147
148 static struct kunit_suite kunit_fault_test_sui
149 .name = "kunit_fault",
150 .init = kunit_try_catch_test_init,
151 .test_cases = kunit_fault_test_cases,
152 };
153
154 /*
155 * Context for testing test managed resources
156 * is_resource_initialized is used to test arb
157 */
158 struct kunit_test_resource_context {
159 struct kunit test;
160 bool is_resource_initialized;
161 int allocate_order[2];
162 int free_order[4];
163 };
164
165 static int fake_resource_init(struct kunit_res
166 {
167 struct kunit_test_resource_context *ct
168
169 res->data = &ctx->is_resource_initiali
170 ctx->is_resource_initialized = true;
171 return 0;
172 }
173
174 static void fake_resource_free(struct kunit_re
175 {
176 bool *is_resource_initialized = res->d
177
178 *is_resource_initialized = false;
179 }
180
181 static void kunit_resource_test_init_resources
182 {
183 struct kunit_test_resource_context *ct
184
185 kunit_init_test(&ctx->test, "testing_t
186
187 KUNIT_EXPECT_TRUE(test, list_empty(&ct
188 }
189
190 static void kunit_resource_test_alloc_resource
191 {
192 struct kunit_test_resource_context *ct
193 struct kunit_resource *res;
194 kunit_resource_free_t free = fake_reso
195
196 res = kunit_alloc_and_get_resource(&ct
197 fak
198 fak
199 GFP
200 ctx
201
202 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, res
203 KUNIT_EXPECT_PTR_EQ(test,
204 &ctx->is_resource_
205 (bool *)res->data)
206 KUNIT_EXPECT_TRUE(test, list_is_last(&
207 KUNIT_EXPECT_PTR_EQ(test, free, res->f
208
209 kunit_put_resource(res);
210 }
211
212 static inline bool kunit_resource_instance_mat
213
214
215 {
216 return res->data == match_data;
217 }
218
219 /*
220 * Note: tests below use kunit_alloc_and_get_r
221 * they have a reference to the associated res
222 * via kunit_put_resource(). In normal operat
223 * have to do this for cases where they use ku
224 * kunit_alloc_resource() function will be use
225 * resource reference).
226 */
227 static void kunit_resource_test_destroy_resour
228 {
229 struct kunit_test_resource_context *ct
230 struct kunit_resource *res = kunit_all
231 &ctx->test,
232 fake_resource_init,
233 fake_resource_free,
234 GFP_KERNEL,
235 ctx);
236
237 kunit_put_resource(res);
238
239 KUNIT_ASSERT_FALSE(test,
240 kunit_destroy_resou
241
242
243
244 KUNIT_EXPECT_FALSE(test, ctx->is_resou
245 KUNIT_EXPECT_TRUE(test, list_empty(&ct
246 }
247
248 static void kunit_resource_test_remove_resourc
249 {
250 struct kunit_test_resource_context *ct
251 struct kunit_resource *res = kunit_all
252 &ctx->test,
253 fake_resource_init,
254 fake_resource_free,
255 GFP_KERNEL,
256 ctx);
257
258 /* The resource is in the list */
259 KUNIT_EXPECT_FALSE(test, list_empty(&c
260
261 /* Remove the resource. The pointer is
262 * found.
263 */
264 kunit_remove_resource(test, res);
265 KUNIT_EXPECT_TRUE(test, list_empty(&ct
266 /* We haven't been freed yet. */
267 KUNIT_EXPECT_TRUE(test, ctx->is_resour
268
269 /* Removing the resource multiple time
270 kunit_remove_resource(test, res);
271 KUNIT_EXPECT_TRUE(test, list_empty(&ct
272 /* Despite having been removed twice (
273 * resource still has not been freed.
274 */
275 KUNIT_EXPECT_TRUE(test, ctx->is_resour
276
277 /* Free the resource. */
278 kunit_put_resource(res);
279 KUNIT_EXPECT_FALSE(test, ctx->is_resou
280 }
281
282 static void kunit_resource_test_cleanup_resour
283 {
284 int i;
285 struct kunit_test_resource_context *ct
286 struct kunit_resource *resources[5];
287
288 for (i = 0; i < ARRAY_SIZE(resources);
289 resources[i] = kunit_alloc_and
290
291
292
293
294 kunit_put_resource(resources[i
295 }
296
297 kunit_cleanup(&ctx->test);
298
299 KUNIT_EXPECT_TRUE(test, list_empty(&ct
300 }
301
302 static void kunit_resource_test_mark_order(int
303 siz
304 int
305 {
306 int i;
307
308 for (i = 0; i < order_size && order_ar
309 ;
310
311 order_array[i] = key;
312 }
313
314 #define KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, or
315 kunit_resource_test_mark_order
316
317
318
319 static int fake_resource_2_init(struct kunit_r
320 {
321 struct kunit_test_resource_context *ct
322
323 KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, al
324
325 res->data = ctx;
326
327 return 0;
328 }
329
330 static void fake_resource_2_free(struct kunit_
331 {
332 struct kunit_test_resource_context *ct
333
334 KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, fr
335 }
336
337 static int fake_resource_1_init(struct kunit_r
338 {
339 struct kunit_test_resource_context *ct
340 struct kunit_resource *res2;
341
342 res2 = kunit_alloc_and_get_resource(&c
343 fa
344 fa
345 GF
346 ct
347
348 KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, al
349
350 res->data = ctx;
351
352 kunit_put_resource(res2);
353
354 return 0;
355 }
356
357 static void fake_resource_1_free(struct kunit_
358 {
359 struct kunit_test_resource_context *ct
360
361 KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, fr
362 }
363
364 /*
365 * TODO(brendanhiggins@google.com): replace th
366 * order of allocation and freeing with strict
367 * to assert allocation and freeing order when
368 */
369 static void kunit_resource_test_proper_free_or
370 {
371 struct kunit_test_resource_context *ct
372 struct kunit_resource *res;
373
374 /* fake_resource_1 allocates a fake_re
375 res = kunit_alloc_and_get_resource(&ct
376 fak
377 fak
378 GFP
379 ctx
380
381 /*
382 * Since fake_resource_2_init calls KU
383 * before returning to fake_resource_1
384 * put its key in the allocate_order a
385 */
386 KUNIT_EXPECT_EQ(test, ctx->allocate_or
387 KUNIT_EXPECT_EQ(test, ctx->allocate_or
388
389 kunit_put_resource(res);
390
391 kunit_cleanup(&ctx->test);
392
393 /*
394 * Because fake_resource_2 finishes al
395 * fake_resource_1 should be freed fir
396 * fake_resource_2.
397 */
398 KUNIT_EXPECT_EQ(test, ctx->free_order[
399 KUNIT_EXPECT_EQ(test, ctx->free_order[
400 }
401
402 static void kunit_resource_test_static(struct
403 {
404 struct kunit_test_resource_context ctx
405 struct kunit_resource res;
406
407 KUNIT_EXPECT_EQ(test, kunit_add_resour
408 0);
409
410 KUNIT_EXPECT_PTR_EQ(test, res.data, (v
411
412 kunit_cleanup(test);
413
414 KUNIT_EXPECT_TRUE(test, list_empty(&te
415 }
416
417 static void kunit_resource_test_named(struct k
418 {
419 struct kunit_resource res1, res2, *fou
420 struct kunit_test_resource_context ctx
421
422 KUNIT_EXPECT_EQ(test,
423 kunit_add_named_resour
424
425 0);
426 KUNIT_EXPECT_PTR_EQ(test, res1.data, (
427
428 KUNIT_EXPECT_EQ(test,
429 kunit_add_named_resour
430
431 -EEXIST);
432
433 KUNIT_EXPECT_EQ(test,
434 kunit_add_named_resour
435
436 0);
437
438 found = kunit_find_named_resource(test
439
440 KUNIT_EXPECT_PTR_EQ(test, found, &res1
441
442 if (found)
443 kunit_put_resource(&res1);
444
445 KUNIT_EXPECT_EQ(test, kunit_destroy_na
446 0);
447
448 kunit_cleanup(test);
449
450 KUNIT_EXPECT_TRUE(test, list_empty(&te
451 }
452
453 static void increment_int(void *ctx)
454 {
455 int *i = (int *)ctx;
456 (*i)++;
457 }
458
459 static void kunit_resource_test_action(struct
460 {
461 int num_actions = 0;
462
463 kunit_add_action(test, increment_int,
464 KUNIT_EXPECT_EQ(test, num_actions, 0);
465 kunit_cleanup(test);
466 KUNIT_EXPECT_EQ(test, num_actions, 1);
467
468 /* Once we've cleaned up, the action q
469 kunit_cleanup(test);
470 KUNIT_EXPECT_EQ(test, num_actions, 1);
471
472 /* Check the same function can be defe
473 kunit_add_action(test, increment_int,
474 kunit_add_action(test, increment_int,
475 kunit_cleanup(test);
476 KUNIT_EXPECT_EQ(test, num_actions, 3);
477 }
478 static void kunit_resource_test_remove_action(
479 {
480 int num_actions = 0;
481
482 kunit_add_action(test, increment_int,
483 KUNIT_EXPECT_EQ(test, num_actions, 0);
484
485 kunit_remove_action(test, increment_in
486 kunit_cleanup(test);
487 KUNIT_EXPECT_EQ(test, num_actions, 0);
488 }
489 static void kunit_resource_test_release_action
490 {
491 int num_actions = 0;
492
493 kunit_add_action(test, increment_int,
494 KUNIT_EXPECT_EQ(test, num_actions, 0);
495 /* Runs immediately on trigger. */
496 kunit_release_action(test, increment_i
497 KUNIT_EXPECT_EQ(test, num_actions, 1);
498
499 /* Doesn't run again on test exit. */
500 kunit_cleanup(test);
501 KUNIT_EXPECT_EQ(test, num_actions, 1);
502 }
503 static void action_order_1(void *ctx)
504 {
505 struct kunit_test_resource_context *re
506
507 KUNIT_RESOURCE_TEST_MARK_ORDER(res_ctx
508 kunit_log(KERN_INFO, current->kunit_te
509 }
510 static void action_order_2(void *ctx)
511 {
512 struct kunit_test_resource_context *re
513
514 KUNIT_RESOURCE_TEST_MARK_ORDER(res_ctx
515 kunit_log(KERN_INFO, current->kunit_te
516 }
517 static void kunit_resource_test_action_orderin
518 {
519 struct kunit_test_resource_context *ct
520
521 kunit_add_action(test, action_order_1,
522 kunit_add_action(test, action_order_2,
523 kunit_add_action(test, action_order_1,
524 kunit_add_action(test, action_order_2,
525 kunit_remove_action(test, action_order
526 kunit_release_action(test, action_orde
527 kunit_cleanup(test);
528
529 /* [2 is triggered] [2], [(1 is cancel
530 KUNIT_EXPECT_EQ(test, ctx->free_order[
531 KUNIT_EXPECT_EQ(test, ctx->free_order[
532 KUNIT_EXPECT_EQ(test, ctx->free_order[
533 }
534
535 static int kunit_resource_test_init(struct kun
536 {
537 struct kunit_test_resource_context *ct
538 kzalloc(sizeof(*ctx),
539
540 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx
541
542 test->priv = ctx;
543
544 kunit_init_test(&ctx->test, "test_test
545
546 return 0;
547 }
548
549 static void kunit_resource_test_exit(struct ku
550 {
551 struct kunit_test_resource_context *ct
552
553 kunit_cleanup(&ctx->test);
554 kfree(ctx);
555 }
556
557 static struct kunit_case kunit_resource_test_c
558 KUNIT_CASE(kunit_resource_test_init_re
559 KUNIT_CASE(kunit_resource_test_alloc_r
560 KUNIT_CASE(kunit_resource_test_destroy
561 KUNIT_CASE(kunit_resource_test_remove_
562 KUNIT_CASE(kunit_resource_test_cleanup
563 KUNIT_CASE(kunit_resource_test_proper_
564 KUNIT_CASE(kunit_resource_test_static)
565 KUNIT_CASE(kunit_resource_test_named),
566 KUNIT_CASE(kunit_resource_test_action)
567 KUNIT_CASE(kunit_resource_test_remove_
568 KUNIT_CASE(kunit_resource_test_release
569 KUNIT_CASE(kunit_resource_test_action_
570 {}
571 };
572
573 static struct kunit_suite kunit_resource_test_
574 .name = "kunit-resource-test",
575 .init = kunit_resource_test_init,
576 .exit = kunit_resource_test_exit,
577 .test_cases = kunit_resource_test_case
578 };
579
580 /*
581 * Log tests call string_stream functions, whi
582 * build this code if this test is built-in.
583 */
584 #if IS_BUILTIN(CONFIG_KUNIT_TEST)
585
586 /* This avoids a cast warning if kfree() is pa
587 KUNIT_DEFINE_ACTION_WRAPPER(kfree_wrapper, kfr
588
589 static void kunit_log_test(struct kunit *test)
590 {
591 struct kunit_suite suite;
592 #ifdef CONFIG_KUNIT_DEBUGFS
593 char *full_log;
594 #endif
595 suite.log = kunit_alloc_string_stream(
596 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sui
597 string_stream_set_append_newlines(suit
598
599 kunit_log(KERN_INFO, test, "put this i
600 kunit_log(KERN_INFO, test, "this too."
601 kunit_log(KERN_INFO, &suite, "add to s
602 kunit_log(KERN_INFO, &suite, "along wi
603
604 #ifdef CONFIG_KUNIT_DEBUGFS
605 KUNIT_EXPECT_TRUE(test, test->log->app
606
607 full_log = string_stream_get_string(te
608 kunit_add_action(test, kfree_wrapper,
609 KUNIT_EXPECT_NOT_ERR_OR_NULL(test,
610 strstr(fu
611 KUNIT_EXPECT_NOT_ERR_OR_NULL(test,
612 strstr(fu
613
614 full_log = string_stream_get_string(su
615 kunit_add_action(test, kfree_wrapper,
616 KUNIT_EXPECT_NOT_ERR_OR_NULL(test,
617 strstr(fu
618 KUNIT_EXPECT_NOT_ERR_OR_NULL(test,
619 strstr(fu
620 #else
621 KUNIT_EXPECT_NULL(test, test->log);
622 #endif
623 }
624
625 static void kunit_log_newline_test(struct kuni
626 {
627 char *full_log;
628
629 kunit_info(test, "Add newline\n");
630 if (test->log) {
631 full_log = string_stream_get_s
632 kunit_add_action(test, kfree_w
633 KUNIT_ASSERT_NOT_NULL_MSG(test
634 "Missing log line, ful
635 KUNIT_EXPECT_NULL(test, strstr
636 } else {
637 kunit_skip(test, "only useful
638 }
639 }
640 #else
641 static void kunit_log_test(struct kunit *test)
642 {
643 kunit_skip(test, "Log tests only run w
644 }
645
646 static void kunit_log_newline_test(struct kuni
647 {
648 kunit_skip(test, "Log tests only run w
649 }
650 #endif /* IS_BUILTIN(CONFIG_KUNIT_TEST) */
651
652 static struct kunit_case kunit_log_test_cases[
653 KUNIT_CASE(kunit_log_test),
654 KUNIT_CASE(kunit_log_newline_test),
655 {}
656 };
657
658 static struct kunit_suite kunit_log_test_suite
659 .name = "kunit-log-test",
660 .test_cases = kunit_log_test_cases,
661 };
662
663 static void kunit_status_set_failure_test(stru
664 {
665 struct kunit fake;
666
667 kunit_init_test(&fake, "fake test", NU
668
669 KUNIT_EXPECT_EQ(test, fake.status, (en
670 kunit_set_failure(&fake);
671 KUNIT_EXPECT_EQ(test, fake.status, (en
672 }
673
674 static void kunit_status_mark_skipped_test(str
675 {
676 struct kunit fake;
677
678 kunit_init_test(&fake, "fake test", NU
679
680 /* Before: Should be SUCCESS with no c
681 KUNIT_EXPECT_EQ(test, fake.status, KUN
682 KUNIT_EXPECT_STREQ(test, fake.status_c
683
684 /* Mark the test as skipped. */
685 kunit_mark_skipped(&fake, "Accepts for
686
687 /* After: Should be SKIPPED with our c
688 KUNIT_EXPECT_EQ(test, fake.status, (en
689 KUNIT_EXPECT_STREQ(test, fake.status_c
690 }
691
692 static struct kunit_case kunit_status_test_cas
693 KUNIT_CASE(kunit_status_set_failure_te
694 KUNIT_CASE(kunit_status_mark_skipped_t
695 {}
696 };
697
698 static struct kunit_suite kunit_status_test_su
699 .name = "kunit_status",
700 .test_cases = kunit_status_test_cases,
701 };
702
703 static void kunit_current_test(struct kunit *t
704 {
705 /* Check results of both current->kuni
706 * kunit_get_current_test() are equiva
707 */
708 KUNIT_EXPECT_PTR_EQ(test, test, curren
709 KUNIT_EXPECT_PTR_EQ(test, test, kunit_
710 }
711
712 static void kunit_current_fail_test(struct kun
713 {
714 struct kunit fake;
715
716 kunit_init_test(&fake, "fake test", NU
717 KUNIT_EXPECT_EQ(test, fake.status, KUN
718
719 /* Set current->kunit_test to fake tes
720 current->kunit_test = &fake;
721
722 kunit_fail_current_test("This should m
723 KUNIT_EXPECT_EQ(test, fake.status, (en
724 kunit_cleanup(&fake);
725
726 /* Reset current->kunit_test to curren
727 current->kunit_test = test;
728 }
729
730 static struct kunit_case kunit_current_test_ca
731 KUNIT_CASE(kunit_current_test),
732 KUNIT_CASE(kunit_current_fail_test),
733 {}
734 };
735
736 static void test_dev_action(void *priv)
737 {
738 *(void **)priv = (void *)1;
739 }
740
741 static void kunit_device_test(struct kunit *te
742 {
743 struct device *test_device;
744 long action_was_run = 0;
745
746 test_device = kunit_device_register(te
747 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, tes
748
749 // Add an action to verify cleanup.
750 devm_add_action(test_device, test_dev_
751
752 KUNIT_EXPECT_EQ(test, action_was_run,
753
754 kunit_device_unregister(test, test_dev
755
756 KUNIT_EXPECT_EQ(test, action_was_run,
757 }
758
759 static void kunit_device_cleanup_test(struct k
760 {
761 struct device *test_device;
762 long action_was_run = 0;
763
764 test_device = kunit_device_register(te
765 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, tes
766
767 /* Add an action to verify cleanup. */
768 devm_add_action(test_device, test_dev_
769
770 KUNIT_EXPECT_EQ(test, action_was_run,
771
772 /* Force KUnit to run cleanup early. *
773 kunit_cleanup(test);
774
775 KUNIT_EXPECT_EQ(test, action_was_run,
776 }
777
778 struct driver_test_state {
779 bool driver_device_probed;
780 bool driver_device_removed;
781 long action_was_run;
782 };
783
784 static int driver_probe_hook(struct device *de
785 {
786 struct kunit *test = kunit_get_current
787 struct driver_test_state *state = (str
788
789 state->driver_device_probed = true;
790 return 0;
791 }
792
793 static int driver_remove_hook(struct device *d
794 {
795 struct kunit *test = kunit_get_current
796 struct driver_test_state *state = (str
797
798 state->driver_device_removed = true;
799 return 0;
800 }
801
802 static void kunit_device_driver_test(struct ku
803 {
804 struct device_driver *test_driver;
805 struct device *test_device;
806 struct driver_test_state *test_state =
807
808 test->priv = test_state;
809 test_driver = kunit_driver_create(test
810
811 // This can fail with an error pointer
812 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, tes
813
814 test_driver->probe = driver_probe_hook
815 test_driver->remove = driver_remove_ho
816
817 test_device = kunit_device_register_wi
818
819 // This can fail with an error pointer
820 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, tes
821
822 // Make sure the probe function was ca
823 KUNIT_ASSERT_TRUE(test, test_state->dr
824
825 // Add an action to verify cleanup.
826 devm_add_action(test_device, test_dev_
827
828 KUNIT_EXPECT_EQ(test, test_state->acti
829
830 kunit_device_unregister(test, test_dev
831 test_device = NULL;
832
833 // Make sure the remove hook was calle
834 KUNIT_ASSERT_TRUE(test, test_state->dr
835
836 // We're going to test this again.
837 test_state->driver_device_probed = fal
838
839 // The driver should not automatically
840 // kunit_device_unregister, so we can
841 test_device = kunit_device_register_wi
842
843 // This can fail with an error pointer
844 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, tes
845
846 // Probe was called again.
847 KUNIT_ASSERT_TRUE(test, test_state->dr
848
849 // Everything is automatically freed h
850 }
851
852 static struct kunit_case kunit_device_test_cas
853 KUNIT_CASE(kunit_device_test),
854 KUNIT_CASE(kunit_device_cleanup_test),
855 KUNIT_CASE(kunit_device_driver_test),
856 {}
857 };
858
859 static struct kunit_suite kunit_device_test_su
860 .name = "kunit_device",
861 .test_cases = kunit_device_test_cases,
862 };
863
864 static struct kunit_suite kunit_current_test_s
865 .name = "kunit_current",
866 .test_cases = kunit_current_test_cases
867 };
868
869 kunit_test_suites(&kunit_try_catch_test_suite,
870 &kunit_log_test_suite, &kuni
871 &kunit_current_test_suite, &
872 &kunit_fault_test_suite);
873
874 MODULE_DESCRIPTION("KUnit test for core test i
875 MODULE_LICENSE("GPL v2");
876
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.