// SPDX-License-Identifier: GPL-2.0/* * KUnit test for core test infrastructure. * * Copyright (C) 2019, Google LLC. * Author: Brendan Higgins <brendanhiggins@google.com> */#include "linux/gfp_types.h"#include <kunit/test.h>#include <kunit/test-bug.h>#include <kunit/static_stub.h> #include <linux/device.h>#include <kunit/device.h> #include "string-stream.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, 300 * msecs_to_jiffies(MSEC_PER_SEC)); 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, 300 * msecs_to_jiffies(MSEC_PER_SEC)); 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,}; #if IS_ENABLED(CONFIG_KUNIT_FAULT_TEST) static void kunit_test_null_dereference(void *data){ struct kunit *test = data; int *null = NULL; *null = 0; KUNIT_FAIL(test, "This line should never be reached\n");} static void kunit_test_fault_null_dereference(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_null_dereference, kunit_test_catch, 300 * msecs_to_jiffies(MSEC_PER_SEC)); kunit_try_catch_run(try_catch, test); KUNIT_EXPECT_EQ(test, try_catch->try_result, -EINTR); KUNIT_EXPECT_TRUE(test, ctx->function_called);} #endif /* CONFIG_KUNIT_FAULT_TEST */ static struct kunit_case kunit_fault_test_cases[] = {#if IS_ENABLED(CONFIG_KUNIT_FAULT_TEST) KUNIT_CASE(kunit_test_fault_null_dereference),#endif /* CONFIG_KUNIT_FAULT_TEST */ {}}; static struct kunit_suite kunit_fault_test_suite = { .name = "kunit_fault", .init = kunit_try_catch_test_init, .test_cases = kunit_fault_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[4];}; 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);} static inline bool kunit_resource_instance_match(struct kunit *test, struct kunit_resource *res, void *match_data){ return res->data == match_data;} /* * 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_remove_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); /* The resource is in the list */ KUNIT_EXPECT_FALSE(test, list_empty(&ctx->test.resources)); /* Remove the resource. The pointer is still valid, but it can't be * found. */ kunit_remove_resource(test, res); KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); /* We haven't been freed yet. */ KUNIT_EXPECT_TRUE(test, ctx->is_resource_initialized); /* Removing the resource multiple times is valid. */ kunit_remove_resource(test, res); KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); /* Despite having been removed twice (from only one reference), the * resource still has not been freed. */ KUNIT_EXPECT_TRUE(test, ctx->is_resource_initialized); /* Free the resource. */ kunit_put_resource(res); KUNIT_EXPECT_FALSE(test, ctx->is_resource_initialized);} 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 void increment_int(void *ctx){ int *i = (int *)ctx; (*i)++;} static void kunit_resource_test_action(struct kunit *test){ int num_actions = 0; kunit_add_action(test, increment_int, &num_actions); KUNIT_EXPECT_EQ(test, num_actions, 0); kunit_cleanup(test); KUNIT_EXPECT_EQ(test, num_actions, 1); /* Once we've cleaned up, the action queue is empty. */ kunit_cleanup(test); KUNIT_EXPECT_EQ(test, num_actions, 1); /* Check the same function can be deferred multiple times. */ kunit_add_action(test, increment_int, &num_actions); kunit_add_action(test, increment_int, &num_actions); kunit_cleanup(test); KUNIT_EXPECT_EQ(test, num_actions, 3);}static void kunit_resource_test_remove_action(struct kunit *test){ int num_actions = 0; kunit_add_action(test, increment_int, &num_actions); KUNIT_EXPECT_EQ(test, num_actions, 0); kunit_remove_action(test, increment_int, &num_actions); kunit_cleanup(test); KUNIT_EXPECT_EQ(test, num_actions, 0);}static void kunit_resource_test_release_action(struct kunit *test){ int num_actions = 0; kunit_add_action(test, increment_int, &num_actions); KUNIT_EXPECT_EQ(test, num_actions, 0); /* Runs immediately on trigger. */ kunit_release_action(test, increment_int, &num_actions);Lines 1–500 of 923. Load more
// SPDX-License-Identifier: GPL-2.0 /* * KUnit test for core test infrastructure. * * Copyright (C) 2019, Google LLC. * Author: Brendan Higgins <brendanhiggins@google.com> */ #include "linux/gfp_types.h" #include <kunit/test.h> #include <kunit/test-bug.h> #include <kunit/static_stub.h> #include <linux/device.h> #include <kunit/device.h> #include "string-stream.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, 300 * msecs_to_jiffies(MSEC_PER_SEC)); 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, 300 * msecs_to_jiffies(MSEC_PER_SEC)); 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, }; #if IS_ENABLED(CONFIG_KUNIT_FAULT_TEST) static void kunit_test_null_dereference(void *data) { struct kunit *test = data; int *null = NULL; *null = 0; KUNIT_FAIL(test, "This line should never be reached\n"); } static void kunit_test_fault_null_dereference(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_null_dereference, kunit_test_catch, 300 * msecs_to_jiffies(MSEC_PER_SEC)); kunit_try_catch_run(try_catch, test); KUNIT_EXPECT_EQ(test, try_catch->try_result, -EINTR); KUNIT_EXPECT_TRUE(test, ctx->function_called); } #endif /* CONFIG_KUNIT_FAULT_TEST */ static struct kunit_case kunit_fault_test_cases[] = { #if IS_ENABLED(CONFIG_KUNIT_FAULT_TEST) KUNIT_CASE(kunit_test_fault_null_dereference), #endif /* CONFIG_KUNIT_FAULT_TEST */ {} }; static struct kunit_suite kunit_fault_test_suite = { .name = "kunit_fault", .init = kunit_try_catch_test_init, .test_cases = kunit_fault_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[4]; }; 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); } static inline bool kunit_resource_instance_match(struct kunit *test, struct kunit_resource *res, void *match_data) { return res->data == match_data; } /* * 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_remove_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); /* The resource is in the list */ KUNIT_EXPECT_FALSE(test, list_empty(&ctx->test.resources)); /* Remove the resource. The pointer is still valid, but it can't be * found. */ kunit_remove_resource(test, res); KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); /* We haven't been freed yet. */ KUNIT_EXPECT_TRUE(test, ctx->is_resource_initialized); /* Removing the resource multiple times is valid. */ kunit_remove_resource(test, res); KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); /* Despite having been removed twice (from only one reference), the * resource still has not been freed. */ KUNIT_EXPECT_TRUE(test, ctx->is_resource_initialized); /* Free the resource. */ kunit_put_resource(res); KUNIT_EXPECT_FALSE(test, ctx->is_resource_initialized); } 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 void increment_int(void *ctx) { int *i = (int *)ctx; (*i)++; } static void kunit_resource_test_action(struct kunit *test) { int num_actions = 0; kunit_add_action(test, increment_int, &num_actions); KUNIT_EXPECT_EQ(test, num_actions, 0); kunit_cleanup(test); KUNIT_EXPECT_EQ(test, num_actions, 1); /* Once we've cleaned up, the action queue is empty. */ kunit_cleanup(test); KUNIT_EXPECT_EQ(test, num_actions, 1); /* Check the same function can be deferred multiple times. */ kunit_add_action(test, increment_int, &num_actions); kunit_add_action(test, increment_int, &num_actions); kunit_cleanup(test); KUNIT_EXPECT_EQ(test, num_actions, 3); } static void kunit_resource_test_remove_action(struct kunit *test) { int num_actions = 0; kunit_add_action(test, increment_int, &num_actions); KUNIT_EXPECT_EQ(test, num_actions, 0); kunit_remove_action(test, increment_int, &num_actions); kunit_cleanup(test); KUNIT_EXPECT_EQ(test, num_actions, 0); } static void kunit_resource_test_release_action(struct kunit *test) { int num_actions = 0; kunit_add_action(test, increment_int, &num_actions); KUNIT_EXPECT_EQ(test, num_actions, 0); /* Runs immediately on trigger. */ kunit_release_action(test, increment_int, &num_actions);