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