kunit: Add parent kunit for parameterized test context

Currently, KUnit parameterized tests lack a mechanism to share
resources across parameter runs because the same `struct kunit`
instance is cleaned up and reused for each run.

This patch introduces parameterized test context, enabling test
users to share resources between parameter runs. It also allows
setting up resources that need to be available for all parameter
runs only once, which is helpful in cases where setup is expensive.

To establish a parameterized test context, this patch adds a
parent pointer field to `struct kunit`. This allows resources added
to the parent `struct kunit` to be shared and accessible across all
parameter runs.

In kunit_run_tests(), the default `struct kunit` created is now
designated to act as the parameterized test context whenever a test
is parameterized.

Subsequently, a new `struct kunit` is made for each parameter run, and
its parent pointer is set to the `struct kunit` that holds the
parameterized test context.

Link: https://lore.kernel.org/r/20250826091341.1427123-2-davidgow@google.com
Reviewed-by: David Gow <davidgow@google.com>
Reviewed-by: Rae Moar <rmoar@google.com>
Signed-off-by: Marie Zhussupova <marievic@google.com>
Signed-off-by: David Gow <davidgow@google.com>
Signed-off-by: Shuah Khan <skhan@linuxfoundation.org>

diff --git a/include/kunit/test.h b/include/kunit/test.h
index d958ee53050e1f5b13d73c788798e1c1567bce27..9766403afd564ecdea9354b691434466aa40728c 100644 (file)
--- a/include/kunit/test.h
+++ b/include/kunit/test.h
@@ -268,14 +268,18 @@ struct kunit_suite_set {
  *
  * @priv: for user to store arbitrary data. Commonly used to pass data
  *       created in the init function (see &struct kunit_suite).
+ * @parent: reference to the parent context of type struct kunit that can
+ *         be used for storing shared resources.
  *
  * Used to store information about the current context under which the test
  * is running. Most of this data is private and should only be accessed
- * indirectly via public functions; the one exception is @priv which can be
- * used by the test writer to store arbitrary data.
+ * indirectly via public functions; the two exceptions are @priv and @parent
+ * which can be used by the test writer to store arbitrary data and access the
+ * parent context, respectively.
  */
 struct kunit {
        void *priv;
+       struct kunit *parent;
 
        /* private: internal use only. */
        const char *name; /* Read only after initialization! */

diff --git a/lib/kunit/test.c b/lib/kunit/test.c
index d2bfa331a2b1eb4a793b99ba7822f1a5a9831219..587b5c51db589387d027a416f42027cd211202ae 100644 (file)
--- a/lib/kunit/test.c
+++ b/lib/kunit/test.c
@@ -647,6 +647,7 @@ int kunit_run_tests(struct kunit_suite *suite)
        struct kunit_case *test_case;
        struct kunit_result_stats suite_stats = { 0 };
        struct kunit_result_stats total_stats = { 0 };
+       const void *curr_param;
 
        /* Taint the kernel so we know we've run tests. */
        add_taint(TAINT_TEST, LOCKDEP_STILL_OK);
@@ -679,37 +680,42 @@ int kunit_run_tests(struct kunit_suite *suite)
                } else {
                        /* Get initial param. */
                        param_desc[0] = '\0';
-                       test.param_value = test_case->generate_params(NULL, param_desc);
+                       /* TODO: Make generate_params try-catch */
+                       curr_param = test_case->generate_params(NULL, param_desc);
                        test_case->status = KUNIT_SKIPPED;
                        kunit_log(KERN_INFO, &test, KUNIT_SUBTEST_INDENT KUNIT_SUBTEST_INDENT
                                  "KTAP version 1\n");
                        kunit_log(KERN_INFO, &test, KUNIT_SUBTEST_INDENT KUNIT_SUBTEST_INDENT
                                  "# Subtest: %s", test_case->name);
 
-                       while (test.param_value) {
-                               kunit_run_case_catch_errors(suite, test_case, &test);
+                       while (curr_param) {
+                               struct kunit param_test = {
+                                       .param_value = curr_param,
+                                       .param_index = ++test.param_index,
+                                       .parent = &test,
+                               };
+                               kunit_init_test(&param_test, test_case->name, test_case->log);
+                               kunit_run_case_catch_errors(suite, test_case, &param_test);
 
                                if (param_desc[0] == '\0') {
                                        snprintf(param_desc, sizeof(param_desc),
-                                                "param-%d", test.param_index);
+                                                "param-%d", param_test.param_index);
                                }
 
-                               kunit_print_ok_not_ok(&test, KUNIT_LEVEL_CASE_PARAM,
-                                                     test.status,
-                                                     test.param_index + 1,
+                               kunit_print_ok_not_ok(&param_test, KUNIT_LEVEL_CASE_PARAM,
+                                                     param_test.status,
+                                                     param_test.param_index,
                                                      param_desc,
-                                                     test.status_comment);
+                                                     param_test.status_comment);
 
-                               kunit_update_stats(&param_stats, test.status);
+                               kunit_update_stats(&param_stats, param_test.status);
 
                                /* Get next param. */
                                param_desc[0] = '\0';
-                               test.param_value = test_case->generate_params(test.param_value, param_desc);
-                               test.param_index++;
-                               test.status = KUNIT_SUCCESS;
-                               test.status_comment[0] = '\0';
-                               test.priv = NULL;
+                               curr_param = test_case->generate_params(curr_param, param_desc);
                        }
+                       /* TODO: Put this kunit_cleanup into a try-catch. */
+                       kunit_cleanup(&test);
                }
 
                kunit_print_attr((void *)test_case, true, KUNIT_LEVEL_CASE);