diff options
Diffstat (limited to 'roms/u-boot/include/test')
| -rw-r--r-- | roms/u-boot/include/test/compression.h | 16 | ||||
| -rw-r--r-- | roms/u-boot/include/test/env.h | 15 | ||||
| -rw-r--r-- | roms/u-boot/include/test/export.h | 16 | ||||
| -rw-r--r-- | roms/u-boot/include/test/lib.h | 14 | ||||
| -rw-r--r-- | roms/u-boot/include/test/log.h | 19 | ||||
| -rw-r--r-- | roms/u-boot/include/test/optee.h | 14 | ||||
| -rw-r--r-- | roms/u-boot/include/test/overlay.h | 15 | ||||
| -rw-r--r-- | roms/u-boot/include/test/suites.h | 51 | ||||
| -rw-r--r-- | roms/u-boot/include/test/test.h | 136 | ||||
| -rw-r--r-- | roms/u-boot/include/test/ut.h | 387 |
10 files changed, 683 insertions, 0 deletions
diff --git a/roms/u-boot/include/test/compression.h b/roms/u-boot/include/test/compression.h new file mode 100644 index 000000000..02fcfa49f --- /dev/null +++ b/roms/u-boot/include/test/compression.h @@ -0,0 +1,16 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * Copyright (c) 2017 Google, Inc + * Written by Simon Glass <sjg@chromium.org> + */ + +#ifndef __TEST_COMPRESSION_H__ +#define __TEST_COMPRESSION_H__ + +#include <test/test.h> + +/* Declare a new compression test */ +#define COMPRESSION_TEST(_name, _flags) \ + UNIT_TEST(_name, _flags, compression_test) + +#endif /* __TEST_ENV_H__ */ diff --git a/roms/u-boot/include/test/env.h b/roms/u-boot/include/test/env.h new file mode 100644 index 000000000..f45e33d71 --- /dev/null +++ b/roms/u-boot/include/test/env.h @@ -0,0 +1,15 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * (C) Copyright 2015 + * Joe Hershberger, National Instruments, joe.hershberger@ni.com + */ + +#ifndef __TEST_ENV_H__ +#define __TEST_ENV_H__ + +#include <test/test.h> + +/* Declare a new environment test */ +#define ENV_TEST(_name, _flags) UNIT_TEST(_name, _flags, env_test) + +#endif /* __TEST_ENV_H__ */ diff --git a/roms/u-boot/include/test/export.h b/roms/u-boot/include/test/export.h new file mode 100644 index 000000000..afc755a8f --- /dev/null +++ b/roms/u-boot/include/test/export.h @@ -0,0 +1,16 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * Copyright (C) 2020 Sean Anderson <seanga2@gmail.com> + */ + +#ifndef TEST_EXPORT_H +#define TEST_EXPORT_H + +/* Declare something static, unless we are doing unit tests */ +#ifdef CONFIG_UNIT_TEST +#define TEST_STATIC +#else +#define TEST_STATIC static +#endif + +#endif /* TEST_EXPORT_H */ diff --git a/roms/u-boot/include/test/lib.h b/roms/u-boot/include/test/lib.h new file mode 100644 index 000000000..04b6241e5 --- /dev/null +++ b/roms/u-boot/include/test/lib.h @@ -0,0 +1,14 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright (c) 2019 Heinrich Schuchardt <xypron.glpk@gmx.de> + */ + +#ifndef __TEST_LIB_H__ +#define __TEST_LIB_H__ + +#include <test/test.h> + +/* Declare a new library function test */ +#define LIB_TEST(_name, _flags) UNIT_TEST(_name, _flags, lib_test) + +#endif /* __TEST_LIB_H__ */ diff --git a/roms/u-boot/include/test/log.h b/roms/u-boot/include/test/log.h new file mode 100644 index 000000000..e90289145 --- /dev/null +++ b/roms/u-boot/include/test/log.h @@ -0,0 +1,19 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright (c) 2020, Heinrich Schuchardt <xypron.glpk@gmx.de> + * + * Tests for logging functions + */ + +#ifndef __TEST_LOG_H__ +#define __TEST_LOG_H__ + +#include <test/test.h> + +#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) + +#endif /* __TEST_LOG_H__ */ diff --git a/roms/u-boot/include/test/optee.h b/roms/u-boot/include/test/optee.h new file mode 100644 index 000000000..a8c6e6395 --- /dev/null +++ b/roms/u-boot/include/test/optee.h @@ -0,0 +1,14 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * Copyright (C) 2019, Theobroma Systems Design und Consulting GmbH + */ + +#ifndef __TEST_OPTEE_H__ +#define __TEST_OPTEE_H__ + +#include <test/test.h> + +/* Declare a new environment test */ +#define OPTEE_TEST(_name, _flags) UNIT_TEST(_name, _flags, optee_test) + +#endif /* __TEST_OPTEE_H__ */ diff --git a/roms/u-boot/include/test/overlay.h b/roms/u-boot/include/test/overlay.h new file mode 100644 index 000000000..c13f4d66e --- /dev/null +++ b/roms/u-boot/include/test/overlay.h @@ -0,0 +1,15 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * Copyright (c) 2016 NextThing Co + * Copyright (c) 2016 Free Electrons + */ + +#ifndef __TEST_OVERLAY_H__ +#define __TEST_OVERLAY_H__ + +#include <test/test.h> + +/* Declare a new environment test */ +#define OVERLAY_TEST(_name, _flags) UNIT_TEST(_name, _flags, overlay_test) + +#endif /* __TEST_OVERLAY_H__ */ diff --git a/roms/u-boot/include/test/suites.h b/roms/u-boot/include/test/suites.h new file mode 100644 index 000000000..f5d8e139c --- /dev/null +++ b/roms/u-boot/include/test/suites.h @@ -0,0 +1,51 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * (C) Copyright 2015 + * Joe Hershberger, National Instruments, joe.hershberger@ni.com + */ + +#ifndef __TEST_SUITES_H__ +#define __TEST_SUITES_H__ + +struct cmd_tbl; +struct unit_test; + +/** + * cmd_ut_category() - Run a category of unit tests + * + * @name: Category name + * @prefix: Prefix of test name + * @tests: List of tests to run + * @n_ents: Number of tests in @tests + * @argc: Argument count provided. Must be >= 1. If this is 1 then all + * tests are run, otherwise only the one named @argv[1] is run. + * @argv: Arguments: argv[1] is the test to run (if @argc >= 2) + * @return 0 if OK, CMD_RET_FAILURE on failure + */ +int cmd_ut_category(const char *name, const char *prefix, + struct unit_test *tests, int n_ents, + int argc, char *const argv[]); + +int do_ut_addrmap(struct cmd_tbl *cmdtp, int flag, int argc, + char *const argv[]); +int do_ut_bootm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]); +int do_ut_bloblist(struct cmd_tbl *cmdtp, int flag, int argc, + char *const argv[]); +int do_ut_compression(struct cmd_tbl *cmdtp, int flag, int argc, + char *const argv[]); +int do_ut_dm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]); +int do_ut_env(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]); +int do_ut_lib(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]); +int do_ut_log(struct cmd_tbl *cmdtp, int flag, int argc, char * const argv[]); +int do_ut_mem(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]); +int do_ut_optee(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]); +int do_ut_overlay(struct cmd_tbl *cmdtp, int flag, int argc, + char *const argv[]); +int do_ut_setexpr(struct cmd_tbl *cmdtp, int flag, int argc, + char *const argv[]); +int do_ut_str(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]); +int do_ut_time(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]); +int do_ut_unicode(struct cmd_tbl *cmdtp, int flag, int argc, + char *const argv[]); + +#endif /* __TEST_SUITES_H__ */ diff --git a/roms/u-boot/include/test/test.h b/roms/u-boot/include/test/test.h new file mode 100644 index 000000000..bf7d785d8 --- /dev/null +++ b/roms/u-boot/include/test/test.h @@ -0,0 +1,136 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * Copyright (c) 2013 Google, Inc. + */ + +#ifndef __TEST_TEST_H +#define __TEST_TEST_H + +#include <malloc.h> +#include <linux/bitops.h> + +/* + * struct unit_test_state - Entire state of test system + * + * @fail_count: Number of tests that failed + * @start: Store the starting mallinfo when doing leak test + * @of_live: true to use livetree if available, false to use flattree + * @of_root: Record of the livetree root node (used for setting up tests) + * @root: Root device + * @testdev: Test device + * @force_fail_alloc: Force all memory allocs to fail + * @skip_post_probe: Skip uclass post-probe processing + * @expect_str: Temporary string used to hold expected string value + * @actual_str: Temporary string used to hold actual string value + */ +struct unit_test_state { + int fail_count; + struct mallinfo start; + struct device_node *of_root; + bool of_live; + struct udevice *root; + struct udevice *testdev; + int force_fail_alloc; + int skip_post_probe; + char expect_str[256]; + char actual_str[256]; +}; + +/* 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 */ + /* do extra driver model init and uninit */ + UT_TESTF_DM = BIT(6), +}; + +/** + * struct unit_test - Information about a unit test + * + * @name: Name of test + * @func: Function to call to perform test + * @flags: Flags indicated pre-conditions for test + */ +struct unit_test { + const char *file; + const char *name; + int (*func)(struct unit_test_state *state); + int flags; +}; + +/** + * UNIT_TEST() - create linker generated list entry for unit a unit test + * + * The macro UNIT_TEST() is used to create a linker generated list entry. These + * list entries are enumerate tests that can be execute using the ut command. + * The list entries are used both by the implementation of the ut command as + * well as in a related Python test. + * + * For Python testing the subtests are collected in Python function + * generate_ut_subtest() by applying a regular expression to the lines of file + * u-boot.sym. The list entries have to follow strict naming conventions to be + * matched by the expression. + * + * Use UNIT_TEST(foo_test_bar, _flags, foo_test) for a test bar in test suite + * foo that can be executed via command 'ut foo bar' and is implemented in + * function foo_test_bar(). + * + * @_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 + * @_suite: name of the test suite concatenated with "_test" + */ +#define UNIT_TEST(_name, _flags, _suite) \ + ll_entry_declare(struct unit_test, _name, ut_ ## _suite) = { \ + .file = __FILE__, \ + .name = #_name, \ + .flags = _flags, \ + .func = _name, \ + } + +/* Get the start of a list of unit tests for a particular suite */ +#define UNIT_TEST_SUITE_START(_suite) \ + ll_entry_start(struct unit_test, ut_ ## _suite) +#define UNIT_TEST_SUITE_COUNT(_suite) \ + ll_entry_count(struct unit_test, ut_ ## _suite) + +/* Use ! and ~ so that all tests will be sorted between these two values */ +#define UNIT_TEST_ALL_START() ll_entry_start(struct unit_test, ut_!) +#define UNIT_TEST_ALL_END() ll_entry_start(struct unit_test, ut_~) +#define UNIT_TEST_ALL_COUNT() (UNIT_TEST_ALL_END() - UNIT_TEST_ALL_START()) + +/* Sizes for devres tests */ +enum { + TEST_DEVRES_SIZE = 100, + TEST_DEVRES_COUNT = 10, + TEST_DEVRES_TOTAL = TEST_DEVRES_SIZE * TEST_DEVRES_COUNT, + + /* A few different sizes */ + TEST_DEVRES_SIZE2 = 15, + TEST_DEVRES_SIZE3 = 37, +}; + +/** + * testbus_get_clear_removed() - Test function to obtain removed device + * + * This is used in testbus to find out which device was removed. Calling this + * function returns a pointer to the device and then clears it back to NULL, so + * that a future test can check it. + */ +struct udevice *testbus_get_clear_removed(void); + +static inline void arch_reset_for_test(void) +{ +#ifdef CONFIG_SANDBOX +#include <asm/state.h> + + state_reset_for_test(state_get_current()); +#endif +} + +#endif /* __TEST_TEST_H */ diff --git a/roms/u-boot/include/test/ut.h b/roms/u-boot/include/test/ut.h new file mode 100644 index 000000000..656e25fe5 --- /dev/null +++ b/roms/u-boot/include/test/ut.h @@ -0,0 +1,387 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * Simple unit test library + * + * Copyright (c) 2013 Google, Inc + */ + +#ifndef __TEST_UT_H +#define __TEST_UT_H + +#include <command.h> +#include <hexdump.h> +#include <linux/err.h> +#include <test/test.h> + +struct unit_test_state; + +/** + * ut_fail() - Record failure of a unit test + * + * @uts: Test state + * @fname: Filename where the error occurred + * @line: Line number where the error occurred + * @func: Function name where the error occurred + * @cond: The condition that failed + */ +void ut_fail(struct unit_test_state *uts, const char *fname, int line, + const char *func, const char *cond); + +/** + * ut_failf() - Record failure of a unit test + * + * @uts: Test state + * @fname: Filename where the error occurred + * @line: Line number where the error occurred + * @func: Function name where the error occurred + * @cond: The condition that failed + * @fmt: printf() format string for the error, followed by args + */ +void ut_failf(struct unit_test_state *uts, const char *fname, int line, + const char *func, const char *cond, const char *fmt, ...) + __attribute__ ((format (__printf__, 6, 7))); + +/** + * ut_check_console_line() - Check the next console line against expectations + * + * This creates a string and then checks it against the next line of console + * output obtained with console_record_readline(). + * + * After the function returns, uts->expect_str holds the expected string and + * uts->actual_str holds the actual string read from the console. + * + * @uts: Test state + * @fmt: printf() format string for the error, followed by args + * @return 0 if OK, other value on error + */ +int ut_check_console_line(struct unit_test_state *uts, const char *fmt, ...) + __attribute__ ((format (__printf__, 2, 3))); + +/** + * ut_check_console_linen() - Check part of the next console line + * + * This creates a string and then checks it against the next line of console + * output obtained with console_record_readline(). Only the length of the + * string is checked + * + * After the function returns, uts->expect_str holds the expected string and + * uts->actual_str holds the actual string read from the console. + * + * @uts: Test state + * @fmt: printf() format string for the error, followed by args + * @return 0 if OK, other value on error + */ +int ut_check_console_linen(struct unit_test_state *uts, const char *fmt, ...) + __attribute__ ((format (__printf__, 2, 3))); + +/** + * ut_check_skipline() - Check that the next console line exists and skip it + * + * @uts: Test state + * @return 0 if OK, other value on error + */ +int ut_check_skipline(struct unit_test_state *uts); + +/** + * ut_check_console_end() - Check there is no more console output + * + * After the function returns, uts->actual_str holds the actual string read + * from the console + * + * @uts: Test state + * @return 0 if OK (console has no output), other value on error + */ +int ut_check_console_end(struct unit_test_state *uts); + +/** + * ut_check_console_dump() - Check that next lines have a print_buffer() dump + * + * This only supports a byte dump. + * + * @total_bytes: Size of the expected dump in bytes` + * @return 0 if OK (looks like a dump and the length matches), other value on + * error + */ +int ut_check_console_dump(struct unit_test_state *uts, int total_bytes); + +/* Assert that a condition is non-zero */ +#define ut_assert(cond) \ + if (!(cond)) { \ + ut_fail(uts, __FILE__, __LINE__, __func__, #cond); \ + return CMD_RET_FAILURE; \ + } + +/* Assert that a condition is non-zero, with printf() string */ +#define ut_assertf(cond, fmt, args...) \ + if (!(cond)) { \ + ut_failf(uts, __FILE__, __LINE__, __func__, #cond, \ + fmt, ##args); \ + return CMD_RET_FAILURE; \ + } + +/* Assert that two int expressions are equal */ +#define ut_asserteq(expr1, expr2) { \ + unsigned int _val1 = (expr1), _val2 = (expr2); \ + \ + if (_val1 != _val2) { \ + ut_failf(uts, __FILE__, __LINE__, __func__, \ + #expr1 " == " #expr2, \ + "Expected %#x (%d), got %#x (%d)", \ + _val1, _val1, _val2, _val2); \ + return CMD_RET_FAILURE; \ + } \ +} + +/* Assert that two 64 int expressions are equal */ +#define ut_asserteq_64(expr1, expr2) { \ + u64 _val1 = (expr1), _val2 = (expr2); \ + \ + if (_val1 != _val2) { \ + ut_failf(uts, __FILE__, __LINE__, __func__, \ + #expr1 " == " #expr2, \ + "Expected %#llx (%lld), got %#llx (%lld)", \ + (unsigned long long)_val1, \ + (unsigned long long)_val1, \ + (unsigned long long)_val2, \ + (unsigned long long)_val2); \ + return CMD_RET_FAILURE; \ + } \ +} + +/* Assert that two string expressions are equal */ +#define ut_asserteq_str(expr1, expr2) { \ + const char *_val1 = (expr1), *_val2 = (expr2); \ + \ + if (strcmp(_val1, _val2)) { \ + ut_failf(uts, __FILE__, __LINE__, __func__, \ + #expr1 " = " #expr2, \ + "Expected \"%s\", got \"%s\"", _val1, _val2); \ + return CMD_RET_FAILURE; \ + } \ +} + +/* + * Assert that two string expressions are equal, up to length of the + * first + */ +#define ut_asserteq_strn(expr1, expr2) { \ + const char *_val1 = (expr1), *_val2 = (expr2); \ + int _len = strlen(_val1); \ + \ + if (memcmp(_val1, _val2, _len)) { \ + ut_failf(uts, __FILE__, __LINE__, __func__, \ + #expr1 " = " #expr2, \ + "Expected \"%.*s\", got \"%.*s\"", \ + _len, _val1, _len, _val2); \ + return CMD_RET_FAILURE; \ + } \ +} + +/* Assert that two memory areas are equal */ +#define ut_asserteq_mem(expr1, expr2, len) { \ + const u8 *_val1 = (u8 *)(expr1), *_val2 = (u8 *)(expr2); \ + const uint __len = len; \ + \ + if (memcmp(_val1, _val2, __len)) { \ + char __buf1[64 + 1] = "\0"; \ + char __buf2[64 + 1] = "\0"; \ + bin2hex(__buf1, _val1, min(__len, (uint)32)); \ + bin2hex(__buf2, _val2, min(__len, (uint)32)); \ + ut_failf(uts, __FILE__, __LINE__, __func__, \ + #expr1 " = " #expr2, \ + "Expected \"%s\", got \"%s\"", \ + __buf1, __buf2); \ + return CMD_RET_FAILURE; \ + } \ +} + +/* Assert that two pointers are equal */ +#define ut_asserteq_ptr(expr1, expr2) { \ + const void *_val1 = (expr1), *_val2 = (expr2); \ + \ + if (_val1 != _val2) { \ + ut_failf(uts, __FILE__, __LINE__, __func__, \ + #expr1 " = " #expr2, \ + "Expected %p, got %p", _val1, _val2); \ + return CMD_RET_FAILURE; \ + } \ +} + +/* Assert that two addresses (converted from pointers) are equal */ +#define ut_asserteq_addr(expr1, expr2) { \ + ulong _val1 = map_to_sysmem(expr1); \ + ulong _val2 = map_to_sysmem(expr2); \ + \ + if (_val1 != _val2) { \ + ut_failf(uts, __FILE__, __LINE__, __func__, \ + #expr1 " = " #expr2, \ + "Expected %lx, got %lx", _val1, _val2); \ + return CMD_RET_FAILURE; \ + } \ +} + +/* Assert that a pointer is NULL */ +#define ut_assertnull(expr) { \ + const void *_val = (expr); \ + \ + if (_val) { \ + ut_failf(uts, __FILE__, __LINE__, __func__, \ + #expr " != NULL", \ + "Expected NULL, got %p", _val); \ + return CMD_RET_FAILURE; \ + } \ +} + +/* Assert that a pointer is not NULL */ +#define ut_assertnonnull(expr) { \ + const void *_val = (expr); \ + \ + if (!_val) { \ + ut_failf(uts, __FILE__, __LINE__, __func__, \ + #expr " = NULL", \ + "Expected non-null, got NULL"); \ + return CMD_RET_FAILURE; \ + } \ +} + +/* Assert that a pointer is not an error pointer */ +#define ut_assertok_ptr(expr) { \ + const void *_val = (expr); \ + \ + if (IS_ERR(_val)) { \ + ut_failf(uts, __FILE__, __LINE__, __func__, \ + #expr " = NULL", \ + "Expected pointer, got error %ld", \ + PTR_ERR(_val)); \ + return CMD_RET_FAILURE; \ + } \ +} + +/* Assert that an operation succeeds (returns 0) */ +#define ut_assertok(cond) ut_asserteq(0, cond) + +/* Assert that the next console output line matches */ +#define ut_assert_nextline(fmt, args...) \ + if (ut_check_console_line(uts, fmt, ##args)) { \ + ut_failf(uts, __FILE__, __LINE__, __func__, \ + "console", "\nExpected '%s',\n got '%s'", \ + uts->expect_str, uts->actual_str); \ + return CMD_RET_FAILURE; \ + } \ + +/* Assert that the next console output line matches up to the length */ +#define ut_assert_nextlinen(fmt, args...) \ + if (ut_check_console_linen(uts, fmt, ##args)) { \ + ut_failf(uts, __FILE__, __LINE__, __func__, \ + "console", "\nExpected '%s',\n got '%s'", \ + uts->expect_str, uts->actual_str); \ + return CMD_RET_FAILURE; \ + } \ + +/* Assert that there is a 'next' console output line, and skip it */ +#define ut_assert_skipline() \ + if (ut_check_skipline(uts)) { \ + ut_failf(uts, __FILE__, __LINE__, __func__, \ + "console", "\nExpected a line, got end"); \ + return CMD_RET_FAILURE; \ + } \ + +/* Assert that there is no more console output */ +#define ut_assert_console_end() \ + if (ut_check_console_end(uts)) { \ + ut_failf(uts, __FILE__, __LINE__, __func__, \ + "console", "Expected no more output, got '%s'",\ + uts->actual_str); \ + return CMD_RET_FAILURE; \ + } \ + +/* Assert that the next lines are print_buffer() dump at an address */ +#define ut_assert_nextlines_are_dump(total_bytes) \ + if (ut_check_console_dump(uts, total_bytes)) { \ + ut_failf(uts, __FILE__, __LINE__, __func__, \ + "console", \ + "Expected dump of length %x bytes, got '%s'", \ + total_bytes, uts->actual_str); \ + return CMD_RET_FAILURE; \ + } \ + +/** + * ut_check_free() - Return the number of bytes free in the malloc() pool + * + * @return bytes free + */ +ulong ut_check_free(void); + +/** + * ut_check_delta() - Return the number of bytes allocated/freed + * + * @last: Last value from ut_check_free + * @return free memory delta from @last; positive means more memory has been + * allocated, negative means less has been allocated (i.e. some is freed) + */ +long ut_check_delta(ulong last); + +/** + * ut_silence_console() - Silence the console if requested by the user + * + * This stops test output from appear on the console. It is the default on + * sandbox, unless the -v flag is given. For other boards, this does nothing. + * + * @uts: Test state (in case in future we want to keep state here) + */ +void ut_silence_console(struct unit_test_state *uts); + +/** + * ut_unsilence_console() - Unsilence the console after a test + * + * This restarts console output again and turns off console recording. This + * happens on all boards, including sandbox. + */ +void ut_unsilence_console(struct unit_test_state *uts); + +/** + * ut_set_skip_delays() - Sets whether delays should be skipped + * + * Normally functions like mdelay() cause U-Boot to wait for a while. This + * allows all such delays to be skipped on sandbox, to speed up tests + * + * @uts: Test state (in case in future we want to keep state here) + * @skip_delays: true to skip delays, false to process them normally + */ +void ut_set_skip_delays(struct unit_test_state *uts, bool skip_delays); + +/** + * test_get_state() - Get the active test state + * + * @return the currently active test state, or NULL if none + */ +struct unit_test_state *test_get_state(void); + +/** + * test_set_state() - Set the active test state + * + * @uts: Test state to use as currently active test state, or NULL if none + */ +void test_set_state(struct unit_test_state *uts); + +/** + * ut_run_tests() - Run a set of tests + * + * This runs the test, handling any preparation and clean-up needed. It prints + * the name of each test before running it. + * + * @category: Category of these tests. This is a string printed at the start to + * announce the the number of tests + * @prefix: String prefix for the tests. Any tests that have this prefix will be + * printed without the prefix, so that it is easier to see the unique part + * of the test name. If NULL, no prefix processing is done + * @tests: List of tests to run + * @count: Number of tests to run + * @select_name: Name of a single test to run (from the list provided). If NULL + * then all tests are run + * @return 0 if all tests passed, -1 if any failed + */ +int ut_run_list(const char *name, const char *prefix, struct unit_test *tests, + int count, const char *select_name); + +#endif |