← Back to branch summary

~ubuntu-branches/debian/experimental/parted/experimental

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Otavio Salvador, Otavio Salvador, Colin Watson, Xavier Oswald, Xavier Oswald, Colin Watson
  • Date: 2010-02-06 16:39:19 UTC
  • mfrom: (1.1.4 upstream) (7.1.3 squeeze)
  • Revision ID: james.westby@ubuntu.com-20100206163919-rt7jssmitulmp010
Tags: 2.1-1
http://bugs.debian.org/553824
http://bugs.debian.org/497626
http://bugs.debian.org/487833
http://bugs.debian.org/557044
* New upstream release

[ Otavio Salvador ]
* control.in: bump preferred soname for libreadline (closes: #553824).

[ Colin Watson ]
* control.in: Remove copy-and-paste error from libparted1.8-i18n
  description (closes: #497626).
* copyright: Document parted.info's licence, namely GFDL 1.1 with no
  invariant sections, front-cover texts, or back-cover texts (closes:
  #500201).
* rules: Cell partition tables are misdetected as pc98, so disable pc98
  support on powerpc (closes: #487833).
* control.in: Don't build-depend on libdevmapper-dev on hurd-i386.
* control.in: Build-depend on libdevmapper-dev (>= 1.02.33), for
  dm_task_set_major_minor.

[ Xavier Oswald ]
* debian/control.in: 
  - Change my mail address
  - Bump Standards-Version to 3.8.3
  - Update Build-Depends on debhelper 7
* debian/compat: update version to 7
* Parted not informing the kernel of changes to the partition table 
  (Closes: #557044), fixed upstream

[ Otavio Salvador ]
* debian/watch: fix URL to download
* Switch to quilt to manage patches
  - unpartitioned-disks.dpatch, drop (merged upstream)
  - unblacklist-md.dpatch, drop (merged upstream)
  - amiga-raid-lvm-fix.dpatch, drop (not used for ages)
  - devfs.dpatch, drop (devfs is not used)
  - reiserfs-libname.dpatch, drop (referenced library is unavailable)

[ Xavier Oswald, Colin Watson ]
* Refresh update-ext4-code.patch

[ Otavio Salvador ]
* Fix parted-doc info files installation
* Add lintian overrides for parted package
* Use soname in libparted udeb name

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
 
}