1 /* Test of POSIX compatible vsprintf() and sprintf() functions.
2 Copyright (C) 2007-2008 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 /* The SGI MIPS floating-point format does not distinguish 0.0 and -0.0. */
25 static double plus_zero = 0.0;
26 static double minus_zero = -0.0;
27 return memcmp (&plus_zero, &minus_zero, sizeof (double)) != 0;
30 /* Representation of an 80-bit 'long double' as an initializer for a sequence
31 of 'unsigned int' words. */
32 #ifdef WORDS_BIGENDIAN
33 # define LDBL80_WORDS(exponent,manthi,mantlo) \
34 { ((unsigned int) (exponent) << 16) | ((unsigned int) (manthi) >> 16), \
35 ((unsigned int) (manthi) << 16) | (unsigned int) (mantlo) >> 16), \
36 (unsigned int) (mantlo) << 16 \
39 # define LDBL80_WORDS(exponent,manthi,mantlo) \
40 { mantlo, manthi, exponent }
44 strmatch (const char *pattern, const char *string)
46 if (strlen (pattern) != strlen (string))
48 for (; *pattern != '\0'; pattern++, string++)
49 if (*pattern != '*' && *string != *pattern)
54 /* Test whether string[start_index..end_index-1] is a valid textual
55 representation of NaN. */
57 strisnan (const char *string, size_t start_index, size_t end_index, int uppercase)
59 if (start_index < end_index)
61 if (string[start_index] == '-')
63 if (start_index + 3 <= end_index
64 && memcmp (string + start_index, uppercase ? "NAN" : "nan", 3) == 0)
67 if (start_index == end_index
68 || (string[start_index] == '(' && string[end_index - 1] == ')'))
76 test_function (int (*my_sprintf) (char *, const char *, ...))
80 /* Test return value convention. */
85 memcpy (buf, "DEADBEEF", 8);
86 retval = my_sprintf (buf, "%d", 12345);
88 ASSERT (memcmp (buf, "12345\0EF", 8) == 0);
91 /* Test support of size specifiers as in C99. */
96 my_sprintf (result, "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
97 ASSERT (strcmp (result, "12345671 33") == 0);
98 ASSERT (retval == strlen (result));
104 my_sprintf (result, "%zu %d", (size_t) 12345672, 33, 44, 55);
105 ASSERT (strcmp (result, "12345672 33") == 0);
106 ASSERT (retval == strlen (result));
112 my_sprintf (result, "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
113 ASSERT (strcmp (result, "12345673 33") == 0);
114 ASSERT (retval == strlen (result));
120 my_sprintf (result, "%Lg %d", (long double) 1.5, 33, 44, 55);
121 ASSERT (strcmp (result, "1.5 33") == 0);
122 ASSERT (retval == strlen (result));
125 /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
126 output of floating-point numbers. */
128 { /* A positive number. */
131 my_sprintf (result, "%a %d", 3.1416015625, 33, 44, 55);
132 ASSERT (strcmp (result, "0x1.922p+1 33") == 0
133 || strcmp (result, "0x3.244p+0 33") == 0
134 || strcmp (result, "0x6.488p-1 33") == 0
135 || strcmp (result, "0xc.91p-2 33") == 0);
136 ASSERT (retval == strlen (result));
139 { /* A negative number. */
142 my_sprintf (result, "%A %d", -3.1416015625, 33, 44, 55);
143 ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
144 || strcmp (result, "-0X3.244P+0 33") == 0
145 || strcmp (result, "-0X6.488P-1 33") == 0
146 || strcmp (result, "-0XC.91P-2 33") == 0);
147 ASSERT (retval == strlen (result));
150 { /* Positive zero. */
153 my_sprintf (result, "%a %d", 0.0, 33, 44, 55);
154 ASSERT (strcmp (result, "0x0p+0 33") == 0);
155 ASSERT (retval == strlen (result));
158 { /* Negative zero. */
161 my_sprintf (result, "%a %d", -0.0, 33, 44, 55);
162 if (have_minus_zero ())
163 ASSERT (strcmp (result, "-0x0p+0 33") == 0);
164 ASSERT (retval == strlen (result));
167 { /* Positive infinity. */
170 my_sprintf (result, "%a %d", 1.0 / 0.0, 33, 44, 55);
171 ASSERT (strcmp (result, "inf 33") == 0);
172 ASSERT (retval == strlen (result));
175 { /* Negative infinity. */
178 my_sprintf (result, "%a %d", -1.0 / 0.0, 33, 44, 55);
179 ASSERT (strcmp (result, "-inf 33") == 0);
180 ASSERT (retval == strlen (result));
186 my_sprintf (result, "%a %d", NaNd (), 33, 44, 55);
187 ASSERT (strlen (result) >= 3 + 3
188 && strisnan (result, 0, strlen (result) - 3, 0)
189 && strcmp (result + strlen (result) - 3, " 33") == 0);
190 ASSERT (retval == strlen (result));
193 { /* Rounding near the decimal point. */
196 my_sprintf (result, "%.0a %d", 1.5, 33, 44, 55);
197 ASSERT (strcmp (result, "0x2p+0 33") == 0
198 || strcmp (result, "0x3p-1 33") == 0
199 || strcmp (result, "0x6p-2 33") == 0
200 || strcmp (result, "0xcp-3 33") == 0);
201 ASSERT (retval == strlen (result));
204 { /* Rounding with precision 0. */
207 my_sprintf (result, "%.0a %d", 1.51, 33, 44, 55);
208 ASSERT (strcmp (result, "0x2p+0 33") == 0
209 || strcmp (result, "0x3p-1 33") == 0
210 || strcmp (result, "0x6p-2 33") == 0
211 || strcmp (result, "0xcp-3 33") == 0);
212 ASSERT (retval == strlen (result));
215 { /* Rounding with precision 1. */
218 my_sprintf (result, "%.1a %d", 1.51, 33, 44, 55);
219 ASSERT (strcmp (result, "0x1.8p+0 33") == 0
220 || strcmp (result, "0x3.0p-1 33") == 0
221 || strcmp (result, "0x6.1p-2 33") == 0
222 || strcmp (result, "0xc.1p-3 33") == 0);
223 ASSERT (retval == strlen (result));
226 { /* Rounding with precision 2. */
229 my_sprintf (result, "%.2a %d", 1.51, 33, 44, 55);
230 ASSERT (strcmp (result, "0x1.83p+0 33") == 0
231 || strcmp (result, "0x3.05p-1 33") == 0
232 || strcmp (result, "0x6.0ap-2 33") == 0
233 || strcmp (result, "0xc.14p-3 33") == 0);
234 ASSERT (retval == strlen (result));
237 { /* Rounding with precision 3. */
240 my_sprintf (result, "%.3a %d", 1.51, 33, 44, 55);
241 ASSERT (strcmp (result, "0x1.829p+0 33") == 0
242 || strcmp (result, "0x3.052p-1 33") == 0
243 || strcmp (result, "0x6.0a4p-2 33") == 0
244 || strcmp (result, "0xc.148p-3 33") == 0);
245 ASSERT (retval == strlen (result));
248 { /* Rounding can turn a ...FFF into a ...000. */
251 my_sprintf (result, "%.3a %d", 1.49999, 33, 44, 55);
252 ASSERT (strcmp (result, "0x1.800p+0 33") == 0
253 || strcmp (result, "0x3.000p-1 33") == 0
254 || strcmp (result, "0x6.000p-2 33") == 0
255 || strcmp (result, "0xc.000p-3 33") == 0);
256 ASSERT (retval == strlen (result));
259 { /* Rounding can turn a ...FFF into a ...000.
260 This shows a MacOS X 10.3.9 (Darwin 7.9) bug. */
263 my_sprintf (result, "%.1a %d", 1.999, 33, 44, 55);
264 ASSERT (strcmp (result, "0x1.0p+1 33") == 0
265 || strcmp (result, "0x2.0p+0 33") == 0
266 || strcmp (result, "0x4.0p-1 33") == 0
267 || strcmp (result, "0x8.0p-2 33") == 0);
268 ASSERT (retval == strlen (result));
274 my_sprintf (result, "%10a %d", 1.75, 33, 44, 55);
275 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
276 || strcmp (result, " 0x3.8p-1 33") == 0
277 || strcmp (result, " 0x7p-2 33") == 0
278 || strcmp (result, " 0xep-3 33") == 0);
279 ASSERT (retval == strlen (result));
282 { /* Small precision. */
285 my_sprintf (result, "%.10a %d", 1.75, 33, 44, 55);
286 ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
287 || strcmp (result, "0x3.8000000000p-1 33") == 0
288 || strcmp (result, "0x7.0000000000p-2 33") == 0
289 || strcmp (result, "0xe.0000000000p-3 33") == 0);
290 ASSERT (retval == strlen (result));
293 { /* Large precision. */
296 my_sprintf (result, "%.50a %d", 1.75, 33, 44, 55);
297 ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
298 || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
299 || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
300 || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
301 ASSERT (retval == strlen (result));
307 my_sprintf (result, "%-10a %d", 1.75, 33, 44, 55);
308 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
309 || strcmp (result, "0x3.8p-1 33") == 0
310 || strcmp (result, "0x7p-2 33") == 0
311 || strcmp (result, "0xep-3 33") == 0);
312 ASSERT (retval == strlen (result));
315 { /* FLAG_SHOWSIGN. */
318 my_sprintf (result, "%+a %d", 1.75, 33, 44, 55);
319 ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
320 || strcmp (result, "+0x3.8p-1 33") == 0
321 || strcmp (result, "+0x7p-2 33") == 0
322 || strcmp (result, "+0xep-3 33") == 0);
323 ASSERT (retval == strlen (result));
329 my_sprintf (result, "% a %d", 1.75, 33, 44, 55);
330 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
331 || strcmp (result, " 0x3.8p-1 33") == 0
332 || strcmp (result, " 0x7p-2 33") == 0
333 || strcmp (result, " 0xep-3 33") == 0);
334 ASSERT (retval == strlen (result));
340 my_sprintf (result, "%#a %d", 1.75, 33, 44, 55);
341 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
342 || strcmp (result, "0x3.8p-1 33") == 0
343 || strcmp (result, "0x7.p-2 33") == 0
344 || strcmp (result, "0xe.p-3 33") == 0);
345 ASSERT (retval == strlen (result));
351 my_sprintf (result, "%#a %d", 1.0, 33, 44, 55);
352 ASSERT (strcmp (result, "0x1.p+0 33") == 0
353 || strcmp (result, "0x2.p-1 33") == 0
354 || strcmp (result, "0x4.p-2 33") == 0
355 || strcmp (result, "0x8.p-3 33") == 0);
356 ASSERT (retval == strlen (result));
359 { /* FLAG_ZERO with finite number. */
362 my_sprintf (result, "%010a %d", 1.75, 33, 44, 55);
363 ASSERT (strcmp (result, "0x001.cp+0 33") == 0
364 || strcmp (result, "0x003.8p-1 33") == 0
365 || strcmp (result, "0x00007p-2 33") == 0
366 || strcmp (result, "0x0000ep-3 33") == 0);
367 ASSERT (retval == strlen (result));
370 { /* FLAG_ZERO with infinite number. */
373 my_sprintf (result, "%010a %d", 1.0 / 0.0, 33, 44, 55);
374 /* "0000000inf 33" is not a valid result; see
375 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
376 ASSERT (strcmp (result, " inf 33") == 0);
377 ASSERT (retval == strlen (result));
380 { /* FLAG_ZERO with NaN. */
383 my_sprintf (result, "%050a %d", NaNd (), 33, 44, 55);
384 /* "0000000nan 33" is not a valid result; see
385 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
386 ASSERT (strlen (result) == 50 + 3
387 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
388 && strcmp (result + strlen (result) - 3, " 33") == 0);
389 ASSERT (retval == strlen (result));
392 { /* A positive number. */
395 my_sprintf (result, "%La %d", 3.1416015625L, 33, 44, 55);
396 ASSERT (strcmp (result, "0x1.922p+1 33") == 0
397 || strcmp (result, "0x3.244p+0 33") == 0
398 || strcmp (result, "0x6.488p-1 33") == 0
399 || strcmp (result, "0xc.91p-2 33") == 0);
400 ASSERT (retval == strlen (result));
403 { /* A negative number. */
406 my_sprintf (result, "%LA %d", -3.1416015625L, 33, 44, 55);
407 ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
408 || strcmp (result, "-0X3.244P+0 33") == 0
409 || strcmp (result, "-0X6.488P-1 33") == 0
410 || strcmp (result, "-0XC.91P-2 33") == 0);
411 ASSERT (retval == strlen (result));
414 { /* Positive zero. */
417 my_sprintf (result, "%La %d", 0.0L, 33, 44, 55);
418 ASSERT (strcmp (result, "0x0p+0 33") == 0);
419 ASSERT (retval == strlen (result));
422 { /* Negative zero. */
425 my_sprintf (result, "%La %d", -0.0L, 33, 44, 55);
426 if (have_minus_zero ())
427 ASSERT (strcmp (result, "-0x0p+0 33") == 0);
428 ASSERT (retval == strlen (result));
431 { /* Positive infinity. */
434 my_sprintf (result, "%La %d", 1.0L / 0.0L, 33, 44, 55);
435 ASSERT (strcmp (result, "inf 33") == 0);
436 ASSERT (retval == strlen (result));
439 { /* Negative infinity. */
442 my_sprintf (result, "%La %d", -1.0L / 0.0L, 33, 44, 55);
443 ASSERT (strcmp (result, "-inf 33") == 0);
444 ASSERT (retval == strlen (result));
450 my_sprintf (result, "%La %d", NaNl (), 33, 44, 55);
451 ASSERT (strlen (result) >= 3 + 3
452 && strisnan (result, 0, strlen (result) - 3, 0)
453 && strcmp (result + strlen (result) - 3, " 33") == 0);
454 ASSERT (retval == strlen (result));
456 #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_))
458 static union { unsigned int word[4]; long double value; } x =
459 { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
462 my_sprintf (result, "%La %d", x.value, 33, 44, 55);
463 ASSERT (strlen (result) >= 3 + 3
464 && strisnan (result, 0, strlen (result) - 3, 0)
465 && strcmp (result + strlen (result) - 3, " 33") == 0);
466 ASSERT (retval == strlen (result));
469 /* Signalling NaN. */
470 static union { unsigned int word[4]; long double value; } x =
471 { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
474 my_sprintf (result, "%La %d", x.value, 33, 44, 55);
475 ASSERT (strlen (result) >= 3 + 3
476 && strisnan (result, 0, strlen (result) - 3, 0)
477 && strcmp (result + strlen (result) - 3, " 33") == 0);
478 ASSERT (retval == strlen (result));
480 /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
481 Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
482 Intel IA-64 Architecture Software Developer's Manual, Volume 1:
483 Application Architecture.
484 Table 5-2 "Floating-Point Register Encodings"
485 Figure 5-6 "Memory to Floating-Point Register Data Translation"
488 static union { unsigned int word[4]; long double value; } x =
489 { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
492 my_sprintf (result, "%La %d", x.value, 33, 44, 55);
493 ASSERT (strlen (result) >= 3 + 3
494 && strisnan (result, 0, strlen (result) - 3, 0)
495 && strcmp (result + strlen (result) - 3, " 33") == 0);
496 ASSERT (retval == strlen (result));
498 { /* Pseudo-Infinity. */
499 static union { unsigned int word[4]; long double value; } x =
500 { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
503 my_sprintf (result, "%La %d", x.value, 33, 44, 55);
504 ASSERT (strlen (result) >= 3 + 3
505 && strisnan (result, 0, strlen (result) - 3, 0)
506 && strcmp (result + strlen (result) - 3, " 33") == 0);
507 ASSERT (retval == strlen (result));
510 static union { unsigned int word[4]; long double value; } x =
511 { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
514 my_sprintf (result, "%La %d", x.value, 33, 44, 55);
515 ASSERT (strlen (result) >= 3 + 3
516 && strisnan (result, 0, strlen (result) - 3, 0)
517 && strcmp (result + strlen (result) - 3, " 33") == 0);
518 ASSERT (retval == strlen (result));
520 { /* Unnormalized number. */
521 static union { unsigned int word[4]; long double value; } x =
522 { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
525 my_sprintf (result, "%La %d", x.value, 33, 44, 55);
526 ASSERT (strlen (result) >= 3 + 3
527 && strisnan (result, 0, strlen (result) - 3, 0)
528 && strcmp (result + strlen (result) - 3, " 33") == 0);
529 ASSERT (retval == strlen (result));
531 { /* Pseudo-Denormal. */
532 static union { unsigned int word[4]; long double value; } x =
533 { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
536 my_sprintf (result, "%La %d", x.value, 33, 44, 55);
537 ASSERT (strlen (result) >= 3 + 3
538 && strisnan (result, 0, strlen (result) - 3, 0)
539 && strcmp (result + strlen (result) - 3, " 33") == 0);
540 ASSERT (retval == strlen (result));
544 { /* Rounding near the decimal point. */
547 my_sprintf (result, "%.0La %d", 1.5L, 33, 44, 55);
548 ASSERT (strcmp (result, "0x2p+0 33") == 0
549 || strcmp (result, "0x3p-1 33") == 0
550 || strcmp (result, "0x6p-2 33") == 0
551 || strcmp (result, "0xcp-3 33") == 0);
552 ASSERT (retval == strlen (result));
555 { /* Rounding with precision 0. */
558 my_sprintf (result, "%.0La %d", 1.51L, 33, 44, 55);
559 ASSERT (strcmp (result, "0x2p+0 33") == 0
560 || strcmp (result, "0x3p-1 33") == 0
561 || strcmp (result, "0x6p-2 33") == 0
562 || strcmp (result, "0xcp-3 33") == 0);
563 ASSERT (retval == strlen (result));
566 { /* Rounding with precision 1. */
569 my_sprintf (result, "%.1La %d", 1.51L, 33, 44, 55);
570 ASSERT (strcmp (result, "0x1.8p+0 33") == 0
571 || strcmp (result, "0x3.0p-1 33") == 0
572 || strcmp (result, "0x6.1p-2 33") == 0
573 || strcmp (result, "0xc.1p-3 33") == 0);
574 ASSERT (retval == strlen (result));
577 { /* Rounding with precision 2. */
580 my_sprintf (result, "%.2La %d", 1.51L, 33, 44, 55);
581 ASSERT (strcmp (result, "0x1.83p+0 33") == 0
582 || strcmp (result, "0x3.05p-1 33") == 0
583 || strcmp (result, "0x6.0ap-2 33") == 0
584 || strcmp (result, "0xc.14p-3 33") == 0);
585 ASSERT (retval == strlen (result));
588 { /* Rounding with precision 3. */
591 my_sprintf (result, "%.3La %d", 1.51L, 33, 44, 55);
592 ASSERT (strcmp (result, "0x1.829p+0 33") == 0
593 || strcmp (result, "0x3.052p-1 33") == 0
594 || strcmp (result, "0x6.0a4p-2 33") == 0
595 || strcmp (result, "0xc.148p-3 33") == 0);
596 ASSERT (retval == strlen (result));
599 { /* Rounding can turn a ...FFF into a ...000. */
602 my_sprintf (result, "%.3La %d", 1.49999L, 33, 44, 55);
603 ASSERT (strcmp (result, "0x1.800p+0 33") == 0
604 || strcmp (result, "0x3.000p-1 33") == 0
605 || strcmp (result, "0x6.000p-2 33") == 0
606 || strcmp (result, "0xc.000p-3 33") == 0);
607 ASSERT (retval == strlen (result));
610 { /* Rounding can turn a ...FFF into a ...000.
611 This shows a MacOS X 10.3.9 (Darwin 7.9) bug and a
612 glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>. */
615 my_sprintf (result, "%.1La %d", 1.999L, 33, 44, 55);
616 ASSERT (strcmp (result, "0x1.0p+1 33") == 0
617 || strcmp (result, "0x2.0p+0 33") == 0
618 || strcmp (result, "0x4.0p-1 33") == 0
619 || strcmp (result, "0x8.0p-2 33") == 0);
620 ASSERT (retval == strlen (result));
626 my_sprintf (result, "%10La %d", 1.75L, 33, 44, 55);
627 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
628 || strcmp (result, " 0x3.8p-1 33") == 0
629 || strcmp (result, " 0x7p-2 33") == 0
630 || strcmp (result, " 0xep-3 33") == 0);
631 ASSERT (retval == strlen (result));
634 { /* Small precision. */
637 my_sprintf (result, "%.10La %d", 1.75L, 33, 44, 55);
638 ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
639 || strcmp (result, "0x3.8000000000p-1 33") == 0
640 || strcmp (result, "0x7.0000000000p-2 33") == 0
641 || strcmp (result, "0xe.0000000000p-3 33") == 0);
642 ASSERT (retval == strlen (result));
645 { /* Large precision. */
648 my_sprintf (result, "%.50La %d", 1.75L, 33, 44, 55);
649 ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
650 || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
651 || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
652 || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
653 ASSERT (retval == strlen (result));
659 my_sprintf (result, "%-10La %d", 1.75L, 33, 44, 55);
660 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
661 || strcmp (result, "0x3.8p-1 33") == 0
662 || strcmp (result, "0x7p-2 33") == 0
663 || strcmp (result, "0xep-3 33") == 0);
664 ASSERT (retval == strlen (result));
667 { /* FLAG_SHOWSIGN. */
670 my_sprintf (result, "%+La %d", 1.75L, 33, 44, 55);
671 ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
672 || strcmp (result, "+0x3.8p-1 33") == 0
673 || strcmp (result, "+0x7p-2 33") == 0
674 || strcmp (result, "+0xep-3 33") == 0);
675 ASSERT (retval == strlen (result));
681 my_sprintf (result, "% La %d", 1.75L, 33, 44, 55);
682 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
683 || strcmp (result, " 0x3.8p-1 33") == 0
684 || strcmp (result, " 0x7p-2 33") == 0
685 || strcmp (result, " 0xep-3 33") == 0);
686 ASSERT (retval == strlen (result));
692 my_sprintf (result, "%#La %d", 1.75L, 33, 44, 55);
693 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
694 || strcmp (result, "0x3.8p-1 33") == 0
695 || strcmp (result, "0x7.p-2 33") == 0
696 || strcmp (result, "0xe.p-3 33") == 0);
697 ASSERT (retval == strlen (result));
703 my_sprintf (result, "%#La %d", 1.0L, 33, 44, 55);
704 ASSERT (strcmp (result, "0x1.p+0 33") == 0
705 || strcmp (result, "0x2.p-1 33") == 0
706 || strcmp (result, "0x4.p-2 33") == 0
707 || strcmp (result, "0x8.p-3 33") == 0);
708 ASSERT (retval == strlen (result));
711 { /* FLAG_ZERO with finite number. */
714 my_sprintf (result, "%010La %d", 1.75L, 33, 44, 55);
715 ASSERT (strcmp (result, "0x001.cp+0 33") == 0
716 || strcmp (result, "0x003.8p-1 33") == 0
717 || strcmp (result, "0x00007p-2 33") == 0
718 || strcmp (result, "0x0000ep-3 33") == 0);
719 ASSERT (retval == strlen (result));
722 { /* FLAG_ZERO with infinite number. */
725 my_sprintf (result, "%010La %d", 1.0L / 0.0L, 33, 44, 55);
726 /* "0000000inf 33" is not a valid result; see
727 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
728 ASSERT (strcmp (result, " inf 33") == 0);
729 ASSERT (retval == strlen (result));
732 { /* FLAG_ZERO with NaN. */
735 my_sprintf (result, "%050La %d", NaNl (), 33, 44, 55);
736 /* "0000000nan 33" is not a valid result; see
737 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
738 ASSERT (strlen (result) == 50 + 3
739 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
740 && strcmp (result + strlen (result) - 3, " 33") == 0);
741 ASSERT (retval == strlen (result));
744 /* Test the support of the %f format directive. */
746 { /* A positive number. */
749 my_sprintf (result, "%f %d", 12.75, 33, 44, 55);
750 ASSERT (strcmp (result, "12.750000 33") == 0);
751 ASSERT (retval == strlen (result));
754 { /* A larger positive number. */
757 my_sprintf (result, "%f %d", 1234567.0, 33, 44, 55);
758 ASSERT (strcmp (result, "1234567.000000 33") == 0);
759 ASSERT (retval == strlen (result));
762 { /* Small and large positive numbers. */
763 static struct { double value; const char *string; } data[] =
765 { 1.234321234321234e-37, "0.000000" },
766 { 1.234321234321234e-36, "0.000000" },
767 { 1.234321234321234e-35, "0.000000" },
768 { 1.234321234321234e-34, "0.000000" },
769 { 1.234321234321234e-33, "0.000000" },
770 { 1.234321234321234e-32, "0.000000" },
771 { 1.234321234321234e-31, "0.000000" },
772 { 1.234321234321234e-30, "0.000000" },
773 { 1.234321234321234e-29, "0.000000" },
774 { 1.234321234321234e-28, "0.000000" },
775 { 1.234321234321234e-27, "0.000000" },
776 { 1.234321234321234e-26, "0.000000" },
777 { 1.234321234321234e-25, "0.000000" },
778 { 1.234321234321234e-24, "0.000000" },
779 { 1.234321234321234e-23, "0.000000" },
780 { 1.234321234321234e-22, "0.000000" },
781 { 1.234321234321234e-21, "0.000000" },
782 { 1.234321234321234e-20, "0.000000" },
783 { 1.234321234321234e-19, "0.000000" },
784 { 1.234321234321234e-18, "0.000000" },
785 { 1.234321234321234e-17, "0.000000" },
786 { 1.234321234321234e-16, "0.000000" },
787 { 1.234321234321234e-15, "0.000000" },
788 { 1.234321234321234e-14, "0.000000" },
789 { 1.234321234321234e-13, "0.000000" },
790 { 1.234321234321234e-12, "0.000000" },
791 { 1.234321234321234e-11, "0.000000" },
792 { 1.234321234321234e-10, "0.000000" },
793 { 1.234321234321234e-9, "0.000000" },
794 { 1.234321234321234e-8, "0.000000" },
795 { 1.234321234321234e-7, "0.000000" },
796 { 1.234321234321234e-6, "0.000001" },
797 { 1.234321234321234e-5, "0.000012" },
798 { 1.234321234321234e-4, "0.000123" },
799 { 1.234321234321234e-3, "0.001234" },
800 { 1.234321234321234e-2, "0.012343" },
801 { 1.234321234321234e-1, "0.123432" },
802 { 1.234321234321234, "1.234321" },
803 { 1.234321234321234e1, "12.343212" },
804 { 1.234321234321234e2, "123.432123" },
805 { 1.234321234321234e3, "1234.321234" },
806 { 1.234321234321234e4, "12343.212343" },
807 { 1.234321234321234e5, "123432.123432" },
808 { 1.234321234321234e6, "1234321.234321" },
809 { 1.234321234321234e7, "12343212.343212" },
810 { 1.234321234321234e8, "123432123.432123" },
811 { 1.234321234321234e9, "1234321234.321234" },
812 { 1.234321234321234e10, "12343212343.2123**" },
813 { 1.234321234321234e11, "123432123432.123***" },
814 { 1.234321234321234e12, "1234321234321.23****" },
815 { 1.234321234321234e13, "12343212343212.3*****" },
816 { 1.234321234321234e14, "123432123432123.******" },
817 { 1.234321234321234e15, "1234321234321234.000000" },
818 { 1.234321234321234e16, "123432123432123**.000000" },
819 { 1.234321234321234e17, "123432123432123***.000000" },
820 { 1.234321234321234e18, "123432123432123****.000000" },
821 { 1.234321234321234e19, "123432123432123*****.000000" },
822 { 1.234321234321234e20, "123432123432123******.000000" },
823 { 1.234321234321234e21, "123432123432123*******.000000" },
824 { 1.234321234321234e22, "123432123432123********.000000" },
825 { 1.234321234321234e23, "123432123432123*********.000000" },
826 { 1.234321234321234e24, "123432123432123**********.000000" },
827 { 1.234321234321234e25, "123432123432123***********.000000" },
828 { 1.234321234321234e26, "123432123432123************.000000" },
829 { 1.234321234321234e27, "123432123432123*************.000000" },
830 { 1.234321234321234e28, "123432123432123**************.000000" },
831 { 1.234321234321234e29, "123432123432123***************.000000" },
832 { 1.234321234321234e30, "123432123432123****************.000000" },
833 { 1.234321234321234e31, "123432123432123*****************.000000" },
834 { 1.234321234321234e32, "123432123432123******************.000000" },
835 { 1.234321234321234e33, "123432123432123*******************.000000" },
836 { 1.234321234321234e34, "123432123432123********************.000000" },
837 { 1.234321234321234e35, "123432123432123*********************.000000" },
838 { 1.234321234321234e36, "123432123432123**********************.000000" }
841 for (k = 0; k < SIZEOF (data); k++)
845 my_sprintf (result, "%f", data[k].value);
846 ASSERT (strmatch (data[k].string, result));
847 ASSERT (retval == strlen (result));
851 { /* A negative number. */
854 my_sprintf (result, "%f %d", -0.03125, 33, 44, 55);
855 ASSERT (strcmp (result, "-0.031250 33") == 0);
856 ASSERT (retval == strlen (result));
859 { /* Positive zero. */
862 my_sprintf (result, "%f %d", 0.0, 33, 44, 55);
863 ASSERT (strcmp (result, "0.000000 33") == 0);
864 ASSERT (retval == strlen (result));
867 { /* Negative zero. */
870 my_sprintf (result, "%f %d", -0.0, 33, 44, 55);
871 if (have_minus_zero ())
872 ASSERT (strcmp (result, "-0.000000 33") == 0);
873 ASSERT (retval == strlen (result));
876 { /* Positive infinity. */
879 my_sprintf (result, "%f %d", 1.0 / 0.0, 33, 44, 55);
880 ASSERT (strcmp (result, "inf 33") == 0
881 || strcmp (result, "infinity 33") == 0);
882 ASSERT (retval == strlen (result));
885 { /* Negative infinity. */
888 my_sprintf (result, "%f %d", -1.0 / 0.0, 33, 44, 55);
889 ASSERT (strcmp (result, "-inf 33") == 0
890 || strcmp (result, "-infinity 33") == 0);
891 ASSERT (retval == strlen (result));
897 my_sprintf (result, "%f %d", NaNd (), 33, 44, 55);
898 ASSERT (strlen (result) >= 3 + 3
899 && strisnan (result, 0, strlen (result) - 3, 0)
900 && strcmp (result + strlen (result) - 3, " 33") == 0);
901 ASSERT (retval == strlen (result));
907 my_sprintf (result, "%10f %d", 1.75, 33, 44, 55);
908 ASSERT (strcmp (result, " 1.750000 33") == 0);
909 ASSERT (retval == strlen (result));
915 my_sprintf (result, "%-10f %d", 1.75, 33, 44, 55);
916 ASSERT (strcmp (result, "1.750000 33") == 0);
917 ASSERT (retval == strlen (result));
920 { /* FLAG_SHOWSIGN. */
923 my_sprintf (result, "%+f %d", 1.75, 33, 44, 55);
924 ASSERT (strcmp (result, "+1.750000 33") == 0);
925 ASSERT (retval == strlen (result));
931 my_sprintf (result, "% f %d", 1.75, 33, 44, 55);
932 ASSERT (strcmp (result, " 1.750000 33") == 0);
933 ASSERT (retval == strlen (result));
939 my_sprintf (result, "%#f %d", 1.75, 33, 44, 55);
940 ASSERT (strcmp (result, "1.750000 33") == 0);
941 ASSERT (retval == strlen (result));
947 my_sprintf (result, "%#.f %d", 1.75, 33, 44, 55);
948 ASSERT (strcmp (result, "2. 33") == 0);
949 ASSERT (retval == strlen (result));
952 { /* FLAG_ZERO with finite number. */
955 my_sprintf (result, "%015f %d", 1234.0, 33, 44, 55);
956 ASSERT (strcmp (result, "00001234.000000 33") == 0);
957 ASSERT (retval == strlen (result));
960 { /* FLAG_ZERO with infinite number. */
963 my_sprintf (result, "%015f %d", -1.0 / 0.0, 33, 44, 55);
964 ASSERT (strcmp (result, " -inf 33") == 0
965 || strcmp (result, " -infinity 33") == 0);
966 ASSERT (retval == strlen (result));
969 { /* FLAG_ZERO with NaN. */
972 my_sprintf (result, "%050f %d", NaNd (), 33, 44, 55);
973 ASSERT (strlen (result) == 50 + 3
974 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
975 && strcmp (result + strlen (result) - 3, " 33") == 0);
976 ASSERT (retval == strlen (result));
982 my_sprintf (result, "%.f %d", 1234.0, 33, 44, 55);
983 ASSERT (strcmp (result, "1234 33") == 0);
984 ASSERT (retval == strlen (result));
987 { /* Precision with no rounding. */
990 my_sprintf (result, "%.2f %d", 999.951, 33, 44, 55);
991 ASSERT (strcmp (result, "999.95 33") == 0);
992 ASSERT (retval == strlen (result));
995 { /* Precision with rounding. */
998 my_sprintf (result, "%.2f %d", 999.996, 33, 44, 55);
999 ASSERT (strcmp (result, "1000.00 33") == 0);
1000 ASSERT (retval == strlen (result));
1003 { /* A positive number. */
1006 my_sprintf (result, "%Lf %d", 12.75L, 33, 44, 55);
1007 ASSERT (strcmp (result, "12.750000 33") == 0);
1008 ASSERT (retval == strlen (result));
1011 { /* A larger positive number. */
1014 my_sprintf (result, "%Lf %d", 1234567.0L, 33, 44, 55);
1015 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1016 ASSERT (retval == strlen (result));
1019 { /* Small and large positive numbers. */
1020 static struct { long double value; const char *string; } data[] =
1022 { 1.234321234321234e-37L, "0.000000" },
1023 { 1.234321234321234e-36L, "0.000000" },
1024 { 1.234321234321234e-35L, "0.000000" },
1025 { 1.234321234321234e-34L, "0.000000" },
1026 { 1.234321234321234e-33L, "0.000000" },
1027 { 1.234321234321234e-32L, "0.000000" },
1028 { 1.234321234321234e-31L, "0.000000" },
1029 { 1.234321234321234e-30L, "0.000000" },
1030 { 1.234321234321234e-29L, "0.000000" },
1031 { 1.234321234321234e-28L, "0.000000" },
1032 { 1.234321234321234e-27L, "0.000000" },
1033 { 1.234321234321234e-26L, "0.000000" },
1034 { 1.234321234321234e-25L, "0.000000" },
1035 { 1.234321234321234e-24L, "0.000000" },
1036 { 1.234321234321234e-23L, "0.000000" },
1037 { 1.234321234321234e-22L, "0.000000" },
1038 { 1.234321234321234e-21L, "0.000000" },
1039 { 1.234321234321234e-20L, "0.000000" },
1040 { 1.234321234321234e-19L, "0.000000" },
1041 { 1.234321234321234e-18L, "0.000000" },
1042 { 1.234321234321234e-17L, "0.000000" },
1043 { 1.234321234321234e-16L, "0.000000" },
1044 { 1.234321234321234e-15L, "0.000000" },
1045 { 1.234321234321234e-14L, "0.000000" },
1046 { 1.234321234321234e-13L, "0.000000" },
1047 { 1.234321234321234e-12L, "0.000000" },
1048 { 1.234321234321234e-11L, "0.000000" },
1049 { 1.234321234321234e-10L, "0.000000" },
1050 { 1.234321234321234e-9L, "0.000000" },
1051 { 1.234321234321234e-8L, "0.000000" },
1052 { 1.234321234321234e-7L, "0.000000" },
1053 { 1.234321234321234e-6L, "0.000001" },
1054 { 1.234321234321234e-5L, "0.000012" },
1055 { 1.234321234321234e-4L, "0.000123" },
1056 { 1.234321234321234e-3L, "0.001234" },
1057 { 1.234321234321234e-2L, "0.012343" },
1058 { 1.234321234321234e-1L, "0.123432" },
1059 { 1.234321234321234L, "1.234321" },
1060 { 1.234321234321234e1L, "12.343212" },
1061 { 1.234321234321234e2L, "123.432123" },
1062 { 1.234321234321234e3L, "1234.321234" },
1063 { 1.234321234321234e4L, "12343.212343" },
1064 { 1.234321234321234e5L, "123432.123432" },
1065 { 1.234321234321234e6L, "1234321.234321" },
1066 { 1.234321234321234e7L, "12343212.343212" },
1067 { 1.234321234321234e8L, "123432123.432123" },
1068 { 1.234321234321234e9L, "1234321234.321234" },
1069 { 1.234321234321234e10L, "12343212343.2123**" },
1070 { 1.234321234321234e11L, "123432123432.123***" },
1071 { 1.234321234321234e12L, "1234321234321.23****" },
1072 { 1.234321234321234e13L, "12343212343212.3*****" },
1073 { 1.234321234321234e14L, "123432123432123.******" },
1074 { 1.234321234321234e15L, "1234321234321234.000000" },
1075 { 1.234321234321234e16L, "123432123432123**.000000" },
1076 { 1.234321234321234e17L, "123432123432123***.000000" },
1077 { 1.234321234321234e18L, "123432123432123****.000000" },
1078 { 1.234321234321234e19L, "123432123432123*****.000000" },
1079 { 1.234321234321234e20L, "123432123432123******.000000" },
1080 { 1.234321234321234e21L, "123432123432123*******.000000" },
1081 { 1.234321234321234e22L, "123432123432123********.000000" },
1082 { 1.234321234321234e23L, "123432123432123*********.000000" },
1083 { 1.234321234321234e24L, "123432123432123**********.000000" },
1084 { 1.234321234321234e25L, "123432123432123***********.000000" },
1085 { 1.234321234321234e26L, "123432123432123************.000000" },
1086 { 1.234321234321234e27L, "123432123432123*************.000000" },
1087 { 1.234321234321234e28L, "123432123432123**************.000000" },
1088 { 1.234321234321234e29L, "123432123432123***************.000000" },
1089 { 1.234321234321234e30L, "123432123432123****************.000000" },
1090 { 1.234321234321234e31L, "123432123432123*****************.000000" },
1091 { 1.234321234321234e32L, "123432123432123******************.000000" },
1092 { 1.234321234321234e33L, "123432123432123*******************.000000" },
1093 { 1.234321234321234e34L, "123432123432123********************.000000" },
1094 { 1.234321234321234e35L, "123432123432123*********************.000000" },
1095 { 1.234321234321234e36L, "123432123432123**********************.000000" }
1098 for (k = 0; k < SIZEOF (data); k++)
1102 my_sprintf (result, "%Lf", data[k].value);
1103 ASSERT (strmatch (data[k].string, result));
1104 ASSERT (retval == strlen (result));
1108 { /* A negative number. */
1111 my_sprintf (result, "%Lf %d", -0.03125L, 33, 44, 55);
1112 ASSERT (strcmp (result, "-0.031250 33") == 0);
1113 ASSERT (retval == strlen (result));
1116 { /* Positive zero. */
1119 my_sprintf (result, "%Lf %d", 0.0L, 33, 44, 55);
1120 ASSERT (strcmp (result, "0.000000 33") == 0);
1121 ASSERT (retval == strlen (result));
1124 { /* Negative zero. */
1127 my_sprintf (result, "%Lf %d", -0.0L, 33, 44, 55);
1128 if (have_minus_zero ())
1129 ASSERT (strcmp (result, "-0.000000 33") == 0);
1130 ASSERT (retval == strlen (result));
1133 { /* Positive infinity. */
1136 my_sprintf (result, "%Lf %d", 1.0L / 0.0L, 33, 44, 55);
1137 ASSERT (strcmp (result, "inf 33") == 0
1138 || strcmp (result, "infinity 33") == 0);
1139 ASSERT (retval == strlen (result));
1142 { /* Negative infinity. */
1145 my_sprintf (result, "%Lf %d", -1.0L / 0.0L, 33, 44, 55);
1146 ASSERT (strcmp (result, "-inf 33") == 0
1147 || strcmp (result, "-infinity 33") == 0);
1148 ASSERT (retval == strlen (result));
1154 my_sprintf (result, "%Lf %d", NaNl (), 33, 44, 55);
1155 ASSERT (strlen (result) >= 3 + 3
1156 && strisnan (result, 0, strlen (result) - 3, 0)
1157 && strcmp (result + strlen (result) - 3, " 33") == 0);
1158 ASSERT (retval == strlen (result));
1160 #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_))
1162 static union { unsigned int word[4]; long double value; } x =
1163 { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
1166 my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
1167 ASSERT (strlen (result) >= 3 + 3
1168 && strisnan (result, 0, strlen (result) - 3, 0)
1169 && strcmp (result + strlen (result) - 3, " 33") == 0);
1170 ASSERT (retval == strlen (result));
1173 /* Signalling NaN. */
1174 static union { unsigned int word[4]; long double value; } x =
1175 { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
1178 my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
1179 ASSERT (strlen (result) >= 3 + 3
1180 && strisnan (result, 0, strlen (result) - 3, 0)
1181 && strcmp (result + strlen (result) - 3, " 33") == 0);
1182 ASSERT (retval == strlen (result));
1184 /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
1185 Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
1186 Intel IA-64 Architecture Software Developer's Manual, Volume 1:
1187 Application Architecture.
1188 Table 5-2 "Floating-Point Register Encodings"
1189 Figure 5-6 "Memory to Floating-Point Register Data Translation"
1192 static union { unsigned int word[4]; long double value; } x =
1193 { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
1196 my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
1197 ASSERT (strlen (result) >= 3 + 3
1198 && strisnan (result, 0, strlen (result) - 3, 0)
1199 && strcmp (result + strlen (result) - 3, " 33") == 0);
1200 ASSERT (retval == strlen (result));
1202 { /* Pseudo-Infinity. */
1203 static union { unsigned int word[4]; long double value; } x =
1204 { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
1207 my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
1208 ASSERT (strlen (result) >= 3 + 3
1209 && strisnan (result, 0, strlen (result) - 3, 0)
1210 && strcmp (result + strlen (result) - 3, " 33") == 0);
1211 ASSERT (retval == strlen (result));
1213 { /* Pseudo-Zero. */
1214 static union { unsigned int word[4]; long double value; } x =
1215 { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
1218 my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
1219 ASSERT (strlen (result) >= 3 + 3
1220 && strisnan (result, 0, strlen (result) - 3, 0)
1221 && strcmp (result + strlen (result) - 3, " 33") == 0);
1222 ASSERT (retval == strlen (result));
1224 { /* Unnormalized number. */
1225 static union { unsigned int word[4]; long double value; } x =
1226 { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
1229 my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
1230 ASSERT (strlen (result) >= 3 + 3
1231 && strisnan (result, 0, strlen (result) - 3, 0)
1232 && strcmp (result + strlen (result) - 3, " 33") == 0);
1233 ASSERT (retval == strlen (result));
1235 { /* Pseudo-Denormal. */
1236 static union { unsigned int word[4]; long double value; } x =
1237 { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
1240 my_sprintf (result, "%Lf %d", x.value, 33, 44, 55);
1241 ASSERT (strlen (result) >= 3 + 3
1242 && strisnan (result, 0, strlen (result) - 3, 0)
1243 && strcmp (result + strlen (result) - 3, " 33") == 0);
1244 ASSERT (retval == strlen (result));
1251 my_sprintf (result, "%10Lf %d", 1.75L, 33, 44, 55);
1252 ASSERT (strcmp (result, " 1.750000 33") == 0);
1253 ASSERT (retval == strlen (result));
1259 my_sprintf (result, "%-10Lf %d", 1.75L, 33, 44, 55);
1260 ASSERT (strcmp (result, "1.750000 33") == 0);
1261 ASSERT (retval == strlen (result));
1264 { /* FLAG_SHOWSIGN. */
1267 my_sprintf (result, "%+Lf %d", 1.75L, 33, 44, 55);
1268 ASSERT (strcmp (result, "+1.750000 33") == 0);
1269 ASSERT (retval == strlen (result));
1275 my_sprintf (result, "% Lf %d", 1.75L, 33, 44, 55);
1276 ASSERT (strcmp (result, " 1.750000 33") == 0);
1277 ASSERT (retval == strlen (result));
1283 my_sprintf (result, "%#Lf %d", 1.75L, 33, 44, 55);
1284 ASSERT (strcmp (result, "1.750000 33") == 0);
1285 ASSERT (retval == strlen (result));
1291 my_sprintf (result, "%#.Lf %d", 1.75L, 33, 44, 55);
1292 ASSERT (strcmp (result, "2. 33") == 0);
1293 ASSERT (retval == strlen (result));
1296 { /* FLAG_ZERO with finite number. */
1299 my_sprintf (result, "%015Lf %d", 1234.0L, 33, 44, 55);
1300 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1301 ASSERT (retval == strlen (result));
1304 { /* FLAG_ZERO with infinite number. */
1307 my_sprintf (result, "%015Lf %d", -1.0L / 0.0L, 33, 44, 55);
1308 ASSERT (strcmp (result, " -inf 33") == 0
1309 || strcmp (result, " -infinity 33") == 0);
1310 ASSERT (retval == strlen (result));
1313 { /* FLAG_ZERO with NaN. */
1316 my_sprintf (result, "%050Lf %d", NaNl (), 33, 44, 55);
1317 ASSERT (strlen (result) == 50 + 3
1318 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1319 && strcmp (result + strlen (result) - 3, " 33") == 0);
1320 ASSERT (retval == strlen (result));
1326 my_sprintf (result, "%.Lf %d", 1234.0L, 33, 44, 55);
1327 ASSERT (strcmp (result, "1234 33") == 0);
1328 ASSERT (retval == strlen (result));
1331 { /* Precision with no rounding. */
1334 my_sprintf (result, "%.2Lf %d", 999.951L, 33, 44, 55);
1335 ASSERT (strcmp (result, "999.95 33") == 0);
1336 ASSERT (retval == strlen (result));
1339 { /* Precision with rounding. */
1342 my_sprintf (result, "%.2Lf %d", 999.996L, 33, 44, 55);
1343 ASSERT (strcmp (result, "1000.00 33") == 0);
1344 ASSERT (retval == strlen (result));
1347 /* Test the support of the %F format directive. */
1349 { /* A positive number. */
1352 my_sprintf (result, "%F %d", 12.75, 33, 44, 55);
1353 ASSERT (strcmp (result, "12.750000 33") == 0);
1354 ASSERT (retval == strlen (result));
1357 { /* A larger positive number. */
1360 my_sprintf (result, "%F %d", 1234567.0, 33, 44, 55);
1361 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1362 ASSERT (retval == strlen (result));
1365 { /* A negative number. */
1368 my_sprintf (result, "%F %d", -0.03125, 33, 44, 55);
1369 ASSERT (strcmp (result, "-0.031250 33") == 0);
1370 ASSERT (retval == strlen (result));
1373 { /* Positive zero. */
1376 my_sprintf (result, "%F %d", 0.0, 33, 44, 55);
1377 ASSERT (strcmp (result, "0.000000 33") == 0);
1378 ASSERT (retval == strlen (result));
1381 { /* Negative zero. */
1384 my_sprintf (result, "%F %d", -0.0, 33, 44, 55);
1385 if (have_minus_zero ())
1386 ASSERT (strcmp (result, "-0.000000 33") == 0);
1387 ASSERT (retval == strlen (result));
1390 { /* Positive infinity. */
1393 my_sprintf (result, "%F %d", 1.0 / 0.0, 33, 44, 55);
1394 ASSERT (strcmp (result, "INF 33") == 0
1395 || strcmp (result, "INFINITY 33") == 0);
1396 ASSERT (retval == strlen (result));
1399 { /* Negative infinity. */
1402 my_sprintf (result, "%F %d", -1.0 / 0.0, 33, 44, 55);
1403 ASSERT (strcmp (result, "-INF 33") == 0
1404 || strcmp (result, "-INFINITY 33") == 0);
1405 ASSERT (retval == strlen (result));
1411 my_sprintf (result, "%F %d", NaNd (), 33, 44, 55);
1412 ASSERT (strlen (result) >= 3 + 3
1413 && strisnan (result, 0, strlen (result) - 3, 1)
1414 && strcmp (result + strlen (result) - 3, " 33") == 0);
1415 ASSERT (retval == strlen (result));
1421 my_sprintf (result, "%015F %d", 1234.0, 33, 44, 55);
1422 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1423 ASSERT (retval == strlen (result));
1426 { /* FLAG_ZERO with infinite number. */
1429 my_sprintf (result, "%015F %d", -1.0 / 0.0, 33, 44, 55);
1430 ASSERT (strcmp (result, " -INF 33") == 0
1431 || strcmp (result, " -INFINITY 33") == 0);
1432 ASSERT (retval == strlen (result));
1438 my_sprintf (result, "%.F %d", 1234.0, 33, 44, 55);
1439 ASSERT (strcmp (result, "1234 33") == 0);
1440 ASSERT (retval == strlen (result));
1443 { /* Precision with no rounding. */
1446 my_sprintf (result, "%.2F %d", 999.951, 33, 44, 55);
1447 ASSERT (strcmp (result, "999.95 33") == 0);
1448 ASSERT (retval == strlen (result));
1451 { /* Precision with rounding. */
1454 my_sprintf (result, "%.2F %d", 999.996, 33, 44, 55);
1455 ASSERT (strcmp (result, "1000.00 33") == 0);
1456 ASSERT (retval == strlen (result));
1459 { /* A positive number. */
1462 my_sprintf (result, "%LF %d", 12.75L, 33, 44, 55);
1463 ASSERT (strcmp (result, "12.750000 33") == 0);
1464 ASSERT (retval == strlen (result));
1467 { /* A larger positive number. */
1470 my_sprintf (result, "%LF %d", 1234567.0L, 33, 44, 55);
1471 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1472 ASSERT (retval == strlen (result));
1475 { /* A negative number. */
1478 my_sprintf (result, "%LF %d", -0.03125L, 33, 44, 55);
1479 ASSERT (strcmp (result, "-0.031250 33") == 0);
1480 ASSERT (retval == strlen (result));
1483 { /* Positive zero. */
1486 my_sprintf (result, "%LF %d", 0.0L, 33, 44, 55);
1487 ASSERT (strcmp (result, "0.000000 33") == 0);
1488 ASSERT (retval == strlen (result));
1491 { /* Negative zero. */
1494 my_sprintf (result, "%LF %d", -0.0L, 33, 44, 55);
1495 if (have_minus_zero ())
1496 ASSERT (strcmp (result, "-0.000000 33") == 0);
1497 ASSERT (retval == strlen (result));
1500 { /* Positive infinity. */
1503 my_sprintf (result, "%LF %d", 1.0L / 0.0L, 33, 44, 55);
1504 ASSERT (strcmp (result, "INF 33") == 0
1505 || strcmp (result, "INFINITY 33") == 0);
1506 ASSERT (retval == strlen (result));
1509 { /* Negative infinity. */
1512 my_sprintf (result, "%LF %d", -1.0L / 0.0L, 33, 44, 55);
1513 ASSERT (strcmp (result, "-INF 33") == 0
1514 || strcmp (result, "-INFINITY 33") == 0);
1515 ASSERT (retval == strlen (result));
1521 my_sprintf (result, "%LF %d", NaNl (), 33, 44, 55);
1522 ASSERT (strlen (result) >= 3 + 3
1523 && strisnan (result, 0, strlen (result) - 3, 1)
1524 && strcmp (result + strlen (result) - 3, " 33") == 0);
1525 ASSERT (retval == strlen (result));
1531 my_sprintf (result, "%015LF %d", 1234.0L, 33, 44, 55);
1532 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1533 ASSERT (retval == strlen (result));
1536 { /* FLAG_ZERO with infinite number. */
1539 my_sprintf (result, "%015LF %d", -1.0L / 0.0L, 33, 44, 55);
1540 ASSERT (strcmp (result, " -INF 33") == 0
1541 || strcmp (result, " -INFINITY 33") == 0);
1542 ASSERT (retval == strlen (result));
1548 my_sprintf (result, "%.LF %d", 1234.0L, 33, 44, 55);
1549 ASSERT (strcmp (result, "1234 33") == 0);
1550 ASSERT (retval == strlen (result));
1553 { /* Precision with no rounding. */
1556 my_sprintf (result, "%.2LF %d", 999.951L, 33, 44, 55);
1557 ASSERT (strcmp (result, "999.95 33") == 0);
1558 ASSERT (retval == strlen (result));
1561 { /* Precision with rounding. */
1564 my_sprintf (result, "%.2LF %d", 999.996L, 33, 44, 55);
1565 ASSERT (strcmp (result, "1000.00 33") == 0);
1566 ASSERT (retval == strlen (result));
1569 /* Test the support of the %e format directive. */
1571 { /* A positive number. */
1574 my_sprintf (result, "%e %d", 12.75, 33, 44, 55);
1575 ASSERT (strcmp (result, "1.275000e+01 33") == 0
1576 || strcmp (result, "1.275000e+001 33") == 0);
1577 ASSERT (retval == strlen (result));
1580 { /* A larger positive number. */
1583 my_sprintf (result, "%e %d", 1234567.0, 33, 44, 55);
1584 ASSERT (strcmp (result, "1.234567e+06 33") == 0
1585 || strcmp (result, "1.234567e+006 33") == 0);
1586 ASSERT (retval == strlen (result));
1589 { /* Small and large positive numbers. */
1590 static struct { double value; const char *string; } data[] =
1592 { 1.234321234321234e-37, "1.234321e-37" },
1593 { 1.234321234321234e-36, "1.234321e-36" },
1594 { 1.234321234321234e-35, "1.234321e-35" },
1595 { 1.234321234321234e-34, "1.234321e-34" },
1596 { 1.234321234321234e-33, "1.234321e-33" },
1597 { 1.234321234321234e-32, "1.234321e-32" },
1598 { 1.234321234321234e-31, "1.234321e-31" },
1599 { 1.234321234321234e-30, "1.234321e-30" },
1600 { 1.234321234321234e-29, "1.234321e-29" },
1601 { 1.234321234321234e-28, "1.234321e-28" },
1602 { 1.234321234321234e-27, "1.234321e-27" },
1603 { 1.234321234321234e-26, "1.234321e-26" },
1604 { 1.234321234321234e-25, "1.234321e-25" },
1605 { 1.234321234321234e-24, "1.234321e-24" },
1606 { 1.234321234321234e-23, "1.234321e-23" },
1607 { 1.234321234321234e-22, "1.234321e-22" },
1608 { 1.234321234321234e-21, "1.234321e-21" },
1609 { 1.234321234321234e-20, "1.234321e-20" },
1610 { 1.234321234321234e-19, "1.234321e-19" },
1611 { 1.234321234321234e-18, "1.234321e-18" },
1612 { 1.234321234321234e-17, "1.234321e-17" },
1613 { 1.234321234321234e-16, "1.234321e-16" },
1614 { 1.234321234321234e-15, "1.234321e-15" },
1615 { 1.234321234321234e-14, "1.234321e-14" },
1616 { 1.234321234321234e-13, "1.234321e-13" },
1617 { 1.234321234321234e-12, "1.234321e-12" },
1618 { 1.234321234321234e-11, "1.234321e-11" },
1619 { 1.234321234321234e-10, "1.234321e-10" },
1620 { 1.234321234321234e-9, "1.234321e-09" },
1621 { 1.234321234321234e-8, "1.234321e-08" },
1622 { 1.234321234321234e-7, "1.234321e-07" },
1623 { 1.234321234321234e-6, "1.234321e-06" },
1624 { 1.234321234321234e-5, "1.234321e-05" },
1625 { 1.234321234321234e-4, "1.234321e-04" },
1626 { 1.234321234321234e-3, "1.234321e-03" },
1627 { 1.234321234321234e-2, "1.234321e-02" },
1628 { 1.234321234321234e-1, "1.234321e-01" },
1629 { 1.234321234321234, "1.234321e+00" },
1630 { 1.234321234321234e1, "1.234321e+01" },
1631 { 1.234321234321234e2, "1.234321e+02" },
1632 { 1.234321234321234e3, "1.234321e+03" },
1633 { 1.234321234321234e4, "1.234321e+04" },
1634 { 1.234321234321234e5, "1.234321e+05" },
1635 { 1.234321234321234e6, "1.234321e+06" },
1636 { 1.234321234321234e7, "1.234321e+07" },
1637 { 1.234321234321234e8, "1.234321e+08" },
1638 { 1.234321234321234e9, "1.234321e+09" },
1639 { 1.234321234321234e10, "1.234321e+10" },
1640 { 1.234321234321234e11, "1.234321e+11" },
1641 { 1.234321234321234e12, "1.234321e+12" },
1642 { 1.234321234321234e13, "1.234321e+13" },
1643 { 1.234321234321234e14, "1.234321e+14" },
1644 { 1.234321234321234e15, "1.234321e+15" },
1645 { 1.234321234321234e16, "1.234321e+16" },
1646 { 1.234321234321234e17, "1.234321e+17" },
1647 { 1.234321234321234e18, "1.234321e+18" },
1648 { 1.234321234321234e19, "1.234321e+19" },
1649 { 1.234321234321234e20, "1.234321e+20" },
1650 { 1.234321234321234e21, "1.234321e+21" },
1651 { 1.234321234321234e22, "1.234321e+22" },
1652 { 1.234321234321234e23, "1.234321e+23" },
1653 { 1.234321234321234e24, "1.234321e+24" },
1654 { 1.234321234321234e25, "1.234321e+25" },
1655 { 1.234321234321234e26, "1.234321e+26" },
1656 { 1.234321234321234e27, "1.234321e+27" },
1657 { 1.234321234321234e28, "1.234321e+28" },
1658 { 1.234321234321234e29, "1.234321e+29" },
1659 { 1.234321234321234e30, "1.234321e+30" },
1660 { 1.234321234321234e31, "1.234321e+31" },
1661 { 1.234321234321234e32, "1.234321e+32" },
1662 { 1.234321234321234e33, "1.234321e+33" },
1663 { 1.234321234321234e34, "1.234321e+34" },
1664 { 1.234321234321234e35, "1.234321e+35" },
1665 { 1.234321234321234e36, "1.234321e+36" }
1668 for (k = 0; k < SIZEOF (data); k++)
1672 my_sprintf (result, "%e", data[k].value);
1673 const char *expected = data[k].string;
1674 ASSERT (result != NULL);
1675 ASSERT (strcmp (result, expected) == 0
1676 /* Some implementations produce exponents with 3 digits. */
1677 || (strlen (result) == strlen (expected) + 1
1678 && memcmp (result, expected, strlen (expected) - 2) == 0
1679 && result[strlen (expected) - 2] == '0'
1680 && strcmp (result + strlen (expected) - 1,
1681 expected + strlen (expected) - 2)
1683 ASSERT (retval == strlen (result));
1687 { /* A negative number. */
1690 my_sprintf (result, "%e %d", -0.03125, 33, 44, 55);
1691 ASSERT (strcmp (result, "-3.125000e-02 33") == 0
1692 || strcmp (result, "-3.125000e-002 33") == 0);
1693 ASSERT (retval == strlen (result));
1696 { /* Positive zero. */
1699 my_sprintf (result, "%e %d", 0.0, 33, 44, 55);
1700 ASSERT (strcmp (result, "0.000000e+00 33") == 0
1701 || strcmp (result, "0.000000e+000 33") == 0);
1702 ASSERT (retval == strlen (result));
1705 { /* Negative zero. */
1708 my_sprintf (result, "%e %d", -0.0, 33, 44, 55);
1709 if (have_minus_zero ())
1710 ASSERT (strcmp (result, "-0.000000e+00 33") == 0
1711 || strcmp (result, "-0.000000e+000 33") == 0);
1712 ASSERT (retval == strlen (result));
1715 { /* Positive infinity. */
1718 my_sprintf (result, "%e %d", 1.0 / 0.0, 33, 44, 55);
1719 ASSERT (strcmp (result, "inf 33") == 0
1720 || strcmp (result, "infinity 33") == 0);
1721 ASSERT (retval == strlen (result));
1724 { /* Negative infinity. */
1727 my_sprintf (result, "%e %d", -1.0 / 0.0, 33, 44, 55);
1728 ASSERT (strcmp (result, "-inf 33") == 0
1729 || strcmp (result, "-infinity 33") == 0);
1730 ASSERT (retval == strlen (result));
1736 my_sprintf (result, "%e %d", NaNd (), 33, 44, 55);
1737 ASSERT (strlen (result) >= 3 + 3
1738 && strisnan (result, 0, strlen (result) - 3, 0)
1739 && strcmp (result + strlen (result) - 3, " 33") == 0);
1740 ASSERT (retval == strlen (result));
1746 my_sprintf (result, "%15e %d", 1.75, 33, 44, 55);
1747 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
1748 || strcmp (result, " 1.750000e+000 33") == 0);
1749 ASSERT (retval == strlen (result));
1755 my_sprintf (result, "%-15e %d", 1.75, 33, 44, 55);
1756 ASSERT (strcmp (result, "1.750000e+00 33") == 0
1757 || strcmp (result, "1.750000e+000 33") == 0);
1758 ASSERT (retval == strlen (result));
1761 { /* FLAG_SHOWSIGN. */
1764 my_sprintf (result, "%+e %d", 1.75, 33, 44, 55);
1765 ASSERT (strcmp (result, "+1.750000e+00 33") == 0
1766 || strcmp (result, "+1.750000e+000 33") == 0);
1767 ASSERT (retval == strlen (result));
1773 my_sprintf (result, "% e %d", 1.75, 33, 44, 55);
1774 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
1775 || strcmp (result, " 1.750000e+000 33") == 0);
1776 ASSERT (retval == strlen (result));
1782 my_sprintf (result, "%#e %d", 1.75, 33, 44, 55);
1783 ASSERT (strcmp (result, "1.750000e+00 33") == 0
1784 || strcmp (result, "1.750000e+000 33") == 0);
1785 ASSERT (retval == strlen (result));
1791 my_sprintf (result, "%#.e %d", 1.75, 33, 44, 55);
1792 ASSERT (strcmp (result, "2.e+00 33") == 0
1793 || strcmp (result, "2.e+000 33") == 0);
1794 ASSERT (retval == strlen (result));
1800 my_sprintf (result, "%#.e %d", 9.75, 33, 44, 55);
1801 ASSERT (strcmp (result, "1.e+01 33") == 0
1802 || strcmp (result, "1.e+001 33") == 0);
1803 ASSERT (retval == strlen (result));
1806 { /* FLAG_ZERO with finite number. */
1809 my_sprintf (result, "%015e %d", 1234.0, 33, 44, 55);
1810 ASSERT (strcmp (result, "0001.234000e+03 33") == 0
1811 || strcmp (result, "001.234000e+003 33") == 0);
1812 ASSERT (retval == strlen (result));
1815 { /* FLAG_ZERO with infinite number. */
1818 my_sprintf (result, "%015e %d", -1.0 / 0.0, 33, 44, 55);
1819 ASSERT (strcmp (result, " -inf 33") == 0
1820 || strcmp (result, " -infinity 33") == 0);
1821 ASSERT (retval == strlen (result));
1824 { /* FLAG_ZERO with NaN. */
1827 my_sprintf (result, "%050e %d", NaNd (), 33, 44, 55);
1828 ASSERT (strlen (result) == 50 + 3
1829 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1830 && strcmp (result + strlen (result) - 3, " 33") == 0);
1831 ASSERT (retval == strlen (result));
1837 my_sprintf (result, "%.e %d", 1234.0, 33, 44, 55);
1838 ASSERT (strcmp (result, "1e+03 33") == 0
1839 || strcmp (result, "1e+003 33") == 0);
1840 ASSERT (retval == strlen (result));
1843 { /* Precision with no rounding. */
1846 my_sprintf (result, "%.4e %d", 999.951, 33, 44, 55);
1847 ASSERT (strcmp (result, "9.9995e+02 33") == 0
1848 || strcmp (result, "9.9995e+002 33") == 0);
1849 ASSERT (retval == strlen (result));
1852 { /* Precision with rounding. */
1855 my_sprintf (result, "%.4e %d", 999.996, 33, 44, 55);
1856 ASSERT (strcmp (result, "1.0000e+03 33") == 0
1857 || strcmp (result, "1.0000e+003 33") == 0);
1858 ASSERT (retval == strlen (result));
1861 { /* A positive number. */
1864 my_sprintf (result, "%Le %d", 12.75L, 33, 44, 55);
1865 ASSERT (strcmp (result, "1.275000e+01 33") == 0);
1866 ASSERT (retval == strlen (result));
1869 { /* A larger positive number. */
1872 my_sprintf (result, "%Le %d", 1234567.0L, 33, 44, 55);
1873 ASSERT (strcmp (result, "1.234567e+06 33") == 0);
1874 ASSERT (retval == strlen (result));
1877 { /* Small and large positive numbers. */
1878 static struct { long double value; const char *string; } data[] =
1880 { 1.234321234321234e-37L, "1.234321e-37" },
1881 { 1.234321234321234e-36L, "1.234321e-36" },
1882 { 1.234321234321234e-35L, "1.234321e-35" },
1883 { 1.234321234321234e-34L, "1.234321e-34" },
1884 { 1.234321234321234e-33L, "1.234321e-33" },
1885 { 1.234321234321234e-32L, "1.234321e-32" },
1886 { 1.234321234321234e-31L, "1.234321e-31" },
1887 { 1.234321234321234e-30L, "1.234321e-30" },
1888 { 1.234321234321234e-29L, "1.234321e-29" },
1889 { 1.234321234321234e-28L, "1.234321e-28" },
1890 { 1.234321234321234e-27L, "1.234321e-27" },
1891 { 1.234321234321234e-26L, "1.234321e-26" },
1892 { 1.234321234321234e-25L, "1.234321e-25" },
1893 { 1.234321234321234e-24L, "1.234321e-24" },
1894 { 1.234321234321234e-23L, "1.234321e-23" },
1895 { 1.234321234321234e-22L, "1.234321e-22" },
1896 { 1.234321234321234e-21L, "1.234321e-21" },
1897 { 1.234321234321234e-20L, "1.234321e-20" },
1898 { 1.234321234321234e-19L, "1.234321e-19" },
1899 { 1.234321234321234e-18L, "1.234321e-18" },
1900 { 1.234321234321234e-17L, "1.234321e-17" },
1901 { 1.234321234321234e-16L, "1.234321e-16" },
1902 { 1.234321234321234e-15L, "1.234321e-15" },
1903 { 1.234321234321234e-14L, "1.234321e-14" },
1904 { 1.234321234321234e-13L, "1.234321e-13" },
1905 { 1.234321234321234e-12L, "1.234321e-12" },
1906 { 1.234321234321234e-11L, "1.234321e-11" },
1907 { 1.234321234321234e-10L, "1.234321e-10" },
1908 { 1.234321234321234e-9L, "1.234321e-09" },
1909 { 1.234321234321234e-8L, "1.234321e-08" },
1910 { 1.234321234321234e-7L, "1.234321e-07" },
1911 { 1.234321234321234e-6L, "1.234321e-06" },
1912 { 1.234321234321234e-5L, "1.234321e-05" },
1913 { 1.234321234321234e-4L, "1.234321e-04" },
1914 { 1.234321234321234e-3L, "1.234321e-03" },
1915 { 1.234321234321234e-2L, "1.234321e-02" },
1916 { 1.234321234321234e-1L, "1.234321e-01" },
1917 { 1.234321234321234L, "1.234321e+00" },
1918 { 1.234321234321234e1L, "1.234321e+01" },
1919 { 1.234321234321234e2L, "1.234321e+02" },
1920 { 1.234321234321234e3L, "1.234321e+03" },
1921 { 1.234321234321234e4L, "1.234321e+04" },
1922 { 1.234321234321234e5L, "1.234321e+05" },
1923 { 1.234321234321234e6L, "1.234321e+06" },
1924 { 1.234321234321234e7L, "1.234321e+07" },
1925 { 1.234321234321234e8L, "1.234321e+08" },
1926 { 1.234321234321234e9L, "1.234321e+09" },
1927 { 1.234321234321234e10L, "1.234321e+10" },
1928 { 1.234321234321234e11L, "1.234321e+11" },
1929 { 1.234321234321234e12L, "1.234321e+12" },
1930 { 1.234321234321234e13L, "1.234321e+13" },
1931 { 1.234321234321234e14L, "1.234321e+14" },
1932 { 1.234321234321234e15L, "1.234321e+15" },
1933 { 1.234321234321234e16L, "1.234321e+16" },
1934 { 1.234321234321234e17L, "1.234321e+17" },
1935 { 1.234321234321234e18L, "1.234321e+18" },
1936 { 1.234321234321234e19L, "1.234321e+19" },
1937 { 1.234321234321234e20L, "1.234321e+20" },
1938 { 1.234321234321234e21L, "1.234321e+21" },
1939 { 1.234321234321234e22L, "1.234321e+22" },
1940 { 1.234321234321234e23L, "1.234321e+23" },
1941 { 1.234321234321234e24L, "1.234321e+24" },
1942 { 1.234321234321234e25L, "1.234321e+25" },
1943 { 1.234321234321234e26L, "1.234321e+26" },
1944 { 1.234321234321234e27L, "1.234321e+27" },
1945 { 1.234321234321234e28L, "1.234321e+28" },
1946 { 1.234321234321234e29L, "1.234321e+29" },
1947 { 1.234321234321234e30L, "1.234321e+30" },
1948 { 1.234321234321234e31L, "1.234321e+31" },
1949 { 1.234321234321234e32L, "1.234321e+32" },
1950 { 1.234321234321234e33L, "1.234321e+33" },
1951 { 1.234321234321234e34L, "1.234321e+34" },
1952 { 1.234321234321234e35L, "1.234321e+35" },
1953 { 1.234321234321234e36L, "1.234321e+36" }
1956 for (k = 0; k < SIZEOF (data); k++)
1960 my_sprintf (result, "%Le", data[k].value);
1961 ASSERT (strcmp (result, data[k].string) == 0);
1962 ASSERT (retval == strlen (result));
1966 { /* A negative number. */
1969 my_sprintf (result, "%Le %d", -0.03125L, 33, 44, 55);
1970 ASSERT (strcmp (result, "-3.125000e-02 33") == 0);
1971 ASSERT (retval == strlen (result));
1974 { /* Positive zero. */
1977 my_sprintf (result, "%Le %d", 0.0L, 33, 44, 55);
1978 ASSERT (strcmp (result, "0.000000e+00 33") == 0);
1979 ASSERT (retval == strlen (result));
1982 { /* Negative zero. */
1985 my_sprintf (result, "%Le %d", -0.0L, 33, 44, 55);
1986 if (have_minus_zero ())
1987 ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
1988 ASSERT (retval == strlen (result));
1991 { /* Positive infinity. */
1994 my_sprintf (result, "%Le %d", 1.0L / 0.0L, 33, 44, 55);
1995 ASSERT (strcmp (result, "inf 33") == 0
1996 || strcmp (result, "infinity 33") == 0);
1997 ASSERT (retval == strlen (result));
2000 { /* Negative infinity. */
2003 my_sprintf (result, "%Le %d", -1.0L / 0.0L, 33, 44, 55);
2004 ASSERT (strcmp (result, "-inf 33") == 0
2005 || strcmp (result, "-infinity 33") == 0);
2006 ASSERT (retval == strlen (result));
2012 my_sprintf (result, "%Le %d", NaNl (), 33, 44, 55);
2013 ASSERT (strlen (result) >= 3 + 3
2014 && strisnan (result, 0, strlen (result) - 3, 0)
2015 && strcmp (result + strlen (result) - 3, " 33") == 0);
2016 ASSERT (retval == strlen (result));
2018 #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_))
2020 static union { unsigned int word[4]; long double value; } x =
2021 { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
2024 my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
2025 ASSERT (strlen (result) >= 3 + 3
2026 && strisnan (result, 0, strlen (result) - 3, 0)
2027 && strcmp (result + strlen (result) - 3, " 33") == 0);
2028 ASSERT (retval == strlen (result));
2031 /* Signalling NaN. */
2032 static union { unsigned int word[4]; long double value; } x =
2033 { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
2036 my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
2037 ASSERT (strlen (result) >= 3 + 3
2038 && strisnan (result, 0, strlen (result) - 3, 0)
2039 && strcmp (result + strlen (result) - 3, " 33") == 0);
2040 ASSERT (retval == strlen (result));
2042 /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
2043 Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
2044 Intel IA-64 Architecture Software Developer's Manual, Volume 1:
2045 Application Architecture.
2046 Table 5-2 "Floating-Point Register Encodings"
2047 Figure 5-6 "Memory to Floating-Point Register Data Translation"
2050 static union { unsigned int word[4]; long double value; } x =
2051 { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
2054 my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
2055 ASSERT (strlen (result) >= 3 + 3
2056 && strisnan (result, 0, strlen (result) - 3, 0)
2057 && strcmp (result + strlen (result) - 3, " 33") == 0);
2058 ASSERT (retval == strlen (result));
2060 { /* Pseudo-Infinity. */
2061 static union { unsigned int word[4]; long double value; } x =
2062 { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
2065 my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
2066 ASSERT (strlen (result) >= 3 + 3
2067 && strisnan (result, 0, strlen (result) - 3, 0)
2068 && strcmp (result + strlen (result) - 3, " 33") == 0);
2069 ASSERT (retval == strlen (result));
2071 { /* Pseudo-Zero. */
2072 static union { unsigned int word[4]; long double value; } x =
2073 { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
2076 my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
2077 ASSERT (strlen (result) >= 3 + 3
2078 && strisnan (result, 0, strlen (result) - 3, 0)
2079 && strcmp (result + strlen (result) - 3, " 33") == 0);
2080 ASSERT (retval == strlen (result));
2082 { /* Unnormalized number. */
2083 static union { unsigned int word[4]; long double value; } x =
2084 { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
2087 my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
2088 ASSERT (strlen (result) >= 3 + 3
2089 && strisnan (result, 0, strlen (result) - 3, 0)
2090 && strcmp (result + strlen (result) - 3, " 33") == 0);
2091 ASSERT (retval == strlen (result));
2093 { /* Pseudo-Denormal. */
2094 static union { unsigned int word[4]; long double value; } x =
2095 { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
2098 my_sprintf (result, "%Le %d", x.value, 33, 44, 55);
2099 ASSERT (strlen (result) >= 3 + 3
2100 && strisnan (result, 0, strlen (result) - 3, 0)
2101 && strcmp (result + strlen (result) - 3, " 33") == 0);
2102 ASSERT (retval == strlen (result));
2109 my_sprintf (result, "%15Le %d", 1.75L, 33, 44, 55);
2110 ASSERT (strcmp (result, " 1.750000e+00 33") == 0);
2111 ASSERT (retval == strlen (result));
2117 my_sprintf (result, "%-15Le %d", 1.75L, 33, 44, 55);
2118 ASSERT (strcmp (result, "1.750000e+00 33") == 0);
2119 ASSERT (retval == strlen (result));
2122 { /* FLAG_SHOWSIGN. */
2125 my_sprintf (result, "%+Le %d", 1.75L, 33, 44, 55);
2126 ASSERT (strcmp (result, "+1.750000e+00 33") == 0);
2127 ASSERT (retval == strlen (result));
2133 my_sprintf (result, "% Le %d", 1.75L, 33, 44, 55);
2134 ASSERT (strcmp (result, " 1.750000e+00 33") == 0);
2135 ASSERT (retval == strlen (result));
2141 my_sprintf (result, "%#Le %d", 1.75L, 33, 44, 55);
2142 ASSERT (strcmp (result, "1.750000e+00 33") == 0);
2143 ASSERT (retval == strlen (result));
2149 my_sprintf (result, "%#.Le %d", 1.75L, 33, 44, 55);
2150 ASSERT (strcmp (result, "2.e+00 33") == 0);
2151 ASSERT (retval == strlen (result));
2157 my_sprintf (result, "%#.Le %d", 9.75L, 33, 44, 55);
2158 ASSERT (strcmp (result, "1.e+01 33") == 0);
2159 ASSERT (retval == strlen (result));
2162 { /* FLAG_ZERO with finite number. */
2165 my_sprintf (result, "%015Le %d", 1234.0L, 33, 44, 55);
2166 ASSERT (strcmp (result, "0001.234000e+03 33") == 0);
2167 ASSERT (retval == strlen (result));
2170 { /* FLAG_ZERO with infinite number. */
2173 my_sprintf (result, "%015Le %d", -1.0L / 0.0L, 33, 44, 55);
2174 ASSERT (strcmp (result, " -inf 33") == 0
2175 || strcmp (result, " -infinity 33") == 0);
2176 ASSERT (retval == strlen (result));
2179 { /* FLAG_ZERO with NaN. */
2182 my_sprintf (result, "%050Le %d", NaNl (), 33, 44, 55);
2183 ASSERT (strlen (result) == 50 + 3
2184 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2185 && strcmp (result + strlen (result) - 3, " 33") == 0);
2186 ASSERT (retval == strlen (result));
2192 my_sprintf (result, "%.Le %d", 1234.0L, 33, 44, 55);
2193 ASSERT (strcmp (result, "1e+03 33") == 0);
2194 ASSERT (retval == strlen (result));
2197 { /* Precision with no rounding. */
2200 my_sprintf (result, "%.4Le %d", 999.951L, 33, 44, 55);
2201 ASSERT (strcmp (result, "9.9995e+02 33") == 0);
2202 ASSERT (retval == strlen (result));
2205 { /* Precision with rounding. */
2208 my_sprintf (result, "%.4Le %d", 999.996L, 33, 44, 55);
2209 ASSERT (strcmp (result, "1.0000e+03 33") == 0);
2210 ASSERT (retval == strlen (result));
2213 /* Test the support of the %g format directive. */
2215 { /* A positive number. */
2218 my_sprintf (result, "%g %d", 12.75, 33, 44, 55);
2219 ASSERT (strcmp (result, "12.75 33") == 0);
2220 ASSERT (retval == strlen (result));
2223 { /* A larger positive number. */
2226 my_sprintf (result, "%g %d", 1234567.0, 33, 44, 55);
2227 ASSERT (strcmp (result, "1.23457e+06 33") == 0
2228 || strcmp (result, "1.23457e+006 33") == 0);
2229 ASSERT (retval == strlen (result));
2232 { /* Small and large positive numbers. */
2233 static struct { double value; const char *string; } data[] =
2235 { 1.234321234321234e-37, "1.23432e-37" },
2236 { 1.234321234321234e-36, "1.23432e-36" },
2237 { 1.234321234321234e-35, "1.23432e-35" },
2238 { 1.234321234321234e-34, "1.23432e-34" },
2239 { 1.234321234321234e-33, "1.23432e-33" },
2240 { 1.234321234321234e-32, "1.23432e-32" },
2241 { 1.234321234321234e-31, "1.23432e-31" },
2242 { 1.234321234321234e-30, "1.23432e-30" },
2243 { 1.234321234321234e-29, "1.23432e-29" },
2244 { 1.234321234321234e-28, "1.23432e-28" },
2245 { 1.234321234321234e-27, "1.23432e-27" },
2246 { 1.234321234321234e-26, "1.23432e-26" },
2247 { 1.234321234321234e-25, "1.23432e-25" },
2248 { 1.234321234321234e-24, "1.23432e-24" },
2249 { 1.234321234321234e-23, "1.23432e-23" },
2250 { 1.234321234321234e-22, "1.23432e-22" },
2251 { 1.234321234321234e-21, "1.23432e-21" },
2252 { 1.234321234321234e-20, "1.23432e-20" },
2253 { 1.234321234321234e-19, "1.23432e-19" },
2254 { 1.234321234321234e-18, "1.23432e-18" },
2255 { 1.234321234321234e-17, "1.23432e-17" },
2256 { 1.234321234321234e-16, "1.23432e-16" },
2257 { 1.234321234321234e-15, "1.23432e-15" },
2258 { 1.234321234321234e-14, "1.23432e-14" },
2259 { 1.234321234321234e-13, "1.23432e-13" },
2260 { 1.234321234321234e-12, "1.23432e-12" },
2261 { 1.234321234321234e-11, "1.23432e-11" },
2262 { 1.234321234321234e-10, "1.23432e-10" },
2263 { 1.234321234321234e-9, "1.23432e-09" },
2264 { 1.234321234321234e-8, "1.23432e-08" },
2265 { 1.234321234321234e-7, "1.23432e-07" },
2266 { 1.234321234321234e-6, "1.23432e-06" },
2267 { 1.234321234321234e-5, "1.23432e-05" },
2268 { 1.234321234321234e-4, "0.000123432" },
2269 { 1.234321234321234e-3, "0.00123432" },
2270 { 1.234321234321234e-2, "0.0123432" },
2271 { 1.234321234321234e-1, "0.123432" },
2272 { 1.234321234321234, "1.23432" },
2273 { 1.234321234321234e1, "12.3432" },
2274 { 1.234321234321234e2, "123.432" },
2275 { 1.234321234321234e3, "1234.32" },
2276 { 1.234321234321234e4, "12343.2" },
2277 { 1.234321234321234e5, "123432" },
2278 { 1.234321234321234e6, "1.23432e+06" },
2279 { 1.234321234321234e7, "1.23432e+07" },
2280 { 1.234321234321234e8, "1.23432e+08" },
2281 { 1.234321234321234e9, "1.23432e+09" },
2282 { 1.234321234321234e10, "1.23432e+10" },
2283 { 1.234321234321234e11, "1.23432e+11" },
2284 { 1.234321234321234e12, "1.23432e+12" },
2285 { 1.234321234321234e13, "1.23432e+13" },
2286 { 1.234321234321234e14, "1.23432e+14" },
2287 { 1.234321234321234e15, "1.23432e+15" },
2288 { 1.234321234321234e16, "1.23432e+16" },
2289 { 1.234321234321234e17, "1.23432e+17" },
2290 { 1.234321234321234e18, "1.23432e+18" },
2291 { 1.234321234321234e19, "1.23432e+19" },
2292 { 1.234321234321234e20, "1.23432e+20" },
2293 { 1.234321234321234e21, "1.23432e+21" },
2294 { 1.234321234321234e22, "1.23432e+22" },
2295 { 1.234321234321234e23, "1.23432e+23" },
2296 { 1.234321234321234e24, "1.23432e+24" },
2297 { 1.234321234321234e25, "1.23432e+25" },
2298 { 1.234321234321234e26, "1.23432e+26" },
2299 { 1.234321234321234e27, "1.23432e+27" },
2300 { 1.234321234321234e28, "1.23432e+28" },
2301 { 1.234321234321234e29, "1.23432e+29" },
2302 { 1.234321234321234e30, "1.23432e+30" },
2303 { 1.234321234321234e31, "1.23432e+31" },
2304 { 1.234321234321234e32, "1.23432e+32" },
2305 { 1.234321234321234e33, "1.23432e+33" },
2306 { 1.234321234321234e34, "1.23432e+34" },
2307 { 1.234321234321234e35, "1.23432e+35" },
2308 { 1.234321234321234e36, "1.23432e+36" }
2311 for (k = 0; k < SIZEOF (data); k++)
2315 my_sprintf (result, "%g", data[k].value);
2316 const char *expected = data[k].string;
2317 ASSERT (strcmp (result, expected) == 0
2318 /* Some implementations produce exponents with 3 digits. */
2319 || (expected[strlen (expected) - 4] == 'e'
2320 && strlen (result) == strlen (expected) + 1
2321 && memcmp (result, expected, strlen (expected) - 2) == 0
2322 && result[strlen (expected) - 2] == '0'
2323 && strcmp (result + strlen (expected) - 1,
2324 expected + strlen (expected) - 2)
2326 ASSERT (retval == strlen (result));
2330 { /* A negative number. */
2333 my_sprintf (result, "%g %d", -0.03125, 33, 44, 55);
2334 ASSERT (strcmp (result, "-0.03125 33") == 0);
2335 ASSERT (retval == strlen (result));
2338 { /* Positive zero. */
2341 my_sprintf (result, "%g %d", 0.0, 33, 44, 55);
2342 ASSERT (strcmp (result, "0 33") == 0);
2343 ASSERT (retval == strlen (result));
2346 { /* Negative zero. */
2349 my_sprintf (result, "%g %d", -0.0, 33, 44, 55);
2350 if (have_minus_zero ())
2351 ASSERT (strcmp (result, "-0 33") == 0);
2352 ASSERT (retval == strlen (result));
2355 { /* Positive infinity. */
2358 my_sprintf (result, "%g %d", 1.0 / 0.0, 33, 44, 55);
2359 ASSERT (strcmp (result, "inf 33") == 0
2360 || strcmp (result, "infinity 33") == 0);
2361 ASSERT (retval == strlen (result));
2364 { /* Negative infinity. */
2367 my_sprintf (result, "%g %d", -1.0 / 0.0, 33, 44, 55);
2368 ASSERT (strcmp (result, "-inf 33") == 0
2369 || strcmp (result, "-infinity 33") == 0);
2370 ASSERT (retval == strlen (result));
2376 my_sprintf (result, "%g %d", NaNd (), 33, 44, 55);
2377 ASSERT (strlen (result) >= 3 + 3
2378 && strisnan (result, 0, strlen (result) - 3, 0)
2379 && strcmp (result + strlen (result) - 3, " 33") == 0);
2380 ASSERT (retval == strlen (result));
2386 my_sprintf (result, "%10g %d", 1.75, 33, 44, 55);
2387 ASSERT (strcmp (result, " 1.75 33") == 0);
2388 ASSERT (retval == strlen (result));
2394 my_sprintf (result, "%-10g %d", 1.75, 33, 44, 55);
2395 ASSERT (strcmp (result, "1.75 33") == 0);
2396 ASSERT (retval == strlen (result));
2399 { /* FLAG_SHOWSIGN. */
2402 my_sprintf (result, "%+g %d", 1.75, 33, 44, 55);
2403 ASSERT (strcmp (result, "+1.75 33") == 0);
2404 ASSERT (retval == strlen (result));
2410 my_sprintf (result, "% g %d", 1.75, 33, 44, 55);
2411 ASSERT (strcmp (result, " 1.75 33") == 0);
2412 ASSERT (retval == strlen (result));
2418 my_sprintf (result, "%#g %d", 1.75, 33, 44, 55);
2419 ASSERT (strcmp (result, "1.75000 33") == 0);
2420 ASSERT (retval == strlen (result));
2426 my_sprintf (result, "%#.g %d", 1.75, 33, 44, 55);
2427 ASSERT (strcmp (result, "2. 33") == 0);
2428 ASSERT (retval == strlen (result));
2434 my_sprintf (result, "%#.g %d", 9.75, 33, 44, 55);
2435 ASSERT (strcmp (result, "1.e+01 33") == 0
2436 || strcmp (result, "1.e+001 33") == 0);
2437 ASSERT (retval == strlen (result));
2440 { /* FLAG_ZERO with finite number. */
2443 my_sprintf (result, "%010g %d", 1234.0, 33, 44, 55);
2444 ASSERT (strcmp (result, "0000001234 33") == 0);
2445 ASSERT (retval == strlen (result));
2448 { /* FLAG_ZERO with infinite number. */
2451 my_sprintf (result, "%015g %d", -1.0 / 0.0, 33, 44, 55);
2452 ASSERT (strcmp (result, " -inf 33") == 0
2453 || strcmp (result, " -infinity 33") == 0);
2454 ASSERT (retval == strlen (result));
2457 { /* FLAG_ZERO with NaN. */
2460 my_sprintf (result, "%050g %d", NaNd (), 33, 44, 55);
2461 ASSERT (strlen (result) == 50 + 3
2462 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2463 && strcmp (result + strlen (result) - 3, " 33") == 0);
2464 ASSERT (retval == strlen (result));
2470 my_sprintf (result, "%.g %d", 1234.0, 33, 44, 55);
2471 ASSERT (strcmp (result, "1e+03 33") == 0
2472 || strcmp (result, "1e+003 33") == 0);
2473 ASSERT (retval == strlen (result));
2476 { /* Precision with no rounding. */
2479 my_sprintf (result, "%.5g %d", 999.951, 33, 44, 55);
2480 ASSERT (strcmp (result, "999.95 33") == 0);
2481 ASSERT (retval == strlen (result));
2484 { /* Precision with rounding. */
2487 my_sprintf (result, "%.5g %d", 999.996, 33, 44, 55);
2488 ASSERT (strcmp (result, "1000 33") == 0);
2489 ASSERT (retval == strlen (result));
2492 { /* A positive number. */
2495 my_sprintf (result, "%Lg %d", 12.75L, 33, 44, 55);
2496 ASSERT (strcmp (result, "12.75 33") == 0);
2497 ASSERT (retval == strlen (result));
2500 { /* A larger positive number. */
2503 my_sprintf (result, "%Lg %d", 1234567.0L, 33, 44, 55);
2504 ASSERT (strcmp (result, "1.23457e+06 33") == 0);
2505 ASSERT (retval == strlen (result));
2508 { /* Small and large positive numbers. */
2509 static struct { long double value; const char *string; } data[] =
2511 { 1.234321234321234e-37L, "1.23432e-37" },
2512 { 1.234321234321234e-36L, "1.23432e-36" },
2513 { 1.234321234321234e-35L, "1.23432e-35" },
2514 { 1.234321234321234e-34L, "1.23432e-34" },
2515 { 1.234321234321234e-33L, "1.23432e-33" },
2516 { 1.234321234321234e-32L, "1.23432e-32" },
2517 { 1.234321234321234e-31L, "1.23432e-31" },
2518 { 1.234321234321234e-30L, "1.23432e-30" },
2519 { 1.234321234321234e-29L, "1.23432e-29" },
2520 { 1.234321234321234e-28L, "1.23432e-28" },
2521 { 1.234321234321234e-27L, "1.23432e-27" },
2522 { 1.234321234321234e-26L, "1.23432e-26" },
2523 { 1.234321234321234e-25L, "1.23432e-25" },
2524 { 1.234321234321234e-24L, "1.23432e-24" },
2525 { 1.234321234321234e-23L, "1.23432e-23" },
2526 { 1.234321234321234e-22L, "1.23432e-22" },
2527 { 1.234321234321234e-21L, "1.23432e-21" },
2528 { 1.234321234321234e-20L, "1.23432e-20" },
2529 { 1.234321234321234e-19L, "1.23432e-19" },
2530 { 1.234321234321234e-18L, "1.23432e-18" },
2531 { 1.234321234321234e-17L, "1.23432e-17" },
2532 { 1.234321234321234e-16L, "1.23432e-16" },
2533 { 1.234321234321234e-15L, "1.23432e-15" },
2534 { 1.234321234321234e-14L, "1.23432e-14" },
2535 { 1.234321234321234e-13L, "1.23432e-13" },
2536 { 1.234321234321234e-12L, "1.23432e-12" },
2537 { 1.234321234321234e-11L, "1.23432e-11" },
2538 { 1.234321234321234e-10L, "1.23432e-10" },
2539 { 1.234321234321234e-9L, "1.23432e-09" },
2540 { 1.234321234321234e-8L, "1.23432e-08" },
2541 { 1.234321234321234e-7L, "1.23432e-07" },
2542 { 1.234321234321234e-6L, "1.23432e-06" },
2543 { 1.234321234321234e-5L, "1.23432e-05" },
2544 { 1.234321234321234e-4L, "0.000123432" },
2545 { 1.234321234321234e-3L, "0.00123432" },
2546 { 1.234321234321234e-2L, "0.0123432" },
2547 { 1.234321234321234e-1L, "0.123432" },
2548 { 1.234321234321234L, "1.23432" },
2549 { 1.234321234321234e1L, "12.3432" },
2550 { 1.234321234321234e2L, "123.432" },
2551 { 1.234321234321234e3L, "1234.32" },
2552 { 1.234321234321234e4L, "12343.2" },
2553 { 1.234321234321234e5L, "123432" },
2554 { 1.234321234321234e6L, "1.23432e+06" },
2555 { 1.234321234321234e7L, "1.23432e+07" },
2556 { 1.234321234321234e8L, "1.23432e+08" },
2557 { 1.234321234321234e9L, "1.23432e+09" },
2558 { 1.234321234321234e10L, "1.23432e+10" },
2559 { 1.234321234321234e11L, "1.23432e+11" },
2560 { 1.234321234321234e12L, "1.23432e+12" },
2561 { 1.234321234321234e13L, "1.23432e+13" },
2562 { 1.234321234321234e14L, "1.23432e+14" },
2563 { 1.234321234321234e15L, "1.23432e+15" },
2564 { 1.234321234321234e16L, "1.23432e+16" },
2565 { 1.234321234321234e17L, "1.23432e+17" },
2566 { 1.234321234321234e18L, "1.23432e+18" },
2567 { 1.234321234321234e19L, "1.23432e+19" },
2568 { 1.234321234321234e20L, "1.23432e+20" },
2569 { 1.234321234321234e21L, "1.23432e+21" },
2570 { 1.234321234321234e22L, "1.23432e+22" },
2571 { 1.234321234321234e23L, "1.23432e+23" },
2572 { 1.234321234321234e24L, "1.23432e+24" },
2573 { 1.234321234321234e25L, "1.23432e+25" },
2574 { 1.234321234321234e26L, "1.23432e+26" },
2575 { 1.234321234321234e27L, "1.23432e+27" },
2576 { 1.234321234321234e28L, "1.23432e+28" },
2577 { 1.234321234321234e29L, "1.23432e+29" },
2578 { 1.234321234321234e30L, "1.23432e+30" },
2579 { 1.234321234321234e31L, "1.23432e+31" },
2580 { 1.234321234321234e32L, "1.23432e+32" },
2581 { 1.234321234321234e33L, "1.23432e+33" },
2582 { 1.234321234321234e34L, "1.23432e+34" },
2583 { 1.234321234321234e35L, "1.23432e+35" },
2584 { 1.234321234321234e36L, "1.23432e+36" }
2587 for (k = 0; k < SIZEOF (data); k++)
2591 my_sprintf (result, "%Lg", data[k].value);
2592 ASSERT (strcmp (result, data[k].string) == 0);
2593 ASSERT (retval == strlen (result));
2597 { /* A negative number. */
2600 my_sprintf (result, "%Lg %d", -0.03125L, 33, 44, 55);
2601 ASSERT (strcmp (result, "-0.03125 33") == 0);
2602 ASSERT (retval == strlen (result));
2605 { /* Positive zero. */
2608 my_sprintf (result, "%Lg %d", 0.0L, 33, 44, 55);
2609 ASSERT (strcmp (result, "0 33") == 0);
2610 ASSERT (retval == strlen (result));
2613 { /* Negative zero. */
2616 my_sprintf (result, "%Lg %d", -0.0L, 33, 44, 55);
2617 if (have_minus_zero ())
2618 ASSERT (strcmp (result, "-0 33") == 0);
2619 ASSERT (retval == strlen (result));
2622 { /* Positive infinity. */
2625 my_sprintf (result, "%Lg %d", 1.0L / 0.0L, 33, 44, 55);
2626 ASSERT (strcmp (result, "inf 33") == 0
2627 || strcmp (result, "infinity 33") == 0);
2628 ASSERT (retval == strlen (result));
2631 { /* Negative infinity. */
2634 my_sprintf (result, "%Lg %d", -1.0L / 0.0L, 33, 44, 55);
2635 ASSERT (strcmp (result, "-inf 33") == 0
2636 || strcmp (result, "-infinity 33") == 0);
2637 ASSERT (retval == strlen (result));
2643 my_sprintf (result, "%Lg %d", NaNl (), 33, 44, 55);
2644 ASSERT (strlen (result) >= 3 + 3
2645 && strisnan (result, 0, strlen (result) - 3, 0)
2646 && strcmp (result + strlen (result) - 3, " 33") == 0);
2647 ASSERT (retval == strlen (result));
2649 #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_))
2651 static union { unsigned int word[4]; long double value; } x =
2652 { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
2655 my_sprintf (result, "%La %d", x.value, 33, 44, 55);
2656 ASSERT (strlen (result) >= 3 + 3
2657 && strisnan (result, 0, strlen (result) - 3, 0)
2658 && strcmp (result + strlen (result) - 3, " 33") == 0);
2659 ASSERT (retval == strlen (result));
2662 /* Signalling NaN. */
2663 static union { unsigned int word[4]; long double value; } x =
2664 { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
2667 my_sprintf (result, "%La %d", x.value, 33, 44, 55);
2668 ASSERT (strlen (result) >= 3 + 3
2669 && strisnan (result, 0, strlen (result) - 3, 0)
2670 && strcmp (result + strlen (result) - 3, " 33") == 0);
2671 ASSERT (retval == strlen (result));
2673 /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
2674 Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
2675 Intel IA-64 Architecture Software Developer's Manual, Volume 1:
2676 Application Architecture.
2677 Table 5-2 "Floating-Point Register Encodings"
2678 Figure 5-6 "Memory to Floating-Point Register Data Translation"
2681 static union { unsigned int word[4]; long double value; } x =
2682 { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
2685 my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
2686 ASSERT (strlen (result) >= 3 + 3
2687 && strisnan (result, 0, strlen (result) - 3, 0)
2688 && strcmp (result + strlen (result) - 3, " 33") == 0);
2689 ASSERT (retval == strlen (result));
2691 { /* Pseudo-Infinity. */
2692 static union { unsigned int word[4]; long double value; } x =
2693 { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
2696 my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
2697 ASSERT (strlen (result) >= 3 + 3
2698 && strisnan (result, 0, strlen (result) - 3, 0)
2699 && strcmp (result + strlen (result) - 3, " 33") == 0);
2700 ASSERT (retval == strlen (result));
2702 { /* Pseudo-Zero. */
2703 static union { unsigned int word[4]; long double value; } x =
2704 { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
2707 my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
2708 ASSERT (strlen (result) >= 3 + 3
2709 && strisnan (result, 0, strlen (result) - 3, 0)
2710 && strcmp (result + strlen (result) - 3, " 33") == 0);
2711 ASSERT (retval == strlen (result));
2713 { /* Unnormalized number. */
2714 static union { unsigned int word[4]; long double value; } x =
2715 { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
2718 my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
2719 ASSERT (strlen (result) >= 3 + 3
2720 && strisnan (result, 0, strlen (result) - 3, 0)
2721 && strcmp (result + strlen (result) - 3, " 33") == 0);
2722 ASSERT (retval == strlen (result));
2724 { /* Pseudo-Denormal. */
2725 static union { unsigned int word[4]; long double value; } x =
2726 { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
2729 my_sprintf (result, "%Lg %d", x.value, 33, 44, 55);
2730 ASSERT (strlen (result) >= 3 + 3
2731 && strisnan (result, 0, strlen (result) - 3, 0)
2732 && strcmp (result + strlen (result) - 3, " 33") == 0);
2733 ASSERT (retval == strlen (result));
2740 my_sprintf (result, "%10Lg %d", 1.75L, 33, 44, 55);
2741 ASSERT (strcmp (result, " 1.75 33") == 0);
2742 ASSERT (retval == strlen (result));
2748 my_sprintf (result, "%-10Lg %d", 1.75L, 33, 44, 55);
2749 ASSERT (strcmp (result, "1.75 33") == 0);
2750 ASSERT (retval == strlen (result));
2753 { /* FLAG_SHOWSIGN. */
2756 my_sprintf (result, "%+Lg %d", 1.75L, 33, 44, 55);
2757 ASSERT (strcmp (result, "+1.75 33") == 0);
2758 ASSERT (retval == strlen (result));
2764 my_sprintf (result, "% Lg %d", 1.75L, 33, 44, 55);
2765 ASSERT (strcmp (result, " 1.75 33") == 0);
2766 ASSERT (retval == strlen (result));
2772 my_sprintf (result, "%#Lg %d", 1.75L, 33, 44, 55);
2773 ASSERT (strcmp (result, "1.75000 33") == 0);
2774 ASSERT (retval == strlen (result));
2780 my_sprintf (result, "%#.Lg %d", 1.75L, 33, 44, 55);
2781 ASSERT (strcmp (result, "2. 33") == 0);
2782 ASSERT (retval == strlen (result));
2788 my_sprintf (result, "%#.Lg %d", 9.75L, 33, 44, 55);
2789 ASSERT (strcmp (result, "1.e+01 33") == 0);
2790 ASSERT (retval == strlen (result));
2793 { /* FLAG_ZERO with finite number. */
2796 my_sprintf (result, "%010Lg %d", 1234.0L, 33, 44, 55);
2797 ASSERT (strcmp (result, "0000001234 33") == 0);
2798 ASSERT (retval == strlen (result));
2801 { /* FLAG_ZERO with infinite number. */
2804 my_sprintf (result, "%015Lg %d", -1.0L / 0.0L, 33, 44, 55);
2805 ASSERT (strcmp (result, " -inf 33") == 0
2806 || strcmp (result, " -infinity 33") == 0);
2807 ASSERT (retval == strlen (result));
2810 { /* FLAG_ZERO with NaN. */
2813 my_sprintf (result, "%050Lg %d", NaNl (), 33, 44, 55);
2814 ASSERT (strlen (result) == 50 + 3
2815 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2816 && strcmp (result + strlen (result) - 3, " 33") == 0);
2817 ASSERT (retval == strlen (result));
2823 my_sprintf (result, "%.Lg %d", 1234.0L, 33, 44, 55);
2824 ASSERT (strcmp (result, "1e+03 33") == 0);
2825 ASSERT (retval == strlen (result));
2828 { /* Precision with no rounding. */
2831 my_sprintf (result, "%.5Lg %d", 999.951L, 33, 44, 55);
2832 ASSERT (strcmp (result, "999.95 33") == 0);
2833 ASSERT (retval == strlen (result));
2836 { /* Precision with rounding. */
2839 my_sprintf (result, "%.5Lg %d", 999.996L, 33, 44, 55);
2840 ASSERT (strcmp (result, "1000 33") == 0);
2841 ASSERT (retval == strlen (result));
2844 /* Test the support of the %n format directive. */
2850 my_sprintf (result, "%d %n", 123, &count, 33, 44, 55);
2851 ASSERT (strcmp (result, "123 ") == 0);
2852 ASSERT (retval == strlen (result));
2853 ASSERT (count == 4);
2856 /* Test the support of the POSIX/XSI format strings with positions. */
2861 my_sprintf (result, "%2$d %1$d", 33, 55);
2862 ASSERT (strcmp (result, "55 33") == 0);
2863 ASSERT (retval == strlen (result));
2866 /* Test the support of the grouping flag. */
2871 my_sprintf (result, "%'d %d", 1234567, 99);
2872 ASSERT (result[strlen (result) - 1] == '9');
2873 ASSERT (retval == strlen (result));
2876 /* Test the support of the left-adjust flag. */
2881 my_sprintf (result, "a%*sc", -3, "b");
2882 ASSERT (strcmp (result, "ab c") == 0);
2883 ASSERT (retval == strlen (result));
2889 my_sprintf (result, "a%-*sc", 3, "b");
2890 ASSERT (strcmp (result, "ab c") == 0);
2891 ASSERT (retval == strlen (result));
2897 my_sprintf (result, "a%-*sc", -3, "b");
2898 ASSERT (strcmp (result, "ab c") == 0);
2899 ASSERT (retval == strlen (result));
2902 /* Test the support of large precision. */
2907 my_sprintf (result, "%.4000d %d", 1234567, 99);
2909 ASSERT (result != NULL);
2910 for (i = 0; i < 4000 - 7; i++)
2911 ASSERT (result[i] == '0');
2912 ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
2913 ASSERT (retval == strlen (result));
2919 my_sprintf (result, "%.4000d %d", -1234567, 99);
2921 ASSERT (result != NULL);
2922 ASSERT (result[0] == '-');
2923 for (i = 0; i < 4000 - 7; i++)
2924 ASSERT (result[1 + i] == '0');
2925 ASSERT (strcmp (result + 1 + 4000 - 7, "1234567 99") == 0);
2926 ASSERT (retval == strlen (result));
2932 my_sprintf (result, "%.4000u %d", 1234567, 99);
2934 ASSERT (result != NULL);
2935 for (i = 0; i < 4000 - 7; i++)
2936 ASSERT (result[i] == '0');
2937 ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
2938 ASSERT (retval == strlen (result));
2944 my_sprintf (result, "%.4000o %d", 1234567, 99);
2946 ASSERT (result != NULL);
2947 for (i = 0; i < 4000 - 7; i++)
2948 ASSERT (result[i] == '0');
2949 ASSERT (strcmp (result + 4000 - 7, "4553207 99") == 0);
2950 ASSERT (retval == strlen (result));
2956 my_sprintf (result, "%.4000x %d", 1234567, 99);
2958 ASSERT (result != NULL);
2959 for (i = 0; i < 4000 - 6; i++)
2960 ASSERT (result[i] == '0');
2961 ASSERT (strcmp (result + 4000 - 6, "12d687 99") == 0);
2962 ASSERT (retval == strlen (result));
2968 my_sprintf (result, "%#.4000x %d", 1234567, 99);
2970 ASSERT (result != NULL);
2971 ASSERT (result[0] == '0');
2972 ASSERT (result[1] == 'x');
2973 for (i = 0; i < 4000 - 6; i++)
2974 ASSERT (result[2 + i] == '0');
2975 ASSERT (strcmp (result + 2 + 4000 - 6, "12d687 99") == 0);
2976 ASSERT (retval == strlen (result));
2985 for (i = 0; i < sizeof (input) - 1; i++)
2986 input[i] = 'a' + ((1000000 / (i + 1)) % 26);
2988 retval = my_sprintf (result, "%.4000s %d", input, 99);
2989 ASSERT (result != NULL);
2990 ASSERT (memcmp (result, input, 4000) == 0);
2991 ASSERT (strcmp (result + 4000, " 99") == 0);
2992 ASSERT (retval == strlen (result));