1 /* Test of POSIX compatible vsnprintf() and snprintf() 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_snprintf) (char *, size_t, const char *, ...))
79 /* Test return value convention. */
81 for (size = 0; size <= 8; size++)
85 memcpy (buf, "DEADBEEF", 8);
86 retval = my_snprintf (buf, size, "%d", 12345);
92 ASSERT (memcmp (buf, "12345", size - 1) == 0);
93 ASSERT (buf[size - 1] == '\0');
95 ASSERT (memcmp (buf + size, "DEADBEEF" + size, 8 - size) == 0);
99 ASSERT (memcmp (buf, "12345\0EF", 8) == 0);
103 /* Test support of size specifiers as in C99. */
108 my_snprintf (result, sizeof (result), "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
109 ASSERT (strcmp (result, "12345671 33") == 0);
110 ASSERT (retval == strlen (result));
116 my_snprintf (result, sizeof (result), "%zu %d", (size_t) 12345672, 33, 44, 55);
117 ASSERT (strcmp (result, "12345672 33") == 0);
118 ASSERT (retval == strlen (result));
124 my_snprintf (result, sizeof (result), "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
125 ASSERT (strcmp (result, "12345673 33") == 0);
126 ASSERT (retval == strlen (result));
132 my_snprintf (result, sizeof (result), "%Lg %d", (long double) 1.5, 33, 44, 55);
133 ASSERT (strcmp (result, "1.5 33") == 0);
134 ASSERT (retval == strlen (result));
137 /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
138 output of floating-point numbers. */
140 { /* A positive number. */
143 my_snprintf (result, sizeof (result), "%a %d", 3.1416015625, 33, 44, 55);
144 ASSERT (strcmp (result, "0x1.922p+1 33") == 0
145 || strcmp (result, "0x3.244p+0 33") == 0
146 || strcmp (result, "0x6.488p-1 33") == 0
147 || strcmp (result, "0xc.91p-2 33") == 0);
148 ASSERT (retval == strlen (result));
151 { /* A negative number. */
154 my_snprintf (result, sizeof (result), "%A %d", -3.1416015625, 33, 44, 55);
155 ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
156 || strcmp (result, "-0X3.244P+0 33") == 0
157 || strcmp (result, "-0X6.488P-1 33") == 0
158 || strcmp (result, "-0XC.91P-2 33") == 0);
159 ASSERT (retval == strlen (result));
162 { /* Positive zero. */
165 my_snprintf (result, sizeof (result), "%a %d", 0.0, 33, 44, 55);
166 ASSERT (strcmp (result, "0x0p+0 33") == 0);
167 ASSERT (retval == strlen (result));
170 { /* Negative zero. */
173 my_snprintf (result, sizeof (result), "%a %d", -0.0, 33, 44, 55);
174 if (have_minus_zero ())
175 ASSERT (strcmp (result, "-0x0p+0 33") == 0);
176 ASSERT (retval == strlen (result));
179 { /* Positive infinity. */
182 my_snprintf (result, sizeof (result), "%a %d", 1.0 / 0.0, 33, 44, 55);
183 ASSERT (strcmp (result, "inf 33") == 0);
184 ASSERT (retval == strlen (result));
187 { /* Negative infinity. */
190 my_snprintf (result, sizeof (result), "%a %d", -1.0 / 0.0, 33, 44, 55);
191 ASSERT (strcmp (result, "-inf 33") == 0);
192 ASSERT (retval == strlen (result));
198 my_snprintf (result, sizeof (result), "%a %d", NaN (), 33, 44, 55);
199 ASSERT (strlen (result) >= 3 + 3
200 && strisnan (result, 0, strlen (result) - 3, 0)
201 && strcmp (result + strlen (result) - 3, " 33") == 0);
202 ASSERT (retval == strlen (result));
205 { /* Rounding near the decimal point. */
208 my_snprintf (result, sizeof (result), "%.0a %d", 1.5, 33, 44, 55);
209 ASSERT (strcmp (result, "0x2p+0 33") == 0
210 || strcmp (result, "0x3p-1 33") == 0
211 || strcmp (result, "0x6p-2 33") == 0
212 || strcmp (result, "0xcp-3 33") == 0);
213 ASSERT (retval == strlen (result));
216 { /* Rounding with precision 0. */
219 my_snprintf (result, sizeof (result), "%.0a %d", 1.51, 33, 44, 55);
220 ASSERT (strcmp (result, "0x2p+0 33") == 0
221 || strcmp (result, "0x3p-1 33") == 0
222 || strcmp (result, "0x6p-2 33") == 0
223 || strcmp (result, "0xcp-3 33") == 0);
224 ASSERT (retval == strlen (result));
227 { /* Rounding with precision 1. */
230 my_snprintf (result, sizeof (result), "%.1a %d", 1.51, 33, 44, 55);
231 ASSERT (strcmp (result, "0x1.8p+0 33") == 0
232 || strcmp (result, "0x3.0p-1 33") == 0
233 || strcmp (result, "0x6.1p-2 33") == 0
234 || strcmp (result, "0xc.1p-3 33") == 0);
235 ASSERT (retval == strlen (result));
238 { /* Rounding with precision 2. */
241 my_snprintf (result, sizeof (result), "%.2a %d", 1.51, 33, 44, 55);
242 ASSERT (strcmp (result, "0x1.83p+0 33") == 0
243 || strcmp (result, "0x3.05p-1 33") == 0
244 || strcmp (result, "0x6.0ap-2 33") == 0
245 || strcmp (result, "0xc.14p-3 33") == 0);
246 ASSERT (retval == strlen (result));
249 { /* Rounding with precision 3. */
252 my_snprintf (result, sizeof (result), "%.3a %d", 1.51, 33, 44, 55);
253 ASSERT (strcmp (result, "0x1.829p+0 33") == 0
254 || strcmp (result, "0x3.052p-1 33") == 0
255 || strcmp (result, "0x6.0a4p-2 33") == 0
256 || strcmp (result, "0xc.148p-3 33") == 0);
257 ASSERT (retval == strlen (result));
260 { /* Rounding can turn a ...FFF into a ...000. */
263 my_snprintf (result, sizeof (result), "%.3a %d", 1.49999, 33, 44, 55);
264 ASSERT (strcmp (result, "0x1.800p+0 33") == 0
265 || strcmp (result, "0x3.000p-1 33") == 0
266 || strcmp (result, "0x6.000p-2 33") == 0
267 || strcmp (result, "0xc.000p-3 33") == 0);
268 ASSERT (retval == strlen (result));
271 { /* Rounding can turn a ...FFF into a ...000.
272 This shows a MacOS X 10.3.9 (Darwin 7.9) bug. */
275 my_snprintf (result, sizeof (result), "%.1a %d", 1.999, 33, 44, 55);
276 ASSERT (strcmp (result, "0x1.0p+1 33") == 0
277 || strcmp (result, "0x2.0p+0 33") == 0
278 || strcmp (result, "0x4.0p-1 33") == 0
279 || strcmp (result, "0x8.0p-2 33") == 0);
280 ASSERT (retval == strlen (result));
286 my_snprintf (result, sizeof (result), "%10a %d", 1.75, 33, 44, 55);
287 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
288 || strcmp (result, " 0x3.8p-1 33") == 0
289 || strcmp (result, " 0x7p-2 33") == 0
290 || strcmp (result, " 0xep-3 33") == 0);
291 ASSERT (retval == strlen (result));
294 { /* Small precision. */
297 my_snprintf (result, sizeof (result), "%.10a %d", 1.75, 33, 44, 55);
298 ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
299 || strcmp (result, "0x3.8000000000p-1 33") == 0
300 || strcmp (result, "0x7.0000000000p-2 33") == 0
301 || strcmp (result, "0xe.0000000000p-3 33") == 0);
302 ASSERT (retval == strlen (result));
305 { /* Large precision. */
308 my_snprintf (result, sizeof (result), "%.50a %d", 1.75, 33, 44, 55);
309 ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
310 || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
311 || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
312 || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
313 ASSERT (retval == strlen (result));
319 my_snprintf (result, sizeof (result), "%-10a %d", 1.75, 33, 44, 55);
320 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
321 || strcmp (result, "0x3.8p-1 33") == 0
322 || strcmp (result, "0x7p-2 33") == 0
323 || strcmp (result, "0xep-3 33") == 0);
324 ASSERT (retval == strlen (result));
327 { /* FLAG_SHOWSIGN. */
330 my_snprintf (result, sizeof (result), "%+a %d", 1.75, 33, 44, 55);
331 ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
332 || strcmp (result, "+0x3.8p-1 33") == 0
333 || strcmp (result, "+0x7p-2 33") == 0
334 || strcmp (result, "+0xep-3 33") == 0);
335 ASSERT (retval == strlen (result));
341 my_snprintf (result, sizeof (result), "% a %d", 1.75, 33, 44, 55);
342 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
343 || strcmp (result, " 0x3.8p-1 33") == 0
344 || strcmp (result, " 0x7p-2 33") == 0
345 || strcmp (result, " 0xep-3 33") == 0);
346 ASSERT (retval == strlen (result));
352 my_snprintf (result, sizeof (result), "%#a %d", 1.75, 33, 44, 55);
353 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
354 || strcmp (result, "0x3.8p-1 33") == 0
355 || strcmp (result, "0x7.p-2 33") == 0
356 || strcmp (result, "0xe.p-3 33") == 0);
357 ASSERT (retval == strlen (result));
363 my_snprintf (result, sizeof (result), "%#a %d", 1.0, 33, 44, 55);
364 ASSERT (strcmp (result, "0x1.p+0 33") == 0
365 || strcmp (result, "0x2.p-1 33") == 0
366 || strcmp (result, "0x4.p-2 33") == 0
367 || strcmp (result, "0x8.p-3 33") == 0);
368 ASSERT (retval == strlen (result));
371 { /* FLAG_ZERO with finite number. */
374 my_snprintf (result, sizeof (result), "%010a %d", 1.75, 33, 44, 55);
375 ASSERT (strcmp (result, "0x001.cp+0 33") == 0
376 || strcmp (result, "0x003.8p-1 33") == 0
377 || strcmp (result, "0x00007p-2 33") == 0
378 || strcmp (result, "0x0000ep-3 33") == 0);
379 ASSERT (retval == strlen (result));
382 { /* FLAG_ZERO with infinite number. */
385 my_snprintf (result, sizeof (result), "%010a %d", 1.0 / 0.0, 33, 44, 55);
386 /* "0000000inf 33" is not a valid result; see
387 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
388 ASSERT (strcmp (result, " inf 33") == 0);
389 ASSERT (retval == strlen (result));
392 { /* FLAG_ZERO with NaN. */
395 my_snprintf (result, sizeof (result), "%050a %d", NaN (), 33, 44, 55);
396 /* "0000000nan 33" is not a valid result; see
397 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
398 ASSERT (strlen (result) == 50 + 3
399 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
400 && strcmp (result + strlen (result) - 3, " 33") == 0);
401 ASSERT (retval == strlen (result));
404 { /* A positive number. */
407 my_snprintf (result, sizeof (result), "%La %d", 3.1416015625L, 33, 44, 55);
408 ASSERT (strcmp (result, "0x1.922p+1 33") == 0
409 || strcmp (result, "0x3.244p+0 33") == 0
410 || strcmp (result, "0x6.488p-1 33") == 0
411 || strcmp (result, "0xc.91p-2 33") == 0);
412 ASSERT (retval == strlen (result));
415 { /* A negative number. */
418 my_snprintf (result, sizeof (result), "%LA %d", -3.1416015625L, 33, 44, 55);
419 ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
420 || strcmp (result, "-0X3.244P+0 33") == 0
421 || strcmp (result, "-0X6.488P-1 33") == 0
422 || strcmp (result, "-0XC.91P-2 33") == 0);
423 ASSERT (retval == strlen (result));
426 { /* Positive zero. */
429 my_snprintf (result, sizeof (result), "%La %d", 0.0L, 33, 44, 55);
430 ASSERT (strcmp (result, "0x0p+0 33") == 0);
431 ASSERT (retval == strlen (result));
434 { /* Negative zero. */
437 my_snprintf (result, sizeof (result), "%La %d", -0.0L, 33, 44, 55);
438 if (have_minus_zero ())
439 ASSERT (strcmp (result, "-0x0p+0 33") == 0);
440 ASSERT (retval == strlen (result));
443 { /* Positive infinity. */
446 my_snprintf (result, sizeof (result), "%La %d", 1.0L / 0.0L, 33, 44, 55);
447 ASSERT (strcmp (result, "inf 33") == 0);
448 ASSERT (retval == strlen (result));
451 { /* Negative infinity. */
454 my_snprintf (result, sizeof (result), "%La %d", -1.0L / 0.0L, 33, 44, 55);
455 ASSERT (strcmp (result, "-inf 33") == 0);
456 ASSERT (retval == strlen (result));
462 my_snprintf (result, sizeof (result), "%La %d", 0.0L / 0.0L, 33, 44, 55);
463 ASSERT (strlen (result) >= 3 + 3
464 && strisnan (result, 0, strlen (result) - 3, 0)
465 && strcmp (result + strlen (result) - 3, " 33") == 0);
466 ASSERT (retval == strlen (result));
469 { /* Rounding near the decimal point. */
472 my_snprintf (result, sizeof (result), "%.0La %d", 1.5L, 33, 44, 55);
473 ASSERT (strcmp (result, "0x2p+0 33") == 0
474 || strcmp (result, "0x3p-1 33") == 0
475 || strcmp (result, "0x6p-2 33") == 0
476 || strcmp (result, "0xcp-3 33") == 0);
477 ASSERT (retval == strlen (result));
480 { /* Rounding with precision 0. */
483 my_snprintf (result, sizeof (result), "%.0La %d", 1.51L, 33, 44, 55);
484 ASSERT (strcmp (result, "0x2p+0 33") == 0
485 || strcmp (result, "0x3p-1 33") == 0
486 || strcmp (result, "0x6p-2 33") == 0
487 || strcmp (result, "0xcp-3 33") == 0);
488 ASSERT (retval == strlen (result));
491 { /* Rounding with precision 1. */
494 my_snprintf (result, sizeof (result), "%.1La %d", 1.51L, 33, 44, 55);
495 ASSERT (strcmp (result, "0x1.8p+0 33") == 0
496 || strcmp (result, "0x3.0p-1 33") == 0
497 || strcmp (result, "0x6.1p-2 33") == 0
498 || strcmp (result, "0xc.1p-3 33") == 0);
499 ASSERT (retval == strlen (result));
502 { /* Rounding with precision 2. */
505 my_snprintf (result, sizeof (result), "%.2La %d", 1.51L, 33, 44, 55);
506 ASSERT (strcmp (result, "0x1.83p+0 33") == 0
507 || strcmp (result, "0x3.05p-1 33") == 0
508 || strcmp (result, "0x6.0ap-2 33") == 0
509 || strcmp (result, "0xc.14p-3 33") == 0);
510 ASSERT (retval == strlen (result));
513 { /* Rounding with precision 3. */
516 my_snprintf (result, sizeof (result), "%.3La %d", 1.51L, 33, 44, 55);
517 ASSERT (strcmp (result, "0x1.829p+0 33") == 0
518 || strcmp (result, "0x3.052p-1 33") == 0
519 || strcmp (result, "0x6.0a4p-2 33") == 0
520 || strcmp (result, "0xc.148p-3 33") == 0);
521 ASSERT (retval == strlen (result));
524 { /* Rounding can turn a ...FFF into a ...000. */
527 my_snprintf (result, sizeof (result), "%.3La %d", 1.49999L, 33, 44, 55);
528 ASSERT (strcmp (result, "0x1.800p+0 33") == 0
529 || strcmp (result, "0x3.000p-1 33") == 0
530 || strcmp (result, "0x6.000p-2 33") == 0
531 || strcmp (result, "0xc.000p-3 33") == 0);
532 ASSERT (retval == strlen (result));
535 { /* Rounding can turn a ...FFF into a ...000.
536 This shows a MacOS X 10.3.9 (Darwin 7.9) bug and a
537 glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>. */
540 my_snprintf (result, sizeof (result), "%.1La %d", 1.999L, 33, 44, 55);
541 ASSERT (strcmp (result, "0x1.0p+1 33") == 0
542 || strcmp (result, "0x2.0p+0 33") == 0
543 || strcmp (result, "0x4.0p-1 33") == 0
544 || strcmp (result, "0x8.0p-2 33") == 0);
545 ASSERT (retval == strlen (result));
551 my_snprintf (result, sizeof (result), "%10La %d", 1.75L, 33, 44, 55);
552 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
553 || strcmp (result, " 0x3.8p-1 33") == 0
554 || strcmp (result, " 0x7p-2 33") == 0
555 || strcmp (result, " 0xep-3 33") == 0);
556 ASSERT (retval == strlen (result));
559 { /* Small precision. */
562 my_snprintf (result, sizeof (result), "%.10La %d", 1.75L, 33, 44, 55);
563 ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
564 || strcmp (result, "0x3.8000000000p-1 33") == 0
565 || strcmp (result, "0x7.0000000000p-2 33") == 0
566 || strcmp (result, "0xe.0000000000p-3 33") == 0);
567 ASSERT (retval == strlen (result));
570 { /* Large precision. */
573 my_snprintf (result, sizeof (result), "%.50La %d", 1.75L, 33, 44, 55);
574 ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
575 || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
576 || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
577 || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
578 ASSERT (retval == strlen (result));
584 my_snprintf (result, sizeof (result), "%-10La %d", 1.75L, 33, 44, 55);
585 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
586 || strcmp (result, "0x3.8p-1 33") == 0
587 || strcmp (result, "0x7p-2 33") == 0
588 || strcmp (result, "0xep-3 33") == 0);
589 ASSERT (retval == strlen (result));
592 { /* FLAG_SHOWSIGN. */
595 my_snprintf (result, sizeof (result), "%+La %d", 1.75L, 33, 44, 55);
596 ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
597 || strcmp (result, "+0x3.8p-1 33") == 0
598 || strcmp (result, "+0x7p-2 33") == 0
599 || strcmp (result, "+0xep-3 33") == 0);
600 ASSERT (retval == strlen (result));
606 my_snprintf (result, sizeof (result), "% La %d", 1.75L, 33, 44, 55);
607 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
608 || strcmp (result, " 0x3.8p-1 33") == 0
609 || strcmp (result, " 0x7p-2 33") == 0
610 || strcmp (result, " 0xep-3 33") == 0);
611 ASSERT (retval == strlen (result));
617 my_snprintf (result, sizeof (result), "%#La %d", 1.75L, 33, 44, 55);
618 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
619 || strcmp (result, "0x3.8p-1 33") == 0
620 || strcmp (result, "0x7.p-2 33") == 0
621 || strcmp (result, "0xe.p-3 33") == 0);
622 ASSERT (retval == strlen (result));
628 my_snprintf (result, sizeof (result), "%#La %d", 1.0L, 33, 44, 55);
629 ASSERT (strcmp (result, "0x1.p+0 33") == 0
630 || strcmp (result, "0x2.p-1 33") == 0
631 || strcmp (result, "0x4.p-2 33") == 0
632 || strcmp (result, "0x8.p-3 33") == 0);
633 ASSERT (retval == strlen (result));
636 { /* FLAG_ZERO with finite number. */
639 my_snprintf (result, sizeof (result), "%010La %d", 1.75L, 33, 44, 55);
640 ASSERT (strcmp (result, "0x001.cp+0 33") == 0
641 || strcmp (result, "0x003.8p-1 33") == 0
642 || strcmp (result, "0x00007p-2 33") == 0
643 || strcmp (result, "0x0000ep-3 33") == 0);
644 ASSERT (retval == strlen (result));
647 { /* FLAG_ZERO with infinite number. */
650 my_snprintf (result, sizeof (result), "%010La %d", 1.0L / 0.0L, 33, 44, 55);
651 /* "0000000inf 33" is not a valid result; see
652 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
653 ASSERT (strcmp (result, " inf 33") == 0);
654 ASSERT (retval == strlen (result));
657 { /* FLAG_ZERO with NaN. */
660 my_snprintf (result, sizeof (result), "%050La %d", 0.0L / 0.0L, 33, 44, 55);
661 /* "0000000nan 33" is not a valid result; see
662 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
663 ASSERT (strlen (result) == 50 + 3
664 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
665 && strcmp (result + strlen (result) - 3, " 33") == 0);
666 ASSERT (retval == strlen (result));
669 /* Test the support of the %f format directive. */
671 { /* A positive number. */
674 my_snprintf (result, sizeof (result), "%f %d", 12.75, 33, 44, 55);
675 ASSERT (strcmp (result, "12.750000 33") == 0);
676 ASSERT (retval == strlen (result));
679 { /* A larger positive number. */
682 my_snprintf (result, sizeof (result), "%f %d", 1234567.0, 33, 44, 55);
683 ASSERT (strcmp (result, "1234567.000000 33") == 0);
684 ASSERT (retval == strlen (result));
687 { /* Small and large positive numbers. */
688 static struct { double value; const char *string; } data[] =
690 { 1.234321234321234e-37, "0.000000" },
691 { 1.234321234321234e-36, "0.000000" },
692 { 1.234321234321234e-35, "0.000000" },
693 { 1.234321234321234e-34, "0.000000" },
694 { 1.234321234321234e-33, "0.000000" },
695 { 1.234321234321234e-32, "0.000000" },
696 { 1.234321234321234e-31, "0.000000" },
697 { 1.234321234321234e-30, "0.000000" },
698 { 1.234321234321234e-29, "0.000000" },
699 { 1.234321234321234e-28, "0.000000" },
700 { 1.234321234321234e-27, "0.000000" },
701 { 1.234321234321234e-26, "0.000000" },
702 { 1.234321234321234e-25, "0.000000" },
703 { 1.234321234321234e-24, "0.000000" },
704 { 1.234321234321234e-23, "0.000000" },
705 { 1.234321234321234e-22, "0.000000" },
706 { 1.234321234321234e-21, "0.000000" },
707 { 1.234321234321234e-20, "0.000000" },
708 { 1.234321234321234e-19, "0.000000" },
709 { 1.234321234321234e-18, "0.000000" },
710 { 1.234321234321234e-17, "0.000000" },
711 { 1.234321234321234e-16, "0.000000" },
712 { 1.234321234321234e-15, "0.000000" },
713 { 1.234321234321234e-14, "0.000000" },
714 { 1.234321234321234e-13, "0.000000" },
715 { 1.234321234321234e-12, "0.000000" },
716 { 1.234321234321234e-11, "0.000000" },
717 { 1.234321234321234e-10, "0.000000" },
718 { 1.234321234321234e-9, "0.000000" },
719 { 1.234321234321234e-8, "0.000000" },
720 { 1.234321234321234e-7, "0.000000" },
721 { 1.234321234321234e-6, "0.000001" },
722 { 1.234321234321234e-5, "0.000012" },
723 { 1.234321234321234e-4, "0.000123" },
724 { 1.234321234321234e-3, "0.001234" },
725 { 1.234321234321234e-2, "0.012343" },
726 { 1.234321234321234e-1, "0.123432" },
727 { 1.234321234321234, "1.234321" },
728 { 1.234321234321234e1, "12.343212" },
729 { 1.234321234321234e2, "123.432123" },
730 { 1.234321234321234e3, "1234.321234" },
731 { 1.234321234321234e4, "12343.212343" },
732 { 1.234321234321234e5, "123432.123432" },
733 { 1.234321234321234e6, "1234321.234321" },
734 { 1.234321234321234e7, "12343212.343212" },
735 { 1.234321234321234e8, "123432123.432123" },
736 { 1.234321234321234e9, "1234321234.321234" },
737 { 1.234321234321234e10, "12343212343.2123**" },
738 { 1.234321234321234e11, "123432123432.123***" },
739 { 1.234321234321234e12, "1234321234321.23****" },
740 { 1.234321234321234e13, "12343212343212.3*****" },
741 { 1.234321234321234e14, "123432123432123.******" },
742 { 1.234321234321234e15, "1234321234321234.000000" },
743 { 1.234321234321234e16, "123432123432123**.000000" },
744 { 1.234321234321234e17, "123432123432123***.000000" },
745 { 1.234321234321234e18, "123432123432123****.000000" },
746 { 1.234321234321234e19, "123432123432123*****.000000" },
747 { 1.234321234321234e20, "123432123432123******.000000" },
748 { 1.234321234321234e21, "123432123432123*******.000000" },
749 { 1.234321234321234e22, "123432123432123********.000000" },
750 { 1.234321234321234e23, "123432123432123*********.000000" },
751 { 1.234321234321234e24, "123432123432123**********.000000" },
752 { 1.234321234321234e25, "123432123432123***********.000000" },
753 { 1.234321234321234e26, "123432123432123************.000000" },
754 { 1.234321234321234e27, "123432123432123*************.000000" },
755 { 1.234321234321234e28, "123432123432123**************.000000" },
756 { 1.234321234321234e29, "123432123432123***************.000000" },
757 { 1.234321234321234e30, "123432123432123****************.000000" },
758 { 1.234321234321234e31, "123432123432123*****************.000000" },
759 { 1.234321234321234e32, "123432123432123******************.000000" },
760 { 1.234321234321234e33, "123432123432123*******************.000000" },
761 { 1.234321234321234e34, "123432123432123********************.000000" },
762 { 1.234321234321234e35, "123432123432123*********************.000000" },
763 { 1.234321234321234e36, "123432123432123**********************.000000" }
766 for (k = 0; k < SIZEOF (data); k++)
770 my_snprintf (result, sizeof (result), "%f", data[k].value);
771 ASSERT (strmatch (data[k].string, result));
772 ASSERT (retval == strlen (result));
776 { /* A negative number. */
779 my_snprintf (result, sizeof (result), "%f %d", -0.03125, 33, 44, 55);
780 ASSERT (strcmp (result, "-0.031250 33") == 0);
781 ASSERT (retval == strlen (result));
784 { /* Positive zero. */
787 my_snprintf (result, sizeof (result), "%f %d", 0.0, 33, 44, 55);
788 ASSERT (strcmp (result, "0.000000 33") == 0);
789 ASSERT (retval == strlen (result));
792 { /* Negative zero. */
795 my_snprintf (result, sizeof (result), "%f %d", -0.0, 33, 44, 55);
796 if (have_minus_zero ())
797 ASSERT (strcmp (result, "-0.000000 33") == 0);
798 ASSERT (retval == strlen (result));
801 { /* Positive infinity. */
804 my_snprintf (result, sizeof (result), "%f %d", 1.0 / 0.0, 33, 44, 55);
805 ASSERT (strcmp (result, "inf 33") == 0
806 || strcmp (result, "infinity 33") == 0);
807 ASSERT (retval == strlen (result));
810 { /* Negative infinity. */
813 my_snprintf (result, sizeof (result), "%f %d", -1.0 / 0.0, 33, 44, 55);
814 ASSERT (strcmp (result, "-inf 33") == 0
815 || strcmp (result, "-infinity 33") == 0);
816 ASSERT (retval == strlen (result));
822 my_snprintf (result, sizeof (result), "%f %d", NaN (), 33, 44, 55);
823 ASSERT (strlen (result) >= 3 + 3
824 && strisnan (result, 0, strlen (result) - 3, 0)
825 && strcmp (result + strlen (result) - 3, " 33") == 0);
826 ASSERT (retval == strlen (result));
832 my_snprintf (result, sizeof (result), "%10f %d", 1.75, 33, 44, 55);
833 ASSERT (result != NULL);
834 ASSERT (strcmp (result, " 1.750000 33") == 0);
835 ASSERT (retval == strlen (result));
841 my_snprintf (result, sizeof (result), "%-10f %d", 1.75, 33, 44, 55);
842 ASSERT (result != NULL);
843 ASSERT (strcmp (result, "1.750000 33") == 0);
844 ASSERT (retval == strlen (result));
847 { /* FLAG_SHOWSIGN. */
850 my_snprintf (result, sizeof (result), "%+f %d", 1.75, 33, 44, 55);
851 ASSERT (result != NULL);
852 ASSERT (strcmp (result, "+1.750000 33") == 0);
853 ASSERT (retval == strlen (result));
859 my_snprintf (result, sizeof (result), "% f %d", 1.75, 33, 44, 55);
860 ASSERT (result != NULL);
861 ASSERT (strcmp (result, " 1.750000 33") == 0);
862 ASSERT (retval == strlen (result));
868 my_snprintf (result, sizeof (result), "%#f %d", 1.75, 33, 44, 55);
869 ASSERT (result != NULL);
870 ASSERT (strcmp (result, "1.750000 33") == 0);
871 ASSERT (retval == strlen (result));
877 my_snprintf (result, sizeof (result), "%#.f %d", 1.75, 33, 44, 55);
878 ASSERT (result != NULL);
879 ASSERT (strcmp (result, "2. 33") == 0);
880 ASSERT (retval == strlen (result));
883 { /* FLAG_ZERO with finite number. */
886 my_snprintf (result, sizeof (result), "%015f %d", 1234.0, 33, 44, 55);
887 ASSERT (strcmp (result, "00001234.000000 33") == 0);
888 ASSERT (retval == strlen (result));
891 { /* FLAG_ZERO with infinite number. */
894 my_snprintf (result, sizeof (result), "%015f %d", -1.0 / 0.0, 33, 44, 55);
895 ASSERT (strcmp (result, " -inf 33") == 0
896 || strcmp (result, " -infinity 33") == 0);
897 ASSERT (retval == strlen (result));
900 { /* FLAG_ZERO with NaN. */
903 my_snprintf (result, sizeof (result), "%050f %d", NaN (), 33, 44, 55);
904 ASSERT (strlen (result) == 50 + 3
905 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
906 && strcmp (result + strlen (result) - 3, " 33") == 0);
907 ASSERT (retval == strlen (result));
913 my_snprintf (result, sizeof (result), "%.f %d", 1234.0, 33, 44, 55);
914 ASSERT (strcmp (result, "1234 33") == 0);
915 ASSERT (retval == strlen (result));
918 { /* A positive number. */
921 my_snprintf (result, sizeof (result), "%Lf %d", 12.75L, 33, 44, 55);
922 ASSERT (strcmp (result, "12.750000 33") == 0);
923 ASSERT (retval == strlen (result));
926 { /* A larger positive number. */
929 my_snprintf (result, sizeof (result), "%Lf %d", 1234567.0L, 33, 44, 55);
930 ASSERT (strcmp (result, "1234567.000000 33") == 0);
931 ASSERT (retval == strlen (result));
934 { /* Small and large positive numbers. */
935 static struct { long double value; const char *string; } data[] =
937 { 1.234321234321234e-37L, "0.000000" },
938 { 1.234321234321234e-36L, "0.000000" },
939 { 1.234321234321234e-35L, "0.000000" },
940 { 1.234321234321234e-34L, "0.000000" },
941 { 1.234321234321234e-33L, "0.000000" },
942 { 1.234321234321234e-32L, "0.000000" },
943 { 1.234321234321234e-31L, "0.000000" },
944 { 1.234321234321234e-30L, "0.000000" },
945 { 1.234321234321234e-29L, "0.000000" },
946 { 1.234321234321234e-28L, "0.000000" },
947 { 1.234321234321234e-27L, "0.000000" },
948 { 1.234321234321234e-26L, "0.000000" },
949 { 1.234321234321234e-25L, "0.000000" },
950 { 1.234321234321234e-24L, "0.000000" },
951 { 1.234321234321234e-23L, "0.000000" },
952 { 1.234321234321234e-22L, "0.000000" },
953 { 1.234321234321234e-21L, "0.000000" },
954 { 1.234321234321234e-20L, "0.000000" },
955 { 1.234321234321234e-19L, "0.000000" },
956 { 1.234321234321234e-18L, "0.000000" },
957 { 1.234321234321234e-17L, "0.000000" },
958 { 1.234321234321234e-16L, "0.000000" },
959 { 1.234321234321234e-15L, "0.000000" },
960 { 1.234321234321234e-14L, "0.000000" },
961 { 1.234321234321234e-13L, "0.000000" },
962 { 1.234321234321234e-12L, "0.000000" },
963 { 1.234321234321234e-11L, "0.000000" },
964 { 1.234321234321234e-10L, "0.000000" },
965 { 1.234321234321234e-9L, "0.000000" },
966 { 1.234321234321234e-8L, "0.000000" },
967 { 1.234321234321234e-7L, "0.000000" },
968 { 1.234321234321234e-6L, "0.000001" },
969 { 1.234321234321234e-5L, "0.000012" },
970 { 1.234321234321234e-4L, "0.000123" },
971 { 1.234321234321234e-3L, "0.001234" },
972 { 1.234321234321234e-2L, "0.012343" },
973 { 1.234321234321234e-1L, "0.123432" },
974 { 1.234321234321234L, "1.234321" },
975 { 1.234321234321234e1L, "12.343212" },
976 { 1.234321234321234e2L, "123.432123" },
977 { 1.234321234321234e3L, "1234.321234" },
978 { 1.234321234321234e4L, "12343.212343" },
979 { 1.234321234321234e5L, "123432.123432" },
980 { 1.234321234321234e6L, "1234321.234321" },
981 { 1.234321234321234e7L, "12343212.343212" },
982 { 1.234321234321234e8L, "123432123.432123" },
983 { 1.234321234321234e9L, "1234321234.321234" },
984 { 1.234321234321234e10L, "12343212343.2123**" },
985 { 1.234321234321234e11L, "123432123432.123***" },
986 { 1.234321234321234e12L, "1234321234321.23****" },
987 { 1.234321234321234e13L, "12343212343212.3*****" },
988 { 1.234321234321234e14L, "123432123432123.******" },
989 { 1.234321234321234e15L, "1234321234321234.000000" },
990 { 1.234321234321234e16L, "123432123432123**.000000" },
991 { 1.234321234321234e17L, "123432123432123***.000000" },
992 { 1.234321234321234e18L, "123432123432123****.000000" },
993 { 1.234321234321234e19L, "123432123432123*****.000000" },
994 { 1.234321234321234e20L, "123432123432123******.000000" },
995 { 1.234321234321234e21L, "123432123432123*******.000000" },
996 { 1.234321234321234e22L, "123432123432123********.000000" },
997 { 1.234321234321234e23L, "123432123432123*********.000000" },
998 { 1.234321234321234e24L, "123432123432123**********.000000" },
999 { 1.234321234321234e25L, "123432123432123***********.000000" },
1000 { 1.234321234321234e26L, "123432123432123************.000000" },
1001 { 1.234321234321234e27L, "123432123432123*************.000000" },
1002 { 1.234321234321234e28L, "123432123432123**************.000000" },
1003 { 1.234321234321234e29L, "123432123432123***************.000000" },
1004 { 1.234321234321234e30L, "123432123432123****************.000000" },
1005 { 1.234321234321234e31L, "123432123432123*****************.000000" },
1006 { 1.234321234321234e32L, "123432123432123******************.000000" },
1007 { 1.234321234321234e33L, "123432123432123*******************.000000" },
1008 { 1.234321234321234e34L, "123432123432123********************.000000" },
1009 { 1.234321234321234e35L, "123432123432123*********************.000000" },
1010 { 1.234321234321234e36L, "123432123432123**********************.000000" }
1013 for (k = 0; k < SIZEOF (data); k++)
1017 my_snprintf (result, sizeof (result), "%Lf", data[k].value);
1018 ASSERT (strmatch (data[k].string, result));
1019 ASSERT (retval == strlen (result));
1023 { /* A negative number. */
1026 my_snprintf (result, sizeof (result), "%Lf %d", -0.03125L, 33, 44, 55);
1027 ASSERT (strcmp (result, "-0.031250 33") == 0);
1028 ASSERT (retval == strlen (result));
1031 { /* Positive zero. */
1034 my_snprintf (result, sizeof (result), "%Lf %d", 0.0L, 33, 44, 55);
1035 ASSERT (strcmp (result, "0.000000 33") == 0);
1036 ASSERT (retval == strlen (result));
1039 { /* Negative zero. */
1042 my_snprintf (result, sizeof (result), "%Lf %d", -0.0L, 33, 44, 55);
1043 if (have_minus_zero ())
1044 ASSERT (strcmp (result, "-0.000000 33") == 0);
1045 ASSERT (retval == strlen (result));
1048 { /* Positive infinity. */
1051 my_snprintf (result, sizeof (result), "%Lf %d", 1.0L / 0.0L, 33, 44, 55);
1052 ASSERT (strcmp (result, "inf 33") == 0
1053 || strcmp (result, "infinity 33") == 0);
1054 ASSERT (retval == strlen (result));
1057 { /* Negative infinity. */
1060 my_snprintf (result, sizeof (result), "%Lf %d", -1.0L / 0.0L, 33, 44, 55);
1061 ASSERT (strcmp (result, "-inf 33") == 0
1062 || strcmp (result, "-infinity 33") == 0);
1063 ASSERT (retval == strlen (result));
1067 static long double zero = 0.0L;
1070 my_snprintf (result, sizeof (result), "%Lf %d", zero / zero, 33, 44, 55);
1071 ASSERT (strlen (result) >= 3 + 3
1072 && strisnan (result, 0, strlen (result) - 3, 0)
1073 && strcmp (result + strlen (result) - 3, " 33") == 0);
1074 ASSERT (retval == strlen (result));
1080 my_snprintf (result, sizeof (result), "%10Lf %d", 1.75L, 33, 44, 55);
1081 ASSERT (result != NULL);
1082 ASSERT (strcmp (result, " 1.750000 33") == 0);
1083 ASSERT (retval == strlen (result));
1089 my_snprintf (result, sizeof (result), "%-10Lf %d", 1.75L, 33, 44, 55);
1090 ASSERT (result != NULL);
1091 ASSERT (strcmp (result, "1.750000 33") == 0);
1092 ASSERT (retval == strlen (result));
1095 { /* FLAG_SHOWSIGN. */
1098 my_snprintf (result, sizeof (result), "%+Lf %d", 1.75L, 33, 44, 55);
1099 ASSERT (result != NULL);
1100 ASSERT (strcmp (result, "+1.750000 33") == 0);
1101 ASSERT (retval == strlen (result));
1107 my_snprintf (result, sizeof (result), "% Lf %d", 1.75L, 33, 44, 55);
1108 ASSERT (result != NULL);
1109 ASSERT (strcmp (result, " 1.750000 33") == 0);
1110 ASSERT (retval == strlen (result));
1116 my_snprintf (result, sizeof (result), "%#Lf %d", 1.75L, 33, 44, 55);
1117 ASSERT (result != NULL);
1118 ASSERT (strcmp (result, "1.750000 33") == 0);
1119 ASSERT (retval == strlen (result));
1125 my_snprintf (result, sizeof (result), "%#.Lf %d", 1.75L, 33, 44, 55);
1126 ASSERT (result != NULL);
1127 ASSERT (strcmp (result, "2. 33") == 0);
1128 ASSERT (retval == strlen (result));
1131 { /* FLAG_ZERO with finite number. */
1134 my_snprintf (result, sizeof (result), "%015Lf %d", 1234.0L, 33, 44, 55);
1135 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1136 ASSERT (retval == strlen (result));
1139 { /* FLAG_ZERO with infinite number. */
1142 my_snprintf (result, sizeof (result), "%015Lf %d", -1.0L / 0.0L, 33, 44, 55);
1143 ASSERT (strcmp (result, " -inf 33") == 0
1144 || strcmp (result, " -infinity 33") == 0);
1145 ASSERT (retval == strlen (result));
1148 { /* FLAG_ZERO with NaN. */
1149 static long double zero = 0.0L;
1152 my_snprintf (result, sizeof (result), "%050Lf %d", zero / zero, 33, 44, 55);
1153 ASSERT (strlen (result) == 50 + 3
1154 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1155 && strcmp (result + strlen (result) - 3, " 33") == 0);
1156 ASSERT (retval == strlen (result));
1162 my_snprintf (result, sizeof (result), "%.Lf %d", 1234.0L, 33, 44, 55);
1163 ASSERT (strcmp (result, "1234 33") == 0);
1164 ASSERT (retval == strlen (result));
1167 /* Test the support of the %F format directive. */
1169 { /* A positive number. */
1172 my_snprintf (result, sizeof (result), "%F %d", 12.75, 33, 44, 55);
1173 ASSERT (strcmp (result, "12.750000 33") == 0);
1174 ASSERT (retval == strlen (result));
1177 { /* A larger positive number. */
1180 my_snprintf (result, sizeof (result), "%F %d", 1234567.0, 33, 44, 55);
1181 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1182 ASSERT (retval == strlen (result));
1185 { /* A negative number. */
1188 my_snprintf (result, sizeof (result), "%F %d", -0.03125, 33, 44, 55);
1189 ASSERT (strcmp (result, "-0.031250 33") == 0);
1190 ASSERT (retval == strlen (result));
1193 { /* Positive zero. */
1196 my_snprintf (result, sizeof (result), "%F %d", 0.0, 33, 44, 55);
1197 ASSERT (strcmp (result, "0.000000 33") == 0);
1198 ASSERT (retval == strlen (result));
1201 { /* Negative zero. */
1204 my_snprintf (result, sizeof (result), "%F %d", -0.0, 33, 44, 55);
1205 if (have_minus_zero ())
1206 ASSERT (strcmp (result, "-0.000000 33") == 0);
1207 ASSERT (retval == strlen (result));
1210 { /* Positive infinity. */
1213 my_snprintf (result, sizeof (result), "%F %d", 1.0 / 0.0, 33, 44, 55);
1214 ASSERT (strcmp (result, "INF 33") == 0
1215 || strcmp (result, "INFINITY 33") == 0);
1216 ASSERT (retval == strlen (result));
1219 { /* Negative infinity. */
1222 my_snprintf (result, sizeof (result), "%F %d", -1.0 / 0.0, 33, 44, 55);
1223 ASSERT (strcmp (result, "-INF 33") == 0
1224 || strcmp (result, "-INFINITY 33") == 0);
1225 ASSERT (retval == strlen (result));
1231 my_snprintf (result, sizeof (result), "%F %d", NaN (), 33, 44, 55);
1232 ASSERT (strlen (result) >= 3 + 3
1233 && strisnan (result, 0, strlen (result) - 3, 1)
1234 && strcmp (result + strlen (result) - 3, " 33") == 0);
1235 ASSERT (retval == strlen (result));
1241 my_snprintf (result, sizeof (result), "%015F %d", 1234.0, 33, 44, 55);
1242 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1243 ASSERT (retval == strlen (result));
1246 { /* FLAG_ZERO with infinite number. */
1249 my_snprintf (result, sizeof (result), "%015F %d", -1.0 / 0.0, 33, 44, 55);
1250 ASSERT (strcmp (result, " -INF 33") == 0
1251 || strcmp (result, " -INFINITY 33") == 0);
1252 ASSERT (retval == strlen (result));
1258 my_snprintf (result, sizeof (result), "%.F %d", 1234.0, 33, 44, 55);
1259 ASSERT (strcmp (result, "1234 33") == 0);
1260 ASSERT (retval == strlen (result));
1263 { /* A positive number. */
1266 my_snprintf (result, sizeof (result), "%LF %d", 12.75L, 33, 44, 55);
1267 ASSERT (strcmp (result, "12.750000 33") == 0);
1268 ASSERT (retval == strlen (result));
1271 { /* A larger positive number. */
1274 my_snprintf (result, sizeof (result), "%LF %d", 1234567.0L, 33, 44, 55);
1275 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1276 ASSERT (retval == strlen (result));
1279 { /* A negative number. */
1282 my_snprintf (result, sizeof (result), "%LF %d", -0.03125L, 33, 44, 55);
1283 ASSERT (strcmp (result, "-0.031250 33") == 0);
1284 ASSERT (retval == strlen (result));
1287 { /* Positive zero. */
1290 my_snprintf (result, sizeof (result), "%LF %d", 0.0L, 33, 44, 55);
1291 ASSERT (strcmp (result, "0.000000 33") == 0);
1292 ASSERT (retval == strlen (result));
1295 { /* Negative zero. */
1298 my_snprintf (result, sizeof (result), "%LF %d", -0.0L, 33, 44, 55);
1299 if (have_minus_zero ())
1300 ASSERT (strcmp (result, "-0.000000 33") == 0);
1301 ASSERT (retval == strlen (result));
1304 { /* Positive infinity. */
1307 my_snprintf (result, sizeof (result), "%LF %d", 1.0L / 0.0L, 33, 44, 55);
1308 ASSERT (strcmp (result, "INF 33") == 0
1309 || strcmp (result, "INFINITY 33") == 0);
1310 ASSERT (retval == strlen (result));
1313 { /* Negative infinity. */
1316 my_snprintf (result, sizeof (result), "%LF %d", -1.0L / 0.0L, 33, 44, 55);
1317 ASSERT (strcmp (result, "-INF 33") == 0
1318 || strcmp (result, "-INFINITY 33") == 0);
1319 ASSERT (retval == strlen (result));
1323 static long double zero = 0.0L;
1326 my_snprintf (result, sizeof (result), "%LF %d", zero / zero, 33, 44, 55);
1327 ASSERT (strlen (result) >= 3 + 3
1328 && strisnan (result, 0, strlen (result) - 3, 1)
1329 && strcmp (result + strlen (result) - 3, " 33") == 0);
1330 ASSERT (retval == strlen (result));
1336 my_snprintf (result, sizeof (result), "%015LF %d", 1234.0L, 33, 44, 55);
1337 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1338 ASSERT (retval == strlen (result));
1341 { /* FLAG_ZERO with infinite number. */
1344 my_snprintf (result, sizeof (result), "%015LF %d", -1.0L / 0.0L, 33, 44, 55);
1345 ASSERT (strcmp (result, " -INF 33") == 0
1346 || strcmp (result, " -INFINITY 33") == 0);
1347 ASSERT (retval == strlen (result));
1353 my_snprintf (result, sizeof (result), "%.LF %d", 1234.0L, 33, 44, 55);
1354 ASSERT (strcmp (result, "1234 33") == 0);
1355 ASSERT (retval == strlen (result));
1358 /* Test the support of the %e format directive. */
1360 { /* A positive number. */
1363 my_snprintf (result, sizeof (result), "%e %d", 12.75, 33, 44, 55);
1364 ASSERT (strcmp (result, "1.275000e+01 33") == 0
1365 || strcmp (result, "1.275000e+001 33") == 0);
1366 ASSERT (retval == strlen (result));
1369 { /* A larger positive number. */
1372 my_snprintf (result, sizeof (result), "%e %d", 1234567.0, 33, 44, 55);
1373 ASSERT (strcmp (result, "1.234567e+06 33") == 0
1374 || strcmp (result, "1.234567e+006 33") == 0);
1375 ASSERT (retval == strlen (result));
1378 { /* Small and large positive numbers. */
1379 static struct { double value; const char *string; } data[] =
1381 { 1.234321234321234e-37, "1.234321e-37" },
1382 { 1.234321234321234e-36, "1.234321e-36" },
1383 { 1.234321234321234e-35, "1.234321e-35" },
1384 { 1.234321234321234e-34, "1.234321e-34" },
1385 { 1.234321234321234e-33, "1.234321e-33" },
1386 { 1.234321234321234e-32, "1.234321e-32" },
1387 { 1.234321234321234e-31, "1.234321e-31" },
1388 { 1.234321234321234e-30, "1.234321e-30" },
1389 { 1.234321234321234e-29, "1.234321e-29" },
1390 { 1.234321234321234e-28, "1.234321e-28" },
1391 { 1.234321234321234e-27, "1.234321e-27" },
1392 { 1.234321234321234e-26, "1.234321e-26" },
1393 { 1.234321234321234e-25, "1.234321e-25" },
1394 { 1.234321234321234e-24, "1.234321e-24" },
1395 { 1.234321234321234e-23, "1.234321e-23" },
1396 { 1.234321234321234e-22, "1.234321e-22" },
1397 { 1.234321234321234e-21, "1.234321e-21" },
1398 { 1.234321234321234e-20, "1.234321e-20" },
1399 { 1.234321234321234e-19, "1.234321e-19" },
1400 { 1.234321234321234e-18, "1.234321e-18" },
1401 { 1.234321234321234e-17, "1.234321e-17" },
1402 { 1.234321234321234e-16, "1.234321e-16" },
1403 { 1.234321234321234e-15, "1.234321e-15" },
1404 { 1.234321234321234e-14, "1.234321e-14" },
1405 { 1.234321234321234e-13, "1.234321e-13" },
1406 { 1.234321234321234e-12, "1.234321e-12" },
1407 { 1.234321234321234e-11, "1.234321e-11" },
1408 { 1.234321234321234e-10, "1.234321e-10" },
1409 { 1.234321234321234e-9, "1.234321e-09" },
1410 { 1.234321234321234e-8, "1.234321e-08" },
1411 { 1.234321234321234e-7, "1.234321e-07" },
1412 { 1.234321234321234e-6, "1.234321e-06" },
1413 { 1.234321234321234e-5, "1.234321e-05" },
1414 { 1.234321234321234e-4, "1.234321e-04" },
1415 { 1.234321234321234e-3, "1.234321e-03" },
1416 { 1.234321234321234e-2, "1.234321e-02" },
1417 { 1.234321234321234e-1, "1.234321e-01" },
1418 { 1.234321234321234, "1.234321e+00" },
1419 { 1.234321234321234e1, "1.234321e+01" },
1420 { 1.234321234321234e2, "1.234321e+02" },
1421 { 1.234321234321234e3, "1.234321e+03" },
1422 { 1.234321234321234e4, "1.234321e+04" },
1423 { 1.234321234321234e5, "1.234321e+05" },
1424 { 1.234321234321234e6, "1.234321e+06" },
1425 { 1.234321234321234e7, "1.234321e+07" },
1426 { 1.234321234321234e8, "1.234321e+08" },
1427 { 1.234321234321234e9, "1.234321e+09" },
1428 { 1.234321234321234e10, "1.234321e+10" },
1429 { 1.234321234321234e11, "1.234321e+11" },
1430 { 1.234321234321234e12, "1.234321e+12" },
1431 { 1.234321234321234e13, "1.234321e+13" },
1432 { 1.234321234321234e14, "1.234321e+14" },
1433 { 1.234321234321234e15, "1.234321e+15" },
1434 { 1.234321234321234e16, "1.234321e+16" },
1435 { 1.234321234321234e17, "1.234321e+17" },
1436 { 1.234321234321234e18, "1.234321e+18" },
1437 { 1.234321234321234e19, "1.234321e+19" },
1438 { 1.234321234321234e20, "1.234321e+20" },
1439 { 1.234321234321234e21, "1.234321e+21" },
1440 { 1.234321234321234e22, "1.234321e+22" },
1441 { 1.234321234321234e23, "1.234321e+23" },
1442 { 1.234321234321234e24, "1.234321e+24" },
1443 { 1.234321234321234e25, "1.234321e+25" },
1444 { 1.234321234321234e26, "1.234321e+26" },
1445 { 1.234321234321234e27, "1.234321e+27" },
1446 { 1.234321234321234e28, "1.234321e+28" },
1447 { 1.234321234321234e29, "1.234321e+29" },
1448 { 1.234321234321234e30, "1.234321e+30" },
1449 { 1.234321234321234e31, "1.234321e+31" },
1450 { 1.234321234321234e32, "1.234321e+32" },
1451 { 1.234321234321234e33, "1.234321e+33" },
1452 { 1.234321234321234e34, "1.234321e+34" },
1453 { 1.234321234321234e35, "1.234321e+35" },
1454 { 1.234321234321234e36, "1.234321e+36" }
1457 for (k = 0; k < SIZEOF (data); k++)
1461 my_snprintf (result, sizeof (result), "%e", data[k].value);
1462 const char *expected = data[k].string;
1463 ASSERT (result != NULL);
1464 ASSERT (strcmp (result, expected) == 0
1465 /* Some implementations produce exponents with 3 digits. */
1466 || (strlen (result) == strlen (expected) + 1
1467 && memcmp (result, expected, strlen (expected) - 2) == 0
1468 && result[strlen (expected) - 2] == '0'
1469 && strcmp (result + strlen (expected) - 1,
1470 expected + strlen (expected) - 2)
1472 ASSERT (retval == strlen (result));
1476 { /* A negative number. */
1479 my_snprintf (result, sizeof (result), "%e %d", -0.03125, 33, 44, 55);
1480 ASSERT (strcmp (result, "-3.125000e-02 33") == 0
1481 || strcmp (result, "-3.125000e-002 33") == 0);
1482 ASSERT (retval == strlen (result));
1485 { /* Positive zero. */
1488 my_snprintf (result, sizeof (result), "%e %d", 0.0, 33, 44, 55);
1489 ASSERT (strcmp (result, "0.000000e+00 33") == 0
1490 || strcmp (result, "0.000000e+000 33") == 0);
1491 ASSERT (retval == strlen (result));
1494 { /* Negative zero. */
1497 my_snprintf (result, sizeof (result), "%e %d", -0.0, 33, 44, 55);
1498 if (have_minus_zero ())
1499 ASSERT (strcmp (result, "-0.000000e+00 33") == 0
1500 || strcmp (result, "-0.000000e+000 33") == 0);
1501 ASSERT (retval == strlen (result));
1504 { /* Positive infinity. */
1507 my_snprintf (result, sizeof (result), "%e %d", 1.0 / 0.0, 33, 44, 55);
1508 ASSERT (strcmp (result, "inf 33") == 0
1509 || strcmp (result, "infinity 33") == 0);
1510 ASSERT (retval == strlen (result));
1513 { /* Negative infinity. */
1516 my_snprintf (result, sizeof (result), "%e %d", -1.0 / 0.0, 33, 44, 55);
1517 ASSERT (strcmp (result, "-inf 33") == 0
1518 || strcmp (result, "-infinity 33") == 0);
1519 ASSERT (retval == strlen (result));
1525 my_snprintf (result, sizeof (result), "%e %d", NaN (), 33, 44, 55);
1526 ASSERT (strlen (result) >= 3 + 3
1527 && strisnan (result, 0, strlen (result) - 3, 0)
1528 && strcmp (result + strlen (result) - 3, " 33") == 0);
1529 ASSERT (retval == strlen (result));
1535 my_snprintf (result, sizeof (result), "%15e %d", 1.75, 33, 44, 55);
1536 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
1537 || strcmp (result, " 1.750000e+000 33") == 0);
1538 ASSERT (retval == strlen (result));
1544 my_snprintf (result, sizeof (result), "%-15e %d", 1.75, 33, 44, 55);
1545 ASSERT (strcmp (result, "1.750000e+00 33") == 0
1546 || strcmp (result, "1.750000e+000 33") == 0);
1547 ASSERT (retval == strlen (result));
1550 { /* FLAG_SHOWSIGN. */
1553 my_snprintf (result, sizeof (result), "%+e %d", 1.75, 33, 44, 55);
1554 ASSERT (strcmp (result, "+1.750000e+00 33") == 0
1555 || strcmp (result, "+1.750000e+000 33") == 0);
1556 ASSERT (retval == strlen (result));
1562 my_snprintf (result, sizeof (result), "% e %d", 1.75, 33, 44, 55);
1563 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
1564 || strcmp (result, " 1.750000e+000 33") == 0);
1565 ASSERT (retval == strlen (result));
1571 my_snprintf (result, sizeof (result), "%#e %d", 1.75, 33, 44, 55);
1572 ASSERT (strcmp (result, "1.750000e+00 33") == 0
1573 || strcmp (result, "1.750000e+000 33") == 0);
1574 ASSERT (retval == strlen (result));
1580 my_snprintf (result, sizeof (result), "%#.e %d", 1.75, 33, 44, 55);
1581 ASSERT (strcmp (result, "2.e+00 33") == 0
1582 || strcmp (result, "2.e+000 33") == 0);
1583 ASSERT (retval == strlen (result));
1589 my_snprintf (result, sizeof (result), "%#.e %d", 9.75, 33, 44, 55);
1590 ASSERT (strcmp (result, "1.e+01 33") == 0
1591 || strcmp (result, "1.e+001 33") == 0);
1592 ASSERT (retval == strlen (result));
1595 { /* FLAG_ZERO with finite number. */
1598 my_snprintf (result, sizeof (result), "%015e %d", 1234.0, 33, 44, 55);
1599 ASSERT (strcmp (result, "0001.234000e+03 33") == 0
1600 || strcmp (result, "001.234000e+003 33") == 0);
1601 ASSERT (retval == strlen (result));
1604 { /* FLAG_ZERO with infinite number. */
1607 my_snprintf (result, sizeof (result), "%015e %d", -1.0 / 0.0, 33, 44, 55);
1608 ASSERT (strcmp (result, " -inf 33") == 0
1609 || strcmp (result, " -infinity 33") == 0);
1610 ASSERT (retval == strlen (result));
1613 { /* FLAG_ZERO with NaN. */
1616 my_snprintf (result, sizeof (result), "%050e %d", NaN (), 33, 44, 55);
1617 ASSERT (strlen (result) == 50 + 3
1618 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1619 && strcmp (result + strlen (result) - 3, " 33") == 0);
1620 ASSERT (retval == strlen (result));
1626 my_snprintf (result, sizeof (result), "%.e %d", 1234.0, 33, 44, 55);
1627 ASSERT (strcmp (result, "1e+03 33") == 0
1628 || strcmp (result, "1e+003 33") == 0);
1629 ASSERT (retval == strlen (result));
1632 { /* A positive number. */
1635 my_snprintf (result, sizeof (result), "%Le %d", 12.75L, 33, 44, 55);
1636 ASSERT (strcmp (result, "1.275000e+01 33") == 0);
1637 ASSERT (retval == strlen (result));
1640 { /* A larger positive number. */
1643 my_snprintf (result, sizeof (result), "%Le %d", 1234567.0L, 33, 44, 55);
1644 ASSERT (strcmp (result, "1.234567e+06 33") == 0);
1645 ASSERT (retval == strlen (result));
1648 { /* Small and large positive numbers. */
1649 static struct { long double value; const char *string; } data[] =
1651 { 1.234321234321234e-37L, "1.234321e-37" },
1652 { 1.234321234321234e-36L, "1.234321e-36" },
1653 { 1.234321234321234e-35L, "1.234321e-35" },
1654 { 1.234321234321234e-34L, "1.234321e-34" },
1655 { 1.234321234321234e-33L, "1.234321e-33" },
1656 { 1.234321234321234e-32L, "1.234321e-32" },
1657 { 1.234321234321234e-31L, "1.234321e-31" },
1658 { 1.234321234321234e-30L, "1.234321e-30" },
1659 { 1.234321234321234e-29L, "1.234321e-29" },
1660 { 1.234321234321234e-28L, "1.234321e-28" },
1661 { 1.234321234321234e-27L, "1.234321e-27" },
1662 { 1.234321234321234e-26L, "1.234321e-26" },
1663 { 1.234321234321234e-25L, "1.234321e-25" },
1664 { 1.234321234321234e-24L, "1.234321e-24" },
1665 { 1.234321234321234e-23L, "1.234321e-23" },
1666 { 1.234321234321234e-22L, "1.234321e-22" },
1667 { 1.234321234321234e-21L, "1.234321e-21" },
1668 { 1.234321234321234e-20L, "1.234321e-20" },
1669 { 1.234321234321234e-19L, "1.234321e-19" },
1670 { 1.234321234321234e-18L, "1.234321e-18" },
1671 { 1.234321234321234e-17L, "1.234321e-17" },
1672 { 1.234321234321234e-16L, "1.234321e-16" },
1673 { 1.234321234321234e-15L, "1.234321e-15" },
1674 { 1.234321234321234e-14L, "1.234321e-14" },
1675 { 1.234321234321234e-13L, "1.234321e-13" },
1676 { 1.234321234321234e-12L, "1.234321e-12" },
1677 { 1.234321234321234e-11L, "1.234321e-11" },
1678 { 1.234321234321234e-10L, "1.234321e-10" },
1679 { 1.234321234321234e-9L, "1.234321e-09" },
1680 { 1.234321234321234e-8L, "1.234321e-08" },
1681 { 1.234321234321234e-7L, "1.234321e-07" },
1682 { 1.234321234321234e-6L, "1.234321e-06" },
1683 { 1.234321234321234e-5L, "1.234321e-05" },
1684 { 1.234321234321234e-4L, "1.234321e-04" },
1685 { 1.234321234321234e-3L, "1.234321e-03" },
1686 { 1.234321234321234e-2L, "1.234321e-02" },
1687 { 1.234321234321234e-1L, "1.234321e-01" },
1688 { 1.234321234321234L, "1.234321e+00" },
1689 { 1.234321234321234e1L, "1.234321e+01" },
1690 { 1.234321234321234e2L, "1.234321e+02" },
1691 { 1.234321234321234e3L, "1.234321e+03" },
1692 { 1.234321234321234e4L, "1.234321e+04" },
1693 { 1.234321234321234e5L, "1.234321e+05" },
1694 { 1.234321234321234e6L, "1.234321e+06" },
1695 { 1.234321234321234e7L, "1.234321e+07" },
1696 { 1.234321234321234e8L, "1.234321e+08" },
1697 { 1.234321234321234e9L, "1.234321e+09" },
1698 { 1.234321234321234e10L, "1.234321e+10" },
1699 { 1.234321234321234e11L, "1.234321e+11" },
1700 { 1.234321234321234e12L, "1.234321e+12" },
1701 { 1.234321234321234e13L, "1.234321e+13" },
1702 { 1.234321234321234e14L, "1.234321e+14" },
1703 { 1.234321234321234e15L, "1.234321e+15" },
1704 { 1.234321234321234e16L, "1.234321e+16" },
1705 { 1.234321234321234e17L, "1.234321e+17" },
1706 { 1.234321234321234e18L, "1.234321e+18" },
1707 { 1.234321234321234e19L, "1.234321e+19" },
1708 { 1.234321234321234e20L, "1.234321e+20" },
1709 { 1.234321234321234e21L, "1.234321e+21" },
1710 { 1.234321234321234e22L, "1.234321e+22" },
1711 { 1.234321234321234e23L, "1.234321e+23" },
1712 { 1.234321234321234e24L, "1.234321e+24" },
1713 { 1.234321234321234e25L, "1.234321e+25" },
1714 { 1.234321234321234e26L, "1.234321e+26" },
1715 { 1.234321234321234e27L, "1.234321e+27" },
1716 { 1.234321234321234e28L, "1.234321e+28" },
1717 { 1.234321234321234e29L, "1.234321e+29" },
1718 { 1.234321234321234e30L, "1.234321e+30" },
1719 { 1.234321234321234e31L, "1.234321e+31" },
1720 { 1.234321234321234e32L, "1.234321e+32" },
1721 { 1.234321234321234e33L, "1.234321e+33" },
1722 { 1.234321234321234e34L, "1.234321e+34" },
1723 { 1.234321234321234e35L, "1.234321e+35" },
1724 { 1.234321234321234e36L, "1.234321e+36" }
1727 for (k = 0; k < SIZEOF (data); k++)
1731 my_snprintf (result, sizeof (result), "%Le", data[k].value);
1732 ASSERT (strcmp (result, data[k].string) == 0);
1733 ASSERT (retval == strlen (result));
1737 { /* A negative number. */
1740 my_snprintf (result, sizeof (result), "%Le %d", -0.03125L, 33, 44, 55);
1741 ASSERT (strcmp (result, "-3.125000e-02 33") == 0);
1742 ASSERT (retval == strlen (result));
1745 { /* Positive zero. */
1748 my_snprintf (result, sizeof (result), "%Le %d", 0.0L, 33, 44, 55);
1749 ASSERT (strcmp (result, "0.000000e+00 33") == 0);
1750 ASSERT (retval == strlen (result));
1753 { /* Negative zero. */
1756 my_snprintf (result, sizeof (result), "%Le %d", -0.0L, 33, 44, 55);
1757 if (have_minus_zero ())
1758 ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
1759 ASSERT (retval == strlen (result));
1762 { /* Positive infinity. */
1765 my_snprintf (result, sizeof (result), "%Le %d", 1.0L / 0.0L, 33, 44, 55);
1766 ASSERT (strcmp (result, "inf 33") == 0
1767 || strcmp (result, "infinity 33") == 0);
1768 ASSERT (retval == strlen (result));
1771 { /* Negative infinity. */
1774 my_snprintf (result, sizeof (result), "%Le %d", -1.0L / 0.0L, 33, 44, 55);
1775 ASSERT (strcmp (result, "-inf 33") == 0
1776 || strcmp (result, "-infinity 33") == 0);
1777 ASSERT (retval == strlen (result));
1781 static long double zero = 0.0L;
1784 my_snprintf (result, sizeof (result), "%Le %d", zero / zero, 33, 44, 55);
1785 ASSERT (strlen (result) >= 3 + 3
1786 && strisnan (result, 0, strlen (result) - 3, 0)
1787 && strcmp (result + strlen (result) - 3, " 33") == 0);
1788 ASSERT (retval == strlen (result));
1794 my_snprintf (result, sizeof (result), "%15Le %d", 1.75L, 33, 44, 55);
1795 ASSERT (strcmp (result, " 1.750000e+00 33") == 0);
1796 ASSERT (retval == strlen (result));
1802 my_snprintf (result, sizeof (result), "%-15Le %d", 1.75L, 33, 44, 55);
1803 ASSERT (strcmp (result, "1.750000e+00 33") == 0);
1804 ASSERT (retval == strlen (result));
1807 { /* FLAG_SHOWSIGN. */
1810 my_snprintf (result, sizeof (result), "%+Le %d", 1.75L, 33, 44, 55);
1811 ASSERT (strcmp (result, "+1.750000e+00 33") == 0);
1812 ASSERT (retval == strlen (result));
1818 my_snprintf (result, sizeof (result), "% Le %d", 1.75L, 33, 44, 55);
1819 ASSERT (strcmp (result, " 1.750000e+00 33") == 0);
1820 ASSERT (retval == strlen (result));
1826 my_snprintf (result, sizeof (result), "%#Le %d", 1.75L, 33, 44, 55);
1827 ASSERT (strcmp (result, "1.750000e+00 33") == 0);
1828 ASSERT (retval == strlen (result));
1834 my_snprintf (result, sizeof (result), "%#.Le %d", 1.75L, 33, 44, 55);
1835 ASSERT (strcmp (result, "2.e+00 33") == 0);
1836 ASSERT (retval == strlen (result));
1842 my_snprintf (result, sizeof (result), "%#.Le %d", 9.75L, 33, 44, 55);
1843 ASSERT (strcmp (result, "1.e+01 33") == 0);
1844 ASSERT (retval == strlen (result));
1847 { /* FLAG_ZERO with finite number. */
1850 my_snprintf (result, sizeof (result), "%015Le %d", 1234.0L, 33, 44, 55);
1851 ASSERT (strcmp (result, "0001.234000e+03 33") == 0);
1852 ASSERT (retval == strlen (result));
1855 { /* FLAG_ZERO with infinite number. */
1858 my_snprintf (result, sizeof (result), "%015Le %d", -1.0L / 0.0L, 33, 44, 55);
1859 ASSERT (strcmp (result, " -inf 33") == 0
1860 || strcmp (result, " -infinity 33") == 0);
1861 ASSERT (retval == strlen (result));
1864 { /* FLAG_ZERO with NaN. */
1865 static long double zero = 0.0L;
1868 my_snprintf (result, sizeof (result), "%050Le %d", zero / zero, 33, 44, 55);
1869 ASSERT (strlen (result) == 50 + 3
1870 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1871 && strcmp (result + strlen (result) - 3, " 33") == 0);
1872 ASSERT (retval == strlen (result));
1878 my_snprintf (result, sizeof (result), "%.Le %d", 1234.0L, 33, 44, 55);
1879 ASSERT (strcmp (result, "1e+03 33") == 0);
1880 ASSERT (retval == strlen (result));
1883 /* Test the support of the %g format directive. */
1885 { /* A positive number. */
1888 my_snprintf (result, sizeof (result), "%g %d", 12.75, 33, 44, 55);
1889 ASSERT (strcmp (result, "12.75 33") == 0);
1890 ASSERT (retval == strlen (result));
1893 { /* A larger positive number. */
1896 my_snprintf (result, sizeof (result), "%g %d", 1234567.0, 33, 44, 55);
1897 ASSERT (strcmp (result, "1.23457e+06 33") == 0
1898 || strcmp (result, "1.23457e+006 33") == 0);
1899 ASSERT (retval == strlen (result));
1902 { /* Small and large positive numbers. */
1903 static struct { double value; const char *string; } data[] =
1905 { 1.234321234321234e-37, "1.23432e-37" },
1906 { 1.234321234321234e-36, "1.23432e-36" },
1907 { 1.234321234321234e-35, "1.23432e-35" },
1908 { 1.234321234321234e-34, "1.23432e-34" },
1909 { 1.234321234321234e-33, "1.23432e-33" },
1910 { 1.234321234321234e-32, "1.23432e-32" },
1911 { 1.234321234321234e-31, "1.23432e-31" },
1912 { 1.234321234321234e-30, "1.23432e-30" },
1913 { 1.234321234321234e-29, "1.23432e-29" },
1914 { 1.234321234321234e-28, "1.23432e-28" },
1915 { 1.234321234321234e-27, "1.23432e-27" },
1916 { 1.234321234321234e-26, "1.23432e-26" },
1917 { 1.234321234321234e-25, "1.23432e-25" },
1918 { 1.234321234321234e-24, "1.23432e-24" },
1919 { 1.234321234321234e-23, "1.23432e-23" },
1920 { 1.234321234321234e-22, "1.23432e-22" },
1921 { 1.234321234321234e-21, "1.23432e-21" },
1922 { 1.234321234321234e-20, "1.23432e-20" },
1923 { 1.234321234321234e-19, "1.23432e-19" },
1924 { 1.234321234321234e-18, "1.23432e-18" },
1925 { 1.234321234321234e-17, "1.23432e-17" },
1926 { 1.234321234321234e-16, "1.23432e-16" },
1927 { 1.234321234321234e-15, "1.23432e-15" },
1928 { 1.234321234321234e-14, "1.23432e-14" },
1929 { 1.234321234321234e-13, "1.23432e-13" },
1930 { 1.234321234321234e-12, "1.23432e-12" },
1931 { 1.234321234321234e-11, "1.23432e-11" },
1932 { 1.234321234321234e-10, "1.23432e-10" },
1933 { 1.234321234321234e-9, "1.23432e-09" },
1934 { 1.234321234321234e-8, "1.23432e-08" },
1935 { 1.234321234321234e-7, "1.23432e-07" },
1936 { 1.234321234321234e-6, "1.23432e-06" },
1937 { 1.234321234321234e-5, "1.23432e-05" },
1938 { 1.234321234321234e-4, "0.000123432" },
1939 { 1.234321234321234e-3, "0.00123432" },
1940 { 1.234321234321234e-2, "0.0123432" },
1941 { 1.234321234321234e-1, "0.123432" },
1942 { 1.234321234321234, "1.23432" },
1943 { 1.234321234321234e1, "12.3432" },
1944 { 1.234321234321234e2, "123.432" },
1945 { 1.234321234321234e3, "1234.32" },
1946 { 1.234321234321234e4, "12343.2" },
1947 { 1.234321234321234e5, "123432" },
1948 { 1.234321234321234e6, "1.23432e+06" },
1949 { 1.234321234321234e7, "1.23432e+07" },
1950 { 1.234321234321234e8, "1.23432e+08" },
1951 { 1.234321234321234e9, "1.23432e+09" },
1952 { 1.234321234321234e10, "1.23432e+10" },
1953 { 1.234321234321234e11, "1.23432e+11" },
1954 { 1.234321234321234e12, "1.23432e+12" },
1955 { 1.234321234321234e13, "1.23432e+13" },
1956 { 1.234321234321234e14, "1.23432e+14" },
1957 { 1.234321234321234e15, "1.23432e+15" },
1958 { 1.234321234321234e16, "1.23432e+16" },
1959 { 1.234321234321234e17, "1.23432e+17" },
1960 { 1.234321234321234e18, "1.23432e+18" },
1961 { 1.234321234321234e19, "1.23432e+19" },
1962 { 1.234321234321234e20, "1.23432e+20" },
1963 { 1.234321234321234e21, "1.23432e+21" },
1964 { 1.234321234321234e22, "1.23432e+22" },
1965 { 1.234321234321234e23, "1.23432e+23" },
1966 { 1.234321234321234e24, "1.23432e+24" },
1967 { 1.234321234321234e25, "1.23432e+25" },
1968 { 1.234321234321234e26, "1.23432e+26" },
1969 { 1.234321234321234e27, "1.23432e+27" },
1970 { 1.234321234321234e28, "1.23432e+28" },
1971 { 1.234321234321234e29, "1.23432e+29" },
1972 { 1.234321234321234e30, "1.23432e+30" },
1973 { 1.234321234321234e31, "1.23432e+31" },
1974 { 1.234321234321234e32, "1.23432e+32" },
1975 { 1.234321234321234e33, "1.23432e+33" },
1976 { 1.234321234321234e34, "1.23432e+34" },
1977 { 1.234321234321234e35, "1.23432e+35" },
1978 { 1.234321234321234e36, "1.23432e+36" }
1981 for (k = 0; k < SIZEOF (data); k++)
1985 my_snprintf (result, sizeof (result), "%g", data[k].value);
1986 const char *expected = data[k].string;
1987 ASSERT (strcmp (result, expected) == 0
1988 /* Some implementations produce exponents with 3 digits. */
1989 || (expected[strlen (expected) - 4] == 'e'
1990 && strlen (result) == strlen (expected) + 1
1991 && memcmp (result, expected, strlen (expected) - 2) == 0
1992 && result[strlen (expected) - 2] == '0'
1993 && strcmp (result + strlen (expected) - 1,
1994 expected + strlen (expected) - 2)
1996 ASSERT (retval == strlen (result));
2000 { /* A negative number. */
2003 my_snprintf (result, sizeof (result), "%g %d", -0.03125, 33, 44, 55);
2004 ASSERT (strcmp (result, "-0.03125 33") == 0);
2005 ASSERT (retval == strlen (result));
2008 { /* Positive zero. */
2011 my_snprintf (result, sizeof (result), "%g %d", 0.0, 33, 44, 55);
2012 ASSERT (strcmp (result, "0 33") == 0);
2013 ASSERT (retval == strlen (result));
2016 { /* Negative zero. */
2019 my_snprintf (result, sizeof (result), "%g %d", -0.0, 33, 44, 55);
2020 if (have_minus_zero ())
2021 ASSERT (strcmp (result, "-0 33") == 0);
2022 ASSERT (retval == strlen (result));
2025 { /* Positive infinity. */
2028 my_snprintf (result, sizeof (result), "%g %d", 1.0 / 0.0, 33, 44, 55);
2029 ASSERT (strcmp (result, "inf 33") == 0
2030 || strcmp (result, "infinity 33") == 0);
2031 ASSERT (retval == strlen (result));
2034 { /* Negative infinity. */
2037 my_snprintf (result, sizeof (result), "%g %d", -1.0 / 0.0, 33, 44, 55);
2038 ASSERT (strcmp (result, "-inf 33") == 0
2039 || strcmp (result, "-infinity 33") == 0);
2040 ASSERT (retval == strlen (result));
2046 my_snprintf (result, sizeof (result), "%g %d", NaN (), 33, 44, 55);
2047 ASSERT (strlen (result) >= 3 + 3
2048 && strisnan (result, 0, strlen (result) - 3, 0)
2049 && strcmp (result + strlen (result) - 3, " 33") == 0);
2050 ASSERT (retval == strlen (result));
2056 my_snprintf (result, sizeof (result), "%10g %d", 1.75, 33, 44, 55);
2057 ASSERT (strcmp (result, " 1.75 33") == 0);
2058 ASSERT (retval == strlen (result));
2064 my_snprintf (result, sizeof (result), "%-10g %d", 1.75, 33, 44, 55);
2065 ASSERT (strcmp (result, "1.75 33") == 0);
2066 ASSERT (retval == strlen (result));
2069 { /* FLAG_SHOWSIGN. */
2072 my_snprintf (result, sizeof (result), "%+g %d", 1.75, 33, 44, 55);
2073 ASSERT (strcmp (result, "+1.75 33") == 0);
2074 ASSERT (retval == strlen (result));
2080 my_snprintf (result, sizeof (result), "% g %d", 1.75, 33, 44, 55);
2081 ASSERT (strcmp (result, " 1.75 33") == 0);
2082 ASSERT (retval == strlen (result));
2088 my_snprintf (result, sizeof (result), "%#g %d", 1.75, 33, 44, 55);
2089 ASSERT (strcmp (result, "1.75000 33") == 0);
2090 ASSERT (retval == strlen (result));
2096 my_snprintf (result, sizeof (result), "%#.g %d", 1.75, 33, 44, 55);
2097 ASSERT (strcmp (result, "2. 33") == 0);
2098 ASSERT (retval == strlen (result));
2104 my_snprintf (result, sizeof (result), "%#.g %d", 9.75, 33, 44, 55);
2105 ASSERT (strcmp (result, "1.e+01 33") == 0
2106 || strcmp (result, "1.e+001 33") == 0);
2107 ASSERT (retval == strlen (result));
2110 { /* FLAG_ZERO with finite number. */
2113 my_snprintf (result, sizeof (result), "%010g %d", 1234.0, 33, 44, 55);
2114 ASSERT (strcmp (result, "0000001234 33") == 0);
2115 ASSERT (retval == strlen (result));
2118 { /* FLAG_ZERO with infinite number. */
2121 my_snprintf (result, sizeof (result), "%015g %d", -1.0 / 0.0, 33, 44, 55);
2122 ASSERT (strcmp (result, " -inf 33") == 0
2123 || strcmp (result, " -infinity 33") == 0);
2124 ASSERT (retval == strlen (result));
2127 { /* FLAG_ZERO with NaN. */
2130 my_snprintf (result, sizeof (result), "%050g %d", NaN (), 33, 44, 55);
2131 ASSERT (strlen (result) == 50 + 3
2132 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2133 && strcmp (result + strlen (result) - 3, " 33") == 0);
2134 ASSERT (retval == strlen (result));
2140 my_snprintf (result, sizeof (result), "%.g %d", 1234.0, 33, 44, 55);
2141 ASSERT (strcmp (result, "1e+03 33") == 0
2142 || strcmp (result, "1e+003 33") == 0);
2143 ASSERT (retval == strlen (result));
2146 { /* A positive number. */
2149 my_snprintf (result, sizeof (result), "%Lg %d", 12.75L, 33, 44, 55);
2150 ASSERT (strcmp (result, "12.75 33") == 0);
2151 ASSERT (retval == strlen (result));
2154 { /* A larger positive number. */
2157 my_snprintf (result, sizeof (result), "%Lg %d", 1234567.0L, 33, 44, 55);
2158 ASSERT (strcmp (result, "1.23457e+06 33") == 0);
2159 ASSERT (retval == strlen (result));
2162 { /* Small and large positive numbers. */
2163 static struct { long double value; const char *string; } data[] =
2165 { 1.234321234321234e-37L, "1.23432e-37" },
2166 { 1.234321234321234e-36L, "1.23432e-36" },
2167 { 1.234321234321234e-35L, "1.23432e-35" },
2168 { 1.234321234321234e-34L, "1.23432e-34" },
2169 { 1.234321234321234e-33L, "1.23432e-33" },
2170 { 1.234321234321234e-32L, "1.23432e-32" },
2171 { 1.234321234321234e-31L, "1.23432e-31" },
2172 { 1.234321234321234e-30L, "1.23432e-30" },
2173 { 1.234321234321234e-29L, "1.23432e-29" },
2174 { 1.234321234321234e-28L, "1.23432e-28" },
2175 { 1.234321234321234e-27L, "1.23432e-27" },
2176 { 1.234321234321234e-26L, "1.23432e-26" },
2177 { 1.234321234321234e-25L, "1.23432e-25" },
2178 { 1.234321234321234e-24L, "1.23432e-24" },
2179 { 1.234321234321234e-23L, "1.23432e-23" },
2180 { 1.234321234321234e-22L, "1.23432e-22" },
2181 { 1.234321234321234e-21L, "1.23432e-21" },
2182 { 1.234321234321234e-20L, "1.23432e-20" },
2183 { 1.234321234321234e-19L, "1.23432e-19" },
2184 { 1.234321234321234e-18L, "1.23432e-18" },
2185 { 1.234321234321234e-17L, "1.23432e-17" },
2186 { 1.234321234321234e-16L, "1.23432e-16" },
2187 { 1.234321234321234e-15L, "1.23432e-15" },
2188 { 1.234321234321234e-14L, "1.23432e-14" },
2189 { 1.234321234321234e-13L, "1.23432e-13" },
2190 { 1.234321234321234e-12L, "1.23432e-12" },
2191 { 1.234321234321234e-11L, "1.23432e-11" },
2192 { 1.234321234321234e-10L, "1.23432e-10" },
2193 { 1.234321234321234e-9L, "1.23432e-09" },
2194 { 1.234321234321234e-8L, "1.23432e-08" },
2195 { 1.234321234321234e-7L, "1.23432e-07" },
2196 { 1.234321234321234e-6L, "1.23432e-06" },
2197 { 1.234321234321234e-5L, "1.23432e-05" },
2198 { 1.234321234321234e-4L, "0.000123432" },
2199 { 1.234321234321234e-3L, "0.00123432" },
2200 { 1.234321234321234e-2L, "0.0123432" },
2201 { 1.234321234321234e-1L, "0.123432" },
2202 { 1.234321234321234L, "1.23432" },
2203 { 1.234321234321234e1L, "12.3432" },
2204 { 1.234321234321234e2L, "123.432" },
2205 { 1.234321234321234e3L, "1234.32" },
2206 { 1.234321234321234e4L, "12343.2" },
2207 { 1.234321234321234e5L, "123432" },
2208 { 1.234321234321234e6L, "1.23432e+06" },
2209 { 1.234321234321234e7L, "1.23432e+07" },
2210 { 1.234321234321234e8L, "1.23432e+08" },
2211 { 1.234321234321234e9L, "1.23432e+09" },
2212 { 1.234321234321234e10L, "1.23432e+10" },
2213 { 1.234321234321234e11L, "1.23432e+11" },
2214 { 1.234321234321234e12L, "1.23432e+12" },
2215 { 1.234321234321234e13L, "1.23432e+13" },
2216 { 1.234321234321234e14L, "1.23432e+14" },
2217 { 1.234321234321234e15L, "1.23432e+15" },
2218 { 1.234321234321234e16L, "1.23432e+16" },
2219 { 1.234321234321234e17L, "1.23432e+17" },
2220 { 1.234321234321234e18L, "1.23432e+18" },
2221 { 1.234321234321234e19L, "1.23432e+19" },
2222 { 1.234321234321234e20L, "1.23432e+20" },
2223 { 1.234321234321234e21L, "1.23432e+21" },
2224 { 1.234321234321234e22L, "1.23432e+22" },
2225 { 1.234321234321234e23L, "1.23432e+23" },
2226 { 1.234321234321234e24L, "1.23432e+24" },
2227 { 1.234321234321234e25L, "1.23432e+25" },
2228 { 1.234321234321234e26L, "1.23432e+26" },
2229 { 1.234321234321234e27L, "1.23432e+27" },
2230 { 1.234321234321234e28L, "1.23432e+28" },
2231 { 1.234321234321234e29L, "1.23432e+29" },
2232 { 1.234321234321234e30L, "1.23432e+30" },
2233 { 1.234321234321234e31L, "1.23432e+31" },
2234 { 1.234321234321234e32L, "1.23432e+32" },
2235 { 1.234321234321234e33L, "1.23432e+33" },
2236 { 1.234321234321234e34L, "1.23432e+34" },
2237 { 1.234321234321234e35L, "1.23432e+35" },
2238 { 1.234321234321234e36L, "1.23432e+36" }
2241 for (k = 0; k < SIZEOF (data); k++)
2245 my_snprintf (result, sizeof (result), "%Lg", data[k].value);
2246 ASSERT (strcmp (result, data[k].string) == 0);
2247 ASSERT (retval == strlen (result));
2251 { /* A negative number. */
2254 my_snprintf (result, sizeof (result), "%Lg %d", -0.03125L, 33, 44, 55);
2255 ASSERT (strcmp (result, "-0.03125 33") == 0);
2256 ASSERT (retval == strlen (result));
2259 { /* Positive zero. */
2262 my_snprintf (result, sizeof (result), "%Lg %d", 0.0L, 33, 44, 55);
2263 ASSERT (strcmp (result, "0 33") == 0);
2264 ASSERT (retval == strlen (result));
2267 { /* Negative zero. */
2270 my_snprintf (result, sizeof (result), "%Lg %d", -0.0L, 33, 44, 55);
2271 if (have_minus_zero ())
2272 ASSERT (strcmp (result, "-0 33") == 0);
2273 ASSERT (retval == strlen (result));
2276 { /* Positive infinity. */
2279 my_snprintf (result, sizeof (result), "%Lg %d", 1.0L / 0.0L, 33, 44, 55);
2280 ASSERT (strcmp (result, "inf 33") == 0
2281 || strcmp (result, "infinity 33") == 0);
2282 ASSERT (retval == strlen (result));
2285 { /* Negative infinity. */
2288 my_snprintf (result, sizeof (result), "%Lg %d", -1.0L / 0.0L, 33, 44, 55);
2289 ASSERT (strcmp (result, "-inf 33") == 0
2290 || strcmp (result, "-infinity 33") == 0);
2291 ASSERT (retval == strlen (result));
2295 static long double zero = 0.0L;
2298 my_snprintf (result, sizeof (result), "%Lg %d", zero / zero, 33, 44, 55);
2299 ASSERT (strlen (result) >= 3 + 3
2300 && strisnan (result, 0, strlen (result) - 3, 0)
2301 && strcmp (result + strlen (result) - 3, " 33") == 0);
2302 ASSERT (retval == strlen (result));
2308 my_snprintf (result, sizeof (result), "%10Lg %d", 1.75L, 33, 44, 55);
2309 ASSERT (strcmp (result, " 1.75 33") == 0);
2310 ASSERT (retval == strlen (result));
2316 my_snprintf (result, sizeof (result), "%-10Lg %d", 1.75L, 33, 44, 55);
2317 ASSERT (strcmp (result, "1.75 33") == 0);
2318 ASSERT (retval == strlen (result));
2321 { /* FLAG_SHOWSIGN. */
2324 my_snprintf (result, sizeof (result), "%+Lg %d", 1.75L, 33, 44, 55);
2325 ASSERT (strcmp (result, "+1.75 33") == 0);
2326 ASSERT (retval == strlen (result));
2332 my_snprintf (result, sizeof (result), "% Lg %d", 1.75L, 33, 44, 55);
2333 ASSERT (strcmp (result, " 1.75 33") == 0);
2334 ASSERT (retval == strlen (result));
2340 my_snprintf (result, sizeof (result), "%#Lg %d", 1.75L, 33, 44, 55);
2341 ASSERT (strcmp (result, "1.75000 33") == 0);
2342 ASSERT (retval == strlen (result));
2348 my_snprintf (result, sizeof (result), "%#.Lg %d", 1.75L, 33, 44, 55);
2349 ASSERT (strcmp (result, "2. 33") == 0);
2350 ASSERT (retval == strlen (result));
2356 my_snprintf (result, sizeof (result), "%#.Lg %d", 9.75L, 33, 44, 55);
2357 ASSERT (strcmp (result, "1.e+01 33") == 0);
2358 ASSERT (retval == strlen (result));
2361 { /* FLAG_ZERO with finite number. */
2364 my_snprintf (result, sizeof (result), "%010Lg %d", 1234.0L, 33, 44, 55);
2365 ASSERT (strcmp (result, "0000001234 33") == 0);
2366 ASSERT (retval == strlen (result));
2369 { /* FLAG_ZERO with infinite number. */
2372 my_snprintf (result, sizeof (result), "%015Lg %d", -1.0L / 0.0L, 33, 44, 55);
2373 ASSERT (strcmp (result, " -inf 33") == 0
2374 || strcmp (result, " -infinity 33") == 0);
2375 ASSERT (retval == strlen (result));
2378 { /* FLAG_ZERO with NaN. */
2379 static long double zero = 0.0L;
2382 my_snprintf (result, sizeof (result), "%050Lg %d", zero / zero, 33, 44, 55);
2383 ASSERT (strlen (result) == 50 + 3
2384 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2385 && strcmp (result + strlen (result) - 3, " 33") == 0);
2386 ASSERT (retval == strlen (result));
2392 my_snprintf (result, sizeof (result), "%.Lg %d", 1234.0L, 33, 44, 55);
2393 ASSERT (strcmp (result, "1e+03 33") == 0);
2394 ASSERT (retval == strlen (result));
2397 /* Test the support of the %n format directive. */
2403 my_snprintf (result, sizeof (result), "%d %n", 123, &count, 33, 44, 55);
2404 ASSERT (strcmp (result, "123 ") == 0);
2405 ASSERT (retval == strlen (result));
2406 ASSERT (count == 4);
2409 /* Test the support of the POSIX/XSI format strings with positions. */
2414 my_snprintf (result, sizeof (result), "%2$d %1$d", 33, 55);
2415 ASSERT (strcmp (result, "55 33") == 0);
2416 ASSERT (retval == strlen (result));
2419 /* Test the support of the grouping flag. */
2424 my_snprintf (result, sizeof (result), "%'d %d", 1234567, 99);
2425 ASSERT (result[strlen (result) - 1] == '9');
2426 ASSERT (retval == strlen (result));