ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Bugfixes for the implementation and the compliance test 

In the implementation, don't always display double hex digits when
printing with "%X". This is in line with the behaviour observed both
in mbed OS's printf (Newlib) and Linux's printf (glibc).
In the tests, always compare the baseline result with the result
returned by the minimal printf implementation, instead of comparing
with a constant value.
pull/11051/head
Bogdan Marinescu 2018-04-25 22:31:16 +03:00
parent fbbffd613e
commit 362dd3fbcf
2 changed files with 70 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

118
features/minimal-printf/TESTS/minimal-printf/compliance/main.cpp
View File

@ -95,11 +95,11 @@ static control_t test_printf_d(const size_t call_count)
#else #else
result_minimal = mbed_printf("jd: %jd\r\n", INT32_MIN); result_minimal = mbed_printf("jd: %jd\r\n", INT32_MIN);
result_baseline = printf("jd: %jd\r\n", (intmax_t) INT32_MIN); result_baseline = printf("jd: %jd\r\n", (intmax_t) INT32_MIN);
TEST_ASSERT_EQUAL_INT(17, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_printf("jd: %jd\r\n", INT32_MAX); result_minimal = mbed_printf("jd: %jd\r\n", INT32_MAX);
result_baseline = printf("jd: %jd\r\n", (intmax_t) INT32_MAX); result_baseline = printf("jd: %jd\r\n", (intmax_t) INT32_MAX);
TEST_ASSERT_EQUAL_INT(16, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
#endif #endif
#ifdef TARGET_LIKE_MBED #ifdef TARGET_LIKE_MBED
@ -107,11 +107,11 @@ static control_t test_printf_d(const size_t call_count)
#else #else
result_minimal = mbed_printf("zd: %zd\r\n", INT32_MIN); result_minimal = mbed_printf("zd: %zd\r\n", INT32_MIN);
result_baseline = printf("zd: %zd\r\n", (ssize_t) INT32_MIN); result_baseline = printf("zd: %zd\r\n", (ssize_t) INT32_MIN);
TEST_ASSERT_EQUAL_INT(17, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_printf("zd: %zd\r\n", INT32_MAX); result_minimal = mbed_printf("zd: %zd\r\n", INT32_MAX);
result_baseline = printf("zd: %zd\r\n", (ssize_t) INT32_MAX); result_baseline = printf("zd: %zd\r\n", (ssize_t) INT32_MAX);
TEST_ASSERT_EQUAL_INT(16, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
#endif #endif
#ifdef TARGET_LIKE_MBED #ifdef TARGET_LIKE_MBED
@ -119,11 +119,11 @@ static control_t test_printf_d(const size_t call_count)
#else #else
result_minimal = mbed_printf("td: %td\r\n", PTRDIFF_MIN); result_minimal = mbed_printf("td: %td\r\n", PTRDIFF_MIN);
result_baseline = printf("td: %td\r\n", PTRDIFF_MIN); result_baseline = printf("td: %td\r\n", PTRDIFF_MIN);
TEST_ASSERT_EQUAL_INT(17, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_printf("td: %td\r\n", PTRDIFF_MAX); result_minimal = mbed_printf("td: %td\r\n", PTRDIFF_MAX);
result_baseline = printf("td: %td\r\n", PTRDIFF_MAX); result_baseline = printf("td: %td\r\n", PTRDIFF_MAX);
TEST_ASSERT_EQUAL_INT(16, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
#endif #endif
return CaseNext; return CaseNext;
@ -181,11 +181,11 @@ static control_t test_printf_u(const size_t call_count)
#else #else
result_minimal = mbed_printf("ju: %ju\r\n", 0); result_minimal = mbed_printf("ju: %ju\r\n", 0);
result_baseline = printf("ju: %ju\r\n",(uintmax_t) 0); result_baseline = printf("ju: %ju\r\n",(uintmax_t) 0);
TEST_ASSERT_EQUAL_INT(7, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_printf("ju: %ju\r\n", UINTMAX_MAX); result_minimal = mbed_printf("ju: %ju\r\n", UINTMAX_MAX);
result_baseline = printf("ju: %ju\r\n", UINTMAX_MAX); result_baseline = printf("ju: %ju\r\n", UINTMAX_MAX);
TEST_ASSERT_EQUAL_INT(7, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
#endif #endif
#ifdef TARGET_LIKE_MBED #ifdef TARGET_LIKE_MBED
@ -193,11 +193,11 @@ static control_t test_printf_u(const size_t call_count)
#else #else
result_minimal = mbed_printf("zu: %zu\r\n", 0); result_minimal = mbed_printf("zu: %zu\r\n", 0);
result_baseline = printf("zu: %zu\r\n", 0); result_baseline = printf("zu: %zu\r\n", 0);
TEST_ASSERT_EQUAL_INT(7, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_printf("zu: %zu\r\n", SIZE_MAX); result_minimal = mbed_printf("zu: %zu\r\n", SIZE_MAX);
result_baseline = printf("zu: %zu\r\n", SIZE_MAX); result_baseline = printf("zu: %zu\r\n", SIZE_MAX);
TEST_ASSERT_EQUAL_INT(16, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
#endif #endif
#ifdef TARGET_LIKE_MBED #ifdef TARGET_LIKE_MBED
@ -205,11 +205,11 @@ static control_t test_printf_u(const size_t call_count)
#else #else
result_minimal = mbed_printf("tu: %tu\r\n", 0); result_minimal = mbed_printf("tu: %tu\r\n", 0);
result_baseline = printf("tu: %tu\r\n", 0); result_baseline = printf("tu: %tu\r\n", 0);
TEST_ASSERT_EQUAL_INT(7, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_printf("tu: %tu\r\n", UINTPTR_MAX); result_minimal = mbed_printf("tu: %tu\r\n", UINTPTR_MAX);
result_baseline = printf("tu: %tu\r\n", UINTPTR_MAX); result_baseline = printf("tu: %tu\r\n", UINTPTR_MAX);
TEST_ASSERT_EQUAL_INT(26, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
#endif #endif
return CaseNext; return CaseNext;
@ -222,11 +222,9 @@ static control_t test_printf_x(const size_t call_count)
/*************************************************************************/ /*************************************************************************/
/*************************************************************************/ /*************************************************************************/
printf("%%x always prints even characters\r\n");
result_minimal = mbed_printf("hhX: %hhX\r\n", 0); result_minimal = mbed_printf("hhX: %hhX\r\n", 0);
result_baseline = printf("hhX: %hhX\r\n", 0); result_baseline = printf("hhX: %hhX\r\n", 0);
TEST_ASSERT_EQUAL_INT(9, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_printf("hhX: %hhX\r\n", UCHAR_MAX); result_minimal = mbed_printf("hhX: %hhX\r\n", UCHAR_MAX);
result_baseline = printf("hhX: %hhX\r\n", UCHAR_MAX); result_baseline = printf("hhX: %hhX\r\n", UCHAR_MAX);
@ -234,7 +232,7 @@ static control_t test_printf_x(const size_t call_count)
result_minimal = mbed_printf("hX: %hX\r\n", 0); result_minimal = mbed_printf("hX: %hX\r\n", 0);
result_baseline = printf("hX: %hX\r\n", 0); result_baseline = printf("hX: %hX\r\n", 0);
TEST_ASSERT_EQUAL_INT(8, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_printf("hX: %hX\r\n", USHRT_MAX); result_minimal = mbed_printf("hX: %hX\r\n", USHRT_MAX);
result_baseline = printf("hX: %hX\r\n", USHRT_MAX); result_baseline = printf("hX: %hX\r\n", USHRT_MAX);
@ -242,7 +240,7 @@ static control_t test_printf_x(const size_t call_count)
result_minimal = mbed_printf("X: %X\r\n", 0); result_minimal = mbed_printf("X: %X\r\n", 0);
result_baseline = printf("X: %X\r\n", 0); result_baseline = printf("X: %X\r\n", 0);
TEST_ASSERT_EQUAL_INT(7, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_printf("X: %X\r\n", UINT_MAX); result_minimal = mbed_printf("X: %X\r\n", UINT_MAX);
result_baseline = printf("X: %X\r\n", UINT_MAX); result_baseline = printf("X: %X\r\n", UINT_MAX);
@ -250,7 +248,7 @@ static control_t test_printf_x(const size_t call_count)
result_minimal = mbed_printf("lX: %lX\r\n", 0); result_minimal = mbed_printf("lX: %lX\r\n", 0);
result_baseline = printf("lX: %lX\r\n", 0UL); result_baseline = printf("lX: %lX\r\n", 0UL);
TEST_ASSERT_EQUAL_INT(8, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_printf("lX: %lX\r\n", ULONG_MAX); result_minimal = mbed_printf("lX: %lX\r\n", ULONG_MAX);
result_baseline = printf("lX: %lX\r\n", ULONG_MAX); result_baseline = printf("lX: %lX\r\n", ULONG_MAX);
@ -258,7 +256,7 @@ static control_t test_printf_x(const size_t call_count)
result_minimal = mbed_printf("llX: %llX\r\n", 0); result_minimal = mbed_printf("llX: %llX\r\n", 0);
result_baseline = printf("llX: %llX\r\n", 0ULL); result_baseline = printf("llX: %llX\r\n", 0ULL);
TEST_ASSERT_EQUAL_INT(9, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_printf("llX: %llX\r\n", ULLONG_MAX); result_minimal = mbed_printf("llX: %llX\r\n", ULLONG_MAX);
result_baseline = printf("llX: %llX\r\n", ULLONG_MAX); result_baseline = printf("llX: %llX\r\n", ULLONG_MAX);
@ -269,11 +267,11 @@ static control_t test_printf_x(const size_t call_count)
#else #else
result_minimal = mbed_printf("jX: %jX\r\n", 0); result_minimal = mbed_printf("jX: %jX\r\n", 0);
result_baseline = printf("jX: %jX\r\n", (uintmax_t) 0); result_baseline = printf("jX: %jX\r\n", (uintmax_t) 0);
TEST_ASSERT_EQUAL_INT(8, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_printf("jX: %jX\r\n", UINTMAX_MAX); result_minimal = mbed_printf("jX: %jX\r\n", UINTMAX_MAX);
result_baseline = printf("jX: %jX\r\n", UINTMAX_MAX); result_baseline = printf("jX: %jX\r\n", UINTMAX_MAX);
TEST_ASSERT_EQUAL_INT(8, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
#endif #endif
#ifdef TARGET_LIKE_MBED #ifdef TARGET_LIKE_MBED
@ -281,11 +279,11 @@ static control_t test_printf_x(const size_t call_count)
#else #else
result_minimal = mbed_printf("zX: %zX\r\n", 0); result_minimal = mbed_printf("zX: %zX\r\n", 0);
result_baseline = printf("zX: %zX\r\n", 0); result_baseline = printf("zX: %zX\r\n", 0);
TEST_ASSERT_EQUAL_INT(8, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_printf("zX: %zX\r\n", SIZE_MAX); result_minimal = mbed_printf("zX: %zX\r\n", SIZE_MAX);
result_baseline = printf("zX: %zX\r\n", SIZE_MAX); result_baseline = printf("zX: %zX\r\n", SIZE_MAX);
TEST_ASSERT_EQUAL_INT(14, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
#endif #endif
#ifdef TARGET_LIKE_MBED #ifdef TARGET_LIKE_MBED
@ -293,11 +291,11 @@ static control_t test_printf_x(const size_t call_count)
#else #else
result_minimal = mbed_printf("tX: %tX\r\n", 0); result_minimal = mbed_printf("tX: %tX\r\n", 0);
result_baseline = printf("tX: %tX\r\n", 0); result_baseline = printf("tX: %tX\r\n", 0);
TEST_ASSERT_EQUAL_INT(8, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_printf("tX: %tX\r\n", UINTPTR_MAX); result_minimal = mbed_printf("tX: %tX\r\n", UINTPTR_MAX);
result_baseline = printf("tX: %tX\r\n", UINTPTR_MAX); result_baseline = printf("tX: %tX\r\n", UINTPTR_MAX);
TEST_ASSERT_EQUAL_INT(22, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
#endif #endif
return CaseNext; return CaseNext;
@ -374,12 +372,12 @@ static control_t test_snprintf_d(const size_t call_count)
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "jd: %jd\r\n", INT32_MIN); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "jd: %jd\r\n", INT32_MIN);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "jd: %jd\r\n", (intmax_t) INT32_MIN); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "jd: %jd\r\n", (intmax_t) INT32_MIN);
TEST_ASSERT_EQUAL_STRING("jd: -2147483648\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("jd: -2147483648\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(17, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "jd: %jd\r\n", INT32_MAX); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "jd: %jd\r\n", INT32_MAX);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "jd: %jd\r\n", (intmax_t) INT32_MAX); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "jd: %jd\r\n", (intmax_t) INT32_MAX);
TEST_ASSERT_EQUAL_STRING("jd: 2147483647\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("jd: 2147483647\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(16, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
#endif #endif
#ifdef TARGET_LIKE_MBED #ifdef TARGET_LIKE_MBED
@ -388,12 +386,12 @@ static control_t test_snprintf_d(const size_t call_count)
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zd: %zd\r\n", INT32_MIN); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zd: %zd\r\n", INT32_MIN);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zd: %zd\r\n", (ssize_t) INT32_MIN); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zd: %zd\r\n", (ssize_t) INT32_MIN);
TEST_ASSERT_EQUAL_STRING("zd: -2147483648\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("zd: -2147483648\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(17, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zd: %zd\r\n", INT32_MAX); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zd: %zd\r\n", INT32_MAX);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zd: %zd\r\n", (ssize_t) INT32_MAX); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zd: %zd\r\n", (ssize_t) INT32_MAX);
TEST_ASSERT_EQUAL_STRING("zd: 2147483647\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("zd: 2147483647\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(16, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
#endif #endif
#ifdef TARGET_LIKE_MBED #ifdef TARGET_LIKE_MBED
@ -402,12 +400,12 @@ static control_t test_snprintf_d(const size_t call_count)
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "td: %td\r\n", PTRDIFF_MIN); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "td: %td\r\n", PTRDIFF_MIN);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "td: %td\r\n", PTRDIFF_MIN); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "td: %td\r\n", PTRDIFF_MIN);
TEST_ASSERT_EQUAL_STRING("td: -2147483648\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("td: -2147483648\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(17, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "td: %td\r\n", PTRDIFF_MAX); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "td: %td\r\n", PTRDIFF_MAX);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "td: %td\r\n", PTRDIFF_MAX); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "td: %td\r\n", PTRDIFF_MAX);
TEST_ASSERT_EQUAL_STRING("td: 2147483647\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("td: 2147483647\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(16, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
#endif #endif
return CaseNext; return CaseNext;
@ -478,12 +476,12 @@ static control_t test_snprintf_u(const size_t call_count)
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "ju: %ju\r\n", 0); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "ju: %ju\r\n", 0);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "ju: %ju\r\n", (uintmax_t) 0); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "ju: %ju\r\n", (uintmax_t) 0);
TEST_ASSERT_EQUAL_STRING("ju: 0\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("ju: 0\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(7, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "ju: %ju\r\n", UINTMAX_MAX); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "ju: %ju\r\n", UINTMAX_MAX);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "ju: %ju\r\n", UINTMAX_MAX); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "ju: %ju\r\n", UINTMAX_MAX);
TEST_ASSERT_EQUAL_STRING("ju: 0\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("ju: 0\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(7, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
#endif #endif
#ifdef TARGET_LIKE_MBED #ifdef TARGET_LIKE_MBED
@ -492,12 +490,12 @@ static control_t test_snprintf_u(const size_t call_count)
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zu: %zu\r\n", 0); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zu: %zu\r\n", 0);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zu: %zu\r\n", 0); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zu: %zu\r\n", 0);
TEST_ASSERT_EQUAL_STRING("zu: 0\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("zu: 0\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(7, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zu: %zu\r\n", SIZE_MAX); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zu: %zu\r\n", SIZE_MAX);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zu: %zu\r\n", SIZE_MAX); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zu: %zu\r\n", SIZE_MAX);
TEST_ASSERT_EQUAL_STRING("zu: 4294967295\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("zu: 4294967295\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(16, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
#endif #endif
#ifdef TARGET_LIKE_MBED #ifdef TARGET_LIKE_MBED
@ -506,12 +504,12 @@ static control_t test_snprintf_u(const size_t call_count)
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "tu: %tu\r\n", 0); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "tu: %tu\r\n", 0);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "tu: %tu\r\n", 0); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "tu: %tu\r\n", 0);
TEST_ASSERT_EQUAL_STRING("tu: 0\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("tu: 0\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(7, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "tu: %tu\r\n", UINTPTR_MAX); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "tu: %tu\r\n", UINTPTR_MAX);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "tu: %tu\r\n", UINTPTR_MAX); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "tu: %tu\r\n", UINTPTR_MAX);
TEST_ASSERT_EQUAL_STRING("tu: 18446744073709551615\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("tu: 18446744073709551615\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(26, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
#endif #endif
return CaseNext; return CaseNext;
@ -526,12 +524,10 @@ static control_t test_snprintf_x(const size_t call_count)
/*************************************************************************/ /*************************************************************************/
/*************************************************************************/ /*************************************************************************/
printf("%%x always prints even characters\r\n");
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hhX: %hhX\r\n", 0); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hhX: %hhX\r\n", 0);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhX: %hhX\r\n", 0); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhX: %hhX\r\n", 0);
TEST_ASSERT_EQUAL_STRING("hhX: 00\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("hhX: 0\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(9, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hhX: %hhX\r\n", UCHAR_MAX); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hhX: %hhX\r\n", UCHAR_MAX);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhX: %hhX\r\n", UCHAR_MAX); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hhX: %hhX\r\n", UCHAR_MAX);
@ -540,8 +536,8 @@ static control_t test_snprintf_x(const size_t call_count)
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hX: %hX\r\n", 0); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hX: %hX\r\n", 0);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hX: %hX\r\n", 0); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hX: %hX\r\n", 0);
TEST_ASSERT_EQUAL_STRING("hX: 00\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("hX: 0\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(8, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hX: %hX\r\n", USHRT_MAX); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "hX: %hX\r\n", USHRT_MAX);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hX: %hX\r\n", USHRT_MAX); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "hX: %hX\r\n", USHRT_MAX);
@ -549,8 +545,8 @@ static control_t test_snprintf_x(const size_t call_count)
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "X: %X\r\n", 0); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "X: %X\r\n", 0);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "X: %X\r\n", 0); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "X: %X\r\n", 0);
TEST_ASSERT_EQUAL_STRING("X: 00\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("X: 0\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(7, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "X: %X\r\n", UINT_MAX); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "X: %X\r\n", UINT_MAX);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "X: %X\r\n", UINT_MAX); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "X: %X\r\n", UINT_MAX);
@ -559,8 +555,8 @@ static control_t test_snprintf_x(const size_t call_count)
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "lX: %lX\r\n", 0); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "lX: %lX\r\n", 0);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "lX: %lX\r\n", 0UL); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "lX: %lX\r\n", 0UL);
TEST_ASSERT_EQUAL_STRING("lX: 00\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("lX: 0\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(8, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "lX: %lX\r\n", ULONG_MAX); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "lX: %lX\r\n", ULONG_MAX);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "lX: %lX\r\n", ULONG_MAX); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "lX: %lX\r\n", ULONG_MAX);
@ -569,8 +565,8 @@ static control_t test_snprintf_x(const size_t call_count)
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "llX: %llX\r\n", 0); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "llX: %llX\r\n", 0);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "llX: %llX\r\n", 0ULL); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "llX: %llX\r\n", 0ULL);
TEST_ASSERT_EQUAL_STRING("llX: 00\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("llX: 0\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(9, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "llX: %llX\r\n", ULLONG_MAX); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "llX: %llX\r\n", ULLONG_MAX);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "llX: %llX\r\n", ULLONG_MAX); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "llX: %llX\r\n", ULLONG_MAX);
@ -582,13 +578,13 @@ static control_t test_snprintf_x(const size_t call_count)
#else #else
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "jX: %jX\r\n", 0); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "jX: %jX\r\n", 0);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "jX: %jX\r\n", (uintmax_t) 0); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "jX: %jX\r\n", (uintmax_t) 0);
TEST_ASSERT_EQUAL_STRING("jX: 00\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("jX: 0\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(8, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "jX: %jX\r\n", UINTMAX_MAX); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "jX: %jX\r\n", UINTMAX_MAX);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "jX: %jX\r\n", UINTMAX_MAX); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "jX: %jX\r\n", UINTMAX_MAX);
TEST_ASSERT_EQUAL_STRING("jX: 00\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("jX: 0\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(8, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
#endif #endif
#ifdef TARGET_LIKE_MBED #ifdef TARGET_LIKE_MBED
@ -596,13 +592,13 @@ static control_t test_snprintf_x(const size_t call_count)
#else #else
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zX: %zX\r\n", 0); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zX: %zX\r\n", 0);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zX: %zX\r\n", 0); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zX: %zX\r\n", 0);
TEST_ASSERT_EQUAL_STRING("zX: 00\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("zX: 0\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(8, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zX: %zX\r\n", SIZE_MAX); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zX: %zX\r\n", SIZE_MAX);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zX: %zX\r\n", SIZE_MAX); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zX: %zX\r\n", SIZE_MAX);
TEST_ASSERT_EQUAL_STRING("zX: FFFFFFFF\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("zX: FFFFFFFF\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(14, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
#endif #endif
#ifdef TARGET_LIKE_MBED #ifdef TARGET_LIKE_MBED
@ -610,13 +606,13 @@ static control_t test_snprintf_x(const size_t call_count)
#else #else
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "tX: %tX\r\n", 0); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "tX: %tX\r\n", 0);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "tX: %tX\r\n", 0); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "tX: %tX\r\n", 0);
TEST_ASSERT_EQUAL_STRING("tX: 00\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("tX: 0\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(8, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "tX: %tX\r\n", UINTPTR_MAX); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "tX: %tX\r\n", UINTPTR_MAX);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "tX: %tX\r\n", UINTPTR_MAX); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "tX: %tX\r\n", UINTPTR_MAX);
TEST_ASSERT_EQUAL_STRING("tX: FFFFFFFFFFFFFFFF\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("tX: FFFFFFFFFFFFFFFF\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(22, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
#endif #endif
return CaseNext; return CaseNext;
@ -638,7 +634,7 @@ static control_t test_printf_f(const size_t call_count)
result_minimal = mbed_printf("f: %f\r\n", 0); result_minimal = mbed_printf("f: %f\r\n", 0);
result_baseline = printf("f: %f\r\n", 0); result_baseline = printf("f: %f\r\n", 0);
TEST_ASSERT_EQUAL_INT(8, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_printf("f: %f\r\n", pi); result_minimal = mbed_printf("f: %f\r\n", pi);
result_baseline = printf("f: %f\r\n", pi); result_baseline = printf("f: %f\r\n", pi);
@ -667,7 +663,7 @@ static control_t test_snprintf_f(const size_t call_count)
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "f: %f\r\n", 0); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "f: %f\r\n", 0);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "f: %f\r\n", 0); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "f: %f\r\n", 0);
TEST_ASSERT_EQUAL_STRING("f: 0.0\r\n", buffer_minimal); TEST_ASSERT_EQUAL_STRING("f: 0.0\r\n", buffer_minimal);
TEST_ASSERT_EQUAL_INT(8, result_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "f: %f\r\n", pi); result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "f: %f\r\n", pi);
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "f: %f\r\n", pi); result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "f: %f\r\n", pi);

17
features/minimal-printf/mbed_printf_implementation.c
View File

@ -18,6 +18,8 @@
#include <stdbool.h> #include <stdbool.h>
#include <limits.h> #include <limits.h>
#include <stdint.h>
#include <stddef.h>
/***************************/ /***************************/
/* MBED */ /* MBED */
@ -272,16 +274,23 @@ static void mbed_minimal_formatted_string_hexadecimal(char* buffer, size_t lengt
/* write to buffer or stdout */ /* write to buffer or stdout */
if (buffer) if (buffer)
{ {
buffer[*result] = int2hex[nibble_one]; if (nibble_one != 0) {
buffer[*result + 1] = int2hex[nibble_two]; buffer[*result] = int2hex[nibble_one];
*result += 1;
}
buffer[*result] = int2hex[nibble_two];
*result += 1;
} }
else else
{ {
MBED_PRINT_CHARACTER(int2hex[nibble_one]); if (nibble_one != 0) {
MBED_PRINT_CHARACTER(int2hex[nibble_one]);
*result += 1;
}
MBED_PRINT_CHARACTER(int2hex[nibble_two]); MBED_PRINT_CHARACTER(int2hex[nibble_two]);
*result += 1;
} }
*result += 2;
} }
} }
} }