From fbbffd613e16618c904c8d261559b3f752cc0feb Mon Sep 17 00:00:00 2001 From: Bogdan Marinescu Date: Wed, 25 Apr 2018 19:00:55 +0300 Subject: [PATCH] Disabled tests that aren't relevant on mbed targets The minimal-printf implementation supports a number of length modifiers (j, z and t) that are not supported by the native mbed OS libc implementation. The compliance test has tests for these modifiers, which means that it isn't possible to check the output of mbed-printf against a known good implementation (libc's printf) when running on mbed OS. This, in turn, can give the impression that the tests for these modifiers pass, when that might not be the case. To address this issue, this PR removes the tests for these modifiers in mbed OS. This PR was created because some of the tests for these modifiers actually fail in Linux, for example: ``` >>> Running case #3: 'printf %u'... hhu: 0 hhu: 0 hhu: 255 hhu: 255 hu: 0 hu: 0 hu: 65535 hu: 65535 u: 0 u: 0 u: 4294967295 u: 4294967295 lu: 0 lu: 0 lu: 4294967295 lu: 4294967295 llu: 0 llu: 0 llu: 18446744073709551615 llu: 18446744073709551615 ju: 0 ju: 0 ju: 4294967295 ju: 18446744073709551615 :188::FAIL: Expected 7 Was 16 >>> 'printf %u': 0 passed, 1 failed with reason 'Assertion Failed' ``` --- .../TESTS/minimal-printf/compliance/main.cpp | 74 +++++++++++++++++-- 1 file changed, 68 insertions(+), 6 deletions(-) diff --git a/features/minimal-printf/TESTS/minimal-printf/compliance/main.cpp b/features/minimal-printf/TESTS/minimal-printf/compliance/main.cpp index 6a8694c790..ca9e82cb1b 100755 --- a/features/minimal-printf/TESTS/minimal-printf/compliance/main.cpp +++ b/features/minimal-printf/TESTS/minimal-printf/compliance/main.cpp @@ -14,7 +14,9 @@ * limitations under the License. */ +#ifdef TARGET_LIKE_MBED #include "mbed.h" +#endif #include "mbed_printf.h" #include "utest/utest.h" @@ -88,8 +90,9 @@ static control_t test_printf_d(const size_t call_count) result_baseline = printf("lld: %lld\r\n", LLONG_MAX); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); +#ifdef TARGET_LIKE_MBED printf("%%jd not supported by mbed\r\n"); - +#else result_minimal = mbed_printf("jd: %jd\r\n", INT32_MIN); result_baseline = printf("jd: %jd\r\n", (intmax_t) INT32_MIN); TEST_ASSERT_EQUAL_INT(17, result_minimal); @@ -97,9 +100,11 @@ static control_t test_printf_d(const size_t call_count) result_minimal = mbed_printf("jd: %jd\r\n", INT32_MAX); result_baseline = printf("jd: %jd\r\n", (intmax_t) INT32_MAX); TEST_ASSERT_EQUAL_INT(16, result_minimal); +#endif +#ifdef TARGET_LIKE_MBED printf("%%zd not supported by mbed\r\n"); - +#else result_minimal = mbed_printf("zd: %zd\r\n", INT32_MIN); result_baseline = printf("zd: %zd\r\n", (ssize_t) INT32_MIN); TEST_ASSERT_EQUAL_INT(17, result_minimal); @@ -107,9 +112,11 @@ static control_t test_printf_d(const size_t call_count) result_minimal = mbed_printf("zd: %zd\r\n", INT32_MAX); result_baseline = printf("zd: %zd\r\n", (ssize_t) INT32_MAX); TEST_ASSERT_EQUAL_INT(16, result_minimal); +#endif +#ifdef TARGET_LIKE_MBED printf("%%td not supported by mbed\r\n"); - +#else result_minimal = mbed_printf("td: %td\r\n", PTRDIFF_MIN); result_baseline = printf("td: %td\r\n", PTRDIFF_MIN); TEST_ASSERT_EQUAL_INT(17, result_minimal); @@ -117,6 +124,7 @@ static control_t test_printf_d(const size_t call_count) result_minimal = mbed_printf("td: %td\r\n", PTRDIFF_MAX); result_baseline = printf("td: %td\r\n", PTRDIFF_MAX); TEST_ASSERT_EQUAL_INT(16, result_minimal); +#endif return CaseNext; } @@ -168,6 +176,9 @@ static control_t test_printf_u(const size_t call_count) result_baseline = printf("llu: %llu\r\n", ULLONG_MAX); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); +#ifdef TARGET_LIKE_MBED + printf("%%ju not supported by mbed\r\n"); +#else result_minimal = mbed_printf("ju: %ju\r\n", 0); result_baseline = printf("ju: %ju\r\n",(uintmax_t) 0); TEST_ASSERT_EQUAL_INT(7, result_minimal); @@ -175,7 +186,11 @@ static control_t test_printf_u(const size_t call_count) result_minimal = mbed_printf("ju: %ju\r\n", UINTMAX_MAX); result_baseline = printf("ju: %ju\r\n", UINTMAX_MAX); TEST_ASSERT_EQUAL_INT(7, result_minimal); +#endif +#ifdef TARGET_LIKE_MBED + printf("%%zu not supported by mbed\r\n"); +#else result_minimal = mbed_printf("zu: %zu\r\n", 0); result_baseline = printf("zu: %zu\r\n", 0); TEST_ASSERT_EQUAL_INT(7, result_minimal); @@ -183,7 +198,11 @@ static control_t test_printf_u(const size_t call_count) result_minimal = mbed_printf("zu: %zu\r\n", SIZE_MAX); result_baseline = printf("zu: %zu\r\n", SIZE_MAX); TEST_ASSERT_EQUAL_INT(16, result_minimal); +#endif +#ifdef TARGET_LIKE_MBED + printf("%%tu not supported by mbed\r\n"); +#else result_minimal = mbed_printf("tu: %tu\r\n", 0); result_baseline = printf("tu: %tu\r\n", 0); TEST_ASSERT_EQUAL_INT(7, result_minimal); @@ -191,6 +210,7 @@ static control_t test_printf_u(const size_t call_count) result_minimal = mbed_printf("tu: %tu\r\n", UINTPTR_MAX); result_baseline = printf("tu: %tu\r\n", UINTPTR_MAX); TEST_ASSERT_EQUAL_INT(26, result_minimal); +#endif return CaseNext; } @@ -244,6 +264,9 @@ static control_t test_printf_x(const size_t call_count) result_baseline = printf("llX: %llX\r\n", ULLONG_MAX); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); +#ifdef TARGET_LIKE_MBED + printf("%%jX not supported by mbed\r\n"); +#else result_minimal = mbed_printf("jX: %jX\r\n", 0); result_baseline = printf("jX: %jX\r\n", (uintmax_t) 0); TEST_ASSERT_EQUAL_INT(8, result_minimal); @@ -251,7 +274,11 @@ static control_t test_printf_x(const size_t call_count) result_minimal = mbed_printf("jX: %jX\r\n", UINTMAX_MAX); result_baseline = printf("jX: %jX\r\n", UINTMAX_MAX); TEST_ASSERT_EQUAL_INT(8, result_minimal); +#endif +#ifdef TARGET_LIKE_MBED + printf("%%zX not supported by mbed\r\n"); +#else result_minimal = mbed_printf("zX: %zX\r\n", 0); result_baseline = printf("zX: %zX\r\n", 0); TEST_ASSERT_EQUAL_INT(8, result_minimal); @@ -259,7 +286,11 @@ static control_t test_printf_x(const size_t call_count) result_minimal = mbed_printf("zX: %zX\r\n", SIZE_MAX); result_baseline = printf("zX: %zX\r\n", SIZE_MAX); TEST_ASSERT_EQUAL_INT(14, result_minimal); +#endif +#ifdef TARGET_LIKE_MBED + printf("%%tX not supported by mbed\r\n"); +#else result_minimal = mbed_printf("tX: %tX\r\n", 0); result_baseline = printf("tX: %tX\r\n", 0); TEST_ASSERT_EQUAL_INT(8, result_minimal); @@ -267,6 +298,7 @@ static control_t test_printf_x(const size_t call_count) result_minimal = mbed_printf("tX: %tX\r\n", UINTPTR_MAX); result_baseline = printf("tX: %tX\r\n", UINTPTR_MAX); TEST_ASSERT_EQUAL_INT(22, result_minimal); +#endif return CaseNext; } @@ -336,8 +368,9 @@ static control_t test_snprintf_d(const size_t call_count) TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); +#ifdef TARGET_LIKE_MBED printf("%%jd not supported by mbed\r\n"); - +#else 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); TEST_ASSERT_EQUAL_STRING("jd: -2147483648\r\n", buffer_minimal); @@ -347,9 +380,11 @@ static control_t test_snprintf_d(const size_t call_count) 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_INT(16, result_minimal); +#endif +#ifdef TARGET_LIKE_MBED printf("%%zd not supported by mbed\r\n"); - +#else 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); TEST_ASSERT_EQUAL_STRING("zd: -2147483648\r\n", buffer_minimal); @@ -359,9 +394,11 @@ static control_t test_snprintf_d(const size_t call_count) 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_INT(16, result_minimal); +#endif +#ifdef TARGET_LIKE_MBED printf("%%td not supported by mbed\r\n"); - +#else 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); TEST_ASSERT_EQUAL_STRING("td: -2147483648\r\n", buffer_minimal); @@ -371,6 +408,7 @@ static control_t test_snprintf_d(const size_t call_count) 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_INT(16, result_minimal); +#endif return CaseNext; } @@ -434,6 +472,9 @@ static control_t test_snprintf_u(const size_t call_count) TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); +#ifdef TARGET_LIKE_MBED + printf("%%ju not supported by mbed\r\n"); +#else 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); TEST_ASSERT_EQUAL_STRING("ju: 0\r\n", buffer_minimal); @@ -443,7 +484,11 @@ static control_t test_snprintf_u(const size_t call_count) 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_INT(7, result_minimal); +#endif +#ifdef TARGET_LIKE_MBED + printf("%%zu not supported by mbed\r\n"); +#else 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); TEST_ASSERT_EQUAL_STRING("zu: 0\r\n", buffer_minimal); @@ -453,7 +498,11 @@ static control_t test_snprintf_u(const size_t call_count) 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_INT(16, result_minimal); +#endif +#ifdef TARGET_LIKE_MBED + printf("%%tu not supported by mbed\r\n"); +#else 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); TEST_ASSERT_EQUAL_STRING("tu: 0\r\n", buffer_minimal); @@ -463,6 +512,7 @@ static control_t test_snprintf_u(const size_t call_count) 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_INT(26, result_minimal); +#endif return CaseNext; } @@ -527,6 +577,9 @@ static control_t test_snprintf_x(const size_t call_count) TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal); TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal); +#ifdef TARGET_LIKE_MBED + printf("%%jX not supported by mbed\r\n"); +#else 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); TEST_ASSERT_EQUAL_STRING("jX: 00\r\n", buffer_minimal); @@ -536,7 +589,11 @@ static control_t test_snprintf_x(const size_t call_count) 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_INT(8, result_minimal); +#endif +#ifdef TARGET_LIKE_MBED + printf("%%xX not supported by mbed\r\n"); +#else 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); TEST_ASSERT_EQUAL_STRING("zX: 00\r\n", buffer_minimal); @@ -546,7 +603,11 @@ static control_t test_snprintf_x(const size_t call_count) 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_INT(14, result_minimal); +#endif +#ifdef TARGET_LIKE_MBED + printf("%%tX not supported by mbed\r\n"); +#else 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); TEST_ASSERT_EQUAL_STRING("tX: 00\r\n", buffer_minimal); @@ -556,6 +617,7 @@ static control_t test_snprintf_x(const size_t call_count) 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_INT(22, result_minimal); +#endif return CaseNext; }