1 /* Test of POSIX compatible vasprintf() and asprintf() functions.
2 Copyright (C) 2007-2013 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. */
31 #include "minus-zero.h"
35 /* The SGI MIPS floating-point format does not distinguish 0.0 and -0.0. */
39 static double plus_zero = 0.0;
40 double minus_zero = minus_zerod;
41 return memcmp (&plus_zero, &minus_zero, sizeof (double)) != 0;
44 /* Representation of an 80-bit 'long double' as an initializer for a sequence
45 of 'unsigned int' words. */
46 #ifdef WORDS_BIGENDIAN
47 # define LDBL80_WORDS(exponent,manthi,mantlo) \
48 { ((unsigned int) (exponent) << 16) | ((unsigned int) (manthi) >> 16), \
49 ((unsigned int) (manthi) << 16) | (unsigned int) (mantlo) >> 16), \
50 (unsigned int) (mantlo) << 16 \
53 # define LDBL80_WORDS(exponent,manthi,mantlo) \
54 { mantlo, manthi, exponent }
58 strmatch (const char *pattern, const char *string)
60 if (strlen (pattern) != strlen (string))
62 for (; *pattern != '\0'; pattern++, string++)
63 if (*pattern != '*' && *string != *pattern)
68 /* Test whether string[start_index..end_index-1] is a valid textual
69 representation of NaN. */
71 strisnan (const char *string, size_t start_index, size_t end_index, int uppercase)
73 if (start_index < end_index)
75 if (string[start_index] == '-')
77 if (start_index + 3 <= end_index
78 && memcmp (string + start_index, uppercase ? "NAN" : "nan", 3) == 0)
81 if (start_index == end_index
82 || (string[start_index] == '(' && string[end_index - 1] == ')'))
90 test_function (int (*my_asprintf) (char **, const char *, ...))
94 /* Test return value convention. */
96 for (repeat = 0; repeat <= 8; repeat++)
99 int retval = asprintf (&result, "%d", 12345);
100 ASSERT (retval == 5);
101 ASSERT (result != NULL);
102 ASSERT (strcmp (result, "12345") == 0);
106 /* Test support of size specifiers as in C99. */
111 my_asprintf (&result, "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
112 ASSERT (result != NULL);
113 ASSERT (strcmp (result, "12345671 33") == 0);
114 ASSERT (retval == strlen (result));
121 my_asprintf (&result, "%zu %d", (size_t) 12345672, 33, 44, 55);
122 ASSERT (result != NULL);
123 ASSERT (strcmp (result, "12345672 33") == 0);
124 ASSERT (retval == strlen (result));
131 my_asprintf (&result, "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
132 ASSERT (result != NULL);
133 ASSERT (strcmp (result, "12345673 33") == 0);
134 ASSERT (retval == strlen (result));
141 my_asprintf (&result, "%Lg %d", (long double) 1.5, 33, 44, 55);
142 ASSERT (result != NULL);
143 ASSERT (strcmp (result, "1.5 33") == 0);
144 ASSERT (retval == strlen (result));
148 /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
149 output of floating-point numbers. */
151 { /* A positive number. */
154 my_asprintf (&result, "%a %d", 3.1416015625, 33, 44, 55);
155 ASSERT (result != NULL);
156 ASSERT (strcmp (result, "0x1.922p+1 33") == 0
157 || strcmp (result, "0x3.244p+0 33") == 0
158 || strcmp (result, "0x6.488p-1 33") == 0
159 || strcmp (result, "0xc.91p-2 33") == 0);
160 ASSERT (retval == strlen (result));
164 { /* A negative number. */
167 my_asprintf (&result, "%A %d", -3.1416015625, 33, 44, 55);
168 ASSERT (result != NULL);
169 ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
170 || strcmp (result, "-0X3.244P+0 33") == 0
171 || strcmp (result, "-0X6.488P-1 33") == 0
172 || strcmp (result, "-0XC.91P-2 33") == 0);
173 ASSERT (retval == strlen (result));
177 { /* Positive zero. */
180 my_asprintf (&result, "%a %d", 0.0, 33, 44, 55);
181 ASSERT (result != NULL);
182 ASSERT (strcmp (result, "0x0p+0 33") == 0);
183 ASSERT (retval == strlen (result));
187 { /* Negative zero. */
190 my_asprintf (&result, "%a %d", minus_zerod, 33, 44, 55);
191 ASSERT (result != NULL);
192 if (have_minus_zero ())
193 ASSERT (strcmp (result, "-0x0p+0 33") == 0);
194 ASSERT (retval == strlen (result));
198 { /* Positive infinity. */
201 my_asprintf (&result, "%a %d", Infinityd (), 33, 44, 55);
202 ASSERT (result != NULL);
203 ASSERT (strcmp (result, "inf 33") == 0);
204 ASSERT (retval == strlen (result));
208 { /* Negative infinity. */
211 my_asprintf (&result, "%a %d", - Infinityd (), 33, 44, 55);
212 ASSERT (result != NULL);
213 ASSERT (strcmp (result, "-inf 33") == 0);
214 ASSERT (retval == strlen (result));
221 my_asprintf (&result, "%a %d", NaNd (), 33, 44, 55);
222 ASSERT (result != NULL);
223 ASSERT (strlen (result) >= 3 + 3
224 && strisnan (result, 0, strlen (result) - 3, 0)
225 && strcmp (result + strlen (result) - 3, " 33") == 0);
226 ASSERT (retval == strlen (result));
230 { /* Rounding near the decimal point. */
233 my_asprintf (&result, "%.0a %d", 1.5, 33, 44, 55);
234 ASSERT (result != NULL);
235 ASSERT (strcmp (result, "0x1p+0 33") == 0
236 || 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 0. */
247 my_asprintf (&result, "%.0a %d", 1.51, 33, 44, 55);
248 ASSERT (result != NULL);
249 ASSERT (strcmp (result, "0x1p+0 33") == 0
250 || strcmp (result, "0x2p+0 33") == 0
251 || strcmp (result, "0x3p-1 33") == 0
252 || strcmp (result, "0x6p-2 33") == 0
253 || strcmp (result, "0xcp-3 33") == 0);
254 ASSERT (retval == strlen (result));
258 { /* Rounding with precision 1. */
261 my_asprintf (&result, "%.1a %d", 1.51, 33, 44, 55);
262 ASSERT (result != NULL);
263 ASSERT (strcmp (result, "0x1.8p+0 33") == 0
264 || strcmp (result, "0x3.0p-1 33") == 0
265 || strcmp (result, "0x6.1p-2 33") == 0
266 || strcmp (result, "0xc.1p-3 33") == 0);
267 ASSERT (retval == strlen (result));
271 { /* Rounding with precision 2. */
274 my_asprintf (&result, "%.2a %d", 1.51, 33, 44, 55);
275 ASSERT (result != NULL);
276 ASSERT (strcmp (result, "0x1.83p+0 33") == 0
277 || strcmp (result, "0x3.05p-1 33") == 0
278 || strcmp (result, "0x6.0ap-2 33") == 0
279 || strcmp (result, "0xc.14p-3 33") == 0);
280 ASSERT (retval == strlen (result));
284 { /* Rounding with precision 3. */
287 my_asprintf (&result, "%.3a %d", 1.51, 33, 44, 55);
288 ASSERT (result != NULL);
289 ASSERT (strcmp (result, "0x1.829p+0 33") == 0
290 || strcmp (result, "0x3.052p-1 33") == 0
291 || strcmp (result, "0x6.0a4p-2 33") == 0
292 || strcmp (result, "0xc.148p-3 33") == 0);
293 ASSERT (retval == strlen (result));
297 { /* Rounding can turn a ...FFF into a ...000. */
300 my_asprintf (&result, "%.3a %d", 1.49999, 33, 44, 55);
301 ASSERT (result != NULL);
302 ASSERT (strcmp (result, "0x1.800p+0 33") == 0
303 || strcmp (result, "0x3.000p-1 33") == 0
304 || strcmp (result, "0x6.000p-2 33") == 0
305 || strcmp (result, "0xc.000p-3 33") == 0);
306 ASSERT (retval == strlen (result));
310 { /* Rounding can turn a ...FFF into a ...000.
311 This shows a Mac OS X 10.3.9 (Darwin 7.9) bug. */
314 my_asprintf (&result, "%.1a %d", 1.999, 33, 44, 55);
315 ASSERT (result != NULL);
316 ASSERT (strcmp (result, "0x1.0p+1 33") == 0
317 || strcmp (result, "0x2.0p+0 33") == 0
318 || strcmp (result, "0x4.0p-1 33") == 0
319 || strcmp (result, "0x8.0p-2 33") == 0);
320 ASSERT (retval == strlen (result));
327 my_asprintf (&result, "%10a %d", 1.75, 33, 44, 55);
328 ASSERT (result != NULL);
329 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
330 || strcmp (result, " 0x3.8p-1 33") == 0
331 || strcmp (result, " 0x7p-2 33") == 0
332 || strcmp (result, " 0xep-3 33") == 0);
333 ASSERT (retval == strlen (result));
337 { /* Small precision. */
340 my_asprintf (&result, "%.10a %d", 1.75, 33, 44, 55);
341 ASSERT (result != NULL);
342 ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
343 || strcmp (result, "0x3.8000000000p-1 33") == 0
344 || strcmp (result, "0x7.0000000000p-2 33") == 0
345 || strcmp (result, "0xe.0000000000p-3 33") == 0);
346 ASSERT (retval == strlen (result));
350 { /* Large precision. */
353 my_asprintf (&result, "%.50a %d", 1.75, 33, 44, 55);
354 ASSERT (result != NULL);
355 ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
356 || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
357 || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
358 || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
359 ASSERT (retval == strlen (result));
366 my_asprintf (&result, "%-10a %d", 1.75, 33, 44, 55);
367 ASSERT (result != NULL);
368 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
369 || strcmp (result, "0x3.8p-1 33") == 0
370 || strcmp (result, "0x7p-2 33") == 0
371 || strcmp (result, "0xep-3 33") == 0);
372 ASSERT (retval == strlen (result));
376 { /* FLAG_SHOWSIGN. */
379 my_asprintf (&result, "%+a %d", 1.75, 33, 44, 55);
380 ASSERT (result != NULL);
381 ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
382 || strcmp (result, "+0x3.8p-1 33") == 0
383 || strcmp (result, "+0x7p-2 33") == 0
384 || strcmp (result, "+0xep-3 33") == 0);
385 ASSERT (retval == strlen (result));
392 my_asprintf (&result, "% a %d", 1.75, 33, 44, 55);
393 ASSERT (result != NULL);
394 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
395 || strcmp (result, " 0x3.8p-1 33") == 0
396 || strcmp (result, " 0x7p-2 33") == 0
397 || strcmp (result, " 0xep-3 33") == 0);
398 ASSERT (retval == strlen (result));
405 my_asprintf (&result, "%#a %d", 1.75, 33, 44, 55);
406 ASSERT (result != NULL);
407 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
408 || strcmp (result, "0x3.8p-1 33") == 0
409 || strcmp (result, "0x7.p-2 33") == 0
410 || strcmp (result, "0xe.p-3 33") == 0);
411 ASSERT (retval == strlen (result));
418 my_asprintf (&result, "%#a %d", 1.0, 33, 44, 55);
419 ASSERT (result != NULL);
420 ASSERT (strcmp (result, "0x1.p+0 33") == 0
421 || strcmp (result, "0x2.p-1 33") == 0
422 || strcmp (result, "0x4.p-2 33") == 0
423 || strcmp (result, "0x8.p-3 33") == 0);
424 ASSERT (retval == strlen (result));
428 { /* FLAG_ZERO with finite number. */
431 my_asprintf (&result, "%010a %d", 1.75, 33, 44, 55);
432 ASSERT (result != NULL);
433 ASSERT (strcmp (result, "0x001.cp+0 33") == 0
434 || strcmp (result, "0x003.8p-1 33") == 0
435 || strcmp (result, "0x00007p-2 33") == 0
436 || strcmp (result, "0x0000ep-3 33") == 0);
437 ASSERT (retval == strlen (result));
441 { /* FLAG_ZERO with infinite number. */
444 my_asprintf (&result, "%010a %d", Infinityd (), 33, 44, 55);
445 ASSERT (result != NULL);
446 /* "0000000inf 33" is not a valid result; see
447 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
448 ASSERT (strcmp (result, " inf 33") == 0);
449 ASSERT (retval == strlen (result));
453 { /* FLAG_ZERO with NaN. */
456 my_asprintf (&result, "%050a %d", NaNd (), 33, 44, 55);
457 ASSERT (result != NULL);
458 /* "0000000nan 33" is not a valid result; see
459 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
460 ASSERT (strlen (result) == 50 + 3
461 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
462 && strcmp (result + strlen (result) - 3, " 33") == 0);
463 ASSERT (retval == strlen (result));
467 { /* A positive number. */
470 my_asprintf (&result, "%La %d", 3.1416015625L, 33, 44, 55);
471 ASSERT (result != NULL);
472 ASSERT (strcmp (result, "0x1.922p+1 33") == 0
473 || strcmp (result, "0x3.244p+0 33") == 0
474 || strcmp (result, "0x6.488p-1 33") == 0
475 || strcmp (result, "0xc.91p-2 33") == 0);
476 ASSERT (retval == strlen (result));
480 { /* A negative number. */
483 my_asprintf (&result, "%LA %d", -3.1416015625L, 33, 44, 55);
484 ASSERT (result != NULL);
485 ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
486 || strcmp (result, "-0X3.244P+0 33") == 0
487 || strcmp (result, "-0X6.488P-1 33") == 0
488 || strcmp (result, "-0XC.91P-2 33") == 0);
489 ASSERT (retval == strlen (result));
493 { /* Positive zero. */
496 my_asprintf (&result, "%La %d", 0.0L, 33, 44, 55);
497 ASSERT (result != NULL);
498 ASSERT (strcmp (result, "0x0p+0 33") == 0);
499 ASSERT (retval == strlen (result));
503 { /* Negative zero. */
506 my_asprintf (&result, "%La %d", minus_zerol, 33, 44, 55);
507 ASSERT (result != NULL);
508 if (have_minus_zero ())
509 ASSERT (strcmp (result, "-0x0p+0 33") == 0);
510 ASSERT (retval == strlen (result));
514 { /* Positive infinity. */
517 my_asprintf (&result, "%La %d", Infinityl (), 33, 44, 55);
518 ASSERT (result != NULL);
519 ASSERT (strcmp (result, "inf 33") == 0);
520 ASSERT (retval == strlen (result));
524 { /* Negative infinity. */
527 my_asprintf (&result, "%La %d", - Infinityl (), 33, 44, 55);
528 ASSERT (result != NULL);
529 ASSERT (strcmp (result, "-inf 33") == 0);
530 ASSERT (retval == strlen (result));
537 my_asprintf (&result, "%La %d", NaNl (), 33, 44, 55);
538 ASSERT (result != NULL);
539 ASSERT (strlen (result) >= 3 + 3
540 && strisnan (result, 0, strlen (result) - 3, 0)
541 && strcmp (result + strlen (result) - 3, " 33") == 0);
542 ASSERT (retval == strlen (result));
545 #if CHECK_PRINTF_SAFE && ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_)) && !HAVE_SAME_LONG_DOUBLE_AS_DOUBLE
547 static union { unsigned int word[4]; long double value; } x =
548 { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
551 my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
552 ASSERT (result != NULL);
553 ASSERT (strlen (result) >= 3 + 3
554 && strisnan (result, 0, strlen (result) - 3, 0)
555 && strcmp (result + strlen (result) - 3, " 33") == 0);
556 ASSERT (retval == strlen (result));
560 /* Signalling NaN. */
561 static union { unsigned int word[4]; long double value; } x =
562 { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
565 my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
566 ASSERT (result != NULL);
567 ASSERT (strlen (result) >= 3 + 3
568 && strisnan (result, 0, strlen (result) - 3, 0)
569 && strcmp (result + strlen (result) - 3, " 33") == 0);
570 ASSERT (retval == strlen (result));
573 /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
574 Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
575 Intel IA-64 Architecture Software Developer's Manual, Volume 1:
576 Application Architecture.
577 Table 5-2 "Floating-Point Register Encodings"
578 Figure 5-6 "Memory to Floating-Point Register Data Translation"
581 static union { unsigned int word[4]; long double value; } x =
582 { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
585 my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
586 ASSERT (result != NULL);
587 ASSERT (strlen (result) >= 3 + 3
588 && strisnan (result, 0, strlen (result) - 3, 0)
589 && strcmp (result + strlen (result) - 3, " 33") == 0);
590 ASSERT (retval == strlen (result));
593 { /* Pseudo-Infinity. */
594 static union { unsigned int word[4]; long double value; } x =
595 { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
598 my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
599 ASSERT (result != NULL);
600 ASSERT (strlen (result) >= 3 + 3
601 && strisnan (result, 0, strlen (result) - 3, 0)
602 && strcmp (result + strlen (result) - 3, " 33") == 0);
603 ASSERT (retval == strlen (result));
607 static union { unsigned int word[4]; long double value; } x =
608 { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
611 my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
612 ASSERT (result != NULL);
613 ASSERT (strlen (result) >= 3 + 3
614 && strisnan (result, 0, strlen (result) - 3, 0)
615 && strcmp (result + strlen (result) - 3, " 33") == 0);
616 ASSERT (retval == strlen (result));
619 { /* Unnormalized number. */
620 static union { unsigned int word[4]; long double value; } x =
621 { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
624 my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
625 ASSERT (result != NULL);
626 ASSERT (strlen (result) >= 3 + 3
627 && strisnan (result, 0, strlen (result) - 3, 0)
628 && strcmp (result + strlen (result) - 3, " 33") == 0);
629 ASSERT (retval == strlen (result));
632 { /* Pseudo-Denormal. */
633 static union { unsigned int word[4]; long double value; } x =
634 { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
637 my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
638 ASSERT (result != NULL);
639 ASSERT (strlen (result) >= 3 + 3
640 && strisnan (result, 0, strlen (result) - 3, 0)
641 && strcmp (result + strlen (result) - 3, " 33") == 0);
642 ASSERT (retval == strlen (result));
647 { /* Rounding near the decimal point. */
650 my_asprintf (&result, "%.0La %d", 1.5L, 33, 44, 55);
651 ASSERT (result != NULL);
652 ASSERT (strcmp (result, "0x2p+0 33") == 0
653 || strcmp (result, "0x3p-1 33") == 0
654 || strcmp (result, "0x6p-2 33") == 0
655 || strcmp (result, "0xcp-3 33") == 0);
656 ASSERT (retval == strlen (result));
660 { /* Rounding with precision 0. */
663 my_asprintf (&result, "%.0La %d", 1.51L, 33, 44, 55);
664 ASSERT (result != NULL);
665 ASSERT (strcmp (result, "0x2p+0 33") == 0
666 || strcmp (result, "0x3p-1 33") == 0
667 || strcmp (result, "0x6p-2 33") == 0
668 || strcmp (result, "0xcp-3 33") == 0);
669 ASSERT (retval == strlen (result));
673 { /* Rounding with precision 1. */
676 my_asprintf (&result, "%.1La %d", 1.51L, 33, 44, 55);
677 ASSERT (result != NULL);
678 ASSERT (strcmp (result, "0x1.8p+0 33") == 0
679 || strcmp (result, "0x3.0p-1 33") == 0
680 || strcmp (result, "0x6.1p-2 33") == 0
681 || strcmp (result, "0xc.1p-3 33") == 0);
682 ASSERT (retval == strlen (result));
686 { /* Rounding with precision 2. */
689 my_asprintf (&result, "%.2La %d", 1.51L, 33, 44, 55);
690 ASSERT (result != NULL);
691 ASSERT (strcmp (result, "0x1.83p+0 33") == 0
692 || strcmp (result, "0x3.05p-1 33") == 0
693 || strcmp (result, "0x6.0ap-2 33") == 0
694 || strcmp (result, "0xc.14p-3 33") == 0);
695 ASSERT (retval == strlen (result));
699 { /* Rounding with precision 3. */
702 my_asprintf (&result, "%.3La %d", 1.51L, 33, 44, 55);
703 ASSERT (result != NULL);
704 ASSERT (strcmp (result, "0x1.829p+0 33") == 0
705 || strcmp (result, "0x3.052p-1 33") == 0
706 || strcmp (result, "0x6.0a4p-2 33") == 0
707 || strcmp (result, "0xc.148p-3 33") == 0);
708 ASSERT (retval == strlen (result));
712 { /* Rounding can turn a ...FFF into a ...000. */
715 my_asprintf (&result, "%.3La %d", 1.49999L, 33, 44, 55);
716 ASSERT (result != NULL);
717 ASSERT (strcmp (result, "0x1.800p+0 33") == 0
718 || strcmp (result, "0x3.000p-1 33") == 0
719 || strcmp (result, "0x6.000p-2 33") == 0
720 || strcmp (result, "0xc.000p-3 33") == 0);
721 ASSERT (retval == strlen (result));
725 { /* Rounding can turn a ...FFF into a ...000.
726 This shows a Mac OS X 10.3.9 (Darwin 7.9) bug and a
727 glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>. */
730 my_asprintf (&result, "%.1La %d", 1.999L, 33, 44, 55);
731 ASSERT (result != NULL);
732 ASSERT (strcmp (result, "0x1.0p+1 33") == 0
733 || strcmp (result, "0x2.0p+0 33") == 0
734 || strcmp (result, "0x4.0p-1 33") == 0
735 || strcmp (result, "0x8.0p-2 33") == 0);
736 ASSERT (retval == strlen (result));
743 my_asprintf (&result, "%10La %d", 1.75L, 33, 44, 55);
744 ASSERT (result != NULL);
745 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
746 || strcmp (result, " 0x3.8p-1 33") == 0
747 || strcmp (result, " 0x7p-2 33") == 0
748 || strcmp (result, " 0xep-3 33") == 0);
749 ASSERT (retval == strlen (result));
753 { /* Small precision. */
756 my_asprintf (&result, "%.10La %d", 1.75L, 33, 44, 55);
757 ASSERT (result != NULL);
758 ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
759 || strcmp (result, "0x3.8000000000p-1 33") == 0
760 || strcmp (result, "0x7.0000000000p-2 33") == 0
761 || strcmp (result, "0xe.0000000000p-3 33") == 0);
762 ASSERT (retval == strlen (result));
766 { /* Large precision. */
769 my_asprintf (&result, "%.50La %d", 1.75L, 33, 44, 55);
770 ASSERT (result != NULL);
771 ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
772 || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
773 || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
774 || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
775 ASSERT (retval == strlen (result));
782 my_asprintf (&result, "%-10La %d", 1.75L, 33, 44, 55);
783 ASSERT (result != NULL);
784 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
785 || strcmp (result, "0x3.8p-1 33") == 0
786 || strcmp (result, "0x7p-2 33") == 0
787 || strcmp (result, "0xep-3 33") == 0);
788 ASSERT (retval == strlen (result));
792 { /* FLAG_SHOWSIGN. */
795 my_asprintf (&result, "%+La %d", 1.75L, 33, 44, 55);
796 ASSERT (result != NULL);
797 ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
798 || strcmp (result, "+0x3.8p-1 33") == 0
799 || strcmp (result, "+0x7p-2 33") == 0
800 || strcmp (result, "+0xep-3 33") == 0);
801 ASSERT (retval == strlen (result));
808 my_asprintf (&result, "% La %d", 1.75L, 33, 44, 55);
809 ASSERT (result != NULL);
810 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
811 || strcmp (result, " 0x3.8p-1 33") == 0
812 || strcmp (result, " 0x7p-2 33") == 0
813 || strcmp (result, " 0xep-3 33") == 0);
814 ASSERT (retval == strlen (result));
821 my_asprintf (&result, "%#La %d", 1.75L, 33, 44, 55);
822 ASSERT (result != NULL);
823 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
824 || strcmp (result, "0x3.8p-1 33") == 0
825 || strcmp (result, "0x7.p-2 33") == 0
826 || strcmp (result, "0xe.p-3 33") == 0);
827 ASSERT (retval == strlen (result));
834 my_asprintf (&result, "%#La %d", 1.0L, 33, 44, 55);
835 ASSERT (result != NULL);
836 ASSERT (strcmp (result, "0x1.p+0 33") == 0
837 || strcmp (result, "0x2.p-1 33") == 0
838 || strcmp (result, "0x4.p-2 33") == 0
839 || strcmp (result, "0x8.p-3 33") == 0);
840 ASSERT (retval == strlen (result));
844 { /* FLAG_ZERO with finite number. */
847 my_asprintf (&result, "%010La %d", 1.75L, 33, 44, 55);
848 ASSERT (result != NULL);
849 ASSERT (strcmp (result, "0x001.cp+0 33") == 0
850 || strcmp (result, "0x003.8p-1 33") == 0
851 || strcmp (result, "0x00007p-2 33") == 0
852 || strcmp (result, "0x0000ep-3 33") == 0);
853 ASSERT (retval == strlen (result));
857 { /* FLAG_ZERO with infinite number. */
860 my_asprintf (&result, "%010La %d", Infinityl (), 33, 44, 55);
861 ASSERT (result != NULL);
862 /* "0000000inf 33" is not a valid result; see
863 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
864 ASSERT (strcmp (result, " inf 33") == 0);
865 ASSERT (retval == strlen (result));
869 { /* FLAG_ZERO with NaN. */
872 my_asprintf (&result, "%050La %d", NaNl (), 33, 44, 55);
873 ASSERT (result != NULL);
874 /* "0000000nan 33" is not a valid result; see
875 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
876 ASSERT (strlen (result) == 50 + 3
877 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
878 && strcmp (result + strlen (result) - 3, " 33") == 0);
879 ASSERT (retval == strlen (result));
883 /* Test the support of the %f format directive. */
885 { /* A positive number. */
888 my_asprintf (&result, "%f %d", 12.75, 33, 44, 55);
889 ASSERT (result != NULL);
890 ASSERT (strcmp (result, "12.750000 33") == 0);
891 ASSERT (retval == strlen (result));
895 { /* A larger positive number. */
898 my_asprintf (&result, "%f %d", 1234567.0, 33, 44, 55);
899 ASSERT (result != NULL);
900 ASSERT (strcmp (result, "1234567.000000 33") == 0);
901 ASSERT (retval == strlen (result));
905 { /* Small and large positive numbers. */
906 static struct { double value; const char *string; } data[] =
908 { 1.234321234321234e-37, "0.000000" },
909 { 1.234321234321234e-36, "0.000000" },
910 { 1.234321234321234e-35, "0.000000" },
911 { 1.234321234321234e-34, "0.000000" },
912 { 1.234321234321234e-33, "0.000000" },
913 { 1.234321234321234e-32, "0.000000" },
914 { 1.234321234321234e-31, "0.000000" },
915 { 1.234321234321234e-30, "0.000000" },
916 { 1.234321234321234e-29, "0.000000" },
917 { 1.234321234321234e-28, "0.000000" },
918 { 1.234321234321234e-27, "0.000000" },
919 { 1.234321234321234e-26, "0.000000" },
920 { 1.234321234321234e-25, "0.000000" },
921 { 1.234321234321234e-24, "0.000000" },
922 { 1.234321234321234e-23, "0.000000" },
923 { 1.234321234321234e-22, "0.000000" },
924 { 1.234321234321234e-21, "0.000000" },
925 { 1.234321234321234e-20, "0.000000" },
926 { 1.234321234321234e-19, "0.000000" },
927 { 1.234321234321234e-18, "0.000000" },
928 { 1.234321234321234e-17, "0.000000" },
929 { 1.234321234321234e-16, "0.000000" },
930 { 1.234321234321234e-15, "0.000000" },
931 { 1.234321234321234e-14, "0.000000" },
932 { 1.234321234321234e-13, "0.000000" },
933 { 1.234321234321234e-12, "0.000000" },
934 { 1.234321234321234e-11, "0.000000" },
935 { 1.234321234321234e-10, "0.000000" },
936 { 1.234321234321234e-9, "0.000000" },
937 { 1.234321234321234e-8, "0.000000" },
938 { 1.234321234321234e-7, "0.000000" },
939 { 1.234321234321234e-6, "0.000001" },
940 { 1.234321234321234e-5, "0.000012" },
941 { 1.234321234321234e-4, "0.000123" },
942 { 1.234321234321234e-3, "0.001234" },
943 { 1.234321234321234e-2, "0.012343" },
944 { 1.234321234321234e-1, "0.123432" },
945 { 1.234321234321234, "1.234321" },
946 { 1.234321234321234e1, "12.343212" },
947 { 1.234321234321234e2, "123.432123" },
948 { 1.234321234321234e3, "1234.321234" },
949 { 1.234321234321234e4, "12343.212343" },
950 { 1.234321234321234e5, "123432.123432" },
951 { 1.234321234321234e6, "1234321.234321" },
952 { 1.234321234321234e7, "12343212.343212" },
953 { 1.234321234321234e8, "123432123.432123" },
954 { 1.234321234321234e9, "1234321234.321234" },
955 { 1.234321234321234e10, "12343212343.2123**" },
956 { 1.234321234321234e11, "123432123432.123***" },
957 { 1.234321234321234e12, "1234321234321.23****" },
958 { 1.234321234321234e13, "12343212343212.3*****" },
959 { 1.234321234321234e14, "123432123432123.******" },
960 { 1.234321234321234e15, "1234321234321234.000000" },
961 { 1.234321234321234e16, "123432123432123**.000000" },
962 { 1.234321234321234e17, "123432123432123***.000000" },
963 { 1.234321234321234e18, "123432123432123****.000000" },
964 { 1.234321234321234e19, "123432123432123*****.000000" },
965 { 1.234321234321234e20, "123432123432123******.000000" },
966 { 1.234321234321234e21, "123432123432123*******.000000" },
967 { 1.234321234321234e22, "123432123432123********.000000" },
968 { 1.234321234321234e23, "123432123432123*********.000000" },
969 { 1.234321234321234e24, "123432123432123**********.000000" },
970 { 1.234321234321234e25, "123432123432123***********.000000" },
971 { 1.234321234321234e26, "123432123432123************.000000" },
972 { 1.234321234321234e27, "123432123432123*************.000000" },
973 { 1.234321234321234e28, "123432123432123**************.000000" },
974 { 1.234321234321234e29, "123432123432123***************.000000" },
975 { 1.234321234321234e30, "123432123432123****************.000000" },
976 { 1.234321234321234e31, "123432123432123*****************.000000" },
977 { 1.234321234321234e32, "123432123432123******************.000000" },
978 { 1.234321234321234e33, "123432123432123*******************.000000" },
979 { 1.234321234321234e34, "123432123432123********************.000000" },
980 { 1.234321234321234e35, "123432123432123*********************.000000" },
981 { 1.234321234321234e36, "123432123432123**********************.000000" }
984 for (k = 0; k < SIZEOF (data); k++)
988 my_asprintf (&result, "%f", data[k].value);
989 ASSERT (result != NULL);
990 ASSERT (strmatch (data[k].string, result));
991 ASSERT (retval == strlen (result));
996 { /* A negative number. */
999 my_asprintf (&result, "%f %d", -0.03125, 33, 44, 55);
1000 ASSERT (result != NULL);
1001 ASSERT (strcmp (result, "-0.031250 33") == 0);
1002 ASSERT (retval == strlen (result));
1006 { /* Positive zero. */
1009 my_asprintf (&result, "%f %d", 0.0, 33, 44, 55);
1010 ASSERT (result != NULL);
1011 ASSERT (strcmp (result, "0.000000 33") == 0);
1012 ASSERT (retval == strlen (result));
1016 { /* Negative zero. */
1019 my_asprintf (&result, "%f %d", minus_zerod, 33, 44, 55);
1020 ASSERT (result != NULL);
1021 if (have_minus_zero ())
1022 ASSERT (strcmp (result, "-0.000000 33") == 0);
1023 ASSERT (retval == strlen (result));
1027 { /* Positive infinity. */
1030 my_asprintf (&result, "%f %d", Infinityd (), 33, 44, 55);
1031 ASSERT (result != NULL);
1032 ASSERT (strcmp (result, "inf 33") == 0
1033 || strcmp (result, "infinity 33") == 0);
1034 ASSERT (retval == strlen (result));
1038 { /* Negative infinity. */
1041 my_asprintf (&result, "%f %d", - Infinityd (), 33, 44, 55);
1042 ASSERT (result != NULL);
1043 ASSERT (strcmp (result, "-inf 33") == 0
1044 || strcmp (result, "-infinity 33") == 0);
1045 ASSERT (retval == strlen (result));
1052 my_asprintf (&result, "%f %d", NaNd (), 33, 44, 55);
1053 ASSERT (result != NULL);
1054 ASSERT (strlen (result) >= 3 + 3
1055 && strisnan (result, 0, strlen (result) - 3, 0)
1056 && strcmp (result + strlen (result) - 3, " 33") == 0);
1057 ASSERT (retval == strlen (result));
1064 my_asprintf (&result, "%10f %d", 1.75, 33, 44, 55);
1065 ASSERT (result != NULL);
1066 ASSERT (strcmp (result, " 1.750000 33") == 0);
1067 ASSERT (retval == strlen (result));
1074 my_asprintf (&result, "%-10f %d", 1.75, 33, 44, 55);
1075 ASSERT (result != NULL);
1076 ASSERT (strcmp (result, "1.750000 33") == 0);
1077 ASSERT (retval == strlen (result));
1081 { /* FLAG_SHOWSIGN. */
1084 my_asprintf (&result, "%+f %d", 1.75, 33, 44, 55);
1085 ASSERT (result != NULL);
1086 ASSERT (strcmp (result, "+1.750000 33") == 0);
1087 ASSERT (retval == strlen (result));
1094 my_asprintf (&result, "% f %d", 1.75, 33, 44, 55);
1095 ASSERT (result != NULL);
1096 ASSERT (strcmp (result, " 1.750000 33") == 0);
1097 ASSERT (retval == strlen (result));
1104 my_asprintf (&result, "%#f %d", 1.75, 33, 44, 55);
1105 ASSERT (result != NULL);
1106 ASSERT (strcmp (result, "1.750000 33") == 0);
1107 ASSERT (retval == strlen (result));
1114 my_asprintf (&result, "%#.f %d", 1.75, 33, 44, 55);
1115 ASSERT (result != NULL);
1116 ASSERT (strcmp (result, "2. 33") == 0);
1117 ASSERT (retval == strlen (result));
1121 { /* FLAG_ZERO with finite number. */
1124 my_asprintf (&result, "%015f %d", 1234.0, 33, 44, 55);
1125 ASSERT (result != NULL);
1126 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1127 ASSERT (retval == strlen (result));
1131 { /* FLAG_ZERO with infinite number. */
1134 my_asprintf (&result, "%015f %d", - Infinityd (), 33, 44, 55);
1135 ASSERT (result != NULL);
1136 ASSERT (strcmp (result, " -inf 33") == 0
1137 || strcmp (result, " -infinity 33") == 0);
1138 ASSERT (retval == strlen (result));
1142 { /* FLAG_ZERO with NaN. */
1145 my_asprintf (&result, "%050f %d", NaNd (), 33, 44, 55);
1146 ASSERT (result != NULL);
1147 ASSERT (strlen (result) == 50 + 3
1148 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1149 && strcmp (result + strlen (result) - 3, " 33") == 0);
1150 ASSERT (retval == strlen (result));
1157 my_asprintf (&result, "%.f %d", 1234.0, 33, 44, 55);
1158 ASSERT (result != NULL);
1159 ASSERT (strcmp (result, "1234 33") == 0);
1160 ASSERT (retval == strlen (result));
1164 { /* Precision with no rounding. */
1167 my_asprintf (&result, "%.2f %d", 999.951, 33, 44, 55);
1168 ASSERT (result != NULL);
1169 ASSERT (strcmp (result, "999.95 33") == 0);
1170 ASSERT (retval == strlen (result));
1174 { /* Precision with rounding. */
1177 my_asprintf (&result, "%.2f %d", 999.996, 33, 44, 55);
1178 ASSERT (result != NULL);
1179 ASSERT (strcmp (result, "1000.00 33") == 0);
1180 ASSERT (retval == strlen (result));
1184 { /* A positive number. */
1187 my_asprintf (&result, "%Lf %d", 12.75L, 33, 44, 55);
1188 ASSERT (result != NULL);
1189 ASSERT (strcmp (result, "12.750000 33") == 0);
1190 ASSERT (retval == strlen (result));
1194 { /* A larger positive number. */
1197 my_asprintf (&result, "%Lf %d", 1234567.0L, 33, 44, 55);
1198 ASSERT (result != NULL);
1199 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1200 ASSERT (retval == strlen (result));
1204 { /* Small and large positive numbers. */
1205 static struct { long double value; const char *string; } data[] =
1207 { 1.234321234321234e-37L, "0.000000" },
1208 { 1.234321234321234e-36L, "0.000000" },
1209 { 1.234321234321234e-35L, "0.000000" },
1210 { 1.234321234321234e-34L, "0.000000" },
1211 { 1.234321234321234e-33L, "0.000000" },
1212 { 1.234321234321234e-32L, "0.000000" },
1213 { 1.234321234321234e-31L, "0.000000" },
1214 { 1.234321234321234e-30L, "0.000000" },
1215 { 1.234321234321234e-29L, "0.000000" },
1216 { 1.234321234321234e-28L, "0.000000" },
1217 { 1.234321234321234e-27L, "0.000000" },
1218 { 1.234321234321234e-26L, "0.000000" },
1219 { 1.234321234321234e-25L, "0.000000" },
1220 { 1.234321234321234e-24L, "0.000000" },
1221 { 1.234321234321234e-23L, "0.000000" },
1222 { 1.234321234321234e-22L, "0.000000" },
1223 { 1.234321234321234e-21L, "0.000000" },
1224 { 1.234321234321234e-20L, "0.000000" },
1225 { 1.234321234321234e-19L, "0.000000" },
1226 { 1.234321234321234e-18L, "0.000000" },
1227 { 1.234321234321234e-17L, "0.000000" },
1228 { 1.234321234321234e-16L, "0.000000" },
1229 { 1.234321234321234e-15L, "0.000000" },
1230 { 1.234321234321234e-14L, "0.000000" },
1231 { 1.234321234321234e-13L, "0.000000" },
1232 { 1.234321234321234e-12L, "0.000000" },
1233 { 1.234321234321234e-11L, "0.000000" },
1234 { 1.234321234321234e-10L, "0.000000" },
1235 { 1.234321234321234e-9L, "0.000000" },
1236 { 1.234321234321234e-8L, "0.000000" },
1237 { 1.234321234321234e-7L, "0.000000" },
1238 { 1.234321234321234e-6L, "0.000001" },
1239 { 1.234321234321234e-5L, "0.000012" },
1240 { 1.234321234321234e-4L, "0.000123" },
1241 { 1.234321234321234e-3L, "0.001234" },
1242 { 1.234321234321234e-2L, "0.012343" },
1243 { 1.234321234321234e-1L, "0.123432" },
1244 { 1.234321234321234L, "1.234321" },
1245 { 1.234321234321234e1L, "12.343212" },
1246 { 1.234321234321234e2L, "123.432123" },
1247 { 1.234321234321234e3L, "1234.321234" },
1248 { 1.234321234321234e4L, "12343.212343" },
1249 { 1.234321234321234e5L, "123432.123432" },
1250 { 1.234321234321234e6L, "1234321.234321" },
1251 { 1.234321234321234e7L, "12343212.343212" },
1252 { 1.234321234321234e8L, "123432123.432123" },
1253 { 1.234321234321234e9L, "1234321234.321234" },
1254 { 1.234321234321234e10L, "12343212343.2123**" },
1255 { 1.234321234321234e11L, "123432123432.123***" },
1256 { 1.234321234321234e12L, "1234321234321.23****" },
1257 { 1.234321234321234e13L, "12343212343212.3*****" },
1258 { 1.234321234321234e14L, "123432123432123.******" },
1259 { 1.234321234321234e15L, "1234321234321234.000000" },
1260 { 1.234321234321234e16L, "123432123432123**.000000" },
1261 { 1.234321234321234e17L, "123432123432123***.000000" },
1262 { 1.234321234321234e18L, "123432123432123****.000000" },
1263 { 1.234321234321234e19L, "123432123432123*****.000000" },
1264 { 1.234321234321234e20L, "123432123432123******.000000" },
1265 { 1.234321234321234e21L, "123432123432123*******.000000" },
1266 { 1.234321234321234e22L, "123432123432123********.000000" },
1267 { 1.234321234321234e23L, "123432123432123*********.000000" },
1268 { 1.234321234321234e24L, "123432123432123**********.000000" },
1269 { 1.234321234321234e25L, "123432123432123***********.000000" },
1270 { 1.234321234321234e26L, "123432123432123************.000000" },
1271 { 1.234321234321234e27L, "123432123432123*************.000000" },
1272 { 1.234321234321234e28L, "123432123432123**************.000000" },
1273 { 1.234321234321234e29L, "123432123432123***************.000000" },
1274 { 1.234321234321234e30L, "123432123432123****************.000000" },
1275 { 1.234321234321234e31L, "123432123432123*****************.000000" },
1276 { 1.234321234321234e32L, "123432123432123******************.000000" },
1277 { 1.234321234321234e33L, "123432123432123*******************.000000" },
1278 { 1.234321234321234e34L, "123432123432123********************.000000" },
1279 { 1.234321234321234e35L, "123432123432123*********************.000000" },
1280 { 1.234321234321234e36L, "123432123432123**********************.000000" }
1283 for (k = 0; k < SIZEOF (data); k++)
1287 my_asprintf (&result, "%Lf", data[k].value);
1288 ASSERT (result != NULL);
1289 ASSERT (strmatch (data[k].string, result));
1290 ASSERT (retval == strlen (result));
1295 { /* A negative number. */
1298 my_asprintf (&result, "%Lf %d", -0.03125L, 33, 44, 55);
1299 ASSERT (result != NULL);
1300 ASSERT (strcmp (result, "-0.031250 33") == 0);
1301 ASSERT (retval == strlen (result));
1305 { /* Positive zero. */
1308 my_asprintf (&result, "%Lf %d", 0.0L, 33, 44, 55);
1309 ASSERT (result != NULL);
1310 ASSERT (strcmp (result, "0.000000 33") == 0);
1311 ASSERT (retval == strlen (result));
1315 { /* Negative zero. */
1318 my_asprintf (&result, "%Lf %d", minus_zerol, 33, 44, 55);
1319 ASSERT (result != NULL);
1320 if (have_minus_zero ())
1321 ASSERT (strcmp (result, "-0.000000 33") == 0);
1322 ASSERT (retval == strlen (result));
1326 { /* Positive infinity. */
1329 my_asprintf (&result, "%Lf %d", Infinityl (), 33, 44, 55);
1330 ASSERT (result != NULL);
1331 ASSERT (strcmp (result, "inf 33") == 0
1332 || strcmp (result, "infinity 33") == 0);
1333 ASSERT (retval == strlen (result));
1337 { /* Negative infinity. */
1340 my_asprintf (&result, "%Lf %d", - Infinityl (), 33, 44, 55);
1341 ASSERT (result != NULL);
1342 ASSERT (strcmp (result, "-inf 33") == 0
1343 || strcmp (result, "-infinity 33") == 0);
1344 ASSERT (retval == strlen (result));
1351 my_asprintf (&result, "%Lf %d", NaNl (), 33, 44, 55);
1352 ASSERT (result != NULL);
1353 ASSERT (strlen (result) >= 3 + 3
1354 && strisnan (result, 0, strlen (result) - 3, 0)
1355 && strcmp (result + strlen (result) - 3, " 33") == 0);
1356 ASSERT (retval == strlen (result));
1359 #if CHECK_PRINTF_SAFE && ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_)) && !HAVE_SAME_LONG_DOUBLE_AS_DOUBLE
1361 static union { unsigned int word[4]; long double value; } x =
1362 { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
1365 my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
1366 ASSERT (result != NULL);
1367 ASSERT (strlen (result) >= 3 + 3
1368 && strisnan (result, 0, strlen (result) - 3, 0)
1369 && strcmp (result + strlen (result) - 3, " 33") == 0);
1370 ASSERT (retval == strlen (result));
1374 /* Signalling NaN. */
1375 static union { unsigned int word[4]; long double value; } x =
1376 { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
1379 my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
1380 ASSERT (result != NULL);
1381 ASSERT (strlen (result) >= 3 + 3
1382 && strisnan (result, 0, strlen (result) - 3, 0)
1383 && strcmp (result + strlen (result) - 3, " 33") == 0);
1384 ASSERT (retval == strlen (result));
1387 /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
1388 Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
1389 Intel IA-64 Architecture Software Developer's Manual, Volume 1:
1390 Application Architecture.
1391 Table 5-2 "Floating-Point Register Encodings"
1392 Figure 5-6 "Memory to Floating-Point Register Data Translation"
1395 static union { unsigned int word[4]; long double value; } x =
1396 { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
1399 my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
1400 ASSERT (result != NULL);
1401 ASSERT (strlen (result) >= 3 + 3
1402 && strisnan (result, 0, strlen (result) - 3, 0)
1403 && strcmp (result + strlen (result) - 3, " 33") == 0);
1404 ASSERT (retval == strlen (result));
1407 { /* Pseudo-Infinity. */
1408 static union { unsigned int word[4]; long double value; } x =
1409 { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
1412 my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
1413 ASSERT (result != NULL);
1414 ASSERT (strlen (result) >= 3 + 3
1415 && strisnan (result, 0, strlen (result) - 3, 0)
1416 && strcmp (result + strlen (result) - 3, " 33") == 0);
1417 ASSERT (retval == strlen (result));
1420 { /* Pseudo-Zero. */
1421 static union { unsigned int word[4]; long double value; } x =
1422 { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
1425 my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
1426 ASSERT (result != NULL);
1427 ASSERT (strlen (result) >= 3 + 3
1428 && strisnan (result, 0, strlen (result) - 3, 0)
1429 && strcmp (result + strlen (result) - 3, " 33") == 0);
1430 ASSERT (retval == strlen (result));
1433 { /* Unnormalized number. */
1434 static union { unsigned int word[4]; long double value; } x =
1435 { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
1438 my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
1439 ASSERT (result != NULL);
1440 ASSERT (strlen (result) >= 3 + 3
1441 && strisnan (result, 0, strlen (result) - 3, 0)
1442 && strcmp (result + strlen (result) - 3, " 33") == 0);
1443 ASSERT (retval == strlen (result));
1446 { /* Pseudo-Denormal. */
1447 static union { unsigned int word[4]; long double value; } x =
1448 { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
1451 my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
1452 ASSERT (result != NULL);
1453 ASSERT (strlen (result) >= 3 + 3
1454 && strisnan (result, 0, strlen (result) - 3, 0)
1455 && strcmp (result + strlen (result) - 3, " 33") == 0);
1456 ASSERT (retval == strlen (result));
1464 my_asprintf (&result, "%10Lf %d", 1.75L, 33, 44, 55);
1465 ASSERT (result != NULL);
1466 ASSERT (strcmp (result, " 1.750000 33") == 0);
1467 ASSERT (retval == strlen (result));
1474 my_asprintf (&result, "%-10Lf %d", 1.75L, 33, 44, 55);
1475 ASSERT (result != NULL);
1476 ASSERT (strcmp (result, "1.750000 33") == 0);
1477 ASSERT (retval == strlen (result));
1481 { /* FLAG_SHOWSIGN. */
1484 my_asprintf (&result, "%+Lf %d", 1.75L, 33, 44, 55);
1485 ASSERT (result != NULL);
1486 ASSERT (strcmp (result, "+1.750000 33") == 0);
1487 ASSERT (retval == strlen (result));
1494 my_asprintf (&result, "% Lf %d", 1.75L, 33, 44, 55);
1495 ASSERT (result != NULL);
1496 ASSERT (strcmp (result, " 1.750000 33") == 0);
1497 ASSERT (retval == strlen (result));
1504 my_asprintf (&result, "%#Lf %d", 1.75L, 33, 44, 55);
1505 ASSERT (result != NULL);
1506 ASSERT (strcmp (result, "1.750000 33") == 0);
1507 ASSERT (retval == strlen (result));
1514 my_asprintf (&result, "%#.Lf %d", 1.75L, 33, 44, 55);
1515 ASSERT (result != NULL);
1516 ASSERT (strcmp (result, "2. 33") == 0);
1517 ASSERT (retval == strlen (result));
1521 { /* FLAG_ZERO with finite number. */
1524 my_asprintf (&result, "%015Lf %d", 1234.0L, 33, 44, 55);
1525 ASSERT (result != NULL);
1526 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1527 ASSERT (retval == strlen (result));
1531 { /* FLAG_ZERO with infinite number. */
1534 my_asprintf (&result, "%015Lf %d", - Infinityl (), 33, 44, 55);
1535 ASSERT (result != NULL);
1536 ASSERT (strcmp (result, " -inf 33") == 0
1537 || strcmp (result, " -infinity 33") == 0);
1538 ASSERT (retval == strlen (result));
1542 { /* FLAG_ZERO with NaN. */
1545 my_asprintf (&result, "%050Lf %d", NaNl (), 33, 44, 55);
1546 ASSERT (result != NULL);
1547 ASSERT (strlen (result) == 50 + 3
1548 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1549 && strcmp (result + strlen (result) - 3, " 33") == 0);
1550 ASSERT (retval == strlen (result));
1557 my_asprintf (&result, "%.Lf %d", 1234.0L, 33, 44, 55);
1558 ASSERT (result != NULL);
1559 ASSERT (strcmp (result, "1234 33") == 0);
1560 ASSERT (retval == strlen (result));
1564 { /* Precision with no rounding. */
1567 my_asprintf (&result, "%.2Lf %d", 999.951L, 33, 44, 55);
1568 ASSERT (result != NULL);
1569 ASSERT (strcmp (result, "999.95 33") == 0);
1570 ASSERT (retval == strlen (result));
1574 { /* Precision with rounding. */
1577 my_asprintf (&result, "%.2Lf %d", 999.996L, 33, 44, 55);
1578 ASSERT (result != NULL);
1579 ASSERT (strcmp (result, "1000.00 33") == 0);
1580 ASSERT (retval == strlen (result));
1584 /* Test the support of the %F format directive. */
1586 { /* A positive number. */
1589 my_asprintf (&result, "%F %d", 12.75, 33, 44, 55);
1590 ASSERT (result != NULL);
1591 ASSERT (strcmp (result, "12.750000 33") == 0);
1592 ASSERT (retval == strlen (result));
1596 { /* A larger positive number. */
1599 my_asprintf (&result, "%F %d", 1234567.0, 33, 44, 55);
1600 ASSERT (result != NULL);
1601 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1602 ASSERT (retval == strlen (result));
1606 { /* A negative number. */
1609 my_asprintf (&result, "%F %d", -0.03125, 33, 44, 55);
1610 ASSERT (result != NULL);
1611 ASSERT (strcmp (result, "-0.031250 33") == 0);
1612 ASSERT (retval == strlen (result));
1616 { /* Positive zero. */
1619 my_asprintf (&result, "%F %d", 0.0, 33, 44, 55);
1620 ASSERT (result != NULL);
1621 ASSERT (strcmp (result, "0.000000 33") == 0);
1622 ASSERT (retval == strlen (result));
1626 { /* Negative zero. */
1629 my_asprintf (&result, "%F %d", minus_zerod, 33, 44, 55);
1630 ASSERT (result != NULL);
1631 if (have_minus_zero ())
1632 ASSERT (strcmp (result, "-0.000000 33") == 0);
1633 ASSERT (retval == strlen (result));
1637 { /* Positive infinity. */
1640 my_asprintf (&result, "%F %d", Infinityd (), 33, 44, 55);
1641 ASSERT (result != NULL);
1642 ASSERT (strcmp (result, "INF 33") == 0
1643 || strcmp (result, "INFINITY 33") == 0);
1644 ASSERT (retval == strlen (result));
1648 { /* Negative infinity. */
1651 my_asprintf (&result, "%F %d", - Infinityd (), 33, 44, 55);
1652 ASSERT (result != NULL);
1653 ASSERT (strcmp (result, "-INF 33") == 0
1654 || strcmp (result, "-INFINITY 33") == 0);
1655 ASSERT (retval == strlen (result));
1662 my_asprintf (&result, "%F %d", NaNd (), 33, 44, 55);
1663 ASSERT (result != NULL);
1664 ASSERT (strlen (result) >= 3 + 3
1665 && strisnan (result, 0, strlen (result) - 3, 1)
1666 && strcmp (result + strlen (result) - 3, " 33") == 0);
1667 ASSERT (retval == strlen (result));
1674 my_asprintf (&result, "%015F %d", 1234.0, 33, 44, 55);
1675 ASSERT (result != NULL);
1676 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1677 ASSERT (retval == strlen (result));
1681 { /* FLAG_ZERO with infinite number. */
1684 my_asprintf (&result, "%015F %d", - Infinityd (), 33, 44, 55);
1685 ASSERT (result != NULL);
1686 ASSERT (strcmp (result, " -INF 33") == 0
1687 || strcmp (result, " -INFINITY 33") == 0);
1688 ASSERT (retval == strlen (result));
1695 my_asprintf (&result, "%.F %d", 1234.0, 33, 44, 55);
1696 ASSERT (result != NULL);
1697 ASSERT (strcmp (result, "1234 33") == 0);
1698 ASSERT (retval == strlen (result));
1702 { /* Precision with no rounding. */
1705 my_asprintf (&result, "%.2F %d", 999.951, 33, 44, 55);
1706 ASSERT (result != NULL);
1707 ASSERT (strcmp (result, "999.95 33") == 0);
1708 ASSERT (retval == strlen (result));
1712 { /* Precision with rounding. */
1715 my_asprintf (&result, "%.2F %d", 999.996, 33, 44, 55);
1716 ASSERT (result != NULL);
1717 ASSERT (strcmp (result, "1000.00 33") == 0);
1718 ASSERT (retval == strlen (result));
1722 { /* A positive number. */
1725 my_asprintf (&result, "%LF %d", 12.75L, 33, 44, 55);
1726 ASSERT (result != NULL);
1727 ASSERT (strcmp (result, "12.750000 33") == 0);
1728 ASSERT (retval == strlen (result));
1732 { /* A larger positive number. */
1735 my_asprintf (&result, "%LF %d", 1234567.0L, 33, 44, 55);
1736 ASSERT (result != NULL);
1737 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1738 ASSERT (retval == strlen (result));
1742 { /* A negative number. */
1745 my_asprintf (&result, "%LF %d", -0.03125L, 33, 44, 55);
1746 ASSERT (result != NULL);
1747 ASSERT (strcmp (result, "-0.031250 33") == 0);
1748 ASSERT (retval == strlen (result));
1752 { /* Positive zero. */
1755 my_asprintf (&result, "%LF %d", 0.0L, 33, 44, 55);
1756 ASSERT (result != NULL);
1757 ASSERT (strcmp (result, "0.000000 33") == 0);
1758 ASSERT (retval == strlen (result));
1762 { /* Negative zero. */
1765 my_asprintf (&result, "%LF %d", minus_zerol, 33, 44, 55);
1766 ASSERT (result != NULL);
1767 if (have_minus_zero ())
1768 ASSERT (strcmp (result, "-0.000000 33") == 0);
1769 ASSERT (retval == strlen (result));
1773 { /* Positive infinity. */
1776 my_asprintf (&result, "%LF %d", Infinityl (), 33, 44, 55);
1777 ASSERT (result != NULL);
1778 ASSERT (strcmp (result, "INF 33") == 0
1779 || strcmp (result, "INFINITY 33") == 0);
1780 ASSERT (retval == strlen (result));
1784 { /* Negative infinity. */
1787 my_asprintf (&result, "%LF %d", - Infinityl (), 33, 44, 55);
1788 ASSERT (result != NULL);
1789 ASSERT (strcmp (result, "-INF 33") == 0
1790 || strcmp (result, "-INFINITY 33") == 0);
1791 ASSERT (retval == strlen (result));
1798 my_asprintf (&result, "%LF %d", NaNl (), 33, 44, 55);
1799 ASSERT (result != NULL);
1800 ASSERT (strlen (result) >= 3 + 3
1801 && strisnan (result, 0, strlen (result) - 3, 1)
1802 && strcmp (result + strlen (result) - 3, " 33") == 0);
1803 ASSERT (retval == strlen (result));
1810 my_asprintf (&result, "%015LF %d", 1234.0L, 33, 44, 55);
1811 ASSERT (result != NULL);
1812 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1813 ASSERT (retval == strlen (result));
1817 { /* FLAG_ZERO with infinite number. */
1820 my_asprintf (&result, "%015LF %d", - Infinityl (), 33, 44, 55);
1821 ASSERT (result != NULL);
1822 ASSERT (strcmp (result, " -INF 33") == 0
1823 || strcmp (result, " -INFINITY 33") == 0);
1824 ASSERT (retval == strlen (result));
1831 my_asprintf (&result, "%.LF %d", 1234.0L, 33, 44, 55);
1832 ASSERT (result != NULL);
1833 ASSERT (strcmp (result, "1234 33") == 0);
1834 ASSERT (retval == strlen (result));
1838 { /* Precision with no rounding. */
1841 my_asprintf (&result, "%.2LF %d", 999.951L, 33, 44, 55);
1842 ASSERT (result != NULL);
1843 ASSERT (strcmp (result, "999.95 33") == 0);
1844 ASSERT (retval == strlen (result));
1848 { /* Precision with rounding. */
1851 my_asprintf (&result, "%.2LF %d", 999.996L, 33, 44, 55);
1852 ASSERT (result != NULL);
1853 ASSERT (strcmp (result, "1000.00 33") == 0);
1854 ASSERT (retval == strlen (result));
1858 /* Test the support of the %e format directive. */
1860 { /* A positive number. */
1863 my_asprintf (&result, "%e %d", 12.75, 33, 44, 55);
1864 ASSERT (result != NULL);
1865 ASSERT (strcmp (result, "1.275000e+01 33") == 0
1866 || strcmp (result, "1.275000e+001 33") == 0);
1867 ASSERT (retval == strlen (result));
1871 { /* A larger positive number. */
1874 my_asprintf (&result, "%e %d", 1234567.0, 33, 44, 55);
1875 ASSERT (result != NULL);
1876 ASSERT (strcmp (result, "1.234567e+06 33") == 0
1877 || strcmp (result, "1.234567e+006 33") == 0);
1878 ASSERT (retval == strlen (result));
1882 { /* Small and large positive numbers. */
1883 static struct { double value; const char *string; } data[] =
1885 { 1.234321234321234e-37, "1.234321e-37" },
1886 { 1.234321234321234e-36, "1.234321e-36" },
1887 { 1.234321234321234e-35, "1.234321e-35" },
1888 { 1.234321234321234e-34, "1.234321e-34" },
1889 { 1.234321234321234e-33, "1.234321e-33" },
1890 { 1.234321234321234e-32, "1.234321e-32" },
1891 { 1.234321234321234e-31, "1.234321e-31" },
1892 { 1.234321234321234e-30, "1.234321e-30" },
1893 { 1.234321234321234e-29, "1.234321e-29" },
1894 { 1.234321234321234e-28, "1.234321e-28" },
1895 { 1.234321234321234e-27, "1.234321e-27" },
1896 { 1.234321234321234e-26, "1.234321e-26" },
1897 { 1.234321234321234e-25, "1.234321e-25" },
1898 { 1.234321234321234e-24, "1.234321e-24" },
1899 { 1.234321234321234e-23, "1.234321e-23" },
1900 { 1.234321234321234e-22, "1.234321e-22" },
1901 { 1.234321234321234e-21, "1.234321e-21" },
1902 { 1.234321234321234e-20, "1.234321e-20" },
1903 { 1.234321234321234e-19, "1.234321e-19" },
1904 { 1.234321234321234e-18, "1.234321e-18" },
1905 { 1.234321234321234e-17, "1.234321e-17" },
1906 { 1.234321234321234e-16, "1.234321e-16" },
1907 { 1.234321234321234e-15, "1.234321e-15" },
1908 { 1.234321234321234e-14, "1.234321e-14" },
1909 { 1.234321234321234e-13, "1.234321e-13" },
1910 { 1.234321234321234e-12, "1.234321e-12" },
1911 { 1.234321234321234e-11, "1.234321e-11" },
1912 { 1.234321234321234e-10, "1.234321e-10" },
1913 { 1.234321234321234e-9, "1.234321e-09" },
1914 { 1.234321234321234e-8, "1.234321e-08" },
1915 { 1.234321234321234e-7, "1.234321e-07" },
1916 { 1.234321234321234e-6, "1.234321e-06" },
1917 { 1.234321234321234e-5, "1.234321e-05" },
1918 { 1.234321234321234e-4, "1.234321e-04" },
1919 { 1.234321234321234e-3, "1.234321e-03" },
1920 { 1.234321234321234e-2, "1.234321e-02" },
1921 { 1.234321234321234e-1, "1.234321e-01" },
1922 { 1.234321234321234, "1.234321e+00" },
1923 { 1.234321234321234e1, "1.234321e+01" },
1924 { 1.234321234321234e2, "1.234321e+02" },
1925 { 1.234321234321234e3, "1.234321e+03" },
1926 { 1.234321234321234e4, "1.234321e+04" },
1927 { 1.234321234321234e5, "1.234321e+05" },
1928 { 1.234321234321234e6, "1.234321e+06" },
1929 { 1.234321234321234e7, "1.234321e+07" },
1930 { 1.234321234321234e8, "1.234321e+08" },
1931 { 1.234321234321234e9, "1.234321e+09" },
1932 { 1.234321234321234e10, "1.234321e+10" },
1933 { 1.234321234321234e11, "1.234321e+11" },
1934 { 1.234321234321234e12, "1.234321e+12" },
1935 { 1.234321234321234e13, "1.234321e+13" },
1936 { 1.234321234321234e14, "1.234321e+14" },
1937 { 1.234321234321234e15, "1.234321e+15" },
1938 { 1.234321234321234e16, "1.234321e+16" },
1939 { 1.234321234321234e17, "1.234321e+17" },
1940 { 1.234321234321234e18, "1.234321e+18" },
1941 { 1.234321234321234e19, "1.234321e+19" },
1942 { 1.234321234321234e20, "1.234321e+20" },
1943 { 1.234321234321234e21, "1.234321e+21" },
1944 { 1.234321234321234e22, "1.234321e+22" },
1945 { 1.234321234321234e23, "1.234321e+23" },
1946 { 1.234321234321234e24, "1.234321e+24" },
1947 { 1.234321234321234e25, "1.234321e+25" },
1948 { 1.234321234321234e26, "1.234321e+26" },
1949 { 1.234321234321234e27, "1.234321e+27" },
1950 { 1.234321234321234e28, "1.234321e+28" },
1951 { 1.234321234321234e29, "1.234321e+29" },
1952 { 1.234321234321234e30, "1.234321e+30" },
1953 { 1.234321234321234e31, "1.234321e+31" },
1954 { 1.234321234321234e32, "1.234321e+32" },
1955 { 1.234321234321234e33, "1.234321e+33" },
1956 { 1.234321234321234e34, "1.234321e+34" },
1957 { 1.234321234321234e35, "1.234321e+35" },
1958 { 1.234321234321234e36, "1.234321e+36" }
1961 for (k = 0; k < SIZEOF (data); k++)
1965 my_asprintf (&result, "%e", data[k].value);
1966 const char *expected = data[k].string;
1967 ASSERT (result != NULL);
1968 ASSERT (strcmp (result, expected) == 0
1969 /* Some implementations produce exponents with 3 digits. */
1970 || (strlen (result) == strlen (expected) + 1
1971 && memcmp (result, expected, strlen (expected) - 2) == 0
1972 && result[strlen (expected) - 2] == '0'
1973 && strcmp (result + strlen (expected) - 1,
1974 expected + strlen (expected) - 2)
1976 ASSERT (retval == strlen (result));
1981 { /* A negative number. */
1984 my_asprintf (&result, "%e %d", -0.03125, 33, 44, 55);
1985 ASSERT (result != NULL);
1986 ASSERT (strcmp (result, "-3.125000e-02 33") == 0
1987 || strcmp (result, "-3.125000e-002 33") == 0);
1988 ASSERT (retval == strlen (result));
1992 { /* Positive zero. */
1995 my_asprintf (&result, "%e %d", 0.0, 33, 44, 55);
1996 ASSERT (result != NULL);
1997 ASSERT (strcmp (result, "0.000000e+00 33") == 0
1998 || strcmp (result, "0.000000e+000 33") == 0);
1999 ASSERT (retval == strlen (result));
2003 { /* Negative zero. */
2006 my_asprintf (&result, "%e %d", minus_zerod, 33, 44, 55);
2007 ASSERT (result != NULL);
2008 if (have_minus_zero ())
2009 ASSERT (strcmp (result, "-0.000000e+00 33") == 0
2010 || strcmp (result, "-0.000000e+000 33") == 0);
2011 ASSERT (retval == strlen (result));
2015 { /* Positive infinity. */
2018 my_asprintf (&result, "%e %d", Infinityd (), 33, 44, 55);
2019 ASSERT (result != NULL);
2020 ASSERT (strcmp (result, "inf 33") == 0
2021 || strcmp (result, "infinity 33") == 0);
2022 ASSERT (retval == strlen (result));
2026 { /* Negative infinity. */
2029 my_asprintf (&result, "%e %d", - Infinityd (), 33, 44, 55);
2030 ASSERT (result != NULL);
2031 ASSERT (strcmp (result, "-inf 33") == 0
2032 || strcmp (result, "-infinity 33") == 0);
2033 ASSERT (retval == strlen (result));
2040 my_asprintf (&result, "%e %d", NaNd (), 33, 44, 55);
2041 ASSERT (result != NULL);
2042 ASSERT (strlen (result) >= 3 + 3
2043 && strisnan (result, 0, strlen (result) - 3, 0)
2044 && strcmp (result + strlen (result) - 3, " 33") == 0);
2045 ASSERT (retval == strlen (result));
2052 my_asprintf (&result, "%15e %d", 1.75, 33, 44, 55);
2053 ASSERT (result != NULL);
2054 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
2055 || strcmp (result, " 1.750000e+000 33") == 0);
2056 ASSERT (retval == strlen (result));
2063 my_asprintf (&result, "%-15e %d", 1.75, 33, 44, 55);
2064 ASSERT (result != NULL);
2065 ASSERT (strcmp (result, "1.750000e+00 33") == 0
2066 || strcmp (result, "1.750000e+000 33") == 0);
2067 ASSERT (retval == strlen (result));
2071 { /* FLAG_SHOWSIGN. */
2074 my_asprintf (&result, "%+e %d", 1.75, 33, 44, 55);
2075 ASSERT (result != NULL);
2076 ASSERT (strcmp (result, "+1.750000e+00 33") == 0
2077 || strcmp (result, "+1.750000e+000 33") == 0);
2078 ASSERT (retval == strlen (result));
2085 my_asprintf (&result, "% e %d", 1.75, 33, 44, 55);
2086 ASSERT (result != NULL);
2087 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
2088 || strcmp (result, " 1.750000e+000 33") == 0);
2089 ASSERT (retval == strlen (result));
2096 my_asprintf (&result, "%#e %d", 1.75, 33, 44, 55);
2097 ASSERT (result != NULL);
2098 ASSERT (strcmp (result, "1.750000e+00 33") == 0
2099 || strcmp (result, "1.750000e+000 33") == 0);
2100 ASSERT (retval == strlen (result));
2107 my_asprintf (&result, "%#.e %d", 1.75, 33, 44, 55);
2108 ASSERT (result != NULL);
2109 ASSERT (strcmp (result, "2.e+00 33") == 0
2110 || strcmp (result, "2.e+000 33") == 0);
2111 ASSERT (retval == strlen (result));
2118 my_asprintf (&result, "%#.e %d", 9.75, 33, 44, 55);
2119 ASSERT (result != NULL);
2120 ASSERT (strcmp (result, "1.e+01 33") == 0
2121 || strcmp (result, "1.e+001 33") == 0);
2122 ASSERT (retval == strlen (result));
2126 { /* FLAG_ZERO with finite number. */
2129 my_asprintf (&result, "%015e %d", 1234.0, 33, 44, 55);
2130 ASSERT (result != NULL);
2131 ASSERT (strcmp (result, "0001.234000e+03 33") == 0
2132 || strcmp (result, "001.234000e+003 33") == 0);
2133 ASSERT (retval == strlen (result));
2137 { /* FLAG_ZERO with infinite number. */
2140 my_asprintf (&result, "%015e %d", - Infinityd (), 33, 44, 55);
2141 ASSERT (result != NULL);
2142 ASSERT (strcmp (result, " -inf 33") == 0
2143 || strcmp (result, " -infinity 33") == 0);
2144 ASSERT (retval == strlen (result));
2148 { /* FLAG_ZERO with NaN. */
2151 my_asprintf (&result, "%050e %d", NaNd (), 33, 44, 55);
2152 ASSERT (result != NULL);
2153 ASSERT (strlen (result) == 50 + 3
2154 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2155 && strcmp (result + strlen (result) - 3, " 33") == 0);
2156 ASSERT (retval == strlen (result));
2163 my_asprintf (&result, "%.e %d", 1234.0, 33, 44, 55);
2164 ASSERT (result != NULL);
2165 ASSERT (strcmp (result, "1e+03 33") == 0
2166 || strcmp (result, "1e+003 33") == 0);
2167 ASSERT (retval == strlen (result));
2171 { /* Precision with no rounding. */
2174 my_asprintf (&result, "%.4e %d", 999.951, 33, 44, 55);
2175 ASSERT (result != NULL);
2176 ASSERT (strcmp (result, "9.9995e+02 33") == 0
2177 || strcmp (result, "9.9995e+002 33") == 0);
2178 ASSERT (retval == strlen (result));
2182 { /* Precision with rounding. */
2185 my_asprintf (&result, "%.4e %d", 999.996, 33, 44, 55);
2186 ASSERT (result != NULL);
2187 ASSERT (strcmp (result, "1.0000e+03 33") == 0
2188 || strcmp (result, "1.0000e+003 33") == 0);
2189 ASSERT (retval == strlen (result));
2193 { /* A positive number. */
2196 my_asprintf (&result, "%Le %d", 12.75L, 33, 44, 55);
2197 ASSERT (result != NULL);
2198 ASSERT (strcmp (result, "1.275000e+01 33") == 0
2199 || strcmp (result, "1.275000e+001 33") == 0);
2200 ASSERT (retval == strlen (result));
2204 { /* A larger positive number. */
2207 my_asprintf (&result, "%Le %d", 1234567.0L, 33, 44, 55);
2208 ASSERT (result != NULL);
2209 ASSERT (strcmp (result, "1.234567e+06 33") == 0
2210 || strcmp (result, "1.234567e+006 33") == 0);
2211 ASSERT (retval == strlen (result));
2215 { /* Small and large positive numbers. */
2216 static struct { long double value; const char *string; } data[] =
2218 { 1.234321234321234e-37L, "1.234321e-37" },
2219 { 1.234321234321234e-36L, "1.234321e-36" },
2220 { 1.234321234321234e-35L, "1.234321e-35" },
2221 { 1.234321234321234e-34L, "1.234321e-34" },
2222 { 1.234321234321234e-33L, "1.234321e-33" },
2223 { 1.234321234321234e-32L, "1.234321e-32" },
2224 { 1.234321234321234e-31L, "1.234321e-31" },
2225 { 1.234321234321234e-30L, "1.234321e-30" },
2226 { 1.234321234321234e-29L, "1.234321e-29" },
2227 { 1.234321234321234e-28L, "1.234321e-28" },
2228 { 1.234321234321234e-27L, "1.234321e-27" },
2229 { 1.234321234321234e-26L, "1.234321e-26" },
2230 { 1.234321234321234e-25L, "1.234321e-25" },
2231 { 1.234321234321234e-24L, "1.234321e-24" },
2232 { 1.234321234321234e-23L, "1.234321e-23" },
2233 { 1.234321234321234e-22L, "1.234321e-22" },
2234 { 1.234321234321234e-21L, "1.234321e-21" },
2235 { 1.234321234321234e-20L, "1.234321e-20" },
2236 { 1.234321234321234e-19L, "1.234321e-19" },
2237 { 1.234321234321234e-18L, "1.234321e-18" },
2238 { 1.234321234321234e-17L, "1.234321e-17" },
2239 { 1.234321234321234e-16L, "1.234321e-16" },
2240 { 1.234321234321234e-15L, "1.234321e-15" },
2241 { 1.234321234321234e-14L, "1.234321e-14" },
2242 { 1.234321234321234e-13L, "1.234321e-13" },
2243 { 1.234321234321234e-12L, "1.234321e-12" },
2244 { 1.234321234321234e-11L, "1.234321e-11" },
2245 { 1.234321234321234e-10L, "1.234321e-10" },
2246 { 1.234321234321234e-9L, "1.234321e-09" },
2247 { 1.234321234321234e-8L, "1.234321e-08" },
2248 { 1.234321234321234e-7L, "1.234321e-07" },
2249 { 1.234321234321234e-6L, "1.234321e-06" },
2250 { 1.234321234321234e-5L, "1.234321e-05" },
2251 { 1.234321234321234e-4L, "1.234321e-04" },
2252 { 1.234321234321234e-3L, "1.234321e-03" },
2253 { 1.234321234321234e-2L, "1.234321e-02" },
2254 { 1.234321234321234e-1L, "1.234321e-01" },
2255 { 1.234321234321234L, "1.234321e+00" },
2256 { 1.234321234321234e1L, "1.234321e+01" },
2257 { 1.234321234321234e2L, "1.234321e+02" },
2258 { 1.234321234321234e3L, "1.234321e+03" },
2259 { 1.234321234321234e4L, "1.234321e+04" },
2260 { 1.234321234321234e5L, "1.234321e+05" },
2261 { 1.234321234321234e6L, "1.234321e+06" },
2262 { 1.234321234321234e7L, "1.234321e+07" },
2263 { 1.234321234321234e8L, "1.234321e+08" },
2264 { 1.234321234321234e9L, "1.234321e+09" },
2265 { 1.234321234321234e10L, "1.234321e+10" },
2266 { 1.234321234321234e11L, "1.234321e+11" },
2267 { 1.234321234321234e12L, "1.234321e+12" },
2268 { 1.234321234321234e13L, "1.234321e+13" },
2269 { 1.234321234321234e14L, "1.234321e+14" },
2270 { 1.234321234321234e15L, "1.234321e+15" },
2271 { 1.234321234321234e16L, "1.234321e+16" },
2272 { 1.234321234321234e17L, "1.234321e+17" },
2273 { 1.234321234321234e18L, "1.234321e+18" },
2274 { 1.234321234321234e19L, "1.234321e+19" },
2275 { 1.234321234321234e20L, "1.234321e+20" },
2276 { 1.234321234321234e21L, "1.234321e+21" },
2277 { 1.234321234321234e22L, "1.234321e+22" },
2278 { 1.234321234321234e23L, "1.234321e+23" },
2279 { 1.234321234321234e24L, "1.234321e+24" },
2280 { 1.234321234321234e25L, "1.234321e+25" },
2281 { 1.234321234321234e26L, "1.234321e+26" },
2282 { 1.234321234321234e27L, "1.234321e+27" },
2283 { 1.234321234321234e28L, "1.234321e+28" },
2284 { 1.234321234321234e29L, "1.234321e+29" },
2285 { 1.234321234321234e30L, "1.234321e+30" },
2286 { 1.234321234321234e31L, "1.234321e+31" },
2287 { 1.234321234321234e32L, "1.234321e+32" },
2288 { 1.234321234321234e33L, "1.234321e+33" },
2289 { 1.234321234321234e34L, "1.234321e+34" },
2290 { 1.234321234321234e35L, "1.234321e+35" },
2291 { 1.234321234321234e36L, "1.234321e+36" }
2294 for (k = 0; k < SIZEOF (data); k++)
2298 my_asprintf (&result, "%Le", data[k].value);
2299 const char *expected = data[k].string;
2300 ASSERT (result != NULL);
2301 ASSERT (strcmp (result, expected) == 0
2302 /* Some implementations produce exponents with 3 digits. */
2303 || (strlen (result) == strlen (expected) + 1
2304 && memcmp (result, expected, strlen (expected) - 2) == 0
2305 && result[strlen (expected) - 2] == '0'
2306 && strcmp (result + strlen (expected) - 1,
2307 expected + strlen (expected) - 2)
2309 ASSERT (retval == strlen (result));
2314 { /* A negative number. */
2317 my_asprintf (&result, "%Le %d", -0.03125L, 33, 44, 55);
2318 ASSERT (result != NULL);
2319 ASSERT (strcmp (result, "-3.125000e-02 33") == 0
2320 || strcmp (result, "-3.125000e-002 33") == 0);
2321 ASSERT (retval == strlen (result));
2325 { /* Positive zero. */
2328 my_asprintf (&result, "%Le %d", 0.0L, 33, 44, 55);
2329 ASSERT (result != NULL);
2330 ASSERT (strcmp (result, "0.000000e+00 33") == 0
2331 || strcmp (result, "0.000000e+000 33") == 0);
2332 ASSERT (retval == strlen (result));
2336 { /* Negative zero. */
2339 my_asprintf (&result, "%Le %d", minus_zerol, 33, 44, 55);
2340 ASSERT (result != NULL);
2341 if (have_minus_zero ())
2342 ASSERT (strcmp (result, "-0.000000e+00 33") == 0
2343 || strcmp (result, "-0.000000e+000 33") == 0);
2344 ASSERT (retval == strlen (result));
2348 { /* Positive infinity. */
2351 my_asprintf (&result, "%Le %d", Infinityl (), 33, 44, 55);
2352 ASSERT (result != NULL);
2353 ASSERT (strcmp (result, "inf 33") == 0
2354 || strcmp (result, "infinity 33") == 0);
2355 ASSERT (retval == strlen (result));
2359 { /* Negative infinity. */
2362 my_asprintf (&result, "%Le %d", - Infinityl (), 33, 44, 55);
2363 ASSERT (result != NULL);
2364 ASSERT (strcmp (result, "-inf 33") == 0
2365 || strcmp (result, "-infinity 33") == 0);
2366 ASSERT (retval == strlen (result));
2373 my_asprintf (&result, "%Le %d", NaNl (), 33, 44, 55);
2374 ASSERT (result != NULL);
2375 ASSERT (strlen (result) >= 3 + 3
2376 && strisnan (result, 0, strlen (result) - 3, 0)
2377 && strcmp (result + strlen (result) - 3, " 33") == 0);
2378 ASSERT (retval == strlen (result));
2381 #if CHECK_PRINTF_SAFE && ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_)) && !HAVE_SAME_LONG_DOUBLE_AS_DOUBLE
2383 static union { unsigned int word[4]; long double value; } x =
2384 { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
2387 my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
2388 ASSERT (result != NULL);
2389 ASSERT (strlen (result) >= 3 + 3
2390 && strisnan (result, 0, strlen (result) - 3, 0)
2391 && strcmp (result + strlen (result) - 3, " 33") == 0);
2392 ASSERT (retval == strlen (result));
2396 /* Signalling NaN. */
2397 static union { unsigned int word[4]; long double value; } x =
2398 { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
2401 my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
2402 ASSERT (result != NULL);
2403 ASSERT (strlen (result) >= 3 + 3
2404 && strisnan (result, 0, strlen (result) - 3, 0)
2405 && strcmp (result + strlen (result) - 3, " 33") == 0);
2406 ASSERT (retval == strlen (result));
2409 /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
2410 Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
2411 Intel IA-64 Architecture Software Developer's Manual, Volume 1:
2412 Application Architecture.
2413 Table 5-2 "Floating-Point Register Encodings"
2414 Figure 5-6 "Memory to Floating-Point Register Data Translation"
2417 static union { unsigned int word[4]; long double value; } x =
2418 { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
2421 my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
2422 ASSERT (result != NULL);
2423 ASSERT (strlen (result) >= 3 + 3
2424 && strisnan (result, 0, strlen (result) - 3, 0)
2425 && strcmp (result + strlen (result) - 3, " 33") == 0);
2426 ASSERT (retval == strlen (result));
2429 { /* Pseudo-Infinity. */
2430 static union { unsigned int word[4]; long double value; } x =
2431 { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
2434 my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
2435 ASSERT (result != NULL);
2436 ASSERT (strlen (result) >= 3 + 3
2437 && strisnan (result, 0, strlen (result) - 3, 0)
2438 && strcmp (result + strlen (result) - 3, " 33") == 0);
2439 ASSERT (retval == strlen (result));
2442 { /* Pseudo-Zero. */
2443 static union { unsigned int word[4]; long double value; } x =
2444 { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
2447 my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
2448 ASSERT (result != NULL);
2449 ASSERT (strlen (result) >= 3 + 3
2450 && strisnan (result, 0, strlen (result) - 3, 0)
2451 && strcmp (result + strlen (result) - 3, " 33") == 0);
2452 ASSERT (retval == strlen (result));
2455 { /* Unnormalized number. */
2456 static union { unsigned int word[4]; long double value; } x =
2457 { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
2460 my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
2461 ASSERT (result != NULL);
2462 ASSERT (strlen (result) >= 3 + 3
2463 && strisnan (result, 0, strlen (result) - 3, 0)
2464 && strcmp (result + strlen (result) - 3, " 33") == 0);
2465 ASSERT (retval == strlen (result));
2468 { /* Pseudo-Denormal. */
2469 static union { unsigned int word[4]; long double value; } x =
2470 { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
2473 my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
2474 ASSERT (result != NULL);
2475 ASSERT (strlen (result) >= 3 + 3
2476 && strisnan (result, 0, strlen (result) - 3, 0)
2477 && strcmp (result + strlen (result) - 3, " 33") == 0);
2478 ASSERT (retval == strlen (result));
2486 my_asprintf (&result, "%15Le %d", 1.75L, 33, 44, 55);
2487 ASSERT (result != NULL);
2488 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
2489 || strcmp (result, " 1.750000e+000 33") == 0);
2490 ASSERT (retval == strlen (result));
2497 my_asprintf (&result, "%-15Le %d", 1.75L, 33, 44, 55);
2498 ASSERT (result != NULL);
2499 ASSERT (strcmp (result, "1.750000e+00 33") == 0
2500 || strcmp (result, "1.750000e+000 33") == 0);
2501 ASSERT (retval == strlen (result));
2505 { /* FLAG_SHOWSIGN. */
2508 my_asprintf (&result, "%+Le %d", 1.75L, 33, 44, 55);
2509 ASSERT (result != NULL);
2510 ASSERT (strcmp (result, "+1.750000e+00 33") == 0
2511 || strcmp (result, "+1.750000e+000 33") == 0);
2512 ASSERT (retval == strlen (result));
2519 my_asprintf (&result, "% Le %d", 1.75L, 33, 44, 55);
2520 ASSERT (result != NULL);
2521 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
2522 || strcmp (result, " 1.750000e+000 33") == 0);
2523 ASSERT (retval == strlen (result));
2530 my_asprintf (&result, "%#Le %d", 1.75L, 33, 44, 55);
2531 ASSERT (result != NULL);
2532 ASSERT (strcmp (result, "1.750000e+00 33") == 0
2533 || strcmp (result, "1.750000e+000 33") == 0);
2534 ASSERT (retval == strlen (result));
2541 my_asprintf (&result, "%#.Le %d", 1.75L, 33, 44, 55);
2542 ASSERT (result != NULL);
2543 ASSERT (strcmp (result, "2.e+00 33") == 0
2544 || strcmp (result, "2.e+000 33") == 0);
2545 ASSERT (retval == strlen (result));
2552 my_asprintf (&result, "%#.Le %d", 9.75L, 33, 44, 55);
2553 ASSERT (result != NULL);
2554 ASSERT (strcmp (result, "1.e+01 33") == 0
2555 || strcmp (result, "1.e+001 33") == 0);
2556 ASSERT (retval == strlen (result));
2560 { /* FLAG_ZERO with finite number. */
2563 my_asprintf (&result, "%015Le %d", 1234.0L, 33, 44, 55);
2564 ASSERT (result != NULL);
2565 ASSERT (strcmp (result, "0001.234000e+03 33") == 0
2566 || strcmp (result, "001.234000e+003 33") == 0);
2567 ASSERT (retval == strlen (result));
2571 { /* FLAG_ZERO with infinite number. */
2574 my_asprintf (&result, "%015Le %d", - Infinityl (), 33, 44, 55);
2575 ASSERT (result != NULL);
2576 ASSERT (strcmp (result, " -inf 33") == 0
2577 || strcmp (result, " -infinity 33") == 0);
2578 ASSERT (retval == strlen (result));
2582 { /* FLAG_ZERO with NaN. */
2585 my_asprintf (&result, "%050Le %d", NaNl (), 33, 44, 55);
2586 ASSERT (result != NULL);
2587 ASSERT (strlen (result) == 50 + 3
2588 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2589 && strcmp (result + strlen (result) - 3, " 33") == 0);
2590 ASSERT (retval == strlen (result));
2597 my_asprintf (&result, "%.Le %d", 1234.0L, 33, 44, 55);
2598 ASSERT (result != NULL);
2599 ASSERT (strcmp (result, "1e+03 33") == 0
2600 || strcmp (result, "1e+003 33") == 0);
2601 ASSERT (retval == strlen (result));
2605 { /* Precision with no rounding. */
2608 my_asprintf (&result, "%.4Le %d", 999.951L, 33, 44, 55);
2609 ASSERT (result != NULL);
2610 ASSERT (strcmp (result, "9.9995e+02 33") == 0
2611 || strcmp (result, "9.9995e+002 33") == 0);
2612 ASSERT (retval == strlen (result));
2616 { /* Precision with rounding. */
2619 my_asprintf (&result, "%.4Le %d", 999.996L, 33, 44, 55);
2620 ASSERT (result != NULL);
2621 ASSERT (strcmp (result, "1.0000e+03 33") == 0
2622 || strcmp (result, "1.0000e+003 33") == 0);
2623 ASSERT (retval == strlen (result));
2627 /* Test the support of the %g format directive. */
2629 { /* A positive number. */
2632 my_asprintf (&result, "%g %d", 12.75, 33, 44, 55);
2633 ASSERT (result != NULL);
2634 ASSERT (strcmp (result, "12.75 33") == 0);
2635 ASSERT (retval == strlen (result));
2639 { /* A larger positive number. */
2642 my_asprintf (&result, "%g %d", 1234567.0, 33, 44, 55);
2643 ASSERT (result != NULL);
2644 ASSERT (strcmp (result, "1.23457e+06 33") == 0
2645 || strcmp (result, "1.23457e+006 33") == 0);
2646 ASSERT (retval == strlen (result));
2650 { /* Small and large positive numbers. */
2651 static struct { double value; const char *string; } data[] =
2653 { 1.234321234321234e-37, "1.23432e-37" },
2654 { 1.234321234321234e-36, "1.23432e-36" },
2655 { 1.234321234321234e-35, "1.23432e-35" },
2656 { 1.234321234321234e-34, "1.23432e-34" },
2657 { 1.234321234321234e-33, "1.23432e-33" },
2658 { 1.234321234321234e-32, "1.23432e-32" },
2659 { 1.234321234321234e-31, "1.23432e-31" },
2660 { 1.234321234321234e-30, "1.23432e-30" },
2661 { 1.234321234321234e-29, "1.23432e-29" },
2662 { 1.234321234321234e-28, "1.23432e-28" },
2663 { 1.234321234321234e-27, "1.23432e-27" },
2664 { 1.234321234321234e-26, "1.23432e-26" },
2665 { 1.234321234321234e-25, "1.23432e-25" },
2666 { 1.234321234321234e-24, "1.23432e-24" },
2667 { 1.234321234321234e-23, "1.23432e-23" },
2668 { 1.234321234321234e-22, "1.23432e-22" },
2669 { 1.234321234321234e-21, "1.23432e-21" },
2670 { 1.234321234321234e-20, "1.23432e-20" },
2671 { 1.234321234321234e-19, "1.23432e-19" },
2672 { 1.234321234321234e-18, "1.23432e-18" },
2673 { 1.234321234321234e-17, "1.23432e-17" },
2674 { 1.234321234321234e-16, "1.23432e-16" },
2675 { 1.234321234321234e-15, "1.23432e-15" },
2676 { 1.234321234321234e-14, "1.23432e-14" },
2677 { 1.234321234321234e-13, "1.23432e-13" },
2678 { 1.234321234321234e-12, "1.23432e-12" },
2679 { 1.234321234321234e-11, "1.23432e-11" },
2680 { 1.234321234321234e-10, "1.23432e-10" },
2681 { 1.234321234321234e-9, "1.23432e-09" },
2682 { 1.234321234321234e-8, "1.23432e-08" },
2683 { 1.234321234321234e-7, "1.23432e-07" },
2684 { 1.234321234321234e-6, "1.23432e-06" },
2685 { 1.234321234321234e-5, "1.23432e-05" },
2686 { 1.234321234321234e-4, "0.000123432" },
2687 { 1.234321234321234e-3, "0.00123432" },
2688 { 1.234321234321234e-2, "0.0123432" },
2689 { 1.234321234321234e-1, "0.123432" },
2690 { 1.234321234321234, "1.23432" },
2691 { 1.234321234321234e1, "12.3432" },
2692 { 1.234321234321234e2, "123.432" },
2693 { 1.234321234321234e3, "1234.32" },
2694 { 1.234321234321234e4, "12343.2" },
2695 { 1.234321234321234e5, "123432" },
2696 { 1.234321234321234e6, "1.23432e+06" },
2697 { 1.234321234321234e7, "1.23432e+07" },
2698 { 1.234321234321234e8, "1.23432e+08" },
2699 { 1.234321234321234e9, "1.23432e+09" },
2700 { 1.234321234321234e10, "1.23432e+10" },
2701 { 1.234321234321234e11, "1.23432e+11" },
2702 { 1.234321234321234e12, "1.23432e+12" },
2703 { 1.234321234321234e13, "1.23432e+13" },
2704 { 1.234321234321234e14, "1.23432e+14" },
2705 { 1.234321234321234e15, "1.23432e+15" },
2706 { 1.234321234321234e16, "1.23432e+16" },
2707 { 1.234321234321234e17, "1.23432e+17" },
2708 { 1.234321234321234e18, "1.23432e+18" },
2709 { 1.234321234321234e19, "1.23432e+19" },
2710 { 1.234321234321234e20, "1.23432e+20" },
2711 { 1.234321234321234e21, "1.23432e+21" },
2712 { 1.234321234321234e22, "1.23432e+22" },
2713 { 1.234321234321234e23, "1.23432e+23" },
2714 { 1.234321234321234e24, "1.23432e+24" },
2715 { 1.234321234321234e25, "1.23432e+25" },
2716 { 1.234321234321234e26, "1.23432e+26" },
2717 { 1.234321234321234e27, "1.23432e+27" },
2718 { 1.234321234321234e28, "1.23432e+28" },
2719 { 1.234321234321234e29, "1.23432e+29" },
2720 { 1.234321234321234e30, "1.23432e+30" },
2721 { 1.234321234321234e31, "1.23432e+31" },
2722 { 1.234321234321234e32, "1.23432e+32" },
2723 { 1.234321234321234e33, "1.23432e+33" },
2724 { 1.234321234321234e34, "1.23432e+34" },
2725 { 1.234321234321234e35, "1.23432e+35" },
2726 { 1.234321234321234e36, "1.23432e+36" }
2729 for (k = 0; k < SIZEOF (data); k++)
2733 my_asprintf (&result, "%g", data[k].value);
2734 const char *expected = data[k].string;
2735 ASSERT (result != NULL);
2736 ASSERT (strcmp (result, expected) == 0
2737 /* Some implementations produce exponents with 3 digits. */
2738 || (expected[strlen (expected) - 4] == 'e'
2739 && strlen (result) == strlen (expected) + 1
2740 && memcmp (result, expected, strlen (expected) - 2) == 0
2741 && result[strlen (expected) - 2] == '0'
2742 && strcmp (result + strlen (expected) - 1,
2743 expected + strlen (expected) - 2)
2745 ASSERT (retval == strlen (result));
2750 { /* A negative number. */
2753 my_asprintf (&result, "%g %d", -0.03125, 33, 44, 55);
2754 ASSERT (result != NULL);
2755 ASSERT (strcmp (result, "-0.03125 33") == 0);
2756 ASSERT (retval == strlen (result));
2760 { /* Positive zero. */
2763 my_asprintf (&result, "%g %d", 0.0, 33, 44, 55);
2764 ASSERT (result != NULL);
2765 ASSERT (strcmp (result, "0 33") == 0);
2766 ASSERT (retval == strlen (result));
2770 { /* Negative zero. */
2773 my_asprintf (&result, "%g %d", minus_zerod, 33, 44, 55);
2774 ASSERT (result != NULL);
2775 if (have_minus_zero ())
2776 ASSERT (strcmp (result, "-0 33") == 0);
2777 ASSERT (retval == strlen (result));
2781 { /* Positive infinity. */
2784 my_asprintf (&result, "%g %d", Infinityd (), 33, 44, 55);
2785 ASSERT (result != NULL);
2786 ASSERT (strcmp (result, "inf 33") == 0
2787 || strcmp (result, "infinity 33") == 0);
2788 ASSERT (retval == strlen (result));
2792 { /* Negative infinity. */
2795 my_asprintf (&result, "%g %d", - Infinityd (), 33, 44, 55);
2796 ASSERT (result != NULL);
2797 ASSERT (strcmp (result, "-inf 33") == 0
2798 || strcmp (result, "-infinity 33") == 0);
2799 ASSERT (retval == strlen (result));
2806 my_asprintf (&result, "%g %d", NaNd (), 33, 44, 55);
2807 ASSERT (result != NULL);
2808 ASSERT (strlen (result) >= 3 + 3
2809 && strisnan (result, 0, strlen (result) - 3, 0)
2810 && strcmp (result + strlen (result) - 3, " 33") == 0);
2811 ASSERT (retval == strlen (result));
2818 my_asprintf (&result, "%10g %d", 1.75, 33, 44, 55);
2819 ASSERT (result != NULL);
2820 ASSERT (strcmp (result, " 1.75 33") == 0);
2821 ASSERT (retval == strlen (result));
2828 my_asprintf (&result, "%-10g %d", 1.75, 33, 44, 55);
2829 ASSERT (result != NULL);
2830 ASSERT (strcmp (result, "1.75 33") == 0);
2831 ASSERT (retval == strlen (result));
2835 { /* FLAG_SHOWSIGN. */
2838 my_asprintf (&result, "%+g %d", 1.75, 33, 44, 55);
2839 ASSERT (result != NULL);
2840 ASSERT (strcmp (result, "+1.75 33") == 0);
2841 ASSERT (retval == strlen (result));
2848 my_asprintf (&result, "% g %d", 1.75, 33, 44, 55);
2849 ASSERT (result != NULL);
2850 ASSERT (strcmp (result, " 1.75 33") == 0);
2851 ASSERT (retval == strlen (result));
2858 my_asprintf (&result, "%#g %d", 1.75, 33, 44, 55);
2859 ASSERT (result != NULL);
2860 ASSERT (strcmp (result, "1.75000 33") == 0);
2861 ASSERT (retval == strlen (result));
2868 my_asprintf (&result, "%#.g %d", 1.75, 33, 44, 55);
2869 ASSERT (result != NULL);
2870 ASSERT (strcmp (result, "2. 33") == 0);
2871 ASSERT (retval == strlen (result));
2878 my_asprintf (&result, "%#.g %d", 9.75, 33, 44, 55);
2879 ASSERT (result != NULL);
2880 ASSERT (strcmp (result, "1.e+01 33") == 0
2881 || strcmp (result, "1.e+001 33") == 0);
2882 ASSERT (retval == strlen (result));
2886 { /* FLAG_ZERO with finite number. */
2889 my_asprintf (&result, "%010g %d", 1234.0, 33, 44, 55);
2890 ASSERT (result != NULL);
2891 ASSERT (strcmp (result, "0000001234 33") == 0);
2892 ASSERT (retval == strlen (result));
2896 { /* FLAG_ZERO with infinite number. */
2899 my_asprintf (&result, "%015g %d", - Infinityd (), 33, 44, 55);
2900 ASSERT (result != NULL);
2901 ASSERT (strcmp (result, " -inf 33") == 0
2902 || strcmp (result, " -infinity 33") == 0);
2903 ASSERT (retval == strlen (result));
2907 { /* FLAG_ZERO with NaN. */
2910 my_asprintf (&result, "%050g %d", NaNd (), 33, 44, 55);
2911 ASSERT (result != NULL);
2912 ASSERT (strlen (result) == 50 + 3
2913 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2914 && strcmp (result + strlen (result) - 3, " 33") == 0);
2915 ASSERT (retval == strlen (result));
2922 my_asprintf (&result, "%.g %d", 1234.0, 33, 44, 55);
2923 ASSERT (result != NULL);
2924 ASSERT (strcmp (result, "1e+03 33") == 0
2925 || strcmp (result, "1e+003 33") == 0);
2926 ASSERT (retval == strlen (result));
2930 { /* Precision with no rounding. */
2933 my_asprintf (&result, "%.5g %d", 999.951, 33, 44, 55);
2934 ASSERT (result != NULL);
2935 ASSERT (strcmp (result, "999.95 33") == 0);
2936 ASSERT (retval == strlen (result));
2940 { /* Precision with rounding. */
2943 my_asprintf (&result, "%.5g %d", 999.996, 33, 44, 55);
2944 ASSERT (result != NULL);
2945 ASSERT (strcmp (result, "1000 33") == 0);
2946 ASSERT (retval == strlen (result));
2950 { /* A positive number. */
2953 my_asprintf (&result, "%Lg %d", 12.75L, 33, 44, 55);
2954 ASSERT (result != NULL);
2955 ASSERT (strcmp (result, "12.75 33") == 0);
2956 ASSERT (retval == strlen (result));
2960 { /* A larger positive number. */
2963 my_asprintf (&result, "%Lg %d", 1234567.0L, 33, 44, 55);
2964 ASSERT (result != NULL);
2965 ASSERT (strcmp (result, "1.23457e+06 33") == 0
2966 || strcmp (result, "1.23457e+006 33") == 0);
2967 ASSERT (retval == strlen (result));
2971 { /* Small and large positive numbers. */
2972 static struct { long double value; const char *string; } data[] =
2974 { 1.234321234321234e-37L, "1.23432e-37" },
2975 { 1.234321234321234e-36L, "1.23432e-36" },
2976 { 1.234321234321234e-35L, "1.23432e-35" },
2977 { 1.234321234321234e-34L, "1.23432e-34" },
2978 { 1.234321234321234e-33L, "1.23432e-33" },
2979 { 1.234321234321234e-32L, "1.23432e-32" },
2980 { 1.234321234321234e-31L, "1.23432e-31" },
2981 { 1.234321234321234e-30L, "1.23432e-30" },
2982 { 1.234321234321234e-29L, "1.23432e-29" },
2983 { 1.234321234321234e-28L, "1.23432e-28" },
2984 { 1.234321234321234e-27L, "1.23432e-27" },
2985 { 1.234321234321234e-26L, "1.23432e-26" },
2986 { 1.234321234321234e-25L, "1.23432e-25" },
2987 { 1.234321234321234e-24L, "1.23432e-24" },
2988 { 1.234321234321234e-23L, "1.23432e-23" },
2989 { 1.234321234321234e-22L, "1.23432e-22" },
2990 { 1.234321234321234e-21L, "1.23432e-21" },
2991 { 1.234321234321234e-20L, "1.23432e-20" },
2992 { 1.234321234321234e-19L, "1.23432e-19" },
2993 { 1.234321234321234e-18L, "1.23432e-18" },
2994 { 1.234321234321234e-17L, "1.23432e-17" },
2995 { 1.234321234321234e-16L, "1.23432e-16" },
2996 { 1.234321234321234e-15L, "1.23432e-15" },
2997 { 1.234321234321234e-14L, "1.23432e-14" },
2998 { 1.234321234321234e-13L, "1.23432e-13" },
2999 { 1.234321234321234e-12L, "1.23432e-12" },
3000 { 1.234321234321234e-11L, "1.23432e-11" },
3001 { 1.234321234321234e-10L, "1.23432e-10" },
3002 { 1.234321234321234e-9L, "1.23432e-09" },
3003 { 1.234321234321234e-8L, "1.23432e-08" },
3004 { 1.234321234321234e-7L, "1.23432e-07" },
3005 { 1.234321234321234e-6L, "1.23432e-06" },
3006 { 1.234321234321234e-5L, "1.23432e-05" },
3007 { 1.234321234321234e-4L, "0.000123432" },
3008 { 1.234321234321234e-3L, "0.00123432" },
3009 { 1.234321234321234e-2L, "0.0123432" },
3010 { 1.234321234321234e-1L, "0.123432" },
3011 { 1.234321234321234L, "1.23432" },
3012 { 1.234321234321234e1L, "12.3432" },
3013 { 1.234321234321234e2L, "123.432" },
3014 { 1.234321234321234e3L, "1234.32" },
3015 { 1.234321234321234e4L, "12343.2" },
3016 { 1.234321234321234e5L, "123432" },
3017 { 1.234321234321234e6L, "1.23432e+06" },
3018 { 1.234321234321234e7L, "1.23432e+07" },
3019 { 1.234321234321234e8L, "1.23432e+08" },
3020 { 1.234321234321234e9L, "1.23432e+09" },
3021 { 1.234321234321234e10L, "1.23432e+10" },
3022 { 1.234321234321234e11L, "1.23432e+11" },
3023 { 1.234321234321234e12L, "1.23432e+12" },
3024 { 1.234321234321234e13L, "1.23432e+13" },
3025 { 1.234321234321234e14L, "1.23432e+14" },
3026 { 1.234321234321234e15L, "1.23432e+15" },
3027 { 1.234321234321234e16L, "1.23432e+16" },
3028 { 1.234321234321234e17L, "1.23432e+17" },
3029 { 1.234321234321234e18L, "1.23432e+18" },
3030 { 1.234321234321234e19L, "1.23432e+19" },
3031 { 1.234321234321234e20L, "1.23432e+20" },
3032 { 1.234321234321234e21L, "1.23432e+21" },
3033 { 1.234321234321234e22L, "1.23432e+22" },
3034 { 1.234321234321234e23L, "1.23432e+23" },
3035 { 1.234321234321234e24L, "1.23432e+24" },
3036 { 1.234321234321234e25L, "1.23432e+25" },
3037 { 1.234321234321234e26L, "1.23432e+26" },
3038 { 1.234321234321234e27L, "1.23432e+27" },
3039 { 1.234321234321234e28L, "1.23432e+28" },
3040 { 1.234321234321234e29L, "1.23432e+29" },
3041 { 1.234321234321234e30L, "1.23432e+30" },
3042 { 1.234321234321234e31L, "1.23432e+31" },
3043 { 1.234321234321234e32L, "1.23432e+32" },
3044 { 1.234321234321234e33L, "1.23432e+33" },
3045 { 1.234321234321234e34L, "1.23432e+34" },
3046 { 1.234321234321234e35L, "1.23432e+35" },
3047 { 1.234321234321234e36L, "1.23432e+36" }
3050 for (k = 0; k < SIZEOF (data); k++)
3054 my_asprintf (&result, "%Lg", data[k].value);
3055 const char *expected = data[k].string;
3056 ASSERT (result != NULL);
3057 ASSERT (strcmp (result, expected) == 0
3058 /* Some implementations produce exponents with 3 digits. */
3059 || (expected[strlen (expected) - 4] == 'e'
3060 && strlen (result) == strlen (expected) + 1
3061 && memcmp (result, expected, strlen (expected) - 2) == 0
3062 && result[strlen (expected) - 2] == '0'
3063 && strcmp (result + strlen (expected) - 1,
3064 expected + strlen (expected) - 2)
3066 ASSERT (retval == strlen (result));
3071 { /* A negative number. */
3074 my_asprintf (&result, "%Lg %d", -0.03125L, 33, 44, 55);
3075 ASSERT (result != NULL);
3076 ASSERT (strcmp (result, "-0.03125 33") == 0);
3077 ASSERT (retval == strlen (result));
3081 { /* Positive zero. */
3084 my_asprintf (&result, "%Lg %d", 0.0L, 33, 44, 55);
3085 ASSERT (result != NULL);
3086 ASSERT (strcmp (result, "0 33") == 0);
3087 ASSERT (retval == strlen (result));
3091 { /* Negative zero. */
3094 my_asprintf (&result, "%Lg %d", minus_zerol, 33, 44, 55);
3095 ASSERT (result != NULL);
3096 if (have_minus_zero ())
3097 ASSERT (strcmp (result, "-0 33") == 0);
3098 ASSERT (retval == strlen (result));
3102 { /* Positive infinity. */
3105 my_asprintf (&result, "%Lg %d", Infinityl (), 33, 44, 55);
3106 ASSERT (result != NULL);
3107 ASSERT (strcmp (result, "inf 33") == 0
3108 || strcmp (result, "infinity 33") == 0);
3109 ASSERT (retval == strlen (result));
3113 { /* Negative infinity. */
3116 my_asprintf (&result, "%Lg %d", - Infinityl (), 33, 44, 55);
3117 ASSERT (result != NULL);
3118 ASSERT (strcmp (result, "-inf 33") == 0
3119 || strcmp (result, "-infinity 33") == 0);
3120 ASSERT (retval == strlen (result));
3127 my_asprintf (&result, "%Lg %d", NaNl (), 33, 44, 55);
3128 ASSERT (result != NULL);
3129 ASSERT (strlen (result) >= 3 + 3
3130 && strisnan (result, 0, strlen (result) - 3, 0)
3131 && strcmp (result + strlen (result) - 3, " 33") == 0);
3132 ASSERT (retval == strlen (result));
3135 #if CHECK_PRINTF_SAFE && ((defined __ia64 && LDBL_MANT_DIG == 64) || (defined __x86_64__ || defined __amd64__) || (defined __i386 || defined __i386__ || defined _I386 || defined _M_IX86 || defined _X86_)) && !HAVE_SAME_LONG_DOUBLE_AS_DOUBLE
3137 static union { unsigned int word[4]; long double value; } x =
3138 { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
3141 my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
3142 ASSERT (result != NULL);
3143 ASSERT (strlen (result) >= 3 + 3
3144 && strisnan (result, 0, strlen (result) - 3, 0)
3145 && strcmp (result + strlen (result) - 3, " 33") == 0);
3146 ASSERT (retval == strlen (result));
3150 /* Signalling NaN. */
3151 static union { unsigned int word[4]; long double value; } x =
3152 { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
3155 my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
3156 ASSERT (result != NULL);
3157 ASSERT (strlen (result) >= 3 + 3
3158 && strisnan (result, 0, strlen (result) - 3, 0)
3159 && strcmp (result + strlen (result) - 3, " 33") == 0);
3160 ASSERT (retval == strlen (result));
3163 /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
3164 Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
3165 Intel IA-64 Architecture Software Developer's Manual, Volume 1:
3166 Application Architecture.
3167 Table 5-2 "Floating-Point Register Encodings"
3168 Figure 5-6 "Memory to Floating-Point Register Data Translation"
3171 static union { unsigned int word[4]; long double value; } x =
3172 { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
3175 my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
3176 ASSERT (result != NULL);
3177 ASSERT (strlen (result) >= 3 + 3
3178 && strisnan (result, 0, strlen (result) - 3, 0)
3179 && strcmp (result + strlen (result) - 3, " 33") == 0);
3180 ASSERT (retval == strlen (result));
3183 { /* Pseudo-Infinity. */
3184 static union { unsigned int word[4]; long double value; } x =
3185 { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
3188 my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
3189 ASSERT (result != NULL);
3190 ASSERT (strlen (result) >= 3 + 3
3191 && strisnan (result, 0, strlen (result) - 3, 0)
3192 && strcmp (result + strlen (result) - 3, " 33") == 0);
3193 ASSERT (retval == strlen (result));
3196 { /* Pseudo-Zero. */
3197 static union { unsigned int word[4]; long double value; } x =
3198 { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
3201 my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
3202 ASSERT (result != NULL);
3203 ASSERT (strlen (result) >= 3 + 3
3204 && strisnan (result, 0, strlen (result) - 3, 0)
3205 && strcmp (result + strlen (result) - 3, " 33") == 0);
3206 ASSERT (retval == strlen (result));
3209 { /* Unnormalized number. */
3210 static union { unsigned int word[4]; long double value; } x =
3211 { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
3214 my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
3215 ASSERT (result != NULL);
3216 ASSERT (strlen (result) >= 3 + 3
3217 && strisnan (result, 0, strlen (result) - 3, 0)
3218 && strcmp (result + strlen (result) - 3, " 33") == 0);
3219 ASSERT (retval == strlen (result));
3222 { /* Pseudo-Denormal. */
3223 static union { unsigned int word[4]; long double value; } x =
3224 { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
3227 my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
3228 ASSERT (result != NULL);
3229 ASSERT (strlen (result) >= 3 + 3
3230 && strisnan (result, 0, strlen (result) - 3, 0)
3231 && strcmp (result + strlen (result) - 3, " 33") == 0);
3232 ASSERT (retval == strlen (result));
3240 my_asprintf (&result, "%10Lg %d", 1.75L, 33, 44, 55);
3241 ASSERT (result != NULL);
3242 ASSERT (strcmp (result, " 1.75 33") == 0);
3243 ASSERT (retval == strlen (result));
3250 my_asprintf (&result, "%-10Lg %d", 1.75L, 33, 44, 55);
3251 ASSERT (result != NULL);
3252 ASSERT (strcmp (result, "1.75 33") == 0);
3253 ASSERT (retval == strlen (result));
3257 { /* FLAG_SHOWSIGN. */
3260 my_asprintf (&result, "%+Lg %d", 1.75L, 33, 44, 55);
3261 ASSERT (result != NULL);
3262 ASSERT (strcmp (result, "+1.75 33") == 0);
3263 ASSERT (retval == strlen (result));
3270 my_asprintf (&result, "% Lg %d", 1.75L, 33, 44, 55);
3271 ASSERT (result != NULL);
3272 ASSERT (strcmp (result, " 1.75 33") == 0);
3273 ASSERT (retval == strlen (result));
3280 my_asprintf (&result, "%#Lg %d", 1.75L, 33, 44, 55);
3281 ASSERT (result != NULL);
3282 ASSERT (strcmp (result, "1.75000 33") == 0);
3283 ASSERT (retval == strlen (result));
3290 my_asprintf (&result, "%#.Lg %d", 1.75L, 33, 44, 55);
3291 ASSERT (result != NULL);
3292 ASSERT (strcmp (result, "2. 33") == 0);
3293 ASSERT (retval == strlen (result));
3300 my_asprintf (&result, "%#.Lg %d", 9.75L, 33, 44, 55);
3301 ASSERT (result != NULL);
3302 ASSERT (strcmp (result, "1.e+01 33") == 0
3303 || strcmp (result, "1.e+001 33") == 0);
3304 ASSERT (retval == strlen (result));
3308 { /* FLAG_ZERO with finite number. */
3311 my_asprintf (&result, "%010Lg %d", 1234.0L, 33, 44, 55);
3312 ASSERT (result != NULL);
3313 ASSERT (strcmp (result, "0000001234 33") == 0);
3314 ASSERT (retval == strlen (result));
3318 { /* FLAG_ZERO with infinite number. */
3321 my_asprintf (&result, "%015Lg %d", - Infinityl (), 33, 44, 55);
3322 ASSERT (result != NULL);
3323 ASSERT (strcmp (result, " -inf 33") == 0
3324 || strcmp (result, " -infinity 33") == 0);
3325 ASSERT (retval == strlen (result));
3329 { /* FLAG_ZERO with NaN. */
3332 my_asprintf (&result, "%050Lg %d", NaNl (), 33, 44, 55);
3333 ASSERT (result != NULL);
3334 ASSERT (strlen (result) == 50 + 3
3335 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
3336 && strcmp (result + strlen (result) - 3, " 33") == 0);
3337 ASSERT (retval == strlen (result));
3344 my_asprintf (&result, "%.Lg %d", 1234.0L, 33, 44, 55);
3345 ASSERT (result != NULL);
3346 ASSERT (strcmp (result, "1e+03 33") == 0
3347 || strcmp (result, "1e+003 33") == 0);
3348 ASSERT (retval == strlen (result));
3352 { /* Precision with no rounding. */
3355 my_asprintf (&result, "%.5Lg %d", 999.951L, 33, 44, 55);
3356 ASSERT (result != NULL);
3357 ASSERT (strcmp (result, "999.95 33") == 0);
3358 ASSERT (retval == strlen (result));
3362 { /* Precision with rounding. */
3365 my_asprintf (&result, "%.5Lg %d", 999.996L, 33, 44, 55);
3366 ASSERT (result != NULL);
3367 ASSERT (strcmp (result, "1000 33") == 0);
3368 ASSERT (retval == strlen (result));
3372 /* Test the support of the %n format directive. */
3378 my_asprintf (&result, "%d %n", 123, &count, 33, 44, 55);
3379 ASSERT (result != NULL);
3380 ASSERT (strcmp (result, "123 ") == 0);
3381 ASSERT (retval == strlen (result));
3382 ASSERT (count == 4);
3386 /* Test the support of the POSIX/XSI format strings with positions. */
3391 my_asprintf (&result, "%2$d %1$d", 33, 55);
3392 ASSERT (result != NULL);
3393 ASSERT (strcmp (result, "55 33") == 0);
3394 ASSERT (retval == strlen (result));
3398 /* Test the support of the grouping flag. */
3403 my_asprintf (&result, "%'d %d", 1234567, 99);
3404 ASSERT (result != NULL);
3405 ASSERT (result[strlen (result) - 1] == '9');
3406 ASSERT (retval == strlen (result));
3410 /* Test the support of the left-adjust flag. */
3415 my_asprintf (&result, "a%*sc", -3, "b");
3416 ASSERT (result != NULL);
3417 ASSERT (strcmp (result, "ab c") == 0);
3418 ASSERT (retval == strlen (result));
3425 my_asprintf (&result, "a%-*sc", 3, "b");
3426 ASSERT (result != NULL);
3427 ASSERT (strcmp (result, "ab c") == 0);
3428 ASSERT (retval == strlen (result));
3435 my_asprintf (&result, "a%-*sc", -3, "b");
3436 ASSERT (result != NULL);
3437 ASSERT (strcmp (result, "ab c") == 0);
3438 ASSERT (retval == strlen (result));
3442 /* Test the support of large precision. */
3447 my_asprintf (&result, "%.4000d %d", 1234567, 99);
3449 ASSERT (result != NULL);
3450 for (i = 0; i < 4000 - 7; i++)
3451 ASSERT (result[i] == '0');
3452 ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
3453 ASSERT (retval == strlen (result));
3460 my_asprintf (&result, "%.*d %d", 4000, 1234567, 99);
3462 ASSERT (result != NULL);
3463 for (i = 0; i < 4000 - 7; i++)
3464 ASSERT (result[i] == '0');
3465 ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
3466 ASSERT (retval == strlen (result));
3473 my_asprintf (&result, "%.4000d %d", -1234567, 99);
3475 ASSERT (result != NULL);
3476 ASSERT (result[0] == '-');
3477 for (i = 0; i < 4000 - 7; i++)
3478 ASSERT (result[1 + i] == '0');
3479 ASSERT (strcmp (result + 1 + 4000 - 7, "1234567 99") == 0);
3480 ASSERT (retval == strlen (result));
3487 my_asprintf (&result, "%.4000u %d", 1234567, 99);
3489 ASSERT (result != NULL);
3490 for (i = 0; i < 4000 - 7; i++)
3491 ASSERT (result[i] == '0');
3492 ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
3493 ASSERT (retval == strlen (result));
3500 my_asprintf (&result, "%.4000o %d", 1234567, 99);
3502 ASSERT (result != NULL);
3503 for (i = 0; i < 4000 - 7; i++)
3504 ASSERT (result[i] == '0');
3505 ASSERT (strcmp (result + 4000 - 7, "4553207 99") == 0);
3506 ASSERT (retval == strlen (result));
3513 my_asprintf (&result, "%.4000x %d", 1234567, 99);
3515 ASSERT (result != NULL);
3516 for (i = 0; i < 4000 - 6; i++)
3517 ASSERT (result[i] == '0');
3518 ASSERT (strcmp (result + 4000 - 6, "12d687 99") == 0);
3519 ASSERT (retval == strlen (result));
3526 my_asprintf (&result, "%#.4000x %d", 1234567, 99);
3528 ASSERT (result != NULL);
3529 ASSERT (result[0] == '0');
3530 ASSERT (result[1] == 'x');
3531 for (i = 0; i < 4000 - 6; i++)
3532 ASSERT (result[2 + i] == '0');
3533 ASSERT (strcmp (result + 2 + 4000 - 6, "12d687 99") == 0);
3534 ASSERT (retval == strlen (result));
3541 my_asprintf (&result, "%.4000f %d", 1.0, 99);
3543 ASSERT (result != NULL);
3544 ASSERT (result[0] == '1');
3545 ASSERT (result[1] == '.');
3546 for (i = 0; i < 4000; i++)
3547 ASSERT (result[2 + i] == '0');
3548 ASSERT (strcmp (result + 2 + 4000, " 99") == 0);
3549 ASSERT (retval == strlen (result));
3556 my_asprintf (&result, "%.511f %d", 1.0, 99);
3558 ASSERT (result != NULL);
3559 ASSERT (result[0] == '1');
3560 ASSERT (result[1] == '.');
3561 for (i = 0; i < 511; i++)
3562 ASSERT (result[2 + i] == '0');
3563 ASSERT (strcmp (result + 2 + 511, " 99") == 0);
3564 ASSERT (retval == strlen (result));
3574 for (i = 0; i < sizeof (input) - 1; i++)
3575 input[i] = 'a' + ((1000000 / (i + 1)) % 26);
3577 retval = my_asprintf (&result, "%.4000s %d", input, 99);
3578 ASSERT (result != NULL);
3579 ASSERT (memcmp (result, input, 4000) == 0);
3580 ASSERT (strcmp (result + 4000, " 99") == 0);
3581 ASSERT (retval == strlen (result));
3585 /* Test the support of the %s format directive. */
3587 /* To verify that these tests succeed, it is necessary to run them under
3588 a tool that checks against invalid memory accesses, such as ElectricFence
3589 or "valgrind --tool=memcheck". */
3593 for (i = 1; i <= 8; i++)
3599 block = (char *) malloc (i);
3600 memcpy (block, "abcdefgh", i);
3601 retval = my_asprintf (&result, "%.*s", (int) i, block);
3602 ASSERT (result != NULL);
3603 ASSERT (memcmp (result, block, i) == 0);
3604 ASSERT (result[i] == '\0');
3605 ASSERT (retval == strlen (result));
3614 for (i = 1; i <= 8; i++)
3621 block = (wchar_t *) malloc (i * sizeof (wchar_t));
3622 for (j = 0; j < i; j++)
3623 block[j] = "abcdefgh"[j];
3624 retval = my_asprintf (&result, "%.*ls", (int) i, block);
3625 ASSERT (result != NULL);
3626 ASSERT (memcmp (result, "abcdefgh", i) == 0);
3627 ASSERT (result[i] == '\0');
3628 ASSERT (retval == strlen (result));
3637 my_asprintf (char **result, const char *format, ...)
3642 va_start (args, format);
3643 ret = vasprintf (result, format, args);
3651 test_function (my_asprintf);
3657 test_function (asprintf);
3661 main (int argc, char *argv[])