projects / gnulib.git / blob
? search:


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