?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
usleep tests: Avoid failure due to known Cygwin 3.5.3 bug.
[gnulib.git] / tests / test-snprintf-posix.h
blob40c45db1bb67258b4b73f87a41d98404ec43770a
1 /* Test of POSIX compatible vsnprintf() and snprintf() functions.
2 Copyright (C) 2007-2024 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 #include "snan.h"
23
24 /* The SGI MIPS floating-point format does not distinguish 0.0 and -0.0. */
25 static int
26 have_minus_zero ()
27 {
28 static double plus_zero = 0.0;
29 double minus_zero = minus_zerod;
30 return memcmp (&plus_zero, &minus_zero, sizeof (double)) != 0;
31 }
32
33 /* Representation of an 80-bit 'long double' as an initializer for a sequence
34 of 'unsigned int' words. */
35 #ifdef WORDS_BIGENDIAN
36 # define LDBL80_WORDS(exponent,manthi,mantlo) \
37 { ((unsigned int) (exponent) << 16) | ((unsigned int) (manthi) >> 16), \
38 ((unsigned int) (manthi) << 16) | ((unsigned int) (mantlo) >> 16), \
39 (unsigned int) (mantlo) << 16 \
40 }
41 #else
42 # define LDBL80_WORDS(exponent,manthi,mantlo) \
43 { mantlo, manthi, exponent }
44 #endif
45
46 static int
47 strmatch (const char *pattern, const char *string)
48 {
49 if (strlen (pattern) != strlen (string))
50 return 0;
51 for (; *pattern != '\0'; pattern++, string++)
52 if (*pattern != '*' && *string != *pattern)
53 return 0;
54 return 1;
55 }
56
57 /* Test whether string[start_index..end_index-1] is a valid textual
58 representation of NaN. */
59 static int
60 strisnan (const char *string, size_t start_index, size_t end_index, int uppercase)
61 {
62 if (start_index < end_index)
63 {
64 if (string[start_index] == '-')
65 start_index++;
66 if (start_index + 3 <= end_index
67 && memcmp (string + start_index, uppercase ? "NAN" : "nan", 3) == 0)
68 {
69 start_index += 3;
70 if (start_index == end_index
71 || (string[start_index] == '(' && string[end_index - 1] == ')'))
72 return 1;
73 }
74 }
75 return 0;
76 }
77
78 static void
79 test_function (int (*my_snprintf) (char *, size_t, const char *, ...))
80 {
81 char buf[8];
82 int size;
83 char result[5000];
84
85 /* Test return value convention. */
86
87 for (size = 0; size <= 8; size++)
88 {
89 int retval;
90
91 memcpy (buf, "DEADBEEF", 8);
92 retval = my_snprintf (buf, size, "%d", 12345);
93 ASSERT (retval == 5);
94 if (size < 6)
95 {
96 if (size > 0)
97 {
98 ASSERT (memcmp (buf, "12345", size - 1) == 0);
99 ASSERT (buf[size - 1] == '\0');
100 }
101 ASSERT (memcmp (buf + size, &"DEADBEEF"[size], 8 - size) == 0);
102 }
103 else
104 {
105 ASSERT (memcmp (buf, "12345\0EF", 8) == 0);
106 }
107 }
108
109 /* Test support of size specifiers as in C99. */
110
111 {
112 int retval =
113 my_snprintf (result, sizeof (result), "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
114 ASSERT (strcmp (result, "12345671 33") == 0);
115 ASSERT (retval == strlen (result));
116 }
117
118 {
119 int retval =
120 my_snprintf (result, sizeof (result), "%zu %d", (size_t) 12345672, 33, 44, 55);
121 ASSERT (strcmp (result, "12345672 33") == 0);
122 ASSERT (retval == strlen (result));
123 }
124
125 {
126 int retval =
127 my_snprintf (result, sizeof (result), "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
128 ASSERT (strcmp (result, "12345673 33") == 0);
129 ASSERT (retval == strlen (result));
130 }
131
132 {
133 int retval =
134 my_snprintf (result, sizeof (result), "%Lg %d", (long double) 1.5, 33, 44, 55);
135 ASSERT (strcmp (result, "1.5 33") == 0);
136 ASSERT (retval == strlen (result));
137 }
138
139 /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
140 output of floating-point numbers. */
141
142 { /* A positive number. */
143 int retval =
144 my_snprintf (result, sizeof (result), "%a %d", 3.1416015625, 33, 44, 55);
145 ASSERT (strcmp (result, "0x1.922p+1 33") == 0
146 || strcmp (result, "0x3.244p+0 33") == 0
147 || strcmp (result, "0x6.488p-1 33") == 0
148 || strcmp (result, "0xc.91p-2 33") == 0);
149 ASSERT (retval == strlen (result));
150 }
151
152 { /* A negative number. */
153 int retval =
154 my_snprintf (result, sizeof (result), "%A %d", -3.1416015625, 33, 44, 55);
155 ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
156 || strcmp (result, "-0X3.244P+0 33") == 0
157 || strcmp (result, "-0X6.488P-1 33") == 0
158 || strcmp (result, "-0XC.91P-2 33") == 0);
159 ASSERT (retval == strlen (result));
160 }
161
162 { /* Positive zero. */
163 int retval =
164 my_snprintf (result, sizeof (result), "%a %d", 0.0, 33, 44, 55);
165 ASSERT (strcmp (result, "0x0p+0 33") == 0);
166 ASSERT (retval == strlen (result));
167 }
168
169 { /* Negative zero. */
170 int retval =
171 my_snprintf (result, sizeof (result), "%a %d", minus_zerod, 33, 44, 55);
172 if (have_minus_zero ())
173 ASSERT (strcmp (result, "-0x0p+0 33") == 0);
174 ASSERT (retval == strlen (result));
175 }
176
177 { /* Positive infinity. */
178 int retval =
179 my_snprintf (result, sizeof (result), "%a %d", Infinityd (), 33, 44, 55);
180 ASSERT (strcmp (result, "inf 33") == 0);
181 ASSERT (retval == strlen (result));
182 }
183
184 { /* Negative infinity. */
185 int retval =
186 my_snprintf (result, sizeof (result), "%a %d", - Infinityd (), 33, 44, 55);
187 ASSERT (strcmp (result, "-inf 33") == 0);
188 ASSERT (retval == strlen (result));
189 }
190
191 { /* NaN. */
192 int retval =
193 my_snprintf (result, sizeof (result), "%a %d", NaNd (), 33, 44, 55);
194 ASSERT (strlen (result) >= 3 + 3
195 && strisnan (result, 0, strlen (result) - 3, 0)
196 && strcmp (result + strlen (result) - 3, " 33") == 0);
197 ASSERT (retval == strlen (result));
198 }
199 #if HAVE_SNAND
200 { /* Signalling NaN. */
201 int retval =
202 my_snprintf (result, sizeof (result), "%a %d", SNaNd (), 33, 44, 55);
203 ASSERT (strlen (result) >= 3 + 3
204 && strisnan (result, 0, strlen (result) - 3, 0)
205 && strcmp (result + strlen (result) - 3, " 33") == 0);
206 ASSERT (retval == strlen (result));
207 }
208 #endif
209
210 { /* Rounding near the decimal point. */
211 int retval =
212 my_snprintf (result, sizeof (result), "%.0a %d", 1.5, 33, 44, 55);
213 ASSERT (strcmp (result, "0x2p+0 33") == 0
214 || strcmp (result, "0x3p-1 33") == 0
215 || strcmp (result, "0x6p-2 33") == 0
216 || strcmp (result, "0xcp-3 33") == 0);
217 ASSERT (retval == strlen (result));
218 }
219
220 { /* Rounding with precision 0. */
221 int retval =
222 my_snprintf (result, sizeof (result), "%.0a %d", 1.51, 33, 44, 55);
223 ASSERT (strcmp (result, "0x2p+0 33") == 0
224 || strcmp (result, "0x3p-1 33") == 0
225 || strcmp (result, "0x6p-2 33") == 0
226 || strcmp (result, "0xcp-3 33") == 0);
227 ASSERT (retval == strlen (result));
228 }
229
230 { /* Rounding with precision 1. */
231 int retval =
232 my_snprintf (result, sizeof (result), "%.1a %d", 1.51, 33, 44, 55);
233 ASSERT (strcmp (result, "0x1.8p+0 33") == 0
234 || strcmp (result, "0x3.0p-1 33") == 0
235 || strcmp (result, "0x6.1p-2 33") == 0
236 || strcmp (result, "0xc.1p-3 33") == 0);
237 ASSERT (retval == strlen (result));
238 }
239
240 { /* Rounding with precision 2. */
241 int retval =
242 my_snprintf (result, sizeof (result), "%.2a %d", 1.51, 33, 44, 55);
243 ASSERT (strcmp (result, "0x1.83p+0 33") == 0
244 || strcmp (result, "0x3.05p-1 33") == 0
245 || strcmp (result, "0x6.0ap-2 33") == 0
246 || strcmp (result, "0xc.14p-3 33") == 0);
247 ASSERT (retval == strlen (result));
248 }
249
250 { /* Rounding with precision 3. */
251 int retval =
252 my_snprintf (result, sizeof (result), "%.3a %d", 1.51, 33, 44, 55);
253 ASSERT (strcmp (result, "0x1.829p+0 33") == 0
254 || strcmp (result, "0x3.052p-1 33") == 0
255 || strcmp (result, "0x6.0a4p-2 33") == 0
256 || strcmp (result, "0xc.148p-3 33") == 0);
257 ASSERT (retval == strlen (result));
258 }
259
260 { /* Rounding can turn a ...FFF into a ...000. */
261 int retval =
262 my_snprintf (result, sizeof (result), "%.3a %d", 1.49999, 33, 44, 55);
263 ASSERT (strcmp (result, "0x1.800p+0 33") == 0
264 || strcmp (result, "0x3.000p-1 33") == 0
265 || strcmp (result, "0x6.000p-2 33") == 0
266 || strcmp (result, "0xc.000p-3 33") == 0);
267 ASSERT (retval == strlen (result));
268 }
269
270 { /* Rounding can turn a ...FFF into a ...000.
271 This shows a Mac OS X 10.3.9 (Darwin 7.9) bug. */
272 int retval =
273 my_snprintf (result, sizeof (result), "%.1a %d", 1.999, 33, 44, 55);
274 ASSERT (strcmp (result, "0x1.0p+1 33") == 0
275 || strcmp (result, "0x2.0p+0 33") == 0
276 || strcmp (result, "0x4.0p-1 33") == 0
277 || strcmp (result, "0x8.0p-2 33") == 0);
278 ASSERT (retval == strlen (result));
279 }
280
281 { /* Width. */
282 int retval =
283 my_snprintf (result, sizeof (result), "%10a %d", 1.75, 33, 44, 55);
284 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
285 || strcmp (result, " 0x3.8p-1 33") == 0
286 || strcmp (result, " 0x7p-2 33") == 0
287 || strcmp (result, " 0xep-3 33") == 0);
288 ASSERT (retval == strlen (result));
289 }
290
291 { /* Width given as argument. */
292 int retval =
293 my_snprintf (result, sizeof (result), "%*a %d", 10, 1.75, 33, 44, 55);
294 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
295 || strcmp (result, " 0x3.8p-1 33") == 0
296 || strcmp (result, " 0x7p-2 33") == 0
297 || strcmp (result, " 0xep-3 33") == 0);
298 ASSERT (retval == strlen (result));
299 }
300
301 { /* Negative width given as argument (cf. FLAG_LEFT below). */
302 int retval =
303 my_snprintf (result, sizeof (result), "%*a %d", -10, 1.75, 33, 44, 55);
304 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
305 || strcmp (result, "0x3.8p-1 33") == 0
306 || strcmp (result, "0x7p-2 33") == 0
307 || strcmp (result, "0xep-3 33") == 0);
308 ASSERT (retval == strlen (result));
309 }
310
311 { /* Small precision. */
312 int retval =
313 my_snprintf (result, sizeof (result), "%.10a %d", 1.75, 33, 44, 55);
314 ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
315 || strcmp (result, "0x3.8000000000p-1 33") == 0
316 || strcmp (result, "0x7.0000000000p-2 33") == 0
317 || strcmp (result, "0xe.0000000000p-3 33") == 0);
318 ASSERT (retval == strlen (result));
319 }
320
321 { /* Large precision. */
322 int retval =
323 my_snprintf (result, sizeof (result), "%.50a %d", 1.75, 33, 44, 55);
324 ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
325 || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
326 || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
327 || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
328 ASSERT (retval == strlen (result));
329 }
330
331 { /* FLAG_LEFT. */
332 int retval =
333 my_snprintf (result, sizeof (result), "%-10a %d", 1.75, 33, 44, 55);
334 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
335 || strcmp (result, "0x3.8p-1 33") == 0
336 || strcmp (result, "0x7p-2 33") == 0
337 || strcmp (result, "0xep-3 33") == 0);
338 ASSERT (retval == strlen (result));
339 }
340
341 { /* FLAG_SHOWSIGN. */
342 int retval =
343 my_snprintf (result, sizeof (result), "%+a %d", 1.75, 33, 44, 55);
344 ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
345 || strcmp (result, "+0x3.8p-1 33") == 0
346 || strcmp (result, "+0x7p-2 33") == 0
347 || strcmp (result, "+0xep-3 33") == 0);
348 ASSERT (retval == strlen (result));
349 }
350
351 { /* FLAG_SPACE. */
352 int retval =
353 my_snprintf (result, sizeof (result), "% a %d", 1.75, 33, 44, 55);
354 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
355 || strcmp (result, " 0x3.8p-1 33") == 0
356 || strcmp (result, " 0x7p-2 33") == 0
357 || strcmp (result, " 0xep-3 33") == 0);
358 ASSERT (retval == strlen (result));
359 }
360
361 { /* FLAG_ALT. */
362 int retval =
363 my_snprintf (result, sizeof (result), "%#a %d", 1.75, 33, 44, 55);
364 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
365 || strcmp (result, "0x3.8p-1 33") == 0
366 || strcmp (result, "0x7.p-2 33") == 0
367 || strcmp (result, "0xe.p-3 33") == 0);
368 ASSERT (retval == strlen (result));
369 }
370
371 { /* FLAG_ALT. */
372 int retval =
373 my_snprintf (result, sizeof (result), "%#a %d", 1.0, 33, 44, 55);
374 ASSERT (strcmp (result, "0x1.p+0 33") == 0
375 || strcmp (result, "0x2.p-1 33") == 0
376 || strcmp (result, "0x4.p-2 33") == 0
377 || strcmp (result, "0x8.p-3 33") == 0);
378 ASSERT (retval == strlen (result));
379 }
380
381 { /* FLAG_ZERO with finite number. */
382 int retval =
383 my_snprintf (result, sizeof (result), "%010a %d", 1.75, 33, 44, 55);
384 ASSERT (strcmp (result, "0x001.cp+0 33") == 0
385 || strcmp (result, "0x003.8p-1 33") == 0
386 || strcmp (result, "0x00007p-2 33") == 0
387 || strcmp (result, "0x0000ep-3 33") == 0);
388 ASSERT (retval == strlen (result));
389 }
390
391 { /* FLAG_ZERO with infinite number. */
392 int retval =
393 my_snprintf (result, sizeof (result), "%010a %d", Infinityd (), 33, 44, 55);
394 /* "0000000inf 33" is not a valid result; see
395 <https://lists.gnu.org/r/bug-gnulib/2007-04/msg00107.html> */
396 ASSERT (strcmp (result, " inf 33") == 0);
397 ASSERT (retval == strlen (result));
398 }
399
400 { /* FLAG_ZERO with NaN. */
401 int retval =
402 my_snprintf (result, sizeof (result), "%050a %d", NaNd (), 33, 44, 55);
403 /* "0000000nan 33" is not a valid result; see
404 <https://lists.gnu.org/r/bug-gnulib/2007-04/msg00107.html> */
405 ASSERT (strlen (result) == 50 + 3
406 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
407 && strcmp (result + strlen (result) - 3, " 33") == 0);
408 ASSERT (retval == strlen (result));
409 }
410
411 { /* A positive number. */
412 int retval =
413 my_snprintf (result, sizeof (result), "%La %d", 3.1416015625L, 33, 44, 55);
414 ASSERT (strcmp (result, "0x1.922p+1 33") == 0
415 || strcmp (result, "0x3.244p+0 33") == 0
416 || strcmp (result, "0x6.488p-1 33") == 0
417 || strcmp (result, "0xc.91p-2 33") == 0);
418 ASSERT (retval == strlen (result));
419 }
420
421 { /* A negative number. */
422 int retval =
423 my_snprintf (result, sizeof (result), "%LA %d", -3.1416015625L, 33, 44, 55);
424 ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
425 || strcmp (result, "-0X3.244P+0 33") == 0
426 || strcmp (result, "-0X6.488P-1 33") == 0
427 || strcmp (result, "-0XC.91P-2 33") == 0);
428 ASSERT (retval == strlen (result));
429 }
430
431 { /* Positive zero. */
432 int retval =
433 my_snprintf (result, sizeof (result), "%La %d", 0.0L, 33, 44, 55);
434 ASSERT (strcmp (result, "0x0p+0 33") == 0);
435 ASSERT (retval == strlen (result));
436 }
437
438 { /* Negative zero. */
439 int retval =
440 my_snprintf (result, sizeof (result), "%La %d", minus_zerol, 33, 44, 55);
441 if (have_minus_zero ())
442 ASSERT (strcmp (result, "-0x0p+0 33") == 0);
443 ASSERT (retval == strlen (result));
444 }
445
446 { /* Positive infinity. */
447 int retval =
448 my_snprintf (result, sizeof (result), "%La %d", Infinityl (), 33, 44, 55);
449 /* Note: This assertion fails under valgrind.
450 Reported at <https://bugs.kde.org/show_bug.cgi?id=424044>. */
451 ASSERT (strcmp (result, "inf 33") == 0);
452 ASSERT (retval == strlen (result));
453 }
454
455 { /* Negative infinity. */
456 int retval =
457 my_snprintf (result, sizeof (result), "%La %d", - Infinityl (), 33, 44, 55);
458 ASSERT (strcmp (result, "-inf 33") == 0);
459 ASSERT (retval == strlen (result));
460 }
461
462 { /* NaN. */
463 int retval =
464 my_snprintf (result, sizeof (result), "%La %d", NaNl (), 33, 44, 55);
465 ASSERT (strlen (result) >= 3 + 3
466 && strisnan (result, 0, strlen (result) - 3, 0)
467 && strcmp (result + strlen (result) - 3, " 33") == 0);
468 ASSERT (retval == strlen (result));
469 }
470 #if HAVE_SNANL
471 { /* Signalling NaN. */
472 int retval =
473 my_snprintf (result, sizeof (result), "%La %d", SNaNl (), 33, 44, 55);
474 ASSERT (strlen (result) >= 3 + 3
475 && strisnan (result, 0, strlen (result) - 3, 0)
476 && strcmp (result + strlen (result) - 3, " 33") == 0);
477 ASSERT (retval == strlen (result));
478 }
479 #endif
480 #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
481 { /* Quiet NaN. */
482 static union { unsigned int word[4]; long double value; } x =
483 { .word = LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
484 int retval =
485 my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
486 ASSERT (strlen (result) >= 3 + 3
487 && strisnan (result, 0, strlen (result) - 3, 0)
488 && strcmp (result + strlen (result) - 3, " 33") == 0);
489 ASSERT (retval == strlen (result));
490 }
491 {
492 /* Signalling NaN. */
493 static union { unsigned int word[4]; long double value; } x =
494 { .word = LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
495 int retval =
496 my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
497 ASSERT (strlen (result) >= 3 + 3
498 && strisnan (result, 0, strlen (result) - 3, 0)
499 && strcmp (result + strlen (result) - 3, " 33") == 0);
500 ASSERT (retval == strlen (result));
501 }
502 /* snprintf should print something for noncanonical values. */
503 { /* Pseudo-NaN. */
504 static union { unsigned int word[4]; long double value; } x =
505 { .word = LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
506 int retval =
507 my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
508 ASSERT (retval == strlen (result));
509 ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
510 }
511 { /* Pseudo-Infinity. */
512 static union { unsigned int word[4]; long double value; } x =
513 { .word = LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
514 int retval =
515 my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
516 ASSERT (retval == strlen (result));
517 ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
518 }
519 { /* Pseudo-Zero. */
520 static union { unsigned int word[4]; long double value; } x =
521 { .word = LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
522 int retval =
523 my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
524 ASSERT (retval == strlen (result));
525 ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
526 }
527 { /* Unnormalized number. */
528 static union { unsigned int word[4]; long double value; } x =
529 { .word = LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
530 int retval =
531 my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
532 ASSERT (retval == strlen (result));
533 ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
534 }
535 { /* Pseudo-Denormal. */
536 static union { unsigned int word[4]; long double value; } x =
537 { .word = LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
538 int retval =
539 my_snprintf (result, sizeof (result), "%La %d", x.value, 33, 44, 55);
540 ASSERT (retval == strlen (result));
541 ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
542 }
543 #endif
544
545 { /* Rounding near the decimal point. */
546 int retval =
547 my_snprintf (result, sizeof (result), "%.0La %d", 1.5L, 33, 44, 55);
548 ASSERT (strcmp (result, "0x2p+0 33") == 0
549 || strcmp (result, "0x3p-1 33") == 0
550 || strcmp (result, "0x6p-2 33") == 0
551 || strcmp (result, "0xcp-3 33") == 0);
552 ASSERT (retval == strlen (result));
553 }
554
555 { /* Rounding with precision 0. */
556 int retval =
557 my_snprintf (result, sizeof (result), "%.0La %d", 1.51L, 33, 44, 55);
558 ASSERT (strcmp (result, "0x2p+0 33") == 0
559 || strcmp (result, "0x3p-1 33") == 0
560 || strcmp (result, "0x6p-2 33") == 0
561 || strcmp (result, "0xcp-3 33") == 0);
562 ASSERT (retval == strlen (result));
563 }
564
565 { /* Rounding with precision 1. */
566 int retval =
567 my_snprintf (result, sizeof (result), "%.1La %d", 1.51L, 33, 44, 55);
568 ASSERT (strcmp (result, "0x1.8p+0 33") == 0
569 || strcmp (result, "0x3.0p-1 33") == 0
570 || strcmp (result, "0x6.1p-2 33") == 0
571 || strcmp (result, "0xc.1p-3 33") == 0);
572 ASSERT (retval == strlen (result));
573 }
574
575 { /* Rounding with precision 2. */
576 int retval =
577 my_snprintf (result, sizeof (result), "%.2La %d", 1.51L, 33, 44, 55);
578 ASSERT (strcmp (result, "0x1.83p+0 33") == 0
579 || strcmp (result, "0x3.05p-1 33") == 0
580 || strcmp (result, "0x6.0ap-2 33") == 0
581 || strcmp (result, "0xc.14p-3 33") == 0);
582 ASSERT (retval == strlen (result));
583 }
584
585 { /* Rounding with precision 3. */
586 int retval =
587 my_snprintf (result, sizeof (result), "%.3La %d", 1.51L, 33, 44, 55);
588 ASSERT (strcmp (result, "0x1.829p+0 33") == 0
589 || strcmp (result, "0x3.052p-1 33") == 0
590 || strcmp (result, "0x6.0a4p-2 33") == 0
591 || strcmp (result, "0xc.148p-3 33") == 0);
592 ASSERT (retval == strlen (result));
593 }
594
595 { /* Rounding can turn a ...FFF into a ...000. */
596 int retval =
597 my_snprintf (result, sizeof (result), "%.3La %d", 1.49999L, 33, 44, 55);
598 ASSERT (strcmp (result, "0x1.800p+0 33") == 0
599 || strcmp (result, "0x3.000p-1 33") == 0
600 || strcmp (result, "0x6.000p-2 33") == 0
601 || strcmp (result, "0xc.000p-3 33") == 0);
602 ASSERT (retval == strlen (result));
603 }
604
605 { /* Rounding can turn a ...FFF into a ...000.
606 This shows a Mac OS X 10.3.9 (Darwin 7.9) bug and a
607 glibc 2.4 bug <https://sourceware.org/bugzilla/show_bug.cgi?id=2908>. */
608 int retval =
609 my_snprintf (result, sizeof (result), "%.1La %d", 1.999L, 33, 44, 55);
610 ASSERT (strcmp (result, "0x1.0p+1 33") == 0
611 || strcmp (result, "0x2.0p+0 33") == 0
612 || strcmp (result, "0x4.0p-1 33") == 0
613 || strcmp (result, "0x8.0p-2 33") == 0);
614 ASSERT (retval == strlen (result));
615 }
616
617 { /* Width. */
618 int retval =
619 my_snprintf (result, sizeof (result), "%10La %d", 1.75L, 33, 44, 55);
620 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
621 || strcmp (result, " 0x3.8p-1 33") == 0
622 || strcmp (result, " 0x7p-2 33") == 0
623 || strcmp (result, " 0xep-3 33") == 0);
624 ASSERT (retval == strlen (result));
625 }
626
627 { /* Width given as argument. */
628 int retval =
629 my_snprintf (result, sizeof (result), "%*La %d", 10, 1.75L, 33, 44, 55);
630 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
631 || strcmp (result, " 0x3.8p-1 33") == 0
632 || strcmp (result, " 0x7p-2 33") == 0
633 || strcmp (result, " 0xep-3 33") == 0);
634 ASSERT (retval == strlen (result));
635 }
636
637 { /* Negative width given as argument (cf. FLAG_LEFT below). */
638 int retval =
639 my_snprintf (result, sizeof (result), "%*La %d", -10, 1.75L, 33, 44, 55);
640 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
641 || strcmp (result, "0x3.8p-1 33") == 0
642 || strcmp (result, "0x7p-2 33") == 0
643 || strcmp (result, "0xep-3 33") == 0);
644 ASSERT (retval == strlen (result));
645 }
646
647 { /* Small precision. */
648 int retval =
649 my_snprintf (result, sizeof (result), "%.10La %d", 1.75L, 33, 44, 55);
650 ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
651 || strcmp (result, "0x3.8000000000p-1 33") == 0
652 || strcmp (result, "0x7.0000000000p-2 33") == 0
653 || strcmp (result, "0xe.0000000000p-3 33") == 0);
654 ASSERT (retval == strlen (result));
655 }
656
657 { /* Large precision. */
658 int retval =
659 my_snprintf (result, sizeof (result), "%.50La %d", 1.75L, 33, 44, 55);
660 ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
661 || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
662 || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
663 || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
664 ASSERT (retval == strlen (result));
665 }
666
667 { /* FLAG_LEFT. */
668 int retval =
669 my_snprintf (result, sizeof (result), "%-10La %d", 1.75L, 33, 44, 55);
670 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
671 || strcmp (result, "0x3.8p-1 33") == 0
672 || strcmp (result, "0x7p-2 33") == 0
673 || strcmp (result, "0xep-3 33") == 0);
674 ASSERT (retval == strlen (result));
675 }
676
677 { /* FLAG_SHOWSIGN. */
678 int retval =
679 my_snprintf (result, sizeof (result), "%+La %d", 1.75L, 33, 44, 55);
680 ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
681 || strcmp (result, "+0x3.8p-1 33") == 0
682 || strcmp (result, "+0x7p-2 33") == 0
683 || strcmp (result, "+0xep-3 33") == 0);
684 ASSERT (retval == strlen (result));
685 }
686
687 { /* FLAG_SPACE. */
688 int retval =
689 my_snprintf (result, sizeof (result), "% La %d", 1.75L, 33, 44, 55);
690 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
691 || strcmp (result, " 0x3.8p-1 33") == 0
692 || strcmp (result, " 0x7p-2 33") == 0
693 || strcmp (result, " 0xep-3 33") == 0);
694 ASSERT (retval == strlen (result));
695 }
696
697 { /* FLAG_ALT. */
698 int retval =
699 my_snprintf (result, sizeof (result), "%#La %d", 1.75L, 33, 44, 55);
700 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
701 || strcmp (result, "0x3.8p-1 33") == 0
702 || strcmp (result, "0x7.p-2 33") == 0
703 || strcmp (result, "0xe.p-3 33") == 0);
704 ASSERT (retval == strlen (result));
705 }
706
707 { /* FLAG_ALT. */
708 int retval =
709 my_snprintf (result, sizeof (result), "%#La %d", 1.0L, 33, 44, 55);
710 ASSERT (strcmp (result, "0x1.p+0 33") == 0
711 || strcmp (result, "0x2.p-1 33") == 0
712 || strcmp (result, "0x4.p-2 33") == 0
713 || strcmp (result, "0x8.p-3 33") == 0);
714 ASSERT (retval == strlen (result));
715 }
716
717 { /* FLAG_ZERO with finite number. */
718 int retval =
719 my_snprintf (result, sizeof (result), "%010La %d", 1.75L, 33, 44, 55);
720 ASSERT (strcmp (result, "0x001.cp+0 33") == 0
721 || strcmp (result, "0x003.8p-1 33") == 0
722 || strcmp (result, "0x00007p-2 33") == 0
723 || strcmp (result, "0x0000ep-3 33") == 0);
724 ASSERT (retval == strlen (result));
725 }
726
727 { /* FLAG_ZERO with infinite number. */
728 int retval =
729 my_snprintf (result, sizeof (result), "%010La %d", Infinityl (), 33, 44, 55);
730 /* "0000000inf 33" is not a valid result; see
731 <https://lists.gnu.org/r/bug-gnulib/2007-04/msg00107.html> */
732 ASSERT (strcmp (result, " inf 33") == 0);
733 ASSERT (retval == strlen (result));
734 }
735
736 { /* FLAG_ZERO with NaN. */
737 int retval =
738 my_snprintf (result, sizeof (result), "%050La %d", NaNl (), 33, 44, 55);
739 /* "0000000nan 33" is not a valid result; see
740 <https://lists.gnu.org/r/bug-gnulib/2007-04/msg00107.html> */
741 ASSERT (strlen (result) == 50 + 3
742 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
743 && strcmp (result + strlen (result) - 3, " 33") == 0);
744 ASSERT (retval == strlen (result));
745 }
746
747 /* Test the support of the %f format directive. */
748
749 { /* A positive number. */
750 int retval =
751 my_snprintf (result, sizeof (result), "%f %d", 12.75, 33, 44, 55);
752 ASSERT (strcmp (result, "12.750000 33") == 0);
753 ASSERT (retval == strlen (result));
754 }
755
756 { /* A larger positive number. */
757 int retval =
758 my_snprintf (result, sizeof (result), "%f %d", 1234567.0, 33, 44, 55);
759 ASSERT (strcmp (result, "1234567.000000 33") == 0);
760 ASSERT (retval == strlen (result));
761 }
762
763 { /* Small and large positive numbers. */
764 static struct { double value; const char *string; } data[] =
765 {
766 { 1.234321234321234e-37, "0.000000" },
767 { 1.234321234321234e-36, "0.000000" },
768 { 1.234321234321234e-35, "0.000000" },
769 { 1.234321234321234e-34, "0.000000" },
770 { 1.234321234321234e-33, "0.000000" },
771 { 1.234321234321234e-32, "0.000000" },
772 { 1.234321234321234e-31, "0.000000" },
773 { 1.234321234321234e-30, "0.000000" },
774 { 1.234321234321234e-29, "0.000000" },
775 { 1.234321234321234e-28, "0.000000" },
776 { 1.234321234321234e-27, "0.000000" },
777 { 1.234321234321234e-26, "0.000000" },
778 { 1.234321234321234e-25, "0.000000" },
779 { 1.234321234321234e-24, "0.000000" },
780 { 1.234321234321234e-23, "0.000000" },
781 { 1.234321234321234e-22, "0.000000" },
782 { 1.234321234321234e-21, "0.000000" },
783 { 1.234321234321234e-20, "0.000000" },
784 { 1.234321234321234e-19, "0.000000" },
785 { 1.234321234321234e-18, "0.000000" },
786 { 1.234321234321234e-17, "0.000000" },
787 { 1.234321234321234e-16, "0.000000" },
788 { 1.234321234321234e-15, "0.000000" },
789 { 1.234321234321234e-14, "0.000000" },
790 { 1.234321234321234e-13, "0.000000" },
791 { 1.234321234321234e-12, "0.000000" },
792 { 1.234321234321234e-11, "0.000000" },
793 { 1.234321234321234e-10, "0.000000" },
794 { 1.234321234321234e-9, "0.000000" },
795 { 1.234321234321234e-8, "0.000000" },
796 { 1.234321234321234e-7, "0.000000" },
797 { 1.234321234321234e-6, "0.000001" },
798 { 1.234321234321234e-5, "0.000012" },
799 { 1.234321234321234e-4, "0.000123" },
800 { 1.234321234321234e-3, "0.001234" },
801 { 1.234321234321234e-2, "0.012343" },
802 { 1.234321234321234e-1, "0.123432" },
803 { 1.234321234321234, "1.234321" },
804 { 1.234321234321234e1, "12.343212" },
805 { 1.234321234321234e2, "123.432123" },
806 { 1.234321234321234e3, "1234.321234" },
807 { 1.234321234321234e4, "12343.212343" },
808 { 1.234321234321234e5, "123432.123432" },
809 { 1.234321234321234e6, "1234321.234321" },
810 { 1.234321234321234e7, "12343212.343212" },
811 { 1.234321234321234e8, "123432123.432123" },
812 { 1.234321234321234e9, "1234321234.321234" },
813 { 1.234321234321234e10, "12343212343.2123**" },
814 { 1.234321234321234e11, "123432123432.123***" },
815 { 1.234321234321234e12, "1234321234321.23****" },
816 { 1.234321234321234e13, "12343212343212.3*****" },
817 { 1.234321234321234e14, "123432123432123.******" },
818 { 1.234321234321234e15, "1234321234321234.000000" },
819 { 1.234321234321234e16, "123432123432123**.000000" },
820 { 1.234321234321234e17, "123432123432123***.000000" },
821 { 1.234321234321234e18, "123432123432123****.000000" },
822 { 1.234321234321234e19, "123432123432123*****.000000" },
823 { 1.234321234321234e20, "123432123432123******.000000" },
824 { 1.234321234321234e21, "123432123432123*******.000000" },
825 { 1.234321234321234e22, "123432123432123********.000000" },
826 { 1.234321234321234e23, "123432123432123*********.000000" },
827 { 1.234321234321234e24, "123432123432123**********.000000" },
828 { 1.234321234321234e25, "123432123432123***********.000000" },
829 { 1.234321234321234e26, "123432123432123************.000000" },
830 { 1.234321234321234e27, "123432123432123*************.000000" },
831 { 1.234321234321234e28, "123432123432123**************.000000" },
832 { 1.234321234321234e29, "123432123432123***************.000000" },
833 { 1.234321234321234e30, "123432123432123****************.000000" },
834 { 1.234321234321234e31, "123432123432123*****************.000000" },
835 { 1.234321234321234e32, "123432123432123******************.000000" },
836 { 1.234321234321234e33, "123432123432123*******************.000000" },
837 { 1.234321234321234e34, "123432123432123********************.000000" },
838 { 1.234321234321234e35, "123432123432123*********************.000000" },
839 { 1.234321234321234e36, "123432123432123**********************.000000" }
840 };
841 size_t k;
842 for (k = 0; k < SIZEOF (data); k++)
843 {
844 int retval =
845 my_snprintf (result, sizeof (result), "%f", data[k].value);
846 ASSERT (strmatch (data[k].string, result));
847 ASSERT (retval == strlen (result));
848 }
849 }
850
851 { /* A negative number. */
852 int retval =
853 my_snprintf (result, sizeof (result), "%f %d", -0.03125, 33, 44, 55);
854 ASSERT (strcmp (result, "-0.031250 33") == 0);
855 ASSERT (retval == strlen (result));
856 }
857
858 { /* Positive zero. */
859 int retval =
860 my_snprintf (result, sizeof (result), "%f %d", 0.0, 33, 44, 55);
861 ASSERT (strcmp (result, "0.000000 33") == 0);
862 ASSERT (retval == strlen (result));
863 }
864
865 { /* Negative zero. */
866 int retval =
867 my_snprintf (result, sizeof (result), "%f %d", minus_zerod, 33, 44, 55);
868 if (have_minus_zero ())
869 ASSERT (strcmp (result, "-0.000000 33") == 0);
870 ASSERT (retval == strlen (result));
871 }
872
873 { /* Positive infinity. */
874 int retval =
875 my_snprintf (result, sizeof (result), "%f %d", Infinityd (), 33, 44, 55);
876 ASSERT (strcmp (result, "inf 33") == 0
877 || strcmp (result, "infinity 33") == 0);
878 ASSERT (retval == strlen (result));
879 }
880
881 { /* Negative infinity. */
882 int retval =
883 my_snprintf (result, sizeof (result), "%f %d", - Infinityd (), 33, 44, 55);
884 ASSERT (strcmp (result, "-inf 33") == 0
885 || strcmp (result, "-infinity 33") == 0);
886 ASSERT (retval == strlen (result));
887 }
888
889 { /* NaN. */
890 int retval =
891 my_snprintf (result, sizeof (result), "%f %d", NaNd (), 33, 44, 55);
892 ASSERT (strlen (result) >= 3 + 3
893 && strisnan (result, 0, strlen (result) - 3, 0)
894 && strcmp (result + strlen (result) - 3, " 33") == 0);
895 ASSERT (retval == strlen (result));
896 }
897 #if HAVE_SNAND
898 { /* Signalling NaN. */
899 int retval =
900 my_snprintf (result, sizeof (result), "%f %d", SNaNd (), 33, 44, 55);
901 ASSERT (strlen (result) >= 3 + 3
902 && strisnan (result, 0, strlen (result) - 3, 0)
903 && strcmp (result + strlen (result) - 3, " 33") == 0);
904 ASSERT (retval == strlen (result));
905 }
906 #endif
907
908 { /* Width. */
909 int retval =
910 my_snprintf (result, sizeof (result), "%10f %d", 1.75, 33, 44, 55);
911 ASSERT (strcmp (result, " 1.750000 33") == 0);
912 ASSERT (retval == strlen (result));
913 }
914
915 { /* Width given as argument. */
916 int retval =
917 my_snprintf (result, sizeof (result), "%*f %d", 10, 1.75, 33, 44, 55);
918 ASSERT (strcmp (result, " 1.750000 33") == 0);
919 ASSERT (retval == strlen (result));
920 }
921
922 { /* Negative width given as argument (cf. FLAG_LEFT below). */
923 int retval =
924 my_snprintf (result, sizeof (result), "%*f %d", -10, 1.75, 33, 44, 55);
925 ASSERT (strcmp (result, "1.750000 33") == 0);
926 ASSERT (retval == strlen (result));
927 }
928
929 { /* FLAG_LEFT. */
930 int retval =
931 my_snprintf (result, sizeof (result), "%-10f %d", 1.75, 33, 44, 55);
932 ASSERT (strcmp (result, "1.750000 33") == 0);
933 ASSERT (retval == strlen (result));
934 }
935
936 { /* FLAG_SHOWSIGN. */
937 int retval =
938 my_snprintf (result, sizeof (result), "%+f %d", 1.75, 33, 44, 55);
939 ASSERT (strcmp (result, "+1.750000 33") == 0);
940 ASSERT (retval == strlen (result));
941 }
942
943 { /* FLAG_SPACE. */
944 int retval =
945 my_snprintf (result, sizeof (result), "% f %d", 1.75, 33, 44, 55);
946 ASSERT (strcmp (result, " 1.750000 33") == 0);
947 ASSERT (retval == strlen (result));
948 }
949
950 { /* FLAG_ALT. */
951 int retval =
952 my_snprintf (result, sizeof (result), "%#f %d", 1.75, 33, 44, 55);
953 ASSERT (strcmp (result, "1.750000 33") == 0);
954 ASSERT (retval == strlen (result));
955 }
956
957 { /* FLAG_ALT. */
958 int retval =
959 my_snprintf (result, sizeof (result), "%#.f %d", 1.75, 33, 44, 55);
960 ASSERT (strcmp (result, "2. 33") == 0);
961 ASSERT (retval == strlen (result));
962 }
963
964 { /* FLAG_ZERO with finite number. */
965 int retval =
966 my_snprintf (result, sizeof (result), "%015f %d", 1234.0, 33, 44, 55);
967 ASSERT (strcmp (result, "00001234.000000 33") == 0);
968 ASSERT (retval == strlen (result));
969 }
970
971 { /* FLAG_ZERO with infinite number. */
972 int retval =
973 my_snprintf (result, sizeof (result), "%015f %d", - Infinityd (), 33, 44, 55);
974 ASSERT (strcmp (result, " -inf 33") == 0
975 || strcmp (result, " -infinity 33") == 0);
976 ASSERT (retval == strlen (result));
977 }
978
979 { /* FLAG_ZERO with NaN. */
980 int retval =
981 my_snprintf (result, sizeof (result), "%050f %d", NaNd (), 33, 44, 55);
982 ASSERT (strlen (result) == 50 + 3
983 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
984 && strcmp (result + strlen (result) - 3, " 33") == 0);
985 ASSERT (retval == strlen (result));
986 }
987
988 { /* Precision. */
989 int retval =
990 my_snprintf (result, sizeof (result), "%.f %d", 1234.0, 33, 44, 55);
991 ASSERT (strcmp (result, "1234 33") == 0);
992 ASSERT (retval == strlen (result));
993 }
994
995 { /* Precision with no rounding. */
996 int retval =
997 my_snprintf (result, sizeof (result), "%.2f %d", 999.951, 33, 44, 55);
998 ASSERT (strcmp (result, "999.95 33") == 0);
999 ASSERT (retval == strlen (result));
1000 }
1001
1002 { /* Precision with rounding. */
1003 int retval =
1004 my_snprintf (result, sizeof (result), "%.2f %d", 999.996, 33, 44, 55);
1005 ASSERT (strcmp (result, "1000.00 33") == 0);
1006 ASSERT (retval == strlen (result));
1007 }
1008
1009 { /* A positive number. */
1010 int retval =
1011 my_snprintf (result, sizeof (result), "%Lf %d", 12.75L, 33, 44, 55);
1012 ASSERT (strcmp (result, "12.750000 33") == 0);
1013 ASSERT (retval == strlen (result));
1014 }
1015
1016 { /* A larger positive number. */
1017 int retval =
1018 my_snprintf (result, sizeof (result), "%Lf %d", 1234567.0L, 33, 44, 55);
1019 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1020 ASSERT (retval == strlen (result));
1021 }
1022
1023 { /* Small and large positive numbers. */
1024 static struct { long double value; const char *string; } data[] =
1025 {
1026 { 1.234321234321234e-37L, "0.000000" },
1027 { 1.234321234321234e-36L, "0.000000" },
1028 { 1.234321234321234e-35L, "0.000000" },
1029 { 1.234321234321234e-34L, "0.000000" },
1030 { 1.234321234321234e-33L, "0.000000" },
1031 { 1.234321234321234e-32L, "0.000000" },
1032 { 1.234321234321234e-31L, "0.000000" },
1033 { 1.234321234321234e-30L, "0.000000" },
1034 { 1.234321234321234e-29L, "0.000000" },
1035 { 1.234321234321234e-28L, "0.000000" },
1036 { 1.234321234321234e-27L, "0.000000" },
1037 { 1.234321234321234e-26L, "0.000000" },
1038 { 1.234321234321234e-25L, "0.000000" },
1039 { 1.234321234321234e-24L, "0.000000" },
1040 { 1.234321234321234e-23L, "0.000000" },
1041 { 1.234321234321234e-22L, "0.000000" },
1042 { 1.234321234321234e-21L, "0.000000" },
1043 { 1.234321234321234e-20L, "0.000000" },
1044 { 1.234321234321234e-19L, "0.000000" },
1045 { 1.234321234321234e-18L, "0.000000" },
1046 { 1.234321234321234e-17L, "0.000000" },
1047 { 1.234321234321234e-16L, "0.000000" },
1048 { 1.234321234321234e-15L, "0.000000" },
1049 { 1.234321234321234e-14L, "0.000000" },
1050 { 1.234321234321234e-13L, "0.000000" },
1051 { 1.234321234321234e-12L, "0.000000" },
1052 { 1.234321234321234e-11L, "0.000000" },
1053 { 1.234321234321234e-10L, "0.000000" },
1054 { 1.234321234321234e-9L, "0.000000" },
1055 { 1.234321234321234e-8L, "0.000000" },
1056 { 1.234321234321234e-7L, "0.000000" },
1057 { 1.234321234321234e-6L, "0.000001" },
1058 { 1.234321234321234e-5L, "0.000012" },
1059 { 1.234321234321234e-4L, "0.000123" },
1060 { 1.234321234321234e-3L, "0.001234" },
1061 { 1.234321234321234e-2L, "0.012343" },
1062 { 1.234321234321234e-1L, "0.123432" },
1063 { 1.234321234321234L, "1.234321" },
1064 { 1.234321234321234e1L, "12.343212" },
1065 { 1.234321234321234e2L, "123.432123" },
1066 { 1.234321234321234e3L, "1234.321234" },
1067 { 1.234321234321234e4L, "12343.212343" },
1068 { 1.234321234321234e5L, "123432.123432" },
1069 { 1.234321234321234e6L, "1234321.234321" },
1070 { 1.234321234321234e7L, "12343212.343212" },
1071 { 1.234321234321234e8L, "123432123.432123" },
1072 { 1.234321234321234e9L, "1234321234.321234" },
1073 { 1.234321234321234e10L, "12343212343.2123**" },
1074 { 1.234321234321234e11L, "123432123432.123***" },
1075 { 1.234321234321234e12L, "1234321234321.23****" },
1076 { 1.234321234321234e13L, "12343212343212.3*****" },
1077 { 1.234321234321234e14L, "123432123432123.******" },
1078 { 1.234321234321234e15L, "1234321234321234.000000" },
1079 { 1.234321234321234e16L, "123432123432123**.000000" },
1080 { 1.234321234321234e17L, "123432123432123***.000000" },
1081 { 1.234321234321234e18L, "123432123432123****.000000" },
1082 { 1.234321234321234e19L, "123432123432123*****.000000" },
1083 { 1.234321234321234e20L, "123432123432123******.000000" },
1084 { 1.234321234321234e21L, "123432123432123*******.000000" },
1085 { 1.234321234321234e22L, "123432123432123********.000000" },
1086 { 1.234321234321234e23L, "123432123432123*********.000000" },
1087 { 1.234321234321234e24L, "123432123432123**********.000000" },
1088 { 1.234321234321234e25L, "123432123432123***********.000000" },
1089 { 1.234321234321234e26L, "123432123432123************.000000" },
1090 { 1.234321234321234e27L, "123432123432123*************.000000" },
1091 { 1.234321234321234e28L, "123432123432123**************.000000" },
1092 { 1.234321234321234e29L, "123432123432123***************.000000" },
1093 { 1.234321234321234e30L, "123432123432123****************.000000" },
1094 { 1.234321234321234e31L, "123432123432123*****************.000000" },
1095 { 1.234321234321234e32L, "123432123432123******************.000000" },
1096 { 1.234321234321234e33L, "123432123432123*******************.000000" },
1097 { 1.234321234321234e34L, "123432123432123********************.000000" },
1098 { 1.234321234321234e35L, "123432123432123*********************.000000" },
1099 { 1.234321234321234e36L, "123432123432123**********************.000000" }
1100 };
1101 size_t k;
1102 for (k = 0; k < SIZEOF (data); k++)
1103 {
1104 int retval =
1105 my_snprintf (result, sizeof (result), "%Lf", data[k].value);
1106 ASSERT (strmatch (data[k].string, result));
1107 ASSERT (retval == strlen (result));
1108 }
1109 }
1110
1111 { /* A negative number. */
1112 int retval =
1113 my_snprintf (result, sizeof (result), "%Lf %d", -0.03125L, 33, 44, 55);
1114 ASSERT (strcmp (result, "-0.031250 33") == 0);
1115 ASSERT (retval == strlen (result));
1116 }
1117
1118 { /* Positive zero. */
1119 int retval =
1120 my_snprintf (result, sizeof (result), "%Lf %d", 0.0L, 33, 44, 55);
1121 ASSERT (strcmp (result, "0.000000 33") == 0);
1122 ASSERT (retval == strlen (result));
1123 }
1124
1125 { /* Negative zero. */
1126 int retval =
1127 my_snprintf (result, sizeof (result), "%Lf %d", minus_zerol, 33, 44, 55);
1128 if (have_minus_zero ())
1129 ASSERT (strcmp (result, "-0.000000 33") == 0);
1130 ASSERT (retval == strlen (result));
1131 }
1132
1133 { /* Positive infinity. */
1134 int retval =
1135 my_snprintf (result, sizeof (result), "%Lf %d", Infinityl (), 33, 44, 55);
1136 ASSERT (strcmp (result, "inf 33") == 0
1137 || strcmp (result, "infinity 33") == 0);
1138 ASSERT (retval == strlen (result));
1139 }
1140
1141 { /* Negative infinity. */
1142 int retval =
1143 my_snprintf (result, sizeof (result), "%Lf %d", - Infinityl (), 33, 44, 55);
1144 ASSERT (strcmp (result, "-inf 33") == 0
1145 || strcmp (result, "-infinity 33") == 0);
1146 ASSERT (retval == strlen (result));
1147 }
1148
1149 { /* NaN. */
1150 int retval =
1151 my_snprintf (result, sizeof (result), "%Lf %d", NaNl (), 33, 44, 55);
1152 ASSERT (strlen (result) >= 3 + 3
1153 && strisnan (result, 0, strlen (result) - 3, 0)
1154 && strcmp (result + strlen (result) - 3, " 33") == 0);
1155 ASSERT (retval == strlen (result));
1156 }
1157 #if HAVE_SNANL
1158 { /* Signalling NaN. */
1159 int retval =
1160 my_snprintf (result, sizeof (result), "%Lf %d", SNaNl (), 33, 44, 55);
1161 ASSERT (strlen (result) >= 3 + 3
1162 && strisnan (result, 0, strlen (result) - 3, 0)
1163 && strcmp (result + strlen (result) - 3, " 33") == 0);
1164 ASSERT (retval == strlen (result));
1165 }
1166 #endif
1167 #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
1168 { /* Quiet NaN. */
1169 static union { unsigned int word[4]; long double value; } x =
1170 { .word = LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
1171 int retval =
1172 my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
1173 ASSERT (strlen (result) >= 3 + 3
1174 && strisnan (result, 0, strlen (result) - 3, 0)
1175 && strcmp (result + strlen (result) - 3, " 33") == 0);
1176 ASSERT (retval == strlen (result));
1177 }
1178 {
1179 /* Signalling NaN. */
1180 static union { unsigned int word[4]; long double value; } x =
1181 { .word = LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
1182 int retval =
1183 my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
1184 ASSERT (strlen (result) >= 3 + 3
1185 && strisnan (result, 0, strlen (result) - 3, 0)
1186 && strcmp (result + strlen (result) - 3, " 33") == 0);
1187 ASSERT (retval == strlen (result));
1188 }
1189 /* snprintf should print something for noncanonical values. */
1190 { /* Pseudo-NaN. */
1191 static union { unsigned int word[4]; long double value; } x =
1192 { .word = LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
1193 int retval =
1194 my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
1195 ASSERT (retval == strlen (result));
1196 ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
1197 }
1198 { /* Pseudo-Infinity. */
1199 static union { unsigned int word[4]; long double value; } x =
1200 { .word = LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
1201 int retval =
1202 my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
1203 ASSERT (retval == strlen (result));
1204 ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
1205 }
1206 { /* Pseudo-Zero. */
1207 static union { unsigned int word[4]; long double value; } x =
1208 { .word = LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
1209 int retval =
1210 my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
1211 ASSERT (retval == strlen (result));
1212 ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
1213 }
1214 { /* Unnormalized number. */
1215 static union { unsigned int word[4]; long double value; } x =
1216 { .word = LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
1217 int retval =
1218 my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
1219 ASSERT (retval == strlen (result));
1220 ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
1221 }
1222 { /* Pseudo-Denormal. */
1223 static union { unsigned int word[4]; long double value; } x =
1224 { .word = LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
1225 int retval =
1226 my_snprintf (result, sizeof (result), "%Lf %d", x.value, 33, 44, 55);
1227 ASSERT (retval == strlen (result));
1228 ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
1229 }
1230 #endif
1231
1232 { /* Width. */
1233 int retval =
1234 my_snprintf (result, sizeof (result), "%10Lf %d", 1.75L, 33, 44, 55);
1235 ASSERT (strcmp (result, " 1.750000 33") == 0);
1236 ASSERT (retval == strlen (result));
1237 }
1238
1239 { /* Width given as argument. */
1240 int retval =
1241 my_snprintf (result, sizeof (result), "%*Lf %d", 10, 1.75L, 33, 44, 55);
1242 ASSERT (strcmp (result, " 1.750000 33") == 0);
1243 ASSERT (retval == strlen (result));
1244 }
1245
1246 { /* Negative width given as argument (cf. FLAG_LEFT below). */
1247 int retval =
1248 my_snprintf (result, sizeof (result), "%*Lf %d", -10, 1.75L, 33, 44, 55);
1249 ASSERT (strcmp (result, "1.750000 33") == 0);
1250 ASSERT (retval == strlen (result));
1251 }
1252
1253 { /* FLAG_LEFT. */
1254 int retval =
1255 my_snprintf (result, sizeof (result), "%-10Lf %d", 1.75L, 33, 44, 55);
1256 ASSERT (strcmp (result, "1.750000 33") == 0);
1257 ASSERT (retval == strlen (result));
1258 }
1259
1260 { /* FLAG_SHOWSIGN. */
1261 int retval =
1262 my_snprintf (result, sizeof (result), "%+Lf %d", 1.75L, 33, 44, 55);
1263 ASSERT (strcmp (result, "+1.750000 33") == 0);
1264 ASSERT (retval == strlen (result));
1265 }
1266
1267 { /* FLAG_SPACE. */
1268 int retval =
1269 my_snprintf (result, sizeof (result), "% Lf %d", 1.75L, 33, 44, 55);
1270 ASSERT (strcmp (result, " 1.750000 33") == 0);
1271 ASSERT (retval == strlen (result));
1272 }
1273
1274 { /* FLAG_ALT. */
1275 int retval =
1276 my_snprintf (result, sizeof (result), "%#Lf %d", 1.75L, 33, 44, 55);
1277 ASSERT (strcmp (result, "1.750000 33") == 0);
1278 ASSERT (retval == strlen (result));
1279 }
1280
1281 { /* FLAG_ALT. */
1282 int retval =
1283 my_snprintf (result, sizeof (result), "%#.Lf %d", 1.75L, 33, 44, 55);
1284 ASSERT (strcmp (result, "2. 33") == 0);
1285 ASSERT (retval == strlen (result));
1286 }
1287
1288 { /* FLAG_ZERO with finite number. */
1289 int retval =
1290 my_snprintf (result, sizeof (result), "%015Lf %d", 1234.0L, 33, 44, 55);
1291 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1292 ASSERT (retval == strlen (result));
1293 }
1294
1295 { /* FLAG_ZERO with infinite number. */
1296 int retval =
1297 my_snprintf (result, sizeof (result), "%015Lf %d", - Infinityl (), 33, 44, 55);
1298 ASSERT (strcmp (result, " -inf 33") == 0
1299 || strcmp (result, " -infinity 33") == 0);
1300 ASSERT (retval == strlen (result));
1301 }
1302
1303 { /* FLAG_ZERO with NaN. */
1304 int retval =
1305 my_snprintf (result, sizeof (result), "%050Lf %d", NaNl (), 33, 44, 55);
1306 ASSERT (strlen (result) == 50 + 3
1307 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1308 && strcmp (result + strlen (result) - 3, " 33") == 0);
1309 ASSERT (retval == strlen (result));
1310 }
1311
1312 { /* Precision. */
1313 int retval =
1314 my_snprintf (result, sizeof (result), "%.Lf %d", 1234.0L, 33, 44, 55);
1315 ASSERT (strcmp (result, "1234 33") == 0);
1316 ASSERT (retval == strlen (result));
1317 }
1318
1319 { /* Precision with no rounding. */
1320 int retval =
1321 my_snprintf (result, sizeof (result), "%.2Lf %d", 999.951L, 33, 44, 55);
1322 ASSERT (strcmp (result, "999.95 33") == 0);
1323 ASSERT (retval == strlen (result));
1324 }
1325
1326 { /* Precision with rounding. */
1327 int retval =
1328 my_snprintf (result, sizeof (result), "%.2Lf %d", 999.996L, 33, 44, 55);
1329 ASSERT (strcmp (result, "1000.00 33") == 0);
1330 ASSERT (retval == strlen (result));
1331 }
1332
1333 /* Test the support of the %F format directive. */
1334
1335 { /* A positive number. */
1336 int retval =
1337 my_snprintf (result, sizeof (result), "%F %d", 12.75, 33, 44, 55);
1338 ASSERT (strcmp (result, "12.750000 33") == 0);
1339 ASSERT (retval == strlen (result));
1340 }
1341
1342 { /* A larger positive number. */
1343 int retval =
1344 my_snprintf (result, sizeof (result), "%F %d", 1234567.0, 33, 44, 55);
1345 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1346 ASSERT (retval == strlen (result));
1347 }
1348
1349 { /* A negative number. */
1350 int retval =
1351 my_snprintf (result, sizeof (result), "%F %d", -0.03125, 33, 44, 55);
1352 ASSERT (strcmp (result, "-0.031250 33") == 0);
1353 ASSERT (retval == strlen (result));
1354 }
1355
1356 { /* Positive zero. */
1357 int retval =
1358 my_snprintf (result, sizeof (result), "%F %d", 0.0, 33, 44, 55);
1359 ASSERT (strcmp (result, "0.000000 33") == 0);
1360 ASSERT (retval == strlen (result));
1361 }
1362
1363 { /* Negative zero. */
1364 int retval =
1365 my_snprintf (result, sizeof (result), "%F %d", minus_zerod, 33, 44, 55);
1366 if (have_minus_zero ())
1367 ASSERT (strcmp (result, "-0.000000 33") == 0);
1368 ASSERT (retval == strlen (result));
1369 }
1370
1371 { /* Positive infinity. */
1372 int retval =
1373 my_snprintf (result, sizeof (result), "%F %d", Infinityd (), 33, 44, 55);
1374 ASSERT (strcmp (result, "INF 33") == 0
1375 || strcmp (result, "INFINITY 33") == 0);
1376 ASSERT (retval == strlen (result));
1377 }
1378
1379 { /* Negative infinity. */
1380 int retval =
1381 my_snprintf (result, sizeof (result), "%F %d", - Infinityd (), 33, 44, 55);
1382 ASSERT (strcmp (result, "-INF 33") == 0
1383 || strcmp (result, "-INFINITY 33") == 0);
1384 ASSERT (retval == strlen (result));
1385 }
1386
1387 { /* NaN. */
1388 int retval =
1389 my_snprintf (result, sizeof (result), "%F %d", NaNd (), 33, 44, 55);
1390 ASSERT (strlen (result) >= 3 + 3
1391 && strisnan (result, 0, strlen (result) - 3, 1)
1392 && strcmp (result + strlen (result) - 3, " 33") == 0);
1393 ASSERT (retval == strlen (result));
1394 }
1395 #if HAVE_SNAND
1396 { /* Signalling NaN. */
1397 int retval =
1398 my_snprintf (result, sizeof (result), "%F %d", SNaNd (), 33, 44, 55);
1399 ASSERT (strlen (result) >= 3 + 3
1400 && strisnan (result, 0, strlen (result) - 3, 1)
1401 && strcmp (result + strlen (result) - 3, " 33") == 0);
1402 ASSERT (retval == strlen (result));
1403 }
1404 #endif
1405
1406 { /* FLAG_ZERO. */
1407 int retval =
1408 my_snprintf (result, sizeof (result), "%015F %d", 1234.0, 33, 44, 55);
1409 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1410 ASSERT (retval == strlen (result));
1411 }
1412
1413 { /* FLAG_ZERO with infinite number. */
1414 int retval =
1415 my_snprintf (result, sizeof (result), "%015F %d", - Infinityd (), 33, 44, 55);
1416 ASSERT (strcmp (result, " -INF 33") == 0
1417 || strcmp (result, " -INFINITY 33") == 0);
1418 ASSERT (retval == strlen (result));
1419 }
1420
1421 { /* Precision. */
1422 int retval =
1423 my_snprintf (result, sizeof (result), "%.F %d", 1234.0, 33, 44, 55);
1424 ASSERT (strcmp (result, "1234 33") == 0);
1425 ASSERT (retval == strlen (result));
1426 }
1427
1428 { /* Precision with no rounding. */
1429 int retval =
1430 my_snprintf (result, sizeof (result), "%.2F %d", 999.951, 33, 44, 55);
1431 ASSERT (strcmp (result, "999.95 33") == 0);
1432 ASSERT (retval == strlen (result));
1433 }
1434
1435 { /* Precision with rounding. */
1436 int retval =
1437 my_snprintf (result, sizeof (result), "%.2F %d", 999.996, 33, 44, 55);
1438 ASSERT (strcmp (result, "1000.00 33") == 0);
1439 ASSERT (retval == strlen (result));
1440 }
1441
1442 { /* A positive number. */
1443 int retval =
1444 my_snprintf (result, sizeof (result), "%LF %d", 12.75L, 33, 44, 55);
1445 ASSERT (strcmp (result, "12.750000 33") == 0);
1446 ASSERT (retval == strlen (result));
1447 }
1448
1449 { /* A larger positive number. */
1450 int retval =
1451 my_snprintf (result, sizeof (result), "%LF %d", 1234567.0L, 33, 44, 55);
1452 ASSERT (strcmp (result, "1234567.000000 33") == 0);
1453 ASSERT (retval == strlen (result));
1454 }
1455
1456 { /* A negative number. */
1457 int retval =
1458 my_snprintf (result, sizeof (result), "%LF %d", -0.03125L, 33, 44, 55);
1459 ASSERT (strcmp (result, "-0.031250 33") == 0);
1460 ASSERT (retval == strlen (result));
1461 }
1462
1463 { /* Positive zero. */
1464 int retval =
1465 my_snprintf (result, sizeof (result), "%LF %d", 0.0L, 33, 44, 55);
1466 ASSERT (strcmp (result, "0.000000 33") == 0);
1467 ASSERT (retval == strlen (result));
1468 }
1469
1470 { /* Negative zero. */
1471 int retval =
1472 my_snprintf (result, sizeof (result), "%LF %d", minus_zerol, 33, 44, 55);
1473 if (have_minus_zero ())
1474 ASSERT (strcmp (result, "-0.000000 33") == 0);
1475 ASSERT (retval == strlen (result));
1476 }
1477
1478 { /* Positive infinity. */
1479 int retval =
1480 my_snprintf (result, sizeof (result), "%LF %d", Infinityl (), 33, 44, 55);
1481 ASSERT (strcmp (result, "INF 33") == 0
1482 || strcmp (result, "INFINITY 33") == 0);
1483 ASSERT (retval == strlen (result));
1484 }
1485
1486 { /* Negative infinity. */
1487 int retval =
1488 my_snprintf (result, sizeof (result), "%LF %d", - Infinityl (), 33, 44, 55);
1489 ASSERT (strcmp (result, "-INF 33") == 0
1490 || strcmp (result, "-INFINITY 33") == 0);
1491 ASSERT (retval == strlen (result));
1492 }
1493
1494 { /* NaN. */
1495 int retval =
1496 my_snprintf (result, sizeof (result), "%LF %d", NaNl (), 33, 44, 55);
1497 ASSERT (strlen (result) >= 3 + 3
1498 && strisnan (result, 0, strlen (result) - 3, 1)
1499 && strcmp (result + strlen (result) - 3, " 33") == 0);
1500 ASSERT (retval == strlen (result));
1501 }
1502 #if HAVE_SNANL
1503 { /* Signalling NaN. */
1504 int retval =
1505 my_snprintf (result, sizeof (result), "%LF %d", SNaNl (), 33, 44, 55);
1506 ASSERT (strlen (result) >= 3 + 3
1507 && strisnan (result, 0, strlen (result) - 3, 1)
1508 && strcmp (result + strlen (result) - 3, " 33") == 0);
1509 ASSERT (retval == strlen (result));
1510 }
1511 #endif
1512
1513 { /* FLAG_ZERO. */
1514 int retval =
1515 my_snprintf (result, sizeof (result), "%015LF %d", 1234.0L, 33, 44, 55);
1516 ASSERT (strcmp (result, "00001234.000000 33") == 0);
1517 ASSERT (retval == strlen (result));
1518 }
1519
1520 { /* FLAG_ZERO with infinite number. */
1521 int retval =
1522 my_snprintf (result, sizeof (result), "%015LF %d", - Infinityl (), 33, 44, 55);
1523 ASSERT (strcmp (result, " -INF 33") == 0
1524 || strcmp (result, " -INFINITY 33") == 0);
1525 ASSERT (retval == strlen (result));
1526 }
1527
1528 { /* Precision. */
1529 int retval =
1530 my_snprintf (result, sizeof (result), "%.LF %d", 1234.0L, 33, 44, 55);
1531 ASSERT (strcmp (result, "1234 33") == 0);
1532 ASSERT (retval == strlen (result));
1533 }
1534
1535 { /* Precision with no rounding. */
1536 int retval =
1537 my_snprintf (result, sizeof (result), "%.2LF %d", 999.951L, 33, 44, 55);
1538 ASSERT (strcmp (result, "999.95 33") == 0);
1539 ASSERT (retval == strlen (result));
1540 }
1541
1542 { /* Precision with rounding. */
1543 int retval =
1544 my_snprintf (result, sizeof (result), "%.2LF %d", 999.996L, 33, 44, 55);
1545 ASSERT (strcmp (result, "1000.00 33") == 0);
1546 ASSERT (retval == strlen (result));
1547 }
1548
1549 /* Test the support of the %e format directive. */
1550
1551 { /* A positive number. */
1552 int retval =
1553 my_snprintf (result, sizeof (result), "%e %d", 12.75, 33, 44, 55);
1554 ASSERT (strcmp (result, "1.275000e+01 33") == 0
1555 || strcmp (result, "1.275000e+001 33") == 0);
1556 ASSERT (retval == strlen (result));
1557 }
1558
1559 { /* A larger positive number. */
1560 int retval =
1561 my_snprintf (result, sizeof (result), "%e %d", 1234567.0, 33, 44, 55);
1562 ASSERT (strcmp (result, "1.234567e+06 33") == 0
1563 || strcmp (result, "1.234567e+006 33") == 0);
1564 ASSERT (retval == strlen (result));
1565 }
1566
1567 { /* Small and large positive numbers. */
1568 static struct { double value; const char *string; } data[] =
1569 {
1570 { 1.234321234321234e-37, "1.234321e-37" },
1571 { 1.234321234321234e-36, "1.234321e-36" },
1572 { 1.234321234321234e-35, "1.234321e-35" },
1573 { 1.234321234321234e-34, "1.234321e-34" },
1574 { 1.234321234321234e-33, "1.234321e-33" },
1575 { 1.234321234321234e-32, "1.234321e-32" },
1576 { 1.234321234321234e-31, "1.234321e-31" },
1577 { 1.234321234321234e-30, "1.234321e-30" },
1578 { 1.234321234321234e-29, "1.234321e-29" },
1579 { 1.234321234321234e-28, "1.234321e-28" },
1580 { 1.234321234321234e-27, "1.234321e-27" },
1581 { 1.234321234321234e-26, "1.234321e-26" },
1582 { 1.234321234321234e-25, "1.234321e-25" },
1583 { 1.234321234321234e-24, "1.234321e-24" },
1584 { 1.234321234321234e-23, "1.234321e-23" },
1585 { 1.234321234321234e-22, "1.234321e-22" },
1586 { 1.234321234321234e-21, "1.234321e-21" },
1587 { 1.234321234321234e-20, "1.234321e-20" },
1588 { 1.234321234321234e-19, "1.234321e-19" },
1589 { 1.234321234321234e-18, "1.234321e-18" },
1590 { 1.234321234321234e-17, "1.234321e-17" },
1591 { 1.234321234321234e-16, "1.234321e-16" },
1592 { 1.234321234321234e-15, "1.234321e-15" },
1593 { 1.234321234321234e-14, "1.234321e-14" },
1594 { 1.234321234321234e-13, "1.234321e-13" },
1595 { 1.234321234321234e-12, "1.234321e-12" },
1596 { 1.234321234321234e-11, "1.234321e-11" },
1597 { 1.234321234321234e-10, "1.234321e-10" },
1598 { 1.234321234321234e-9, "1.234321e-09" },
1599 { 1.234321234321234e-8, "1.234321e-08" },
1600 { 1.234321234321234e-7, "1.234321e-07" },
1601 { 1.234321234321234e-6, "1.234321e-06" },
1602 { 1.234321234321234e-5, "1.234321e-05" },
1603 { 1.234321234321234e-4, "1.234321e-04" },
1604 { 1.234321234321234e-3, "1.234321e-03" },
1605 { 1.234321234321234e-2, "1.234321e-02" },
1606 { 1.234321234321234e-1, "1.234321e-01" },
1607 { 1.234321234321234, "1.234321e+00" },
1608 { 1.234321234321234e1, "1.234321e+01" },
1609 { 1.234321234321234e2, "1.234321e+02" },
1610 { 1.234321234321234e3, "1.234321e+03" },
1611 { 1.234321234321234e4, "1.234321e+04" },
1612 { 1.234321234321234e5, "1.234321e+05" },
1613 { 1.234321234321234e6, "1.234321e+06" },
1614 { 1.234321234321234e7, "1.234321e+07" },
1615 { 1.234321234321234e8, "1.234321e+08" },
1616 { 1.234321234321234e9, "1.234321e+09" },
1617 { 1.234321234321234e10, "1.234321e+10" },
1618 { 1.234321234321234e11, "1.234321e+11" },
1619 { 1.234321234321234e12, "1.234321e+12" },
1620 { 1.234321234321234e13, "1.234321e+13" },
1621 { 1.234321234321234e14, "1.234321e+14" },
1622 { 1.234321234321234e15, "1.234321e+15" },
1623 { 1.234321234321234e16, "1.234321e+16" },
1624 { 1.234321234321234e17, "1.234321e+17" },
1625 { 1.234321234321234e18, "1.234321e+18" },
1626 { 1.234321234321234e19, "1.234321e+19" },
1627 { 1.234321234321234e20, "1.234321e+20" },
1628 { 1.234321234321234e21, "1.234321e+21" },
1629 { 1.234321234321234e22, "1.234321e+22" },
1630 { 1.234321234321234e23, "1.234321e+23" },
1631 { 1.234321234321234e24, "1.234321e+24" },
1632 { 1.234321234321234e25, "1.234321e+25" },
1633 { 1.234321234321234e26, "1.234321e+26" },
1634 { 1.234321234321234e27, "1.234321e+27" },
1635 { 1.234321234321234e28, "1.234321e+28" },
1636 { 1.234321234321234e29, "1.234321e+29" },
1637 { 1.234321234321234e30, "1.234321e+30" },
1638 { 1.234321234321234e31, "1.234321e+31" },
1639 { 1.234321234321234e32, "1.234321e+32" },
1640 { 1.234321234321234e33, "1.234321e+33" },
1641 { 1.234321234321234e34, "1.234321e+34" },
1642 { 1.234321234321234e35, "1.234321e+35" },
1643 { 1.234321234321234e36, "1.234321e+36" }
1644 };
1645 size_t k;
1646 for (k = 0; k < SIZEOF (data); k++)
1647 {
1648 int retval =
1649 my_snprintf (result, sizeof (result), "%e", data[k].value);
1650 const char *expected = data[k].string;
1651 ASSERT (strcmp (result, expected) == 0
1652 /* Some implementations produce exponents with 3 digits. */
1653 || (strlen (result) == strlen (expected) + 1
1654 && memcmp (result, expected, strlen (expected) - 2) == 0
1655 && result[strlen (expected) - 2] == '0'
1656 && strcmp (result + strlen (expected) - 1,
1657 expected + strlen (expected) - 2)
1658 == 0));
1659 ASSERT (retval == strlen (result));
1660 }
1661 }
1662
1663 { /* A negative number. */
1664 int retval =
1665 my_snprintf (result, sizeof (result), "%e %d", -0.03125, 33, 44, 55);
1666 ASSERT (strcmp (result, "-3.125000e-02 33") == 0
1667 || strcmp (result, "-3.125000e-002 33") == 0);
1668 ASSERT (retval == strlen (result));
1669 }
1670
1671 { /* Positive zero. */
1672 int retval =
1673 my_snprintf (result, sizeof (result), "%e %d", 0.0, 33, 44, 55);
1674 ASSERT (strcmp (result, "0.000000e+00 33") == 0
1675 || strcmp (result, "0.000000e+000 33") == 0);
1676 ASSERT (retval == strlen (result));
1677 }
1678
1679 { /* Negative zero. */
1680 int retval =
1681 my_snprintf (result, sizeof (result), "%e %d", minus_zerod, 33, 44, 55);
1682 if (have_minus_zero ())
1683 ASSERT (strcmp (result, "-0.000000e+00 33") == 0
1684 || strcmp (result, "-0.000000e+000 33") == 0);
1685 ASSERT (retval == strlen (result));
1686 }
1687
1688 { /* Positive infinity. */
1689 int retval =
1690 my_snprintf (result, sizeof (result), "%e %d", Infinityd (), 33, 44, 55);
1691 ASSERT (strcmp (result, "inf 33") == 0
1692 || strcmp (result, "infinity 33") == 0);
1693 ASSERT (retval == strlen (result));
1694 }
1695
1696 { /* Negative infinity. */
1697 int retval =
1698 my_snprintf (result, sizeof (result), "%e %d", - Infinityd (), 33, 44, 55);
1699 ASSERT (strcmp (result, "-inf 33") == 0
1700 || strcmp (result, "-infinity 33") == 0);
1701 ASSERT (retval == strlen (result));
1702 }
1703
1704 { /* NaN. */
1705 int retval =
1706 my_snprintf (result, sizeof (result), "%e %d", NaNd (), 33, 44, 55);
1707 ASSERT (strlen (result) >= 3 + 3
1708 && strisnan (result, 0, strlen (result) - 3, 0)
1709 && strcmp (result + strlen (result) - 3, " 33") == 0);
1710 ASSERT (retval == strlen (result));
1711 }
1712 #if HAVE_SNAND
1713 { /* Signalling NaN. */
1714 int retval =
1715 my_snprintf (result, sizeof (result), "%e %d", SNaNd (), 33, 44, 55);
1716 ASSERT (strlen (result) >= 3 + 3
1717 && strisnan (result, 0, strlen (result) - 3, 0)
1718 && strcmp (result + strlen (result) - 3, " 33") == 0);
1719 ASSERT (retval == strlen (result));
1720 }
1721 #endif
1722
1723 { /* Width. */
1724 int retval =
1725 my_snprintf (result, sizeof (result), "%15e %d", 1.75, 33, 44, 55);
1726 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
1727 || strcmp (result, " 1.750000e+000 33") == 0);
1728 ASSERT (retval == strlen (result));
1729 }
1730
1731 { /* Width given as argument. */
1732 int retval =
1733 my_snprintf (result, sizeof (result), "%*e %d", 15, 1.75, 33, 44, 55);
1734 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
1735 || strcmp (result, " 1.750000e+000 33") == 0);
1736 ASSERT (retval == strlen (result));
1737 }
1738
1739 { /* Negative width given as argument (cf. FLAG_LEFT below). */
1740 int retval =
1741 my_snprintf (result, sizeof (result), "%*e %d", -15, 1.75, 33, 44, 55);
1742 ASSERT (strcmp (result, "1.750000e+00 33") == 0
1743 || strcmp (result, "1.750000e+000 33") == 0);
1744 ASSERT (retval == strlen (result));
1745 }
1746
1747 { /* FLAG_LEFT. */
1748 int retval =
1749 my_snprintf (result, sizeof (result), "%-15e %d", 1.75, 33, 44, 55);
1750 ASSERT (strcmp (result, "1.750000e+00 33") == 0
1751 || strcmp (result, "1.750000e+000 33") == 0);
1752 ASSERT (retval == strlen (result));
1753 }
1754
1755 { /* FLAG_SHOWSIGN. */
1756 int retval =
1757 my_snprintf (result, sizeof (result), "%+e %d", 1.75, 33, 44, 55);
1758 ASSERT (strcmp (result, "+1.750000e+00 33") == 0
1759 || strcmp (result, "+1.750000e+000 33") == 0);
1760 ASSERT (retval == strlen (result));
1761 }
1762
1763 { /* FLAG_SPACE. */
1764 int retval =
1765 my_snprintf (result, sizeof (result), "% e %d", 1.75, 33, 44, 55);
1766 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
1767 || strcmp (result, " 1.750000e+000 33") == 0);
1768 ASSERT (retval == strlen (result));
1769 }
1770
1771 { /* FLAG_ALT. */
1772 int retval =
1773 my_snprintf (result, sizeof (result), "%#e %d", 1.75, 33, 44, 55);
1774 ASSERT (strcmp (result, "1.750000e+00 33") == 0
1775 || strcmp (result, "1.750000e+000 33") == 0);
1776 ASSERT (retval == strlen (result));
1777 }
1778
1779 { /* FLAG_ALT. */
1780 int retval =
1781 my_snprintf (result, sizeof (result), "%#.e %d", 1.75, 33, 44, 55);
1782 ASSERT (strcmp (result, "2.e+00 33") == 0
1783 || strcmp (result, "2.e+000 33") == 0);
1784 ASSERT (retval == strlen (result));
1785 }
1786
1787 { /* FLAG_ALT. */
1788 int retval =
1789 my_snprintf (result, sizeof (result), "%#.e %d", 9.75, 33, 44, 55);
1790 ASSERT (strcmp (result, "1.e+01 33") == 0
1791 || strcmp (result, "1.e+001 33") == 0);
1792 ASSERT (retval == strlen (result));
1793 }
1794
1795 { /* FLAG_ZERO with finite number. */
1796 int retval =
1797 my_snprintf (result, sizeof (result), "%015e %d", 1234.0, 33, 44, 55);
1798 ASSERT (strcmp (result, "0001.234000e+03 33") == 0
1799 || strcmp (result, "001.234000e+003 33") == 0);
1800 ASSERT (retval == strlen (result));
1801 }
1802
1803 { /* FLAG_ZERO with infinite number. */
1804 int retval =
1805 my_snprintf (result, sizeof (result), "%015e %d", - Infinityd (), 33, 44, 55);
1806 ASSERT (strcmp (result, " -inf 33") == 0
1807 || strcmp (result, " -infinity 33") == 0);
1808 ASSERT (retval == strlen (result));
1809 }
1810
1811 { /* FLAG_ZERO with NaN. */
1812 int retval =
1813 my_snprintf (result, sizeof (result), "%050e %d", NaNd (), 33, 44, 55);
1814 ASSERT (strlen (result) == 50 + 3
1815 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
1816 && strcmp (result + strlen (result) - 3, " 33") == 0);
1817 ASSERT (retval == strlen (result));
1818 }
1819
1820 { /* Precision. */
1821 int retval =
1822 my_snprintf (result, sizeof (result), "%.e %d", 1234.0, 33, 44, 55);
1823 ASSERT (strcmp (result, "1e+03 33") == 0
1824 || strcmp (result, "1e+003 33") == 0);
1825 ASSERT (retval == strlen (result));
1826 }
1827
1828 { /* Precision with no rounding. */
1829 int retval =
1830 my_snprintf (result, sizeof (result), "%.4e %d", 999.951, 33, 44, 55);
1831 ASSERT (strcmp (result, "9.9995e+02 33") == 0
1832 || strcmp (result, "9.9995e+002 33") == 0);
1833 ASSERT (retval == strlen (result));
1834 }
1835
1836 { /* Precision with rounding. */
1837 int retval =
1838 my_snprintf (result, sizeof (result), "%.4e %d", 999.996, 33, 44, 55);
1839 ASSERT (strcmp (result, "1.0000e+03 33") == 0
1840 || strcmp (result, "1.0000e+003 33") == 0);
1841 ASSERT (retval == strlen (result));
1842 }
1843
1844 { /* A positive number. */
1845 int retval =
1846 my_snprintf (result, sizeof (result), "%Le %d", 12.75L, 33, 44, 55);
1847 ASSERT (strcmp (result, "1.275000e+01 33") == 0
1848 || strcmp (result, "1.275000e+001 33") == 0);
1849 ASSERT (retval == strlen (result));
1850 }
1851
1852 { /* A larger positive number. */
1853 int retval =
1854 my_snprintf (result, sizeof (result), "%Le %d", 1234567.0L, 33, 44, 55);
1855 ASSERT (strcmp (result, "1.234567e+06 33") == 0
1856 || strcmp (result, "1.234567e+006 33") == 0);
1857 ASSERT (retval == strlen (result));
1858 }
1859
1860 { /* Small and large positive numbers. */
1861 static struct { long double value; const char *string; } data[] =
1862 {
1863 { 1.234321234321234e-37L, "1.234321e-37" },
1864 { 1.234321234321234e-36L, "1.234321e-36" },
1865 { 1.234321234321234e-35L, "1.234321e-35" },
1866 { 1.234321234321234e-34L, "1.234321e-34" },
1867 { 1.234321234321234e-33L, "1.234321e-33" },
1868 { 1.234321234321234e-32L, "1.234321e-32" },
1869 { 1.234321234321234e-31L, "1.234321e-31" },
1870 { 1.234321234321234e-30L, "1.234321e-30" },
1871 { 1.234321234321234e-29L, "1.234321e-29" },
1872 { 1.234321234321234e-28L, "1.234321e-28" },
1873 { 1.234321234321234e-27L, "1.234321e-27" },
1874 { 1.234321234321234e-26L, "1.234321e-26" },
1875 { 1.234321234321234e-25L, "1.234321e-25" },
1876 { 1.234321234321234e-24L, "1.234321e-24" },
1877 { 1.234321234321234e-23L, "1.234321e-23" },
1878 { 1.234321234321234e-22L, "1.234321e-22" },
1879 { 1.234321234321234e-21L, "1.234321e-21" },
1880 { 1.234321234321234e-20L, "1.234321e-20" },
1881 { 1.234321234321234e-19L, "1.234321e-19" },
1882 { 1.234321234321234e-18L, "1.234321e-18" },
1883 { 1.234321234321234e-17L, "1.234321e-17" },
1884 { 1.234321234321234e-16L, "1.234321e-16" },
1885 { 1.234321234321234e-15L, "1.234321e-15" },
1886 { 1.234321234321234e-14L, "1.234321e-14" },
1887 { 1.234321234321234e-13L, "1.234321e-13" },
1888 { 1.234321234321234e-12L, "1.234321e-12" },
1889 { 1.234321234321234e-11L, "1.234321e-11" },
1890 { 1.234321234321234e-10L, "1.234321e-10" },
1891 { 1.234321234321234e-9L, "1.234321e-09" },
1892 { 1.234321234321234e-8L, "1.234321e-08" },
1893 { 1.234321234321234e-7L, "1.234321e-07" },
1894 { 1.234321234321234e-6L, "1.234321e-06" },
1895 { 1.234321234321234e-5L, "1.234321e-05" },
1896 { 1.234321234321234e-4L, "1.234321e-04" },
1897 { 1.234321234321234e-3L, "1.234321e-03" },
1898 { 1.234321234321234e-2L, "1.234321e-02" },
1899 { 1.234321234321234e-1L, "1.234321e-01" },
1900 { 1.234321234321234L, "1.234321e+00" },
1901 { 1.234321234321234e1L, "1.234321e+01" },
1902 { 1.234321234321234e2L, "1.234321e+02" },
1903 { 1.234321234321234e3L, "1.234321e+03" },
1904 { 1.234321234321234e4L, "1.234321e+04" },
1905 { 1.234321234321234e5L, "1.234321e+05" },
1906 { 1.234321234321234e6L, "1.234321e+06" },
1907 { 1.234321234321234e7L, "1.234321e+07" },
1908 { 1.234321234321234e8L, "1.234321e+08" },
1909 { 1.234321234321234e9L, "1.234321e+09" },
1910 { 1.234321234321234e10L, "1.234321e+10" },
1911 { 1.234321234321234e11L, "1.234321e+11" },
1912 { 1.234321234321234e12L, "1.234321e+12" },
1913 { 1.234321234321234e13L, "1.234321e+13" },
1914 { 1.234321234321234e14L, "1.234321e+14" },
1915 { 1.234321234321234e15L, "1.234321e+15" },
1916 { 1.234321234321234e16L, "1.234321e+16" },
1917 { 1.234321234321234e17L, "1.234321e+17" },
1918 { 1.234321234321234e18L, "1.234321e+18" },
1919 { 1.234321234321234e19L, "1.234321e+19" },
1920 { 1.234321234321234e20L, "1.234321e+20" },
1921 { 1.234321234321234e21L, "1.234321e+21" },
1922 { 1.234321234321234e22L, "1.234321e+22" },
1923 { 1.234321234321234e23L, "1.234321e+23" },
1924 { 1.234321234321234e24L, "1.234321e+24" },
1925 { 1.234321234321234e25L, "1.234321e+25" },
1926 { 1.234321234321234e26L, "1.234321e+26" },
1927 { 1.234321234321234e27L, "1.234321e+27" },
1928 { 1.234321234321234e28L, "1.234321e+28" },
1929 { 1.234321234321234e29L, "1.234321e+29" },
1930 { 1.234321234321234e30L, "1.234321e+30" },
1931 { 1.234321234321234e31L, "1.234321e+31" },
1932 { 1.234321234321234e32L, "1.234321e+32" },
1933 { 1.234321234321234e33L, "1.234321e+33" },
1934 { 1.234321234321234e34L, "1.234321e+34" },
1935 { 1.234321234321234e35L, "1.234321e+35" },
1936 { 1.234321234321234e36L, "1.234321e+36" }
1937 };
1938 size_t k;
1939 for (k = 0; k < SIZEOF (data); k++)
1940 {
1941 int retval =
1942 my_snprintf (result, sizeof (result), "%Le", data[k].value);
1943 const char *expected = data[k].string;
1944 ASSERT (strcmp (result, expected) == 0
1945 /* Some implementations produce exponents with 3 digits. */
1946 || (strlen (result) == strlen (expected) + 1
1947 && memcmp (result, expected, strlen (expected) - 2) == 0
1948 && result[strlen (expected) - 2] == '0'
1949 && strcmp (result + strlen (expected) - 1,
1950 expected + strlen (expected) - 2)
1951 == 0));
1952 ASSERT (retval == strlen (result));
1953 }
1954 }
1955
1956 { /* A negative number. */
1957 int retval =
1958 my_snprintf (result, sizeof (result), "%Le %d", -0.03125L, 33, 44, 55);
1959 ASSERT (strcmp (result, "-3.125000e-02 33") == 0
1960 || strcmp (result, "-3.125000e-002 33") == 0);
1961 ASSERT (retval == strlen (result));
1962 }
1963
1964 { /* Positive zero. */
1965 int retval =
1966 my_snprintf (result, sizeof (result), "%Le %d", 0.0L, 33, 44, 55);
1967 ASSERT (strcmp (result, "0.000000e+00 33") == 0
1968 || strcmp (result, "0.000000e+000 33") == 0);
1969 ASSERT (retval == strlen (result));
1970 }
1971
1972 { /* Negative zero. */
1973 int retval =
1974 my_snprintf (result, sizeof (result), "%Le %d", minus_zerol, 33, 44, 55);
1975 if (have_minus_zero ())
1976 ASSERT (strcmp (result, "-0.000000e+00 33") == 0
1977 || strcmp (result, "-0.000000e+000 33") == 0);
1978 ASSERT (retval == strlen (result));
1979 }
1980
1981 { /* Positive infinity. */
1982 int retval =
1983 my_snprintf (result, sizeof (result), "%Le %d", Infinityl (), 33, 44, 55);
1984 ASSERT (strcmp (result, "inf 33") == 0
1985 || strcmp (result, "infinity 33") == 0);
1986 ASSERT (retval == strlen (result));
1987 }
1988
1989 { /* Negative infinity. */
1990 int retval =
1991 my_snprintf (result, sizeof (result), "%Le %d", - Infinityl (), 33, 44, 55);
1992 ASSERT (strcmp (result, "-inf 33") == 0
1993 || strcmp (result, "-infinity 33") == 0);
1994 ASSERT (retval == strlen (result));
1995 }
1996
1997 { /* NaN. */
1998 int retval =
1999 my_snprintf (result, sizeof (result), "%Le %d", NaNl (), 33, 44, 55);
2000 ASSERT (strlen (result) >= 3 + 3
2001 && strisnan (result, 0, strlen (result) - 3, 0)
2002 && strcmp (result + strlen (result) - 3, " 33") == 0);
2003 ASSERT (retval == strlen (result));
2004 }
2005 #if HAVE_SNANL
2006 { /* Signalling NaN. */
2007 int retval =
2008 my_snprintf (result, sizeof (result), "%Le %d", SNaNl (), 33, 44, 55);
2009 ASSERT (strlen (result) >= 3 + 3
2010 && strisnan (result, 0, strlen (result) - 3, 0)
2011 && strcmp (result + strlen (result) - 3, " 33") == 0);
2012 ASSERT (retval == strlen (result));
2013 }
2014 #endif
2015 #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
2016 { /* Quiet NaN. */
2017 static union { unsigned int word[4]; long double value; } x =
2018 { .word = LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
2019 int retval =
2020 my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
2021 ASSERT (strlen (result) >= 3 + 3
2022 && strisnan (result, 0, strlen (result) - 3, 0)
2023 && strcmp (result + strlen (result) - 3, " 33") == 0);
2024 ASSERT (retval == strlen (result));
2025 }
2026 {
2027 /* Signalling NaN. */
2028 static union { unsigned int word[4]; long double value; } x =
2029 { .word = LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
2030 int retval =
2031 my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
2032 ASSERT (strlen (result) >= 3 + 3
2033 && strisnan (result, 0, strlen (result) - 3, 0)
2034 && strcmp (result + strlen (result) - 3, " 33") == 0);
2035 ASSERT (retval == strlen (result));
2036 }
2037 /* snprintf should print something for noncanonical values. */
2038 { /* Pseudo-NaN. */
2039 static union { unsigned int word[4]; long double value; } x =
2040 { .word = LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
2041 int retval =
2042 my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
2043 ASSERT (retval == strlen (result));
2044 ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
2045 }
2046 { /* Pseudo-Infinity. */
2047 static union { unsigned int word[4]; long double value; } x =
2048 { .word = LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
2049 int retval =
2050 my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
2051 ASSERT (retval == strlen (result));
2052 ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
2053 }
2054 { /* Pseudo-Zero. */
2055 static union { unsigned int word[4]; long double value; } x =
2056 { .word = LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
2057 int retval =
2058 my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
2059 ASSERT (retval == strlen (result));
2060 ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
2061 }
2062 { /* Unnormalized number. */
2063 static union { unsigned int word[4]; long double value; } x =
2064 { .word = LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
2065 int retval =
2066 my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
2067 ASSERT (retval == strlen (result));
2068 ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
2069 }
2070 { /* Pseudo-Denormal. */
2071 static union { unsigned int word[4]; long double value; } x =
2072 { .word = LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
2073 int retval =
2074 my_snprintf (result, sizeof (result), "%Le %d", x.value, 33, 44, 55);
2075 ASSERT (retval == strlen (result));
2076 ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
2077 }
2078 #endif
2079
2080 { /* Width. */
2081 int retval =
2082 my_snprintf (result, sizeof (result), "%15Le %d", 1.75L, 33, 44, 55);
2083 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
2084 || strcmp (result, " 1.750000e+000 33") == 0);
2085 ASSERT (retval == strlen (result));
2086 }
2087
2088 { /* Width given as argument. */
2089 int retval =
2090 my_snprintf (result, sizeof (result), "%*Le %d", 15, 1.75L, 33, 44, 55);
2091 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
2092 || strcmp (result, " 1.750000e+000 33") == 0);
2093 ASSERT (retval == strlen (result));
2094 }
2095
2096 { /* Negative width given as argument (cf. FLAG_LEFT below). */
2097 int retval =
2098 my_snprintf (result, sizeof (result), "%*Le %d", -15, 1.75L, 33, 44, 55);
2099 ASSERT (strcmp (result, "1.750000e+00 33") == 0
2100 || strcmp (result, "1.750000e+000 33") == 0);
2101 ASSERT (retval == strlen (result));
2102 }
2103
2104 { /* FLAG_LEFT. */
2105 int retval =
2106 my_snprintf (result, sizeof (result), "%-15Le %d", 1.75L, 33, 44, 55);
2107 ASSERT (strcmp (result, "1.750000e+00 33") == 0
2108 || strcmp (result, "1.750000e+000 33") == 0);
2109 ASSERT (retval == strlen (result));
2110 }
2111
2112 { /* FLAG_SHOWSIGN. */
2113 int retval =
2114 my_snprintf (result, sizeof (result), "%+Le %d", 1.75L, 33, 44, 55);
2115 ASSERT (strcmp (result, "+1.750000e+00 33") == 0
2116 || strcmp (result, "+1.750000e+000 33") == 0);
2117 ASSERT (retval == strlen (result));
2118 }
2119
2120 { /* FLAG_SPACE. */
2121 int retval =
2122 my_snprintf (result, sizeof (result), "% Le %d", 1.75L, 33, 44, 55);
2123 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
2124 || strcmp (result, " 1.750000e+000 33") == 0);
2125 ASSERT (retval == strlen (result));
2126 }
2127
2128 { /* FLAG_ALT. */
2129 int retval =
2130 my_snprintf (result, sizeof (result), "%#Le %d", 1.75L, 33, 44, 55);
2131 ASSERT (strcmp (result, "1.750000e+00 33") == 0
2132 || strcmp (result, "1.750000e+000 33") == 0);
2133 ASSERT (retval == strlen (result));
2134 }
2135
2136 { /* FLAG_ALT. */
2137 int retval =
2138 my_snprintf (result, sizeof (result), "%#.Le %d", 1.75L, 33, 44, 55);
2139 ASSERT (strcmp (result, "2.e+00 33") == 0
2140 || strcmp (result, "2.e+000 33") == 0);
2141 ASSERT (retval == strlen (result));
2142 }
2143
2144 { /* FLAG_ALT. */
2145 int retval =
2146 my_snprintf (result, sizeof (result), "%#.Le %d", 9.75L, 33, 44, 55);
2147 ASSERT (strcmp (result, "1.e+01 33") == 0
2148 || strcmp (result, "1.e+001 33") == 0);
2149 ASSERT (retval == strlen (result));
2150 }
2151
2152 { /* FLAG_ZERO with finite number. */
2153 int retval =
2154 my_snprintf (result, sizeof (result), "%015Le %d", 1234.0L, 33, 44, 55);
2155 ASSERT (strcmp (result, "0001.234000e+03 33") == 0
2156 || strcmp (result, "001.234000e+003 33") == 0);
2157 ASSERT (retval == strlen (result));
2158 }
2159
2160 { /* FLAG_ZERO with infinite number. */
2161 int retval =
2162 my_snprintf (result, sizeof (result), "%015Le %d", - Infinityl (), 33, 44, 55);
2163 ASSERT (strcmp (result, " -inf 33") == 0
2164 || strcmp (result, " -infinity 33") == 0);
2165 ASSERT (retval == strlen (result));
2166 }
2167
2168 { /* FLAG_ZERO with NaN. */
2169 int retval =
2170 my_snprintf (result, sizeof (result), "%050Le %d", NaNl (), 33, 44, 55);
2171 ASSERT (strlen (result) == 50 + 3
2172 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2173 && strcmp (result + strlen (result) - 3, " 33") == 0);
2174 ASSERT (retval == strlen (result));
2175 }
2176
2177 { /* Precision. */
2178 int retval =
2179 my_snprintf (result, sizeof (result), "%.Le %d", 1234.0L, 33, 44, 55);
2180 ASSERT (strcmp (result, "1e+03 33") == 0
2181 || strcmp (result, "1e+003 33") == 0);
2182 ASSERT (retval == strlen (result));
2183 }
2184
2185 { /* Precision with no rounding. */
2186 int retval =
2187 my_snprintf (result, sizeof (result), "%.4Le %d", 999.951L, 33, 44, 55);
2188 ASSERT (strcmp (result, "9.9995e+02 33") == 0
2189 || strcmp (result, "9.9995e+002 33") == 0);
2190 ASSERT (retval == strlen (result));
2191 }
2192
2193 { /* Precision with rounding. */
2194 int retval =
2195 my_snprintf (result, sizeof (result), "%.4Le %d", 999.996L, 33, 44, 55);
2196 ASSERT (strcmp (result, "1.0000e+03 33") == 0
2197 || strcmp (result, "1.0000e+003 33") == 0);
2198 ASSERT (retval == strlen (result));
2199 }
2200
2201 /* Test the support of the %g format directive. */
2202
2203 { /* A positive number. */
2204 int retval =
2205 my_snprintf (result, sizeof (result), "%g %d", 12.75, 33, 44, 55);
2206 ASSERT (strcmp (result, "12.75 33") == 0);
2207 ASSERT (retval == strlen (result));
2208 }
2209
2210 { /* A larger positive number. */
2211 int retval =
2212 my_snprintf (result, sizeof (result), "%g %d", 1234567.0, 33, 44, 55);
2213 ASSERT (strcmp (result, "1.23457e+06 33") == 0
2214 || strcmp (result, "1.23457e+006 33") == 0);
2215 ASSERT (retval == strlen (result));
2216 }
2217
2218 { /* Small and large positive numbers. */
2219 static struct { double value; const char *string; } data[] =
2220 {
2221 { 1.234321234321234e-37, "1.23432e-37" },
2222 { 1.234321234321234e-36, "1.23432e-36" },
2223 { 1.234321234321234e-35, "1.23432e-35" },
2224 { 1.234321234321234e-34, "1.23432e-34" },
2225 { 1.234321234321234e-33, "1.23432e-33" },
2226 { 1.234321234321234e-32, "1.23432e-32" },
2227 { 1.234321234321234e-31, "1.23432e-31" },
2228 { 1.234321234321234e-30, "1.23432e-30" },
2229 { 1.234321234321234e-29, "1.23432e-29" },
2230 { 1.234321234321234e-28, "1.23432e-28" },
2231 { 1.234321234321234e-27, "1.23432e-27" },
2232 { 1.234321234321234e-26, "1.23432e-26" },
2233 { 1.234321234321234e-25, "1.23432e-25" },
2234 { 1.234321234321234e-24, "1.23432e-24" },
2235 { 1.234321234321234e-23, "1.23432e-23" },
2236 { 1.234321234321234e-22, "1.23432e-22" },
2237 { 1.234321234321234e-21, "1.23432e-21" },
2238 { 1.234321234321234e-20, "1.23432e-20" },
2239 { 1.234321234321234e-19, "1.23432e-19" },
2240 { 1.234321234321234e-18, "1.23432e-18" },
2241 { 1.234321234321234e-17, "1.23432e-17" },
2242 { 1.234321234321234e-16, "1.23432e-16" },
2243 { 1.234321234321234e-15, "1.23432e-15" },
2244 { 1.234321234321234e-14, "1.23432e-14" },
2245 { 1.234321234321234e-13, "1.23432e-13" },
2246 { 1.234321234321234e-12, "1.23432e-12" },
2247 { 1.234321234321234e-11, "1.23432e-11" },
2248 { 1.234321234321234e-10, "1.23432e-10" },
2249 { 1.234321234321234e-9, "1.23432e-09" },
2250 { 1.234321234321234e-8, "1.23432e-08" },
2251 { 1.234321234321234e-7, "1.23432e-07" },
2252 { 1.234321234321234e-6, "1.23432e-06" },
2253 { 1.234321234321234e-5, "1.23432e-05" },
2254 { 1.234321234321234e-4, "0.000123432" },
2255 { 1.234321234321234e-3, "0.00123432" },
2256 { 1.234321234321234e-2, "0.0123432" },
2257 { 1.234321234321234e-1, "0.123432" },
2258 { 1.234321234321234, "1.23432" },
2259 { 1.234321234321234e1, "12.3432" },
2260 { 1.234321234321234e2, "123.432" },
2261 { 1.234321234321234e3, "1234.32" },
2262 { 1.234321234321234e4, "12343.2" },
2263 { 1.234321234321234e5, "123432" },
2264 { 1.234321234321234e6, "1.23432e+06" },
2265 { 1.234321234321234e7, "1.23432e+07" },
2266 { 1.234321234321234e8, "1.23432e+08" },
2267 { 1.234321234321234e9, "1.23432e+09" },
2268 { 1.234321234321234e10, "1.23432e+10" },
2269 { 1.234321234321234e11, "1.23432e+11" },
2270 { 1.234321234321234e12, "1.23432e+12" },
2271 { 1.234321234321234e13, "1.23432e+13" },
2272 { 1.234321234321234e14, "1.23432e+14" },
2273 { 1.234321234321234e15, "1.23432e+15" },
2274 { 1.234321234321234e16, "1.23432e+16" },
2275 { 1.234321234321234e17, "1.23432e+17" },
2276 { 1.234321234321234e18, "1.23432e+18" },
2277 { 1.234321234321234e19, "1.23432e+19" },
2278 { 1.234321234321234e20, "1.23432e+20" },
2279 { 1.234321234321234e21, "1.23432e+21" },
2280 { 1.234321234321234e22, "1.23432e+22" },
2281 { 1.234321234321234e23, "1.23432e+23" },
2282 { 1.234321234321234e24, "1.23432e+24" },
2283 { 1.234321234321234e25, "1.23432e+25" },
2284 { 1.234321234321234e26, "1.23432e+26" },
2285 { 1.234321234321234e27, "1.23432e+27" },
2286 { 1.234321234321234e28, "1.23432e+28" },
2287 { 1.234321234321234e29, "1.23432e+29" },
2288 { 1.234321234321234e30, "1.23432e+30" },
2289 { 1.234321234321234e31, "1.23432e+31" },
2290 { 1.234321234321234e32, "1.23432e+32" },
2291 { 1.234321234321234e33, "1.23432e+33" },
2292 { 1.234321234321234e34, "1.23432e+34" },
2293 { 1.234321234321234e35, "1.23432e+35" },
2294 { 1.234321234321234e36, "1.23432e+36" }
2295 };
2296 size_t k;
2297 for (k = 0; k < SIZEOF (data); k++)
2298 {
2299 int retval =
2300 my_snprintf (result, sizeof (result), "%g", data[k].value);
2301 const char *expected = data[k].string;
2302 ASSERT (strcmp (result, expected) == 0
2303 /* Some implementations produce exponents with 3 digits. */
2304 || (expected[strlen (expected) - 4] == 'e'
2305 && strlen (result) == strlen (expected) + 1
2306 && memcmp (result, expected, strlen (expected) - 2) == 0
2307 && result[strlen (expected) - 2] == '0'
2308 && strcmp (result + strlen (expected) - 1,
2309 expected + strlen (expected) - 2)
2310 == 0));
2311 ASSERT (retval == strlen (result));
2312 }
2313 }
2314
2315 { /* A negative number. */
2316 int retval =
2317 my_snprintf (result, sizeof (result), "%g %d", -0.03125, 33, 44, 55);
2318 ASSERT (strcmp (result, "-0.03125 33") == 0);
2319 ASSERT (retval == strlen (result));
2320 }
2321
2322 { /* Positive zero. */
2323 int retval =
2324 my_snprintf (result, sizeof (result), "%g %d", 0.0, 33, 44, 55);
2325 ASSERT (strcmp (result, "0 33") == 0);
2326 ASSERT (retval == strlen (result));
2327 }
2328
2329 { /* Negative zero. */
2330 int retval =
2331 my_snprintf (result, sizeof (result), "%g %d", minus_zerod, 33, 44, 55);
2332 if (have_minus_zero ())
2333 ASSERT (strcmp (result, "-0 33") == 0);
2334 ASSERT (retval == strlen (result));
2335 }
2336
2337 { /* Positive infinity. */
2338 int retval =
2339 my_snprintf (result, sizeof (result), "%g %d", Infinityd (), 33, 44, 55);
2340 ASSERT (strcmp (result, "inf 33") == 0
2341 || strcmp (result, "infinity 33") == 0);
2342 ASSERT (retval == strlen (result));
2343 }
2344
2345 { /* Negative infinity. */
2346 int retval =
2347 my_snprintf (result, sizeof (result), "%g %d", - Infinityd (), 33, 44, 55);
2348 ASSERT (strcmp (result, "-inf 33") == 0
2349 || strcmp (result, "-infinity 33") == 0);
2350 ASSERT (retval == strlen (result));
2351 }
2352
2353 { /* NaN. */
2354 int retval =
2355 my_snprintf (result, sizeof (result), "%g %d", NaNd (), 33, 44, 55);
2356 ASSERT (strlen (result) >= 3 + 3
2357 && strisnan (result, 0, strlen (result) - 3, 0)
2358 && strcmp (result + strlen (result) - 3, " 33") == 0);
2359 ASSERT (retval == strlen (result));
2360 }
2361 #if HAVE_SNAND
2362 { /* Signalling NaN. */
2363 int retval =
2364 my_snprintf (result, sizeof (result), "%g %d", SNaNd (), 33, 44, 55);
2365 ASSERT (strlen (result) >= 3 + 3
2366 && strisnan (result, 0, strlen (result) - 3, 0)
2367 && strcmp (result + strlen (result) - 3, " 33") == 0);
2368 ASSERT (retval == strlen (result));
2369 }
2370 #endif
2371
2372 { /* Width. */
2373 int retval =
2374 my_snprintf (result, sizeof (result), "%10g %d", 1.75, 33, 44, 55);
2375 ASSERT (strcmp (result, " 1.75 33") == 0);
2376 ASSERT (retval == strlen (result));
2377 }
2378
2379 { /* Width given as argument. */
2380 int retval =
2381 my_snprintf (result, sizeof (result), "%*g %d", 10, 1.75, 33, 44, 55);
2382 ASSERT (strcmp (result, " 1.75 33") == 0);
2383 ASSERT (retval == strlen (result));
2384 }
2385
2386 { /* Negative width given as argument (cf. FLAG_LEFT below). */
2387 int retval =
2388 my_snprintf (result, sizeof (result), "%*g %d", -10, 1.75, 33, 44, 55);
2389 ASSERT (strcmp (result, "1.75 33") == 0);
2390 ASSERT (retval == strlen (result));
2391 }
2392
2393 { /* FLAG_LEFT. */
2394 int retval =
2395 my_snprintf (result, sizeof (result), "%-10g %d", 1.75, 33, 44, 55);
2396 ASSERT (strcmp (result, "1.75 33") == 0);
2397 ASSERT (retval == strlen (result));
2398 }
2399
2400 { /* FLAG_SHOWSIGN. */
2401 int retval =
2402 my_snprintf (result, sizeof (result), "%+g %d", 1.75, 33, 44, 55);
2403 ASSERT (strcmp (result, "+1.75 33") == 0);
2404 ASSERT (retval == strlen (result));
2405 }
2406
2407 { /* FLAG_SPACE. */
2408 int retval =
2409 my_snprintf (result, sizeof (result), "% g %d", 1.75, 33, 44, 55);
2410 ASSERT (strcmp (result, " 1.75 33") == 0);
2411 ASSERT (retval == strlen (result));
2412 }
2413
2414 { /* FLAG_ALT. */
2415 int retval =
2416 my_snprintf (result, sizeof (result), "%#g %d", 1.75, 33, 44, 55);
2417 ASSERT (strcmp (result, "1.75000 33") == 0);
2418 ASSERT (retval == strlen (result));
2419 }
2420
2421 { /* FLAG_ALT. */
2422 int retval =
2423 my_snprintf (result, sizeof (result), "%#.g %d", 1.75, 33, 44, 55);
2424 ASSERT (strcmp (result, "2. 33") == 0);
2425 ASSERT (retval == strlen (result));
2426 }
2427
2428 { /* FLAG_ALT. */
2429 int retval =
2430 my_snprintf (result, sizeof (result), "%#.g %d", 9.75, 33, 44, 55);
2431 ASSERT (strcmp (result, "1.e+01 33") == 0
2432 || strcmp (result, "1.e+001 33") == 0);
2433 ASSERT (retval == strlen (result));
2434 }
2435
2436 { /* FLAG_ZERO with finite number. */
2437 int retval =
2438 my_snprintf (result, sizeof (result), "%010g %d", 1234.0, 33, 44, 55);
2439 ASSERT (strcmp (result, "0000001234 33") == 0);
2440 ASSERT (retval == strlen (result));
2441 }
2442
2443 { /* FLAG_ZERO with infinite number. */
2444 int retval =
2445 my_snprintf (result, sizeof (result), "%015g %d", - Infinityd (), 33, 44, 55);
2446 ASSERT (strcmp (result, " -inf 33") == 0
2447 || strcmp (result, " -infinity 33") == 0);
2448 ASSERT (retval == strlen (result));
2449 }
2450
2451 { /* FLAG_ZERO with NaN. */
2452 int retval =
2453 my_snprintf (result, sizeof (result), "%050g %d", NaNd (), 33, 44, 55);
2454 ASSERT (strlen (result) == 50 + 3
2455 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2456 && strcmp (result + strlen (result) - 3, " 33") == 0);
2457 ASSERT (retval == strlen (result));
2458 }
2459
2460 { /* Precision. */
2461 int retval =
2462 my_snprintf (result, sizeof (result), "%.g %d", 1234.0, 33, 44, 55);
2463 ASSERT (strcmp (result, "1e+03 33") == 0
2464 || strcmp (result, "1e+003 33") == 0);
2465 ASSERT (retval == strlen (result));
2466 }
2467
2468 { /* Precision with no rounding. */
2469 int retval =
2470 my_snprintf (result, sizeof (result), "%.5g %d", 999.951, 33, 44, 55);
2471 ASSERT (strcmp (result, "999.95 33") == 0);
2472 ASSERT (retval == strlen (result));
2473 }
2474
2475 { /* Precision with rounding. */
2476 int retval =
2477 my_snprintf (result, sizeof (result), "%.5g %d", 999.996, 33, 44, 55);
2478 ASSERT (strcmp (result, "1000 33") == 0);
2479 ASSERT (retval == strlen (result));
2480 }
2481
2482 { /* A positive number. */
2483 int retval =
2484 my_snprintf (result, sizeof (result), "%Lg %d", 12.75L, 33, 44, 55);
2485 ASSERT (strcmp (result, "12.75 33") == 0);
2486 ASSERT (retval == strlen (result));
2487 }
2488
2489 { /* A larger positive number. */
2490 int retval =
2491 my_snprintf (result, sizeof (result), "%Lg %d", 1234567.0L, 33, 44, 55);
2492 ASSERT (strcmp (result, "1.23457e+06 33") == 0
2493 || strcmp (result, "1.23457e+006 33") == 0);
2494 ASSERT (retval == strlen (result));
2495 }
2496
2497 { /* Small and large positive numbers. */
2498 static struct { long double value; const char *string; } data[] =
2499 {
2500 { 1.234321234321234e-37L, "1.23432e-37" },
2501 { 1.234321234321234e-36L, "1.23432e-36" },
2502 { 1.234321234321234e-35L, "1.23432e-35" },
2503 { 1.234321234321234e-34L, "1.23432e-34" },
2504 { 1.234321234321234e-33L, "1.23432e-33" },
2505 { 1.234321234321234e-32L, "1.23432e-32" },
2506 { 1.234321234321234e-31L, "1.23432e-31" },
2507 { 1.234321234321234e-30L, "1.23432e-30" },
2508 { 1.234321234321234e-29L, "1.23432e-29" },
2509 { 1.234321234321234e-28L, "1.23432e-28" },
2510 { 1.234321234321234e-27L, "1.23432e-27" },
2511 { 1.234321234321234e-26L, "1.23432e-26" },
2512 { 1.234321234321234e-25L, "1.23432e-25" },
2513 { 1.234321234321234e-24L, "1.23432e-24" },
2514 { 1.234321234321234e-23L, "1.23432e-23" },
2515 { 1.234321234321234e-22L, "1.23432e-22" },
2516 { 1.234321234321234e-21L, "1.23432e-21" },
2517 { 1.234321234321234e-20L, "1.23432e-20" },
2518 { 1.234321234321234e-19L, "1.23432e-19" },
2519 { 1.234321234321234e-18L, "1.23432e-18" },
2520 { 1.234321234321234e-17L, "1.23432e-17" },
2521 { 1.234321234321234e-16L, "1.23432e-16" },
2522 { 1.234321234321234e-15L, "1.23432e-15" },
2523 { 1.234321234321234e-14L, "1.23432e-14" },
2524 { 1.234321234321234e-13L, "1.23432e-13" },
2525 { 1.234321234321234e-12L, "1.23432e-12" },
2526 { 1.234321234321234e-11L, "1.23432e-11" },
2527 { 1.234321234321234e-10L, "1.23432e-10" },
2528 { 1.234321234321234e-9L, "1.23432e-09" },
2529 { 1.234321234321234e-8L, "1.23432e-08" },
2530 { 1.234321234321234e-7L, "1.23432e-07" },
2531 { 1.234321234321234e-6L, "1.23432e-06" },
2532 { 1.234321234321234e-5L, "1.23432e-05" },
2533 { 1.234321234321234e-4L, "0.000123432" },
2534 { 1.234321234321234e-3L, "0.00123432" },
2535 { 1.234321234321234e-2L, "0.0123432" },
2536 { 1.234321234321234e-1L, "0.123432" },
2537 { 1.234321234321234L, "1.23432" },
2538 { 1.234321234321234e1L, "12.3432" },
2539 { 1.234321234321234e2L, "123.432" },
2540 { 1.234321234321234e3L, "1234.32" },
2541 { 1.234321234321234e4L, "12343.2" },
2542 { 1.234321234321234e5L, "123432" },
2543 { 1.234321234321234e6L, "1.23432e+06" },
2544 { 1.234321234321234e7L, "1.23432e+07" },
2545 { 1.234321234321234e8L, "1.23432e+08" },
2546 { 1.234321234321234e9L, "1.23432e+09" },
2547 { 1.234321234321234e10L, "1.23432e+10" },
2548 { 1.234321234321234e11L, "1.23432e+11" },
2549 { 1.234321234321234e12L, "1.23432e+12" },
2550 { 1.234321234321234e13L, "1.23432e+13" },
2551 { 1.234321234321234e14L, "1.23432e+14" },
2552 { 1.234321234321234e15L, "1.23432e+15" },
2553 { 1.234321234321234e16L, "1.23432e+16" },
2554 { 1.234321234321234e17L, "1.23432e+17" },
2555 { 1.234321234321234e18L, "1.23432e+18" },
2556 { 1.234321234321234e19L, "1.23432e+19" },
2557 { 1.234321234321234e20L, "1.23432e+20" },
2558 { 1.234321234321234e21L, "1.23432e+21" },
2559 { 1.234321234321234e22L, "1.23432e+22" },
2560 { 1.234321234321234e23L, "1.23432e+23" },
2561 { 1.234321234321234e24L, "1.23432e+24" },
2562 { 1.234321234321234e25L, "1.23432e+25" },
2563 { 1.234321234321234e26L, "1.23432e+26" },
2564 { 1.234321234321234e27L, "1.23432e+27" },
2565 { 1.234321234321234e28L, "1.23432e+28" },
2566 { 1.234321234321234e29L, "1.23432e+29" },
2567 { 1.234321234321234e30L, "1.23432e+30" },
2568 { 1.234321234321234e31L, "1.23432e+31" },
2569 { 1.234321234321234e32L, "1.23432e+32" },
2570 { 1.234321234321234e33L, "1.23432e+33" },
2571 { 1.234321234321234e34L, "1.23432e+34" },
2572 { 1.234321234321234e35L, "1.23432e+35" },
2573 { 1.234321234321234e36L, "1.23432e+36" }
2574 };
2575 size_t k;
2576 for (k = 0; k < SIZEOF (data); k++)
2577 {
2578 int retval =
2579 my_snprintf (result, sizeof (result), "%Lg", data[k].value);
2580 const char *expected = data[k].string;
2581 ASSERT (strcmp (result, expected) == 0
2582 /* Some implementations produce exponents with 3 digits. */
2583 || (expected[strlen (expected) - 4] == 'e'
2584 && strlen (result) == strlen (expected) + 1
2585 && memcmp (result, expected, strlen (expected) - 2) == 0
2586 && result[strlen (expected) - 2] == '0'
2587 && strcmp (result + strlen (expected) - 1,
2588 expected + strlen (expected) - 2)
2589 == 0));
2590 ASSERT (retval == strlen (result));
2591 }
2592 }
2593
2594 { /* A negative number. */
2595 int retval =
2596 my_snprintf (result, sizeof (result), "%Lg %d", -0.03125L, 33, 44, 55);
2597 ASSERT (strcmp (result, "-0.03125 33") == 0);
2598 ASSERT (retval == strlen (result));
2599 }
2600
2601 { /* Positive zero. */
2602 int retval =
2603 my_snprintf (result, sizeof (result), "%Lg %d", 0.0L, 33, 44, 55);
2604 ASSERT (strcmp (result, "0 33") == 0);
2605 ASSERT (retval == strlen (result));
2606 }
2607
2608 { /* Negative zero. */
2609 int retval =
2610 my_snprintf (result, sizeof (result), "%Lg %d", minus_zerol, 33, 44, 55);
2611 if (have_minus_zero ())
2612 ASSERT (strcmp (result, "-0 33") == 0);
2613 ASSERT (retval == strlen (result));
2614 }
2615
2616 { /* Positive infinity. */
2617 int retval =
2618 my_snprintf (result, sizeof (result), "%Lg %d", Infinityl (), 33, 44, 55);
2619 ASSERT (strcmp (result, "inf 33") == 0
2620 || strcmp (result, "infinity 33") == 0);
2621 ASSERT (retval == strlen (result));
2622 }
2623
2624 { /* Negative infinity. */
2625 int retval =
2626 my_snprintf (result, sizeof (result), "%Lg %d", - Infinityl (), 33, 44, 55);
2627 ASSERT (strcmp (result, "-inf 33") == 0
2628 || strcmp (result, "-infinity 33") == 0);
2629 ASSERT (retval == strlen (result));
2630 }
2631
2632 { /* NaN. */
2633 int retval =
2634 my_snprintf (result, sizeof (result), "%Lg %d", NaNl (), 33, 44, 55);
2635 ASSERT (strlen (result) >= 3 + 3
2636 && strisnan (result, 0, strlen (result) - 3, 0)
2637 && strcmp (result + strlen (result) - 3, " 33") == 0);
2638 ASSERT (retval == strlen (result));
2639 }
2640 #if HAVE_SNANL
2641 { /* Signalling NaN. */
2642 int retval =
2643 my_snprintf (result, sizeof (result), "%Lg %d", SNaNl (), 33, 44, 55);
2644 ASSERT (strlen (result) >= 3 + 3
2645 && strisnan (result, 0, strlen (result) - 3, 0)
2646 && strcmp (result + strlen (result) - 3, " 33") == 0);
2647 ASSERT (retval == strlen (result));
2648 }
2649 #endif
2650 #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
2651 { /* Quiet NaN. */
2652 static union { unsigned int word[4]; long double value; } x =
2653 { .word = LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
2654 int retval =
2655 my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
2656 ASSERT (strlen (result) >= 3 + 3
2657 && strisnan (result, 0, strlen (result) - 3, 0)
2658 && strcmp (result + strlen (result) - 3, " 33") == 0);
2659 ASSERT (retval == strlen (result));
2660 }
2661 {
2662 /* Signalling NaN. */
2663 static union { unsigned int word[4]; long double value; } x =
2664 { .word = LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
2665 int retval =
2666 my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
2667 ASSERT (strlen (result) >= 3 + 3
2668 && strisnan (result, 0, strlen (result) - 3, 0)
2669 && strcmp (result + strlen (result) - 3, " 33") == 0);
2670 ASSERT (retval == strlen (result));
2671 }
2672 /* snprintf should print something for noncanonical values. */
2673 { /* Pseudo-NaN. */
2674 static union { unsigned int word[4]; long double value; } x =
2675 { .word = LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
2676 int retval =
2677 my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
2678 ASSERT (retval == strlen (result));
2679 ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
2680 }
2681 { /* Pseudo-Infinity. */
2682 static union { unsigned int word[4]; long double value; } x =
2683 { .word = LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
2684 int retval =
2685 my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
2686 ASSERT (retval == strlen (result));
2687 ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
2688 }
2689 { /* Pseudo-Zero. */
2690 static union { unsigned int word[4]; long double value; } x =
2691 { .word = LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
2692 int retval =
2693 my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
2694 ASSERT (retval == strlen (result));
2695 ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
2696 }
2697 { /* Unnormalized number. */
2698 static union { unsigned int word[4]; long double value; } x =
2699 { .word = LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
2700 int retval =
2701 my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
2702 ASSERT (retval == strlen (result));
2703 ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
2704 }
2705 { /* Pseudo-Denormal. */
2706 static union { unsigned int word[4]; long double value; } x =
2707 { .word = LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
2708 int retval =
2709 my_snprintf (result, sizeof (result), "%Lg %d", x.value, 33, 44, 55);
2710 ASSERT (retval == strlen (result));
2711 ASSERT (3 < retval && strcmp (result + retval - 3, " 33") == 0);
2712 }
2713 #endif
2714
2715 { /* Width. */
2716 int retval =
2717 my_snprintf (result, sizeof (result), "%10Lg %d", 1.75L, 33, 44, 55);
2718 ASSERT (strcmp (result, " 1.75 33") == 0);
2719 ASSERT (retval == strlen (result));
2720 }
2721
2722 { /* Width given as argument. */
2723 int retval =
2724 my_snprintf (result, sizeof (result), "%*Lg %d", 10, 1.75L, 33, 44, 55);
2725 ASSERT (strcmp (result, " 1.75 33") == 0);
2726 ASSERT (retval == strlen (result));
2727 }
2728
2729 { /* Negative width given as argument (cf. FLAG_LEFT below). */
2730 int retval =
2731 my_snprintf (result, sizeof (result), "%*Lg %d", -10, 1.75L, 33, 44, 55);
2732 ASSERT (strcmp (result, "1.75 33") == 0);
2733 ASSERT (retval == strlen (result));
2734 }
2735
2736 { /* FLAG_LEFT. */
2737 int retval =
2738 my_snprintf (result, sizeof (result), "%-10Lg %d", 1.75L, 33, 44, 55);
2739 ASSERT (strcmp (result, "1.75 33") == 0);
2740 ASSERT (retval == strlen (result));
2741 }
2742
2743 { /* FLAG_SHOWSIGN. */
2744 int retval =
2745 my_snprintf (result, sizeof (result), "%+Lg %d", 1.75L, 33, 44, 55);
2746 ASSERT (strcmp (result, "+1.75 33") == 0);
2747 ASSERT (retval == strlen (result));
2748 }
2749
2750 { /* FLAG_SPACE. */
2751 int retval =
2752 my_snprintf (result, sizeof (result), "% Lg %d", 1.75L, 33, 44, 55);
2753 ASSERT (strcmp (result, " 1.75 33") == 0);
2754 ASSERT (retval == strlen (result));
2755 }
2756
2757 { /* FLAG_ALT. */
2758 int retval =
2759 my_snprintf (result, sizeof (result), "%#Lg %d", 1.75L, 33, 44, 55);
2760 ASSERT (strcmp (result, "1.75000 33") == 0);
2761 ASSERT (retval == strlen (result));
2762 }
2763
2764 { /* FLAG_ALT. */
2765 int retval =
2766 my_snprintf (result, sizeof (result), "%#.Lg %d", 1.75L, 33, 44, 55);
2767 ASSERT (strcmp (result, "2. 33") == 0);
2768 ASSERT (retval == strlen (result));
2769 }
2770
2771 { /* FLAG_ALT. */
2772 int retval =
2773 my_snprintf (result, sizeof (result), "%#.Lg %d", 9.75L, 33, 44, 55);
2774 ASSERT (strcmp (result, "1.e+01 33") == 0
2775 || strcmp (result, "1.e+001 33") == 0);
2776 ASSERT (retval == strlen (result));
2777 }
2778
2779 { /* FLAG_ZERO with finite number. */
2780 int retval =
2781 my_snprintf (result, sizeof (result), "%010Lg %d", 1234.0L, 33, 44, 55);
2782 ASSERT (strcmp (result, "0000001234 33") == 0);
2783 ASSERT (retval == strlen (result));
2784 }
2785
2786 { /* FLAG_ZERO with infinite number. */
2787 int retval =
2788 my_snprintf (result, sizeof (result), "%015Lg %d", - Infinityl (), 33, 44, 55);
2789 ASSERT (strcmp (result, " -inf 33") == 0
2790 || strcmp (result, " -infinity 33") == 0);
2791 ASSERT (retval == strlen (result));
2792 }
2793
2794 { /* FLAG_ZERO with NaN. */
2795 int retval =
2796 my_snprintf (result, sizeof (result), "%050Lg %d", NaNl (), 33, 44, 55);
2797 ASSERT (strlen (result) == 50 + 3
2798 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
2799 && strcmp (result + strlen (result) - 3, " 33") == 0);
2800 ASSERT (retval == strlen (result));
2801 }
2802
2803 { /* Precision. */
2804 int retval =
2805 my_snprintf (result, sizeof (result), "%.Lg %d", 1234.0L, 33, 44, 55);
2806 ASSERT (strcmp (result, "1e+03 33") == 0
2807 || strcmp (result, "1e+003 33") == 0);
2808 ASSERT (retval == strlen (result));
2809 }
2810
2811 { /* Precision with no rounding. */
2812 int retval =
2813 my_snprintf (result, sizeof (result), "%.5Lg %d", 999.951L, 33, 44, 55);
2814 ASSERT (strcmp (result, "999.95 33") == 0);
2815 ASSERT (retval == strlen (result));
2816 }
2817
2818 { /* Precision with rounding. */
2819 int retval =
2820 my_snprintf (result, sizeof (result), "%.5Lg %d", 999.996L, 33, 44, 55);
2821 ASSERT (strcmp (result, "1000 33") == 0);
2822 ASSERT (retval == strlen (result));
2823 }
2824
2825 #if NEED_PRINTF_WITH_N_DIRECTIVE
2826 /* Test the support of the %n format directive. */
2827
2828 {
2829 int count = -1;
2830 int retval =
2831 my_snprintf (result, sizeof (result), "%d %n", 123, &count, 33, 44, 55);
2832 ASSERT (strcmp (result, "123 ") == 0);
2833 ASSERT (retval == strlen (result));
2834 ASSERT (count == 4);
2835 }
2836 #endif
2837
2838 /* Test the support of the POSIX/XSI format strings with positions. */
2839
2840 {
2841 int retval =
2842 my_snprintf (result, sizeof (result), "%2$d %1$d", 33, 55);
2843 ASSERT (strcmp (result, "55 33") == 0);
2844 ASSERT (retval == strlen (result));
2845 }
2846
2847 /* Test the support of the grouping flag. */
2848
2849 {
2850 int retval =
2851 my_snprintf (result, sizeof (result), "%'d %d", 1234567, 99);
2852 ASSERT (result[strlen (result) - 1] == '9');
2853 ASSERT (retval == strlen (result));
2854 }
2855
2856 /* Test the support of the left-adjust flag. */
2857
2858 {
2859 int retval =
2860 my_snprintf (result, sizeof (result), "a%*sc", -3, "b");
2861 ASSERT (strcmp (result, "ab c") == 0);
2862 ASSERT (retval == strlen (result));
2863 }
2864
2865 {
2866 int retval =
2867 my_snprintf (result, sizeof (result), "a%-*sc", 3, "b");
2868 ASSERT (strcmp (result, "ab c") == 0);
2869 ASSERT (retval == strlen (result));
2870 }
2871
2872 {
2873 int retval =
2874 my_snprintf (result, sizeof (result), "a%-*sc", -3, "b");
2875 ASSERT (strcmp (result, "ab c") == 0);
2876 ASSERT (retval == strlen (result));
2877 }
2878
2879 /* Test the support of large precision. */
2880
2881 {
2882 int retval =
2883 my_snprintf (result, sizeof (result), "%.4000d %d", 1234567, 99);
2884 size_t i;
2885 for (i = 0; i < 4000 - 7; i++)
2886 ASSERT (result[i] == '0');
2887 ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
2888 ASSERT (retval == strlen (result));
2889 }
2890
2891 {
2892 int retval =
2893 my_snprintf (result, sizeof (result), "%.*d %d", 4000, 1234567, 99);
2894 size_t i;
2895 for (i = 0; i < 4000 - 7; i++)
2896 ASSERT (result[i] == '0');
2897 ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
2898 ASSERT (retval == strlen (result));
2899 }
2900
2901 {
2902 int retval =
2903 my_snprintf (result, sizeof (result), "%.4000d %d", -1234567, 99);
2904 size_t i;
2905 ASSERT (result[0] == '-');
2906 for (i = 0; i < 4000 - 7; i++)
2907 ASSERT (result[1 + i] == '0');
2908 ASSERT (strcmp (result + 1 + 4000 - 7, "1234567 99") == 0);
2909 ASSERT (retval == strlen (result));
2910 }
2911
2912 {
2913 int retval =
2914 my_snprintf (result, sizeof (result), "%.4000u %d", 1234567, 99);
2915 size_t i;
2916 for (i = 0; i < 4000 - 7; i++)
2917 ASSERT (result[i] == '0');
2918 ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
2919 ASSERT (retval == strlen (result));
2920 }
2921
2922 {
2923 int retval =
2924 my_snprintf (result, sizeof (result), "%.4000o %d", 1234567, 99);
2925 size_t i;
2926 for (i = 0; i < 4000 - 7; i++)
2927 ASSERT (result[i] == '0');
2928 ASSERT (strcmp (result + 4000 - 7, "4553207 99") == 0);
2929 ASSERT (retval == strlen (result));
2930 }
2931
2932 {
2933 int retval =
2934 my_snprintf (result, sizeof (result), "%.4000x %d", 1234567, 99);
2935 size_t i;
2936 for (i = 0; i < 4000 - 6; i++)
2937 ASSERT (result[i] == '0');
2938 ASSERT (strcmp (result + 4000 - 6, "12d687 99") == 0);
2939 ASSERT (retval == strlen (result));
2940 }
2941
2942 {
2943 int retval =
2944 my_snprintf (result, sizeof (result), "%#.4000x %d", 1234567, 99);
2945 size_t i;
2946 ASSERT (result[0] == '0');
2947 ASSERT (result[1] == 'x');
2948 for (i = 0; i < 4000 - 6; i++)
2949 ASSERT (result[2 + i] == '0');
2950 ASSERT (strcmp (result + 2 + 4000 - 6, "12d687 99") == 0);
2951 ASSERT (retval == strlen (result));
2952 }
2953
2954 {
2955 int retval =
2956 my_snprintf (result, sizeof (result), "%.4000f %d", 1.0, 99);
2957 size_t i;
2958 ASSERT (result[0] == '1');
2959 ASSERT (result[1] == '.');
2960 for (i = 0; i < 4000; i++)
2961 ASSERT (result[2 + i] == '0');
2962 ASSERT (strcmp (result + 2 + 4000, " 99") == 0);
2963 ASSERT (retval == strlen (result));
2964 }
2965
2966 {
2967 int retval =
2968 my_snprintf (result, sizeof (result), "%.511f %d", 1.0, 99);
2969 size_t i;
2970 ASSERT (result[0] == '1');
2971 ASSERT (result[1] == '.');
2972 for (i = 0; i < 511; i++)
2973 ASSERT (result[2 + i] == '0');
2974 ASSERT (strcmp (result + 2 + 511, " 99") == 0);
2975 ASSERT (retval == strlen (result));
2976 }
2977
2978 {
2979 char input[5000];
2980 int retval;
2981 size_t i;
2982
2983 for (i = 0; i < sizeof (input) - 1; i++)
2984 input[i] = 'a' + ((1000000 / (i + 1)) % 26);
2985 input[i] = '\0';
2986 retval = my_snprintf (result, sizeof (result), "%.4000s %d", input, 99);
2987 ASSERT (memcmp (result, input, 4000) == 0);
2988 ASSERT (strcmp (result + 4000, " 99") == 0);
2989 ASSERT (retval == strlen (result));
2990 }
2991
2992 /* Test the support of the %s format directive. */
2993
2994 { /* Width. */
2995 int retval =
2996 my_snprintf (result, sizeof (result), "%10s %d", "xyz", 33, 44, 55);
2997 ASSERT (strcmp (result, " xyz 33") == 0);
2998 ASSERT (retval == strlen (result));
2999 }
3000
3001 { /* Width given as argument. */
3002 int retval =
3003 my_snprintf (result, sizeof (result), "%*s %d", 10, "xyz", 33, 44, 55);
3004 ASSERT (strcmp (result, " xyz 33") == 0);
3005 ASSERT (retval == strlen (result));
3006 }
3007
3008 { /* Negative width given as argument (cf. FLAG_LEFT below). */
3009 int retval =
3010 my_snprintf (result, sizeof (result), "%*s %d", -10, "xyz", 33, 44, 55);
3011 ASSERT (strcmp (result, "xyz 33") == 0);
3012 ASSERT (retval == strlen (result));
3013 }
3014
3015 { /* FLAG_LEFT. */
3016 int retval =
3017 my_snprintf (result, sizeof (result), "%-10s %d", "xyz", 33, 44, 55);
3018 ASSERT (strcmp (result, "xyz 33") == 0);
3019 ASSERT (retval == strlen (result));
3020 }
3021
3022 #if HAVE_WCHAR_T
3023 static wchar_t L_xyz[4] = { 'x', 'y', 'z', 0 };
3024
3025 { /* Width. */
3026 int retval =
3027 my_snprintf (result, sizeof (result), "%10ls %d", L_xyz, 33, 44, 55);
3028 ASSERT (strcmp (result, " xyz 33") == 0);
3029 ASSERT (retval == strlen (result));
3030 }
3031
3032 { /* Width given as argument. */
3033 int retval =
3034 my_snprintf (result, sizeof (result), "%*ls %d", 10, L_xyz, 33, 44, 55);
3035 ASSERT (strcmp (result, " xyz 33") == 0);
3036 ASSERT (retval == strlen (result));
3037 }
3038
3039 { /* Negative width given as argument (cf. FLAG_LEFT below). */
3040 int retval =
3041 my_snprintf (result, sizeof (result), "%*ls %d", -10, L_xyz, 33, 44, 55);
3042 ASSERT (strcmp (result, "xyz 33") == 0);
3043 ASSERT (retval == strlen (result));
3044 }
3045
3046 { /* FLAG_LEFT. */
3047 int retval =
3048 my_snprintf (result, sizeof (result), "%-10ls %d", L_xyz, 33, 44, 55);
3049 ASSERT (strcmp (result, "xyz 33") == 0);
3050 ASSERT (retval == strlen (result));
3051 }
3052 #endif
3053
3054 /* To verify that these tests succeed, it is necessary to run them under
3055 a tool that checks against invalid memory accesses, such as ElectricFence
3056 or "valgrind --tool=memcheck". */
3057 {
3058 size_t i;
3059
3060 for (i = 1; i <= 8; i++)
3061 {
3062 char *block;
3063 int retval;
3064
3065 block = (char *) malloc (i);
3066 memcpy (block, "abcdefgh", i);
3067 retval = my_snprintf (result, sizeof (result), "%.*s", (int) i, block);
3068 ASSERT (memcmp (result, block, i) == 0);
3069 ASSERT (result[i] == '\0');
3070 ASSERT (retval == strlen (result));
3071 free (block);
3072 }
3073 }
3074 #if HAVE_WCHAR_T
3075 {
3076 size_t i;
3077
3078 for (i = 1; i <= 8; i++)
3079 {
3080 wchar_t *block;
3081 size_t j;
3082 int retval;
3083
3084 block = (wchar_t *) malloc (i * sizeof (wchar_t));
3085 for (j = 0; j < i; j++)
3086 block[j] = "abcdefgh"[j];
3087 retval = my_snprintf (result, sizeof (result), "%.*ls", (int) i, block);
3088 ASSERT (memcmp (result, "abcdefgh", i) == 0);
3089 ASSERT (result[i] == '\0');
3090 ASSERT (retval == strlen (result));
3091 free (block);
3092 }
3093 }
3094 #endif
3095
3096 /* Test the support of the %c format directive. */
3097
3098 { /* Width. */
3099 int retval =
3100 my_snprintf (result, sizeof (result),
3101 "%10c %d", (unsigned char) 'x', 33, 44, 55);
3102 ASSERT (strcmp (result, " x 33") == 0);
3103 ASSERT (retval == strlen (result));
3104 }
3105
3106 { /* Width given as argument. */
3107 int retval =
3108 my_snprintf (result, sizeof (result),
3109 "%*c %d", 10, (unsigned char) 'x', 33, 44, 55);
3110 ASSERT (strcmp (result, " x 33") == 0);
3111 ASSERT (retval == strlen (result));
3112 }
3113
3114 { /* Negative width given as argument (cf. FLAG_LEFT below). */
3115 int retval =
3116 my_snprintf (result, sizeof (result),
3117 "%*c %d", -10, (unsigned char) 'x', 33, 44, 55);
3118 ASSERT (strcmp (result, "x 33") == 0);
3119 ASSERT (retval == strlen (result));
3120 }
3121
3122 { /* FLAG_LEFT. */
3123 int retval =
3124 my_snprintf (result, sizeof (result),
3125 "%-10c %d", (unsigned char) 'x', 33, 44, 55);
3126 ASSERT (strcmp (result, "x 33") == 0);
3127 ASSERT (retval == strlen (result));
3128 }
3129
3130 { /* Precision is ignored. */
3131 int retval =
3132 my_snprintf (result, sizeof (result),
3133 "%.0c %d", (unsigned char) 'x', 33, 44, 55);
3134 ASSERT (strcmp (result, "x 33") == 0);
3135 ASSERT (retval == strlen (result));
3136 }
3137
3138 { /* NUL character. */
3139 int retval =
3140 my_snprintf (result, sizeof (result),
3141 "a%cz %d", '\0', 33, 44, 55);
3142 ASSERT (memcmp (result, "a\0z 33\0", 6 + 1) == 0);
3143 ASSERT (retval == 6);
3144 }
3145
3146 #if HAVE_WCHAR_T
3147 static wint_t L_x = (wchar_t) 'x';
3148
3149 { /* Width. */
3150 int retval =
3151 my_snprintf (result, sizeof (result), "%10lc %d", L_x, 33, 44, 55);
3152 ASSERT (strcmp (result, " x 33") == 0);
3153 ASSERT (retval == strlen (result));
3154 }
3155
3156 { /* Width given as argument. */
3157 int retval =
3158 my_snprintf (result, sizeof (result), "%*lc %d", 10, L_x, 33, 44, 55);
3159 ASSERT (strcmp (result, " x 33") == 0);
3160 ASSERT (retval == strlen (result));
3161 }
3162
3163 { /* Negative width given as argument (cf. FLAG_LEFT below). */
3164 int retval =
3165 my_snprintf (result, sizeof (result), "%*lc %d", -10, L_x, 33, 44, 55);
3166 ASSERT (strcmp (result, "x 33") == 0);
3167 ASSERT (retval == strlen (result));
3168 }
3169
3170 { /* FLAG_LEFT. */
3171 int retval =
3172 my_snprintf (result, sizeof (result), "%-10lc %d", L_x, 33, 44, 55);
3173 ASSERT (strcmp (result, "x 33") == 0);
3174 ASSERT (retval == strlen (result));
3175 }
3176
3177 { /* Precision is ignored. */
3178 int retval =
3179 my_snprintf (result, sizeof (result),
3180 "%.0lc %d", L_x, 33, 44, 55);
3181 ASSERT (strcmp (result, "x 33") == 0);
3182 ASSERT (retval == strlen (result));
3183 }
3184
3185 { /* NUL character. */
3186 int retval =
3187 my_snprintf (result, sizeof (result),
3188 "a%lcz %d", (wint_t) L'\0', 33, 44, 55);
3189 /* ISO C had this wrong for decades. ISO C 23 now corrects it, through
3190 this wording:
3191 "If an l length modifier is present, the wint_t argument is converted
3192 as if by a call to the wcrtomb function with a pointer to storage of
3193 at least MB_CUR_MAX bytes, the wint_t argument converted to wchar_t,
3194 and an initial shift state." */
3195 ASSERT (memcmp (result, "a\0z 33\0", 6 + 1) == 0);
3196 ASSERT (retval == 6);
3197 }
3198
3199 static wint_t L_invalid = (wchar_t) 0x76543210;
3200
3201 { /* Invalid wide character.
3202 The conversion may succeed or may fail, but it should not abort. */
3203 int retval =
3204 my_snprintf (result, sizeof (result),
3205 "%lc %d", L_invalid, 33, 44, 55);
3206 (void) retval;
3207 }
3208
3209 { /* Invalid wide character and width.
3210 The conversion may succeed or may fail, but it should not abort. */
3211 int retval =
3212 my_snprintf (result, sizeof (result),
3213 "%10lc %d", L_invalid, 33, 44, 55);
3214 (void) retval;
3215 }
3216 #endif
3217
3218 /* Test the support of the 'x' conversion specifier for hexadecimal output of
3219 integers. */
3220
3221 { /* Zero. */
3222 int retval =
3223 my_snprintf (result, sizeof (result), "%x %d", 0, 33, 44, 55);
3224 ASSERT (strcmp (result, "0 33") == 0);
3225 ASSERT (retval == strlen (result));
3226 }
3227
3228 { /* A positive number. */
3229 int retval =
3230 my_snprintf (result, sizeof (result), "%x %d", 12348, 33, 44, 55);
3231 ASSERT (strcmp (result, "303c 33") == 0);
3232 ASSERT (retval == strlen (result));
3233 }
3234
3235 { /* A large positive number. */
3236 int retval =
3237 my_snprintf (result, sizeof (result), "%x %d", 0xFFFFFFFEU, 33, 44, 55);
3238 ASSERT (strcmp (result, "fffffffe 33") == 0);
3239 ASSERT (retval == strlen (result));
3240 }
3241
3242 { /* Width. */
3243 int retval =
3244 my_snprintf (result, sizeof (result), "%10x %d", 12348, 33, 44, 55);
3245 ASSERT (strcmp (result, " 303c 33") == 0);
3246 ASSERT (retval == strlen (result));
3247 }
3248
3249 { /* Width given as argument. */
3250 int retval =
3251 my_snprintf (result, sizeof (result), "%*x %d", 10, 12348, 33, 44, 55);
3252 ASSERT (strcmp (result, " 303c 33") == 0);
3253 ASSERT (retval == strlen (result));
3254 }
3255
3256 { /* Negative width given as argument (cf. FLAG_LEFT below). */
3257 int retval =
3258 my_snprintf (result, sizeof (result), "%*x %d", -10, 12348, 33, 44, 55);
3259 ASSERT (strcmp (result, "303c 33") == 0);
3260 ASSERT (retval == strlen (result));
3261 }
3262
3263 { /* Precision. */
3264 int retval =
3265 my_snprintf (result, sizeof (result), "%.10x %d", 12348, 33, 44, 55);
3266 ASSERT (strcmp (result, "000000303c 33") == 0);
3267 ASSERT (retval == strlen (result));
3268 }
3269
3270 { /* Zero precision and a positive number. */
3271 int retval =
3272 my_snprintf (result, sizeof (result), "%.0x %d", 12348, 33, 44, 55);
3273 ASSERT (strcmp (result, "303c 33") == 0);
3274 ASSERT (retval == strlen (result));
3275 }
3276
3277 { /* Zero precision and a zero number. */
3278 int retval =
3279 my_snprintf (result, sizeof (result), "%.0x %d", 0, 33, 44, 55);
3280 /* ISO C and POSIX specify that "The result of converting a zero value
3281 with a precision of zero is no characters." */
3282 ASSERT (strcmp (result, " 33") == 0);
3283 ASSERT (retval == strlen (result));
3284 }
3285
3286 { /* Width and precision. */
3287 int retval =
3288 my_snprintf (result, sizeof (result), "%15.10x %d", 12348, 33, 44, 55);
3289 ASSERT (strcmp (result, " 000000303c 33") == 0);
3290 ASSERT (retval == strlen (result));
3291 }
3292
3293 { /* Padding and precision. */
3294 int retval =
3295 my_snprintf (result, sizeof (result), "%015.10x %d", 12348, 33, 44, 55);
3296 /* ISO C 99 § 7.19.6.1.(6) says: "For d, i, o, u, x, and X conversions, if a
3297 precision is specified, the 0 flag is ignored." */
3298 ASSERT (strcmp (result, " 000000303c 33") == 0);
3299 ASSERT (retval == strlen (result));
3300 }
3301
3302 { /* FLAG_LEFT. */
3303 int retval =
3304 my_snprintf (result, sizeof (result), "%-10x %d", 12348, 33, 44, 55);
3305 ASSERT (strcmp (result, "303c 33") == 0);
3306 ASSERT (retval == strlen (result));
3307 }
3308
3309 { /* FLAG_ALT with zero. */
3310 int retval =
3311 my_snprintf (result, sizeof (result), "%#x %d", 0, 33, 44, 55);
3312 ASSERT (strcmp (result, "0 33") == 0);
3313 ASSERT (retval == strlen (result));
3314 }
3315
3316 { /* FLAG_ALT with a positive number. */
3317 int retval =
3318 my_snprintf (result, sizeof (result), "%#x %d", 12348, 33, 44, 55);
3319 ASSERT (strcmp (result, "0x303c 33") == 0);
3320 ASSERT (retval == strlen (result));
3321 }
3322
3323 { /* FLAG_ALT with a positive number and width. */
3324 int retval =
3325 my_snprintf (result, sizeof (result), "%#10x %d", 12348, 33, 44, 55);
3326 ASSERT (strcmp (result, " 0x303c 33") == 0);
3327 ASSERT (retval == strlen (result));
3328 }
3329
3330 { /* FLAG_ALT with a positive number and padding. */
3331 int retval =
3332 my_snprintf (result, sizeof (result), "%0#10x %d", 12348, 33, 44, 55);
3333 ASSERT (strcmp (result, "0x0000303c 33") == 0);
3334 ASSERT (retval == strlen (result));
3335 }
3336
3337 { /* FLAG_ALT with a positive number and precision. */
3338 int retval =
3339 my_snprintf (result, sizeof (result), "%0#.10x %d", 12348, 33, 44, 55);
3340 ASSERT (strcmp (result, "0x000000303c 33") == 0);
3341 ASSERT (retval == strlen (result));
3342 }
3343
3344 { /* FLAG_ALT with a positive number and width and precision. */
3345 int retval =
3346 my_snprintf (result, sizeof (result), "%#15.10x %d", 12348, 33, 44, 55);
3347 ASSERT (strcmp (result, " 0x000000303c 33") == 0);
3348 ASSERT (retval == strlen (result));
3349 }
3350
3351 { /* FLAG_ALT with a positive number and padding and precision. */
3352 int retval =
3353 my_snprintf (result, sizeof (result), "%0#15.10x %d", 12348, 33, 44, 55);
3354 /* ISO C 99 § 7.19.6.1.(6) says: "For d, i, o, u, x, and X conversions, if a
3355 precision is specified, the 0 flag is ignored." */
3356 ASSERT (strcmp (result, " 0x000000303c 33") == 0);
3357 ASSERT (retval == strlen (result));
3358 }
3359
3360 { /* FLAG_ALT with a zero precision and a zero number. */
3361 int retval =
3362 my_snprintf (result, sizeof (result), "%#.0x %d", 0, 33, 44, 55);
3363 /* ISO C and POSIX specify that "The result of converting a zero value
3364 with a precision of zero is no characters.", and the prefix is added
3365 only for non-zero values. */
3366 ASSERT (strcmp (result, " 33") == 0);
3367 ASSERT (retval == strlen (result));
3368 }
3369
3370 { /* Uppercase 'X'. */
3371 int retval =
3372 my_snprintf (result, sizeof (result), "%X %d", 12348, 33, 44, 55);
3373 ASSERT (strcmp (result, "303C 33") == 0);
3374 ASSERT (retval == strlen (result));
3375 }
3376
3377 { /* Uppercase 'X' with FLAG_ALT. */
3378 int retval =
3379 my_snprintf (result, sizeof (result), "%#X %d", 12348, 33, 44, 55);
3380 ASSERT (strcmp (result, "0X303C 33") == 0);
3381 ASSERT (retval == strlen (result));
3382 }
3383
3384 { /* Uppercase 'X' with FLAG_ALT and zero precision and a zero number. */
3385 int retval =
3386 my_snprintf (result, sizeof (result), "%#.0X %d", 0, 33, 44, 55);
3387 /* ISO C and POSIX specify that "The result of converting a zero value
3388 with a precision of zero is no characters.", and the prefix is added
3389 only for non-zero values. */
3390 ASSERT (strcmp (result, " 33") == 0);
3391 ASSERT (retval == strlen (result));
3392 }
3393
3394 /* Test the support of the 'b' conversion specifier for binary output of
3395 integers. */
3396
3397 { /* Zero. */
3398 int retval =
3399 my_snprintf (result, sizeof (result), "%b %d", 0, 33, 44, 55);
3400 ASSERT (strcmp (result, "0 33") == 0);
3401 ASSERT (retval == strlen (result));
3402 }
3403
3404 { /* A positive number. */
3405 int retval =
3406 my_snprintf (result, sizeof (result), "%b %d", 12345, 33, 44, 55);
3407 ASSERT (strcmp (result, "11000000111001 33") == 0);
3408 ASSERT (retval == strlen (result));
3409 }
3410
3411 { /* A large positive number. */
3412 int retval =
3413 my_snprintf (result, sizeof (result), "%b %d", 0xFFFFFFFEU, 33, 44, 55);
3414 ASSERT (strcmp (result, "11111111111111111111111111111110 33") == 0);
3415 ASSERT (retval == strlen (result));
3416 }
3417
3418 { /* Width. */
3419 int retval =
3420 my_snprintf (result, sizeof (result), "%20b %d", 12345, 33, 44, 55);
3421 ASSERT (strcmp (result, " 11000000111001 33") == 0);
3422 ASSERT (retval == strlen (result));
3423 }
3424
3425 { /* Width given as argument. */
3426 int retval =
3427 my_snprintf (result, sizeof (result), "%*b %d", 20, 12345, 33, 44, 55);
3428 ASSERT (strcmp (result, " 11000000111001 33") == 0);
3429 ASSERT (retval == strlen (result));
3430 }
3431
3432 { /* Negative width given as argument (cf. FLAG_LEFT below). */
3433 int retval =
3434 my_snprintf (result, sizeof (result), "%*b %d", -20, 12345, 33, 44, 55);
3435 ASSERT (strcmp (result, "11000000111001 33") == 0);
3436 ASSERT (retval == strlen (result));
3437 }
3438
3439 { /* Precision. */
3440 int retval =
3441 my_snprintf (result, sizeof (result), "%.20b %d", 12345, 33, 44, 55);
3442 ASSERT (strcmp (result, "00000011000000111001 33") == 0);
3443 ASSERT (retval == strlen (result));
3444 }
3445
3446 { /* Zero precision and a positive number. */
3447 int retval =
3448 my_snprintf (result, sizeof (result), "%.0b %d", 12345, 33, 44, 55);
3449 ASSERT (strcmp (result, "11000000111001 33") == 0);
3450 ASSERT (retval == strlen (result));
3451 }
3452
3453 { /* Zero precision and a zero number. */
3454 int retval =
3455 my_snprintf (result, sizeof (result), "%.0b %d", 0, 33, 44, 55);
3456 /* ISO C and POSIX specify that "The result of converting a zero value
3457 with a precision of zero is no characters." */
3458 ASSERT (strcmp (result, " 33") == 0);
3459 ASSERT (retval == strlen (result));
3460 }
3461
3462 { /* Width and precision. */
3463 int retval =
3464 my_snprintf (result, sizeof (result), "%25.20b %d", 12345, 33, 44, 55);
3465 ASSERT (strcmp (result, " 00000011000000111001 33") == 0);
3466 ASSERT (retval == strlen (result));
3467 }
3468
3469 { /* Padding and precision. */
3470 int retval =
3471 my_snprintf (result, sizeof (result), "%025.20b %d", 12345, 33, 44, 55);
3472 /* Neither ISO C nor POSIX specify that the '0' flag is ignored when
3473 a width and a precision are both present. But implementations do so. */
3474 ASSERT (strcmp (result, " 00000011000000111001 33") == 0);
3475 ASSERT (retval == strlen (result));
3476 }
3477
3478 { /* FLAG_LEFT. */
3479 int retval =
3480 my_snprintf (result, sizeof (result), "%-20b %d", 12345, 33, 44, 55);
3481 ASSERT (strcmp (result, "11000000111001 33") == 0);
3482 ASSERT (retval == strlen (result));
3483 }
3484
3485 { /* FLAG_ALT with zero. */
3486 int retval =
3487 my_snprintf (result, sizeof (result), "%#b %d", 0, 33, 44, 55);
3488 ASSERT (strcmp (result, "0 33") == 0);
3489 ASSERT (retval == strlen (result));
3490 }
3491
3492 { /* FLAG_ALT with a positive number. */
3493 int retval =
3494 my_snprintf (result, sizeof (result), "%#b %d", 12345, 33, 44, 55);
3495 ASSERT (strcmp (result, "0b11000000111001 33") == 0);
3496 ASSERT (retval == strlen (result));
3497 }
3498
3499 { /* FLAG_ALT with a positive number and width. */
3500 int retval =
3501 my_snprintf (result, sizeof (result), "%#20b %d", 12345, 33, 44, 55);
3502 ASSERT (strcmp (result, " 0b11000000111001 33") == 0);
3503 ASSERT (retval == strlen (result));
3504 }
3505
3506 { /* FLAG_ALT with a positive number and padding. */
3507 int retval =
3508 my_snprintf (result, sizeof (result), "%0#20b %d", 12345, 33, 44, 55);
3509 ASSERT (strcmp (result, "0b000011000000111001 33") == 0);
3510 ASSERT (retval == strlen (result));
3511 }
3512
3513 { /* FLAG_ALT with a positive number and precision. */
3514 int retval =
3515 my_snprintf (result, sizeof (result), "%0#.20b %d", 12345, 33, 44, 55);
3516 ASSERT (strcmp (result, "0b00000011000000111001 33") == 0);
3517 ASSERT (retval == strlen (result));
3518 }
3519
3520 { /* FLAG_ALT with a positive number and width and precision. */
3521 int retval =
3522 my_snprintf (result, sizeof (result), "%#25.20b %d", 12345, 33, 44, 55);
3523 ASSERT (strcmp (result, " 0b00000011000000111001 33") == 0);
3524 ASSERT (retval == strlen (result));
3525 }
3526
3527 { /* FLAG_ALT with a positive number and padding and precision. */
3528 int retval =
3529 my_snprintf (result, sizeof (result), "%0#25.20b %d", 12345, 33, 44, 55);
3530 /* Neither ISO C nor POSIX specify that the '0' flag is ignored when
3531 a width and a precision are both present. But implementations do so. */
3532 ASSERT (strcmp (result, " 0b00000011000000111001 33") == 0);
3533 ASSERT (retval == strlen (result));
3534 }
3535
3536 { /* FLAG_ALT with a zero precision and a zero number. */
3537 int retval =
3538 my_snprintf (result, sizeof (result), "%#.0b %d", 0, 33, 44, 55);
3539 /* ISO C and POSIX specify that "The result of converting a zero value
3540 with a precision of zero is no characters.", and the prefix is added
3541 only for non-zero values. */
3542 ASSERT (strcmp (result, " 33") == 0);
3543 ASSERT (retval == strlen (result));
3544 }
3545
3546 /* Test the support of argument type/size specifiers for signed integer
3547 conversions. */
3548
3549 {
3550 int retval =
3551 my_snprintf (result, sizeof (result),
3552 "%hhd %d", (signed char) -42, 33, 44, 55);
3553 ASSERT (strcmp (result, "-42 33") == 0);
3554 ASSERT (retval == strlen (result));
3555 }
3556
3557 {
3558 int retval =
3559 my_snprintf (result, sizeof (result),
3560 "%hd %d", (short) -12345, 33, 44, 55);
3561 ASSERT (strcmp (result, "-12345 33") == 0);
3562 ASSERT (retval == strlen (result));
3563 }
3564
3565 {
3566 int retval =
3567 my_snprintf (result, sizeof (result),
3568 "%d %d", -12345, 33, 44, 55);
3569 ASSERT (strcmp (result, "-12345 33") == 0);
3570 ASSERT (retval == strlen (result));
3571 }
3572
3573 {
3574 int retval =
3575 my_snprintf (result, sizeof (result),
3576 "%ld %d", (long int) -12345, 33, 44, 55);
3577 ASSERT (strcmp (result, "-12345 33") == 0);
3578 ASSERT (retval == strlen (result));
3579 }
3580
3581 {
3582 int retval =
3583 my_snprintf (result, sizeof (result),
3584 "%lld %d", (long long int) -12345, 33, 44, 55);
3585 ASSERT (strcmp (result, "-12345 33") == 0);
3586 ASSERT (retval == strlen (result));
3587 }
3588
3589 {
3590 int retval =
3591 my_snprintf (result, sizeof (result),
3592 "%w8d %d", (int8_t) -42, 33, 44, 55);
3593 ASSERT (strcmp (result, "-42 33") == 0);
3594 ASSERT (retval == strlen (result));
3595 }
3596
3597 {
3598 int retval =
3599 my_snprintf (result, sizeof (result),
3600 "%w16d %d", (int16_t) -12345, 33, 44, 55);
3601 ASSERT (strcmp (result, "-12345 33") == 0);
3602 ASSERT (retval == strlen (result));
3603 }
3604
3605 {
3606 int retval =
3607 my_snprintf (result, sizeof (result),
3608 "%w32d %d", (int32_t) -12345, 33, 44, 55);
3609 ASSERT (strcmp (result, "-12345 33") == 0);
3610 ASSERT (retval == strlen (result));
3611 }
3612
3613 {
3614 int retval =
3615 my_snprintf (result, sizeof (result),
3616 "%w64d %d", (int64_t) -12345, 33, 44, 55);
3617 ASSERT (strcmp (result, "-12345 33") == 0);
3618 ASSERT (retval == strlen (result));
3619 }
3620
3621 {
3622 int retval =
3623 my_snprintf (result, sizeof (result),
3624 "%wf8d %d", (int_fast8_t) -42, 33, 44, 55);
3625 ASSERT (strcmp (result, "-42 33") == 0);
3626 ASSERT (retval == strlen (result));
3627 }
3628
3629 {
3630 int retval =
3631 my_snprintf (result, sizeof (result),
3632 "%wf16d %d", (int_fast16_t) -12345, 33, 44, 55);
3633 ASSERT (strcmp (result, "-12345 33") == 0);
3634 ASSERT (retval == strlen (result));
3635 }
3636
3637 {
3638 int retval =
3639 my_snprintf (result, sizeof (result),
3640 "%wf32d %d", (int_fast32_t) -12345, 33, 44, 55);
3641 ASSERT (strcmp (result, "-12345 33") == 0);
3642 ASSERT (retval == strlen (result));
3643 }
3644
3645 {
3646 int retval =
3647 my_snprintf (result, sizeof (result),
3648 "%wf64d %d", (int_fast64_t) -12345, 33, 44, 55);
3649 ASSERT (strcmp (result, "-12345 33") == 0);
3650 ASSERT (retval == strlen (result));
3651 }
3652
3653 /* Test the support of argument type/size specifiers for unsigned integer
3654 conversions: %u */
3655
3656 {
3657 int retval =
3658 my_snprintf (result, sizeof (result),
3659 "%hhu %d", (unsigned char) 42, 33, 44, 55);
3660 ASSERT (strcmp (result, "42 33") == 0);
3661 ASSERT (retval == strlen (result));
3662 }
3663
3664 {
3665 int retval =
3666 my_snprintf (result, sizeof (result),
3667 "%hu %d", (unsigned short) 12345, 33, 44, 55);
3668 ASSERT (strcmp (result, "12345 33") == 0);
3669 ASSERT (retval == strlen (result));
3670 }
3671
3672 {
3673 int retval =
3674 my_snprintf (result, sizeof (result),
3675 "%u %d", (unsigned int) 12345, 33, 44, 55);
3676 ASSERT (strcmp (result, "12345 33") == 0);
3677 ASSERT (retval == strlen (result));
3678 }
3679
3680 {
3681 int retval =
3682 my_snprintf (result, sizeof (result),
3683 "%lu %d", (unsigned long int) 12345, 33, 44, 55);
3684 ASSERT (strcmp (result, "12345 33") == 0);
3685 ASSERT (retval == strlen (result));
3686 }
3687
3688 {
3689 int retval =
3690 my_snprintf (result, sizeof (result),
3691 "%llu %d", (unsigned long long int) 12345, 33, 44, 55);
3692 ASSERT (strcmp (result, "12345 33") == 0);
3693 ASSERT (retval == strlen (result));
3694 }
3695
3696 {
3697 int retval =
3698 my_snprintf (result, sizeof (result),
3699 "%w8u %d", (uint8_t) 42, 33, 44, 55);
3700 ASSERT (strcmp (result, "42 33") == 0);
3701 ASSERT (retval == strlen (result));
3702 }
3703
3704 {
3705 int retval =
3706 my_snprintf (result, sizeof (result),
3707 "%w16u %d", (uint16_t) 12345, 33, 44, 55);
3708 ASSERT (strcmp (result, "12345 33") == 0);
3709 ASSERT (retval == strlen (result));
3710 }
3711
3712 {
3713 int retval =
3714 my_snprintf (result, sizeof (result),
3715 "%w32u %d", (uint32_t) 12345, 33, 44, 55);
3716 ASSERT (strcmp (result, "12345 33") == 0);
3717 ASSERT (retval == strlen (result));
3718 }
3719
3720 {
3721 int retval =
3722 my_snprintf (result, sizeof (result),
3723 "%w64u %d", (uint64_t) 12345, 33, 44, 55);
3724 ASSERT (strcmp (result, "12345 33") == 0);
3725 ASSERT (retval == strlen (result));
3726 }
3727
3728 {
3729 int retval =
3730 my_snprintf (result, sizeof (result),
3731 "%wf8u %d", (uint_fast8_t) 42, 33, 44, 55);
3732 ASSERT (strcmp (result, "42 33") == 0);
3733 ASSERT (retval == strlen (result));
3734 }
3735
3736 {
3737 int retval =
3738 my_snprintf (result, sizeof (result),
3739 "%wf16u %d", (uint_fast16_t) 12345, 33, 44, 55);
3740 ASSERT (strcmp (result, "12345 33") == 0);
3741 ASSERT (retval == strlen (result));
3742 }
3743
3744 {
3745 int retval =
3746 my_snprintf (result, sizeof (result),
3747 "%wf32u %d", (uint_fast32_t) 12345, 33, 44, 55);
3748 ASSERT (strcmp (result, "12345 33") == 0);
3749 ASSERT (retval == strlen (result));
3750 }
3751
3752 {
3753 int retval =
3754 my_snprintf (result, sizeof (result),
3755 "%wf64u %d", (uint_fast64_t) 12345, 33, 44, 55);
3756 ASSERT (strcmp (result, "12345 33") == 0);
3757 ASSERT (retval == strlen (result));
3758 }
3759
3760 /* Test the support of argument type/size specifiers for unsigned integer
3761 conversions: %b */
3762
3763 {
3764 int retval =
3765 my_snprintf (result, sizeof (result),
3766 "%hhb %d", (unsigned char) 42, 33, 44, 55);
3767 ASSERT (strcmp (result, "101010 33") == 0);
3768 ASSERT (retval == strlen (result));
3769 }
3770
3771 {
3772 int retval =
3773 my_snprintf (result, sizeof (result),
3774 "%hb %d", (unsigned short) 12345, 33, 44, 55);
3775 ASSERT (strcmp (result, "11000000111001 33") == 0);
3776 ASSERT (retval == strlen (result));
3777 }
3778
3779 {
3780 int retval =
3781 my_snprintf (result, sizeof (result),
3782 "%b %d", (unsigned int) 12345, 33, 44, 55);
3783 ASSERT (strcmp (result, "11000000111001 33") == 0);
3784 ASSERT (retval == strlen (result));
3785 }
3786
3787 {
3788 int retval =
3789 my_snprintf (result, sizeof (result),
3790 "%lb %d", (unsigned long int) 12345, 33, 44, 55);
3791 ASSERT (strcmp (result, "11000000111001 33") == 0);
3792 ASSERT (retval == strlen (result));
3793 }
3794
3795 {
3796 int retval =
3797 my_snprintf (result, sizeof (result),
3798 "%llb %d", (unsigned long long int) 12345, 33, 44, 55);
3799 ASSERT (strcmp (result, "11000000111001 33") == 0);
3800 ASSERT (retval == strlen (result));
3801 }
3802
3803 {
3804 int retval =
3805 my_snprintf (result, sizeof (result),
3806 "%w8b %d", (uint8_t) 42, 33, 44, 55);
3807 ASSERT (strcmp (result, "101010 33") == 0);
3808 ASSERT (retval == strlen (result));
3809 }
3810
3811 {
3812 int retval =
3813 my_snprintf (result, sizeof (result),
3814 "%w16b %d", (uint16_t) 12345, 33, 44, 55);
3815 ASSERT (strcmp (result, "11000000111001 33") == 0);
3816 ASSERT (retval == strlen (result));
3817 }
3818
3819 {
3820 int retval =
3821 my_snprintf (result, sizeof (result),
3822 "%w32b %d", (uint32_t) 12345, 33, 44, 55);
3823 ASSERT (strcmp (result, "11000000111001 33") == 0);
3824 ASSERT (retval == strlen (result));
3825 }
3826
3827 {
3828 int retval =
3829 my_snprintf (result, sizeof (result),
3830 "%w64b %d", (uint64_t) 12345, 33, 44, 55);
3831 ASSERT (strcmp (result, "11000000111001 33") == 0);
3832 ASSERT (retval == strlen (result));
3833 }
3834
3835 {
3836 int retval =
3837 my_snprintf (result, sizeof (result),
3838 "%wf8b %d", (uint_fast8_t) 42, 33, 44, 55);
3839 ASSERT (strcmp (result, "101010 33") == 0);
3840 ASSERT (retval == strlen (result));
3841 }
3842
3843 {
3844 int retval =
3845 my_snprintf (result, sizeof (result),
3846 "%wf16b %d", (uint_fast16_t) 12345, 33, 44, 55);
3847 ASSERT (strcmp (result, "11000000111001 33") == 0);
3848 ASSERT (retval == strlen (result));
3849 }
3850
3851 {
3852 int retval =
3853 my_snprintf (result, sizeof (result),
3854 "%wf32b %d", (uint_fast32_t) 12345, 33, 44, 55);
3855 ASSERT (strcmp (result, "11000000111001 33") == 0);
3856 ASSERT (retval == strlen (result));
3857 }
3858
3859 {
3860 int retval =
3861 my_snprintf (result, sizeof (result),
3862 "%wf64b %d", (uint_fast64_t) 12345, 33, 44, 55);
3863 ASSERT (strcmp (result, "11000000111001 33") == 0);
3864 ASSERT (retval == strlen (result));
3865 }
3866
3867 /* Test the support of argument type/size specifiers for unsigned integer
3868 conversions: %o */
3869
3870 {
3871 int retval =
3872 my_snprintf (result, sizeof (result),
3873 "%hho %d", (unsigned char) 42, 33, 44, 55);
3874 ASSERT (strcmp (result, "52 33") == 0);
3875 ASSERT (retval == strlen (result));
3876 }
3877
3878 {
3879 int retval =
3880 my_snprintf (result, sizeof (result),
3881 "%ho %d", (unsigned short) 12345, 33, 44, 55);
3882 ASSERT (strcmp (result, "30071 33") == 0);
3883 ASSERT (retval == strlen (result));
3884 }
3885
3886 {
3887 int retval =
3888 my_snprintf (result, sizeof (result),
3889 "%o %d", (unsigned int) 12345, 33, 44, 55);
3890 ASSERT (strcmp (result, "30071 33") == 0);
3891 ASSERT (retval == strlen (result));
3892 }
3893
3894 {
3895 int retval =
3896 my_snprintf (result, sizeof (result),
3897 "%lo %d", (unsigned long int) 12345, 33, 44, 55);
3898 ASSERT (strcmp (result, "30071 33") == 0);
3899 ASSERT (retval == strlen (result));
3900 }
3901
3902 {
3903 int retval =
3904 my_snprintf (result, sizeof (result),
3905 "%llo %d", (unsigned long long int) 12345, 33, 44, 55);
3906 ASSERT (strcmp (result, "30071 33") == 0);
3907 ASSERT (retval == strlen (result));
3908 }
3909
3910 {
3911 int retval =
3912 my_snprintf (result, sizeof (result),
3913 "%w8o %d", (uint8_t) 42, 33, 44, 55);
3914 ASSERT (strcmp (result, "52 33") == 0);
3915 ASSERT (retval == strlen (result));
3916 }
3917
3918 {
3919 int retval =
3920 my_snprintf (result, sizeof (result),
3921 "%w16o %d", (uint16_t) 12345, 33, 44, 55);
3922 ASSERT (strcmp (result, "30071 33") == 0);
3923 ASSERT (retval == strlen (result));
3924 }
3925
3926 {
3927 int retval =
3928 my_snprintf (result, sizeof (result),
3929 "%w32o %d", (uint32_t) 12345, 33, 44, 55);
3930 ASSERT (strcmp (result, "30071 33") == 0);
3931 ASSERT (retval == strlen (result));
3932 }
3933
3934 {
3935 int retval =
3936 my_snprintf (result, sizeof (result),
3937 "%w64o %d", (uint64_t) 12345, 33, 44, 55);
3938 ASSERT (strcmp (result, "30071 33") == 0);
3939 ASSERT (retval == strlen (result));
3940 }
3941
3942 {
3943 int retval =
3944 my_snprintf (result, sizeof (result),
3945 "%wf8o %d", (uint_fast8_t) 42, 33, 44, 55);
3946 ASSERT (strcmp (result, "52 33") == 0);
3947 ASSERT (retval == strlen (result));
3948 }
3949
3950 {
3951 int retval =
3952 my_snprintf (result, sizeof (result),
3953 "%wf16o %d", (uint_fast16_t) 12345, 33, 44, 55);
3954 ASSERT (strcmp (result, "30071 33") == 0);
3955 ASSERT (retval == strlen (result));
3956 }
3957
3958 {
3959 int retval =
3960 my_snprintf (result, sizeof (result),
3961 "%wf32o %d", (uint_fast32_t) 12345, 33, 44, 55);
3962 ASSERT (strcmp (result, "30071 33") == 0);
3963 ASSERT (retval == strlen (result));
3964 }
3965
3966 {
3967 int retval =
3968 my_snprintf (result, sizeof (result),
3969 "%wf64o %d", (uint_fast64_t) 12345, 33, 44, 55);
3970 ASSERT (strcmp (result, "30071 33") == 0);
3971 ASSERT (retval == strlen (result));
3972 }
3973
3974 /* Test the support of argument type/size specifiers for unsigned integer
3975 conversions: %x */
3976
3977 {
3978 int retval =
3979 my_snprintf (result, sizeof (result),
3980 "%hhX %d", (unsigned char) 42, 33, 44, 55);
3981 ASSERT (strcmp (result, "2A 33") == 0);
3982 ASSERT (retval == strlen (result));
3983 }
3984
3985 {
3986 int retval =
3987 my_snprintf (result, sizeof (result),
3988 "%hX %d", (unsigned short) 12345, 33, 44, 55);
3989 ASSERT (strcmp (result, "3039 33") == 0);
3990 ASSERT (retval == strlen (result));
3991 }
3992
3993 {
3994 int retval =
3995 my_snprintf (result, sizeof (result),
3996 "%X %d", (unsigned int) 12345, 33, 44, 55);
3997 ASSERT (strcmp (result, "3039 33") == 0);
3998 ASSERT (retval == strlen (result));
3999 }
4000
4001 {
4002 int retval =
4003 my_snprintf (result, sizeof (result),
4004 "%lX %d", (unsigned long int) 12345, 33, 44, 55);
4005 ASSERT (strcmp (result, "3039 33") == 0);
4006 ASSERT (retval == strlen (result));
4007 }
4008
4009 {
4010 int retval =
4011 my_snprintf (result, sizeof (result),
4012 "%llX %d", (unsigned long long int) 12345, 33, 44, 55);
4013 ASSERT (strcmp (result, "3039 33") == 0);
4014 ASSERT (retval == strlen (result));
4015 }
4016
4017 {
4018 int retval =
4019 my_snprintf (result, sizeof (result),
4020 "%w8X %d", (uint8_t) 42, 33, 44, 55);
4021 ASSERT (strcmp (result, "2A 33") == 0);
4022 ASSERT (retval == strlen (result));
4023 }
4024
4025 {
4026 int retval =
4027 my_snprintf (result, sizeof (result),
4028 "%w16X %d", (uint16_t) 12345, 33, 44, 55);
4029 ASSERT (strcmp (result, "3039 33") == 0);
4030 ASSERT (retval == strlen (result));
4031 }
4032
4033 {
4034 int retval =
4035 my_snprintf (result, sizeof (result),
4036 "%w32X %d", (uint32_t) 12345, 33, 44, 55);
4037 ASSERT (strcmp (result, "3039 33") == 0);
4038 ASSERT (retval == strlen (result));
4039 }
4040
4041 {
4042 int retval =
4043 my_snprintf (result, sizeof (result),
4044 "%w64X %d", (uint64_t) 12345, 33, 44, 55);
4045 ASSERT (strcmp (result, "3039 33") == 0);
4046 ASSERT (retval == strlen (result));
4047 }
4048
4049 {
4050 int retval =
4051 my_snprintf (result, sizeof (result),
4052 "%wf8X %d", (uint_fast8_t) 42, 33, 44, 55);
4053 ASSERT (strcmp (result, "2A 33") == 0);
4054 ASSERT (retval == strlen (result));
4055 }
4056
4057 {
4058 int retval =
4059 my_snprintf (result, sizeof (result),
4060 "%wf16X %d", (uint_fast16_t) 12345, 33, 44, 55);
4061 ASSERT (strcmp (result, "3039 33") == 0);
4062 ASSERT (retval == strlen (result));
4063 }
4064
4065 {
4066 int retval =
4067 my_snprintf (result, sizeof (result),
4068 "%wf32X %d", (uint_fast32_t) 12345, 33, 44, 55);
4069 ASSERT (strcmp (result, "3039 33") == 0);
4070 ASSERT (retval == strlen (result));
4071 }
4072
4073 {
4074 int retval =
4075 my_snprintf (result, sizeof (result),
4076 "%wf64X %d", (uint_fast64_t) 12345, 33, 44, 55);
4077 ASSERT (strcmp (result, "3039 33") == 0);
4078 ASSERT (retval == strlen (result));
4079 }
4080 }
Mirror of the GNU Gnulib repository