1
2
3
4
5
6
7#include <common.h>
8#include <console.h>
9#include <dm.h>
10#include <dm/root.h>
11#include <dm/test.h>
12#include <dm/uclass-internal.h>
13#include <test/test.h>
14#include <test/ut.h>
15
16DECLARE_GLOBAL_DATA_PTR;
17
18
19static struct unit_test_state *cur_test_state;
20
21struct unit_test_state *test_get_state(void)
22{
23 return cur_test_state;
24}
25
26void test_set_state(struct unit_test_state *uts)
27{
28 cur_test_state = uts;
29}
30
31
32
33
34
35
36
37
38
39static int dm_test_pre_run(struct unit_test_state *uts)
40{
41 bool of_live = uts->of_live;
42
43 uts->root = NULL;
44 uts->testdev = NULL;
45 uts->force_fail_alloc = false;
46 uts->skip_post_probe = false;
47 gd->dm_root = NULL;
48 if (CONFIG_IS_ENABLED(UT_DM) && !CONFIG_IS_ENABLED(OF_PLATDATA))
49 memset(dm_testdrv_op_count, '\0', sizeof(dm_testdrv_op_count));
50 arch_reset_for_test();
51
52
53 gd_set_of_root(of_live ? uts->of_root : NULL);
54 ut_assertok(dm_init(of_live));
55 uts->root = dm_root();
56
57 return 0;
58}
59
60static int dm_test_post_run(struct unit_test_state *uts)
61{
62 int id;
63
64
65
66
67
68
69 if (!CONFIG_IS_ENABLED(OF_PLATDATA_INST)) {
70 for (id = 0; id < UCLASS_COUNT; id++) {
71 struct uclass *uc;
72
73
74
75
76
77
78 uc = uclass_find(id);
79 if (!uc)
80 continue;
81 ut_assertok(uclass_destroy(uc));
82 }
83 }
84
85 return 0;
86}
87
88
89static int do_autoprobe(struct unit_test_state *uts)
90{
91 struct udevice *dev;
92 int ret;
93
94
95 for (ret = uclass_first_device(UCLASS_TEST, &dev);
96 dev;
97 ret = uclass_next_device(&dev))
98 ;
99
100 return ret;
101}
102
103
104
105
106
107
108
109
110
111static bool ut_test_run_on_flattree(struct unit_test *test)
112{
113 const char *fname = strrchr(test->file, '/') + 1;
114
115 if (!(test->flags & UT_TESTF_DM))
116 return false;
117
118 return !strstr(fname, "video") || strstr(test->name, "video_base");
119}
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135static bool test_matches(const char *prefix, const char *test_name,
136 const char *select_name)
137{
138 size_t len;
139
140 if (!select_name)
141 return true;
142
143
144 len = select_name[strlen(select_name) - 1] == '*' ? strlen(select_name) : 0;
145 if (len-- == 1)
146 return true;
147
148 if (!strncmp(test_name, select_name, len))
149 return true;
150
151 if (prefix) {
152
153 if (!strncmp(test_name, prefix, strlen(prefix)))
154 test_name += strlen(prefix);
155 } else {
156 const char *p = strstr(test_name, "_test_");
157
158
159 if (p)
160 test_name = p + strlen("_test_");
161 }
162
163 if (!strncmp(test_name, select_name, len))
164 return true;
165
166 return false;
167}
168
169
170
171
172
173
174
175
176static bool ut_list_has_dm_tests(struct unit_test *tests, int count)
177{
178 struct unit_test *test;
179
180 for (test = tests; test < tests + count; test++) {
181 if (test->flags & UT_TESTF_DM)
182 return true;
183 }
184
185 return false;
186}
187
188
189
190
191
192
193
194static int dm_test_restore(struct device_node *of_root)
195{
196 int ret;
197
198 gd_set_of_root(of_root);
199 gd->dm_root = NULL;
200 ret = dm_init(CONFIG_IS_ENABLED(OF_LIVE));
201 if (ret)
202 return ret;
203 dm_scan_plat(false);
204 if (!CONFIG_IS_ENABLED(OF_PLATDATA))
205 dm_scan_fdt(false);
206
207 return 0;
208}
209
210
211
212
213
214
215
216
217
218
219static int test_pre_run(struct unit_test_state *uts, struct unit_test *test)
220{
221 if (test->flags & UT_TESTF_DM)
222 ut_assertok(dm_test_pre_run(uts));
223
224 ut_set_skip_delays(uts, false);
225
226 uts->start = mallinfo();
227
228 if (test->flags & UT_TESTF_SCAN_PDATA)
229 ut_assertok(dm_scan_plat(false));
230
231 if (test->flags & UT_TESTF_PROBE_TEST)
232 ut_assertok(do_autoprobe(uts));
233
234 if (!CONFIG_IS_ENABLED(OF_PLATDATA) &&
235 (test->flags & UT_TESTF_SCAN_FDT))
236 ut_assertok(dm_extended_scan(false));
237
238 if (test->flags & UT_TESTF_CONSOLE_REC) {
239 int ret = console_record_reset_enable();
240
241 if (ret) {
242 printf("Skipping: Console recording disabled\n");
243 return -EAGAIN;
244 }
245 }
246 ut_silence_console(uts);
247
248 return 0;
249}
250
251
252
253
254
255
256
257
258static int test_post_run(struct unit_test_state *uts, struct unit_test *test)
259{
260 ut_unsilence_console(uts);
261 if (test->flags & UT_TESTF_DM)
262 ut_assertok(dm_test_post_run(uts));
263
264 return 0;
265}
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281static int ut_run_test(struct unit_test_state *uts, struct unit_test *test,
282 const char *test_name)
283{
284 const char *fname = strrchr(test->file, '/') + 1;
285 const char *note = "";
286 int ret;
287
288 if ((test->flags & UT_TESTF_DM) && !uts->of_live)
289 note = " (flat tree)";
290 printf("Test: %s: %s%s\n", test_name, fname, note);
291
292
293 test_set_state(uts);
294
295 ret = test_pre_run(uts, test);
296 if (ret == -EAGAIN)
297 return -EAGAIN;
298 if (ret)
299 return ret;
300
301 test->func(uts);
302
303 ret = test_post_run(uts, test);
304 if (ret)
305 return ret;
306
307 test_set_state( NULL);
308
309 return 0;
310}
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329static int ut_run_test_live_flat(struct unit_test_state *uts,
330 struct unit_test *test, const char *name)
331{
332 int runs;
333
334
335 runs = 0;
336 if (CONFIG_IS_ENABLED(OF_LIVE)) {
337 if (!(test->flags & UT_TESTF_FLAT_TREE)) {
338 uts->of_live = true;
339 ut_assertok(ut_run_test(uts, test, test->name));
340 runs++;
341 }
342 }
343
344
345
346
347
348 if (!(test->flags & UT_TESTF_LIVE_TREE) &&
349 (!runs || ut_test_run_on_flattree(test))) {
350 uts->of_live = false;
351 ut_assertok(ut_run_test(uts, test, test->name));
352 runs++;
353 }
354
355 return 0;
356}
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377static int ut_run_tests(struct unit_test_state *uts, const char *prefix,
378 struct unit_test *tests, int count,
379 const char *select_name)
380{
381 struct unit_test *test;
382 int found = 0;
383
384 for (test = tests; test < tests + count; test++) {
385 const char *test_name = test->name;
386 int ret;
387
388 if (!test_matches(prefix, test_name, select_name))
389 continue;
390 ret = ut_run_test_live_flat(uts, test, select_name);
391 found++;
392 if (ret == -EAGAIN)
393 continue;
394 if (ret)
395 return ret;
396 }
397 if (select_name && !found)
398 return -ENOENT;
399
400 return uts->fail_count ? -EBADF : 0;
401}
402
403int ut_run_list(const char *category, const char *prefix,
404 struct unit_test *tests, int count, const char *select_name)
405{
406 struct unit_test_state uts = { .fail_count = 0 };
407 bool has_dm_tests = false;
408 int ret;
409
410 if (!CONFIG_IS_ENABLED(OF_PLATDATA) &&
411 ut_list_has_dm_tests(tests, count)) {
412 has_dm_tests = true;
413
414
415
416
417 if (!gd->fdt_blob || fdt_next_node(gd->fdt_blob, 0, NULL) < 0) {
418 puts("Please run with test device tree:\n"
419 " ./u-boot -d arch/sandbox/dts/test.dtb\n");
420 return CMD_RET_FAILURE;
421 }
422 }
423
424 if (!select_name)
425 printf("Running %d %s tests\n", count, category);
426
427 uts.of_root = gd_of_root();
428 ret = ut_run_tests(&uts, prefix, tests, count, select_name);
429
430 if (ret == -ENOENT)
431 printf("Test '%s' not found\n", select_name);
432 else
433 printf("Failures: %d\n", uts.fail_count);
434
435
436 if (has_dm_tests)
437 dm_test_restore(uts.of_root);
438
439 return ret;
440}
441