test: fit: Using variable 'old_dtb' before assignment

[u-boot.git] / test / print_ut.c

diff --git a/test/print_ut.c b/test/print_ut.c
index 247011f2db03af9c52e253daa0a7d12193121f0c..bb844d2542b7038da1020da724d987bb6fd9fca3 100644 (file)
--- a/test/print_ut.c
+++ b/test/print_ut.c
@@ -170,6 +170,10 @@ static int print_display_buffer(struct unit_test_state *uts)
        u8 *buf;
        int i;
 
+       /* This test requires writable memory at zero */
+       if (IS_ENABLED(CONFIG_X86))
+               return -EAGAIN;
+
        buf = map_sysmem(0, BUF_SIZE);
        memset(buf, '\0', BUF_SIZE);
        for (i = 0; i < 0x11; i++)
@@ -275,6 +279,10 @@ static int print_do_hex_dump(struct unit_test_state *uts)
        u8 *buf;
        int i;
 
+       /* This test requires writable memory at zero */
+       if (IS_ENABLED(CONFIG_X86))
+               return -EAGAIN;
+
        buf = map_sysmem(0, BUF_SIZE);
        memset(buf, '\0', BUF_SIZE);
        for (i = 0; i < 0x11; i++)
@@ -283,16 +291,21 @@ static int print_do_hex_dump(struct unit_test_state *uts)
        /* bytes */
        console_record_reset();
        print_hex_dump_bytes("", DUMP_PREFIX_ADDRESS, buf, 0x12);
-       ut_assert_nextline("00000000: 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff  ..\"3DUfw........");
-       ut_assert_nextline("00000010: 10 00                                            ..");
+       ut_assert_nextline("%0*lx: 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff  ..\"3DUfw........",
+                          IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x0UL);
+       ut_assert_nextline("%0*lx: 10 00                                            ..",
+                          IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x10UL);
        ut_assert_console_end();
 
        /* line length */
        console_record_reset();
        print_hex_dump("", DUMP_PREFIX_ADDRESS, 8, 1, buf, 0x12, true);
-       ut_assert_nextline("00000000: 00 11 22 33 44 55 66 77  ..\"3DUfw");
-       ut_assert_nextline("00000008: 88 99 aa bb cc dd ee ff  ........");
-       ut_assert_nextline("00000010: 10 00                    ..");
+       ut_assert_nextline("%0*lx: 00 11 22 33 44 55 66 77  ..\"3DUfw",
+                          IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x0UL);
+       ut_assert_nextline("%0*lx: 88 99 aa bb cc dd ee ff  ........",
+                          IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x8UL);
+       ut_assert_nextline("%0*lx: 10 00                    ..",
+                          IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x10UL);
        ut_assert_console_end();
        unmap_sysmem(buf);
 
@@ -300,31 +313,39 @@ static int print_do_hex_dump(struct unit_test_state *uts)
        console_record_reset();
        buf[0x41] = 0x41;
        print_hex_dump("", DUMP_PREFIX_ADDRESS, 0x40, 1, buf, 0x42, true);
-       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........................................................");
-       ut_assert_nextline("00000040: 00 41                                                                                                                                                                                            .A");
+       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........................................................",
+                          IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x0UL);
+       ut_assert_nextline("%0*lx: 00 41                                                                                                                                                                                            .A",
+                          IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x40UL);
        ut_assert_console_end();
 
        /* 16-bit */
        console_record_reset();
        print_hex_dump("", DUMP_PREFIX_ADDRESS, 0, 2, buf, 0x12, true);
-       ut_assert_nextline("00000000: 1100 3322 5544 7766 9988 bbaa ddcc ffee  ..\"3DUfw........");
-       ut_assert_nextline("00000010: 0010                                     ..");
+       ut_assert_nextline("%0*lx: 1100 3322 5544 7766 9988 bbaa ddcc ffee  ..\"3DUfw........",
+                          IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x0UL);
+       ut_assert_nextline("%0*lx: 0010                                     ..",
+                          IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x10UL);
        ut_assert_console_end();
        unmap_sysmem(buf);
 
        /* 32-bit */
        console_record_reset();
        print_hex_dump("", DUMP_PREFIX_ADDRESS, 0, 4, buf, 0x14, true);
-       ut_assert_nextline("00000000: 33221100 77665544 bbaa9988 ffeeddcc  ..\"3DUfw........");
-       ut_assert_nextline("00000010: 00000010                             ....");
+       ut_assert_nextline("%0*lx: 33221100 77665544 bbaa9988 ffeeddcc  ..\"3DUfw........",
+                          IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x0UL);
+       ut_assert_nextline("%0*lx: 00000010                             ....",
+                          IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x10UL);
        ut_assert_console_end();
        unmap_sysmem(buf);
 
        /* 64-bit */
        console_record_reset();
        print_hex_dump("", DUMP_PREFIX_ADDRESS, 16, 8, buf, 0x18, true);
-       ut_assert_nextline("00000000: 7766554433221100 ffeeddccbbaa9988  ..\"3DUfw........");
-       ut_assert_nextline("00000010: 0000000000000010                   ........");
+       ut_assert_nextline("%0*lx: 7766554433221100 ffeeddccbbaa9988  ..\"3DUfw........",
+                          IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x0UL);
+       ut_assert_nextline("%0*lx: 0000000000000010                   ........",
+                          IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x10UL);
        ut_assert_console_end();
        unmap_sysmem(buf);
 
@@ -337,7 +358,8 @@ static int print_do_hex_dump(struct unit_test_state *uts)
                buf[4 + i] = 126 + i;
        buf[8] = 255;
        print_hex_dump("", DUMP_PREFIX_ADDRESS, 0, 1, buf, 10, true);
-       ut_assert_nextline("00000000: 00 1f 20 21 7e 7f 80 81 ff 99                    .. !~.....");
+       ut_assert_nextline("%0*lx: 00 1f 20 21 7e 7f 80 81 ff 99                    .. !~.....",
+                          IS_ENABLED(CONFIG_PHYS_64BIT) ? 16 : 8, 0x0UL);
        ut_assert_console_end();
        unmap_sysmem(buf);
 
@@ -345,26 +367,6 @@ static int print_do_hex_dump(struct unit_test_state *uts)
 }
 PRINT_TEST(print_do_hex_dump, UT_TESTF_CONSOLE_REC);
 
-static int print_itoa(struct unit_test_state *uts)
-{
-       ut_asserteq_str("123", simple_itoa(123));
-       ut_asserteq_str("0", simple_itoa(0));
-       ut_asserteq_str("2147483647", simple_itoa(0x7fffffff));
-       ut_asserteq_str("4294967295", simple_itoa(0xffffffff));
-
-       /* Use #ifdef here to avoid a compiler warning on 32-bit machines */
-#ifdef CONFIG_PHYS_64BIT
-       if (sizeof(ulong) == 8) {
-               ut_asserteq_str("9223372036854775807",
-                               simple_itoa((1UL << 63) - 1));
-               ut_asserteq_str("18446744073709551615", simple_itoa(-1));
-       }
-#endif /* CONFIG_PHYS_64BIT */
-
-       return 0;
-}
-PRINT_TEST(print_itoa, 0);
-
 static int snprint(struct unit_test_state *uts)
 {
        char buf[10] = "xxxxxxxxx";
@@ -391,26 +393,6 @@ static int snprint(struct unit_test_state *uts)
 }
 PRINT_TEST(snprint, 0);
 
-static int print_xtoa(struct unit_test_state *uts)
-{
-       ut_asserteq_str("7f", simple_xtoa(127));
-       ut_asserteq_str("00", simple_xtoa(0));
-       ut_asserteq_str("7fffffff", simple_xtoa(0x7fffffff));
-       ut_asserteq_str("ffffffff", simple_xtoa(0xffffffff));
-
-       /* Use #ifdef here to avoid a compiler warning on 32-bit machines */
-#ifdef CONFIG_PHYS_64BIT
-       if (sizeof(ulong) == 8) {
-               ut_asserteq_str("7fffffffffffffff",
-                               simple_xtoa((1UL << 63) - 1));
-               ut_asserteq_str("ffffffffffffffff", simple_xtoa(-1));
-       }
-#endif /* CONFIG_PHYS_64BIT */
-
-       return 0;
-}
-PRINT_TEST(print_xtoa, 0);
-
 int do_ut_print(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 {
        struct unit_test *tests = UNIT_TEST_SUITE_START(print_test);