1 /* Test of u8_v[a]s[n]printf() function.
2 Copyright (C) 2007, 2009-2014 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 3 of the License, or
7 (at your option) any later version.
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, see <http://www.gnu.org/licenses/>. */
17 /* Written by Bruno Haible <bruno@clisp.org>, 2007. */
20 test_xfunction (uint8_t * (*my_xasprintf) (const char *, ...))
22 /* Test support of size specifiers as in C99. */
26 my_xasprintf ("%ju %d", (uintmax_t) 12345671, 33, 44, 55);
27 static const uint8_t expected[] = "12345671 33";
28 ASSERT (result != NULL);
29 ASSERT (u8_strcmp (result, expected) == 0);
35 my_xasprintf ("%zu %d", (size_t) 12345672, 33, 44, 55);
36 static const uint8_t expected[] = "12345672 33";
37 ASSERT (result != NULL);
38 ASSERT (u8_strcmp (result, expected) == 0);
44 my_xasprintf ("%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
45 static const uint8_t expected[] = "12345673 33";
46 ASSERT (result != NULL);
47 ASSERT (u8_strcmp (result, expected) == 0);
53 my_xasprintf ("%Lg %d", (long double) 1.5, 33, 44, 55);
54 static const uint8_t expected[] = "1.5 33";
55 ASSERT (result != NULL);
56 ASSERT (u8_strcmp (result, expected) == 0);
60 /* Test the support of the 'U' conversion specifier for Unicode strings. */
63 static const uint8_t unicode_string[] = "Hello";
66 my_xasprintf ("%U %d", unicode_string, 33, 44, 55);
67 static const uint8_t expected[] = "Hello 33";
68 ASSERT (result != NULL);
69 ASSERT (u8_strcmp (result, expected) == 0);
74 my_xasprintf ("%10U %d", unicode_string, 33, 44, 55);
75 static const uint8_t expected[] = " Hello 33";
76 ASSERT (result != NULL);
77 ASSERT (u8_strcmp (result, expected) == 0);
82 my_xasprintf ("%-10U %d", unicode_string, 33, 44, 55);
83 static const uint8_t expected[] = "Hello 33";
84 ASSERT (result != NULL);
85 ASSERT (u8_strcmp (result, expected) == 0);
88 { /* FLAG_ZERO: no effect. */
90 my_xasprintf ("%010U %d", unicode_string, 33, 44, 55);
91 static const uint8_t expected[] = " Hello 33";
92 ASSERT (result != NULL);
93 ASSERT (u8_strcmp (result, expected) == 0);
99 static const uint16_t unicode_string[] = { 'H', 'e', 'l', 'l', 'o', 0 };
102 my_xasprintf ("%lU %d", unicode_string, 33, 44, 55);
103 static const uint8_t expected[] = "Hello 33";
104 ASSERT (result != NULL);
105 ASSERT (u8_strcmp (result, expected) == 0);
110 my_xasprintf ("%10lU %d", unicode_string, 33, 44, 55);
111 static const uint8_t expected[] = " Hello 33";
112 ASSERT (result != NULL);
113 ASSERT (u8_strcmp (result, expected) == 0);
118 my_xasprintf ("%-10lU %d", unicode_string, 33, 44, 55);
119 static const uint8_t expected[] = "Hello 33";
120 ASSERT (result != NULL);
121 ASSERT (u8_strcmp (result, expected) == 0);
124 { /* FLAG_ZERO: no effect. */
126 my_xasprintf ("%010lU %d", unicode_string, 33, 44, 55);
127 static const uint8_t expected[] = " Hello 33";
128 ASSERT (result != NULL);
129 ASSERT (u8_strcmp (result, expected) == 0);
135 static const uint32_t unicode_string[] = { 'H', 'e', 'l', 'l', 'o', 0 };
138 my_xasprintf ("%llU %d", unicode_string, 33, 44, 55);
139 static const uint8_t expected[] = "Hello 33";
140 ASSERT (result != NULL);
141 ASSERT (u8_strcmp (result, expected) == 0);
146 my_xasprintf ("%10llU %d", unicode_string, 33, 44, 55);
147 static const uint8_t expected[] = " Hello 33";
148 ASSERT (result != NULL);
149 ASSERT (u8_strcmp (result, expected) == 0);
154 my_xasprintf ("%-10llU %d", unicode_string, 33, 44, 55);
155 static const uint8_t expected[] = "Hello 33";
156 ASSERT (result != NULL);
157 ASSERT (u8_strcmp (result, expected) == 0);
160 { /* FLAG_ZERO: no effect. */
162 my_xasprintf ("%010llU %d", unicode_string, 33, 44, 55);
163 static const uint8_t expected[] = " Hello 33";
164 ASSERT (result != NULL);
165 ASSERT (u8_strcmp (result, expected) == 0);
170 /* Test the support of the 's' conversion specifier for strings. */
174 my_xasprintf ("Mr. %s %d", "Ronald Reagan", 33, 44, 55);
175 static const uint8_t expected[] = "Mr. Ronald Reagan 33";
176 ASSERT (result != NULL);
177 ASSERT (u8_strcmp (result, expected) == 0);
183 my_xasprintf ("Mr. %20s %d", "Ronald Reagan", 33, 44, 55);
184 static const uint8_t expected[] = "Mr. Ronald Reagan 33";
185 ASSERT (result != NULL);
186 ASSERT (u8_strcmp (result, expected) == 0);
192 my_xasprintf ("Mr. %-20s %d", "Ronald Reagan", 33, 44, 55);
193 static const uint8_t expected[] = "Mr. Ronald Reagan 33";
194 ASSERT (result != NULL);
195 ASSERT (u8_strcmp (result, expected) == 0);
199 { /* FLAG_ZERO: no effect. */
201 my_xasprintf ("Mr. %020s %d", "Ronald Reagan", 33, 44, 55);
202 static const uint8_t expected[] = "Mr. Ronald Reagan 33";
203 ASSERT (result != NULL);
204 ASSERT (u8_strcmp (result, expected) == 0);
208 /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
209 output of floating-point numbers. */
211 { /* A positive number. */
213 my_xasprintf ("%a %d", 3.1416015625, 33, 44, 55);
214 static const uint8_t expected1[] = "0x1.922p+1 33";
215 static const uint8_t expected2[] = "0x3.244p+0 33";
216 static const uint8_t expected3[] = "0x6.488p-1 33";
217 static const uint8_t expected4[] = "0xc.91p-2 33";
218 ASSERT (result != NULL);
219 ASSERT (u8_strcmp (result, expected1) == 0
220 || u8_strcmp (result, expected2) == 0
221 || u8_strcmp (result, expected3) == 0
222 || u8_strcmp (result, expected4) == 0);
228 my_xasprintf ("%10a %d", 1.75, 33, 44, 55);
229 static const uint8_t expected1[] = " 0x1.cp+0 33";
230 static const uint8_t expected2[] = " 0x3.8p-1 33";
231 static const uint8_t expected3[] = " 0x7p-2 33";
232 static const uint8_t expected4[] = " 0xep-3 33";
233 ASSERT (result != NULL);
234 ASSERT (u8_strcmp (result, expected1) == 0
235 || u8_strcmp (result, expected2) == 0
236 || u8_strcmp (result, expected3) == 0
237 || u8_strcmp (result, expected4) == 0);
241 { /* Small precision. */
243 my_xasprintf ("%.10a %d", 1.75, 33, 44, 55);
244 static const uint8_t expected1[] = "0x1.c000000000p+0 33";
245 static const uint8_t expected2[] = "0x3.8000000000p-1 33";
246 static const uint8_t expected3[] = "0x7.0000000000p-2 33";
247 static const uint8_t expected4[] = "0xe.0000000000p-3 33";
248 ASSERT (result != NULL);
249 ASSERT (u8_strcmp (result, expected1) == 0
250 || u8_strcmp (result, expected2) == 0
251 || u8_strcmp (result, expected3) == 0
252 || u8_strcmp (result, expected4) == 0);
256 { /* Large precision. */
258 my_xasprintf ("%.50a %d", 1.75, 33, 44, 55);
259 static const uint8_t expected1[] = "0x1.c0000000000000000000000000000000000000000000000000p+0 33";
260 static const uint8_t expected2[] = "0x3.80000000000000000000000000000000000000000000000000p-1 33";
261 static const uint8_t expected3[] = "0x7.00000000000000000000000000000000000000000000000000p-2 33";
262 static const uint8_t expected4[] = "0xe.00000000000000000000000000000000000000000000000000p-3 33";
263 ASSERT (result != NULL);
264 ASSERT (u8_strcmp (result, expected1) == 0
265 || u8_strcmp (result, expected2) == 0
266 || u8_strcmp (result, expected3) == 0
267 || u8_strcmp (result, expected4) == 0);
271 { /* A positive number. */
273 my_xasprintf ("%La %d", 3.1416015625L, 33, 44, 55);
274 static const uint8_t expected1[] = "0x1.922p+1 33";
275 static const uint8_t expected2[] = "0x3.244p+0 33";
276 static const uint8_t expected3[] = "0x6.488p-1 33";
277 static const uint8_t expected4[] = "0xc.91p-2 33";
278 ASSERT (result != NULL);
279 ASSERT (u8_strcmp (result, expected1) == 0
280 || u8_strcmp (result, expected2) == 0
281 || u8_strcmp (result, expected3) == 0
282 || u8_strcmp (result, expected4) == 0);
288 my_xasprintf ("%10La %d", 1.75L, 33, 44, 55);
289 static const uint8_t expected1[] = " 0x1.cp+0 33";
290 static const uint8_t expected2[] = " 0x3.8p-1 33";
291 static const uint8_t expected3[] = " 0x7p-2 33";
292 static const uint8_t expected4[] = " 0xep-3 33";
293 ASSERT (result != NULL);
294 ASSERT (u8_strcmp (result, expected1) == 0
295 || u8_strcmp (result, expected2) == 0
296 || u8_strcmp (result, expected3) == 0
297 || u8_strcmp (result, expected4) == 0);
301 { /* Small precision. */
303 my_xasprintf ("%.10La %d", 1.75L, 33, 44, 55);
304 static const uint8_t expected1[] = "0x1.c000000000p+0 33";
305 static const uint8_t expected2[] = "0x3.8000000000p-1 33";
306 static const uint8_t expected3[] = "0x7.0000000000p-2 33";
307 static const uint8_t expected4[] = "0xe.0000000000p-3 33";
308 ASSERT (result != NULL);
309 ASSERT (u8_strcmp (result, expected1) == 0
310 || u8_strcmp (result, expected2) == 0
311 || u8_strcmp (result, expected3) == 0
312 || u8_strcmp (result, expected4) == 0);
316 { /* Large precision. */
318 my_xasprintf ("%.50La %d", 1.75L, 33, 44, 55);
319 static const uint8_t expected1[] = "0x1.c0000000000000000000000000000000000000000000000000p+0 33";
320 static const uint8_t expected2[] = "0x3.80000000000000000000000000000000000000000000000000p-1 33";
321 static const uint8_t expected3[] = "0x7.00000000000000000000000000000000000000000000000000p-2 33";
322 static const uint8_t expected4[] = "0xe.00000000000000000000000000000000000000000000000000p-3 33";
323 ASSERT (result != NULL);
324 ASSERT (u8_strcmp (result, expected1) == 0
325 || u8_strcmp (result, expected2) == 0
326 || u8_strcmp (result, expected3) == 0
327 || u8_strcmp (result, expected4) == 0);
331 /* Test the support of the %f format directive. */
333 { /* A positive number. */
335 my_xasprintf ("%f %d", 12.75, 33, 44, 55);
336 static const uint8_t expected[] = "12.750000 33";
337 ASSERT (result != NULL);
338 ASSERT (u8_strcmp (result, expected) == 0);
344 my_xasprintf ("%10f %d", 1.75, 33, 44, 55);
345 static const uint8_t expected[] = " 1.750000 33";
346 ASSERT (result != NULL);
347 ASSERT (u8_strcmp (result, expected) == 0);
353 my_xasprintf ("%.f %d", 1234.0, 33, 44, 55);
354 static const uint8_t expected[] = "1234 33";
355 ASSERT (result != NULL);
356 ASSERT (u8_strcmp (result, expected) == 0);
360 { /* A positive number. */
362 my_xasprintf ("%Lf %d", 12.75L, 33, 44, 55);
363 static const uint8_t expected[] = "12.750000 33";
364 ASSERT (result != NULL);
365 ASSERT (u8_strcmp (result, expected) == 0);
371 my_xasprintf ("%10Lf %d", 1.75L, 33, 44, 55);
372 static const uint8_t expected[] = " 1.750000 33";
373 ASSERT (result != NULL);
374 ASSERT (u8_strcmp (result, expected) == 0);
380 my_xasprintf ("%.Lf %d", 1234.0L, 33, 44, 55);
381 static const uint8_t expected[] = "1234 33";
382 ASSERT (result != NULL);
383 ASSERT (u8_strcmp (result, expected) == 0);
387 /* Test the support of the %F format directive. */
389 { /* A positive number. */
391 my_xasprintf ("%F %d", 12.75, 33, 44, 55);
392 static const uint8_t expected[] = "12.750000 33";
393 ASSERT (result != NULL);
394 ASSERT (u8_strcmp (result, expected) == 0);
400 my_xasprintf ("%.F %d", 1234.0, 33, 44, 55);
401 static const uint8_t expected[] = "1234 33";
402 ASSERT (result != NULL);
403 ASSERT (u8_strcmp (result, expected) == 0);
407 { /* A positive number. */
409 my_xasprintf ("%LF %d", 12.75L, 33, 44, 55);
410 static const uint8_t expected[] = "12.750000 33";
411 ASSERT (result != NULL);
412 ASSERT (u8_strcmp (result, expected) == 0);
418 my_xasprintf ("%.LF %d", 1234.0L, 33, 44, 55);
419 static const uint8_t expected[] = "1234 33";
420 ASSERT (result != NULL);
421 ASSERT (u8_strcmp (result, expected) == 0);
425 /* Test the support of the %e format directive. */
427 { /* A positive number. */
429 my_xasprintf ("%e %d", 12.75, 33, 44, 55);
430 static const uint8_t expected1[] = "1.275000e+01 33";
431 static const uint8_t expected2[] = "1.275000e+001 33";
432 ASSERT (result != NULL);
433 ASSERT (u8_strcmp (result, expected1) == 0
434 || u8_strcmp (result, expected2) == 0);
440 my_xasprintf ("%15e %d", 1.75, 33, 44, 55);
441 static const uint8_t expected1[] = " 1.750000e+00 33";
442 static const uint8_t expected2[] = " 1.750000e+000 33";
443 ASSERT (result != NULL);
444 ASSERT (u8_strcmp (result, expected1) == 0
445 || u8_strcmp (result, expected2) == 0);
451 my_xasprintf ("%.e %d", 1234.0, 33, 44, 55);
452 static const uint8_t expected1[] = "1e+03 33";
453 static const uint8_t expected2[] = "1e+003 33";
454 ASSERT (result != NULL);
455 ASSERT (u8_strcmp (result, expected1) == 0
456 || u8_strcmp (result, expected2) == 0);
460 { /* A positive number. */
462 my_xasprintf ("%Le %d", 12.75L, 33, 44, 55);
463 static const uint8_t expected[] = "1.275000e+01 33";
464 ASSERT (result != NULL);
465 ASSERT (u8_strcmp (result, expected) == 0);
471 my_xasprintf ("%15Le %d", 1.75L, 33, 44, 55);
472 static const uint8_t expected[] = " 1.750000e+00 33";
473 ASSERT (result != NULL);
474 ASSERT (u8_strcmp (result, expected) == 0);
480 my_xasprintf ("%.Le %d", 1234.0L, 33, 44, 55);
481 static const uint8_t expected[] = "1e+03 33";
482 ASSERT (result != NULL);
483 ASSERT (u8_strcmp (result, expected) == 0);
487 /* Test the support of the %g format directive. */
489 { /* A positive number. */
491 my_xasprintf ("%g %d", 12.75, 33, 44, 55);
492 static const uint8_t expected[] = "12.75 33";
493 ASSERT (result != NULL);
494 ASSERT (u8_strcmp (result, expected) == 0);
500 my_xasprintf ("%10g %d", 1.75, 33, 44, 55);
501 static const uint8_t expected[] = " 1.75 33";
502 ASSERT (result != NULL);
503 ASSERT (u8_strcmp (result, expected) == 0);
509 my_xasprintf ("%.g %d", 1234.0, 33, 44, 55);
510 static const uint8_t expected1[] = "1e+03 33";
511 static const uint8_t expected2[] = "1e+003 33";
512 ASSERT (result != NULL);
513 ASSERT (u8_strcmp (result, expected1) == 0
514 || u8_strcmp (result, expected2) == 0);
518 { /* A positive number. */
520 my_xasprintf ("%Lg %d", 12.75L, 33, 44, 55);
521 static const uint8_t expected[] = "12.75 33";
522 ASSERT (result != NULL);
523 ASSERT (u8_strcmp (result, expected) == 0);
529 my_xasprintf ("%10Lg %d", 1.75L, 33, 44, 55);
530 static const uint8_t expected[] = " 1.75 33";
531 ASSERT (result != NULL);
532 ASSERT (u8_strcmp (result, expected) == 0);
538 my_xasprintf ("%.Lg %d", 1234.0L, 33, 44, 55);
539 static const uint8_t expected[] = "1e+03 33";
540 ASSERT (result != NULL);
541 ASSERT (u8_strcmp (result, expected) == 0);
545 /* Test the support of the %n format directive. */
550 my_xasprintf ("%d %n", 123, &count, 33, 44, 55);
551 static const uint8_t expected[] = "123 ";
552 ASSERT (result != NULL);
553 ASSERT (u8_strcmp (result, expected) == 0);
558 /* Test the support of the POSIX/XSI format strings with positions. */
562 my_xasprintf ("%2$d %1$d", 33, 55);
563 static const uint8_t expected[] = "55 33";
564 ASSERT (result != NULL);
565 ASSERT (u8_strcmp (result, expected) == 0);
569 /* Test the support of the grouping flag. */
573 my_xasprintf ("%'d %d", 1234567, 99);
574 ASSERT (result != NULL);
575 ASSERT (result[u8_strlen (result) - 1] == '9');
579 /* Test the support of the 'U' conversion specifier for Unicode strings. */
582 static const uint8_t unicode_string[] = "Rafa\305\202 Maszkowski"; /* Rafał Maszkowski */
585 my_xasprintf ("%U %d", unicode_string, 33, 44, 55);
586 static const uint8_t expected[] = "Rafa\305\202 Maszkowski 33";
587 ASSERT (result != NULL);
588 ASSERT (u8_strcmp (result, expected) == 0);
593 my_xasprintf ("%20U %d", unicode_string, 33, 44, 55);
594 static const uint8_t expected[] = " Rafa\305\202 Maszkowski 33";
595 ASSERT (result != NULL);
596 ASSERT (u8_strcmp (result, expected) == 0);
601 my_xasprintf ("%-20U %d", unicode_string, 33, 44, 55);
602 static const uint8_t expected[] = "Rafa\305\202 Maszkowski 33";
603 ASSERT (result != NULL);
604 ASSERT (u8_strcmp (result, expected) == 0);
607 { /* FLAG_ZERO: no effect. */
609 my_xasprintf ("%020U %d", unicode_string, 33, 44, 55);
610 static const uint8_t expected[] = " Rafa\305\202 Maszkowski 33";
611 ASSERT (result != NULL);
612 ASSERT (u8_strcmp (result, expected) == 0);
618 static const uint16_t unicode_string[] = /* Rafał Maszkowski */
620 'R', 'a', 'f', 'a', 0x0142, ' ', 'M', 'a', 's', 'z', 'k', 'o', 'w',
625 my_xasprintf ("%lU %d", unicode_string, 33, 44, 55);
626 static const uint8_t expected[] = "Rafa\305\202 Maszkowski 33";
627 ASSERT (result != NULL);
628 ASSERT (u8_strcmp (result, expected) == 0);
633 my_xasprintf ("%20lU %d", unicode_string, 33, 44, 55);
634 static const uint8_t expected[] = " Rafa\305\202 Maszkowski 33";
635 ASSERT (result != NULL);
636 ASSERT (u8_strcmp (result, expected) == 0);
641 my_xasprintf ("%-20lU %d", unicode_string, 33, 44, 55);
642 static const uint8_t expected[] = "Rafa\305\202 Maszkowski 33";
643 ASSERT (result != NULL);
644 ASSERT (u8_strcmp (result, expected) == 0);
647 { /* FLAG_ZERO: no effect. */
649 my_xasprintf ("%020lU %d", unicode_string, 33, 44, 55);
650 static const uint8_t expected[] = " Rafa\305\202 Maszkowski 33";
651 ASSERT (result != NULL);
652 ASSERT (u8_strcmp (result, expected) == 0);
658 static const uint32_t unicode_string[] = /* Rafał Maszkowski */
660 'R', 'a', 'f', 'a', 0x0142, ' ', 'M', 'a', 's', 'z', 'k', 'o', 'w',
665 my_xasprintf ("%llU %d", unicode_string, 33, 44, 55);
666 static const uint8_t expected[] = "Rafa\305\202 Maszkowski 33";
667 ASSERT (result != NULL);
668 ASSERT (u8_strcmp (result, expected) == 0);
673 my_xasprintf ("%20llU %d", unicode_string, 33, 44, 55);
674 static const uint8_t expected[] = " Rafa\305\202 Maszkowski 33";
675 ASSERT (result != NULL);
676 ASSERT (u8_strcmp (result, expected) == 0);
681 my_xasprintf ("%-20llU %d", unicode_string, 33, 44, 55);
682 static const uint8_t expected[] = "Rafa\305\202 Maszkowski 33";
683 ASSERT (result != NULL);
684 ASSERT (u8_strcmp (result, expected) == 0);
687 { /* FLAG_ZERO: no effect. */
689 my_xasprintf ("%020llU %d", unicode_string, 33, 44, 55);
690 static const uint8_t expected[] = " Rafa\305\202 Maszkowski 33";
691 ASSERT (result != NULL);
692 ASSERT (u8_strcmp (result, expected) == 0);
697 /* Test non-ASCII characters in the format string. */
701 my_xasprintf ("\304rger", 33, 44, 55);
702 ASSERT (result == NULL && errno == EINVAL);