1 /* Test of POSIX compatible vsprintf() and sprintf() functions.
2 Copyright (C) 2007 Free Software Foundation, Inc.
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2, or (at your option)
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software Foundation,
16 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
18 /* Written by Bruno Haible <bruno@clisp.org>, 2007. */
20 /* The Compaq (ex-DEC) C 6.4 compiler chokes on the expression 0.0 / 0.0. */
25 static double zero = 0.0;
29 # define NaN() (0.0 / 0.0)
32 /* The SGI MIPS floating-point format does not distinguish 0.0 and -0.0. */
36 static double plus_zero = 0.0;
37 static double minus_zero = -0.0;
38 return memcmp (&plus_zero, &minus_zero, sizeof (double)) != 0;
42 strmatch (const char *pattern, const char *string)
44 if (strlen (pattern) != strlen (string))
46 for (; *pattern != '\0'; pattern++, string++)
47 if (*pattern != '*' && *string != *pattern)
52 /* Test whether string[start_index..end_index-1] is a valid textual
53 representation of NaN. */
55 strisnan (const char *string, size_t start_index, size_t end_index, int uppercase)
57 if (start_index < end_index)
59 if (string[start_index] == '-')
61 if (start_index + 3 <= end_index
62 && memcmp (string + start_index, uppercase ? "NAN" : "nan", 3) == 0)
65 if (start_index == end_index
66 || (string[start_index] == '(' && string[end_index - 1] == ')'))
74 test_function (int (*my_sprintf) (char *, const char *, ...))
78 /* Test return value convention. */
83 memcpy (buf, "DEADBEEF", 8);
84 retval = my_sprintf (buf, "%d", 12345);
86 ASSERT (memcmp (buf, "12345\0EF", 8) == 0);
89 /* Test support of size specifiers as in C99. */
94 my_sprintf (result, "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
95 ASSERT (strcmp (result, "12345671 33") == 0);
96 ASSERT (retval == strlen (result));
102 my_sprintf (result, "%zu %d", (size_t) 12345672, 33, 44, 55);
103 ASSERT (strcmp (result, "12345672 33") == 0);
104 ASSERT (retval == strlen (result));
110 my_sprintf (result, "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
111 ASSERT (strcmp (result, "12345673 33") == 0);
112 ASSERT (retval == strlen (result));
118 my_sprintf (result, "%Lg %d", (long double) 1.5, 33, 44, 55);
119 ASSERT (strcmp (result, "1.5 33") == 0);
120 ASSERT (retval == strlen (result));
123 /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
124 output of floating-point numbers. */
126 { /* A positive number. */
129 my_sprintf (result, "%a %d", 3.1416015625, 33, 44, 55);
130 ASSERT (strcmp (result, "0x1.922p+1 33") == 0
131 || strcmp (result, "0x3.244p+0 33") == 0
132 || strcmp (result, "0x6.488p-1 33") == 0
133 || strcmp (result, "0xc.91p-2 33") == 0);
134 ASSERT (retval == strlen (result));
137 { /* A negative number. */
140 my_sprintf (result, "%A %d", -3.1416015625, 33, 44, 55);
141 ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
142 || strcmp (result, "-0X3.244P+0 33") == 0
143 || strcmp (result, "-0X6.488P-1 33") == 0
144 || strcmp (result, "-0XC.91P-2 33") == 0);
145 ASSERT (retval == strlen (result));
148 { /* Positive zero. */
151 my_sprintf (result, "%a %d", 0.0, 33, 44, 55);
152 ASSERT (strcmp (result, "0x0p+0 33") == 0);
153 ASSERT (retval == strlen (result));
156 { /* Negative zero. */
159 my_sprintf (result, "%a %d", -0.0, 33, 44, 55);
160 if (have_minus_zero ())
161 ASSERT (strcmp (result, "-0x0p+0 33") == 0);
162 ASSERT (retval == strlen (result));
165 { /* Positive infinity. */
168 my_sprintf (result, "%a %d", 1.0 / 0.0, 33, 44, 55);
169 ASSERT (strcmp (result, "inf 33") == 0);
170 ASSERT (retval == strlen (result));
173 { /* Negative infinity. */
176 my_sprintf (result, "%a %d", -1.0 / 0.0, 33, 44, 55);
177 ASSERT (strcmp (result, "-inf 33") == 0);
178 ASSERT (retval == strlen (result));
184 my_sprintf (result, "%a %d", NaN (), 33, 44, 55);
185 ASSERT (strlen (result) >= 3 + 3
186 && strisnan (result, 0, strlen (result) - 3, 0)
187 && strcmp (result + strlen (result) - 3, " 33") == 0);
188 ASSERT (retval == strlen (result));
191 { /* Rounding near the decimal point. */
194 my_sprintf (result, "%.0a %d", 1.5, 33, 44, 55);
195 ASSERT (strcmp (result, "0x2p+0 33") == 0
196 || strcmp (result, "0x3p-1 33") == 0
197 || strcmp (result, "0x6p-2 33") == 0
198 || strcmp (result, "0xcp-3 33") == 0);
199 ASSERT (retval == strlen (result));
202 { /* Rounding with precision 0. */
205 my_sprintf (result, "%.0a %d", 1.51, 33, 44, 55);
206 ASSERT (strcmp (result, "0x2p+0 33") == 0
207 || strcmp (result, "0x3p-1 33") == 0
208 || strcmp (result, "0x6p-2 33") == 0
209 || strcmp (result, "0xcp-3 33") == 0);
210 ASSERT (retval == strlen (result));
213 { /* Rounding with precision 1. */
216 my_sprintf (result, "%.1a %d", 1.51, 33, 44, 55);
217 ASSERT (strcmp (result, "0x1.8p+0 33") == 0
218 || strcmp (result, "0x3.0p-1 33") == 0
219 || strcmp (result, "0x6.1p-2 33") == 0
220 || strcmp (result, "0xc.1p-3 33") == 0);
221 ASSERT (retval == strlen (result));
224 { /* Rounding with precision 2. */
227 my_sprintf (result, "%.2a %d", 1.51, 33, 44, 55);
228 ASSERT (strcmp (result, "0x1.83p+0 33") == 0
229 || strcmp (result, "0x3.05p-1 33") == 0
230 || strcmp (result, "0x6.0ap-2 33") == 0
231 || strcmp (result, "0xc.14p-3 33") == 0);
232 ASSERT (retval == strlen (result));
235 { /* Rounding with precision 3. */
238 my_sprintf (result, "%.3a %d", 1.51, 33, 44, 55);
239 ASSERT (strcmp (result, "0x1.829p+0 33") == 0
240 || strcmp (result, "0x3.052p-1 33") == 0
241 || strcmp (result, "0x6.0a4p-2 33") == 0
242 || strcmp (result, "0xc.148p-3 33") == 0);
243 ASSERT (retval == strlen (result));
246 { /* Rounding can turn a ...FFF into a ...000. */
249 my_sprintf (result, "%.3a %d", 1.49999, 33, 44, 55);
250 ASSERT (strcmp (result, "0x1.800p+0 33") == 0
251 || strcmp (result, "0x3.000p-1 33") == 0
252 || strcmp (result, "0x6.000p-2 33") == 0
253 || strcmp (result, "0xc.000p-3 33") == 0);
254 ASSERT (retval == strlen (result));
257 { /* Rounding can turn a ...FFF into a ...000.
258 This shows a MacOS X 10.3.9 (Darwin 7.9) bug. */
261 my_sprintf (result, "%.1a %d", 1.999, 33, 44, 55);
262 ASSERT (strcmp (result, "0x1.0p+1 33") == 0
263 || strcmp (result, "0x2.0p+0 33") == 0
264 || strcmp (result, "0x4.0p-1 33") == 0
265 || strcmp (result, "0x8.0p-2 33") == 0);
266 ASSERT (retval == strlen (result));
272 my_sprintf (result, "%10a %d", 1.75, 33, 44, 55);
273 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
274 || strcmp (result, " 0x3.8p-1 33") == 0
275 || strcmp (result, " 0x7p-2 33") == 0
276 || strcmp (result, " 0xep-3 33") == 0);
277 ASSERT (retval == strlen (result));
280 { /* Small precision. */
283 my_sprintf (result, "%.10a %d", 1.75, 33, 44, 55);
284 ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
285 || strcmp (result, "0x3.8000000000p-1 33") == 0
286 || strcmp (result, "0x7.0000000000p-2 33") == 0
287 || strcmp (result, "0xe.0000000000p-3 33") == 0);
288 ASSERT (retval == strlen (result));
291 { /* Large precision. */
294 my_sprintf (result, "%.50a %d", 1.75, 33, 44, 55);
295 ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
296 || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
297 || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
298 || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
299 ASSERT (retval == strlen (result));
305 my_sprintf (result, "%-10a %d", 1.75, 33, 44, 55);
306 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
307 || strcmp (result, "0x3.8p-1 33") == 0
308 || strcmp (result, "0x7p-2 33") == 0
309 || strcmp (result, "0xep-3 33") == 0);
310 ASSERT (retval == strlen (result));
313 { /* FLAG_SHOWSIGN. */
316 my_sprintf (result, "%+a %d", 1.75, 33, 44, 55);
317 ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
318 || strcmp (result, "+0x3.8p-1 33") == 0
319 || strcmp (result, "+0x7p-2 33") == 0
320 || strcmp (result, "+0xep-3 33") == 0);
321 ASSERT (retval == strlen (result));
327 my_sprintf (result, "% a %d", 1.75, 33, 44, 55);
328 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
329 || strcmp (result, " 0x3.8p-1 33") == 0
330 || strcmp (result, " 0x7p-2 33") == 0
331 || strcmp (result, " 0xep-3 33") == 0);
332 ASSERT (retval == strlen (result));
338 my_sprintf (result, "%#a %d", 1.75, 33, 44, 55);
339 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
340 || strcmp (result, "0x3.8p-1 33") == 0
341 || strcmp (result, "0x7.p-2 33") == 0
342 || strcmp (result, "0xe.p-3 33") == 0);
343 ASSERT (retval == strlen (result));
349 my_sprintf (result, "%#a %d", 1.0, 33, 44, 55);
350 ASSERT (strcmp (result, "0x1.p+0 33") == 0
351 || strcmp (result, "0x2.p-1 33") == 0
352 || strcmp (result, "0x4.p-2 33") == 0
353 || strcmp (result, "0x8.p-3 33") == 0);
354 ASSERT (retval == strlen (result));
357 { /* FLAG_ZERO with finite number. */
360 my_sprintf (result, "%010a %d", 1.75, 33, 44, 55);
361 ASSERT (strcmp (result, "0x001.cp+0 33") == 0
362 || strcmp (result, "0x003.8p-1 33") == 0
363 || strcmp (result, "0x00007p-2 33") == 0
364 || strcmp (result, "0x0000ep-3 33") == 0);
365 ASSERT (retval == strlen (result));
368 { /* FLAG_ZERO with infinite number. */
371 my_sprintf (result, "%010a %d", 1.0 / 0.0, 33, 44, 55);
372 /* "0000000inf 33" is not a valid result; see
373 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
374 ASSERT (strcmp (result, " inf 33") == 0);
375 ASSERT (retval == strlen (result));
378 { /* FLAG_ZERO with NaN. */
381 my_sprintf (result, "%050a %d", NaN (), 33, 44, 55);
382 /* "0000000nan 33" is not a valid result; see
383 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
384 ASSERT (strlen (result) == 50 + 3
385 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
386 && strcmp (result + strlen (result) - 3, " 33") == 0);
387 ASSERT (retval == strlen (result));
390 { /* A positive number. */
393 my_sprintf (result, "%La %d", 3.1416015625L, 33, 44, 55);
394 ASSERT (strcmp (result, "0x1.922p+1 33") == 0
395 || strcmp (result, "0x3.244p+0 33") == 0
396 || strcmp (result, "0x6.488p-1 33") == 0
397 || strcmp (result, "0xc.91p-2 33") == 0);
398 ASSERT (retval == strlen (result));
401 { /* A negative number. */
404 my_sprintf (result, "%LA %d", -3.1416015625L, 33, 44, 55);
405 ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
406 || strcmp (result, "-0X3.244P+0 33") == 0
407 || strcmp (result, "-0X6.488P-1 33") == 0
408 || strcmp (result, "-0XC.91P-2 33") == 0);
409 ASSERT (retval == strlen (result));
412 { /* Positive zero. */
415 my_sprintf (result, "%La %d", 0.0L, 33, 44, 55);
416 ASSERT (strcmp (result, "0x0p+0 33") == 0);
417 ASSERT (retval == strlen (result));
420 { /* Negative zero. */
423 my_sprintf (result, "%La %d", -0.0L, 33, 44, 55);
424 if (have_minus_zero ())
425 ASSERT (strcmp (result, "-0x0p+0 33") == 0);
426 ASSERT (retval == strlen (result));
429 { /* Positive infinity. */
432 my_sprintf (result, "%La %d", 1.0L / 0.0L, 33, 44, 55);
433 ASSERT (strcmp (result, "inf 33") == 0);
434 ASSERT (retval == strlen (result));
437 { /* Negative infinity. */
440 my_sprintf (result, "%La %d", -1.0L / 0.0L, 33, 44, 55);
441 ASSERT (strcmp (result, "-inf 33") == 0);
442 ASSERT (retval == strlen (result));
448 my_sprintf (result, "%La %d", 0.0L / 0.0L, 33, 44, 55);
449 ASSERT (strlen (result) >= 3 + 3
450 && strisnan (result, 0, strlen (result) - 3, 0)
451 && strcmp (result + strlen (result) - 3, " 33") == 0);
452 ASSERT (retval == strlen (result));
455 { /* Rounding near the decimal point. */
458 my_sprintf (result, "%.0La %d", 1.5L, 33, 44, 55);
459 ASSERT (strcmp (result, "0x2p+0 33") == 0
460 || strcmp (result, "0x3p-1 33") == 0
461 || strcmp (result, "0x6p-2 33") == 0
462 || strcmp (result, "0xcp-3 33") == 0);
463 ASSERT (retval == strlen (result));
466 { /* Rounding with precision 0. */
469 my_sprintf (result, "%.0La %d", 1.51L, 33, 44, 55);
470 ASSERT (strcmp (result, "0x2p+0 33") == 0
471 || strcmp (result, "0x3p-1 33") == 0
472 || strcmp (result, "0x6p-2 33") == 0
473 || strcmp (result, "0xcp-3 33") == 0);
474 ASSERT (retval == strlen (result));
477 { /* Rounding with precision 1. */
480 my_sprintf (result, "%.1La %d", 1.51L, 33, 44, 55);
481 ASSERT (strcmp (result, "0x1.8p+0 33") == 0
482 || strcmp (result, "0x3.0p-1 33") == 0
483 || strcmp (result, "0x6.1p-2 33") == 0
484 || strcmp (result, "0xc.1p-3 33") == 0);
485 ASSERT (retval == strlen (result));
488 { /* Rounding with precision 2. */
491 my_sprintf (result, "%.2La %d", 1.51L, 33, 44, 55);
492 ASSERT (strcmp (result, "0x1.83p+0 33") == 0
493 || strcmp (result, "0x3.05p-1 33") == 0
494 || strcmp (result, "0x6.0ap-2 33") == 0
495 || strcmp (result, "0xc.14p-3 33") == 0);
496 ASSERT (retval == strlen (result));
499 { /* Rounding with precision 3. */
502 my_sprintf (result, "%.3La %d", 1.51L, 33, 44, 55);
503 ASSERT (strcmp (result, "0x1.829p+0 33") == 0
504 || strcmp (result, "0x3.052p-1 33") == 0
505 || strcmp (result, "0x6.0a4p-2 33") == 0
506 || strcmp (result, "0xc.148p-3 33") == 0);
507 ASSERT (retval == strlen (result));
510 { /* Rounding can turn a ...FFF into a ...000. */
513 my_sprintf (result, "%.3La %d", 1.49999L, 33, 44, 55);
514 ASSERT (strcmp (result, "0x1.800p+0 33") == 0
515 || strcmp (result, "0x3.000p-1 33") == 0
516 || strcmp (result, "0x6.000p-2 33") == 0
517 || strcmp (result, "0xc.000p-3 33") == 0);
518 ASSERT (retval == strlen (result));
521 { /* Rounding can turn a ...FFF into a ...000.
522 This shows a MacOS X 10.3.9 (Darwin 7.9) bug and a
523 glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>. */
526 my_sprintf (result, "%.1La %d", 1.999L, 33, 44, 55);
527 ASSERT (strcmp (result, "0x1.0p+1 33") == 0
528 || strcmp (result, "0x2.0p+0 33") == 0
529 || strcmp (result, "0x4.0p-1 33") == 0
530 || strcmp (result, "0x8.0p-2 33") == 0);
531 ASSERT (retval == strlen (result));
537 my_sprintf (result, "%10La %d", 1.75L, 33, 44, 55);
538 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
539 || strcmp (result, " 0x3.8p-1 33") == 0
540 || strcmp (result, " 0x7p-2 33") == 0
541 || strcmp (result, " 0xep-3 33") == 0);
542 ASSERT (retval == strlen (result));
545 { /* Small precision. */
548 my_sprintf (result, "%.10La %d", 1.75L, 33, 44, 55);
549 ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
550 || strcmp (result, "0x3.8000000000p-1 33") == 0
551 || strcmp (result, "0x7.0000000000p-2 33") == 0
552 || strcmp (result, "0xe.0000000000p-3 33") == 0);
553 ASSERT (retval == strlen (result));
556 { /* Large precision. */
559 my_sprintf (result, "%.50La %d", 1.75L, 33, 44, 55);
560 ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
561 || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
562 || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
563 || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
564 ASSERT (retval == strlen (result));
570 my_sprintf (result, "%-10La %d", 1.75L, 33, 44, 55);
571 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
572 || strcmp (result, "0x3.8p-1 33") == 0
573 || strcmp (result, "0x7p-2 33") == 0
574 || strcmp (result, "0xep-3 33") == 0);
575 ASSERT (retval == strlen (result));
578 { /* FLAG_SHOWSIGN. */
581 my_sprintf (result, "%+La %d", 1.75L, 33, 44, 55);
582 ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
583 || strcmp (result, "+0x3.8p-1 33") == 0
584 || strcmp (result, "+0x7p-2 33") == 0
585 || strcmp (result, "+0xep-3 33") == 0);
586 ASSERT (retval == strlen (result));
592 my_sprintf (result, "% La %d", 1.75L, 33, 44, 55);
593 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
594 || strcmp (result, " 0x3.8p-1 33") == 0
595 || strcmp (result, " 0x7p-2 33") == 0
596 || strcmp (result, " 0xep-3 33") == 0);
597 ASSERT (retval == strlen (result));
603 my_sprintf (result, "%#La %d", 1.75L, 33, 44, 55);
604 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
605 || strcmp (result, "0x3.8p-1 33") == 0
606 || strcmp (result, "0x7.p-2 33") == 0
607 || strcmp (result, "0xe.p-3 33") == 0);
608 ASSERT (retval == strlen (result));
614 my_sprintf (result, "%#La %d", 1.0L, 33, 44, 55);
615 ASSERT (strcmp (result, "0x1.p+0 33") == 0
616 || strcmp (result, "0x2.p-1 33") == 0
617 || strcmp (result, "0x4.p-2 33") == 0
618 || strcmp (result, "0x8.p-3 33") == 0);
619 ASSERT (retval == strlen (result));
622 { /* FLAG_ZERO with finite number. */
625 my_sprintf (result, "%010La %d", 1.75L, 33, 44, 55);
626 ASSERT (strcmp (result, "0x001.cp+0 33") == 0
627 || strcmp (result, "0x003.8p-1 33") == 0
628 || strcmp (result, "0x00007p-2 33") == 0
629 || strcmp (result, "0x0000ep-3 33") == 0);
630 ASSERT (retval == strlen (result));
633 { /* FLAG_ZERO with infinite number. */
636 my_sprintf (result, "%010La %d", 1.0L / 0.0L, 33, 44, 55);
637 /* "0000000inf 33" is not a valid result; see
638 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
639 ASSERT (strcmp (result, " inf 33") == 0);
640 ASSERT (retval == strlen (result));
643 { /* FLAG_ZERO with NaN. */
646 my_sprintf (result, "%050La %d", 0.0L / 0.0L, 33, 44, 55);
647 /* "0000000nan 33" is not a valid result; see
648 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
649 ASSERT (strlen (result) == 50 + 3
650 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
651 && strcmp (result + strlen (result) - 3, " 33") == 0);
652 ASSERT (retval == strlen (result));
655 /* Test the support of the %f format directive. */
657 { /* A positive number. */
660 my_sprintf (result, "%f %d", 12.75, 33, 44, 55);
661 ASSERT (strcmp (result, "12.750000 33") == 0);
662 ASSERT (retval == strlen (result));
665 { /* A larger positive number. */
668 my_sprintf (result, "%f %d", 1234567.0, 33, 44, 55);
669 ASSERT (strcmp (result, "1234567.000000 33") == 0);
670 ASSERT (retval == strlen (result));
673 { /* Small and large positive numbers. */
674 static struct { double value; const char *string; } data[] =
676 { 1.234321234321234e-37, "0.000000" },
677 { 1.234321234321234e-36, "0.000000" },
678 { 1.234321234321234e-35, "0.000000" },
679 { 1.234321234321234e-34, "0.000000" },
680 { 1.234321234321234e-33, "0.000000" },
681 { 1.234321234321234e-32, "0.000000" },
682 { 1.234321234321234e-31, "0.000000" },
683 { 1.234321234321234e-30, "0.000000" },
684 { 1.234321234321234e-29, "0.000000" },
685 { 1.234321234321234e-28, "0.000000" },
686 { 1.234321234321234e-27, "0.000000" },
687 { 1.234321234321234e-26, "0.000000" },
688 { 1.234321234321234e-25, "0.000000" },
689 { 1.234321234321234e-24, "0.000000" },
690 { 1.234321234321234e-23, "0.000000" },
691 { 1.234321234321234e-22, "0.000000" },
692 { 1.234321234321234e-21, "0.000000" },
693 { 1.234321234321234e-20, "0.000000" },
694 { 1.234321234321234e-19, "0.000000" },
695 { 1.234321234321234e-18, "0.000000" },
696 { 1.234321234321234e-17, "0.000000" },
697 { 1.234321234321234e-16, "0.000000" },
698 { 1.234321234321234e-15, "0.000000" },
699 { 1.234321234321234e-14, "0.000000" },
700 { 1.234321234321234e-13, "0.000000" },
701 { 1.234321234321234e-12, "0.000000" },
702 { 1.234321234321234e-11, "0.000000" },
703 { 1.234321234321234e-10, "0.000000" },
704 { 1.234321234321234e-9, "0.000000" },
705 { 1.234321234321234e-8, "0.000000" },
706 { 1.234321234321234e-7, "0.000000" },
707 { 1.234321234321234e-6, "0.000001" },
708 { 1.234321234321234e-5, "0.000012" },
709 { 1.234321234321234e-4, "0.000123" },
710 { 1.234321234321234e-3, "0.001234" },
711 { 1.234321234321234e-2, "0.012343" },
712 { 1.234321234321234e-1, "0.123432" },
713 { 1.234321234321234, "1.234321" },
714 { 1.234321234321234e1, "12.343212" },
715 { 1.234321234321234e2, "123.432123" },
716 { 1.234321234321234e3, "1234.321234" },
717 { 1.234321234321234e4, "12343.212343" },
718 { 1.234321234321234e5, "123432.123432" },
719 { 1.234321234321234e6, "1234321.234321" },
720 { 1.234321234321234e7, "12343212.343212" },
721 { 1.234321234321234e8, "123432123.432123" },
722 { 1.234321234321234e9, "1234321234.321234" },
723 { 1.234321234321234e10, "12343212343.2123**" },
724 { 1.234321234321234e11, "123432123432.123***" },
725 { 1.234321234321234e12, "1234321234321.23****" },
726 { 1.234321234321234e13, "12343212343212.3*****" },
727 { 1.234321234321234e14, "123432123432123.******" },
728 { 1.234321234321234e15, "1234321234321234.000000" },
729 { 1.234321234321234e16, "123432123432123**.000000" },
730 { 1.234321234321234e17, "123432123432123***.000000" },
731 { 1.234321234321234e18, "123432123432123****.000000" },
732 { 1.234321234321234e19, "123432123432123*****.000000" },
733 { 1.234321234321234e20, "123432123432123******.000000" },
734 { 1.234321234321234e21, "123432123432123*******.000000" },
735 { 1.234321234321234e22, "123432123432123********.000000" },
736 { 1.234321234321234e23, "123432123432123*********.000000" },
737 { 1.234321234321234e24, "123432123432123**********.000000" },
738 { 1.234321234321234e25, "123432123432123***********.000000" },
739 { 1.234321234321234e26, "123432123432123************.000000" },
740 { 1.234321234321234e27, "123432123432123*************.000000" },
741 { 1.234321234321234e28, "123432123432123**************.000000" },
742 { 1.234321234321234e29, "123432123432123***************.000000" },
743 { 1.234321234321234e30, "123432123432123****************.000000" },
744 { 1.234321234321234e31, "123432123432123*****************.000000" },
745 { 1.234321234321234e32, "123432123432123******************.000000" },
746 { 1.234321234321234e33, "123432123432123*******************.000000" },
747 { 1.234321234321234e34, "123432123432123********************.000000" },
748 { 1.234321234321234e35, "123432123432123*********************.000000" },
749 { 1.234321234321234e36, "123432123432123**********************.000000" }
752 for (k = 0; k < SIZEOF (data); k++)
756 my_sprintf (result, "%f", data[k].value);
757 ASSERT (strmatch (data[k].string, result));
758 ASSERT (retval == strlen (result));
762 { /* A negative number. */
765 my_sprintf (result, "%f %d", -0.03125, 33, 44, 55);
766 ASSERT (strcmp (result, "-0.031250 33") == 0);
767 ASSERT (retval == strlen (result));
770 { /* Positive zero. */
773 my_sprintf (result, "%f %d", 0.0, 33, 44, 55);
774 ASSERT (strcmp (result, "0.000000 33") == 0);
775 ASSERT (retval == strlen (result));
778 { /* Negative zero. */
781 my_sprintf (result, "%f %d", -0.0, 33, 44, 55);
782 if (have_minus_zero ())
783 ASSERT (strcmp (result, "-0.000000 33") == 0);
784 ASSERT (retval == strlen (result));
787 { /* Positive infinity. */
790 my_sprintf (result, "%f %d", 1.0 / 0.0, 33, 44, 55);
791 ASSERT (strcmp (result, "inf 33") == 0
792 || strcmp (result, "infinity 33") == 0);
793 ASSERT (retval == strlen (result));
796 { /* Negative infinity. */
799 my_sprintf (result, "%f %d", -1.0 / 0.0, 33, 44, 55);
800 ASSERT (strcmp (result, "-inf 33") == 0
801 || strcmp (result, "-infinity 33") == 0);
802 ASSERT (retval == strlen (result));
808 my_sprintf (result, "%f %d", NaN (), 33, 44, 55);
809 ASSERT (strlen (result) >= 3 + 3
810 && strisnan (result, 0, strlen (result) - 3, 0)
811 && strcmp (result + strlen (result) - 3, " 33") == 0);
812 ASSERT (retval == strlen (result));
818 my_sprintf (result, "%10f %d", 1.75, 33, 44, 55);
819 ASSERT (strcmp (result, " 1.750000 33") == 0);
820 ASSERT (retval == strlen (result));
826 my_sprintf (result, "%-10f %d", 1.75, 33, 44, 55);
827 ASSERT (strcmp (result, "1.750000 33") == 0);
828 ASSERT (retval == strlen (result));
831 { /* FLAG_SHOWSIGN. */
834 my_sprintf (result, "%+f %d", 1.75, 33, 44, 55);
835 ASSERT (strcmp (result, "+1.750000 33") == 0);
836 ASSERT (retval == strlen (result));
842 my_sprintf (result, "% f %d", 1.75, 33, 44, 55);
843 ASSERT (strcmp (result, " 1.750000 33") == 0);
844 ASSERT (retval == strlen (result));
850 my_sprintf (result, "%#f %d", 1.75, 33, 44, 55);
851 ASSERT (strcmp (result, "1.750000 33") == 0);
852 ASSERT (retval == strlen (result));
858 my_sprintf (result, "%#.f %d", 1.75, 33, 44, 55);
859 ASSERT (strcmp (result, "2. 33") == 0);
860 ASSERT (retval == strlen (result));
863 { /* FLAG_ZERO with finite number. */
866 my_sprintf (result, "%015f %d", 1234.0, 33, 44, 55);
867 ASSERT (strcmp (result, "00001234.000000 33") == 0);
868 ASSERT (retval == strlen (result));
871 { /* FLAG_ZERO with infinite number. */
874 my_sprintf (result, "%015f %d", -1.0 / 0.0, 33, 44, 55);
875 ASSERT (strcmp (result, " -inf 33") == 0
876 || strcmp (result, " -infinity 33") == 0);
877 ASSERT (retval == strlen (result));
880 { /* FLAG_ZERO with NaN. */
883 my_sprintf (result, "%050f %d", NaN (), 33, 44, 55);
884 ASSERT (strlen (result) == 50 + 3
885 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
886 && strcmp (result + strlen (result) - 3, " 33") == 0);
887 ASSERT (retval == strlen (result));
893 my_sprintf (result, "%.f %d", 1234.0, 33, 44, 55);
894 ASSERT (strcmp (result, "1234 33") == 0);
895 ASSERT (retval == strlen (result));
898 { /* A positive number. */
901 my_sprintf (result, "%Lf %d", 12.75L, 33, 44, 55);
902 ASSERT (strcmp (result, "12.750000 33") == 0);
903 ASSERT (retval == strlen (result));
906 { /* A larger positive number. */
909 my_sprintf (result, "%Lf %d", 1234567.0L, 33, 44, 55);
910 ASSERT (strcmp (result, "1234567.000000 33") == 0);
911 ASSERT (retval == strlen (result));
914 { /* Small and large positive numbers. */
915 static struct { long double value; const char *string; } data[] =
917 { 1.234321234321234e-37L, "0.000000" },
918 { 1.234321234321234e-36L, "0.000000" },
919 { 1.234321234321234e-35L, "0.000000" },
920 { 1.234321234321234e-34L, "0.000000" },
921 { 1.234321234321234e-33L, "0.000000" },
922 { 1.234321234321234e-32L, "0.000000" },
923 { 1.234321234321234e-31L, "0.000000" },
924 { 1.234321234321234e-30L, "0.000000" },
925 { 1.234321234321234e-29L, "0.000000" },
926 { 1.234321234321234e-28L, "0.000000" },
927 { 1.234321234321234e-27L, "0.000000" },
928 { 1.234321234321234e-26L, "0.000000" },
929 { 1.234321234321234e-25L, "0.000000" },
930 { 1.234321234321234e-24L, "0.000000" },
931 { 1.234321234321234e-23L, "0.000000" },
932 { 1.234321234321234e-22L, "0.000000" },
933 { 1.234321234321234e-21L, "0.000000" },
934 { 1.234321234321234e-20L, "0.000000" },
935 { 1.234321234321234e-19L, "0.000000" },
936 { 1.234321234321234e-18L, "0.000000" },
937 { 1.234321234321234e-17L, "0.000000" },
938 { 1.234321234321234e-16L, "0.000000" },
939 { 1.234321234321234e-15L, "0.000000" },
940 { 1.234321234321234e-14L, "0.000000" },
941 { 1.234321234321234e-13L, "0.000000" },
942 { 1.234321234321234e-12L, "0.000000" },
943 { 1.234321234321234e-11L, "0.000000" },
944 { 1.234321234321234e-10L, "0.000000" },
945 { 1.234321234321234e-9L, "0.000000" },
946 { 1.234321234321234e-8L, "0.000000" },
947 { 1.234321234321234e-7L, "0.000000" },
948 { 1.234321234321234e-6L, "0.000001" },
949 { 1.234321234321234e-5L, "0.000012" },
950 { 1.234321234321234e-4L, "0.000123" },
951 { 1.234321234321234e-3L, "0.001234" },
952 { 1.234321234321234e-2L, "0.012343" },
953 { 1.234321234321234e-1L, "0.123432" },
954 { 1.234321234321234L, "1.234321" },
955 { 1.234321234321234e1L, "12.343212" },
956 { 1.234321234321234e2L, "123.432123" },
957 { 1.234321234321234e3L, "1234.321234" },
958 { 1.234321234321234e4L, "12343.212343" },
959 { 1.234321234321234e5L, "123432.123432" },
960 { 1.234321234321234e6L, "1234321.234321" },
961 { 1.234321234321234e7L, "12343212.343212" },
962 { 1.234321234321234e8L, "123432123.432123" },
963 { 1.234321234321234e9L, "1234321234.321234" },
964 { 1.234321234321234e10L, "12343212343.2123**" },
965 { 1.234321234321234e11L, "123432123432.123***" },
966 { 1.234321234321234e12L, "1234321234321.23****" },
967 { 1.234321234321234e13L, "12343212343212.3*****" },
968 { 1.234321234321234e14L, "123432123432123.******" },
969 { 1.234321234321234e15L, "1234321234321234.000000" },
970 { 1.234321234321234e16L, "123432123432123**.000000" },
971 { 1.234321234321234e17L, "123432123432123***.000000" },
972 { 1.234321234321234e18L, "123432123432123****.000000" },
973 { 1.234321234321234e19L, "123432123432123*****.000000" },
974 { 1.234321234321234e20L, "123432123432123******.000000" },
975 { 1.234321234321234e21L, "123432123432123*******.000000" },
976 { 1.234321234321234e22L, "123432123432123********.000000" },
977 { 1.234321234321234e23L, "123432123432123*********.000000" },
978 { 1.234321234321234e24L, "123432123432123**********.000000" },
979 { 1.234321234321234e25L, "123432123432123***********.000000" },
980 { 1.234321234321234e26L, "123432123432123************.000000" },
981 { 1.234321234321234e27L, "123432123432123*************.000000" },
982 { 1.234321234321234e28L, "123432123432123**************.000000" },
983 { 1.234321234321234e29L, "123432123432123***************.000000" },
984 { 1.234321234321234e30L, "123432123432123****************.000000" },
985 { 1.234321234321234e31L, "123432123432123*****************.000000" },
986 { 1.234321234321234e32L, "123432123432123******************.000000" },
987 { 1.234321234321234e33L, "123432123432123*******************.000000" },
988 { 1.234321234321234e34L, "123432123432123********************.000000" },
989 { 1.234321234321234e35L, "123432123432123*********************.000000" },
990 { 1.234321234321234e36L, "123432123432123**********************.000000" }
993 for (k = 0; k < SIZEOF (data); k++)
997 my_sprintf (result, "%Lf", data[k].value);
998 ASSERT (strmatch (data[k].string, result));
999 ASSERT (retval == strlen (result));
1003 { /* A negative number. */
1006 my_sprintf (result, "%Lf %d", -0.03125L, 33, 44, 55);
1007 ASSERT (strcmp (result, "-0.031250 33") == 0);
1008 ASSERT (retval == strlen (result));
1011 { /* Positive zero. */
1014 my_sprintf (result, "%Lf %d", 0.0L, 33, 44, 55);
1015 ASSERT (strcmp (result, "0.000000 33") == 0);
1016 ASSERT (retval == strlen (result));
1019 { /* Negative zero. */
1022 my_sprintf (result, "%Lf %d", -0.0L, 33, 44, 55);
1023 if (have_minus_zero ())
1024 ASSERT (strcmp (result, "-0.000000 33") == 0);
1025 ASSERT (retval == strlen (result));
1028 { /* Positive infinity. */
1031 my_sprintf (result, "%Lf %d", 1.0L / 0.0L, 33, 44, 55);
1032 ASSERT (strcmp (result, "inf 33") == 0
1033 || strcmp (result, "infinity 33") == 0);
1034 ASSERT (retval == strlen (result));
1037 { /* Negative infinity. */
1040 my_sprintf (result, "%Lf %d", -1.0L / 0.0L, 33, 44, 55);
1041 ASSERT (strcmp (result, "-inf 33") == 0
1042 || strcmp (result, "-infinity 33") == 0);
1043 ASSERT (retval == strlen (result));
1047 static long double zero = 0.0L;
1050 my_sprintf (result, "%Lf %d", zero / zero, 33, 44, 55);
1051 ASSERT (strlen (result) >= 3 + 3
1052 && strisnan (result, 0, strlen (result) - 3, 0)
1053 && strcmp (result + strlen (result) - 3, " 33") == 0);
1054 ASSERT (retval == strlen (result));
1060 my_sprintf (result, "%10Lf %d", 1.75L, 33, 44, 55);
1061 ASSERT (strcmp (result, " 1.750000 33") == 0);
1062 ASSERT (retval == strlen (result));
1068 my_sprintf (result, "%-10Lf %d", 1.75L, 33, 44, 55);
1069 ASSERT (strcmp (result, "1.750000 33") == 0);
1070 ASSERT (retval == strlen (result));
1073 { /* FLAG_SHOWSIGN. */
1076 my_sprintf (result, "%+Lf %d", 1.75L, 33, 44, 55);
1077 ASSERT (strcmp (result, "+1.750000 33") == 0);
1078 ASSERT (retval == strlen (result));
1084 my_sprintf (result, "% Lf %d", 1.75L, 33, 44, 55);
1085 ASSERT (strcmp (result, " 1.750000 33") == 0);
1086 ASSERT (retval == strlen (result));
1092 my_sprintf (result, "%#Lf %d", 1.75L, 33, 44, 55);
1093 ASSERT (strcmp (result, "1.750000 33") == 0);
1094 ASSERT (retval == strlen (result));
1100 my_sprintf (result, "%#.Lf %d", 1.75L, 33, 44, 55);
1101 ASSERT (strcmp (result, "2. 33") == 0);
1102 ASSERT (retval == strlen (result));
1105 { /* FLAG_ZERO with finite number. */
1108 my_sprintf (result, "%015Lf %d", 1234.0L, 33, 44, 55);
1109 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1110 ASSERT (retval == strlen (result));
1113 { /* FLAG_ZERO with infinite number. */
1116 my_sprintf (result, "%015Lf %d", -1.0L / 0.0L, 33, 44, 55);
1117 ASSERT (strcmp (result, " -inf 33") == 0
1118 || strcmp (result, " -infinity 33") == 0);
1119 ASSERT (retval == strlen (result));
1122 { /* FLAG_ZERO with NaN. */
1123 static long double zero = 0.0L;
1126 my_sprintf (result, "%050Lf %d", zero / zero, 33, 44, 55);
1127 ASSERT (strlen (result) == 50 + 3
1128 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1129 && strcmp (result + strlen (result) - 3, " 33") == 0);
1130 ASSERT (retval == strlen (result));
1136 my_sprintf (result, "%.Lf %d", 1234.0L, 33, 44, 55);
1137 ASSERT (strcmp (result, "1234 33") == 0);
1138 ASSERT (retval == strlen (result));
1141 /* Test the support of the %F format directive. */
1143 { /* A positive number. */
1146 my_sprintf (result, "%F %d", 12.75, 33, 44, 55);
1147 ASSERT (strcmp (result, "12.750000 33") == 0);
1148 ASSERT (retval == strlen (result));
1151 { /* A larger positive number. */
1154 my_sprintf (result, "%F %d", 1234567.0, 33, 44, 55);
1155 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1156 ASSERT (retval == strlen (result));
1159 { /* A negative number. */
1162 my_sprintf (result, "%F %d", -0.03125, 33, 44, 55);
1163 ASSERT (strcmp (result, "-0.031250 33") == 0);
1164 ASSERT (retval == strlen (result));
1167 { /* Positive zero. */
1170 my_sprintf (result, "%F %d", 0.0, 33, 44, 55);
1171 ASSERT (strcmp (result, "0.000000 33") == 0);
1172 ASSERT (retval == strlen (result));
1175 { /* Negative zero. */
1178 my_sprintf (result, "%F %d", -0.0, 33, 44, 55);
1179 if (have_minus_zero ())
1180 ASSERT (strcmp (result, "-0.000000 33") == 0);
1181 ASSERT (retval == strlen (result));
1184 { /* Positive infinity. */
1187 my_sprintf (result, "%F %d", 1.0 / 0.0, 33, 44, 55);
1188 ASSERT (strcmp (result, "INF 33") == 0
1189 || strcmp (result, "INFINITY 33") == 0);
1190 ASSERT (retval == strlen (result));
1193 { /* Negative infinity. */
1196 my_sprintf (result, "%F %d", -1.0 / 0.0, 33, 44, 55);
1197 ASSERT (strcmp (result, "-INF 33") == 0
1198 || strcmp (result, "-INFINITY 33") == 0);
1199 ASSERT (retval == strlen (result));
1205 my_sprintf (result, "%F %d", NaN (), 33, 44, 55);
1206 ASSERT (strlen (result) >= 3 + 3
1207 && strisnan (result, 0, strlen (result) - 3, 1)
1208 && strcmp (result + strlen (result) - 3, " 33") == 0);
1209 ASSERT (retval == strlen (result));
1215 my_sprintf (result, "%015F %d", 1234.0, 33, 44, 55);
1216 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1217 ASSERT (retval == strlen (result));
1220 { /* FLAG_ZERO with infinite number. */
1223 my_sprintf (result, "%015F %d", -1.0 / 0.0, 33, 44, 55);
1224 ASSERT (strcmp (result, " -INF 33") == 0
1225 || strcmp (result, " -INFINITY 33") == 0);
1226 ASSERT (retval == strlen (result));
1232 my_sprintf (result, "%.F %d", 1234.0, 33, 44, 55);
1233 ASSERT (strcmp (result, "1234 33") == 0);
1234 ASSERT (retval == strlen (result));
1237 { /* A positive number. */
1240 my_sprintf (result, "%LF %d", 12.75L, 33, 44, 55);
1241 ASSERT (strcmp (result, "12.750000 33") == 0);
1242 ASSERT (retval == strlen (result));
1245 { /* A larger positive number. */
1248 my_sprintf (result, "%LF %d", 1234567.0L, 33, 44, 55);
1249 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1250 ASSERT (retval == strlen (result));
1253 { /* A negative number. */
1256 my_sprintf (result, "%LF %d", -0.03125L, 33, 44, 55);
1257 ASSERT (strcmp (result, "-0.031250 33") == 0);
1258 ASSERT (retval == strlen (result));
1261 { /* Positive zero. */
1264 my_sprintf (result, "%LF %d", 0.0L, 33, 44, 55);
1265 ASSERT (strcmp (result, "0.000000 33") == 0);
1266 ASSERT (retval == strlen (result));
1269 { /* Negative zero. */
1272 my_sprintf (result, "%LF %d", -0.0L, 33, 44, 55);
1273 if (have_minus_zero ())
1274 ASSERT (strcmp (result, "-0.000000 33") == 0);
1275 ASSERT (retval == strlen (result));
1278 { /* Positive infinity. */
1281 my_sprintf (result, "%LF %d", 1.0L / 0.0L, 33, 44, 55);
1282 ASSERT (strcmp (result, "INF 33") == 0
1283 || strcmp (result, "INFINITY 33") == 0);
1284 ASSERT (retval == strlen (result));
1287 { /* Negative infinity. */
1290 my_sprintf (result, "%LF %d", -1.0L / 0.0L, 33, 44, 55);
1291 ASSERT (strcmp (result, "-INF 33") == 0
1292 || strcmp (result, "-INFINITY 33") == 0);
1293 ASSERT (retval == strlen (result));
1297 static long double zero = 0.0L;
1300 my_sprintf (result, "%LF %d", zero / zero, 33, 44, 55);
1301 ASSERT (strlen (result) >= 3 + 3
1302 && strisnan (result, 0, strlen (result) - 3, 1)
1303 && strcmp (result + strlen (result) - 3, " 33") == 0);
1304 ASSERT (retval == strlen (result));
1310 my_sprintf (result, "%015LF %d", 1234.0L, 33, 44, 55);
1311 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1312 ASSERT (retval == strlen (result));
1315 { /* FLAG_ZERO with infinite number. */
1318 my_sprintf (result, "%015LF %d", -1.0L / 0.0L, 33, 44, 55);
1319 ASSERT (strcmp (result, " -INF 33") == 0
1320 || strcmp (result, " -INFINITY 33") == 0);
1321 ASSERT (retval == strlen (result));
1327 my_sprintf (result, "%.LF %d", 1234.0L, 33, 44, 55);
1328 ASSERT (strcmp (result, "1234 33") == 0);
1329 ASSERT (retval == strlen (result));
1332 /* Test the support of the %e format directive. */
1334 { /* A positive number. */
1337 my_sprintf (result, "%e %d", 12.75, 33, 44, 55);
1338 ASSERT (strcmp (result, "1.275000e+01 33") == 0
1339 || strcmp (result, "1.275000e+001 33") == 0);
1340 ASSERT (retval == strlen (result));
1343 { /* A larger positive number. */
1346 my_sprintf (result, "%e %d", 1234567.0, 33, 44, 55);
1347 ASSERT (strcmp (result, "1.234567e+06 33") == 0
1348 || strcmp (result, "1.234567e+006 33") == 0);
1349 ASSERT (retval == strlen (result));
1352 { /* Small and large positive numbers. */
1353 static struct { double value; const char *string; } data[] =
1355 { 1.234321234321234e-37, "1.234321e-37" },
1356 { 1.234321234321234e-36, "1.234321e-36" },
1357 { 1.234321234321234e-35, "1.234321e-35" },
1358 { 1.234321234321234e-34, "1.234321e-34" },
1359 { 1.234321234321234e-33, "1.234321e-33" },
1360 { 1.234321234321234e-32, "1.234321e-32" },
1361 { 1.234321234321234e-31, "1.234321e-31" },
1362 { 1.234321234321234e-30, "1.234321e-30" },
1363 { 1.234321234321234e-29, "1.234321e-29" },
1364 { 1.234321234321234e-28, "1.234321e-28" },
1365 { 1.234321234321234e-27, "1.234321e-27" },
1366 { 1.234321234321234e-26, "1.234321e-26" },
1367 { 1.234321234321234e-25, "1.234321e-25" },
1368 { 1.234321234321234e-24, "1.234321e-24" },
1369 { 1.234321234321234e-23, "1.234321e-23" },
1370 { 1.234321234321234e-22, "1.234321e-22" },
1371 { 1.234321234321234e-21, "1.234321e-21" },
1372 { 1.234321234321234e-20, "1.234321e-20" },
1373 { 1.234321234321234e-19, "1.234321e-19" },
1374 { 1.234321234321234e-18, "1.234321e-18" },
1375 { 1.234321234321234e-17, "1.234321e-17" },
1376 { 1.234321234321234e-16, "1.234321e-16" },
1377 { 1.234321234321234e-15, "1.234321e-15" },
1378 { 1.234321234321234e-14, "1.234321e-14" },
1379 { 1.234321234321234e-13, "1.234321e-13" },
1380 { 1.234321234321234e-12, "1.234321e-12" },
1381 { 1.234321234321234e-11, "1.234321e-11" },
1382 { 1.234321234321234e-10, "1.234321e-10" },
1383 { 1.234321234321234e-9, "1.234321e-09" },
1384 { 1.234321234321234e-8, "1.234321e-08" },
1385 { 1.234321234321234e-7, "1.234321e-07" },
1386 { 1.234321234321234e-6, "1.234321e-06" },
1387 { 1.234321234321234e-5, "1.234321e-05" },
1388 { 1.234321234321234e-4, "1.234321e-04" },
1389 { 1.234321234321234e-3, "1.234321e-03" },
1390 { 1.234321234321234e-2, "1.234321e-02" },
1391 { 1.234321234321234e-1, "1.234321e-01" },
1392 { 1.234321234321234, "1.234321e+00" },
1393 { 1.234321234321234e1, "1.234321e+01" },
1394 { 1.234321234321234e2, "1.234321e+02" },
1395 { 1.234321234321234e3, "1.234321e+03" },
1396 { 1.234321234321234e4, "1.234321e+04" },
1397 { 1.234321234321234e5, "1.234321e+05" },
1398 { 1.234321234321234e6, "1.234321e+06" },
1399 { 1.234321234321234e7, "1.234321e+07" },
1400 { 1.234321234321234e8, "1.234321e+08" },
1401 { 1.234321234321234e9, "1.234321e+09" },
1402 { 1.234321234321234e10, "1.234321e+10" },
1403 { 1.234321234321234e11, "1.234321e+11" },
1404 { 1.234321234321234e12, "1.234321e+12" },
1405 { 1.234321234321234e13, "1.234321e+13" },
1406 { 1.234321234321234e14, "1.234321e+14" },
1407 { 1.234321234321234e15, "1.234321e+15" },
1408 { 1.234321234321234e16, "1.234321e+16" },
1409 { 1.234321234321234e17, "1.234321e+17" },
1410 { 1.234321234321234e18, "1.234321e+18" },
1411 { 1.234321234321234e19, "1.234321e+19" },
1412 { 1.234321234321234e20, "1.234321e+20" },
1413 { 1.234321234321234e21, "1.234321e+21" },
1414 { 1.234321234321234e22, "1.234321e+22" },
1415 { 1.234321234321234e23, "1.234321e+23" },
1416 { 1.234321234321234e24, "1.234321e+24" },
1417 { 1.234321234321234e25, "1.234321e+25" },
1418 { 1.234321234321234e26, "1.234321e+26" },
1419 { 1.234321234321234e27, "1.234321e+27" },
1420 { 1.234321234321234e28, "1.234321e+28" },
1421 { 1.234321234321234e29, "1.234321e+29" },
1422 { 1.234321234321234e30, "1.234321e+30" },
1423 { 1.234321234321234e31, "1.234321e+31" },
1424 { 1.234321234321234e32, "1.234321e+32" },
1425 { 1.234321234321234e33, "1.234321e+33" },
1426 { 1.234321234321234e34, "1.234321e+34" },
1427 { 1.234321234321234e35, "1.234321e+35" },
1428 { 1.234321234321234e36, "1.234321e+36" }
1431 for (k = 0; k < SIZEOF (data); k++)
1435 my_sprintf (result, "%e", data[k].value);
1436 const char *expected = data[k].string;
1437 ASSERT (result != NULL);
1438 ASSERT (strcmp (result, expected) == 0
1439 /* Some implementations produce exponents with 3 digits. */
1440 || (strlen (result) == strlen (expected) + 1
1441 && memcmp (result, expected, strlen (expected) - 2) == 0
1442 && result[strlen (expected) - 2] == '0'
1443 && strcmp (result + strlen (expected) - 1,
1444 expected + strlen (expected) - 2)
1446 ASSERT (retval == strlen (result));
1450 { /* A negative number. */
1453 my_sprintf (result, "%e %d", -0.03125, 33, 44, 55);
1454 ASSERT (strcmp (result, "-3.125000e-02 33") == 0
1455 || strcmp (result, "-3.125000e-002 33") == 0);
1456 ASSERT (retval == strlen (result));
1459 { /* Positive zero. */
1462 my_sprintf (result, "%e %d", 0.0, 33, 44, 55);
1463 ASSERT (strcmp (result, "0.000000e+00 33") == 0
1464 || strcmp (result, "0.000000e+000 33") == 0);
1465 ASSERT (retval == strlen (result));
1468 { /* Negative zero. */
1471 my_sprintf (result, "%e %d", -0.0, 33, 44, 55);
1472 if (have_minus_zero ())
1473 ASSERT (strcmp (result, "-0.000000e+00 33") == 0
1474 || strcmp (result, "-0.000000e+000 33") == 0);
1475 ASSERT (retval == strlen (result));
1478 { /* Positive infinity. */
1481 my_sprintf (result, "%e %d", 1.0 / 0.0, 33, 44, 55);
1482 ASSERT (strcmp (result, "inf 33") == 0
1483 || strcmp (result, "infinity 33") == 0);
1484 ASSERT (retval == strlen (result));
1487 { /* Negative infinity. */
1490 my_sprintf (result, "%e %d", -1.0 / 0.0, 33, 44, 55);
1491 ASSERT (strcmp (result, "-inf 33") == 0
1492 || strcmp (result, "-infinity 33") == 0);
1493 ASSERT (retval == strlen (result));
1499 my_sprintf (result, "%e %d", NaN (), 33, 44, 55);
1500 ASSERT (strlen (result) >= 3 + 3
1501 && strisnan (result, 0, strlen (result) - 3, 0)
1502 && strcmp (result + strlen (result) - 3, " 33") == 0);
1503 ASSERT (retval == strlen (result));
1509 my_sprintf (result, "%15e %d", 1.75, 33, 44, 55);
1510 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
1511 || strcmp (result, " 1.750000e+000 33") == 0);
1512 ASSERT (retval == strlen (result));
1518 my_sprintf (result, "%-15e %d", 1.75, 33, 44, 55);
1519 ASSERT (strcmp (result, "1.750000e+00 33") == 0
1520 || strcmp (result, "1.750000e+000 33") == 0);
1521 ASSERT (retval == strlen (result));
1524 { /* FLAG_SHOWSIGN. */
1527 my_sprintf (result, "%+e %d", 1.75, 33, 44, 55);
1528 ASSERT (strcmp (result, "+1.750000e+00 33") == 0
1529 || strcmp (result, "+1.750000e+000 33") == 0);
1530 ASSERT (retval == strlen (result));
1536 my_sprintf (result, "% e %d", 1.75, 33, 44, 55);
1537 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
1538 || strcmp (result, " 1.750000e+000 33") == 0);
1539 ASSERT (retval == strlen (result));
1545 my_sprintf (result, "%#e %d", 1.75, 33, 44, 55);
1546 ASSERT (strcmp (result, "1.750000e+00 33") == 0
1547 || strcmp (result, "1.750000e+000 33") == 0);
1548 ASSERT (retval == strlen (result));
1554 my_sprintf (result, "%#.e %d", 1.75, 33, 44, 55);
1555 ASSERT (strcmp (result, "2.e+00 33") == 0
1556 || strcmp (result, "2.e+000 33") == 0);
1557 ASSERT (retval == strlen (result));
1563 my_sprintf (result, "%#.e %d", 9.75, 33, 44, 55);
1564 ASSERT (strcmp (result, "1.e+01 33") == 0
1565 || strcmp (result, "1.e+001 33") == 0);
1566 ASSERT (retval == strlen (result));
1569 { /* FLAG_ZERO with finite number. */
1572 my_sprintf (result, "%015e %d", 1234.0, 33, 44, 55);
1573 ASSERT (strcmp (result, "0001.234000e+03 33") == 0
1574 || strcmp (result, "001.234000e+003 33") == 0);
1575 ASSERT (retval == strlen (result));
1578 { /* FLAG_ZERO with infinite number. */
1581 my_sprintf (result, "%015e %d", -1.0 / 0.0, 33, 44, 55);
1582 ASSERT (strcmp (result, " -inf 33") == 0
1583 || strcmp (result, " -infinity 33") == 0);
1584 ASSERT (retval == strlen (result));
1587 { /* FLAG_ZERO with NaN. */
1590 my_sprintf (result, "%050e %d", NaN (), 33, 44, 55);
1591 ASSERT (strlen (result) == 50 + 3
1592 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1593 && strcmp (result + strlen (result) - 3, " 33") == 0);
1594 ASSERT (retval == strlen (result));
1600 my_sprintf (result, "%.e %d", 1234.0, 33, 44, 55);
1601 ASSERT (strcmp (result, "1e+03 33") == 0
1602 || strcmp (result, "1e+003 33") == 0);
1603 ASSERT (retval == strlen (result));
1606 { /* A positive number. */
1609 my_sprintf (result, "%Le %d", 12.75L, 33, 44, 55);
1610 ASSERT (strcmp (result, "1.275000e+01 33") == 0);
1611 ASSERT (retval == strlen (result));
1614 { /* A larger positive number. */
1617 my_sprintf (result, "%Le %d", 1234567.0L, 33, 44, 55);
1618 ASSERT (strcmp (result, "1.234567e+06 33") == 0);
1619 ASSERT (retval == strlen (result));
1622 { /* Small and large positive numbers. */
1623 static struct { long double value; const char *string; } data[] =
1625 { 1.234321234321234e-37L, "1.234321e-37" },
1626 { 1.234321234321234e-36L, "1.234321e-36" },
1627 { 1.234321234321234e-35L, "1.234321e-35" },
1628 { 1.234321234321234e-34L, "1.234321e-34" },
1629 { 1.234321234321234e-33L, "1.234321e-33" },
1630 { 1.234321234321234e-32L, "1.234321e-32" },
1631 { 1.234321234321234e-31L, "1.234321e-31" },
1632 { 1.234321234321234e-30L, "1.234321e-30" },
1633 { 1.234321234321234e-29L, "1.234321e-29" },
1634 { 1.234321234321234e-28L, "1.234321e-28" },
1635 { 1.234321234321234e-27L, "1.234321e-27" },
1636 { 1.234321234321234e-26L, "1.234321e-26" },
1637 { 1.234321234321234e-25L, "1.234321e-25" },
1638 { 1.234321234321234e-24L, "1.234321e-24" },
1639 { 1.234321234321234e-23L, "1.234321e-23" },
1640 { 1.234321234321234e-22L, "1.234321e-22" },
1641 { 1.234321234321234e-21L, "1.234321e-21" },
1642 { 1.234321234321234e-20L, "1.234321e-20" },
1643 { 1.234321234321234e-19L, "1.234321e-19" },
1644 { 1.234321234321234e-18L, "1.234321e-18" },
1645 { 1.234321234321234e-17L, "1.234321e-17" },
1646 { 1.234321234321234e-16L, "1.234321e-16" },
1647 { 1.234321234321234e-15L, "1.234321e-15" },
1648 { 1.234321234321234e-14L, "1.234321e-14" },
1649 { 1.234321234321234e-13L, "1.234321e-13" },
1650 { 1.234321234321234e-12L, "1.234321e-12" },
1651 { 1.234321234321234e-11L, "1.234321e-11" },
1652 { 1.234321234321234e-10L, "1.234321e-10" },
1653 { 1.234321234321234e-9L, "1.234321e-09" },
1654 { 1.234321234321234e-8L, "1.234321e-08" },
1655 { 1.234321234321234e-7L, "1.234321e-07" },
1656 { 1.234321234321234e-6L, "1.234321e-06" },
1657 { 1.234321234321234e-5L, "1.234321e-05" },
1658 { 1.234321234321234e-4L, "1.234321e-04" },
1659 { 1.234321234321234e-3L, "1.234321e-03" },
1660 { 1.234321234321234e-2L, "1.234321e-02" },
1661 { 1.234321234321234e-1L, "1.234321e-01" },
1662 { 1.234321234321234L, "1.234321e+00" },
1663 { 1.234321234321234e1L, "1.234321e+01" },
1664 { 1.234321234321234e2L, "1.234321e+02" },
1665 { 1.234321234321234e3L, "1.234321e+03" },
1666 { 1.234321234321234e4L, "1.234321e+04" },
1667 { 1.234321234321234e5L, "1.234321e+05" },
1668 { 1.234321234321234e6L, "1.234321e+06" },
1669 { 1.234321234321234e7L, "1.234321e+07" },
1670 { 1.234321234321234e8L, "1.234321e+08" },
1671 { 1.234321234321234e9L, "1.234321e+09" },
1672 { 1.234321234321234e10L, "1.234321e+10" },
1673 { 1.234321234321234e11L, "1.234321e+11" },
1674 { 1.234321234321234e12L, "1.234321e+12" },
1675 { 1.234321234321234e13L, "1.234321e+13" },
1676 { 1.234321234321234e14L, "1.234321e+14" },
1677 { 1.234321234321234e15L, "1.234321e+15" },
1678 { 1.234321234321234e16L, "1.234321e+16" },
1679 { 1.234321234321234e17L, "1.234321e+17" },
1680 { 1.234321234321234e18L, "1.234321e+18" },
1681 { 1.234321234321234e19L, "1.234321e+19" },
1682 { 1.234321234321234e20L, "1.234321e+20" },
1683 { 1.234321234321234e21L, "1.234321e+21" },
1684 { 1.234321234321234e22L, "1.234321e+22" },
1685 { 1.234321234321234e23L, "1.234321e+23" },
1686 { 1.234321234321234e24L, "1.234321e+24" },
1687 { 1.234321234321234e25L, "1.234321e+25" },
1688 { 1.234321234321234e26L, "1.234321e+26" },
1689 { 1.234321234321234e27L, "1.234321e+27" },
1690 { 1.234321234321234e28L, "1.234321e+28" },
1691 { 1.234321234321234e29L, "1.234321e+29" },
1692 { 1.234321234321234e30L, "1.234321e+30" },
1693 { 1.234321234321234e31L, "1.234321e+31" },
1694 { 1.234321234321234e32L, "1.234321e+32" },
1695 { 1.234321234321234e33L, "1.234321e+33" },
1696 { 1.234321234321234e34L, "1.234321e+34" },
1697 { 1.234321234321234e35L, "1.234321e+35" },
1698 { 1.234321234321234e36L, "1.234321e+36" }
1701 for (k = 0; k < SIZEOF (data); k++)
1705 my_sprintf (result, "%Le", data[k].value);
1706 ASSERT (strcmp (result, data[k].string) == 0);
1707 ASSERT (retval == strlen (result));
1711 { /* A negative number. */
1714 my_sprintf (result, "%Le %d", -0.03125L, 33, 44, 55);
1715 ASSERT (strcmp (result, "-3.125000e-02 33") == 0);
1716 ASSERT (retval == strlen (result));
1719 { /* Positive zero. */
1722 my_sprintf (result, "%Le %d", 0.0L, 33, 44, 55);
1723 ASSERT (strcmp (result, "0.000000e+00 33") == 0);
1724 ASSERT (retval == strlen (result));
1727 { /* Negative zero. */
1730 my_sprintf (result, "%Le %d", -0.0L, 33, 44, 55);
1731 if (have_minus_zero ())
1732 ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
1733 ASSERT (retval == strlen (result));
1736 { /* Positive infinity. */
1739 my_sprintf (result, "%Le %d", 1.0L / 0.0L, 33, 44, 55);
1740 ASSERT (strcmp (result, "inf 33") == 0
1741 || strcmp (result, "infinity 33") == 0);
1742 ASSERT (retval == strlen (result));
1745 { /* Negative infinity. */
1748 my_sprintf (result, "%Le %d", -1.0L / 0.0L, 33, 44, 55);
1749 ASSERT (strcmp (result, "-inf 33") == 0
1750 || strcmp (result, "-infinity 33") == 0);
1751 ASSERT (retval == strlen (result));
1755 static long double zero = 0.0L;
1758 my_sprintf (result, "%Le %d", zero / zero, 33, 44, 55);
1759 ASSERT (strlen (result) >= 3 + 3
1760 && strisnan (result, 0, strlen (result) - 3, 0)
1761 && strcmp (result + strlen (result) - 3, " 33") == 0);
1762 ASSERT (retval == strlen (result));
1768 my_sprintf (result, "%15Le %d", 1.75L, 33, 44, 55);
1769 ASSERT (strcmp (result, " 1.750000e+00 33") == 0);
1770 ASSERT (retval == strlen (result));
1776 my_sprintf (result, "%-15Le %d", 1.75L, 33, 44, 55);
1777 ASSERT (strcmp (result, "1.750000e+00 33") == 0);
1778 ASSERT (retval == strlen (result));
1781 { /* FLAG_SHOWSIGN. */
1784 my_sprintf (result, "%+Le %d", 1.75L, 33, 44, 55);
1785 ASSERT (strcmp (result, "+1.750000e+00 33") == 0);
1786 ASSERT (retval == strlen (result));
1792 my_sprintf (result, "% Le %d", 1.75L, 33, 44, 55);
1793 ASSERT (strcmp (result, " 1.750000e+00 33") == 0);
1794 ASSERT (retval == strlen (result));
1800 my_sprintf (result, "%#Le %d", 1.75L, 33, 44, 55);
1801 ASSERT (strcmp (result, "1.750000e+00 33") == 0);
1802 ASSERT (retval == strlen (result));
1808 my_sprintf (result, "%#.Le %d", 1.75L, 33, 44, 55);
1809 ASSERT (strcmp (result, "2.e+00 33") == 0);
1810 ASSERT (retval == strlen (result));
1816 my_sprintf (result, "%#.Le %d", 9.75L, 33, 44, 55);
1817 ASSERT (strcmp (result, "1.e+01 33") == 0);
1818 ASSERT (retval == strlen (result));
1821 { /* FLAG_ZERO with finite number. */
1824 my_sprintf (result, "%015Le %d", 1234.0L, 33, 44, 55);
1825 ASSERT (strcmp (result, "0001.234000e+03 33") == 0);
1826 ASSERT (retval == strlen (result));
1829 { /* FLAG_ZERO with infinite number. */
1832 my_sprintf (result, "%015Le %d", -1.0L / 0.0L, 33, 44, 55);
1833 ASSERT (strcmp (result, " -inf 33") == 0
1834 || strcmp (result, " -infinity 33") == 0);
1835 ASSERT (retval == strlen (result));
1838 { /* FLAG_ZERO with NaN. */
1839 static long double zero = 0.0L;
1842 my_sprintf (result, "%050Le %d", zero / zero, 33, 44, 55);
1843 ASSERT (strlen (result) == 50 + 3
1844 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1845 && strcmp (result + strlen (result) - 3, " 33") == 0);
1846 ASSERT (retval == strlen (result));
1852 my_sprintf (result, "%.Le %d", 1234.0L, 33, 44, 55);
1853 ASSERT (strcmp (result, "1e+03 33") == 0);
1854 ASSERT (retval == strlen (result));
1857 /* Test the support of the %g format directive. */
1859 { /* A positive number. */
1862 my_sprintf (result, "%g %d", 12.75, 33, 44, 55);
1863 ASSERT (strcmp (result, "12.75 33") == 0);
1864 ASSERT (retval == strlen (result));
1867 { /* A larger positive number. */
1870 my_sprintf (result, "%g %d", 1234567.0, 33, 44, 55);
1871 ASSERT (strcmp (result, "1.23457e+06 33") == 0
1872 || strcmp (result, "1.23457e+006 33") == 0);
1873 ASSERT (retval == strlen (result));
1876 { /* Small and large positive numbers. */
1877 static struct { double value; const char *string; } data[] =
1879 { 1.234321234321234e-37, "1.23432e-37" },
1880 { 1.234321234321234e-36, "1.23432e-36" },
1881 { 1.234321234321234e-35, "1.23432e-35" },
1882 { 1.234321234321234e-34, "1.23432e-34" },
1883 { 1.234321234321234e-33, "1.23432e-33" },
1884 { 1.234321234321234e-32, "1.23432e-32" },
1885 { 1.234321234321234e-31, "1.23432e-31" },
1886 { 1.234321234321234e-30, "1.23432e-30" },
1887 { 1.234321234321234e-29, "1.23432e-29" },
1888 { 1.234321234321234e-28, "1.23432e-28" },
1889 { 1.234321234321234e-27, "1.23432e-27" },
1890 { 1.234321234321234e-26, "1.23432e-26" },
1891 { 1.234321234321234e-25, "1.23432e-25" },
1892 { 1.234321234321234e-24, "1.23432e-24" },
1893 { 1.234321234321234e-23, "1.23432e-23" },
1894 { 1.234321234321234e-22, "1.23432e-22" },
1895 { 1.234321234321234e-21, "1.23432e-21" },
1896 { 1.234321234321234e-20, "1.23432e-20" },
1897 { 1.234321234321234e-19, "1.23432e-19" },
1898 { 1.234321234321234e-18, "1.23432e-18" },
1899 { 1.234321234321234e-17, "1.23432e-17" },
1900 { 1.234321234321234e-16, "1.23432e-16" },
1901 { 1.234321234321234e-15, "1.23432e-15" },
1902 { 1.234321234321234e-14, "1.23432e-14" },
1903 { 1.234321234321234e-13, "1.23432e-13" },
1904 { 1.234321234321234e-12, "1.23432e-12" },
1905 { 1.234321234321234e-11, "1.23432e-11" },
1906 { 1.234321234321234e-10, "1.23432e-10" },
1907 { 1.234321234321234e-9, "1.23432e-09" },
1908 { 1.234321234321234e-8, "1.23432e-08" },
1909 { 1.234321234321234e-7, "1.23432e-07" },
1910 { 1.234321234321234e-6, "1.23432e-06" },
1911 { 1.234321234321234e-5, "1.23432e-05" },
1912 { 1.234321234321234e-4, "0.000123432" },
1913 { 1.234321234321234e-3, "0.00123432" },
1914 { 1.234321234321234e-2, "0.0123432" },
1915 { 1.234321234321234e-1, "0.123432" },
1916 { 1.234321234321234, "1.23432" },
1917 { 1.234321234321234e1, "12.3432" },
1918 { 1.234321234321234e2, "123.432" },
1919 { 1.234321234321234e3, "1234.32" },
1920 { 1.234321234321234e4, "12343.2" },
1921 { 1.234321234321234e5, "123432" },
1922 { 1.234321234321234e6, "1.23432e+06" },
1923 { 1.234321234321234e7, "1.23432e+07" },
1924 { 1.234321234321234e8, "1.23432e+08" },
1925 { 1.234321234321234e9, "1.23432e+09" },
1926 { 1.234321234321234e10, "1.23432e+10" },
1927 { 1.234321234321234e11, "1.23432e+11" },
1928 { 1.234321234321234e12, "1.23432e+12" },
1929 { 1.234321234321234e13, "1.23432e+13" },
1930 { 1.234321234321234e14, "1.23432e+14" },
1931 { 1.234321234321234e15, "1.23432e+15" },
1932 { 1.234321234321234e16, "1.23432e+16" },
1933 { 1.234321234321234e17, "1.23432e+17" },
1934 { 1.234321234321234e18, "1.23432e+18" },
1935 { 1.234321234321234e19, "1.23432e+19" },
1936 { 1.234321234321234e20, "1.23432e+20" },
1937 { 1.234321234321234e21, "1.23432e+21" },
1938 { 1.234321234321234e22, "1.23432e+22" },
1939 { 1.234321234321234e23, "1.23432e+23" },
1940 { 1.234321234321234e24, "1.23432e+24" },
1941 { 1.234321234321234e25, "1.23432e+25" },
1942 { 1.234321234321234e26, "1.23432e+26" },
1943 { 1.234321234321234e27, "1.23432e+27" },
1944 { 1.234321234321234e28, "1.23432e+28" },
1945 { 1.234321234321234e29, "1.23432e+29" },
1946 { 1.234321234321234e30, "1.23432e+30" },
1947 { 1.234321234321234e31, "1.23432e+31" },
1948 { 1.234321234321234e32, "1.23432e+32" },
1949 { 1.234321234321234e33, "1.23432e+33" },
1950 { 1.234321234321234e34, "1.23432e+34" },
1951 { 1.234321234321234e35, "1.23432e+35" },
1952 { 1.234321234321234e36, "1.23432e+36" }
1955 for (k = 0; k < SIZEOF (data); k++)
1959 my_sprintf (result, "%g", data[k].value);
1960 const char *expected = data[k].string;
1961 ASSERT (strcmp (result, expected) == 0
1962 /* Some implementations produce exponents with 3 digits. */
1963 || (expected[strlen (expected) - 4] == 'e'
1964 && strlen (result) == strlen (expected) + 1
1965 && memcmp (result, expected, strlen (expected) - 2) == 0
1966 && result[strlen (expected) - 2] == '0'
1967 && strcmp (result + strlen (expected) - 1,
1968 expected + strlen (expected) - 2)
1970 ASSERT (retval == strlen (result));
1974 { /* A negative number. */
1977 my_sprintf (result, "%g %d", -0.03125, 33, 44, 55);
1978 ASSERT (strcmp (result, "-0.03125 33") == 0);
1979 ASSERT (retval == strlen (result));
1982 { /* Positive zero. */
1985 my_sprintf (result, "%g %d", 0.0, 33, 44, 55);
1986 ASSERT (strcmp (result, "0 33") == 0);
1987 ASSERT (retval == strlen (result));
1990 { /* Negative zero. */
1993 my_sprintf (result, "%g %d", -0.0, 33, 44, 55);
1994 if (have_minus_zero ())
1995 ASSERT (strcmp (result, "-0 33") == 0);
1996 ASSERT (retval == strlen (result));
1999 { /* Positive infinity. */
2002 my_sprintf (result, "%g %d", 1.0 / 0.0, 33, 44, 55);
2003 ASSERT (strcmp (result, "inf 33") == 0
2004 || strcmp (result, "infinity 33") == 0);
2005 ASSERT (retval == strlen (result));
2008 { /* Negative infinity. */
2011 my_sprintf (result, "%g %d", -1.0 / 0.0, 33, 44, 55);
2012 ASSERT (strcmp (result, "-inf 33") == 0
2013 || strcmp (result, "-infinity 33") == 0);
2014 ASSERT (retval == strlen (result));
2020 my_sprintf (result, "%g %d", NaN (), 33, 44, 55);
2021 ASSERT (strlen (result) >= 3 + 3
2022 && strisnan (result, 0, strlen (result) - 3, 0)
2023 && strcmp (result + strlen (result) - 3, " 33") == 0);
2024 ASSERT (retval == strlen (result));
2030 my_sprintf (result, "%10g %d", 1.75, 33, 44, 55);
2031 ASSERT (strcmp (result, " 1.75 33") == 0);
2032 ASSERT (retval == strlen (result));
2038 my_sprintf (result, "%-10g %d", 1.75, 33, 44, 55);
2039 ASSERT (strcmp (result, "1.75 33") == 0);
2040 ASSERT (retval == strlen (result));
2043 { /* FLAG_SHOWSIGN. */
2046 my_sprintf (result, "%+g %d", 1.75, 33, 44, 55);
2047 ASSERT (strcmp (result, "+1.75 33") == 0);
2048 ASSERT (retval == strlen (result));
2054 my_sprintf (result, "% g %d", 1.75, 33, 44, 55);
2055 ASSERT (strcmp (result, " 1.75 33") == 0);
2056 ASSERT (retval == strlen (result));
2062 my_sprintf (result, "%#g %d", 1.75, 33, 44, 55);
2063 ASSERT (strcmp (result, "1.75000 33") == 0);
2064 ASSERT (retval == strlen (result));
2070 my_sprintf (result, "%#.g %d", 1.75, 33, 44, 55);
2071 ASSERT (strcmp (result, "2. 33") == 0);
2072 ASSERT (retval == strlen (result));
2078 my_sprintf (result, "%#.g %d", 9.75, 33, 44, 55);
2079 ASSERT (strcmp (result, "1.e+01 33") == 0
2080 || strcmp (result, "1.e+001 33") == 0);
2081 ASSERT (retval == strlen (result));
2084 { /* FLAG_ZERO with finite number. */
2087 my_sprintf (result, "%010g %d", 1234.0, 33, 44, 55);
2088 ASSERT (strcmp (result, "0000001234 33") == 0);
2089 ASSERT (retval == strlen (result));
2092 { /* FLAG_ZERO with infinite number. */
2095 my_sprintf (result, "%015g %d", -1.0 / 0.0, 33, 44, 55);
2096 ASSERT (strcmp (result, " -inf 33") == 0
2097 || strcmp (result, " -infinity 33") == 0);
2098 ASSERT (retval == strlen (result));
2101 { /* FLAG_ZERO with NaN. */
2104 my_sprintf (result, "%050g %d", NaN (), 33, 44, 55);
2105 ASSERT (strlen (result) == 50 + 3
2106 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2107 && strcmp (result + strlen (result) - 3, " 33") == 0);
2108 ASSERT (retval == strlen (result));
2114 my_sprintf (result, "%.g %d", 1234.0, 33, 44, 55);
2115 ASSERT (strcmp (result, "1e+03 33") == 0
2116 || strcmp (result, "1e+003 33") == 0);
2117 ASSERT (retval == strlen (result));
2120 { /* A positive number. */
2123 my_sprintf (result, "%Lg %d", 12.75L, 33, 44, 55);
2124 ASSERT (strcmp (result, "12.75 33") == 0);
2125 ASSERT (retval == strlen (result));
2128 { /* A larger positive number. */
2131 my_sprintf (result, "%Lg %d", 1234567.0L, 33, 44, 55);
2132 ASSERT (strcmp (result, "1.23457e+06 33") == 0);
2133 ASSERT (retval == strlen (result));
2136 { /* Small and large positive numbers. */
2137 static struct { long double value; const char *string; } data[] =
2139 { 1.234321234321234e-37L, "1.23432e-37" },
2140 { 1.234321234321234e-36L, "1.23432e-36" },
2141 { 1.234321234321234e-35L, "1.23432e-35" },
2142 { 1.234321234321234e-34L, "1.23432e-34" },
2143 { 1.234321234321234e-33L, "1.23432e-33" },
2144 { 1.234321234321234e-32L, "1.23432e-32" },
2145 { 1.234321234321234e-31L, "1.23432e-31" },
2146 { 1.234321234321234e-30L, "1.23432e-30" },
2147 { 1.234321234321234e-29L, "1.23432e-29" },
2148 { 1.234321234321234e-28L, "1.23432e-28" },
2149 { 1.234321234321234e-27L, "1.23432e-27" },
2150 { 1.234321234321234e-26L, "1.23432e-26" },
2151 { 1.234321234321234e-25L, "1.23432e-25" },
2152 { 1.234321234321234e-24L, "1.23432e-24" },
2153 { 1.234321234321234e-23L, "1.23432e-23" },
2154 { 1.234321234321234e-22L, "1.23432e-22" },
2155 { 1.234321234321234e-21L, "1.23432e-21" },
2156 { 1.234321234321234e-20L, "1.23432e-20" },
2157 { 1.234321234321234e-19L, "1.23432e-19" },
2158 { 1.234321234321234e-18L, "1.23432e-18" },
2159 { 1.234321234321234e-17L, "1.23432e-17" },
2160 { 1.234321234321234e-16L, "1.23432e-16" },
2161 { 1.234321234321234e-15L, "1.23432e-15" },
2162 { 1.234321234321234e-14L, "1.23432e-14" },
2163 { 1.234321234321234e-13L, "1.23432e-13" },
2164 { 1.234321234321234e-12L, "1.23432e-12" },
2165 { 1.234321234321234e-11L, "1.23432e-11" },
2166 { 1.234321234321234e-10L, "1.23432e-10" },
2167 { 1.234321234321234e-9L, "1.23432e-09" },
2168 { 1.234321234321234e-8L, "1.23432e-08" },
2169 { 1.234321234321234e-7L, "1.23432e-07" },
2170 { 1.234321234321234e-6L, "1.23432e-06" },
2171 { 1.234321234321234e-5L, "1.23432e-05" },
2172 { 1.234321234321234e-4L, "0.000123432" },
2173 { 1.234321234321234e-3L, "0.00123432" },
2174 { 1.234321234321234e-2L, "0.0123432" },
2175 { 1.234321234321234e-1L, "0.123432" },
2176 { 1.234321234321234L, "1.23432" },
2177 { 1.234321234321234e1L, "12.3432" },
2178 { 1.234321234321234e2L, "123.432" },
2179 { 1.234321234321234e3L, "1234.32" },
2180 { 1.234321234321234e4L, "12343.2" },
2181 { 1.234321234321234e5L, "123432" },
2182 { 1.234321234321234e6L, "1.23432e+06" },
2183 { 1.234321234321234e7L, "1.23432e+07" },
2184 { 1.234321234321234e8L, "1.23432e+08" },
2185 { 1.234321234321234e9L, "1.23432e+09" },
2186 { 1.234321234321234e10L, "1.23432e+10" },
2187 { 1.234321234321234e11L, "1.23432e+11" },
2188 { 1.234321234321234e12L, "1.23432e+12" },
2189 { 1.234321234321234e13L, "1.23432e+13" },
2190 { 1.234321234321234e14L, "1.23432e+14" },
2191 { 1.234321234321234e15L, "1.23432e+15" },
2192 { 1.234321234321234e16L, "1.23432e+16" },
2193 { 1.234321234321234e17L, "1.23432e+17" },
2194 { 1.234321234321234e18L, "1.23432e+18" },
2195 { 1.234321234321234e19L, "1.23432e+19" },
2196 { 1.234321234321234e20L, "1.23432e+20" },
2197 { 1.234321234321234e21L, "1.23432e+21" },
2198 { 1.234321234321234e22L, "1.23432e+22" },
2199 { 1.234321234321234e23L, "1.23432e+23" },
2200 { 1.234321234321234e24L, "1.23432e+24" },
2201 { 1.234321234321234e25L, "1.23432e+25" },
2202 { 1.234321234321234e26L, "1.23432e+26" },
2203 { 1.234321234321234e27L, "1.23432e+27" },
2204 { 1.234321234321234e28L, "1.23432e+28" },
2205 { 1.234321234321234e29L, "1.23432e+29" },
2206 { 1.234321234321234e30L, "1.23432e+30" },
2207 { 1.234321234321234e31L, "1.23432e+31" },
2208 { 1.234321234321234e32L, "1.23432e+32" },
2209 { 1.234321234321234e33L, "1.23432e+33" },
2210 { 1.234321234321234e34L, "1.23432e+34" },
2211 { 1.234321234321234e35L, "1.23432e+35" },
2212 { 1.234321234321234e36L, "1.23432e+36" }
2215 for (k = 0; k < SIZEOF (data); k++)
2219 my_sprintf (result, "%Lg", data[k].value);
2220 ASSERT (strcmp (result, data[k].string) == 0);
2221 ASSERT (retval == strlen (result));
2225 { /* A negative number. */
2228 my_sprintf (result, "%Lg %d", -0.03125L, 33, 44, 55);
2229 ASSERT (strcmp (result, "-0.03125 33") == 0);
2230 ASSERT (retval == strlen (result));
2233 { /* Positive zero. */
2236 my_sprintf (result, "%Lg %d", 0.0L, 33, 44, 55);
2237 ASSERT (strcmp (result, "0 33") == 0);
2238 ASSERT (retval == strlen (result));
2241 { /* Negative zero. */
2244 my_sprintf (result, "%Lg %d", -0.0L, 33, 44, 55);
2245 if (have_minus_zero ())
2246 ASSERT (strcmp (result, "-0 33") == 0);
2247 ASSERT (retval == strlen (result));
2250 { /* Positive infinity. */
2253 my_sprintf (result, "%Lg %d", 1.0L / 0.0L, 33, 44, 55);
2254 ASSERT (strcmp (result, "inf 33") == 0
2255 || strcmp (result, "infinity 33") == 0);
2256 ASSERT (retval == strlen (result));
2259 { /* Negative infinity. */
2262 my_sprintf (result, "%Lg %d", -1.0L / 0.0L, 33, 44, 55);
2263 ASSERT (strcmp (result, "-inf 33") == 0
2264 || strcmp (result, "-infinity 33") == 0);
2265 ASSERT (retval == strlen (result));
2269 static long double zero = 0.0L;
2272 my_sprintf (result, "%Lg %d", zero / zero, 33, 44, 55);
2273 ASSERT (strlen (result) >= 3 + 3
2274 && strisnan (result, 0, strlen (result) - 3, 0)
2275 && strcmp (result + strlen (result) - 3, " 33") == 0);
2276 ASSERT (retval == strlen (result));
2282 my_sprintf (result, "%10Lg %d", 1.75L, 33, 44, 55);
2283 ASSERT (strcmp (result, " 1.75 33") == 0);
2284 ASSERT (retval == strlen (result));
2290 my_sprintf (result, "%-10Lg %d", 1.75L, 33, 44, 55);
2291 ASSERT (strcmp (result, "1.75 33") == 0);
2292 ASSERT (retval == strlen (result));
2295 { /* FLAG_SHOWSIGN. */
2298 my_sprintf (result, "%+Lg %d", 1.75L, 33, 44, 55);
2299 ASSERT (strcmp (result, "+1.75 33") == 0);
2300 ASSERT (retval == strlen (result));
2306 my_sprintf (result, "% Lg %d", 1.75L, 33, 44, 55);
2307 ASSERT (strcmp (result, " 1.75 33") == 0);
2308 ASSERT (retval == strlen (result));
2314 my_sprintf (result, "%#Lg %d", 1.75L, 33, 44, 55);
2315 ASSERT (strcmp (result, "1.75000 33") == 0);
2316 ASSERT (retval == strlen (result));
2322 my_sprintf (result, "%#.Lg %d", 1.75L, 33, 44, 55);
2323 ASSERT (strcmp (result, "2. 33") == 0);
2324 ASSERT (retval == strlen (result));
2330 my_sprintf (result, "%#.Lg %d", 9.75L, 33, 44, 55);
2331 ASSERT (strcmp (result, "1.e+01 33") == 0);
2332 ASSERT (retval == strlen (result));
2335 { /* FLAG_ZERO with finite number. */
2338 my_sprintf (result, "%010Lg %d", 1234.0L, 33, 44, 55);
2339 ASSERT (strcmp (result, "0000001234 33") == 0);
2340 ASSERT (retval == strlen (result));
2343 { /* FLAG_ZERO with infinite number. */
2346 my_sprintf (result, "%015Lg %d", -1.0L / 0.0L, 33, 44, 55);
2347 ASSERT (strcmp (result, " -inf 33") == 0
2348 || strcmp (result, " -infinity 33") == 0);
2349 ASSERT (retval == strlen (result));
2352 { /* FLAG_ZERO with NaN. */
2353 static long double zero = 0.0L;
2356 my_sprintf (result, "%050Lg %d", zero / zero, 33, 44, 55);
2357 ASSERT (strlen (result) == 50 + 3
2358 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2359 && strcmp (result + strlen (result) - 3, " 33") == 0);
2360 ASSERT (retval == strlen (result));
2366 my_sprintf (result, "%.Lg %d", 1234.0L, 33, 44, 55);
2367 ASSERT (strcmp (result, "1e+03 33") == 0);
2368 ASSERT (retval == strlen (result));
2371 /* Test the support of the %n format directive. */
2377 my_sprintf (result, "%d %n", 123, &count, 33, 44, 55);
2378 ASSERT (strcmp (result, "123 ") == 0);
2379 ASSERT (retval == strlen (result));
2380 ASSERT (count == 4);
2383 /* Test the support of the POSIX/XSI format strings with positions. */
2388 my_sprintf (result, "%2$d %1$d", 33, 55);
2389 ASSERT (strcmp (result, "55 33") == 0);
2390 ASSERT (retval == strlen (result));
2393 /* Test the support of the grouping flag. */
2398 my_sprintf (result, "%'d %d", 1234567, 99);
2399 ASSERT (result[strlen (result) - 1] == '9');
2400 ASSERT (retval == strlen (result));