1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (c) 2012, The Chromium Authors
9 #include <display_options.h>
12 #include <version_string.h>
14 #include <test/suites.h>
15 #include <test/test.h>
18 #define BUF_SIZE 0x100
20 #define FAKE_BUILD_TAG "jenkins-u-boot-denx_uboot_dm-master-build-aarch64" \
21 "and a lot more text to come"
23 /* Declare a new print test */
24 #define PRINT_TEST(_name, _flags) UNIT_TEST(_name, _flags, print_test)
26 #if CONFIG_IS_ENABLED(LIB_UUID)
27 /* Test printing GUIDs */
28 static int print_guid(struct unit_test_state
*uts
)
30 unsigned char guid
[16] = {
31 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
33 unsigned char guid_esp
[16] = {
34 0x28, 0x73, 0x2a, 0xc1, 0x1f, 0xf8, 0xd2, 0x11,
35 0xBA, 0x4B, 0x00, 0xA0, 0xC9, 0x3E, 0xC9, 0x3B
40 sprintf(str
, "%pUb", guid
);
41 ut_asserteq_str("01020304-0506-0708-090a-0b0c0d0e0f10", str
);
42 sprintf(str
, "%pUB", guid
);
43 ut_asserteq_str("01020304-0506-0708-090A-0B0C0D0E0F10", str
);
44 sprintf(str
, "%pUl", guid
);
45 ut_asserteq_str("04030201-0605-0807-090a-0b0c0d0e0f10", str
);
46 sprintf(str
, "%pUs", guid
);
47 ut_asserteq_str("04030201-0605-0807-090a-0b0c0d0e0f10", str
);
48 sprintf(str
, "%pUL", guid
);
49 ut_asserteq_str("04030201-0605-0807-090A-0B0C0D0E0F10", str
);
50 sprintf(str
, "%pUs", guid_esp
);
51 if (IS_ENABLED(CONFIG_PARTITION_TYPE_GUID
)) { /* brace needed */
52 ut_asserteq_str("system", str
);
54 ut_asserteq_str("c12a7328-f81f-11d2-ba4b-00a0c93ec93b", str
);
56 ret
= snprintf(str
, 4, "%pUL", guid
);
57 ut_asserteq(0, str
[3]);
62 PRINT_TEST(print_guid
, 0);
65 #if CONFIG_IS_ENABLED(EFI_LOADER) && !defined(API_BUILD)
66 /* Test efi_loader specific printing */
67 static int print_efi_ut(struct unit_test_state
*uts
)
70 u8 buf
[sizeof(struct efi_device_path_sd_mmc_path
) +
71 sizeof(struct efi_device_path
)];
73 struct efi_device_path
*dp_end
;
74 struct efi_device_path_sd_mmc_path
*dp_sd
=
75 (struct efi_device_path_sd_mmc_path
*)pos
;
77 /* Create a device path for an SD card */
78 dp_sd
->dp
.type
= DEVICE_PATH_TYPE_MESSAGING_DEVICE
;
79 dp_sd
->dp
.sub_type
= DEVICE_PATH_SUB_TYPE_MSG_SD
;
80 dp_sd
->dp
.length
= sizeof(struct efi_device_path_sd_mmc_path
);
81 dp_sd
->slot_number
= 3;
82 pos
+= sizeof(struct efi_device_path_sd_mmc_path
);
84 dp_end
= (struct efi_device_path
*)pos
;
85 dp_end
->type
= DEVICE_PATH_TYPE_END
;
86 dp_end
->sub_type
= DEVICE_PATH_SUB_TYPE_END
;
87 dp_end
->length
= sizeof(struct efi_device_path
);
89 snprintf(str
, sizeof(str
), "_%pD_", buf
);
90 ut_assertok(strcmp("_/SD(3)_", str
));
92 /* NULL device path */
93 snprintf(str
, sizeof(str
), "_%pD_", NULL
);
94 ut_assertok(strcmp("_<NULL>_", str
));
98 PRINT_TEST(print_efi_ut
, 0);
101 static int print_printf(struct unit_test_state
*uts
)
108 snprintf(str
, sizeof(str
), "testing");
109 ut_assertok(strcmp("testing", str
));
111 snprintf(str
, sizeof(str
), "testing but too long");
112 ut_assertok(strcmp("testing b", str
));
114 snprintf(str
, 1, "testing none");
115 ut_assertok(strcmp("", str
));
118 snprintf(str
, 0, "testing none");
119 ut_asserteq('x', *str
);
121 sprintf(big_str
, "_%ls_", u
"foo");
122 ut_assertok(strcmp("_foo_", big_str
));
124 /* Test the banner function */
125 s
= display_options_get_banner(true, str
, sizeof(str
));
126 ut_asserteq_ptr(str
, s
);
127 ut_assertok(strcmp("\n\nU-Boo\n\n", s
));
129 /* Assert that we do not overwrite memory before the buffer */
131 s
= display_options_get_banner(true, str
+ 1, 1);
132 ut_asserteq_ptr(str
+ 1, s
);
133 ut_assertok(strcmp("`", str
));
136 s
= display_options_get_banner(true, str
+ 1, 2);
137 ut_asserteq_ptr(str
+ 1, s
);
138 ut_assertok(strcmp("~\n", str
));
140 /* The last two characters are set to \n\n for all buffer sizes > 2 */
141 s
= display_options_get_banner(false, str
, sizeof(str
));
142 ut_asserteq_ptr(str
, s
);
143 ut_assertok(strcmp("U-Boot \n\n", s
));
145 /* Give it enough space for some of the version */
146 big_str_len
= strlen(version_string
) - 5;
147 s
= display_options_get_banner_priv(false, FAKE_BUILD_TAG
, big_str
,
149 ut_asserteq_ptr(big_str
, s
);
150 ut_assertok(strncmp(version_string
, s
, big_str_len
- 3));
151 ut_assertok(strcmp("\n\n", s
+ big_str_len
- 3));
153 /* Give it enough space for the version and some of the build tag */
154 big_str_len
= strlen(version_string
) + 9 + 20;
155 s
= display_options_get_banner_priv(false, FAKE_BUILD_TAG
, big_str
,
157 ut_asserteq_ptr(big_str
, s
);
158 len
= strlen(version_string
);
159 ut_assertok(strncmp(version_string
, s
, len
));
160 ut_assertok(strncmp(", Build: ", s
+ len
, 9));
161 ut_assertok(strncmp(FAKE_BUILD_TAG
, s
+ 9 + len
, 12));
162 ut_assertok(strcmp("\n\n", s
+ big_str_len
- 3));
166 PRINT_TEST(print_printf
, 0);
168 static int print_display_buffer(struct unit_test_state
*uts
)
173 /* This test requires writable memory at zero */
174 if (IS_ENABLED(CONFIG_X86
))
177 buf
= map_sysmem(0, BUF_SIZE
);
178 memset(buf
, '\0', BUF_SIZE
);
179 for (i
= 0; i
< 0x11; i
++)
183 console_record_reset();
184 print_buffer(0, buf
, 1, 0x12, 0);
185 ut_assert_nextline("00000000: 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff ..\"3DUfw........");
186 ut_assert_nextline("00000010: 10 00 ..");
187 ut_assert_console_end();
190 console_record_reset();
191 print_buffer(0, buf
, 1, 0x12, 8);
192 ut_assert_nextline("00000000: 00 11 22 33 44 55 66 77 ..\"3DUfw");
193 ut_assert_nextline("00000008: 88 99 aa bb cc dd ee ff ........");
194 ut_assert_nextline("00000010: 10 00 ..");
195 ut_assert_console_end();
198 console_record_reset();
200 print_buffer(0, buf
, 1, 0x42, 0x40);
201 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........................................................");
202 ut_assert_nextline("00000040: 00 41 .A");
203 ut_assert_console_end();
206 console_record_reset();
207 print_buffer(0x12345678, buf
, 1, 0x12, 0);
208 ut_assert_nextline("12345678: 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff ..\"3DUfw........");
209 ut_assert_nextline("12345688: 10 00 ..");
210 ut_assert_console_end();
213 console_record_reset();
214 print_buffer(0, buf
, 2, 9, 0);
215 ut_assert_nextline("00000000: 1100 3322 5544 7766 9988 bbaa ddcc ffee ..\"3DUfw........");
216 ut_assert_nextline("00000010: 0010 ..");
217 ut_assert_console_end();
220 console_record_reset();
221 print_buffer(0, buf
, 4, 5, 0);
222 ut_assert_nextline("00000000: 33221100 77665544 bbaa9988 ffeeddcc ..\"3DUfw........");
223 ut_assert_nextline("00000010: 00000010 ....");
224 ut_assert_console_end();
227 console_record_reset();
228 print_buffer(0, buf
, 8, 3, 0);
229 ut_assert_nextline("00000000: 7766554433221100 ffeeddccbbaa9988 ..\"3DUfw........");
230 ut_assert_nextline("00000010: 0000000000000010 ........");
231 ut_assert_console_end();
234 console_record_reset();
238 for (i
= 0; i
< 4; i
++)
239 buf
[4 + i
] = 126 + i
;
241 print_buffer(0, buf
, 1, 10, 0);
242 ut_assert_nextline("00000000: 00 1f 20 21 7e 7f 80 81 ff 99 .. !~.....");
243 ut_assert_console_end();
249 PRINT_TEST(print_display_buffer
, UT_TESTF_CONSOLE_REC
);
251 static int print_hexdump_line(struct unit_test_state
*uts
)
257 buf
= map_sysmem(0, BUF_SIZE
);
258 memset(buf
, '\0', BUF_SIZE
);
259 for (i
= 0; i
< 0x11; i
++)
262 /* Check buffer size calculations */
263 linebuf
= map_sysmem(0x400, BUF_SIZE
);
264 memset(linebuf
, '\xff', BUF_SIZE
);
265 ut_asserteq(-ENOSPC
, hexdump_line(0, buf
, 1, 0x10, 0, linebuf
, 75));
266 ut_asserteq(-1, linebuf
[0]);
267 ut_asserteq(0x10, hexdump_line(0, buf
, 1, 0x10, 0, linebuf
, 76));
268 ut_asserteq(0, linebuf
[75]);
269 ut_asserteq(-1, linebuf
[76]);
275 PRINT_TEST(print_hexdump_line
, UT_TESTF_CONSOLE_REC
);
277 static int print_do_hex_dump(struct unit_test_state
*uts
)
282 /* This test requires writable memory at zero */
283 if (IS_ENABLED(CONFIG_X86
))
286 buf
= map_sysmem(0, BUF_SIZE
);
287 memset(buf
, '\0', BUF_SIZE
);
288 for (i
= 0; i
< 0x11; i
++)
292 console_record_reset();
293 print_hex_dump_bytes("", DUMP_PREFIX_ADDRESS
, buf
, 0x12);
294 ut_assert_nextline("%0*lx: 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff ..\"3DUfw........",
295 IS_ENABLED(CONFIG_PHYS_64BIT
) ? 16 : 8, 0x0UL
);
296 ut_assert_nextline("%0*lx: 10 00 ..",
297 IS_ENABLED(CONFIG_PHYS_64BIT
) ? 16 : 8, 0x10UL
);
298 ut_assert_console_end();
301 console_record_reset();
302 print_hex_dump("", DUMP_PREFIX_ADDRESS
, 8, 1, buf
, 0x12, true);
303 ut_assert_nextline("%0*lx: 00 11 22 33 44 55 66 77 ..\"3DUfw",
304 IS_ENABLED(CONFIG_PHYS_64BIT
) ? 16 : 8, 0x0UL
);
305 ut_assert_nextline("%0*lx: 88 99 aa bb cc dd ee ff ........",
306 IS_ENABLED(CONFIG_PHYS_64BIT
) ? 16 : 8, 0x8UL
);
307 ut_assert_nextline("%0*lx: 10 00 ..",
308 IS_ENABLED(CONFIG_PHYS_64BIT
) ? 16 : 8, 0x10UL
);
309 ut_assert_console_end();
313 console_record_reset();
315 print_hex_dump("", DUMP_PREFIX_ADDRESS
, 0x40, 1, buf
, 0x42, true);
316 ut_assert_nextline("%0*lx: 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........................................................",
317 IS_ENABLED(CONFIG_PHYS_64BIT
) ? 16 : 8, 0x0UL
);
318 ut_assert_nextline("%0*lx: 00 41 .A",
319 IS_ENABLED(CONFIG_PHYS_64BIT
) ? 16 : 8, 0x40UL
);
320 ut_assert_console_end();
323 console_record_reset();
324 print_hex_dump("", DUMP_PREFIX_ADDRESS
, 0, 2, buf
, 0x12, true);
325 ut_assert_nextline("%0*lx: 1100 3322 5544 7766 9988 bbaa ddcc ffee ..\"3DUfw........",
326 IS_ENABLED(CONFIG_PHYS_64BIT
) ? 16 : 8, 0x0UL
);
327 ut_assert_nextline("%0*lx: 0010 ..",
328 IS_ENABLED(CONFIG_PHYS_64BIT
) ? 16 : 8, 0x10UL
);
329 ut_assert_console_end();
333 console_record_reset();
334 print_hex_dump("", DUMP_PREFIX_ADDRESS
, 0, 4, buf
, 0x14, true);
335 ut_assert_nextline("%0*lx: 33221100 77665544 bbaa9988 ffeeddcc ..\"3DUfw........",
336 IS_ENABLED(CONFIG_PHYS_64BIT
) ? 16 : 8, 0x0UL
);
337 ut_assert_nextline("%0*lx: 00000010 ....",
338 IS_ENABLED(CONFIG_PHYS_64BIT
) ? 16 : 8, 0x10UL
);
339 ut_assert_console_end();
343 console_record_reset();
344 print_hex_dump("", DUMP_PREFIX_ADDRESS
, 16, 8, buf
, 0x18, true);
345 ut_assert_nextline("%0*lx: 7766554433221100 ffeeddccbbaa9988 ..\"3DUfw........",
346 IS_ENABLED(CONFIG_PHYS_64BIT
) ? 16 : 8, 0x0UL
);
347 ut_assert_nextline("%0*lx: 0000000000000010 ........",
348 IS_ENABLED(CONFIG_PHYS_64BIT
) ? 16 : 8, 0x10UL
);
349 ut_assert_console_end();
353 console_record_reset();
357 for (i
= 0; i
< 4; i
++)
358 buf
[4 + i
] = 126 + i
;
360 print_hex_dump("", DUMP_PREFIX_ADDRESS
, 0, 1, buf
, 10, true);
361 ut_assert_nextline("%0*lx: 00 1f 20 21 7e 7f 80 81 ff 99 .. !~.....",
362 IS_ENABLED(CONFIG_PHYS_64BIT
) ? 16 : 8, 0x0UL
);
363 ut_assert_console_end();
368 PRINT_TEST(print_do_hex_dump
, UT_TESTF_CONSOLE_REC
);
370 static int snprint(struct unit_test_state
*uts
)
372 char buf
[10] = "xxxxxxxxx";
375 ret
= snprintf(buf
, 5, "%d", 12345678);
376 ut_asserteq_str("1234", buf
);
378 ret
= snprintf(buf
, 5, "0x%x", 0x1234);
379 ut_asserteq_str("0x12", buf
);
381 ret
= snprintf(buf
, 5, "0x%08x", 0x1234);
382 ut_asserteq_str("0x00", buf
);
383 ut_asserteq(10, ret
);
384 ret
= snprintf(buf
, 3, "%s", "abc");
385 ut_asserteq_str("ab", buf
);
387 ret
= snprintf(buf
, 4, "%s:%s", "abc", "def");
388 ut_asserteq(0, buf
[3]);
390 ret
= snprintf(buf
, 4, "%s:%d", "abc", 9999);
394 PRINT_TEST(snprint
, 0);
396 int do_ut_print(struct cmd_tbl
*cmdtp
, int flag
, int argc
, char *const argv
[])
398 struct unit_test
*tests
= UNIT_TEST_SUITE_START(print_test
);
399 const int n_ents
= UNIT_TEST_SUITE_COUNT(print_test
);
401 return cmd_ut_category("print", "print_", tests
, n_ents
, argc
, argv
);