interconnect: qcom: icc-rpm: Fix peak rate calculation
[linux-2.6-microblaze.git] / lib / kunit / kunit-test.c
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");