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