1
2
3
4
5
6#include <common.h>
7#include <command.h>
8#include <efi_api.h>
9#include <display_options.h>
10#include <log.h>
11#include <mapmem.h>
12#include <version_string.h>
13#include <vsprintf.h>
14#include <test/suites.h>
15#include <test/test.h>
16#include <test/ut.h>
17
18#define BUF_SIZE 0x100
19
20#define FAKE_BUILD_TAG "jenkins-u-boot-denx_uboot_dm-master-build-aarch64" \
21 "and a lot more text to come"
22
23
24#define PRINT_TEST(_name, _flags) UNIT_TEST(_name, _flags, print_test)
25
26#if CONFIG_IS_ENABLED(LIB_UUID)
27
28static int print_guid(struct unit_test_state *uts)
29{
30 unsigned char guid[16] = {
31 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
32 };
33 char str[40];
34 int ret;
35
36 sprintf(str, "%pUb", guid);
37 ut_assertok(strcmp("01020304-0506-0708-090a-0b0c0d0e0f10", str));
38 sprintf(str, "%pUB", guid);
39 ut_assertok(strcmp("01020304-0506-0708-090A-0B0C0D0E0F10", str));
40 sprintf(str, "%pUl", guid);
41 ut_assertok(strcmp("04030201-0605-0807-090a-0b0c0d0e0f10", str));
42 sprintf(str, "%pUL", guid);
43 ut_assertok(strcmp("04030201-0605-0807-090A-0B0C0D0E0F10", str));
44 ret = snprintf(str, 4, "%pUL", guid);
45 ut_asserteq(0, str[3]);
46 ut_asserteq(36, ret);
47
48 return 0;
49}
50PRINT_TEST(print_guid, 0);
51#endif
52
53#if CONFIG_IS_ENABLED(EFI_LOADER) && !defined(API_BUILD)
54
55static int print_efi_ut(struct unit_test_state *uts)
56{
57 char str[10];
58 u8 buf[sizeof(struct efi_device_path_sd_mmc_path) +
59 sizeof(struct efi_device_path)];
60 u8 *pos = buf;
61 struct efi_device_path *dp_end;
62 struct efi_device_path_sd_mmc_path *dp_sd =
63 (struct efi_device_path_sd_mmc_path *)pos;
64
65
66 dp_sd->dp.type = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
67 dp_sd->dp.sub_type = DEVICE_PATH_SUB_TYPE_MSG_SD;
68 dp_sd->dp.length = sizeof(struct efi_device_path_sd_mmc_path);
69 dp_sd->slot_number = 3;
70 pos += sizeof(struct efi_device_path_sd_mmc_path);
71
72 dp_end = (struct efi_device_path *)pos;
73 dp_end->type = DEVICE_PATH_TYPE_END;
74 dp_end->sub_type = DEVICE_PATH_SUB_TYPE_END;
75 dp_end->length = sizeof(struct efi_device_path);
76
77 snprintf(str, sizeof(str), "_%pD_", buf);
78 ut_assertok(strcmp("_/SD(3)_", str));
79
80
81 snprintf(str, sizeof(str), "_%pD_", NULL);
82 ut_assertok(strcmp("_<NULL>_", str));
83
84 return 0;
85}
86PRINT_TEST(print_efi_ut, 0);
87#endif
88
89static int print_printf(struct unit_test_state *uts)
90{
91 char big_str[400];
92 int big_str_len;
93 char str[10], *s;
94 int len;
95
96 snprintf(str, sizeof(str), "testing");
97 ut_assertok(strcmp("testing", str));
98
99 snprintf(str, sizeof(str), "testing but too long");
100 ut_assertok(strcmp("testing b", str));
101
102 snprintf(str, 1, "testing none");
103 ut_assertok(strcmp("", str));
104
105 *str = 'x';
106 snprintf(str, 0, "testing none");
107 ut_asserteq('x', *str);
108
109 sprintf(big_str, "_%ls_", L"foo");
110 ut_assertok(strcmp("_foo_", big_str));
111
112
113 s = display_options_get_banner(true, str, sizeof(str));
114 ut_asserteq_ptr(str, s);
115 ut_assertok(strcmp("\n\nU-Boo\n\n", s));
116
117
118 str[0] = '`';
119 s = display_options_get_banner(true, str + 1, 1);
120 ut_asserteq_ptr(str + 1, s);
121 ut_assertok(strcmp("`", str));
122
123 str[0] = '~';
124 s = display_options_get_banner(true, str + 1, 2);
125 ut_asserteq_ptr(str + 1, s);
126 ut_assertok(strcmp("~\n", str));
127
128
129 s = display_options_get_banner(false, str, sizeof(str));
130 ut_asserteq_ptr(str, s);
131 ut_assertok(strcmp("U-Boot \n\n", s));
132
133
134 big_str_len = strlen(version_string) - 5;
135 s = display_options_get_banner_priv(false, FAKE_BUILD_TAG, big_str,
136 big_str_len);
137 ut_asserteq_ptr(big_str, s);
138 ut_assertok(strncmp(version_string, s, big_str_len - 3));
139 ut_assertok(strcmp("\n\n", s + big_str_len - 3));
140
141
142 big_str_len = strlen(version_string) + 9 + 20;
143 s = display_options_get_banner_priv(false, FAKE_BUILD_TAG, big_str,
144 big_str_len);
145 ut_asserteq_ptr(big_str, s);
146 len = strlen(version_string);
147 ut_assertok(strncmp(version_string, s, len));
148 ut_assertok(strncmp(", Build: ", s + len, 9));
149 ut_assertok(strncmp(FAKE_BUILD_TAG, s + 9 + len, 12));
150 ut_assertok(strcmp("\n\n", s + big_str_len - 3));
151
152 return 0;
153}
154PRINT_TEST(print_printf, 0);
155
156static int print_display_buffer(struct unit_test_state *uts)
157{
158 u8 *buf;
159 int i;
160
161 buf = map_sysmem(0, BUF_SIZE);
162 memset(buf, '\0', BUF_SIZE);
163 for (i = 0; i < 0x11; i++)
164 buf[i] = i * 0x11;
165
166
167 console_record_reset();
168 print_buffer(0, buf, 1, 0x12, 0);
169 ut_assert_nextline("00000000: 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff ..\"3DUfw........");
170 ut_assert_nextline("00000010: 10 00 ..");
171 ut_assert_console_end();
172
173
174 console_record_reset();
175 print_buffer(0, buf, 1, 0x12, 8);
176 ut_assert_nextline("00000000: 00 11 22 33 44 55 66 77 ..\"3DUfw");
177 ut_assert_nextline("00000008: 88 99 aa bb cc dd ee ff ........");
178 ut_assert_nextline("00000010: 10 00 ..");
179 ut_assert_console_end();
180
181
182 console_record_reset();
183 buf[0x41] = 0x41;
184 print_buffer(0, buf, 1, 0x42, 0x40);
185 ut_assert_nextline("00000000: 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff 10 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ..\"3DUfw........................................................");
186 ut_assert_nextline("00000040: 00 41 .A");
187 ut_assert_console_end();
188
189
190 console_record_reset();
191 print_buffer(0x12345678, buf, 1, 0x12, 0);
192 ut_assert_nextline("12345678: 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff ..\"3DUfw........");
193 ut_assert_nextline("12345688: 10 00 ..");
194 ut_assert_console_end();
195
196
197 console_record_reset();
198 print_buffer(0, buf, 2, 9, 0);
199 ut_assert_nextline("00000000: 1100 3322 5544 7766 9988 bbaa ddcc ffee ..\"3DUfw........");
200 ut_assert_nextline("00000010: 0010 ..");
201 ut_assert_console_end();
202
203
204 console_record_reset();
205 print_buffer(0, buf, 4, 5, 0);
206 ut_assert_nextline("00000000: 33221100 77665544 bbaa9988 ffeeddcc ..\"3DUfw........");
207 ut_assert_nextline("00000010: 00000010 ....");
208 ut_assert_console_end();
209
210
211 console_record_reset();
212 print_buffer(0, buf, 8, 3, 0);
213 ut_assert_nextline("00000000: 7766554433221100 ffeeddccbbaa9988 ..\"3DUfw........");
214 ut_assert_nextline("00000010: 0000000000000010 ........");
215 ut_assert_console_end();
216
217
218 console_record_reset();
219 buf[1] = 31;
220 buf[2] = 32;
221 buf[3] = 33;
222 for (i = 0; i < 4; i++)
223 buf[4 + i] = 126 + i;
224 buf[8] = 255;
225 print_buffer(0, buf, 1, 10, 0);
226 ut_assert_nextline("00000000: 00 1f 20 21 7e 7f 80 81 ff 99 .. !~.....");
227 ut_assert_console_end();
228
229 unmap_sysmem(buf);
230
231 return 0;
232}
233PRINT_TEST(print_display_buffer, UT_TESTF_CONSOLE_REC);
234
235static int print_hexdump_line(struct unit_test_state *uts)
236{
237 char *linebuf;
238 u8 *buf;
239 int i;
240
241 buf = map_sysmem(0, BUF_SIZE);
242 memset(buf, '\0', BUF_SIZE);
243 for (i = 0; i < 0x11; i++)
244 buf[i] = i * 0x11;
245
246
247 linebuf = map_sysmem(0x400, BUF_SIZE);
248 memset(linebuf, '\xff', BUF_SIZE);
249 ut_asserteq(-ENOSPC, hexdump_line(0, buf, 1, 0x10, 0, linebuf, 75));
250 ut_asserteq(-1, linebuf[0]);
251 ut_asserteq(0x10, hexdump_line(0, buf, 1, 0x10, 0, linebuf, 76));
252 ut_asserteq(0, linebuf[75]);
253 ut_asserteq(-1, linebuf[76]);
254
255 unmap_sysmem(buf);
256
257 return 0;
258}
259PRINT_TEST(print_hexdump_line, UT_TESTF_CONSOLE_REC);
260
261static int print_do_hex_dump(struct unit_test_state *uts)
262{
263 u8 *buf;
264 int i;
265
266 buf = map_sysmem(0, BUF_SIZE);
267 memset(buf, '\0', BUF_SIZE);
268 for (i = 0; i < 0x11; i++)
269 buf[i] = i * 0x11;
270
271
272 console_record_reset();
273 print_hex_dump_bytes("", DUMP_PREFIX_ADDRESS, buf, 0x12);
274 ut_assert_nextline("00000000: 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff ..\"3DUfw........");
275 ut_assert_nextline("00000010: 10 00 ..");
276 ut_assert_console_end();
277
278
279 console_record_reset();
280 print_hex_dump("", DUMP_PREFIX_ADDRESS, 8, 1, buf, 0x12, true);
281 ut_assert_nextline("00000000: 00 11 22 33 44 55 66 77 ..\"3DUfw");
282 ut_assert_nextline("00000008: 88 99 aa bb cc dd ee ff ........");
283 ut_assert_nextline("00000010: 10 00 ..");
284 ut_assert_console_end();
285 unmap_sysmem(buf);
286
287
288 console_record_reset();
289 buf[0x41] = 0x41;
290 print_hex_dump("", DUMP_PREFIX_ADDRESS, 0x40, 1, buf, 0x42, true);
291 ut_assert_nextline("00000000: 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff 10 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ..\"3DUfw........................................................");
292 ut_assert_nextline("00000040: 00 41 .A");
293 ut_assert_console_end();
294
295
296 console_record_reset();
297 print_hex_dump("", DUMP_PREFIX_ADDRESS, 0, 2, buf, 0x12, true);
298 ut_assert_nextline("00000000: 1100 3322 5544 7766 9988 bbaa ddcc ffee ..\"3DUfw........");
299 ut_assert_nextline("00000010: 0010 ..");
300 ut_assert_console_end();
301 unmap_sysmem(buf);
302
303
304 console_record_reset();
305 print_hex_dump("", DUMP_PREFIX_ADDRESS, 0, 4, buf, 0x14, true);
306 ut_assert_nextline("00000000: 33221100 77665544 bbaa9988 ffeeddcc ..\"3DUfw........");
307 ut_assert_nextline("00000010: 00000010 ....");
308 ut_assert_console_end();
309 unmap_sysmem(buf);
310
311
312 console_record_reset();
313 print_hex_dump("", DUMP_PREFIX_ADDRESS, 16, 8, buf, 0x18, true);
314 ut_assert_nextline("00000000: 7766554433221100 ffeeddccbbaa9988 ..\"3DUfw........");
315 ut_assert_nextline("00000010: 0000000000000010 ........");
316 ut_assert_console_end();
317 unmap_sysmem(buf);
318
319
320 console_record_reset();
321 buf[1] = 31;
322 buf[2] = 32;
323 buf[3] = 33;
324 for (i = 0; i < 4; i++)
325 buf[4 + i] = 126 + i;
326 buf[8] = 255;
327 print_hex_dump("", DUMP_PREFIX_ADDRESS, 0, 1, buf, 10, true);
328 ut_assert_nextline("00000000: 00 1f 20 21 7e 7f 80 81 ff 99 .. !~.....");
329 ut_assert_console_end();
330 unmap_sysmem(buf);
331
332 return 0;
333}
334PRINT_TEST(print_do_hex_dump, UT_TESTF_CONSOLE_REC);
335
336static int print_itoa(struct unit_test_state *uts)
337{
338 ut_asserteq_str("123", simple_itoa(123));
339 ut_asserteq_str("0", simple_itoa(0));
340 ut_asserteq_str("2147483647", simple_itoa(0x7fffffff));
341 ut_asserteq_str("4294967295", simple_itoa(0xffffffff));
342
343
344#ifdef CONFIG_PHYS_64BIT
345 if (sizeof(ulong) == 8) {
346 ut_asserteq_str("9223372036854775807",
347 simple_itoa((1UL << 63) - 1));
348 ut_asserteq_str("18446744073709551615", simple_itoa(-1));
349 }
350#endif
351
352 return 0;
353}
354PRINT_TEST(print_itoa, 0);
355
356static int snprint(struct unit_test_state *uts)
357{
358 char buf[10] = "xxxxxxxxx";
359 int ret;
360
361 ret = snprintf(buf, 4, "%s:%s", "abc", "def");
362 ut_asserteq(0, buf[3]);
363 ut_asserteq(7, ret);
364 ret = snprintf(buf, 4, "%s:%d", "abc", 9999);
365 ut_asserteq(8, ret);
366 return 0;
367}
368PRINT_TEST(snprint, 0);
369
370static int print_xtoa(struct unit_test_state *uts)
371{
372 ut_asserteq_str("7f", simple_xtoa(127));
373 ut_asserteq_str("00", simple_xtoa(0));
374 ut_asserteq_str("7fffffff", simple_xtoa(0x7fffffff));
375 ut_asserteq_str("ffffffff", simple_xtoa(0xffffffff));
376
377
378#ifdef CONFIG_PHYS_64BIT
379 if (sizeof(ulong) == 8) {
380 ut_asserteq_str("7fffffffffffffff",
381 simple_xtoa((1UL << 63) - 1));
382 ut_asserteq_str("ffffffffffffffff", simple_xtoa(-1));
383 }
384#endif
385
386 return 0;
387}
388PRINT_TEST(print_xtoa, 0);
389
390int do_ut_print(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
391{
392 struct unit_test *tests = UNIT_TEST_SUITE_START(print_test);
393 const int n_ents = UNIT_TEST_SUITE_COUNT(print_test);
394
395 return cmd_ut_category("print", "print_", tests, n_ents, argc, argv);
396}
397
