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)
33 strmatch (const char *pattern, const char *string)
35 if (strlen (pattern) != strlen (string))
37 for (; *pattern != '\0'; pattern++, string++)
38 if (*pattern != '*' && *string != *pattern)
44 test_function (int (*my_sprintf) (char *, const char *, ...))
48 /* Test return value convention. */
53 memcpy (buf, "DEADBEEF", 8);
54 retval = my_sprintf (buf, "%d", 12345);
56 ASSERT (memcmp (buf, "12345\0EF", 8) == 0);
59 /* Test support of size specifiers as in C99. */
64 my_sprintf (result, "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
65 ASSERT (strcmp (result, "12345671 33") == 0);
66 ASSERT (retval == strlen (result));
72 my_sprintf (result, "%zu %d", (size_t) 12345672, 33, 44, 55);
73 ASSERT (strcmp (result, "12345672 33") == 0);
74 ASSERT (retval == strlen (result));
80 my_sprintf (result, "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
81 ASSERT (strcmp (result, "12345673 33") == 0);
82 ASSERT (retval == strlen (result));
88 my_sprintf (result, "%Lg %d", (long double) 1.5, 33, 44, 55);
89 ASSERT (strcmp (result, "1.5 33") == 0);
90 ASSERT (retval == strlen (result));
93 /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
94 output of floating-point numbers. */
96 { /* A positive number. */
99 my_sprintf (result, "%a %d", 3.1416015625, 33, 44, 55);
100 ASSERT (strcmp (result, "0x1.922p+1 33") == 0
101 || strcmp (result, "0x3.244p+0 33") == 0
102 || strcmp (result, "0x6.488p-1 33") == 0
103 || strcmp (result, "0xc.91p-2 33") == 0);
104 ASSERT (retval == strlen (result));
107 { /* A negative number. */
110 my_sprintf (result, "%A %d", -3.1416015625, 33, 44, 55);
111 ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
112 || strcmp (result, "-0X3.244P+0 33") == 0
113 || strcmp (result, "-0X6.488P-1 33") == 0
114 || strcmp (result, "-0XC.91P-2 33") == 0);
115 ASSERT (retval == strlen (result));
118 { /* Positive zero. */
121 my_sprintf (result, "%a %d", 0.0, 33, 44, 55);
122 ASSERT (strcmp (result, "0x0p+0 33") == 0);
123 ASSERT (retval == strlen (result));
126 { /* Negative zero. */
129 my_sprintf (result, "%a %d", -0.0, 33, 44, 55);
130 ASSERT (strcmp (result, "-0x0p+0 33") == 0);
131 ASSERT (retval == strlen (result));
134 { /* Positive infinity. */
137 my_sprintf (result, "%a %d", 1.0 / 0.0, 33, 44, 55);
138 ASSERT (strcmp (result, "inf 33") == 0);
139 ASSERT (retval == strlen (result));
142 { /* Negative infinity. */
145 my_sprintf (result, "%a %d", -1.0 / 0.0, 33, 44, 55);
146 ASSERT (strcmp (result, "-inf 33") == 0);
147 ASSERT (retval == strlen (result));
153 my_sprintf (result, "%a %d", NaN (), 33, 44, 55);
154 ASSERT (strlen (result) >= 3 + 3
155 && memcmp (result, "nan", 3) == 0
156 && strcmp (result + strlen (result) - 3, " 33") == 0);
157 ASSERT (retval == strlen (result));
160 { /* Rounding near the decimal point. */
163 my_sprintf (result, "%.0a %d", 1.5, 33, 44, 55);
164 ASSERT (strcmp (result, "0x2p+0 33") == 0
165 || strcmp (result, "0x3p-1 33") == 0
166 || strcmp (result, "0x6p-2 33") == 0
167 || strcmp (result, "0xcp-3 33") == 0);
168 ASSERT (retval == strlen (result));
171 { /* Rounding with precision 0. */
174 my_sprintf (result, "%.0a %d", 1.51, 33, 44, 55);
175 ASSERT (strcmp (result, "0x2p+0 33") == 0
176 || strcmp (result, "0x3p-1 33") == 0
177 || strcmp (result, "0x6p-2 33") == 0
178 || strcmp (result, "0xcp-3 33") == 0);
179 ASSERT (retval == strlen (result));
182 { /* Rounding with precision 1. */
185 my_sprintf (result, "%.1a %d", 1.51, 33, 44, 55);
186 ASSERT (strcmp (result, "0x1.8p+0 33") == 0
187 || strcmp (result, "0x3.0p-1 33") == 0
188 || strcmp (result, "0x6.1p-2 33") == 0
189 || strcmp (result, "0xc.1p-3 33") == 0);
190 ASSERT (retval == strlen (result));
193 { /* Rounding with precision 2. */
196 my_sprintf (result, "%.2a %d", 1.51, 33, 44, 55);
197 ASSERT (strcmp (result, "0x1.83p+0 33") == 0
198 || strcmp (result, "0x3.05p-1 33") == 0
199 || strcmp (result, "0x6.0ap-2 33") == 0
200 || strcmp (result, "0xc.14p-3 33") == 0);
201 ASSERT (retval == strlen (result));
204 { /* Rounding with precision 3. */
207 my_sprintf (result, "%.3a %d", 1.51, 33, 44, 55);
208 ASSERT (strcmp (result, "0x1.829p+0 33") == 0
209 || strcmp (result, "0x3.052p-1 33") == 0
210 || strcmp (result, "0x6.0a4p-2 33") == 0
211 || strcmp (result, "0xc.148p-3 33") == 0);
212 ASSERT (retval == strlen (result));
215 { /* Rounding can turn a ...FFF into a ...000. */
218 my_sprintf (result, "%.3a %d", 1.49999, 33, 44, 55);
219 ASSERT (strcmp (result, "0x1.800p+0 33") == 0
220 || strcmp (result, "0x3.000p-1 33") == 0
221 || strcmp (result, "0x6.000p-2 33") == 0
222 || strcmp (result, "0xc.000p-3 33") == 0);
223 ASSERT (retval == strlen (result));
226 { /* Rounding can turn a ...FFF into a ...000.
227 This shows a MacOS X 10.3.9 (Darwin 7.9) bug. */
230 my_sprintf (result, "%.1a %d", 1.999, 33, 44, 55);
231 ASSERT (strcmp (result, "0x1.0p+1 33") == 0
232 || strcmp (result, "0x2.0p+0 33") == 0
233 || strcmp (result, "0x4.0p-1 33") == 0
234 || strcmp (result, "0x8.0p-2 33") == 0);
235 ASSERT (retval == strlen (result));
241 my_sprintf (result, "%10a %d", 1.75, 33, 44, 55);
242 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
243 || strcmp (result, " 0x3.8p-1 33") == 0
244 || strcmp (result, " 0x7p-2 33") == 0
245 || strcmp (result, " 0xep-3 33") == 0);
246 ASSERT (retval == strlen (result));
249 { /* Small precision. */
252 my_sprintf (result, "%.10a %d", 1.75, 33, 44, 55);
253 ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
254 || strcmp (result, "0x3.8000000000p-1 33") == 0
255 || strcmp (result, "0x7.0000000000p-2 33") == 0
256 || strcmp (result, "0xe.0000000000p-3 33") == 0);
257 ASSERT (retval == strlen (result));
260 { /* Large precision. */
263 my_sprintf (result, "%.50a %d", 1.75, 33, 44, 55);
264 ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
265 || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
266 || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
267 || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 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 { /* FLAG_SHOWSIGN. */
285 my_sprintf (result, "%+a %d", 1.75, 33, 44, 55);
286 ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
287 || strcmp (result, "+0x3.8p-1 33") == 0
288 || strcmp (result, "+0x7p-2 33") == 0
289 || strcmp (result, "+0xep-3 33") == 0);
290 ASSERT (retval == strlen (result));
296 my_sprintf (result, "% a %d", 1.75, 33, 44, 55);
297 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
298 || strcmp (result, " 0x3.8p-1 33") == 0
299 || strcmp (result, " 0x7p-2 33") == 0
300 || strcmp (result, " 0xep-3 33") == 0);
301 ASSERT (retval == strlen (result));
307 my_sprintf (result, "%#a %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, "0x7.p-2 33") == 0
311 || strcmp (result, "0xe.p-3 33") == 0);
312 ASSERT (retval == strlen (result));
318 my_sprintf (result, "%#a %d", 1.0, 33, 44, 55);
319 ASSERT (strcmp (result, "0x1.p+0 33") == 0
320 || strcmp (result, "0x2.p-1 33") == 0
321 || strcmp (result, "0x4.p-2 33") == 0
322 || strcmp (result, "0x8.p-3 33") == 0);
323 ASSERT (retval == strlen (result));
326 { /* FLAG_ZERO with finite number. */
329 my_sprintf (result, "%010a %d", 1.75, 33, 44, 55);
330 ASSERT (strcmp (result, "0x001.cp+0 33") == 0
331 || strcmp (result, "0x003.8p-1 33") == 0
332 || strcmp (result, "0x00007p-2 33") == 0
333 || strcmp (result, "0x0000ep-3 33") == 0);
334 ASSERT (retval == strlen (result));
337 { /* FLAG_ZERO with infinite number. */
340 my_sprintf (result, "%010a %d", 1.0 / 0.0, 33, 44, 55);
341 /* "0000000inf 33" is not a valid result; see
342 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
343 ASSERT (strcmp (result, " inf 33") == 0);
344 ASSERT (retval == strlen (result));
347 { /* FLAG_ZERO with NaN. */
350 my_sprintf (result, "%020a %d", NaN (), 33, 44, 55);
351 /* "0000000nan 33" is not a valid result; see
352 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
353 ASSERT (strlen (result) == 20 + 3
354 && memcmp (result + strspn (result, " "), "nan", 3) == 0
355 && strcmp (result + strlen (result) - 3, " 33") == 0);
356 ASSERT (retval == strlen (result));
359 { /* A positive number. */
362 my_sprintf (result, "%La %d", 3.1416015625L, 33, 44, 55);
363 ASSERT (strcmp (result, "0x1.922p+1 33") == 0
364 || strcmp (result, "0x3.244p+0 33") == 0
365 || strcmp (result, "0x6.488p-1 33") == 0
366 || strcmp (result, "0xc.91p-2 33") == 0);
367 ASSERT (retval == strlen (result));
370 { /* A negative number. */
373 my_sprintf (result, "%LA %d", -3.1416015625L, 33, 44, 55);
374 ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
375 || strcmp (result, "-0X3.244P+0 33") == 0
376 || strcmp (result, "-0X6.488P-1 33") == 0
377 || strcmp (result, "-0XC.91P-2 33") == 0);
378 ASSERT (retval == strlen (result));
381 { /* Positive zero. */
384 my_sprintf (result, "%La %d", 0.0L, 33, 44, 55);
385 ASSERT (strcmp (result, "0x0p+0 33") == 0);
386 ASSERT (retval == strlen (result));
389 { /* Negative zero. */
392 my_sprintf (result, "%La %d", -0.0L, 33, 44, 55);
393 ASSERT (strcmp (result, "-0x0p+0 33") == 0);
394 ASSERT (retval == strlen (result));
397 { /* Positive infinity. */
400 my_sprintf (result, "%La %d", 1.0L / 0.0L, 33, 44, 55);
401 ASSERT (strcmp (result, "inf 33") == 0);
402 ASSERT (retval == strlen (result));
405 { /* Negative infinity. */
408 my_sprintf (result, "%La %d", -1.0L / 0.0L, 33, 44, 55);
409 ASSERT (strcmp (result, "-inf 33") == 0);
410 ASSERT (retval == strlen (result));
416 my_sprintf (result, "%La %d", 0.0L / 0.0L, 33, 44, 55);
417 ASSERT (strlen (result) >= 3 + 3
418 && memcmp (result, "nan", 3) == 0
419 && strcmp (result + strlen (result) - 3, " 33") == 0);
420 ASSERT (retval == strlen (result));
423 { /* Rounding near the decimal point. */
426 my_sprintf (result, "%.0La %d", 1.5L, 33, 44, 55);
427 ASSERT (strcmp (result, "0x2p+0 33") == 0
428 || strcmp (result, "0x3p-1 33") == 0
429 || strcmp (result, "0x6p-2 33") == 0
430 || strcmp (result, "0xcp-3 33") == 0);
431 ASSERT (retval == strlen (result));
434 { /* Rounding with precision 0. */
437 my_sprintf (result, "%.0La %d", 1.51L, 33, 44, 55);
438 ASSERT (strcmp (result, "0x2p+0 33") == 0
439 || strcmp (result, "0x3p-1 33") == 0
440 || strcmp (result, "0x6p-2 33") == 0
441 || strcmp (result, "0xcp-3 33") == 0);
442 ASSERT (retval == strlen (result));
445 { /* Rounding with precision 1. */
448 my_sprintf (result, "%.1La %d", 1.51L, 33, 44, 55);
449 ASSERT (strcmp (result, "0x1.8p+0 33") == 0
450 || strcmp (result, "0x3.0p-1 33") == 0
451 || strcmp (result, "0x6.1p-2 33") == 0
452 || strcmp (result, "0xc.1p-3 33") == 0);
453 ASSERT (retval == strlen (result));
456 { /* Rounding with precision 2. */
459 my_sprintf (result, "%.2La %d", 1.51L, 33, 44, 55);
460 ASSERT (strcmp (result, "0x1.83p+0 33") == 0
461 || strcmp (result, "0x3.05p-1 33") == 0
462 || strcmp (result, "0x6.0ap-2 33") == 0
463 || strcmp (result, "0xc.14p-3 33") == 0);
464 ASSERT (retval == strlen (result));
467 { /* Rounding with precision 3. */
470 my_sprintf (result, "%.3La %d", 1.51L, 33, 44, 55);
471 ASSERT (strcmp (result, "0x1.829p+0 33") == 0
472 || strcmp (result, "0x3.052p-1 33") == 0
473 || strcmp (result, "0x6.0a4p-2 33") == 0
474 || strcmp (result, "0xc.148p-3 33") == 0);
475 ASSERT (retval == strlen (result));
478 { /* Rounding can turn a ...FFF into a ...000. */
481 my_sprintf (result, "%.3La %d", 1.49999L, 33, 44, 55);
482 ASSERT (strcmp (result, "0x1.800p+0 33") == 0
483 || strcmp (result, "0x3.000p-1 33") == 0
484 || strcmp (result, "0x6.000p-2 33") == 0
485 || strcmp (result, "0xc.000p-3 33") == 0);
486 ASSERT (retval == strlen (result));
489 { /* Rounding can turn a ...FFF into a ...000.
490 This shows a MacOS X 10.3.9 (Darwin 7.9) bug and a
491 glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>. */
494 my_sprintf (result, "%.1La %d", 1.999L, 33, 44, 55);
495 ASSERT (strcmp (result, "0x1.0p+1 33") == 0
496 || strcmp (result, "0x2.0p+0 33") == 0
497 || strcmp (result, "0x4.0p-1 33") == 0
498 || strcmp (result, "0x8.0p-2 33") == 0);
499 ASSERT (retval == strlen (result));
505 my_sprintf (result, "%10La %d", 1.75L, 33, 44, 55);
506 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
507 || strcmp (result, " 0x3.8p-1 33") == 0
508 || strcmp (result, " 0x7p-2 33") == 0
509 || strcmp (result, " 0xep-3 33") == 0);
510 ASSERT (retval == strlen (result));
513 { /* Small precision. */
516 my_sprintf (result, "%.10La %d", 1.75L, 33, 44, 55);
517 ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
518 || strcmp (result, "0x3.8000000000p-1 33") == 0
519 || strcmp (result, "0x7.0000000000p-2 33") == 0
520 || strcmp (result, "0xe.0000000000p-3 33") == 0);
521 ASSERT (retval == strlen (result));
524 { /* Large precision. */
527 my_sprintf (result, "%.50La %d", 1.75L, 33, 44, 55);
528 ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
529 || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
530 || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
531 || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
532 ASSERT (retval == strlen (result));
538 my_sprintf (result, "%-10La %d", 1.75L, 33, 44, 55);
539 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
540 || strcmp (result, "0x3.8p-1 33") == 0
541 || strcmp (result, "0x7p-2 33") == 0
542 || strcmp (result, "0xep-3 33") == 0);
543 ASSERT (retval == strlen (result));
546 { /* FLAG_SHOWSIGN. */
549 my_sprintf (result, "%+La %d", 1.75L, 33, 44, 55);
550 ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
551 || strcmp (result, "+0x3.8p-1 33") == 0
552 || strcmp (result, "+0x7p-2 33") == 0
553 || strcmp (result, "+0xep-3 33") == 0);
554 ASSERT (retval == strlen (result));
560 my_sprintf (result, "% La %d", 1.75L, 33, 44, 55);
561 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
562 || strcmp (result, " 0x3.8p-1 33") == 0
563 || strcmp (result, " 0x7p-2 33") == 0
564 || strcmp (result, " 0xep-3 33") == 0);
565 ASSERT (retval == strlen (result));
571 my_sprintf (result, "%#La %d", 1.75L, 33, 44, 55);
572 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
573 || strcmp (result, "0x3.8p-1 33") == 0
574 || strcmp (result, "0x7.p-2 33") == 0
575 || strcmp (result, "0xe.p-3 33") == 0);
576 ASSERT (retval == strlen (result));
582 my_sprintf (result, "%#La %d", 1.0L, 33, 44, 55);
583 ASSERT (strcmp (result, "0x1.p+0 33") == 0
584 || strcmp (result, "0x2.p-1 33") == 0
585 || strcmp (result, "0x4.p-2 33") == 0
586 || strcmp (result, "0x8.p-3 33") == 0);
587 ASSERT (retval == strlen (result));
590 { /* FLAG_ZERO with finite number. */
593 my_sprintf (result, "%010La %d", 1.75L, 33, 44, 55);
594 ASSERT (strcmp (result, "0x001.cp+0 33") == 0
595 || strcmp (result, "0x003.8p-1 33") == 0
596 || strcmp (result, "0x00007p-2 33") == 0
597 || strcmp (result, "0x0000ep-3 33") == 0);
598 ASSERT (retval == strlen (result));
601 { /* FLAG_ZERO with infinite number. */
604 my_sprintf (result, "%010La %d", 1.0L / 0.0L, 33, 44, 55);
605 /* "0000000inf 33" is not a valid result; see
606 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
607 ASSERT (strcmp (result, " inf 33") == 0);
608 ASSERT (retval == strlen (result));
611 { /* FLAG_ZERO with NaN. */
614 my_sprintf (result, "%020La %d", 0.0L / 0.0L, 33, 44, 55);
615 /* "0000000nan 33" is not a valid result; see
616 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
617 ASSERT (strlen (result) == 20 + 3
618 && memcmp (result + strspn (result, " "), "nan", 3) == 0
619 && strcmp (result + strlen (result) - 3, " 33") == 0);
620 ASSERT (retval == strlen (result));
623 /* Test the support of the %f format directive. */
625 { /* A positive number. */
628 my_sprintf (result, "%f %d", 12.75, 33, 44, 55);
629 ASSERT (strcmp (result, "12.750000 33") == 0);
630 ASSERT (retval == strlen (result));
633 { /* A larger positive number. */
636 my_sprintf (result, "%f %d", 1234567.0, 33, 44, 55);
637 ASSERT (strcmp (result, "1234567.000000 33") == 0);
638 ASSERT (retval == strlen (result));
641 { /* Small and large positive numbers. */
642 static struct { double value; const char *string; } data[] =
644 { 1.234321234321234e-37, "0.000000" },
645 { 1.234321234321234e-36, "0.000000" },
646 { 1.234321234321234e-35, "0.000000" },
647 { 1.234321234321234e-34, "0.000000" },
648 { 1.234321234321234e-33, "0.000000" },
649 { 1.234321234321234e-32, "0.000000" },
650 { 1.234321234321234e-31, "0.000000" },
651 { 1.234321234321234e-30, "0.000000" },
652 { 1.234321234321234e-29, "0.000000" },
653 { 1.234321234321234e-28, "0.000000" },
654 { 1.234321234321234e-27, "0.000000" },
655 { 1.234321234321234e-26, "0.000000" },
656 { 1.234321234321234e-25, "0.000000" },
657 { 1.234321234321234e-24, "0.000000" },
658 { 1.234321234321234e-23, "0.000000" },
659 { 1.234321234321234e-22, "0.000000" },
660 { 1.234321234321234e-21, "0.000000" },
661 { 1.234321234321234e-20, "0.000000" },
662 { 1.234321234321234e-19, "0.000000" },
663 { 1.234321234321234e-18, "0.000000" },
664 { 1.234321234321234e-17, "0.000000" },
665 { 1.234321234321234e-16, "0.000000" },
666 { 1.234321234321234e-15, "0.000000" },
667 { 1.234321234321234e-14, "0.000000" },
668 { 1.234321234321234e-13, "0.000000" },
669 { 1.234321234321234e-12, "0.000000" },
670 { 1.234321234321234e-11, "0.000000" },
671 { 1.234321234321234e-10, "0.000000" },
672 { 1.234321234321234e-9, "0.000000" },
673 { 1.234321234321234e-8, "0.000000" },
674 { 1.234321234321234e-7, "0.000000" },
675 { 1.234321234321234e-6, "0.000001" },
676 { 1.234321234321234e-5, "0.000012" },
677 { 1.234321234321234e-4, "0.000123" },
678 { 1.234321234321234e-3, "0.001234" },
679 { 1.234321234321234e-2, "0.012343" },
680 { 1.234321234321234e-1, "0.123432" },
681 { 1.234321234321234, "1.234321" },
682 { 1.234321234321234e1, "12.343212" },
683 { 1.234321234321234e2, "123.432123" },
684 { 1.234321234321234e3, "1234.321234" },
685 { 1.234321234321234e4, "12343.212343" },
686 { 1.234321234321234e5, "123432.123432" },
687 { 1.234321234321234e6, "1234321.234321" },
688 { 1.234321234321234e7, "12343212.343212" },
689 { 1.234321234321234e8, "123432123.432123" },
690 { 1.234321234321234e9, "1234321234.321234" },
691 { 1.234321234321234e10, "12343212343.2123**" },
692 { 1.234321234321234e11, "123432123432.123***" },
693 { 1.234321234321234e12, "1234321234321.23****" },
694 { 1.234321234321234e13, "12343212343212.3*****" },
695 { 1.234321234321234e14, "123432123432123.******" },
696 { 1.234321234321234e15, "1234321234321234.000000" },
697 { 1.234321234321234e16, "123432123432123**.000000" },
698 { 1.234321234321234e17, "123432123432123***.000000" },
699 { 1.234321234321234e18, "123432123432123****.000000" },
700 { 1.234321234321234e19, "123432123432123*****.000000" },
701 { 1.234321234321234e20, "123432123432123******.000000" },
702 { 1.234321234321234e21, "123432123432123*******.000000" },
703 { 1.234321234321234e22, "123432123432123********.000000" },
704 { 1.234321234321234e23, "123432123432123*********.000000" },
705 { 1.234321234321234e24, "123432123432123**********.000000" },
706 { 1.234321234321234e25, "123432123432123***********.000000" },
707 { 1.234321234321234e26, "123432123432123************.000000" },
708 { 1.234321234321234e27, "123432123432123*************.000000" },
709 { 1.234321234321234e28, "123432123432123**************.000000" },
710 { 1.234321234321234e29, "123432123432123***************.000000" },
711 { 1.234321234321234e30, "123432123432123****************.000000" },
712 { 1.234321234321234e31, "123432123432123*****************.000000" },
713 { 1.234321234321234e32, "123432123432123******************.000000" },
714 { 1.234321234321234e33, "123432123432123*******************.000000" },
715 { 1.234321234321234e34, "123432123432123********************.000000" },
716 { 1.234321234321234e35, "123432123432123*********************.000000" },
717 { 1.234321234321234e36, "123432123432123**********************.000000" }
720 for (k = 0; k < SIZEOF (data); k++)
724 my_sprintf (result, "%f", data[k].value);
725 ASSERT (strmatch (data[k].string, result));
726 ASSERT (retval == strlen (result));
730 { /* A negative number. */
733 my_sprintf (result, "%f %d", -0.03125, 33, 44, 55);
734 ASSERT (strcmp (result, "-0.031250 33") == 0);
735 ASSERT (retval == strlen (result));
738 { /* Positive zero. */
741 my_sprintf (result, "%f %d", 0.0, 33, 44, 55);
742 ASSERT (strcmp (result, "0.000000 33") == 0);
743 ASSERT (retval == strlen (result));
746 { /* Negative zero. */
749 my_sprintf (result, "%f %d", -0.0, 33, 44, 55);
750 ASSERT (strcmp (result, "-0.000000 33") == 0);
751 ASSERT (retval == strlen (result));
754 { /* Positive infinity. */
757 my_sprintf (result, "%f %d", 1.0 / 0.0, 33, 44, 55);
758 ASSERT (strcmp (result, "inf 33") == 0
759 || strcmp (result, "infinity 33") == 0);
760 ASSERT (retval == strlen (result));
763 { /* Negative infinity. */
766 my_sprintf (result, "%f %d", -1.0 / 0.0, 33, 44, 55);
767 ASSERT (strcmp (result, "-inf 33") == 0
768 || strcmp (result, "-infinity 33") == 0);
769 ASSERT (retval == strlen (result));
775 my_sprintf (result, "%f %d", NaN (), 33, 44, 55);
776 ASSERT (strlen (result) >= 3 + 3
777 && memcmp (result, "nan", 3) == 0
778 && strcmp (result + strlen (result) - 3, " 33") == 0);
779 ASSERT (retval == strlen (result));
785 my_sprintf (result, "%10f %d", 1.75, 33, 44, 55);
786 ASSERT (strcmp (result, " 1.750000 33") == 0);
787 ASSERT (retval == strlen (result));
793 my_sprintf (result, "%-10f %d", 1.75, 33, 44, 55);
794 ASSERT (strcmp (result, "1.750000 33") == 0);
795 ASSERT (retval == strlen (result));
798 { /* FLAG_SHOWSIGN. */
801 my_sprintf (result, "%+f %d", 1.75, 33, 44, 55);
802 ASSERT (strcmp (result, "+1.750000 33") == 0);
803 ASSERT (retval == strlen (result));
809 my_sprintf (result, "% f %d", 1.75, 33, 44, 55);
810 ASSERT (strcmp (result, " 1.750000 33") == 0);
811 ASSERT (retval == strlen (result));
817 my_sprintf (result, "%#f %d", 1.75, 33, 44, 55);
818 ASSERT (strcmp (result, "1.750000 33") == 0);
819 ASSERT (retval == strlen (result));
825 my_sprintf (result, "%#.f %d", 1.75, 33, 44, 55);
826 ASSERT (strcmp (result, "2. 33") == 0);
827 ASSERT (retval == strlen (result));
830 { /* FLAG_ZERO with finite number. */
833 my_sprintf (result, "%015f %d", 1234.0, 33, 44, 55);
834 ASSERT (strcmp (result, "00001234.000000 33") == 0);
835 ASSERT (retval == strlen (result));
838 { /* FLAG_ZERO with infinite number. */
841 my_sprintf (result, "%015f %d", -1.0 / 0.0, 33, 44, 55);
842 ASSERT (strcmp (result, " -inf 33") == 0
843 || strcmp (result, " -infinity 33") == 0);
844 ASSERT (retval == strlen (result));
847 { /* FLAG_ZERO with NaN. */
850 my_sprintf (result, "%020f %d", NaN (), 33, 44, 55);
851 ASSERT (strlen (result) == 20 + 3
852 && memcmp (result + strspn (result, " "), "nan", 3) == 0
853 && strcmp (result + strlen (result) - 3, " 33") == 0);
854 ASSERT (retval == strlen (result));
860 my_sprintf (result, "%.f %d", 1234.0, 33, 44, 55);
861 ASSERT (strcmp (result, "1234 33") == 0);
862 ASSERT (retval == strlen (result));
865 { /* A positive number. */
868 my_sprintf (result, "%Lf %d", 12.75L, 33, 44, 55);
869 ASSERT (strcmp (result, "12.750000 33") == 0);
870 ASSERT (retval == strlen (result));
873 { /* A larger positive number. */
876 my_sprintf (result, "%Lf %d", 1234567.0L, 33, 44, 55);
877 ASSERT (strcmp (result, "1234567.000000 33") == 0);
878 ASSERT (retval == strlen (result));
881 { /* Small and large positive numbers. */
882 static struct { long double value; const char *string; } data[] =
884 { 1.234321234321234e-37L, "0.000000" },
885 { 1.234321234321234e-36L, "0.000000" },
886 { 1.234321234321234e-35L, "0.000000" },
887 { 1.234321234321234e-34L, "0.000000" },
888 { 1.234321234321234e-33L, "0.000000" },
889 { 1.234321234321234e-32L, "0.000000" },
890 { 1.234321234321234e-31L, "0.000000" },
891 { 1.234321234321234e-30L, "0.000000" },
892 { 1.234321234321234e-29L, "0.000000" },
893 { 1.234321234321234e-28L, "0.000000" },
894 { 1.234321234321234e-27L, "0.000000" },
895 { 1.234321234321234e-26L, "0.000000" },
896 { 1.234321234321234e-25L, "0.000000" },
897 { 1.234321234321234e-24L, "0.000000" },
898 { 1.234321234321234e-23L, "0.000000" },
899 { 1.234321234321234e-22L, "0.000000" },
900 { 1.234321234321234e-21L, "0.000000" },
901 { 1.234321234321234e-20L, "0.000000" },
902 { 1.234321234321234e-19L, "0.000000" },
903 { 1.234321234321234e-18L, "0.000000" },
904 { 1.234321234321234e-17L, "0.000000" },
905 { 1.234321234321234e-16L, "0.000000" },
906 { 1.234321234321234e-15L, "0.000000" },
907 { 1.234321234321234e-14L, "0.000000" },
908 { 1.234321234321234e-13L, "0.000000" },
909 { 1.234321234321234e-12L, "0.000000" },
910 { 1.234321234321234e-11L, "0.000000" },
911 { 1.234321234321234e-10L, "0.000000" },
912 { 1.234321234321234e-9L, "0.000000" },
913 { 1.234321234321234e-8L, "0.000000" },
914 { 1.234321234321234e-7L, "0.000000" },
915 { 1.234321234321234e-6L, "0.000001" },
916 { 1.234321234321234e-5L, "0.000012" },
917 { 1.234321234321234e-4L, "0.000123" },
918 { 1.234321234321234e-3L, "0.001234" },
919 { 1.234321234321234e-2L, "0.012343" },
920 { 1.234321234321234e-1L, "0.123432" },
921 { 1.234321234321234L, "1.234321" },
922 { 1.234321234321234e1L, "12.343212" },
923 { 1.234321234321234e2L, "123.432123" },
924 { 1.234321234321234e3L, "1234.321234" },
925 { 1.234321234321234e4L, "12343.212343" },
926 { 1.234321234321234e5L, "123432.123432" },
927 { 1.234321234321234e6L, "1234321.234321" },
928 { 1.234321234321234e7L, "12343212.343212" },
929 { 1.234321234321234e8L, "123432123.432123" },
930 { 1.234321234321234e9L, "1234321234.321234" },
931 { 1.234321234321234e10L, "12343212343.2123**" },
932 { 1.234321234321234e11L, "123432123432.123***" },
933 { 1.234321234321234e12L, "1234321234321.23****" },
934 { 1.234321234321234e13L, "12343212343212.3*****" },
935 { 1.234321234321234e14L, "123432123432123.******" },
936 { 1.234321234321234e15L, "1234321234321234.000000" },
937 { 1.234321234321234e16L, "123432123432123**.000000" },
938 { 1.234321234321234e17L, "123432123432123***.000000" },
939 { 1.234321234321234e18L, "123432123432123****.000000" },
940 { 1.234321234321234e19L, "123432123432123*****.000000" },
941 { 1.234321234321234e20L, "123432123432123******.000000" },
942 { 1.234321234321234e21L, "123432123432123*******.000000" },
943 { 1.234321234321234e22L, "123432123432123********.000000" },
944 { 1.234321234321234e23L, "123432123432123*********.000000" },
945 { 1.234321234321234e24L, "123432123432123**********.000000" },
946 { 1.234321234321234e25L, "123432123432123***********.000000" },
947 { 1.234321234321234e26L, "123432123432123************.000000" },
948 { 1.234321234321234e27L, "123432123432123*************.000000" },
949 { 1.234321234321234e28L, "123432123432123**************.000000" },
950 { 1.234321234321234e29L, "123432123432123***************.000000" },
951 { 1.234321234321234e30L, "123432123432123****************.000000" },
952 { 1.234321234321234e31L, "123432123432123*****************.000000" },
953 { 1.234321234321234e32L, "123432123432123******************.000000" },
954 { 1.234321234321234e33L, "123432123432123*******************.000000" },
955 { 1.234321234321234e34L, "123432123432123********************.000000" },
956 { 1.234321234321234e35L, "123432123432123*********************.000000" },
957 { 1.234321234321234e36L, "123432123432123**********************.000000" }
960 for (k = 0; k < SIZEOF (data); k++)
964 my_sprintf (result, "%Lf", data[k].value);
965 ASSERT (strmatch (data[k].string, result));
966 ASSERT (retval == strlen (result));
970 { /* A negative number. */
973 my_sprintf (result, "%Lf %d", -0.03125L, 33, 44, 55);
974 ASSERT (strcmp (result, "-0.031250 33") == 0);
975 ASSERT (retval == strlen (result));
978 { /* Positive zero. */
981 my_sprintf (result, "%Lf %d", 0.0L, 33, 44, 55);
982 ASSERT (strcmp (result, "0.000000 33") == 0);
983 ASSERT (retval == strlen (result));
986 { /* Negative zero. */
989 my_sprintf (result, "%Lf %d", -0.0L, 33, 44, 55);
990 ASSERT (strcmp (result, "-0.000000 33") == 0);
991 ASSERT (retval == strlen (result));
994 { /* Positive infinity. */
997 my_sprintf (result, "%Lf %d", 1.0L / 0.0L, 33, 44, 55);
998 ASSERT (strcmp (result, "inf 33") == 0
999 || strcmp (result, "infinity 33") == 0);
1000 ASSERT (retval == strlen (result));
1003 { /* Negative infinity. */
1006 my_sprintf (result, "%Lf %d", -1.0L / 0.0L, 33, 44, 55);
1007 ASSERT (strcmp (result, "-inf 33") == 0
1008 || strcmp (result, "-infinity 33") == 0);
1009 ASSERT (retval == strlen (result));
1013 static long double zero = 0.0L;
1016 my_sprintf (result, "%Lf %d", zero / zero, 33, 44, 55);
1017 ASSERT (strlen (result) >= 3 + 3
1018 && memcmp (result, "nan", 3) == 0
1019 && strcmp (result + strlen (result) - 3, " 33") == 0);
1020 ASSERT (retval == strlen (result));
1026 my_sprintf (result, "%10Lf %d", 1.75L, 33, 44, 55);
1027 ASSERT (strcmp (result, " 1.750000 33") == 0);
1028 ASSERT (retval == strlen (result));
1034 my_sprintf (result, "%-10Lf %d", 1.75L, 33, 44, 55);
1035 ASSERT (strcmp (result, "1.750000 33") == 0);
1036 ASSERT (retval == strlen (result));
1039 { /* FLAG_SHOWSIGN. */
1042 my_sprintf (result, "%+Lf %d", 1.75L, 33, 44, 55);
1043 ASSERT (strcmp (result, "+1.750000 33") == 0);
1044 ASSERT (retval == strlen (result));
1050 my_sprintf (result, "% Lf %d", 1.75L, 33, 44, 55);
1051 ASSERT (strcmp (result, " 1.750000 33") == 0);
1052 ASSERT (retval == strlen (result));
1058 my_sprintf (result, "%#Lf %d", 1.75L, 33, 44, 55);
1059 ASSERT (strcmp (result, "1.750000 33") == 0);
1060 ASSERT (retval == strlen (result));
1066 my_sprintf (result, "%#.Lf %d", 1.75L, 33, 44, 55);
1067 ASSERT (strcmp (result, "2. 33") == 0);
1068 ASSERT (retval == strlen (result));
1071 { /* FLAG_ZERO with finite number. */
1074 my_sprintf (result, "%015Lf %d", 1234.0L, 33, 44, 55);
1075 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1076 ASSERT (retval == strlen (result));
1079 { /* FLAG_ZERO with infinite number. */
1082 my_sprintf (result, "%015Lf %d", -1.0L / 0.0L, 33, 44, 55);
1083 ASSERT (strcmp (result, " -inf 33") == 0
1084 || strcmp (result, " -infinity 33") == 0);
1085 ASSERT (retval == strlen (result));
1088 { /* FLAG_ZERO with NaN. */
1089 static long double zero = 0.0L;
1092 my_sprintf (result, "%020Lf %d", zero / zero, 33, 44, 55);
1093 ASSERT (strlen (result) == 20 + 3
1094 && memcmp (result + strspn (result, " "), "nan", 3) == 0
1095 && strcmp (result + strlen (result) - 3, " 33") == 0);
1096 ASSERT (retval == strlen (result));
1102 my_sprintf (result, "%.Lf %d", 1234.0L, 33, 44, 55);
1103 ASSERT (strcmp (result, "1234 33") == 0);
1104 ASSERT (retval == strlen (result));
1107 /* Test the support of the %F format directive. */
1109 { /* A positive number. */
1112 my_sprintf (result, "%F %d", 12.75, 33, 44, 55);
1113 ASSERT (strcmp (result, "12.750000 33") == 0);
1114 ASSERT (retval == strlen (result));
1117 { /* A larger positive number. */
1120 my_sprintf (result, "%F %d", 1234567.0, 33, 44, 55);
1121 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1122 ASSERT (retval == strlen (result));
1125 { /* A negative number. */
1128 my_sprintf (result, "%F %d", -0.03125, 33, 44, 55);
1129 ASSERT (strcmp (result, "-0.031250 33") == 0);
1130 ASSERT (retval == strlen (result));
1133 { /* Positive zero. */
1136 my_sprintf (result, "%F %d", 0.0, 33, 44, 55);
1137 ASSERT (strcmp (result, "0.000000 33") == 0);
1138 ASSERT (retval == strlen (result));
1141 { /* Negative zero. */
1144 my_sprintf (result, "%F %d", -0.0, 33, 44, 55);
1145 ASSERT (strcmp (result, "-0.000000 33") == 0);
1146 ASSERT (retval == strlen (result));
1149 { /* Positive infinity. */
1152 my_sprintf (result, "%F %d", 1.0 / 0.0, 33, 44, 55);
1153 ASSERT (strcmp (result, "INF 33") == 0
1154 || strcmp (result, "INFINITY 33") == 0);
1155 ASSERT (retval == strlen (result));
1158 { /* Negative infinity. */
1161 my_sprintf (result, "%F %d", -1.0 / 0.0, 33, 44, 55);
1162 ASSERT (strcmp (result, "-INF 33") == 0
1163 || strcmp (result, "-INFINITY 33") == 0);
1164 ASSERT (retval == strlen (result));
1170 my_sprintf (result, "%F %d", NaN (), 33, 44, 55);
1171 ASSERT (strlen (result) >= 3 + 3
1172 && memcmp (result, "NAN", 3) == 0
1173 && strcmp (result + strlen (result) - 3, " 33") == 0);
1174 ASSERT (retval == strlen (result));
1180 my_sprintf (result, "%015F %d", 1234.0, 33, 44, 55);
1181 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1182 ASSERT (retval == strlen (result));
1185 { /* FLAG_ZERO with infinite number. */
1188 my_sprintf (result, "%015F %d", -1.0 / 0.0, 33, 44, 55);
1189 ASSERT (strcmp (result, " -INF 33") == 0
1190 || strcmp (result, " -INFINITY 33") == 0);
1191 ASSERT (retval == strlen (result));
1197 my_sprintf (result, "%.F %d", 1234.0, 33, 44, 55);
1198 ASSERT (strcmp (result, "1234 33") == 0);
1199 ASSERT (retval == strlen (result));
1202 { /* A positive number. */
1205 my_sprintf (result, "%LF %d", 12.75L, 33, 44, 55);
1206 ASSERT (strcmp (result, "12.750000 33") == 0);
1207 ASSERT (retval == strlen (result));
1210 { /* A larger positive number. */
1213 my_sprintf (result, "%LF %d", 1234567.0L, 33, 44, 55);
1214 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1215 ASSERT (retval == strlen (result));
1218 { /* A negative number. */
1221 my_sprintf (result, "%LF %d", -0.03125L, 33, 44, 55);
1222 ASSERT (strcmp (result, "-0.031250 33") == 0);
1223 ASSERT (retval == strlen (result));
1226 { /* Positive zero. */
1229 my_sprintf (result, "%LF %d", 0.0L, 33, 44, 55);
1230 ASSERT (strcmp (result, "0.000000 33") == 0);
1231 ASSERT (retval == strlen (result));
1234 { /* Negative zero. */
1237 my_sprintf (result, "%LF %d", -0.0L, 33, 44, 55);
1238 ASSERT (strcmp (result, "-0.000000 33") == 0);
1239 ASSERT (retval == strlen (result));
1242 { /* Positive infinity. */
1245 my_sprintf (result, "%LF %d", 1.0L / 0.0L, 33, 44, 55);
1246 ASSERT (strcmp (result, "INF 33") == 0
1247 || strcmp (result, "INFINITY 33") == 0);
1248 ASSERT (retval == strlen (result));
1251 { /* Negative infinity. */
1254 my_sprintf (result, "%LF %d", -1.0L / 0.0L, 33, 44, 55);
1255 ASSERT (strcmp (result, "-INF 33") == 0
1256 || strcmp (result, "-INFINITY 33") == 0);
1257 ASSERT (retval == strlen (result));
1261 static long double zero = 0.0L;
1264 my_sprintf (result, "%LF %d", zero / zero, 33, 44, 55);
1265 ASSERT (strlen (result) >= 3 + 3
1266 && memcmp (result, "NAN", 3) == 0
1267 && strcmp (result + strlen (result) - 3, " 33") == 0);
1268 ASSERT (retval == strlen (result));
1274 my_sprintf (result, "%015LF %d", 1234.0L, 33, 44, 55);
1275 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1276 ASSERT (retval == strlen (result));
1279 { /* FLAG_ZERO with infinite number. */
1282 my_sprintf (result, "%015LF %d", -1.0L / 0.0L, 33, 44, 55);
1283 ASSERT (strcmp (result, " -INF 33") == 0
1284 || strcmp (result, " -INFINITY 33") == 0);
1285 ASSERT (retval == strlen (result));
1291 my_sprintf (result, "%.LF %d", 1234.0L, 33, 44, 55);
1292 ASSERT (strcmp (result, "1234 33") == 0);
1293 ASSERT (retval == strlen (result));
1296 /* Test the support of the %e format directive. */
1298 { /* A positive number. */
1301 my_sprintf (result, "%e %d", 12.75, 33, 44, 55);
1302 ASSERT (strcmp (result, "1.275000e+01 33") == 0
1303 || strcmp (result, "1.275000e+001 33") == 0);
1304 ASSERT (retval == strlen (result));
1307 { /* A larger positive number. */
1310 my_sprintf (result, "%e %d", 1234567.0, 33, 44, 55);
1311 ASSERT (strcmp (result, "1.234567e+06 33") == 0
1312 || strcmp (result, "1.234567e+006 33") == 0);
1313 ASSERT (retval == strlen (result));
1316 { /* Small and large positive numbers. */
1317 static struct { double value; const char *string; } data[] =
1319 { 1.234321234321234e-37, "1.234321e-37" },
1320 { 1.234321234321234e-36, "1.234321e-36" },
1321 { 1.234321234321234e-35, "1.234321e-35" },
1322 { 1.234321234321234e-34, "1.234321e-34" },
1323 { 1.234321234321234e-33, "1.234321e-33" },
1324 { 1.234321234321234e-32, "1.234321e-32" },
1325 { 1.234321234321234e-31, "1.234321e-31" },
1326 { 1.234321234321234e-30, "1.234321e-30" },
1327 { 1.234321234321234e-29, "1.234321e-29" },
1328 { 1.234321234321234e-28, "1.234321e-28" },
1329 { 1.234321234321234e-27, "1.234321e-27" },
1330 { 1.234321234321234e-26, "1.234321e-26" },
1331 { 1.234321234321234e-25, "1.234321e-25" },
1332 { 1.234321234321234e-24, "1.234321e-24" },
1333 { 1.234321234321234e-23, "1.234321e-23" },
1334 { 1.234321234321234e-22, "1.234321e-22" },
1335 { 1.234321234321234e-21, "1.234321e-21" },
1336 { 1.234321234321234e-20, "1.234321e-20" },
1337 { 1.234321234321234e-19, "1.234321e-19" },
1338 { 1.234321234321234e-18, "1.234321e-18" },
1339 { 1.234321234321234e-17, "1.234321e-17" },
1340 { 1.234321234321234e-16, "1.234321e-16" },
1341 { 1.234321234321234e-15, "1.234321e-15" },
1342 { 1.234321234321234e-14, "1.234321e-14" },
1343 { 1.234321234321234e-13, "1.234321e-13" },
1344 { 1.234321234321234e-12, "1.234321e-12" },
1345 { 1.234321234321234e-11, "1.234321e-11" },
1346 { 1.234321234321234e-10, "1.234321e-10" },
1347 { 1.234321234321234e-9, "1.234321e-09" },
1348 { 1.234321234321234e-8, "1.234321e-08" },
1349 { 1.234321234321234e-7, "1.234321e-07" },
1350 { 1.234321234321234e-6, "1.234321e-06" },
1351 { 1.234321234321234e-5, "1.234321e-05" },
1352 { 1.234321234321234e-4, "1.234321e-04" },
1353 { 1.234321234321234e-3, "1.234321e-03" },
1354 { 1.234321234321234e-2, "1.234321e-02" },
1355 { 1.234321234321234e-1, "1.234321e-01" },
1356 { 1.234321234321234, "1.234321e+00" },
1357 { 1.234321234321234e1, "1.234321e+01" },
1358 { 1.234321234321234e2, "1.234321e+02" },
1359 { 1.234321234321234e3, "1.234321e+03" },
1360 { 1.234321234321234e4, "1.234321e+04" },
1361 { 1.234321234321234e5, "1.234321e+05" },
1362 { 1.234321234321234e6, "1.234321e+06" },
1363 { 1.234321234321234e7, "1.234321e+07" },
1364 { 1.234321234321234e8, "1.234321e+08" },
1365 { 1.234321234321234e9, "1.234321e+09" },
1366 { 1.234321234321234e10, "1.234321e+10" },
1367 { 1.234321234321234e11, "1.234321e+11" },
1368 { 1.234321234321234e12, "1.234321e+12" },
1369 { 1.234321234321234e13, "1.234321e+13" },
1370 { 1.234321234321234e14, "1.234321e+14" },
1371 { 1.234321234321234e15, "1.234321e+15" },
1372 { 1.234321234321234e16, "1.234321e+16" },
1373 { 1.234321234321234e17, "1.234321e+17" },
1374 { 1.234321234321234e18, "1.234321e+18" },
1375 { 1.234321234321234e19, "1.234321e+19" },
1376 { 1.234321234321234e20, "1.234321e+20" },
1377 { 1.234321234321234e21, "1.234321e+21" },
1378 { 1.234321234321234e22, "1.234321e+22" },
1379 { 1.234321234321234e23, "1.234321e+23" },
1380 { 1.234321234321234e24, "1.234321e+24" },
1381 { 1.234321234321234e25, "1.234321e+25" },
1382 { 1.234321234321234e26, "1.234321e+26" },
1383 { 1.234321234321234e27, "1.234321e+27" },
1384 { 1.234321234321234e28, "1.234321e+28" },
1385 { 1.234321234321234e29, "1.234321e+29" },
1386 { 1.234321234321234e30, "1.234321e+30" },
1387 { 1.234321234321234e31, "1.234321e+31" },
1388 { 1.234321234321234e32, "1.234321e+32" },
1389 { 1.234321234321234e33, "1.234321e+33" },
1390 { 1.234321234321234e34, "1.234321e+34" },
1391 { 1.234321234321234e35, "1.234321e+35" },
1392 { 1.234321234321234e36, "1.234321e+36" }
1395 for (k = 0; k < SIZEOF (data); k++)
1399 my_sprintf (result, "%e", data[k].value);
1400 const char *expected = data[k].string;
1401 ASSERT (result != NULL);
1402 ASSERT (strcmp (result, expected) == 0
1403 /* Some implementations produce exponents with 3 digits. */
1404 || (strlen (result) == strlen (expected) + 1
1405 && memcmp (result, expected, strlen (expected) - 2) == 0
1406 && result[strlen (expected) - 2] == '0'
1407 && strcmp (result + strlen (expected) - 1,
1408 expected + strlen (expected) - 2)
1410 ASSERT (retval == strlen (result));
1414 { /* A negative number. */
1417 my_sprintf (result, "%e %d", -0.03125, 33, 44, 55);
1418 ASSERT (strcmp (result, "-3.125000e-02 33") == 0
1419 || strcmp (result, "-3.125000e-002 33") == 0);
1420 ASSERT (retval == strlen (result));
1423 { /* Positive zero. */
1426 my_sprintf (result, "%e %d", 0.0, 33, 44, 55);
1427 ASSERT (strcmp (result, "0.000000e+00 33") == 0
1428 || strcmp (result, "0.000000e+000 33") == 0);
1429 ASSERT (retval == strlen (result));
1432 { /* Negative zero. */
1435 my_sprintf (result, "%e %d", -0.0, 33, 44, 55);
1436 ASSERT (strcmp (result, "-0.000000e+00 33") == 0
1437 || strcmp (result, "-0.000000e+000 33") == 0);
1438 ASSERT (retval == strlen (result));
1441 { /* Positive infinity. */
1444 my_sprintf (result, "%e %d", 1.0 / 0.0, 33, 44, 55);
1445 ASSERT (strcmp (result, "inf 33") == 0
1446 || strcmp (result, "infinity 33") == 0);
1447 ASSERT (retval == strlen (result));
1450 { /* Negative infinity. */
1453 my_sprintf (result, "%e %d", -1.0 / 0.0, 33, 44, 55);
1454 ASSERT (strcmp (result, "-inf 33") == 0
1455 || strcmp (result, "-infinity 33") == 0);
1456 ASSERT (retval == strlen (result));
1462 my_sprintf (result, "%e %d", NaN (), 33, 44, 55);
1463 ASSERT (strlen (result) >= 3 + 3
1464 && memcmp (result, "nan", 3) == 0
1465 && strcmp (result + strlen (result) - 3, " 33") == 0);
1466 ASSERT (retval == strlen (result));
1472 my_sprintf (result, "%15e %d", 1.75, 33, 44, 55);
1473 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
1474 || strcmp (result, " 1.750000e+000 33") == 0);
1475 ASSERT (retval == strlen (result));
1481 my_sprintf (result, "%-15e %d", 1.75, 33, 44, 55);
1482 ASSERT (strcmp (result, "1.750000e+00 33") == 0
1483 || strcmp (result, "1.750000e+000 33") == 0);
1484 ASSERT (retval == strlen (result));
1487 { /* FLAG_SHOWSIGN. */
1490 my_sprintf (result, "%+e %d", 1.75, 33, 44, 55);
1491 ASSERT (strcmp (result, "+1.750000e+00 33") == 0
1492 || strcmp (result, "+1.750000e+000 33") == 0);
1493 ASSERT (retval == strlen (result));
1499 my_sprintf (result, "% e %d", 1.75, 33, 44, 55);
1500 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
1501 || strcmp (result, " 1.750000e+000 33") == 0);
1502 ASSERT (retval == strlen (result));
1508 my_sprintf (result, "%#e %d", 1.75, 33, 44, 55);
1509 ASSERT (strcmp (result, "1.750000e+00 33") == 0
1510 || strcmp (result, "1.750000e+000 33") == 0);
1511 ASSERT (retval == strlen (result));
1517 my_sprintf (result, "%#.e %d", 1.75, 33, 44, 55);
1518 ASSERT (strcmp (result, "2.e+00 33") == 0
1519 || strcmp (result, "2.e+000 33") == 0);
1520 ASSERT (retval == strlen (result));
1526 my_sprintf (result, "%#.e %d", 9.75, 33, 44, 55);
1527 ASSERT (strcmp (result, "1.e+01 33") == 0
1528 || strcmp (result, "1.e+001 33") == 0);
1529 ASSERT (retval == strlen (result));
1532 { /* FLAG_ZERO with finite number. */
1535 my_sprintf (result, "%015e %d", 1234.0, 33, 44, 55);
1536 ASSERT (strcmp (result, "0001.234000e+03 33") == 0
1537 || strcmp (result, "001.234000e+003 33") == 0);
1538 ASSERT (retval == strlen (result));
1541 { /* FLAG_ZERO with infinite number. */
1544 my_sprintf (result, "%015e %d", -1.0 / 0.0, 33, 44, 55);
1545 ASSERT (strcmp (result, " -inf 33") == 0
1546 || strcmp (result, " -infinity 33") == 0);
1547 ASSERT (retval == strlen (result));
1550 { /* FLAG_ZERO with NaN. */
1553 my_sprintf (result, "%020e %d", NaN (), 33, 44, 55);
1554 ASSERT (strlen (result) == 20 + 3
1555 && memcmp (result + strspn (result, " "), "nan", 3) == 0
1556 && strcmp (result + strlen (result) - 3, " 33") == 0);
1557 ASSERT (retval == strlen (result));
1563 my_sprintf (result, "%.e %d", 1234.0, 33, 44, 55);
1564 ASSERT (strcmp (result, "1e+03 33") == 0
1565 || strcmp (result, "1e+003 33") == 0);
1566 ASSERT (retval == strlen (result));
1569 { /* A positive number. */
1572 my_sprintf (result, "%Le %d", 12.75L, 33, 44, 55);
1573 ASSERT (strcmp (result, "1.275000e+01 33") == 0);
1574 ASSERT (retval == strlen (result));
1577 { /* A larger positive number. */
1580 my_sprintf (result, "%Le %d", 1234567.0L, 33, 44, 55);
1581 ASSERT (strcmp (result, "1.234567e+06 33") == 0);
1582 ASSERT (retval == strlen (result));
1585 { /* Small and large positive numbers. */
1586 static struct { long double value; const char *string; } data[] =
1588 { 1.234321234321234e-37L, "1.234321e-37" },
1589 { 1.234321234321234e-36L, "1.234321e-36" },
1590 { 1.234321234321234e-35L, "1.234321e-35" },
1591 { 1.234321234321234e-34L, "1.234321e-34" },
1592 { 1.234321234321234e-33L, "1.234321e-33" },
1593 { 1.234321234321234e-32L, "1.234321e-32" },
1594 { 1.234321234321234e-31L, "1.234321e-31" },
1595 { 1.234321234321234e-30L, "1.234321e-30" },
1596 { 1.234321234321234e-29L, "1.234321e-29" },
1597 { 1.234321234321234e-28L, "1.234321e-28" },
1598 { 1.234321234321234e-27L, "1.234321e-27" },
1599 { 1.234321234321234e-26L, "1.234321e-26" },
1600 { 1.234321234321234e-25L, "1.234321e-25" },
1601 { 1.234321234321234e-24L, "1.234321e-24" },
1602 { 1.234321234321234e-23L, "1.234321e-23" },
1603 { 1.234321234321234e-22L, "1.234321e-22" },
1604 { 1.234321234321234e-21L, "1.234321e-21" },
1605 { 1.234321234321234e-20L, "1.234321e-20" },
1606 { 1.234321234321234e-19L, "1.234321e-19" },
1607 { 1.234321234321234e-18L, "1.234321e-18" },
1608 { 1.234321234321234e-17L, "1.234321e-17" },
1609 { 1.234321234321234e-16L, "1.234321e-16" },
1610 { 1.234321234321234e-15L, "1.234321e-15" },
1611 { 1.234321234321234e-14L, "1.234321e-14" },
1612 { 1.234321234321234e-13L, "1.234321e-13" },
1613 { 1.234321234321234e-12L, "1.234321e-12" },
1614 { 1.234321234321234e-11L, "1.234321e-11" },
1615 { 1.234321234321234e-10L, "1.234321e-10" },
1616 { 1.234321234321234e-9L, "1.234321e-09" },
1617 { 1.234321234321234e-8L, "1.234321e-08" },
1618 { 1.234321234321234e-7L, "1.234321e-07" },
1619 { 1.234321234321234e-6L, "1.234321e-06" },
1620 { 1.234321234321234e-5L, "1.234321e-05" },
1621 { 1.234321234321234e-4L, "1.234321e-04" },
1622 { 1.234321234321234e-3L, "1.234321e-03" },
1623 { 1.234321234321234e-2L, "1.234321e-02" },
1624 { 1.234321234321234e-1L, "1.234321e-01" },
1625 { 1.234321234321234L, "1.234321e+00" },
1626 { 1.234321234321234e1L, "1.234321e+01" },
1627 { 1.234321234321234e2L, "1.234321e+02" },
1628 { 1.234321234321234e3L, "1.234321e+03" },
1629 { 1.234321234321234e4L, "1.234321e+04" },
1630 { 1.234321234321234e5L, "1.234321e+05" },
1631 { 1.234321234321234e6L, "1.234321e+06" },
1632 { 1.234321234321234e7L, "1.234321e+07" },
1633 { 1.234321234321234e8L, "1.234321e+08" },
1634 { 1.234321234321234e9L, "1.234321e+09" },
1635 { 1.234321234321234e10L, "1.234321e+10" },
1636 { 1.234321234321234e11L, "1.234321e+11" },
1637 { 1.234321234321234e12L, "1.234321e+12" },
1638 { 1.234321234321234e13L, "1.234321e+13" },
1639 { 1.234321234321234e14L, "1.234321e+14" },
1640 { 1.234321234321234e15L, "1.234321e+15" },
1641 { 1.234321234321234e16L, "1.234321e+16" },
1642 { 1.234321234321234e17L, "1.234321e+17" },
1643 { 1.234321234321234e18L, "1.234321e+18" },
1644 { 1.234321234321234e19L, "1.234321e+19" },
1645 { 1.234321234321234e20L, "1.234321e+20" },
1646 { 1.234321234321234e21L, "1.234321e+21" },
1647 { 1.234321234321234e22L, "1.234321e+22" },
1648 { 1.234321234321234e23L, "1.234321e+23" },
1649 { 1.234321234321234e24L, "1.234321e+24" },
1650 { 1.234321234321234e25L, "1.234321e+25" },
1651 { 1.234321234321234e26L, "1.234321e+26" },
1652 { 1.234321234321234e27L, "1.234321e+27" },
1653 { 1.234321234321234e28L, "1.234321e+28" },
1654 { 1.234321234321234e29L, "1.234321e+29" },
1655 { 1.234321234321234e30L, "1.234321e+30" },
1656 { 1.234321234321234e31L, "1.234321e+31" },
1657 { 1.234321234321234e32L, "1.234321e+32" },
1658 { 1.234321234321234e33L, "1.234321e+33" },
1659 { 1.234321234321234e34L, "1.234321e+34" },
1660 { 1.234321234321234e35L, "1.234321e+35" },
1661 { 1.234321234321234e36L, "1.234321e+36" }
1664 for (k = 0; k < SIZEOF (data); k++)
1668 my_sprintf (result, "%Le", data[k].value);
1669 ASSERT (strcmp (result, data[k].string) == 0);
1670 ASSERT (retval == strlen (result));
1674 { /* A negative number. */
1677 my_sprintf (result, "%Le %d", -0.03125L, 33, 44, 55);
1678 ASSERT (strcmp (result, "-3.125000e-02 33") == 0);
1679 ASSERT (retval == strlen (result));
1682 { /* Positive zero. */
1685 my_sprintf (result, "%Le %d", 0.0L, 33, 44, 55);
1686 ASSERT (strcmp (result, "0.000000e+00 33") == 0);
1687 ASSERT (retval == strlen (result));
1690 { /* Negative zero. */
1693 my_sprintf (result, "%Le %d", -0.0L, 33, 44, 55);
1694 ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
1695 ASSERT (retval == strlen (result));
1698 { /* Positive infinity. */
1701 my_sprintf (result, "%Le %d", 1.0L / 0.0L, 33, 44, 55);
1702 ASSERT (strcmp (result, "inf 33") == 0
1703 || strcmp (result, "infinity 33") == 0);
1704 ASSERT (retval == strlen (result));
1707 { /* Negative infinity. */
1710 my_sprintf (result, "%Le %d", -1.0L / 0.0L, 33, 44, 55);
1711 ASSERT (strcmp (result, "-inf 33") == 0
1712 || strcmp (result, "-infinity 33") == 0);
1713 ASSERT (retval == strlen (result));
1717 static long double zero = 0.0L;
1720 my_sprintf (result, "%Le %d", zero / zero, 33, 44, 55);
1721 ASSERT (strlen (result) >= 3 + 3
1722 && memcmp (result, "nan", 3) == 0
1723 && strcmp (result + strlen (result) - 3, " 33") == 0);
1724 ASSERT (retval == strlen (result));
1730 my_sprintf (result, "%15Le %d", 1.75L, 33, 44, 55);
1731 ASSERT (strcmp (result, " 1.750000e+00 33") == 0);
1732 ASSERT (retval == strlen (result));
1738 my_sprintf (result, "%-15Le %d", 1.75L, 33, 44, 55);
1739 ASSERT (strcmp (result, "1.750000e+00 33") == 0);
1740 ASSERT (retval == strlen (result));
1743 { /* FLAG_SHOWSIGN. */
1746 my_sprintf (result, "%+Le %d", 1.75L, 33, 44, 55);
1747 ASSERT (strcmp (result, "+1.750000e+00 33") == 0);
1748 ASSERT (retval == strlen (result));
1754 my_sprintf (result, "% Le %d", 1.75L, 33, 44, 55);
1755 ASSERT (strcmp (result, " 1.750000e+00 33") == 0);
1756 ASSERT (retval == strlen (result));
1762 my_sprintf (result, "%#Le %d", 1.75L, 33, 44, 55);
1763 ASSERT (strcmp (result, "1.750000e+00 33") == 0);
1764 ASSERT (retval == strlen (result));
1770 my_sprintf (result, "%#.Le %d", 1.75L, 33, 44, 55);
1771 ASSERT (strcmp (result, "2.e+00 33") == 0);
1772 ASSERT (retval == strlen (result));
1778 my_sprintf (result, "%#.Le %d", 9.75L, 33, 44, 55);
1779 ASSERT (strcmp (result, "1.e+01 33") == 0);
1780 ASSERT (retval == strlen (result));
1783 { /* FLAG_ZERO with finite number. */
1786 my_sprintf (result, "%015Le %d", 1234.0L, 33, 44, 55);
1787 ASSERT (strcmp (result, "0001.234000e+03 33") == 0);
1788 ASSERT (retval == strlen (result));
1791 { /* FLAG_ZERO with infinite number. */
1794 my_sprintf (result, "%015Le %d", -1.0L / 0.0L, 33, 44, 55);
1795 ASSERT (strcmp (result, " -inf 33") == 0
1796 || strcmp (result, " -infinity 33") == 0);
1797 ASSERT (retval == strlen (result));
1800 { /* FLAG_ZERO with NaN. */
1801 static long double zero = 0.0L;
1804 my_sprintf (result, "%020Le %d", zero / zero, 33, 44, 55);
1805 ASSERT (strlen (result) == 20 + 3
1806 && memcmp (result + strspn (result, " "), "nan", 3) == 0
1807 && strcmp (result + strlen (result) - 3, " 33") == 0);
1808 ASSERT (retval == strlen (result));
1814 my_sprintf (result, "%.Le %d", 1234.0L, 33, 44, 55);
1815 ASSERT (strcmp (result, "1e+03 33") == 0);
1816 ASSERT (retval == strlen (result));
1819 /* Test the support of the %g format directive. */
1821 { /* A positive number. */
1824 my_sprintf (result, "%g %d", 12.75, 33, 44, 55);
1825 ASSERT (strcmp (result, "12.75 33") == 0);
1826 ASSERT (retval == strlen (result));
1829 { /* A larger positive number. */
1832 my_sprintf (result, "%g %d", 1234567.0, 33, 44, 55);
1833 ASSERT (strcmp (result, "1.23457e+06 33") == 0
1834 || strcmp (result, "1.23457e+006 33") == 0);
1835 ASSERT (retval == strlen (result));
1838 { /* Small and large positive numbers. */
1839 static struct { double value; const char *string; } data[] =
1841 { 1.234321234321234e-37, "1.23432e-37" },
1842 { 1.234321234321234e-36, "1.23432e-36" },
1843 { 1.234321234321234e-35, "1.23432e-35" },
1844 { 1.234321234321234e-34, "1.23432e-34" },
1845 { 1.234321234321234e-33, "1.23432e-33" },
1846 { 1.234321234321234e-32, "1.23432e-32" },
1847 { 1.234321234321234e-31, "1.23432e-31" },
1848 { 1.234321234321234e-30, "1.23432e-30" },
1849 { 1.234321234321234e-29, "1.23432e-29" },
1850 { 1.234321234321234e-28, "1.23432e-28" },
1851 { 1.234321234321234e-27, "1.23432e-27" },
1852 { 1.234321234321234e-26, "1.23432e-26" },
1853 { 1.234321234321234e-25, "1.23432e-25" },
1854 { 1.234321234321234e-24, "1.23432e-24" },
1855 { 1.234321234321234e-23, "1.23432e-23" },
1856 { 1.234321234321234e-22, "1.23432e-22" },
1857 { 1.234321234321234e-21, "1.23432e-21" },
1858 { 1.234321234321234e-20, "1.23432e-20" },
1859 { 1.234321234321234e-19, "1.23432e-19" },
1860 { 1.234321234321234e-18, "1.23432e-18" },
1861 { 1.234321234321234e-17, "1.23432e-17" },
1862 { 1.234321234321234e-16, "1.23432e-16" },
1863 { 1.234321234321234e-15, "1.23432e-15" },
1864 { 1.234321234321234e-14, "1.23432e-14" },
1865 { 1.234321234321234e-13, "1.23432e-13" },
1866 { 1.234321234321234e-12, "1.23432e-12" },
1867 { 1.234321234321234e-11, "1.23432e-11" },
1868 { 1.234321234321234e-10, "1.23432e-10" },
1869 { 1.234321234321234e-9, "1.23432e-09" },
1870 { 1.234321234321234e-8, "1.23432e-08" },
1871 { 1.234321234321234e-7, "1.23432e-07" },
1872 { 1.234321234321234e-6, "1.23432e-06" },
1873 { 1.234321234321234e-5, "1.23432e-05" },
1874 { 1.234321234321234e-4, "0.000123432" },
1875 { 1.234321234321234e-3, "0.00123432" },
1876 { 1.234321234321234e-2, "0.0123432" },
1877 { 1.234321234321234e-1, "0.123432" },
1878 { 1.234321234321234, "1.23432" },
1879 { 1.234321234321234e1, "12.3432" },
1880 { 1.234321234321234e2, "123.432" },
1881 { 1.234321234321234e3, "1234.32" },
1882 { 1.234321234321234e4, "12343.2" },
1883 { 1.234321234321234e5, "123432" },
1884 { 1.234321234321234e6, "1.23432e+06" },
1885 { 1.234321234321234e7, "1.23432e+07" },
1886 { 1.234321234321234e8, "1.23432e+08" },
1887 { 1.234321234321234e9, "1.23432e+09" },
1888 { 1.234321234321234e10, "1.23432e+10" },
1889 { 1.234321234321234e11, "1.23432e+11" },
1890 { 1.234321234321234e12, "1.23432e+12" },
1891 { 1.234321234321234e13, "1.23432e+13" },
1892 { 1.234321234321234e14, "1.23432e+14" },
1893 { 1.234321234321234e15, "1.23432e+15" },
1894 { 1.234321234321234e16, "1.23432e+16" },
1895 { 1.234321234321234e17, "1.23432e+17" },
1896 { 1.234321234321234e18, "1.23432e+18" },
1897 { 1.234321234321234e19, "1.23432e+19" },
1898 { 1.234321234321234e20, "1.23432e+20" },
1899 { 1.234321234321234e21, "1.23432e+21" },
1900 { 1.234321234321234e22, "1.23432e+22" },
1901 { 1.234321234321234e23, "1.23432e+23" },
1902 { 1.234321234321234e24, "1.23432e+24" },
1903 { 1.234321234321234e25, "1.23432e+25" },
1904 { 1.234321234321234e26, "1.23432e+26" },
1905 { 1.234321234321234e27, "1.23432e+27" },
1906 { 1.234321234321234e28, "1.23432e+28" },
1907 { 1.234321234321234e29, "1.23432e+29" },
1908 { 1.234321234321234e30, "1.23432e+30" },
1909 { 1.234321234321234e31, "1.23432e+31" },
1910 { 1.234321234321234e32, "1.23432e+32" },
1911 { 1.234321234321234e33, "1.23432e+33" },
1912 { 1.234321234321234e34, "1.23432e+34" },
1913 { 1.234321234321234e35, "1.23432e+35" },
1914 { 1.234321234321234e36, "1.23432e+36" }
1917 for (k = 0; k < SIZEOF (data); k++)
1921 my_sprintf (result, "%g", data[k].value);
1922 const char *expected = data[k].string;
1923 ASSERT (strcmp (result, expected) == 0
1924 /* Some implementations produce exponents with 3 digits. */
1925 || (expected[strlen (expected) - 4] == 'e'
1926 && strlen (result) == strlen (expected) + 1
1927 && memcmp (result, expected, strlen (expected) - 2) == 0
1928 && result[strlen (expected) - 2] == '0'
1929 && strcmp (result + strlen (expected) - 1,
1930 expected + strlen (expected) - 2)
1932 ASSERT (retval == strlen (result));
1936 { /* A negative number. */
1939 my_sprintf (result, "%g %d", -0.03125, 33, 44, 55);
1940 ASSERT (strcmp (result, "-0.03125 33") == 0);
1941 ASSERT (retval == strlen (result));
1944 { /* Positive zero. */
1947 my_sprintf (result, "%g %d", 0.0, 33, 44, 55);
1948 ASSERT (strcmp (result, "0 33") == 0);
1949 ASSERT (retval == strlen (result));
1952 { /* Negative zero. */
1955 my_sprintf (result, "%g %d", -0.0, 33, 44, 55);
1956 ASSERT (strcmp (result, "-0 33") == 0);
1957 ASSERT (retval == strlen (result));
1960 { /* Positive infinity. */
1963 my_sprintf (result, "%g %d", 1.0 / 0.0, 33, 44, 55);
1964 ASSERT (strcmp (result, "inf 33") == 0
1965 || strcmp (result, "infinity 33") == 0);
1966 ASSERT (retval == strlen (result));
1969 { /* Negative infinity. */
1972 my_sprintf (result, "%g %d", -1.0 / 0.0, 33, 44, 55);
1973 ASSERT (strcmp (result, "-inf 33") == 0
1974 || strcmp (result, "-infinity 33") == 0);
1975 ASSERT (retval == strlen (result));
1981 my_sprintf (result, "%g %d", NaN (), 33, 44, 55);
1982 ASSERT (strlen (result) >= 3 + 3
1983 && memcmp (result, "nan", 3) == 0
1984 && strcmp (result + strlen (result) - 3, " 33") == 0);
1985 ASSERT (retval == strlen (result));
1991 my_sprintf (result, "%10g %d", 1.75, 33, 44, 55);
1992 ASSERT (strcmp (result, " 1.75 33") == 0);
1993 ASSERT (retval == strlen (result));
1999 my_sprintf (result, "%-10g %d", 1.75, 33, 44, 55);
2000 ASSERT (strcmp (result, "1.75 33") == 0);
2001 ASSERT (retval == strlen (result));
2004 { /* FLAG_SHOWSIGN. */
2007 my_sprintf (result, "%+g %d", 1.75, 33, 44, 55);
2008 ASSERT (strcmp (result, "+1.75 33") == 0);
2009 ASSERT (retval == strlen (result));
2015 my_sprintf (result, "% g %d", 1.75, 33, 44, 55);
2016 ASSERT (strcmp (result, " 1.75 33") == 0);
2017 ASSERT (retval == strlen (result));
2023 my_sprintf (result, "%#g %d", 1.75, 33, 44, 55);
2024 ASSERT (strcmp (result, "1.75000 33") == 0);
2025 ASSERT (retval == strlen (result));
2031 my_sprintf (result, "%#.g %d", 1.75, 33, 44, 55);
2032 ASSERT (strcmp (result, "2. 33") == 0);
2033 ASSERT (retval == strlen (result));
2039 my_sprintf (result, "%#.g %d", 9.75, 33, 44, 55);
2040 ASSERT (strcmp (result, "1.e+01 33") == 0
2041 || strcmp (result, "1.e+001 33") == 0);
2042 ASSERT (retval == strlen (result));
2045 { /* FLAG_ZERO with finite number. */
2048 my_sprintf (result, "%010g %d", 1234.0, 33, 44, 55);
2049 ASSERT (strcmp (result, "0000001234 33") == 0);
2050 ASSERT (retval == strlen (result));
2053 { /* FLAG_ZERO with infinite number. */
2056 my_sprintf (result, "%015g %d", -1.0 / 0.0, 33, 44, 55);
2057 ASSERT (strcmp (result, " -inf 33") == 0
2058 || strcmp (result, " -infinity 33") == 0);
2059 ASSERT (retval == strlen (result));
2062 { /* FLAG_ZERO with NaN. */
2065 my_sprintf (result, "%020g %d", NaN (), 33, 44, 55);
2066 ASSERT (strlen (result) == 20 + 3
2067 && memcmp (result + strspn (result, " "), "nan", 3) == 0
2068 && strcmp (result + strlen (result) - 3, " 33") == 0);
2069 ASSERT (retval == strlen (result));
2075 my_sprintf (result, "%.g %d", 1234.0, 33, 44, 55);
2076 ASSERT (strcmp (result, "1e+03 33") == 0
2077 || strcmp (result, "1e+003 33") == 0);
2078 ASSERT (retval == strlen (result));
2081 { /* A positive number. */
2084 my_sprintf (result, "%Lg %d", 12.75L, 33, 44, 55);
2085 ASSERT (strcmp (result, "12.75 33") == 0);
2086 ASSERT (retval == strlen (result));
2089 { /* A larger positive number. */
2092 my_sprintf (result, "%Lg %d", 1234567.0L, 33, 44, 55);
2093 ASSERT (strcmp (result, "1.23457e+06 33") == 0);
2094 ASSERT (retval == strlen (result));
2097 { /* Small and large positive numbers. */
2098 static struct { long double value; const char *string; } data[] =
2100 { 1.234321234321234e-37L, "1.23432e-37" },
2101 { 1.234321234321234e-36L, "1.23432e-36" },
2102 { 1.234321234321234e-35L, "1.23432e-35" },
2103 { 1.234321234321234e-34L, "1.23432e-34" },
2104 { 1.234321234321234e-33L, "1.23432e-33" },
2105 { 1.234321234321234e-32L, "1.23432e-32" },
2106 { 1.234321234321234e-31L, "1.23432e-31" },
2107 { 1.234321234321234e-30L, "1.23432e-30" },
2108 { 1.234321234321234e-29L, "1.23432e-29" },
2109 { 1.234321234321234e-28L, "1.23432e-28" },
2110 { 1.234321234321234e-27L, "1.23432e-27" },
2111 { 1.234321234321234e-26L, "1.23432e-26" },
2112 { 1.234321234321234e-25L, "1.23432e-25" },
2113 { 1.234321234321234e-24L, "1.23432e-24" },
2114 { 1.234321234321234e-23L, "1.23432e-23" },
2115 { 1.234321234321234e-22L, "1.23432e-22" },
2116 { 1.234321234321234e-21L, "1.23432e-21" },
2117 { 1.234321234321234e-20L, "1.23432e-20" },
2118 { 1.234321234321234e-19L, "1.23432e-19" },
2119 { 1.234321234321234e-18L, "1.23432e-18" },
2120 { 1.234321234321234e-17L, "1.23432e-17" },
2121 { 1.234321234321234e-16L, "1.23432e-16" },
2122 { 1.234321234321234e-15L, "1.23432e-15" },
2123 { 1.234321234321234e-14L, "1.23432e-14" },
2124 { 1.234321234321234e-13L, "1.23432e-13" },
2125 { 1.234321234321234e-12L, "1.23432e-12" },
2126 { 1.234321234321234e-11L, "1.23432e-11" },
2127 { 1.234321234321234e-10L, "1.23432e-10" },
2128 { 1.234321234321234e-9L, "1.23432e-09" },
2129 { 1.234321234321234e-8L, "1.23432e-08" },
2130 { 1.234321234321234e-7L, "1.23432e-07" },
2131 { 1.234321234321234e-6L, "1.23432e-06" },
2132 { 1.234321234321234e-5L, "1.23432e-05" },
2133 { 1.234321234321234e-4L, "0.000123432" },
2134 { 1.234321234321234e-3L, "0.00123432" },
2135 { 1.234321234321234e-2L, "0.0123432" },
2136 { 1.234321234321234e-1L, "0.123432" },
2137 { 1.234321234321234L, "1.23432" },
2138 { 1.234321234321234e1L, "12.3432" },
2139 { 1.234321234321234e2L, "123.432" },
2140 { 1.234321234321234e3L, "1234.32" },
2141 { 1.234321234321234e4L, "12343.2" },
2142 { 1.234321234321234e5L, "123432" },
2143 { 1.234321234321234e6L, "1.23432e+06" },
2144 { 1.234321234321234e7L, "1.23432e+07" },
2145 { 1.234321234321234e8L, "1.23432e+08" },
2146 { 1.234321234321234e9L, "1.23432e+09" },
2147 { 1.234321234321234e10L, "1.23432e+10" },
2148 { 1.234321234321234e11L, "1.23432e+11" },
2149 { 1.234321234321234e12L, "1.23432e+12" },
2150 { 1.234321234321234e13L, "1.23432e+13" },
2151 { 1.234321234321234e14L, "1.23432e+14" },
2152 { 1.234321234321234e15L, "1.23432e+15" },
2153 { 1.234321234321234e16L, "1.23432e+16" },
2154 { 1.234321234321234e17L, "1.23432e+17" },
2155 { 1.234321234321234e18L, "1.23432e+18" },
2156 { 1.234321234321234e19L, "1.23432e+19" },
2157 { 1.234321234321234e20L, "1.23432e+20" },
2158 { 1.234321234321234e21L, "1.23432e+21" },
2159 { 1.234321234321234e22L, "1.23432e+22" },
2160 { 1.234321234321234e23L, "1.23432e+23" },
2161 { 1.234321234321234e24L, "1.23432e+24" },
2162 { 1.234321234321234e25L, "1.23432e+25" },
2163 { 1.234321234321234e26L, "1.23432e+26" },
2164 { 1.234321234321234e27L, "1.23432e+27" },
2165 { 1.234321234321234e28L, "1.23432e+28" },
2166 { 1.234321234321234e29L, "1.23432e+29" },
2167 { 1.234321234321234e30L, "1.23432e+30" },
2168 { 1.234321234321234e31L, "1.23432e+31" },
2169 { 1.234321234321234e32L, "1.23432e+32" },
2170 { 1.234321234321234e33L, "1.23432e+33" },
2171 { 1.234321234321234e34L, "1.23432e+34" },
2172 { 1.234321234321234e35L, "1.23432e+35" },
2173 { 1.234321234321234e36L, "1.23432e+36" }
2176 for (k = 0; k < SIZEOF (data); k++)
2180 my_sprintf (result, "%Lg", data[k].value);
2181 ASSERT (strcmp (result, data[k].string) == 0);
2182 ASSERT (retval == strlen (result));
2186 { /* A negative number. */
2189 my_sprintf (result, "%Lg %d", -0.03125L, 33, 44, 55);
2190 ASSERT (strcmp (result, "-0.03125 33") == 0);
2191 ASSERT (retval == strlen (result));
2194 { /* Positive zero. */
2197 my_sprintf (result, "%Lg %d", 0.0L, 33, 44, 55);
2198 ASSERT (strcmp (result, "0 33") == 0);
2199 ASSERT (retval == strlen (result));
2202 { /* Negative zero. */
2205 my_sprintf (result, "%Lg %d", -0.0L, 33, 44, 55);
2206 ASSERT (strcmp (result, "-0 33") == 0);
2207 ASSERT (retval == strlen (result));
2210 { /* Positive infinity. */
2213 my_sprintf (result, "%Lg %d", 1.0L / 0.0L, 33, 44, 55);
2214 ASSERT (strcmp (result, "inf 33") == 0
2215 || strcmp (result, "infinity 33") == 0);
2216 ASSERT (retval == strlen (result));
2219 { /* Negative infinity. */
2222 my_sprintf (result, "%Lg %d", -1.0L / 0.0L, 33, 44, 55);
2223 ASSERT (strcmp (result, "-inf 33") == 0
2224 || strcmp (result, "-infinity 33") == 0);
2225 ASSERT (retval == strlen (result));
2229 static long double zero = 0.0L;
2232 my_sprintf (result, "%Lg %d", zero / zero, 33, 44, 55);
2233 ASSERT (strlen (result) >= 3 + 3
2234 && memcmp (result, "nan", 3) == 0
2235 && strcmp (result + strlen (result) - 3, " 33") == 0);
2236 ASSERT (retval == strlen (result));
2242 my_sprintf (result, "%10Lg %d", 1.75L, 33, 44, 55);
2243 ASSERT (strcmp (result, " 1.75 33") == 0);
2244 ASSERT (retval == strlen (result));
2250 my_sprintf (result, "%-10Lg %d", 1.75L, 33, 44, 55);
2251 ASSERT (strcmp (result, "1.75 33") == 0);
2252 ASSERT (retval == strlen (result));
2255 { /* FLAG_SHOWSIGN. */
2258 my_sprintf (result, "%+Lg %d", 1.75L, 33, 44, 55);
2259 ASSERT (strcmp (result, "+1.75 33") == 0);
2260 ASSERT (retval == strlen (result));
2266 my_sprintf (result, "% Lg %d", 1.75L, 33, 44, 55);
2267 ASSERT (strcmp (result, " 1.75 33") == 0);
2268 ASSERT (retval == strlen (result));
2274 my_sprintf (result, "%#Lg %d", 1.75L, 33, 44, 55);
2275 ASSERT (strcmp (result, "1.75000 33") == 0);
2276 ASSERT (retval == strlen (result));
2282 my_sprintf (result, "%#.Lg %d", 1.75L, 33, 44, 55);
2283 ASSERT (strcmp (result, "2. 33") == 0);
2284 ASSERT (retval == strlen (result));
2290 my_sprintf (result, "%#.Lg %d", 9.75L, 33, 44, 55);
2291 ASSERT (strcmp (result, "1.e+01 33") == 0);
2292 ASSERT (retval == strlen (result));
2295 { /* FLAG_ZERO with finite number. */
2298 my_sprintf (result, "%010Lg %d", 1234.0L, 33, 44, 55);
2299 ASSERT (strcmp (result, "0000001234 33") == 0);
2300 ASSERT (retval == strlen (result));
2303 { /* FLAG_ZERO with infinite number. */
2306 my_sprintf (result, "%015Lg %d", -1.0L / 0.0L, 33, 44, 55);
2307 ASSERT (strcmp (result, " -inf 33") == 0
2308 || strcmp (result, " -infinity 33") == 0);
2309 ASSERT (retval == strlen (result));
2312 { /* FLAG_ZERO with NaN. */
2313 static long double zero = 0.0L;
2316 my_sprintf (result, "%020Lg %d", zero / zero, 33, 44, 55);
2317 ASSERT (strlen (result) == 20 + 3
2318 && memcmp (result + strspn (result, " "), "nan", 3) == 0
2319 && strcmp (result + strlen (result) - 3, " 33") == 0);
2320 ASSERT (retval == strlen (result));
2326 my_sprintf (result, "%.Lg %d", 1234.0L, 33, 44, 55);
2327 ASSERT (strcmp (result, "1e+03 33") == 0);
2328 ASSERT (retval == strlen (result));
2331 /* Test the support of the %n format directive. */
2337 my_sprintf (result, "%d %n", 123, &count, 33, 44, 55);
2338 ASSERT (strcmp (result, "123 ") == 0);
2339 ASSERT (retval == strlen (result));
2340 ASSERT (count == 4);
2343 /* Test the support of the POSIX/XSI format strings with positions. */
2348 my_sprintf (result, "%2$d %1$d", 33, 55);
2349 ASSERT (strcmp (result, "55 33") == 0);
2350 ASSERT (retval == strlen (result));
2353 /* Test the support of the grouping flag. */
2358 my_sprintf (result, "%'d %d", 1234567, 99);
2359 ASSERT (result[strlen (result) - 1] == '9');
2360 ASSERT (retval == strlen (result));