1 /* Test of POSIX compatible vasnprintf() and asnprintf() functions.
2 Copyright (C) 2007 Free Software Foundation, Inc.
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 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. */
21 #include "vasnprintf.h"
31 #define SIZEOF(array) (sizeof (array) / sizeof (array[0]))
32 #define ASSERT(expr) \
37 fprintf (stderr, "%s:%d: assertion failed\n", __FILE__, __LINE__); \
43 /* The Compaq (ex-DEC) C 6.4 compiler chokes on the expression 0.0 / 0.0. */
48 static double zero = 0.0;
52 # define NaN() (0.0 / 0.0)
55 /* The SGI MIPS floating-point format does not distinguish 0.0 and -0.0. */
59 static double plus_zero = 0.0;
60 static double minus_zero = -0.0;
61 return memcmp (&plus_zero, &minus_zero, sizeof (double)) != 0;
64 /* Representation of an 80-bit 'long double' as an initializer for a sequence
65 of 'unsigned int' words. */
66 #ifdef WORDS_BIGENDIAN
67 # define LDBL80_WORDS(exponent,manthi,mantlo) \
68 { ((unsigned int) (exponent) << 16) | ((unsigned int) (manthi) >> 16), \
69 ((unsigned int) (manthi) << 16) | (unsigned int) (mantlo) >> 16), \
70 (unsigned int) (mantlo) << 16 \
73 # define LDBL80_WORDS(exponent,manthi,mantlo) \
74 { mantlo, manthi, exponent }
78 strmatch (const char *pattern, const char *string)
80 if (strlen (pattern) != strlen (string))
82 for (; *pattern != '\0'; pattern++, string++)
83 if (*pattern != '*' && *string != *pattern)
88 /* Test whether string[start_index..end_index-1] is a valid textual
89 representation of NaN. */
91 strisnan (const char *string, size_t start_index, size_t end_index, int uppercase)
93 if (start_index < end_index)
95 if (string[start_index] == '-')
97 if (start_index + 3 <= end_index
98 && memcmp (string + start_index, uppercase ? "NAN" : "nan", 3) == 0)
101 if (start_index == end_index
102 || (string[start_index] == '(' && string[end_index - 1] == ')'))
110 test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...))
115 /* Test return value convention. */
117 for (size = 0; size <= 8; size++)
119 size_t length = size;
120 char *result = my_asnprintf (NULL, &length, "%d", 12345);
121 ASSERT (result != NULL);
122 ASSERT (strcmp (result, "12345") == 0);
123 ASSERT (length == 5);
127 for (size = 0; size <= 8; size++)
132 memcpy (buf, "DEADBEEF", 8);
134 result = my_asnprintf (buf, &length, "%d", 12345);
135 ASSERT (result != NULL);
136 ASSERT (strcmp (result, "12345") == 0);
137 ASSERT (length == 5);
139 ASSERT (result != buf);
140 ASSERT (memcmp (buf + size, "DEADBEEF" + size, 8 - size) == 0);
145 /* Test support of size specifiers as in C99. */
150 my_asnprintf (NULL, &length, "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
151 ASSERT (result != NULL);
152 ASSERT (strcmp (result, "12345671 33") == 0);
153 ASSERT (length == strlen (result));
160 my_asnprintf (NULL, &length, "%zu %d", (size_t) 12345672, 33, 44, 55);
161 ASSERT (result != NULL);
162 ASSERT (strcmp (result, "12345672 33") == 0);
163 ASSERT (length == strlen (result));
170 my_asnprintf (NULL, &length, "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
171 ASSERT (result != NULL);
172 ASSERT (strcmp (result, "12345673 33") == 0);
173 ASSERT (length == strlen (result));
180 my_asnprintf (NULL, &length, "%Lg %d", (long double) 1.5, 33, 44, 55);
181 ASSERT (result != NULL);
182 ASSERT (strcmp (result, "1.5 33") == 0);
183 ASSERT (length == strlen (result));
187 /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
188 output of floating-point numbers. */
190 { /* A positive number. */
193 my_asnprintf (NULL, &length, "%a %d", 3.1416015625, 33, 44, 55);
194 ASSERT (result != NULL);
195 ASSERT (strcmp (result, "0x1.922p+1 33") == 0
196 || strcmp (result, "0x3.244p+0 33") == 0
197 || strcmp (result, "0x6.488p-1 33") == 0
198 || strcmp (result, "0xc.91p-2 33") == 0);
199 ASSERT (length == strlen (result));
203 { /* A negative number. */
206 my_asnprintf (NULL, &length, "%A %d", -3.1416015625, 33, 44, 55);
207 ASSERT (result != NULL);
208 ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
209 || strcmp (result, "-0X3.244P+0 33") == 0
210 || strcmp (result, "-0X6.488P-1 33") == 0
211 || strcmp (result, "-0XC.91P-2 33") == 0);
212 ASSERT (length == strlen (result));
216 { /* Positive zero. */
219 my_asnprintf (NULL, &length, "%a %d", 0.0, 33, 44, 55);
220 ASSERT (result != NULL);
221 ASSERT (strcmp (result, "0x0p+0 33") == 0);
222 ASSERT (length == strlen (result));
226 { /* Negative zero. */
229 my_asnprintf (NULL, &length, "%a %d", -0.0, 33, 44, 55);
230 ASSERT (result != NULL);
231 if (have_minus_zero ())
232 ASSERT (strcmp (result, "-0x0p+0 33") == 0);
233 ASSERT (length == strlen (result));
237 { /* Positive infinity. */
240 my_asnprintf (NULL, &length, "%a %d", 1.0 / 0.0, 33, 44, 55);
241 ASSERT (result != NULL);
242 ASSERT (strcmp (result, "inf 33") == 0);
243 ASSERT (length == strlen (result));
247 { /* Negative infinity. */
250 my_asnprintf (NULL, &length, "%a %d", -1.0 / 0.0, 33, 44, 55);
251 ASSERT (result != NULL);
252 ASSERT (strcmp (result, "-inf 33") == 0);
253 ASSERT (length == strlen (result));
260 my_asnprintf (NULL, &length, "%a %d", NaN (), 33, 44, 55);
261 ASSERT (result != NULL);
262 ASSERT (strlen (result) >= 3 + 3
263 && strisnan (result, 0, strlen (result) - 3, 0)
264 && strcmp (result + strlen (result) - 3, " 33") == 0);
265 ASSERT (length == strlen (result));
269 { /* Rounding near the decimal point. */
272 my_asnprintf (NULL, &length, "%.0a %d", 1.5, 33, 44, 55);
273 ASSERT (result != NULL);
274 ASSERT (strcmp (result, "0x2p+0 33") == 0
275 || strcmp (result, "0x3p-1 33") == 0
276 || strcmp (result, "0x6p-2 33") == 0
277 || strcmp (result, "0xcp-3 33") == 0);
278 ASSERT (length == strlen (result));
282 { /* Rounding with precision 0. */
285 my_asnprintf (NULL, &length, "%.0a %d", 1.51, 33, 44, 55);
286 ASSERT (result != NULL);
287 ASSERT (strcmp (result, "0x2p+0 33") == 0
288 || strcmp (result, "0x3p-1 33") == 0
289 || strcmp (result, "0x6p-2 33") == 0
290 || strcmp (result, "0xcp-3 33") == 0);
291 ASSERT (length == strlen (result));
295 { /* Rounding with precision 1. */
298 my_asnprintf (NULL, &length, "%.1a %d", 1.51, 33, 44, 55);
299 ASSERT (result != NULL);
300 ASSERT (strcmp (result, "0x1.8p+0 33") == 0
301 || strcmp (result, "0x3.0p-1 33") == 0
302 || strcmp (result, "0x6.1p-2 33") == 0
303 || strcmp (result, "0xc.1p-3 33") == 0);
304 ASSERT (length == strlen (result));
308 { /* Rounding with precision 2. */
311 my_asnprintf (NULL, &length, "%.2a %d", 1.51, 33, 44, 55);
312 ASSERT (result != NULL);
313 ASSERT (strcmp (result, "0x1.83p+0 33") == 0
314 || strcmp (result, "0x3.05p-1 33") == 0
315 || strcmp (result, "0x6.0ap-2 33") == 0
316 || strcmp (result, "0xc.14p-3 33") == 0);
317 ASSERT (length == strlen (result));
321 { /* Rounding with precision 3. */
324 my_asnprintf (NULL, &length, "%.3a %d", 1.51, 33, 44, 55);
325 ASSERT (result != NULL);
326 ASSERT (strcmp (result, "0x1.829p+0 33") == 0
327 || strcmp (result, "0x3.052p-1 33") == 0
328 || strcmp (result, "0x6.0a4p-2 33") == 0
329 || strcmp (result, "0xc.148p-3 33") == 0);
330 ASSERT (length == strlen (result));
334 { /* Rounding can turn a ...FFF into a ...000. */
337 my_asnprintf (NULL, &length, "%.3a %d", 1.49999, 33, 44, 55);
338 ASSERT (result != NULL);
339 ASSERT (strcmp (result, "0x1.800p+0 33") == 0
340 || strcmp (result, "0x3.000p-1 33") == 0
341 || strcmp (result, "0x6.000p-2 33") == 0
342 || strcmp (result, "0xc.000p-3 33") == 0);
343 ASSERT (length == strlen (result));
347 { /* Rounding can turn a ...FFF into a ...000.
348 This shows a MacOS X 10.3.9 (Darwin 7.9) bug. */
351 my_asnprintf (NULL, &length, "%.1a %d", 1.999, 33, 44, 55);
352 ASSERT (result != NULL);
353 ASSERT (strcmp (result, "0x1.0p+1 33") == 0
354 || strcmp (result, "0x2.0p+0 33") == 0
355 || strcmp (result, "0x4.0p-1 33") == 0
356 || strcmp (result, "0x8.0p-2 33") == 0);
357 ASSERT (length == strlen (result));
364 my_asnprintf (NULL, &length, "%10a %d", 1.75, 33, 44, 55);
365 ASSERT (result != NULL);
366 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
367 || strcmp (result, " 0x3.8p-1 33") == 0
368 || strcmp (result, " 0x7p-2 33") == 0
369 || strcmp (result, " 0xep-3 33") == 0);
370 ASSERT (length == strlen (result));
374 { /* Small precision. */
377 my_asnprintf (NULL, &length, "%.10a %d", 1.75, 33, 44, 55);
378 ASSERT (result != NULL);
379 ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
380 || strcmp (result, "0x3.8000000000p-1 33") == 0
381 || strcmp (result, "0x7.0000000000p-2 33") == 0
382 || strcmp (result, "0xe.0000000000p-3 33") == 0);
383 ASSERT (length == strlen (result));
387 { /* Large precision. */
390 my_asnprintf (NULL, &length, "%.50a %d", 1.75, 33, 44, 55);
391 ASSERT (result != NULL);
392 ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
393 || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
394 || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
395 || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
396 ASSERT (length == strlen (result));
403 my_asnprintf (NULL, &length, "%-10a %d", 1.75, 33, 44, 55);
404 ASSERT (result != NULL);
405 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
406 || strcmp (result, "0x3.8p-1 33") == 0
407 || strcmp (result, "0x7p-2 33") == 0
408 || strcmp (result, "0xep-3 33") == 0);
409 ASSERT (length == strlen (result));
413 { /* FLAG_SHOWSIGN. */
416 my_asnprintf (NULL, &length, "%+a %d", 1.75, 33, 44, 55);
417 ASSERT (result != NULL);
418 ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
419 || strcmp (result, "+0x3.8p-1 33") == 0
420 || strcmp (result, "+0x7p-2 33") == 0
421 || strcmp (result, "+0xep-3 33") == 0);
422 ASSERT (length == strlen (result));
429 my_asnprintf (NULL, &length, "% a %d", 1.75, 33, 44, 55);
430 ASSERT (result != NULL);
431 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
432 || strcmp (result, " 0x3.8p-1 33") == 0
433 || strcmp (result, " 0x7p-2 33") == 0
434 || strcmp (result, " 0xep-3 33") == 0);
435 ASSERT (length == strlen (result));
442 my_asnprintf (NULL, &length, "%#a %d", 1.75, 33, 44, 55);
443 ASSERT (result != NULL);
444 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
445 || strcmp (result, "0x3.8p-1 33") == 0
446 || strcmp (result, "0x7.p-2 33") == 0
447 || strcmp (result, "0xe.p-3 33") == 0);
448 ASSERT (length == strlen (result));
455 my_asnprintf (NULL, &length, "%#a %d", 1.0, 33, 44, 55);
456 ASSERT (result != NULL);
457 ASSERT (strcmp (result, "0x1.p+0 33") == 0
458 || strcmp (result, "0x2.p-1 33") == 0
459 || strcmp (result, "0x4.p-2 33") == 0
460 || strcmp (result, "0x8.p-3 33") == 0);
461 ASSERT (length == strlen (result));
465 { /* FLAG_ZERO with finite number. */
468 my_asnprintf (NULL, &length, "%010a %d", 1.75, 33, 44, 55);
469 ASSERT (result != NULL);
470 ASSERT (strcmp (result, "0x001.cp+0 33") == 0
471 || strcmp (result, "0x003.8p-1 33") == 0
472 || strcmp (result, "0x00007p-2 33") == 0
473 || strcmp (result, "0x0000ep-3 33") == 0);
474 ASSERT (length == strlen (result));
478 { /* FLAG_ZERO with infinite number. */
481 my_asnprintf (NULL, &length, "%010a %d", 1.0 / 0.0, 33, 44, 55);
482 ASSERT (result != NULL);
483 /* "0000000inf 33" is not a valid result; see
484 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
485 ASSERT (strcmp (result, " inf 33") == 0);
486 ASSERT (length == strlen (result));
490 { /* FLAG_ZERO with NaN. */
493 my_asnprintf (NULL, &length, "%050a %d", NaN (), 33, 44, 55);
494 ASSERT (result != NULL);
495 /* "0000000nan 33" is not a valid result; see
496 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
497 ASSERT (strlen (result) == 50 + 3
498 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
499 && strcmp (result + strlen (result) - 3, " 33") == 0);
500 ASSERT (length == strlen (result));
504 { /* A positive number. */
507 my_asnprintf (NULL, &length, "%La %d", 3.1416015625L, 33, 44, 55);
508 ASSERT (result != NULL);
509 ASSERT (strcmp (result, "0x1.922p+1 33") == 0
510 || strcmp (result, "0x3.244p+0 33") == 0
511 || strcmp (result, "0x6.488p-1 33") == 0
512 || strcmp (result, "0xc.91p-2 33") == 0);
513 ASSERT (length == strlen (result));
517 { /* A negative number. */
520 my_asnprintf (NULL, &length, "%LA %d", -3.1416015625L, 33, 44, 55);
521 ASSERT (result != NULL);
522 ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
523 || strcmp (result, "-0X3.244P+0 33") == 0
524 || strcmp (result, "-0X6.488P-1 33") == 0
525 || strcmp (result, "-0XC.91P-2 33") == 0);
526 ASSERT (length == strlen (result));
530 { /* Positive zero. */
533 my_asnprintf (NULL, &length, "%La %d", 0.0L, 33, 44, 55);
534 ASSERT (result != NULL);
535 ASSERT (strcmp (result, "0x0p+0 33") == 0);
536 ASSERT (length == strlen (result));
540 { /* Negative zero. */
543 my_asnprintf (NULL, &length, "%La %d", -0.0L, 33, 44, 55);
544 ASSERT (result != NULL);
545 if (have_minus_zero ())
546 ASSERT (strcmp (result, "-0x0p+0 33") == 0);
547 ASSERT (length == strlen (result));
551 { /* Positive infinity. */
554 my_asnprintf (NULL, &length, "%La %d", 1.0L / 0.0L, 33, 44, 55);
555 ASSERT (result != NULL);
556 ASSERT (strcmp (result, "inf 33") == 0);
557 ASSERT (length == strlen (result));
561 { /* Negative infinity. */
564 my_asnprintf (NULL, &length, "%La %d", -1.0L / 0.0L, 33, 44, 55);
565 ASSERT (result != NULL);
566 ASSERT (strcmp (result, "-inf 33") == 0);
567 ASSERT (length == strlen (result));
574 my_asnprintf (NULL, &length, "%La %d", 0.0L / 0.0L, 33, 44, 55);
575 ASSERT (result != NULL);
576 ASSERT (strlen (result) >= 3 + 3
577 && strisnan (result, 0, strlen (result) - 3, 0)
578 && strcmp (result + strlen (result) - 3, " 33") == 0);
579 ASSERT (length == strlen (result));
582 #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_))
584 static union { unsigned int word[4]; long double value; } x =
585 { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
588 my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55);
589 ASSERT (result != NULL);
590 ASSERT (strlen (result) >= 3 + 3
591 && strisnan (result, 0, strlen (result) - 3, 0)
592 && strcmp (result + strlen (result) - 3, " 33") == 0);
593 ASSERT (length == strlen (result));
597 /* Signalling NaN. */
598 static union { unsigned int word[4]; long double value; } x =
599 { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
602 my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55);
603 ASSERT (result != NULL);
604 ASSERT (strlen (result) >= 3 + 3
605 && strisnan (result, 0, strlen (result) - 3, 0)
606 && strcmp (result + strlen (result) - 3, " 33") == 0);
607 ASSERT (length == strlen (result));
610 /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
611 Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
612 Intel IA-64 Architecture Software Developer's Manual, Volume 1:
613 Application Architecture.
614 Table 5-2 "Floating-Point Register Encodings"
615 Figure 5-6 "Memory to Floating-Point Register Data Translation"
618 static union { unsigned int word[4]; long double value; } x =
619 { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
622 my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55);
623 ASSERT (result != NULL);
624 ASSERT (strlen (result) >= 3 + 3
625 && strisnan (result, 0, strlen (result) - 3, 0)
626 && strcmp (result + strlen (result) - 3, " 33") == 0);
627 ASSERT (length == strlen (result));
630 { /* Pseudo-Infinity. */
631 static union { unsigned int word[4]; long double value; } x =
632 { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
635 my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55);
636 ASSERT (result != NULL);
637 ASSERT (strlen (result) >= 3 + 3
638 && strisnan (result, 0, strlen (result) - 3, 0)
639 && strcmp (result + strlen (result) - 3, " 33") == 0);
640 ASSERT (length == strlen (result));
644 static union { unsigned int word[4]; long double value; } x =
645 { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
648 my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55);
649 ASSERT (result != NULL);
650 ASSERT (strlen (result) >= 3 + 3
651 && strisnan (result, 0, strlen (result) - 3, 0)
652 && strcmp (result + strlen (result) - 3, " 33") == 0);
653 ASSERT (length == strlen (result));
656 { /* Unnormalized number. */
657 static union { unsigned int word[4]; long double value; } x =
658 { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
661 my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55);
662 ASSERT (result != NULL);
663 ASSERT (strlen (result) >= 3 + 3
664 && strisnan (result, 0, strlen (result) - 3, 0)
665 && strcmp (result + strlen (result) - 3, " 33") == 0);
666 ASSERT (length == strlen (result));
669 { /* Pseudo-Denormal. */
670 static union { unsigned int word[4]; long double value; } x =
671 { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
674 my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55);
675 ASSERT (result != NULL);
676 ASSERT (strlen (result) >= 3 + 3
677 && strisnan (result, 0, strlen (result) - 3, 0)
678 && strcmp (result + strlen (result) - 3, " 33") == 0);
679 ASSERT (length == strlen (result));
684 { /* Rounding near the decimal point. */
687 my_asnprintf (NULL, &length, "%.0La %d", 1.5L, 33, 44, 55);
688 ASSERT (result != NULL);
689 ASSERT (strcmp (result, "0x2p+0 33") == 0
690 || strcmp (result, "0x3p-1 33") == 0
691 || strcmp (result, "0x6p-2 33") == 0
692 || strcmp (result, "0xcp-3 33") == 0);
693 ASSERT (length == strlen (result));
697 { /* Rounding with precision 0. */
700 my_asnprintf (NULL, &length, "%.0La %d", 1.51L, 33, 44, 55);
701 ASSERT (result != NULL);
702 ASSERT (strcmp (result, "0x2p+0 33") == 0
703 || strcmp (result, "0x3p-1 33") == 0
704 || strcmp (result, "0x6p-2 33") == 0
705 || strcmp (result, "0xcp-3 33") == 0);
706 ASSERT (length == strlen (result));
710 { /* Rounding with precision 1. */
713 my_asnprintf (NULL, &length, "%.1La %d", 1.51L, 33, 44, 55);
714 ASSERT (result != NULL);
715 ASSERT (strcmp (result, "0x1.8p+0 33") == 0
716 || strcmp (result, "0x3.0p-1 33") == 0
717 || strcmp (result, "0x6.1p-2 33") == 0
718 || strcmp (result, "0xc.1p-3 33") == 0);
719 ASSERT (length == strlen (result));
723 { /* Rounding with precision 2. */
726 my_asnprintf (NULL, &length, "%.2La %d", 1.51L, 33, 44, 55);
727 ASSERT (result != NULL);
728 ASSERT (strcmp (result, "0x1.83p+0 33") == 0
729 || strcmp (result, "0x3.05p-1 33") == 0
730 || strcmp (result, "0x6.0ap-2 33") == 0
731 || strcmp (result, "0xc.14p-3 33") == 0);
732 ASSERT (length == strlen (result));
736 { /* Rounding with precision 3. */
739 my_asnprintf (NULL, &length, "%.3La %d", 1.51L, 33, 44, 55);
740 ASSERT (result != NULL);
741 ASSERT (strcmp (result, "0x1.829p+0 33") == 0
742 || strcmp (result, "0x3.052p-1 33") == 0
743 || strcmp (result, "0x6.0a4p-2 33") == 0
744 || strcmp (result, "0xc.148p-3 33") == 0);
745 ASSERT (length == strlen (result));
749 { /* Rounding can turn a ...FFF into a ...000. */
752 my_asnprintf (NULL, &length, "%.3La %d", 1.49999L, 33, 44, 55);
753 ASSERT (result != NULL);
754 ASSERT (strcmp (result, "0x1.800p+0 33") == 0
755 || strcmp (result, "0x3.000p-1 33") == 0
756 || strcmp (result, "0x6.000p-2 33") == 0
757 || strcmp (result, "0xc.000p-3 33") == 0);
758 ASSERT (length == strlen (result));
762 { /* Rounding can turn a ...FFF into a ...000.
763 This shows a MacOS X 10.3.9 (Darwin 7.9) bug and a
764 glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>. */
767 my_asnprintf (NULL, &length, "%.1La %d", 1.999L, 33, 44, 55);
768 ASSERT (result != NULL);
769 ASSERT (strcmp (result, "0x1.0p+1 33") == 0
770 || strcmp (result, "0x2.0p+0 33") == 0
771 || strcmp (result, "0x4.0p-1 33") == 0
772 || strcmp (result, "0x8.0p-2 33") == 0);
773 ASSERT (length == strlen (result));
780 my_asnprintf (NULL, &length, "%10La %d", 1.75L, 33, 44, 55);
781 ASSERT (result != NULL);
782 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
783 || strcmp (result, " 0x3.8p-1 33") == 0
784 || strcmp (result, " 0x7p-2 33") == 0
785 || strcmp (result, " 0xep-3 33") == 0);
786 ASSERT (length == strlen (result));
790 { /* Small precision. */
793 my_asnprintf (NULL, &length, "%.10La %d", 1.75L, 33, 44, 55);
794 ASSERT (result != NULL);
795 ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
796 || strcmp (result, "0x3.8000000000p-1 33") == 0
797 || strcmp (result, "0x7.0000000000p-2 33") == 0
798 || strcmp (result, "0xe.0000000000p-3 33") == 0);
799 ASSERT (length == strlen (result));
803 { /* Large precision. */
806 my_asnprintf (NULL, &length, "%.50La %d", 1.75L, 33, 44, 55);
807 ASSERT (result != NULL);
808 ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
809 || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
810 || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
811 || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
812 ASSERT (length == strlen (result));
819 my_asnprintf (NULL, &length, "%-10La %d", 1.75L, 33, 44, 55);
820 ASSERT (result != NULL);
821 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
822 || strcmp (result, "0x3.8p-1 33") == 0
823 || strcmp (result, "0x7p-2 33") == 0
824 || strcmp (result, "0xep-3 33") == 0);
825 ASSERT (length == strlen (result));
829 { /* FLAG_SHOWSIGN. */
832 my_asnprintf (NULL, &length, "%+La %d", 1.75L, 33, 44, 55);
833 ASSERT (result != NULL);
834 ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
835 || strcmp (result, "+0x3.8p-1 33") == 0
836 || strcmp (result, "+0x7p-2 33") == 0
837 || strcmp (result, "+0xep-3 33") == 0);
838 ASSERT (length == strlen (result));
845 my_asnprintf (NULL, &length, "% La %d", 1.75L, 33, 44, 55);
846 ASSERT (result != NULL);
847 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
848 || strcmp (result, " 0x3.8p-1 33") == 0
849 || strcmp (result, " 0x7p-2 33") == 0
850 || strcmp (result, " 0xep-3 33") == 0);
851 ASSERT (length == strlen (result));
858 my_asnprintf (NULL, &length, "%#La %d", 1.75L, 33, 44, 55);
859 ASSERT (result != NULL);
860 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
861 || strcmp (result, "0x3.8p-1 33") == 0
862 || strcmp (result, "0x7.p-2 33") == 0
863 || strcmp (result, "0xe.p-3 33") == 0);
864 ASSERT (length == strlen (result));
871 my_asnprintf (NULL, &length, "%#La %d", 1.0L, 33, 44, 55);
872 ASSERT (result != NULL);
873 ASSERT (strcmp (result, "0x1.p+0 33") == 0
874 || strcmp (result, "0x2.p-1 33") == 0
875 || strcmp (result, "0x4.p-2 33") == 0
876 || strcmp (result, "0x8.p-3 33") == 0);
877 ASSERT (length == strlen (result));
881 { /* FLAG_ZERO with finite number. */
884 my_asnprintf (NULL, &length, "%010La %d", 1.75L, 33, 44, 55);
885 ASSERT (result != NULL);
886 ASSERT (strcmp (result, "0x001.cp+0 33") == 0
887 || strcmp (result, "0x003.8p-1 33") == 0
888 || strcmp (result, "0x00007p-2 33") == 0
889 || strcmp (result, "0x0000ep-3 33") == 0);
890 ASSERT (length == strlen (result));
894 { /* FLAG_ZERO with infinite number. */
897 my_asnprintf (NULL, &length, "%010La %d", 1.0L / 0.0L, 33, 44, 55);
898 ASSERT (result != NULL);
899 /* "0000000inf 33" is not a valid result; see
900 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
901 ASSERT (strcmp (result, " inf 33") == 0);
902 ASSERT (length == strlen (result));
906 { /* FLAG_ZERO with NaN. */
909 my_asnprintf (NULL, &length, "%050La %d", 0.0L / 0.0L, 33, 44, 55);
910 ASSERT (result != NULL);
911 /* "0000000nan 33" is not a valid result; see
912 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
913 ASSERT (strlen (result) == 50 + 3
914 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
915 && strcmp (result + strlen (result) - 3, " 33") == 0);
916 ASSERT (length == strlen (result));
920 /* Test the support of the %f format directive. */
922 { /* A positive number. */
925 my_asnprintf (NULL, &length, "%f %d", 12.75, 33, 44, 55);
926 ASSERT (result != NULL);
927 ASSERT (strcmp (result, "12.750000 33") == 0);
928 ASSERT (length == strlen (result));
932 { /* A larger positive number. */
935 my_asnprintf (NULL, &length, "%f %d", 1234567.0, 33, 44, 55);
936 ASSERT (result != NULL);
937 ASSERT (strcmp (result, "1234567.000000 33") == 0);
938 ASSERT (length == strlen (result));
942 { /* Small and large positive numbers. */
943 static struct { double value; const char *string; } data[] =
945 { 1.234321234321234e-37, "0.000000" },
946 { 1.234321234321234e-36, "0.000000" },
947 { 1.234321234321234e-35, "0.000000" },
948 { 1.234321234321234e-34, "0.000000" },
949 { 1.234321234321234e-33, "0.000000" },
950 { 1.234321234321234e-32, "0.000000" },
951 { 1.234321234321234e-31, "0.000000" },
952 { 1.234321234321234e-30, "0.000000" },
953 { 1.234321234321234e-29, "0.000000" },
954 { 1.234321234321234e-28, "0.000000" },
955 { 1.234321234321234e-27, "0.000000" },
956 { 1.234321234321234e-26, "0.000000" },
957 { 1.234321234321234e-25, "0.000000" },
958 { 1.234321234321234e-24, "0.000000" },
959 { 1.234321234321234e-23, "0.000000" },
960 { 1.234321234321234e-22, "0.000000" },
961 { 1.234321234321234e-21, "0.000000" },
962 { 1.234321234321234e-20, "0.000000" },
963 { 1.234321234321234e-19, "0.000000" },
964 { 1.234321234321234e-18, "0.000000" },
965 { 1.234321234321234e-17, "0.000000" },
966 { 1.234321234321234e-16, "0.000000" },
967 { 1.234321234321234e-15, "0.000000" },
968 { 1.234321234321234e-14, "0.000000" },
969 { 1.234321234321234e-13, "0.000000" },
970 { 1.234321234321234e-12, "0.000000" },
971 { 1.234321234321234e-11, "0.000000" },
972 { 1.234321234321234e-10, "0.000000" },
973 { 1.234321234321234e-9, "0.000000" },
974 { 1.234321234321234e-8, "0.000000" },
975 { 1.234321234321234e-7, "0.000000" },
976 { 1.234321234321234e-6, "0.000001" },
977 { 1.234321234321234e-5, "0.000012" },
978 { 1.234321234321234e-4, "0.000123" },
979 { 1.234321234321234e-3, "0.001234" },
980 { 1.234321234321234e-2, "0.012343" },
981 { 1.234321234321234e-1, "0.123432" },
982 { 1.234321234321234, "1.234321" },
983 { 1.234321234321234e1, "12.343212" },
984 { 1.234321234321234e2, "123.432123" },
985 { 1.234321234321234e3, "1234.321234" },
986 { 1.234321234321234e4, "12343.212343" },
987 { 1.234321234321234e5, "123432.123432" },
988 { 1.234321234321234e6, "1234321.234321" },
989 { 1.234321234321234e7, "12343212.343212" },
990 { 1.234321234321234e8, "123432123.432123" },
991 { 1.234321234321234e9, "1234321234.321234" },
992 { 1.234321234321234e10, "12343212343.2123**" },
993 { 1.234321234321234e11, "123432123432.123***" },
994 { 1.234321234321234e12, "1234321234321.23****" },
995 { 1.234321234321234e13, "12343212343212.3*****" },
996 { 1.234321234321234e14, "123432123432123.******" },
997 { 1.234321234321234e15, "1234321234321234.000000" },
998 { 1.234321234321234e16, "123432123432123**.000000" },
999 { 1.234321234321234e17, "123432123432123***.000000" },
1000 { 1.234321234321234e18, "123432123432123****.000000" },
1001 { 1.234321234321234e19, "123432123432123*****.000000" },
1002 { 1.234321234321234e20, "123432123432123******.000000" },
1003 { 1.234321234321234e21, "123432123432123*******.000000" },
1004 { 1.234321234321234e22, "123432123432123********.000000" },
1005 { 1.234321234321234e23, "123432123432123*********.000000" },
1006 { 1.234321234321234e24, "123432123432123**********.000000" },
1007 { 1.234321234321234e25, "123432123432123***********.000000" },
1008 { 1.234321234321234e26, "123432123432123************.000000" },
1009 { 1.234321234321234e27, "123432123432123*************.000000" },
1010 { 1.234321234321234e28, "123432123432123**************.000000" },
1011 { 1.234321234321234e29, "123432123432123***************.000000" },
1012 { 1.234321234321234e30, "123432123432123****************.000000" },
1013 { 1.234321234321234e31, "123432123432123*****************.000000" },
1014 { 1.234321234321234e32, "123432123432123******************.000000" },
1015 { 1.234321234321234e33, "123432123432123*******************.000000" },
1016 { 1.234321234321234e34, "123432123432123********************.000000" },
1017 { 1.234321234321234e35, "123432123432123*********************.000000" },
1018 { 1.234321234321234e36, "123432123432123**********************.000000" }
1021 for (k = 0; k < SIZEOF (data); k++)
1025 my_asnprintf (NULL, &length, "%f", data[k].value);
1026 ASSERT (result != NULL);
1027 ASSERT (strmatch (data[k].string, result));
1028 ASSERT (length == strlen (result));
1033 { /* A negative number. */
1036 my_asnprintf (NULL, &length, "%f %d", -0.03125, 33, 44, 55);
1037 ASSERT (result != NULL);
1038 ASSERT (strcmp (result, "-0.031250 33") == 0);
1039 ASSERT (length == strlen (result));
1043 { /* Positive zero. */
1046 my_asnprintf (NULL, &length, "%f %d", 0.0, 33, 44, 55);
1047 ASSERT (result != NULL);
1048 ASSERT (strcmp (result, "0.000000 33") == 0);
1049 ASSERT (length == strlen (result));
1053 { /* Negative zero. */
1056 my_asnprintf (NULL, &length, "%f %d", -0.0, 33, 44, 55);
1057 ASSERT (result != NULL);
1058 if (have_minus_zero ())
1059 ASSERT (strcmp (result, "-0.000000 33") == 0);
1060 ASSERT (length == strlen (result));
1064 { /* Positive infinity. */
1067 my_asnprintf (NULL, &length, "%f %d", 1.0 / 0.0, 33, 44, 55);
1068 ASSERT (result != NULL);
1069 ASSERT (strcmp (result, "inf 33") == 0
1070 || strcmp (result, "infinity 33") == 0);
1071 ASSERT (length == strlen (result));
1075 { /* Negative infinity. */
1078 my_asnprintf (NULL, &length, "%f %d", -1.0 / 0.0, 33, 44, 55);
1079 ASSERT (result != NULL);
1080 ASSERT (strcmp (result, "-inf 33") == 0
1081 || strcmp (result, "-infinity 33") == 0);
1082 ASSERT (length == strlen (result));
1089 my_asnprintf (NULL, &length, "%f %d", NaN (), 33, 44, 55);
1090 ASSERT (result != NULL);
1091 ASSERT (strlen (result) >= 3 + 3
1092 && strisnan (result, 0, strlen (result) - 3, 0)
1093 && strcmp (result + strlen (result) - 3, " 33") == 0);
1094 ASSERT (length == strlen (result));
1101 my_asnprintf (NULL, &length, "%10f %d", 1.75, 33, 44, 55);
1102 ASSERT (result != NULL);
1103 ASSERT (strcmp (result, " 1.750000 33") == 0);
1104 ASSERT (length == strlen (result));
1111 my_asnprintf (NULL, &length, "%-10f %d", 1.75, 33, 44, 55);
1112 ASSERT (result != NULL);
1113 ASSERT (strcmp (result, "1.750000 33") == 0);
1114 ASSERT (length == strlen (result));
1118 { /* FLAG_SHOWSIGN. */
1121 my_asnprintf (NULL, &length, "%+f %d", 1.75, 33, 44, 55);
1122 ASSERT (result != NULL);
1123 ASSERT (strcmp (result, "+1.750000 33") == 0);
1124 ASSERT (length == strlen (result));
1131 my_asnprintf (NULL, &length, "% f %d", 1.75, 33, 44, 55);
1132 ASSERT (result != NULL);
1133 ASSERT (strcmp (result, " 1.750000 33") == 0);
1134 ASSERT (length == strlen (result));
1141 my_asnprintf (NULL, &length, "%#f %d", 1.75, 33, 44, 55);
1142 ASSERT (result != NULL);
1143 ASSERT (strcmp (result, "1.750000 33") == 0);
1144 ASSERT (length == strlen (result));
1151 my_asnprintf (NULL, &length, "%#.f %d", 1.75, 33, 44, 55);
1152 ASSERT (result != NULL);
1153 ASSERT (strcmp (result, "2. 33") == 0);
1154 ASSERT (length == strlen (result));
1158 { /* FLAG_ZERO with finite number. */
1161 my_asnprintf (NULL, &length, "%015f %d", 1234.0, 33, 44, 55);
1162 ASSERT (result != NULL);
1163 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1164 ASSERT (length == strlen (result));
1168 { /* FLAG_ZERO with infinite number. */
1171 my_asnprintf (NULL, &length, "%015f %d", -1.0 / 0.0, 33, 44, 55);
1172 ASSERT (result != NULL);
1173 ASSERT (strcmp (result, " -inf 33") == 0
1174 || strcmp (result, " -infinity 33") == 0);
1175 ASSERT (length == strlen (result));
1179 { /* FLAG_ZERO with NaN. */
1182 my_asnprintf (NULL, &length, "%050f %d", NaN (), 33, 44, 55);
1183 ASSERT (result != NULL);
1184 ASSERT (strlen (result) == 50 + 3
1185 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1186 && strcmp (result + strlen (result) - 3, " 33") == 0);
1187 ASSERT (length == strlen (result));
1194 my_asnprintf (NULL, &length, "%.f %d", 1234.0, 33, 44, 55);
1195 ASSERT (result != NULL);
1196 ASSERT (strcmp (result, "1234 33") == 0);
1197 ASSERT (length == strlen (result));
1201 { /* A positive number. */
1204 my_asnprintf (NULL, &length, "%Lf %d", 12.75L, 33, 44, 55);
1205 ASSERT (result != NULL);
1206 ASSERT (strcmp (result, "12.750000 33") == 0);
1207 ASSERT (length == strlen (result));
1211 { /* A larger positive number. */
1214 my_asnprintf (NULL, &length, "%Lf %d", 1234567.0L, 33, 44, 55);
1215 ASSERT (result != NULL);
1216 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1217 ASSERT (length == strlen (result));
1221 { /* Small and large positive numbers. */
1222 static struct { long double value; const char *string; } data[] =
1224 { 1.234321234321234e-37L, "0.000000" },
1225 { 1.234321234321234e-36L, "0.000000" },
1226 { 1.234321234321234e-35L, "0.000000" },
1227 { 1.234321234321234e-34L, "0.000000" },
1228 { 1.234321234321234e-33L, "0.000000" },
1229 { 1.234321234321234e-32L, "0.000000" },
1230 { 1.234321234321234e-31L, "0.000000" },
1231 { 1.234321234321234e-30L, "0.000000" },
1232 { 1.234321234321234e-29L, "0.000000" },
1233 { 1.234321234321234e-28L, "0.000000" },
1234 { 1.234321234321234e-27L, "0.000000" },
1235 { 1.234321234321234e-26L, "0.000000" },
1236 { 1.234321234321234e-25L, "0.000000" },
1237 { 1.234321234321234e-24L, "0.000000" },
1238 { 1.234321234321234e-23L, "0.000000" },
1239 { 1.234321234321234e-22L, "0.000000" },
1240 { 1.234321234321234e-21L, "0.000000" },
1241 { 1.234321234321234e-20L, "0.000000" },
1242 { 1.234321234321234e-19L, "0.000000" },
1243 { 1.234321234321234e-18L, "0.000000" },
1244 { 1.234321234321234e-17L, "0.000000" },
1245 { 1.234321234321234e-16L, "0.000000" },
1246 { 1.234321234321234e-15L, "0.000000" },
1247 { 1.234321234321234e-14L, "0.000000" },
1248 { 1.234321234321234e-13L, "0.000000" },
1249 { 1.234321234321234e-12L, "0.000000" },
1250 { 1.234321234321234e-11L, "0.000000" },
1251 { 1.234321234321234e-10L, "0.000000" },
1252 { 1.234321234321234e-9L, "0.000000" },
1253 { 1.234321234321234e-8L, "0.000000" },
1254 { 1.234321234321234e-7L, "0.000000" },
1255 { 1.234321234321234e-6L, "0.000001" },
1256 { 1.234321234321234e-5L, "0.000012" },
1257 { 1.234321234321234e-4L, "0.000123" },
1258 { 1.234321234321234e-3L, "0.001234" },
1259 { 1.234321234321234e-2L, "0.012343" },
1260 { 1.234321234321234e-1L, "0.123432" },
1261 { 1.234321234321234L, "1.234321" },
1262 { 1.234321234321234e1L, "12.343212" },
1263 { 1.234321234321234e2L, "123.432123" },
1264 { 1.234321234321234e3L, "1234.321234" },
1265 { 1.234321234321234e4L, "12343.212343" },
1266 { 1.234321234321234e5L, "123432.123432" },
1267 { 1.234321234321234e6L, "1234321.234321" },
1268 { 1.234321234321234e7L, "12343212.343212" },
1269 { 1.234321234321234e8L, "123432123.432123" },
1270 { 1.234321234321234e9L, "1234321234.321234" },
1271 { 1.234321234321234e10L, "12343212343.2123**" },
1272 { 1.234321234321234e11L, "123432123432.123***" },
1273 { 1.234321234321234e12L, "1234321234321.23****" },
1274 { 1.234321234321234e13L, "12343212343212.3*****" },
1275 { 1.234321234321234e14L, "123432123432123.******" },
1276 { 1.234321234321234e15L, "1234321234321234.000000" },
1277 { 1.234321234321234e16L, "123432123432123**.000000" },
1278 { 1.234321234321234e17L, "123432123432123***.000000" },
1279 { 1.234321234321234e18L, "123432123432123****.000000" },
1280 { 1.234321234321234e19L, "123432123432123*****.000000" },
1281 { 1.234321234321234e20L, "123432123432123******.000000" },
1282 { 1.234321234321234e21L, "123432123432123*******.000000" },
1283 { 1.234321234321234e22L, "123432123432123********.000000" },
1284 { 1.234321234321234e23L, "123432123432123*********.000000" },
1285 { 1.234321234321234e24L, "123432123432123**********.000000" },
1286 { 1.234321234321234e25L, "123432123432123***********.000000" },
1287 { 1.234321234321234e26L, "123432123432123************.000000" },
1288 { 1.234321234321234e27L, "123432123432123*************.000000" },
1289 { 1.234321234321234e28L, "123432123432123**************.000000" },
1290 { 1.234321234321234e29L, "123432123432123***************.000000" },
1291 { 1.234321234321234e30L, "123432123432123****************.000000" },
1292 { 1.234321234321234e31L, "123432123432123*****************.000000" },
1293 { 1.234321234321234e32L, "123432123432123******************.000000" },
1294 { 1.234321234321234e33L, "123432123432123*******************.000000" },
1295 { 1.234321234321234e34L, "123432123432123********************.000000" },
1296 { 1.234321234321234e35L, "123432123432123*********************.000000" },
1297 { 1.234321234321234e36L, "123432123432123**********************.000000" }
1300 for (k = 0; k < SIZEOF (data); k++)
1304 my_asnprintf (NULL, &length, "%Lf", data[k].value);
1305 ASSERT (result != NULL);
1306 ASSERT (strmatch (data[k].string, result));
1307 ASSERT (length == strlen (result));
1312 { /* A negative number. */
1315 my_asnprintf (NULL, &length, "%Lf %d", -0.03125L, 33, 44, 55);
1316 ASSERT (result != NULL);
1317 ASSERT (strcmp (result, "-0.031250 33") == 0);
1318 ASSERT (length == strlen (result));
1322 { /* Positive zero. */
1325 my_asnprintf (NULL, &length, "%Lf %d", 0.0L, 33, 44, 55);
1326 ASSERT (result != NULL);
1327 ASSERT (strcmp (result, "0.000000 33") == 0);
1328 ASSERT (length == strlen (result));
1332 { /* Negative zero. */
1335 my_asnprintf (NULL, &length, "%Lf %d", -0.0L, 33, 44, 55);
1336 ASSERT (result != NULL);
1337 if (have_minus_zero ())
1338 ASSERT (strcmp (result, "-0.000000 33") == 0);
1339 ASSERT (length == strlen (result));
1343 { /* Positive infinity. */
1346 my_asnprintf (NULL, &length, "%Lf %d", 1.0L / 0.0L, 33, 44, 55);
1347 ASSERT (result != NULL);
1348 ASSERT (strcmp (result, "inf 33") == 0
1349 || strcmp (result, "infinity 33") == 0);
1350 ASSERT (length == strlen (result));
1354 { /* Negative infinity. */
1357 my_asnprintf (NULL, &length, "%Lf %d", -1.0L / 0.0L, 33, 44, 55);
1358 ASSERT (result != NULL);
1359 ASSERT (strcmp (result, "-inf 33") == 0
1360 || strcmp (result, "-infinity 33") == 0);
1361 ASSERT (length == strlen (result));
1366 static long double zero = 0.0L;
1369 my_asnprintf (NULL, &length, "%Lf %d", zero / zero, 33, 44, 55);
1370 ASSERT (result != NULL);
1371 ASSERT (strlen (result) >= 3 + 3
1372 && strisnan (result, 0, strlen (result) - 3, 0)
1373 && strcmp (result + strlen (result) - 3, " 33") == 0);
1374 ASSERT (length == strlen (result));
1377 #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_))
1379 static union { unsigned int word[4]; long double value; } x =
1380 { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
1383 my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55);
1384 ASSERT (result != NULL);
1385 ASSERT (strlen (result) >= 3 + 3
1386 && strisnan (result, 0, strlen (result) - 3, 0)
1387 && strcmp (result + strlen (result) - 3, " 33") == 0);
1388 ASSERT (length == strlen (result));
1392 /* Signalling NaN. */
1393 static union { unsigned int word[4]; long double value; } x =
1394 { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
1397 my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55);
1398 ASSERT (result != NULL);
1399 ASSERT (strlen (result) >= 3 + 3
1400 && strisnan (result, 0, strlen (result) - 3, 0)
1401 && strcmp (result + strlen (result) - 3, " 33") == 0);
1402 ASSERT (length == strlen (result));
1405 /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
1406 Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
1407 Intel IA-64 Architecture Software Developer's Manual, Volume 1:
1408 Application Architecture.
1409 Table 5-2 "Floating-Point Register Encodings"
1410 Figure 5-6 "Memory to Floating-Point Register Data Translation"
1413 static union { unsigned int word[4]; long double value; } x =
1414 { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
1417 my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55);
1418 ASSERT (result != NULL);
1419 ASSERT (strlen (result) >= 3 + 3
1420 && strisnan (result, 0, strlen (result) - 3, 0)
1421 && strcmp (result + strlen (result) - 3, " 33") == 0);
1422 ASSERT (length == strlen (result));
1425 { /* Pseudo-Infinity. */
1426 static union { unsigned int word[4]; long double value; } x =
1427 { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
1430 my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55);
1431 ASSERT (result != NULL);
1432 ASSERT (strlen (result) >= 3 + 3
1433 && strisnan (result, 0, strlen (result) - 3, 0)
1434 && strcmp (result + strlen (result) - 3, " 33") == 0);
1435 ASSERT (length == strlen (result));
1438 { /* Pseudo-Zero. */
1439 static union { unsigned int word[4]; long double value; } x =
1440 { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
1443 my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55);
1444 ASSERT (result != NULL);
1445 ASSERT (strlen (result) >= 3 + 3
1446 && strisnan (result, 0, strlen (result) - 3, 0)
1447 && strcmp (result + strlen (result) - 3, " 33") == 0);
1448 ASSERT (length == strlen (result));
1451 { /* Unnormalized number. */
1452 static union { unsigned int word[4]; long double value; } x =
1453 { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
1456 my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55);
1457 ASSERT (result != NULL);
1458 ASSERT (strlen (result) >= 3 + 3
1459 && strisnan (result, 0, strlen (result) - 3, 0)
1460 && strcmp (result + strlen (result) - 3, " 33") == 0);
1461 ASSERT (length == strlen (result));
1464 { /* Pseudo-Denormal. */
1465 static union { unsigned int word[4]; long double value; } x =
1466 { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
1469 my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55);
1470 ASSERT (result != NULL);
1471 ASSERT (strlen (result) >= 3 + 3
1472 && strisnan (result, 0, strlen (result) - 3, 0)
1473 && strcmp (result + strlen (result) - 3, " 33") == 0);
1474 ASSERT (length == strlen (result));
1482 my_asnprintf (NULL, &length, "%10Lf %d", 1.75L, 33, 44, 55);
1483 ASSERT (result != NULL);
1484 ASSERT (strcmp (result, " 1.750000 33") == 0);
1485 ASSERT (length == strlen (result));
1492 my_asnprintf (NULL, &length, "%-10Lf %d", 1.75L, 33, 44, 55);
1493 ASSERT (result != NULL);
1494 ASSERT (strcmp (result, "1.750000 33") == 0);
1495 ASSERT (length == strlen (result));
1499 { /* FLAG_SHOWSIGN. */
1502 my_asnprintf (NULL, &length, "%+Lf %d", 1.75L, 33, 44, 55);
1503 ASSERT (result != NULL);
1504 ASSERT (strcmp (result, "+1.750000 33") == 0);
1505 ASSERT (length == strlen (result));
1512 my_asnprintf (NULL, &length, "% Lf %d", 1.75L, 33, 44, 55);
1513 ASSERT (result != NULL);
1514 ASSERT (strcmp (result, " 1.750000 33") == 0);
1515 ASSERT (length == strlen (result));
1522 my_asnprintf (NULL, &length, "%#Lf %d", 1.75L, 33, 44, 55);
1523 ASSERT (result != NULL);
1524 ASSERT (strcmp (result, "1.750000 33") == 0);
1525 ASSERT (length == strlen (result));
1532 my_asnprintf (NULL, &length, "%#.Lf %d", 1.75L, 33, 44, 55);
1533 ASSERT (result != NULL);
1534 ASSERT (strcmp (result, "2. 33") == 0);
1535 ASSERT (length == strlen (result));
1539 { /* FLAG_ZERO with finite number. */
1542 my_asnprintf (NULL, &length, "%015Lf %d", 1234.0L, 33, 44, 55);
1543 ASSERT (result != NULL);
1544 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1545 ASSERT (length == strlen (result));
1549 { /* FLAG_ZERO with infinite number. */
1552 my_asnprintf (NULL, &length, "%015Lf %d", -1.0L / 0.0L, 33, 44, 55);
1553 ASSERT (result != NULL);
1554 ASSERT (strcmp (result, " -inf 33") == 0
1555 || strcmp (result, " -infinity 33") == 0);
1556 ASSERT (length == strlen (result));
1560 { /* FLAG_ZERO with NaN. */
1561 static long double zero = 0.0L;
1564 my_asnprintf (NULL, &length, "%050Lf %d", zero / zero, 33, 44, 55);
1565 ASSERT (result != NULL);
1566 ASSERT (strlen (result) == 50 + 3
1567 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1568 && strcmp (result + strlen (result) - 3, " 33") == 0);
1569 ASSERT (length == strlen (result));
1576 my_asnprintf (NULL, &length, "%.Lf %d", 1234.0L, 33, 44, 55);
1577 ASSERT (result != NULL);
1578 ASSERT (strcmp (result, "1234 33") == 0);
1579 ASSERT (length == strlen (result));
1583 /* Test the support of the %F format directive. */
1585 { /* A positive number. */
1588 my_asnprintf (NULL, &length, "%F %d", 12.75, 33, 44, 55);
1589 ASSERT (result != NULL);
1590 ASSERT (strcmp (result, "12.750000 33") == 0);
1591 ASSERT (length == strlen (result));
1595 { /* A larger positive number. */
1598 my_asnprintf (NULL, &length, "%F %d", 1234567.0, 33, 44, 55);
1599 ASSERT (result != NULL);
1600 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1601 ASSERT (length == strlen (result));
1605 { /* A negative number. */
1608 my_asnprintf (NULL, &length, "%F %d", -0.03125, 33, 44, 55);
1609 ASSERT (result != NULL);
1610 ASSERT (strcmp (result, "-0.031250 33") == 0);
1611 ASSERT (length == strlen (result));
1615 { /* Positive zero. */
1618 my_asnprintf (NULL, &length, "%F %d", 0.0, 33, 44, 55);
1619 ASSERT (result != NULL);
1620 ASSERT (strcmp (result, "0.000000 33") == 0);
1621 ASSERT (length == strlen (result));
1625 { /* Negative zero. */
1628 my_asnprintf (NULL, &length, "%F %d", -0.0, 33, 44, 55);
1629 ASSERT (result != NULL);
1630 if (have_minus_zero ())
1631 ASSERT (strcmp (result, "-0.000000 33") == 0);
1632 ASSERT (length == strlen (result));
1636 { /* Positive infinity. */
1639 my_asnprintf (NULL, &length, "%F %d", 1.0 / 0.0, 33, 44, 55);
1640 ASSERT (result != NULL);
1641 ASSERT (strcmp (result, "INF 33") == 0
1642 || strcmp (result, "INFINITY 33") == 0);
1643 ASSERT (length == strlen (result));
1647 { /* Negative infinity. */
1650 my_asnprintf (NULL, &length, "%F %d", -1.0 / 0.0, 33, 44, 55);
1651 ASSERT (result != NULL);
1652 ASSERT (strcmp (result, "-INF 33") == 0
1653 || strcmp (result, "-INFINITY 33") == 0);
1654 ASSERT (length == strlen (result));
1661 my_asnprintf (NULL, &length, "%F %d", NaN (), 33, 44, 55);
1662 ASSERT (result != NULL);
1663 ASSERT (strlen (result) >= 3 + 3
1664 && strisnan (result, 0, strlen (result) - 3, 1)
1665 && strcmp (result + strlen (result) - 3, " 33") == 0);
1666 ASSERT (length == strlen (result));
1673 my_asnprintf (NULL, &length, "%015F %d", 1234.0, 33, 44, 55);
1674 ASSERT (result != NULL);
1675 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1676 ASSERT (length == strlen (result));
1680 { /* FLAG_ZERO with infinite number. */
1683 my_asnprintf (NULL, &length, "%015F %d", -1.0 / 0.0, 33, 44, 55);
1684 ASSERT (result != NULL);
1685 ASSERT (strcmp (result, " -INF 33") == 0
1686 || strcmp (result, " -INFINITY 33") == 0);
1687 ASSERT (length == strlen (result));
1694 my_asnprintf (NULL, &length, "%.F %d", 1234.0, 33, 44, 55);
1695 ASSERT (result != NULL);
1696 ASSERT (strcmp (result, "1234 33") == 0);
1697 ASSERT (length == strlen (result));
1701 { /* A positive number. */
1704 my_asnprintf (NULL, &length, "%LF %d", 12.75L, 33, 44, 55);
1705 ASSERT (result != NULL);
1706 ASSERT (strcmp (result, "12.750000 33") == 0);
1707 ASSERT (length == strlen (result));
1711 { /* A larger positive number. */
1714 my_asnprintf (NULL, &length, "%LF %d", 1234567.0L, 33, 44, 55);
1715 ASSERT (result != NULL);
1716 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1717 ASSERT (length == strlen (result));
1721 { /* A negative number. */
1724 my_asnprintf (NULL, &length, "%LF %d", -0.03125L, 33, 44, 55);
1725 ASSERT (result != NULL);
1726 ASSERT (strcmp (result, "-0.031250 33") == 0);
1727 ASSERT (length == strlen (result));
1731 { /* Positive zero. */
1734 my_asnprintf (NULL, &length, "%LF %d", 0.0L, 33, 44, 55);
1735 ASSERT (result != NULL);
1736 ASSERT (strcmp (result, "0.000000 33") == 0);
1737 ASSERT (length == strlen (result));
1741 { /* Negative zero. */
1744 my_asnprintf (NULL, &length, "%LF %d", -0.0L, 33, 44, 55);
1745 ASSERT (result != NULL);
1746 if (have_minus_zero ())
1747 ASSERT (strcmp (result, "-0.000000 33") == 0);
1748 ASSERT (length == strlen (result));
1752 { /* Positive infinity. */
1755 my_asnprintf (NULL, &length, "%LF %d", 1.0L / 0.0L, 33, 44, 55);
1756 ASSERT (result != NULL);
1757 ASSERT (strcmp (result, "INF 33") == 0
1758 || strcmp (result, "INFINITY 33") == 0);
1759 ASSERT (length == strlen (result));
1763 { /* Negative infinity. */
1766 my_asnprintf (NULL, &length, "%LF %d", -1.0L / 0.0L, 33, 44, 55);
1767 ASSERT (result != NULL);
1768 ASSERT (strcmp (result, "-INF 33") == 0
1769 || strcmp (result, "-INFINITY 33") == 0);
1770 ASSERT (length == strlen (result));
1775 static long double zero = 0.0L;
1778 my_asnprintf (NULL, &length, "%LF %d", zero / zero, 33, 44, 55);
1779 ASSERT (result != NULL);
1780 ASSERT (strlen (result) >= 3 + 3
1781 && strisnan (result, 0, strlen (result) - 3, 1)
1782 && strcmp (result + strlen (result) - 3, " 33") == 0);
1783 ASSERT (length == strlen (result));
1790 my_asnprintf (NULL, &length, "%015LF %d", 1234.0L, 33, 44, 55);
1791 ASSERT (result != NULL);
1792 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1793 ASSERT (length == strlen (result));
1797 { /* FLAG_ZERO with infinite number. */
1800 my_asnprintf (NULL, &length, "%015LF %d", -1.0L / 0.0L, 33, 44, 55);
1801 ASSERT (result != NULL);
1802 ASSERT (strcmp (result, " -INF 33") == 0
1803 || strcmp (result, " -INFINITY 33") == 0);
1804 ASSERT (length == strlen (result));
1811 my_asnprintf (NULL, &length, "%.LF %d", 1234.0L, 33, 44, 55);
1812 ASSERT (result != NULL);
1813 ASSERT (strcmp (result, "1234 33") == 0);
1814 ASSERT (length == strlen (result));
1818 /* Test the support of the %e format directive. */
1820 { /* A positive number. */
1823 my_asnprintf (NULL, &length, "%e %d", 12.75, 33, 44, 55);
1824 ASSERT (result != NULL);
1825 ASSERT (strcmp (result, "1.275000e+01 33") == 0
1826 || strcmp (result, "1.275000e+001 33") == 0);
1827 ASSERT (length == strlen (result));
1831 { /* A larger positive number. */
1834 my_asnprintf (NULL, &length, "%e %d", 1234567.0, 33, 44, 55);
1835 ASSERT (result != NULL);
1836 ASSERT (strcmp (result, "1.234567e+06 33") == 0
1837 || strcmp (result, "1.234567e+006 33") == 0);
1838 ASSERT (length == strlen (result));
1842 { /* Small and large positive numbers. */
1843 static struct { double value; const char *string; } data[] =
1845 { 1.234321234321234e-37, "1.234321e-37" },
1846 { 1.234321234321234e-36, "1.234321e-36" },
1847 { 1.234321234321234e-35, "1.234321e-35" },
1848 { 1.234321234321234e-34, "1.234321e-34" },
1849 { 1.234321234321234e-33, "1.234321e-33" },
1850 { 1.234321234321234e-32, "1.234321e-32" },
1851 { 1.234321234321234e-31, "1.234321e-31" },
1852 { 1.234321234321234e-30, "1.234321e-30" },
1853 { 1.234321234321234e-29, "1.234321e-29" },
1854 { 1.234321234321234e-28, "1.234321e-28" },
1855 { 1.234321234321234e-27, "1.234321e-27" },
1856 { 1.234321234321234e-26, "1.234321e-26" },
1857 { 1.234321234321234e-25, "1.234321e-25" },
1858 { 1.234321234321234e-24, "1.234321e-24" },
1859 { 1.234321234321234e-23, "1.234321e-23" },
1860 { 1.234321234321234e-22, "1.234321e-22" },
1861 { 1.234321234321234e-21, "1.234321e-21" },
1862 { 1.234321234321234e-20, "1.234321e-20" },
1863 { 1.234321234321234e-19, "1.234321e-19" },
1864 { 1.234321234321234e-18, "1.234321e-18" },
1865 { 1.234321234321234e-17, "1.234321e-17" },
1866 { 1.234321234321234e-16, "1.234321e-16" },
1867 { 1.234321234321234e-15, "1.234321e-15" },
1868 { 1.234321234321234e-14, "1.234321e-14" },
1869 { 1.234321234321234e-13, "1.234321e-13" },
1870 { 1.234321234321234e-12, "1.234321e-12" },
1871 { 1.234321234321234e-11, "1.234321e-11" },
1872 { 1.234321234321234e-10, "1.234321e-10" },
1873 { 1.234321234321234e-9, "1.234321e-09" },
1874 { 1.234321234321234e-8, "1.234321e-08" },
1875 { 1.234321234321234e-7, "1.234321e-07" },
1876 { 1.234321234321234e-6, "1.234321e-06" },
1877 { 1.234321234321234e-5, "1.234321e-05" },
1878 { 1.234321234321234e-4, "1.234321e-04" },
1879 { 1.234321234321234e-3, "1.234321e-03" },
1880 { 1.234321234321234e-2, "1.234321e-02" },
1881 { 1.234321234321234e-1, "1.234321e-01" },
1882 { 1.234321234321234, "1.234321e+00" },
1883 { 1.234321234321234e1, "1.234321e+01" },
1884 { 1.234321234321234e2, "1.234321e+02" },
1885 { 1.234321234321234e3, "1.234321e+03" },
1886 { 1.234321234321234e4, "1.234321e+04" },
1887 { 1.234321234321234e5, "1.234321e+05" },
1888 { 1.234321234321234e6, "1.234321e+06" },
1889 { 1.234321234321234e7, "1.234321e+07" },
1890 { 1.234321234321234e8, "1.234321e+08" },
1891 { 1.234321234321234e9, "1.234321e+09" },
1892 { 1.234321234321234e10, "1.234321e+10" },
1893 { 1.234321234321234e11, "1.234321e+11" },
1894 { 1.234321234321234e12, "1.234321e+12" },
1895 { 1.234321234321234e13, "1.234321e+13" },
1896 { 1.234321234321234e14, "1.234321e+14" },
1897 { 1.234321234321234e15, "1.234321e+15" },
1898 { 1.234321234321234e16, "1.234321e+16" },
1899 { 1.234321234321234e17, "1.234321e+17" },
1900 { 1.234321234321234e18, "1.234321e+18" },
1901 { 1.234321234321234e19, "1.234321e+19" },
1902 { 1.234321234321234e20, "1.234321e+20" },
1903 { 1.234321234321234e21, "1.234321e+21" },
1904 { 1.234321234321234e22, "1.234321e+22" },
1905 { 1.234321234321234e23, "1.234321e+23" },
1906 { 1.234321234321234e24, "1.234321e+24" },
1907 { 1.234321234321234e25, "1.234321e+25" },
1908 { 1.234321234321234e26, "1.234321e+26" },
1909 { 1.234321234321234e27, "1.234321e+27" },
1910 { 1.234321234321234e28, "1.234321e+28" },
1911 { 1.234321234321234e29, "1.234321e+29" },
1912 { 1.234321234321234e30, "1.234321e+30" },
1913 { 1.234321234321234e31, "1.234321e+31" },
1914 { 1.234321234321234e32, "1.234321e+32" },
1915 { 1.234321234321234e33, "1.234321e+33" },
1916 { 1.234321234321234e34, "1.234321e+34" },
1917 { 1.234321234321234e35, "1.234321e+35" },
1918 { 1.234321234321234e36, "1.234321e+36" }
1921 for (k = 0; k < SIZEOF (data); k++)
1925 my_asnprintf (NULL, &length, "%e", data[k].value);
1926 const char *expected = data[k].string;
1927 ASSERT (result != NULL);
1928 ASSERT (strcmp (result, expected) == 0
1929 /* Some implementations produce exponents with 3 digits. */
1930 || (strlen (result) == strlen (expected) + 1
1931 && memcmp (result, expected, strlen (expected) - 2) == 0
1932 && result[strlen (expected) - 2] == '0'
1933 && strcmp (result + strlen (expected) - 1,
1934 expected + strlen (expected) - 2)
1936 ASSERT (length == strlen (result));
1941 { /* A negative number. */
1944 my_asnprintf (NULL, &length, "%e %d", -0.03125, 33, 44, 55);
1945 ASSERT (result != NULL);
1946 ASSERT (strcmp (result, "-3.125000e-02 33") == 0
1947 || strcmp (result, "-3.125000e-002 33") == 0);
1948 ASSERT (length == strlen (result));
1952 { /* Positive zero. */
1955 my_asnprintf (NULL, &length, "%e %d", 0.0, 33, 44, 55);
1956 ASSERT (result != NULL);
1957 ASSERT (strcmp (result, "0.000000e+00 33") == 0
1958 || strcmp (result, "0.000000e+000 33") == 0);
1959 ASSERT (length == strlen (result));
1963 { /* Negative zero. */
1966 my_asnprintf (NULL, &length, "%e %d", -0.0, 33, 44, 55);
1967 ASSERT (result != NULL);
1968 if (have_minus_zero ())
1969 ASSERT (strcmp (result, "-0.000000e+00 33") == 0
1970 || strcmp (result, "-0.000000e+000 33") == 0);
1971 ASSERT (length == strlen (result));
1975 { /* Positive infinity. */
1978 my_asnprintf (NULL, &length, "%e %d", 1.0 / 0.0, 33, 44, 55);
1979 ASSERT (result != NULL);
1980 ASSERT (strcmp (result, "inf 33") == 0
1981 || strcmp (result, "infinity 33") == 0);
1982 ASSERT (length == strlen (result));
1986 { /* Negative infinity. */
1989 my_asnprintf (NULL, &length, "%e %d", -1.0 / 0.0, 33, 44, 55);
1990 ASSERT (result != NULL);
1991 ASSERT (strcmp (result, "-inf 33") == 0
1992 || strcmp (result, "-infinity 33") == 0);
1993 ASSERT (length == strlen (result));
2000 my_asnprintf (NULL, &length, "%e %d", NaN (), 33, 44, 55);
2001 ASSERT (result != NULL);
2002 ASSERT (strlen (result) >= 3 + 3
2003 && strisnan (result, 0, strlen (result) - 3, 0)
2004 && strcmp (result + strlen (result) - 3, " 33") == 0);
2005 ASSERT (length == strlen (result));
2012 my_asnprintf (NULL, &length, "%15e %d", 1.75, 33, 44, 55);
2013 ASSERT (result != NULL);
2014 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
2015 || strcmp (result, " 1.750000e+000 33") == 0);
2016 ASSERT (length == strlen (result));
2023 my_asnprintf (NULL, &length, "%-15e %d", 1.75, 33, 44, 55);
2024 ASSERT (result != NULL);
2025 ASSERT (strcmp (result, "1.750000e+00 33") == 0
2026 || strcmp (result, "1.750000e+000 33") == 0);
2027 ASSERT (length == strlen (result));
2031 { /* FLAG_SHOWSIGN. */
2034 my_asnprintf (NULL, &length, "%+e %d", 1.75, 33, 44, 55);
2035 ASSERT (result != NULL);
2036 ASSERT (strcmp (result, "+1.750000e+00 33") == 0
2037 || strcmp (result, "+1.750000e+000 33") == 0);
2038 ASSERT (length == strlen (result));
2045 my_asnprintf (NULL, &length, "% e %d", 1.75, 33, 44, 55);
2046 ASSERT (result != NULL);
2047 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
2048 || strcmp (result, " 1.750000e+000 33") == 0);
2049 ASSERT (length == strlen (result));
2056 my_asnprintf (NULL, &length, "%#e %d", 1.75, 33, 44, 55);
2057 ASSERT (result != NULL);
2058 ASSERT (strcmp (result, "1.750000e+00 33") == 0
2059 || strcmp (result, "1.750000e+000 33") == 0);
2060 ASSERT (length == strlen (result));
2067 my_asnprintf (NULL, &length, "%#.e %d", 1.75, 33, 44, 55);
2068 ASSERT (result != NULL);
2069 ASSERT (strcmp (result, "2.e+00 33") == 0
2070 || strcmp (result, "2.e+000 33") == 0);
2071 ASSERT (length == strlen (result));
2078 my_asnprintf (NULL, &length, "%#.e %d", 9.75, 33, 44, 55);
2079 ASSERT (result != NULL);
2080 ASSERT (strcmp (result, "1.e+01 33") == 0
2081 || strcmp (result, "1.e+001 33") == 0);
2082 ASSERT (length == strlen (result));
2086 { /* FLAG_ZERO with finite number. */
2089 my_asnprintf (NULL, &length, "%015e %d", 1234.0, 33, 44, 55);
2090 ASSERT (result != NULL);
2091 ASSERT (strcmp (result, "0001.234000e+03 33") == 0
2092 || strcmp (result, "001.234000e+003 33") == 0);
2093 ASSERT (length == strlen (result));
2097 { /* FLAG_ZERO with infinite number. */
2100 my_asnprintf (NULL, &length, "%015e %d", -1.0 / 0.0, 33, 44, 55);
2101 ASSERT (result != NULL);
2102 ASSERT (strcmp (result, " -inf 33") == 0
2103 || strcmp (result, " -infinity 33") == 0);
2104 ASSERT (length == strlen (result));
2108 { /* FLAG_ZERO with NaN. */
2111 my_asnprintf (NULL, &length, "%050e %d", NaN (), 33, 44, 55);
2112 ASSERT (result != NULL);
2113 ASSERT (strlen (result) == 50 + 3
2114 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2115 && strcmp (result + strlen (result) - 3, " 33") == 0);
2116 ASSERT (length == strlen (result));
2123 my_asnprintf (NULL, &length, "%.e %d", 1234.0, 33, 44, 55);
2124 ASSERT (result != NULL);
2125 ASSERT (strcmp (result, "1e+03 33") == 0
2126 || strcmp (result, "1e+003 33") == 0);
2127 ASSERT (length == strlen (result));
2131 { /* A positive number. */
2134 my_asnprintf (NULL, &length, "%Le %d", 12.75L, 33, 44, 55);
2135 ASSERT (result != NULL);
2136 ASSERT (strcmp (result, "1.275000e+01 33") == 0);
2137 ASSERT (length == strlen (result));
2141 { /* A larger positive number. */
2144 my_asnprintf (NULL, &length, "%Le %d", 1234567.0L, 33, 44, 55);
2145 ASSERT (result != NULL);
2146 ASSERT (strcmp (result, "1.234567e+06 33") == 0);
2147 ASSERT (length == strlen (result));
2151 { /* Small and large positive numbers. */
2152 static struct { long double value; const char *string; } data[] =
2154 { 1.234321234321234e-37L, "1.234321e-37" },
2155 { 1.234321234321234e-36L, "1.234321e-36" },
2156 { 1.234321234321234e-35L, "1.234321e-35" },
2157 { 1.234321234321234e-34L, "1.234321e-34" },
2158 { 1.234321234321234e-33L, "1.234321e-33" },
2159 { 1.234321234321234e-32L, "1.234321e-32" },
2160 { 1.234321234321234e-31L, "1.234321e-31" },
2161 { 1.234321234321234e-30L, "1.234321e-30" },
2162 { 1.234321234321234e-29L, "1.234321e-29" },
2163 { 1.234321234321234e-28L, "1.234321e-28" },
2164 { 1.234321234321234e-27L, "1.234321e-27" },
2165 { 1.234321234321234e-26L, "1.234321e-26" },
2166 { 1.234321234321234e-25L, "1.234321e-25" },
2167 { 1.234321234321234e-24L, "1.234321e-24" },
2168 { 1.234321234321234e-23L, "1.234321e-23" },
2169 { 1.234321234321234e-22L, "1.234321e-22" },
2170 { 1.234321234321234e-21L, "1.234321e-21" },
2171 { 1.234321234321234e-20L, "1.234321e-20" },
2172 { 1.234321234321234e-19L, "1.234321e-19" },
2173 { 1.234321234321234e-18L, "1.234321e-18" },
2174 { 1.234321234321234e-17L, "1.234321e-17" },
2175 { 1.234321234321234e-16L, "1.234321e-16" },
2176 { 1.234321234321234e-15L, "1.234321e-15" },
2177 { 1.234321234321234e-14L, "1.234321e-14" },
2178 { 1.234321234321234e-13L, "1.234321e-13" },
2179 { 1.234321234321234e-12L, "1.234321e-12" },
2180 { 1.234321234321234e-11L, "1.234321e-11" },
2181 { 1.234321234321234e-10L, "1.234321e-10" },
2182 { 1.234321234321234e-9L, "1.234321e-09" },
2183 { 1.234321234321234e-8L, "1.234321e-08" },
2184 { 1.234321234321234e-7L, "1.234321e-07" },
2185 { 1.234321234321234e-6L, "1.234321e-06" },
2186 { 1.234321234321234e-5L, "1.234321e-05" },
2187 { 1.234321234321234e-4L, "1.234321e-04" },
2188 { 1.234321234321234e-3L, "1.234321e-03" },
2189 { 1.234321234321234e-2L, "1.234321e-02" },
2190 { 1.234321234321234e-1L, "1.234321e-01" },
2191 { 1.234321234321234L, "1.234321e+00" },
2192 { 1.234321234321234e1L, "1.234321e+01" },
2193 { 1.234321234321234e2L, "1.234321e+02" },
2194 { 1.234321234321234e3L, "1.234321e+03" },
2195 { 1.234321234321234e4L, "1.234321e+04" },
2196 { 1.234321234321234e5L, "1.234321e+05" },
2197 { 1.234321234321234e6L, "1.234321e+06" },
2198 { 1.234321234321234e7L, "1.234321e+07" },
2199 { 1.234321234321234e8L, "1.234321e+08" },
2200 { 1.234321234321234e9L, "1.234321e+09" },
2201 { 1.234321234321234e10L, "1.234321e+10" },
2202 { 1.234321234321234e11L, "1.234321e+11" },
2203 { 1.234321234321234e12L, "1.234321e+12" },
2204 { 1.234321234321234e13L, "1.234321e+13" },
2205 { 1.234321234321234e14L, "1.234321e+14" },
2206 { 1.234321234321234e15L, "1.234321e+15" },
2207 { 1.234321234321234e16L, "1.234321e+16" },
2208 { 1.234321234321234e17L, "1.234321e+17" },
2209 { 1.234321234321234e18L, "1.234321e+18" },
2210 { 1.234321234321234e19L, "1.234321e+19" },
2211 { 1.234321234321234e20L, "1.234321e+20" },
2212 { 1.234321234321234e21L, "1.234321e+21" },
2213 { 1.234321234321234e22L, "1.234321e+22" },
2214 { 1.234321234321234e23L, "1.234321e+23" },
2215 { 1.234321234321234e24L, "1.234321e+24" },
2216 { 1.234321234321234e25L, "1.234321e+25" },
2217 { 1.234321234321234e26L, "1.234321e+26" },
2218 { 1.234321234321234e27L, "1.234321e+27" },
2219 { 1.234321234321234e28L, "1.234321e+28" },
2220 { 1.234321234321234e29L, "1.234321e+29" },
2221 { 1.234321234321234e30L, "1.234321e+30" },
2222 { 1.234321234321234e31L, "1.234321e+31" },
2223 { 1.234321234321234e32L, "1.234321e+32" },
2224 { 1.234321234321234e33L, "1.234321e+33" },
2225 { 1.234321234321234e34L, "1.234321e+34" },
2226 { 1.234321234321234e35L, "1.234321e+35" },
2227 { 1.234321234321234e36L, "1.234321e+36" }
2230 for (k = 0; k < SIZEOF (data); k++)
2234 my_asnprintf (NULL, &length, "%Le", data[k].value);
2235 ASSERT (result != NULL);
2236 ASSERT (strcmp (result, data[k].string) == 0);
2237 ASSERT (length == strlen (result));
2242 { /* A negative number. */
2245 my_asnprintf (NULL, &length, "%Le %d", -0.03125L, 33, 44, 55);
2246 ASSERT (result != NULL);
2247 ASSERT (strcmp (result, "-3.125000e-02 33") == 0);
2248 ASSERT (length == strlen (result));
2252 { /* Positive zero. */
2255 my_asnprintf (NULL, &length, "%Le %d", 0.0L, 33, 44, 55);
2256 ASSERT (result != NULL);
2257 ASSERT (strcmp (result, "0.000000e+00 33") == 0);
2258 ASSERT (length == strlen (result));
2262 { /* Negative zero. */
2265 my_asnprintf (NULL, &length, "%Le %d", -0.0L, 33, 44, 55);
2266 ASSERT (result != NULL);
2267 if (have_minus_zero ())
2268 ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
2269 ASSERT (length == strlen (result));
2273 { /* Positive infinity. */
2276 my_asnprintf (NULL, &length, "%Le %d", 1.0L / 0.0L, 33, 44, 55);
2277 ASSERT (result != NULL);
2278 ASSERT (strcmp (result, "inf 33") == 0
2279 || strcmp (result, "infinity 33") == 0);
2280 ASSERT (length == strlen (result));
2284 { /* Negative infinity. */
2287 my_asnprintf (NULL, &length, "%Le %d", -1.0L / 0.0L, 33, 44, 55);
2288 ASSERT (result != NULL);
2289 ASSERT (strcmp (result, "-inf 33") == 0
2290 || strcmp (result, "-infinity 33") == 0);
2291 ASSERT (length == strlen (result));
2296 static long double zero = 0.0L;
2299 my_asnprintf (NULL, &length, "%Le %d", zero / zero, 33, 44, 55);
2300 ASSERT (result != NULL);
2301 ASSERT (strlen (result) >= 3 + 3
2302 && strisnan (result, 0, strlen (result) - 3, 0)
2303 && strcmp (result + strlen (result) - 3, " 33") == 0);
2304 ASSERT (length == strlen (result));
2307 #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_))
2309 static union { unsigned int word[4]; long double value; } x =
2310 { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
2313 my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55);
2314 ASSERT (result != NULL);
2315 ASSERT (strlen (result) >= 3 + 3
2316 && strisnan (result, 0, strlen (result) - 3, 0)
2317 && strcmp (result + strlen (result) - 3, " 33") == 0);
2318 ASSERT (length == strlen (result));
2322 /* Signalling NaN. */
2323 static union { unsigned int word[4]; long double value; } x =
2324 { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
2327 my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55);
2328 ASSERT (result != NULL);
2329 ASSERT (strlen (result) >= 3 + 3
2330 && strisnan (result, 0, strlen (result) - 3, 0)
2331 && strcmp (result + strlen (result) - 3, " 33") == 0);
2332 ASSERT (length == strlen (result));
2335 /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
2336 Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
2337 Intel IA-64 Architecture Software Developer's Manual, Volume 1:
2338 Application Architecture.
2339 Table 5-2 "Floating-Point Register Encodings"
2340 Figure 5-6 "Memory to Floating-Point Register Data Translation"
2343 static union { unsigned int word[4]; long double value; } x =
2344 { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
2347 my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55);
2348 ASSERT (result != NULL);
2349 ASSERT (strlen (result) >= 3 + 3
2350 && strisnan (result, 0, strlen (result) - 3, 0)
2351 && strcmp (result + strlen (result) - 3, " 33") == 0);
2352 ASSERT (length == strlen (result));
2355 { /* Pseudo-Infinity. */
2356 static union { unsigned int word[4]; long double value; } x =
2357 { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
2360 my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55);
2361 ASSERT (result != NULL);
2362 ASSERT (strlen (result) >= 3 + 3
2363 && strisnan (result, 0, strlen (result) - 3, 0)
2364 && strcmp (result + strlen (result) - 3, " 33") == 0);
2365 ASSERT (length == strlen (result));
2368 { /* Pseudo-Zero. */
2369 static union { unsigned int word[4]; long double value; } x =
2370 { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
2373 my_asnprintf (NULL, &length, "%Le %d", x.value, 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 (length == strlen (result));
2381 { /* Unnormalized number. */
2382 static union { unsigned int word[4]; long double value; } x =
2383 { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
2386 my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55);
2387 ASSERT (result != NULL);
2388 ASSERT (strlen (result) >= 3 + 3
2389 && strisnan (result, 0, strlen (result) - 3, 0)
2390 && strcmp (result + strlen (result) - 3, " 33") == 0);
2391 ASSERT (length == strlen (result));
2394 { /* Pseudo-Denormal. */
2395 static union { unsigned int word[4]; long double value; } x =
2396 { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
2399 my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55);
2400 ASSERT (result != NULL);
2401 ASSERT (strlen (result) >= 3 + 3
2402 && strisnan (result, 0, strlen (result) - 3, 0)
2403 && strcmp (result + strlen (result) - 3, " 33") == 0);
2404 ASSERT (length == strlen (result));
2412 my_asnprintf (NULL, &length, "%15Le %d", 1.75L, 33, 44, 55);
2413 ASSERT (result != NULL);
2414 ASSERT (strcmp (result, " 1.750000e+00 33") == 0);
2415 ASSERT (length == strlen (result));
2422 my_asnprintf (NULL, &length, "%-15Le %d", 1.75L, 33, 44, 55);
2423 ASSERT (result != NULL);
2424 ASSERT (strcmp (result, "1.750000e+00 33") == 0);
2425 ASSERT (length == strlen (result));
2429 { /* FLAG_SHOWSIGN. */
2432 my_asnprintf (NULL, &length, "%+Le %d", 1.75L, 33, 44, 55);
2433 ASSERT (result != NULL);
2434 ASSERT (strcmp (result, "+1.750000e+00 33") == 0);
2435 ASSERT (length == strlen (result));
2442 my_asnprintf (NULL, &length, "% Le %d", 1.75L, 33, 44, 55);
2443 ASSERT (result != NULL);
2444 ASSERT (strcmp (result, " 1.750000e+00 33") == 0);
2445 ASSERT (length == strlen (result));
2452 my_asnprintf (NULL, &length, "%#Le %d", 1.75L, 33, 44, 55);
2453 ASSERT (result != NULL);
2454 ASSERT (strcmp (result, "1.750000e+00 33") == 0);
2455 ASSERT (length == strlen (result));
2462 my_asnprintf (NULL, &length, "%#.Le %d", 1.75L, 33, 44, 55);
2463 ASSERT (result != NULL);
2464 ASSERT (strcmp (result, "2.e+00 33") == 0);
2465 ASSERT (length == strlen (result));
2472 my_asnprintf (NULL, &length, "%#.Le %d", 9.75L, 33, 44, 55);
2473 ASSERT (result != NULL);
2474 ASSERT (strcmp (result, "1.e+01 33") == 0);
2475 ASSERT (length == strlen (result));
2479 { /* FLAG_ZERO with finite number. */
2482 my_asnprintf (NULL, &length, "%015Le %d", 1234.0L, 33, 44, 55);
2483 ASSERT (result != NULL);
2484 ASSERT (strcmp (result, "0001.234000e+03 33") == 0);
2485 ASSERT (length == strlen (result));
2489 { /* FLAG_ZERO with infinite number. */
2492 my_asnprintf (NULL, &length, "%015Le %d", -1.0L / 0.0L, 33, 44, 55);
2493 ASSERT (result != NULL);
2494 ASSERT (strcmp (result, " -inf 33") == 0
2495 || strcmp (result, " -infinity 33") == 0);
2496 ASSERT (length == strlen (result));
2500 { /* FLAG_ZERO with NaN. */
2501 static long double zero = 0.0L;
2504 my_asnprintf (NULL, &length, "%050Le %d", zero / zero, 33, 44, 55);
2505 ASSERT (result != NULL);
2506 ASSERT (strlen (result) == 50 + 3
2507 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2508 && strcmp (result + strlen (result) - 3, " 33") == 0);
2509 ASSERT (length == strlen (result));
2516 my_asnprintf (NULL, &length, "%.Le %d", 1234.0L, 33, 44, 55);
2517 ASSERT (result != NULL);
2518 ASSERT (strcmp (result, "1e+03 33") == 0);
2519 ASSERT (length == strlen (result));
2523 /* Test the support of the %g format directive. */
2525 { /* A positive number. */
2528 my_asnprintf (NULL, &length, "%g %d", 12.75, 33, 44, 55);
2529 ASSERT (result != NULL);
2530 ASSERT (strcmp (result, "12.75 33") == 0);
2531 ASSERT (length == strlen (result));
2535 { /* A larger positive number. */
2538 my_asnprintf (NULL, &length, "%g %d", 1234567.0, 33, 44, 55);
2539 ASSERT (result != NULL);
2540 ASSERT (strcmp (result, "1.23457e+06 33") == 0
2541 || strcmp (result, "1.23457e+006 33") == 0);
2542 ASSERT (length == strlen (result));
2546 { /* Small and large positive numbers. */
2547 static struct { double value; const char *string; } data[] =
2549 { 1.234321234321234e-37, "1.23432e-37" },
2550 { 1.234321234321234e-36, "1.23432e-36" },
2551 { 1.234321234321234e-35, "1.23432e-35" },
2552 { 1.234321234321234e-34, "1.23432e-34" },
2553 { 1.234321234321234e-33, "1.23432e-33" },
2554 { 1.234321234321234e-32, "1.23432e-32" },
2555 { 1.234321234321234e-31, "1.23432e-31" },
2556 { 1.234321234321234e-30, "1.23432e-30" },
2557 { 1.234321234321234e-29, "1.23432e-29" },
2558 { 1.234321234321234e-28, "1.23432e-28" },
2559 { 1.234321234321234e-27, "1.23432e-27" },
2560 { 1.234321234321234e-26, "1.23432e-26" },
2561 { 1.234321234321234e-25, "1.23432e-25" },
2562 { 1.234321234321234e-24, "1.23432e-24" },
2563 { 1.234321234321234e-23, "1.23432e-23" },
2564 { 1.234321234321234e-22, "1.23432e-22" },
2565 { 1.234321234321234e-21, "1.23432e-21" },
2566 { 1.234321234321234e-20, "1.23432e-20" },
2567 { 1.234321234321234e-19, "1.23432e-19" },
2568 { 1.234321234321234e-18, "1.23432e-18" },
2569 { 1.234321234321234e-17, "1.23432e-17" },
2570 { 1.234321234321234e-16, "1.23432e-16" },
2571 { 1.234321234321234e-15, "1.23432e-15" },
2572 { 1.234321234321234e-14, "1.23432e-14" },
2573 { 1.234321234321234e-13, "1.23432e-13" },
2574 { 1.234321234321234e-12, "1.23432e-12" },
2575 { 1.234321234321234e-11, "1.23432e-11" },
2576 { 1.234321234321234e-10, "1.23432e-10" },
2577 { 1.234321234321234e-9, "1.23432e-09" },
2578 { 1.234321234321234e-8, "1.23432e-08" },
2579 { 1.234321234321234e-7, "1.23432e-07" },
2580 { 1.234321234321234e-6, "1.23432e-06" },
2581 { 1.234321234321234e-5, "1.23432e-05" },
2582 { 1.234321234321234e-4, "0.000123432" },
2583 { 1.234321234321234e-3, "0.00123432" },
2584 { 1.234321234321234e-2, "0.0123432" },
2585 { 1.234321234321234e-1, "0.123432" },
2586 { 1.234321234321234, "1.23432" },
2587 { 1.234321234321234e1, "12.3432" },
2588 { 1.234321234321234e2, "123.432" },
2589 { 1.234321234321234e3, "1234.32" },
2590 { 1.234321234321234e4, "12343.2" },
2591 { 1.234321234321234e5, "123432" },
2592 { 1.234321234321234e6, "1.23432e+06" },
2593 { 1.234321234321234e7, "1.23432e+07" },
2594 { 1.234321234321234e8, "1.23432e+08" },
2595 { 1.234321234321234e9, "1.23432e+09" },
2596 { 1.234321234321234e10, "1.23432e+10" },
2597 { 1.234321234321234e11, "1.23432e+11" },
2598 { 1.234321234321234e12, "1.23432e+12" },
2599 { 1.234321234321234e13, "1.23432e+13" },
2600 { 1.234321234321234e14, "1.23432e+14" },
2601 { 1.234321234321234e15, "1.23432e+15" },
2602 { 1.234321234321234e16, "1.23432e+16" },
2603 { 1.234321234321234e17, "1.23432e+17" },
2604 { 1.234321234321234e18, "1.23432e+18" },
2605 { 1.234321234321234e19, "1.23432e+19" },
2606 { 1.234321234321234e20, "1.23432e+20" },
2607 { 1.234321234321234e21, "1.23432e+21" },
2608 { 1.234321234321234e22, "1.23432e+22" },
2609 { 1.234321234321234e23, "1.23432e+23" },
2610 { 1.234321234321234e24, "1.23432e+24" },
2611 { 1.234321234321234e25, "1.23432e+25" },
2612 { 1.234321234321234e26, "1.23432e+26" },
2613 { 1.234321234321234e27, "1.23432e+27" },
2614 { 1.234321234321234e28, "1.23432e+28" },
2615 { 1.234321234321234e29, "1.23432e+29" },
2616 { 1.234321234321234e30, "1.23432e+30" },
2617 { 1.234321234321234e31, "1.23432e+31" },
2618 { 1.234321234321234e32, "1.23432e+32" },
2619 { 1.234321234321234e33, "1.23432e+33" },
2620 { 1.234321234321234e34, "1.23432e+34" },
2621 { 1.234321234321234e35, "1.23432e+35" },
2622 { 1.234321234321234e36, "1.23432e+36" }
2625 for (k = 0; k < SIZEOF (data); k++)
2629 my_asnprintf (NULL, &length, "%g", data[k].value);
2630 const char *expected = data[k].string;
2631 ASSERT (result != NULL);
2632 ASSERT (strcmp (result, expected) == 0
2633 /* Some implementations produce exponents with 3 digits. */
2634 || (expected[strlen (expected) - 4] == 'e'
2635 && strlen (result) == strlen (expected) + 1
2636 && memcmp (result, expected, strlen (expected) - 2) == 0
2637 && result[strlen (expected) - 2] == '0'
2638 && strcmp (result + strlen (expected) - 1,
2639 expected + strlen (expected) - 2)
2641 ASSERT (length == strlen (result));
2646 { /* A negative number. */
2649 my_asnprintf (NULL, &length, "%g %d", -0.03125, 33, 44, 55);
2650 ASSERT (result != NULL);
2651 ASSERT (strcmp (result, "-0.03125 33") == 0);
2652 ASSERT (length == strlen (result));
2656 { /* Positive zero. */
2659 my_asnprintf (NULL, &length, "%g %d", 0.0, 33, 44, 55);
2660 ASSERT (result != NULL);
2661 ASSERT (strcmp (result, "0 33") == 0);
2662 ASSERT (length == strlen (result));
2666 { /* Negative zero. */
2669 my_asnprintf (NULL, &length, "%g %d", -0.0, 33, 44, 55);
2670 ASSERT (result != NULL);
2671 if (have_minus_zero ())
2672 ASSERT (strcmp (result, "-0 33") == 0);
2673 ASSERT (length == strlen (result));
2677 { /* Positive infinity. */
2680 my_asnprintf (NULL, &length, "%g %d", 1.0 / 0.0, 33, 44, 55);
2681 ASSERT (result != NULL);
2682 ASSERT (strcmp (result, "inf 33") == 0
2683 || strcmp (result, "infinity 33") == 0);
2684 ASSERT (length == strlen (result));
2688 { /* Negative infinity. */
2691 my_asnprintf (NULL, &length, "%g %d", -1.0 / 0.0, 33, 44, 55);
2692 ASSERT (result != NULL);
2693 ASSERT (strcmp (result, "-inf 33") == 0
2694 || strcmp (result, "-infinity 33") == 0);
2695 ASSERT (length == strlen (result));
2702 my_asnprintf (NULL, &length, "%g %d", NaN (), 33, 44, 55);
2703 ASSERT (result != NULL);
2704 ASSERT (strlen (result) >= 3 + 3
2705 && strisnan (result, 0, strlen (result) - 3, 0)
2706 && strcmp (result + strlen (result) - 3, " 33") == 0);
2707 ASSERT (length == strlen (result));
2714 my_asnprintf (NULL, &length, "%10g %d", 1.75, 33, 44, 55);
2715 ASSERT (result != NULL);
2716 ASSERT (strcmp (result, " 1.75 33") == 0);
2717 ASSERT (length == strlen (result));
2724 my_asnprintf (NULL, &length, "%-10g %d", 1.75, 33, 44, 55);
2725 ASSERT (result != NULL);
2726 ASSERT (strcmp (result, "1.75 33") == 0);
2727 ASSERT (length == strlen (result));
2731 { /* FLAG_SHOWSIGN. */
2734 my_asnprintf (NULL, &length, "%+g %d", 1.75, 33, 44, 55);
2735 ASSERT (result != NULL);
2736 ASSERT (strcmp (result, "+1.75 33") == 0);
2737 ASSERT (length == strlen (result));
2744 my_asnprintf (NULL, &length, "% g %d", 1.75, 33, 44, 55);
2745 ASSERT (result != NULL);
2746 ASSERT (strcmp (result, " 1.75 33") == 0);
2747 ASSERT (length == strlen (result));
2754 my_asnprintf (NULL, &length, "%#g %d", 1.75, 33, 44, 55);
2755 ASSERT (result != NULL);
2756 ASSERT (strcmp (result, "1.75000 33") == 0);
2757 ASSERT (length == strlen (result));
2764 my_asnprintf (NULL, &length, "%#.g %d", 1.75, 33, 44, 55);
2765 ASSERT (result != NULL);
2766 ASSERT (strcmp (result, "2. 33") == 0);
2767 ASSERT (length == strlen (result));
2774 my_asnprintf (NULL, &length, "%#.g %d", 9.75, 33, 44, 55);
2775 ASSERT (result != NULL);
2776 ASSERT (strcmp (result, "1.e+01 33") == 0
2777 || strcmp (result, "1.e+001 33") == 0);
2778 ASSERT (length == strlen (result));
2782 { /* FLAG_ZERO with finite number. */
2785 my_asnprintf (NULL, &length, "%010g %d", 1234.0, 33, 44, 55);
2786 ASSERT (result != NULL);
2787 ASSERT (strcmp (result, "0000001234 33") == 0);
2788 ASSERT (length == strlen (result));
2792 { /* FLAG_ZERO with infinite number. */
2795 my_asnprintf (NULL, &length, "%015g %d", -1.0 / 0.0, 33, 44, 55);
2796 ASSERT (result != NULL);
2797 ASSERT (strcmp (result, " -inf 33") == 0
2798 || strcmp (result, " -infinity 33") == 0);
2799 ASSERT (length == strlen (result));
2803 { /* FLAG_ZERO with NaN. */
2806 my_asnprintf (NULL, &length, "%050g %d", NaN (), 33, 44, 55);
2807 ASSERT (result != NULL);
2808 ASSERT (strlen (result) == 50 + 3
2809 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2810 && strcmp (result + strlen (result) - 3, " 33") == 0);
2811 ASSERT (length == strlen (result));
2818 my_asnprintf (NULL, &length, "%.g %d", 1234.0, 33, 44, 55);
2819 ASSERT (result != NULL);
2820 ASSERT (strcmp (result, "1e+03 33") == 0
2821 || strcmp (result, "1e+003 33") == 0);
2822 ASSERT (length == strlen (result));
2826 { /* A positive number. */
2829 my_asnprintf (NULL, &length, "%Lg %d", 12.75L, 33, 44, 55);
2830 ASSERT (result != NULL);
2831 ASSERT (strcmp (result, "12.75 33") == 0);
2832 ASSERT (length == strlen (result));
2836 { /* A larger positive number. */
2839 my_asnprintf (NULL, &length, "%Lg %d", 1234567.0L, 33, 44, 55);
2840 ASSERT (result != NULL);
2841 ASSERT (strcmp (result, "1.23457e+06 33") == 0);
2842 ASSERT (length == strlen (result));
2846 { /* Small and large positive numbers. */
2847 static struct { long double value; const char *string; } data[] =
2849 { 1.234321234321234e-37L, "1.23432e-37" },
2850 { 1.234321234321234e-36L, "1.23432e-36" },
2851 { 1.234321234321234e-35L, "1.23432e-35" },
2852 { 1.234321234321234e-34L, "1.23432e-34" },
2853 { 1.234321234321234e-33L, "1.23432e-33" },
2854 { 1.234321234321234e-32L, "1.23432e-32" },
2855 { 1.234321234321234e-31L, "1.23432e-31" },
2856 { 1.234321234321234e-30L, "1.23432e-30" },
2857 { 1.234321234321234e-29L, "1.23432e-29" },
2858 { 1.234321234321234e-28L, "1.23432e-28" },
2859 { 1.234321234321234e-27L, "1.23432e-27" },
2860 { 1.234321234321234e-26L, "1.23432e-26" },
2861 { 1.234321234321234e-25L, "1.23432e-25" },
2862 { 1.234321234321234e-24L, "1.23432e-24" },
2863 { 1.234321234321234e-23L, "1.23432e-23" },
2864 { 1.234321234321234e-22L, "1.23432e-22" },
2865 { 1.234321234321234e-21L, "1.23432e-21" },
2866 { 1.234321234321234e-20L, "1.23432e-20" },
2867 { 1.234321234321234e-19L, "1.23432e-19" },
2868 { 1.234321234321234e-18L, "1.23432e-18" },
2869 { 1.234321234321234e-17L, "1.23432e-17" },
2870 { 1.234321234321234e-16L, "1.23432e-16" },
2871 { 1.234321234321234e-15L, "1.23432e-15" },
2872 { 1.234321234321234e-14L, "1.23432e-14" },
2873 { 1.234321234321234e-13L, "1.23432e-13" },
2874 { 1.234321234321234e-12L, "1.23432e-12" },
2875 { 1.234321234321234e-11L, "1.23432e-11" },
2876 { 1.234321234321234e-10L, "1.23432e-10" },
2877 { 1.234321234321234e-9L, "1.23432e-09" },
2878 { 1.234321234321234e-8L, "1.23432e-08" },
2879 { 1.234321234321234e-7L, "1.23432e-07" },
2880 { 1.234321234321234e-6L, "1.23432e-06" },
2881 { 1.234321234321234e-5L, "1.23432e-05" },
2882 { 1.234321234321234e-4L, "0.000123432" },
2883 { 1.234321234321234e-3L, "0.00123432" },
2884 { 1.234321234321234e-2L, "0.0123432" },
2885 { 1.234321234321234e-1L, "0.123432" },
2886 { 1.234321234321234L, "1.23432" },
2887 { 1.234321234321234e1L, "12.3432" },
2888 { 1.234321234321234e2L, "123.432" },
2889 { 1.234321234321234e3L, "1234.32" },
2890 { 1.234321234321234e4L, "12343.2" },
2891 { 1.234321234321234e5L, "123432" },
2892 { 1.234321234321234e6L, "1.23432e+06" },
2893 { 1.234321234321234e7L, "1.23432e+07" },
2894 { 1.234321234321234e8L, "1.23432e+08" },
2895 { 1.234321234321234e9L, "1.23432e+09" },
2896 { 1.234321234321234e10L, "1.23432e+10" },
2897 { 1.234321234321234e11L, "1.23432e+11" },
2898 { 1.234321234321234e12L, "1.23432e+12" },
2899 { 1.234321234321234e13L, "1.23432e+13" },
2900 { 1.234321234321234e14L, "1.23432e+14" },
2901 { 1.234321234321234e15L, "1.23432e+15" },
2902 { 1.234321234321234e16L, "1.23432e+16" },
2903 { 1.234321234321234e17L, "1.23432e+17" },
2904 { 1.234321234321234e18L, "1.23432e+18" },
2905 { 1.234321234321234e19L, "1.23432e+19" },
2906 { 1.234321234321234e20L, "1.23432e+20" },
2907 { 1.234321234321234e21L, "1.23432e+21" },
2908 { 1.234321234321234e22L, "1.23432e+22" },
2909 { 1.234321234321234e23L, "1.23432e+23" },
2910 { 1.234321234321234e24L, "1.23432e+24" },
2911 { 1.234321234321234e25L, "1.23432e+25" },
2912 { 1.234321234321234e26L, "1.23432e+26" },
2913 { 1.234321234321234e27L, "1.23432e+27" },
2914 { 1.234321234321234e28L, "1.23432e+28" },
2915 { 1.234321234321234e29L, "1.23432e+29" },
2916 { 1.234321234321234e30L, "1.23432e+30" },
2917 { 1.234321234321234e31L, "1.23432e+31" },
2918 { 1.234321234321234e32L, "1.23432e+32" },
2919 { 1.234321234321234e33L, "1.23432e+33" },
2920 { 1.234321234321234e34L, "1.23432e+34" },
2921 { 1.234321234321234e35L, "1.23432e+35" },
2922 { 1.234321234321234e36L, "1.23432e+36" }
2925 for (k = 0; k < SIZEOF (data); k++)
2929 my_asnprintf (NULL, &length, "%Lg", data[k].value);
2930 ASSERT (result != NULL);
2931 ASSERT (strcmp (result, data[k].string) == 0);
2932 ASSERT (length == strlen (result));
2937 { /* A negative number. */
2940 my_asnprintf (NULL, &length, "%Lg %d", -0.03125L, 33, 44, 55);
2941 ASSERT (result != NULL);
2942 ASSERT (strcmp (result, "-0.03125 33") == 0);
2943 ASSERT (length == strlen (result));
2947 { /* Positive zero. */
2950 my_asnprintf (NULL, &length, "%Lg %d", 0.0L, 33, 44, 55);
2951 ASSERT (result != NULL);
2952 ASSERT (strcmp (result, "0 33") == 0);
2953 ASSERT (length == strlen (result));
2957 { /* Negative zero. */
2960 my_asnprintf (NULL, &length, "%Lg %d", -0.0L, 33, 44, 55);
2961 ASSERT (result != NULL);
2962 if (have_minus_zero ())
2963 ASSERT (strcmp (result, "-0 33") == 0);
2964 ASSERT (length == strlen (result));
2968 { /* Positive infinity. */
2971 my_asnprintf (NULL, &length, "%Lg %d", 1.0L / 0.0L, 33, 44, 55);
2972 ASSERT (result != NULL);
2973 ASSERT (strcmp (result, "inf 33") == 0
2974 || strcmp (result, "infinity 33") == 0);
2975 ASSERT (length == strlen (result));
2979 { /* Negative infinity. */
2982 my_asnprintf (NULL, &length, "%Lg %d", -1.0L / 0.0L, 33, 44, 55);
2983 ASSERT (result != NULL);
2984 ASSERT (strcmp (result, "-inf 33") == 0
2985 || strcmp (result, "-infinity 33") == 0);
2986 ASSERT (length == strlen (result));
2991 static long double zero = 0.0L;
2994 my_asnprintf (NULL, &length, "%Lg %d", zero / zero, 33, 44, 55);
2995 ASSERT (result != NULL);
2996 ASSERT (strlen (result) >= 3 + 3
2997 && strisnan (result, 0, strlen (result) - 3, 0)
2998 && strcmp (result + strlen (result) - 3, " 33") == 0);
2999 ASSERT (length == strlen (result));
3002 #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_))
3004 static union { unsigned int word[4]; long double value; } x =
3005 { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
3008 my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55);
3009 ASSERT (result != NULL);
3010 ASSERT (strlen (result) >= 3 + 3
3011 && strisnan (result, 0, strlen (result) - 3, 0)
3012 && strcmp (result + strlen (result) - 3, " 33") == 0);
3013 ASSERT (length == strlen (result));
3017 /* Signalling NaN. */
3018 static union { unsigned int word[4]; long double value; } x =
3019 { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
3022 my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55);
3023 ASSERT (result != NULL);
3024 ASSERT (strlen (result) >= 3 + 3
3025 && strisnan (result, 0, strlen (result) - 3, 0)
3026 && strcmp (result + strlen (result) - 3, " 33") == 0);
3027 ASSERT (length == strlen (result));
3030 /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
3031 Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
3032 Intel IA-64 Architecture Software Developer's Manual, Volume 1:
3033 Application Architecture.
3034 Table 5-2 "Floating-Point Register Encodings"
3035 Figure 5-6 "Memory to Floating-Point Register Data Translation"
3038 static union { unsigned int word[4]; long double value; } x =
3039 { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
3042 my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55);
3043 ASSERT (result != NULL);
3044 ASSERT (strlen (result) >= 3 + 3
3045 && strisnan (result, 0, strlen (result) - 3, 0)
3046 && strcmp (result + strlen (result) - 3, " 33") == 0);
3047 ASSERT (length == strlen (result));
3050 { /* Pseudo-Infinity. */
3051 static union { unsigned int word[4]; long double value; } x =
3052 { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
3055 my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55);
3056 ASSERT (result != NULL);
3057 ASSERT (strlen (result) >= 3 + 3
3058 && strisnan (result, 0, strlen (result) - 3, 0)
3059 && strcmp (result + strlen (result) - 3, " 33") == 0);
3060 ASSERT (length == strlen (result));
3063 { /* Pseudo-Zero. */
3064 static union { unsigned int word[4]; long double value; } x =
3065 { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
3068 my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55);
3069 ASSERT (result != NULL);
3070 ASSERT (strlen (result) >= 3 + 3
3071 && strisnan (result, 0, strlen (result) - 3, 0)
3072 && strcmp (result + strlen (result) - 3, " 33") == 0);
3073 ASSERT (length == strlen (result));
3076 { /* Unnormalized number. */
3077 static union { unsigned int word[4]; long double value; } x =
3078 { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
3081 my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55);
3082 ASSERT (result != NULL);
3083 ASSERT (strlen (result) >= 3 + 3
3084 && strisnan (result, 0, strlen (result) - 3, 0)
3085 && strcmp (result + strlen (result) - 3, " 33") == 0);
3086 ASSERT (length == strlen (result));
3089 { /* Pseudo-Denormal. */
3090 static union { unsigned int word[4]; long double value; } x =
3091 { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
3094 my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55);
3095 ASSERT (result != NULL);
3096 ASSERT (strlen (result) >= 3 + 3
3097 && strisnan (result, 0, strlen (result) - 3, 0)
3098 && strcmp (result + strlen (result) - 3, " 33") == 0);
3099 ASSERT (length == strlen (result));
3107 my_asnprintf (NULL, &length, "%10Lg %d", 1.75L, 33, 44, 55);
3108 ASSERT (result != NULL);
3109 ASSERT (strcmp (result, " 1.75 33") == 0);
3110 ASSERT (length == strlen (result));
3117 my_asnprintf (NULL, &length, "%-10Lg %d", 1.75L, 33, 44, 55);
3118 ASSERT (result != NULL);
3119 ASSERT (strcmp (result, "1.75 33") == 0);
3120 ASSERT (length == strlen (result));
3124 { /* FLAG_SHOWSIGN. */
3127 my_asnprintf (NULL, &length, "%+Lg %d", 1.75L, 33, 44, 55);
3128 ASSERT (result != NULL);
3129 ASSERT (strcmp (result, "+1.75 33") == 0);
3130 ASSERT (length == strlen (result));
3137 my_asnprintf (NULL, &length, "% Lg %d", 1.75L, 33, 44, 55);
3138 ASSERT (result != NULL);
3139 ASSERT (strcmp (result, " 1.75 33") == 0);
3140 ASSERT (length == strlen (result));
3147 my_asnprintf (NULL, &length, "%#Lg %d", 1.75L, 33, 44, 55);
3148 ASSERT (result != NULL);
3149 ASSERT (strcmp (result, "1.75000 33") == 0);
3150 ASSERT (length == strlen (result));
3157 my_asnprintf (NULL, &length, "%#.Lg %d", 1.75L, 33, 44, 55);
3158 ASSERT (result != NULL);
3159 ASSERT (strcmp (result, "2. 33") == 0);
3160 ASSERT (length == strlen (result));
3167 my_asnprintf (NULL, &length, "%#.Lg %d", 9.75L, 33, 44, 55);
3168 ASSERT (result != NULL);
3169 ASSERT (strcmp (result, "1.e+01 33") == 0);
3170 ASSERT (length == strlen (result));
3174 { /* FLAG_ZERO with finite number. */
3177 my_asnprintf (NULL, &length, "%010Lg %d", 1234.0L, 33, 44, 55);
3178 ASSERT (result != NULL);
3179 ASSERT (strcmp (result, "0000001234 33") == 0);
3180 ASSERT (length == strlen (result));
3184 { /* FLAG_ZERO with infinite number. */
3187 my_asnprintf (NULL, &length, "%015Lg %d", -1.0L / 0.0L, 33, 44, 55);
3188 ASSERT (result != NULL);
3189 ASSERT (strcmp (result, " -inf 33") == 0
3190 || strcmp (result, " -infinity 33") == 0);
3191 ASSERT (length == strlen (result));
3195 { /* FLAG_ZERO with NaN. */
3196 static long double zero = 0.0L;
3199 my_asnprintf (NULL, &length, "%050Lg %d", zero / zero, 33, 44, 55);
3200 ASSERT (result != NULL);
3201 ASSERT (strlen (result) == 50 + 3
3202 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
3203 && strcmp (result + strlen (result) - 3, " 33") == 0);
3204 ASSERT (length == strlen (result));
3211 my_asnprintf (NULL, &length, "%.Lg %d", 1234.0L, 33, 44, 55);
3212 ASSERT (result != NULL);
3213 ASSERT (strcmp (result, "1e+03 33") == 0);
3214 ASSERT (length == strlen (result));
3218 /* Test the support of the %n format directive. */
3224 my_asnprintf (NULL, &length, "%d %n", 123, &count, 33, 44, 55);
3225 ASSERT (result != NULL);
3226 ASSERT (strcmp (result, "123 ") == 0);
3227 ASSERT (length == strlen (result));
3228 ASSERT (count == 4);
3232 /* Test the support of the POSIX/XSI format strings with positions. */
3237 my_asnprintf (NULL, &length, "%2$d %1$d", 33, 55);
3238 ASSERT (result != NULL);
3239 ASSERT (strcmp (result, "55 33") == 0);
3240 ASSERT (length == strlen (result));
3244 /* Test the support of the grouping flag. */
3249 my_asnprintf (NULL, &length, "%'d %d", 1234567, 99);
3250 ASSERT (result != NULL);
3251 ASSERT (result[strlen (result) - 1] == '9');
3252 ASSERT (length == strlen (result));
3258 my_asnprintf (char *resultbuf, size_t *lengthp, const char *format, ...)
3263 va_start (args, format);
3264 ret = vasnprintf (resultbuf, lengthp, format, args);
3272 test_function (my_asnprintf);
3278 test_function (asnprintf);
3282 main (int argc, char *argv[])