1 /* Test of u8_v[a]s[n]printf() function.
2 Copyright (C) 2007 Free Software Foundation, Inc.
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2, or (at your option)
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software Foundation,
16 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
18 /* Written by Bruno Haible <bruno@clisp.org>, 2007. */
21 test_xfunction (uint8_t * (*my_xasprintf) (const char *, ...))
23 /* Test support of size specifiers as in C99. */
27 my_xasprintf ("%ju %d", (uintmax_t) 12345671, 33, 44, 55);
28 static const uint8_t expected[] = "12345671 33";
29 ASSERT (result != NULL);
30 ASSERT (u8_strcmp (result, expected) == 0);
36 my_xasprintf ("%zu %d", (size_t) 12345672, 33, 44, 55);
37 static const uint8_t expected[] = "12345672 33";
38 ASSERT (result != NULL);
39 ASSERT (u8_strcmp (result, expected) == 0);
45 my_xasprintf ("%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
46 static const uint8_t expected[] = "12345673 33";
47 ASSERT (result != NULL);
48 ASSERT (u8_strcmp (result, expected) == 0);
54 my_xasprintf ("%Lg %d", (long double) 1.5, 33, 44, 55);
55 static const uint8_t expected[] = "1.5 33";
56 ASSERT (result != NULL);
57 ASSERT (u8_strcmp (result, expected) == 0);
61 /* Test the support of the 'U' conversion specifier for Unicode strings. */
64 static const uint8_t unicode_string[] = "Hello";
67 my_xasprintf ("%U %d", unicode_string, 33, 44, 55);
68 static const uint8_t expected[] = "Hello 33";
69 ASSERT (result != NULL);
70 ASSERT (u8_strcmp (result, expected) == 0);
75 my_xasprintf ("%10U %d", unicode_string, 33, 44, 55);
76 static const uint8_t expected[] = " Hello 33";
77 ASSERT (result != NULL);
78 ASSERT (u8_strcmp (result, expected) == 0);
83 my_xasprintf ("%-10U %d", unicode_string, 33, 44, 55);
84 static const uint8_t expected[] = "Hello 33";
85 ASSERT (result != NULL);
86 ASSERT (u8_strcmp (result, expected) == 0);
89 { /* FLAG_ZERO: no effect. */
91 my_xasprintf ("%010U %d", unicode_string, 33, 44, 55);
92 static const uint8_t expected[] = " Hello 33";
93 ASSERT (result != NULL);
94 ASSERT (u8_strcmp (result, expected) == 0);
100 static const uint16_t unicode_string[] = { 'H', 'e', 'l', 'l', 'o', 0 };
103 my_xasprintf ("%lU %d", unicode_string, 33, 44, 55);
104 static const uint8_t expected[] = "Hello 33";
105 ASSERT (result != NULL);
106 ASSERT (u8_strcmp (result, expected) == 0);
111 my_xasprintf ("%10lU %d", unicode_string, 33, 44, 55);
112 static const uint8_t expected[] = " Hello 33";
113 ASSERT (result != NULL);
114 ASSERT (u8_strcmp (result, expected) == 0);
119 my_xasprintf ("%-10lU %d", unicode_string, 33, 44, 55);
120 static const uint8_t expected[] = "Hello 33";
121 ASSERT (result != NULL);
122 ASSERT (u8_strcmp (result, expected) == 0);
125 { /* FLAG_ZERO: no effect. */
127 my_xasprintf ("%010lU %d", unicode_string, 33, 44, 55);
128 static const uint8_t expected[] = " Hello 33";
129 ASSERT (result != NULL);
130 ASSERT (u8_strcmp (result, expected) == 0);
136 static const uint32_t unicode_string[] = { 'H', 'e', 'l', 'l', 'o', 0 };
139 my_xasprintf ("%llU %d", unicode_string, 33, 44, 55);
140 static const uint8_t expected[] = "Hello 33";
141 ASSERT (result != NULL);
142 ASSERT (u8_strcmp (result, expected) == 0);
147 my_xasprintf ("%10llU %d", unicode_string, 33, 44, 55);
148 static const uint8_t expected[] = " Hello 33";
149 ASSERT (result != NULL);
150 ASSERT (u8_strcmp (result, expected) == 0);
155 my_xasprintf ("%-10llU %d", unicode_string, 33, 44, 55);
156 static const uint8_t expected[] = "Hello 33";
157 ASSERT (result != NULL);
158 ASSERT (u8_strcmp (result, expected) == 0);
161 { /* FLAG_ZERO: no effect. */
163 my_xasprintf ("%010llU %d", unicode_string, 33, 44, 55);
164 static const uint8_t expected[] = " Hello 33";
165 ASSERT (result != NULL);
166 ASSERT (u8_strcmp (result, expected) == 0);
171 /* Test the support of the 's' conversion specifier for strings. */
175 my_xasprintf ("Mr. %s %d", "Ronald Reagan", 33, 44, 55);
176 static const uint8_t expected[] = "Mr. Ronald Reagan 33";
177 ASSERT (result != NULL);
178 ASSERT (u8_strcmp (result, expected) == 0);
184 my_xasprintf ("Mr. %20s %d", "Ronald Reagan", 33, 44, 55);
185 static const uint8_t expected[] = "Mr. Ronald Reagan 33";
186 ASSERT (result != NULL);
187 ASSERT (u8_strcmp (result, expected) == 0);
193 my_xasprintf ("Mr. %-20s %d", "Ronald Reagan", 33, 44, 55);
194 static const uint8_t expected[] = "Mr. Ronald Reagan 33";
195 ASSERT (result != NULL);
196 ASSERT (u8_strcmp (result, expected) == 0);
200 { /* FLAG_ZERO: no effect. */
202 my_xasprintf ("Mr. %020s %d", "Ronald Reagan", 33, 44, 55);
203 static const uint8_t expected[] = "Mr. Ronald Reagan 33";
204 ASSERT (result != NULL);
205 ASSERT (u8_strcmp (result, expected) == 0);
209 /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
210 output of floating-point numbers. */
212 { /* A positive number. */
214 my_xasprintf ("%a %d", 3.1416015625, 33, 44, 55);
215 static const uint8_t expected1[] = "0x1.922p+1 33";
216 static const uint8_t expected2[] = "0x3.244p+0 33";
217 static const uint8_t expected3[] = "0x6.488p-1 33";
218 static const uint8_t expected4[] = "0xc.91p-2 33";
219 ASSERT (result != NULL);
220 ASSERT (u8_strcmp (result, expected1) == 0
221 || u8_strcmp (result, expected2) == 0
222 || u8_strcmp (result, expected3) == 0
223 || u8_strcmp (result, expected4) == 0);
229 my_xasprintf ("%10a %d", 1.75, 33, 44, 55);
230 static const uint8_t expected1[] = " 0x1.cp+0 33";
231 static const uint8_t expected2[] = " 0x3.8p-1 33";
232 static const uint8_t expected3[] = " 0x7p-2 33";
233 static const uint8_t expected4[] = " 0xep-3 33";
234 ASSERT (result != NULL);
235 ASSERT (u8_strcmp (result, expected1) == 0
236 || u8_strcmp (result, expected2) == 0
237 || u8_strcmp (result, expected3) == 0
238 || u8_strcmp (result, expected4) == 0);
242 { /* Small precision. */
244 my_xasprintf ("%.10a %d", 1.75, 33, 44, 55);
245 static const uint8_t expected1[] = "0x1.c000000000p+0 33";
246 static const uint8_t expected2[] = "0x3.8000000000p-1 33";
247 static const uint8_t expected3[] = "0x7.0000000000p-2 33";
248 static const uint8_t expected4[] = "0xe.0000000000p-3 33";
249 ASSERT (result != NULL);
250 ASSERT (u8_strcmp (result, expected1) == 0
251 || u8_strcmp (result, expected2) == 0
252 || u8_strcmp (result, expected3) == 0
253 || u8_strcmp (result, expected4) == 0);
257 { /* Large precision. */
259 my_xasprintf ("%.50a %d", 1.75, 33, 44, 55);
260 static const uint8_t expected1[] = "0x1.c0000000000000000000000000000000000000000000000000p+0 33";
261 static const uint8_t expected2[] = "0x3.80000000000000000000000000000000000000000000000000p-1 33";
262 static const uint8_t expected3[] = "0x7.00000000000000000000000000000000000000000000000000p-2 33";
263 static const uint8_t expected4[] = "0xe.00000000000000000000000000000000000000000000000000p-3 33";
264 ASSERT (result != NULL);
265 ASSERT (u8_strcmp (result, expected1) == 0
266 || u8_strcmp (result, expected2) == 0
267 || u8_strcmp (result, expected3) == 0
268 || u8_strcmp (result, expected4) == 0);
272 { /* A positive number. */
274 my_xasprintf ("%La %d", 3.1416015625L, 33, 44, 55);
275 static const uint8_t expected1[] = "0x1.922p+1 33";
276 static const uint8_t expected2[] = "0x3.244p+0 33";
277 static const uint8_t expected3[] = "0x6.488p-1 33";
278 static const uint8_t expected4[] = "0xc.91p-2 33";
279 ASSERT (result != NULL);
280 ASSERT (u8_strcmp (result, expected1) == 0
281 || u8_strcmp (result, expected2) == 0
282 || u8_strcmp (result, expected3) == 0
283 || u8_strcmp (result, expected4) == 0);
289 my_xasprintf ("%10La %d", 1.75L, 33, 44, 55);
290 static const uint8_t expected1[] = " 0x1.cp+0 33";
291 static const uint8_t expected2[] = " 0x3.8p-1 33";
292 static const uint8_t expected3[] = " 0x7p-2 33";
293 static const uint8_t expected4[] = " 0xep-3 33";
294 ASSERT (result != NULL);
295 ASSERT (u8_strcmp (result, expected1) == 0
296 || u8_strcmp (result, expected2) == 0
297 || u8_strcmp (result, expected3) == 0
298 || u8_strcmp (result, expected4) == 0);
302 { /* Small precision. */
304 my_xasprintf ("%.10La %d", 1.75L, 33, 44, 55);
305 static const uint8_t expected1[] = "0x1.c000000000p+0 33";
306 static const uint8_t expected2[] = "0x3.8000000000p-1 33";
307 static const uint8_t expected3[] = "0x7.0000000000p-2 33";
308 static const uint8_t expected4[] = "0xe.0000000000p-3 33";
309 ASSERT (result != NULL);
310 ASSERT (u8_strcmp (result, expected1) == 0
311 || u8_strcmp (result, expected2) == 0
312 || u8_strcmp (result, expected3) == 0
313 || u8_strcmp (result, expected4) == 0);
317 { /* Large precision. */
319 my_xasprintf ("%.50La %d", 1.75L, 33, 44, 55);
320 static const uint8_t expected1[] = "0x1.c0000000000000000000000000000000000000000000000000p+0 33";
321 static const uint8_t expected2[] = "0x3.80000000000000000000000000000000000000000000000000p-1 33";
322 static const uint8_t expected3[] = "0x7.00000000000000000000000000000000000000000000000000p-2 33";
323 static const uint8_t expected4[] = "0xe.00000000000000000000000000000000000000000000000000p-3 33";
324 ASSERT (result != NULL);
325 ASSERT (u8_strcmp (result, expected1) == 0
326 || u8_strcmp (result, expected2) == 0
327 || u8_strcmp (result, expected3) == 0
328 || u8_strcmp (result, expected4) == 0);
332 /* Test the support of the %f format directive. */
334 { /* A positive number. */
336 my_xasprintf ("%f %d", 12.75, 33, 44, 55);
337 static const uint8_t expected[] = "12.750000 33";
338 ASSERT (result != NULL);
339 ASSERT (u8_strcmp (result, expected) == 0);
345 my_xasprintf ("%10f %d", 1.75, 33, 44, 55);
346 static const uint8_t expected[] = " 1.750000 33";
347 ASSERT (result != NULL);
348 ASSERT (u8_strcmp (result, expected) == 0);
354 my_xasprintf ("%.f %d", 1234.0, 33, 44, 55);
355 static const uint8_t expected[] = "1234 33";
356 ASSERT (result != NULL);
357 ASSERT (u8_strcmp (result, expected) == 0);
361 { /* A positive number. */
363 my_xasprintf ("%Lf %d", 12.75L, 33, 44, 55);
364 static const uint8_t expected[] = "12.750000 33";
365 ASSERT (result != NULL);
366 ASSERT (u8_strcmp (result, expected) == 0);
372 my_xasprintf ("%10Lf %d", 1.75L, 33, 44, 55);
373 static const uint8_t expected[] = " 1.750000 33";
374 ASSERT (result != NULL);
375 ASSERT (u8_strcmp (result, expected) == 0);
381 my_xasprintf ("%.Lf %d", 1234.0L, 33, 44, 55);
382 static const uint8_t expected[] = "1234 33";
383 ASSERT (result != NULL);
384 ASSERT (u8_strcmp (result, expected) == 0);
388 /* Test the support of the %F format directive. */
390 { /* A positive number. */
392 my_xasprintf ("%F %d", 12.75, 33, 44, 55);
393 static const uint8_t expected[] = "12.750000 33";
394 ASSERT (result != NULL);
395 ASSERT (u8_strcmp (result, expected) == 0);
401 my_xasprintf ("%.F %d", 1234.0, 33, 44, 55);
402 static const uint8_t expected[] = "1234 33";
403 ASSERT (result != NULL);
404 ASSERT (u8_strcmp (result, expected) == 0);
408 { /* A positive number. */
410 my_xasprintf ("%LF %d", 12.75L, 33, 44, 55);
411 static const uint8_t expected[] = "12.750000 33";
412 ASSERT (result != NULL);
413 ASSERT (u8_strcmp (result, expected) == 0);
419 my_xasprintf ("%.LF %d", 1234.0L, 33, 44, 55);
420 static const uint8_t expected[] = "1234 33";
421 ASSERT (result != NULL);
422 ASSERT (u8_strcmp (result, expected) == 0);
426 /* Test the support of the %e format directive. */
428 { /* A positive number. */
430 my_xasprintf ("%e %d", 12.75, 33, 44, 55);
431 static const uint8_t expected1[] = "1.275000e+01 33";
432 static const uint8_t expected2[] = "1.275000e+001 33";
433 ASSERT (result != NULL);
434 ASSERT (u8_strcmp (result, expected1) == 0
435 || u8_strcmp (result, expected2) == 0);
441 my_xasprintf ("%15e %d", 1.75, 33, 44, 55);
442 static const uint8_t expected1[] = " 1.750000e+00 33";
443 static const uint8_t expected2[] = " 1.750000e+000 33";
444 ASSERT (result != NULL);
445 ASSERT (u8_strcmp (result, expected1) == 0
446 || u8_strcmp (result, expected2) == 0);
452 my_xasprintf ("%.e %d", 1234.0, 33, 44, 55);
453 static const uint8_t expected1[] = "1e+03 33";
454 static const uint8_t expected2[] = "1e+003 33";
455 ASSERT (result != NULL);
456 ASSERT (u8_strcmp (result, expected1) == 0
457 || u8_strcmp (result, expected2) == 0);
461 { /* A positive number. */
463 my_xasprintf ("%Le %d", 12.75L, 33, 44, 55);
464 static const uint8_t expected[] = "1.275000e+01 33";
465 ASSERT (result != NULL);
466 ASSERT (u8_strcmp (result, expected) == 0);
472 my_xasprintf ("%15Le %d", 1.75L, 33, 44, 55);
473 static const uint8_t expected[] = " 1.750000e+00 33";
474 ASSERT (result != NULL);
475 ASSERT (u8_strcmp (result, expected) == 0);
481 my_xasprintf ("%.Le %d", 1234.0L, 33, 44, 55);
482 static const uint8_t expected[] = "1e+03 33";
483 ASSERT (result != NULL);
484 ASSERT (u8_strcmp (result, expected) == 0);
488 /* Test the support of the %g format directive. */
490 { /* A positive number. */
492 my_xasprintf ("%g %d", 12.75, 33, 44, 55);
493 static const uint8_t expected[] = "12.75 33";
494 ASSERT (result != NULL);
495 ASSERT (u8_strcmp (result, expected) == 0);
501 my_xasprintf ("%10g %d", 1.75, 33, 44, 55);
502 static const uint8_t expected[] = " 1.75 33";
503 ASSERT (result != NULL);
504 ASSERT (u8_strcmp (result, expected) == 0);
510 my_xasprintf ("%.g %d", 1234.0, 33, 44, 55);
511 static const uint8_t expected1[] = "1e+03 33";
512 static const uint8_t expected2[] = "1e+003 33";
513 ASSERT (result != NULL);
514 ASSERT (u8_strcmp (result, expected1) == 0
515 || u8_strcmp (result, expected2) == 0);
519 { /* A positive number. */
521 my_xasprintf ("%Lg %d", 12.75L, 33, 44, 55);
522 static const uint8_t expected[] = "12.75 33";
523 ASSERT (result != NULL);
524 ASSERT (u8_strcmp (result, expected) == 0);
530 my_xasprintf ("%10Lg %d", 1.75L, 33, 44, 55);
531 static const uint8_t expected[] = " 1.75 33";
532 ASSERT (result != NULL);
533 ASSERT (u8_strcmp (result, expected) == 0);
539 my_xasprintf ("%.Lg %d", 1234.0L, 33, 44, 55);
540 static const uint8_t expected[] = "1e+03 33";
541 ASSERT (result != NULL);
542 ASSERT (u8_strcmp (result, expected) == 0);
546 /* Test the support of the %n format directive. */
551 my_xasprintf ("%d %n", 123, &count, 33, 44, 55);
552 static const uint8_t expected[] = "123 ";
553 ASSERT (result != NULL);
554 ASSERT (u8_strcmp (result, expected) == 0);
559 /* Test the support of the POSIX/XSI format strings with positions. */
563 my_xasprintf ("%2$d %1$d", 33, 55);
564 static const uint8_t expected[] = "55 33";
565 ASSERT (result != NULL);
566 ASSERT (u8_strcmp (result, expected) == 0);
570 /* Test the support of the grouping flag. */
574 my_xasprintf ("%'d %d", 1234567, 99);
575 ASSERT (result != NULL);
576 ASSERT (result[u8_strlen (result) - 1] == '9');
580 /* Test the support of the 'U' conversion specifier for Unicode strings. */
583 static const uint8_t unicode_string[] = "Rafa\305\202 Maszkowski"; /* Rafał Maszkowski */
586 my_xasprintf ("%U %d", unicode_string, 33, 44, 55);
587 static const uint8_t expected[] = "Rafa\305\202 Maszkowski 33";
588 ASSERT (result != NULL);
589 ASSERT (u8_strcmp (result, expected) == 0);
594 my_xasprintf ("%20U %d", unicode_string, 33, 44, 55);
595 static const uint8_t expected[] = " Rafa\305\202 Maszkowski 33";
596 ASSERT (result != NULL);
597 ASSERT (u8_strcmp (result, expected) == 0);
602 my_xasprintf ("%-20U %d", unicode_string, 33, 44, 55);
603 static const uint8_t expected[] = "Rafa\305\202 Maszkowski 33";
604 ASSERT (result != NULL);
605 ASSERT (u8_strcmp (result, expected) == 0);
608 { /* FLAG_ZERO: no effect. */
610 my_xasprintf ("%020U %d", unicode_string, 33, 44, 55);
611 static const uint8_t expected[] = " Rafa\305\202 Maszkowski 33";
612 ASSERT (result != NULL);
613 ASSERT (u8_strcmp (result, expected) == 0);
619 static const uint16_t unicode_string[] = /* Rafał Maszkowski */
621 'R', 'a', 'f', 'a', 0x0142, ' ', 'M', 'a', 's', 'z', 'k', 'o', 'w',
626 my_xasprintf ("%lU %d", unicode_string, 33, 44, 55);
627 static const uint8_t expected[] = "Rafa\305\202 Maszkowski 33";
628 ASSERT (result != NULL);
629 ASSERT (u8_strcmp (result, expected) == 0);
634 my_xasprintf ("%20lU %d", unicode_string, 33, 44, 55);
635 static const uint8_t expected[] = " Rafa\305\202 Maszkowski 33";
636 ASSERT (result != NULL);
637 ASSERT (u8_strcmp (result, expected) == 0);
642 my_xasprintf ("%-20lU %d", unicode_string, 33, 44, 55);
643 static const uint8_t expected[] = "Rafa\305\202 Maszkowski 33";
644 ASSERT (result != NULL);
645 ASSERT (u8_strcmp (result, expected) == 0);
648 { /* FLAG_ZERO: no effect. */
650 my_xasprintf ("%020lU %d", unicode_string, 33, 44, 55);
651 static const uint8_t expected[] = " Rafa\305\202 Maszkowski 33";
652 ASSERT (result != NULL);
653 ASSERT (u8_strcmp (result, expected) == 0);
659 static const uint32_t unicode_string[] = /* Rafał Maszkowski */
661 'R', 'a', 'f', 'a', 0x0142, ' ', 'M', 'a', 's', 'z', 'k', 'o', 'w',
666 my_xasprintf ("%llU %d", unicode_string, 33, 44, 55);
667 static const uint8_t expected[] = "Rafa\305\202 Maszkowski 33";
668 ASSERT (result != NULL);
669 ASSERT (u8_strcmp (result, expected) == 0);
674 my_xasprintf ("%20llU %d", unicode_string, 33, 44, 55);
675 static const uint8_t expected[] = " Rafa\305\202 Maszkowski 33";
676 ASSERT (result != NULL);
677 ASSERT (u8_strcmp (result, expected) == 0);
682 my_xasprintf ("%-20llU %d", unicode_string, 33, 44, 55);
683 static const uint8_t expected[] = "Rafa\305\202 Maszkowski 33";
684 ASSERT (result != NULL);
685 ASSERT (u8_strcmp (result, expected) == 0);
688 { /* FLAG_ZERO: no effect. */
690 my_xasprintf ("%020llU %d", unicode_string, 33, 44, 55);
691 static const uint8_t expected[] = " Rafa\305\202 Maszkowski 33";
692 ASSERT (result != NULL);
693 ASSERT (u8_strcmp (result, expected) == 0);
698 /* Test non-ASCII characters in the format string. */
702 my_xasprintf ("\304rger", 33, 44, 55);
703 ASSERT (result == NULL && errno == EINVAL);