From ba8444a06623b4f9af051aec47247c202937ec00 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Mon, 27 Jan 2020 08:49:41 -0700 Subject: test: Add underscore prefix to macro parameters If a test happens to use the same variable as the macro parameter the macro does not work as intended. Add an underscore to guard against this. Signed-off-by: Simon Glass --- include/test/ut.h | 44 ++++++++++++++++++++++---------------------- 1 file changed, 22 insertions(+), 22 deletions(-) (limited to 'include/test') diff --git a/include/test/ut.h b/include/test/ut.h index f616c202f35..c9fc9cc8395 100644 --- a/include/test/ut.h +++ b/include/test/ut.h @@ -56,39 +56,39 @@ void ut_failf(struct unit_test_state *uts, const char *fname, int line, /* Assert that two int expressions are equal */ #define ut_asserteq(expr1, expr2) { \ - unsigned int val1 = (expr1), val2 = (expr2); \ + unsigned int _val1 = (expr1), _val2 = (expr2); \ \ - if (val1 != val2) { \ + if (_val1 != _val2) { \ ut_failf(uts, __FILE__, __LINE__, __func__, \ #expr1 " == " #expr2, \ - "Expected %#x (%d), got %#x (%d)", val1, val1, \ - val2, val2); \ + "Expected %#x (%d), got %#x (%d)", \ + _val1, _val1, _val2, _val2); \ return CMD_RET_FAILURE; \ } \ } /* Assert that two string expressions are equal */ #define ut_asserteq_str(expr1, expr2) { \ - const char *val1 = (expr1), *val2 = (expr2); \ + const char *_val1 = (expr1), *_val2 = (expr2); \ \ - if (strcmp(val1, val2)) { \ + if (strcmp(_val1, _val2)) { \ ut_failf(uts, __FILE__, __LINE__, __func__, \ #expr1 " = " #expr2, \ - "Expected \"%s\", got \"%s\"", val1, val2); \ + "Expected \"%s\", got \"%s\"", _val1, _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 u8 *_val1 = (u8 *)(expr1), *_val2 = (u8 *)(expr2); \ const uint __len = len; \ \ - if (memcmp(val1, val2, __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)); \ + 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\"", \ @@ -99,33 +99,33 @@ void ut_failf(struct unit_test_state *uts, const char *fname, int line, /* Assert that two pointers are equal */ #define ut_asserteq_ptr(expr1, expr2) { \ - const void *val1 = (expr1), *val2 = (expr2); \ + const void *_val1 = (expr1), *_val2 = (expr2); \ \ - if (val1 != val2) { \ + if (_val1 != _val2) { \ ut_failf(uts, __FILE__, __LINE__, __func__, \ #expr1 " = " #expr2, \ - "Expected %p, got %p", val1, val2); \ + "Expected %p, got %p", _val1, _val2); \ return CMD_RET_FAILURE; \ } \ } /* Assert that a pointer is NULL */ #define ut_assertnull(expr) { \ - const void *val = (expr); \ + const void *_val = (expr); \ \ - if (val != NULL) { \ + if (_val) { \ ut_failf(uts, __FILE__, __LINE__, __func__, \ #expr " != NULL", \ - "Expected NULL, got %p", val); \ + "Expected NULL, got %p", _val); \ return CMD_RET_FAILURE; \ } \ } /* Assert that a pointer is not NULL */ #define ut_assertnonnull(expr) { \ - const void *val = (expr); \ + const void *_val = (expr); \ \ - if (val == NULL) { \ + if (!_val) { \ ut_failf(uts, __FILE__, __LINE__, __func__, \ #expr " = NULL", \ "Expected non-null, got NULL"); \ @@ -135,13 +135,13 @@ void ut_failf(struct unit_test_state *uts, const char *fname, int line, /* Assert that a pointer is not an error pointer */ #define ut_assertok_ptr(expr) { \ - const void *val = (expr); \ + const void *_val = (expr); \ \ - if (IS_ERR(val)) { \ + if (IS_ERR(_val)) { \ ut_failf(uts, __FILE__, __LINE__, __func__, \ #expr " = NULL", \ "Expected pointer, got error %ld", \ - PTR_ERR(val)); \ + PTR_ERR(_val)); \ return CMD_RET_FAILURE; \ } \ } -- cgit v1.3.1 From 400175b0a7daa062ed88def052ae6d54ec56a7e9 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Mon, 27 Jan 2020 08:49:56 -0700 Subject: test: Add a way to check each line of console output When writing tests to check the output from commands it is useful to be able to check the output line by line using an assertion. Add helper macros to support this and to check that there is no unexpected trailing data. Also some commands produce a dump using print_buffer(). Add a way to check that the correct number of bytes are dumped (ignoring the actual contents). Signed-off-by: Simon Glass --- include/test/test.h | 4 ++++ include/test/ut.h | 65 +++++++++++++++++++++++++++++++++++++++++++++++++++++ test/ut.c | 46 +++++++++++++++++++++++++++++++++++++ 3 files changed, 115 insertions(+) (limited to 'include/test') diff --git a/include/test/test.h b/include/test/test.h index e5bef4759a6..2a752110083 100644 --- a/include/test/test.h +++ b/include/test/test.h @@ -15,12 +15,16 @@ * @start: Store the starting mallinfo when doing leak test * @priv: A pointer to some other info some suites want to track * @of_root: Record of the livetree root node (used for setting up tests) + * @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; void *priv; struct device_node *of_root; + char expect_str[256]; + char actual_str[256]; }; /** diff --git a/include/test/ut.h b/include/test/ut.h index c9fc9cc8395..04df8ba3af3 100644 --- a/include/test/ut.h +++ b/include/test/ut.h @@ -38,6 +38,43 @@ 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_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) \ @@ -149,6 +186,34 @@ void ut_failf(struct unit_test_state *uts, const char *fname, int line, /* 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 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 * diff --git a/test/ut.c b/test/ut.c index 265da4a0d89..c64f0b554d5 100644 --- a/test/ut.c +++ b/test/ut.c @@ -6,6 +6,7 @@ */ #include +#include #include #include #include @@ -46,3 +47,48 @@ long ut_check_delta(ulong last) return ut_check_free() - last; } +int ut_check_console_line(struct unit_test_state *uts, const char *fmt, ...) +{ + va_list args; + + va_start(args, fmt); + vsnprintf(uts->expect_str, sizeof(uts->expect_str), fmt, args); + va_end(args); + console_record_readline(uts->actual_str, sizeof(uts->actual_str)); + + return strcmp(uts->expect_str, uts->actual_str); +} + +int ut_check_console_end(struct unit_test_state *uts) +{ + if (!console_record_avail()) + return 0; + + console_record_readline(uts->actual_str, sizeof(uts->actual_str)); + + return 1; +} + +int ut_check_console_dump(struct unit_test_state *uts, int total_bytes) +{ + char *str = uts->actual_str; + int upto; + + /* Handle empty dump */ + if (!total_bytes) + return 0; + + for (upto = 0; upto < total_bytes;) { + int len; + int bytes; + + len = console_record_readline(str, sizeof(uts->actual_str)); + if (str[8] != ':' || str[9] != ' ') + return 1; + + bytes = len - 8 - 2 - 3 * 16 - 4; + upto += bytes; + } + + return upto == total_bytes ? 0 : 1; +} -- cgit v1.3.1