projects / gnulib.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Avoid test failures on some versions of HP-UX 11.
[gnulib.git] / tests / test-vasprintf-posix.c
1 /* Test of POSIX compatible vasprintf() and asprintf() functions.
2    Copyright (C) 2007 Free Software Foundation, Inc.
3
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)
7    any later version.
8
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.
13
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.  */
17
18 /* Written by Bruno Haible <bruno@clisp.org>, 2007.  */
19
20 #ifdef HAVE_CONFIG_H
21 # include <config.h>
22 #endif
23
24 #include <stdio.h>
25
26 #include <stdarg.h>
27 #include <stddef.h>
28 #include <stdio.h>
29 #include <stdint.h>
30 #include <stdlib.h>
31 #include <string.h>
32
33 #define SIZEOF(array) (sizeof (array) / sizeof (array[0]))
34 #define ASSERT(expr) \
35   do                                                                         \
36     {                                                                        \
37       if (!(expr))                                                           \
38         {                                                                    \
39           fprintf (stderr, "%s:%d: assertion failed\n", __FILE__, __LINE__); \
40           abort ();                                                          \
41         }                                                                    \
42     }                                                                        \
43   while (0)
44
45 /* The Compaq (ex-DEC) C 6.4 compiler chokes on the expression 0.0 / 0.0.  */
46 #ifdef __DECC
47 static double
48 NaN ()
49 {
50   static double zero = 0.0;
51   return zero / zero;
52 }
53 #else
54 # define NaN() (0.0 / 0.0)
55 #endif
56
57 /* The SGI MIPS floating-point format does not distinguish 0.0 and -0.0.  */
58 static int
59 have_minus_zero ()
60 {
61   static double plus_zero = 0.0;
62   static double minus_zero = -0.0;
63   return memcmp (&plus_zero, &minus_zero, sizeof (double)) != 0;
64 }
65
66 static int
67 strmatch (const char *pattern, const char *string)
68 {
69   if (strlen (pattern) != strlen (string))
70     return 0;
71   for (; *pattern != '\0'; pattern++, string++)
72     if (*pattern != '*' && *string != *pattern)
73       return 0;
74   return 1;
75 }
76
77 static void
78 test_function (int (*my_asprintf) (char **, const char *, ...))
79 {
80   int repeat;
81
82   /* Test return value convention.  */
83
84   for (repeat = 0; repeat <= 8; repeat++)
85     {
86       char *result;
87       int retval = asprintf (&result, "%d", 12345);
88       ASSERT (retval == 5);
89       ASSERT (result != NULL);
90       ASSERT (strcmp (result, "12345") == 0);
91       free (result);
92     }
93
94   /* Test support of size specifiers as in C99.  */
95
96   {
97     char *result;
98     int retval =
99       my_asprintf (&result, "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
100     ASSERT (result != NULL);
101     ASSERT (strcmp (result, "12345671 33") == 0);
102     ASSERT (retval == strlen (result));
103     free (result);
104   }
105
106   {
107     char *result;
108     int retval =
109       my_asprintf (&result, "%zu %d", (size_t) 12345672, 33, 44, 55);
110     ASSERT (result != NULL);
111     ASSERT (strcmp (result, "12345672 33") == 0);
112     ASSERT (retval == strlen (result));
113     free (result);
114   }
115
116   {
117     char *result;
118     int retval =
119       my_asprintf (&result, "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
120     ASSERT (result != NULL);
121     ASSERT (strcmp (result, "12345673 33") == 0);
122     ASSERT (retval == strlen (result));
123     free (result);
124   }
125
126   {
127     char *result;
128     int retval =
129       my_asprintf (&result, "%Lg %d", (long double) 1.5, 33, 44, 55);
130     ASSERT (result != NULL);
131     ASSERT (strcmp (result, "1.5 33") == 0);
132     ASSERT (retval == strlen (result));
133     free (result);
134   }
135
136   /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
137      output of floating-point numbers.  */
138
139   { /* A positive number.  */
140     char *result;
141     int retval =
142       my_asprintf (&result, "%a %d", 3.1416015625, 33, 44, 55);
143     ASSERT (result != NULL);
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));
149     free (result);
150   }
151
152   { /* A negative number.  */
153     char *result;
154     int retval =
155       my_asprintf (&result, "%A %d", -3.1416015625, 33, 44, 55);
156     ASSERT (result != NULL);
157     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
158             || strcmp (result, "-0X3.244P+0 33") == 0
159             || strcmp (result, "-0X6.488P-1 33") == 0
160             || strcmp (result, "-0XC.91P-2 33") == 0);
161     ASSERT (retval == strlen (result));
162     free (result);
163   }
164
165   { /* Positive zero.  */
166     char *result;
167     int retval =
168       my_asprintf (&result, "%a %d", 0.0, 33, 44, 55);
169     ASSERT (result != NULL);
170     ASSERT (strcmp (result, "0x0p+0 33") == 0);
171     ASSERT (retval == strlen (result));
172     free (result);
173   }
174
175   { /* Negative zero.  */
176     char *result;
177     int retval =
178       my_asprintf (&result, "%a %d", -0.0, 33, 44, 55);
179     ASSERT (result != NULL);
180     if (have_minus_zero ())
181       ASSERT (strcmp (result, "-0x0p+0 33") == 0);
182     ASSERT (retval == strlen (result));
183     free (result);
184   }
185
186   { /* Positive infinity.  */
187     char *result;
188     int retval =
189       my_asprintf (&result, "%a %d", 1.0 / 0.0, 33, 44, 55);
190     ASSERT (result != NULL);
191     ASSERT (strcmp (result, "inf 33") == 0);
192     ASSERT (retval == strlen (result));
193     free (result);
194   }
195
196   { /* Negative infinity.  */
197     char *result;
198     int retval =
199       my_asprintf (&result, "%a %d", -1.0 / 0.0, 33, 44, 55);
200     ASSERT (result != NULL);
201     ASSERT (strcmp (result, "-inf 33") == 0);
202     ASSERT (retval == strlen (result));
203     free (result);
204   }
205
206   { /* NaN.  */
207     char *result;
208     int retval =
209       my_asprintf (&result, "%a %d", NaN (), 33, 44, 55);
210     ASSERT (result != NULL);
211     ASSERT (strlen (result) >= 3 + 3
212             && (memcmp (result, "nan", 3) == 0
213                 || memcmp (result, "-nan", 4) == 0)
214             && strcmp (result + strlen (result) - 3, " 33") == 0);
215     ASSERT (retval == strlen (result));
216     free (result);
217   }
218
219   { /* Rounding near the decimal point.  */
220     char *result;
221     int retval =
222       my_asprintf (&result, "%.0a %d", 1.5, 33, 44, 55);
223     ASSERT (result != NULL);
224     ASSERT (strcmp (result, "0x2p+0 33") == 0
225             || strcmp (result, "0x3p-1 33") == 0
226             || strcmp (result, "0x6p-2 33") == 0
227             || strcmp (result, "0xcp-3 33") == 0);
228     ASSERT (retval == strlen (result));
229     free (result);
230   }
231
232   { /* Rounding with precision 0.  */
233     char *result;
234     int retval =
235       my_asprintf (&result, "%.0a %d", 1.51, 33, 44, 55);
236     ASSERT (result != NULL);
237     ASSERT (strcmp (result, "0x2p+0 33") == 0
238             || strcmp (result, "0x3p-1 33") == 0
239             || strcmp (result, "0x6p-2 33") == 0
240             || strcmp (result, "0xcp-3 33") == 0);
241     ASSERT (retval == strlen (result));
242     free (result);
243   }
244
245   { /* Rounding with precision 1.  */
246     char *result;
247     int retval =
248       my_asprintf (&result, "%.1a %d", 1.51, 33, 44, 55);
249     ASSERT (result != NULL);
250     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
251             || strcmp (result, "0x3.0p-1 33") == 0
252             || strcmp (result, "0x6.1p-2 33") == 0
253             || strcmp (result, "0xc.1p-3 33") == 0);
254     ASSERT (retval == strlen (result));
255     free (result);
256   }
257
258   { /* Rounding with precision 2.  */
259     char *result;
260     int retval =
261       my_asprintf (&result, "%.2a %d", 1.51, 33, 44, 55);
262     ASSERT (result != NULL);
263     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
264             || strcmp (result, "0x3.05p-1 33") == 0
265             || strcmp (result, "0x6.0ap-2 33") == 0
266             || strcmp (result, "0xc.14p-3 33") == 0);
267     ASSERT (retval == strlen (result));
268     free (result);
269   }
270
271   { /* Rounding with precision 3.  */
272     char *result;
273     int retval =
274       my_asprintf (&result, "%.3a %d", 1.51, 33, 44, 55);
275     ASSERT (result != NULL);
276     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
277             || strcmp (result, "0x3.052p-1 33") == 0
278             || strcmp (result, "0x6.0a4p-2 33") == 0
279             || strcmp (result, "0xc.148p-3 33") == 0);
280     ASSERT (retval == strlen (result));
281     free (result);
282   }
283
284   { /* Rounding can turn a ...FFF into a ...000.  */
285     char *result;
286     int retval =
287       my_asprintf (&result, "%.3a %d", 1.49999, 33, 44, 55);
288     ASSERT (result != NULL);
289     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
290             || strcmp (result, "0x3.000p-1 33") == 0
291             || strcmp (result, "0x6.000p-2 33") == 0
292             || strcmp (result, "0xc.000p-3 33") == 0);
293     ASSERT (retval == strlen (result));
294     free (result);
295   }
296
297   { /* Rounding can turn a ...FFF into a ...000.
298        This shows a MacOS X 10.3.9 (Darwin 7.9) bug.  */
299     char *result;
300     int retval =
301       my_asprintf (&result, "%.1a %d", 1.999, 33, 44, 55);
302     ASSERT (result != NULL);
303     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
304             || strcmp (result, "0x2.0p+0 33") == 0
305             || strcmp (result, "0x4.0p-1 33") == 0
306             || strcmp (result, "0x8.0p-2 33") == 0);
307     ASSERT (retval == strlen (result));
308     free (result);
309   }
310
311   { /* Width.  */
312     char *result;
313     int retval =
314       my_asprintf (&result, "%10a %d", 1.75, 33, 44, 55);
315     ASSERT (result != NULL);
316     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
317             || strcmp (result, "  0x3.8p-1 33") == 0
318             || strcmp (result, "    0x7p-2 33") == 0
319             || strcmp (result, "    0xep-3 33") == 0);
320     ASSERT (retval == strlen (result));
321     free (result);
322   }
323
324   { /* Small precision.  */
325     char *result;
326     int retval =
327       my_asprintf (&result, "%.10a %d", 1.75, 33, 44, 55);
328     ASSERT (result != NULL);
329     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
330             || strcmp (result, "0x3.8000000000p-1 33") == 0
331             || strcmp (result, "0x7.0000000000p-2 33") == 0
332             || strcmp (result, "0xe.0000000000p-3 33") == 0);
333     ASSERT (retval == strlen (result));
334     free (result);
335   }
336
337   { /* Large precision.  */
338     char *result;
339     int retval =
340       my_asprintf (&result, "%.50a %d", 1.75, 33, 44, 55);
341     ASSERT (result != NULL);
342     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
343             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
344             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
345             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
346     ASSERT (retval == strlen (result));
347     free (result);
348   }
349
350   { /* FLAG_LEFT.  */
351     char *result;
352     int retval =
353       my_asprintf (&result, "%-10a %d", 1.75, 33, 44, 55);
354     ASSERT (result != NULL);
355     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
356             || strcmp (result, "0x3.8p-1   33") == 0
357             || strcmp (result, "0x7p-2     33") == 0
358             || strcmp (result, "0xep-3     33") == 0);
359     ASSERT (retval == strlen (result));
360     free (result);
361   }
362
363   { /* FLAG_SHOWSIGN.  */
364     char *result;
365     int retval =
366       my_asprintf (&result, "%+a %d", 1.75, 33, 44, 55);
367     ASSERT (result != NULL);
368     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
369             || strcmp (result, "+0x3.8p-1 33") == 0
370             || strcmp (result, "+0x7p-2 33") == 0
371             || strcmp (result, "+0xep-3 33") == 0);
372     ASSERT (retval == strlen (result));
373     free (result);
374   }
375
376   { /* FLAG_SPACE.  */
377     char *result;
378     int retval =
379       my_asprintf (&result, "% a %d", 1.75, 33, 44, 55);
380     ASSERT (result != NULL);
381     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
382             || strcmp (result, " 0x3.8p-1 33") == 0
383             || strcmp (result, " 0x7p-2 33") == 0
384             || strcmp (result, " 0xep-3 33") == 0);
385     ASSERT (retval == strlen (result));
386     free (result);
387   }
388
389   { /* FLAG_ALT.  */
390     char *result;
391     int retval =
392       my_asprintf (&result, "%#a %d", 1.75, 33, 44, 55);
393     ASSERT (result != NULL);
394     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
395             || strcmp (result, "0x3.8p-1 33") == 0
396             || strcmp (result, "0x7.p-2 33") == 0
397             || strcmp (result, "0xe.p-3 33") == 0);
398     ASSERT (retval == strlen (result));
399     free (result);
400   }
401
402   { /* FLAG_ALT.  */
403     char *result;
404     int retval =
405       my_asprintf (&result, "%#a %d", 1.0, 33, 44, 55);
406     ASSERT (result != NULL);
407     ASSERT (strcmp (result, "0x1.p+0 33") == 0
408             || strcmp (result, "0x2.p-1 33") == 0
409             || strcmp (result, "0x4.p-2 33") == 0
410             || strcmp (result, "0x8.p-3 33") == 0);
411     ASSERT (retval == strlen (result));
412     free (result);
413   }
414
415   { /* FLAG_ZERO with finite number.  */
416     char *result;
417     int retval =
418       my_asprintf (&result, "%010a %d", 1.75, 33, 44, 55);
419     ASSERT (result != NULL);
420     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
421             || strcmp (result, "0x003.8p-1 33") == 0
422             || strcmp (result, "0x00007p-2 33") == 0
423             || strcmp (result, "0x0000ep-3 33") == 0);
424     ASSERT (retval == strlen (result));
425     free (result);
426   }
427
428   { /* FLAG_ZERO with infinite number.  */
429     char *result;
430     int retval =
431       my_asprintf (&result, "%010a %d", 1.0 / 0.0, 33, 44, 55);
432     ASSERT (result != NULL);
433     /* "0000000inf 33" is not a valid result; see
434        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
435     ASSERT (strcmp (result, "       inf 33") == 0);
436     ASSERT (retval == strlen (result));
437     free (result);
438   }
439
440   { /* FLAG_ZERO with NaN.  */
441     char *result;
442     int retval =
443       my_asprintf (&result, "%020a %d", NaN (), 33, 44, 55);
444     ASSERT (result != NULL);
445     /* "0000000nan 33" is not a valid result; see
446        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
447     ASSERT (strlen (result) == 20 + 3
448             && (memcmp (result + strspn (result, " "), "nan", 3) == 0
449                 || memcmp (result + strspn (result, " "), "-nan", 4) == 0)
450             && strcmp (result + strlen (result) - 3, " 33") == 0);
451     ASSERT (retval == strlen (result));
452     free (result);
453   }
454
455   { /* A positive number.  */
456     char *result;
457     int retval =
458       my_asprintf (&result, "%La %d", 3.1416015625L, 33, 44, 55);
459     ASSERT (result != NULL);
460     ASSERT (strcmp (result, "0x1.922p+1 33") == 0
461             || strcmp (result, "0x3.244p+0 33") == 0
462             || strcmp (result, "0x6.488p-1 33") == 0
463             || strcmp (result, "0xc.91p-2 33") == 0);
464     ASSERT (retval == strlen (result));
465     free (result);
466   }
467
468   { /* A negative number.  */
469     char *result;
470     int retval =
471       my_asprintf (&result, "%LA %d", -3.1416015625L, 33, 44, 55);
472     ASSERT (result != NULL);
473     ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
474             || strcmp (result, "-0X3.244P+0 33") == 0
475             || strcmp (result, "-0X6.488P-1 33") == 0
476             || strcmp (result, "-0XC.91P-2 33") == 0);
477     ASSERT (retval == strlen (result));
478     free (result);
479   }
480
481   { /* Positive zero.  */
482     char *result;
483     int retval =
484       my_asprintf (&result, "%La %d", 0.0L, 33, 44, 55);
485     ASSERT (result != NULL);
486     ASSERT (strcmp (result, "0x0p+0 33") == 0);
487     ASSERT (retval == strlen (result));
488     free (result);
489   }
490
491   { /* Negative zero.  */
492     char *result;
493     int retval =
494       my_asprintf (&result, "%La %d", -0.0L, 33, 44, 55);
495     ASSERT (result != NULL);
496     if (have_minus_zero ())
497       ASSERT (strcmp (result, "-0x0p+0 33") == 0);
498     ASSERT (retval == strlen (result));
499     free (result);
500   }
501
502   { /* Positive infinity.  */
503     char *result;
504     int retval =
505       my_asprintf (&result, "%La %d", 1.0L / 0.0L, 33, 44, 55);
506     ASSERT (result != NULL);
507     ASSERT (strcmp (result, "inf 33") == 0);
508     ASSERT (retval == strlen (result));
509     free (result);
510   }
511
512   { /* Negative infinity.  */
513     char *result;
514     int retval =
515       my_asprintf (&result, "%La %d", -1.0L / 0.0L, 33, 44, 55);
516     ASSERT (result != NULL);
517     ASSERT (strcmp (result, "-inf 33") == 0);
518     ASSERT (retval == strlen (result));
519     free (result);
520   }
521
522   { /* NaN.  */
523     char *result;
524     int retval =
525       my_asprintf (&result, "%La %d", 0.0L / 0.0L, 33, 44, 55);
526     ASSERT (result != NULL);
527     ASSERT (strlen (result) >= 3 + 3
528             && (memcmp (result, "nan", 3) == 0
529                 || memcmp (result, "-nan", 4) == 0)
530             && strcmp (result + strlen (result) - 3, " 33") == 0);
531     ASSERT (retval == strlen (result));
532     free (result);
533   }
534
535   { /* Rounding near the decimal point.  */
536     char *result;
537     int retval =
538       my_asprintf (&result, "%.0La %d", 1.5L, 33, 44, 55);
539     ASSERT (result != NULL);
540     ASSERT (strcmp (result, "0x2p+0 33") == 0
541             || strcmp (result, "0x3p-1 33") == 0
542             || strcmp (result, "0x6p-2 33") == 0
543             || strcmp (result, "0xcp-3 33") == 0);
544     ASSERT (retval == strlen (result));
545     free (result);
546   }
547
548   { /* Rounding with precision 0.  */
549     char *result;
550     int retval =
551       my_asprintf (&result, "%.0La %d", 1.51L, 33, 44, 55);
552     ASSERT (result != NULL);
553     ASSERT (strcmp (result, "0x2p+0 33") == 0
554             || strcmp (result, "0x3p-1 33") == 0
555             || strcmp (result, "0x6p-2 33") == 0
556             || strcmp (result, "0xcp-3 33") == 0);
557     ASSERT (retval == strlen (result));
558     free (result);
559   }
560
561   { /* Rounding with precision 1.  */
562     char *result;
563     int retval =
564       my_asprintf (&result, "%.1La %d", 1.51L, 33, 44, 55);
565     ASSERT (result != NULL);
566     ASSERT (strcmp (result, "0x1.8p+0 33") == 0
567             || strcmp (result, "0x3.0p-1 33") == 0
568             || strcmp (result, "0x6.1p-2 33") == 0
569             || strcmp (result, "0xc.1p-3 33") == 0);
570     ASSERT (retval == strlen (result));
571     free (result);
572   }
573
574   { /* Rounding with precision 2.  */
575     char *result;
576     int retval =
577       my_asprintf (&result, "%.2La %d", 1.51L, 33, 44, 55);
578     ASSERT (result != NULL);
579     ASSERT (strcmp (result, "0x1.83p+0 33") == 0
580             || strcmp (result, "0x3.05p-1 33") == 0
581             || strcmp (result, "0x6.0ap-2 33") == 0
582             || strcmp (result, "0xc.14p-3 33") == 0);
583     ASSERT (retval == strlen (result));
584     free (result);
585   }
586
587   { /* Rounding with precision 3.  */
588     char *result;
589     int retval =
590       my_asprintf (&result, "%.3La %d", 1.51L, 33, 44, 55);
591     ASSERT (result != NULL);
592     ASSERT (strcmp (result, "0x1.829p+0 33") == 0
593             || strcmp (result, "0x3.052p-1 33") == 0
594             || strcmp (result, "0x6.0a4p-2 33") == 0
595             || strcmp (result, "0xc.148p-3 33") == 0);
596     ASSERT (retval == strlen (result));
597     free (result);
598   }
599
600   { /* Rounding can turn a ...FFF into a ...000.  */
601     char *result;
602     int retval =
603       my_asprintf (&result, "%.3La %d", 1.49999L, 33, 44, 55);
604     ASSERT (result != NULL);
605     ASSERT (strcmp (result, "0x1.800p+0 33") == 0
606             || strcmp (result, "0x3.000p-1 33") == 0
607             || strcmp (result, "0x6.000p-2 33") == 0
608             || strcmp (result, "0xc.000p-3 33") == 0);
609     ASSERT (retval == strlen (result));
610     free (result);
611   }
612
613   { /* Rounding can turn a ...FFF into a ...000.
614        This shows a MacOS X 10.3.9 (Darwin 7.9) bug and a
615        glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>.  */
616     char *result;
617     int retval =
618       my_asprintf (&result, "%.1La %d", 1.999L, 33, 44, 55);
619     ASSERT (result != NULL);
620     ASSERT (strcmp (result, "0x1.0p+1 33") == 0
621             || strcmp (result, "0x2.0p+0 33") == 0
622             || strcmp (result, "0x4.0p-1 33") == 0
623             || strcmp (result, "0x8.0p-2 33") == 0);
624     ASSERT (retval == strlen (result));
625     free (result);
626   }
627
628   { /* Width.  */
629     char *result;
630     int retval =
631       my_asprintf (&result, "%10La %d", 1.75L, 33, 44, 55);
632     ASSERT (result != NULL);
633     ASSERT (strcmp (result, "  0x1.cp+0 33") == 0
634             || strcmp (result, "  0x3.8p-1 33") == 0
635             || strcmp (result, "    0x7p-2 33") == 0
636             || strcmp (result, "    0xep-3 33") == 0);
637     ASSERT (retval == strlen (result));
638     free (result);
639   }
640
641   { /* Small precision.  */
642     char *result;
643     int retval =
644       my_asprintf (&result, "%.10La %d", 1.75L, 33, 44, 55);
645     ASSERT (result != NULL);
646     ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
647             || strcmp (result, "0x3.8000000000p-1 33") == 0
648             || strcmp (result, "0x7.0000000000p-2 33") == 0
649             || strcmp (result, "0xe.0000000000p-3 33") == 0);
650     ASSERT (retval == strlen (result));
651     free (result);
652   }
653
654   { /* Large precision.  */
655     char *result;
656     int retval =
657       my_asprintf (&result, "%.50La %d", 1.75L, 33, 44, 55);
658     ASSERT (result != NULL);
659     ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
660             || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
661             || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
662             || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
663     ASSERT (retval == strlen (result));
664     free (result);
665   }
666
667   { /* FLAG_LEFT.  */
668     char *result;
669     int retval =
670       my_asprintf (&result, "%-10La %d", 1.75L, 33, 44, 55);
671     ASSERT (result != NULL);
672     ASSERT (strcmp (result, "0x1.cp+0   33") == 0
673             || strcmp (result, "0x3.8p-1   33") == 0
674             || strcmp (result, "0x7p-2     33") == 0
675             || strcmp (result, "0xep-3     33") == 0);
676     ASSERT (retval == strlen (result));
677     free (result);
678   }
679
680   { /* FLAG_SHOWSIGN.  */
681     char *result;
682     int retval =
683       my_asprintf (&result, "%+La %d", 1.75L, 33, 44, 55);
684     ASSERT (result != NULL);
685     ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
686             || strcmp (result, "+0x3.8p-1 33") == 0
687             || strcmp (result, "+0x7p-2 33") == 0
688             || strcmp (result, "+0xep-3 33") == 0);
689     ASSERT (retval == strlen (result));
690     free (result);
691   }
692
693   { /* FLAG_SPACE.  */
694     char *result;
695     int retval =
696       my_asprintf (&result, "% La %d", 1.75L, 33, 44, 55);
697     ASSERT (result != NULL);
698     ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
699             || strcmp (result, " 0x3.8p-1 33") == 0
700             || strcmp (result, " 0x7p-2 33") == 0
701             || strcmp (result, " 0xep-3 33") == 0);
702     ASSERT (retval == strlen (result));
703     free (result);
704   }
705
706   { /* FLAG_ALT.  */
707     char *result;
708     int retval =
709       my_asprintf (&result, "%#La %d", 1.75L, 33, 44, 55);
710     ASSERT (result != NULL);
711     ASSERT (strcmp (result, "0x1.cp+0 33") == 0
712             || strcmp (result, "0x3.8p-1 33") == 0
713             || strcmp (result, "0x7.p-2 33") == 0
714             || strcmp (result, "0xe.p-3 33") == 0);
715     ASSERT (retval == strlen (result));
716     free (result);
717   }
718
719   { /* FLAG_ALT.  */
720     char *result;
721     int retval =
722       my_asprintf (&result, "%#La %d", 1.0L, 33, 44, 55);
723     ASSERT (result != NULL);
724     ASSERT (strcmp (result, "0x1.p+0 33") == 0
725             || strcmp (result, "0x2.p-1 33") == 0
726             || strcmp (result, "0x4.p-2 33") == 0
727             || strcmp (result, "0x8.p-3 33") == 0);
728     ASSERT (retval == strlen (result));
729     free (result);
730   }
731
732   { /* FLAG_ZERO with finite number.  */
733     char *result;
734     int retval =
735       my_asprintf (&result, "%010La %d", 1.75L, 33, 44, 55);
736     ASSERT (result != NULL);
737     ASSERT (strcmp (result, "0x001.cp+0 33") == 0
738             || strcmp (result, "0x003.8p-1 33") == 0
739             || strcmp (result, "0x00007p-2 33") == 0
740             || strcmp (result, "0x0000ep-3 33") == 0);
741     ASSERT (retval == strlen (result));
742     free (result);
743   }
744
745   { /* FLAG_ZERO with infinite number.  */
746     char *result;
747     int retval =
748       my_asprintf (&result, "%010La %d", 1.0L / 0.0L, 33, 44, 55);
749     ASSERT (result != NULL);
750     /* "0000000inf 33" is not a valid result; see
751        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
752     ASSERT (strcmp (result, "       inf 33") == 0);
753     ASSERT (retval == strlen (result));
754     free (result);
755   }
756
757   { /* FLAG_ZERO with NaN.  */
758     char *result;
759     int retval =
760       my_asprintf (&result, "%020La %d", 0.0L / 0.0L, 33, 44, 55);
761     ASSERT (result != NULL);
762     /* "0000000nan 33" is not a valid result; see
763        <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
764     ASSERT (strlen (result) == 20 + 3
765             && (memcmp (result + strspn (result, " "), "nan", 3) == 0
766                 || memcmp (result + strspn (result, " "), "-nan", 4) == 0)
767             && strcmp (result + strlen (result) - 3, " 33") == 0);
768     ASSERT (retval == strlen (result));
769     free (result);
770   }
771
772   /* Test the support of the %f format directive.  */
773
774   { /* A positive number.  */
775     char *result;
776     int retval =
777       my_asprintf (&result, "%f %d", 12.75, 33, 44, 55);
778     ASSERT (result != NULL);
779     ASSERT (strcmp (result, "12.750000 33") == 0);
780     ASSERT (retval == strlen (result));
781     free (result);
782   }
783
784   { /* A larger positive number.  */
785     char *result;
786     int retval =
787       my_asprintf (&result, "%f %d", 1234567.0, 33, 44, 55);
788     ASSERT (result != NULL);
789     ASSERT (strcmp (result, "1234567.000000 33") == 0);
790     ASSERT (retval == strlen (result));
791     free (result);
792   }
793
794   { /* Small and large positive numbers.  */
795     static struct { double value; const char *string; } data[] =
796       {
797         { 1.234321234321234e-37, "0.000000" },
798         { 1.234321234321234e-36, "0.000000" },
799         { 1.234321234321234e-35, "0.000000" },
800         { 1.234321234321234e-34, "0.000000" },
801         { 1.234321234321234e-33, "0.000000" },
802         { 1.234321234321234e-32, "0.000000" },
803         { 1.234321234321234e-31, "0.000000" },
804         { 1.234321234321234e-30, "0.000000" },
805         { 1.234321234321234e-29, "0.000000" },
806         { 1.234321234321234e-28, "0.000000" },
807         { 1.234321234321234e-27, "0.000000" },
808         { 1.234321234321234e-26, "0.000000" },
809         { 1.234321234321234e-25, "0.000000" },
810         { 1.234321234321234e-24, "0.000000" },
811         { 1.234321234321234e-23, "0.000000" },
812         { 1.234321234321234e-22, "0.000000" },
813         { 1.234321234321234e-21, "0.000000" },
814         { 1.234321234321234e-20, "0.000000" },
815         { 1.234321234321234e-19, "0.000000" },
816         { 1.234321234321234e-18, "0.000000" },
817         { 1.234321234321234e-17, "0.000000" },
818         { 1.234321234321234e-16, "0.000000" },
819         { 1.234321234321234e-15, "0.000000" },
820         { 1.234321234321234e-14, "0.000000" },
821         { 1.234321234321234e-13, "0.000000" },
822         { 1.234321234321234e-12, "0.000000" },
823         { 1.234321234321234e-11, "0.000000" },
824         { 1.234321234321234e-10, "0.000000" },
825         { 1.234321234321234e-9, "0.000000" },
826         { 1.234321234321234e-8, "0.000000" },
827         { 1.234321234321234e-7, "0.000000" },
828         { 1.234321234321234e-6, "0.000001" },
829         { 1.234321234321234e-5, "0.000012" },
830         { 1.234321234321234e-4, "0.000123" },
831         { 1.234321234321234e-3, "0.001234" },
832         { 1.234321234321234e-2, "0.012343" },
833         { 1.234321234321234e-1, "0.123432" },
834         { 1.234321234321234, "1.234321" },
835         { 1.234321234321234e1, "12.343212" },
836         { 1.234321234321234e2, "123.432123" },
837         { 1.234321234321234e3, "1234.321234" },
838         { 1.234321234321234e4, "12343.212343" },
839         { 1.234321234321234e5, "123432.123432" },
840         { 1.234321234321234e6, "1234321.234321" },
841         { 1.234321234321234e7, "12343212.343212" },
842         { 1.234321234321234e8, "123432123.432123" },
843         { 1.234321234321234e9, "1234321234.321234" },
844         { 1.234321234321234e10, "12343212343.2123**" },
845         { 1.234321234321234e11, "123432123432.123***" },
846         { 1.234321234321234e12, "1234321234321.23****" },
847         { 1.234321234321234e13, "12343212343212.3*****" },
848         { 1.234321234321234e14, "123432123432123.******" },
849         { 1.234321234321234e15, "1234321234321234.000000" },
850         { 1.234321234321234e16, "123432123432123**.000000" },
851         { 1.234321234321234e17, "123432123432123***.000000" },
852         { 1.234321234321234e18, "123432123432123****.000000" },
853         { 1.234321234321234e19, "123432123432123*****.000000" },
854         { 1.234321234321234e20, "123432123432123******.000000" },
855         { 1.234321234321234e21, "123432123432123*******.000000" },
856         { 1.234321234321234e22, "123432123432123********.000000" },
857         { 1.234321234321234e23, "123432123432123*********.000000" },
858         { 1.234321234321234e24, "123432123432123**********.000000" },
859         { 1.234321234321234e25, "123432123432123***********.000000" },
860         { 1.234321234321234e26, "123432123432123************.000000" },
861         { 1.234321234321234e27, "123432123432123*************.000000" },
862         { 1.234321234321234e28, "123432123432123**************.000000" },
863         { 1.234321234321234e29, "123432123432123***************.000000" },
864         { 1.234321234321234e30, "123432123432123****************.000000" },
865         { 1.234321234321234e31, "123432123432123*****************.000000" },
866         { 1.234321234321234e32, "123432123432123******************.000000" },
867         { 1.234321234321234e33, "123432123432123*******************.000000" },
868         { 1.234321234321234e34, "123432123432123********************.000000" },
869         { 1.234321234321234e35, "123432123432123*********************.000000" },
870         { 1.234321234321234e36, "123432123432123**********************.000000" }
871       };
872     size_t k;
873     for (k = 0; k < SIZEOF (data); k++)
874       {
875         char *result;
876         int retval =
877           my_asprintf (&result, "%f", data[k].value);
878         ASSERT (result != NULL);
879         ASSERT (strmatch (data[k].string, result));
880         ASSERT (retval == strlen (result));
881         free (result);
882       }
883   }
884
885   { /* A negative number.  */
886     char *result;
887     int retval =
888       my_asprintf (&result, "%f %d", -0.03125, 33, 44, 55);
889     ASSERT (result != NULL);
890     ASSERT (strcmp (result, "-0.031250 33") == 0);
891     ASSERT (retval == strlen (result));
892     free (result);
893   }
894
895   { /* Positive zero.  */
896     char *result;
897     int retval =
898       my_asprintf (&result, "%f %d", 0.0, 33, 44, 55);
899     ASSERT (result != NULL);
900     ASSERT (strcmp (result, "0.000000 33") == 0);
901     ASSERT (retval == strlen (result));
902     free (result);
903   }
904
905   { /* Negative zero.  */
906     char *result;
907     int retval =
908       my_asprintf (&result, "%f %d", -0.0, 33, 44, 55);
909     ASSERT (result != NULL);
910     if (have_minus_zero ())
911       ASSERT (strcmp (result, "-0.000000 33") == 0);
912     ASSERT (retval == strlen (result));
913     free (result);
914   }
915
916   { /* Positive infinity.  */
917     char *result;
918     int retval =
919       my_asprintf (&result, "%f %d", 1.0 / 0.0, 33, 44, 55);
920     ASSERT (result != NULL);
921     ASSERT (strcmp (result, "inf 33") == 0
922             || strcmp (result, "infinity 33") == 0);
923     ASSERT (retval == strlen (result));
924     free (result);
925   }
926
927   { /* Negative infinity.  */
928     char *result;
929     int retval =
930       my_asprintf (&result, "%f %d", -1.0 / 0.0, 33, 44, 55);
931     ASSERT (result != NULL);
932     ASSERT (strcmp (result, "-inf 33") == 0
933             || strcmp (result, "-infinity 33") == 0);
934     ASSERT (retval == strlen (result));
935     free (result);
936   }
937
938   { /* NaN.  */
939     char *result;
940     int retval =
941       my_asprintf (&result, "%f %d", NaN (), 33, 44, 55);
942     ASSERT (result != NULL);
943     ASSERT (strlen (result) >= 3 + 3
944             && (memcmp (result, "nan", 3) == 0
945                 || memcmp (result, "-nan", 4) == 0)
946             && strcmp (result + strlen (result) - 3, " 33") == 0);
947     ASSERT (retval == strlen (result));
948     free (result);
949   }
950
951   { /* Width.  */
952     char *result;
953     int retval =
954       my_asprintf (&result, "%10f %d", 1.75, 33, 44, 55);
955     ASSERT (result != NULL);
956     ASSERT (strcmp (result, "  1.750000 33") == 0);
957     ASSERT (retval == strlen (result));
958     free (result);
959   }
960
961   { /* FLAG_LEFT.  */
962     char *result;
963     int retval =
964       my_asprintf (&result, "%-10f %d", 1.75, 33, 44, 55);
965     ASSERT (result != NULL);
966     ASSERT (strcmp (result, "1.750000   33") == 0);
967     ASSERT (retval == strlen (result));
968     free (result);
969   }
970
971   { /* FLAG_SHOWSIGN.  */
972     char *result;
973     int retval =
974       my_asprintf (&result, "%+f %d", 1.75, 33, 44, 55);
975     ASSERT (result != NULL);
976     ASSERT (strcmp (result, "+1.750000 33") == 0);
977     ASSERT (retval == strlen (result));
978     free (result);
979   }
980
981   { /* FLAG_SPACE.  */
982     char *result;
983     int retval =
984       my_asprintf (&result, "% f %d", 1.75, 33, 44, 55);
985     ASSERT (result != NULL);
986     ASSERT (strcmp (result, " 1.750000 33") == 0);
987     ASSERT (retval == strlen (result));
988     free (result);
989   }
990
991   { /* FLAG_ALT.  */
992     char *result;
993     int retval =
994       my_asprintf (&result, "%#f %d", 1.75, 33, 44, 55);
995     ASSERT (result != NULL);
996     ASSERT (strcmp (result, "1.750000 33") == 0);
997     ASSERT (retval == strlen (result));
998     free (result);
999   }
1000
1001   { /* FLAG_ALT.  */
1002     char *result;
1003     int retval =
1004       my_asprintf (&result, "%#.f %d", 1.75, 33, 44, 55);
1005     ASSERT (result != NULL);
1006     ASSERT (strcmp (result, "2. 33") == 0);
1007     ASSERT (retval == strlen (result));
1008     free (result);
1009   }
1010
1011   { /* FLAG_ZERO with finite number.  */
1012     char *result;
1013     int retval =
1014       my_asprintf (&result, "%015f %d", 1234.0, 33, 44, 55);
1015     ASSERT (result != NULL);
1016     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1017     ASSERT (retval == strlen (result));
1018     free (result);
1019   }
1020
1021   { /* FLAG_ZERO with infinite number.  */
1022     char *result;
1023     int retval =
1024       my_asprintf (&result, "%015f %d", -1.0 / 0.0, 33, 44, 55);
1025     ASSERT (result != NULL);
1026     ASSERT (strcmp (result, "           -inf 33") == 0
1027             || strcmp (result, "      -infinity 33") == 0);
1028     ASSERT (retval == strlen (result));
1029     free (result);
1030   }
1031
1032   { /* FLAG_ZERO with NaN.  */
1033     char *result;
1034     int retval =
1035       my_asprintf (&result, "%020f %d", NaN (), 33, 44, 55);
1036     ASSERT (result != NULL);
1037     ASSERT (strlen (result) == 20 + 3
1038             && (memcmp (result + strspn (result, " "), "nan", 3) == 0
1039                 || memcmp (result + strspn (result, " "), "-nan", 4) == 0)
1040             && strcmp (result + strlen (result) - 3, " 33") == 0);
1041     ASSERT (retval == strlen (result));
1042     free (result);
1043   }
1044
1045   { /* Precision.  */
1046     char *result;
1047     int retval =
1048       my_asprintf (&result, "%.f %d", 1234.0, 33, 44, 55);
1049     ASSERT (result != NULL);
1050     ASSERT (strcmp (result, "1234 33") == 0);
1051     ASSERT (retval == strlen (result));
1052     free (result);
1053   }
1054
1055   { /* A positive number.  */
1056     char *result;
1057     int retval =
1058       my_asprintf (&result, "%Lf %d", 12.75L, 33, 44, 55);
1059     ASSERT (result != NULL);
1060     ASSERT (strcmp (result, "12.750000 33") == 0);
1061     ASSERT (retval == strlen (result));
1062     free (result);
1063   }
1064
1065   { /* A larger positive number.  */
1066     char *result;
1067     int retval =
1068       my_asprintf (&result, "%Lf %d", 1234567.0L, 33, 44, 55);
1069     ASSERT (result != NULL);
1070     ASSERT (strcmp (result, "1234567.000000 33") == 0);
1071     ASSERT (retval == strlen (result));
1072     free (result);
1073   }
1074
1075   { /* Small and large positive numbers.  */
1076     static struct { long double value; const char *string; } data[] =
1077       {
1078         { 1.234321234321234e-37L, "0.000000" },
1079         { 1.234321234321234e-36L, "0.000000" },
1080         { 1.234321234321234e-35L, "0.000000" },
1081         { 1.234321234321234e-34L, "0.000000" },
1082         { 1.234321234321234e-33L, "0.000000" },
1083         { 1.234321234321234e-32L, "0.000000" },
1084         { 1.234321234321234e-31L, "0.000000" },
1085         { 1.234321234321234e-30L, "0.000000" },
1086         { 1.234321234321234e-29L, "0.000000" },
1087         { 1.234321234321234e-28L, "0.000000" },
1088         { 1.234321234321234e-27L, "0.000000" },
1089         { 1.234321234321234e-26L, "0.000000" },
1090         { 1.234321234321234e-25L, "0.000000" },
1091         { 1.234321234321234e-24L, "0.000000" },
1092         { 1.234321234321234e-23L, "0.000000" },
1093         { 1.234321234321234e-22L, "0.000000" },
1094         { 1.234321234321234e-21L, "0.000000" },
1095         { 1.234321234321234e-20L, "0.000000" },
1096         { 1.234321234321234e-19L, "0.000000" },
1097         { 1.234321234321234e-18L, "0.000000" },
1098         { 1.234321234321234e-17L, "0.000000" },
1099         { 1.234321234321234e-16L, "0.000000" },
1100         { 1.234321234321234e-15L, "0.000000" },
1101         { 1.234321234321234e-14L, "0.000000" },
1102         { 1.234321234321234e-13L, "0.000000" },
1103         { 1.234321234321234e-12L, "0.000000" },
1104         { 1.234321234321234e-11L, "0.000000" },
1105         { 1.234321234321234e-10L, "0.000000" },
1106         { 1.234321234321234e-9L, "0.000000" },
1107         { 1.234321234321234e-8L, "0.000000" },
1108         { 1.234321234321234e-7L, "0.000000" },
1109         { 1.234321234321234e-6L, "0.000001" },
1110         { 1.234321234321234e-5L, "0.000012" },
1111         { 1.234321234321234e-4L, "0.000123" },
1112         { 1.234321234321234e-3L, "0.001234" },
1113         { 1.234321234321234e-2L, "0.012343" },
1114         { 1.234321234321234e-1L, "0.123432" },
1115         { 1.234321234321234L, "1.234321" },
1116         { 1.234321234321234e1L, "12.343212" },
1117         { 1.234321234321234e2L, "123.432123" },
1118         { 1.234321234321234e3L, "1234.321234" },
1119         { 1.234321234321234e4L, "12343.212343" },
1120         { 1.234321234321234e5L, "123432.123432" },
1121         { 1.234321234321234e6L, "1234321.234321" },
1122         { 1.234321234321234e7L, "12343212.343212" },
1123         { 1.234321234321234e8L, "123432123.432123" },
1124         { 1.234321234321234e9L, "1234321234.321234" },
1125         { 1.234321234321234e10L, "12343212343.2123**" },
1126         { 1.234321234321234e11L, "123432123432.123***" },
1127         { 1.234321234321234e12L, "1234321234321.23****" },
1128         { 1.234321234321234e13L, "12343212343212.3*****" },
1129         { 1.234321234321234e14L, "123432123432123.******" },
1130         { 1.234321234321234e15L, "1234321234321234.000000" },
1131         { 1.234321234321234e16L, "123432123432123**.000000" },
1132         { 1.234321234321234e17L, "123432123432123***.000000" },
1133         { 1.234321234321234e18L, "123432123432123****.000000" },
1134         { 1.234321234321234e19L, "123432123432123*****.000000" },
1135         { 1.234321234321234e20L, "123432123432123******.000000" },
1136         { 1.234321234321234e21L, "123432123432123*******.000000" },
1137         { 1.234321234321234e22L, "123432123432123********.000000" },
1138         { 1.234321234321234e23L, "123432123432123*********.000000" },
1139         { 1.234321234321234e24L, "123432123432123**********.000000" },
1140         { 1.234321234321234e25L, "123432123432123***********.000000" },
1141         { 1.234321234321234e26L, "123432123432123************.000000" },
1142         { 1.234321234321234e27L, "123432123432123*************.000000" },
1143         { 1.234321234321234e28L, "123432123432123**************.000000" },
1144         { 1.234321234321234e29L, "123432123432123***************.000000" },
1145         { 1.234321234321234e30L, "123432123432123****************.000000" },
1146         { 1.234321234321234e31L, "123432123432123*****************.000000" },
1147         { 1.234321234321234e32L, "123432123432123******************.000000" },
1148         { 1.234321234321234e33L, "123432123432123*******************.000000" },
1149         { 1.234321234321234e34L, "123432123432123********************.000000" },
1150         { 1.234321234321234e35L, "123432123432123*********************.000000" },
1151         { 1.234321234321234e36L, "123432123432123**********************.000000" }
1152       };
1153     size_t k;
1154     for (k = 0; k < SIZEOF (data); k++)
1155       {
1156         char *result;
1157         int retval =
1158           my_asprintf (&result, "%Lf", data[k].value);
1159         ASSERT (result != NULL);
1160         ASSERT (strmatch (data[k].string, result));
1161         ASSERT (retval == strlen (result));
1162         free (result);
1163       }
1164   }
1165
1166   { /* A negative number.  */
1167     char *result;
1168     int retval =
1169       my_asprintf (&result, "%Lf %d", -0.03125L, 33, 44, 55);
1170     ASSERT (result != NULL);
1171     ASSERT (strcmp (result, "-0.031250 33") == 0);
1172     ASSERT (retval == strlen (result));
1173     free (result);
1174   }
1175
1176   { /* Positive zero.  */
1177     char *result;
1178     int retval =
1179       my_asprintf (&result, "%Lf %d", 0.0L, 33, 44, 55);
1180     ASSERT (result != NULL);
1181     ASSERT (strcmp (result, "0.000000 33") == 0);
1182     ASSERT (retval == strlen (result));
1183     free (result);
1184   }
1185
1186   { /* Negative zero.  */
1187     char *result;
1188     int retval =
1189       my_asprintf (&result, "%Lf %d", -0.0L, 33, 44, 55);
1190     ASSERT (result != NULL);
1191     if (have_minus_zero ())
1192       ASSERT (strcmp (result, "-0.000000 33") == 0);
1193     ASSERT (retval == strlen (result));
1194     free (result);
1195   }
1196
1197   { /* Positive infinity.  */
1198     char *result;
1199     int retval =
1200       my_asprintf (&result, "%Lf %d", 1.0L / 0.0L, 33, 44, 55);
1201     ASSERT (result != NULL);
1202     ASSERT (strcmp (result, "inf 33") == 0
1203             || strcmp (result, "infinity 33") == 0);
1204     ASSERT (retval == strlen (result));
1205     free (result);
1206   }
1207
1208   { /* Negative infinity.  */
1209     char *result;
1210     int retval =
1211       my_asprintf (&result, "%Lf %d", -1.0L / 0.0L, 33, 44, 55);
1212     ASSERT (result != NULL);
1213     ASSERT (strcmp (result, "-inf 33") == 0
1214             || strcmp (result, "-infinity 33") == 0);
1215     ASSERT (retval == strlen (result));
1216     free (result);
1217   }
1218
1219   { /* NaN.  */
1220     static long double zero = 0.0L;
1221     char *result;
1222     int retval =
1223       my_asprintf (&result, "%Lf %d", zero / zero, 33, 44, 55);
1224     ASSERT (result != NULL);
1225     ASSERT (strlen (result) >= 3 + 3
1226             && (memcmp (result, "nan", 3) == 0
1227                 || memcmp (result, "-nan", 4) == 0)
1228             && strcmp (result + strlen (result) - 3, " 33") == 0);
1229     ASSERT (retval == strlen (result));
1230     free (result);
1231   }
1232
1233   { /* Width.  */
1234     char *result;
1235     int retval =
1236       my_asprintf (&result, "%10Lf %d", 1.75L, 33, 44, 55);
1237     ASSERT (result != NULL);
1238     ASSERT (strcmp (result, "  1.750000 33") == 0);
1239     ASSERT (retval == strlen (result));
1240     free (result);
1241   }
1242
1243   { /* FLAG_LEFT.  */
1244     char *result;
1245     int retval =
1246       my_asprintf (&result, "%-10Lf %d", 1.75L, 33, 44, 55);
1247     ASSERT (result != NULL);
1248     ASSERT (strcmp (result, "1.750000   33") == 0);
1249     ASSERT (retval == strlen (result));
1250     free (result);
1251   }
1252
1253   { /* FLAG_SHOWSIGN.  */
1254     char *result;
1255     int retval =
1256       my_asprintf (&result, "%+Lf %d", 1.75L, 33, 44, 55);
1257     ASSERT (result != NULL);
1258     ASSERT (strcmp (result, "+1.750000 33") == 0);
1259     ASSERT (retval == strlen (result));
1260     free (result);
1261   }
1262
1263   { /* FLAG_SPACE.  */
1264     char *result;
1265     int retval =
1266       my_asprintf (&result, "% Lf %d", 1.75L, 33, 44, 55);
1267     ASSERT (result != NULL);
1268     ASSERT (strcmp (result, " 1.750000 33") == 0);
1269     ASSERT (retval == strlen (result));
1270     free (result);
1271   }
1272
1273   { /* FLAG_ALT.  */
1274     char *result;
1275     int retval =
1276       my_asprintf (&result, "%#Lf %d", 1.75L, 33, 44, 55);
1277     ASSERT (result != NULL);
1278     ASSERT (strcmp (result, "1.750000 33") == 0);
1279     ASSERT (retval == strlen (result));
1280     free (result);
1281   }
1282
1283   { /* FLAG_ALT.  */
1284     char *result;
1285     int retval =
1286       my_asprintf (&result, "%#.Lf %d", 1.75L, 33, 44, 55);
1287     ASSERT (result != NULL);
1288     ASSERT (strcmp (result, "2. 33") == 0);
1289     ASSERT (retval == strlen (result));
1290     free (result);
1291   }
1292
1293   { /* FLAG_ZERO with finite number.  */
1294     char *result;
1295     int retval =
1296       my_asprintf (&result, "%015Lf %d", 1234.0L, 33, 44, 55);
1297     ASSERT (result != NULL);
1298     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1299     ASSERT (retval == strlen (result));
1300     free (result);
1301   }
1302
1303   { /* FLAG_ZERO with infinite number.  */
1304     char *result;
1305     int retval =
1306       my_asprintf (&result, "%015Lf %d", -1.0L / 0.0L, 33, 44, 55);
1307     ASSERT (result != NULL);
1308     ASSERT (strcmp (result, "           -inf 33") == 0
1309             || strcmp (result, "      -infinity 33") == 0);
1310     ASSERT (retval == strlen (result));
1311     free (result);
1312   }
1313
1314   { /* FLAG_ZERO with NaN.  */
1315     static long double zero = 0.0L;
1316     char *result;
1317     int retval =
1318       my_asprintf (&result, "%020Lf %d", zero / zero, 33, 44, 55);
1319     ASSERT (result != NULL);
1320     ASSERT (strlen (result) == 20 + 3
1321             && (memcmp (result + strspn (result, " "), "nan", 3) == 0
1322                 || memcmp (result + strspn (result, " "), "-nan", 4) == 0)
1323             && strcmp (result + strlen (result) - 3, " 33") == 0);
1324     ASSERT (retval == strlen (result));
1325     free (result);
1326   }
1327
1328   { /* Precision.  */
1329     char *result;
1330     int retval =
1331       my_asprintf (&result, "%.Lf %d", 1234.0L, 33, 44, 55);
1332     ASSERT (result != NULL);
1333     ASSERT (strcmp (result, "1234 33") == 0);
1334     ASSERT (retval == strlen (result));
1335     free (result);
1336   }
1337
1338   /* Test the support of the %F format directive.  */
1339
1340   { /* A positive number.  */
1341     char *result;
1342     int retval =
1343       my_asprintf (&result, "%F %d", 12.75, 33, 44, 55);
1344     ASSERT (result != NULL);
1345     ASSERT (strcmp (result, "12.750000 33") == 0);
1346     ASSERT (retval == strlen (result));
1347     free (result);
1348   }
1349
1350   { /* A larger positive number.  */
1351     char *result;
1352     int retval =
1353       my_asprintf (&result, "%F %d", 1234567.0, 33, 44, 55);
1354     ASSERT (result != NULL);
1355     ASSERT (strcmp (result, "1234567.000000 33") == 0);
1356     ASSERT (retval == strlen (result));
1357     free (result);
1358   }
1359
1360   { /* A negative number.  */
1361     char *result;
1362     int retval =
1363       my_asprintf (&result, "%F %d", -0.03125, 33, 44, 55);
1364     ASSERT (result != NULL);
1365     ASSERT (strcmp (result, "-0.031250 33") == 0);
1366     ASSERT (retval == strlen (result));
1367     free (result);
1368   }
1369
1370   { /* Positive zero.  */
1371     char *result;
1372     int retval =
1373       my_asprintf (&result, "%F %d", 0.0, 33, 44, 55);
1374     ASSERT (result != NULL);
1375     ASSERT (strcmp (result, "0.000000 33") == 0);
1376     ASSERT (retval == strlen (result));
1377     free (result);
1378   }
1379
1380   { /* Negative zero.  */
1381     char *result;
1382     int retval =
1383       my_asprintf (&result, "%F %d", -0.0, 33, 44, 55);
1384     ASSERT (result != NULL);
1385     if (have_minus_zero ())
1386       ASSERT (strcmp (result, "-0.000000 33") == 0);
1387     ASSERT (retval == strlen (result));
1388     free (result);
1389   }
1390
1391   { /* Positive infinity.  */
1392     char *result;
1393     int retval =
1394       my_asprintf (&result, "%F %d", 1.0 / 0.0, 33, 44, 55);
1395     ASSERT (result != NULL);
1396     ASSERT (strcmp (result, "INF 33") == 0
1397             || strcmp (result, "INFINITY 33") == 0);
1398     ASSERT (retval == strlen (result));
1399     free (result);
1400   }
1401
1402   { /* Negative infinity.  */
1403     char *result;
1404     int retval =
1405       my_asprintf (&result, "%F %d", -1.0 / 0.0, 33, 44, 55);
1406     ASSERT (result != NULL);
1407     ASSERT (strcmp (result, "-INF 33") == 0
1408             || strcmp (result, "-INFINITY 33") == 0);
1409     ASSERT (retval == strlen (result));
1410     free (result);
1411   }
1412
1413   { /* NaN.  */
1414     char *result;
1415     int retval =
1416       my_asprintf (&result, "%F %d", NaN (), 33, 44, 55);
1417     ASSERT (result != NULL);
1418     ASSERT (strlen (result) >= 3 + 3
1419             && (memcmp (result, "NAN", 3) == 0
1420                 || memcmp (result, "-NAN", 4) == 0)
1421             && strcmp (result + strlen (result) - 3, " 33") == 0);
1422     ASSERT (retval == strlen (result));
1423     free (result);
1424   }
1425
1426   { /* FLAG_ZERO.  */
1427     char *result;
1428     int retval =
1429       my_asprintf (&result, "%015F %d", 1234.0, 33, 44, 55);
1430     ASSERT (result != NULL);
1431     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1432     ASSERT (retval == strlen (result));
1433     free (result);
1434   }
1435
1436   { /* FLAG_ZERO with infinite number.  */
1437     char *result;
1438     int retval =
1439       my_asprintf (&result, "%015F %d", -1.0 / 0.0, 33, 44, 55);
1440     ASSERT (result != NULL);
1441     ASSERT (strcmp (result, "           -INF 33") == 0
1442             || strcmp (result, "      -INFINITY 33") == 0);
1443     ASSERT (retval == strlen (result));
1444     free (result);
1445   }
1446
1447   { /* Precision.  */
1448     char *result;
1449     int retval =
1450       my_asprintf (&result, "%.F %d", 1234.0, 33, 44, 55);
1451     ASSERT (result != NULL);
1452     ASSERT (strcmp (result, "1234 33") == 0);
1453     ASSERT (retval == strlen (result));
1454     free (result);
1455   }
1456
1457   { /* A positive number.  */
1458     char *result;
1459     int retval =
1460       my_asprintf (&result, "%LF %d", 12.75L, 33, 44, 55);
1461     ASSERT (result != NULL);
1462     ASSERT (strcmp (result, "12.750000 33") == 0);
1463     ASSERT (retval == strlen (result));
1464     free (result);
1465   }
1466
1467   { /* A larger positive number.  */
1468     char *result;
1469     int retval =
1470       my_asprintf (&result, "%LF %d", 1234567.0L, 33, 44, 55);
1471     ASSERT (result != NULL);
1472     ASSERT (strcmp (result, "1234567.000000 33") == 0);
1473     ASSERT (retval == strlen (result));
1474     free (result);
1475   }
1476
1477   { /* A negative number.  */
1478     char *result;
1479     int retval =
1480       my_asprintf (&result, "%LF %d", -0.03125L, 33, 44, 55);
1481     ASSERT (result != NULL);
1482     ASSERT (strcmp (result, "-0.031250 33") == 0);
1483     ASSERT (retval == strlen (result));
1484     free (result);
1485   }
1486
1487   { /* Positive zero.  */
1488     char *result;
1489     int retval =
1490       my_asprintf (&result, "%LF %d", 0.0L, 33, 44, 55);
1491     ASSERT (result != NULL);
1492     ASSERT (strcmp (result, "0.000000 33") == 0);
1493     ASSERT (retval == strlen (result));
1494     free (result);
1495   }
1496
1497   { /* Negative zero.  */
1498     char *result;
1499     int retval =
1500       my_asprintf (&result, "%LF %d", -0.0L, 33, 44, 55);
1501     ASSERT (result != NULL);
1502     if (have_minus_zero ())
1503       ASSERT (strcmp (result, "-0.000000 33") == 0);
1504     ASSERT (retval == strlen (result));
1505     free (result);
1506   }
1507
1508   { /* Positive infinity.  */
1509     char *result;
1510     int retval =
1511       my_asprintf (&result, "%LF %d", 1.0L / 0.0L, 33, 44, 55);
1512     ASSERT (result != NULL);
1513     ASSERT (strcmp (result, "INF 33") == 0
1514             || strcmp (result, "INFINITY 33") == 0);
1515     ASSERT (retval == strlen (result));
1516     free (result);
1517   }
1518
1519   { /* Negative infinity.  */
1520     char *result;
1521     int retval =
1522       my_asprintf (&result, "%LF %d", -1.0L / 0.0L, 33, 44, 55);
1523     ASSERT (result != NULL);
1524     ASSERT (strcmp (result, "-INF 33") == 0
1525             || strcmp (result, "-INFINITY 33") == 0);
1526     ASSERT (retval == strlen (result));
1527     free (result);
1528   }
1529
1530   { /* NaN.  */
1531     static long double zero = 0.0L;
1532     char *result;
1533     int retval =
1534       my_asprintf (&result, "%LF %d", zero / zero, 33, 44, 55);
1535     ASSERT (result != NULL);
1536     ASSERT (strlen (result) >= 3 + 3
1537             && (memcmp (result, "NAN", 3) == 0
1538                 || memcmp (result, "-NAN", 4) == 0)
1539             && strcmp (result + strlen (result) - 3, " 33") == 0);
1540     ASSERT (retval == strlen (result));
1541     free (result);
1542   }
1543
1544   { /* FLAG_ZERO.  */
1545     char *result;
1546     int retval =
1547       my_asprintf (&result, "%015LF %d", 1234.0L, 33, 44, 55);
1548     ASSERT (result != NULL);
1549     ASSERT (strcmp (result, "00001234.000000 33") == 0);
1550     ASSERT (retval == strlen (result));
1551     free (result);
1552   }
1553
1554   { /* FLAG_ZERO with infinite number.  */
1555     char *result;
1556     int retval =
1557       my_asprintf (&result, "%015LF %d", -1.0L / 0.0L, 33, 44, 55);
1558     ASSERT (result != NULL);
1559     ASSERT (strcmp (result, "           -INF 33") == 0
1560             || strcmp (result, "      -INFINITY 33") == 0);
1561     ASSERT (retval == strlen (result));
1562     free (result);
1563   }
1564
1565   { /* Precision.  */
1566     char *result;
1567     int retval =
1568       my_asprintf (&result, "%.LF %d", 1234.0L, 33, 44, 55);
1569     ASSERT (result != NULL);
1570     ASSERT (strcmp (result, "1234 33") == 0);
1571     ASSERT (retval == strlen (result));
1572     free (result);
1573   }
1574
1575   /* Test the support of the %e format directive.  */
1576
1577   { /* A positive number.  */
1578     char *result;
1579     int retval =
1580       my_asprintf (&result, "%e %d", 12.75, 33, 44, 55);
1581     ASSERT (result != NULL);
1582     ASSERT (strcmp (result, "1.275000e+01 33") == 0
1583             || strcmp (result, "1.275000e+001 33") == 0);
1584     ASSERT (retval == strlen (result));
1585     free (result);
1586   }
1587
1588   { /* A larger positive number.  */
1589     char *result;
1590     int retval =
1591       my_asprintf (&result, "%e %d", 1234567.0, 33, 44, 55);
1592     ASSERT (result != NULL);
1593     ASSERT (strcmp (result, "1.234567e+06 33") == 0
1594             || strcmp (result, "1.234567e+006 33") == 0);
1595     ASSERT (retval == strlen (result));
1596     free (result);
1597   }
1598
1599   { /* Small and large positive numbers.  */
1600     static struct { double value; const char *string; } data[] =
1601       {
1602         { 1.234321234321234e-37, "1.234321e-37" },
1603         { 1.234321234321234e-36, "1.234321e-36" },
1604         { 1.234321234321234e-35, "1.234321e-35" },
1605         { 1.234321234321234e-34, "1.234321e-34" },
1606         { 1.234321234321234e-33, "1.234321e-33" },
1607         { 1.234321234321234e-32, "1.234321e-32" },
1608         { 1.234321234321234e-31, "1.234321e-31" },
1609         { 1.234321234321234e-30, "1.234321e-30" },
1610         { 1.234321234321234e-29, "1.234321e-29" },
1611         { 1.234321234321234e-28, "1.234321e-28" },
1612         { 1.234321234321234e-27, "1.234321e-27" },
1613         { 1.234321234321234e-26, "1.234321e-26" },
1614         { 1.234321234321234e-25, "1.234321e-25" },
1615         { 1.234321234321234e-24, "1.234321e-24" },
1616         { 1.234321234321234e-23, "1.234321e-23" },
1617         { 1.234321234321234e-22, "1.234321e-22" },
1618         { 1.234321234321234e-21, "1.234321e-21" },
1619         { 1.234321234321234e-20, "1.234321e-20" },
1620         { 1.234321234321234e-19, "1.234321e-19" },
1621         { 1.234321234321234e-18, "1.234321e-18" },
1622         { 1.234321234321234e-17, "1.234321e-17" },
1623         { 1.234321234321234e-16, "1.234321e-16" },
1624         { 1.234321234321234e-15, "1.234321e-15" },
1625         { 1.234321234321234e-14, "1.234321e-14" },
1626         { 1.234321234321234e-13, "1.234321e-13" },
1627         { 1.234321234321234e-12, "1.234321e-12" },
1628         { 1.234321234321234e-11, "1.234321e-11" },
1629         { 1.234321234321234e-10, "1.234321e-10" },
1630         { 1.234321234321234e-9, "1.234321e-09" },
1631         { 1.234321234321234e-8, "1.234321e-08" },
1632         { 1.234321234321234e-7, "1.234321e-07" },
1633         { 1.234321234321234e-6, "1.234321e-06" },
1634         { 1.234321234321234e-5, "1.234321e-05" },
1635         { 1.234321234321234e-4, "1.234321e-04" },
1636         { 1.234321234321234e-3, "1.234321e-03" },
1637         { 1.234321234321234e-2, "1.234321e-02" },
1638         { 1.234321234321234e-1, "1.234321e-01" },
1639         { 1.234321234321234, "1.234321e+00" },
1640         { 1.234321234321234e1, "1.234321e+01" },
1641         { 1.234321234321234e2, "1.234321e+02" },
1642         { 1.234321234321234e3, "1.234321e+03" },
1643         { 1.234321234321234e4, "1.234321e+04" },
1644         { 1.234321234321234e5, "1.234321e+05" },
1645         { 1.234321234321234e6, "1.234321e+06" },
1646         { 1.234321234321234e7, "1.234321e+07" },
1647         { 1.234321234321234e8, "1.234321e+08" },
1648         { 1.234321234321234e9, "1.234321e+09" },
1649         { 1.234321234321234e10, "1.234321e+10" },
1650         { 1.234321234321234e11, "1.234321e+11" },
1651         { 1.234321234321234e12, "1.234321e+12" },
1652         { 1.234321234321234e13, "1.234321e+13" },
1653         { 1.234321234321234e14, "1.234321e+14" },
1654         { 1.234321234321234e15, "1.234321e+15" },
1655         { 1.234321234321234e16, "1.234321e+16" },
1656         { 1.234321234321234e17, "1.234321e+17" },
1657         { 1.234321234321234e18, "1.234321e+18" },
1658         { 1.234321234321234e19, "1.234321e+19" },
1659         { 1.234321234321234e20, "1.234321e+20" },
1660         { 1.234321234321234e21, "1.234321e+21" },
1661         { 1.234321234321234e22, "1.234321e+22" },
1662         { 1.234321234321234e23, "1.234321e+23" },
1663         { 1.234321234321234e24, "1.234321e+24" },
1664         { 1.234321234321234e25, "1.234321e+25" },
1665         { 1.234321234321234e26, "1.234321e+26" },
1666         { 1.234321234321234e27, "1.234321e+27" },
1667         { 1.234321234321234e28, "1.234321e+28" },
1668         { 1.234321234321234e29, "1.234321e+29" },
1669         { 1.234321234321234e30, "1.234321e+30" },
1670         { 1.234321234321234e31, "1.234321e+31" },
1671         { 1.234321234321234e32, "1.234321e+32" },
1672         { 1.234321234321234e33, "1.234321e+33" },
1673         { 1.234321234321234e34, "1.234321e+34" },
1674         { 1.234321234321234e35, "1.234321e+35" },
1675         { 1.234321234321234e36, "1.234321e+36" }
1676       };
1677     size_t k;
1678     for (k = 0; k < SIZEOF (data); k++)
1679       {
1680         char *result;
1681         int retval =
1682           my_asprintf (&result, "%e", data[k].value);
1683         const char *expected = data[k].string;
1684         ASSERT (result != NULL);
1685         ASSERT (strcmp (result, expected) == 0
1686                 /* Some implementations produce exponents with 3 digits.  */
1687                 || (strlen (result) == strlen (expected) + 1
1688                     && memcmp (result, expected, strlen (expected) - 2) == 0
1689                     && result[strlen (expected) - 2] == '0'
1690                     && strcmp (result + strlen (expected) - 1,
1691                                expected + strlen (expected) - 2)
1692                        == 0));
1693         ASSERT (retval == strlen (result));
1694         free (result);
1695       }
1696   }
1697
1698   { /* A negative number.  */
1699     char *result;
1700     int retval =
1701       my_asprintf (&result, "%e %d", -0.03125, 33, 44, 55);
1702     ASSERT (result != NULL);
1703     ASSERT (strcmp (result, "-3.125000e-02 33") == 0
1704             || strcmp (result, "-3.125000e-002 33") == 0);
1705     ASSERT (retval == strlen (result));
1706     free (result);
1707   }
1708
1709   { /* Positive zero.  */
1710     char *result;
1711     int retval =
1712       my_asprintf (&result, "%e %d", 0.0, 33, 44, 55);
1713     ASSERT (result != NULL);
1714     ASSERT (strcmp (result, "0.000000e+00 33") == 0
1715             || strcmp (result, "0.000000e+000 33") == 0);
1716     ASSERT (retval == strlen (result));
1717     free (result);
1718   }
1719
1720   { /* Negative zero.  */
1721     char *result;
1722     int retval =
1723       my_asprintf (&result, "%e %d", -0.0, 33, 44, 55);
1724     ASSERT (result != NULL);
1725     if (have_minus_zero ())
1726       ASSERT (strcmp (result, "-0.000000e+00 33") == 0
1727               || strcmp (result, "-0.000000e+000 33") == 0);
1728     ASSERT (retval == strlen (result));
1729     free (result);
1730   }
1731
1732   { /* Positive infinity.  */
1733     char *result;
1734     int retval =
1735       my_asprintf (&result, "%e %d", 1.0 / 0.0, 33, 44, 55);
1736     ASSERT (result != NULL);
1737     ASSERT (strcmp (result, "inf 33") == 0
1738             || strcmp (result, "infinity 33") == 0);
1739     ASSERT (retval == strlen (result));
1740     free (result);
1741   }
1742
1743   { /* Negative infinity.  */
1744     char *result;
1745     int retval =
1746       my_asprintf (&result, "%e %d", -1.0 / 0.0, 33, 44, 55);
1747     ASSERT (result != NULL);
1748     ASSERT (strcmp (result, "-inf 33") == 0
1749             || strcmp (result, "-infinity 33") == 0);
1750     ASSERT (retval == strlen (result));
1751     free (result);
1752   }
1753
1754   { /* NaN.  */
1755     char *result;
1756     int retval =
1757       my_asprintf (&result, "%e %d", NaN (), 33, 44, 55);
1758     ASSERT (result != NULL);
1759     ASSERT (strlen (result) >= 3 + 3
1760             && (memcmp (result, "nan", 3) == 0
1761                 || memcmp (result, "-nan", 4) == 0)
1762             && strcmp (result + strlen (result) - 3, " 33") == 0);
1763     ASSERT (retval == strlen (result));
1764     free (result);
1765   }
1766
1767   { /* Width.  */
1768     char *result;
1769     int retval =
1770       my_asprintf (&result, "%15e %d", 1.75, 33, 44, 55);
1771     ASSERT (result != NULL);
1772     ASSERT (strcmp (result, "   1.750000e+00 33") == 0
1773             || strcmp (result, "  1.750000e+000 33") == 0);
1774     ASSERT (retval == strlen (result));
1775     free (result);
1776   }
1777
1778   { /* FLAG_LEFT.  */
1779     char *result;
1780     int retval =
1781       my_asprintf (&result, "%-15e %d", 1.75, 33, 44, 55);
1782     ASSERT (result != NULL);
1783     ASSERT (strcmp (result, "1.750000e+00    33") == 0
1784             || strcmp (result, "1.750000e+000   33") == 0);
1785     ASSERT (retval == strlen (result));
1786     free (result);
1787   }
1788
1789   { /* FLAG_SHOWSIGN.  */
1790     char *result;
1791     int retval =
1792       my_asprintf (&result, "%+e %d", 1.75, 33, 44, 55);
1793     ASSERT (result != NULL);
1794     ASSERT (strcmp (result, "+1.750000e+00 33") == 0
1795             || strcmp (result, "+1.750000e+000 33") == 0);
1796     ASSERT (retval == strlen (result));
1797     free (result);
1798   }
1799
1800   { /* FLAG_SPACE.  */
1801     char *result;
1802     int retval =
1803       my_asprintf (&result, "% e %d", 1.75, 33, 44, 55);
1804     ASSERT (result != NULL);
1805     ASSERT (strcmp (result, " 1.750000e+00 33") == 0
1806             || strcmp (result, " 1.750000e+000 33") == 0);
1807     ASSERT (retval == strlen (result));
1808     free (result);
1809   }
1810
1811   { /* FLAG_ALT.  */
1812     char *result;
1813     int retval =
1814       my_asprintf (&result, "%#e %d", 1.75, 33, 44, 55);
1815     ASSERT (result != NULL);
1816     ASSERT (strcmp (result, "1.750000e+00 33") == 0
1817             || strcmp (result, "1.750000e+000 33") == 0);
1818     ASSERT (retval == strlen (result));
1819     free (result);
1820   }
1821
1822   { /* FLAG_ALT.  */
1823     char *result;
1824     int retval =
1825       my_asprintf (&result, "%#.e %d", 1.75, 33, 44, 55);
1826     ASSERT (result != NULL);
1827     ASSERT (strcmp (result, "2.e+00 33") == 0
1828             || strcmp (result, "2.e+000 33") == 0);
1829     ASSERT (retval == strlen (result));
1830     free (result);
1831   }
1832
1833   { /* FLAG_ALT.  */
1834     char *result;
1835     int retval =
1836       my_asprintf (&result, "%#.e %d", 9.75, 33, 44, 55);
1837     ASSERT (result != NULL);
1838     ASSERT (strcmp (result, "1.e+01 33") == 0
1839             || strcmp (result, "1.e+001 33") == 0);
1840     ASSERT (retval == strlen (result));
1841     free (result);
1842   }
1843
1844   { /* FLAG_ZERO with finite number.  */
1845     char *result;
1846     int retval =
1847       my_asprintf (&result, "%015e %d", 1234.0, 33, 44, 55);
1848     ASSERT (result != NULL);
1849     ASSERT (strcmp (result, "0001.234000e+03 33") == 0
1850             || strcmp (result, "001.234000e+003 33") == 0);
1851     ASSERT (retval == strlen (result));
1852     free (result);
1853   }
1854
1855   { /* FLAG_ZERO with infinite number.  */
1856     char *result;
1857     int retval =
1858       my_asprintf (&result, "%015e %d", -1.0 / 0.0, 33, 44, 55);
1859     ASSERT (result != NULL);
1860     ASSERT (strcmp (result, "           -inf 33") == 0
1861             || strcmp (result, "      -infinity 33") == 0);
1862     ASSERT (retval == strlen (result));
1863     free (result);
1864   }
1865
1866   { /* FLAG_ZERO with NaN.  */
1867     char *result;
1868     int retval =
1869       my_asprintf (&result, "%020e %d", NaN (), 33, 44, 55);
1870     ASSERT (result != NULL);
1871     ASSERT (strlen (result) == 20 + 3
1872             && (memcmp (result + strspn (result, " "), "nan", 3) == 0
1873                 || memcmp (result + strspn (result, " "), "-nan", 4) == 0)
1874             && strcmp (result + strlen (result) - 3, " 33") == 0);
1875     ASSERT (retval == strlen (result));
1876     free (result);
1877   }
1878
1879   { /* Precision.  */
1880     char *result;
1881     int retval =
1882       my_asprintf (&result, "%.e %d", 1234.0, 33, 44, 55);
1883     ASSERT (result != NULL);
1884     ASSERT (strcmp (result, "1e+03 33") == 0
1885             || strcmp (result, "1e+003 33") == 0);
1886     ASSERT (retval == strlen (result));
1887     free (result);
1888   }
1889
1890   { /* A positive number.  */
1891     char *result;
1892     int retval =
1893       my_asprintf (&result, "%Le %d", 12.75L, 33, 44, 55);
1894     ASSERT (result != NULL);
1895     ASSERT (strcmp (result, "1.275000e+01 33") == 0);
1896     ASSERT (retval == strlen (result));
1897     free (result);
1898   }
1899
1900   { /* A larger positive number.  */
1901     char *result;
1902     int retval =
1903       my_asprintf (&result, "%Le %d", 1234567.0L, 33, 44, 55);
1904     ASSERT (result != NULL);
1905     ASSERT (strcmp (result, "1.234567e+06 33") == 0);
1906     ASSERT (retval == strlen (result));
1907     free (result);
1908   }
1909
1910   { /* Small and large positive numbers.  */
1911     static struct { long double value; const char *string; } data[] =
1912       {
1913         { 1.234321234321234e-37L, "1.234321e-37" },
1914         { 1.234321234321234e-36L, "1.234321e-36" },
1915         { 1.234321234321234e-35L, "1.234321e-35" },
1916         { 1.234321234321234e-34L, "1.234321e-34" },
1917         { 1.234321234321234e-33L, "1.234321e-33" },
1918         { 1.234321234321234e-32L, "1.234321e-32" },
1919         { 1.234321234321234e-31L, "1.234321e-31" },
1920         { 1.234321234321234e-30L, "1.234321e-30" },
1921         { 1.234321234321234e-29L, "1.234321e-29" },
1922         { 1.234321234321234e-28L, "1.234321e-28" },
1923         { 1.234321234321234e-27L, "1.234321e-27" },
1924         { 1.234321234321234e-26L, "1.234321e-26" },
1925         { 1.234321234321234e-25L, "1.234321e-25" },
1926         { 1.234321234321234e-24L, "1.234321e-24" },
1927         { 1.234321234321234e-23L, "1.234321e-23" },
1928         { 1.234321234321234e-22L, "1.234321e-22" },
1929         { 1.234321234321234e-21L, "1.234321e-21" },
1930         { 1.234321234321234e-20L, "1.234321e-20" },
1931         { 1.234321234321234e-19L, "1.234321e-19" },
1932         { 1.234321234321234e-18L, "1.234321e-18" },
1933         { 1.234321234321234e-17L, "1.234321e-17" },
1934         { 1.234321234321234e-16L, "1.234321e-16" },
1935         { 1.234321234321234e-15L, "1.234321e-15" },
1936         { 1.234321234321234e-14L, "1.234321e-14" },
1937         { 1.234321234321234e-13L, "1.234321e-13" },
1938         { 1.234321234321234e-12L, "1.234321e-12" },
1939         { 1.234321234321234e-11L, "1.234321e-11" },
1940         { 1.234321234321234e-10L, "1.234321e-10" },
1941         { 1.234321234321234e-9L, "1.234321e-09" },
1942         { 1.234321234321234e-8L, "1.234321e-08" },
1943         { 1.234321234321234e-7L, "1.234321e-07" },
1944         { 1.234321234321234e-6L, "1.234321e-06" },
1945         { 1.234321234321234e-5L, "1.234321e-05" },
1946         { 1.234321234321234e-4L, "1.234321e-04" },
1947         { 1.234321234321234e-3L, "1.234321e-03" },
1948         { 1.234321234321234e-2L, "1.234321e-02" },
1949         { 1.234321234321234e-1L, "1.234321e-01" },
1950         { 1.234321234321234L, "1.234321e+00" },
1951         { 1.234321234321234e1L, "1.234321e+01" },
1952         { 1.234321234321234e2L, "1.234321e+02" },
1953         { 1.234321234321234e3L, "1.234321e+03" },
1954         { 1.234321234321234e4L, "1.234321e+04" },
1955         { 1.234321234321234e5L, "1.234321e+05" },
1956         { 1.234321234321234e6L, "1.234321e+06" },
1957         { 1.234321234321234e7L, "1.234321e+07" },
1958         { 1.234321234321234e8L, "1.234321e+08" },
1959         { 1.234321234321234e9L, "1.234321e+09" },
1960         { 1.234321234321234e10L, "1.234321e+10" },
1961         { 1.234321234321234e11L, "1.234321e+11" },
1962         { 1.234321234321234e12L, "1.234321e+12" },
1963         { 1.234321234321234e13L, "1.234321e+13" },
1964         { 1.234321234321234e14L, "1.234321e+14" },
1965         { 1.234321234321234e15L, "1.234321e+15" },
1966         { 1.234321234321234e16L, "1.234321e+16" },
1967         { 1.234321234321234e17L, "1.234321e+17" },
1968         { 1.234321234321234e18L, "1.234321e+18" },
1969         { 1.234321234321234e19L, "1.234321e+19" },
1970         { 1.234321234321234e20L, "1.234321e+20" },
1971         { 1.234321234321234e21L, "1.234321e+21" },
1972         { 1.234321234321234e22L, "1.234321e+22" },
1973         { 1.234321234321234e23L, "1.234321e+23" },
1974         { 1.234321234321234e24L, "1.234321e+24" },
1975         { 1.234321234321234e25L, "1.234321e+25" },
1976         { 1.234321234321234e26L, "1.234321e+26" },
1977         { 1.234321234321234e27L, "1.234321e+27" },
1978         { 1.234321234321234e28L, "1.234321e+28" },
1979         { 1.234321234321234e29L, "1.234321e+29" },
1980         { 1.234321234321234e30L, "1.234321e+30" },
1981         { 1.234321234321234e31L, "1.234321e+31" },
1982         { 1.234321234321234e32L, "1.234321e+32" },
1983         { 1.234321234321234e33L, "1.234321e+33" },
1984         { 1.234321234321234e34L, "1.234321e+34" },
1985         { 1.234321234321234e35L, "1.234321e+35" },
1986         { 1.234321234321234e36L, "1.234321e+36" }
1987       };
1988     size_t k;
1989     for (k = 0; k < SIZEOF (data); k++)
1990       {
1991         char *result;
1992         int retval =
1993           my_asprintf (&result, "%Le", data[k].value);
1994         ASSERT (result != NULL);
1995         ASSERT (strcmp (result, data[k].string) == 0);
1996         ASSERT (retval == strlen (result));
1997         free (result);
1998       }
1999   }
2000
2001   { /* A negative number.  */
2002     char *result;
2003     int retval =
2004       my_asprintf (&result, "%Le %d", -0.03125L, 33, 44, 55);
2005     ASSERT (result != NULL);
2006     ASSERT (strcmp (result, "-3.125000e-02 33") == 0);
2007     ASSERT (retval == strlen (result));
2008     free (result);
2009   }
2010
2011   { /* Positive zero.  */
2012     char *result;
2013     int retval =
2014       my_asprintf (&result, "%Le %d", 0.0L, 33, 44, 55);
2015     ASSERT (result != NULL);
2016     ASSERT (strcmp (result, "0.000000e+00 33") == 0);
2017     ASSERT (retval == strlen (result));
2018     free (result);
2019   }
2020
2021   { /* Negative zero.  */
2022     char *result;
2023     int retval =
2024       my_asprintf (&result, "%Le %d", -0.0L, 33, 44, 55);
2025     ASSERT (result != NULL);
2026     if (have_minus_zero ())
2027       ASSERT (strcmp (result, "-0.000000e+00 33") == 0);
2028     ASSERT (retval == strlen (result));
2029     free (result);
2030   }
2031
2032   { /* Positive infinity.  */
2033     char *result;
2034     int retval =
2035       my_asprintf (&result, "%Le %d", 1.0L / 0.0L, 33, 44, 55);
2036     ASSERT (result != NULL);
2037     ASSERT (strcmp (result, "inf 33") == 0
2038             || strcmp (result, "infinity 33") == 0);
2039     ASSERT (retval == strlen (result));
2040     free (result);
2041   }
2042
2043   { /* Negative infinity.  */
2044     char *result;
2045     int retval =
2046       my_asprintf (&result, "%Le %d", -1.0L / 0.0L, 33, 44, 55);
2047     ASSERT (result != NULL);
2048     ASSERT (strcmp (result, "-inf 33") == 0
2049             || strcmp (result, "-infinity 33") == 0);
2050     ASSERT (retval == strlen (result));
2051     free (result);
2052   }
2053
2054   { /* NaN.  */
2055     static long double zero = 0.0L;
2056     char *result;
2057     int retval =
2058       my_asprintf (&result, "%Le %d", zero / zero, 33, 44, 55);
2059     ASSERT (result != NULL);
2060     ASSERT (strlen (result) >= 3 + 3
2061             && (memcmp (result, "nan", 3) == 0
2062                 || memcmp (result, "-nan", 4) == 0)
2063             && strcmp (result + strlen (result) - 3, " 33") == 0);
2064     ASSERT (retval == strlen (result));
2065     free (result);
2066   }
2067
2068   { /* Width.  */
2069     char *result;
2070     int retval =
2071       my_asprintf (&result, "%15Le %d", 1.75L, 33, 44, 55);
2072     ASSERT (result != NULL);
2073     ASSERT (strcmp (result, "   1.750000e+00 33") == 0);
2074     ASSERT (retval == strlen (result));
2075     free (result);
2076   }
2077
2078   { /* FLAG_LEFT.  */
2079     char *result;
2080     int retval =
2081       my_asprintf (&result, "%-15Le %d", 1.75L, 33, 44, 55);
2082     ASSERT (result != NULL);
2083     ASSERT (strcmp (result, "1.750000e+00    33") == 0);
2084     ASSERT (retval == strlen (result));
2085     free (result);
2086   }
2087
2088   { /* FLAG_SHOWSIGN.  */
2089     char *result;
2090     int retval =
2091       my_asprintf (&result, "%+Le %d", 1.75L, 33, 44, 55);
2092     ASSERT (result != NULL);
2093     ASSERT (strcmp (result, "+1.750000e+00 33") == 0);
2094     ASSERT (retval == strlen (result));
2095     free (result);
2096   }
2097
2098   { /* FLAG_SPACE.  */
2099     char *result;
2100     int retval =
2101       my_asprintf (&result, "% Le %d", 1.75L, 33, 44, 55);
2102     ASSERT (result != NULL);
2103     ASSERT (strcmp (result, " 1.750000e+00 33") == 0);
2104     ASSERT (retval == strlen (result));
2105     free (result);
2106   }
2107
2108   { /* FLAG_ALT.  */
2109     char *result;
2110     int retval =
2111       my_asprintf (&result, "%#Le %d", 1.75L, 33, 44, 55);
2112     ASSERT (result != NULL);
2113     ASSERT (strcmp (result, "1.750000e+00 33") == 0);
2114     ASSERT (retval == strlen (result));
2115     free (result);
2116   }
2117
2118   { /* FLAG_ALT.  */
2119     char *result;
2120     int retval =
2121       my_asprintf (&result, "%#.Le %d", 1.75L, 33, 44, 55);
2122     ASSERT (result != NULL);
2123     ASSERT (strcmp (result, "2.e+00 33") == 0);
2124     ASSERT (retval == strlen (result));
2125     free (result);
2126   }
2127
2128   { /* FLAG_ALT.  */
2129     char *result;
2130     int retval =
2131       my_asprintf (&result, "%#.Le %d", 9.75L, 33, 44, 55);
2132     ASSERT (result != NULL);
2133     ASSERT (strcmp (result, "1.e+01 33") == 0);
2134     ASSERT (retval == strlen (result));
2135     free (result);
2136   }
2137
2138   { /* FLAG_ZERO with finite number.  */
2139     char *result;
2140     int retval =
2141       my_asprintf (&result, "%015Le %d", 1234.0L, 33, 44, 55);
2142     ASSERT (result != NULL);
2143     ASSERT (strcmp (result, "0001.234000e+03 33") == 0);
2144     ASSERT (retval == strlen (result));
2145     free (result);
2146   }
2147
2148   { /* FLAG_ZERO with infinite number.  */
2149     char *result;
2150     int retval =
2151       my_asprintf (&result, "%015Le %d", -1.0L / 0.0L, 33, 44, 55);
2152     ASSERT (result != NULL);
2153     ASSERT (strcmp (result, "           -inf 33") == 0
2154             || strcmp (result, "      -infinity 33") == 0);
2155     ASSERT (retval == strlen (result));
2156     free (result);
2157   }
2158
2159   { /* FLAG_ZERO with NaN.  */
2160     static long double zero = 0.0L;
2161     char *result;
2162     int retval =
2163       my_asprintf (&result, "%020Le %d", zero / zero, 33, 44, 55);
2164     ASSERT (result != NULL);
2165     ASSERT (strlen (result) == 20 + 3
2166             && (memcmp (result + strspn (result, " "), "nan", 3) == 0
2167                 || memcmp (result + strspn (result, " "), "-nan", 4) == 0)
2168             && strcmp (result + strlen (result) - 3, " 33") == 0);
2169     ASSERT (retval == strlen (result));
2170     free (result);
2171   }
2172
2173   { /* Precision.  */
2174     char *result;
2175     int retval =
2176       my_asprintf (&result, "%.Le %d", 1234.0L, 33, 44, 55);
2177     ASSERT (result != NULL);
2178     ASSERT (strcmp (result, "1e+03 33") == 0);
2179     ASSERT (retval == strlen (result));
2180     free (result);
2181   }
2182
2183   /* Test the support of the %g format directive.  */
2184
2185   { /* A positive number.  */
2186     char *result;
2187     int retval =
2188       my_asprintf (&result, "%g %d", 12.75, 33, 44, 55);
2189     ASSERT (result != NULL);
2190     ASSERT (strcmp (result, "12.75 33") == 0);
2191     ASSERT (retval == strlen (result));
2192     free (result);
2193   }
2194
2195   { /* A larger positive number.  */
2196     char *result;
2197     int retval =
2198       my_asprintf (&result, "%g %d", 1234567.0, 33, 44, 55);
2199     ASSERT (result != NULL);
2200     ASSERT (strcmp (result, "1.23457e+06 33") == 0
2201             || strcmp (result, "1.23457e+006 33") == 0);
2202     ASSERT (retval == strlen (result));
2203     free (result);
2204   }
2205
2206   { /* Small and large positive numbers.  */
2207     static struct { double value; const char *string; } data[] =
2208       {
2209         { 1.234321234321234e-37, "1.23432e-37" },
2210         { 1.234321234321234e-36, "1.23432e-36" },
2211         { 1.234321234321234e-35, "1.23432e-35" },
2212         { 1.234321234321234e-34, "1.23432e-34" },
2213         { 1.234321234321234e-33, "1.23432e-33" },
2214         { 1.234321234321234e-32, "1.23432e-32" },
2215         { 1.234321234321234e-31, "1.23432e-31" },
2216         { 1.234321234321234e-30, "1.23432e-30" },
2217         { 1.234321234321234e-29, "1.23432e-29" },
2218         { 1.234321234321234e-28, "1.23432e-28" },
2219         { 1.234321234321234e-27, "1.23432e-27" },
2220         { 1.234321234321234e-26, "1.23432e-26" },
2221         { 1.234321234321234e-25, "1.23432e-25" },
2222         { 1.234321234321234e-24, "1.23432e-24" },
2223         { 1.234321234321234e-23, "1.23432e-23" },
2224         { 1.234321234321234e-22, "1.23432e-22" },
2225         { 1.234321234321234e-21, "1.23432e-21" },
2226         { 1.234321234321234e-20, "1.23432e-20" },
2227         { 1.234321234321234e-19, "1.23432e-19" },
2228         { 1.234321234321234e-18, "1.23432e-18" },
2229         { 1.234321234321234e-17, "1.23432e-17" },
2230         { 1.234321234321234e-16, "1.23432e-16" },
2231         { 1.234321234321234e-15, "1.23432e-15" },
2232         { 1.234321234321234e-14, "1.23432e-14" },
2233         { 1.234321234321234e-13, "1.23432e-13" },
2234         { 1.234321234321234e-12, "1.23432e-12" },
2235         { 1.234321234321234e-11, "1.23432e-11" },
2236         { 1.234321234321234e-10, "1.23432e-10" },
2237         { 1.234321234321234e-9, "1.23432e-09" },
2238         { 1.234321234321234e-8, "1.23432e-08" },
2239         { 1.234321234321234e-7, "1.23432e-07" },
2240         { 1.234321234321234e-6, "1.23432e-06" },
2241         { 1.234321234321234e-5, "1.23432e-05" },
2242         { 1.234321234321234e-4, "0.000123432" },
2243         { 1.234321234321234e-3, "0.00123432" },
2244         { 1.234321234321234e-2, "0.0123432" },
2245         { 1.234321234321234e-1, "0.123432" },
2246         { 1.234321234321234, "1.23432" },
2247         { 1.234321234321234e1, "12.3432" },
2248         { 1.234321234321234e2, "123.432" },
2249         { 1.234321234321234e3, "1234.32" },
2250         { 1.234321234321234e4, "12343.2" },
2251         { 1.234321234321234e5, "123432" },
2252         { 1.234321234321234e6, "1.23432e+06" },
2253         { 1.234321234321234e7, "1.23432e+07" },
2254         { 1.234321234321234e8, "1.23432e+08" },
2255         { 1.234321234321234e9, "1.23432e+09" },
2256         { 1.234321234321234e10, "1.23432e+10" },
2257         { 1.234321234321234e11, "1.23432e+11" },
2258         { 1.234321234321234e12, "1.23432e+12" },
2259         { 1.234321234321234e13, "1.23432e+13" },
2260         { 1.234321234321234e14, "1.23432e+14" },
2261         { 1.234321234321234e15, "1.23432e+15" },
2262         { 1.234321234321234e16, "1.23432e+16" },
2263         { 1.234321234321234e17, "1.23432e+17" },
2264         { 1.234321234321234e18, "1.23432e+18" },
2265         { 1.234321234321234e19, "1.23432e+19" },
2266         { 1.234321234321234e20, "1.23432e+20" },
2267         { 1.234321234321234e21, "1.23432e+21" },
2268         { 1.234321234321234e22, "1.23432e+22" },
2269         { 1.234321234321234e23, "1.23432e+23" },
2270         { 1.234321234321234e24, "1.23432e+24" },
2271         { 1.234321234321234e25, "1.23432e+25" },
2272         { 1.234321234321234e26, "1.23432e+26" },
2273         { 1.234321234321234e27, "1.23432e+27" },
2274         { 1.234321234321234e28, "1.23432e+28" },
2275         { 1.234321234321234e29, "1.23432e+29" },
2276         { 1.234321234321234e30, "1.23432e+30" },
2277         { 1.234321234321234e31, "1.23432e+31" },
2278         { 1.234321234321234e32, "1.23432e+32" },
2279         { 1.234321234321234e33, "1.23432e+33" },
2280         { 1.234321234321234e34, "1.23432e+34" },
2281         { 1.234321234321234e35, "1.23432e+35" },
2282         { 1.234321234321234e36, "1.23432e+36" }
2283       };
2284     size_t k;
2285     for (k = 0; k < SIZEOF (data); k++)
2286       {
2287         char *result;
2288         int retval =
2289           my_asprintf (&result, "%g", data[k].value);
2290         const char *expected = data[k].string;
2291         ASSERT (result != NULL);
2292         ASSERT (strcmp (result, expected) == 0
2293                 /* Some implementations produce exponents with 3 digits.  */
2294                 || (expected[strlen (expected) - 4] == 'e'
2295                     && strlen (result) == strlen (expected) + 1
2296                     && memcmp (result, expected, strlen (expected) - 2) == 0
2297                     && result[strlen (expected) - 2] == '0'
2298                     && strcmp (result + strlen (expected) - 1,
2299                                expected + strlen (expected) - 2)
2300                        == 0));
2301         ASSERT (retval == strlen (result));
2302         free (result);
2303       }
2304   }
2305
2306   { /* A negative number.  */
2307     char *result;
2308     int retval =
2309       my_asprintf (&result, "%g %d", -0.03125, 33, 44, 55);
2310     ASSERT (result != NULL);
2311     ASSERT (strcmp (result, "-0.03125 33") == 0);
2312     ASSERT (retval == strlen (result));
2313     free (result);
2314   }
2315
2316   { /* Positive zero.  */
2317     char *result;
2318     int retval =
2319       my_asprintf (&result, "%g %d", 0.0, 33, 44, 55);
2320     ASSERT (result != NULL);
2321     ASSERT (strcmp (result, "0 33") == 0);
2322     ASSERT (retval == strlen (result));
2323     free (result);
2324   }
2325
2326   { /* Negative zero.  */
2327     char *result;
2328     int retval =
2329       my_asprintf (&result, "%g %d", -0.0, 33, 44, 55);
2330     ASSERT (result != NULL);
2331     if (have_minus_zero ())
2332       ASSERT (strcmp (result, "-0 33") == 0);
2333     ASSERT (retval == strlen (result));
2334     free (result);
2335   }
2336
2337   { /* Positive infinity.  */
2338     char *result;
2339     int retval =
2340       my_asprintf (&result, "%g %d", 1.0 / 0.0, 33, 44, 55);
2341     ASSERT (result != NULL);
2342     ASSERT (strcmp (result, "inf 33") == 0
2343             || strcmp (result, "infinity 33") == 0);
2344     ASSERT (retval == strlen (result));
2345     free (result);
2346   }
2347
2348   { /* Negative infinity.  */
2349     char *result;
2350     int retval =
2351       my_asprintf (&result, "%g %d", -1.0 / 0.0, 33, 44, 55);
2352     ASSERT (result != NULL);
2353     ASSERT (strcmp (result, "-inf 33") == 0
2354             || strcmp (result, "-infinity 33") == 0);
2355     ASSERT (retval == strlen (result));
2356     free (result);
2357   }
2358
2359   { /* NaN.  */
2360     char *result;
2361     int retval =
2362       my_asprintf (&result, "%g %d", NaN (), 33, 44, 55);
2363     ASSERT (result != NULL);
2364     ASSERT (strlen (result) >= 3 + 3
2365             && (memcmp (result, "nan", 3) == 0
2366                 || memcmp (result, "-nan", 4) == 0)
2367             && strcmp (result + strlen (result) - 3, " 33") == 0);
2368     ASSERT (retval == strlen (result));
2369     free (result);
2370   }
2371
2372   { /* Width.  */
2373     char *result;
2374     int retval =
2375       my_asprintf (&result, "%10g %d", 1.75, 33, 44, 55);
2376     ASSERT (result != NULL);
2377     ASSERT (strcmp (result, "      1.75 33") == 0);
2378     ASSERT (retval == strlen (result));
2379     free (result);
2380   }
2381
2382   { /* FLAG_LEFT.  */
2383     char *result;
2384     int retval =
2385       my_asprintf (&result, "%-10g %d", 1.75, 33, 44, 55);
2386     ASSERT (result != NULL);
2387     ASSERT (strcmp (result, "1.75       33") == 0);
2388     ASSERT (retval == strlen (result));
2389     free (result);
2390   }
2391
2392   { /* FLAG_SHOWSIGN.  */
2393     char *result;
2394     int retval =
2395       my_asprintf (&result, "%+g %d", 1.75, 33, 44, 55);
2396     ASSERT (result != NULL);
2397     ASSERT (strcmp (result, "+1.75 33") == 0);
2398     ASSERT (retval == strlen (result));
2399     free (result);
2400   }
2401
2402   { /* FLAG_SPACE.  */
2403     char *result;
2404     int retval =
2405       my_asprintf (&result, "% g %d", 1.75, 33, 44, 55);
2406     ASSERT (result != NULL);
2407     ASSERT (strcmp (result, " 1.75 33") == 0);
2408     ASSERT (retval == strlen (result));
2409     free (result);
2410   }
2411
2412   { /* FLAG_ALT.  */
2413     char *result;
2414     int retval =
2415       my_asprintf (&result, "%#g %d", 1.75, 33, 44, 55);
2416     ASSERT (result != NULL);
2417     ASSERT (strcmp (result, "1.75000 33") == 0);
2418     ASSERT (retval == strlen (result));
2419     free (result);
2420   }
2421
2422   { /* FLAG_ALT.  */
2423     char *result;
2424     int retval =
2425       my_asprintf (&result, "%#.g %d", 1.75, 33, 44, 55);
2426     ASSERT (result != NULL);
2427     ASSERT (strcmp (result, "2. 33") == 0);
2428     ASSERT (retval == strlen (result));
2429     free (result);
2430   }
2431
2432   { /* FLAG_ALT.  */
2433     char *result;
2434     int retval =
2435       my_asprintf (&result, "%#.g %d", 9.75, 33, 44, 55);
2436     ASSERT (result != NULL);
2437     ASSERT (strcmp (result, "1.e+01 33") == 0
2438             || strcmp (result, "1.e+001 33") == 0);
2439     ASSERT (retval == strlen (result));
2440     free (result);
2441   }
2442
2443   { /* FLAG_ZERO with finite number.  */
2444     char *result;
2445     int retval =
2446       my_asprintf (&result, "%010g %d", 1234.0, 33, 44, 55);
2447     ASSERT (result != NULL);
2448     ASSERT (strcmp (result, "0000001234 33") == 0);
2449     ASSERT (retval == strlen (result));
2450     free (result);
2451   }
2452
2453   { /* FLAG_ZERO with infinite number.  */
2454     char *result;
2455     int retval =
2456       my_asprintf (&result, "%015g %d", -1.0 / 0.0, 33, 44, 55);
2457     ASSERT (result != NULL);
2458     ASSERT (strcmp (result, "           -inf 33") == 0
2459             || strcmp (result, "      -infinity 33") == 0);
2460     ASSERT (retval == strlen (result));
2461     free (result);
2462   }
2463
2464   { /* FLAG_ZERO with NaN.  */
2465     char *result;
2466     int retval =
2467       my_asprintf (&result, "%020g %d", NaN (), 33, 44, 55);
2468     ASSERT (result != NULL);
2469     ASSERT (strlen (result) == 20 + 3
2470             && (memcmp (result + strspn (result, " "), "nan", 3) == 0
2471                 || memcmp (result + strspn (result, " "), "-nan", 4) == 0)
2472             && strcmp (result + strlen (result) - 3, " 33") == 0);
2473     ASSERT (retval == strlen (result));
2474     free (result);
2475   }
2476
2477   { /* Precision.  */
2478     char *result;
2479     int retval =
2480       my_asprintf (&result, "%.g %d", 1234.0, 33, 44, 55);
2481     ASSERT (result != NULL);
2482     ASSERT (strcmp (result, "1e+03 33") == 0
2483             || strcmp (result, "1e+003 33") == 0);
2484     ASSERT (retval == strlen (result));
2485     free (result);
2486   }
2487
2488   { /* A positive number.  */
2489     char *result;
2490     int retval =
2491       my_asprintf (&result, "%Lg %d", 12.75L, 33, 44, 55);
2492     ASSERT (result != NULL);
2493     ASSERT (strcmp (result, "12.75 33") == 0);
2494     ASSERT (retval == strlen (result));
2495     free (result);
2496   }
2497
2498   { /* A larger positive number.  */
2499     char *result;
2500     int retval =
2501       my_asprintf (&result, "%Lg %d", 1234567.0L, 33, 44, 55);
2502     ASSERT (result != NULL);
2503     ASSERT (strcmp (result, "1.23457e+06 33") == 0);
2504     ASSERT (retval == strlen (result));
2505     free (result);
2506   }
2507
2508   { /* Small and large positive numbers.  */
2509     static struct { long double value; const char *string; } data[] =
2510       {
2511         { 1.234321234321234e-37L, "1.23432e-37" },
2512         { 1.234321234321234e-36L, "1.23432e-36" },
2513         { 1.234321234321234e-35L, "1.23432e-35" },
2514         { 1.234321234321234e-34L, "1.23432e-34" },
2515         { 1.234321234321234e-33L, "1.23432e-33" },
2516         { 1.234321234321234e-32L, "1.23432e-32" },
2517         { 1.234321234321234e-31L, "1.23432e-31" },
2518         { 1.234321234321234e-30L, "1.23432e-30" },
2519         { 1.234321234321234e-29L, "1.23432e-29" },
2520         { 1.234321234321234e-28L, "1.23432e-28" },
2521         { 1.234321234321234e-27L, "1.23432e-27" },
2522         { 1.234321234321234e-26L, "1.23432e-26" },
2523         { 1.234321234321234e-25L, "1.23432e-25" },
2524         { 1.234321234321234e-24L, "1.23432e-24" },
2525         { 1.234321234321234e-23L, "1.23432e-23" },
2526         { 1.234321234321234e-22L, "1.23432e-22" },
2527         { 1.234321234321234e-21L, "1.23432e-21" },
2528         { 1.234321234321234e-20L, "1.23432e-20" },
2529         { 1.234321234321234e-19L, "1.23432e-19" },
2530         { 1.234321234321234e-18L, "1.23432e-18" },
2531         { 1.234321234321234e-17L, "1.23432e-17" },
2532         { 1.234321234321234e-16L, "1.23432e-16" },
2533         { 1.234321234321234e-15L, "1.23432e-15" },
2534         { 1.234321234321234e-14L, "1.23432e-14" },
2535         { 1.234321234321234e-13L, "1.23432e-13" },
2536         { 1.234321234321234e-12L, "1.23432e-12" },
2537         { 1.234321234321234e-11L, "1.23432e-11" },
2538         { 1.234321234321234e-10L, "1.23432e-10" },
2539         { 1.234321234321234e-9L, "1.23432e-09" },
2540         { 1.234321234321234e-8L, "1.23432e-08" },
2541         { 1.234321234321234e-7L, "1.23432e-07" },
2542         { 1.234321234321234e-6L, "1.23432e-06" },
2543         { 1.234321234321234e-5L, "1.23432e-05" },
2544         { 1.234321234321234e-4L, "0.000123432" },
2545         { 1.234321234321234e-3L, "0.00123432" },
2546         { 1.234321234321234e-2L, "0.0123432" },
2547         { 1.234321234321234e-1L, "0.123432" },
2548         { 1.234321234321234L, "1.23432" },
2549         { 1.234321234321234e1L, "12.3432" },
2550         { 1.234321234321234e2L, "123.432" },
2551         { 1.234321234321234e3L, "1234.32" },
2552         { 1.234321234321234e4L, "12343.2" },
2553         { 1.234321234321234e5L, "123432" },
2554         { 1.234321234321234e6L, "1.23432e+06" },
2555         { 1.234321234321234e7L, "1.23432e+07" },
2556         { 1.234321234321234e8L, "1.23432e+08" },
2557         { 1.234321234321234e9L, "1.23432e+09" },
2558         { 1.234321234321234e10L, "1.23432e+10" },
2559         { 1.234321234321234e11L, "1.23432e+11" },
2560         { 1.234321234321234e12L, "1.23432e+12" },
2561         { 1.234321234321234e13L, "1.23432e+13" },
2562         { 1.234321234321234e14L, "1.23432e+14" },
2563         { 1.234321234321234e15L, "1.23432e+15" },
2564         { 1.234321234321234e16L, "1.23432e+16" },
2565         { 1.234321234321234e17L, "1.23432e+17" },
2566         { 1.234321234321234e18L, "1.23432e+18" },
2567         { 1.234321234321234e19L, "1.23432e+19" },
2568         { 1.234321234321234e20L, "1.23432e+20" },
2569         { 1.234321234321234e21L, "1.23432e+21" },
2570         { 1.234321234321234e22L, "1.23432e+22" },
2571         { 1.234321234321234e23L, "1.23432e+23" },
2572         { 1.234321234321234e24L, "1.23432e+24" },
2573         { 1.234321234321234e25L, "1.23432e+25" },
2574         { 1.234321234321234e26L, "1.23432e+26" },
2575         { 1.234321234321234e27L, "1.23432e+27" },
2576         { 1.234321234321234e28L, "1.23432e+28" },
2577         { 1.234321234321234e29L, "1.23432e+29" },
2578         { 1.234321234321234e30L, "1.23432e+30" },
2579         { 1.234321234321234e31L, "1.23432e+31" },
2580         { 1.234321234321234e32L, "1.23432e+32" },
2581         { 1.234321234321234e33L, "1.23432e+33" },
2582         { 1.234321234321234e34L, "1.23432e+34" },
2583         { 1.234321234321234e35L, "1.23432e+35" },
2584         { 1.234321234321234e36L, "1.23432e+36" }
2585       };
2586     size_t k;
2587     for (k = 0; k < SIZEOF (data); k++)
2588       {
2589         char *result;
2590         int retval =
2591           my_asprintf (&result, "%Lg", data[k].value);
2592         ASSERT (result != NULL);
2593         ASSERT (strcmp (result, data[k].string) == 0);
2594         ASSERT (retval == strlen (result));
2595         free (result);
2596       }
2597   }
2598
2599   { /* A negative number.  */
2600     char *result;
2601     int retval =
2602       my_asprintf (&result, "%Lg %d", -0.03125L, 33, 44, 55);
2603     ASSERT (result != NULL);
2604     ASSERT (strcmp (result, "-0.03125 33") == 0);
2605     ASSERT (retval == strlen (result));
2606     free (result);
2607   }
2608
2609   { /* Positive zero.  */
2610     char *result;
2611     int retval =
2612       my_asprintf (&result, "%Lg %d", 0.0L, 33, 44, 55);
2613     ASSERT (result != NULL);
2614     ASSERT (strcmp (result, "0 33") == 0);
2615     ASSERT (retval == strlen (result));
2616     free (result);
2617   }
2618
2619   { /* Negative zero.  */
2620     char *result;
2621     int retval =
2622       my_asprintf (&result, "%Lg %d", -0.0L, 33, 44, 55);
2623     ASSERT (result != NULL);
2624     if (have_minus_zero ())
2625       ASSERT (strcmp (result, "-0 33") == 0);
2626     ASSERT (retval == strlen (result));
2627     free (result);
2628   }
2629
2630   { /* Positive infinity.  */
2631     char *result;
2632     int retval =
2633       my_asprintf (&result, "%Lg %d", 1.0L / 0.0L, 33, 44, 55);
2634     ASSERT (result != NULL);
2635     ASSERT (strcmp (result, "inf 33") == 0
2636             || strcmp (result, "infinity 33") == 0);
2637     ASSERT (retval == strlen (result));
2638     free (result);
2639   }
2640
2641   { /* Negative infinity.  */
2642     char *result;
2643     int retval =
2644       my_asprintf (&result, "%Lg %d", -1.0L / 0.0L, 33, 44, 55);
2645     ASSERT (result != NULL);
2646     ASSERT (strcmp (result, "-inf 33") == 0
2647             || strcmp (result, "-infinity 33") == 0);
2648     ASSERT (retval == strlen (result));
2649     free (result);
2650   }
2651
2652   { /* NaN.  */
2653     static long double zero = 0.0L;
2654     char *result;
2655     int retval =
2656       my_asprintf (&result, "%Lg %d", zero / zero, 33, 44, 55);
2657     ASSERT (result != NULL);
2658     ASSERT (strlen (result) >= 3 + 3
2659             && (memcmp (result, "nan", 3) == 0
2660                 || memcmp (result, "-nan", 4) == 0)
2661             && strcmp (result + strlen (result) - 3, " 33") == 0);
2662     ASSERT (retval == strlen (result));
2663     free (result);
2664   }
2665
2666   { /* Width.  */
2667     char *result;
2668     int retval =
2669       my_asprintf (&result, "%10Lg %d", 1.75L, 33, 44, 55);
2670     ASSERT (result != NULL);
2671     ASSERT (strcmp (result, "      1.75 33") == 0);
2672     ASSERT (retval == strlen (result));
2673     free (result);
2674   }
2675
2676   { /* FLAG_LEFT.  */
2677     char *result;
2678     int retval =
2679       my_asprintf (&result, "%-10Lg %d", 1.75L, 33, 44, 55);
2680     ASSERT (result != NULL);
2681     ASSERT (strcmp (result, "1.75       33") == 0);
2682     ASSERT (retval == strlen (result));
2683     free (result);
2684   }
2685
2686   { /* FLAG_SHOWSIGN.  */
2687     char *result;
2688     int retval =
2689       my_asprintf (&result, "%+Lg %d", 1.75L, 33, 44, 55);
2690     ASSERT (result != NULL);
2691     ASSERT (strcmp (result, "+1.75 33") == 0);
2692     ASSERT (retval == strlen (result));
2693     free (result);
2694   }
2695
2696   { /* FLAG_SPACE.  */
2697     char *result;
2698     int retval =
2699       my_asprintf (&result, "% Lg %d", 1.75L, 33, 44, 55);
2700     ASSERT (result != NULL);
2701     ASSERT (strcmp (result, " 1.75 33") == 0);
2702     ASSERT (retval == strlen (result));
2703     free (result);
2704   }
2705
2706   { /* FLAG_ALT.  */
2707     char *result;
2708     int retval =
2709       my_asprintf (&result, "%#Lg %d", 1.75L, 33, 44, 55);
2710     ASSERT (result != NULL);
2711     ASSERT (strcmp (result, "1.75000 33") == 0);
2712     ASSERT (retval == strlen (result));
2713     free (result);
2714   }
2715
2716   { /* FLAG_ALT.  */
2717     char *result;
2718     int retval =
2719       my_asprintf (&result, "%#.Lg %d", 1.75L, 33, 44, 55);
2720     ASSERT (result != NULL);
2721     ASSERT (strcmp (result, "2. 33") == 0);
2722     ASSERT (retval == strlen (result));
2723     free (result);
2724   }
2725
2726   { /* FLAG_ALT.  */
2727     char *result;
2728     int retval =
2729       my_asprintf (&result, "%#.Lg %d", 9.75L, 33, 44, 55);
2730     ASSERT (result != NULL);
2731     ASSERT (strcmp (result, "1.e+01 33") == 0);
2732     ASSERT (retval == strlen (result));
2733     free (result);
2734   }
2735
2736   { /* FLAG_ZERO with finite number.  */
2737     char *result;
2738     int retval =
2739       my_asprintf (&result, "%010Lg %d", 1234.0L, 33, 44, 55);
2740     ASSERT (result != NULL);
2741     ASSERT (strcmp (result, "0000001234 33") == 0);
2742     ASSERT (retval == strlen (result));
2743     free (result);
2744   }
2745
2746   { /* FLAG_ZERO with infinite number.  */
2747     char *result;
2748     int retval =
2749       my_asprintf (&result, "%015Lg %d", -1.0L / 0.0L, 33, 44, 55);
2750     ASSERT (result != NULL);
2751     ASSERT (strcmp (result, "           -inf 33") == 0
2752             || strcmp (result, "      -infinity 33") == 0);
2753     ASSERT (retval == strlen (result));
2754     free (result);
2755   }
2756
2757   { /* FLAG_ZERO with NaN.  */
2758     static long double zero = 0.0L;
2759     char *result;
2760     int retval =
2761       my_asprintf (&result, "%020Lg %d", zero / zero, 33, 44, 55);
2762     ASSERT (result != NULL);
2763     ASSERT (strlen (result) == 20 + 3
2764             && (memcmp (result + strspn (result, " "), "nan", 3) == 0
2765                 || memcmp (result + strspn (result, " "), "-nan", 4) == 0)
2766             && strcmp (result + strlen (result) - 3, " 33") == 0);
2767     ASSERT (retval == strlen (result));
2768     free (result);
2769   }
2770
2771   { /* Precision.  */
2772     char *result;
2773     int retval =
2774       my_asprintf (&result, "%.Lg %d", 1234.0L, 33, 44, 55);
2775     ASSERT (result != NULL);
2776     ASSERT (strcmp (result, "1e+03 33") == 0);
2777     ASSERT (retval == strlen (result));
2778     free (result);
2779   }
2780
2781   /* Test the support of the %n format directive.  */
2782
2783   {
2784     int count = -1;
2785     char *result;
2786     int retval =
2787       my_asprintf (&result, "%d %n", 123, &count, 33, 44, 55);
2788     ASSERT (result != NULL);
2789     ASSERT (strcmp (result, "123 ") == 0);
2790     ASSERT (retval == strlen (result));
2791     ASSERT (count == 4);
2792     free (result);
2793   }
2794
2795   /* Test the support of the POSIX/XSI format strings with positions.  */
2796
2797   {
2798     char *result;
2799     int retval =
2800       my_asprintf (&result, "%2$d %1$d", 33, 55);
2801     ASSERT (result != NULL);
2802     ASSERT (strcmp (result, "55 33") == 0);
2803     ASSERT (retval == strlen (result));
2804     free (result);
2805   }
2806
2807   /* Test the support of the grouping flag.  */
2808
2809   {
2810     char *result;
2811     int retval =
2812       my_asprintf (&result, "%'d %d", 1234567, 99);
2813     ASSERT (result != NULL);
2814     ASSERT (result[strlen (result) - 1] == '9');
2815     ASSERT (retval == strlen (result));
2816     free (result);
2817   }
2818 }
2819
2820 static int
2821 my_asprintf (char **result, const char *format, ...)
2822 {
2823   va_list args;
2824   int ret;
2825
2826   va_start (args, format);
2827   ret = vasprintf (result, format, args);
2828   va_end (args);
2829   return ret;
2830 }
2831
2832 static void
2833 test_vasprintf ()
2834 {
2835   test_function (my_asprintf);
2836 }
2837
2838 static void
2839 test_asprintf ()
2840 {
2841   test_function (asprintf);
2842 }
2843
2844 int
2845 main (int argc, char *argv[])
2846 {
2847   test_vasprintf ();
2848   test_asprintf ();
2849   return 0;
2850 }
gnulib debian + stable branches