]>
Commit | Line | Data |
---|---|---|
83d290c5 | 1 | /* SPDX-License-Identifier: GPL-2.0+ */ |
2e7d35d2 | 2 | /* |
e721b882 | 3 | * Simple unit test library |
2e7d35d2 SG |
4 | * |
5 | * Copyright (c) 2013 Google, Inc | |
2e7d35d2 SG |
6 | */ |
7 | ||
e721b882 JH |
8 | #ifndef __TEST_UT_H |
9 | #define __TEST_UT_H | |
2e7d35d2 | 10 | |
09140113 | 11 | #include <command.h> |
1f4431e4 | 12 | #include <hexdump.h> |
85aeda4a | 13 | #include <linux/err.h> |
0e1fad43 | 14 | #include <test/test.h> |
85aeda4a | 15 | |
e721b882 | 16 | struct unit_test_state; |
2e7d35d2 SG |
17 | |
18 | /** | |
19 | * ut_fail() - Record failure of a unit test | |
20 | * | |
e721b882 | 21 | * @uts: Test state |
eae4b2b6 VC |
22 | * @fname: Filename where the error occurred |
23 | * @line: Line number where the error occurred | |
24 | * @func: Function name where the error occurred | |
2e7d35d2 SG |
25 | * @cond: The condition that failed |
26 | */ | |
e721b882 | 27 | void ut_fail(struct unit_test_state *uts, const char *fname, int line, |
2e7d35d2 SG |
28 | const char *func, const char *cond); |
29 | ||
30 | /** | |
31 | * ut_failf() - Record failure of a unit test | |
32 | * | |
e721b882 | 33 | * @uts: Test state |
eae4b2b6 VC |
34 | * @fname: Filename where the error occurred |
35 | * @line: Line number where the error occurred | |
36 | * @func: Function name where the error occurred | |
2e7d35d2 SG |
37 | * @cond: The condition that failed |
38 | * @fmt: printf() format string for the error, followed by args | |
39 | */ | |
e721b882 | 40 | void ut_failf(struct unit_test_state *uts, const char *fname, int line, |
2e7d35d2 SG |
41 | const char *func, const char *cond, const char *fmt, ...) |
42 | __attribute__ ((format (__printf__, 6, 7))); | |
43 | ||
400175b0 SG |
44 | /** |
45 | * ut_check_console_line() - Check the next console line against expectations | |
46 | * | |
47 | * This creates a string and then checks it against the next line of console | |
48 | * output obtained with console_record_readline(). | |
49 | * | |
50 | * After the function returns, uts->expect_str holds the expected string and | |
51 | * uts->actual_str holds the actual string read from the console. | |
52 | * | |
53 | * @uts: Test state | |
54 | * @fmt: printf() format string for the error, followed by args | |
55 | * @return 0 if OK, other value on error | |
56 | */ | |
57 | int ut_check_console_line(struct unit_test_state *uts, const char *fmt, ...) | |
58 | __attribute__ ((format (__printf__, 2, 3))); | |
59 | ||
33d7edfd SG |
60 | /** |
61 | * ut_check_console_linen() - Check part of the next console line | |
62 | * | |
63 | * This creates a string and then checks it against the next line of console | |
64 | * output obtained with console_record_readline(). Only the length of the | |
65 | * string is checked | |
66 | * | |
67 | * After the function returns, uts->expect_str holds the expected string and | |
68 | * uts->actual_str holds the actual string read from the console. | |
69 | * | |
70 | * @uts: Test state | |
71 | * @fmt: printf() format string for the error, followed by args | |
72 | * @return 0 if OK, other value on error | |
73 | */ | |
74 | int ut_check_console_linen(struct unit_test_state *uts, const char *fmt, ...) | |
75 | __attribute__ ((format (__printf__, 2, 3))); | |
76 | ||
77 | /** | |
78 | * ut_check_skipline() - Check that the next console line exists and skip it | |
79 | * | |
80 | * @uts: Test state | |
81 | * @return 0 if OK, other value on error | |
82 | */ | |
83 | int ut_check_skipline(struct unit_test_state *uts); | |
84 | ||
400175b0 SG |
85 | /** |
86 | * ut_check_console_end() - Check there is no more console output | |
87 | * | |
88 | * After the function returns, uts->actual_str holds the actual string read | |
89 | * from the console | |
90 | * | |
91 | * @uts: Test state | |
92 | * @return 0 if OK (console has no output), other value on error | |
93 | */ | |
94 | int ut_check_console_end(struct unit_test_state *uts); | |
95 | ||
96 | /** | |
97 | * ut_check_console_dump() - Check that next lines have a print_buffer() dump | |
98 | * | |
99 | * This only supports a byte dump. | |
100 | * | |
101 | * @total_bytes: Size of the expected dump in bytes` | |
102 | * @return 0 if OK (looks like a dump and the length matches), other value on | |
103 | * error | |
104 | */ | |
105 | int ut_check_console_dump(struct unit_test_state *uts, int total_bytes); | |
2e7d35d2 SG |
106 | |
107 | /* Assert that a condition is non-zero */ | |
108 | #define ut_assert(cond) \ | |
109 | if (!(cond)) { \ | |
e721b882 | 110 | ut_fail(uts, __FILE__, __LINE__, __func__, #cond); \ |
fe3f6a65 | 111 | return CMD_RET_FAILURE; \ |
2e7d35d2 SG |
112 | } |
113 | ||
114 | /* Assert that a condition is non-zero, with printf() string */ | |
115 | #define ut_assertf(cond, fmt, args...) \ | |
116 | if (!(cond)) { \ | |
e721b882 | 117 | ut_failf(uts, __FILE__, __LINE__, __func__, #cond, \ |
2e7d35d2 | 118 | fmt, ##args); \ |
fe3f6a65 | 119 | return CMD_RET_FAILURE; \ |
2e7d35d2 SG |
120 | } |
121 | ||
122 | /* Assert that two int expressions are equal */ | |
123 | #define ut_asserteq(expr1, expr2) { \ | |
ba8444a0 | 124 | unsigned int _val1 = (expr1), _val2 = (expr2); \ |
2e7d35d2 | 125 | \ |
ba8444a0 | 126 | if (_val1 != _val2) { \ |
e721b882 | 127 | ut_failf(uts, __FILE__, __LINE__, __func__, \ |
2e7d35d2 | 128 | #expr1 " == " #expr2, \ |
ba8444a0 SG |
129 | "Expected %#x (%d), got %#x (%d)", \ |
130 | _val1, _val1, _val2, _val2); \ | |
fe3f6a65 | 131 | return CMD_RET_FAILURE; \ |
2e7d35d2 SG |
132 | } \ |
133 | } | |
134 | ||
70573c6c DB |
135 | /* Assert that two 64 int expressions are equal */ |
136 | #define ut_asserteq_64(expr1, expr2) { \ | |
137 | u64 _val1 = (expr1), _val2 = (expr2); \ | |
138 | \ | |
139 | if (_val1 != _val2) { \ | |
140 | ut_failf(uts, __FILE__, __LINE__, __func__, \ | |
141 | #expr1 " == " #expr2, \ | |
142 | "Expected %#llx (%lld), got %#llx (%lld)", \ | |
143 | (unsigned long long)_val1, \ | |
144 | (unsigned long long)_val1, \ | |
145 | (unsigned long long)_val2, \ | |
146 | (unsigned long long)_val2); \ | |
147 | return CMD_RET_FAILURE; \ | |
148 | } \ | |
149 | } | |
150 | ||
2e7d35d2 SG |
151 | /* Assert that two string expressions are equal */ |
152 | #define ut_asserteq_str(expr1, expr2) { \ | |
ba8444a0 | 153 | const char *_val1 = (expr1), *_val2 = (expr2); \ |
2e7d35d2 | 154 | \ |
ba8444a0 | 155 | if (strcmp(_val1, _val2)) { \ |
e721b882 | 156 | ut_failf(uts, __FILE__, __LINE__, __func__, \ |
2e7d35d2 | 157 | #expr1 " = " #expr2, \ |
ba8444a0 | 158 | "Expected \"%s\", got \"%s\"", _val1, _val2); \ |
fe3f6a65 | 159 | return CMD_RET_FAILURE; \ |
2e7d35d2 SG |
160 | } \ |
161 | } | |
162 | ||
7aed90d4 SG |
163 | /* |
164 | * Assert that two string expressions are equal, up to length of the | |
165 | * first | |
166 | */ | |
167 | #define ut_asserteq_strn(expr1, expr2) { \ | |
168 | const char *_val1 = (expr1), *_val2 = (expr2); \ | |
169 | int _len = strlen(_val1); \ | |
170 | \ | |
171 | if (memcmp(_val1, _val2, _len)) { \ | |
172 | ut_failf(uts, __FILE__, __LINE__, __func__, \ | |
173 | #expr1 " = " #expr2, \ | |
174 | "Expected \"%.*s\", got \"%.*s\"", \ | |
175 | _len, _val1, _len, _val2); \ | |
176 | return CMD_RET_FAILURE; \ | |
177 | } \ | |
178 | } | |
179 | ||
33d7edfd SG |
180 | /* |
181 | * Assert that two string expressions are equal, up to length of the | |
182 | * first | |
183 | */ | |
184 | #define ut_asserteq_strn(expr1, expr2) { \ | |
185 | const char *_val1 = (expr1), *_val2 = (expr2); \ | |
186 | int _len = strlen(_val1); \ | |
187 | \ | |
188 | if (memcmp(_val1, _val2, _len)) { \ | |
189 | ut_failf(uts, __FILE__, __LINE__, __func__, \ | |
190 | #expr1 " = " #expr2, \ | |
191 | "Expected \"%.*s\", got \"%.*s\"", \ | |
192 | _len, _val1, _len, _val2); \ | |
193 | return CMD_RET_FAILURE; \ | |
194 | } \ | |
195 | } | |
196 | ||
41f67e3b MS |
197 | /* Assert that two memory areas are equal */ |
198 | #define ut_asserteq_mem(expr1, expr2, len) { \ | |
ba8444a0 | 199 | const u8 *_val1 = (u8 *)(expr1), *_val2 = (u8 *)(expr2); \ |
41f67e3b MS |
200 | const uint __len = len; \ |
201 | \ | |
ba8444a0 | 202 | if (memcmp(_val1, _val2, __len)) { \ |
41f67e3b MS |
203 | char __buf1[64 + 1] = "\0"; \ |
204 | char __buf2[64 + 1] = "\0"; \ | |
ba8444a0 SG |
205 | bin2hex(__buf1, _val1, min(__len, (uint)32)); \ |
206 | bin2hex(__buf2, _val2, min(__len, (uint)32)); \ | |
41f67e3b MS |
207 | ut_failf(uts, __FILE__, __LINE__, __func__, \ |
208 | #expr1 " = " #expr2, \ | |
209 | "Expected \"%s\", got \"%s\"", \ | |
210 | __buf1, __buf2); \ | |
211 | return CMD_RET_FAILURE; \ | |
212 | } \ | |
213 | } | |
214 | ||
2e7d35d2 SG |
215 | /* Assert that two pointers are equal */ |
216 | #define ut_asserteq_ptr(expr1, expr2) { \ | |
ba8444a0 | 217 | const void *_val1 = (expr1), *_val2 = (expr2); \ |
2e7d35d2 | 218 | \ |
ba8444a0 | 219 | if (_val1 != _val2) { \ |
e721b882 | 220 | ut_failf(uts, __FILE__, __LINE__, __func__, \ |
2e7d35d2 | 221 | #expr1 " = " #expr2, \ |
ba8444a0 | 222 | "Expected %p, got %p", _val1, _val2); \ |
fe3f6a65 | 223 | return CMD_RET_FAILURE; \ |
2e7d35d2 SG |
224 | } \ |
225 | } | |
226 | ||
cdd4e30d SG |
227 | /* Assert that two addresses (converted from pointers) are equal */ |
228 | #define ut_asserteq_addr(expr1, expr2) { \ | |
229 | ulong _val1 = map_to_sysmem(expr1); \ | |
230 | ulong _val2 = map_to_sysmem(expr2); \ | |
231 | \ | |
232 | if (_val1 != _val2) { \ | |
233 | ut_failf(uts, __FILE__, __LINE__, __func__, \ | |
234 | #expr1 " = " #expr2, \ | |
235 | "Expected %lx, got %lx", _val1, _val2); \ | |
236 | return CMD_RET_FAILURE; \ | |
237 | } \ | |
238 | } | |
239 | ||
8d545790 RF |
240 | /* Assert that a pointer is NULL */ |
241 | #define ut_assertnull(expr) { \ | |
ba8444a0 | 242 | const void *_val = (expr); \ |
8d545790 | 243 | \ |
ba8444a0 | 244 | if (_val) { \ |
8d545790 RF |
245 | ut_failf(uts, __FILE__, __LINE__, __func__, \ |
246 | #expr " != NULL", \ | |
ba8444a0 | 247 | "Expected NULL, got %p", _val); \ |
8d545790 RF |
248 | return CMD_RET_FAILURE; \ |
249 | } \ | |
250 | } | |
251 | ||
ecc2ed55 SG |
252 | /* Assert that a pointer is not NULL */ |
253 | #define ut_assertnonnull(expr) { \ | |
ba8444a0 | 254 | const void *_val = (expr); \ |
ecc2ed55 | 255 | \ |
ba8444a0 | 256 | if (!_val) { \ |
e721b882 | 257 | ut_failf(uts, __FILE__, __LINE__, __func__, \ |
ecc2ed55 SG |
258 | #expr " = NULL", \ |
259 | "Expected non-null, got NULL"); \ | |
fe3f6a65 | 260 | return CMD_RET_FAILURE; \ |
ecc2ed55 SG |
261 | } \ |
262 | } | |
263 | ||
85aeda4a | 264 | /* Assert that a pointer is not an error pointer */ |
fe3c0b5b | 265 | #define ut_assertok_ptr(expr) { \ |
ba8444a0 | 266 | const void *_val = (expr); \ |
85aeda4a | 267 | \ |
ba8444a0 | 268 | if (IS_ERR(_val)) { \ |
85aeda4a SG |
269 | ut_failf(uts, __FILE__, __LINE__, __func__, \ |
270 | #expr " = NULL", \ | |
271 | "Expected pointer, got error %ld", \ | |
ba8444a0 | 272 | PTR_ERR(_val)); \ |
85aeda4a SG |
273 | return CMD_RET_FAILURE; \ |
274 | } \ | |
275 | } | |
276 | ||
2e7d35d2 SG |
277 | /* Assert that an operation succeeds (returns 0) */ |
278 | #define ut_assertok(cond) ut_asserteq(0, cond) | |
279 | ||
400175b0 SG |
280 | /* Assert that the next console output line matches */ |
281 | #define ut_assert_nextline(fmt, args...) \ | |
282 | if (ut_check_console_line(uts, fmt, ##args)) { \ | |
283 | ut_failf(uts, __FILE__, __LINE__, __func__, \ | |
284 | "console", "\nExpected '%s',\n got '%s'", \ | |
285 | uts->expect_str, uts->actual_str); \ | |
286 | return CMD_RET_FAILURE; \ | |
287 | } \ | |
288 | ||
33d7edfd SG |
289 | /* Assert that the next console output line matches up to the length */ |
290 | #define ut_assert_nextlinen(fmt, args...) \ | |
291 | if (ut_check_console_linen(uts, fmt, ##args)) { \ | |
292 | ut_failf(uts, __FILE__, __LINE__, __func__, \ | |
293 | "console", "\nExpected '%s',\n got '%s'", \ | |
294 | uts->expect_str, uts->actual_str); \ | |
295 | return CMD_RET_FAILURE; \ | |
296 | } \ | |
297 | ||
298 | /* Assert that there is a 'next' console output line, and skip it */ | |
299 | #define ut_assert_skipline() \ | |
300 | if (ut_check_skipline(uts)) { \ | |
301 | ut_failf(uts, __FILE__, __LINE__, __func__, \ | |
302 | "console", "\nExpected a line, got end"); \ | |
303 | return CMD_RET_FAILURE; \ | |
304 | } \ | |
305 | ||
400175b0 SG |
306 | /* Assert that there is no more console output */ |
307 | #define ut_assert_console_end() \ | |
308 | if (ut_check_console_end(uts)) { \ | |
309 | ut_failf(uts, __FILE__, __LINE__, __func__, \ | |
310 | "console", "Expected no more output, got '%s'",\ | |
311 | uts->actual_str); \ | |
312 | return CMD_RET_FAILURE; \ | |
313 | } \ | |
314 | ||
315 | /* Assert that the next lines are print_buffer() dump at an address */ | |
316 | #define ut_assert_nextlines_are_dump(total_bytes) \ | |
317 | if (ut_check_console_dump(uts, total_bytes)) { \ | |
318 | ut_failf(uts, __FILE__, __LINE__, __func__, \ | |
319 | "console", \ | |
320 | "Expected dump of length %x bytes, got '%s'", \ | |
321 | total_bytes, uts->actual_str); \ | |
322 | return CMD_RET_FAILURE; \ | |
323 | } \ | |
324 | ||
8109863f SG |
325 | /** |
326 | * ut_check_free() - Return the number of bytes free in the malloc() pool | |
327 | * | |
328 | * @return bytes free | |
329 | */ | |
330 | ulong ut_check_free(void); | |
331 | ||
332 | /** | |
333 | * ut_check_delta() - Return the number of bytes allocated/freed | |
334 | * | |
335 | * @last: Last value from ut_check_free | |
336 | * @return free memory delta from @last; positive means more memory has been | |
337 | * allocated, negative means less has been allocated (i.e. some is freed) | |
338 | */ | |
339 | long ut_check_delta(ulong last); | |
340 | ||
ef7e2649 SG |
341 | /** |
342 | * ut_silence_console() - Silence the console if requested by the user | |
343 | * | |
344 | * This stops test output from appear on the console. It is the default on | |
345 | * sandbox, unless the -v flag is given. For other boards, this does nothing. | |
346 | * | |
347 | * @uts: Test state (in case in future we want to keep state here) | |
348 | */ | |
349 | void ut_silence_console(struct unit_test_state *uts); | |
350 | ||
351 | /** | |
352 | * ut_unsilence_console() - Unsilence the console after a test | |
353 | * | |
354 | * This restarts console output again and turns off console recording. This | |
355 | * happens on all boards, including sandbox. | |
356 | */ | |
357 | void ut_unsilence_console(struct unit_test_state *uts); | |
358 | ||
2e7d35d2 | 359 | #endif |