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 "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
 18struct kunit_try_catch_test_context {
 19	struct kunit_try_catch *try_catch;
 20	bool function_called;
 21};
 22
 23static void kunit_test_successful_try(void *data)
 24{
 25	struct kunit *test = data;
 26	struct kunit_try_catch_test_context *ctx = test->priv;
 27
 28	ctx->function_called = true;
 29}
 30
 31static void kunit_test_no_catch(void *data)
 32{
 33	struct kunit *test = data;
 34
 35	KUNIT_FAIL(test, "Catch should not be called\n");
 36}
 37
 38static void kunit_test_try_catch_successful_try_no_catch(struct kunit *test)
 39{
 40	struct kunit_try_catch_test_context *ctx = test->priv;
 41	struct kunit_try_catch *try_catch = ctx->try_catch;
 42
 43	kunit_try_catch_init(try_catch,
 44			     test,
 45			     kunit_test_successful_try,
 46			     kunit_test_no_catch);
 47	kunit_try_catch_run(try_catch, test);
 48
 49	KUNIT_EXPECT_TRUE(test, ctx->function_called);
 50}
 51
 52static void kunit_test_unsuccessful_try(void *data)
 53{
 54	struct kunit *test = data;
 55	struct kunit_try_catch_test_context *ctx = test->priv;
 56	struct kunit_try_catch *try_catch = ctx->try_catch;
 57
 58	kunit_try_catch_throw(try_catch);
 59	KUNIT_FAIL(test, "This line should never be reached\n");
 60}
 61
 62static void kunit_test_catch(void *data)
 63{
 64	struct kunit *test = data;
 65	struct kunit_try_catch_test_context *ctx = test->priv;
 66
 67	ctx->function_called = true;
 68}
 69
 70static void kunit_test_try_catch_unsuccessful_try_does_catch(struct kunit *test)
 71{
 72	struct kunit_try_catch_test_context *ctx = test->priv;
 73	struct kunit_try_catch *try_catch = ctx->try_catch;
 74
 75	kunit_try_catch_init(try_catch,
 76			     test,
 77			     kunit_test_unsuccessful_try,
 78			     kunit_test_catch);
 79	kunit_try_catch_run(try_catch, test);
 80
 81	KUNIT_EXPECT_TRUE(test, ctx->function_called);
 82}
 83
 84static int kunit_try_catch_test_init(struct kunit *test)
 85{
 86	struct kunit_try_catch_test_context *ctx;
 87
 88	ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
 89	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
 90	test->priv = ctx;
 91
 92	ctx->try_catch = kunit_kmalloc(test,
 93				       sizeof(*ctx->try_catch),
 94				       GFP_KERNEL);
 95	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->try_catch);
 96
 97	return 0;
 98}
 99
100static struct kunit_case kunit_try_catch_test_cases[] = {
101	KUNIT_CASE(kunit_test_try_catch_successful_try_no_catch),
102	KUNIT_CASE(kunit_test_try_catch_unsuccessful_try_does_catch),
103	{}
104};
105
106static struct kunit_suite kunit_try_catch_test_suite = {
107	.name = "kunit-try-catch-test",
108	.init = kunit_try_catch_test_init,
109	.test_cases = kunit_try_catch_test_cases,
110};
111
112#if IS_ENABLED(CONFIG_KUNIT_FAULT_TEST)
113
114static void kunit_test_null_dereference(void *data)
115{
116	struct kunit *test = data;
117	int *null = NULL;
118
119	*null = 0;
120
121	KUNIT_FAIL(test, "This line should never be reached\n");
122}
123
124static void kunit_test_fault_null_dereference(struct kunit *test)
125{
126	struct kunit_try_catch_test_context *ctx = test->priv;
127	struct kunit_try_catch *try_catch = ctx->try_catch;
128
129	kunit_try_catch_init(try_catch,
130			     test,
131			     kunit_test_null_dereference,
132			     kunit_test_catch);
133	kunit_try_catch_run(try_catch, test);
134
135	KUNIT_EXPECT_EQ(test, try_catch->try_result, -EINTR);
136	KUNIT_EXPECT_TRUE(test, ctx->function_called);
137}
138
139#endif /* CONFIG_KUNIT_FAULT_TEST */
140
141static struct kunit_case kunit_fault_test_cases[] = {
142#if IS_ENABLED(CONFIG_KUNIT_FAULT_TEST)
143	KUNIT_CASE(kunit_test_fault_null_dereference),
144#endif /* CONFIG_KUNIT_FAULT_TEST */
145	{}
146};
147
148static struct kunit_suite kunit_fault_test_suite = {
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 arbitrary resources
157 */
158struct 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
165static int fake_resource_init(struct kunit_resource *res, void *context)
166{
167	struct kunit_test_resource_context *ctx = context;
168
169	res->data = &ctx->is_resource_initialized;
170	ctx->is_resource_initialized = true;
171	return 0;
172}
173
174static void fake_resource_free(struct kunit_resource *res)
175{
176	bool *is_resource_initialized = res->data;
177
178	*is_resource_initialized = false;
179}
180
181static void kunit_resource_test_init_resources(struct kunit *test)
182{
183	struct kunit_test_resource_context *ctx = test->priv;
184
185	kunit_init_test(&ctx->test, "testing_test_init_test", NULL);
186
187	KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources));
188}
189
190static void kunit_resource_test_alloc_resource(struct kunit *test)
191{
192	struct kunit_test_resource_context *ctx = test->priv;
193	struct kunit_resource *res;
194	kunit_resource_free_t free = fake_resource_free;
195
196	res = kunit_alloc_and_get_resource(&ctx->test,
197					   fake_resource_init,
198					   fake_resource_free,
199					   GFP_KERNEL,
200					   ctx);
201
202	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, res);
203	KUNIT_EXPECT_PTR_EQ(test,
204			    &ctx->is_resource_initialized,
205			    (bool *)res->data);
206	KUNIT_EXPECT_TRUE(test, list_is_last(&res->node, &ctx->test.resources));
207	KUNIT_EXPECT_PTR_EQ(test, free, res->free);
208
209	kunit_put_resource(res);
210}
211
212static inline bool kunit_resource_instance_match(struct kunit *test,
213						 struct kunit_resource *res,
214						 void *match_data)
215{
216	return res->data == match_data;
217}
218
219/*
220 * Note: tests below use kunit_alloc_and_get_resource(), so as a consequence
221 * they have a reference to the associated resource that they must release
222 * via kunit_put_resource().  In normal operation, users will only
223 * have to do this for cases where they use kunit_find_resource(), and the
224 * kunit_alloc_resource() function will be used (which does not take a
225 * resource reference).
226 */
227static void kunit_resource_test_destroy_resource(struct kunit *test)
228{
229	struct kunit_test_resource_context *ctx = test->priv;
230	struct kunit_resource *res = kunit_alloc_and_get_resource(
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_resource(&ctx->test,
241						  kunit_resource_instance_match,
242						  res->data));
243
244	KUNIT_EXPECT_FALSE(test, ctx->is_resource_initialized);
245	KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources));
246}
247
248static void kunit_resource_test_remove_resource(struct kunit *test)
249{
250	struct kunit_test_resource_context *ctx = test->priv;
251	struct kunit_resource *res = kunit_alloc_and_get_resource(
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(&ctx->test.resources));
260
261	/* Remove the resource. The pointer is still valid, but it can't be
262	 * found.
263	 */
264	kunit_remove_resource(test, res);
265	KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources));
266	/* We haven't been freed yet. */
267	KUNIT_EXPECT_TRUE(test, ctx->is_resource_initialized);
268
269	/* Removing the resource multiple times is valid. */
270	kunit_remove_resource(test, res);
271	KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources));
272	/* Despite having been removed twice (from only one reference), the
273	 * resource still has not been freed.
274	 */
275	KUNIT_EXPECT_TRUE(test, ctx->is_resource_initialized);
276
277	/* Free the resource. */
278	kunit_put_resource(res);
279	KUNIT_EXPECT_FALSE(test, ctx->is_resource_initialized);
280}
281
282static void kunit_resource_test_cleanup_resources(struct kunit *test)
283{
284	int i;
285	struct kunit_test_resource_context *ctx = test->priv;
286	struct kunit_resource *resources[5];
287
288	for (i = 0; i < ARRAY_SIZE(resources); i++) {
289		resources[i] = kunit_alloc_and_get_resource(&ctx->test,
290							    fake_resource_init,
291							    fake_resource_free,
292							    GFP_KERNEL,
293							    ctx);
294		kunit_put_resource(resources[i]);
295	}
296
297	kunit_cleanup(&ctx->test);
298
299	KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources));
300}
301
302static void kunit_resource_test_mark_order(int order_array[],
303					   size_t order_size,
304					   int key)
305{
306	int i;
307
308	for (i = 0; i < order_size && order_array[i]; i++)
309		;
310
311	order_array[i] = key;
312}
313
314#define KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, order_field, key)		       \
315		kunit_resource_test_mark_order(ctx->order_field,	       \
316					       ARRAY_SIZE(ctx->order_field),   \
317					       key)
318
319static int fake_resource_2_init(struct kunit_resource *res, void *context)
320{
321	struct kunit_test_resource_context *ctx = context;
322
323	KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, allocate_order, 2);
324
325	res->data = ctx;
326
327	return 0;
328}
329
330static void fake_resource_2_free(struct kunit_resource *res)
331{
332	struct kunit_test_resource_context *ctx = res->data;
333
334	KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, free_order, 2);
335}
336
337static int fake_resource_1_init(struct kunit_resource *res, void *context)
338{
339	struct kunit_test_resource_context *ctx = context;
340	struct kunit_resource *res2;
341
342	res2 = kunit_alloc_and_get_resource(&ctx->test,
343					    fake_resource_2_init,
344					    fake_resource_2_free,
345					    GFP_KERNEL,
346					    ctx);
347
348	KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, allocate_order, 1);
349
350	res->data = ctx;
351
352	kunit_put_resource(res2);
353
354	return 0;
355}
356
357static void fake_resource_1_free(struct kunit_resource *res)
358{
359	struct kunit_test_resource_context *ctx = res->data;
360
361	KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, free_order, 1);
362}
363
364/*
365 * TODO(brendanhiggins@google.com): replace the arrays that keep track of the
366 * order of allocation and freeing with strict mocks using the IN_SEQUENCE macro
367 * to assert allocation and freeing order when the feature becomes available.
368 */
369static void kunit_resource_test_proper_free_ordering(struct kunit *test)
370{
371	struct kunit_test_resource_context *ctx = test->priv;
372	struct kunit_resource *res;
373
374	/* fake_resource_1 allocates a fake_resource_2 in its init. */
375	res = kunit_alloc_and_get_resource(&ctx->test,
376					   fake_resource_1_init,
377					   fake_resource_1_free,
378					   GFP_KERNEL,
379					   ctx);
380
381	/*
382	 * Since fake_resource_2_init calls KUNIT_RESOURCE_TEST_MARK_ORDER
383	 * before returning to fake_resource_1_init, it should be the first to
384	 * put its key in the allocate_order array.
385	 */
386	KUNIT_EXPECT_EQ(test, ctx->allocate_order[0], 2);
387	KUNIT_EXPECT_EQ(test, ctx->allocate_order[1], 1);
388
389	kunit_put_resource(res);
390
391	kunit_cleanup(&ctx->test);
392
393	/*
394	 * Because fake_resource_2 finishes allocation before fake_resource_1,
395	 * fake_resource_1 should be freed first since it could depend on
396	 * fake_resource_2.
397	 */
398	KUNIT_EXPECT_EQ(test, ctx->free_order[0], 1);
399	KUNIT_EXPECT_EQ(test, ctx->free_order[1], 2);
400}
401
402static void kunit_resource_test_static(struct kunit *test)
403{
404	struct kunit_test_resource_context ctx;
405	struct kunit_resource res;
406
407	KUNIT_EXPECT_EQ(test, kunit_add_resource(test, NULL, NULL, &res, &ctx),
408			0);
409
410	KUNIT_EXPECT_PTR_EQ(test, res.data, (void *)&ctx);
411
412	kunit_cleanup(test);
413
414	KUNIT_EXPECT_TRUE(test, list_empty(&test->resources));
415}
416
417static void kunit_resource_test_named(struct kunit *test)
418{
419	struct kunit_resource res1, res2, *found = NULL;
420	struct kunit_test_resource_context ctx;
421
422	KUNIT_EXPECT_EQ(test,
423			kunit_add_named_resource(test, NULL, NULL, &res1,
424						 "resource_1", &ctx),
425			0);
426	KUNIT_EXPECT_PTR_EQ(test, res1.data, (void *)&ctx);
427
428	KUNIT_EXPECT_EQ(test,
429			kunit_add_named_resource(test, NULL, NULL, &res1,
430						 "resource_1", &ctx),
431			-EEXIST);
432
433	KUNIT_EXPECT_EQ(test,
434			kunit_add_named_resource(test, NULL, NULL, &res2,
435						 "resource_2", &ctx),
436			0);
437
438	found = kunit_find_named_resource(test, "resource_1");
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_named_resource(test, "resource_2"),
446			0);
447
448	kunit_cleanup(test);
449
450	KUNIT_EXPECT_TRUE(test, list_empty(&test->resources));
451}
452
453static void increment_int(void *ctx)
454{
455	int *i = (int *)ctx;
456	(*i)++;
457}
458
459static void kunit_resource_test_action(struct kunit *test)
460{
461	int num_actions = 0;
462
463	kunit_add_action(test, increment_int, &num_actions);
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 queue is empty. */
469	kunit_cleanup(test);
470	KUNIT_EXPECT_EQ(test, num_actions, 1);
471
472	/* Check the same function can be deferred multiple times. */
473	kunit_add_action(test, increment_int, &num_actions);
474	kunit_add_action(test, increment_int, &num_actions);
475	kunit_cleanup(test);
476	KUNIT_EXPECT_EQ(test, num_actions, 3);
477}
478static void kunit_resource_test_remove_action(struct kunit *test)
479{
480	int num_actions = 0;
481
482	kunit_add_action(test, increment_int, &num_actions);
483	KUNIT_EXPECT_EQ(test, num_actions, 0);
484
485	kunit_remove_action(test, increment_int, &num_actions);
486	kunit_cleanup(test);
487	KUNIT_EXPECT_EQ(test, num_actions, 0);
488}
489static void kunit_resource_test_release_action(struct kunit *test)
490{
491	int num_actions = 0;
492
493	kunit_add_action(test, increment_int, &num_actions);
494	KUNIT_EXPECT_EQ(test, num_actions, 0);
495	/* Runs immediately on trigger. */
496	kunit_release_action(test, increment_int, &num_actions);
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}
503static void action_order_1(void *ctx)
504{
505	struct kunit_test_resource_context *res_ctx = (struct kunit_test_resource_context *)ctx;
506
507	KUNIT_RESOURCE_TEST_MARK_ORDER(res_ctx, free_order, 1);
508	kunit_log(KERN_INFO, current->kunit_test, "action_order_1");
509}
510static void action_order_2(void *ctx)
511{
512	struct kunit_test_resource_context *res_ctx = (struct kunit_test_resource_context *)ctx;
513
514	KUNIT_RESOURCE_TEST_MARK_ORDER(res_ctx, free_order, 2);
515	kunit_log(KERN_INFO, current->kunit_test, "action_order_2");
516}
517static void kunit_resource_test_action_ordering(struct kunit *test)
518{
519	struct kunit_test_resource_context *ctx = test->priv;
520
521	kunit_add_action(test, action_order_1, ctx);
522	kunit_add_action(test, action_order_2, ctx);
523	kunit_add_action(test, action_order_1, ctx);
524	kunit_add_action(test, action_order_2, ctx);
525	kunit_remove_action(test, action_order_1, ctx);
526	kunit_release_action(test, action_order_2, ctx);
527	kunit_cleanup(test);
528
529	/* [2 is triggered] [2], [(1 is cancelled)] [1] */
530	KUNIT_EXPECT_EQ(test, ctx->free_order[0], 2);
531	KUNIT_EXPECT_EQ(test, ctx->free_order[1], 2);
532	KUNIT_EXPECT_EQ(test, ctx->free_order[2], 1);
533}
534
535static int kunit_resource_test_init(struct kunit *test)
536{
537	struct kunit_test_resource_context *ctx =
538			kzalloc(sizeof(*ctx), GFP_KERNEL);
539
540	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
541
542	test->priv = ctx;
543
544	kunit_init_test(&ctx->test, "test_test_context", NULL);
545
546	return 0;
547}
548
549static void kunit_resource_test_exit(struct kunit *test)
550{
551	struct kunit_test_resource_context *ctx = test->priv;
552
553	kunit_cleanup(&ctx->test);
554	kfree(ctx);
555}
556
557static struct kunit_case kunit_resource_test_cases[] = {
558	KUNIT_CASE(kunit_resource_test_init_resources),
559	KUNIT_CASE(kunit_resource_test_alloc_resource),
560	KUNIT_CASE(kunit_resource_test_destroy_resource),
561	KUNIT_CASE(kunit_resource_test_remove_resource),
562	KUNIT_CASE(kunit_resource_test_cleanup_resources),
563	KUNIT_CASE(kunit_resource_test_proper_free_ordering),
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_action),
568	KUNIT_CASE(kunit_resource_test_release_action),
569	KUNIT_CASE(kunit_resource_test_action_ordering),
570	{}
571};
572
573static struct kunit_suite kunit_resource_test_suite = {
574	.name = "kunit-resource-test",
575	.init = kunit_resource_test_init,
576	.exit = kunit_resource_test_exit,
577	.test_cases = kunit_resource_test_cases,
578};
579
580/*
581 * Log tests call string_stream functions, which aren't exported. So only
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 passed direct to kunit_add_action(). */
587KUNIT_DEFINE_ACTION_WRAPPER(kfree_wrapper, kfree, const void *);
588
589static 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(test, GFP_KERNEL);
596	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, suite.log);
597	string_stream_set_append_newlines(suite.log, true);
598
599	kunit_log(KERN_INFO, test, "put this in log.");
600	kunit_log(KERN_INFO, test, "this too.");
601	kunit_log(KERN_INFO, &suite, "add to suite log.");
602	kunit_log(KERN_INFO, &suite, "along with this.");
603
604#ifdef CONFIG_KUNIT_DEBUGFS
605	KUNIT_EXPECT_TRUE(test, test->log->append_newlines);
606
607	full_log = string_stream_get_string(test->log);
608	kunit_add_action(test, kfree_wrapper, full_log);
609	KUNIT_EXPECT_NOT_ERR_OR_NULL(test,
610				     strstr(full_log, "put this in log."));
611	KUNIT_EXPECT_NOT_ERR_OR_NULL(test,
612				     strstr(full_log, "this too."));
613
614	full_log = string_stream_get_string(suite.log);
615	kunit_add_action(test, kfree_wrapper, full_log);
616	KUNIT_EXPECT_NOT_ERR_OR_NULL(test,
617				     strstr(full_log, "add to suite log."));
618	KUNIT_EXPECT_NOT_ERR_OR_NULL(test,
619				     strstr(full_log, "along with this."));
620#else
621	KUNIT_EXPECT_NULL(test, test->log);
622#endif
623}
624
625static void kunit_log_newline_test(struct kunit *test)
626{
627	char *full_log;
628
629	kunit_info(test, "Add newline\n");
630	if (test->log) {
631		full_log = string_stream_get_string(test->log);
632		kunit_add_action(test, kfree_wrapper, full_log);
633		KUNIT_ASSERT_NOT_NULL_MSG(test, strstr(full_log, "Add newline\n"),
634			"Missing log line, full log:\n%s", full_log);
635		KUNIT_EXPECT_NULL(test, strstr(full_log, "Add newline\n\n"));
636	} else {
637		kunit_skip(test, "only useful when debugfs is enabled");
638	}
639}
640#else
641static void kunit_log_test(struct kunit *test)
642{
643	kunit_skip(test, "Log tests only run when built-in");
644}
645
646static void kunit_log_newline_test(struct kunit *test)
647{
648	kunit_skip(test, "Log tests only run when built-in");
649}
650#endif /* IS_BUILTIN(CONFIG_KUNIT_TEST) */
651
652static struct kunit_case kunit_log_test_cases[] = {
653	KUNIT_CASE(kunit_log_test),
654	KUNIT_CASE(kunit_log_newline_test),
655	{}
656};
657
658static struct kunit_suite kunit_log_test_suite = {
659	.name = "kunit-log-test",
660	.test_cases = kunit_log_test_cases,
661};
662
663static void kunit_status_set_failure_test(struct kunit *test)
664{
665	struct kunit fake;
666
667	kunit_init_test(&fake, "fake test", NULL);
668
669	KUNIT_EXPECT_EQ(test, fake.status, (enum kunit_status)KUNIT_SUCCESS);
670	kunit_set_failure(&fake);
671	KUNIT_EXPECT_EQ(test, fake.status, (enum kunit_status)KUNIT_FAILURE);
672}
673
674static void kunit_status_mark_skipped_test(struct kunit *test)
675{
676	struct kunit fake;
677
678	kunit_init_test(&fake, "fake test", NULL);
679
680	/* Before: Should be SUCCESS with no comment. */
681	KUNIT_EXPECT_EQ(test, fake.status, KUNIT_SUCCESS);
682	KUNIT_EXPECT_STREQ(test, fake.status_comment, "");
683
684	/* Mark the test as skipped. */
685	kunit_mark_skipped(&fake, "Accepts format string: %s", "YES");
686
687	/* After: Should be SKIPPED with our comment. */
688	KUNIT_EXPECT_EQ(test, fake.status, (enum kunit_status)KUNIT_SKIPPED);
689	KUNIT_EXPECT_STREQ(test, fake.status_comment, "Accepts format string: YES");
690}
691
692static struct kunit_case kunit_status_test_cases[] = {
693	KUNIT_CASE(kunit_status_set_failure_test),
694	KUNIT_CASE(kunit_status_mark_skipped_test),
695	{}
696};
697
698static struct kunit_suite kunit_status_test_suite = {
699	.name = "kunit_status",
700	.test_cases = kunit_status_test_cases,
701};
702
703static void kunit_current_test(struct kunit *test)
704{
705	/* Check results of both current->kunit_test and
706	 * kunit_get_current_test() are equivalent to current test.
707	 */
708	KUNIT_EXPECT_PTR_EQ(test, test, current->kunit_test);
709	KUNIT_EXPECT_PTR_EQ(test, test, kunit_get_current_test());
710}
711
712static void kunit_current_fail_test(struct kunit *test)
713{
714	struct kunit fake;
715
716	kunit_init_test(&fake, "fake test", NULL);
717	KUNIT_EXPECT_EQ(test, fake.status, KUNIT_SUCCESS);
718
719	/* Set current->kunit_test to fake test. */
720	current->kunit_test = &fake;
721
722	kunit_fail_current_test("This should make `fake` test fail.");
723	KUNIT_EXPECT_EQ(test, fake.status, (enum kunit_status)KUNIT_FAILURE);
724	kunit_cleanup(&fake);
725
726	/* Reset current->kunit_test to current test. */
727	current->kunit_test = test;
728}
729
730static struct kunit_case kunit_current_test_cases[] = {
731	KUNIT_CASE(kunit_current_test),
732	KUNIT_CASE(kunit_current_fail_test),
733	{}
734};
735
736static void test_dev_action(void *priv)
737{
738	*(void **)priv = (void *)1;
739}
740
741static void kunit_device_test(struct kunit *test)
742{
743	struct device *test_device;
744	long action_was_run = 0;
745
746	test_device = kunit_device_register(test, "my_device");
747	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, test_device);
748
749	// Add an action to verify cleanup.
750	devm_add_action(test_device, test_dev_action, &action_was_run);
751
752	KUNIT_EXPECT_EQ(test, action_was_run, 0);
753
754	kunit_device_unregister(test, test_device);
755
756	KUNIT_EXPECT_EQ(test, action_was_run, 1);
757}
758
759static void kunit_device_cleanup_test(struct kunit *test)
760{
761	struct device *test_device;
762	long action_was_run = 0;
763
764	test_device = kunit_device_register(test, "my_device");
765	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, test_device);
766
767	/* Add an action to verify cleanup. */
768	devm_add_action(test_device, test_dev_action, &action_was_run);
769
770	KUNIT_EXPECT_EQ(test, action_was_run, 0);
771
772	/* Force KUnit to run cleanup early. */
773	kunit_cleanup(test);
774
775	KUNIT_EXPECT_EQ(test, action_was_run, 1);
776}
777
778struct driver_test_state {
779	bool driver_device_probed;
780	bool driver_device_removed;
781	long action_was_run;
782};
783
784static int driver_probe_hook(struct device *dev)
785{
786	struct kunit *test = kunit_get_current_test();
787	struct driver_test_state *state = (struct driver_test_state *)test->priv;
788
789	state->driver_device_probed = true;
790	return 0;
791}
792
793static int driver_remove_hook(struct device *dev)
794{
795	struct kunit *test = kunit_get_current_test();
796	struct driver_test_state *state = (struct driver_test_state *)test->priv;
797
798	state->driver_device_removed = true;
799	return 0;
800}
801
802static void kunit_device_driver_test(struct kunit *test)
803{
804	struct device_driver *test_driver;
805	struct device *test_device;
806	struct driver_test_state *test_state = kunit_kzalloc(test, sizeof(*test_state), GFP_KERNEL);
807
808	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, test_state);
809
810	test->priv = test_state;
811	test_driver = kunit_driver_create(test, "my_driver");
812
813	// This can fail with an error pointer.
814	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, test_driver);
815
816	test_driver->probe = driver_probe_hook;
817	test_driver->remove = driver_remove_hook;
818
819	test_device = kunit_device_register_with_driver(test, "my_device", test_driver);
820
821	// This can fail with an error pointer.
822	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, test_device);
823
824	// Make sure the probe function was called.
825	KUNIT_ASSERT_TRUE(test, test_state->driver_device_probed);
826
827	// Add an action to verify cleanup.
828	devm_add_action(test_device, test_dev_action, &test_state->action_was_run);
829
830	KUNIT_EXPECT_EQ(test, test_state->action_was_run, 0);
831
832	kunit_device_unregister(test, test_device);
833	test_device = NULL;
834
835	// Make sure the remove hook was called.
836	KUNIT_ASSERT_TRUE(test, test_state->driver_device_removed);
837
838	// We're going to test this again.
839	test_state->driver_device_probed = false;
840
841	// The driver should not automatically be destroyed by
842	// kunit_device_unregister, so we can re-use it.
843	test_device = kunit_device_register_with_driver(test, "my_device", test_driver);
844
845	// This can fail with an error pointer.
846	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, test_device);
847
848	// Probe was called again.
849	KUNIT_ASSERT_TRUE(test, test_state->driver_device_probed);
850
851	// Everything is automatically freed here.
852}
853
854static struct kunit_case kunit_device_test_cases[] = {
855	KUNIT_CASE(kunit_device_test),
856	KUNIT_CASE(kunit_device_cleanup_test),
857	KUNIT_CASE(kunit_device_driver_test),
858	{}
859};
860
861static struct kunit_suite kunit_device_test_suite = {
862	.name = "kunit_device",
863	.test_cases = kunit_device_test_cases,
864};
865
866static struct kunit_suite kunit_current_test_suite = {
867	.name = "kunit_current",
868	.test_cases = kunit_current_test_cases,
869};
870
871kunit_test_suites(&kunit_try_catch_test_suite, &kunit_resource_test_suite,
872		  &kunit_log_test_suite, &kunit_status_test_suite,
873		  &kunit_current_test_suite, &kunit_device_test_suite,
874		  &kunit_fault_test_suite);
875
876MODULE_DESCRIPTION("KUnit test for core test infrastructure");
877MODULE_LICENSE("GPL v2");