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