1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright 2021 Google LLC
4 * Written by Simon Glass <sjg@chromium.org>
10 #include <asm/state.h>
13 #include <dm/uclass-internal.h>
14 #include <test/test.h>
17 DECLARE_GLOBAL_DATA_PTR;
20 * dm_test_pre_run() - Get ready to run a driver model test
22 * This clears out the driver model data structures. For sandbox it resets the
27 static int dm_test_pre_run(struct unit_test_state *uts)
29 bool of_live = uts->of_live;
33 uts->force_fail_alloc = false;
34 uts->skip_post_probe = false;
36 if (!CONFIG_IS_ENABLED(OF_PLATDATA))
37 memset(dm_testdrv_op_count, '\0', sizeof(dm_testdrv_op_count));
38 state_reset_for_test(state_get_current());
40 /* Determine whether to make the live tree available */
41 gd_set_of_root(of_live ? uts->of_root : NULL);
42 ut_assertok(dm_init(of_live));
43 uts->root = dm_root();
48 static int dm_test_post_run(struct unit_test_state *uts)
52 for (id = 0; id < UCLASS_COUNT; id++) {
56 * If the uclass doesn't exist we don't want to create it. So
57 * check that here before we call uclass_find_device().
62 ut_assertok(uclass_destroy(uc));
68 /* Ensure all the test devices are probed */
69 static int do_autoprobe(struct unit_test_state *uts)
74 /* Scanning the uclass is enough to probe all the devices */
75 for (ret = uclass_first_device(UCLASS_TEST, &dev);
77 ret = uclass_next_device(&dev))
84 * ut_test_run_on_flattree() - Check if we should run a test with flat DT
86 * This skips long/slow tests where there is not much value in running a flat
87 * DT test in addition to a live DT test.
89 * @return true to run the given test on the flat device tree
91 static bool ut_test_run_on_flattree(struct unit_test *test)
93 const char *fname = strrchr(test->file, '/') + 1;
95 if (!(test->flags & UT_TESTF_DM))
98 return !strstr(fname, "video") || strstr(test->name, "video_base");
102 * test_pre_run() - Handle any preparation needed to run a test
105 * @test: Test to prepare for
106 * @return 0 if OK, -EAGAIN to skip this test since some required feature is not
107 * available, other -ve on error (meaning that testing cannot likely
110 static int test_pre_run(struct unit_test_state *uts, struct unit_test *test)
112 if (test->flags & UT_TESTF_DM)
113 ut_assertok(dm_test_pre_run(uts));
115 ut_set_skip_delays(uts, false);
117 uts->start = mallinfo();
119 if (test->flags & UT_TESTF_SCAN_PDATA)
120 ut_assertok(dm_scan_plat(false));
122 if (test->flags & UT_TESTF_PROBE_TEST)
123 ut_assertok(do_autoprobe(uts));
125 if (!CONFIG_IS_ENABLED(OF_PLATDATA) &&
126 (test->flags & UT_TESTF_SCAN_FDT))
127 ut_assertok(dm_extended_scan(false));
129 if (test->flags & UT_TESTF_CONSOLE_REC) {
130 int ret = console_record_reset_enable();
133 printf("Skipping: Console recording disabled\n");
137 ut_silence_console(uts);
143 * test_post_run() - Handle cleaning up after a test
146 * @test: Test to clean up after
147 * @return 0 if OK, -ve on error (meaning that testing cannot likely continue)
149 static int test_post_run(struct unit_test_state *uts, struct unit_test *test)
151 ut_unsilence_console(uts);
152 if (test->flags & UT_TESTF_DM)
153 ut_assertok(dm_test_post_run(uts));
159 * ut_run_test() - Run a single test
161 * This runs the test, handling any preparation and clean-up needed. It prints
162 * the name of each test before running it.
164 * @uts: Test state to update. The caller should ensure that this is zeroed for
165 * the first call to this function. On exit, @uts->fail_count is
166 * incremented by the number of failures (0, one hopes)
167 * @test_name: Test to run
168 * @name: Name of test, possibly skipping a prefix that should not be displayed
169 * @return 0 if all tests passed, -EAGAIN if the test should be skipped, -1 if
172 static int ut_run_test(struct unit_test_state *uts, struct unit_test *test,
173 const char *test_name)
175 const char *fname = strrchr(test->file, '/') + 1;
176 const char *note = "";
179 if ((test->flags & UT_TESTF_DM) && !uts->of_live)
180 note = " (flat tree)";
181 printf("Test: %s: %s%s\n", test_name, fname, note);
183 ret = test_pre_run(uts, test);
191 ret = test_post_run(uts, test);
198 int ut_run_test_live_flat(struct unit_test_state *uts, struct unit_test *test,
203 /* Run with the live tree if possible */
205 if (CONFIG_IS_ENABLED(OF_LIVE)) {
206 if (!(test->flags & UT_TESTF_FLAT_TREE)) {
208 ut_assertok(ut_run_test(uts, test, test->name));
214 * Run with the flat tree if we couldn't run it with live tree,
215 * or it is a core test.
217 if (!(test->flags & UT_TESTF_LIVE_TREE) &&
218 (!runs || ut_test_run_on_flattree(test))) {
219 uts->of_live = false;
220 ut_assertok(ut_run_test(uts, test, test->name));
227 int ut_run_tests(struct unit_test_state *uts, const char *prefix,
228 struct unit_test *tests, int count, const char *select_name)
230 struct unit_test *test;
231 int prefix_len = prefix ? strlen(prefix) : 0;
234 for (test = tests; test < tests + count; test++) {
235 const char *test_name = test->name;
238 /* Remove the prefix */
239 if (prefix && !strncmp(test_name, prefix, prefix_len))
240 test_name += prefix_len;
242 if (select_name && strcmp(select_name, test_name))
244 ret = ut_run_test_live_flat(uts, test, test_name);
251 if (select_name && !found)
254 return uts->fail_count ? -EBADF : 0;
257 int ut_run_list(const char *category, const char *prefix,
258 struct unit_test *tests, int count, const char *select_name)
260 struct unit_test_state uts = { .fail_count = 0 };
264 printf("Running %d %s tests\n", count, category);
266 ret = ut_run_tests(&uts, prefix, tests, count, select_name);
269 printf("Test '%s' not found\n", select_name);
271 printf("Failures: %d\n", uts.fail_count);