← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/parted/intrepid

« back to all changes in this revision

Viewing changes to gnulib/tests/test-snprintf-posix.h

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson
  • Date: 2008-06-24 14:31:05 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20080624143105-rd7yw67a9qnvh51i
Tags: 1.8.8.git.2008.03.24-7ubuntu1
https://launchpad.net/bugs/237568
* Resynchronise with Debian (LP: #237568). Remaining changes:
  - swap-uuid.dpatch: Create UUIDs on new swap partitions.
  - gptsync.dpatch: On Intel Mac systems, write a synced MBR rather than a
    protective MBR.
  - Add -fno-stack-protector on sparc.
  - sparc-new-label.dpatch: Fix sparc disk label generation. This is
    required for LDOM and parallel installations with Solaris 10.
  - loop-partitions.dpatch: Loop devices can only have one partition, so
    don't generate device names such as "/dev/loop0p1".
  - unpartitioned-disks.dpatch: Don't try to call BLKPG ioctls on
    unpartitionable disks (only implemented for loop devices at the
    moment), as they will always fail.
  - When building with gcc-4.3, add -Wno-array-bounds to CFLAGS.
  - Cell partition tables are misdetected as pc98, so disable pc98 support
    on powerpc.
  - array-bounds.dpatch: Backport patch from git to allow building with
    gcc-4.3.

Show diffs side-by-side

added added

removed removed

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