X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=test%2Fdm%2Ftest-main.c;h=62a0c692c897c7c36fc81153044a3e2d92cc4a02;hb=09140113108541b95d340f3c7b6ee597d31ccc73;hp=fbdae688e09274842ecf197444caea76bc5e4caa;hpb=90b51c33f362926e17d4c07dcef1ce822abaa89f;p=oweals%2Fu-boot.git diff --git a/test/dm/test-main.c b/test/dm/test-main.c index fbdae688e0..62a0c692c8 100644 --- a/test/dm/test-main.c +++ b/test/dm/test-main.c @@ -1,36 +1,47 @@ +// SPDX-License-Identifier: GPL-2.0+ /* * Copyright (c) 2013 Google, Inc - * - * SPDX-License-Identifier: GPL-2.0+ */ #include +#include +#include #include #include +#include +#include #include #include #include -#include +#include DECLARE_GLOBAL_DATA_PTR; -struct dm_test_state global_test_state; +struct unit_test_state global_dm_test_state; +static struct dm_test_state _global_priv_dm_test_state; /* Get ready for testing */ -static int dm_test_init(struct dm_test_state *dms) +static int dm_test_init(struct unit_test_state *uts, bool of_live) { + struct dm_test_state *dms = uts->priv; + memset(dms, '\0', sizeof(*dms)); gd->dm_root = NULL; memset(dm_testdrv_op_count, '\0', sizeof(dm_testdrv_op_count)); + state_reset_for_test(state_get_current()); - ut_assertok(dm_init()); +#ifdef CONFIG_OF_LIVE + /* Determine whether to make the live tree available */ + gd->of_root = of_live ? uts->of_root : NULL; +#endif + ut_assertok(dm_init(of_live)); dms->root = dm_root(); return 0; } /* Ensure all the test devices are probed */ -static int do_autoprobe(struct dm_test_state *dms) +static int do_autoprobe(struct unit_test_state *uts) { struct udevice *dev; int ret; @@ -44,7 +55,7 @@ static int do_autoprobe(struct dm_test_state *dms) return ret; } -static int dm_test_destroy(struct dm_test_state *dms) +static int dm_test_destroy(struct unit_test_state *uts) { int id; @@ -53,7 +64,7 @@ static int dm_test_destroy(struct dm_test_state *dms) /* * If the uclass doesn't exist we don't want to create it. So - * check that here before we call uclass_find_device()/ + * check that here before we call uclass_find_device(). */ uc = uclass_find(id); if (!uc) @@ -64,12 +75,65 @@ static int dm_test_destroy(struct dm_test_state *dms) return 0; } -int dm_test_main(void) +static int dm_do_test(struct unit_test_state *uts, struct unit_test *test, + bool of_live) +{ + struct sandbox_state *state = state_get_current(); + const char *fname = strrchr(test->file, '/') + 1; + + printf("Test: %s: %s%s\n", test->name, fname, + !of_live ? " (flat tree)" : ""); + ut_assertok(dm_test_init(uts, of_live)); + + uts->start = mallinfo(); + if (test->flags & DM_TESTF_SCAN_PDATA) + ut_assertok(dm_scan_platdata(false)); + if (test->flags & DM_TESTF_PROBE_TEST) + ut_assertok(do_autoprobe(uts)); + if (test->flags & DM_TESTF_SCAN_FDT) + ut_assertok(dm_extended_scan_fdt(gd->fdt_blob, false)); + + /* + * Silence the console and rely on console recording to get + * our output. + */ + console_record_reset_enable(); + if (!state->show_test_output) + gd->flags |= GD_FLG_SILENT; + test->func(uts); + gd->flags &= ~(GD_FLG_SILENT | GD_FLG_RECORD); + state_set_skip_delays(false); + + ut_assertok(dm_test_destroy(uts)); + + return 0; +} + +/** + * dm_test_run_on_flattree() - Check if we should run a test with flat DT + * + * This skips long/slow tests where there is not much value in running a flat + * DT test in addition to a live DT test. + * + * @return true to run the given test on the flat device tree + */ +static bool dm_test_run_on_flattree(struct unit_test *test) +{ + const char *fname = strrchr(test->file, '/') + 1; + + return !strstr(fname, "video") || strstr(test->name, "video_base"); +} + +static int dm_test_main(const char *test_name) { - struct dm_test *tests = ll_entry_start(struct dm_test, dm_test); - const int n_ents = ll_entry_count(struct dm_test, dm_test); - struct dm_test_state *dms = &global_test_state; - struct dm_test *test; + struct unit_test *tests = ll_entry_start(struct unit_test, dm_test); + const int n_ents = ll_entry_count(struct unit_test, dm_test); + struct unit_test_state *uts = &global_dm_test_state; + struct unit_test *test; + int found; + + uts->priv = &_global_priv_dm_test_state; + uts->fail_count = 0; /* * If we have no device tree, or it only has a root node, then these @@ -77,31 +141,71 @@ int dm_test_main(void) */ if (!gd->fdt_blob || fdt_next_node(gd->fdt_blob, 0, NULL) < 0) { puts("Please run with test device tree:\n" - " dtc -I dts -O dtb test/dm/test.dts -o test/dm/test.dtb\n" - " ./u-boot -d test/dm/test.dtb\n"); + " ./u-boot -d arch/sandbox/dts/test.dtb\n"); ut_assert(gd->fdt_blob); } - printf("Running %d driver model tests\n", n_ents); + if (!test_name) + printf("Running %d driver model tests\n", n_ents); + found = 0; +#ifdef CONFIG_OF_LIVE + uts->of_root = gd->of_root; +#endif for (test = tests; test < tests + n_ents; test++) { - printf("Test: %s\n", test->name); - ut_assertok(dm_test_init(dms)); + const char *name = test->name; + int runs; - if (test->flags & DM_TESTF_SCAN_PDATA) - ut_assertok(dm_scan_platdata()); - if (test->flags & DM_TESTF_PROBE_TEST) - ut_assertok(do_autoprobe(dms)); - if (test->flags & DM_TESTF_SCAN_FDT) - ut_assertok(dm_scan_fdt(gd->fdt_blob)); + /* All tests have this prefix */ + if (!strncmp(name, "dm_test_", 8)) + name += 8; + if (test_name && strcmp(test_name, name)) + continue; - if (test->func(dms)) - break; + /* Run with the live tree if possible */ + runs = 0; + if (IS_ENABLED(CONFIG_OF_LIVE)) { + if (!(test->flags & DM_TESTF_FLAT_TREE)) { + ut_assertok(dm_do_test(uts, test, true)); + runs++; + } + } - ut_assertok(dm_test_destroy(dms)); + /* + * Run with the flat tree if we couldn't run it with live tree, + * or it is a core test. + */ + if (!(test->flags & DM_TESTF_LIVE_TREE) && + (!runs || dm_test_run_on_flattree(test))) { + ut_assertok(dm_do_test(uts, test, false)); + runs++; + } + found++; } - printf("Failures: %d\n", dms->fail_count); + if (test_name && !found) + printf("Test '%s' not found\n", test_name); + else + printf("Failures: %d\n", uts->fail_count); - return 0; + /* Put everything back to normal so that sandbox works as expected */ +#ifdef CONFIG_OF_LIVE + gd->of_root = uts->of_root; +#endif + gd->dm_root = NULL; + ut_assertok(dm_init(IS_ENABLED(CONFIG_OF_LIVE))); + dm_scan_platdata(false); + dm_scan_fdt(gd->fdt_blob, false); + + return uts->fail_count ? CMD_RET_FAILURE : 0; +} + +int do_ut_dm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]) +{ + const char *test_name = NULL; + + if (argc > 1) + test_name = argv[1]; + + return dm_test_main(test_name); }