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