lib/kunit/executor_test.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * KUnit test for the KUnit executor.
0004  *
0005  * Copyright (C) 2021, Google LLC.
0006  * Author: Daniel Latypov <dlatypov@google.com>
0007  */
0008
0009 #include <kunit/test.h>
0010
0011 static void kfree_at_end(struct kunit *test, const void *to_free);
0012 static struct kunit_suite *alloc_fake_suite(struct kunit *test,
0013                         const char *suite_name,
0014                         struct kunit_case *test_cases);
0015
0016 static void dummy_test(struct kunit *test) {}
0017
0018 static struct kunit_case dummy_test_cases[] = {
0019     /* .run_case is not important, just needs to be non-NULL */
0020     { .name = "test1", .run_case = dummy_test },
0021     { .name = "test2", .run_case = dummy_test },
0022     {},
0023 };
0024
0025 static void parse_filter_test(struct kunit *test)
0026 {
0027     struct kunit_test_filter filter = {NULL, NULL};
0028
0029     kunit_parse_filter_glob(&filter, "suite");
0030     KUNIT_EXPECT_STREQ(test, filter.suite_glob, "suite");
0031     KUNIT_EXPECT_FALSE(test, filter.test_glob);
0032     kfree(filter.suite_glob);
0033     kfree(filter.test_glob);
0034
0035     kunit_parse_filter_glob(&filter, "suite.test");
0036     KUNIT_EXPECT_STREQ(test, filter.suite_glob, "suite");
0037     KUNIT_EXPECT_STREQ(test, filter.test_glob, "test");
0038     kfree(filter.suite_glob);
0039     kfree(filter.test_glob);
0040 }
0041
0042 static void filter_suites_test(struct kunit *test)
0043 {
0044     struct kunit_suite *subsuite[3] = {NULL, NULL};
0045     struct suite_set suite_set = {.start = subsuite, .end = &subsuite[2]};
0046     struct suite_set got;
0047     int err = 0;
0048
0049     subsuite[0] = alloc_fake_suite(test, "suite1", dummy_test_cases);
0050     subsuite[1] = alloc_fake_suite(test, "suite2", dummy_test_cases);
0051
0052     /* Want: suite1, suite2, NULL -> suite2, NULL */
0053     got = kunit_filter_suites(&suite_set, "suite2", &err);
0054     KUNIT_ASSERT_NOT_ERR_OR_NULL(test, got.start);
0055     KUNIT_ASSERT_EQ(test, err, 0);
0056     kfree_at_end(test, got.start);
0057
0058     /* Validate we just have suite2 */
0059     KUNIT_ASSERT_NOT_ERR_OR_NULL(test, got.start[0]);
0060     KUNIT_EXPECT_STREQ(test, (const char *)got.start[0]->name, "suite2");
0061
0062     /* Contains one element (end is 1 past end) */
0063     KUNIT_ASSERT_EQ(test, got.end - got.start, 1);
0064 }
0065
0066 static void filter_suites_test_glob_test(struct kunit *test)
0067 {
0068     struct kunit_suite *subsuite[3] = {NULL, NULL};
0069     struct suite_set suite_set = {.start = subsuite, .end = &subsuite[2]};
0070     struct suite_set got;
0071     int err = 0;
0072
0073     subsuite[0] = alloc_fake_suite(test, "suite1", dummy_test_cases);
0074     subsuite[1] = alloc_fake_suite(test, "suite2", dummy_test_cases);
0075
0076     /* Want: suite1, suite2, NULL -> suite2 (just test1), NULL */
0077     got = kunit_filter_suites(&suite_set, "suite2.test2", &err);
0078     KUNIT_ASSERT_NOT_ERR_OR_NULL(test, got.start);
0079     KUNIT_ASSERT_EQ(test, err, 0);
0080     kfree_at_end(test, got.start);
0081
0082     /* Validate we just have suite2 */
0083     KUNIT_ASSERT_NOT_ERR_OR_NULL(test, got.start[0]);
0084     KUNIT_EXPECT_STREQ(test, (const char *)got.start[0]->name, "suite2");
0085     KUNIT_ASSERT_EQ(test, got.end - got.start, 1);
0086
0087     /* Now validate we just have test2 */
0088     KUNIT_ASSERT_NOT_ERR_OR_NULL(test, got.start[0]->test_cases);
0089     KUNIT_EXPECT_STREQ(test, (const char *)got.start[0]->test_cases[0].name, "test2");
0090     KUNIT_EXPECT_FALSE(test, got.start[0]->test_cases[1].name);
0091 }
0092
0093 static void filter_suites_to_empty_test(struct kunit *test)
0094 {
0095     struct kunit_suite *subsuite[3] = {NULL, NULL};
0096     struct suite_set suite_set = {.start = subsuite, .end = &subsuite[2]};
0097     struct suite_set got;
0098     int err = 0;
0099
0100     subsuite[0] = alloc_fake_suite(test, "suite1", dummy_test_cases);
0101     subsuite[1] = alloc_fake_suite(test, "suite2", dummy_test_cases);
0102
0103     got = kunit_filter_suites(&suite_set, "not_found", &err);
0104     KUNIT_ASSERT_EQ(test, err, 0);
0105     kfree_at_end(test, got.start); /* just in case */
0106
0107     KUNIT_EXPECT_PTR_EQ_MSG(test, got.start, got.end,
0108                 "should be empty to indicate no match");
0109 }
0110
0111 static struct kunit_case executor_test_cases[] = {
0112     KUNIT_CASE(parse_filter_test),
0113     KUNIT_CASE(filter_suites_test),
0114     KUNIT_CASE(filter_suites_test_glob_test),
0115     KUNIT_CASE(filter_suites_to_empty_test),
0116     {}
0117 };
0118
0119 static struct kunit_suite executor_test_suite = {
0120     .name = "kunit_executor_test",
0121     .test_cases = executor_test_cases,
0122 };
0123
0124 kunit_test_suites(&executor_test_suite);
0125
0126 /* Test helpers */
0127
0128 static void kfree_res_free(struct kunit_resource *res)
0129 {
0130     kfree(res->data);
0131 }
0132
0133 /* Use the resource API to register a call to kfree(to_free).
0134  * Since we never actually use the resource, it's safe to use on const data.
0135  */
0136 static void kfree_at_end(struct kunit *test, const void *to_free)
0137 {
0138     /* kfree() handles NULL already, but avoid allocating a no-op cleanup. */
0139     if (IS_ERR_OR_NULL(to_free))
0140         return;
0141     kunit_alloc_resource(test, NULL, kfree_res_free, GFP_KERNEL,
0142                  (void *)to_free);
0143 }
0144
0145 static struct kunit_suite *alloc_fake_suite(struct kunit *test,
0146                         const char *suite_name,
0147                         struct kunit_case *test_cases)
0148 {
0149     struct kunit_suite *suite;
0150
0151     /* We normally never expect to allocate suites, hence the non-const cast. */
0152     suite = kunit_kzalloc(test, sizeof(*suite), GFP_KERNEL);
0153     strncpy((char *)suite->name, suite_name, sizeof(suite->name) - 1);
0154     suite->test_cases = test_cases;
0155
0156     return suite;
0157 }