// SPDX-License-Identifier: GPL-2.0/* * KUnit test for core test infrastructure. * * Copyright (C) 2019, Google LLC. * Author: Brendan Higgins <brendanhiggins@google.com> */#include <kunit/test.h> #include "try-catch-impl.h" struct kunit_try_catch_test_context {	struct kunit_try_catch *try_catch;	bool function_called;}; static void kunit_test_successful_try(void *data){	struct kunit *test = data;	struct kunit_try_catch_test_context *ctx = test->priv; 	ctx->function_called = true;} static void kunit_test_no_catch(void *data){	struct kunit *test = data; 	KUNIT_FAIL(test, "Catch should not be called\n");} static void kunit_test_try_catch_successful_try_no_catch(struct kunit *test){	struct kunit_try_catch_test_context *ctx = test->priv;	struct kunit_try_catch *try_catch = ctx->try_catch; 	kunit_try_catch_init(try_catch,			     test,			     kunit_test_successful_try,			     kunit_test_no_catch);	kunit_try_catch_run(try_catch, test); 	KUNIT_EXPECT_TRUE(test, ctx->function_called);} static void kunit_test_unsuccessful_try(void *data){	struct kunit *test = data;	struct kunit_try_catch_test_context *ctx = test->priv;	struct kunit_try_catch *try_catch = ctx->try_catch; 	kunit_try_catch_throw(try_catch);	KUNIT_FAIL(test, "This line should never be reached\n");} static void kunit_test_catch(void *data){	struct kunit *test = data;	struct kunit_try_catch_test_context *ctx = test->priv; 	ctx->function_called = true;} static void kunit_test_try_catch_unsuccessful_try_does_catch(struct kunit *test){	struct kunit_try_catch_test_context *ctx = test->priv;	struct kunit_try_catch *try_catch = ctx->try_catch; 	kunit_try_catch_init(try_catch,			     test,			     kunit_test_unsuccessful_try,			     kunit_test_catch);	kunit_try_catch_run(try_catch, test); 	KUNIT_EXPECT_TRUE(test, ctx->function_called);} static int kunit_try_catch_test_init(struct kunit *test){	struct kunit_try_catch_test_context *ctx; 	ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);	test->priv = ctx; 	ctx->try_catch = kunit_kmalloc(test,				       sizeof(*ctx->try_catch),				       GFP_KERNEL);	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->try_catch); 	return 0;} static struct kunit_case kunit_try_catch_test_cases[] = {	KUNIT_CASE(kunit_test_try_catch_successful_try_no_catch),	KUNIT_CASE(kunit_test_try_catch_unsuccessful_try_does_catch),	{}}; static struct kunit_suite kunit_try_catch_test_suite = {	.name = "kunit-try-catch-test",	.init = kunit_try_catch_test_init,	.test_cases = kunit_try_catch_test_cases,}; /* * Context for testing test managed resources * is_resource_initialized is used to test arbitrary resources */struct kunit_test_resource_context {	struct kunit test;	bool is_resource_initialized;	int allocate_order[2];	int free_order[2];}; static int fake_resource_init(struct kunit_resource *res, void *context){	struct kunit_test_resource_context *ctx = context; 	res->data = &ctx->is_resource_initialized;	ctx->is_resource_initialized = true;	return 0;} static void fake_resource_free(struct kunit_resource *res){	bool *is_resource_initialized = res->data; 	*is_resource_initialized = false;} static void kunit_resource_test_init_resources(struct kunit *test){	struct kunit_test_resource_context *ctx = test->priv; 	kunit_init_test(&ctx->test, "testing_test_init_test", NULL); 	KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources));} static void kunit_resource_test_alloc_resource(struct kunit *test){	struct kunit_test_resource_context *ctx = test->priv;	struct kunit_resource *res;	kunit_resource_free_t free = fake_resource_free; 	res = kunit_alloc_and_get_resource(&ctx->test,					   fake_resource_init,					   fake_resource_free,					   GFP_KERNEL,					   ctx); 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, res);	KUNIT_EXPECT_PTR_EQ(test,			    &ctx->is_resource_initialized,			    (bool *)res->data);	KUNIT_EXPECT_TRUE(test, list_is_last(&res->node, &ctx->test.resources));	KUNIT_EXPECT_PTR_EQ(test, free, res->free); 	kunit_put_resource(res);} /* * Note: tests below use kunit_alloc_and_get_resource(), so as a consequence * they have a reference to the associated resource that they must release * via kunit_put_resource().  In normal operation, users will only * have to do this for cases where they use kunit_find_resource(), and the * kunit_alloc_resource() function will be used (which does not take a * resource reference). */static void kunit_resource_test_destroy_resource(struct kunit *test){	struct kunit_test_resource_context *ctx = test->priv;	struct kunit_resource *res = kunit_alloc_and_get_resource(			&ctx->test,			fake_resource_init,			fake_resource_free,			GFP_KERNEL,			ctx); 	kunit_put_resource(res); 	KUNIT_ASSERT_FALSE(test,			   kunit_destroy_resource(&ctx->test,						  kunit_resource_instance_match,						  res->data)); 	KUNIT_EXPECT_FALSE(test, ctx->is_resource_initialized);	KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources));} static void kunit_resource_test_cleanup_resources(struct kunit *test){	int i;	struct kunit_test_resource_context *ctx = test->priv;	struct kunit_resource *resources[5]; 	for (i = 0; i < ARRAY_SIZE(resources); i++) {		resources[i] = kunit_alloc_and_get_resource(&ctx->test,							    fake_resource_init,							    fake_resource_free,							    GFP_KERNEL,							    ctx);		kunit_put_resource(resources[i]);	} 	kunit_cleanup(&ctx->test); 	KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources));} static void kunit_resource_test_mark_order(int order_array[],					   size_t order_size,					   int key){	int i; 	for (i = 0; i < order_size && order_array[i]; i++)		; 	order_array[i] = key;} #define KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, order_field, key)		       \		kunit_resource_test_mark_order(ctx->order_field,	       \					       ARRAY_SIZE(ctx->order_field),   \					       key) static int fake_resource_2_init(struct kunit_resource *res, void *context){	struct kunit_test_resource_context *ctx = context; 	KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, allocate_order, 2); 	res->data = ctx; 	return 0;} static void fake_resource_2_free(struct kunit_resource *res){	struct kunit_test_resource_context *ctx = res->data; 	KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, free_order, 2);} static int fake_resource_1_init(struct kunit_resource *res, void *context){	struct kunit_test_resource_context *ctx = context;	struct kunit_resource *res2; 	res2 = kunit_alloc_and_get_resource(&ctx->test,					    fake_resource_2_init,					    fake_resource_2_free,					    GFP_KERNEL,					    ctx); 	KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, allocate_order, 1); 	res->data = ctx; 	kunit_put_resource(res2); 	return 0;} static void fake_resource_1_free(struct kunit_resource *res){	struct kunit_test_resource_context *ctx = res->data; 	KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, free_order, 1);} /* * TODO(brendanhiggins@google.com): replace the arrays that keep track of the * order of allocation and freeing with strict mocks using the IN_SEQUENCE macro * to assert allocation and freeing order when the feature becomes available. */static void kunit_resource_test_proper_free_ordering(struct kunit *test){	struct kunit_test_resource_context *ctx = test->priv;	struct kunit_resource *res; 	/* fake_resource_1 allocates a fake_resource_2 in its init. */	res = kunit_alloc_and_get_resource(&ctx->test,					   fake_resource_1_init,					   fake_resource_1_free,					   GFP_KERNEL,					   ctx); 	/*	 * Since fake_resource_2_init calls KUNIT_RESOURCE_TEST_MARK_ORDER	 * before returning to fake_resource_1_init, it should be the first to	 * put its key in the allocate_order array.	 */	KUNIT_EXPECT_EQ(test, ctx->allocate_order[0], 2);	KUNIT_EXPECT_EQ(test, ctx->allocate_order[1], 1); 	kunit_put_resource(res); 	kunit_cleanup(&ctx->test); 	/*	 * Because fake_resource_2 finishes allocation before fake_resource_1,	 * fake_resource_1 should be freed first since it could depend on	 * fake_resource_2.	 */	KUNIT_EXPECT_EQ(test, ctx->free_order[0], 1);	KUNIT_EXPECT_EQ(test, ctx->free_order[1], 2);} static void kunit_resource_test_static(struct kunit *test){	struct kunit_test_resource_context ctx;	struct kunit_resource res; 	KUNIT_EXPECT_EQ(test, kunit_add_resource(test, NULL, NULL, &res, &ctx),			0); 	KUNIT_EXPECT_PTR_EQ(test, res.data, (void *)&ctx); 	kunit_cleanup(test); 	KUNIT_EXPECT_TRUE(test, list_empty(&test->resources));} static void kunit_resource_test_named(struct kunit *test){	struct kunit_resource res1, res2, *found = NULL;	struct kunit_test_resource_context ctx; 	KUNIT_EXPECT_EQ(test,			kunit_add_named_resource(test, NULL, NULL, &res1,						 "resource_1", &ctx),			0);	KUNIT_EXPECT_PTR_EQ(test, res1.data, (void *)&ctx); 	KUNIT_EXPECT_EQ(test,			kunit_add_named_resource(test, NULL, NULL, &res1,						 "resource_1", &ctx),			-EEXIST); 	KUNIT_EXPECT_EQ(test,			kunit_add_named_resource(test, NULL, NULL, &res2,						 "resource_2", &ctx),			0); 	found = kunit_find_named_resource(test, "resource_1"); 	KUNIT_EXPECT_PTR_EQ(test, found, &res1); 	if (found)		kunit_put_resource(&res1); 	KUNIT_EXPECT_EQ(test, kunit_destroy_named_resource(test, "resource_2"),			0); 	kunit_cleanup(test); 	KUNIT_EXPECT_TRUE(test, list_empty(&test->resources));} static int kunit_resource_test_init(struct kunit *test){	struct kunit_test_resource_context *ctx =			kzalloc(sizeof(*ctx), GFP_KERNEL); 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 	test->priv = ctx; 	kunit_init_test(&ctx->test, "test_test_context", NULL); 	return 0;} static void kunit_resource_test_exit(struct kunit *test){	struct kunit_test_resource_context *ctx = test->priv; 	kunit_cleanup(&ctx->test);	kfree(ctx);} static struct kunit_case kunit_resource_test_cases[] = {	KUNIT_CASE(kunit_resource_test_init_resources),	KUNIT_CASE(kunit_resource_test_alloc_resource),	KUNIT_CASE(kunit_resource_test_destroy_resource),	KUNIT_CASE(kunit_resource_test_cleanup_resources),	KUNIT_CASE(kunit_resource_test_proper_free_ordering),	KUNIT_CASE(kunit_resource_test_static),	KUNIT_CASE(kunit_resource_test_named),	{}}; static struct kunit_suite kunit_resource_test_suite = {	.name = "kunit-resource-test",	.init = kunit_resource_test_init,	.exit = kunit_resource_test_exit,	.test_cases = kunit_resource_test_cases,}; static void kunit_log_test(struct kunit *test); static struct kunit_case kunit_log_test_cases[] = {	KUNIT_CASE(kunit_log_test),	{}}; static struct kunit_suite kunit_log_test_suite = {	.name = "kunit-log-test",	.test_cases = kunit_log_test_cases,}; static void kunit_log_test(struct kunit *test){	struct kunit_suite *suite = &kunit_log_test_suite; 	kunit_log(KERN_INFO, test, "put this in log.");	kunit_log(KERN_INFO, test, "this too.");	kunit_log(KERN_INFO, suite, "add to suite log.");	kunit_log(KERN_INFO, suite, "along with this."); #ifdef CONFIG_KUNIT_DEBUGFS	KUNIT_EXPECT_NOT_ERR_OR_NULL(test,				     strstr(test->log, "put this in log."));	KUNIT_EXPECT_NOT_ERR_OR_NULL(test,				     strstr(test->log, "this too."));	KUNIT_EXPECT_NOT_ERR_OR_NULL(test,				     strstr(suite->log, "add to suite log."));	KUNIT_EXPECT_NOT_ERR_OR_NULL(test,				     strstr(suite->log, "along with this."));#else	KUNIT_EXPECT_PTR_EQ(test, test->log, (char *)NULL);	KUNIT_EXPECT_PTR_EQ(test, suite->log, (char *)NULL);#endif} kunit_test_suites(&kunit_try_catch_test_suite, &kunit_resource_test_suite,		  &kunit_log_test_suite); MODULE_LICENSE("GPL v2");