1 /* Test of POSIX compatible vasprintf() and asprintf() functions.
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. */
33 #define SIZEOF(array) (sizeof (array) / sizeof (array[0]))
34 #define ASSERT(expr) \
39 fprintf (stderr, "%s:%d: assertion failed\n", __FILE__, __LINE__); \
45 /* The Compaq (ex-DEC) C 6.4 compiler chokes on the expression 0.0 / 0.0. */
50 static double zero = 0.0;
54 # define NaN() (0.0 / 0.0)
57 /* The SGI MIPS floating-point format does not distinguish 0.0 and -0.0. */
61 static double plus_zero = 0.0;
62 static double minus_zero = -0.0;
63 return memcmp (&plus_zero, &minus_zero, sizeof (double)) != 0;
67 strmatch (const char *pattern, const char *string)
69 if (strlen (pattern) != strlen (string))
71 for (; *pattern != '\0'; pattern++, string++)
72 if (*pattern != '*' && *string != *pattern)
78 test_function (int (*my_asprintf) (char **, const char *, ...))
82 /* Test return value convention. */
84 for (repeat = 0; repeat <= 8; repeat++)
87 int retval = asprintf (&result, "%d", 12345);
89 ASSERT (result != NULL);
90 ASSERT (strcmp (result, "12345") == 0);
94 /* Test support of size specifiers as in C99. */
99 my_asprintf (&result, "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
100 ASSERT (result != NULL);
101 ASSERT (strcmp (result, "12345671 33") == 0);
102 ASSERT (retval == strlen (result));
109 my_asprintf (&result, "%zu %d", (size_t) 12345672, 33, 44, 55);
110 ASSERT (result != NULL);
111 ASSERT (strcmp (result, "12345672 33") == 0);
112 ASSERT (retval == strlen (result));
119 my_asprintf (&result, "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
120 ASSERT (result != NULL);
121 ASSERT (strcmp (result, "12345673 33") == 0);
122 ASSERT (retval == strlen (result));
129 my_asprintf (&result, "%Lg %d", (long double) 1.5, 33, 44, 55);
130 ASSERT (result != NULL);
131 ASSERT (strcmp (result, "1.5 33") == 0);
132 ASSERT (retval == strlen (result));
136 /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
137 output of floating-point numbers. */
139 { /* A positive number. */
142 my_asprintf (&result, "%a %d", 3.1416015625, 33, 44, 55);
143 ASSERT (result != NULL);
144 ASSERT (strcmp (result, "0x1.922p+1 33") == 0
145 || strcmp (result, "0x3.244p+0 33") == 0
146 || strcmp (result, "0x6.488p-1 33") == 0
147 || strcmp (result, "0xc.91p-2 33") == 0);
148 ASSERT (retval == strlen (result));
152 { /* A negative number. */
155 my_asprintf (&result, "%A %d", -3.1416015625, 33, 44, 55);
156 ASSERT (result != NULL);
157 ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
158 || strcmp (result, "-0X3.244P+0 33") == 0
159 || strcmp (result, "-0X6.488P-1 33") == 0
160 || strcmp (result, "-0XC.91P-2 33") == 0);
161 ASSERT (retval == strlen (result));
165 { /* Positive zero. */
168 my_asprintf (&result, "%a %d", 0.0, 33, 44, 55);
169 ASSERT (result != NULL);
170 ASSERT (strcmp (result, "0x0p+0 33") == 0);
171 ASSERT (retval == strlen (result));
175 { /* Negative zero. */
178 my_asprintf (&result, "%a %d", -0.0, 33, 44, 55);
179 ASSERT (result != NULL);
180 if (have_minus_zero ())
181 ASSERT (strcmp (result, "-0x0p+0 33") == 0);
182 ASSERT (retval == strlen (result));
186 { /* Positive infinity. */
189 my_asprintf (&result, "%a %d", 1.0 / 0.0, 33, 44, 55);
190 ASSERT (result != NULL);
191 ASSERT (strcmp (result, "inf 33") == 0);
192 ASSERT (retval == strlen (result));
196 { /* Negative infinity. */
199 my_asprintf (&result, "%a %d", -1.0 / 0.0, 33, 44, 55);
200 ASSERT (result != NULL);
201 ASSERT (strcmp (result, "-inf 33") == 0);
202 ASSERT (retval == strlen (result));
209 my_asprintf (&result, "%a %d", NaN (), 33, 44, 55);
210 ASSERT (result != NULL);
211 ASSERT (strlen (result) >= 3 + 3
212 && memcmp (result, "nan", 3) == 0
213 && strcmp (result + strlen (result) - 3, " 33") == 0);
214 ASSERT (retval == strlen (result));
218 { /* Rounding near the decimal point. */
221 my_asprintf (&result, "%.0a %d", 1.5, 33, 44, 55);
222 ASSERT (result != NULL);
223 ASSERT (strcmp (result, "0x2p+0 33") == 0
224 || strcmp (result, "0x3p-1 33") == 0
225 || strcmp (result, "0x6p-2 33") == 0
226 || strcmp (result, "0xcp-3 33") == 0);
227 ASSERT (retval == strlen (result));
231 { /* Rounding with precision 0. */
234 my_asprintf (&result, "%.0a %d", 1.51, 33, 44, 55);
235 ASSERT (result != NULL);
236 ASSERT (strcmp (result, "0x2p+0 33") == 0
237 || strcmp (result, "0x3p-1 33") == 0
238 || strcmp (result, "0x6p-2 33") == 0
239 || strcmp (result, "0xcp-3 33") == 0);
240 ASSERT (retval == strlen (result));
244 { /* Rounding with precision 1. */
247 my_asprintf (&result, "%.1a %d", 1.51, 33, 44, 55);
248 ASSERT (result != NULL);
249 ASSERT (strcmp (result, "0x1.8p+0 33") == 0
250 || strcmp (result, "0x3.0p-1 33") == 0
251 || strcmp (result, "0x6.1p-2 33") == 0
252 || strcmp (result, "0xc.1p-3 33") == 0);
253 ASSERT (retval == strlen (result));
257 { /* Rounding with precision 2. */
260 my_asprintf (&result, "%.2a %d", 1.51, 33, 44, 55);
261 ASSERT (result != NULL);
262 ASSERT (strcmp (result, "0x1.83p+0 33") == 0
263 || strcmp (result, "0x3.05p-1 33") == 0
264 || strcmp (result, "0x6.0ap-2 33") == 0
265 || strcmp (result, "0xc.14p-3 33") == 0);
266 ASSERT (retval == strlen (result));
270 { /* Rounding with precision 3. */
273 my_asprintf (&result, "%.3a %d", 1.51, 33, 44, 55);
274 ASSERT (result != NULL);
275 ASSERT (strcmp (result, "0x1.829p+0 33") == 0
276 || strcmp (result, "0x3.052p-1 33") == 0
277 || strcmp (result, "0x6.0a4p-2 33") == 0
278 || strcmp (result, "0xc.148p-3 33") == 0);
279 ASSERT (retval == strlen (result));
283 { /* Rounding can turn a ...FFF into a ...000. */
286 my_asprintf (&result, "%.3a %d", 1.49999, 33, 44, 55);
287 ASSERT (result != NULL);
288 ASSERT (strcmp (result, "0x1.800p+0 33") == 0
289 || strcmp (result, "0x3.000p-1 33") == 0
290 || strcmp (result, "0x6.000p-2 33") == 0
291 || strcmp (result, "0xc.000p-3 33") == 0);
292 ASSERT (retval == strlen (result));
296 { /* Rounding can turn a ...FFF into a ...000.
297 This shows a MacOS X 10.3.9 (Darwin 7.9) bug. */
300 my_asprintf (&result, "%.1a %d", 1.999, 33, 44, 55);
301 ASSERT (result != NULL);
302 ASSERT (strcmp (result, "0x1.0p+1 33") == 0
303 || strcmp (result, "0x2.0p+0 33") == 0
304 || strcmp (result, "0x4.0p-1 33") == 0
305 || strcmp (result, "0x8.0p-2 33") == 0);
306 ASSERT (retval == strlen (result));
313 my_asprintf (&result, "%10a %d", 1.75, 33, 44, 55);
314 ASSERT (result != NULL);
315 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
316 || strcmp (result, " 0x3.8p-1 33") == 0
317 || strcmp (result, " 0x7p-2 33") == 0
318 || strcmp (result, " 0xep-3 33") == 0);
319 ASSERT (retval == strlen (result));
323 { /* Small precision. */
326 my_asprintf (&result, "%.10a %d", 1.75, 33, 44, 55);
327 ASSERT (result != NULL);
328 ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
329 || strcmp (result, "0x3.8000000000p-1 33") == 0
330 || strcmp (result, "0x7.0000000000p-2 33") == 0
331 || strcmp (result, "0xe.0000000000p-3 33") == 0);
332 ASSERT (retval == strlen (result));
336 { /* Large precision. */
339 my_asprintf (&result, "%.50a %d", 1.75, 33, 44, 55);
340 ASSERT (result != NULL);
341 ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
342 || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
343 || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
344 || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
345 ASSERT (retval == strlen (result));
352 my_asprintf (&result, "%-10a %d", 1.75, 33, 44, 55);
353 ASSERT (result != NULL);
354 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
355 || strcmp (result, "0x3.8p-1 33") == 0
356 || strcmp (result, "0x7p-2 33") == 0
357 || strcmp (result, "0xep-3 33") == 0);
358 ASSERT (retval == strlen (result));
362 { /* FLAG_SHOWSIGN. */
365 my_asprintf (&result, "%+a %d", 1.75, 33, 44, 55);
366 ASSERT (result != NULL);
367 ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
368 || strcmp (result, "+0x3.8p-1 33") == 0
369 || strcmp (result, "+0x7p-2 33") == 0
370 || strcmp (result, "+0xep-3 33") == 0);
371 ASSERT (retval == strlen (result));
378 my_asprintf (&result, "% a %d", 1.75, 33, 44, 55);
379 ASSERT (result != NULL);
380 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
381 || strcmp (result, " 0x3.8p-1 33") == 0
382 || strcmp (result, " 0x7p-2 33") == 0
383 || strcmp (result, " 0xep-3 33") == 0);
384 ASSERT (retval == strlen (result));
391 my_asprintf (&result, "%#a %d", 1.75, 33, 44, 55);
392 ASSERT (result != NULL);
393 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
394 || strcmp (result, "0x3.8p-1 33") == 0
395 || strcmp (result, "0x7.p-2 33") == 0
396 || strcmp (result, "0xe.p-3 33") == 0);
397 ASSERT (retval == strlen (result));
404 my_asprintf (&result, "%#a %d", 1.0, 33, 44, 55);
405 ASSERT (result != NULL);
406 ASSERT (strcmp (result, "0x1.p+0 33") == 0
407 || strcmp (result, "0x2.p-1 33") == 0
408 || strcmp (result, "0x4.p-2 33") == 0
409 || strcmp (result, "0x8.p-3 33") == 0);
410 ASSERT (retval == strlen (result));
414 { /* FLAG_ZERO with finite number. */
417 my_asprintf (&result, "%010a %d", 1.75, 33, 44, 55);
418 ASSERT (result != NULL);
419 ASSERT (strcmp (result, "0x001.cp+0 33") == 0
420 || strcmp (result, "0x003.8p-1 33") == 0
421 || strcmp (result, "0x00007p-2 33") == 0
422 || strcmp (result, "0x0000ep-3 33") == 0);
423 ASSERT (retval == strlen (result));
427 { /* FLAG_ZERO with infinite number. */
430 my_asprintf (&result, "%010a %d", 1.0 / 0.0, 33, 44, 55);
431 ASSERT (result != NULL);
432 /* "0000000inf 33" is not a valid result; see
433 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
434 ASSERT (strcmp (result, " inf 33") == 0);
435 ASSERT (retval == strlen (result));
439 { /* FLAG_ZERO with NaN. */
442 my_asprintf (&result, "%020a %d", NaN (), 33, 44, 55);
443 ASSERT (result != NULL);
444 /* "0000000nan 33" is not a valid result; see
445 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
446 ASSERT (strlen (result) == 20 + 3
447 && memcmp (result + strspn (result, " "), "nan", 3) == 0
448 && strcmp (result + strlen (result) - 3, " 33") == 0);
449 ASSERT (retval == strlen (result));
453 { /* A positive number. */
456 my_asprintf (&result, "%La %d", 3.1416015625L, 33, 44, 55);
457 ASSERT (result != NULL);
458 ASSERT (strcmp (result, "0x1.922p+1 33") == 0
459 || strcmp (result, "0x3.244p+0 33") == 0
460 || strcmp (result, "0x6.488p-1 33") == 0
461 || strcmp (result, "0xc.91p-2 33") == 0);
462 ASSERT (retval == strlen (result));
466 { /* A negative number. */
469 my_asprintf (&result, "%LA %d", -3.1416015625L, 33, 44, 55);
470 ASSERT (result != NULL);
471 ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
472 || strcmp (result, "-0X3.244P+0 33") == 0
473 || strcmp (result, "-0X6.488P-1 33") == 0
474 || strcmp (result, "-0XC.91P-2 33") == 0);
475 ASSERT (retval == strlen (result));
479 { /* Positive zero. */
482 my_asprintf (&result, "%La %d", 0.0L, 33, 44, 55);
483 ASSERT (result != NULL);
484 ASSERT (strcmp (result, "0x0p+0 33") == 0);
485 ASSERT (retval == strlen (result));
489 { /* Negative zero. */
492 my_asprintf (&result, "%La %d", -0.0L, 33, 44, 55);
493 ASSERT (result != NULL);
494 if (have_minus_zero ())
495 ASSERT (strcmp (result, "-0x0p+0 33") == 0);
496 ASSERT (retval == strlen (result));
500 { /* Positive infinity. */
503 my_asprintf (&result, "%La %d", 1.0L / 0.0L, 33, 44, 55);
504 ASSERT (result != NULL);
505 ASSERT (strcmp (result, "inf 33") == 0);
506 ASSERT (retval == strlen (result));
510 { /* Negative infinity. */
513 my_asprintf (&result, "%La %d", -1.0L / 0.0L, 33, 44, 55);
514 ASSERT (result != NULL);
515 ASSERT (strcmp (result, "-inf 33") == 0);
516 ASSERT (retval == strlen (result));
523 my_asprintf (&result, "%La %d", 0.0L / 0.0L, 33, 44, 55);
524 ASSERT (result != NULL);
525 ASSERT (strlen (result) >= 3 + 3
526 && memcmp (result, "nan", 3) == 0
527 && strcmp (result + strlen (result) - 3, " 33") == 0);
528 ASSERT (retval == strlen (result));
532 { /* Rounding near the decimal point. */
535 my_asprintf (&result, "%.0La %d", 1.5L, 33, 44, 55);
536 ASSERT (result != NULL);
537 ASSERT (strcmp (result, "0x2p+0 33") == 0
538 || strcmp (result, "0x3p-1 33") == 0
539 || strcmp (result, "0x6p-2 33") == 0
540 || strcmp (result, "0xcp-3 33") == 0);
541 ASSERT (retval == strlen (result));
545 { /* Rounding with precision 0. */
548 my_asprintf (&result, "%.0La %d", 1.51L, 33, 44, 55);
549 ASSERT (result != NULL);
550 ASSERT (strcmp (result, "0x2p+0 33") == 0
551 || strcmp (result, "0x3p-1 33") == 0
552 || strcmp (result, "0x6p-2 33") == 0
553 || strcmp (result, "0xcp-3 33") == 0);
554 ASSERT (retval == strlen (result));
558 { /* Rounding with precision 1. */
561 my_asprintf (&result, "%.1La %d", 1.51L, 33, 44, 55);
562 ASSERT (result != NULL);
563 ASSERT (strcmp (result, "0x1.8p+0 33") == 0
564 || strcmp (result, "0x3.0p-1 33") == 0
565 || strcmp (result, "0x6.1p-2 33") == 0
566 || strcmp (result, "0xc.1p-3 33") == 0);
567 ASSERT (retval == strlen (result));
571 { /* Rounding with precision 2. */
574 my_asprintf (&result, "%.2La %d", 1.51L, 33, 44, 55);
575 ASSERT (result != NULL);
576 ASSERT (strcmp (result, "0x1.83p+0 33") == 0
577 || strcmp (result, "0x3.05p-1 33") == 0
578 || strcmp (result, "0x6.0ap-2 33") == 0
579 || strcmp (result, "0xc.14p-3 33") == 0);
580 ASSERT (retval == strlen (result));
584 { /* Rounding with precision 3. */
587 my_asprintf (&result, "%.3La %d", 1.51L, 33, 44, 55);
588 ASSERT (result != NULL);
589 ASSERT (strcmp (result, "0x1.829p+0 33") == 0
590 || strcmp (result, "0x3.052p-1 33") == 0
591 || strcmp (result, "0x6.0a4p-2 33") == 0
592 || strcmp (result, "0xc.148p-3 33") == 0);
593 ASSERT (retval == strlen (result));
597 { /* Rounding can turn a ...FFF into a ...000. */
600 my_asprintf (&result, "%.3La %d", 1.49999L, 33, 44, 55);
601 ASSERT (result != NULL);
602 ASSERT (strcmp (result, "0x1.800p+0 33") == 0
603 || strcmp (result, "0x3.000p-1 33") == 0
604 || strcmp (result, "0x6.000p-2 33") == 0
605 || strcmp (result, "0xc.000p-3 33") == 0);
606 ASSERT (retval == strlen (result));
610 { /* Rounding can turn a ...FFF into a ...000.
611 This shows a MacOS X 10.3.9 (Darwin 7.9) bug and a
612 glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>. */
615 my_asprintf (&result, "%.1La %d", 1.999L, 33, 44, 55);
616 ASSERT (result != NULL);
617 ASSERT (strcmp (result, "0x1.0p+1 33") == 0
618 || strcmp (result, "0x2.0p+0 33") == 0
619 || strcmp (result, "0x4.0p-1 33") == 0
620 || strcmp (result, "0x8.0p-2 33") == 0);
621 ASSERT (retval == strlen (result));
628 my_asprintf (&result, "%10La %d", 1.75L, 33, 44, 55);
629 ASSERT (result != NULL);
630 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
631 || strcmp (result, " 0x3.8p-1 33") == 0
632 || strcmp (result, " 0x7p-2 33") == 0
633 || strcmp (result, " 0xep-3 33") == 0);
634 ASSERT (retval == strlen (result));
638 { /* Small precision. */
641 my_asprintf (&result, "%.10La %d", 1.75L, 33, 44, 55);
642 ASSERT (result != NULL);
643 ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
644 || strcmp (result, "0x3.8000000000p-1 33") == 0
645 || strcmp (result, "0x7.0000000000p-2 33") == 0
646 || strcmp (result, "0xe.0000000000p-3 33") == 0);
647 ASSERT (retval == strlen (result));
651 { /* Large precision. */
654 my_asprintf (&result, "%.50La %d", 1.75L, 33, 44, 55);
655 ASSERT (result != NULL);
656 ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
657 || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
658 || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
659 || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
660 ASSERT (retval == strlen (result));
667 my_asprintf (&result, "%-10La %d", 1.75L, 33, 44, 55);
668 ASSERT (result != NULL);
669 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
670 || strcmp (result, "0x3.8p-1 33") == 0
671 || strcmp (result, "0x7p-2 33") == 0
672 || strcmp (result, "0xep-3 33") == 0);
673 ASSERT (retval == strlen (result));
677 { /* FLAG_SHOWSIGN. */
680 my_asprintf (&result, "%+La %d", 1.75L, 33, 44, 55);
681 ASSERT (result != NULL);
682 ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
683 || strcmp (result, "+0x3.8p-1 33") == 0
684 || strcmp (result, "+0x7p-2 33") == 0
685 || strcmp (result, "+0xep-3 33") == 0);
686 ASSERT (retval == strlen (result));
693 my_asprintf (&result, "% La %d", 1.75L, 33, 44, 55);
694 ASSERT (result != NULL);
695 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
696 || strcmp (result, " 0x3.8p-1 33") == 0
697 || strcmp (result, " 0x7p-2 33") == 0
698 || strcmp (result, " 0xep-3 33") == 0);
699 ASSERT (retval == strlen (result));
706 my_asprintf (&result, "%#La %d", 1.75L, 33, 44, 55);
707 ASSERT (result != NULL);
708 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
709 || strcmp (result, "0x3.8p-1 33") == 0
710 || strcmp (result, "0x7.p-2 33") == 0
711 || strcmp (result, "0xe.p-3 33") == 0);
712 ASSERT (retval == strlen (result));
719 my_asprintf (&result, "%#La %d", 1.0L, 33, 44, 55);
720 ASSERT (result != NULL);
721 ASSERT (strcmp (result, "0x1.p+0 33") == 0
722 || strcmp (result, "0x2.p-1 33") == 0
723 || strcmp (result, "0x4.p-2 33") == 0
724 || strcmp (result, "0x8.p-3 33") == 0);
725 ASSERT (retval == strlen (result));
729 { /* FLAG_ZERO with finite number. */
732 my_asprintf (&result, "%010La %d", 1.75L, 33, 44, 55);
733 ASSERT (result != NULL);
734 ASSERT (strcmp (result, "0x001.cp+0 33") == 0
735 || strcmp (result, "0x003.8p-1 33") == 0
736 || strcmp (result, "0x00007p-2 33") == 0
737 || strcmp (result, "0x0000ep-3 33") == 0);
738 ASSERT (retval == strlen (result));
742 { /* FLAG_ZERO with infinite number. */
745 my_asprintf (&result, "%010La %d", 1.0L / 0.0L, 33, 44, 55);
746 ASSERT (result != NULL);
747 /* "0000000inf 33" is not a valid result; see
748 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
749 ASSERT (strcmp (result, " inf 33") == 0);
750 ASSERT (retval == strlen (result));
754 { /* FLAG_ZERO with NaN. */
757 my_asprintf (&result, "%020La %d", 0.0L / 0.0L, 33, 44, 55);
758 ASSERT (result != NULL);
759 /* "0000000nan 33" is not a valid result; see
760 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
761 ASSERT (strlen (result) == 20 + 3
762 && memcmp (result + strspn (result, " "), "nan", 3) == 0
763 && strcmp (result + strlen (result) - 3, " 33") == 0);
764 ASSERT (retval == strlen (result));
768 /* Test the support of the %f format directive. */
770 { /* A positive number. */
773 my_asprintf (&result, "%f %d", 12.75, 33, 44, 55);
774 ASSERT (result != NULL);
775 ASSERT (strcmp (result, "12.750000 33") == 0);
776 ASSERT (retval == strlen (result));
780 { /* A larger positive number. */
783 my_asprintf (&result, "%f %d", 1234567.0, 33, 44, 55);
784 ASSERT (result != NULL);
785 ASSERT (strcmp (result, "1234567.000000 33") == 0);
786 ASSERT (retval == strlen (result));
790 { /* Small and large positive numbers. */
791 static struct { double value; const char *string; } data[] =
793 { 1.234321234321234e-37, "0.000000" },
794 { 1.234321234321234e-36, "0.000000" },
795 { 1.234321234321234e-35, "0.000000" },
796 { 1.234321234321234e-34, "0.000000" },
797 { 1.234321234321234e-33, "0.000000" },
798 { 1.234321234321234e-32, "0.000000" },
799 { 1.234321234321234e-31, "0.000000" },
800 { 1.234321234321234e-30, "0.000000" },
801 { 1.234321234321234e-29, "0.000000" },
802 { 1.234321234321234e-28, "0.000000" },
803 { 1.234321234321234e-27, "0.000000" },
804 { 1.234321234321234e-26, "0.000000" },
805 { 1.234321234321234e-25, "0.000000" },
806 { 1.234321234321234e-24, "0.000000" },
807 { 1.234321234321234e-23, "0.000000" },
808 { 1.234321234321234e-22, "0.000000" },
809 { 1.234321234321234e-21, "0.000000" },
810 { 1.234321234321234e-20, "0.000000" },
811 { 1.234321234321234e-19, "0.000000" },
812 { 1.234321234321234e-18, "0.000000" },
813 { 1.234321234321234e-17, "0.000000" },
814 { 1.234321234321234e-16, "0.000000" },
815 { 1.234321234321234e-15, "0.000000" },
816 { 1.234321234321234e-14, "0.000000" },
817 { 1.234321234321234e-13, "0.000000" },
818 { 1.234321234321234e-12, "0.000000" },
819 { 1.234321234321234e-11, "0.000000" },
820 { 1.234321234321234e-10, "0.000000" },
821 { 1.234321234321234e-9, "0.000000" },
822 { 1.234321234321234e-8, "0.000000" },
823 { 1.234321234321234e-7, "0.000000" },
824 { 1.234321234321234e-6, "0.000001" },
825 { 1.234321234321234e-5, "0.000012" },
826 { 1.234321234321234e-4, "0.000123" },
827 { 1.234321234321234e-3, "0.001234" },
828 { 1.234321234321234e-2, "0.012343" },
829 { 1.234321234321234e-1, "0.123432" },
830 { 1.234321234321234, "1.234321" },
831 { 1.234321234321234e1, "12.343212" },
832 { 1.234321234321234e2, "123.432123" },
833 { 1.234321234321234e3, "1234.321234" },
834 { 1.234321234321234e4, "12343.212343" },
835 { 1.234321234321234e5, "123432.123432" },
836 { 1.234321234321234e6, "1234321.234321" },
837 { 1.234321234321234e7, "12343212.343212" },
838 { 1.234321234321234e8, "123432123.432123" },
839 { 1.234321234321234e9, "1234321234.321234" },
840 { 1.234321234321234e10, "12343212343.2123**" },
841 { 1.234321234321234e11, "123432123432.123***" },
842 { 1.234321234321234e12, "1234321234321.23****" },
843 { 1.234321234321234e13, "12343212343212.3*****" },
844 { 1.234321234321234e14, "123432123432123.******" },
845 { 1.234321234321234e15, "1234321234321234.000000" },
846 { 1.234321234321234e16, "123432123432123**.000000" },
847 { 1.234321234321234e17, "123432123432123***.000000" },
848 { 1.234321234321234e18, "123432123432123****.000000" },
849 { 1.234321234321234e19, "123432123432123*****.000000" },
850 { 1.234321234321234e20, "123432123432123******.000000" },
851 { 1.234321234321234e21, "123432123432123*******.000000" },
852 { 1.234321234321234e22, "123432123432123********.000000" },
853 { 1.234321234321234e23, "123432123432123*********.000000" },
854 { 1.234321234321234e24, "123432123432123**********.000000" },
855 { 1.234321234321234e25, "123432123432123***********.000000" },
856 { 1.234321234321234e26, "123432123432123************.000000" },
857 { 1.234321234321234e27, "123432123432123*************.000000" },
858 { 1.234321234321234e28, "123432123432123**************.000000" },
859 { 1.234321234321234e29, "123432123432123***************.000000" },
860 { 1.234321234321234e30, "123432123432123****************.000000" },
861 { 1.234321234321234e31, "123432123432123*****************.000000" },
862 { 1.234321234321234e32, "123432123432123******************.000000" },
863 { 1.234321234321234e33, "123432123432123*******************.000000" },
864 { 1.234321234321234e34, "123432123432123********************.000000" },
865 { 1.234321234321234e35, "123432123432123*********************.000000" },
866 { 1.234321234321234e36, "123432123432123**********************.000000" }
869 for (k = 0; k < SIZEOF (data); k++)
873 my_asprintf (&result, "%f", data[k].value);
874 ASSERT (result != NULL);
875 ASSERT (strmatch (data[k].string, result));
876 ASSERT (retval == strlen (result));
881 { /* A negative number. */
884 my_asprintf (&result, "%f %d", -0.03125, 33, 44, 55);
885 ASSERT (result != NULL);
886 ASSERT (strcmp (result, "-0.031250 33") == 0);
887 ASSERT (retval == strlen (result));
891 { /* Positive zero. */
894 my_asprintf (&result, "%f %d", 0.0, 33, 44, 55);
895 ASSERT (result != NULL);
896 ASSERT (strcmp (result, "0.000000 33") == 0);
897 ASSERT (retval == strlen (result));
901 { /* Negative zero. */
904 my_asprintf (&result, "%f %d", -0.0, 33, 44, 55);
905 ASSERT (result != NULL);
906 if (have_minus_zero ())
907 ASSERT (strcmp (result, "-0.000000 33") == 0);
908 ASSERT (retval == strlen (result));
912 { /* Positive infinity. */
915 my_asprintf (&result, "%f %d", 1.0 / 0.0, 33, 44, 55);
916 ASSERT (result != NULL);
917 ASSERT (strcmp (result, "inf 33") == 0
918 || strcmp (result, "infinity 33") == 0);
919 ASSERT (retval == strlen (result));
923 { /* Negative infinity. */
926 my_asprintf (&result, "%f %d", -1.0 / 0.0, 33, 44, 55);
927 ASSERT (result != NULL);
928 ASSERT (strcmp (result, "-inf 33") == 0
929 || strcmp (result, "-infinity 33") == 0);
930 ASSERT (retval == strlen (result));
937 my_asprintf (&result, "%f %d", NaN (), 33, 44, 55);
938 ASSERT (result != NULL);
939 ASSERT (strlen (result) >= 3 + 3
940 && memcmp (result, "nan", 3) == 0
941 && strcmp (result + strlen (result) - 3, " 33") == 0);
942 ASSERT (retval == strlen (result));
949 my_asprintf (&result, "%10f %d", 1.75, 33, 44, 55);
950 ASSERT (result != NULL);
951 ASSERT (strcmp (result, " 1.750000 33") == 0);
952 ASSERT (retval == strlen (result));
959 my_asprintf (&result, "%-10f %d", 1.75, 33, 44, 55);
960 ASSERT (result != NULL);
961 ASSERT (strcmp (result, "1.750000 33") == 0);
962 ASSERT (retval == strlen (result));
966 { /* FLAG_SHOWSIGN. */
969 my_asprintf (&result, "%+f %d", 1.75, 33, 44, 55);
970 ASSERT (result != NULL);
971 ASSERT (strcmp (result, "+1.750000 33") == 0);
972 ASSERT (retval == strlen (result));
979 my_asprintf (&result, "% f %d", 1.75, 33, 44, 55);
980 ASSERT (result != NULL);
981 ASSERT (strcmp (result, " 1.750000 33") == 0);
982 ASSERT (retval == strlen (result));
989 my_asprintf (&result, "%#f %d", 1.75, 33, 44, 55);
990 ASSERT (result != NULL);
991 ASSERT (strcmp (result, "1.750000 33") == 0);
992 ASSERT (retval == strlen (result));
999 my_asprintf (&result, "%#.f %d", 1.75, 33, 44, 55);
1000 ASSERT (result != NULL);
1001 ASSERT (strcmp (result, "2. 33") == 0);
1002 ASSERT (retval == strlen (result));
1006 { /* FLAG_ZERO with finite number. */
1009 my_asprintf (&result, "%015f %d", 1234.0, 33, 44, 55);
1010 ASSERT (result != NULL);
1011 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1012 ASSERT (retval == strlen (result));
1016 { /* FLAG_ZERO with infinite number. */
1019 my_asprintf (&result, "%015f %d", -1.0 / 0.0, 33, 44, 55);
1020 ASSERT (result != NULL);
1021 ASSERT (strcmp (result, " -inf 33") == 0
1022 || strcmp (result, " -infinity 33") == 0);
1023 ASSERT (retval == strlen (result));
1027 { /* FLAG_ZERO with NaN. */
1030 my_asprintf (&result, "%020f %d", NaN (), 33, 44, 55);
1031 ASSERT (result != NULL);
1032 ASSERT (strlen (result) == 20 + 3
1033 && memcmp (result + strspn (result, " "), "nan", 3) == 0
1034 && strcmp (result + strlen (result) - 3, " 33") == 0);
1035 ASSERT (retval == strlen (result));
1042 my_asprintf (&result, "%.f %d", 1234.0, 33, 44, 55);
1043 ASSERT (result != NULL);
1044 ASSERT (strcmp (result, "1234 33") == 0);
1045 ASSERT (retval == strlen (result));
1049 { /* A positive number. */
1052 my_asprintf (&result, "%Lf %d", 12.75L, 33, 44, 55);
1053 ASSERT (result != NULL);
1054 ASSERT (strcmp (result, "12.750000 33") == 0);
1055 ASSERT (retval == strlen (result));
1059 { /* A larger positive number. */
1062 my_asprintf (&result, "%Lf %d", 1234567.0L, 33, 44, 55);
1063 ASSERT (result != NULL);
1064 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1065 ASSERT (retval == strlen (result));
1069 { /* Small and large positive numbers. */
1070 static struct { long double value; const char *string; } data[] =
1072 { 1.234321234321234e-37L, "0.000000" },
1073 { 1.234321234321234e-36L, "0.000000" },
1074 { 1.234321234321234e-35L, "0.000000" },
1075 { 1.234321234321234e-34L, "0.000000" },
1076 { 1.234321234321234e-33L, "0.000000" },
1077 { 1.234321234321234e-32L, "0.000000" },
1078 { 1.234321234321234e-31L, "0.000000" },
1079 { 1.234321234321234e-30L, "0.000000" },
1080 { 1.234321234321234e-29L, "0.000000" },
1081 { 1.234321234321234e-28L, "0.000000" },
1082 { 1.234321234321234e-27L, "0.000000" },
1083 { 1.234321234321234e-26L, "0.000000" },
1084 { 1.234321234321234e-25L, "0.000000" },
1085 { 1.234321234321234e-24L, "0.000000" },
1086 { 1.234321234321234e-23L, "0.000000" },
1087 { 1.234321234321234e-22L, "0.000000" },
1088 { 1.234321234321234e-21L, "0.000000" },
1089 { 1.234321234321234e-20L, "0.000000" },
1090 { 1.234321234321234e-19L, "0.000000" },
1091 { 1.234321234321234e-18L, "0.000000" },
1092 { 1.234321234321234e-17L, "0.000000" },
1093 { 1.234321234321234e-16L, "0.000000" },
1094 { 1.234321234321234e-15L, "0.000000" },
1095 { 1.234321234321234e-14L, "0.000000" },
1096 { 1.234321234321234e-13L, "0.000000" },
1097 { 1.234321234321234e-12L, "0.000000" },
1098 { 1.234321234321234e-11L, "0.000000" },
1099 { 1.234321234321234e-10L, "0.000000" },
1100 { 1.234321234321234e-9L, "0.000000" },
1101 { 1.234321234321234e-8L, "0.000000" },
1102 { 1.234321234321234e-7L, "0.000000" },
1103 { 1.234321234321234e-6L, "0.000001" },
1104 { 1.234321234321234e-5L, "0.000012" },
1105 { 1.234321234321234e-4L, "0.000123" },
1106 { 1.234321234321234e-3L, "0.001234" },
1107 { 1.234321234321234e-2L, "0.012343" },
1108 { 1.234321234321234e-1L, "0.123432" },
1109 { 1.234321234321234L, "1.234321" },
1110 { 1.234321234321234e1L, "12.343212" },
1111 { 1.234321234321234e2L, "123.432123" },
1112 { 1.234321234321234e3L, "1234.321234" },
1113 { 1.234321234321234e4L, "12343.212343" },
1114 { 1.234321234321234e5L, "123432.123432" },
1115 { 1.234321234321234e6L, "1234321.234321" },
1116 { 1.234321234321234e7L, "12343212.343212" },
1117 { 1.234321234321234e8L, "123432123.432123" },
1118 { 1.234321234321234e9L, "1234321234.321234" },
1119 { 1.234321234321234e10L, "12343212343.2123**" },
1120 { 1.234321234321234e11L, "123432123432.123***" },
1121 { 1.234321234321234e12L, "1234321234321.23****" },
1122 { 1.234321234321234e13L, "12343212343212.3*****" },
1123 { 1.234321234321234e14L, "123432123432123.******" },
1124 { 1.234321234321234e15L, "1234321234321234.000000" },
1125 { 1.234321234321234e16L, "123432123432123**.000000" },
1126 { 1.234321234321234e17L, "123432123432123***.000000" },
1127 { 1.234321234321234e18L, "123432123432123****.000000" },
1128 { 1.234321234321234e19L, "123432123432123*****.000000" },
1129 { 1.234321234321234e20L, "123432123432123******.000000" },
1130 { 1.234321234321234e21L, "123432123432123*******.000000" },
1131 { 1.234321234321234e22L, "123432123432123********.000000" },
1132 { 1.234321234321234e23L, "123432123432123*********.000000" },
1133 { 1.234321234321234e24L, "123432123432123**********.000000" },
1134 { 1.234321234321234e25L, "123432123432123***********.000000" },
1135 { 1.234321234321234e26L, "123432123432123************.000000" },
1136 { 1.234321234321234e27L, "123432123432123*************.000000" },
1137 { 1.234321234321234e28L, "123432123432123**************.000000" },
1138 { 1.234321234321234e29L, "123432123432123***************.000000" },
1139 { 1.234321234321234e30L, "123432123432123****************.000000" },
1140 { 1.234321234321234e31L, "123432123432123*****************.000000" },
1141 { 1.234321234321234e32L, "123432123432123******************.000000" },
1142 { 1.234321234321234e33L, "123432123432123*******************.000000" },
1143 { 1.234321234321234e34L, "123432123432123********************.000000" },
1144 { 1.234321234321234e35L, "123432123432123*********************.000000" },
1145 { 1.234321234321234e36L, "123432123432123**********************.000000" }
1148 for (k = 0; k < SIZEOF (data); k++)
1152 my_asprintf (&result, "%Lf", data[k].value);
1153 ASSERT (result != NULL);
1154 ASSERT (strmatch (data[k].string, result));
1155 ASSERT (retval == strlen (result));
1160 { /* A negative number. */
1163 my_asprintf (&result, "%Lf %d", -0.03125L, 33, 44, 55);
1164 ASSERT (result != NULL);
1165 ASSERT (strcmp (result, "-0.031250 33") == 0);
1166 ASSERT (retval == strlen (result));
1170 { /* Positive zero. */
1173 my_asprintf (&result, "%Lf %d", 0.0L, 33, 44, 55);
1174 ASSERT (result != NULL);
1175 ASSERT (strcmp (result, "0.000000 33") == 0);
1176 ASSERT (retval == strlen (result));
1180 { /* Negative zero. */
1183 my_asprintf (&result, "%Lf %d", -0.0L, 33, 44, 55);
1184 ASSERT (result != NULL);
1185 if (have_minus_zero ())
1186 ASSERT (strcmp (result, "-0.000000 33") == 0);
1187 ASSERT (retval == strlen (result));
1191 { /* Positive infinity. */
1194 my_asprintf (&result, "%Lf %d", 1.0L / 0.0L, 33, 44, 55);
1195 ASSERT (result != NULL);
1196 ASSERT (strcmp (result, "inf 33") == 0
1197 || strcmp (result, "infinity 33") == 0);
1198 ASSERT (retval == strlen (result));
1202 { /* Negative infinity. */
1205 my_asprintf (&result, "%Lf %d", -1.0L / 0.0L, 33, 44, 55);
1206 ASSERT (result != NULL);
1207 ASSERT (strcmp (result, "-inf 33") == 0
1208 || strcmp (result, "-infinity 33") == 0);
1209 ASSERT (retval == strlen (result));
1214 static long double zero = 0.0L;
1217 my_asprintf (&result, "%Lf %d", zero / zero, 33, 44, 55);
1218 ASSERT (result != NULL);
1219 ASSERT (strlen (result) >= 3 + 3
1220 && memcmp (result, "nan", 3) == 0
1221 && strcmp (result + strlen (result) - 3, " 33") == 0);
1222 ASSERT (retval == strlen (result));
1229 my_asprintf (&result, "%10Lf %d", 1.75L, 33, 44, 55);
1230 ASSERT (result != NULL);
1231 ASSERT (strcmp (result, " 1.750000 33") == 0);
1232 ASSERT (retval == strlen (result));
1239 my_asprintf (&result, "%-10Lf %d", 1.75L, 33, 44, 55);
1240 ASSERT (result != NULL);
1241 ASSERT (strcmp (result, "1.750000 33") == 0);
1242 ASSERT (retval == strlen (result));
1246 { /* FLAG_SHOWSIGN. */
1249 my_asprintf (&result, "%+Lf %d", 1.75L, 33, 44, 55);
1250 ASSERT (result != NULL);
1251 ASSERT (strcmp (result, "+1.750000 33") == 0);
1252 ASSERT (retval == strlen (result));
1259 my_asprintf (&result, "% Lf %d", 1.75L, 33, 44, 55);
1260 ASSERT (result != NULL);
1261 ASSERT (strcmp (result, " 1.750000 33") == 0);
1262 ASSERT (retval == strlen (result));
1269 my_asprintf (&result, "%#Lf %d", 1.75L, 33, 44, 55);
1270 ASSERT (result != NULL);
1271 ASSERT (strcmp (result, "1.750000 33") == 0);
1272 ASSERT (retval == strlen (result));
1279 my_asprintf (&result, "%#.Lf %d", 1.75L, 33, 44, 55);
1280 ASSERT (result != NULL);
1281 ASSERT (strcmp (result, "2. 33") == 0);
1282 ASSERT (retval == strlen (result));
1286 { /* FLAG_ZERO with finite number. */
1289 my_asprintf (&result, "%015Lf %d", 1234.0L, 33, 44, 55);
1290 ASSERT (result != NULL);
1291 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1292 ASSERT (retval == strlen (result));
1296 { /* FLAG_ZERO with infinite number. */
1299 my_asprintf (&result, "%015Lf %d", -1.0L / 0.0L, 33, 44, 55);
1300 ASSERT (result != NULL);
1301 ASSERT (strcmp (result, " -inf 33") == 0
1302 || strcmp (result, " -infinity 33") == 0);
1303 ASSERT (retval == strlen (result));
1307 { /* FLAG_ZERO with NaN. */
1308 static long double zero = 0.0L;
1311 my_asprintf (&result, "%020Lf %d", zero / zero, 33, 44, 55);
1312 ASSERT (result != NULL);
1313 ASSERT (strlen (result) == 20 + 3
1314 && memcmp (result + strspn (result, " "), "nan", 3) == 0
1315 && strcmp (result + strlen (result) - 3, " 33") == 0);
1316 ASSERT (retval == strlen (result));
1323 my_asprintf (&result, "%.Lf %d", 1234.0L, 33, 44, 55);
1324 ASSERT (result != NULL);
1325 ASSERT (strcmp (result, "1234 33") == 0);
1326 ASSERT (retval == strlen (result));
1330 /* Test the support of the %F format directive. */
1332 { /* A positive number. */
1335 my_asprintf (&result, "%F %d", 12.75, 33, 44, 55);
1336 ASSERT (result != NULL);
1337 ASSERT (strcmp (result, "12.750000 33") == 0);
1338 ASSERT (retval == strlen (result));
1342 { /* A larger positive number. */
1345 my_asprintf (&result, "%F %d", 1234567.0, 33, 44, 55);
1346 ASSERT (result != NULL);
1347 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1348 ASSERT (retval == strlen (result));
1352 { /* A negative number. */
1355 my_asprintf (&result, "%F %d", -0.03125, 33, 44, 55);
1356 ASSERT (result != NULL);
1357 ASSERT (strcmp (result, "-0.031250 33") == 0);
1358 ASSERT (retval == strlen (result));
1362 { /* Positive zero. */
1365 my_asprintf (&result, "%F %d", 0.0, 33, 44, 55);
1366 ASSERT (result != NULL);
1367 ASSERT (strcmp (result, "0.000000 33") == 0);
1368 ASSERT (retval == strlen (result));
1372 { /* Negative zero. */
1375 my_asprintf (&result, "%F %d", -0.0, 33, 44, 55);
1376 ASSERT (result != NULL);
1377 if (have_minus_zero ())
1378 ASSERT (strcmp (result, "-0.000000 33") == 0);
1379 ASSERT (retval == strlen (result));
1383 { /* Positive infinity. */
1386 my_asprintf (&result, "%F %d", 1.0 / 0.0, 33, 44, 55);
1387 ASSERT (result != NULL);
1388 ASSERT (strcmp (result, "INF 33") == 0
1389 || strcmp (result, "INFINITY 33") == 0);
1390 ASSERT (retval == strlen (result));
1394 { /* Negative infinity. */
1397 my_asprintf (&result, "%F %d", -1.0 / 0.0, 33, 44, 55);
1398 ASSERT (result != NULL);
1399 ASSERT (strcmp (result, "-INF 33") == 0
1400 || strcmp (result, "-INFINITY 33") == 0);
1401 ASSERT (retval == strlen (result));
1408 my_asprintf (&result, "%F %d", NaN (), 33, 44, 55);
1409 ASSERT (result != NULL);
1410 ASSERT (strlen (result) >= 3 + 3
1411 && memcmp (result, "NAN", 3) == 0
1412 && strcmp (result + strlen (result) - 3, " 33") == 0);
1413 ASSERT (retval == strlen (result));
1420 my_asprintf (&result, "%015F %d", 1234.0, 33, 44, 55);
1421 ASSERT (result != NULL);
1422 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1423 ASSERT (retval == strlen (result));
1427 { /* FLAG_ZERO with infinite number. */
1430 my_asprintf (&result, "%015F %d", -1.0 / 0.0, 33, 44, 55);
1431 ASSERT (result != NULL);
1432 ASSERT (strcmp (result, " -INF 33") == 0
1433 || strcmp (result, " -INFINITY 33") == 0);
1434 ASSERT (retval == strlen (result));
1441 my_asprintf (&result, "%.F %d", 1234.0, 33, 44, 55);
1442 ASSERT (result != NULL);
1443 ASSERT (strcmp (result, "1234 33") == 0);
1444 ASSERT (retval == strlen (result));
1448 { /* A positive number. */
1451 my_asprintf (&result, "%LF %d", 12.75L, 33, 44, 55);
1452 ASSERT (result != NULL);
1453 ASSERT (strcmp (result, "12.750000 33") == 0);
1454 ASSERT (retval == strlen (result));
1458 { /* A larger positive number. */
1461 my_asprintf (&result, "%LF %d", 1234567.0L, 33, 44, 55);
1462 ASSERT (result != NULL);
1463 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1464 ASSERT (retval == strlen (result));
1468 { /* A negative number. */
1471 my_asprintf (&result, "%LF %d", -0.03125L, 33, 44, 55);
1472 ASSERT (result != NULL);
1473 ASSERT (strcmp (result, "-0.031250 33") == 0);
1474 ASSERT (retval == strlen (result));
1478 { /* Positive zero. */
1481 my_asprintf (&result, "%LF %d", 0.0L, 33, 44, 55);
1482 ASSERT (result != NULL);
1483 ASSERT (strcmp (result, "0.000000 33") == 0);
1484 ASSERT (retval == strlen (result));
1488 { /* Negative zero. */
1491 my_asprintf (&result, "%LF %d", -0.0L, 33, 44, 55);
1492 ASSERT (result != NULL);
1493 if (have_minus_zero ())
1494 ASSERT (strcmp (result, "-0.000000 33") == 0);
1495 ASSERT (retval == strlen (result));
1499 { /* Positive infinity. */
1502 my_asprintf (&result, "%LF %d", 1.0L / 0.0L, 33, 44, 55);
1503 ASSERT (result != NULL);
1504 ASSERT (strcmp (result, "INF 33") == 0
1505 || strcmp (result, "INFINITY 33") == 0);
1506 ASSERT (retval == strlen (result));
1510 { /* Negative infinity. */
1513 my_asprintf (&result, "%LF %d", -1.0L / 0.0L, 33, 44, 55);
1514 ASSERT (result != NULL);
1515 ASSERT (strcmp (result, "-INF 33") == 0
1516 || strcmp (result, "-INFINITY 33") == 0);
1517 ASSERT (retval == strlen (result));
1522 static long double zero = 0.0L;
1525 my_asprintf (&result, "%LF %d", zero / zero, 33, 44, 55);
1526 ASSERT (result != NULL);
1527 ASSERT (strlen (result) >= 3 + 3
1528 && memcmp (result, "NAN", 3) == 0
1529 && strcmp (result + strlen (result) - 3, " 33") == 0);
1530 ASSERT (retval == strlen (result));
1537 my_asprintf (&result, "%015LF %d", 1234.0L, 33, 44, 55);
1538 ASSERT (result != NULL);
1539 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1540 ASSERT (retval == strlen (result));
1544 { /* FLAG_ZERO with infinite number. */
1547 my_asprintf (&result, "%015LF %d", -1.0L / 0.0L, 33, 44, 55);
1548 ASSERT (result != NULL);
1549 ASSERT (strcmp (result, " -INF 33") == 0
1550 || strcmp (result, " -INFINITY 33") == 0);
1551 ASSERT (retval == strlen (result));
1558 my_asprintf (&result, "%.LF %d", 1234.0L, 33, 44, 55);
1559 ASSERT (result != NULL);
1560 ASSERT (strcmp (result, "1234 33") == 0);
1561 ASSERT (retval == strlen (result));
1565 /* Test the support of the %e format directive. */
1567 { /* A positive number. */
1570 my_asprintf (&result, "%e %d", 12.75, 33, 44, 55);
1571 ASSERT (result != NULL);
1572 ASSERT (strcmp (result, "1.275000e+01 33") == 0
1573 || strcmp (result, "1.275000e+001 33") == 0);
1574 ASSERT (retval == strlen (result));
1578 { /* A larger positive number. */
1581 my_asprintf (&result, "%e %d", 1234567.0, 33, 44, 55);
1582 ASSERT (result != NULL);
1583 ASSERT (strcmp (result, "1.234567e+06 33") == 0
1584 || strcmp (result, "1.234567e+006 33") == 0);
1585 ASSERT (retval == strlen (result));
1589 { /* Small and large positive numbers. */
1590 static struct { double value; const char *string; } data[] =
1592 { 1.234321234321234e-37, "1.234321e-37" },
1593 { 1.234321234321234e-36, "1.234321e-36" },
1594 { 1.234321234321234e-35, "1.234321e-35" },
1595 { 1.234321234321234e-34, "1.234321e-34" },
1596 { 1.234321234321234e-33, "1.234321e-33" },
1597 { 1.234321234321234e-32, "1.234321e-32" },
1598 { 1.234321234321234e-31, "1.234321e-31" },
1599 { 1.234321234321234e-30, "1.234321e-30" },
1600 { 1.234321234321234e-29, "1.234321e-29" },
1601 { 1.234321234321234e-28, "1.234321e-28" },
1602 { 1.234321234321234e-27, "1.234321e-27" },
1603 { 1.234321234321234e-26, "1.234321e-26" },
1604 { 1.234321234321234e-25, "1.234321e-25" },
1605 { 1.234321234321234e-24, "1.234321e-24" },
1606 { 1.234321234321234e-23, "1.234321e-23" },
1607 { 1.234321234321234e-22, "1.234321e-22" },
1608 { 1.234321234321234e-21, "1.234321e-21" },
1609 { 1.234321234321234e-20, "1.234321e-20" },
1610 { 1.234321234321234e-19, "1.234321e-19" },
1611 { 1.234321234321234e-18, "1.234321e-18" },
1612 { 1.234321234321234e-17, "1.234321e-17" },
1613 { 1.234321234321234e-16, "1.234321e-16" },
1614 { 1.234321234321234e-15, "1.234321e-15" },
1615 { 1.234321234321234e-14, "1.234321e-14" },
1616 { 1.234321234321234e-13, "1.234321e-13" },
1617 { 1.234321234321234e-12, "1.234321e-12" },
1618 { 1.234321234321234e-11, "1.234321e-11" },
1619 { 1.234321234321234e-10, "1.234321e-10" },
1620 { 1.234321234321234e-9, "1.234321e-09" },
1621 { 1.234321234321234e-8, "1.234321e-08" },
1622 { 1.234321234321234e-7, "1.234321e-07" },
1623 { 1.234321234321234e-6, "1.234321e-06" },
1624 { 1.234321234321234e-5, "1.234321e-05" },
1625 { 1.234321234321234e-4, "1.234321e-04" },
1626 { 1.234321234321234e-3, "1.234321e-03" },
1627 { 1.234321234321234e-2, "1.234321e-02" },
1628 { 1.234321234321234e-1, "1.234321e-01" },
1629 { 1.234321234321234, "1.234321e+00" },
1630 { 1.234321234321234e1, "1.234321e+01" },
1631 { 1.234321234321234e2, "1.234321e+02" },
1632 { 1.234321234321234e3, "1.234321e+03" },
1633 { 1.234321234321234e4, "1.234321e+04" },
1634 { 1.234321234321234e5, "1.234321e+05" },
1635 { 1.234321234321234e6, "1.234321e+06" },
1636 { 1.234321234321234e7, "1.234321e+07" },
1637 { 1.234321234321234e8, "1.234321e+08" },
1638 { 1.234321234321234e9, "1.234321e+09" },
1639 { 1.234321234321234e10, "1.234321e+10" },
1640 { 1.234321234321234e11, "1.234321e+11" },
1641 { 1.234321234321234e12, "1.234321e+12" },
1642 { 1.234321234321234e13, "1.234321e+13" },
1643 { 1.234321234321234e14, "1.234321e+14" },
1644 { 1.234321234321234e15, "1.234321e+15" },
1645 { 1.234321234321234e16, "1.234321e+16" },
1646 { 1.234321234321234e17, "1.234321e+17" },
1647 { 1.234321234321234e18, "1.234321e+18" },
1648 { 1.234321234321234e19, "1.234321e+19" },
1649 { 1.234321234321234e20, "1.234321e+20" },
1650 { 1.234321234321234e21, "1.234321e+21" },
1651 { 1.234321234321234e22, "1.234321e+22" },
1652 { 1.234321234321234e23, "1.234321e+23" },
1653 { 1.234321234321234e24, "1.234321e+24" },
1654 { 1.234321234321234e25, "1.234321e+25" },
1655 { 1.234321234321234e26, "1.234321e+26" },
1656 { 1.234321234321234e27, "1.234321e+27" },
1657 { 1.234321234321234e28, "1.234321e+28" },
1658 { 1.234321234321234e29, "1.234321e+29" },
1659 { 1.234321234321234e30, "1.234321e+30" },
1660 { 1.234321234321234e31, "1.234321e+31" },
1661 { 1.234321234321234e32, "1.234321e+32" },
1662 { 1.234321234321234e33, "1.234321e+33" },
1663 { 1.234321234321234e34, "1.234321e+34" },
1664 { 1.234321234321234e35, "1.234321e+35" },
1665 { 1.234321234321234e36, "1.234321e+36" }
1668 for (k = 0; k < SIZEOF (data); k++)
1672 my_asprintf (&result, "%e", data[k].value);
1673 const char *expected = data[k].string;
1674 ASSERT (result != NULL);
1675 ASSERT (strcmp (result, expected) == 0
1676 /* Some implementations produce exponents with 3 digits. */
1677 || (strlen (result) == strlen (expected) + 1
1678 && memcmp (result, expected, strlen (expected) - 2) == 0
1679 && result[strlen (expected) - 2] == '0'
1680 && strcmp (result + strlen (expected) - 1,
1681 expected + strlen (expected) - 2)
1683 ASSERT (retval == strlen (result));
1688 { /* A negative number. */
1691 my_asprintf (&result, "%e %d", -0.03125, 33, 44, 55);
1692 ASSERT (result != NULL);
1693 ASSERT (strcmp (result, "-3.125000e-02 33") == 0
1694 || strcmp (result, "-3.125000e-002 33") == 0);
1695 ASSERT (retval == strlen (result));
1699 { /* Positive zero. */
1702 my_asprintf (&result, "%e %d", 0.0, 33, 44, 55);
1703 ASSERT (result != NULL);
1704 ASSERT (strcmp (result, "0.000000e+00 33") == 0
1705 || strcmp (result, "0.000000e+000 33") == 0);
1706 ASSERT (retval == strlen (result));
1710 { /* Negative zero. */
1713 my_asprintf (&result, "%e %d", -0.0, 33, 44, 55);
1714 ASSERT (result != NULL);
1715 if (have_minus_zero ())
1716 ASSERT (strcmp (result, "-0.000000e+00 33") == 0
1717 || strcmp (result, "-0.000000e+000 33") == 0);
1718 ASSERT (retval == strlen (result));
1722 { /* Positive infinity. */
1725 my_asprintf (&result, "%e %d", 1.0 / 0.0, 33, 44, 55);
1726 ASSERT (result != NULL);
1727 ASSERT (strcmp (result, "inf 33") == 0
1728 || strcmp (result, "infinity 33") == 0);
1729 ASSERT (retval == strlen (result));
1733 { /* Negative infinity. */
1736 my_asprintf (&result, "%e %d", -1.0 / 0.0, 33, 44, 55);
1737 ASSERT (result != NULL);
1738 ASSERT (strcmp (result, "-inf 33") == 0
1739 || strcmp (result, "-infinity 33") == 0);
1740 ASSERT (retval == strlen (result));
1747 my_asprintf (&result, "%e %d", NaN (), 33, 44, 55);
1748 ASSERT (result != NULL);
1749 ASSERT (strlen (result) >= 3 + 3
1750 && memcmp (result, "nan", 3) == 0
1751 && strcmp (result + strlen (result) - 3, " 33") == 0);
1752 ASSERT (retval == strlen (result));
1759 my_asprintf (&result, "%15e %d", 1.75, 33, 44, 55);
1760 ASSERT (result != NULL);
1761 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
1762 || strcmp (result, " 1.750000e+000 33") == 0);
1763 ASSERT (retval == strlen (result));
1770 my_asprintf (&result, "%-15e %d", 1.75, 33, 44, 55);
1771 ASSERT (result != NULL);
1772 ASSERT (strcmp (result, "1.750000e+00 33") == 0
1773 || strcmp (result, "1.750000e+000 33") == 0);
1774 ASSERT (retval == strlen (result));
1778 { /* FLAG_SHOWSIGN. */
1781 my_asprintf (&result, "%+e %d", 1.75, 33, 44, 55);
1782 ASSERT (result != NULL);
1783 ASSERT (strcmp (result, "+1.750000e+00 33") == 0
1784 || strcmp (result, "+1.750000e+000 33") == 0);
1785 ASSERT (retval == strlen (result));
1792 my_asprintf (&result, "% e %d", 1.75, 33, 44, 55);
1793 ASSERT (result != NULL);
1794 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
1795 || strcmp (result, " 1.750000e+000 33") == 0);
1796 ASSERT (retval == strlen (result));
1803 my_asprintf (&result, "%#e %d", 1.75, 33, 44, 55);
1804 ASSERT (result != NULL);
1805 ASSERT (strcmp (result, "1.750000e+00 33") == 0
1806 || strcmp (result, "1.750000e+000 33") == 0);
1807 ASSERT (retval == strlen (result));
1814 my_asprintf (&result, "%#.e %d", 1.75, 33, 44, 55);
1815 ASSERT (result != NULL);
1816 ASSERT (strcmp (result, "2.e+00 33") == 0
1817 || strcmp (result, "2.e+000 33") == 0);
1818 ASSERT (retval == strlen (result));
1825 my_asprintf (&result, "%#.e %d", 9.75, 33, 44, 55);
1826 ASSERT (result != NULL);
1827 ASSERT (strcmp (result, "1.e+01 33") == 0
1828 || strcmp (result, "1.e+001 33") == 0);
1829 ASSERT (retval == strlen (result));
1833 { /* FLAG_ZERO with finite number. */
1836 my_asprintf (&result, "%015e %d", 1234.0, 33, 44, 55);
1837 ASSERT (result != NULL);
1838 ASSERT (strcmp (result, "0001.234000e+03 33") == 0
1839 || strcmp (result, "001.234000e+003 33") == 0);
1840 ASSERT (retval == strlen (result));
1844 { /* FLAG_ZERO with infinite number. */
1847 my_asprintf (&result, "%015e %d", -1.0 / 0.0, 33, 44, 55);
1848 ASSERT (result != NULL);
1849 ASSERT (strcmp (result, " -inf 33") == 0
1850 || strcmp (result, " -infinity 33") == 0);
1851 ASSERT (retval == strlen (result));
1855 { /* FLAG_ZERO with NaN. */
1858 my_asprintf (&result, "%020e %d", NaN (), 33, 44, 55);
1859 ASSERT (result != NULL);
1860 ASSERT (strlen (result) == 20 + 3
1861 && memcmp (result + strspn (result, " "), "nan", 3) == 0
1862 && strcmp (result + strlen (result) - 3, " 33") == 0);
1863 ASSERT (retval == strlen (result));
1870 my_asprintf (&result, "%.e %d", 1234.0, 33, 44, 55);
1871 ASSERT (result != NULL);
1872 ASSERT (strcmp (result, "1e+03 33") == 0
1873 || strcmp (result, "1e+003 33") == 0);
1874 ASSERT (retval == strlen (result));
1878 { /* A positive number. */
1881 my_asprintf (&result, "%Le %d", 12.75L, 33, 44, 55);
1882 ASSERT (result != NULL);
1883 ASSERT (strcmp (result, "1.275000e+01 33") == 0);
1884 ASSERT (retval == strlen (result));
1888 { /* A larger positive number. */
1891 my_asprintf (&result, "%Le %d", 1234567.0L, 33, 44, 55);
1892 ASSERT (result != NULL);
1893 ASSERT (strcmp (result, "1.234567e+06 33") == 0);
1894 ASSERT (retval == strlen (result));
1898 { /* Small and large positive numbers. */
1899 static struct { long double value; const char *string; } data[] =
1901 { 1.234321234321234e-37L, "1.234321e-37" },
1902 { 1.234321234321234e-36L, "1.234321e-36" },
1903 { 1.234321234321234e-35L, "1.234321e-35" },
1904 { 1.234321234321234e-34L, "1.234321e-34" },
1905 { 1.234321234321234e-33L, "1.234321e-33" },
1906 { 1.234321234321234e-32L, "1.234321e-32" },
1907 { 1.234321234321234e-31L, "1.234321e-31" },
1908 { 1.234321234321234e-30L, "1.234321e-30" },
1909 { 1.234321234321234e-29L, "1.234321e-29" },
1910 { 1.234321234321234e-28L, "1.234321e-28" },
1911 { 1.234321234321234e-27L, "1.234321e-27" },
1912 { 1.234321234321234e-26L, "1.234321e-26" },
1913 { 1.234321234321234e-25L, "1.234321e-25" },
1914 { 1.234321234321234e-24L, "1.234321e-24" },
1915 { 1.234321234321234e-23L, "1.234321e-23" },
1916 { 1.234321234321234e-22L, "1.234321e-22" },
1917 { 1.234321234321234e-21L, "1.234321e-21" },
1918 { 1.234321234321234e-20L, "1.234321e-20" },
1919 { 1.234321234321234e-19L, "1.234321e-19" },
1920 { 1.234321234321234e-18L, "1.234321e-18" },
1921 { 1.234321234321234e-17L, "1.234321e-17" },
1922 { 1.234321234321234e-16L, "1.234321e-16" },
1923 { 1.234321234321234e-15L, "1.234321e-15" },
1924 { 1.234321234321234e-14L, "1.234321e-14" },
1925 { 1.234321234321234e-13L, "1.234321e-13" },
1926 { 1.234321234321234e-12L, "1.234321e-12" },
1927 { 1.234321234321234e-11L, "1.234321e-11" },
1928 { 1.234321234321234e-10L, "1.234321e-10" },
1929 { 1.234321234321234e-9L, "1.234321e-09" },
1930 { 1.234321234321234e-8L, "1.234321e-08" },
1931 { 1.234321234321234e-7L, "1.234321e-07" },
1932 { 1.234321234321234e-6L, "1.234321e-06" },
1933 { 1.234321234321234e-5L, "1.234321e-05" },
1934 { 1.234321234321234e-4L, "1.234321e-04" },
1935 { 1.234321234321234e-3L, "1.234321e-03" },
1936 { 1.234321234321234e-2L, "1.234321e-02" },
1937 { 1.234321234321234e-1L, "1.234321e-01" },
1938 { 1.234321234321234L, "1.234321e+00" },
1939 { 1.234321234321234e1L, "1.234321e+01" },
1940 { 1.234321234321234e2L, "1.234321e+02" },
1941 { 1.234321234321234e3L, "1.234321e+03" },
1942 { 1.234321234321234e4L, "1.234321e+04" },
1943 { 1.234321234321234e5L, "1.234321e+05" },
1944 { 1.234321234321234e6L, "1.234321e+06" },
1945 { 1.234321234321234e7L, "1.234321e+07" },
1946 { 1.234321234321234e8L, "1.234321e+08" },
1947 { 1.234321234321234e9L, "1.234321e+09" },
1948 { 1.234321234321234e10L, "1.234321e+10" },
1949 { 1.234321234321234e11L, "1.234321e+11" },
1950 { 1.234321234321234e12L, "1.234321e+12" },
1951 { 1.234321234321234e13L, "1.234321e+13" },
1952 { 1.234321234321234e14L, "1.234321e+14" },
1953 { 1.234321234321234e15L, "1.234321e+15" },
1954 { 1.234321234321234e16L, "1.234321e+16" },
1955 { 1.234321234321234e17L, "1.234321e+17" },
1956 { 1.234321234321234e18L, "1.234321e+18" },
1957 { 1.234321234321234e19L, "1.234321e+19" },
1958 { 1.234321234321234e20L, "1.234321e+20" },
1959 { 1.234321234321234e21L, "1.234321e+21" },
1960 { 1.234321234321234e22L, "1.234321e+22" },
1961 { 1.234321234321234e23L, "1.234321e+23" },
1962 { 1.234321234321234e24L, "1.234321e+24" },
1963 { 1.234321234321234e25L, "1.234321e+25" },
1964 { 1.234321234321234e26L, "1.234321e+26" },
1965 { 1.234321234321234e27L, "1.234321e+27" },
1966 { 1.234321234321234e28L, "1.234321e+28" },
1967 { 1.234321234321234e29L, "1.234321e+29" },
1968 { 1.234321234321234e30L, "1.234321e+30" },
1969 { 1.234321234321234e31L, "1.234321e+31" },
1970 { 1.234321234321234e32L, "1.234321e+32" },
1971 { 1.234321234321234e33L, "1.234321e+33" },
1972 { 1.234321234321234e34L, "1.234321e+34" },
1973 { 1.234321234321234e35L, "1.234321e+35" },
1974 { 1.234321234321234e36L, "1.234321e+36" }
1977 for (k = 0; k < SIZEOF (data); k++)
1981 my_asprintf (&result, "%Le", data[k].value);
1982 ASSERT (result != NULL);
1983 ASSERT (strcmp (result, data[k].string) == 0);
1984 ASSERT (retval == strlen (result));
1989 { /* A negative number. */
1992 my_asprintf (&result, "%Le %d", -0.03125L, 33, 44, 55);
1993 ASSERT (result != NULL);
1994 ASSERT (strcmp (result, "-3.125000e-02 33") == 0);
1995 ASSERT (retval == strlen (result));
1999 { /* Positive zero. */
2002 my_asprintf (&result, "%Le %d", 0.0L, 33, 44, 55);
2003 ASSERT (result != NULL);
2004 ASSERT (strcmp (result, "0.000000e+00 33") == 0);
2005 ASSERT (retval == strlen (result));
2009 { /* Negative zero. */
2012 my_asprintf (&result, "%Le %d", -0.0L, 33, 44, 55);
2013 ASSERT (result != NULL);
2014 if (have_minus_zero ())
2015 ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
2016 ASSERT (retval == strlen (result));
2020 { /* Positive infinity. */
2023 my_asprintf (&result, "%Le %d", 1.0L / 0.0L, 33, 44, 55);
2024 ASSERT (result != NULL);
2025 ASSERT (strcmp (result, "inf 33") == 0
2026 || strcmp (result, "infinity 33") == 0);
2027 ASSERT (retval == strlen (result));
2031 { /* Negative infinity. */
2034 my_asprintf (&result, "%Le %d", -1.0L / 0.0L, 33, 44, 55);
2035 ASSERT (result != NULL);
2036 ASSERT (strcmp (result, "-inf 33") == 0
2037 || strcmp (result, "-infinity 33") == 0);
2038 ASSERT (retval == strlen (result));
2043 static long double zero = 0.0L;
2046 my_asprintf (&result, "%Le %d", zero / zero, 33, 44, 55);
2047 ASSERT (result != NULL);
2048 ASSERT (strlen (result) >= 3 + 3
2049 && memcmp (result, "nan", 3) == 0
2050 && strcmp (result + strlen (result) - 3, " 33") == 0);
2051 ASSERT (retval == strlen (result));
2058 my_asprintf (&result, "%15Le %d", 1.75L, 33, 44, 55);
2059 ASSERT (result != NULL);
2060 ASSERT (strcmp (result, " 1.750000e+00 33") == 0);
2061 ASSERT (retval == strlen (result));
2068 my_asprintf (&result, "%-15Le %d", 1.75L, 33, 44, 55);
2069 ASSERT (result != NULL);
2070 ASSERT (strcmp (result, "1.750000e+00 33") == 0);
2071 ASSERT (retval == strlen (result));
2075 { /* FLAG_SHOWSIGN. */
2078 my_asprintf (&result, "%+Le %d", 1.75L, 33, 44, 55);
2079 ASSERT (result != NULL);
2080 ASSERT (strcmp (result, "+1.750000e+00 33") == 0);
2081 ASSERT (retval == strlen (result));
2088 my_asprintf (&result, "% Le %d", 1.75L, 33, 44, 55);
2089 ASSERT (result != NULL);
2090 ASSERT (strcmp (result, " 1.750000e+00 33") == 0);
2091 ASSERT (retval == strlen (result));
2098 my_asprintf (&result, "%#Le %d", 1.75L, 33, 44, 55);
2099 ASSERT (result != NULL);
2100 ASSERT (strcmp (result, "1.750000e+00 33") == 0);
2101 ASSERT (retval == strlen (result));
2108 my_asprintf (&result, "%#.Le %d", 1.75L, 33, 44, 55);
2109 ASSERT (result != NULL);
2110 ASSERT (strcmp (result, "2.e+00 33") == 0);
2111 ASSERT (retval == strlen (result));
2118 my_asprintf (&result, "%#.Le %d", 9.75L, 33, 44, 55);
2119 ASSERT (result != NULL);
2120 ASSERT (strcmp (result, "1.e+01 33") == 0);
2121 ASSERT (retval == strlen (result));
2125 { /* FLAG_ZERO with finite number. */
2128 my_asprintf (&result, "%015Le %d", 1234.0L, 33, 44, 55);
2129 ASSERT (result != NULL);
2130 ASSERT (strcmp (result, "0001.234000e+03 33") == 0);
2131 ASSERT (retval == strlen (result));
2135 { /* FLAG_ZERO with infinite number. */
2138 my_asprintf (&result, "%015Le %d", -1.0L / 0.0L, 33, 44, 55);
2139 ASSERT (result != NULL);
2140 ASSERT (strcmp (result, " -inf 33") == 0
2141 || strcmp (result, " -infinity 33") == 0);
2142 ASSERT (retval == strlen (result));
2146 { /* FLAG_ZERO with NaN. */
2147 static long double zero = 0.0L;
2150 my_asprintf (&result, "%020Le %d", zero / zero, 33, 44, 55);
2151 ASSERT (result != NULL);
2152 ASSERT (strlen (result) == 20 + 3
2153 && memcmp (result + strspn (result, " "), "nan", 3) == 0
2154 && strcmp (result + strlen (result) - 3, " 33") == 0);
2155 ASSERT (retval == strlen (result));
2162 my_asprintf (&result, "%.Le %d", 1234.0L, 33, 44, 55);
2163 ASSERT (result != NULL);
2164 ASSERT (strcmp (result, "1e+03 33") == 0);
2165 ASSERT (retval == strlen (result));
2169 /* Test the support of the %g format directive. */
2171 { /* A positive number. */
2174 my_asprintf (&result, "%g %d", 12.75, 33, 44, 55);
2175 ASSERT (result != NULL);
2176 ASSERT (strcmp (result, "12.75 33") == 0);
2177 ASSERT (retval == strlen (result));
2181 { /* A larger positive number. */
2184 my_asprintf (&result, "%g %d", 1234567.0, 33, 44, 55);
2185 ASSERT (result != NULL);
2186 ASSERT (strcmp (result, "1.23457e+06 33") == 0
2187 || strcmp (result, "1.23457e+006 33") == 0);
2188 ASSERT (retval == strlen (result));
2192 { /* Small and large positive numbers. */
2193 static struct { double value; const char *string; } data[] =
2195 { 1.234321234321234e-37, "1.23432e-37" },
2196 { 1.234321234321234e-36, "1.23432e-36" },
2197 { 1.234321234321234e-35, "1.23432e-35" },
2198 { 1.234321234321234e-34, "1.23432e-34" },
2199 { 1.234321234321234e-33, "1.23432e-33" },
2200 { 1.234321234321234e-32, "1.23432e-32" },
2201 { 1.234321234321234e-31, "1.23432e-31" },
2202 { 1.234321234321234e-30, "1.23432e-30" },
2203 { 1.234321234321234e-29, "1.23432e-29" },
2204 { 1.234321234321234e-28, "1.23432e-28" },
2205 { 1.234321234321234e-27, "1.23432e-27" },
2206 { 1.234321234321234e-26, "1.23432e-26" },
2207 { 1.234321234321234e-25, "1.23432e-25" },
2208 { 1.234321234321234e-24, "1.23432e-24" },
2209 { 1.234321234321234e-23, "1.23432e-23" },
2210 { 1.234321234321234e-22, "1.23432e-22" },
2211 { 1.234321234321234e-21, "1.23432e-21" },
2212 { 1.234321234321234e-20, "1.23432e-20" },
2213 { 1.234321234321234e-19, "1.23432e-19" },
2214 { 1.234321234321234e-18, "1.23432e-18" },
2215 { 1.234321234321234e-17, "1.23432e-17" },
2216 { 1.234321234321234e-16, "1.23432e-16" },
2217 { 1.234321234321234e-15, "1.23432e-15" },
2218 { 1.234321234321234e-14, "1.23432e-14" },
2219 { 1.234321234321234e-13, "1.23432e-13" },
2220 { 1.234321234321234e-12, "1.23432e-12" },
2221 { 1.234321234321234e-11, "1.23432e-11" },
2222 { 1.234321234321234e-10, "1.23432e-10" },
2223 { 1.234321234321234e-9, "1.23432e-09" },
2224 { 1.234321234321234e-8, "1.23432e-08" },
2225 { 1.234321234321234e-7, "1.23432e-07" },
2226 { 1.234321234321234e-6, "1.23432e-06" },
2227 { 1.234321234321234e-5, "1.23432e-05" },
2228 { 1.234321234321234e-4, "0.000123432" },
2229 { 1.234321234321234e-3, "0.00123432" },
2230 { 1.234321234321234e-2, "0.0123432" },
2231 { 1.234321234321234e-1, "0.123432" },
2232 { 1.234321234321234, "1.23432" },
2233 { 1.234321234321234e1, "12.3432" },
2234 { 1.234321234321234e2, "123.432" },
2235 { 1.234321234321234e3, "1234.32" },
2236 { 1.234321234321234e4, "12343.2" },
2237 { 1.234321234321234e5, "123432" },
2238 { 1.234321234321234e6, "1.23432e+06" },
2239 { 1.234321234321234e7, "1.23432e+07" },
2240 { 1.234321234321234e8, "1.23432e+08" },
2241 { 1.234321234321234e9, "1.23432e+09" },
2242 { 1.234321234321234e10, "1.23432e+10" },
2243 { 1.234321234321234e11, "1.23432e+11" },
2244 { 1.234321234321234e12, "1.23432e+12" },
2245 { 1.234321234321234e13, "1.23432e+13" },
2246 { 1.234321234321234e14, "1.23432e+14" },
2247 { 1.234321234321234e15, "1.23432e+15" },
2248 { 1.234321234321234e16, "1.23432e+16" },
2249 { 1.234321234321234e17, "1.23432e+17" },
2250 { 1.234321234321234e18, "1.23432e+18" },
2251 { 1.234321234321234e19, "1.23432e+19" },
2252 { 1.234321234321234e20, "1.23432e+20" },
2253 { 1.234321234321234e21, "1.23432e+21" },
2254 { 1.234321234321234e22, "1.23432e+22" },
2255 { 1.234321234321234e23, "1.23432e+23" },
2256 { 1.234321234321234e24, "1.23432e+24" },
2257 { 1.234321234321234e25, "1.23432e+25" },
2258 { 1.234321234321234e26, "1.23432e+26" },
2259 { 1.234321234321234e27, "1.23432e+27" },
2260 { 1.234321234321234e28, "1.23432e+28" },
2261 { 1.234321234321234e29, "1.23432e+29" },
2262 { 1.234321234321234e30, "1.23432e+30" },
2263 { 1.234321234321234e31, "1.23432e+31" },
2264 { 1.234321234321234e32, "1.23432e+32" },
2265 { 1.234321234321234e33, "1.23432e+33" },
2266 { 1.234321234321234e34, "1.23432e+34" },
2267 { 1.234321234321234e35, "1.23432e+35" },
2268 { 1.234321234321234e36, "1.23432e+36" }
2271 for (k = 0; k < SIZEOF (data); k++)
2275 my_asprintf (&result, "%g", data[k].value);
2276 const char *expected = data[k].string;
2277 ASSERT (result != NULL);
2278 ASSERT (strcmp (result, expected) == 0
2279 /* Some implementations produce exponents with 3 digits. */
2280 || (expected[strlen (expected) - 4] == 'e'
2281 && strlen (result) == strlen (expected) + 1
2282 && memcmp (result, expected, strlen (expected) - 2) == 0
2283 && result[strlen (expected) - 2] == '0'
2284 && strcmp (result + strlen (expected) - 1,
2285 expected + strlen (expected) - 2)
2287 ASSERT (retval == strlen (result));
2292 { /* A negative number. */
2295 my_asprintf (&result, "%g %d", -0.03125, 33, 44, 55);
2296 ASSERT (result != NULL);
2297 ASSERT (strcmp (result, "-0.03125 33") == 0);
2298 ASSERT (retval == strlen (result));
2302 { /* Positive zero. */
2305 my_asprintf (&result, "%g %d", 0.0, 33, 44, 55);
2306 ASSERT (result != NULL);
2307 ASSERT (strcmp (result, "0 33") == 0);
2308 ASSERT (retval == strlen (result));
2312 { /* Negative zero. */
2315 my_asprintf (&result, "%g %d", -0.0, 33, 44, 55);
2316 ASSERT (result != NULL);
2317 if (have_minus_zero ())
2318 ASSERT (strcmp (result, "-0 33") == 0);
2319 ASSERT (retval == strlen (result));
2323 { /* Positive infinity. */
2326 my_asprintf (&result, "%g %d", 1.0 / 0.0, 33, 44, 55);
2327 ASSERT (result != NULL);
2328 ASSERT (strcmp (result, "inf 33") == 0
2329 || strcmp (result, "infinity 33") == 0);
2330 ASSERT (retval == strlen (result));
2334 { /* Negative infinity. */
2337 my_asprintf (&result, "%g %d", -1.0 / 0.0, 33, 44, 55);
2338 ASSERT (result != NULL);
2339 ASSERT (strcmp (result, "-inf 33") == 0
2340 || strcmp (result, "-infinity 33") == 0);
2341 ASSERT (retval == strlen (result));
2348 my_asprintf (&result, "%g %d", NaN (), 33, 44, 55);
2349 ASSERT (result != NULL);
2350 ASSERT (strlen (result) >= 3 + 3
2351 && memcmp (result, "nan", 3) == 0
2352 && strcmp (result + strlen (result) - 3, " 33") == 0);
2353 ASSERT (retval == strlen (result));
2360 my_asprintf (&result, "%10g %d", 1.75, 33, 44, 55);
2361 ASSERT (result != NULL);
2362 ASSERT (strcmp (result, " 1.75 33") == 0);
2363 ASSERT (retval == strlen (result));
2370 my_asprintf (&result, "%-10g %d", 1.75, 33, 44, 55);
2371 ASSERT (result != NULL);
2372 ASSERT (strcmp (result, "1.75 33") == 0);
2373 ASSERT (retval == strlen (result));
2377 { /* FLAG_SHOWSIGN. */
2380 my_asprintf (&result, "%+g %d", 1.75, 33, 44, 55);
2381 ASSERT (result != NULL);
2382 ASSERT (strcmp (result, "+1.75 33") == 0);
2383 ASSERT (retval == strlen (result));
2390 my_asprintf (&result, "% g %d", 1.75, 33, 44, 55);
2391 ASSERT (result != NULL);
2392 ASSERT (strcmp (result, " 1.75 33") == 0);
2393 ASSERT (retval == strlen (result));
2400 my_asprintf (&result, "%#g %d", 1.75, 33, 44, 55);
2401 ASSERT (result != NULL);
2402 ASSERT (strcmp (result, "1.75000 33") == 0);
2403 ASSERT (retval == strlen (result));
2410 my_asprintf (&result, "%#.g %d", 1.75, 33, 44, 55);
2411 ASSERT (result != NULL);
2412 ASSERT (strcmp (result, "2. 33") == 0);
2413 ASSERT (retval == strlen (result));
2420 my_asprintf (&result, "%#.g %d", 9.75, 33, 44, 55);
2421 ASSERT (result != NULL);
2422 ASSERT (strcmp (result, "1.e+01 33") == 0
2423 || strcmp (result, "1.e+001 33") == 0);
2424 ASSERT (retval == strlen (result));
2428 { /* FLAG_ZERO with finite number. */
2431 my_asprintf (&result, "%010g %d", 1234.0, 33, 44, 55);
2432 ASSERT (result != NULL);
2433 ASSERT (strcmp (result, "0000001234 33") == 0);
2434 ASSERT (retval == strlen (result));
2438 { /* FLAG_ZERO with infinite number. */
2441 my_asprintf (&result, "%015g %d", -1.0 / 0.0, 33, 44, 55);
2442 ASSERT (result != NULL);
2443 ASSERT (strcmp (result, " -inf 33") == 0
2444 || strcmp (result, " -infinity 33") == 0);
2445 ASSERT (retval == strlen (result));
2449 { /* FLAG_ZERO with NaN. */
2452 my_asprintf (&result, "%020g %d", NaN (), 33, 44, 55);
2453 ASSERT (result != NULL);
2454 ASSERT (strlen (result) == 20 + 3
2455 && memcmp (result + strspn (result, " "), "nan", 3) == 0
2456 && strcmp (result + strlen (result) - 3, " 33") == 0);
2457 ASSERT (retval == strlen (result));
2464 my_asprintf (&result, "%.g %d", 1234.0, 33, 44, 55);
2465 ASSERT (result != NULL);
2466 ASSERT (strcmp (result, "1e+03 33") == 0
2467 || strcmp (result, "1e+003 33") == 0);
2468 ASSERT (retval == strlen (result));
2472 { /* A positive number. */
2475 my_asprintf (&result, "%Lg %d", 12.75L, 33, 44, 55);
2476 ASSERT (result != NULL);
2477 ASSERT (strcmp (result, "12.75 33") == 0);
2478 ASSERT (retval == strlen (result));
2482 { /* A larger positive number. */
2485 my_asprintf (&result, "%Lg %d", 1234567.0L, 33, 44, 55);
2486 ASSERT (result != NULL);
2487 ASSERT (strcmp (result, "1.23457e+06 33") == 0);
2488 ASSERT (retval == strlen (result));
2492 { /* Small and large positive numbers. */
2493 static struct { long double value; const char *string; } data[] =
2495 { 1.234321234321234e-37L, "1.23432e-37" },
2496 { 1.234321234321234e-36L, "1.23432e-36" },
2497 { 1.234321234321234e-35L, "1.23432e-35" },
2498 { 1.234321234321234e-34L, "1.23432e-34" },
2499 { 1.234321234321234e-33L, "1.23432e-33" },
2500 { 1.234321234321234e-32L, "1.23432e-32" },
2501 { 1.234321234321234e-31L, "1.23432e-31" },
2502 { 1.234321234321234e-30L, "1.23432e-30" },
2503 { 1.234321234321234e-29L, "1.23432e-29" },
2504 { 1.234321234321234e-28L, "1.23432e-28" },
2505 { 1.234321234321234e-27L, "1.23432e-27" },
2506 { 1.234321234321234e-26L, "1.23432e-26" },
2507 { 1.234321234321234e-25L, "1.23432e-25" },
2508 { 1.234321234321234e-24L, "1.23432e-24" },
2509 { 1.234321234321234e-23L, "1.23432e-23" },
2510 { 1.234321234321234e-22L, "1.23432e-22" },
2511 { 1.234321234321234e-21L, "1.23432e-21" },
2512 { 1.234321234321234e-20L, "1.23432e-20" },
2513 { 1.234321234321234e-19L, "1.23432e-19" },
2514 { 1.234321234321234e-18L, "1.23432e-18" },
2515 { 1.234321234321234e-17L, "1.23432e-17" },
2516 { 1.234321234321234e-16L, "1.23432e-16" },
2517 { 1.234321234321234e-15L, "1.23432e-15" },
2518 { 1.234321234321234e-14L, "1.23432e-14" },
2519 { 1.234321234321234e-13L, "1.23432e-13" },
2520 { 1.234321234321234e-12L, "1.23432e-12" },
2521 { 1.234321234321234e-11L, "1.23432e-11" },
2522 { 1.234321234321234e-10L, "1.23432e-10" },
2523 { 1.234321234321234e-9L, "1.23432e-09" },
2524 { 1.234321234321234e-8L, "1.23432e-08" },
2525 { 1.234321234321234e-7L, "1.23432e-07" },
2526 { 1.234321234321234e-6L, "1.23432e-06" },
2527 { 1.234321234321234e-5L, "1.23432e-05" },
2528 { 1.234321234321234e-4L, "0.000123432" },
2529 { 1.234321234321234e-3L, "0.00123432" },
2530 { 1.234321234321234e-2L, "0.0123432" },
2531 { 1.234321234321234e-1L, "0.123432" },
2532 { 1.234321234321234L, "1.23432" },
2533 { 1.234321234321234e1L, "12.3432" },
2534 { 1.234321234321234e2L, "123.432" },
2535 { 1.234321234321234e3L, "1234.32" },
2536 { 1.234321234321234e4L, "12343.2" },
2537 { 1.234321234321234e5L, "123432" },
2538 { 1.234321234321234e6L, "1.23432e+06" },
2539 { 1.234321234321234e7L, "1.23432e+07" },
2540 { 1.234321234321234e8L, "1.23432e+08" },
2541 { 1.234321234321234e9L, "1.23432e+09" },
2542 { 1.234321234321234e10L, "1.23432e+10" },
2543 { 1.234321234321234e11L, "1.23432e+11" },
2544 { 1.234321234321234e12L, "1.23432e+12" },
2545 { 1.234321234321234e13L, "1.23432e+13" },
2546 { 1.234321234321234e14L, "1.23432e+14" },
2547 { 1.234321234321234e15L, "1.23432e+15" },
2548 { 1.234321234321234e16L, "1.23432e+16" },
2549 { 1.234321234321234e17L, "1.23432e+17" },
2550 { 1.234321234321234e18L, "1.23432e+18" },
2551 { 1.234321234321234e19L, "1.23432e+19" },
2552 { 1.234321234321234e20L, "1.23432e+20" },
2553 { 1.234321234321234e21L, "1.23432e+21" },
2554 { 1.234321234321234e22L, "1.23432e+22" },
2555 { 1.234321234321234e23L, "1.23432e+23" },
2556 { 1.234321234321234e24L, "1.23432e+24" },
2557 { 1.234321234321234e25L, "1.23432e+25" },
2558 { 1.234321234321234e26L, "1.23432e+26" },
2559 { 1.234321234321234e27L, "1.23432e+27" },
2560 { 1.234321234321234e28L, "1.23432e+28" },
2561 { 1.234321234321234e29L, "1.23432e+29" },
2562 { 1.234321234321234e30L, "1.23432e+30" },
2563 { 1.234321234321234e31L, "1.23432e+31" },
2564 { 1.234321234321234e32L, "1.23432e+32" },
2565 { 1.234321234321234e33L, "1.23432e+33" },
2566 { 1.234321234321234e34L, "1.23432e+34" },
2567 { 1.234321234321234e35L, "1.23432e+35" },
2568 { 1.234321234321234e36L, "1.23432e+36" }
2571 for (k = 0; k < SIZEOF (data); k++)
2575 my_asprintf (&result, "%Lg", data[k].value);
2576 ASSERT (result != NULL);
2577 ASSERT (strcmp (result, data[k].string) == 0);
2578 ASSERT (retval == strlen (result));
2583 { /* A negative number. */
2586 my_asprintf (&result, "%Lg %d", -0.03125L, 33, 44, 55);
2587 ASSERT (result != NULL);
2588 ASSERT (strcmp (result, "-0.03125 33") == 0);
2589 ASSERT (retval == strlen (result));
2593 { /* Positive zero. */
2596 my_asprintf (&result, "%Lg %d", 0.0L, 33, 44, 55);
2597 ASSERT (result != NULL);
2598 ASSERT (strcmp (result, "0 33") == 0);
2599 ASSERT (retval == strlen (result));
2603 { /* Negative zero. */
2606 my_asprintf (&result, "%Lg %d", -0.0L, 33, 44, 55);
2607 ASSERT (result != NULL);
2608 if (have_minus_zero ())
2609 ASSERT (strcmp (result, "-0 33") == 0);
2610 ASSERT (retval == strlen (result));
2614 { /* Positive infinity. */
2617 my_asprintf (&result, "%Lg %d", 1.0L / 0.0L, 33, 44, 55);
2618 ASSERT (result != NULL);
2619 ASSERT (strcmp (result, "inf 33") == 0
2620 || strcmp (result, "infinity 33") == 0);
2621 ASSERT (retval == strlen (result));
2625 { /* Negative infinity. */
2628 my_asprintf (&result, "%Lg %d", -1.0L / 0.0L, 33, 44, 55);
2629 ASSERT (result != NULL);
2630 ASSERT (strcmp (result, "-inf 33") == 0
2631 || strcmp (result, "-infinity 33") == 0);
2632 ASSERT (retval == strlen (result));
2637 static long double zero = 0.0L;
2640 my_asprintf (&result, "%Lg %d", zero / zero, 33, 44, 55);
2641 ASSERT (result != NULL);
2642 ASSERT (strlen (result) >= 3 + 3
2643 && memcmp (result, "nan", 3) == 0
2644 && strcmp (result + strlen (result) - 3, " 33") == 0);
2645 ASSERT (retval == strlen (result));
2652 my_asprintf (&result, "%10Lg %d", 1.75L, 33, 44, 55);
2653 ASSERT (result != NULL);
2654 ASSERT (strcmp (result, " 1.75 33") == 0);
2655 ASSERT (retval == strlen (result));
2662 my_asprintf (&result, "%-10Lg %d", 1.75L, 33, 44, 55);
2663 ASSERT (result != NULL);
2664 ASSERT (strcmp (result, "1.75 33") == 0);
2665 ASSERT (retval == strlen (result));
2669 { /* FLAG_SHOWSIGN. */
2672 my_asprintf (&result, "%+Lg %d", 1.75L, 33, 44, 55);
2673 ASSERT (result != NULL);
2674 ASSERT (strcmp (result, "+1.75 33") == 0);
2675 ASSERT (retval == strlen (result));
2682 my_asprintf (&result, "% Lg %d", 1.75L, 33, 44, 55);
2683 ASSERT (result != NULL);
2684 ASSERT (strcmp (result, " 1.75 33") == 0);
2685 ASSERT (retval == strlen (result));
2692 my_asprintf (&result, "%#Lg %d", 1.75L, 33, 44, 55);
2693 ASSERT (result != NULL);
2694 ASSERT (strcmp (result, "1.75000 33") == 0);
2695 ASSERT (retval == strlen (result));
2702 my_asprintf (&result, "%#.Lg %d", 1.75L, 33, 44, 55);
2703 ASSERT (result != NULL);
2704 ASSERT (strcmp (result, "2. 33") == 0);
2705 ASSERT (retval == strlen (result));
2712 my_asprintf (&result, "%#.Lg %d", 9.75L, 33, 44, 55);
2713 ASSERT (result != NULL);
2714 ASSERT (strcmp (result, "1.e+01 33") == 0);
2715 ASSERT (retval == strlen (result));
2719 { /* FLAG_ZERO with finite number. */
2722 my_asprintf (&result, "%010Lg %d", 1234.0L, 33, 44, 55);
2723 ASSERT (result != NULL);
2724 ASSERT (strcmp (result, "0000001234 33") == 0);
2725 ASSERT (retval == strlen (result));
2729 { /* FLAG_ZERO with infinite number. */
2732 my_asprintf (&result, "%015Lg %d", -1.0L / 0.0L, 33, 44, 55);
2733 ASSERT (result != NULL);
2734 ASSERT (strcmp (result, " -inf 33") == 0
2735 || strcmp (result, " -infinity 33") == 0);
2736 ASSERT (retval == strlen (result));
2740 { /* FLAG_ZERO with NaN. */
2741 static long double zero = 0.0L;
2744 my_asprintf (&result, "%020Lg %d", zero / zero, 33, 44, 55);
2745 ASSERT (result != NULL);
2746 ASSERT (strlen (result) == 20 + 3
2747 && memcmp (result + strspn (result, " "), "nan", 3) == 0
2748 && strcmp (result + strlen (result) - 3, " 33") == 0);
2749 ASSERT (retval == strlen (result));
2756 my_asprintf (&result, "%.Lg %d", 1234.0L, 33, 44, 55);
2757 ASSERT (result != NULL);
2758 ASSERT (strcmp (result, "1e+03 33") == 0);
2759 ASSERT (retval == strlen (result));
2763 /* Test the support of the %n format directive. */
2769 my_asprintf (&result, "%d %n", 123, &count, 33, 44, 55);
2770 ASSERT (result != NULL);
2771 ASSERT (strcmp (result, "123 ") == 0);
2772 ASSERT (retval == strlen (result));
2773 ASSERT (count == 4);
2777 /* Test the support of the POSIX/XSI format strings with positions. */
2782 my_asprintf (&result, "%2$d %1$d", 33, 55);
2783 ASSERT (result != NULL);
2784 ASSERT (strcmp (result, "55 33") == 0);
2785 ASSERT (retval == strlen (result));
2789 /* Test the support of the grouping flag. */
2794 my_asprintf (&result, "%'d %d", 1234567, 99);
2795 ASSERT (result != NULL);
2796 ASSERT (result[strlen (result) - 1] == '9');
2797 ASSERT (retval == strlen (result));
2803 my_asprintf (char **result, const char *format, ...)
2808 va_start (args, format);
2809 ret = vasprintf (result, format, args);
2817 test_function (my_asprintf);
2823 test_function (asprintf);
2827 main (int argc, char *argv[])