Skip to content

Commit 5ed0d75

Browse files
bogdanmhugueskamba
bogdanm
authored and
hugueskamba
committed
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' ```
1 parent 6efbf03 commit 5ed0d75

File tree

1 file changed

+68
-6
lines changed

1 file changed

+68
-6
lines changed

‎TESTS/minimal-printf/compliance/main.cpp

Lines changed: 68 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,9 @@
1414
* limitations under the License.
1515
*/
1616

17+
#ifdef TARGET_LIKE_MBED
1718
#include "mbed.h"
19+
#endif
1820
#include "mbed_printf.h"
1921

2022
#include "utest/utest.h"
@@ -88,35 +90,41 @@ static control_t test_printf_d(const size_t call_count)
8890
result_baseline = printf("lld: %lld\r\n", LLONG_MAX);
8991
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
9092

93+
#ifdef TARGET_LIKE_MBED
9194
printf("%%jd not supported by mbed\r\n");
92-
95+
#else
9396
result_minimal = mbed_printf("jd: %jd\r\n", INT32_MIN);
9497
result_baseline = printf("jd: %jd\r\n", (intmax_t) INT32_MIN);
9598
TEST_ASSERT_EQUAL_INT(17, result_minimal);
9699

97100
result_minimal = mbed_printf("jd: %jd\r\n", INT32_MAX);
98101
result_baseline = printf("jd: %jd\r\n", (intmax_t) INT32_MAX);
99102
TEST_ASSERT_EQUAL_INT(16, result_minimal);
103+
#endif
100104

105+
#ifdef TARGET_LIKE_MBED
101106
printf("%%zd not supported by mbed\r\n");
102-
107+
#else
103108
result_minimal = mbed_printf("zd: %zd\r\n", INT32_MIN);
104109
result_baseline = printf("zd: %zd\r\n", (ssize_t) INT32_MIN);
105110
TEST_ASSERT_EQUAL_INT(17, result_minimal);
106111

107112
result_minimal = mbed_printf("zd: %zd\r\n", INT32_MAX);
108113
result_baseline = printf("zd: %zd\r\n", (ssize_t) INT32_MAX);
109114
TEST_ASSERT_EQUAL_INT(16, result_minimal);
115+
#endif
110116

117+
#ifdef TARGET_LIKE_MBED
111118
printf("%%td not supported by mbed\r\n");
112-
119+
#else
113120
result_minimal = mbed_printf("td: %td\r\n", PTRDIFF_MIN);
114121
result_baseline = printf("td: %td\r\n", PTRDIFF_MIN);
115122
TEST_ASSERT_EQUAL_INT(17, result_minimal);
116123

117124
result_minimal = mbed_printf("td: %td\r\n", PTRDIFF_MAX);
118125
result_baseline = printf("td: %td\r\n", PTRDIFF_MAX);
119126
TEST_ASSERT_EQUAL_INT(16, result_minimal);
127+
#endif
120128

121129
return CaseNext;
122130
}
@@ -168,29 +176,41 @@ static control_t test_printf_u(const size_t call_count)
168176
result_baseline = printf("llu: %llu\r\n", ULLONG_MAX);
169177
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
170178

179+
#ifdef TARGET_LIKE_MBED
180+
printf("%%ju not supported by mbed\r\n");
181+
#else
171182
result_minimal = mbed_printf("ju: %ju\r\n", 0);
172183
result_baseline = printf("ju: %ju\r\n",(uintmax_t) 0);
173184
TEST_ASSERT_EQUAL_INT(7, result_minimal);
174185

175186
result_minimal = mbed_printf("ju: %ju\r\n", UINTMAX_MAX);
176187
result_baseline = printf("ju: %ju\r\n", UINTMAX_MAX);
177188
TEST_ASSERT_EQUAL_INT(7, result_minimal);
189+
#endif
178190

191+
#ifdef TARGET_LIKE_MBED
192+
printf("%%zu not supported by mbed\r\n");
193+
#else
179194
result_minimal = mbed_printf("zu: %zu\r\n", 0);
180195
result_baseline = printf("zu: %zu\r\n", 0);
181196
TEST_ASSERT_EQUAL_INT(7, result_minimal);
182197

183198
result_minimal = mbed_printf("zu: %zu\r\n", SIZE_MAX);
184199
result_baseline = printf("zu: %zu\r\n", SIZE_MAX);
185200
TEST_ASSERT_EQUAL_INT(16, result_minimal);
201+
#endif
186202

203+
#ifdef TARGET_LIKE_MBED
204+
printf("%%tu not supported by mbed\r\n");
205+
#else
187206
result_minimal = mbed_printf("tu: %tu\r\n", 0);
188207
result_baseline = printf("tu: %tu\r\n", 0);
189208
TEST_ASSERT_EQUAL_INT(7, result_minimal);
190209

191210
result_minimal = mbed_printf("tu: %tu\r\n", UINTPTR_MAX);
192211
result_baseline = printf("tu: %tu\r\n", UINTPTR_MAX);
193212
TEST_ASSERT_EQUAL_INT(26, result_minimal);
213+
#endif
194214

195215
return CaseNext;
196216
}
@@ -244,29 +264,41 @@ static control_t test_printf_x(const size_t call_count)
244264
result_baseline = printf("llX: %llX\r\n", ULLONG_MAX);
245265
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
246266

267+
#ifdef TARGET_LIKE_MBED
268+
printf("%%jX not supported by mbed\r\n");
269+
#else
247270
result_minimal = mbed_printf("jX: %jX\r\n", 0);
248271
result_baseline = printf("jX: %jX\r\n", (uintmax_t) 0);
249272
TEST_ASSERT_EQUAL_INT(8, result_minimal);
250273

251274
result_minimal = mbed_printf("jX: %jX\r\n", UINTMAX_MAX);
252275
result_baseline = printf("jX: %jX\r\n", UINTMAX_MAX);
253276
TEST_ASSERT_EQUAL_INT(8, result_minimal);
277+
#endif
254278

279+
#ifdef TARGET_LIKE_MBED
280+
printf("%%zX not supported by mbed\r\n");
281+
#else
255282
result_minimal = mbed_printf("zX: %zX\r\n", 0);
256283
result_baseline = printf("zX: %zX\r\n", 0);
257284
TEST_ASSERT_EQUAL_INT(8, result_minimal);
258285

259286
result_minimal = mbed_printf("zX: %zX\r\n", SIZE_MAX);
260287
result_baseline = printf("zX: %zX\r\n", SIZE_MAX);
261288
TEST_ASSERT_EQUAL_INT(14, result_minimal);
289+
#endif
262290

291+
#ifdef TARGET_LIKE_MBED
292+
printf("%%tX not supported by mbed\r\n");
293+
#else
263294
result_minimal = mbed_printf("tX: %tX\r\n", 0);
264295
result_baseline = printf("tX: %tX\r\n", 0);
265296
TEST_ASSERT_EQUAL_INT(8, result_minimal);
266297

267298
result_minimal = mbed_printf("tX: %tX\r\n", UINTPTR_MAX);
268299
result_baseline = printf("tX: %tX\r\n", UINTPTR_MAX);
269300
TEST_ASSERT_EQUAL_INT(22, result_minimal);
301+
#endif
270302

271303
return CaseNext;
272304
}
@@ -336,8 +368,9 @@ static control_t test_snprintf_d(const size_t call_count)
336368
TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal);
337369
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
338370

371+
#ifdef TARGET_LIKE_MBED
339372
printf("%%jd not supported by mbed\r\n");
340-
373+
#else
341374
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "jd: %jd\r\n", INT32_MIN);
342375
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "jd: %jd\r\n", (intmax_t) INT32_MIN);
343376
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)
347380
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "jd: %jd\r\n", (intmax_t) INT32_MAX);
348381
TEST_ASSERT_EQUAL_STRING("jd: 2147483647\r\n", buffer_minimal);
349382
TEST_ASSERT_EQUAL_INT(16, result_minimal);
383+
#endif
350384

385+
#ifdef TARGET_LIKE_MBED
351386
printf("%%zd not supported by mbed\r\n");
352-
387+
#else
353388
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zd: %zd\r\n", INT32_MIN);
354389
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zd: %zd\r\n", (ssize_t) INT32_MIN);
355390
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)
359394
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zd: %zd\r\n", (ssize_t) INT32_MAX);
360395
TEST_ASSERT_EQUAL_STRING("zd: 2147483647\r\n", buffer_minimal);
361396
TEST_ASSERT_EQUAL_INT(16, result_minimal);
397+
#endif
362398

399+
#ifdef TARGET_LIKE_MBED
363400
printf("%%td not supported by mbed\r\n");
364-
401+
#else
365402
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "td: %td\r\n", PTRDIFF_MIN);
366403
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "td: %td\r\n", PTRDIFF_MIN);
367404
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)
371408
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "td: %td\r\n", PTRDIFF_MAX);
372409
TEST_ASSERT_EQUAL_STRING("td: 2147483647\r\n", buffer_minimal);
373410
TEST_ASSERT_EQUAL_INT(16, result_minimal);
411+
#endif
374412

375413
return CaseNext;
376414
}
@@ -434,6 +472,9 @@ static control_t test_snprintf_u(const size_t call_count)
434472
TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal);
435473
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
436474

475+
#ifdef TARGET_LIKE_MBED
476+
printf("%%ju not supported by mbed\r\n");
477+
#else
437478
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "ju: %ju\r\n", 0);
438479
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "ju: %ju\r\n", (uintmax_t) 0);
439480
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)
443484
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "ju: %ju\r\n", UINTMAX_MAX);
444485
TEST_ASSERT_EQUAL_STRING("ju: 0\r\n", buffer_minimal);
445486
TEST_ASSERT_EQUAL_INT(7, result_minimal);
487+
#endif
446488

489+
#ifdef TARGET_LIKE_MBED
490+
printf("%%zu not supported by mbed\r\n");
491+
#else
447492
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zu: %zu\r\n", 0);
448493
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zu: %zu\r\n", 0);
449494
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)
453498
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zu: %zu\r\n", SIZE_MAX);
454499
TEST_ASSERT_EQUAL_STRING("zu: 4294967295\r\n", buffer_minimal);
455500
TEST_ASSERT_EQUAL_INT(16, result_minimal);
501+
#endif
456502

503+
#ifdef TARGET_LIKE_MBED
504+
printf("%%tu not supported by mbed\r\n");
505+
#else
457506
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "tu: %tu\r\n", 0);
458507
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "tu: %tu\r\n", 0);
459508
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)
463512
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "tu: %tu\r\n", UINTPTR_MAX);
464513
TEST_ASSERT_EQUAL_STRING("tu: 18446744073709551615\r\n", buffer_minimal);
465514
TEST_ASSERT_EQUAL_INT(26, result_minimal);
515+
#endif
466516

467517
return CaseNext;
468518
}
@@ -527,6 +577,9 @@ static control_t test_snprintf_x(const size_t call_count)
527577
TEST_ASSERT_EQUAL_STRING(buffer_baseline, buffer_minimal);
528578
TEST_ASSERT_EQUAL_INT(result_baseline, result_minimal);
529579

580+
#ifdef TARGET_LIKE_MBED
581+
printf("%%jX not supported by mbed\r\n");
582+
#else
530583
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "jX: %jX\r\n", 0);
531584
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "jX: %jX\r\n", (uintmax_t) 0);
532585
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)
536589
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "jX: %jX\r\n", UINTMAX_MAX);
537590
TEST_ASSERT_EQUAL_STRING("jX: 00\r\n", buffer_minimal);
538591
TEST_ASSERT_EQUAL_INT(8, result_minimal);
592+
#endif
539593

594+
#ifdef TARGET_LIKE_MBED
595+
printf("%%xX not supported by mbed\r\n");
596+
#else
540597
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "zX: %zX\r\n", 0);
541598
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zX: %zX\r\n", 0);
542599
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)
546603
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "zX: %zX\r\n", SIZE_MAX);
547604
TEST_ASSERT_EQUAL_STRING("zX: FFFFFFFF\r\n", buffer_minimal);
548605
TEST_ASSERT_EQUAL_INT(14, result_minimal);
606+
#endif
549607

608+
#ifdef TARGET_LIKE_MBED
609+
printf("%%tX not supported by mbed\r\n");
610+
#else
550611
result_minimal = mbed_snprintf(buffer_minimal, sizeof(buffer_minimal), "tX: %tX\r\n", 0);
551612
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "tX: %tX\r\n", 0);
552613
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)
556617
result_baseline = snprintf(buffer_baseline, sizeof(buffer_baseline), "tX: %tX\r\n", UINTPTR_MAX);
557618
TEST_ASSERT_EQUAL_STRING("tX: FFFFFFFFFFFFFFFF\r\n", buffer_minimal);
558619
TEST_ASSERT_EQUAL_INT(22, result_minimal);
620+
#endif
559621

560622
return CaseNext;
561623
}

0 commit comments

Comments
 (0)