1 /* Test of POSIX compatible vasprintf() and asprintf() 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. */
33 #define ASSERT(expr) \
38 fprintf (stderr, "%s:%d: assertion failed\n", __FILE__, __LINE__); \
44 /* The Compaq (ex-DEC) C 6.4 compiler chokes on the expression 0.0 / 0.0. */
49 static double zero = 0.0;
53 # define NaN() (0.0 / 0.0)
57 test_function (int (*my_asprintf) (char **, const char *, ...))
61 /* Test return value convention. */
63 for (repeat = 0; repeat <= 8; repeat++)
66 int retval = asprintf (&result, "%d", 12345);
68 ASSERT (result != NULL);
69 ASSERT (strcmp (result, "12345") == 0);
73 /* Test support of size specifiers as in C99. */
78 my_asprintf (&result, "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
79 ASSERT (result != NULL);
80 ASSERT (strcmp (result, "12345671 33") == 0);
81 ASSERT (retval == strlen (result));
88 my_asprintf (&result, "%zu %d", (size_t) 12345672, 33, 44, 55);
89 ASSERT (result != NULL);
90 ASSERT (strcmp (result, "12345672 33") == 0);
91 ASSERT (retval == strlen (result));
98 my_asprintf (&result, "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
99 ASSERT (result != NULL);
100 ASSERT (strcmp (result, "12345673 33") == 0);
101 ASSERT (retval == strlen (result));
108 my_asprintf (&result, "%Lg %d", (long double) 1.5, 33, 44, 55);
109 ASSERT (result != NULL);
110 ASSERT (strcmp (result, "1.5 33") == 0);
111 ASSERT (retval == strlen (result));
115 /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
116 output of floating-point numbers. */
118 { /* A positive number. */
121 my_asprintf (&result, "%a %d", 3.1416015625, 33, 44, 55);
122 ASSERT (result != NULL);
123 ASSERT (strcmp (result, "0x1.922p+1 33") == 0
124 || strcmp (result, "0x3.244p+0 33") == 0
125 || strcmp (result, "0x6.488p-1 33") == 0
126 || strcmp (result, "0xc.91p-2 33") == 0);
127 ASSERT (retval == strlen (result));
131 { /* A negative number. */
134 my_asprintf (&result, "%A %d", -3.1416015625, 33, 44, 55);
135 ASSERT (result != NULL);
136 ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
137 || strcmp (result, "-0X3.244P+0 33") == 0
138 || strcmp (result, "-0X6.488P-1 33") == 0
139 || strcmp (result, "-0XC.91P-2 33") == 0);
140 ASSERT (retval == strlen (result));
144 { /* Positive zero. */
147 my_asprintf (&result, "%a %d", 0.0, 33, 44, 55);
148 ASSERT (result != NULL);
149 ASSERT (strcmp (result, "0x0p+0 33") == 0);
150 ASSERT (retval == strlen (result));
154 { /* Negative zero. */
157 my_asprintf (&result, "%a %d", -0.0, 33, 44, 55);
158 ASSERT (result != NULL);
159 ASSERT (strcmp (result, "-0x0p+0 33") == 0);
160 ASSERT (retval == strlen (result));
164 { /* Positive infinity. */
167 my_asprintf (&result, "%a %d", 1.0 / 0.0, 33, 44, 55);
168 ASSERT (result != NULL);
169 ASSERT (strcmp (result, "inf 33") == 0);
170 ASSERT (retval == strlen (result));
174 { /* Negative infinity. */
177 my_asprintf (&result, "%a %d", -1.0 / 0.0, 33, 44, 55);
178 ASSERT (result != NULL);
179 ASSERT (strcmp (result, "-inf 33") == 0);
180 ASSERT (retval == strlen (result));
187 my_asprintf (&result, "%a %d", NaN (), 33, 44, 55);
188 ASSERT (result != NULL);
189 ASSERT (strcmp (result, "nan 33") == 0);
190 ASSERT (retval == strlen (result));
194 { /* Rounding near the decimal point. */
197 my_asprintf (&result, "%.0a %d", 1.5, 33, 44, 55);
198 ASSERT (result != NULL);
199 ASSERT (strcmp (result, "0x2p+0 33") == 0
200 || strcmp (result, "0x3p-1 33") == 0
201 || strcmp (result, "0x6p-2 33") == 0
202 || strcmp (result, "0xcp-3 33") == 0);
203 ASSERT (retval == strlen (result));
207 { /* Rounding with precision 0. */
210 my_asprintf (&result, "%.0a %d", 1.51, 33, 44, 55);
211 ASSERT (result != NULL);
212 ASSERT (strcmp (result, "0x2p+0 33") == 0
213 || strcmp (result, "0x3p-1 33") == 0
214 || strcmp (result, "0x6p-2 33") == 0
215 || strcmp (result, "0xcp-3 33") == 0);
216 ASSERT (retval == strlen (result));
220 { /* Rounding with precision 1. */
223 my_asprintf (&result, "%.1a %d", 1.51, 33, 44, 55);
224 ASSERT (result != NULL);
225 ASSERT (strcmp (result, "0x1.8p+0 33") == 0
226 || strcmp (result, "0x3.0p-1 33") == 0
227 || strcmp (result, "0x6.1p-2 33") == 0
228 || strcmp (result, "0xc.1p-3 33") == 0);
229 ASSERT (retval == strlen (result));
233 { /* Rounding with precision 2. */
236 my_asprintf (&result, "%.2a %d", 1.51, 33, 44, 55);
237 ASSERT (result != NULL);
238 ASSERT (strcmp (result, "0x1.83p+0 33") == 0
239 || strcmp (result, "0x3.05p-1 33") == 0
240 || strcmp (result, "0x6.0ap-2 33") == 0
241 || strcmp (result, "0xc.14p-3 33") == 0);
242 ASSERT (retval == strlen (result));
246 { /* Rounding with precision 3. */
249 my_asprintf (&result, "%.3a %d", 1.51, 33, 44, 55);
250 ASSERT (result != NULL);
251 ASSERT (strcmp (result, "0x1.829p+0 33") == 0
252 || strcmp (result, "0x3.052p-1 33") == 0
253 || strcmp (result, "0x6.0a4p-2 33") == 0
254 || strcmp (result, "0xc.148p-3 33") == 0);
255 ASSERT (retval == strlen (result));
259 { /* Rounding can turn a ...FFF into a ...000. */
262 my_asprintf (&result, "%.3a %d", 1.49999, 33, 44, 55);
263 ASSERT (result != NULL);
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));
272 { /* Rounding can turn a ...FFF into a ...000.
273 This shows a MacOS X 10.3.9 (Darwin 7.9) bug. */
276 my_asprintf (&result, "%.1a %d", 1.999, 33, 44, 55);
277 ASSERT (result != NULL);
278 ASSERT (strcmp (result, "0x1.0p+1 33") == 0
279 || strcmp (result, "0x2.0p+0 33") == 0
280 || strcmp (result, "0x4.0p-1 33") == 0
281 || strcmp (result, "0x8.0p-2 33") == 0);
282 ASSERT (retval == strlen (result));
289 my_asprintf (&result, "%10a %d", 1.75, 33, 44, 55);
290 ASSERT (result != NULL);
291 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
292 || strcmp (result, " 0x3.8p-1 33") == 0
293 || strcmp (result, " 0x7p-2 33") == 0
294 || strcmp (result, " 0xep-3 33") == 0);
295 ASSERT (retval == strlen (result));
299 { /* Small precision. */
302 my_asprintf (&result, "%.10a %d", 1.75, 33, 44, 55);
303 ASSERT (result != NULL);
304 ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
305 || strcmp (result, "0x3.8000000000p-1 33") == 0
306 || strcmp (result, "0x7.0000000000p-2 33") == 0
307 || strcmp (result, "0xe.0000000000p-3 33") == 0);
308 ASSERT (retval == strlen (result));
312 { /* Large precision. */
315 my_asprintf (&result, "%.50a %d", 1.75, 33, 44, 55);
316 ASSERT (result != NULL);
317 ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
318 || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
319 || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
320 || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
321 ASSERT (retval == strlen (result));
328 my_asprintf (&result, "%-10a %d", 1.75, 33, 44, 55);
329 ASSERT (result != NULL);
330 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
331 || strcmp (result, "0x3.8p-1 33") == 0
332 || strcmp (result, "0x7p-2 33") == 0
333 || strcmp (result, "0xep-3 33") == 0);
334 ASSERT (retval == strlen (result));
338 { /* FLAG_SHOWSIGN. */
341 my_asprintf (&result, "%+a %d", 1.75, 33, 44, 55);
342 ASSERT (result != NULL);
343 ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
344 || strcmp (result, "+0x3.8p-1 33") == 0
345 || strcmp (result, "+0x7p-2 33") == 0
346 || strcmp (result, "+0xep-3 33") == 0);
347 ASSERT (retval == strlen (result));
354 my_asprintf (&result, "% a %d", 1.75, 33, 44, 55);
355 ASSERT (result != NULL);
356 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
357 || strcmp (result, " 0x3.8p-1 33") == 0
358 || strcmp (result, " 0x7p-2 33") == 0
359 || strcmp (result, " 0xep-3 33") == 0);
360 ASSERT (retval == strlen (result));
367 my_asprintf (&result, "%#a %d", 1.75, 33, 44, 55);
368 ASSERT (result != NULL);
369 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
370 || strcmp (result, "0x3.8p-1 33") == 0
371 || strcmp (result, "0x7.p-2 33") == 0
372 || strcmp (result, "0xe.p-3 33") == 0);
373 ASSERT (retval == strlen (result));
380 my_asprintf (&result, "%#a %d", 1.0, 33, 44, 55);
381 ASSERT (result != NULL);
382 ASSERT (strcmp (result, "0x1.p+0 33") == 0
383 || strcmp (result, "0x2.p-1 33") == 0
384 || strcmp (result, "0x4.p-2 33") == 0
385 || strcmp (result, "0x8.p-3 33") == 0);
386 ASSERT (retval == strlen (result));
390 { /* FLAG_ZERO with finite number. */
393 my_asprintf (&result, "%010a %d", 1.75, 33, 44, 55);
394 ASSERT (result != NULL);
395 ASSERT (strcmp (result, "0x001.cp+0 33") == 0
396 || strcmp (result, "0x003.8p-1 33") == 0
397 || strcmp (result, "0x00007p-2 33") == 0
398 || strcmp (result, "0x0000ep-3 33") == 0);
399 ASSERT (retval == strlen (result));
403 { /* FLAG_ZERO with infinite number. */
406 my_asprintf (&result, "%010a %d", 1.0 / 0.0, 33, 44, 55);
407 ASSERT (result != NULL);
408 /* "0000000inf 33" is not a valid result; see
409 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
410 ASSERT (strcmp (result, " inf 33") == 0);
411 ASSERT (retval == strlen (result));
415 { /* FLAG_ZERO with NaN. */
418 my_asprintf (&result, "%010a %d", NaN (), 33, 44, 55);
419 ASSERT (result != NULL);
420 /* "0000000nan 33" is not a valid result; see
421 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
422 ASSERT (strcmp (result, " nan 33") == 0);
423 ASSERT (retval == strlen (result));
427 { /* A positive number. */
430 my_asprintf (&result, "%La %d", 3.1416015625L, 33, 44, 55);
431 ASSERT (result != NULL);
432 ASSERT (strcmp (result, "0x1.922p+1 33") == 0
433 || strcmp (result, "0x3.244p+0 33") == 0
434 || strcmp (result, "0x6.488p-1 33") == 0
435 || strcmp (result, "0xc.91p-2 33") == 0);
436 ASSERT (retval == strlen (result));
440 { /* A negative number. */
443 my_asprintf (&result, "%LA %d", -3.1416015625L, 33, 44, 55);
444 ASSERT (result != NULL);
445 ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
446 || strcmp (result, "-0X3.244P+0 33") == 0
447 || strcmp (result, "-0X6.488P-1 33") == 0
448 || strcmp (result, "-0XC.91P-2 33") == 0);
449 ASSERT (retval == strlen (result));
453 { /* Positive zero. */
456 my_asprintf (&result, "%La %d", 0.0L, 33, 44, 55);
457 ASSERT (result != NULL);
458 ASSERT (strcmp (result, "0x0p+0 33") == 0);
459 ASSERT (retval == strlen (result));
463 { /* Negative zero. */
466 my_asprintf (&result, "%La %d", -0.0L, 33, 44, 55);
467 ASSERT (result != NULL);
468 ASSERT (strcmp (result, "-0x0p+0 33") == 0);
469 ASSERT (retval == strlen (result));
473 { /* Positive infinity. */
476 my_asprintf (&result, "%La %d", 1.0L / 0.0L, 33, 44, 55);
477 ASSERT (result != NULL);
478 ASSERT (strcmp (result, "inf 33") == 0);
479 ASSERT (retval == strlen (result));
483 { /* Negative infinity. */
486 my_asprintf (&result, "%La %d", -1.0L / 0.0L, 33, 44, 55);
487 ASSERT (result != NULL);
488 ASSERT (strcmp (result, "-inf 33") == 0);
489 ASSERT (retval == strlen (result));
496 my_asprintf (&result, "%La %d", 0.0L / 0.0L, 33, 44, 55);
497 ASSERT (result != NULL);
498 ASSERT (strcmp (result, "nan 33") == 0);
499 ASSERT (retval == strlen (result));
503 { /* Rounding near the decimal point. */
506 my_asprintf (&result, "%.0La %d", 1.5L, 33, 44, 55);
507 ASSERT (result != NULL);
508 ASSERT (strcmp (result, "0x2p+0 33") == 0
509 || strcmp (result, "0x3p-1 33") == 0
510 || strcmp (result, "0x6p-2 33") == 0
511 || strcmp (result, "0xcp-3 33") == 0);
512 ASSERT (retval == strlen (result));
516 { /* Rounding with precision 0. */
519 my_asprintf (&result, "%.0La %d", 1.51L, 33, 44, 55);
520 ASSERT (result != NULL);
521 ASSERT (strcmp (result, "0x2p+0 33") == 0
522 || strcmp (result, "0x3p-1 33") == 0
523 || strcmp (result, "0x6p-2 33") == 0
524 || strcmp (result, "0xcp-3 33") == 0);
525 ASSERT (retval == strlen (result));
529 { /* Rounding with precision 1. */
532 my_asprintf (&result, "%.1La %d", 1.51L, 33, 44, 55);
533 ASSERT (result != NULL);
534 ASSERT (strcmp (result, "0x1.8p+0 33") == 0
535 || strcmp (result, "0x3.0p-1 33") == 0
536 || strcmp (result, "0x6.1p-2 33") == 0
537 || strcmp (result, "0xc.1p-3 33") == 0);
538 ASSERT (retval == strlen (result));
542 { /* Rounding with precision 2. */
545 my_asprintf (&result, "%.2La %d", 1.51L, 33, 44, 55);
546 ASSERT (result != NULL);
547 ASSERT (strcmp (result, "0x1.83p+0 33") == 0
548 || strcmp (result, "0x3.05p-1 33") == 0
549 || strcmp (result, "0x6.0ap-2 33") == 0
550 || strcmp (result, "0xc.14p-3 33") == 0);
551 ASSERT (retval == strlen (result));
555 { /* Rounding with precision 3. */
558 my_asprintf (&result, "%.3La %d", 1.51L, 33, 44, 55);
559 ASSERT (result != NULL);
560 ASSERT (strcmp (result, "0x1.829p+0 33") == 0
561 || strcmp (result, "0x3.052p-1 33") == 0
562 || strcmp (result, "0x6.0a4p-2 33") == 0
563 || strcmp (result, "0xc.148p-3 33") == 0);
564 ASSERT (retval == strlen (result));
568 { /* Rounding can turn a ...FFF into a ...000. */
571 my_asprintf (&result, "%.3La %d", 1.49999L, 33, 44, 55);
572 ASSERT (result != NULL);
573 ASSERT (strcmp (result, "0x1.800p+0 33") == 0
574 || strcmp (result, "0x3.000p-1 33") == 0
575 || strcmp (result, "0x6.000p-2 33") == 0
576 || strcmp (result, "0xc.000p-3 33") == 0);
577 ASSERT (retval == strlen (result));
581 { /* Rounding can turn a ...FFF into a ...000.
582 This shows a MacOS X 10.3.9 (Darwin 7.9) bug and a
583 glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>. */
586 my_asprintf (&result, "%.1La %d", 1.999L, 33, 44, 55);
587 ASSERT (result != NULL);
588 ASSERT (strcmp (result, "0x1.0p+1 33") == 0
589 || strcmp (result, "0x2.0p+0 33") == 0
590 || strcmp (result, "0x4.0p-1 33") == 0
591 || strcmp (result, "0x8.0p-2 33") == 0);
592 ASSERT (retval == strlen (result));
599 my_asprintf (&result, "%10La %d", 1.75L, 33, 44, 55);
600 ASSERT (result != NULL);
601 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
602 || strcmp (result, " 0x3.8p-1 33") == 0
603 || strcmp (result, " 0x7p-2 33") == 0
604 || strcmp (result, " 0xep-3 33") == 0);
605 ASSERT (retval == strlen (result));
609 { /* Small precision. */
612 my_asprintf (&result, "%.10La %d", 1.75L, 33, 44, 55);
613 ASSERT (result != NULL);
614 ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
615 || strcmp (result, "0x3.8000000000p-1 33") == 0
616 || strcmp (result, "0x7.0000000000p-2 33") == 0
617 || strcmp (result, "0xe.0000000000p-3 33") == 0);
618 ASSERT (retval == strlen (result));
622 { /* Large precision. */
625 my_asprintf (&result, "%.50La %d", 1.75L, 33, 44, 55);
626 ASSERT (result != NULL);
627 ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
628 || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
629 || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
630 || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
631 ASSERT (retval == strlen (result));
638 my_asprintf (&result, "%-10La %d", 1.75L, 33, 44, 55);
639 ASSERT (result != NULL);
640 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
641 || strcmp (result, "0x3.8p-1 33") == 0
642 || strcmp (result, "0x7p-2 33") == 0
643 || strcmp (result, "0xep-3 33") == 0);
644 ASSERT (retval == strlen (result));
648 { /* FLAG_SHOWSIGN. */
651 my_asprintf (&result, "%+La %d", 1.75L, 33, 44, 55);
652 ASSERT (result != NULL);
653 ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
654 || strcmp (result, "+0x3.8p-1 33") == 0
655 || strcmp (result, "+0x7p-2 33") == 0
656 || strcmp (result, "+0xep-3 33") == 0);
657 ASSERT (retval == strlen (result));
664 my_asprintf (&result, "% La %d", 1.75L, 33, 44, 55);
665 ASSERT (result != NULL);
666 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
667 || strcmp (result, " 0x3.8p-1 33") == 0
668 || strcmp (result, " 0x7p-2 33") == 0
669 || strcmp (result, " 0xep-3 33") == 0);
670 ASSERT (retval == strlen (result));
677 my_asprintf (&result, "%#La %d", 1.75L, 33, 44, 55);
678 ASSERT (result != NULL);
679 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
680 || strcmp (result, "0x3.8p-1 33") == 0
681 || strcmp (result, "0x7.p-2 33") == 0
682 || strcmp (result, "0xe.p-3 33") == 0);
683 ASSERT (retval == strlen (result));
690 my_asprintf (&result, "%#La %d", 1.0L, 33, 44, 55);
691 ASSERT (result != NULL);
692 ASSERT (strcmp (result, "0x1.p+0 33") == 0
693 || strcmp (result, "0x2.p-1 33") == 0
694 || strcmp (result, "0x4.p-2 33") == 0
695 || strcmp (result, "0x8.p-3 33") == 0);
696 ASSERT (retval == strlen (result));
700 { /* FLAG_ZERO with finite number. */
703 my_asprintf (&result, "%010La %d", 1.75L, 33, 44, 55);
704 ASSERT (result != NULL);
705 ASSERT (strcmp (result, "0x001.cp+0 33") == 0
706 || strcmp (result, "0x003.8p-1 33") == 0
707 || strcmp (result, "0x00007p-2 33") == 0
708 || strcmp (result, "0x0000ep-3 33") == 0);
709 ASSERT (retval == strlen (result));
713 { /* FLAG_ZERO with infinite number. */
716 my_asprintf (&result, "%010La %d", 1.0L / 0.0L, 33, 44, 55);
717 ASSERT (result != NULL);
718 /* "0000000inf 33" is not a valid result; see
719 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
720 ASSERT (strcmp (result, " inf 33") == 0);
721 ASSERT (retval == strlen (result));
725 { /* FLAG_ZERO with NaN. */
728 my_asprintf (&result, "%010La %d", 0.0L / 0.0L, 33, 44, 55);
729 ASSERT (result != NULL);
730 /* "0000000nan 33" is not a valid result; see
731 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
732 ASSERT (strcmp (result, " nan 33") == 0);
733 ASSERT (retval == strlen (result));
737 /* Test the support of the %f format directive. */
739 { /* A positive number. */
742 my_asprintf (&result, "%f %d", 12.75, 33, 44, 55);
743 ASSERT (result != NULL);
744 ASSERT (strcmp (result, "12.750000 33") == 0);
745 ASSERT (retval == strlen (result));
749 { /* A larger positive number. */
752 my_asprintf (&result, "%f %d", 1234567.0, 33, 44, 55);
753 ASSERT (result != NULL);
754 ASSERT (strcmp (result, "1234567.000000 33") == 0);
755 ASSERT (retval == strlen (result));
759 { /* A negative number. */
762 my_asprintf (&result, "%f %d", -0.03125, 33, 44, 55);
763 ASSERT (result != NULL);
764 ASSERT (strcmp (result, "-0.031250 33") == 0);
765 ASSERT (retval == strlen (result));
769 { /* Positive zero. */
772 my_asprintf (&result, "%f %d", 0.0, 33, 44, 55);
773 ASSERT (result != NULL);
774 ASSERT (strcmp (result, "0.000000 33") == 0);
775 ASSERT (retval == strlen (result));
779 { /* Negative zero. */
782 my_asprintf (&result, "%f %d", -0.0, 33, 44, 55);
783 ASSERT (result != NULL);
784 ASSERT (strcmp (result, "-0.000000 33") == 0);
785 ASSERT (retval == strlen (result));
789 { /* Positive infinity. */
792 my_asprintf (&result, "%f %d", 1.0 / 0.0, 33, 44, 55);
793 ASSERT (result != NULL);
794 ASSERT (strcmp (result, "inf 33") == 0
795 || strcmp (result, "infinity 33") == 0);
796 ASSERT (retval == strlen (result));
800 { /* Negative infinity. */
803 my_asprintf (&result, "%f %d", -1.0 / 0.0, 33, 44, 55);
804 ASSERT (result != NULL);
805 ASSERT (strcmp (result, "-inf 33") == 0
806 || strcmp (result, "-infinity 33") == 0);
807 ASSERT (retval == strlen (result));
814 my_asprintf (&result, "%f %d", NaN (), 33, 44, 55);
815 ASSERT (result != NULL);
816 ASSERT (strcmp (result, "nan 33") == 0);
817 ASSERT (retval == strlen (result));
824 my_asprintf (&result, "%10f %d", 1.75, 33, 44, 55);
825 ASSERT (result != NULL);
826 ASSERT (strcmp (result, " 1.750000 33") == 0);
827 ASSERT (retval == strlen (result));
834 my_asprintf (&result, "%-10f %d", 1.75, 33, 44, 55);
835 ASSERT (result != NULL);
836 ASSERT (strcmp (result, "1.750000 33") == 0);
837 ASSERT (retval == strlen (result));
841 { /* FLAG_SHOWSIGN. */
844 my_asprintf (&result, "%+f %d", 1.75, 33, 44, 55);
845 ASSERT (result != NULL);
846 ASSERT (strcmp (result, "+1.750000 33") == 0);
847 ASSERT (retval == strlen (result));
854 my_asprintf (&result, "% f %d", 1.75, 33, 44, 55);
855 ASSERT (result != NULL);
856 ASSERT (strcmp (result, " 1.750000 33") == 0);
857 ASSERT (retval == strlen (result));
864 my_asprintf (&result, "%#f %d", 1.75, 33, 44, 55);
865 ASSERT (result != NULL);
866 ASSERT (strcmp (result, "1.750000 33") == 0);
867 ASSERT (retval == strlen (result));
874 my_asprintf (&result, "%#.f %d", 1.75, 33, 44, 55);
875 ASSERT (result != NULL);
876 ASSERT (strcmp (result, "2. 33") == 0);
877 ASSERT (retval == strlen (result));
881 { /* FLAG_ZERO with finite number. */
884 my_asprintf (&result, "%015f %d", 1234.0, 33, 44, 55);
885 ASSERT (result != NULL);
886 ASSERT (strcmp (result, "00001234.000000 33") == 0);
887 ASSERT (retval == strlen (result));
891 { /* FLAG_ZERO with infinite number. */
894 my_asprintf (&result, "%015f %d", -1.0 / 0.0, 33, 44, 55);
895 ASSERT (result != NULL);
896 ASSERT (strcmp (result, " -inf 33") == 0
897 || strcmp (result, " -infinity 33") == 0);
898 ASSERT (retval == strlen (result));
902 { /* FLAG_ZERO with NaN. */
905 my_asprintf (&result, "%015f %d", NaN (), 33, 44, 55);
906 ASSERT (result != NULL);
907 ASSERT (strcmp (result, " nan 33") == 0);
908 ASSERT (retval == strlen (result));
915 my_asprintf (&result, "%.f %d", 1234.0, 33, 44, 55);
916 ASSERT (result != NULL);
917 ASSERT (strcmp (result, "1234 33") == 0);
918 ASSERT (retval == strlen (result));
922 { /* A positive number. */
925 my_asprintf (&result, "%Lf %d", 12.75L, 33, 44, 55);
926 ASSERT (result != NULL);
927 ASSERT (strcmp (result, "12.750000 33") == 0);
928 ASSERT (retval == strlen (result));
932 { /* A larger positive number. */
935 my_asprintf (&result, "%Lf %d", 1234567.0L, 33, 44, 55);
936 ASSERT (result != NULL);
937 ASSERT (strcmp (result, "1234567.000000 33") == 0);
938 ASSERT (retval == strlen (result));
942 { /* A negative number. */
945 my_asprintf (&result, "%Lf %d", -0.03125L, 33, 44, 55);
946 ASSERT (result != NULL);
947 ASSERT (strcmp (result, "-0.031250 33") == 0);
948 ASSERT (retval == strlen (result));
952 { /* Positive zero. */
955 my_asprintf (&result, "%Lf %d", 0.0L, 33, 44, 55);
956 ASSERT (result != NULL);
957 ASSERT (strcmp (result, "0.000000 33") == 0);
958 ASSERT (retval == strlen (result));
962 { /* Negative zero. */
965 my_asprintf (&result, "%Lf %d", -0.0L, 33, 44, 55);
966 ASSERT (result != NULL);
967 ASSERT (strcmp (result, "-0.000000 33") == 0);
968 ASSERT (retval == strlen (result));
972 { /* Positive infinity. */
975 my_asprintf (&result, "%Lf %d", 1.0L / 0.0L, 33, 44, 55);
976 ASSERT (result != NULL);
977 ASSERT (strcmp (result, "inf 33") == 0
978 || strcmp (result, "infinity 33") == 0);
979 ASSERT (retval == strlen (result));
983 { /* Negative infinity. */
986 my_asprintf (&result, "%Lf %d", -1.0L / 0.0L, 33, 44, 55);
987 ASSERT (result != NULL);
988 ASSERT (strcmp (result, "-inf 33") == 0
989 || strcmp (result, "-infinity 33") == 0);
990 ASSERT (retval == strlen (result));
995 static long double zero = 0.0L;
998 my_asprintf (&result, "%Lf %d", zero / zero, 33, 44, 55);
999 ASSERT (result != NULL);
1000 ASSERT (strcmp (result, "nan 33") == 0);
1001 ASSERT (retval == strlen (result));
1008 my_asprintf (&result, "%10Lf %d", 1.75L, 33, 44, 55);
1009 ASSERT (result != NULL);
1010 ASSERT (strcmp (result, " 1.750000 33") == 0);
1011 ASSERT (retval == strlen (result));
1018 my_asprintf (&result, "%-10Lf %d", 1.75L, 33, 44, 55);
1019 ASSERT (result != NULL);
1020 ASSERT (strcmp (result, "1.750000 33") == 0);
1021 ASSERT (retval == strlen (result));
1025 { /* FLAG_SHOWSIGN. */
1028 my_asprintf (&result, "%+Lf %d", 1.75L, 33, 44, 55);
1029 ASSERT (result != NULL);
1030 ASSERT (strcmp (result, "+1.750000 33") == 0);
1031 ASSERT (retval == strlen (result));
1038 my_asprintf (&result, "% Lf %d", 1.75L, 33, 44, 55);
1039 ASSERT (result != NULL);
1040 ASSERT (strcmp (result, " 1.750000 33") == 0);
1041 ASSERT (retval == strlen (result));
1048 my_asprintf (&result, "%#Lf %d", 1.75L, 33, 44, 55);
1049 ASSERT (result != NULL);
1050 ASSERT (strcmp (result, "1.750000 33") == 0);
1051 ASSERT (retval == strlen (result));
1058 my_asprintf (&result, "%#.Lf %d", 1.75L, 33, 44, 55);
1059 ASSERT (result != NULL);
1060 ASSERT (strcmp (result, "2. 33") == 0);
1061 ASSERT (retval == strlen (result));
1065 { /* FLAG_ZERO with finite number. */
1068 my_asprintf (&result, "%015Lf %d", 1234.0L, 33, 44, 55);
1069 ASSERT (result != NULL);
1070 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1071 ASSERT (retval == strlen (result));
1075 { /* FLAG_ZERO with infinite number. */
1078 my_asprintf (&result, "%015Lf %d", -1.0L / 0.0L, 33, 44, 55);
1079 ASSERT (result != NULL);
1080 ASSERT (strcmp (result, " -inf 33") == 0
1081 || strcmp (result, " -infinity 33") == 0);
1082 ASSERT (retval == strlen (result));
1086 { /* FLAG_ZERO with NaN. */
1087 static long double zero = 0.0L;
1090 my_asprintf (&result, "%015Lf %d", zero / zero, 33, 44, 55);
1091 ASSERT (result != NULL);
1092 ASSERT (strcmp (result, " nan 33") == 0);
1093 ASSERT (retval == strlen (result));
1100 my_asprintf (&result, "%.Lf %d", 1234.0L, 33, 44, 55);
1101 ASSERT (result != NULL);
1102 ASSERT (strcmp (result, "1234 33") == 0);
1103 ASSERT (retval == strlen (result));
1107 /* Test the support of the %F format directive. */
1109 { /* A positive number. */
1112 my_asprintf (&result, "%F %d", 12.75, 33, 44, 55);
1113 ASSERT (result != NULL);
1114 ASSERT (strcmp (result, "12.750000 33") == 0);
1115 ASSERT (retval == strlen (result));
1119 { /* A larger positive number. */
1122 my_asprintf (&result, "%F %d", 1234567.0, 33, 44, 55);
1123 ASSERT (result != NULL);
1124 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1125 ASSERT (retval == strlen (result));
1129 { /* A negative number. */
1132 my_asprintf (&result, "%F %d", -0.03125, 33, 44, 55);
1133 ASSERT (result != NULL);
1134 ASSERT (strcmp (result, "-0.031250 33") == 0);
1135 ASSERT (retval == strlen (result));
1139 { /* Positive zero. */
1142 my_asprintf (&result, "%F %d", 0.0, 33, 44, 55);
1143 ASSERT (result != NULL);
1144 ASSERT (strcmp (result, "0.000000 33") == 0);
1145 ASSERT (retval == strlen (result));
1149 { /* Negative zero. */
1152 my_asprintf (&result, "%F %d", -0.0, 33, 44, 55);
1153 ASSERT (result != NULL);
1154 ASSERT (strcmp (result, "-0.000000 33") == 0);
1155 ASSERT (retval == strlen (result));
1159 { /* Positive infinity. */
1162 my_asprintf (&result, "%F %d", 1.0 / 0.0, 33, 44, 55);
1163 ASSERT (result != NULL);
1164 ASSERT (strcmp (result, "INF 33") == 0
1165 || strcmp (result, "INFINITY 33") == 0);
1166 ASSERT (retval == strlen (result));
1170 { /* Negative infinity. */
1173 my_asprintf (&result, "%F %d", -1.0 / 0.0, 33, 44, 55);
1174 ASSERT (result != NULL);
1175 ASSERT (strcmp (result, "-INF 33") == 0
1176 || strcmp (result, "-INFINITY 33") == 0);
1177 ASSERT (retval == strlen (result));
1184 my_asprintf (&result, "%F %d", NaN (), 33, 44, 55);
1185 ASSERT (result != NULL);
1186 ASSERT (strcmp (result, "NAN 33") == 0);
1187 ASSERT (retval == strlen (result));
1194 my_asprintf (&result, "%015F %d", 1234.0, 33, 44, 55);
1195 ASSERT (result != NULL);
1196 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1197 ASSERT (retval == strlen (result));
1201 { /* FLAG_ZERO with infinite number. */
1204 my_asprintf (&result, "%015F %d", -1.0 / 0.0, 33, 44, 55);
1205 ASSERT (result != NULL);
1206 ASSERT (strcmp (result, " -INF 33") == 0
1207 || strcmp (result, " -INFINITY 33") == 0);
1208 ASSERT (retval == strlen (result));
1215 my_asprintf (&result, "%.F %d", 1234.0, 33, 44, 55);
1216 ASSERT (result != NULL);
1217 ASSERT (strcmp (result, "1234 33") == 0);
1218 ASSERT (retval == strlen (result));
1222 { /* A positive number. */
1225 my_asprintf (&result, "%LF %d", 12.75L, 33, 44, 55);
1226 ASSERT (result != NULL);
1227 ASSERT (strcmp (result, "12.750000 33") == 0);
1228 ASSERT (retval == strlen (result));
1232 { /* A larger positive number. */
1235 my_asprintf (&result, "%LF %d", 1234567.0L, 33, 44, 55);
1236 ASSERT (result != NULL);
1237 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1238 ASSERT (retval == strlen (result));
1242 { /* A negative number. */
1245 my_asprintf (&result, "%LF %d", -0.03125L, 33, 44, 55);
1246 ASSERT (result != NULL);
1247 ASSERT (strcmp (result, "-0.031250 33") == 0);
1248 ASSERT (retval == strlen (result));
1252 { /* Positive zero. */
1255 my_asprintf (&result, "%LF %d", 0.0L, 33, 44, 55);
1256 ASSERT (result != NULL);
1257 ASSERT (strcmp (result, "0.000000 33") == 0);
1258 ASSERT (retval == strlen (result));
1262 { /* Negative zero. */
1265 my_asprintf (&result, "%LF %d", -0.0L, 33, 44, 55);
1266 ASSERT (result != NULL);
1267 ASSERT (strcmp (result, "-0.000000 33") == 0);
1268 ASSERT (retval == strlen (result));
1272 { /* Positive infinity. */
1275 my_asprintf (&result, "%LF %d", 1.0L / 0.0L, 33, 44, 55);
1276 ASSERT (result != NULL);
1277 ASSERT (strcmp (result, "INF 33") == 0
1278 || strcmp (result, "INFINITY 33") == 0);
1279 ASSERT (retval == strlen (result));
1283 { /* Negative infinity. */
1286 my_asprintf (&result, "%LF %d", -1.0L / 0.0L, 33, 44, 55);
1287 ASSERT (result != NULL);
1288 ASSERT (strcmp (result, "-INF 33") == 0
1289 || strcmp (result, "-INFINITY 33") == 0);
1290 ASSERT (retval == strlen (result));
1295 static long double zero = 0.0L;
1298 my_asprintf (&result, "%LF %d", zero / zero, 33, 44, 55);
1299 ASSERT (result != NULL);
1300 ASSERT (strcmp (result, "NAN 33") == 0);
1301 ASSERT (retval == strlen (result));
1308 my_asprintf (&result, "%015LF %d", 1234.0L, 33, 44, 55);
1309 ASSERT (result != NULL);
1310 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1311 ASSERT (retval == strlen (result));
1315 { /* FLAG_ZERO with infinite number. */
1318 my_asprintf (&result, "%015LF %d", -1.0L / 0.0L, 33, 44, 55);
1319 ASSERT (result != NULL);
1320 ASSERT (strcmp (result, " -INF 33") == 0
1321 || strcmp (result, " -INFINITY 33") == 0);
1322 ASSERT (retval == strlen (result));
1329 my_asprintf (&result, "%.LF %d", 1234.0L, 33, 44, 55);
1330 ASSERT (result != NULL);
1331 ASSERT (strcmp (result, "1234 33") == 0);
1332 ASSERT (retval == strlen (result));
1336 /* Test the support of the %n format directive. */
1342 my_asprintf (&result, "%d %n", 123, &count, 33, 44, 55);
1343 ASSERT (result != NULL);
1344 ASSERT (strcmp (result, "123 ") == 0);
1345 ASSERT (retval == strlen (result));
1346 ASSERT (count == 4);
1350 /* Test the support of the POSIX/XSI format strings with positions. */
1355 my_asprintf (&result, "%2$d %1$d", 33, 55);
1356 ASSERT (result != NULL);
1357 ASSERT (strcmp (result, "55 33") == 0);
1358 ASSERT (retval == strlen (result));
1362 /* Test the support of the grouping flag. */
1367 my_asprintf (&result, "%'d %d", 1234567, 99);
1368 ASSERT (result != NULL);
1369 ASSERT (result[strlen (result) - 1] == '9');
1370 ASSERT (retval == strlen (result));
1376 my_asprintf (char **result, const char *format, ...)
1381 va_start (args, format);
1382 ret = vasprintf (result, format, args);
1390 test_function (my_asprintf);
1396 test_function (asprintf);
1400 main (int argc, char *argv[])