Djam/u-boot
1
0
Fork 0
mirror of https://github.com/u-boot/u-boot.git synced 2025-04-16 01:44:34 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge patch series "Tidy up console recording in tests"

Browse source 
Simon Glass <sjg@chromium.org> says:

This series started as a small fix for checking for an empty line,
but in the process several other problems were found and fixed:

- fix tests which use console recording but don't set the flag
- drop unnecessary resetting of the console in tests
- drop unnecessary blank line before MMC output
- update the docs a little
- fix buildman test failure on newer Pythons
- a few other minor things

This series also renames the confusing flag names, so that they are
easier to remember - just a UTF_ (unit-test flags) prefix.
This commit is contained in:
Tom Rini 2024-08-26 18:52:18 -06:00
commit 9735cfaf90
179 changed files with 988 additions and 1327 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
cmd/mmc.c
View file

@ -238,7 +238,7 @@ static int do_mmcrpmb_read(struct cmd_tbl *cmdtp, int flag,
if (argc == 5)
key_addr = (void *)hextoul(argv[4], NULL);
printf("\nMMC RPMB read: dev # %d, block # %d, count %d ... ",
printf("MMC RPMB read: dev # %d, block # %d, count %d ... ",
curr_device, blk, cnt);
n = mmc_rpmb_read(mmc, addr, blk, cnt, key_addr);
@ -265,7 +265,7 @@ static int do_mmcrpmb_write(struct cmd_tbl *cmdtp, int flag,
cnt = hextoul(argv[3], NULL);
key_addr = (void *)hextoul(argv[4], NULL);
printf("\nMMC RPMB write: dev # %d, block # %d, count %d ... ",
printf("MMC RPMB write: dev # %d, block # %d, count %d ... ",
curr_device, blk, cnt);
n = mmc_rpmb_write(mmc, addr, blk, cnt, key_addr);
@ -362,7 +362,7 @@ static int do_mmc_read(struct cmd_tbl *cmdtp, int flag,
if (!mmc)
return CMD_RET_FAILURE;
printf("\nMMC read: dev # %d, block # %d, count %d ... ",
printf("MMC read: dev # %d, block # %d, count %d ... ",
curr_device, blk, cnt);
n = blk_dread(mmc_get_blk_desc(mmc), blk, cnt, addr);
@ -411,7 +411,7 @@ static int do_mmc_sparse_write(struct cmd_tbl *cmdtp, int flag,
if (!mmc)
return CMD_RET_FAILURE;
printf("\nMMC Sparse write: dev # %d, block # %d ... ",
printf("MMC Sparse write: dev # %d, block # %d ... ",
curr_device, blk);
if (mmc_getwp(mmc) == 1) {
@ -455,7 +455,7 @@ static int do_mmc_write(struct cmd_tbl *cmdtp, int flag,
if (!mmc)
return CMD_RET_FAILURE;
printf("\nMMC write: dev # %d, block # %d, count %d ... ",
printf("MMC write: dev # %d, block # %d, count %d ... ",
curr_device, blk, cnt);
if (mmc_getwp(mmc) == 1) {
@ -484,7 +484,7 @@ static int do_mmc_erase(struct cmd_tbl *cmdtp, int flag,
if (!mmc)
return CMD_RET_FAILURE;
printf("\nMMC erase: dev # %d, block # %d, count %d ... ",
printf("MMC erase: dev # %d, block # %d, count %d ... ",
curr_device, blk, cnt);
if (mmc_getwp(mmc) == 1) {

2
common/console.c
View file

@ -846,6 +846,8 @@ int console_record_readline(char *str, int maxlen)
{
if (gd->flags & GD_FLG_RECORD_OVF)
return -ENOSPC;
if (console_record_isempty())
return -ENOENT;
return membuff_readline((struct membuff *)&gd->console_out, str,
maxlen, '\0', false);

9
doc/develop/commands.rst
View file

@ -197,7 +197,6 @@ Here is an example:
ctx.current = buf;
ut_assertok(acpi_fill_ssdt(&ctx));
console_record_reset();
run_command("acpi items", 0);
ut_assert_nextline("dev 'acpi-test', type 1, size 2");
ut_assert_nextline("dev 'acpi-test2', type 1, size 2");
@ -205,13 +204,11 @@ Here is an example:
ctx.current = buf;
ut_assertok(acpi_inject_dsdt(&ctx));
console_record_reset();
run_command("acpi items", 0);
ut_assert_nextline("dev 'acpi-test', type 2, size 2");
ut_assert_nextline("dev 'acpi-test2', type 2, size 2");
ut_assert_console_end();
console_record_reset();
run_command("acpi items -d", 0);
ut_assert_nextline("dev 'acpi-test', type 2, size 2");
ut_assert_nextlines_are_dump(2);
@ -223,4 +220,8 @@ Here is an example:
return 0;
}
DM_TEST(dm_test_acpi_cmd_items, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_cmd_items, UTF_SCAN_PDATA | UTF_SCAN_FDT | UTF_CONSOLE);
Note that it is not necessary to call console_record_reset() unless you are
trying to drop some unchecked output. Consider using ut_check_skip_to_line()
instead.

18
doc/develop/tests_writing.rst
View file

@ -81,7 +81,7 @@ The best of both worlds is sometimes to have a Python test set things up and
perform some operations, with a 'checker' C unit test doing the checks
afterwards. This can be achieved with these steps:
- Add the `UT_TESTF_MANUAL` flag to the checker test so that the `ut` command
- Add the `UTF_MANUAL` flag to the checker test so that the `ut` command
does not run it by default
- Add a `_norun` suffix to the name so that pytest knows to skip it too
@ -95,7 +95,7 @@ test to run it, e.g.::
# Run the checker to make sure that everything worked
ut -f bootstd vbe_test_fixup_norun
Note that apart from the `UT_TESTF_MANUAL` flag, the code in a 'manual' C test
Note that apart from the `UTF_MANUAL` flag, the code in a 'manual' C test
is just like any other C test. It still uses ut_assert...() and other such
constructs, in this case to check that the expected things happened in the
Python test.
@ -151,7 +151,6 @@ There is no exactly equivalent C test, but here is a similar one that tests 'ms'
buf[0x31] = 0x12;
buf[0xff] = 0x12;
buf[0x100] = 0x12;
ut_assertok(console_record_reset_enable());
run_command("ms.b 1 ff 12", 0);
ut_assert_nextline("00000030: 00 12 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................");
ut_assert_nextline("--");
@ -167,7 +166,7 @@ There is no exactly equivalent C test, but here is a similar one that tests 'ms'
return 0;
}
MEM_TEST(mem_test_ms_b, UT_TESTF_CONSOLE_REC);
MEM_TEST(mem_test_ms_b, UTF_CONSOLE);
This runs the command directly in U-Boot, then checks the console output, also
directly in U-Boot. If run by itself this takes 100ms. For 1000 runs it takes
@ -226,14 +225,17 @@ Declare the test with::
return 0;
}
DM_TEST(dm_test_uclassname_what, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_uclassname_what, UTF_SCAN_FDT);
Note that the convention is to NOT add a blank line before the macro, so that
the function it relates to is more obvious.
Replace 'uclassname' with the name of your uclass, if applicable. Replace 'what'
with what you are testing.
The flags for DM_TEST() are defined in test/test.h and you typically want
UT_TESTF_SCAN_FDT so that the devicetree is scanned and all devices are bound
and ready for use. The DM_TEST macro adds UT_TESTF_DM automatically so that
UTF_SCAN_FDT so that the devicetree is scanned and all devices are bound
and ready for use. The DM_TEST macro adds UTF_DM automatically so that
the test runner knows it is a driver model test.
Driver model tests are special in that the entire driver model state is
@ -263,7 +265,7 @@ with the suite. For example, to add a new mem_search test::
return 0;
}
MEM_TEST(mem_test_ms_new_thing, UT_TESTF_CONSOLE_REC);
MEM_TEST(mem_test_ms_new_thing, UTF_CONSOLE);
Note that the MEM_TEST() macros is defined at the top of the file.

2
doc/usage/cmd/ut.rst
View file

@ -32,7 +32,7 @@ to run some tests on real boards.
For a list of available test suites, type `ut` by itself.
Each test is normally run once, although those marked with `UT_TESTF_DM` are
Each test is normally run once, although those marked with `UTF_DM` are
run with livetree and flattree where possible. To run a test more than once,
use the `-r` flag.

2
include/console.h
View file

@ -73,7 +73,7 @@ int console_record_reset_enable(void);
* @str: Place to put string
* @maxlen: Maximum length of @str including nul terminator
* Return: length of string returned, or -ENOSPC if the console buffer was
* overflowed by the output
* overflowed by the output, or -ENOENT if there was nothing to read
*/
int console_record_readline(char *str, int maxlen);

2
include/dm/test.h
View file

@ -143,7 +143,7 @@ extern struct unit_test_state global_dm_test_state;
/* Declare a new driver model test */
#define DM_TEST(_name, _flags) \
UNIT_TEST(_name, UT_TESTF_DM | UT_TESTF_CONSOLE_REC | (_flags), dm_test)
UNIT_TEST(_name, UTF_DM | UTF_CONSOLE | (_flags), dm_test)
/*
* struct sandbox_sdl_plat - Platform data for the SDL video driver

5
include/test/log.h
View file

@ -13,7 +13,8 @@
#define LOGF_TEST (BIT(LOGF_FUNC) | BIT(LOGF_MSG))
/* Declare a new logging test */
#define LOG_TEST(_name) UNIT_TEST(_name, 0, log_test)
#define LOG_TEST_FLAGS(_name, _flags) UNIT_TEST(_name, _flags, log_test)
#define LOG_TEST(_name) UNIT_TEST(_name, UTF_CONSOLE, log_test)
#define LOG_TEST_FLAGS(_name, _flags) \
UNIT_TEST(_name, _flags | UTF_CONSOLE, log_test)
#endif /* __TEST_LOG_H__ */

2
include/test/spl.h
View file

@ -154,6 +154,6 @@ SPL_TEST(func##_##type, flags)
#define SPL_TEST_DATA_SIZE 4099
/* Flags necessary for accessing DM devices */
#define DM_FLAGS (UT_TESTF_DM | UT_TESTF_SCAN_FDT)
#define DM_FLAGS (UTF_DM | UTF_SCAN_FDT)
#endif /* TEST_SPL_H */

32
include/test/test.h
View file

@ -24,11 +24,11 @@
* @fdt_chksum: crc8 of the device tree contents
* @fdt_copy: Copy of the device tree
* @fdt_size: Size of the device-tree copy
* @other_fdt: Buffer for the other FDT (UT_TESTF_OTHER_FDT)
* @other_fdt_size: Size of the other FDT (UT_TESTF_OTHER_FDT)
* @other_fdt: Buffer for the other FDT (UTF_OTHER_FDT)
* @other_fdt_size: Size of the other FDT (UTF_OTHER_FDT)
* @of_other: Live tree for the other FDT
* @runs_per_test: Number of times to run each test (typically 1)
* @force_run: true to run tests marked with the UT_TESTF_MANUAL flag
* @force_run: true to run tests marked with the UTF_MANUAL flag
* @expect_str: Temporary string used to hold expected string value
* @actual_str: Temporary string used to hold actual string value
*/
@ -55,24 +55,24 @@ struct unit_test_state {
};
/* Test flags for each test */
enum {
UT_TESTF_SCAN_PDATA = BIT(0), /* test needs platform data */
UT_TESTF_PROBE_TEST = BIT(1), /* probe test uclass */
UT_TESTF_SCAN_FDT = BIT(2), /* scan device tree */
UT_TESTF_FLAT_TREE = BIT(3), /* test needs flat DT */
UT_TESTF_LIVE_TREE = BIT(4), /* needs live device tree */
UT_TESTF_CONSOLE_REC = BIT(5), /* needs console recording */
enum ut_flags {
UTF_SCAN_PDATA = BIT(0), /* test needs platform data */
UTF_PROBE_TEST = BIT(1), /* probe test uclass */
UTF_SCAN_FDT = BIT(2), /* scan device tree */
UTF_FLAT_TREE = BIT(3), /* test needs flat DT */
UTF_LIVE_TREE = BIT(4), /* needs live device tree */
UTF_CONSOLE = BIT(5), /* needs console recording */
/* do extra driver model init and uninit */
UT_TESTF_DM = BIT(6),
UT_TESTF_OTHER_FDT = BIT(7), /* read in other device tree */
UTF_DM = BIT(6),
UTF_OTHER_FDT = BIT(7), /* read in other device tree */
/*
* Only run if explicitly requested with 'ut -f <suite> <test>'. The
* test name must end in "_norun" so that pytest detects this also,
* since it cannot access the flags.
*/
UT_TESTF_MANUAL = BIT(8),
UT_TESTF_ETH_BOOTDEV = BIT(9), /* enable Ethernet bootdevs */
UT_TESTF_SF_BOOTDEV = BIT(10), /* enable SPI flash bootdevs */
UTF_MANUAL = BIT(8),
UTF_ETH_BOOTDEV = BIT(9), /* enable Ethernet bootdevs */
UTF_SF_BOOTDEV = BIT(10), /* enable SPI flash bootdevs */
};
/**
@ -109,7 +109,7 @@ struct unit_test {
* @_name: concatenation of name of the test suite, "_test_", and the name
* of the test
* @_flags: an integer field that can be evaluated by the test suite
* implementation
* implementation (see enum ut_flags)
* @_suite: name of the test suite concatenated with "_test"
*/
#define UNIT_TEST(_name, _flags, _suite) \

2
include/test/ut.h
View file

@ -495,7 +495,7 @@ void test_set_state(struct unit_test_state *uts);
* @select_name: Name of a single test to run (from the list provided). If NULL
* then all tests are run
* @runs_per_test: Number of times to run each test (typically 1)
* @force_run: Run tests that are marked as manual-only (UT_TESTF_MANUAL)
* @force_run: Run tests that are marked as manual-only (UTF_MANUAL)
* @test_insert: String describing a test to run after n other tests run, in the
* format n:name where n is the number of tests to run before this one and
* name is the name of the test to run. This is used to find which test causes

14
test/bloblist.c
View file

@ -270,20 +270,15 @@ static int bloblist_test_cmd_info(struct unit_test_state *uts)
data = bloblist_ensure(TEST_TAG, TEST_SIZE);
data2 = bloblist_ensure(TEST_TAG2, TEST_SIZE2);
console_record_reset_enable();
ut_silence_console(uts);
console_record_reset();
run_command("bloblist info", 0);
ut_assert_nextline("base: %lx", (ulong)map_to_sysmem(hdr));
ut_assert_nextline("total size: 400 1 KiB");
ut_assert_nextline("used size: 50 80 Bytes");
ut_assert_nextline("free: 3b0 944 Bytes");
ut_assert_console_end();
ut_unsilence_console(uts);
return 0;
}
BLOBLIST_TEST(bloblist_test_cmd_info, 0);
BLOBLIST_TEST(bloblist_test_cmd_info, UTF_CONSOLE);
/* Test the 'bloblist list' command */
static int bloblist_test_cmd_list(struct unit_test_state *uts)
@ -296,21 +291,16 @@ static int bloblist_test_cmd_list(struct unit_test_state *uts)
data = bloblist_ensure(TEST_TAG, TEST_SIZE);
data2 = bloblist_ensure(TEST_TAG2, TEST_SIZE2);
console_record_reset_enable();
ut_silence_console(uts);
console_record_reset();
run_command("bloblist list", 0);
ut_assert_nextline("Address Size Tag Name");
ut_assert_nextline("%08lx %8x fff000 SPL hand-off",
(ulong)map_to_sysmem(data), TEST_SIZE);
ut_assert_nextline("%08lx %8x 202 Chrome OS vboot context",
(ulong)map_to_sysmem(data2), TEST_SIZE2);
ut_assert_console_end();
ut_unsilence_console(uts);
return 0;
}
BLOBLIST_TEST(bloblist_test_cmd_list, 0);
BLOBLIST_TEST(bloblist_test_cmd_list, UTF_CONSOLE);
/* Test alignment of bloblist blobs */
static int bloblist_test_align(struct unit_test_state *uts)

49
test/boot/bootdev.c
View file

@ -28,7 +28,6 @@ static int bootdev_test_cmd_list(struct unit_test_state *uts)
{
int probed;
console_record_reset_enable();
for (probed = 0; probed < 2; probed++) {
int probe_ch = probed ? '+' : ' ';
@ -49,7 +48,7 @@ static int bootdev_test_cmd_list(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootdev_test_cmd_list, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootdev_test_cmd_list, UTF_DM | UTF_SCAN_FDT | UTF_CONSOLE);
/* Check 'bootdev select' and 'info' commands */
static int bootdev_test_cmd_select(struct unit_test_state *uts)
@ -59,7 +58,6 @@ static int bootdev_test_cmd_select(struct unit_test_state *uts)
/* get access to the CLI's cur_bootdev */
ut_assertok(bootstd_get_priv(&std));
console_record_reset_enable();
ut_asserteq(1, run_command("bootdev info", 0));
ut_assert_nextlinen("Please use");
ut_assert_console_end();
@ -99,7 +97,7 @@ static int bootdev_test_cmd_select(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootdev_test_cmd_select, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootdev_test_cmd_select, UTF_DM | UTF_SCAN_FDT | UTF_CONSOLE);
/* Check bootdev labels */
static int bootdev_test_labels(struct unit_test_state *uts)
@ -131,8 +129,7 @@ static int bootdev_test_labels(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootdev_test_labels, UT_TESTF_DM | UT_TESTF_SCAN_FDT |
UT_TESTF_ETH_BOOTDEV);
BOOTSTD_TEST(bootdev_test_labels, UTF_DM | UTF_SCAN_FDT | UTF_ETH_BOOTDEV);
/* Check bootdev_find_by_any() */
static int bootdev_test_any(struct unit_test_state *uts)
@ -158,7 +155,6 @@ static int bootdev_test_any(struct unit_test_state *uts)
* 9 [ + ] OK mmc mmc1.bootdev
* a [ ] OK mmc mmc0.bootdev
*/
console_record_reset_enable();
ut_assertok(bootdev_find_by_any("8", &dev, &mflags));
ut_asserteq(UCLASS_BOOTDEV, device_get_uclass_id(dev));
ut_asserteq(BOOTFLOW_METHF_SINGLE_DEV, mflags);
@ -186,8 +182,8 @@ static int bootdev_test_any(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootdev_test_any, UT_TESTF_DM | UT_TESTF_SCAN_FDT |
UT_TESTF_ETH_BOOTDEV);
BOOTSTD_TEST(bootdev_test_any, UTF_DM | UTF_SCAN_FDT | UTF_ETH_BOOTDEV |
UTF_CONSOLE);
/*
* Check bootdev ordering with the bootdev-order property and boot_targets
@ -274,7 +270,7 @@ static int bootdev_test_order(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootdev_test_order, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootdev_test_order, UTF_DM | UTF_SCAN_FDT);
/* Check default bootdev ordering */
static int bootdev_test_order_default(struct unit_test_state *uts)
@ -301,7 +297,7 @@ static int bootdev_test_order_default(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootdev_test_order_default, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootdev_test_order_default, UTF_DM | UTF_SCAN_FDT);
/* Check bootdev ordering with the uclass priority */
static int bootdev_test_prio(struct unit_test_state *uts)
@ -323,7 +319,6 @@ static int bootdev_test_prio(struct unit_test_state *uts)
ut_assertok(bootstd_test_drop_bootdev_order(uts));
/* 3 MMC and 3 USB bootdevs: MMC should come before USB */
console_record_reset_enable();
ut_assertok(bootflow_scan_first(NULL, NULL, &iter, 0, &bflow));
ut_asserteq(-ENODEV, bootflow_scan_next(&iter, &bflow));
ut_asserteq(6, iter.num_devs);
@ -350,7 +345,7 @@ static int bootdev_test_prio(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootdev_test_prio, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootdev_test_prio, UTF_DM | UTF_SCAN_FDT);
/* Check listing hunters */
static int bootdev_test_hunter(struct unit_test_state *uts)
@ -363,7 +358,6 @@ static int bootdev_test_hunter(struct unit_test_state *uts)
/* get access to the used hunters */
ut_assertok(bootstd_get_priv(&std));
console_record_reset_enable();
bootdev_list_hunters(std);
ut_assert_nextline("Prio Used Uclass Hunter");
ut_assert_nextlinen("----");
@ -390,7 +384,7 @@ static int bootdev_test_hunter(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootdev_test_hunter, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootdev_test_hunter, UTF_DM | UTF_SCAN_FDT | UTF_CONSOLE);
/* Check 'bootdev hunt' command */
static int bootdev_test_cmd_hunt(struct unit_test_state *uts)
@ -403,7 +397,6 @@ static int bootdev_test_cmd_hunt(struct unit_test_state *uts)
/* get access to the used hunters */
ut_assertok(bootstd_get_priv(&std));
console_record_reset_enable();
ut_assertok(run_command("bootdev hunt -l", 0));
ut_assert_nextline("Prio Used Uclass Hunter");
ut_assert_nextlinen("----");
@ -464,8 +457,8 @@ static int bootdev_test_cmd_hunt(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootdev_test_cmd_hunt, UT_TESTF_DM | UT_TESTF_SCAN_FDT |
UT_TESTF_ETH_BOOTDEV);
BOOTSTD_TEST(bootdev_test_cmd_hunt, UTF_DM | UTF_SCAN_FDT | UTF_ETH_BOOTDEV |
UTF_CONSOLE);
/* Check searching for bootdevs using the hunters */
static int bootdev_test_hunt_scan(struct unit_test_state *uts)
@ -485,7 +478,7 @@ static int bootdev_test_hunt_scan(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootdev_test_hunt_scan, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootdev_test_hunt_scan, UTF_DM | UTF_SCAN_FDT);
/* Check that only bootable partitions are processed */
static int bootdev_test_bootable(struct unit_test_state *uts)
@ -522,7 +515,7 @@ static int bootdev_test_bootable(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootdev_test_bootable, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootdev_test_bootable, UTF_DM | UTF_SCAN_FDT);
/* Check hunting for bootdev of a particular priority */
static int bootdev_test_hunt_prio(struct unit_test_state *uts)
@ -530,7 +523,6 @@ static int bootdev_test_hunt_prio(struct unit_test_state *uts)
usb_started = false;
test_set_skip_delays(true);
console_record_reset_enable();
ut_assertok(bootdev_hunt_prio(BOOTDEVP_4_SCAN_FAST, false));
ut_assert_nextline("scanning bus for devices...");
ut_assert_skip_to_line(" Type: Hard Disk");
@ -547,7 +539,7 @@ static int bootdev_test_hunt_prio(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootdev_test_hunt_prio, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootdev_test_hunt_prio, UTF_DM | UTF_SCAN_FDT | UTF_CONSOLE);
/* Check hunting for bootdevs with a particular label */
static int bootdev_test_hunt_label(struct unit_test_state *uts)
@ -562,7 +554,6 @@ static int bootdev_test_hunt_label(struct unit_test_state *uts)
ut_assertok(bootstd_get_priv(&std));
/* scan an unknown uclass */
console_record_reset_enable();
old = (void *)&mflags; /* arbitrary pointer to check against dev */
dev = old;
mflags = 123;
@ -600,7 +591,7 @@ static int bootdev_test_hunt_label(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootdev_test_hunt_label, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootdev_test_hunt_label, UTF_DM | UTF_SCAN_FDT | UTF_CONSOLE);
/* Check iterating to the next label in a list */
static int bootdev_test_next_label(struct unit_test_state *uts)
@ -627,7 +618,6 @@ static int bootdev_test_next_label(struct unit_test_state *uts)
dev = NULL;
mflags = 123;
ut_assertok(bootdev_next_label(&iter, &dev, &mflags));
console_record_reset_enable();
ut_assert_console_end();
ut_assertnonnull(dev);
ut_asserteq_str("mmc0.bootdev", dev->name);
@ -677,8 +667,8 @@ static int bootdev_test_next_label(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootdev_test_next_label, UT_TESTF_DM | UT_TESTF_SCAN_FDT |
UT_TESTF_ETH_BOOTDEV | UT_TESTF_SF_BOOTDEV);
BOOTSTD_TEST(bootdev_test_next_label, UTF_DM | UTF_SCAN_FDT | UTF_ETH_BOOTDEV |
UTF_SF_BOOTDEV | UTF_CONSOLE);
/* Check iterating to the next prioirty in a list */
static int bootdev_test_next_prio(struct unit_test_state *uts)
@ -703,7 +693,6 @@ static int bootdev_test_next_prio(struct unit_test_state *uts)
iter.flags = BOOTFLOWIF_SHOW;
dev = NULL;
console_record_reset_enable();
ut_assertok(bootdev_next_prio(&iter, &dev));
ut_assertnonnull(dev);
ut_asserteq_str("mmc2.bootdev", dev->name);
@ -762,5 +751,5 @@ static int bootdev_test_next_prio(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootdev_test_next_prio, UT_TESTF_DM | UT_TESTF_SCAN_FDT |
UT_TESTF_SF_BOOTDEV);
BOOTSTD_TEST(bootdev_test_next_prio, UTF_DM | UTF_SCAN_FDT | UTF_SF_BOOTDEV |
UTF_CONSOLE);

65
test/boot/bootflow.c
View file

@ -50,7 +50,6 @@ static int inject_response(struct unit_test_state *uts)
/* Check 'bootflow scan/list' commands */
static int bootflow_cmd(struct unit_test_state *uts)
{
console_record_reset_enable();
ut_assertok(run_command("bootdev select 1", 0));
ut_assert_console_end();
ut_assertok(run_command("bootflow scan -lH", 0));
@ -76,14 +75,13 @@ static int bootflow_cmd(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootflow_cmd, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootflow_cmd, UTF_DM | UTF_SCAN_FDT | UTF_CONSOLE);
/* Check 'bootflow scan' with a label / seq */
static int bootflow_cmd_label(struct unit_test_state *uts)
{
test_set_eth_enable(false);
console_record_reset_enable();
ut_assertok(run_command("bootflow scan -lH mmc1", 0));
ut_assert_nextline("Scanning for bootflows with label 'mmc1'");
ut_assert_skip_to_line("(1 bootflow, 1 valid)");
@ -123,15 +121,14 @@ static int bootflow_cmd_label(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootflow_cmd_label, UT_TESTF_DM | UT_TESTF_SCAN_FDT |
UT_TESTF_ETH_BOOTDEV);
BOOTSTD_TEST(bootflow_cmd_label, UTF_DM | UTF_SCAN_FDT | UTF_ETH_BOOTDEV |
UTF_CONSOLE);
/* Check 'bootflow scan/list' commands using all bootdevs */
static int bootflow_cmd_glob(struct unit_test_state *uts)
{
ut_assertok(bootstd_test_drop_bootdev_order(uts));
console_record_reset_enable();
ut_assertok(run_command("bootflow scan -lGH", 0));
ut_assert_nextline("Scanning for bootflows in all bootdevs");
ut_assert_nextline("Seq Method State Uclass Part Name Filename");
@ -156,14 +153,13 @@ static int bootflow_cmd_glob(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootflow_cmd_glob, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootflow_cmd_glob, UTF_DM | UTF_SCAN_FDT | UTF_CONSOLE);
/* Check 'bootflow scan -e' */
static int bootflow_cmd_scan_e(struct unit_test_state *uts)
{
ut_assertok(bootstd_test_drop_bootdev_order(uts));
console_record_reset_enable();
ut_assertok(run_command("bootflow scan -aleGH", 0));
ut_assert_nextline("Scanning for bootflows in all bootdevs");
ut_assert_nextline("Seq Method State Uclass Part Name Filename");
@ -207,12 +203,11 @@ static int bootflow_cmd_scan_e(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootflow_cmd_scan_e, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootflow_cmd_scan_e, UTF_DM | UTF_SCAN_FDT | UTF_CONSOLE);
/* Check 'bootflow info' */
static int bootflow_cmd_info(struct unit_test_state *uts)
{
console_record_reset_enable();
ut_assertok(run_command("bootdev select 1", 0));
ut_assert_console_end();
ut_assertok(run_command("bootflow scan", 0));
@ -248,12 +243,11 @@ static int bootflow_cmd_info(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootflow_cmd_info, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootflow_cmd_info, UTF_DM | UTF_SCAN_FDT | UTF_CONSOLE);
/* Check 'bootflow scan -b' to boot the first available bootdev */
static int bootflow_scan_boot(struct unit_test_state *uts)
{
console_record_reset_enable();
ut_assertok(inject_response(uts));
ut_assertok(run_command("bootflow scan -b", 0));
ut_assert_nextline(
@ -270,7 +264,7 @@ static int bootflow_scan_boot(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootflow_scan_boot, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootflow_scan_boot, UTF_DM | UTF_SCAN_FDT | UTF_CONSOLE);
/* Check iterating through available bootflows */
static int bootflow_iter(struct unit_test_state *uts)
@ -368,7 +362,7 @@ static int bootflow_iter(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootflow_iter, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootflow_iter, UTF_DM | UTF_SCAN_FDT);
#if defined(CONFIG_SANDBOX) && defined(CONFIG_BOOTMETH_GLOBAL)
/* Check using the system bootdev */
@ -386,7 +380,6 @@ static int bootflow_system(struct unit_test_state *uts)
/* We should get a single 'bootmgr' method right at the end */
bootstd_clear_glob();
console_record_reset_enable();
ut_assertok(run_command("bootflow scan -lH", 0));
ut_assert_skip_to_line(
" 0 efi_mgr ready (none) 0 <NULL> ");
@ -396,8 +389,8 @@ static int bootflow_system(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootflow_system, UT_TESTF_DM | UT_TESTF_SCAN_PDATA |
UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootflow_system, UTF_DM | UTF_SCAN_PDATA | UTF_SCAN_FDT |
UTF_CONSOLE);
#endif
/* Check disabling a bootmethod if it requests it */
@ -416,7 +409,6 @@ static int bootflow_iter_disable(struct unit_test_state *uts)
ut_assertok(bootstd_test_drop_bootdev_order(uts));
bootstd_clear_glob();
console_record_reset_enable();
ut_assertok(inject_response(uts));
ut_assertok(run_command("bootflow scan -lbH", 0));
@ -438,7 +430,7 @@ static int bootflow_iter_disable(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootflow_iter_disable, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootflow_iter_disable, UTF_DM | UTF_SCAN_FDT | UTF_CONSOLE);
/* Check 'bootflow scan' with a bootmeth ordering including a global bootmeth */
static int bootflow_scan_glob_bootmeth(struct unit_test_state *uts)
@ -452,7 +444,6 @@ static int bootflow_scan_glob_bootmeth(struct unit_test_state *uts)
* Make sure that the -G flag makes the scan fail, since this is not
* supported when an ordering is provided
*/
console_record_reset_enable();
ut_assertok(bootmeth_set_order("efi firmware0"));
ut_assertok(run_command("bootflow scan -lGH", 0));
ut_assert_nextline("Scanning for bootflows in all bootdevs");
@ -479,12 +470,12 @@ static int bootflow_scan_glob_bootmeth(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootflow_scan_glob_bootmeth, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootflow_scan_glob_bootmeth, UTF_DM | UTF_SCAN_FDT |
UTF_CONSOLE);
/* Check 'bootflow boot' to boot a selected bootflow */
static int bootflow_cmd_boot(struct unit_test_state *uts)
{
console_record_reset_enable();
ut_assertok(run_command("bootdev select 1", 0));
ut_assert_console_end();
ut_assertok(run_command("bootflow scan", 0));
@ -508,7 +499,7 @@ static int bootflow_cmd_boot(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootflow_cmd_boot, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootflow_cmd_boot, UTF_DM | UTF_SCAN_FDT | UTF_CONSOLE);
/**
* prep_mmc_bootdev() - Set up an mmc bootdev so we can access other distros
@ -585,7 +576,6 @@ static int scan_mmc_bootdev(struct unit_test_state *uts, const char *mmc_dev,
ut_assertok(prep_mmc_bootdev(uts, mmc_dev, bind_cros, &old_order));
console_record_reset_enable();
ut_assertok(run_command("bootflow scan", 0));
ut_assert_console_end();
@ -613,7 +603,6 @@ static int scan_mmc_android_bootdev(struct unit_test_state *uts, const char *mmc
ut_assertok(prep_mmc_bootdev(uts, mmc_dev, true, &old_order));
console_record_reset_enable();
ut_assertok(run_command("bootflow scan", 0));
/* Android bootflow might print one or two 'ANDROID:*' logs */
ut_check_skipline(uts);
@ -675,7 +664,7 @@ static int bootflow_cmd_menu(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootflow_cmd_menu, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootflow_cmd_menu, UTF_DM | UTF_SCAN_FDT | UTF_CONSOLE);
/* Check 'bootflow scan -m' to select a bootflow using a menu */
static int bootflow_scan_menu(struct unit_test_state *uts)
@ -723,8 +712,7 @@ static int bootflow_scan_menu(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootflow_scan_menu,
UT_TESTF_DM | UT_TESTF_SCAN_FDT | UT_TESTF_CONSOLE_REC);
BOOTSTD_TEST(bootflow_scan_menu, UTF_DM | UTF_SCAN_FDT | UTF_CONSOLE);
/* Check 'bootflow scan -mb' to select and boot a bootflow using a menu */
static int bootflow_scan_menu_boot(struct unit_test_state *uts)
@ -770,8 +758,7 @@ static int bootflow_scan_menu_boot(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootflow_scan_menu_boot,
UT_TESTF_DM | UT_TESTF_SCAN_FDT | UT_TESTF_CONSOLE_REC);
BOOTSTD_TEST(bootflow_scan_menu_boot, UTF_DM | UTF_SCAN_FDT | UTF_CONSOLE);
/* Check searching for a single bootdev using the hunters */
static int bootflow_cmd_hunt_single(struct unit_test_state *uts)
@ -783,7 +770,6 @@ static int bootflow_cmd_hunt_single(struct unit_test_state *uts)
ut_assertok(bootstd_test_drop_bootdev_order(uts));
console_record_reset_enable();
ut_assertok(run_command("bootflow scan -l mmc1", 0));
ut_assert_nextline("Scanning for bootflows with label 'mmc1'");
ut_assert_skip_to_line("(1 bootflow, 1 valid)");
@ -794,7 +780,8 @@ static int bootflow_cmd_hunt_single(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootflow_cmd_hunt_single, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootflow_cmd_hunt_single, UTF_DM | UTF_SCAN_FDT |
UTF_CONSOLE);
/* Check searching for a uclass label using the hunters */
static int bootflow_cmd_hunt_label(struct unit_test_state *uts)
@ -808,7 +795,6 @@ static int bootflow_cmd_hunt_label(struct unit_test_state *uts)
test_set_eth_enable(false);
ut_assertok(bootstd_test_drop_bootdev_order(uts));
console_record_reset_enable();
ut_assertok(run_command("bootflow scan -l mmc", 0));
/* check that the hunter was used */
@ -831,7 +817,7 @@ static int bootflow_cmd_hunt_label(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootflow_cmd_hunt_label, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootflow_cmd_hunt_label, UTF_DM | UTF_SCAN_FDT | UTF_CONSOLE);
/**
* check_font() - Check that the font size for an item matches expectations
@ -891,7 +877,7 @@ static int bootflow_menu_theme(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootflow_menu_theme, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootflow_menu_theme, UTF_DM | UTF_SCAN_FDT | UTF_CONSOLE);
/**
* check_arg() - Check both the normal case and the buffer-overflow case
@ -1127,7 +1113,6 @@ static int bootflow_cmdline(struct unit_test_state *uts)
{
ut_assertok(run_command("bootflow scan mmc", 0));
ut_assertok(run_command("bootflow sel 0", 0));
console_record_reset_enable();
ut_asserteq(1, run_command("bootflow cmdline get fred", 0));
ut_assert_nextline("Argument not found");
@ -1151,13 +1136,11 @@ static int bootflow_cmdline(struct unit_test_state *uts)
ut_asserteq(0, run_command("bootflow cmdline set mary abc", 0));
ut_asserteq(0, run_command("bootflow cmdline set mary", 0));
ut_assert_nextline_empty();
ut_assert_console_end();
return 0;
}
BOOTSTD_TEST(bootflow_cmdline, 0);
BOOTSTD_TEST(bootflow_cmdline, UTF_CONSOLE);
/* test a few special changes to a long command line */
static int bootflow_cmdline_special(struct unit_test_state *uts)
@ -1198,7 +1181,7 @@ static int bootflow_cros(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootflow_cros, 0);
BOOTSTD_TEST(bootflow_cros, UTF_CONSOLE);
/* Test Android bootmeth */
static int bootflow_android(struct unit_test_state *uts)
@ -1221,4 +1204,4 @@ static int bootflow_android(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootflow_android, 0);
BOOTSTD_TEST(bootflow_android, UTF_CONSOLE);

14
test/boot/bootmeth.c
View file

@ -16,7 +16,6 @@
/* Check 'bootmeth list' command */
static int bootmeth_cmd_list(struct unit_test_state *uts)
{
console_record_reset_enable();
ut_assertok(run_command("bootmeth list", 0));
ut_assert_nextline("Order Seq Name Description");
ut_assert_nextlinen("---");
@ -31,13 +30,12 @@ static int bootmeth_cmd_list(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootmeth_cmd_list, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootmeth_cmd_list, UTF_DM | UTF_SCAN_FDT | UTF_CONSOLE);
/* Check 'bootmeth order' command */
static int bootmeth_cmd_order(struct unit_test_state *uts)
{
/* Select just one bootmethod */
console_record_reset_enable();
ut_assertok(run_command("bootmeth order extlinux", 0));
ut_assert_console_end();
ut_assertnonnull(env_get("bootmeths"));
@ -104,7 +102,7 @@ static int bootmeth_cmd_order(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootmeth_cmd_order, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootmeth_cmd_order, UTF_DM | UTF_SCAN_FDT | UTF_CONSOLE);
/* Check 'bootmeth order' command with global bootmeths */
static int bootmeth_cmd_order_glob(struct unit_test_state *uts)
@ -112,7 +110,6 @@ static int bootmeth_cmd_order_glob(struct unit_test_state *uts)
if (!IS_ENABLED(CONFIG_BOOTMETH_GLOBAL))
return -EAGAIN;
console_record_reset_enable();
ut_assertok(run_command("bootmeth order \"efi firmware0\"", 0));
ut_assert_console_end();
ut_assertok(run_command("bootmeth list", 0));
@ -128,7 +125,7 @@ static int bootmeth_cmd_order_glob(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootmeth_cmd_order_glob, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootmeth_cmd_order_glob, UTF_DM | UTF_SCAN_FDT | UTF_CONSOLE);
/* Check 'bootmeths' env var */
static int bootmeth_env(struct unit_test_state *uts)
@ -138,7 +135,6 @@ static int bootmeth_env(struct unit_test_state *uts)
ut_assertok(bootstd_get_priv(&std));
/* Select just one bootmethod */
console_record_reset_enable();
ut_assertok(env_set("bootmeths", "extlinux"));
ut_asserteq(1, std->bootmeth_count);
@ -154,7 +150,7 @@ static int bootmeth_env(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootmeth_env, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootmeth_env, UTF_DM | UTF_SCAN_FDT | UTF_CONSOLE);
/* Check the get_state_desc() method */
static int bootmeth_state(struct unit_test_state *uts)
@ -170,4 +166,4 @@ static int bootmeth_state(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(bootmeth_state, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(bootmeth_state, UTF_DM | UTF_SCAN_FDT);

13
test/boot/cedit.c
View file

@ -25,8 +25,6 @@ static int cedit_base(struct unit_test_state *uts)
ut_assertok(run_command("cedit load hostfs - cedit.dtb", 0));
console_record_reset_enable();
/*
* ^N Move down to second menu
* ^M Open menu
@ -52,7 +50,7 @@ static int cedit_base(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(cedit_base, 0);
BOOTSTD_TEST(cedit_base, UTF_CONSOLE);
/* Check the cedit write_fdt and read_fdt commands */
static int cedit_fdt(struct unit_test_state *uts)
@ -70,7 +68,6 @@ static int cedit_fdt(struct unit_test_state *uts)
void *fdt;
int i;
console_record_reset_enable();
ut_assertok(run_command("cedit load hostfs - cedit.dtb", 0));
ut_asserteq(ID_SCENE1, cedit_prepare(cur_exp, &vid_priv, &scn));
@ -122,7 +119,7 @@ static int cedit_fdt(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(cedit_fdt, 0);
BOOTSTD_TEST(cedit_fdt, UTF_CONSOLE);
/* Check the cedit write_env and read_env commands */
static int cedit_env(struct unit_test_state *uts)
@ -134,7 +131,6 @@ static int cedit_env(struct unit_test_state *uts)
struct scene *scn;
char *str;
console_record_reset_enable();
ut_assertok(run_command("cedit load hostfs - cedit.dtb", 0));
ut_asserteq(ID_SCENE1, cedit_prepare(cur_exp, &vid_priv, &scn));
@ -177,7 +173,7 @@ static int cedit_env(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(cedit_env, 0);
BOOTSTD_TEST(cedit_env, UTF_CONSOLE);
/* Check the cedit write_cmos and read_cmos commands */
static int cedit_cmos(struct unit_test_state *uts)
@ -187,7 +183,6 @@ static int cedit_cmos(struct unit_test_state *uts)
extern struct expo *cur_exp;
struct scene *scn;
console_record_reset_enable();
ut_assertok(run_command("cedit load hostfs - cedit.dtb", 0));
ut_asserteq(ID_SCENE1, cedit_prepare(cur_exp, &vid_priv, &scn));
@ -218,4 +213,4 @@ static int cedit_cmos(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(cedit_cmos, 0);
BOOTSTD_TEST(cedit_cmos, UTF_CONSOLE);

15
test/boot/expo.c
View file

@ -114,7 +114,7 @@ static int expo_base(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(expo_base, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(expo_base, UTF_DM | UTF_SCAN_FDT);
/* Check creating a scene */
static int expo_scene(struct unit_test_state *uts)
@ -165,7 +165,7 @@ static int expo_scene(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(expo_scene, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(expo_scene, UTF_DM | UTF_SCAN_FDT);
/* Check creating a scene with objects */
static int expo_object(struct unit_test_state *uts)
@ -225,7 +225,7 @@ static int expo_object(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(expo_object, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(expo_object, UTF_DM | UTF_SCAN_FDT);
/* Check setting object attributes and using themes */
static int expo_object_attr(struct unit_test_state *uts)
@ -286,7 +286,7 @@ static int expo_object_attr(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(expo_object_attr, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(expo_object_attr, UTF_DM | UTF_SCAN_FDT);
/**
* struct test_iter_priv - private data for expo-iterator test
@ -432,7 +432,7 @@ static int expo_object_menu(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(expo_object_menu, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(expo_object_menu, UTF_DM | UTF_SCAN_FDT);
/* Check rendering a scene */
static int expo_render_image(struct unit_test_state *uts)
@ -445,7 +445,6 @@ static int expo_render_image(struct unit_test_state *uts)
struct expo *exp;
int id;
console_record_reset_enable();
ut_assertok(uclass_first_device_err(UCLASS_VIDEO, &dev));
ut_assertok(expo_new(EXPO_NAME, NULL, &exp));
@ -633,7 +632,7 @@ static int expo_render_image(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(expo_render_image, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(expo_render_image, UTF_DM | UTF_SCAN_FDT | UTF_CONSOLE);
/* Check building an expo from a devicetree description */
static int expo_test_build(struct unit_test_state *uts)
@ -712,4 +711,4 @@ static int expo_test_build(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(expo_test_build, UT_TESTF_DM);
BOOTSTD_TEST(expo_test_build, UTF_DM);

6
test/boot/upl.c
View file

@ -374,7 +374,7 @@ static int upl_test_info(struct unit_test_state *uts)
return 0;
}
UPL_TEST(upl_test_info, UT_TESTF_CONSOLE_REC);
UPL_TEST(upl_test_info, UTF_CONSOLE);
/* Test 'upl read' and 'upl_write' commands */
static int upl_test_read_write(struct unit_test_state *uts)
@ -396,7 +396,7 @@ static int upl_test_read_write(struct unit_test_state *uts)
return 0;
}
UPL_TEST(upl_test_read_write, UT_TESTF_CONSOLE_REC);
UPL_TEST(upl_test_read_write, UTF_CONSOLE);
/* Test UPL passthrough */
static int upl_test_info_norun(struct unit_test_state *uts)
@ -425,7 +425,7 @@ static int upl_test_info_norun(struct unit_test_state *uts)
return 0;
}
UPL_TEST(upl_test_info_norun, UT_TESTF_CONSOLE_REC | UT_TESTF_MANUAL);
UPL_TEST(upl_test_info_norun, UTF_CONSOLE | UTF_MANUAL);
int do_ut_upl(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{

4
test/boot/vbe_fixup.c
View file

@ -51,5 +51,5 @@ static int vbe_test_fixup_norun(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(vbe_test_fixup_norun, UT_TESTF_DM | UT_TESTF_SCAN_FDT |
UT_TESTF_FLAT_TREE | UT_TESTF_MANUAL);
BOOTSTD_TEST(vbe_test_fixup_norun, UTF_DM | UTF_SCAN_FDT | UTF_FLAT_TREE |
UTF_MANUAL);

2
test/boot/vbe_simple.c
View file

@ -85,4 +85,4 @@ static int vbe_simple_test_base(struct unit_test_state *uts)
return 0;
}
BOOTSTD_TEST(vbe_simple_test_base, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
BOOTSTD_TEST(vbe_simple_test_base, UTF_DM | UTF_SCAN_FDT);

3
test/cmd/addrmap.c
View file

@ -15,7 +15,6 @@
/* Test 'addrmap' command output */
static int addrmap_test_basic(struct unit_test_state *uts)
{
ut_assertok(console_record_reset_enable());
ut_assertok(run_command("addrmap", 0));
ut_assert_nextline(" vaddr paddr size");
ut_assert_nextline("================ ================ ================");
@ -24,7 +23,7 @@ static int addrmap_test_basic(struct unit_test_state *uts)
return 0;
}
ADDRMAP_TEST(addrmap_test_basic, UT_TESTF_CONSOLE_REC);
ADDRMAP_TEST(addrmap_test_basic, UTF_CONSOLE);
int do_ut_addrmap(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{

3
test/cmd/armffa.c
View file

@ -28,5 +28,4 @@ static int dm_test_armffa_cmd(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_armffa_cmd, UT_TESTF_SCAN_FDT | UT_TESTF_CONSOLE_REC);
DM_TEST(dm_test_armffa_cmd, UTF_SCAN_FDT | UTF_CONSOLE);

24
test/cmd/bdinfo.c
View file

@ -232,22 +232,19 @@ static int bdinfo_test_all(struct unit_test_state *uts)
static int bdinfo_test_full(struct unit_test_state *uts)
{
/* Test BDINFO full print */
ut_assertok(console_record_reset_enable());
ut_assertok(run_commandf("bdinfo"));
ut_assertok(bdinfo_test_all(uts));
ut_assertok(run_commandf("bdinfo -a"));
ut_assertok(bdinfo_test_all(uts));
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
return 0;
}
BDINFO_TEST(bdinfo_test_full, UT_TESTF_CONSOLE_REC);
BDINFO_TEST(bdinfo_test_full, UTF_CONSOLE);
static int bdinfo_test_help(struct unit_test_state *uts)
{
/* Test BDINFO unknown option help text print */
ut_assertok(console_record_reset_enable());
if (!CONFIG_IS_ENABLED(GETOPT)) {
ut_asserteq(0, run_commandf("bdinfo -h"));
ut_assertok(bdinfo_test_all(uts));
@ -259,44 +256,39 @@ static int bdinfo_test_help(struct unit_test_state *uts)
ut_assert_nextlinen("Usage:");
ut_assert_nextlinen("bdinfo");
}
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
return 0;
}
BDINFO_TEST(bdinfo_test_help, UT_TESTF_CONSOLE_REC);
BDINFO_TEST(bdinfo_test_help, UTF_CONSOLE);
static int bdinfo_test_memory(struct unit_test_state *uts)
{
/* Test BDINFO memory layout only print */
ut_assertok(console_record_reset_enable());
ut_assertok(run_commandf("bdinfo -m"));
if (!CONFIG_IS_ENABLED(GETOPT))
ut_assertok(bdinfo_test_all(uts));
else
ut_assertok(bdinfo_check_mem(uts));
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
return 0;
}
BDINFO_TEST(bdinfo_test_memory, UT_TESTF_CONSOLE_REC);
BDINFO_TEST(bdinfo_test_memory, UTF_CONSOLE);
static int bdinfo_test_eth(struct unit_test_state *uts)
{
/* Test BDINFO ethernet settings only print */
ut_assertok(console_record_reset_enable());
ut_assertok(run_commandf("bdinfo -e"));
if (!CONFIG_IS_ENABLED(GETOPT))
ut_assertok(bdinfo_test_all(uts));
else if (IS_ENABLED(CONFIG_CMD_NET))
ut_assertok(test_eth(uts));
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
return 0;
}
BDINFO_TEST(bdinfo_test_eth, UT_TESTF_CONSOLE_REC);
BDINFO_TEST(bdinfo_test_eth, UTF_CONSOLE);
int do_ut_bdinfo(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{

39
test/cmd/exit.c
View file

@ -33,96 +33,83 @@ static int cmd_exit_test(struct unit_test_state *uts)
* - return value can be printed outside of 'run' command
*/
for (i = -3; i <= 3; i++) {
ut_assertok(console_record_reset_enable());
ut_assertok(run_commandf("setenv foo 'echo bar ; exit %d ; echo baz' ; run foo ; echo $?", i));
ut_assert_nextline("bar");
ut_assert_nextline("%d", i > 0 ? i : 0);
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
ut_assertok(console_record_reset_enable());
ut_assertok(run_commandf("setenv foo 'echo bar ; exit %d ; echo baz' ; run foo && echo quux ; echo $?", i));
ut_assert_nextline("bar");
if (i <= 0)
ut_assert_nextline("quux");
ut_assert_nextline("%d", i > 0 ? i : 0);
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
ut_assertok(console_record_reset_enable());
ut_assertok(run_commandf("setenv foo 'echo bar ; exit %d ; echo baz' ; run foo || echo quux ; echo $?", i));
ut_assert_nextline("bar");
if (i > 0)
ut_assert_nextline("quux");
/* Either 'exit' returns 0, or 'echo quux' returns 0 */
ut_assert_nextline("0");
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
}
/* Validate that 'exit' behaves the same way as 'exit 0' */
ut_assertok(console_record_reset_enable());
ut_assertok(run_commandf("setenv foo 'echo bar ; exit ; echo baz' ; run foo ; echo $?"));
ut_assert_nextline("bar");
ut_assert_nextline("0");
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
ut_assertok(console_record_reset_enable());
ut_assertok(run_commandf("setenv foo 'echo bar ; exit ; echo baz' ; run foo && echo quux ; echo $?"));
ut_assert_nextline("bar");
ut_assert_nextline("quux");
ut_assert_nextline("0");
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
ut_assertok(console_record_reset_enable());
ut_assertok(run_commandf("setenv foo 'echo bar ; exit ; echo baz' ; run foo || echo quux ; echo $?"));
ut_assert_nextline("bar");
/* Either 'exit' returns 0, or 'echo quux' returns 0 */
ut_assert_nextline("0");
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
/* Validate that return value still propagates from 'run' command */
ut_assertok(console_record_reset_enable());
ut_assertok(run_commandf("setenv foo 'echo bar ; true' ; run foo ; echo $?"));
ut_assert_nextline("bar");
ut_assert_nextline("0");
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
ut_assertok(console_record_reset_enable());
ut_assertok(run_commandf("setenv foo 'echo bar ; true' ; run foo && echo quux ; echo $?"));
ut_assert_nextline("bar");
ut_assert_nextline("quux");
ut_assert_nextline("0");
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
ut_assertok(console_record_reset_enable());
ut_assertok(run_commandf("setenv foo 'echo bar ; true' ; run foo || echo quux ; echo $?"));
ut_assert_nextline("bar");
/* The 'true' returns 0 */
ut_assert_nextline("0");
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
ut_assertok(console_record_reset_enable());
ut_assertok(run_commandf("setenv foo 'echo bar ; false' ; run foo ; echo $?"));
ut_assert_nextline("bar");
ut_assert_nextline("1");
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
ut_assertok(console_record_reset_enable());
ut_assertok(run_commandf("setenv foo 'echo bar ; false' ; run foo && echo quux ; echo $?"));
ut_assert_nextline("bar");
ut_assert_nextline("1");
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
ut_assertok(console_record_reset_enable());
ut_assertok(run_commandf("setenv foo 'echo bar ; false' ; run foo || echo quux ; echo $?"));
ut_assert_nextline("bar");
ut_assert_nextline("quux");
/* The 'echo quux' returns 0 */
ut_assert_nextline("0");
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
return 0;
}
EXIT_TEST(cmd_exit_test, UT_TESTF_CONSOLE_REC);
EXIT_TEST(cmd_exit_test, UTF_CONSOLE);
int do_ut_exit(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{

544
test/cmd/fdt.c
View file

File diff suppressed because it is too large Load diff

13
test/cmd/font.c
View file

@ -26,12 +26,11 @@ static int font_test_base(struct unit_test_state *uts)
ut_assertok(uclass_first_device_err(UCLASS_VIDEO, &dev));
ut_assertok(uclass_first_device_err(UCLASS_VIDEO_CONSOLE, &dev));
ut_assertok(console_record_reset_enable());
ut_assertok(run_command("font list", 0));
ut_assert_nextline("nimbus_sans_l_regular");
if (IS_ENABLED(CONFIG_CONSOLE_TRUETYPE_CANTORAONE))
ut_assert_nextline("cantoraone_regular");
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
ut_assertok(vidconsole_get_font_size(dev, &name, &size));
ut_asserteq_str("nimbus_sans_l_regular", name);
@ -49,19 +48,19 @@ static int font_test_base(struct unit_test_state *uts)
if (max_metrics < 2) {
ut_asserteq(1, ret);
ut_assert_nextline("Failed (error -7)");
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
return 0;
}
ut_assertok(ret);
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
ut_assertok(vidconsole_get_font_size(dev, &name, &size));
ut_asserteq_str("cantoraone_regular", name);
ut_asserteq(40, size);
ut_assertok(run_command("font size 30", 0));
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
ut_assertok(vidconsole_get_font_size(dev, &name, &size));
ut_asserteq_str("cantoraone_regular", name);
@ -69,8 +68,8 @@ static int font_test_base(struct unit_test_state *uts)
return 0;
}
FONT_TEST(font_test_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT |
UT_TESTF_CONSOLE_REC | UT_TESTF_DM);
FONT_TEST(font_test_base, UTF_SCAN_PDATA | UTF_SCAN_FDT | UTF_CONSOLE |
UTF_DM);
int do_ut_font(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{

2
test/cmd/history.c
View file

@ -45,4 +45,4 @@ static int lib_test_history(struct unit_test_state *uts)
return 0;
}
LIB_TEST(lib_test_history, UT_TESTF_CONSOLE_REC);
LIB_TEST(lib_test_history, UTF_CONSOLE);

6
test/cmd/loadm.c
View file

@ -23,7 +23,6 @@
static int loadm_test_params(struct unit_test_state *uts)
{
ut_assertok(console_record_reset_enable());
run_command("loadm", 0);
ut_assert_nextline("loadm - load binary blob from source address to destination address");
@ -41,7 +40,7 @@ static int loadm_test_params(struct unit_test_state *uts)
return 0;
}
LOADM_TEST(loadm_test_params, UT_TESTF_CONSOLE_REC);
LOADM_TEST(loadm_test_params, UTF_CONSOLE);
static int loadm_test_load (struct unit_test_state *uts)
{
@ -51,7 +50,6 @@ static int loadm_test_load (struct unit_test_state *uts)
memset(buf, '\0', BUF_SIZE);
memset(buf, 0xaa, BUF_SIZE / 2);
ut_assertok(console_record_reset_enable());
run_command("loadm 0x0 0x80 0x80", 0);
ut_assert_nextline("loaded bin to memory: size: 128");
@ -59,7 +57,7 @@ static int loadm_test_load (struct unit_test_state *uts)
return 0;
}
LOADM_TEST(loadm_test_load, UT_TESTF_CONSOLE_REC);
LOADM_TEST(loadm_test_load, UTF_CONSOLE);
int do_ut_loadm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{

24
test/cmd/mbr.c
View file

@ -261,11 +261,10 @@ static int mbr_test_run(struct unit_test_state *uts)
/* Make sure mmc6 exists */
ut_asserteq(6, blk_get_device_by_str("mmc", "6", &mmc_dev_desc));
ut_assertok(console_record_reset_enable());
ut_assertok(run_commandf("mmc dev 6"));
ut_assert_nextline("switch to partitions #0, OK");
ut_assert_nextline("mmc6 is current device");
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
/* Make sure mmc6 is 12+ MiB in size */
ut_assertok(run_commandf("mmc read 0x%lx 0x%lx 1", ra, (ulong)0xBFFE00 / 0x200));
@ -281,16 +280,16 @@ static int mbr_test_run(struct unit_test_state *uts)
memset(rbuf, 0, sizeof(rbuf));
ut_assertok(run_commandf("read mmc 6:0 0x%lx 0x%lx 1", ra, ebr_blk));
ut_assertok(memcmp(ebr_wbuf, rbuf, 512));
ut_assertok(console_record_reset_enable());
ut_assertf(0 == run_commandf(mbr_parts_buf), "Invalid partitions string: %s\n", mbr_parts_buf);
ut_assertok(run_commandf("mbr write mmc 6"));
ut_assert_nextlinen("MMC read: dev # 6");
ut_assert_nextline("MBR: write success!");
ut_assertok(run_commandf("mbr verify mmc 6"));
ut_assert_nextline("MBR: verify success!");
memset(rbuf, 0, sizeof(rbuf));
ut_assertok(run_commandf("read mmc 6:0 0x%lx 0x%lx 1", ra, ebr_blk));
ut_assertok(memcmp(ebr_wbuf, rbuf, 512));
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
/*
000001b0 00 00 00 00 00 00 00 00 78 56 34 12 00 00 80 05 |........xV4.....|
000001c0 05 01 0e 25 24 01 00 40 00 00 00 08 00 00 00 00 |...%$..@........|
@ -317,7 +316,6 @@ static int mbr_test_run(struct unit_test_state *uts)
memset(rbuf, 0, sizeof(rbuf));
ut_assertok(run_commandf("read mmc 6:0 0x%lx 0x%lx 1", ra, ebr_blk));
ut_assertok(memcmp(ebr_wbuf, rbuf, 512));
ut_assertok(console_record_reset_enable());
ut_assertf(0 == run_commandf(mbr_parts_buf), "Invalid partitions string: %s\n", mbr_parts_buf);
ut_assertok(run_commandf("mbr write mmc 6"));
ut_assert_nextline("MBR: write success!");
@ -326,7 +324,7 @@ static int mbr_test_run(struct unit_test_state *uts)
memset(rbuf, 0, sizeof(rbuf));
ut_assertok(run_commandf("read mmc 6:0 0x%lx 0x%lx 1", ra, ebr_blk));
ut_assertok(memcmp(ebr_wbuf, rbuf, 512));
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
/*
000001b0 00 00 00 00 00 00 00 00 78 56 34 12 00 00 80 05 |........xV4.....|
000001c0 05 01 0e 25 24 01 00 40 00 00 00 08 00 00 00 25 |...%$..@.......%|
@ -353,7 +351,6 @@ static int mbr_test_run(struct unit_test_state *uts)
memset(rbuf, 0, sizeof(rbuf));
ut_assertok(run_commandf("read mmc 6:0 0x%lx 0x%lx 1", ra, ebr_blk));
ut_assertok(memcmp(ebr_wbuf, rbuf, 512));
ut_assertok(console_record_reset_enable());
ut_assertf(0 == run_commandf(mbr_parts_buf), "Invalid partitions string: %s\n", mbr_parts_buf);
ut_assertok(run_commandf("mbr write mmc 6"));
ut_assert_nextline("MBR: write success!");
@ -362,7 +359,7 @@ static int mbr_test_run(struct unit_test_state *uts)
memset(rbuf, 0, sizeof(rbuf));
ut_assertok(run_commandf("read mmc 6:0 0x%lx 0x%lx 1", ra, ebr_blk));
ut_assertok(memcmp(ebr_wbuf, rbuf, 512));
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
/*
000001b0 00 00 00 00 00 00 00 00 78 56 34 12 00 00 80 05 |........xV4.....|
000001c0 05 01 0e 25 24 01 00 40 00 00 00 08 00 00 00 25 |...%$..@.......%|
@ -389,7 +386,6 @@ static int mbr_test_run(struct unit_test_state *uts)
memset(rbuf, 0, sizeof(rbuf));
ut_assertok(run_commandf("read mmc 6:0 0x%lx 0x%lx 1", ra, ebr_blk));
ut_assertok(memcmp(ebr_wbuf, rbuf, 512));
ut_assertok(console_record_reset_enable());
ut_assertf(0 == run_commandf(mbr_parts_buf), "Invalid partitions string: %s\n", mbr_parts_buf);
ut_assertok(run_commandf("mbr write mmc 6"));
ut_assert_nextline("MBR: write success!");
@ -398,7 +394,7 @@ static int mbr_test_run(struct unit_test_state *uts)
memset(rbuf, 0, sizeof(rbuf));
ut_assertok(run_commandf("read mmc 6:0 0x%lx 0x%lx 1", ra, ebr_blk));
ut_assertok(memcmp(ebr_wbuf, rbuf, 512));
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
/*
000001b0 00 00 00 00 00 00 00 00 78 56 34 12 00 00 80 05 |........xV4.....|
000001c0 05 01 0e 25 24 01 00 40 00 00 00 08 00 00 00 25 |...%$..@.......%|
@ -425,13 +421,12 @@ static int mbr_test_run(struct unit_test_state *uts)
memset(rbuf, 0, sizeof(rbuf));
ut_assertok(run_commandf("read mmc 6:0 0x%lx 0x%lx 1", ra, ebr_blk));
ut_assertok(memcmp(ebr_wbuf, rbuf, 512));
ut_assertok(console_record_reset_enable());
ut_assertf(0 == run_commandf(mbr_parts_buf), "Invalid partitions string: %s\n", mbr_parts_buf);
ut_assertf(0 == run_commandf("mbr write mmc 6"), "Invalid partitions string: %s\n", mbr_parts_buf);
ut_assert_nextline("MBR: write success!");
ut_assertok(run_commandf("mbr verify mmc 6"));
ut_assert_nextline("MBR: verify success!");
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
/*
000001b0 00 00 00 00 00 00 00 00 78 56 34 12 00 00 80 05 |........xV4.....|
000001c0 05 01 0e 25 24 01 00 40 00 00 00 08 00 00 00 25 |...%$..@.......%|
@ -465,7 +460,7 @@ static int mbr_test_run(struct unit_test_state *uts)
}
/* Declare mbr test */
UNIT_TEST(mbr_test_run, UT_TESTF_CONSOLE_REC, mbr_test);
UNIT_TEST(mbr_test_run, UTF_CONSOLE, mbr_test);
int do_ut_mbr(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
@ -479,5 +474,4 @@ static int dm_test_cmd_mbr(struct unit_test_state *uts)
{
return mbr_test_run(uts);
}
DM_TEST(dm_test_cmd_mbr, UT_TESTF_SCAN_FDT | UT_TESTF_CONSOLE_REC);
DM_TEST(dm_test_cmd_mbr, UTF_SCAN_FDT | UTF_CONSOLE);

31
test/cmd/mem_search.c
View file

@ -27,7 +27,6 @@ static int mem_test_ms_b(struct unit_test_state *uts)
buf[0x31] = 0x12;
buf[0xff] = 0x12;
buf[0x100] = 0x12;
ut_assertok(console_record_reset_enable());
run_command("ms.b 1 ff 12", 0);
ut_assert_nextline("00000030: 00 12 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................");
ut_assert_nextline("--");
@ -43,7 +42,7 @@ static int mem_test_ms_b(struct unit_test_state *uts)
return 0;
}
MEM_TEST(mem_test_ms_b, UT_TESTF_CONSOLE_REC);
MEM_TEST(mem_test_ms_b, UTF_CONSOLE);
/* Test 'ms' command with 16-bit values */
static int mem_test_ms_w(struct unit_test_state *uts)
@ -54,7 +53,6 @@ static int mem_test_ms_w(struct unit_test_state *uts)
memset(buf, '\0', BUF_SIZE);
buf[0x34 / 2] = 0x1234;
buf[BUF_SIZE / 2] = 0x1234;
ut_assertok(console_record_reset_enable());
run_command("ms.w 0 80 1234", 0);
ut_assert_nextline("00000030: 0000 0000 1234 0000 0000 0000 0000 0000 ....4...........");
ut_assert_nextline("1 match");
@ -68,7 +66,7 @@ static int mem_test_ms_w(struct unit_test_state *uts)
return 0;
}
MEM_TEST(mem_test_ms_w, UT_TESTF_CONSOLE_REC);
MEM_TEST(mem_test_ms_w, UTF_CONSOLE);
/* Test 'ms' command with 32-bit values */
static int mem_test_ms_l(struct unit_test_state *uts)
@ -79,7 +77,6 @@ static int mem_test_ms_l(struct unit_test_state *uts)
memset(buf, '\0', BUF_SIZE);
buf[0x38 / 4] = 0x12345678;
buf[BUF_SIZE / 4] = 0x12345678;
ut_assertok(console_record_reset_enable());
run_command("ms 0 40 12345678", 0);
ut_assert_nextline("00000030: 00000000 00000000 12345678 00000000 ........xV4.....");
ut_assert_nextline("1 match");
@ -89,7 +86,6 @@ static int mem_test_ms_l(struct unit_test_state *uts)
ut_asserteq(0x38, env_get_hex("memaddr", 0));
ut_asserteq(0x38 / 4, env_get_hex("mempos", 0));
ut_assertok(console_record_reset_enable());
run_command("ms 0 80 12345679", 0);
ut_assert_nextline("0 matches");
ut_assert_console_end();
@ -102,7 +98,7 @@ static int mem_test_ms_l(struct unit_test_state *uts)
return 0;
}
MEM_TEST(mem_test_ms_l, UT_TESTF_CONSOLE_REC);
MEM_TEST(mem_test_ms_l, UTF_CONSOLE);
/* Test 'ms' command with continuation */
static int mem_test_ms_cont(struct unit_test_state *uts)
@ -116,7 +112,6 @@ static int mem_test_ms_cont(struct unit_test_state *uts)
memset(buf, '\0', BUF_SIZE);
for (i = 5; i < 0x33; i += 3)
buf[i] = 0x34;
ut_assertok(console_record_reset_enable());
run_command("ms.b 0 100 34", 0);
ut_assert_nextlinen("00000000: 00 00 00 00 00 34 00 00 34 00 00 34 00 00 34 00");
ut_assert_nextline("--");
@ -134,7 +129,6 @@ static int mem_test_ms_cont(struct unit_test_state *uts)
* run_command() ignoes the repeatable flag when using hush, so call
* cmd_process() directly
*/
ut_assertok(console_record_reset_enable());
cmd_process(CMD_FLAG_REPEAT, 4, args, &repeatable, NULL);
ut_assert_nextlinen("00000020: 34 00 00 34 00 00 34 00 00 34 00 00 34 00 00 34");
ut_assert_nextline("--");
@ -152,7 +146,7 @@ static int mem_test_ms_cont(struct unit_test_state *uts)
return 0;
}
MEM_TEST(mem_test_ms_cont, UT_TESTF_CONSOLE_REC);
MEM_TEST(mem_test_ms_cont, UTF_CONSOLE);
/* Test that an 'ms' command with continuation stops at the end of the range */
static int mem_test_ms_cont_end(struct unit_test_state *uts)
@ -167,7 +161,6 @@ static int mem_test_ms_cont_end(struct unit_test_state *uts)
buf[0x31] = 0x12;
buf[0xff] = 0x12;
buf[0x100] = 0x12;
ut_assertok(console_record_reset_enable());
run_command("ms.b 1 ff 12", 0);
ut_assert_nextlinen("00000030");
ut_assert_nextlinen("--");
@ -181,13 +174,11 @@ static int mem_test_ms_cont_end(struct unit_test_state *uts)
*
* This should produce no matches.
*/
ut_assertok(console_record_reset_enable());
cmd_process(CMD_FLAG_REPEAT, 4, args, &repeatable, NULL);
ut_assert_nextlinen("0 matches");
ut_assert_console_end();
/* One more time */
ut_assertok(console_record_reset_enable());
cmd_process(CMD_FLAG_REPEAT, 4, args, &repeatable, NULL);
ut_assert_nextlinen("0 matches");
ut_assert_console_end();
@ -196,7 +187,7 @@ static int mem_test_ms_cont_end(struct unit_test_state *uts)
return 0;
}
MEM_TEST(mem_test_ms_cont_end, UT_TESTF_CONSOLE_REC);
MEM_TEST(mem_test_ms_cont_end, UTF_CONSOLE);
/* Test 'ms' command with multiple values */
static int mem_test_ms_mult(struct unit_test_state *uts)
@ -225,7 +216,7 @@ static int mem_test_ms_mult(struct unit_test_state *uts)
return 0;
}
MEM_TEST(mem_test_ms_mult, UT_TESTF_CONSOLE_REC);
MEM_TEST(mem_test_ms_mult, UTF_CONSOLE);
/* Test 'ms' command with string */
static int mem_test_ms_s(struct unit_test_state *uts)
@ -239,7 +230,6 @@ static int mem_test_ms_s(struct unit_test_state *uts)
strcpy(buf + 0x1e, str);
strcpy(buf + 0x63, str);
strcpy(buf + 0xa1, str2);
ut_assertok(console_record_reset_enable());
run_command("ms.s 0 100 hello", 0);
ut_assert_nextline("00000010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 68 65 ..............he");
ut_assert_nextline("00000020: 6c 6c 6f 00 00 00 00 00 00 00 00 00 00 00 00 00 llo.............");
@ -254,7 +244,6 @@ static int mem_test_ms_s(struct unit_test_state *uts)
ut_asserteq(0xa1, env_get_hex("memaddr", 0));
ut_asserteq(0xa1, env_get_hex("mempos", 0));
ut_assertok(console_record_reset_enable());
run_command("ms.s 0 100 hello there", 0);
ut_assert_nextline("000000a0: 00 68 65 6c 6c 6f 74 68 65 72 65 00 00 00 00 00 .hellothere.....");
ut_assert_nextline("1 match");
@ -268,7 +257,7 @@ static int mem_test_ms_s(struct unit_test_state *uts)
return 0;
}
MEM_TEST(mem_test_ms_s, UT_TESTF_CONSOLE_REC);
MEM_TEST(mem_test_ms_s, UTF_CONSOLE);
/* Test 'ms' command with limit */
static int mem_test_ms_limit(struct unit_test_state *uts)
@ -281,7 +270,6 @@ static int mem_test_ms_limit(struct unit_test_state *uts)
buf[0x31] = 0x12;
buf[0x62] = 0x12;
buf[0x76] = 0x12;
ut_assertok(console_record_reset_enable());
run_command("ms.b -l2 1 ff 12", 0);
ut_assert_nextline("00000030: 00 12 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................");
ut_assert_nextline("--");
@ -297,7 +285,7 @@ static int mem_test_ms_limit(struct unit_test_state *uts)
return 0;
}
MEM_TEST(mem_test_ms_limit, UT_TESTF_CONSOLE_REC);
MEM_TEST(mem_test_ms_limit, UTF_CONSOLE);
/* Test 'ms' command in quiet mode */
static int mem_test_ms_quiet(struct unit_test_state *uts)
@ -310,7 +298,6 @@ static int mem_test_ms_quiet(struct unit_test_state *uts)
buf[0x31] = 0x12;
buf[0x62] = 0x12;
buf[0x76] = 0x12;
ut_assertok(console_record_reset_enable());
run_command("ms.b -q -l2 1 ff 12", 0);
ut_assert_console_end();
unmap_sysmem(buf);
@ -321,4 +308,4 @@ static int mem_test_ms_quiet(struct unit_test_state *uts)
return 0;
}
MEM_TEST(mem_test_ms_quiet, UT_TESTF_CONSOLE_REC);
MEM_TEST(mem_test_ms_quiet, UTF_CONSOLE);

3
test/cmd/pci_mps.c
View file

@ -27,8 +27,7 @@ static int test_pci_mps_safe(struct unit_test_state *uts)
return 0;
}
PCI_MPS_TEST(test_pci_mps_safe, UT_TESTF_CONSOLE_REC);
PCI_MPS_TEST(test_pci_mps_safe, UTF_CONSOLE);
int do_ut_pci_mps(struct cmd_tbl *cmdtp, int flag, int argc,
char * const argv[])

7
test/cmd/pinmux.c
View file

@ -18,17 +18,14 @@ static int dm_test_cmd_pinmux_status_pinname(struct unit_test_state *uts)
ut_assertok(uclass_get_device(UCLASS_LED, 2, &dev));
/* Test that 'pinmux status <pinname>' displays the selected pin. */
console_record_reset();
run_command("pinmux status a5", 0);
ut_assert_nextlinen("a5 : gpio output .");
ut_assert_console_end();
console_record_reset();
run_command("pinmux status P7", 0);
ut_assert_nextlinen("P7 : GPIO2 bias-pull-down input-enable.");
ut_assert_console_end();
console_record_reset();
run_command("pinmux status P9", 0);
if (IS_ENABLED(CONFIG_LOGF_FUNC)) {
ut_assert_nextlinen(
@ -42,5 +39,5 @@ static int dm_test_cmd_pinmux_status_pinname(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_cmd_pinmux_status_pinname, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_cmd_pinmux_status_pinname, UTF_SCAN_PDATA | UTF_SCAN_FDT |
UTF_CONSOLE);

7
test/cmd/pwm.c
View file

@ -22,8 +22,6 @@ static int dm_test_pwm_cmd(struct unit_test_state *uts)
ut_assertok(uclass_get_device(UCLASS_PWM, 0, &dev));
ut_assertnonnull(dev);
ut_assertok(console_record_reset_enable());
/* pwm <invert> <pwm_dev_num> <channel> <polarity> */
/* cros-ec-pwm doesn't support invert */
ut_asserteq(1, run_command("pwm invert 0 0 1", 0));
@ -49,8 +47,6 @@ static int dm_test_pwm_cmd(struct unit_test_state *uts)
ut_assertok(uclass_get_device(UCLASS_PWM, 1, &dev));
ut_assertnonnull(dev);
ut_assertok(console_record_reset_enable());
/* pwm <invert> <pwm_dev_num> <channel> <polarity> */
ut_assertok(run_command("pwm invert 1 0 1", 0));
ut_assert_console_end();
@ -71,5 +67,4 @@ static int dm_test_pwm_cmd(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_pwm_cmd, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_CONSOLE_REC);
DM_TEST(dm_test_pwm_cmd, UTF_SCAN_PDATA | UTF_SCAN_FDT | UTF_CONSOLE);

5
test/cmd/rw.c
View file

@ -87,17 +87,14 @@ static int dm_test_read_write(struct unit_test_state *uts)
ut_assertok(memcmp(wbuf, rbuf, sizeof(wbuf)));
/* Read/write outside partition bounds should be rejected upfront. */
console_record_reset_enable();
ut_asserteq(1, run_commandf("read mmc 2#data 0x%lx 3 2", ra));
ut_assert_nextlinen("read out of range");
ut_assert_console_end();
console_record_reset_enable();
ut_asserteq(1, run_commandf("write mmc 2#log 0x%lx 9 2", wa));
ut_assert_nextlinen("write out of range");
ut_assert_console_end();
return 0;
}
DM_TEST(dm_test_read_write, UT_TESTF_SCAN_FDT | UT_TESTF_CONSOLE_REC);
DM_TEST(dm_test_read_write, UTF_SCAN_FDT | UTF_CONSOLE);

9
test/cmd/seama.c
View file

@ -16,7 +16,6 @@
static int seama_test_noargs(struct unit_test_state *uts)
{
/* Test that 'seama' with no arguments fails gracefully */
console_record_reset();
run_command("seama", 0);
ut_assert_nextlinen("seama - Load the SEAMA image and sets envs");
ut_assert_skipline();
@ -26,12 +25,11 @@ static int seama_test_noargs(struct unit_test_state *uts)
ut_assert_console_end();
return 0;
}
SEAMA_TEST(seama_test_noargs, UT_TESTF_CONSOLE_REC);
SEAMA_TEST(seama_test_noargs, UTF_CONSOLE);
static int seama_test_addr(struct unit_test_state *uts)
{
/* Test that loads SEAMA image 0 to address 0x01000000 */
console_record_reset();
run_command("seama 0x01000000", 0);
ut_assert_nextlinen("Loading SEAMA image 0 from nand0");
ut_assert_nextlinen("SEMA IMAGE:");
@ -42,12 +40,11 @@ static int seama_test_addr(struct unit_test_state *uts)
ut_assert_console_end();
return 0;
}
SEAMA_TEST(seama_test_addr, UT_TESTF_CONSOLE_REC);
SEAMA_TEST(seama_test_addr, UTF_CONSOLE);
static int seama_test_index(struct unit_test_state *uts)
{
/* Test that loads SEAMA image 0 exlicitly specified */
console_record_reset();
run_command("seama 0x01000000 0", 0);
ut_assert_nextlinen("Loading SEAMA image 0 from nand0");
ut_assert_nextlinen("SEMA IMAGE:");
@ -58,7 +55,7 @@ static int seama_test_index(struct unit_test_state *uts)
ut_assert_console_end();
return 0;
}
SEAMA_TEST(seama_test_index, UT_TESTF_CONSOLE_REC);
SEAMA_TEST(seama_test_index, UTF_CONSOLE);
int do_ut_seama(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{

24
test/cmd/setexpr.c
View file

@ -63,7 +63,7 @@ static int setexpr_test_int(struct unit_test_state *uts)
return 0;
}
SETEXPR_TEST(setexpr_test_int, UT_TESTF_CONSOLE_REC);
SETEXPR_TEST(setexpr_test_int, UTF_CONSOLE);
/* Test 'setexpr' command with + operator */
static int setexpr_test_plus(struct unit_test_state *uts)
@ -105,7 +105,7 @@ static int setexpr_test_plus(struct unit_test_state *uts)
return 0;
}
SETEXPR_TEST(setexpr_test_plus, UT_TESTF_CONSOLE_REC);
SETEXPR_TEST(setexpr_test_plus, UTF_CONSOLE);
/* Test 'setexpr' command with other operators */
static int setexpr_test_oper(struct unit_test_state *uts)
@ -148,7 +148,7 @@ static int setexpr_test_oper(struct unit_test_state *uts)
return 0;
}
SETEXPR_TEST(setexpr_test_oper, UT_TESTF_CONSOLE_REC);
SETEXPR_TEST(setexpr_test_oper, UTF_CONSOLE);
/* Test 'setexpr' command with regex */
static int setexpr_test_regex(struct unit_test_state *uts)
@ -192,7 +192,7 @@ static int setexpr_test_regex(struct unit_test_state *uts)
return 0;
}
SETEXPR_TEST(setexpr_test_regex, UT_TESTF_CONSOLE_REC);
SETEXPR_TEST(setexpr_test_regex, UTF_CONSOLE);
/* Test 'setexpr' command with regex replacement that expands the string */
static int setexpr_test_regex_inc(struct unit_test_state *uts)
@ -209,7 +209,7 @@ static int setexpr_test_regex_inc(struct unit_test_state *uts)
return 0;
}
SETEXPR_TEST(setexpr_test_regex_inc, UT_TESTF_CONSOLE_REC);
SETEXPR_TEST(setexpr_test_regex_inc, UTF_CONSOLE);
/* Test setexpr_regex_sub() directly to check buffer usage */
static int setexpr_test_sub(struct unit_test_state *uts)
@ -249,7 +249,7 @@ static int setexpr_test_sub(struct unit_test_state *uts)
return 0;
}
SETEXPR_TEST(setexpr_test_sub, UT_TESTF_CONSOLE_REC);
SETEXPR_TEST(setexpr_test_sub, UTF_CONSOLE);
/* Test setexpr_regex_sub() with back references */
static int setexpr_test_backref(struct unit_test_state *uts)
@ -292,7 +292,7 @@ static int setexpr_test_backref(struct unit_test_state *uts)
return 0;
}
SETEXPR_TEST(setexpr_test_backref, UT_TESTF_CONSOLE_REC);
SETEXPR_TEST(setexpr_test_backref, UTF_CONSOLE);
/* Test 'setexpr' command with setting strings */
static int setexpr_test_str(struct unit_test_state *uts)
@ -327,7 +327,7 @@ static int setexpr_test_str(struct unit_test_state *uts)
return 0;
}
SETEXPR_TEST(setexpr_test_str, UT_TESTF_CONSOLE_REC);
SETEXPR_TEST(setexpr_test_str, UTF_CONSOLE);
/* Test 'setexpr' command with concatenating strings */
static int setexpr_test_str_oper(struct unit_test_state *uts)
@ -340,7 +340,6 @@ static int setexpr_test_str_oper(struct unit_test_state *uts)
strcpy(buf, "hello");
strcpy(buf + 0x10, " there");
ut_assertok(console_record_reset_enable());
start_mem = ut_check_free();
ut_asserteq(1, run_command("setexpr.s fred *0 * *10", 0));
ut_assertok(ut_check_delta(start_mem));
@ -376,7 +375,7 @@ static int setexpr_test_str_oper(struct unit_test_state *uts)
return 0;
}
SETEXPR_TEST(setexpr_test_str_oper, UT_TESTF_CONSOLE_REC);
SETEXPR_TEST(setexpr_test_str_oper, UTF_CONSOLE);
/* Test 'setexpr' command with a string that is too long */
static int setexpr_test_str_long(struct unit_test_state *uts)
@ -396,7 +395,7 @@ static int setexpr_test_str_long(struct unit_test_state *uts)
return 0;
}
SETEXPR_TEST(setexpr_test_str_long, UT_TESTF_CONSOLE_REC);
SETEXPR_TEST(setexpr_test_str_long, UTF_CONSOLE);
#ifdef CONFIG_CMD_SETEXPR_FMT
/* Test 'setexpr' command with simply setting integers */
@ -478,8 +477,7 @@ static int setexpr_test_fmt(struct unit_test_state *uts)
return 0;
}
SETEXPR_TEST(setexpr_test_fmt, UT_TESTF_CONSOLE_REC);
SETEXPR_TEST(setexpr_test_fmt, UTF_CONSOLE);
#endif
int do_ut_setexpr(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])

5
test/cmd/temperature.c
View file

@ -18,8 +18,6 @@ static int dm_test_cmd_temperature(struct unit_test_state *uts)
ut_assertok(uclass_get_device(UCLASS_THERMAL, 0, &dev));
ut_assertnonnull(dev);
ut_assertok(console_record_reset_enable());
/* Test that "temperature list" shows the sandbox device */
ut_assertok(run_command("temperature list", 0));
ut_assert_nextline("| Device | Driver | Parent");
@ -34,5 +32,4 @@ static int dm_test_cmd_temperature(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_cmd_temperature, UT_TESTF_SCAN_FDT | UT_TESTF_CONSOLE_REC);
DM_TEST(dm_test_cmd_temperature, UTF_SCAN_FDT | UTF_CONSOLE);

8
test/cmd/test_echo.c
View file

@ -45,16 +45,12 @@ static int lib_test_hush_echo(struct unit_test_state *uts)
int i;
for (i = 0; i < ARRAY_SIZE(echo_data); ++i) {
ut_silence_console(uts);
console_record_reset_enable();
ut_assertok(run_command(echo_data[i].cmd, 0));
ut_unsilence_console(uts);
console_record_readline(uts->actual_str,
sizeof(uts->actual_str));
ut_asserteq_str(echo_data[i].expected, uts->actual_str);
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
}
return 0;
}
LIB_TEST(lib_test_hush_echo, 0);
LIB_TEST(lib_test_hush_echo, UTF_CONSOLE);

9
test/cmd/test_pause.c
View file

@ -14,25 +14,22 @@ DECLARE_GLOBAL_DATA_PTR;
static int lib_test_hush_pause(struct unit_test_state *uts)
{
/* Test default message */
console_record_reset_enable();
/* Cook a newline when the command is expected to pause */
console_in_puts("\n");
ut_assertok(run_command("pause", 0));
console_record_readline(uts->actual_str, sizeof(uts->actual_str));
ut_asserteq_str("Press any key to continue...", uts->actual_str);
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
/* Test provided message */
console_record_reset_enable();
/* Cook a newline when the command is expected to pause */
console_in_puts("\n");
ut_assertok(run_command("pause 'Prompt for pause...'", 0));
console_record_readline(uts->actual_str, sizeof(uts->actual_str));
ut_asserteq_str("Prompt for pause...", uts->actual_str);
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
/* Test providing more than one params */
console_record_reset_enable();
/* No newline cooked here since the command is expected to fail */
ut_asserteq(1, run_command("pause a b", 0));
console_record_readline(uts->actual_str, sizeof(uts->actual_str));
@ -41,4 +38,4 @@ static int lib_test_hush_pause(struct unit_test_state *uts)
return 0;
}
LIB_TEST(lib_test_hush_pause, 0);
LIB_TEST(lib_test_hush_pause, UTF_CONSOLE);

9
test/cmd/wget.c
View file

@ -213,15 +213,16 @@ static int net_test_wget(struct unit_test_state *uts)
env_set("ethrotate", "no");
env_set("loadaddr", "0x20000");
ut_assertok(run_command("wget ${loadaddr} 1.1.2.2:/index.html", 0));
ut_assert_nextline("HTTP/1.1 200 OK");
ut_assert_nextline("Packets received 5, Transfer Successful");
ut_assert_nextline("Bytes transferred = 32 (20 hex)");
sandbox_eth_set_tx_handler(0, NULL);
ut_assertok(console_record_reset_enable());
run_command("md5sum ${loadaddr} ${filesize}", 0);
ut_assert_nextline("md5 for 00020000 ... 0002001f ==> 234af48e94b0085060249ecb5942ab57");
ut_assertok(ut_check_console_end(uts));
ut_assert_console_end();
return 0;
}
LIB_TEST(net_test_wget, 0);
LIB_TEST(net_test_wget, UTF_CONSOLE);

4
test/common/cread.c
View file

@ -66,8 +66,6 @@ static int cread_test(struct unit_test_state *uts)
* print_buffer(0, buf, 1, 7, 0);
*/
console_record_reset_enable();
/* simple input */
*buf = '\0';
ut_asserteq(4, console_in_puts("abc\n"));
@ -102,4 +100,4 @@ static int cread_test(struct unit_test_state *uts)
return 0;
}
COMMON_TEST(cread_test, 0);
COMMON_TEST(cread_test, UTF_CONSOLE);

2
test/common/event.c
View file

@ -106,4 +106,4 @@ static int test_event_probe(struct unit_test_state *uts)
return 0;
}
COMMON_TEST(test_event_probe, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
COMMON_TEST(test_event_probe, UTF_DM | UTF_SCAN_FDT);

4
test/common/test_autoboot.c
View file

@ -20,7 +20,6 @@ static int check_for_input(struct unit_test_state *uts, const char *in,
const char *autoboot_prompt =
"Enter password \"a\" in 1 seconds to stop autoboot";
console_record_reset_enable();
console_in_puts(in);
/* turn on keyed autoboot for the test, if possible */
@ -91,5 +90,4 @@ static int test_autoboot(struct unit_test_state *uts)
return CMD_RET_SUCCESS;
}
COMMON_TEST(test_autoboot, 0);
COMMON_TEST(test_autoboot, UTF_CONSOLE);

39
test/dm/acpi.c
View file

@ -195,7 +195,7 @@ static int dm_test_acpi_get_name(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_get_name, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_get_name, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test acpi_get_table_revision() */
static int dm_test_acpi_get_table_revision(struct unit_test_state *uts)
@ -207,8 +207,7 @@ static int dm_test_acpi_get_table_revision(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_get_table_revision,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_get_table_revision, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test acpi_create_dmar() */
static int dm_test_acpi_create_dmar(struct unit_test_state *uts)
@ -225,7 +224,7 @@ static int dm_test_acpi_create_dmar(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_create_dmar, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_create_dmar, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test acpi_fill_header() */
static int dm_test_acpi_fill_header(struct unit_test_state *uts)
@ -251,7 +250,7 @@ static int dm_test_acpi_fill_header(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_fill_header, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_fill_header, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test ACPI write_tables() */
static int dm_test_acpi_write_tables(struct unit_test_state *uts)
@ -297,7 +296,7 @@ static int dm_test_acpi_write_tables(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_write_tables, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_write_tables, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test basic ACPI functions */
static int dm_test_acpi_basic(struct unit_test_state *uts)
@ -325,7 +324,7 @@ static int dm_test_acpi_basic(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_basic, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_basic, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test setup_ctx_and_base_tables */
static int dm_test_acpi_ctx_and_base_tables(struct unit_test_state *uts)
@ -374,8 +373,7 @@ static int dm_test_acpi_ctx_and_base_tables(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_ctx_and_base_tables,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_ctx_and_base_tables, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test 'acpi list' command */
static int dm_test_acpi_cmd_list(struct unit_test_state *uts)
@ -391,7 +389,6 @@ static int dm_test_acpi_cmd_list(struct unit_test_state *uts)
ut_assertok(acpi_write_dev_tables(&ctx));
console_record_reset();
run_command("acpi list", 0);
ut_assert_nextline("Name Base Size Detail");
ut_assert_nextline("---- ---------------- ----- ----------------------------");
@ -418,7 +415,7 @@ static int dm_test_acpi_cmd_list(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_cmd_list, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_cmd_list, UTF_SCAN_PDATA | UTF_SCAN_FDT | UTF_CONSOLE);
/* Test 'acpi dump' command */
static int dm_test_acpi_cmd_dump(struct unit_test_state *uts)
@ -435,13 +432,11 @@ static int dm_test_acpi_cmd_dump(struct unit_test_state *uts)
ut_assertok(acpi_write_dev_tables(&ctx));
/* First search for a non-existent table */
console_record_reset();
run_command("acpi dump rdst", 0);
ut_assert_nextline("Table 'RDST' not found");
ut_assert_console_end();
/* Now a real table */
console_record_reset();
run_command("acpi dump dmar", 0);
addr = ALIGN(nomap_to_sysmem(ctx.xsdt) + sizeof(struct acpi_xsdt), 64);
ut_assert_nextline("DMAR @ %16lx", addr);
@ -450,7 +445,7 @@ static int dm_test_acpi_cmd_dump(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_cmd_dump, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_cmd_dump, UTF_SCAN_PDATA | UTF_SCAN_FDT | UTF_CONSOLE);
/* Test acpi_device_path() */
static int dm_test_acpi_device_path(struct unit_test_state *uts)
@ -487,7 +482,7 @@ static int dm_test_acpi_device_path(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_device_path, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_device_path, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test acpi_device_status() */
static int dm_test_acpi_device_status(struct unit_test_state *uts)
@ -499,7 +494,7 @@ static int dm_test_acpi_device_status(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_device_status, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_device_status, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test acpi_fill_ssdt() */
static int dm_test_acpi_fill_ssdt(struct unit_test_state *uts)
@ -530,7 +525,7 @@ static int dm_test_acpi_fill_ssdt(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_fill_ssdt, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_fill_ssdt, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test acpi_inject_dsdt() */
static int dm_test_acpi_inject_dsdt(struct unit_test_state *uts)
@ -561,7 +556,7 @@ static int dm_test_acpi_inject_dsdt(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_inject_dsdt, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_inject_dsdt, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test 'acpi items' command */
static int dm_test_acpi_cmd_items(struct unit_test_state *uts)
@ -577,7 +572,6 @@ static int dm_test_acpi_cmd_items(struct unit_test_state *uts)
acpi_reset_items();
ctx.current = buf;
ut_assertok(acpi_fill_ssdt(&ctx));
console_record_reset();
run_command("acpi items", 0);
ut_assert_nextline("Seq Type Base Size Device/Writer");
ut_assert_nextline("--- ----- -------- ---- -------------");
@ -588,7 +582,6 @@ static int dm_test_acpi_cmd_items(struct unit_test_state *uts)
acpi_reset_items();
ctx.current = buf;
ut_assertok(acpi_inject_dsdt(&ctx));
console_record_reset();
run_command("acpi items", 0);
ut_assert_nextlinen("Seq");
ut_assert_nextlinen("---");
@ -596,7 +589,6 @@ static int dm_test_acpi_cmd_items(struct unit_test_state *uts)
ut_assert_nextline(" 1 dsdt %8lx 2 acpi-test2", addr + 2);
ut_assert_console_end();
console_record_reset();
run_command("acpi items -d", 0);
ut_assert_nextlinen("Seq");
ut_assert_nextlinen("---");
@ -610,7 +602,7 @@ static int dm_test_acpi_cmd_items(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_cmd_items, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_cmd_items, UTF_SCAN_PDATA | UTF_SCAN_FDT | UTF_CONSOLE);
/* Test 'acpi set' command */
static int dm_test_acpi_cmd_set(struct unit_test_state *uts)
@ -621,7 +613,6 @@ static int dm_test_acpi_cmd_set(struct unit_test_state *uts)
gd_set_acpi_start(0);
console_record_reset();
ut_asserteq(0, gd_acpi_start());
ut_assertok(run_command("acpi set", 0));
ut_assert_nextline("ACPI pointer: 0");
@ -648,7 +639,7 @@ static int dm_test_acpi_cmd_set(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_cmd_set, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_cmd_set, UTF_SCAN_PDATA | UTF_SCAN_FDT | UTF_CONSOLE);
/**
* dm_test_write_test_table() - create test ACPI table

2
test/dm/acpi_dp.c
View file

@ -488,4 +488,4 @@ static int dm_test_acpi_dp_copy(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_dp_copy, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_dp_copy, UTF_SCAN_PDATA | UTF_SCAN_FDT);

19
test/dm/acpigen.c
View file

@ -167,7 +167,7 @@ static int dm_test_acpi_interrupt(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_interrupt, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_interrupt, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test emitting a GPIO descriptor */
static int dm_test_acpi_gpio(struct unit_test_state *uts)
@ -212,7 +212,7 @@ static int dm_test_acpi_gpio(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_gpio, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_gpio, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test emitting a GPIO descriptor with an interrupt */
static int dm_test_acpi_gpio_irq(struct unit_test_state *uts)
@ -257,7 +257,7 @@ static int dm_test_acpi_gpio_irq(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_gpio_irq, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_gpio_irq, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test emitting either a GPIO or interrupt descriptor */
static int dm_test_acpi_interrupt_or_gpio(struct unit_test_state *uts)
@ -296,8 +296,7 @@ static int dm_test_acpi_interrupt_or_gpio(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_interrupt_or_gpio,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_interrupt_or_gpio, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test emitting an I2C descriptor */
static int dm_test_acpi_i2c(struct unit_test_state *uts)
@ -329,7 +328,7 @@ static int dm_test_acpi_i2c(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_i2c, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_i2c, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test emitting a SPI descriptor */
static int dm_test_acpi_spi(struct unit_test_state *uts)
@ -365,7 +364,7 @@ static int dm_test_acpi_spi(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_spi, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_spi, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test emitting a length */
static int dm_test_acpi_len(struct unit_test_state *uts)
@ -806,7 +805,7 @@ static int dm_test_acpi_gpio_toggle(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_gpio_toggle, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_gpio_toggle, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test writing ACPI code to output power-sequence info */
static int dm_test_acpi_power_seq(struct unit_test_state *uts)
@ -873,7 +872,7 @@ static int dm_test_acpi_power_seq(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_power_seq, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_power_seq, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test writing values */
static int dm_test_acpi_write_values(struct unit_test_state *uts)
@ -947,7 +946,7 @@ static int dm_test_acpi_scope(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_acpi_scope, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_acpi_scope, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test writing a resource template */
static int dm_test_acpi_resource_template(struct unit_test_state *uts)

16
test/dm/adc.c
View file

@ -32,7 +32,7 @@ static int dm_test_adc_bind(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_adc_bind, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_adc_bind, UTF_SCAN_FDT);
static int dm_test_adc_wrong_channel_selection(struct unit_test_state *uts)
{
@ -43,7 +43,7 @@ static int dm_test_adc_wrong_channel_selection(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_adc_wrong_channel_selection, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_adc_wrong_channel_selection, UTF_SCAN_FDT);
static int dm_test_adc_supply(struct unit_test_state *uts)
{
@ -79,7 +79,7 @@ static int dm_test_adc_supply(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_adc_supply, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_adc_supply, UTF_SCAN_FDT);
struct adc_channel adc_channel_test_data[] = {
{ 0, SANDBOX_ADC_CHANNEL0_DATA },
@ -104,7 +104,7 @@ static int dm_test_adc_single_channel_conversion(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_adc_single_channel_conversion, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_adc_single_channel_conversion, UTF_SCAN_FDT);
static int dm_test_adc_multi_channel_conversion(struct unit_test_state *uts)
{
@ -127,7 +127,7 @@ static int dm_test_adc_multi_channel_conversion(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_adc_multi_channel_conversion, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_adc_multi_channel_conversion, UTF_SCAN_FDT);
static int dm_test_adc_single_channel_shot(struct unit_test_state *uts)
{
@ -143,7 +143,7 @@ static int dm_test_adc_single_channel_shot(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_adc_single_channel_shot, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_adc_single_channel_shot, UTF_SCAN_FDT);
static int dm_test_adc_multi_channel_shot(struct unit_test_state *uts)
{
@ -163,7 +163,7 @@ static int dm_test_adc_multi_channel_shot(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_adc_multi_channel_shot, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_adc_multi_channel_shot, UTF_SCAN_FDT);
static const int dm_test_adc_uV_data[SANDBOX_ADC_CHANNELS] = {
((u64)SANDBOX_ADC_CHANNEL0_DATA * SANDBOX_BUCK2_INITIAL_EXPECTED_UV) /
@ -194,4 +194,4 @@ static int dm_test_adc_raw_to_uV(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_adc_raw_to_uV, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_adc_raw_to_uV, UTF_SCAN_FDT);

2
test/dm/audio.c
View file

@ -31,4 +31,4 @@ static int dm_test_audio(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_audio, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_audio, UTF_SCAN_PDATA | UTF_SCAN_FDT);

9
test/dm/axi.c
View file

@ -21,8 +21,7 @@ static int dm_test_axi_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_axi_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_axi_base, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test that sandbox PCI bus numbering works correctly */
static int dm_test_axi_busnum(struct unit_test_state *uts)
@ -33,8 +32,7 @@ static int dm_test_axi_busnum(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_axi_busnum, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_axi_busnum, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test that we can use the store device correctly */
static int dm_test_axi_store(struct unit_test_state *uts)
@ -74,5 +72,4 @@ static int dm_test_axi_store(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_axi_store, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_axi_store, UTF_SCAN_PDATA | UTF_SCAN_FDT);

16
test/dm/blk.c
View file

@ -43,7 +43,7 @@ static int dm_test_blk_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_blk_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_blk_base, UTF_SCAN_PDATA | UTF_SCAN_FDT);
static int count_blk_devices(void)
{
@ -92,7 +92,7 @@ static int dm_test_blk_usb(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_blk_usb, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_blk_usb, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test that we can find block devices without probing them */
static int dm_test_blk_find(struct unit_test_state *uts)
@ -114,7 +114,7 @@ static int dm_test_blk_find(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_blk_find, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_blk_find, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test that block device numbering works as expected */
static int dm_test_blk_devnum(struct unit_test_state *uts)
@ -149,7 +149,7 @@ static int dm_test_blk_devnum(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_blk_devnum, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_blk_devnum, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test that we can get a block from its parent */
static int dm_test_blk_get_from_parent(struct unit_test_state *uts)
@ -167,7 +167,7 @@ static int dm_test_blk_get_from_parent(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_blk_get_from_parent, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_blk_get_from_parent, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test iteration through block devices */
static int dm_test_blk_iter(struct unit_test_state *uts)
@ -222,7 +222,7 @@ static int dm_test_blk_iter(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_blk_iter, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_blk_iter, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test finding fixed/removable block devices */
static int dm_test_blk_flags(struct unit_test_state *uts)
@ -287,7 +287,7 @@ static int dm_test_blk_flags(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_blk_flags, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_blk_flags, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test blk_foreach() and friend */
static int dm_test_blk_foreach(struct unit_test_state *uts)
@ -333,4 +333,4 @@ static int dm_test_blk_foreach(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_blk_foreach, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_blk_foreach, UTF_SCAN_PDATA | UTF_SCAN_FDT);

4
test/dm/blkmap.c
View file

@ -165,8 +165,6 @@ static int dm_test_cmd_blkmap(struct unit_test_state *uts)
ulong loadaddr = env_get_hex("loadaddr", 0);
struct udevice *dev;
console_record_reset();
ut_assertok(run_command("blkmap info", 0));
ut_assert_console_end();
@ -197,4 +195,4 @@ static int dm_test_cmd_blkmap(struct unit_test_state *uts)
ut_assert_console_end();
return 0;
}
DM_TEST(dm_test_cmd_blkmap, 0);
DM_TEST(dm_test_cmd_blkmap, UTF_CONSOLE);

10
test/dm/bootcount.c
View file

@ -35,8 +35,7 @@ static int dm_test_bootcount_rtc(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bootcount_rtc, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_bootcount_rtc, UTF_SCAN_PDATA | UTF_SCAN_FDT);
static int dm_test_bootcount_syscon_four_bytes(struct unit_test_state *uts)
{
@ -55,9 +54,8 @@ static int dm_test_bootcount_syscon_four_bytes(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bootcount_syscon_four_bytes,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
UTF_SCAN_PDATA | UTF_SCAN_FDT);
static int dm_test_bootcount_syscon_two_bytes(struct unit_test_state *uts)
{
@ -76,6 +74,4 @@ static int dm_test_bootcount_syscon_two_bytes(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bootcount_syscon_two_bytes,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_bootcount_syscon_two_bytes, UTF_SCAN_PDATA | UTF_SCAN_FDT);

26
test/dm/bus.c
View file

@ -41,7 +41,7 @@ static int dm_test_bus_children(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bus_children, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_bus_children, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test our functions for accessing children */
static int dm_test_bus_children_funcs(struct unit_test_state *uts)
@ -81,7 +81,7 @@ static int dm_test_bus_children_funcs(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bus_children_funcs, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_bus_children_funcs, UTF_SCAN_PDATA | UTF_SCAN_FDT);
static int dm_test_bus_children_of_offset(struct unit_test_state *uts)
{
@ -105,7 +105,7 @@ static int dm_test_bus_children_of_offset(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bus_children_of_offset,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
UTF_SCAN_PDATA | UTF_SCAN_FDT | UTF_FLAT_TREE);
/* Test that we can iterate through children */
static int dm_test_bus_children_iterators(struct unit_test_state *uts)
@ -136,7 +136,7 @@ static int dm_test_bus_children_iterators(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bus_children_iterators,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test that the bus can store data about each child */
static int test_bus_parent_data(struct unit_test_state *uts)
@ -203,7 +203,7 @@ static int dm_test_bus_parent_data(struct unit_test_state *uts)
{
return test_bus_parent_data(uts);
}
DM_TEST(dm_test_bus_parent_data, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_bus_parent_data, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* As above but the size is controlled by the uclass */
static int dm_test_bus_parent_data_uclass(struct unit_test_state *uts)
@ -233,7 +233,7 @@ static int dm_test_bus_parent_data_uclass(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bus_parent_data_uclass,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test that the bus ops are called when a child is probed/removed */
static int dm_test_bus_parent_ops(struct unit_test_state *uts)
@ -270,7 +270,7 @@ static int dm_test_bus_parent_ops(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bus_parent_ops, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_bus_parent_ops, UTF_SCAN_PDATA | UTF_SCAN_FDT);
static int test_bus_parent_plat(struct unit_test_state *uts)
{
@ -345,7 +345,7 @@ static int dm_test_bus_parent_plat(struct unit_test_state *uts)
{
return test_bus_parent_plat(uts);
}
DM_TEST(dm_test_bus_parent_plat, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_bus_parent_plat, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* As above but the size is controlled by the uclass */
static int dm_test_bus_parent_plat_uclass(struct unit_test_state *uts)
@ -374,7 +374,7 @@ static int dm_test_bus_parent_plat_uclass(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bus_parent_plat_uclass,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test that the child post_bind method is called */
static int dm_test_bus_child_post_bind(struct unit_test_state *uts)
@ -395,7 +395,7 @@ static int dm_test_bus_child_post_bind(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bus_child_post_bind, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_bus_child_post_bind, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test that the child post_bind method is called */
static int dm_test_bus_child_post_bind_uclass(struct unit_test_state *uts)
@ -417,7 +417,7 @@ static int dm_test_bus_child_post_bind_uclass(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bus_child_post_bind_uclass,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
UTF_SCAN_PDATA | UTF_SCAN_FDT);
/*
* Test that the bus' uclass' child_pre_probe() is called before the
@ -451,7 +451,7 @@ static int dm_test_bus_child_pre_probe_uclass(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bus_child_pre_probe_uclass,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
UTF_SCAN_PDATA | UTF_SCAN_FDT);
/*
* Test that the bus' uclass' child_post_probe() is called after the
@ -484,4 +484,4 @@ static int dm_test_bus_child_post_probe_uclass(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bus_child_post_probe_uclass,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
UTF_SCAN_PDATA | UTF_SCAN_FDT);

12
test/dm/button.c
View file

@ -37,7 +37,7 @@ static int dm_test_button_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_button_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_button_base, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test of the button uclass using the button_gpio driver */
static int dm_test_button_gpio(struct unit_test_state *uts)
@ -62,7 +62,7 @@ static int dm_test_button_gpio(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_button_gpio, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_button_gpio, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test obtaining a BUTTON by label */
static int dm_test_button_label(struct unit_test_state *uts)
@ -83,7 +83,7 @@ static int dm_test_button_label(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_button_label, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_button_label, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test button has linux,code */
static int dm_test_button_linux_code(struct unit_test_state *uts)
@ -95,7 +95,7 @@ static int dm_test_button_linux_code(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_button_linux_code, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_button_linux_code, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test adc-keys driver */
static int dm_test_button_keys_adc(struct unit_test_state *uts)
@ -129,7 +129,7 @@ static int dm_test_button_keys_adc(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_button_keys_adc, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_button_keys_adc, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test of the button uclass using the button_gpio driver */
static int dm_test_button_cmd(struct unit_test_state *uts)
@ -225,4 +225,4 @@ static int dm_test_button_cmd(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_button_cmd, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_button_cmd, UTF_SCAN_PDATA | UTF_SCAN_FDT);

2
test/dm/cache.c
View file

@ -18,4 +18,4 @@ static int dm_test_reset(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_reset, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_reset, UTF_SCAN_FDT);

7
test/dm/clk.c
View file

@ -46,8 +46,7 @@ static int dm_test_clk_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_clk_base, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_clk_base, UTF_SCAN_FDT);
static int dm_test_clk(struct unit_test_state *uts)
{
@ -187,7 +186,7 @@ static int dm_test_clk(struct unit_test_state *uts)
ut_assertok(device_remove(dev_test, DM_REMOVE_NORMAL));
return 0;
}
DM_TEST(dm_test_clk, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_clk, UTF_SCAN_FDT);
static int dm_test_clk_bulk(struct unit_test_state *uts)
{
@ -225,4 +224,4 @@ static int dm_test_clk_bulk(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_clk_bulk, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_clk_bulk, UTF_SCAN_FDT);

3
test/dm/clk_ccf.c
View file

@ -208,5 +208,4 @@ static int dm_test_clk_ccf(struct unit_test_state *uts)
return 1;
}
DM_TEST(dm_test_clk_ccf, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_clk_ccf, UTF_SCAN_FDT);

47
test/dm/core.c
View file

@ -175,7 +175,7 @@ static int dm_test_autobind_uclass_pdata_alloc(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_autobind_uclass_pdata_alloc, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_autobind_uclass_pdata_alloc, UTF_SCAN_PDATA);
/* compare node names ignoring the unit address */
static int dm_test_compare_node_name(struct unit_test_state *uts)
@ -188,8 +188,7 @@ static int dm_test_compare_node_name(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_compare_node_name, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_compare_node_name, UTF_SCAN_PDATA);
/* Test that binding with uclass plat setting occurs correctly */
static int dm_test_autobind_uclass_pdata_valid(struct unit_test_state *uts)
@ -215,7 +214,7 @@ static int dm_test_autobind_uclass_pdata_valid(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_autobind_uclass_pdata_valid, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_autobind_uclass_pdata_valid, UTF_SCAN_PDATA);
/* Test that autoprobe finds all the expected devices */
static int dm_test_autoprobe(struct unit_test_state *uts)
@ -282,7 +281,7 @@ static int dm_test_autoprobe(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_autoprobe, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_autoprobe, UTF_SCAN_PDATA);
/* Check that we see the correct plat in each device */
static int dm_test_plat(struct unit_test_state *uts)
@ -300,7 +299,7 @@ static int dm_test_plat(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_plat, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_plat, UTF_SCAN_PDATA);
/* Test that we can bind, probe, remove, unbind a driver */
static int dm_test_lifecycle(struct unit_test_state *uts)
@ -369,7 +368,7 @@ static int dm_test_lifecycle(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_lifecycle, UT_TESTF_SCAN_PDATA | UT_TESTF_PROBE_TEST);
DM_TEST(dm_test_lifecycle, UTF_SCAN_PDATA | UTF_PROBE_TEST);
/* Test that we can bind/unbind and the lists update correctly */
static int dm_test_ordering(struct unit_test_state *uts)
@ -424,7 +423,7 @@ static int dm_test_ordering(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ordering, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_ordering, UTF_SCAN_PDATA);
/* Check that we can perform operations on a device (do a ping) */
int dm_check_operations(struct unit_test_state *uts, struct udevice *dev,
@ -482,7 +481,7 @@ static int dm_test_operations(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_operations, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_operations, UTF_SCAN_PDATA);
/* Remove all drivers and check that things work */
static int dm_test_remove(struct unit_test_state *uts)
@ -504,7 +503,7 @@ static int dm_test_remove(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_remove, UT_TESTF_SCAN_PDATA | UT_TESTF_PROBE_TEST);
DM_TEST(dm_test_remove, UTF_SCAN_PDATA | UTF_PROBE_TEST);
/* Remove and recreate everything, check for memory leaks */
static int dm_test_leak(struct unit_test_state *uts)
@ -1033,7 +1032,7 @@ static int dm_test_uclass_devices_find(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_uclass_devices_find, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_uclass_devices_find, UTF_SCAN_PDATA);
static int dm_test_uclass_devices_find_by_name(struct unit_test_state *uts)
{
@ -1070,7 +1069,7 @@ static int dm_test_uclass_devices_find_by_name(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_uclass_devices_find_by_name, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_uclass_devices_find_by_name, UTF_SCAN_FDT);
static int dm_test_uclass_devices_get(struct unit_test_state *uts)
{
@ -1086,7 +1085,7 @@ static int dm_test_uclass_devices_get(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_uclass_devices_get, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_uclass_devices_get, UTF_SCAN_PDATA);
static int dm_test_uclass_devices_get_by_name(struct unit_test_state *uts)
{
@ -1129,7 +1128,7 @@ static int dm_test_uclass_devices_get_by_name(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_uclass_devices_get_by_name, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_uclass_devices_get_by_name, UTF_SCAN_FDT);
static int dm_test_device_get_uclass_id(struct unit_test_state *uts)
{
@ -1140,7 +1139,7 @@ static int dm_test_device_get_uclass_id(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_device_get_uclass_id, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_device_get_uclass_id, UTF_SCAN_PDATA);
static int dm_test_uclass_names(struct unit_test_state *uts)
{
@ -1151,7 +1150,7 @@ static int dm_test_uclass_names(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_uclass_names, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_uclass_names, UTF_SCAN_PDATA);
static int dm_test_inactive_child(struct unit_test_state *uts)
{
@ -1181,7 +1180,7 @@ static int dm_test_inactive_child(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_inactive_child, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_inactive_child, UTF_SCAN_PDATA);
/* Make sure all bound devices have a sequence number */
static int dm_test_all_have_seq(struct unit_test_state *uts)
@ -1200,7 +1199,7 @@ static int dm_test_all_have_seq(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_all_have_seq, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_all_have_seq, UTF_SCAN_PDATA);
#if CONFIG_IS_ENABLED(DM_DMA)
static int dm_test_dma_offset(struct unit_test_state *uts)
@ -1231,7 +1230,7 @@ static int dm_test_dma_offset(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_dma_offset, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_dma_offset, UTF_SCAN_PDATA | UTF_SCAN_FDT);
#endif
/* Test dm_get_stats() */
@ -1245,7 +1244,7 @@ static int dm_test_get_stats(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_get_stats, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_get_stats, UTF_SCAN_FDT);
/* Test uclass_find_device_by_name() */
static int dm_test_uclass_find_device(struct unit_test_state *uts)
@ -1260,7 +1259,7 @@ static int dm_test_uclass_find_device(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_uclass_find_device, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_uclass_find_device, UTF_SCAN_FDT);
/* Test getting information about tags attached to devices */
static int dm_test_dev_get_attach(struct unit_test_state *uts)
@ -1288,7 +1287,7 @@ static int dm_test_dev_get_attach(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_dev_get_attach, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_dev_get_attach, UTF_SCAN_FDT);
/* Test getting information about tags attached to bus devices */
static int dm_test_dev_get_attach_bus(struct unit_test_state *uts)
@ -1340,7 +1339,7 @@ static int dm_test_dev_get_attach_bus(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_dev_get_attach_bus, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_dev_get_attach_bus, UTF_SCAN_FDT);
/* Test getting information about tags attached to bus devices */
static int dm_test_dev_get_mem(struct unit_test_state *uts)
@ -1351,4 +1350,4 @@ static int dm_test_dev_get_mem(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_dev_get_mem, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_dev_get_mem, UTF_SCAN_FDT);

3
test/dm/cpu.c
View file

@ -47,5 +47,4 @@ static int dm_test_cpu(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_cpu, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_cpu, UTF_SCAN_FDT);

18
test/dm/cros_ec.c
View file

@ -28,7 +28,7 @@ static int dm_test_cros_ec_hello(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_cros_ec_hello, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_cros_ec_hello, UTF_SCAN_FDT);
static int dm_test_cros_ec_sku_id(struct unit_test_state *uts)
{
@ -38,14 +38,13 @@ static int dm_test_cros_ec_sku_id(struct unit_test_state *uts)
ut_asserteq(1234, cros_ec_get_sku_id(dev));
/* try the command */
console_record_reset();
ut_assertok(run_command("crosec sku", 0));
ut_assert_nextline("1234");
ut_assert_console_end();
return 0;
}
DM_TEST(dm_test_cros_ec_sku_id, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_cros_ec_sku_id, UTF_SCAN_FDT | UTF_CONSOLE);
static int dm_test_cros_ec_features(struct unit_test_state *uts)
{
@ -64,7 +63,6 @@ static int dm_test_cros_ec_features(struct unit_test_state *uts)
ut_asserteq(true, cros_ec_check_feature(dev, EC_FEATURE_ISH));
/* try the command */
console_record_reset();
ut_assertok(run_command("crosec features", 0));
ut_assert_nextline("flash");
ut_assert_nextline("i2c");
@ -75,7 +73,7 @@ static int dm_test_cros_ec_features(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_cros_ec_features, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_cros_ec_features, UTF_SCAN_FDT | UTF_CONSOLE);
static int dm_test_cros_ec_switches(struct unit_test_state *uts)
{
@ -85,7 +83,6 @@ static int dm_test_cros_ec_switches(struct unit_test_state *uts)
ut_asserteq(0, cros_ec_get_switches(dev));
/* try the command */
console_record_reset();
ut_assertok(run_command("crosec switches", 0));
ut_assert_console_end();
@ -94,14 +91,13 @@ static int dm_test_cros_ec_switches(struct unit_test_state *uts)
ut_asserteq(EC_SWITCH_LID_OPEN, cros_ec_get_switches(dev));
/* try the command */
console_record_reset();
ut_assertok(run_command("crosec switches", 0));
ut_assert_nextline("lid open");
ut_assert_console_end();
return 0;
}
DM_TEST(dm_test_cros_ec_switches, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_cros_ec_switches, UTF_SCAN_FDT | UTF_CONSOLE);
static int dm_test_cros_ec_events(struct unit_test_state *uts)
{
@ -113,7 +109,6 @@ static int dm_test_cros_ec_events(struct unit_test_state *uts)
ut_asserteq(0, events);
/* try the command */
console_record_reset();
ut_assertok(run_command("crosec events", 0));
ut_assert_nextline("00000000");
ut_assert_console_end();
@ -124,7 +119,6 @@ static int dm_test_cros_ec_events(struct unit_test_state *uts)
ut_asserteq(EC_HOST_EVENT_MASK(EC_HOST_EVENT_LID_OPEN), events);
/* try the command */
console_record_reset();
ut_assertok(run_command("crosec events", 0));
ut_assert_nextline("00000002");
ut_assert_nextline("lid_open");
@ -138,7 +132,7 @@ static int dm_test_cros_ec_events(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_cros_ec_events, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_cros_ec_events, UTF_SCAN_FDT | UTF_CONSOLE);
static int dm_test_cros_ec_vstore(struct unit_test_state *uts)
{
@ -174,4 +168,4 @@ static int dm_test_cros_ec_vstore(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_cros_ec_vstore, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_cros_ec_vstore, UTF_SCAN_FDT);

2
test/dm/cros_ec_pwm.c
View file

@ -56,4 +56,4 @@ static int dm_test_cros_ec_pwm(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_cros_ec_pwm, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_cros_ec_pwm, UTF_SCAN_PDATA | UTF_SCAN_FDT);

12
test/dm/devres.c
View file

@ -39,7 +39,7 @@ static int dm_test_devres_alloc(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_devres_alloc, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_devres_alloc, UTF_SCAN_PDATA);
/* Test devm_kfree() can be used to free memory too */
static int dm_test_devres_free(struct unit_test_state *uts)
@ -67,7 +67,7 @@ static int dm_test_devres_free(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_devres_free, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_devres_free, UTF_SCAN_PDATA);
/* Test that kzalloc() returns memory that is zeroed */
static int dm_test_devres_kzalloc(struct unit_test_state *uts)
@ -86,7 +86,7 @@ static int dm_test_devres_kzalloc(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_devres_kzalloc, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_devres_kzalloc, UTF_SCAN_PDATA);
/* Test that devm_kmalloc_array() allocates an array that can be set */
static int dm_test_devres_kmalloc_array(struct unit_test_state *uts)
@ -109,7 +109,7 @@ static int dm_test_devres_kmalloc_array(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_devres_kmalloc_array, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_devres_kmalloc_array, UTF_SCAN_PDATA);
/* Test that devm_kcalloc() allocates a zeroed array */
static int dm_test_devres_kcalloc(struct unit_test_state *uts)
@ -138,7 +138,7 @@ static int dm_test_devres_kcalloc(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_devres_kcalloc, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_devres_kcalloc, UTF_SCAN_PDATA);
/* Test devres releases resources automatically as expected */
static int dm_test_devres_phase(struct unit_test_state *uts)
@ -181,4 +181,4 @@ static int dm_test_devres_phase(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_devres_phase, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_devres_phase, UTF_SCAN_PDATA | UTF_SCAN_FDT);

6
test/dm/dma.c
View file

@ -34,7 +34,7 @@ static int dm_test_dma_m2m(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_dma_m2m, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_dma_m2m, UTF_SCAN_FDT);
static int dm_test_dma(struct unit_test_state *uts)
{
@ -76,7 +76,7 @@ static int dm_test_dma(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_dma, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_dma, UTF_SCAN_FDT);
static int dm_test_dma_rx(struct unit_test_state *uts)
{
@ -121,4 +121,4 @@ static int dm_test_dma_rx(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_dma_rx, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_dma_rx, UTF_SCAN_FDT);

6
test/dm/dsa.c
View file

@ -56,8 +56,7 @@ static int dm_test_dsa_probe(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_dsa_probe, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_dsa_probe, UTF_SCAN_FDT);
/* This test sends ping requests with the local address through each DSA port
* via the sandbox DSA master Eth.
@ -78,5 +77,4 @@ static int dm_test_dsa(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_dsa, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_dsa, UTF_SCAN_FDT);

3
test/dm/dsi_host.c
View file

@ -54,5 +54,4 @@ static int dm_test_dsi_host(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_dsi_host, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_dsi_host, UTF_SCAN_PDATA | UTF_SCAN_FDT);

2
test/dm/ecdsa.c
View file

@ -35,4 +35,4 @@ static int dm_test_ecdsa_verify(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ecdsa_verify, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ecdsa_verify, UTF_SCAN_PDATA | UTF_SCAN_FDT);

2
test/dm/efi_media.c
View file

@ -20,4 +20,4 @@ static int dm_test_efi_media(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_efi_media, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_efi_media, UTF_SCAN_PDATA | UTF_SCAN_FDT);

24
test/dm/eth.c
View file

@ -166,7 +166,7 @@ static int dm_test_ip6_make_lladdr(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ip6_make_lladdr, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ip6_make_lladdr, UTF_SCAN_FDT);
#endif
static int dm_test_eth(struct unit_test_state *uts)
@ -187,7 +187,7 @@ static int dm_test_eth(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_eth, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_eth, UTF_SCAN_FDT);
static int dm_test_eth_alias(struct unit_test_state *uts)
{
@ -211,7 +211,7 @@ static int dm_test_eth_alias(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_eth_alias, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_eth_alias, UTF_SCAN_FDT);
static int dm_test_eth_prime(struct unit_test_state *uts)
{
@ -231,7 +231,7 @@ static int dm_test_eth_prime(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_eth_prime, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_eth_prime, UTF_SCAN_FDT);
/**
* This test case is trying to test the following scenario:
@ -296,7 +296,7 @@ static int dm_test_eth_act(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_eth_act, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_eth_act, UTF_SCAN_FDT);
/* Ensure that all addresses are loaded properly */
static int dm_test_ethaddr(struct unit_test_state *uts)
@ -329,7 +329,7 @@ static int dm_test_ethaddr(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ethaddr, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ethaddr, UTF_SCAN_FDT);
/* The asserts include a return on fail; cleanup in the caller */
static int _dm_test_eth_rotate1(struct unit_test_state *uts)
@ -401,7 +401,7 @@ static int dm_test_eth_rotate(struct unit_test_state *uts)
return retval;
}
DM_TEST(dm_test_eth_rotate, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_eth_rotate, UTF_SCAN_FDT);
/* The asserts include a return on fail; cleanup in the caller */
static int _dm_test_net_retry(struct unit_test_state *uts)
@ -444,7 +444,7 @@ static int dm_test_net_retry(struct unit_test_state *uts)
return retval;
}
DM_TEST(dm_test_net_retry, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_net_retry, UTF_SCAN_FDT);
static int sb_check_arp_reply(struct udevice *dev, void *packet,
unsigned int len)
@ -528,8 +528,7 @@ static int dm_test_eth_async_arp_reply(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_eth_async_arp_reply, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_eth_async_arp_reply, UTF_SCAN_FDT);
static int sb_check_ping_reply(struct udevice *dev, void *packet,
unsigned int len)
@ -613,8 +612,7 @@ static int dm_test_eth_async_ping_reply(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_eth_async_ping_reply, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_eth_async_ping_reply, UTF_SCAN_FDT);
#if IS_ENABLED(CONFIG_IPV6_ROUTER_DISCOVERY)
@ -659,7 +657,6 @@ static int dm_test_validate_ra(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_validate_ra, 0);
static int dm_test_process_ra(struct unit_test_state *uts)
@ -698,7 +695,6 @@ static int dm_test_process_ra(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_process_ra, 0);
#endif

3
test/dm/extcon.c
View file

@ -17,5 +17,4 @@ static int dm_test_extcon(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_extcon, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_extcon, UTF_SCAN_FDT);

2
test/dm/fastboot.c
View file

@ -91,4 +91,4 @@ static int dm_test_fastboot_mmc_part(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_fastboot_mmc_part, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_fastboot_mmc_part, UTF_SCAN_PDATA | UTF_SCAN_FDT);

4
test/dm/fdtdec.c
View file

@ -55,7 +55,7 @@ static int dm_test_fdtdec_set_carveout(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_fdtdec_set_carveout,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
UTF_SCAN_PDATA | UTF_SCAN_FDT | UTF_FLAT_TREE);
static int dm_test_fdtdec_add_reserved_memory(struct unit_test_state *uts)
{
@ -128,4 +128,4 @@ static int dm_test_fdtdec_add_reserved_memory(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_fdtdec_add_reserved_memory,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT | UT_TESTF_FLAT_TREE);
UTF_SCAN_PDATA | UTF_SCAN_FDT | UTF_FLAT_TREE);

6
test/dm/ffa.c
View file

@ -197,8 +197,7 @@ static int dm_test_ffa_ack(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ffa_ack, UT_TESTF_SCAN_FDT | UT_TESTF_CONSOLE_REC);
DM_TEST(dm_test_ffa_ack, UTF_SCAN_FDT | UTF_CONSOLE);
static int dm_test_ffa_nack(struct unit_test_state *uts)
{
@ -256,5 +255,4 @@ static int dm_test_ffa_nack(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ffa_nack, UT_TESTF_SCAN_FDT | UT_TESTF_CONSOLE_REC);
DM_TEST(dm_test_ffa_nack, UTF_SCAN_FDT | UTF_CONSOLE);

2
test/dm/firmware.c
View file

@ -19,4 +19,4 @@ static int dm_test_firmware_probe(struct unit_test_state *uts)
"sandbox-firmware", &dev));
return 0;
}
DM_TEST(dm_test_firmware_probe, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_firmware_probe, UTF_SCAN_FDT);

3
test/dm/fpga.c
View file

@ -16,5 +16,4 @@ static int dm_test_fpga(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_fpga, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_fpga, UTF_SCAN_FDT);

4
test/dm/fwu_mdata.c
View file

@ -111,7 +111,7 @@ static int dm_test_fwu_mdata_read(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_fwu_mdata_read, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_fwu_mdata_read, UTF_SCAN_FDT);
static int dm_test_fwu_mdata_write(struct unit_test_state *uts)
{
@ -142,4 +142,4 @@ static int dm_test_fwu_mdata_write(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_fwu_mdata_write, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_fwu_mdata_write, UTF_SCAN_FDT);

32
test/dm/gpio.c
View file

@ -145,7 +145,7 @@ static int dm_test_gpio(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_gpio, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test that GPIO open-drain/open-source emulation works correctly */
static int dm_test_gpio_opendrain_opensource(struct unit_test_state *uts)
@ -244,7 +244,7 @@ static int dm_test_gpio_opendrain_opensource(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio_opendrain_opensource,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test that sandbox anonymous GPIOs work correctly */
static int dm_test_gpio_anon(struct unit_test_state *uts)
@ -266,7 +266,7 @@ static int dm_test_gpio_anon(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio_anon, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_gpio_anon, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test that gpio_requestf() works as expected */
static int dm_test_gpio_requestf(struct unit_test_state *uts)
@ -284,7 +284,7 @@ static int dm_test_gpio_requestf(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio_requestf, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_gpio_requestf, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test that gpio_request() copies its string */
static int dm_test_gpio_copy(struct unit_test_state *uts)
@ -306,7 +306,7 @@ static int dm_test_gpio_copy(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio_copy, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_gpio_copy, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test that we don't leak memory with GPIOs */
static int dm_test_gpio_leak(struct unit_test_state *uts)
@ -318,7 +318,7 @@ static int dm_test_gpio_leak(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio_leak, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_gpio_leak, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test that we can find GPIOs using phandles */
static int dm_test_gpio_phandles(struct unit_test_state *uts)
@ -392,7 +392,7 @@ static int dm_test_gpio_phandles(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio_phandles, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_gpio_phandles, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Check the gpio pin configuration get from device tree information */
static int dm_test_gpio_get_dir_flags(struct unit_test_state *uts)
@ -428,7 +428,7 @@ static int dm_test_gpio_get_dir_flags(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio_get_dir_flags, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_gpio_get_dir_flags, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test of gpio_get_acpi() */
static int dm_test_gpio_get_acpi(struct unit_test_state *uts)
@ -457,7 +457,7 @@ static int dm_test_gpio_get_acpi(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio_get_acpi, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_gpio_get_acpi, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test of gpio_get_acpi() with an interrupt GPIO */
static int dm_test_gpio_get_acpi_irq(struct unit_test_state *uts)
@ -489,7 +489,7 @@ static int dm_test_gpio_get_acpi_irq(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio_get_acpi_irq, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_gpio_get_acpi_irq, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test that we can get/release GPIOs using managed API */
static int dm_test_gpio_devm(struct unit_test_state *uts)
@ -590,7 +590,7 @@ static int dm_test_gpio_devm(struct unit_test_state *uts)
device_remove(dev2, DM_REMOVE_NORMAL);
return 0;
}
DM_TEST(dm_test_gpio_devm, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_gpio_devm, UTF_SCAN_PDATA | UTF_SCAN_FDT);
static int dm_test_clrset_flags(struct unit_test_state *uts)
{
@ -631,7 +631,7 @@ static int dm_test_clrset_flags(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_clrset_flags, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_clrset_flags, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Check that an active-low GPIO works as expected */
static int dm_test_clrset_flags_invert(struct unit_test_state *uts)
@ -678,7 +678,7 @@ static int dm_test_clrset_flags_invert(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_clrset_flags_invert, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_clrset_flags_invert, UTF_SCAN_PDATA | UTF_SCAN_FDT);
static int set_gpios(struct unit_test_state *uts, struct gpio_desc *desc,
int count, uint value)
@ -719,7 +719,7 @@ static int dm_test_gpio_get_values_as_int(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio_get_values_as_int,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Check that an active-low GPIO works as expected */
static int dm_test_gpio_get_values_as_int_base3(struct unit_test_state *uts)
@ -776,7 +776,7 @@ static int dm_test_gpio_get_values_as_int_base3(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio_get_values_as_int_base3,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Check that gpio_get_status return the label of a GPIO configured as GPIOD_AF */
static int dm_test_gpio_function(struct unit_test_state *uts)
@ -806,4 +806,4 @@ static int dm_test_gpio_function(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_gpio_function,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
UTF_SCAN_PDATA | UTF_SCAN_FDT);

8
test/dm/host.c
View file

@ -72,7 +72,7 @@ static int dm_test_host(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_host, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_host, UTF_SCAN_FDT);
/* reusing the same label should work */
static int dm_test_host_dup(struct unit_test_state *uts)
@ -106,7 +106,7 @@ static int dm_test_host_dup(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_host_dup, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_host_dup, UTF_SCAN_FDT);
/* Basic test of 'host' command */
static int dm_test_cmd_host(struct unit_test_state *uts)
@ -115,8 +115,6 @@ static int dm_test_cmd_host(struct unit_test_state *uts)
struct blk_desc *desc;
char fname[256];
console_record_reset();
/* first check 'host info' with binding */
ut_assertok(run_command("host info", 0));
ut_assert_nextline("dev blocks blksz label path");
@ -199,4 +197,4 @@ static int dm_test_cmd_host(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_cmd_host, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_cmd_host, UTF_SCAN_FDT | UTF_CONSOLE);

3
test/dm/hwspinlock.c
View file

@ -36,5 +36,4 @@ static int dm_test_hwspinlock_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_hwspinlock_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_hwspinlock_base, UTF_SCAN_PDATA | UTF_SCAN_FDT);

19
test/dm/i2c.c
View file

@ -38,7 +38,7 @@ static int dm_test_i2c_find(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_i2c_find, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_i2c_find, UTF_SCAN_PDATA | UTF_SCAN_FDT);
static int dm_test_i2c_read_write(struct unit_test_state *uts)
{
@ -55,7 +55,7 @@ static int dm_test_i2c_read_write(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_i2c_read_write, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_i2c_read_write, UTF_SCAN_PDATA | UTF_SCAN_FDT);
static int dm_test_i2c_speed(struct unit_test_state *uts)
{
@ -77,7 +77,7 @@ static int dm_test_i2c_speed(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_i2c_speed, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_i2c_speed, UTF_SCAN_PDATA | UTF_SCAN_FDT);
static int dm_test_i2c_offset_len(struct unit_test_state *uts)
{
@ -94,7 +94,7 @@ static int dm_test_i2c_offset_len(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_i2c_offset_len, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_i2c_offset_len, UTF_SCAN_PDATA | UTF_SCAN_FDT);
static int dm_test_i2c_probe_empty(struct unit_test_state *uts)
{
@ -109,7 +109,7 @@ static int dm_test_i2c_probe_empty(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_i2c_probe_empty, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_i2c_probe_empty, UTF_SCAN_PDATA | UTF_SCAN_FDT);
static int dm_test_i2c_bytewise(struct unit_test_state *uts)
{
@ -164,7 +164,7 @@ static int dm_test_i2c_bytewise(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_i2c_bytewise, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_i2c_bytewise, UTF_SCAN_PDATA | UTF_SCAN_FDT);
static int dm_test_i2c_offset(struct unit_test_state *uts)
{
@ -237,7 +237,7 @@ static int dm_test_i2c_offset(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_i2c_offset, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_i2c_offset, UTF_SCAN_PDATA | UTF_SCAN_FDT);
static int dm_test_i2c_addr_offset(struct unit_test_state *uts)
{
@ -301,8 +301,7 @@ static int dm_test_i2c_addr_offset(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_i2c_addr_offset, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_i2c_addr_offset, UTF_SCAN_PDATA | UTF_SCAN_FDT);
static int dm_test_i2c_reg_clrset(struct unit_test_state *uts)
{
@ -331,4 +330,4 @@ static int dm_test_i2c_reg_clrset(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_i2c_reg_clrset, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_i2c_reg_clrset, UTF_SCAN_PDATA | UTF_SCAN_FDT);

2
test/dm/i2s.c
View file

@ -29,4 +29,4 @@ static int dm_test_i2s(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_i2s, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_i2s, UTF_SCAN_PDATA | UTF_SCAN_FDT);

8
test/dm/iommu.c
View file

@ -38,7 +38,7 @@ static int dm_test_iommu(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_iommu, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_iommu, UTF_SCAN_FDT);
static int dm_test_iommu_noiommu(struct unit_test_state *uts)
{
@ -66,7 +66,7 @@ static int dm_test_iommu_noiommu(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_iommu_noiommu, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_iommu_noiommu, UTF_SCAN_FDT);
static int dm_test_iommu_pci(struct unit_test_state *uts)
{
@ -81,7 +81,7 @@ static int dm_test_iommu_pci(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_iommu_pci, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_iommu_pci, UTF_SCAN_FDT);
static int dm_test_iommu_pci_noiommu(struct unit_test_state *uts)
{
@ -96,4 +96,4 @@ static int dm_test_iommu_pci_noiommu(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_iommu_pci_noiommu, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_iommu_pci_noiommu, UTF_SCAN_FDT);

10
test/dm/irq.c
View file

@ -30,7 +30,7 @@ static int dm_test_irq_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_irq_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_irq_base, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test of irq_first_device_type() */
static int dm_test_irq_type(struct unit_test_state *uts)
@ -42,7 +42,7 @@ static int dm_test_irq_type(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_irq_type, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_irq_type, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test of irq_read_and_clear() */
static int dm_test_read_and_clear(struct unit_test_state *uts)
@ -59,7 +59,7 @@ static int dm_test_read_and_clear(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_read_and_clear, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_read_and_clear, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test of irq_request() */
static int dm_test_request(struct unit_test_state *uts)
@ -74,7 +74,7 @@ static int dm_test_request(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_request, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_request, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test of irq_get_acpi() */
static int dm_test_irq_get_acpi(struct unit_test_state *uts)
@ -96,4 +96,4 @@ static int dm_test_irq_get_acpi(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_irq_get_acpi, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_irq_get_acpi, UTF_SCAN_PDATA | UTF_SCAN_FDT);

12
test/dm/led.c
View file

@ -24,7 +24,7 @@ static int dm_test_led_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_led_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_led_base, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test of the LED 'default-state' device tree property */
static int dm_test_led_default_state(struct unit_test_state *uts)
@ -41,7 +41,7 @@ static int dm_test_led_default_state(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_led_default_state, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_led_default_state, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test of the led uclass using the led_gpio driver */
static int dm_test_led_gpio(struct unit_test_state *uts)
@ -66,7 +66,7 @@ static int dm_test_led_gpio(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_led_gpio, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_led_gpio, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test that we can toggle LEDs */
static int dm_test_led_toggle(struct unit_test_state *uts)
@ -91,7 +91,7 @@ static int dm_test_led_toggle(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_led_toggle, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_led_toggle, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test obtaining an LED by label */
static int dm_test_led_label(struct unit_test_state *uts)
@ -112,7 +112,7 @@ static int dm_test_led_label(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_led_label, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_led_label, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test LED blinking */
#ifdef CONFIG_LED_BLINK
@ -135,5 +135,5 @@ static int dm_test_led_blink(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_led_blink, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_led_blink, UTF_SCAN_PDATA | UTF_SCAN_FDT);
#endif

2
test/dm/mailbox.c
View file

@ -28,4 +28,4 @@ static int dm_test_mailbox(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_mailbox, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_mailbox, UTF_SCAN_FDT);

3
test/dm/mdio.c
View file

@ -53,5 +53,4 @@ static int dm_test_mdio(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_mdio, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_mdio, UTF_SCAN_FDT);

3
test/dm/mdio_mux.c
View file

@ -76,5 +76,4 @@ static int dm_test_mdio_mux(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_mdio_mux, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_mdio_mux, UTF_SCAN_FDT);

3
test/dm/memory.c
View file

@ -17,5 +17,4 @@ static int dm_test_memory(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_memory, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_memory, UTF_SCAN_FDT);

3
test/dm/misc.c
View file

@ -79,5 +79,4 @@ static int dm_test_misc(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_misc, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_misc, UTF_SCAN_FDT);

4
test/dm/mmc.c
View file

@ -22,7 +22,7 @@ static int dm_test_mmc_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_mmc_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_mmc_base, UTF_SCAN_PDATA | UTF_SCAN_FDT);
static int dm_test_mmc_blk(struct unit_test_state *uts)
{
@ -50,4 +50,4 @@ static int dm_test_mmc_blk(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_mmc_blk, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_mmc_blk, UTF_SCAN_PDATA | UTF_SCAN_FDT);

6
test/dm/mux-cmd.c
View file

@ -109,7 +109,7 @@ static int dm_test_cmd_mux_list(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_cmd_mux_list, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_cmd_mux_list, UTF_SCAN_PDATA | UTF_SCAN_FDT | UTF_CONSOLE);
static int dm_test_cmd_mux_select(struct unit_test_state *uts)
{
@ -143,7 +143,7 @@ static int dm_test_cmd_mux_select(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_cmd_mux_select, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_cmd_mux_select, UTF_SCAN_PDATA | UTF_SCAN_FDT);
static int dm_test_cmd_mux_deselect(struct unit_test_state *uts)
{
@ -174,4 +174,4 @@ static int dm_test_cmd_mux_deselect(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_cmd_mux_deselect, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_cmd_mux_deselect, UTF_SCAN_PDATA | UTF_SCAN_FDT);

4
test/dm/mux-emul.c
View file

@ -79,7 +79,7 @@ static int dm_test_mux_emul_default_state(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_mux_emul_default_state, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_mux_emul_default_state, UTF_SCAN_PDATA | UTF_SCAN_FDT);
static int dm_test_mux_emul_select_deselect(struct unit_test_state *uts)
{
@ -102,4 +102,4 @@ static int dm_test_mux_emul_select_deselect(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_mux_emul_select_deselect, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_mux_emul_select_deselect, UTF_SCAN_PDATA | UTF_SCAN_FDT);

4
test/dm/mux-mmio.c
View file

@ -85,7 +85,7 @@ static int dm_test_mux_mmio_select(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_mux_mmio_select, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_mux_mmio_select, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* Test that managed API for mux work correctly */
static int dm_test_devm_mux_mmio(struct unit_test_state *uts)
@ -134,4 +134,4 @@ static int dm_test_devm_mux_mmio(struct unit_test_state *uts)
device_remove(dev_b, DM_REMOVE_NORMAL);
return 0;
}
DM_TEST(dm_test_devm_mux_mmio, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_devm_mux_mmio, UTF_SCAN_PDATA | UTF_SCAN_FDT);

45
test/dm/nand.c
View file

@ -12,7 +12,7 @@
#include <linux/mtd/mtd.h>
#include <linux/mtd/rawnand.h>
static int dm_test_nand(struct unit_test_state *uts, int dev, bool end)
static int run_test_nand(struct unit_test_state *uts, int dev, bool end)
{
nand_erase_options_t opts = { };
struct mtd_info *mtd;
@ -88,17 +88,34 @@ static int dm_test_nand(struct unit_test_state *uts, int dev, bool end)
return 0;
}
#define DM_NAND_TEST(dev) \
static int dm_test_nand##dev##_start(struct unit_test_state *uts) \
{ \
return dm_test_nand(uts, dev, false); \
} \
DM_TEST(dm_test_nand##dev##_start, UT_TESTF_SCAN_FDT); \
static int dm_test_nand##dev##_end(struct unit_test_state *uts) \
{ \
return dm_test_nand(uts, dev, true); \
} \
DM_TEST(dm_test_nand##dev##_end, UT_TESTF_SCAN_FDT)
static int dm_test_nand0_start(struct unit_test_state *uts)
{
ut_assertok(run_test_nand(uts, 0, false));
DM_NAND_TEST(0);
DM_NAND_TEST(1);
return 0;
}
DM_TEST(dm_test_nand0_start, UTF_SCAN_FDT);
static int dm_test_nand1_start(struct unit_test_state *uts)
{
ut_assertok(run_test_nand(uts, 1, false));
return 0;
}
DM_TEST(dm_test_nand1_start, UTF_SCAN_FDT);
static int dm_test_nand0_end(struct unit_test_state *uts)
{
ut_assertok(run_test_nand(uts, 0, true));
return 0;
}
DM_TEST(dm_test_nand0_end, UTF_SCAN_FDT);
static int dm_test_nand1_end(struct unit_test_state *uts)
{
ut_assertok(run_test_nand(uts, 1, true));
return 0;
}
DM_TEST(dm_test_nand1_end, UTF_SCAN_FDT);

3
test/dm/nop.c
View file

@ -69,5 +69,4 @@ static int dm_test_nop(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_nop, UT_TESTF_FLAT_TREE | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_nop, UTF_FLAT_TREE | UTF_SCAN_FDT);

3
test/dm/nvmxip.c
View file

@ -142,5 +142,4 @@ static int dm_test_nvmxip(struct unit_test_state *uts)
return CMD_RET_SUCCESS;
}
DM_TEST(dm_test_nvmxip, UT_TESTF_SCAN_FDT | UT_TESTF_CONSOLE_REC);
DM_TEST(dm_test_nvmxip, UTF_SCAN_FDT | UTF_CONSOLE);

16
test/dm/of_platdata.c
View file

@ -20,7 +20,7 @@ static int dm_test_of_plat_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_of_plat_base, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_of_plat_base, UTF_SCAN_PDATA);
/* Test that we can read properties from a device */
static int dm_test_of_plat_props(struct unit_test_state *uts)
@ -91,7 +91,7 @@ static int dm_test_of_plat_props(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_of_plat_props, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_of_plat_props, UTF_SCAN_PDATA);
/*
* find_driver_info - recursively find the driver_info for a device
@ -173,7 +173,7 @@ static int dm_test_of_plat_dev(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_of_plat_dev, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_of_plat_dev, UTF_SCAN_PDATA);
/* Test handling of phandles that point to other devices */
static int dm_test_of_plat_phandle(struct unit_test_state *uts)
@ -206,7 +206,7 @@ static int dm_test_of_plat_phandle(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_of_plat_phandle, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_of_plat_phandle, UTF_SCAN_PDATA);
#if CONFIG_IS_ENABLED(OF_PLATDATA_PARENT)
/* Test that device parents are correctly set up */
@ -220,7 +220,7 @@ static int dm_test_of_plat_parent(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_of_plat_parent, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_of_plat_parent, UTF_SCAN_PDATA);
#endif
/* Test clocks with of-platdata */
@ -239,7 +239,7 @@ static int dm_test_of_plat_clk(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_of_plat_clk, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_of_plat_clk, UTF_SCAN_PDATA);
/* Test irqs with of-platdata */
static int dm_test_of_plat_irq(struct unit_test_state *uts)
@ -258,7 +258,7 @@ static int dm_test_of_plat_irq(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_of_plat_irq, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_of_plat_irq, UTF_SCAN_PDATA);
/* Test GPIOs with of-platdata */
static int dm_test_of_plat_gpio(struct unit_test_state *uts)
@ -277,4 +277,4 @@ static int dm_test_of_plat_gpio(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_of_plat_gpio, UT_TESTF_SCAN_PDATA);
DM_TEST(dm_test_of_plat_gpio, UTF_SCAN_PDATA);

106
test/dm/ofnode.c
View file

@ -47,7 +47,7 @@ oftree get_other_oftree(struct unit_test_state *uts)
/* An invalid tree may cause failure or crashes */
if (!oftree_valid(tree))
ut_reportf("test needs the UT_TESTF_OTHER_FDT flag");
ut_reportf("test needs the UTF_OTHER_FDT flag");
return tree;
}
@ -103,7 +103,7 @@ static int dm_test_ofnode_compatible(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_compatible,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* check ofnode_device_is_compatible() with the 'other' FDT */
static int dm_test_ofnode_compatible_ot(struct unit_test_state *uts)
@ -116,7 +116,7 @@ static int dm_test_ofnode_compatible_ot(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_compatible_ot, UT_TESTF_SCAN_FDT | UT_TESTF_OTHER_FDT);
DM_TEST(dm_test_ofnode_compatible_ot, UTF_SCAN_FDT | UTF_OTHER_FDT);
static int dm_test_ofnode_get_by_phandle(struct unit_test_state *uts)
{
@ -134,7 +134,7 @@ static int dm_test_ofnode_get_by_phandle(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_get_by_phandle, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_get_by_phandle, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* test oftree_get_by_phandle() with a the 'other' oftree */
static int dm_test_ofnode_get_by_phandle_ot(struct unit_test_state *uts)
@ -150,7 +150,7 @@ static int dm_test_ofnode_get_by_phandle_ot(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_get_by_phandle_ot,
UT_TESTF_SCAN_FDT | UT_TESTF_OTHER_FDT);
UTF_SCAN_FDT | UTF_OTHER_FDT);
static int check_prop_values(struct unit_test_state *uts, ofnode start,
const char *propname, const char *propval,
@ -189,7 +189,7 @@ static int dm_test_ofnode_by_prop_value(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_by_prop_value, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_by_prop_value, UTF_SCAN_FDT);
/* test ofnode_by_prop_value() with a the 'other' oftree */
static int dm_test_ofnode_by_prop_value_ot(struct unit_test_state *uts)
@ -202,7 +202,7 @@ static int dm_test_ofnode_by_prop_value_ot(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_by_prop_value_ot,
UT_TESTF_SCAN_FDT | UT_TESTF_OTHER_FDT);
UTF_SCAN_FDT | UTF_OTHER_FDT);
/* test ofnode_read_fmap_entry() */
static int dm_test_ofnode_fmap(struct unit_test_state *uts)
@ -218,7 +218,7 @@ static int dm_test_ofnode_fmap(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_fmap, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_fmap, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* test ofnode_read_prop() */
static int dm_test_ofnode_read(struct unit_test_state *uts)
@ -248,7 +248,7 @@ static int dm_test_ofnode_read(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_read, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_read, UTF_SCAN_FDT);
/* test ofnode_read_prop() with the 'other' tree */
static int dm_test_ofnode_read_ot(struct unit_test_state *uts)
@ -271,7 +271,7 @@ static int dm_test_ofnode_read_ot(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_read_ot, UT_TESTF_SCAN_FDT | UT_TESTF_OTHER_FDT);
DM_TEST(dm_test_ofnode_read_ot, UTF_SCAN_FDT | UTF_OTHER_FDT);
/* test ofnode_count_/parse_phandle_with_args() */
static int dm_test_ofnode_phandle(struct unit_test_state *uts)
@ -347,7 +347,7 @@ static int dm_test_ofnode_phandle(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_phandle, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_phandle, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* test ofnode_count_/parse_phandle_with_args() with 'other' tree */
static int dm_test_ofnode_phandle_ot(struct unit_test_state *uts)
@ -376,7 +376,7 @@ static int dm_test_ofnode_phandle_ot(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_phandle_ot, UT_TESTF_OTHER_FDT);
DM_TEST(dm_test_ofnode_phandle_ot, UTF_OTHER_FDT);
/* test ofnode_read_chosen_string/node/prop() */
static int dm_test_ofnode_read_chosen(struct unit_test_state *uts)
@ -406,7 +406,7 @@ static int dm_test_ofnode_read_chosen(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_read_chosen, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_read_chosen, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* test ofnode_get_aliases_node/prop() */
static int dm_test_ofnode_read_aliases(struct unit_test_state *uts)
@ -429,7 +429,7 @@ static int dm_test_ofnode_read_aliases(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_read_aliases, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_read_aliases, UTF_SCAN_PDATA | UTF_SCAN_FDT);
static int dm_test_ofnode_get_child_count(struct unit_test_state *uts)
{
@ -450,7 +450,7 @@ static int dm_test_ofnode_get_child_count(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_get_child_count,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* test ofnode_get_child_count() with 'other' tree */
static int dm_test_ofnode_get_child_count_ot(struct unit_test_state *uts)
@ -473,7 +473,7 @@ static int dm_test_ofnode_get_child_count_ot(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_get_child_count_ot,
UT_TESTF_SCAN_FDT | UT_TESTF_OTHER_FDT);
UTF_SCAN_FDT | UTF_OTHER_FDT);
static int dm_test_ofnode_is_enabled(struct unit_test_state *uts)
{
@ -485,7 +485,7 @@ static int dm_test_ofnode_is_enabled(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_is_enabled, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_is_enabled, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* test ofnode_is_enabled() with 'other' tree */
static int dm_test_ofnode_is_enabled_ot(struct unit_test_state *uts)
@ -499,7 +499,7 @@ static int dm_test_ofnode_is_enabled_ot(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_is_enabled_ot, UT_TESTF_OTHER_FDT);
DM_TEST(dm_test_ofnode_is_enabled_ot, UTF_OTHER_FDT);
/* test ofnode_get_addr/size() */
static int dm_test_ofnode_get_reg(struct unit_test_state *uts)
@ -536,7 +536,7 @@ static int dm_test_ofnode_get_reg(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_get_reg, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_get_reg, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* test ofnode_get_addr() with 'other' tree */
static int dm_test_ofnode_get_reg_ot(struct unit_test_state *uts)
@ -550,7 +550,7 @@ static int dm_test_ofnode_get_reg_ot(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_get_reg_ot, UT_TESTF_SCAN_FDT | UT_TESTF_OTHER_FDT);
DM_TEST(dm_test_ofnode_get_reg_ot, UTF_SCAN_FDT | UTF_OTHER_FDT);
static int dm_test_ofnode_get_path(struct unit_test_state *uts)
{
@ -571,7 +571,7 @@ static int dm_test_ofnode_get_path(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_get_path, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_get_path, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* test ofnode_get_path() with 'other' tree */
static int dm_test_ofnode_get_path_ot(struct unit_test_state *uts)
@ -591,7 +591,7 @@ static int dm_test_ofnode_get_path_ot(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_get_path_ot, UT_TESTF_SCAN_FDT | UT_TESTF_OTHER_FDT);
DM_TEST(dm_test_ofnode_get_path_ot, UTF_SCAN_FDT | UTF_OTHER_FDT);
/* test ofnode_conf_read_bool/int/str() */
static int dm_test_ofnode_conf(struct unit_test_state *uts)
@ -607,7 +607,7 @@ static int dm_test_ofnode_conf(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_conf, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_conf, UTF_SCAN_FDT);
static int dm_test_ofnode_options(struct unit_test_state *uts)
{
@ -644,7 +644,7 @@ static int dm_test_ofnode_for_each_compatible_node(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_for_each_compatible_node, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_for_each_compatible_node, UTF_SCAN_FDT);
/* test dm_test_ofnode_string_count/index/list() */
static int dm_test_ofnode_string(struct unit_test_state *uts)
@ -692,7 +692,7 @@ static int dm_test_ofnode_string(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_string, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_string, UTF_SCAN_FDT);
/* test error returns from ofnode_read_string_count/index/list() */
static int dm_test_ofnode_string_err(struct unit_test_state *uts)
@ -742,7 +742,7 @@ static int dm_test_ofnode_string_err(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_string_err, UT_TESTF_LIVE_TREE);
DM_TEST(dm_test_ofnode_string_err, UTF_LIVE_TREE);
static int dm_test_ofnode_read_phy_mode(struct unit_test_state *uts)
{
@ -764,7 +764,7 @@ static int dm_test_ofnode_read_phy_mode(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_read_phy_mode, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_read_phy_mode, UTF_SCAN_FDT);
/**
* make_ofnode_fdt() - Create an FDT for testing with ofnode
@ -811,7 +811,7 @@ static int dm_test_ofnode_aliases(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_aliases, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_aliases, UTF_SCAN_FDT);
/**
* dm_test_ofnode_root_mult() - Check aliaes on control and 'other' tree
@ -850,7 +850,7 @@ static int dm_test_ofnode_root_mult(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_root_mult, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_root_mult, UTF_SCAN_FDT);
/* test ofnode_set_enabled(), ofnode_write_prop() on a livetree */
static int dm_test_ofnode_livetree_writing(struct unit_test_state *uts)
@ -897,7 +897,7 @@ static int dm_test_ofnode_livetree_writing(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_livetree_writing,
UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
UTF_SCAN_PDATA | UTF_SCAN_FDT);
static int check_write_prop(struct unit_test_state *uts, ofnode node)
{
@ -940,7 +940,7 @@ static int dm_test_ofnode_write_copy(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_write_copy, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_write_copy, UTF_SCAN_FDT);
/* test writing a property to the 'other' tree */
static int dm_test_ofnode_write_copy_ot(struct unit_test_state *uts)
@ -957,7 +957,7 @@ static int dm_test_ofnode_write_copy_ot(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_write_copy_ot, UT_TESTF_SCAN_FDT | UT_TESTF_OTHER_FDT);
DM_TEST(dm_test_ofnode_write_copy_ot, UTF_SCAN_FDT | UTF_OTHER_FDT);
/* test ofnode_read_u32_index/default() */
static int dm_test_ofnode_u32(struct unit_test_state *uts)
@ -985,7 +985,7 @@ static int dm_test_ofnode_u32(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_u32, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_u32, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* test ofnode_read_u32_array() */
static int dm_test_ofnode_u32_array(struct unit_test_state *uts)
@ -1012,7 +1012,7 @@ static int dm_test_ofnode_u32_array(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_u32_array, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_u32_array, UTF_SCAN_PDATA | UTF_SCAN_FDT);
/* test ofnode_read_u64() and ofnode_write_u64() */
static int dm_test_ofnode_u64(struct unit_test_state *uts)
@ -1046,7 +1046,7 @@ static int dm_test_ofnode_u64(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_u64, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_u64, UTF_SCAN_FDT);
static int dm_test_ofnode_add_subnode(struct unit_test_state *uts)
{
@ -1115,7 +1115,7 @@ static int dm_test_ofnode_add_subnode(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_add_subnode, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_add_subnode, UTF_SCAN_PDATA | UTF_SCAN_FDT);
static int dm_test_ofnode_for_each_prop(struct unit_test_state *uts)
{
@ -1139,7 +1139,7 @@ static int dm_test_ofnode_for_each_prop(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_for_each_prop, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_for_each_prop, UTF_SCAN_FDT);
static int dm_test_ofnode_by_compatible(struct unit_test_state *uts)
{
@ -1155,7 +1155,7 @@ static int dm_test_ofnode_by_compatible(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_by_compatible, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_by_compatible, UTF_SCAN_FDT);
/* check ofnode_by_compatible() on the 'other' tree */
static int dm_test_ofnode_by_compatible_ot(struct unit_test_state *uts)
@ -1173,7 +1173,7 @@ static int dm_test_ofnode_by_compatible_ot(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_by_compatible_ot, UT_TESTF_SCAN_FDT | UT_TESTF_OTHER_FDT);
DM_TEST(dm_test_ofnode_by_compatible_ot, UTF_SCAN_FDT | UTF_OTHER_FDT);
static int dm_test_ofnode_find_subnode(struct unit_test_state *uts)
{
@ -1190,7 +1190,7 @@ static int dm_test_ofnode_find_subnode(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_find_subnode, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_find_subnode, UTF_SCAN_FDT);
/* test ofnode_find_subnode() on the 'other' tree */
static int dm_test_ofnode_find_subnode_ot(struct unit_test_state *uts)
@ -1209,7 +1209,7 @@ static int dm_test_ofnode_find_subnode_ot(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_find_subnode_ot, UT_TESTF_OTHER_FDT);
DM_TEST(dm_test_ofnode_find_subnode_ot, UTF_OTHER_FDT);
static int dm_test_ofnode_get_name(struct unit_test_state *uts)
{
@ -1222,7 +1222,7 @@ static int dm_test_ofnode_get_name(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_get_name, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_get_name, UTF_SCAN_FDT);
/* try to access more FDTs than is supported */
static int dm_test_ofnode_too_many(struct unit_test_state *uts)
@ -1259,7 +1259,7 @@ static int dm_test_ofnode_too_many(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_too_many, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_too_many, UTF_SCAN_FDT);
static int check_copy_props(struct unit_test_state *uts, ofnode dst, ofnode src)
{
@ -1304,7 +1304,7 @@ static int dm_test_ofnode_copy_props(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_copy_props, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_copy_props, UTF_SCAN_FDT);
/* test ofnode_copy_props() with the 'other' tree */
static int dm_test_ofnode_copy_props_ot(struct unit_test_state *uts)
@ -1318,7 +1318,7 @@ static int dm_test_ofnode_copy_props_ot(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_copy_props_ot, UT_TESTF_SCAN_FDT | UT_TESTF_OTHER_FDT);
DM_TEST(dm_test_ofnode_copy_props_ot, UTF_SCAN_FDT | UTF_OTHER_FDT);
/* check that the livetree is aligned to a structure boundary */
static int dm_test_livetree_align(struct unit_test_state *uts)
@ -1344,7 +1344,7 @@ static int dm_test_livetree_align(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_livetree_align, UT_TESTF_SCAN_FDT | UT_TESTF_LIVE_TREE);
DM_TEST(dm_test_livetree_align, UTF_SCAN_FDT | UTF_LIVE_TREE);
/* check that it is possible to load an arbitrary livetree */
static int dm_test_livetree_ensure(struct unit_test_state *uts)
@ -1363,7 +1363,7 @@ static int dm_test_livetree_ensure(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_livetree_ensure, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_livetree_ensure, UTF_SCAN_FDT);
static int dm_test_oftree_new(struct unit_test_state *uts)
{
@ -1379,7 +1379,7 @@ static int dm_test_oftree_new(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_oftree_new, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_oftree_new, UTF_SCAN_FDT);
static int check_copy_node(struct unit_test_state *uts, ofnode dst, ofnode src,
ofnode *nodep)
@ -1428,7 +1428,7 @@ static int dm_test_ofnode_copy_node(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_copy_node, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_copy_node, UTF_SCAN_FDT);
/* test ofnode_copy_node() with the 'other' tree */
static int dm_test_ofnode_copy_node_ot(struct unit_test_state *uts)
@ -1442,7 +1442,7 @@ static int dm_test_ofnode_copy_node_ot(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_copy_node_ot, UT_TESTF_SCAN_FDT | UT_TESTF_OTHER_FDT);
DM_TEST(dm_test_ofnode_copy_node_ot, UTF_SCAN_FDT | UTF_OTHER_FDT);
static int dm_test_ofnode_delete(struct unit_test_state *uts)
{
@ -1473,7 +1473,7 @@ static int dm_test_ofnode_delete(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofnode_delete, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofnode_delete, UTF_SCAN_FDT);
static int dm_test_oftree_to_fdt(struct unit_test_state *uts)
{
@ -1495,7 +1495,7 @@ static int dm_test_oftree_to_fdt(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_oftree_to_fdt, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_oftree_to_fdt, UTF_SCAN_FDT);
/* test ofnode_read_bool() and ofnode_write_bool() */
static int dm_test_bool(struct unit_test_state *uts)
@ -1520,4 +1520,4 @@ static int dm_test_bool(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_bool, UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_bool, UTF_SCAN_FDT);

2
test/dm/ofread.c
View file

@ -45,4 +45,4 @@ static int dm_test_ofprop_get_property(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_ofprop_get_property, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_ofprop_get_property, UTF_SCAN_PDATA | UTF_SCAN_FDT);

6
test/dm/osd.c
View file

@ -130,8 +130,7 @@ static int dm_test_osd_basics(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_osd_basics, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_osd_basics, UTF_SCAN_PDATA | UTF_SCAN_FDT);
static int dm_test_osd_extended(struct unit_test_state *uts)
{
@ -214,5 +213,4 @@ static int dm_test_osd_extended(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_osd_extended, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_osd_extended, UTF_SCAN_PDATA | UTF_SCAN_FDT);

2
test/dm/p2sb.c
View file

@ -24,4 +24,4 @@ static int dm_test_p2sb_base(struct unit_test_state *uts)
return 0;
}
DM_TEST(dm_test_p2sb_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
DM_TEST(dm_test_p2sb_base, UTF_SCAN_PDATA | UTF_SCAN_FDT);

Some files were not shown because too many files have changed in this diff Show more