Mercurial > gnulib
annotate tests/test-vasnprintf-posix.c @ 40057:b06060465f09
maint: Run 'make update-copyright'
author | Paul Eggert <eggert@cs.ucla.edu> |
---|---|
date | Tue, 01 Jan 2019 00:25:11 +0100 |
parents | 10eb9086bea0 |
children |
rev | line source |
---|---|
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
1 /* Test of POSIX compatible vasnprintf() and asnprintf() functions. |
40057
b06060465f09
maint: Run 'make update-copyright'
Paul Eggert <eggert@cs.ucla.edu>
parents:
19484
diff
changeset
|
2 Copyright (C) 2007-2019 Free Software Foundation, Inc. |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3 |
9309
bbbbbf4cd1c5
Change copyright notice from GPLv2+ to GPLv3+.
Bruno Haible <bruno@clisp.org>
parents:
8919
diff
changeset
|
4 This program is free software: you can redistribute it and/or modify |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
5 it under the terms of the GNU General Public License as published by |
9309
bbbbbf4cd1c5
Change copyright notice from GPLv2+ to GPLv3+.
Bruno Haible <bruno@clisp.org>
parents:
8919
diff
changeset
|
6 the Free Software Foundation; either version 3 of the License, or |
bbbbbf4cd1c5
Change copyright notice from GPLv2+ to GPLv3+.
Bruno Haible <bruno@clisp.org>
parents:
8919
diff
changeset
|
7 (at your option) any later version. |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
8 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
9 This program is distributed in the hope that it will be useful, |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
10 but WITHOUT ANY WARRANTY; without even the implied warranty of |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
12 GNU General Public License for more details. |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
13 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
14 You should have received a copy of the GNU General Public License |
19190 | 15 along with this program. If not, see <https://www.gnu.org/licenses/>. */ |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
16 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
17 /* Written by Bruno Haible <bruno@clisp.org>, 2007. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
18 |
8891
633babea5f62
Unconditionally include <config.h> in unit tests.
Eric Blake <ebb9@byu.net>
parents:
8870
diff
changeset
|
19 #include <config.h> |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
20 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
21 #include "vasnprintf.h" |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
22 |
13200
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
23 #include <errno.h> |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
24 #include <float.h> |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
25 #include <stdarg.h> |
8354
81b3f885ff9d
Include <stddef.h>, for ptrdiff_t.
Bruno Haible <bruno@clisp.org>
parents:
8344
diff
changeset
|
26 #include <stddef.h> |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
27 #include <stdint.h> |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
28 #include <stdlib.h> |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
29 #include <string.h> |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
30 |
12496
a48d3d749ca5
Refactor common macros used in tests.
Bruno Haible <bruno@clisp.org>
parents:
12421
diff
changeset
|
31 #include "macros.h" |
13834
108bbfd6f03b
frexp, tests: work around ICC bug with -zero
Eric Blake <eblake@redhat.com>
parents:
13200
diff
changeset
|
32 #include "minus-zero.h" |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
33 #include "infinity.h" |
9854
baba3b346ab2
Use macros NaNf, NaNd, NaNl instead of NAN.
Bruno Haible <bruno@clisp.org>
parents:
9850
diff
changeset
|
34 #include "nan.h" |
baba3b346ab2
Use macros NaNf, NaNd, NaNl instead of NAN.
Bruno Haible <bruno@clisp.org>
parents:
9850
diff
changeset
|
35 |
8852
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
36 /* The SGI MIPS floating-point format does not distinguish 0.0 and -0.0. */ |
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
37 static int |
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
38 have_minus_zero () |
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
39 { |
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
40 static double plus_zero = 0.0; |
13834
108bbfd6f03b
frexp, tests: work around ICC bug with -zero
Eric Blake <eblake@redhat.com>
parents:
13200
diff
changeset
|
41 double minus_zero = minus_zerod; |
8852
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
42 return memcmp (&plus_zero, &minus_zero, sizeof (double)) != 0; |
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
43 } |
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
44 |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
45 /* Representation of an 80-bit 'long double' as an initializer for a sequence |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
46 of 'unsigned int' words. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
47 #ifdef WORDS_BIGENDIAN |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
48 # define LDBL80_WORDS(exponent,manthi,mantlo) \ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
49 { ((unsigned int) (exponent) << 16) | ((unsigned int) (manthi) >> 16), \ |
17815
b9d8153a9ca9
Fix LDBL80_WORDS macro on big endian platforms.
Bruno Haible <bruno@clisp.org>
parents:
17576
diff
changeset
|
50 ((unsigned int) (manthi) << 16) | ((unsigned int) (mantlo) >> 16), \ |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
51 (unsigned int) (mantlo) << 16 \ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
52 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
53 #else |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
54 # define LDBL80_WORDS(exponent,manthi,mantlo) \ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
55 { mantlo, manthi, exponent } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
56 #endif |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
57 |
8834 | 58 static int |
59 strmatch (const char *pattern, const char *string) | |
60 { | |
61 if (strlen (pattern) != strlen (string)) | |
62 return 0; | |
63 for (; *pattern != '\0'; pattern++, string++) | |
64 if (*pattern != '*' && *string != *pattern) | |
65 return 0; | |
66 return 1; | |
67 } | |
68 | |
8865
9e203d8ade65
Stricter check for printf result for NaN arguments.
Bruno Haible <bruno@clisp.org>
parents:
8857
diff
changeset
|
69 /* Test whether string[start_index..end_index-1] is a valid textual |
9e203d8ade65
Stricter check for printf result for NaN arguments.
Bruno Haible <bruno@clisp.org>
parents:
8857
diff
changeset
|
70 representation of NaN. */ |
9e203d8ade65
Stricter check for printf result for NaN arguments.
Bruno Haible <bruno@clisp.org>
parents:
8857
diff
changeset
|
71 static int |
9e203d8ade65
Stricter check for printf result for NaN arguments.
Bruno Haible <bruno@clisp.org>
parents:
8857
diff
changeset
|
72 strisnan (const char *string, size_t start_index, size_t end_index, int uppercase) |
9e203d8ade65
Stricter check for printf result for NaN arguments.
Bruno Haible <bruno@clisp.org>
parents:
8857
diff
changeset
|
73 { |
9e203d8ade65
Stricter check for printf result for NaN arguments.
Bruno Haible <bruno@clisp.org>
parents:
8857
diff
changeset
|
74 if (start_index < end_index) |
9e203d8ade65
Stricter check for printf result for NaN arguments.
Bruno Haible <bruno@clisp.org>
parents:
8857
diff
changeset
|
75 { |
9e203d8ade65
Stricter check for printf result for NaN arguments.
Bruno Haible <bruno@clisp.org>
parents:
8857
diff
changeset
|
76 if (string[start_index] == '-') |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
77 start_index++; |
8865
9e203d8ade65
Stricter check for printf result for NaN arguments.
Bruno Haible <bruno@clisp.org>
parents:
8857
diff
changeset
|
78 if (start_index + 3 <= end_index |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
79 && memcmp (string + start_index, uppercase ? "NAN" : "nan", 3) == 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
80 { |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
81 start_index += 3; |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
82 if (start_index == end_index |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
83 || (string[start_index] == '(' && string[end_index - 1] == ')')) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
84 return 1; |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
85 } |
8865
9e203d8ade65
Stricter check for printf result for NaN arguments.
Bruno Haible <bruno@clisp.org>
parents:
8857
diff
changeset
|
86 } |
9e203d8ade65
Stricter check for printf result for NaN arguments.
Bruno Haible <bruno@clisp.org>
parents:
8857
diff
changeset
|
87 return 0; |
9e203d8ade65
Stricter check for printf result for NaN arguments.
Bruno Haible <bruno@clisp.org>
parents:
8857
diff
changeset
|
88 } |
9850 | 89 |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
90 static void |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
91 test_function (char * (*my_asnprintf) (char *, size_t *, const char *, ...)) |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
92 { |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
93 char buf[8]; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
94 int size; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
95 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
96 /* Test return value convention. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
97 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
98 for (size = 0; size <= 8; size++) |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
99 { |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
100 size_t length = size; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
101 char *result = my_asnprintf (NULL, &length, "%d", 12345); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
102 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
103 ASSERT (strcmp (result, "12345") == 0); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
104 ASSERT (length == 5); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
105 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
106 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
107 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
108 for (size = 0; size <= 8; size++) |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
109 { |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
110 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
111 char *result; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
112 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
113 memcpy (buf, "DEADBEEF", 8); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
114 length = size; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
115 result = my_asnprintf (buf, &length, "%d", 12345); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
116 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
117 ASSERT (strcmp (result, "12345") == 0); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
118 ASSERT (length == 5); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
119 if (size < 6) |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
120 ASSERT (result != buf); |
17406
3e765e2f4c46
parse-datetime, tests: don't use "string" + int
Paul Eggert <eggert@cs.ucla.edu>
parents:
17348
diff
changeset
|
121 ASSERT (memcmp (buf + size, &"DEADBEEF"[size], 8 - size) == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
122 if (result != buf) |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
123 free (result); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
124 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
125 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
126 /* Test support of size specifiers as in C99. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
127 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
128 { |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
129 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
130 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
131 my_asnprintf (NULL, &length, "%ju %d", (uintmax_t) 12345671, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
132 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
133 ASSERT (strcmp (result, "12345671 33") == 0); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
134 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
135 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
136 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
137 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
138 { |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
139 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
140 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
141 my_asnprintf (NULL, &length, "%zu %d", (size_t) 12345672, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
142 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
143 ASSERT (strcmp (result, "12345672 33") == 0); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
144 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
145 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
146 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
147 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
148 { |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
149 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
150 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
151 my_asnprintf (NULL, &length, "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
152 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
153 ASSERT (strcmp (result, "12345673 33") == 0); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
154 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
155 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
156 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
157 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
158 { |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
159 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
160 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
161 my_asnprintf (NULL, &length, "%Lg %d", (long double) 1.5, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
162 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
163 ASSERT (strcmp (result, "1.5 33") == 0); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
164 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
165 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
166 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
167 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
168 /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
169 output of floating-point numbers. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
170 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
171 { /* A positive number. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
172 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
173 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
174 my_asnprintf (NULL, &length, "%a %d", 3.1416015625, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
175 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
176 ASSERT (strcmp (result, "0x1.922p+1 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
177 || strcmp (result, "0x3.244p+0 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
178 || strcmp (result, "0x6.488p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
179 || strcmp (result, "0xc.91p-2 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
180 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
181 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
182 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
183 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
184 { /* A negative number. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
185 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
186 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
187 my_asnprintf (NULL, &length, "%A %d", -3.1416015625, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
188 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
189 ASSERT (strcmp (result, "-0X1.922P+1 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
190 || strcmp (result, "-0X3.244P+0 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
191 || strcmp (result, "-0X6.488P-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
192 || strcmp (result, "-0XC.91P-2 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
193 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
194 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
195 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
196 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
197 { /* Positive zero. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
198 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
199 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
200 my_asnprintf (NULL, &length, "%a %d", 0.0, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
201 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
202 ASSERT (strcmp (result, "0x0p+0 33") == 0); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
203 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
204 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
205 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
206 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
207 { /* Negative zero. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
208 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
209 char *result = |
13834
108bbfd6f03b
frexp, tests: work around ICC bug with -zero
Eric Blake <eblake@redhat.com>
parents:
13200
diff
changeset
|
210 my_asnprintf (NULL, &length, "%a %d", minus_zerod, 33, 44, 55); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
211 ASSERT (result != NULL); |
8852
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
212 if (have_minus_zero ()) |
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
213 ASSERT (strcmp (result, "-0x0p+0 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
214 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
215 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
216 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
217 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
218 { /* Positive infinity. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
219 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
220 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
221 my_asnprintf (NULL, &length, "%a %d", Infinityd (), 33, 44, 55); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
222 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
223 ASSERT (strcmp (result, "inf 33") == 0); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
224 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
225 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
226 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
227 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
228 { /* Negative infinity. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
229 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
230 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
231 my_asnprintf (NULL, &length, "%a %d", - Infinityd (), 33, 44, 55); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
232 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
233 ASSERT (strcmp (result, "-inf 33") == 0); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
234 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
235 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
236 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
237 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
238 { /* NaN. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
239 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
240 char *result = |
9854
baba3b346ab2
Use macros NaNf, NaNd, NaNl instead of NAN.
Bruno Haible <bruno@clisp.org>
parents:
9850
diff
changeset
|
241 my_asnprintf (NULL, &length, "%a %d", NaNd (), 33, 44, 55); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
242 ASSERT (result != NULL); |
8850
d1fe16dfbfee
Avoid test failures on IRIX 6.5.
Bruno Haible <bruno@clisp.org>
parents:
8839
diff
changeset
|
243 ASSERT (strlen (result) >= 3 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
244 && strisnan (result, 0, strlen (result) - 3, 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
245 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
246 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
247 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
248 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
249 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
250 { /* Rounding near the decimal point. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
251 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
252 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
253 my_asnprintf (NULL, &length, "%.0a %d", 1.5, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
254 ASSERT (result != NULL); |
17348
b012a6ea32ac
vasnprintf-posix-tests: allow rounding 1.5 to 1
Paul Eggert <eggert@cs.ucla.edu>
parents:
17249
diff
changeset
|
255 ASSERT (strcmp (result, "0x1p+0 33") == 0 |
b012a6ea32ac
vasnprintf-posix-tests: allow rounding 1.5 to 1
Paul Eggert <eggert@cs.ucla.edu>
parents:
17249
diff
changeset
|
256 || strcmp (result, "0x2p+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
257 || strcmp (result, "0x3p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
258 || strcmp (result, "0x6p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
259 || strcmp (result, "0xcp-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
260 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
261 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
262 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
263 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
264 { /* Rounding with precision 0. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
265 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
266 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
267 my_asnprintf (NULL, &length, "%.0a %d", 1.51, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
268 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
269 ASSERT (strcmp (result, "0x2p+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
270 || strcmp (result, "0x3p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
271 || strcmp (result, "0x6p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
272 || strcmp (result, "0xcp-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
273 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
274 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
275 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
276 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
277 { /* Rounding with precision 1. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
278 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
279 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
280 my_asnprintf (NULL, &length, "%.1a %d", 1.51, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
281 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
282 ASSERT (strcmp (result, "0x1.8p+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
283 || strcmp (result, "0x3.0p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
284 || strcmp (result, "0x6.1p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
285 || strcmp (result, "0xc.1p-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
286 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
287 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
288 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
289 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
290 { /* Rounding with precision 2. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
291 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
292 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
293 my_asnprintf (NULL, &length, "%.2a %d", 1.51, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
294 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
295 ASSERT (strcmp (result, "0x1.83p+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
296 || strcmp (result, "0x3.05p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
297 || strcmp (result, "0x6.0ap-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
298 || strcmp (result, "0xc.14p-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
299 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
300 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
301 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
302 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
303 { /* Rounding with precision 3. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
304 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
305 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
306 my_asnprintf (NULL, &length, "%.3a %d", 1.51, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
307 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
308 ASSERT (strcmp (result, "0x1.829p+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
309 || strcmp (result, "0x3.052p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
310 || strcmp (result, "0x6.0a4p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
311 || strcmp (result, "0xc.148p-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
312 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
313 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
314 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
315 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
316 { /* Rounding can turn a ...FFF into a ...000. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
317 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
318 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
319 my_asnprintf (NULL, &length, "%.3a %d", 1.49999, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
320 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
321 ASSERT (strcmp (result, "0x1.800p+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
322 || strcmp (result, "0x3.000p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
323 || strcmp (result, "0x6.000p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
324 || strcmp (result, "0xc.000p-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
325 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
326 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
327 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
328 |
8344
c8055280f68e
Test a corner case. Exclude two buggy implementations.
Bruno Haible <bruno@clisp.org>
parents:
8336
diff
changeset
|
329 { /* Rounding can turn a ...FFF into a ...000. |
16935
498a2211d839
Write "Mac OS X" instead of "MacOS X".
Bruno Haible <bruno@clisp.org>
parents:
16201
diff
changeset
|
330 This shows a Mac OS X 10.3.9 (Darwin 7.9) bug. */ |
8344
c8055280f68e
Test a corner case. Exclude two buggy implementations.
Bruno Haible <bruno@clisp.org>
parents:
8336
diff
changeset
|
331 size_t length; |
c8055280f68e
Test a corner case. Exclude two buggy implementations.
Bruno Haible <bruno@clisp.org>
parents:
8336
diff
changeset
|
332 char *result = |
c8055280f68e
Test a corner case. Exclude two buggy implementations.
Bruno Haible <bruno@clisp.org>
parents:
8336
diff
changeset
|
333 my_asnprintf (NULL, &length, "%.1a %d", 1.999, 33, 44, 55); |
c8055280f68e
Test a corner case. Exclude two buggy implementations.
Bruno Haible <bruno@clisp.org>
parents:
8336
diff
changeset
|
334 ASSERT (result != NULL); |
c8055280f68e
Test a corner case. Exclude two buggy implementations.
Bruno Haible <bruno@clisp.org>
parents:
8336
diff
changeset
|
335 ASSERT (strcmp (result, "0x1.0p+1 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
336 || strcmp (result, "0x2.0p+0 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
337 || strcmp (result, "0x4.0p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
338 || strcmp (result, "0x8.0p-2 33") == 0); |
8344
c8055280f68e
Test a corner case. Exclude two buggy implementations.
Bruno Haible <bruno@clisp.org>
parents:
8336
diff
changeset
|
339 ASSERT (length == strlen (result)); |
c8055280f68e
Test a corner case. Exclude two buggy implementations.
Bruno Haible <bruno@clisp.org>
parents:
8336
diff
changeset
|
340 free (result); |
c8055280f68e
Test a corner case. Exclude two buggy implementations.
Bruno Haible <bruno@clisp.org>
parents:
8336
diff
changeset
|
341 } |
c8055280f68e
Test a corner case. Exclude two buggy implementations.
Bruno Haible <bruno@clisp.org>
parents:
8336
diff
changeset
|
342 |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
343 { /* Width. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
344 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
345 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
346 my_asnprintf (NULL, &length, "%10a %d", 1.75, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
347 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
348 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
349 || strcmp (result, " 0x3.8p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
350 || strcmp (result, " 0x7p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
351 || strcmp (result, " 0xep-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
352 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
353 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
354 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
355 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
356 { /* Small precision. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
357 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
358 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
359 my_asnprintf (NULL, &length, "%.10a %d", 1.75, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
360 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
361 ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
362 || strcmp (result, "0x3.8000000000p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
363 || strcmp (result, "0x7.0000000000p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
364 || strcmp (result, "0xe.0000000000p-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
365 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
366 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
367 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
368 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
369 { /* Large precision. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
370 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
371 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
372 my_asnprintf (NULL, &length, "%.50a %d", 1.75, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
373 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
374 ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
375 || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
376 || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
377 || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
378 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
379 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
380 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
381 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
382 { /* FLAG_LEFT. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
383 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
384 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
385 my_asnprintf (NULL, &length, "%-10a %d", 1.75, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
386 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
387 ASSERT (strcmp (result, "0x1.cp+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
388 || strcmp (result, "0x3.8p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
389 || strcmp (result, "0x7p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
390 || strcmp (result, "0xep-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
391 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
392 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
393 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
394 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
395 { /* FLAG_SHOWSIGN. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
396 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
397 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
398 my_asnprintf (NULL, &length, "%+a %d", 1.75, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
399 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
400 ASSERT (strcmp (result, "+0x1.cp+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
401 || strcmp (result, "+0x3.8p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
402 || strcmp (result, "+0x7p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
403 || strcmp (result, "+0xep-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
404 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
405 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
406 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
407 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
408 { /* FLAG_SPACE. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
409 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
410 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
411 my_asnprintf (NULL, &length, "% a %d", 1.75, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
412 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
413 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
414 || strcmp (result, " 0x3.8p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
415 || strcmp (result, " 0x7p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
416 || strcmp (result, " 0xep-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
417 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
418 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
419 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
420 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
421 { /* FLAG_ALT. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
422 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
423 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
424 my_asnprintf (NULL, &length, "%#a %d", 1.75, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
425 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
426 ASSERT (strcmp (result, "0x1.cp+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
427 || strcmp (result, "0x3.8p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
428 || strcmp (result, "0x7.p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
429 || strcmp (result, "0xe.p-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
430 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
431 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
432 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
433 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
434 { /* FLAG_ALT. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
435 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
436 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
437 my_asnprintf (NULL, &length, "%#a %d", 1.0, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
438 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
439 ASSERT (strcmp (result, "0x1.p+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
440 || strcmp (result, "0x2.p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
441 || strcmp (result, "0x4.p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
442 || strcmp (result, "0x8.p-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
443 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
444 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
445 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
446 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
447 { /* FLAG_ZERO with finite number. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
448 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
449 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
450 my_asnprintf (NULL, &length, "%010a %d", 1.75, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
451 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
452 ASSERT (strcmp (result, "0x001.cp+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
453 || strcmp (result, "0x003.8p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
454 || strcmp (result, "0x00007p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
455 || strcmp (result, "0x0000ep-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
456 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
457 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
458 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
459 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
460 { /* FLAG_ZERO with infinite number. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
461 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
462 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
463 my_asnprintf (NULL, &length, "%010a %d", Infinityd (), 33, 44, 55); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
464 ASSERT (result != NULL); |
8662
023aa5c883a7
Guard against FreeBSD 6.1 bug.
Bruno Haible <bruno@clisp.org>
parents:
8648
diff
changeset
|
465 /* "0000000inf 33" is not a valid result; see |
19439
8bfc20b57265
maint: shorten https://lists.gnu.org/archive/html/... links
Jim Meyering <meyering@fb.com>
parents:
19192
diff
changeset
|
466 <https://lists.gnu.org/r/bug-gnulib/2007-04/msg00107.html> */ |
8662
023aa5c883a7
Guard against FreeBSD 6.1 bug.
Bruno Haible <bruno@clisp.org>
parents:
8648
diff
changeset
|
467 ASSERT (strcmp (result, " inf 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
468 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
469 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
470 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
471 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
472 { /* FLAG_ZERO with NaN. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
473 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
474 char *result = |
9854
baba3b346ab2
Use macros NaNf, NaNd, NaNl instead of NAN.
Bruno Haible <bruno@clisp.org>
parents:
9850
diff
changeset
|
475 my_asnprintf (NULL, &length, "%050a %d", NaNd (), 33, 44, 55); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
476 ASSERT (result != NULL); |
8662
023aa5c883a7
Guard against FreeBSD 6.1 bug.
Bruno Haible <bruno@clisp.org>
parents:
8648
diff
changeset
|
477 /* "0000000nan 33" is not a valid result; see |
19439
8bfc20b57265
maint: shorten https://lists.gnu.org/archive/html/... links
Jim Meyering <meyering@fb.com>
parents:
19192
diff
changeset
|
478 <https://lists.gnu.org/r/bug-gnulib/2007-04/msg00107.html> */ |
8870
4e1f2ea486b4
Allow for a longer printed representation of NaN.
Bruno Haible <bruno@clisp.org>
parents:
8865
diff
changeset
|
479 ASSERT (strlen (result) == 50 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
480 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
481 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
482 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
483 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
484 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
485 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
486 { /* A positive number. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
487 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
488 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
489 my_asnprintf (NULL, &length, "%La %d", 3.1416015625L, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
490 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
491 ASSERT (strcmp (result, "0x1.922p+1 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
492 || strcmp (result, "0x3.244p+0 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
493 || strcmp (result, "0x6.488p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
494 || strcmp (result, "0xc.91p-2 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
495 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
496 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
497 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
498 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
499 { /* A negative number. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
500 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
501 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
502 my_asnprintf (NULL, &length, "%LA %d", -3.1416015625L, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
503 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
504 ASSERT (strcmp (result, "-0X1.922P+1 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
505 || strcmp (result, "-0X3.244P+0 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
506 || strcmp (result, "-0X6.488P-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
507 || strcmp (result, "-0XC.91P-2 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
508 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
509 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
510 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
511 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
512 { /* Positive zero. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
513 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
514 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
515 my_asnprintf (NULL, &length, "%La %d", 0.0L, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
516 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
517 ASSERT (strcmp (result, "0x0p+0 33") == 0); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
518 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
519 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
520 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
521 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
522 { /* Negative zero. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
523 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
524 char *result = |
10601
ca053fa79cd3
Use a more portable replacement expression for -0.0L.
Bruno Haible <bruno@clisp.org>
parents:
10458
diff
changeset
|
525 my_asnprintf (NULL, &length, "%La %d", minus_zerol, 33, 44, 55); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
526 ASSERT (result != NULL); |
8852
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
527 if (have_minus_zero ()) |
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
528 ASSERT (strcmp (result, "-0x0p+0 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
529 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
530 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
531 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
532 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
533 { /* Positive infinity. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
534 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
535 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
536 my_asnprintf (NULL, &length, "%La %d", Infinityl (), 33, 44, 55); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
537 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
538 ASSERT (strcmp (result, "inf 33") == 0); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
539 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
540 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
541 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
542 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
543 { /* Negative infinity. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
544 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
545 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
546 my_asnprintf (NULL, &length, "%La %d", - Infinityl (), 33, 44, 55); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
547 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
548 ASSERT (strcmp (result, "-inf 33") == 0); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
549 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
550 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
551 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
552 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
553 { /* NaN. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
554 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
555 char *result = |
9854
baba3b346ab2
Use macros NaNf, NaNd, NaNl instead of NAN.
Bruno Haible <bruno@clisp.org>
parents:
9850
diff
changeset
|
556 my_asnprintf (NULL, &length, "%La %d", NaNl (), 33, 44, 55); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
557 ASSERT (result != NULL); |
8850
d1fe16dfbfee
Avoid test failures on IRIX 6.5.
Bruno Haible <bruno@clisp.org>
parents:
8839
diff
changeset
|
558 ASSERT (strlen (result) >= 3 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
559 && strisnan (result, 0, strlen (result) - 3, 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
560 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
561 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
562 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
563 } |
15906
400649d35651
*printf-posix tests: Fix for platforms where 'long double' == 'double'.
Bruno Haible <bruno@clisp.org>
parents:
15595
diff
changeset
|
564 #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 |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
565 { /* Quiet NaN. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
566 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
567 { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
568 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
569 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
570 my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
571 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
572 ASSERT (strlen (result) >= 3 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
573 && strisnan (result, 0, strlen (result) - 3, 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
574 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
575 ASSERT (length == strlen (result)); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
576 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
577 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
578 { |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
579 /* Signalling NaN. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
580 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
581 { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
582 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
583 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
584 my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
585 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
586 ASSERT (strlen (result) >= 3 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
587 && strisnan (result, 0, strlen (result) - 3, 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
588 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
589 ASSERT (length == strlen (result)); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
590 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
591 } |
17927
b941bb9e9efb
printf, isinf, etc.: noncanonical != NaN
Paul Eggert <eggert@cs.ucla.edu>
parents:
17848
diff
changeset
|
592 /* asnprintf should print something for noncanonical values. */ |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
593 { /* Pseudo-NaN. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
594 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
595 { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
596 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
597 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
598 my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
599 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
600 ASSERT (length == strlen (result)); |
17927
b941bb9e9efb
printf, isinf, etc.: noncanonical != NaN
Paul Eggert <eggert@cs.ucla.edu>
parents:
17848
diff
changeset
|
601 ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
602 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
603 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
604 { /* Pseudo-Infinity. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
605 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
606 { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
607 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
608 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
609 my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
610 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
611 ASSERT (length == strlen (result)); |
17927
b941bb9e9efb
printf, isinf, etc.: noncanonical != NaN
Paul Eggert <eggert@cs.ucla.edu>
parents:
17848
diff
changeset
|
612 ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
613 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
614 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
615 { /* Pseudo-Zero. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
616 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
617 { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
618 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
619 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
620 my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
621 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
622 ASSERT (length == strlen (result)); |
17927
b941bb9e9efb
printf, isinf, etc.: noncanonical != NaN
Paul Eggert <eggert@cs.ucla.edu>
parents:
17848
diff
changeset
|
623 ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
624 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
625 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
626 { /* Unnormalized number. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
627 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
628 { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
629 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
630 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
631 my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
632 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
633 ASSERT (length == strlen (result)); |
17927
b941bb9e9efb
printf, isinf, etc.: noncanonical != NaN
Paul Eggert <eggert@cs.ucla.edu>
parents:
17848
diff
changeset
|
634 ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
635 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
636 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
637 { /* Pseudo-Denormal. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
638 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
639 { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
640 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
641 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
642 my_asnprintf (NULL, &length, "%La %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
643 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
644 ASSERT (length == strlen (result)); |
17927
b941bb9e9efb
printf, isinf, etc.: noncanonical != NaN
Paul Eggert <eggert@cs.ucla.edu>
parents:
17848
diff
changeset
|
645 ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
646 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
647 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
648 #endif |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
649 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
650 { /* Rounding near the decimal point. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
651 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
652 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
653 my_asnprintf (NULL, &length, "%.0La %d", 1.5L, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
654 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
655 ASSERT (strcmp (result, "0x2p+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
656 || strcmp (result, "0x3p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
657 || strcmp (result, "0x6p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
658 || strcmp (result, "0xcp-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
659 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
660 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
661 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
662 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
663 { /* Rounding with precision 0. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
664 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
665 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
666 my_asnprintf (NULL, &length, "%.0La %d", 1.51L, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
667 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
668 ASSERT (strcmp (result, "0x2p+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
669 || strcmp (result, "0x3p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
670 || strcmp (result, "0x6p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
671 || strcmp (result, "0xcp-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
672 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
673 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
674 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
675 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
676 { /* Rounding with precision 1. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
677 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
678 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
679 my_asnprintf (NULL, &length, "%.1La %d", 1.51L, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
680 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
681 ASSERT (strcmp (result, "0x1.8p+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
682 || strcmp (result, "0x3.0p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
683 || strcmp (result, "0x6.1p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
684 || strcmp (result, "0xc.1p-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
685 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
686 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
687 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
688 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
689 { /* Rounding with precision 2. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
690 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
691 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
692 my_asnprintf (NULL, &length, "%.2La %d", 1.51L, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
693 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
694 ASSERT (strcmp (result, "0x1.83p+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
695 || strcmp (result, "0x3.05p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
696 || strcmp (result, "0x6.0ap-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
697 || strcmp (result, "0xc.14p-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
698 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
699 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
700 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
701 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
702 { /* Rounding with precision 3. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
703 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
704 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
705 my_asnprintf (NULL, &length, "%.3La %d", 1.51L, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
706 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
707 ASSERT (strcmp (result, "0x1.829p+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
708 || strcmp (result, "0x3.052p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
709 || strcmp (result, "0x6.0a4p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
710 || strcmp (result, "0xc.148p-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
711 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
712 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
713 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
714 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
715 { /* Rounding can turn a ...FFF into a ...000. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
716 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
717 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
718 my_asnprintf (NULL, &length, "%.3La %d", 1.49999L, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
719 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
720 ASSERT (strcmp (result, "0x1.800p+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
721 || strcmp (result, "0x3.000p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
722 || strcmp (result, "0x6.000p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
723 || strcmp (result, "0xc.000p-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
724 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
725 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
726 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
727 |
8344
c8055280f68e
Test a corner case. Exclude two buggy implementations.
Bruno Haible <bruno@clisp.org>
parents:
8336
diff
changeset
|
728 { /* Rounding can turn a ...FFF into a ...000. |
16935
498a2211d839
Write "Mac OS X" instead of "MacOS X".
Bruno Haible <bruno@clisp.org>
parents:
16201
diff
changeset
|
729 This shows a Mac OS X 10.3.9 (Darwin 7.9) bug and a |
19192
d86e08b1f555
all: Replace many more http URLs by https URLs. Update stale URLs.
Bruno Haible <bruno@clisp.org>
parents:
19190
diff
changeset
|
730 glibc 2.4 bug <https://sourceware.org/bugzilla/show_bug.cgi?id=2908>. */ |
8344
c8055280f68e
Test a corner case. Exclude two buggy implementations.
Bruno Haible <bruno@clisp.org>
parents:
8336
diff
changeset
|
731 size_t length; |
c8055280f68e
Test a corner case. Exclude two buggy implementations.
Bruno Haible <bruno@clisp.org>
parents:
8336
diff
changeset
|
732 char *result = |
c8055280f68e
Test a corner case. Exclude two buggy implementations.
Bruno Haible <bruno@clisp.org>
parents:
8336
diff
changeset
|
733 my_asnprintf (NULL, &length, "%.1La %d", 1.999L, 33, 44, 55); |
c8055280f68e
Test a corner case. Exclude two buggy implementations.
Bruno Haible <bruno@clisp.org>
parents:
8336
diff
changeset
|
734 ASSERT (result != NULL); |
c8055280f68e
Test a corner case. Exclude two buggy implementations.
Bruno Haible <bruno@clisp.org>
parents:
8336
diff
changeset
|
735 ASSERT (strcmp (result, "0x1.0p+1 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
736 || strcmp (result, "0x2.0p+0 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
737 || strcmp (result, "0x4.0p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
738 || strcmp (result, "0x8.0p-2 33") == 0); |
8344
c8055280f68e
Test a corner case. Exclude two buggy implementations.
Bruno Haible <bruno@clisp.org>
parents:
8336
diff
changeset
|
739 ASSERT (length == strlen (result)); |
c8055280f68e
Test a corner case. Exclude two buggy implementations.
Bruno Haible <bruno@clisp.org>
parents:
8336
diff
changeset
|
740 free (result); |
c8055280f68e
Test a corner case. Exclude two buggy implementations.
Bruno Haible <bruno@clisp.org>
parents:
8336
diff
changeset
|
741 } |
c8055280f68e
Test a corner case. Exclude two buggy implementations.
Bruno Haible <bruno@clisp.org>
parents:
8336
diff
changeset
|
742 |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
743 { /* Width. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
744 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
745 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
746 my_asnprintf (NULL, &length, "%10La %d", 1.75L, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
747 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
748 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
749 || strcmp (result, " 0x3.8p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
750 || strcmp (result, " 0x7p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
751 || strcmp (result, " 0xep-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
752 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
753 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
754 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
755 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
756 { /* Small precision. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
757 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
758 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
759 my_asnprintf (NULL, &length, "%.10La %d", 1.75L, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
760 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
761 ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
762 || strcmp (result, "0x3.8000000000p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
763 || strcmp (result, "0x7.0000000000p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
764 || strcmp (result, "0xe.0000000000p-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
765 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
766 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
767 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
768 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
769 { /* Large precision. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
770 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
771 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
772 my_asnprintf (NULL, &length, "%.50La %d", 1.75L, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
773 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
774 ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
775 || strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
776 || strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
777 || strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
778 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
779 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
780 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
781 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
782 { /* FLAG_LEFT. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
783 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
784 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
785 my_asnprintf (NULL, &length, "%-10La %d", 1.75L, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
786 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
787 ASSERT (strcmp (result, "0x1.cp+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
788 || strcmp (result, "0x3.8p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
789 || strcmp (result, "0x7p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
790 || strcmp (result, "0xep-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
791 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
792 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
793 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
794 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
795 { /* FLAG_SHOWSIGN. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
796 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
797 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
798 my_asnprintf (NULL, &length, "%+La %d", 1.75L, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
799 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
800 ASSERT (strcmp (result, "+0x1.cp+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
801 || strcmp (result, "+0x3.8p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
802 || strcmp (result, "+0x7p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
803 || strcmp (result, "+0xep-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
804 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
805 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
806 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
807 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
808 { /* FLAG_SPACE. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
809 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
810 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
811 my_asnprintf (NULL, &length, "% La %d", 1.75L, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
812 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
813 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
814 || strcmp (result, " 0x3.8p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
815 || strcmp (result, " 0x7p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
816 || strcmp (result, " 0xep-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
817 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
818 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
819 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
820 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
821 { /* FLAG_ALT. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
822 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
823 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
824 my_asnprintf (NULL, &length, "%#La %d", 1.75L, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
825 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
826 ASSERT (strcmp (result, "0x1.cp+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
827 || strcmp (result, "0x3.8p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
828 || strcmp (result, "0x7.p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
829 || strcmp (result, "0xe.p-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
830 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
831 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
832 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
833 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
834 { /* FLAG_ALT. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
835 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
836 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
837 my_asnprintf (NULL, &length, "%#La %d", 1.0L, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
838 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
839 ASSERT (strcmp (result, "0x1.p+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
840 || strcmp (result, "0x2.p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
841 || strcmp (result, "0x4.p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
842 || strcmp (result, "0x8.p-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
843 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
844 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
845 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
846 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
847 { /* FLAG_ZERO with finite number. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
848 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
849 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
850 my_asnprintf (NULL, &length, "%010La %d", 1.75L, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
851 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
852 ASSERT (strcmp (result, "0x001.cp+0 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
853 || strcmp (result, "0x003.8p-1 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
854 || strcmp (result, "0x00007p-2 33") == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
855 || strcmp (result, "0x0000ep-3 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
856 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
857 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
858 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
859 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
860 { /* FLAG_ZERO with infinite number. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
861 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
862 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
863 my_asnprintf (NULL, &length, "%010La %d", Infinityl (), 33, 44, 55); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
864 ASSERT (result != NULL); |
8662
023aa5c883a7
Guard against FreeBSD 6.1 bug.
Bruno Haible <bruno@clisp.org>
parents:
8648
diff
changeset
|
865 /* "0000000inf 33" is not a valid result; see |
19439
8bfc20b57265
maint: shorten https://lists.gnu.org/archive/html/... links
Jim Meyering <meyering@fb.com>
parents:
19192
diff
changeset
|
866 <https://lists.gnu.org/r/bug-gnulib/2007-04/msg00107.html> */ |
8662
023aa5c883a7
Guard against FreeBSD 6.1 bug.
Bruno Haible <bruno@clisp.org>
parents:
8648
diff
changeset
|
867 ASSERT (strcmp (result, " inf 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
868 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
869 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
870 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
871 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
872 { /* FLAG_ZERO with NaN. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
873 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
874 char *result = |
9854
baba3b346ab2
Use macros NaNf, NaNd, NaNl instead of NAN.
Bruno Haible <bruno@clisp.org>
parents:
9850
diff
changeset
|
875 my_asnprintf (NULL, &length, "%050La %d", NaNl (), 33, 44, 55); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
876 ASSERT (result != NULL); |
8662
023aa5c883a7
Guard against FreeBSD 6.1 bug.
Bruno Haible <bruno@clisp.org>
parents:
8648
diff
changeset
|
877 /* "0000000nan 33" is not a valid result; see |
19439
8bfc20b57265
maint: shorten https://lists.gnu.org/archive/html/... links
Jim Meyering <meyering@fb.com>
parents:
19192
diff
changeset
|
878 <https://lists.gnu.org/r/bug-gnulib/2007-04/msg00107.html> */ |
8870
4e1f2ea486b4
Allow for a longer printed representation of NaN.
Bruno Haible <bruno@clisp.org>
parents:
8865
diff
changeset
|
879 ASSERT (strlen (result) == 50 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
880 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
881 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
882 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
883 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
884 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
885 |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
886 /* Test the support of the %f format directive. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
887 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
888 { /* A positive number. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
889 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
890 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
891 my_asnprintf (NULL, &length, "%f %d", 12.75, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
892 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
893 ASSERT (strcmp (result, "12.750000 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
894 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
895 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
896 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
897 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
898 { /* A larger positive number. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
899 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
900 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
901 my_asnprintf (NULL, &length, "%f %d", 1234567.0, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
902 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
903 ASSERT (strcmp (result, "1234567.000000 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
904 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
905 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
906 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
907 |
8834 | 908 { /* Small and large positive numbers. */ |
909 static struct { double value; const char *string; } data[] = | |
910 { | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
911 { 1.234321234321234e-37, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
912 { 1.234321234321234e-36, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
913 { 1.234321234321234e-35, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
914 { 1.234321234321234e-34, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
915 { 1.234321234321234e-33, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
916 { 1.234321234321234e-32, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
917 { 1.234321234321234e-31, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
918 { 1.234321234321234e-30, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
919 { 1.234321234321234e-29, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
920 { 1.234321234321234e-28, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
921 { 1.234321234321234e-27, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
922 { 1.234321234321234e-26, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
923 { 1.234321234321234e-25, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
924 { 1.234321234321234e-24, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
925 { 1.234321234321234e-23, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
926 { 1.234321234321234e-22, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
927 { 1.234321234321234e-21, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
928 { 1.234321234321234e-20, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
929 { 1.234321234321234e-19, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
930 { 1.234321234321234e-18, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
931 { 1.234321234321234e-17, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
932 { 1.234321234321234e-16, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
933 { 1.234321234321234e-15, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
934 { 1.234321234321234e-14, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
935 { 1.234321234321234e-13, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
936 { 1.234321234321234e-12, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
937 { 1.234321234321234e-11, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
938 { 1.234321234321234e-10, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
939 { 1.234321234321234e-9, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
940 { 1.234321234321234e-8, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
941 { 1.234321234321234e-7, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
942 { 1.234321234321234e-6, "0.000001" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
943 { 1.234321234321234e-5, "0.000012" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
944 { 1.234321234321234e-4, "0.000123" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
945 { 1.234321234321234e-3, "0.001234" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
946 { 1.234321234321234e-2, "0.012343" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
947 { 1.234321234321234e-1, "0.123432" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
948 { 1.234321234321234, "1.234321" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
949 { 1.234321234321234e1, "12.343212" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
950 { 1.234321234321234e2, "123.432123" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
951 { 1.234321234321234e3, "1234.321234" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
952 { 1.234321234321234e4, "12343.212343" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
953 { 1.234321234321234e5, "123432.123432" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
954 { 1.234321234321234e6, "1234321.234321" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
955 { 1.234321234321234e7, "12343212.343212" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
956 { 1.234321234321234e8, "123432123.432123" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
957 { 1.234321234321234e9, "1234321234.321234" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
958 { 1.234321234321234e10, "12343212343.2123**" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
959 { 1.234321234321234e11, "123432123432.123***" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
960 { 1.234321234321234e12, "1234321234321.23****" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
961 { 1.234321234321234e13, "12343212343212.3*****" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
962 { 1.234321234321234e14, "123432123432123.******" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
963 { 1.234321234321234e15, "1234321234321234.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
964 { 1.234321234321234e16, "123432123432123**.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
965 { 1.234321234321234e17, "123432123432123***.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
966 { 1.234321234321234e18, "123432123432123****.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
967 { 1.234321234321234e19, "123432123432123*****.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
968 { 1.234321234321234e20, "123432123432123******.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
969 { 1.234321234321234e21, "123432123432123*******.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
970 { 1.234321234321234e22, "123432123432123********.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
971 { 1.234321234321234e23, "123432123432123*********.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
972 { 1.234321234321234e24, "123432123432123**********.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
973 { 1.234321234321234e25, "123432123432123***********.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
974 { 1.234321234321234e26, "123432123432123************.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
975 { 1.234321234321234e27, "123432123432123*************.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
976 { 1.234321234321234e28, "123432123432123**************.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
977 { 1.234321234321234e29, "123432123432123***************.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
978 { 1.234321234321234e30, "123432123432123****************.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
979 { 1.234321234321234e31, "123432123432123*****************.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
980 { 1.234321234321234e32, "123432123432123******************.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
981 { 1.234321234321234e33, "123432123432123*******************.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
982 { 1.234321234321234e34, "123432123432123********************.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
983 { 1.234321234321234e35, "123432123432123*********************.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
984 { 1.234321234321234e36, "123432123432123**********************.000000" } |
8834 | 985 }; |
986 size_t k; | |
987 for (k = 0; k < SIZEOF (data); k++) | |
988 { | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
989 size_t length; |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
990 char *result = |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
991 my_asnprintf (NULL, &length, "%f", data[k].value); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
992 ASSERT (result != NULL); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
993 ASSERT (strmatch (data[k].string, result)); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
994 ASSERT (length == strlen (result)); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
995 free (result); |
8834 | 996 } |
997 } | |
998 | |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
999 { /* A negative number. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1000 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1001 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1002 my_asnprintf (NULL, &length, "%f %d", -0.03125, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1003 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1004 ASSERT (strcmp (result, "-0.031250 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1005 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1006 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1007 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1008 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1009 { /* Positive zero. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1010 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1011 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1012 my_asnprintf (NULL, &length, "%f %d", 0.0, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1013 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1014 ASSERT (strcmp (result, "0.000000 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1015 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1016 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1017 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1018 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1019 { /* Negative zero. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1020 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1021 char *result = |
13834
108bbfd6f03b
frexp, tests: work around ICC bug with -zero
Eric Blake <eblake@redhat.com>
parents:
13200
diff
changeset
|
1022 my_asnprintf (NULL, &length, "%f %d", minus_zerod, 33, 44, 55); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1023 ASSERT (result != NULL); |
8852
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
1024 if (have_minus_zero ()) |
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
1025 ASSERT (strcmp (result, "-0.000000 33") == 0); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1026 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1027 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1028 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1029 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1030 { /* Positive infinity. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1031 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1032 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
1033 my_asnprintf (NULL, &length, "%f %d", Infinityd (), 33, 44, 55); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1034 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1035 ASSERT (strcmp (result, "inf 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1036 || strcmp (result, "infinity 33") == 0); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1037 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1038 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1039 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1040 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1041 { /* Negative infinity. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1042 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1043 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
1044 my_asnprintf (NULL, &length, "%f %d", - Infinityd (), 33, 44, 55); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1045 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1046 ASSERT (strcmp (result, "-inf 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1047 || strcmp (result, "-infinity 33") == 0); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1048 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1049 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1050 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1051 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1052 { /* NaN. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1053 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1054 char *result = |
9854
baba3b346ab2
Use macros NaNf, NaNd, NaNl instead of NAN.
Bruno Haible <bruno@clisp.org>
parents:
9850
diff
changeset
|
1055 my_asnprintf (NULL, &length, "%f %d", NaNd (), 33, 44, 55); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1056 ASSERT (result != NULL); |
8850
d1fe16dfbfee
Avoid test failures on IRIX 6.5.
Bruno Haible <bruno@clisp.org>
parents:
8839
diff
changeset
|
1057 ASSERT (strlen (result) >= 3 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1058 && strisnan (result, 0, strlen (result) - 3, 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1059 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1060 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1061 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1062 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1063 |
8804
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1064 { /* Width. */ |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1065 size_t length; |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1066 char *result = |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1067 my_asnprintf (NULL, &length, "%10f %d", 1.75, 33, 44, 55); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1068 ASSERT (result != NULL); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1069 ASSERT (strcmp (result, " 1.750000 33") == 0); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1070 ASSERT (length == strlen (result)); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1071 free (result); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1072 } |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1073 |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1074 { /* FLAG_LEFT. */ |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1075 size_t length; |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1076 char *result = |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1077 my_asnprintf (NULL, &length, "%-10f %d", 1.75, 33, 44, 55); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1078 ASSERT (result != NULL); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1079 ASSERT (strcmp (result, "1.750000 33") == 0); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1080 ASSERT (length == strlen (result)); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1081 free (result); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1082 } |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1083 |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1084 { /* FLAG_SHOWSIGN. */ |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1085 size_t length; |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1086 char *result = |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1087 my_asnprintf (NULL, &length, "%+f %d", 1.75, 33, 44, 55); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1088 ASSERT (result != NULL); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1089 ASSERT (strcmp (result, "+1.750000 33") == 0); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1090 ASSERT (length == strlen (result)); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1091 free (result); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1092 } |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1093 |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1094 { /* FLAG_SPACE. */ |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1095 size_t length; |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1096 char *result = |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1097 my_asnprintf (NULL, &length, "% f %d", 1.75, 33, 44, 55); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1098 ASSERT (result != NULL); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1099 ASSERT (strcmp (result, " 1.750000 33") == 0); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1100 ASSERT (length == strlen (result)); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1101 free (result); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1102 } |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1103 |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1104 { /* FLAG_ALT. */ |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1105 size_t length; |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1106 char *result = |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1107 my_asnprintf (NULL, &length, "%#f %d", 1.75, 33, 44, 55); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1108 ASSERT (result != NULL); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1109 ASSERT (strcmp (result, "1.750000 33") == 0); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1110 ASSERT (length == strlen (result)); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1111 free (result); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1112 } |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1113 |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1114 { /* FLAG_ALT. */ |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1115 size_t length; |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1116 char *result = |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1117 my_asnprintf (NULL, &length, "%#.f %d", 1.75, 33, 44, 55); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1118 ASSERT (result != NULL); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1119 ASSERT (strcmp (result, "2. 33") == 0); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1120 ASSERT (length == strlen (result)); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1121 free (result); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1122 } |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1123 |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1124 { /* FLAG_ZERO with finite number. */ |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1125 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1126 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1127 my_asnprintf (NULL, &length, "%015f %d", 1234.0, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1128 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1129 ASSERT (strcmp (result, "00001234.000000 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1130 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1131 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1132 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1133 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1134 { /* FLAG_ZERO with infinite number. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1135 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1136 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
1137 my_asnprintf (NULL, &length, "%015f %d", - Infinityd (), 33, 44, 55); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1138 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1139 ASSERT (strcmp (result, " -inf 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1140 || strcmp (result, " -infinity 33") == 0); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1141 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1142 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1143 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1144 |
8804
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1145 { /* FLAG_ZERO with NaN. */ |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1146 size_t length; |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1147 char *result = |
9854
baba3b346ab2
Use macros NaNf, NaNd, NaNl instead of NAN.
Bruno Haible <bruno@clisp.org>
parents:
9850
diff
changeset
|
1148 my_asnprintf (NULL, &length, "%050f %d", NaNd (), 33, 44, 55); |
8804
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1149 ASSERT (result != NULL); |
8870
4e1f2ea486b4
Allow for a longer printed representation of NaN.
Bruno Haible <bruno@clisp.org>
parents:
8865
diff
changeset
|
1150 ASSERT (strlen (result) == 50 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1151 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1152 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8804
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1153 ASSERT (length == strlen (result)); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1154 free (result); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1155 } |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1156 |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1157 { /* Precision. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1158 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1159 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1160 my_asnprintf (NULL, &length, "%.f %d", 1234.0, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1161 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1162 ASSERT (strcmp (result, "1234 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1163 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1164 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1165 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1166 |
9938
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1167 { /* Precision with no rounding. */ |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1168 size_t length; |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1169 char *result = |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1170 my_asnprintf (NULL, &length, "%.2f %d", 999.951, 33, 44, 55); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1171 ASSERT (result != NULL); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1172 ASSERT (strcmp (result, "999.95 33") == 0); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1173 ASSERT (length == strlen (result)); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1174 free (result); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1175 } |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1176 |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1177 { /* Precision with rounding. */ |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1178 size_t length; |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1179 char *result = |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1180 my_asnprintf (NULL, &length, "%.2f %d", 999.996, 33, 44, 55); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1181 ASSERT (result != NULL); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1182 ASSERT (strcmp (result, "1000.00 33") == 0); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1183 ASSERT (length == strlen (result)); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1184 free (result); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1185 } |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1186 |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1187 { /* A positive number. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1188 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1189 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1190 my_asnprintf (NULL, &length, "%Lf %d", 12.75L, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1191 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1192 ASSERT (strcmp (result, "12.750000 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1193 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1194 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1195 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1196 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1197 { /* A larger positive number. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1198 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1199 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1200 my_asnprintf (NULL, &length, "%Lf %d", 1234567.0L, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1201 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1202 ASSERT (strcmp (result, "1234567.000000 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1203 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1204 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1205 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1206 |
8834 | 1207 { /* Small and large positive numbers. */ |
1208 static struct { long double value; const char *string; } data[] = | |
1209 { | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1210 { 1.234321234321234e-37L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1211 { 1.234321234321234e-36L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1212 { 1.234321234321234e-35L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1213 { 1.234321234321234e-34L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1214 { 1.234321234321234e-33L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1215 { 1.234321234321234e-32L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1216 { 1.234321234321234e-31L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1217 { 1.234321234321234e-30L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1218 { 1.234321234321234e-29L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1219 { 1.234321234321234e-28L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1220 { 1.234321234321234e-27L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1221 { 1.234321234321234e-26L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1222 { 1.234321234321234e-25L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1223 { 1.234321234321234e-24L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1224 { 1.234321234321234e-23L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1225 { 1.234321234321234e-22L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1226 { 1.234321234321234e-21L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1227 { 1.234321234321234e-20L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1228 { 1.234321234321234e-19L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1229 { 1.234321234321234e-18L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1230 { 1.234321234321234e-17L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1231 { 1.234321234321234e-16L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1232 { 1.234321234321234e-15L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1233 { 1.234321234321234e-14L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1234 { 1.234321234321234e-13L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1235 { 1.234321234321234e-12L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1236 { 1.234321234321234e-11L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1237 { 1.234321234321234e-10L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1238 { 1.234321234321234e-9L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1239 { 1.234321234321234e-8L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1240 { 1.234321234321234e-7L, "0.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1241 { 1.234321234321234e-6L, "0.000001" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1242 { 1.234321234321234e-5L, "0.000012" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1243 { 1.234321234321234e-4L, "0.000123" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1244 { 1.234321234321234e-3L, "0.001234" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1245 { 1.234321234321234e-2L, "0.012343" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1246 { 1.234321234321234e-1L, "0.123432" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1247 { 1.234321234321234L, "1.234321" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1248 { 1.234321234321234e1L, "12.343212" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1249 { 1.234321234321234e2L, "123.432123" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1250 { 1.234321234321234e3L, "1234.321234" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1251 { 1.234321234321234e4L, "12343.212343" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1252 { 1.234321234321234e5L, "123432.123432" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1253 { 1.234321234321234e6L, "1234321.234321" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1254 { 1.234321234321234e7L, "12343212.343212" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1255 { 1.234321234321234e8L, "123432123.432123" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1256 { 1.234321234321234e9L, "1234321234.321234" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1257 { 1.234321234321234e10L, "12343212343.2123**" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1258 { 1.234321234321234e11L, "123432123432.123***" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1259 { 1.234321234321234e12L, "1234321234321.23****" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1260 { 1.234321234321234e13L, "12343212343212.3*****" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1261 { 1.234321234321234e14L, "123432123432123.******" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1262 { 1.234321234321234e15L, "1234321234321234.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1263 { 1.234321234321234e16L, "123432123432123**.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1264 { 1.234321234321234e17L, "123432123432123***.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1265 { 1.234321234321234e18L, "123432123432123****.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1266 { 1.234321234321234e19L, "123432123432123*****.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1267 { 1.234321234321234e20L, "123432123432123******.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1268 { 1.234321234321234e21L, "123432123432123*******.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1269 { 1.234321234321234e22L, "123432123432123********.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1270 { 1.234321234321234e23L, "123432123432123*********.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1271 { 1.234321234321234e24L, "123432123432123**********.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1272 { 1.234321234321234e25L, "123432123432123***********.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1273 { 1.234321234321234e26L, "123432123432123************.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1274 { 1.234321234321234e27L, "123432123432123*************.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1275 { 1.234321234321234e28L, "123432123432123**************.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1276 { 1.234321234321234e29L, "123432123432123***************.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1277 { 1.234321234321234e30L, "123432123432123****************.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1278 { 1.234321234321234e31L, "123432123432123*****************.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1279 { 1.234321234321234e32L, "123432123432123******************.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1280 { 1.234321234321234e33L, "123432123432123*******************.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1281 { 1.234321234321234e34L, "123432123432123********************.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1282 { 1.234321234321234e35L, "123432123432123*********************.000000" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1283 { 1.234321234321234e36L, "123432123432123**********************.000000" } |
8834 | 1284 }; |
1285 size_t k; | |
1286 for (k = 0; k < SIZEOF (data); k++) | |
1287 { | |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1288 size_t length; |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1289 char *result = |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1290 my_asnprintf (NULL, &length, "%Lf", data[k].value); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1291 ASSERT (result != NULL); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1292 ASSERT (strmatch (data[k].string, result)); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1293 ASSERT (length == strlen (result)); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1294 free (result); |
8834 | 1295 } |
1296 } | |
1297 | |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1298 { /* A negative number. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1299 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1300 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1301 my_asnprintf (NULL, &length, "%Lf %d", -0.03125L, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1302 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1303 ASSERT (strcmp (result, "-0.031250 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1304 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1305 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1306 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1307 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1308 { /* Positive zero. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1309 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1310 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1311 my_asnprintf (NULL, &length, "%Lf %d", 0.0L, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1312 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1313 ASSERT (strcmp (result, "0.000000 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1314 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1315 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1316 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1317 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1318 { /* Negative zero. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1319 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1320 char *result = |
10601
ca053fa79cd3
Use a more portable replacement expression for -0.0L.
Bruno Haible <bruno@clisp.org>
parents:
10458
diff
changeset
|
1321 my_asnprintf (NULL, &length, "%Lf %d", minus_zerol, 33, 44, 55); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1322 ASSERT (result != NULL); |
8852
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
1323 if (have_minus_zero ()) |
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
1324 ASSERT (strcmp (result, "-0.000000 33") == 0); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1325 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1326 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1327 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1328 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1329 { /* Positive infinity. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1330 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1331 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
1332 my_asnprintf (NULL, &length, "%Lf %d", Infinityl (), 33, 44, 55); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1333 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1334 ASSERT (strcmp (result, "inf 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1335 || strcmp (result, "infinity 33") == 0); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1336 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1337 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1338 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1339 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1340 { /* Negative infinity. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1341 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1342 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
1343 my_asnprintf (NULL, &length, "%Lf %d", - Infinityl (), 33, 44, 55); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1344 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1345 ASSERT (strcmp (result, "-inf 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1346 || strcmp (result, "-infinity 33") == 0); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1347 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1348 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1349 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1350 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1351 { /* NaN. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1352 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1353 char *result = |
9854
baba3b346ab2
Use macros NaNf, NaNd, NaNl instead of NAN.
Bruno Haible <bruno@clisp.org>
parents:
9850
diff
changeset
|
1354 my_asnprintf (NULL, &length, "%Lf %d", NaNl (), 33, 44, 55); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1355 ASSERT (result != NULL); |
8850
d1fe16dfbfee
Avoid test failures on IRIX 6.5.
Bruno Haible <bruno@clisp.org>
parents:
8839
diff
changeset
|
1356 ASSERT (strlen (result) >= 3 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1357 && strisnan (result, 0, strlen (result) - 3, 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1358 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1359 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1360 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1361 } |
15906
400649d35651
*printf-posix tests: Fix for platforms where 'long double' == 'double'.
Bruno Haible <bruno@clisp.org>
parents:
15595
diff
changeset
|
1362 #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 |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1363 { /* Quiet NaN. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1364 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1365 { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1366 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1367 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1368 my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1369 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1370 ASSERT (strlen (result) >= 3 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1371 && strisnan (result, 0, strlen (result) - 3, 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1372 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1373 ASSERT (length == strlen (result)); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1374 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1375 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1376 { |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1377 /* Signalling NaN. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1378 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1379 { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1380 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1381 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1382 my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1383 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1384 ASSERT (strlen (result) >= 3 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1385 && strisnan (result, 0, strlen (result) - 3, 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1386 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1387 ASSERT (length == strlen (result)); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1388 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1389 } |
17927
b941bb9e9efb
printf, isinf, etc.: noncanonical != NaN
Paul Eggert <eggert@cs.ucla.edu>
parents:
17848
diff
changeset
|
1390 /* asnprintf should print something for noncanonical values. */ |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1391 { /* Pseudo-NaN. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1392 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1393 { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1394 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1395 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1396 my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1397 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1398 ASSERT (length == strlen (result)); |
17928
dd6f9e7b674a
vasnprintf-posix-tests: use consistent test
Paul Eggert <eggert@cs.ucla.edu>
parents:
17927
diff
changeset
|
1399 ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1400 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1401 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1402 { /* Pseudo-Infinity. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1403 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1404 { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1405 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1406 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1407 my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1408 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1409 ASSERT (length == strlen (result)); |
17928
dd6f9e7b674a
vasnprintf-posix-tests: use consistent test
Paul Eggert <eggert@cs.ucla.edu>
parents:
17927
diff
changeset
|
1410 ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1411 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1412 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1413 { /* Pseudo-Zero. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1414 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1415 { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1416 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1417 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1418 my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1419 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1420 ASSERT (length == strlen (result)); |
17928
dd6f9e7b674a
vasnprintf-posix-tests: use consistent test
Paul Eggert <eggert@cs.ucla.edu>
parents:
17927
diff
changeset
|
1421 ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1422 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1423 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1424 { /* Unnormalized number. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1425 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1426 { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1427 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1428 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1429 my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1430 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1431 ASSERT (length == strlen (result)); |
17928
dd6f9e7b674a
vasnprintf-posix-tests: use consistent test
Paul Eggert <eggert@cs.ucla.edu>
parents:
17927
diff
changeset
|
1432 ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1433 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1434 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1435 { /* Pseudo-Denormal. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1436 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1437 { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1438 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1439 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1440 my_asnprintf (NULL, &length, "%Lf %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1441 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1442 ASSERT (length == strlen (result)); |
17928
dd6f9e7b674a
vasnprintf-posix-tests: use consistent test
Paul Eggert <eggert@cs.ucla.edu>
parents:
17927
diff
changeset
|
1443 ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1444 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1445 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
1446 #endif |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1447 |
8804
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1448 { /* Width. */ |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1449 size_t length; |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1450 char *result = |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1451 my_asnprintf (NULL, &length, "%10Lf %d", 1.75L, 33, 44, 55); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1452 ASSERT (result != NULL); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1453 ASSERT (strcmp (result, " 1.750000 33") == 0); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1454 ASSERT (length == strlen (result)); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1455 free (result); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1456 } |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1457 |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1458 { /* FLAG_LEFT. */ |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1459 size_t length; |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1460 char *result = |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1461 my_asnprintf (NULL, &length, "%-10Lf %d", 1.75L, 33, 44, 55); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1462 ASSERT (result != NULL); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1463 ASSERT (strcmp (result, "1.750000 33") == 0); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1464 ASSERT (length == strlen (result)); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1465 free (result); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1466 } |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1467 |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1468 { /* FLAG_SHOWSIGN. */ |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1469 size_t length; |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1470 char *result = |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1471 my_asnprintf (NULL, &length, "%+Lf %d", 1.75L, 33, 44, 55); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1472 ASSERT (result != NULL); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1473 ASSERT (strcmp (result, "+1.750000 33") == 0); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1474 ASSERT (length == strlen (result)); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1475 free (result); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1476 } |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1477 |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1478 { /* FLAG_SPACE. */ |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1479 size_t length; |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1480 char *result = |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1481 my_asnprintf (NULL, &length, "% Lf %d", 1.75L, 33, 44, 55); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1482 ASSERT (result != NULL); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1483 ASSERT (strcmp (result, " 1.750000 33") == 0); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1484 ASSERT (length == strlen (result)); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1485 free (result); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1486 } |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1487 |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1488 { /* FLAG_ALT. */ |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1489 size_t length; |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1490 char *result = |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1491 my_asnprintf (NULL, &length, "%#Lf %d", 1.75L, 33, 44, 55); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1492 ASSERT (result != NULL); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1493 ASSERT (strcmp (result, "1.750000 33") == 0); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1494 ASSERT (length == strlen (result)); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1495 free (result); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1496 } |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1497 |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1498 { /* FLAG_ALT. */ |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1499 size_t length; |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1500 char *result = |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1501 my_asnprintf (NULL, &length, "%#.Lf %d", 1.75L, 33, 44, 55); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1502 ASSERT (result != NULL); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1503 ASSERT (strcmp (result, "2. 33") == 0); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1504 ASSERT (length == strlen (result)); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1505 free (result); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1506 } |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1507 |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1508 { /* FLAG_ZERO with finite number. */ |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1509 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1510 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1511 my_asnprintf (NULL, &length, "%015Lf %d", 1234.0L, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1512 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1513 ASSERT (strcmp (result, "00001234.000000 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1514 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1515 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1516 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1517 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1518 { /* FLAG_ZERO with infinite number. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1519 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1520 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
1521 my_asnprintf (NULL, &length, "%015Lf %d", - Infinityl (), 33, 44, 55); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1522 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1523 ASSERT (strcmp (result, " -inf 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1524 || strcmp (result, " -infinity 33") == 0); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1525 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1526 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1527 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1528 |
8804
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1529 { /* FLAG_ZERO with NaN. */ |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1530 size_t length; |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1531 char *result = |
9854
baba3b346ab2
Use macros NaNf, NaNd, NaNl instead of NAN.
Bruno Haible <bruno@clisp.org>
parents:
9850
diff
changeset
|
1532 my_asnprintf (NULL, &length, "%050Lf %d", NaNl (), 33, 44, 55); |
8804
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1533 ASSERT (result != NULL); |
8870
4e1f2ea486b4
Allow for a longer printed representation of NaN.
Bruno Haible <bruno@clisp.org>
parents:
8865
diff
changeset
|
1534 ASSERT (strlen (result) == 50 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1535 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1536 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8804
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1537 ASSERT (length == strlen (result)); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1538 free (result); |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1539 } |
6ce313658b4d
Work around an incorrect implementation of the 0 flag on most platforms.
Bruno Haible <bruno@clisp.org>
parents:
8803
diff
changeset
|
1540 |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1541 { /* Precision. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1542 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1543 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1544 my_asnprintf (NULL, &length, "%.Lf %d", 1234.0L, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1545 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1546 ASSERT (strcmp (result, "1234 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1547 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1548 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1549 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1550 |
9938
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1551 { /* Precision with no rounding. */ |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1552 size_t length; |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1553 char *result = |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1554 my_asnprintf (NULL, &length, "%.2Lf %d", 999.951L, 33, 44, 55); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1555 ASSERT (result != NULL); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1556 ASSERT (strcmp (result, "999.95 33") == 0); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1557 ASSERT (length == strlen (result)); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1558 free (result); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1559 } |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1560 |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1561 { /* Precision with rounding. */ |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1562 size_t length; |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1563 char *result = |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1564 my_asnprintf (NULL, &length, "%.2Lf %d", 999.996L, 33, 44, 55); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1565 ASSERT (result != NULL); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1566 ASSERT (strcmp (result, "1000.00 33") == 0); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1567 ASSERT (length == strlen (result)); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1568 free (result); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1569 } |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1570 |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1571 /* Test the support of the %F format directive. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1572 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1573 { /* A positive number. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1574 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1575 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1576 my_asnprintf (NULL, &length, "%F %d", 12.75, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1577 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1578 ASSERT (strcmp (result, "12.750000 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1579 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1580 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1581 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1582 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1583 { /* A larger positive number. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1584 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1585 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1586 my_asnprintf (NULL, &length, "%F %d", 1234567.0, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1587 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1588 ASSERT (strcmp (result, "1234567.000000 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1589 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1590 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1591 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1592 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1593 { /* A negative number. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1594 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1595 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1596 my_asnprintf (NULL, &length, "%F %d", -0.03125, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1597 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1598 ASSERT (strcmp (result, "-0.031250 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1599 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1600 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1601 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1602 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1603 { /* Positive zero. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1604 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1605 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1606 my_asnprintf (NULL, &length, "%F %d", 0.0, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1607 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1608 ASSERT (strcmp (result, "0.000000 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1609 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1610 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1611 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1612 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1613 { /* Negative zero. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1614 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1615 char *result = |
13834
108bbfd6f03b
frexp, tests: work around ICC bug with -zero
Eric Blake <eblake@redhat.com>
parents:
13200
diff
changeset
|
1616 my_asnprintf (NULL, &length, "%F %d", minus_zerod, 33, 44, 55); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1617 ASSERT (result != NULL); |
8852
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
1618 if (have_minus_zero ()) |
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
1619 ASSERT (strcmp (result, "-0.000000 33") == 0); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1620 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1621 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1622 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1623 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1624 { /* Positive infinity. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1625 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1626 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
1627 my_asnprintf (NULL, &length, "%F %d", Infinityd (), 33, 44, 55); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1628 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1629 ASSERT (strcmp (result, "INF 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1630 || strcmp (result, "INFINITY 33") == 0); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1631 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1632 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1633 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1634 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1635 { /* Negative infinity. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1636 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1637 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
1638 my_asnprintf (NULL, &length, "%F %d", - Infinityd (), 33, 44, 55); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1639 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1640 ASSERT (strcmp (result, "-INF 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1641 || strcmp (result, "-INFINITY 33") == 0); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1642 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1643 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1644 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1645 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1646 { /* NaN. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1647 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1648 char *result = |
9854
baba3b346ab2
Use macros NaNf, NaNd, NaNl instead of NAN.
Bruno Haible <bruno@clisp.org>
parents:
9850
diff
changeset
|
1649 my_asnprintf (NULL, &length, "%F %d", NaNd (), 33, 44, 55); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1650 ASSERT (result != NULL); |
8850
d1fe16dfbfee
Avoid test failures on IRIX 6.5.
Bruno Haible <bruno@clisp.org>
parents:
8839
diff
changeset
|
1651 ASSERT (strlen (result) >= 3 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1652 && strisnan (result, 0, strlen (result) - 3, 1) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1653 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1654 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1655 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1656 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1657 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1658 { /* FLAG_ZERO. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1659 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1660 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1661 my_asnprintf (NULL, &length, "%015F %d", 1234.0, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1662 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1663 ASSERT (strcmp (result, "00001234.000000 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1664 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1665 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1666 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1667 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1668 { /* FLAG_ZERO with infinite number. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1669 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1670 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
1671 my_asnprintf (NULL, &length, "%015F %d", - Infinityd (), 33, 44, 55); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1672 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1673 ASSERT (strcmp (result, " -INF 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1674 || strcmp (result, " -INFINITY 33") == 0); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1675 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1676 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1677 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1678 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1679 { /* Precision. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1680 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1681 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1682 my_asnprintf (NULL, &length, "%.F %d", 1234.0, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1683 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1684 ASSERT (strcmp (result, "1234 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1685 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1686 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1687 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1688 |
9938
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1689 { /* Precision with no rounding. */ |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1690 size_t length; |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1691 char *result = |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1692 my_asnprintf (NULL, &length, "%.2F %d", 999.951, 33, 44, 55); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1693 ASSERT (result != NULL); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1694 ASSERT (strcmp (result, "999.95 33") == 0); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1695 ASSERT (length == strlen (result)); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1696 free (result); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1697 } |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1698 |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1699 { /* Precision with rounding. */ |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1700 size_t length; |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1701 char *result = |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1702 my_asnprintf (NULL, &length, "%.2F %d", 999.996, 33, 44, 55); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1703 ASSERT (result != NULL); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1704 ASSERT (strcmp (result, "1000.00 33") == 0); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1705 ASSERT (length == strlen (result)); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1706 free (result); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1707 } |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1708 |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1709 { /* A positive number. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1710 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1711 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1712 my_asnprintf (NULL, &length, "%LF %d", 12.75L, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1713 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1714 ASSERT (strcmp (result, "12.750000 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1715 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1716 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1717 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1718 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1719 { /* A larger positive number. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1720 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1721 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1722 my_asnprintf (NULL, &length, "%LF %d", 1234567.0L, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1723 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1724 ASSERT (strcmp (result, "1234567.000000 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1725 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1726 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1727 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1728 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1729 { /* A negative number. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1730 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1731 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1732 my_asnprintf (NULL, &length, "%LF %d", -0.03125L, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1733 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1734 ASSERT (strcmp (result, "-0.031250 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1735 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1736 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1737 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1738 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1739 { /* Positive zero. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1740 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1741 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1742 my_asnprintf (NULL, &length, "%LF %d", 0.0L, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1743 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1744 ASSERT (strcmp (result, "0.000000 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1745 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1746 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1747 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1748 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1749 { /* Negative zero. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1750 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1751 char *result = |
10601
ca053fa79cd3
Use a more portable replacement expression for -0.0L.
Bruno Haible <bruno@clisp.org>
parents:
10458
diff
changeset
|
1752 my_asnprintf (NULL, &length, "%LF %d", minus_zerol, 33, 44, 55); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1753 ASSERT (result != NULL); |
8852
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
1754 if (have_minus_zero ()) |
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
1755 ASSERT (strcmp (result, "-0.000000 33") == 0); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1756 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1757 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1758 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1759 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1760 { /* Positive infinity. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1761 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1762 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
1763 my_asnprintf (NULL, &length, "%LF %d", Infinityl (), 33, 44, 55); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1764 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1765 ASSERT (strcmp (result, "INF 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1766 || strcmp (result, "INFINITY 33") == 0); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1767 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1768 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1769 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1770 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1771 { /* Negative infinity. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1772 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1773 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
1774 my_asnprintf (NULL, &length, "%LF %d", - Infinityl (), 33, 44, 55); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1775 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1776 ASSERT (strcmp (result, "-INF 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1777 || strcmp (result, "-INFINITY 33") == 0); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1778 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1779 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1780 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1781 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1782 { /* NaN. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1783 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1784 char *result = |
9854
baba3b346ab2
Use macros NaNf, NaNd, NaNl instead of NAN.
Bruno Haible <bruno@clisp.org>
parents:
9850
diff
changeset
|
1785 my_asnprintf (NULL, &length, "%LF %d", NaNl (), 33, 44, 55); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1786 ASSERT (result != NULL); |
8850
d1fe16dfbfee
Avoid test failures on IRIX 6.5.
Bruno Haible <bruno@clisp.org>
parents:
8839
diff
changeset
|
1787 ASSERT (strlen (result) >= 3 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1788 && strisnan (result, 0, strlen (result) - 3, 1) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1789 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1790 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1791 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1792 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1793 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1794 { /* FLAG_ZERO. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1795 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1796 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1797 my_asnprintf (NULL, &length, "%015LF %d", 1234.0L, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1798 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1799 ASSERT (strcmp (result, "00001234.000000 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1800 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1801 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1802 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1803 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1804 { /* FLAG_ZERO with infinite number. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1805 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1806 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
1807 my_asnprintf (NULL, &length, "%015LF %d", - Infinityl (), 33, 44, 55); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1808 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1809 ASSERT (strcmp (result, " -INF 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1810 || strcmp (result, " -INFINITY 33") == 0); |
8684
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1811 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1812 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1813 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1814 |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1815 { /* Precision. */ |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1816 size_t length; |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1817 char *result = |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1818 my_asnprintf (NULL, &length, "%.LF %d", 1234.0L, 33, 44, 55); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1819 ASSERT (result != NULL); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1820 ASSERT (strcmp (result, "1234 33") == 0); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1821 ASSERT (length == strlen (result)); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1822 free (result); |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1823 } |
9ea5590b49d1
Add tests for %f and %F directives.
Bruno Haible <bruno@clisp.org>
parents:
8662
diff
changeset
|
1824 |
9938
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1825 { /* Precision with no rounding. */ |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1826 size_t length; |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1827 char *result = |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1828 my_asnprintf (NULL, &length, "%.2LF %d", 999.951L, 33, 44, 55); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1829 ASSERT (result != NULL); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1830 ASSERT (strcmp (result, "999.95 33") == 0); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1831 ASSERT (length == strlen (result)); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1832 free (result); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1833 } |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1834 |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1835 { /* Precision with rounding. */ |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1836 size_t length; |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1837 char *result = |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1838 my_asnprintf (NULL, &length, "%.2LF %d", 999.996L, 33, 44, 55); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1839 ASSERT (result != NULL); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1840 ASSERT (strcmp (result, "1000.00 33") == 0); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1841 ASSERT (length == strlen (result)); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1842 free (result); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1843 } |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
1844 |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1845 /* Test the support of the %e format directive. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1846 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1847 { /* A positive number. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1848 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1849 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1850 my_asnprintf (NULL, &length, "%e %d", 12.75, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1851 ASSERT (result != NULL); |
8839
5efc1d668039
Accomodate for implementations that produce 3 exponent digits in %e and %g.
Bruno Haible <bruno@clisp.org>
parents:
8836
diff
changeset
|
1852 ASSERT (strcmp (result, "1.275000e+01 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1853 || strcmp (result, "1.275000e+001 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1854 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1855 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1856 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1857 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1858 { /* A larger positive number. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1859 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1860 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1861 my_asnprintf (NULL, &length, "%e %d", 1234567.0, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1862 ASSERT (result != NULL); |
8839
5efc1d668039
Accomodate for implementations that produce 3 exponent digits in %e and %g.
Bruno Haible <bruno@clisp.org>
parents:
8836
diff
changeset
|
1863 ASSERT (strcmp (result, "1.234567e+06 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1864 || strcmp (result, "1.234567e+006 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1865 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1866 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1867 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1868 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1869 { /* Small and large positive numbers. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1870 static struct { double value; const char *string; } data[] = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1871 { |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1872 { 1.234321234321234e-37, "1.234321e-37" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1873 { 1.234321234321234e-36, "1.234321e-36" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1874 { 1.234321234321234e-35, "1.234321e-35" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1875 { 1.234321234321234e-34, "1.234321e-34" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1876 { 1.234321234321234e-33, "1.234321e-33" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1877 { 1.234321234321234e-32, "1.234321e-32" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1878 { 1.234321234321234e-31, "1.234321e-31" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1879 { 1.234321234321234e-30, "1.234321e-30" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1880 { 1.234321234321234e-29, "1.234321e-29" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1881 { 1.234321234321234e-28, "1.234321e-28" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1882 { 1.234321234321234e-27, "1.234321e-27" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1883 { 1.234321234321234e-26, "1.234321e-26" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1884 { 1.234321234321234e-25, "1.234321e-25" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1885 { 1.234321234321234e-24, "1.234321e-24" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1886 { 1.234321234321234e-23, "1.234321e-23" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1887 { 1.234321234321234e-22, "1.234321e-22" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1888 { 1.234321234321234e-21, "1.234321e-21" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1889 { 1.234321234321234e-20, "1.234321e-20" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1890 { 1.234321234321234e-19, "1.234321e-19" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1891 { 1.234321234321234e-18, "1.234321e-18" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1892 { 1.234321234321234e-17, "1.234321e-17" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1893 { 1.234321234321234e-16, "1.234321e-16" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1894 { 1.234321234321234e-15, "1.234321e-15" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1895 { 1.234321234321234e-14, "1.234321e-14" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1896 { 1.234321234321234e-13, "1.234321e-13" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1897 { 1.234321234321234e-12, "1.234321e-12" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1898 { 1.234321234321234e-11, "1.234321e-11" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1899 { 1.234321234321234e-10, "1.234321e-10" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1900 { 1.234321234321234e-9, "1.234321e-09" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1901 { 1.234321234321234e-8, "1.234321e-08" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1902 { 1.234321234321234e-7, "1.234321e-07" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1903 { 1.234321234321234e-6, "1.234321e-06" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1904 { 1.234321234321234e-5, "1.234321e-05" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1905 { 1.234321234321234e-4, "1.234321e-04" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1906 { 1.234321234321234e-3, "1.234321e-03" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1907 { 1.234321234321234e-2, "1.234321e-02" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1908 { 1.234321234321234e-1, "1.234321e-01" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1909 { 1.234321234321234, "1.234321e+00" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1910 { 1.234321234321234e1, "1.234321e+01" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1911 { 1.234321234321234e2, "1.234321e+02" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1912 { 1.234321234321234e3, "1.234321e+03" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1913 { 1.234321234321234e4, "1.234321e+04" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1914 { 1.234321234321234e5, "1.234321e+05" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1915 { 1.234321234321234e6, "1.234321e+06" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1916 { 1.234321234321234e7, "1.234321e+07" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1917 { 1.234321234321234e8, "1.234321e+08" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1918 { 1.234321234321234e9, "1.234321e+09" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1919 { 1.234321234321234e10, "1.234321e+10" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1920 { 1.234321234321234e11, "1.234321e+11" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1921 { 1.234321234321234e12, "1.234321e+12" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1922 { 1.234321234321234e13, "1.234321e+13" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1923 { 1.234321234321234e14, "1.234321e+14" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1924 { 1.234321234321234e15, "1.234321e+15" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1925 { 1.234321234321234e16, "1.234321e+16" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1926 { 1.234321234321234e17, "1.234321e+17" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1927 { 1.234321234321234e18, "1.234321e+18" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1928 { 1.234321234321234e19, "1.234321e+19" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1929 { 1.234321234321234e20, "1.234321e+20" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1930 { 1.234321234321234e21, "1.234321e+21" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1931 { 1.234321234321234e22, "1.234321e+22" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1932 { 1.234321234321234e23, "1.234321e+23" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1933 { 1.234321234321234e24, "1.234321e+24" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1934 { 1.234321234321234e25, "1.234321e+25" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1935 { 1.234321234321234e26, "1.234321e+26" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1936 { 1.234321234321234e27, "1.234321e+27" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1937 { 1.234321234321234e28, "1.234321e+28" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1938 { 1.234321234321234e29, "1.234321e+29" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1939 { 1.234321234321234e30, "1.234321e+30" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1940 { 1.234321234321234e31, "1.234321e+31" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1941 { 1.234321234321234e32, "1.234321e+32" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1942 { 1.234321234321234e33, "1.234321e+33" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1943 { 1.234321234321234e34, "1.234321e+34" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1944 { 1.234321234321234e35, "1.234321e+35" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1945 { 1.234321234321234e36, "1.234321e+36" } |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1946 }; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1947 size_t k; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1948 for (k = 0; k < SIZEOF (data); k++) |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1949 { |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1950 size_t length; |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1951 char *result = |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1952 my_asnprintf (NULL, &length, "%e", data[k].value); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1953 const char *expected = data[k].string; |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1954 ASSERT (result != NULL); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1955 ASSERT (strcmp (result, expected) == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1956 /* Some implementations produce exponents with 3 digits. */ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1957 || (strlen (result) == strlen (expected) + 1 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1958 && memcmp (result, expected, strlen (expected) - 2) == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1959 && result[strlen (expected) - 2] == '0' |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1960 && strcmp (result + strlen (expected) - 1, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1961 expected + strlen (expected) - 2) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1962 == 0)); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1963 ASSERT (length == strlen (result)); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1964 free (result); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1965 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1966 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1967 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1968 { /* A negative number. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1969 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1970 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1971 my_asnprintf (NULL, &length, "%e %d", -0.03125, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1972 ASSERT (result != NULL); |
8839
5efc1d668039
Accomodate for implementations that produce 3 exponent digits in %e and %g.
Bruno Haible <bruno@clisp.org>
parents:
8836
diff
changeset
|
1973 ASSERT (strcmp (result, "-3.125000e-02 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1974 || strcmp (result, "-3.125000e-002 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1975 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1976 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1977 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1978 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1979 { /* Positive zero. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1980 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1981 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1982 my_asnprintf (NULL, &length, "%e %d", 0.0, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1983 ASSERT (result != NULL); |
8839
5efc1d668039
Accomodate for implementations that produce 3 exponent digits in %e and %g.
Bruno Haible <bruno@clisp.org>
parents:
8836
diff
changeset
|
1984 ASSERT (strcmp (result, "0.000000e+00 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1985 || strcmp (result, "0.000000e+000 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1986 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1987 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1988 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1989 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1990 { /* Negative zero. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1991 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1992 char *result = |
13834
108bbfd6f03b
frexp, tests: work around ICC bug with -zero
Eric Blake <eblake@redhat.com>
parents:
13200
diff
changeset
|
1993 my_asnprintf (NULL, &length, "%e %d", minus_zerod, 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1994 ASSERT (result != NULL); |
8852
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
1995 if (have_minus_zero ()) |
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
1996 ASSERT (strcmp (result, "-0.000000e+00 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
1997 || strcmp (result, "-0.000000e+000 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1998 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
1999 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2000 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2001 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2002 { /* Positive infinity. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2003 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2004 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
2005 my_asnprintf (NULL, &length, "%e %d", Infinityd (), 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2006 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2007 ASSERT (strcmp (result, "inf 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2008 || strcmp (result, "infinity 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2009 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2010 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2011 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2012 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2013 { /* Negative infinity. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2014 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2015 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
2016 my_asnprintf (NULL, &length, "%e %d", - Infinityd (), 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2017 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2018 ASSERT (strcmp (result, "-inf 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2019 || strcmp (result, "-infinity 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2020 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2021 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2022 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2023 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2024 { /* NaN. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2025 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2026 char *result = |
9854
baba3b346ab2
Use macros NaNf, NaNd, NaNl instead of NAN.
Bruno Haible <bruno@clisp.org>
parents:
9850
diff
changeset
|
2027 my_asnprintf (NULL, &length, "%e %d", NaNd (), 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2028 ASSERT (result != NULL); |
8850
d1fe16dfbfee
Avoid test failures on IRIX 6.5.
Bruno Haible <bruno@clisp.org>
parents:
8839
diff
changeset
|
2029 ASSERT (strlen (result) >= 3 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2030 && strisnan (result, 0, strlen (result) - 3, 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2031 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2032 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2033 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2034 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2035 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2036 { /* Width. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2037 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2038 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2039 my_asnprintf (NULL, &length, "%15e %d", 1.75, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2040 ASSERT (result != NULL); |
8839
5efc1d668039
Accomodate for implementations that produce 3 exponent digits in %e and %g.
Bruno Haible <bruno@clisp.org>
parents:
8836
diff
changeset
|
2041 ASSERT (strcmp (result, " 1.750000e+00 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2042 || strcmp (result, " 1.750000e+000 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2043 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2044 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2045 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2046 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2047 { /* FLAG_LEFT. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2048 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2049 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2050 my_asnprintf (NULL, &length, "%-15e %d", 1.75, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2051 ASSERT (result != NULL); |
8839
5efc1d668039
Accomodate for implementations that produce 3 exponent digits in %e and %g.
Bruno Haible <bruno@clisp.org>
parents:
8836
diff
changeset
|
2052 ASSERT (strcmp (result, "1.750000e+00 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2053 || strcmp (result, "1.750000e+000 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2054 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2055 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2056 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2057 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2058 { /* FLAG_SHOWSIGN. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2059 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2060 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2061 my_asnprintf (NULL, &length, "%+e %d", 1.75, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2062 ASSERT (result != NULL); |
8839
5efc1d668039
Accomodate for implementations that produce 3 exponent digits in %e and %g.
Bruno Haible <bruno@clisp.org>
parents:
8836
diff
changeset
|
2063 ASSERT (strcmp (result, "+1.750000e+00 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2064 || strcmp (result, "+1.750000e+000 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2065 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2066 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2067 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2068 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2069 { /* FLAG_SPACE. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2070 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2071 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2072 my_asnprintf (NULL, &length, "% e %d", 1.75, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2073 ASSERT (result != NULL); |
8839
5efc1d668039
Accomodate for implementations that produce 3 exponent digits in %e and %g.
Bruno Haible <bruno@clisp.org>
parents:
8836
diff
changeset
|
2074 ASSERT (strcmp (result, " 1.750000e+00 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2075 || strcmp (result, " 1.750000e+000 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2076 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2077 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2078 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2079 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2080 { /* FLAG_ALT. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2081 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2082 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2083 my_asnprintf (NULL, &length, "%#e %d", 1.75, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2084 ASSERT (result != NULL); |
8839
5efc1d668039
Accomodate for implementations that produce 3 exponent digits in %e and %g.
Bruno Haible <bruno@clisp.org>
parents:
8836
diff
changeset
|
2085 ASSERT (strcmp (result, "1.750000e+00 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2086 || strcmp (result, "1.750000e+000 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2087 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2088 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2089 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2090 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2091 { /* FLAG_ALT. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2092 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2093 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2094 my_asnprintf (NULL, &length, "%#.e %d", 1.75, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2095 ASSERT (result != NULL); |
8839
5efc1d668039
Accomodate for implementations that produce 3 exponent digits in %e and %g.
Bruno Haible <bruno@clisp.org>
parents:
8836
diff
changeset
|
2096 ASSERT (strcmp (result, "2.e+00 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2097 || strcmp (result, "2.e+000 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2098 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2099 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2100 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2101 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2102 { /* FLAG_ALT. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2103 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2104 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2105 my_asnprintf (NULL, &length, "%#.e %d", 9.75, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2106 ASSERT (result != NULL); |
8839
5efc1d668039
Accomodate for implementations that produce 3 exponent digits in %e and %g.
Bruno Haible <bruno@clisp.org>
parents:
8836
diff
changeset
|
2107 ASSERT (strcmp (result, "1.e+01 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2108 || strcmp (result, "1.e+001 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2109 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2110 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2111 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2112 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2113 { /* FLAG_ZERO with finite number. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2114 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2115 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2116 my_asnprintf (NULL, &length, "%015e %d", 1234.0, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2117 ASSERT (result != NULL); |
8839
5efc1d668039
Accomodate for implementations that produce 3 exponent digits in %e and %g.
Bruno Haible <bruno@clisp.org>
parents:
8836
diff
changeset
|
2118 ASSERT (strcmp (result, "0001.234000e+03 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2119 || strcmp (result, "001.234000e+003 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2120 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2121 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2122 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2123 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2124 { /* FLAG_ZERO with infinite number. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2125 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2126 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
2127 my_asnprintf (NULL, &length, "%015e %d", - Infinityd (), 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2128 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2129 ASSERT (strcmp (result, " -inf 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2130 || strcmp (result, " -infinity 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2131 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2132 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2133 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2134 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2135 { /* FLAG_ZERO with NaN. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2136 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2137 char *result = |
9854
baba3b346ab2
Use macros NaNf, NaNd, NaNl instead of NAN.
Bruno Haible <bruno@clisp.org>
parents:
9850
diff
changeset
|
2138 my_asnprintf (NULL, &length, "%050e %d", NaNd (), 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2139 ASSERT (result != NULL); |
8870
4e1f2ea486b4
Allow for a longer printed representation of NaN.
Bruno Haible <bruno@clisp.org>
parents:
8865
diff
changeset
|
2140 ASSERT (strlen (result) == 50 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2141 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2142 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2143 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2144 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2145 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2146 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2147 { /* Precision. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2148 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2149 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2150 my_asnprintf (NULL, &length, "%.e %d", 1234.0, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2151 ASSERT (result != NULL); |
8839
5efc1d668039
Accomodate for implementations that produce 3 exponent digits in %e and %g.
Bruno Haible <bruno@clisp.org>
parents:
8836
diff
changeset
|
2152 ASSERT (strcmp (result, "1e+03 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2153 || strcmp (result, "1e+003 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2154 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2155 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2156 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2157 |
9938
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2158 { /* Precision with no rounding. */ |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2159 size_t length; |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2160 char *result = |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2161 my_asnprintf (NULL, &length, "%.4e %d", 999.951, 33, 44, 55); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2162 ASSERT (result != NULL); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2163 ASSERT (strcmp (result, "9.9995e+02 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2164 || strcmp (result, "9.9995e+002 33") == 0); |
9938
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2165 ASSERT (length == strlen (result)); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2166 free (result); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2167 } |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2168 |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2169 { /* Precision with rounding. */ |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2170 size_t length; |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2171 char *result = |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2172 my_asnprintf (NULL, &length, "%.4e %d", 999.996, 33, 44, 55); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2173 ASSERT (result != NULL); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2174 ASSERT (strcmp (result, "1.0000e+03 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2175 || strcmp (result, "1.0000e+003 33") == 0); |
9938
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2176 ASSERT (length == strlen (result)); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2177 free (result); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2178 } |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2179 |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2180 { /* A positive number. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2181 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2182 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2183 my_asnprintf (NULL, &length, "%Le %d", 12.75L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2184 ASSERT (result != NULL); |
10458
1cc9cffb9615
Allow 3-digit exponents in %e and %g results on 'long double'.
Bruno Haible <bruno@clisp.org>
parents:
10394
diff
changeset
|
2185 ASSERT (strcmp (result, "1.275000e+01 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2186 || strcmp (result, "1.275000e+001 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2187 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2188 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2189 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2190 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2191 { /* A larger positive number. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2192 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2193 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2194 my_asnprintf (NULL, &length, "%Le %d", 1234567.0L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2195 ASSERT (result != NULL); |
10458
1cc9cffb9615
Allow 3-digit exponents in %e and %g results on 'long double'.
Bruno Haible <bruno@clisp.org>
parents:
10394
diff
changeset
|
2196 ASSERT (strcmp (result, "1.234567e+06 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2197 || strcmp (result, "1.234567e+006 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2198 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2199 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2200 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2201 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2202 { /* Small and large positive numbers. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2203 static struct { long double value; const char *string; } data[] = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2204 { |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2205 { 1.234321234321234e-37L, "1.234321e-37" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2206 { 1.234321234321234e-36L, "1.234321e-36" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2207 { 1.234321234321234e-35L, "1.234321e-35" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2208 { 1.234321234321234e-34L, "1.234321e-34" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2209 { 1.234321234321234e-33L, "1.234321e-33" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2210 { 1.234321234321234e-32L, "1.234321e-32" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2211 { 1.234321234321234e-31L, "1.234321e-31" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2212 { 1.234321234321234e-30L, "1.234321e-30" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2213 { 1.234321234321234e-29L, "1.234321e-29" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2214 { 1.234321234321234e-28L, "1.234321e-28" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2215 { 1.234321234321234e-27L, "1.234321e-27" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2216 { 1.234321234321234e-26L, "1.234321e-26" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2217 { 1.234321234321234e-25L, "1.234321e-25" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2218 { 1.234321234321234e-24L, "1.234321e-24" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2219 { 1.234321234321234e-23L, "1.234321e-23" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2220 { 1.234321234321234e-22L, "1.234321e-22" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2221 { 1.234321234321234e-21L, "1.234321e-21" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2222 { 1.234321234321234e-20L, "1.234321e-20" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2223 { 1.234321234321234e-19L, "1.234321e-19" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2224 { 1.234321234321234e-18L, "1.234321e-18" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2225 { 1.234321234321234e-17L, "1.234321e-17" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2226 { 1.234321234321234e-16L, "1.234321e-16" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2227 { 1.234321234321234e-15L, "1.234321e-15" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2228 { 1.234321234321234e-14L, "1.234321e-14" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2229 { 1.234321234321234e-13L, "1.234321e-13" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2230 { 1.234321234321234e-12L, "1.234321e-12" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2231 { 1.234321234321234e-11L, "1.234321e-11" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2232 { 1.234321234321234e-10L, "1.234321e-10" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2233 { 1.234321234321234e-9L, "1.234321e-09" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2234 { 1.234321234321234e-8L, "1.234321e-08" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2235 { 1.234321234321234e-7L, "1.234321e-07" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2236 { 1.234321234321234e-6L, "1.234321e-06" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2237 { 1.234321234321234e-5L, "1.234321e-05" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2238 { 1.234321234321234e-4L, "1.234321e-04" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2239 { 1.234321234321234e-3L, "1.234321e-03" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2240 { 1.234321234321234e-2L, "1.234321e-02" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2241 { 1.234321234321234e-1L, "1.234321e-01" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2242 { 1.234321234321234L, "1.234321e+00" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2243 { 1.234321234321234e1L, "1.234321e+01" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2244 { 1.234321234321234e2L, "1.234321e+02" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2245 { 1.234321234321234e3L, "1.234321e+03" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2246 { 1.234321234321234e4L, "1.234321e+04" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2247 { 1.234321234321234e5L, "1.234321e+05" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2248 { 1.234321234321234e6L, "1.234321e+06" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2249 { 1.234321234321234e7L, "1.234321e+07" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2250 { 1.234321234321234e8L, "1.234321e+08" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2251 { 1.234321234321234e9L, "1.234321e+09" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2252 { 1.234321234321234e10L, "1.234321e+10" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2253 { 1.234321234321234e11L, "1.234321e+11" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2254 { 1.234321234321234e12L, "1.234321e+12" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2255 { 1.234321234321234e13L, "1.234321e+13" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2256 { 1.234321234321234e14L, "1.234321e+14" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2257 { 1.234321234321234e15L, "1.234321e+15" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2258 { 1.234321234321234e16L, "1.234321e+16" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2259 { 1.234321234321234e17L, "1.234321e+17" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2260 { 1.234321234321234e18L, "1.234321e+18" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2261 { 1.234321234321234e19L, "1.234321e+19" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2262 { 1.234321234321234e20L, "1.234321e+20" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2263 { 1.234321234321234e21L, "1.234321e+21" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2264 { 1.234321234321234e22L, "1.234321e+22" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2265 { 1.234321234321234e23L, "1.234321e+23" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2266 { 1.234321234321234e24L, "1.234321e+24" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2267 { 1.234321234321234e25L, "1.234321e+25" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2268 { 1.234321234321234e26L, "1.234321e+26" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2269 { 1.234321234321234e27L, "1.234321e+27" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2270 { 1.234321234321234e28L, "1.234321e+28" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2271 { 1.234321234321234e29L, "1.234321e+29" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2272 { 1.234321234321234e30L, "1.234321e+30" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2273 { 1.234321234321234e31L, "1.234321e+31" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2274 { 1.234321234321234e32L, "1.234321e+32" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2275 { 1.234321234321234e33L, "1.234321e+33" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2276 { 1.234321234321234e34L, "1.234321e+34" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2277 { 1.234321234321234e35L, "1.234321e+35" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2278 { 1.234321234321234e36L, "1.234321e+36" } |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2279 }; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2280 size_t k; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2281 for (k = 0; k < SIZEOF (data); k++) |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2282 { |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2283 size_t length; |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2284 char *result = |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2285 my_asnprintf (NULL, &length, "%Le", data[k].value); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2286 const char *expected = data[k].string; |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2287 ASSERT (result != NULL); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2288 ASSERT (strcmp (result, expected) == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2289 /* Some implementations produce exponents with 3 digits. */ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2290 || (strlen (result) == strlen (expected) + 1 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2291 && memcmp (result, expected, strlen (expected) - 2) == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2292 && result[strlen (expected) - 2] == '0' |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2293 && strcmp (result + strlen (expected) - 1, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2294 expected + strlen (expected) - 2) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2295 == 0)); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2296 ASSERT (length == strlen (result)); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2297 free (result); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2298 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2299 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2300 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2301 { /* A negative number. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2302 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2303 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2304 my_asnprintf (NULL, &length, "%Le %d", -0.03125L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2305 ASSERT (result != NULL); |
10458
1cc9cffb9615
Allow 3-digit exponents in %e and %g results on 'long double'.
Bruno Haible <bruno@clisp.org>
parents:
10394
diff
changeset
|
2306 ASSERT (strcmp (result, "-3.125000e-02 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2307 || strcmp (result, "-3.125000e-002 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2308 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2309 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2310 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2311 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2312 { /* Positive zero. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2313 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2314 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2315 my_asnprintf (NULL, &length, "%Le %d", 0.0L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2316 ASSERT (result != NULL); |
10458
1cc9cffb9615
Allow 3-digit exponents in %e and %g results on 'long double'.
Bruno Haible <bruno@clisp.org>
parents:
10394
diff
changeset
|
2317 ASSERT (strcmp (result, "0.000000e+00 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2318 || strcmp (result, "0.000000e+000 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2319 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2320 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2321 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2322 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2323 { /* Negative zero. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2324 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2325 char *result = |
10601
ca053fa79cd3
Use a more portable replacement expression for -0.0L.
Bruno Haible <bruno@clisp.org>
parents:
10458
diff
changeset
|
2326 my_asnprintf (NULL, &length, "%Le %d", minus_zerol, 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2327 ASSERT (result != NULL); |
8852
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
2328 if (have_minus_zero ()) |
10458
1cc9cffb9615
Allow 3-digit exponents in %e and %g results on 'long double'.
Bruno Haible <bruno@clisp.org>
parents:
10394
diff
changeset
|
2329 ASSERT (strcmp (result, "-0.000000e+00 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2330 || strcmp (result, "-0.000000e+000 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2331 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2332 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2333 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2334 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2335 { /* Positive infinity. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2336 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2337 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
2338 my_asnprintf (NULL, &length, "%Le %d", Infinityl (), 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2339 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2340 ASSERT (strcmp (result, "inf 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2341 || strcmp (result, "infinity 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2342 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2343 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2344 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2345 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2346 { /* Negative infinity. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2347 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2348 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
2349 my_asnprintf (NULL, &length, "%Le %d", - Infinityl (), 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2350 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2351 ASSERT (strcmp (result, "-inf 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2352 || strcmp (result, "-infinity 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2353 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2354 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2355 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2356 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2357 { /* NaN. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2358 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2359 char *result = |
9854
baba3b346ab2
Use macros NaNf, NaNd, NaNl instead of NAN.
Bruno Haible <bruno@clisp.org>
parents:
9850
diff
changeset
|
2360 my_asnprintf (NULL, &length, "%Le %d", NaNl (), 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2361 ASSERT (result != NULL); |
8850
d1fe16dfbfee
Avoid test failures on IRIX 6.5.
Bruno Haible <bruno@clisp.org>
parents:
8839
diff
changeset
|
2362 ASSERT (strlen (result) >= 3 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2363 && strisnan (result, 0, strlen (result) - 3, 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2364 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2365 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2366 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2367 } |
15906
400649d35651
*printf-posix tests: Fix for platforms where 'long double' == 'double'.
Bruno Haible <bruno@clisp.org>
parents:
15595
diff
changeset
|
2368 #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 |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2369 { /* Quiet NaN. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2370 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2371 { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2372 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2373 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2374 my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2375 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2376 ASSERT (length == strlen (result)); |
17928
dd6f9e7b674a
vasnprintf-posix-tests: use consistent test
Paul Eggert <eggert@cs.ucla.edu>
parents:
17927
diff
changeset
|
2377 ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2378 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2379 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2380 { |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2381 /* Signalling NaN. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2382 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2383 { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2384 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2385 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2386 my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2387 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2388 ASSERT (length == strlen (result)); |
17928
dd6f9e7b674a
vasnprintf-posix-tests: use consistent test
Paul Eggert <eggert@cs.ucla.edu>
parents:
17927
diff
changeset
|
2389 ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2390 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2391 } |
17927
b941bb9e9efb
printf, isinf, etc.: noncanonical != NaN
Paul Eggert <eggert@cs.ucla.edu>
parents:
17848
diff
changeset
|
2392 /* asnprintf should print something even for noncanonical values. */ |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2393 { /* Pseudo-NaN. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2394 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2395 { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2396 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2397 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2398 my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2399 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2400 ASSERT (length == strlen (result)); |
17928
dd6f9e7b674a
vasnprintf-posix-tests: use consistent test
Paul Eggert <eggert@cs.ucla.edu>
parents:
17927
diff
changeset
|
2401 ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2402 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2403 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2404 { /* Pseudo-Infinity. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2405 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2406 { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2407 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2408 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2409 my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2410 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2411 ASSERT (length == strlen (result)); |
17928
dd6f9e7b674a
vasnprintf-posix-tests: use consistent test
Paul Eggert <eggert@cs.ucla.edu>
parents:
17927
diff
changeset
|
2412 ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2413 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2414 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2415 { /* Pseudo-Zero. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2416 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2417 { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2418 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2419 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2420 my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2421 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2422 ASSERT (length == strlen (result)); |
17928
dd6f9e7b674a
vasnprintf-posix-tests: use consistent test
Paul Eggert <eggert@cs.ucla.edu>
parents:
17927
diff
changeset
|
2423 ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2424 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2425 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2426 { /* Unnormalized number. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2427 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2428 { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2429 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2430 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2431 my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2432 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2433 ASSERT (length == strlen (result)); |
17928
dd6f9e7b674a
vasnprintf-posix-tests: use consistent test
Paul Eggert <eggert@cs.ucla.edu>
parents:
17927
diff
changeset
|
2434 ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2435 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2436 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2437 { /* Pseudo-Denormal. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2438 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2439 { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2440 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2441 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2442 my_asnprintf (NULL, &length, "%Le %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2443 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2444 ASSERT (length == strlen (result)); |
17928
dd6f9e7b674a
vasnprintf-posix-tests: use consistent test
Paul Eggert <eggert@cs.ucla.edu>
parents:
17927
diff
changeset
|
2445 ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2446 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2447 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
2448 #endif |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2449 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2450 { /* Width. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2451 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2452 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2453 my_asnprintf (NULL, &length, "%15Le %d", 1.75L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2454 ASSERT (result != NULL); |
10458
1cc9cffb9615
Allow 3-digit exponents in %e and %g results on 'long double'.
Bruno Haible <bruno@clisp.org>
parents:
10394
diff
changeset
|
2455 ASSERT (strcmp (result, " 1.750000e+00 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2456 || strcmp (result, " 1.750000e+000 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2457 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2458 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2459 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2460 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2461 { /* FLAG_LEFT. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2462 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2463 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2464 my_asnprintf (NULL, &length, "%-15Le %d", 1.75L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2465 ASSERT (result != NULL); |
10458
1cc9cffb9615
Allow 3-digit exponents in %e and %g results on 'long double'.
Bruno Haible <bruno@clisp.org>
parents:
10394
diff
changeset
|
2466 ASSERT (strcmp (result, "1.750000e+00 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2467 || strcmp (result, "1.750000e+000 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2468 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2469 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2470 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2471 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2472 { /* FLAG_SHOWSIGN. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2473 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2474 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2475 my_asnprintf (NULL, &length, "%+Le %d", 1.75L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2476 ASSERT (result != NULL); |
10458
1cc9cffb9615
Allow 3-digit exponents in %e and %g results on 'long double'.
Bruno Haible <bruno@clisp.org>
parents:
10394
diff
changeset
|
2477 ASSERT (strcmp (result, "+1.750000e+00 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2478 || strcmp (result, "+1.750000e+000 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2479 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2480 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2481 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2482 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2483 { /* FLAG_SPACE. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2484 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2485 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2486 my_asnprintf (NULL, &length, "% Le %d", 1.75L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2487 ASSERT (result != NULL); |
10458
1cc9cffb9615
Allow 3-digit exponents in %e and %g results on 'long double'.
Bruno Haible <bruno@clisp.org>
parents:
10394
diff
changeset
|
2488 ASSERT (strcmp (result, " 1.750000e+00 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2489 || strcmp (result, " 1.750000e+000 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2490 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2491 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2492 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2493 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2494 { /* FLAG_ALT. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2495 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2496 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2497 my_asnprintf (NULL, &length, "%#Le %d", 1.75L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2498 ASSERT (result != NULL); |
10458
1cc9cffb9615
Allow 3-digit exponents in %e and %g results on 'long double'.
Bruno Haible <bruno@clisp.org>
parents:
10394
diff
changeset
|
2499 ASSERT (strcmp (result, "1.750000e+00 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2500 || strcmp (result, "1.750000e+000 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2501 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2502 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2503 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2504 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2505 { /* FLAG_ALT. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2506 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2507 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2508 my_asnprintf (NULL, &length, "%#.Le %d", 1.75L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2509 ASSERT (result != NULL); |
10458
1cc9cffb9615
Allow 3-digit exponents in %e and %g results on 'long double'.
Bruno Haible <bruno@clisp.org>
parents:
10394
diff
changeset
|
2510 ASSERT (strcmp (result, "2.e+00 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2511 || strcmp (result, "2.e+000 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2512 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2513 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2514 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2515 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2516 { /* FLAG_ALT. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2517 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2518 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2519 my_asnprintf (NULL, &length, "%#.Le %d", 9.75L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2520 ASSERT (result != NULL); |
10458
1cc9cffb9615
Allow 3-digit exponents in %e and %g results on 'long double'.
Bruno Haible <bruno@clisp.org>
parents:
10394
diff
changeset
|
2521 ASSERT (strcmp (result, "1.e+01 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2522 || strcmp (result, "1.e+001 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2523 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2524 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2525 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2526 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2527 { /* FLAG_ZERO with finite number. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2528 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2529 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2530 my_asnprintf (NULL, &length, "%015Le %d", 1234.0L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2531 ASSERT (result != NULL); |
10458
1cc9cffb9615
Allow 3-digit exponents in %e and %g results on 'long double'.
Bruno Haible <bruno@clisp.org>
parents:
10394
diff
changeset
|
2532 ASSERT (strcmp (result, "0001.234000e+03 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2533 || strcmp (result, "001.234000e+003 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2534 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2535 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2536 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2537 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2538 { /* FLAG_ZERO with infinite number. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2539 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2540 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
2541 my_asnprintf (NULL, &length, "%015Le %d", - Infinityl (), 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2542 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2543 ASSERT (strcmp (result, " -inf 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2544 || strcmp (result, " -infinity 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2545 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2546 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2547 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2548 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2549 { /* FLAG_ZERO with NaN. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2550 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2551 char *result = |
9854
baba3b346ab2
Use macros NaNf, NaNd, NaNl instead of NAN.
Bruno Haible <bruno@clisp.org>
parents:
9850
diff
changeset
|
2552 my_asnprintf (NULL, &length, "%050Le %d", NaNl (), 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2553 ASSERT (result != NULL); |
8870
4e1f2ea486b4
Allow for a longer printed representation of NaN.
Bruno Haible <bruno@clisp.org>
parents:
8865
diff
changeset
|
2554 ASSERT (strlen (result) == 50 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2555 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2556 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2557 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2558 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2559 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2560 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2561 { /* Precision. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2562 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2563 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2564 my_asnprintf (NULL, &length, "%.Le %d", 1234.0L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2565 ASSERT (result != NULL); |
10458
1cc9cffb9615
Allow 3-digit exponents in %e and %g results on 'long double'.
Bruno Haible <bruno@clisp.org>
parents:
10394
diff
changeset
|
2566 ASSERT (strcmp (result, "1e+03 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2567 || strcmp (result, "1e+003 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2568 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2569 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2570 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2571 |
9938
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2572 { /* Precision with no rounding. */ |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2573 size_t length; |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2574 char *result = |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2575 my_asnprintf (NULL, &length, "%.4Le %d", 999.951L, 33, 44, 55); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2576 ASSERT (result != NULL); |
10458
1cc9cffb9615
Allow 3-digit exponents in %e and %g results on 'long double'.
Bruno Haible <bruno@clisp.org>
parents:
10394
diff
changeset
|
2577 ASSERT (strcmp (result, "9.9995e+02 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2578 || strcmp (result, "9.9995e+002 33") == 0); |
9938
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2579 ASSERT (length == strlen (result)); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2580 free (result); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2581 } |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2582 |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2583 { /* Precision with rounding. */ |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2584 size_t length; |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2585 char *result = |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2586 my_asnprintf (NULL, &length, "%.4Le %d", 999.996L, 33, 44, 55); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2587 ASSERT (result != NULL); |
10458
1cc9cffb9615
Allow 3-digit exponents in %e and %g results on 'long double'.
Bruno Haible <bruno@clisp.org>
parents:
10394
diff
changeset
|
2588 ASSERT (strcmp (result, "1.0000e+03 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2589 || strcmp (result, "1.0000e+003 33") == 0); |
9938
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2590 ASSERT (length == strlen (result)); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2591 free (result); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2592 } |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2593 |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2594 /* Test the support of the %g format directive. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2595 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2596 { /* A positive number. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2597 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2598 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2599 my_asnprintf (NULL, &length, "%g %d", 12.75, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2600 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2601 ASSERT (strcmp (result, "12.75 33") == 0); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2602 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2603 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2604 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2605 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2606 { /* A larger positive number. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2607 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2608 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2609 my_asnprintf (NULL, &length, "%g %d", 1234567.0, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2610 ASSERT (result != NULL); |
8839
5efc1d668039
Accomodate for implementations that produce 3 exponent digits in %e and %g.
Bruno Haible <bruno@clisp.org>
parents:
8836
diff
changeset
|
2611 ASSERT (strcmp (result, "1.23457e+06 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2612 || strcmp (result, "1.23457e+006 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2613 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2614 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2615 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2616 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2617 { /* Small and large positive numbers. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2618 static struct { double value; const char *string; } data[] = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2619 { |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2620 { 1.234321234321234e-37, "1.23432e-37" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2621 { 1.234321234321234e-36, "1.23432e-36" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2622 { 1.234321234321234e-35, "1.23432e-35" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2623 { 1.234321234321234e-34, "1.23432e-34" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2624 { 1.234321234321234e-33, "1.23432e-33" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2625 { 1.234321234321234e-32, "1.23432e-32" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2626 { 1.234321234321234e-31, "1.23432e-31" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2627 { 1.234321234321234e-30, "1.23432e-30" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2628 { 1.234321234321234e-29, "1.23432e-29" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2629 { 1.234321234321234e-28, "1.23432e-28" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2630 { 1.234321234321234e-27, "1.23432e-27" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2631 { 1.234321234321234e-26, "1.23432e-26" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2632 { 1.234321234321234e-25, "1.23432e-25" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2633 { 1.234321234321234e-24, "1.23432e-24" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2634 { 1.234321234321234e-23, "1.23432e-23" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2635 { 1.234321234321234e-22, "1.23432e-22" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2636 { 1.234321234321234e-21, "1.23432e-21" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2637 { 1.234321234321234e-20, "1.23432e-20" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2638 { 1.234321234321234e-19, "1.23432e-19" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2639 { 1.234321234321234e-18, "1.23432e-18" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2640 { 1.234321234321234e-17, "1.23432e-17" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2641 { 1.234321234321234e-16, "1.23432e-16" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2642 { 1.234321234321234e-15, "1.23432e-15" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2643 { 1.234321234321234e-14, "1.23432e-14" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2644 { 1.234321234321234e-13, "1.23432e-13" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2645 { 1.234321234321234e-12, "1.23432e-12" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2646 { 1.234321234321234e-11, "1.23432e-11" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2647 { 1.234321234321234e-10, "1.23432e-10" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2648 { 1.234321234321234e-9, "1.23432e-09" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2649 { 1.234321234321234e-8, "1.23432e-08" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2650 { 1.234321234321234e-7, "1.23432e-07" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2651 { 1.234321234321234e-6, "1.23432e-06" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2652 { 1.234321234321234e-5, "1.23432e-05" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2653 { 1.234321234321234e-4, "0.000123432" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2654 { 1.234321234321234e-3, "0.00123432" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2655 { 1.234321234321234e-2, "0.0123432" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2656 { 1.234321234321234e-1, "0.123432" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2657 { 1.234321234321234, "1.23432" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2658 { 1.234321234321234e1, "12.3432" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2659 { 1.234321234321234e2, "123.432" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2660 { 1.234321234321234e3, "1234.32" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2661 { 1.234321234321234e4, "12343.2" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2662 { 1.234321234321234e5, "123432" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2663 { 1.234321234321234e6, "1.23432e+06" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2664 { 1.234321234321234e7, "1.23432e+07" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2665 { 1.234321234321234e8, "1.23432e+08" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2666 { 1.234321234321234e9, "1.23432e+09" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2667 { 1.234321234321234e10, "1.23432e+10" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2668 { 1.234321234321234e11, "1.23432e+11" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2669 { 1.234321234321234e12, "1.23432e+12" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2670 { 1.234321234321234e13, "1.23432e+13" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2671 { 1.234321234321234e14, "1.23432e+14" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2672 { 1.234321234321234e15, "1.23432e+15" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2673 { 1.234321234321234e16, "1.23432e+16" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2674 { 1.234321234321234e17, "1.23432e+17" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2675 { 1.234321234321234e18, "1.23432e+18" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2676 { 1.234321234321234e19, "1.23432e+19" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2677 { 1.234321234321234e20, "1.23432e+20" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2678 { 1.234321234321234e21, "1.23432e+21" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2679 { 1.234321234321234e22, "1.23432e+22" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2680 { 1.234321234321234e23, "1.23432e+23" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2681 { 1.234321234321234e24, "1.23432e+24" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2682 { 1.234321234321234e25, "1.23432e+25" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2683 { 1.234321234321234e26, "1.23432e+26" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2684 { 1.234321234321234e27, "1.23432e+27" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2685 { 1.234321234321234e28, "1.23432e+28" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2686 { 1.234321234321234e29, "1.23432e+29" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2687 { 1.234321234321234e30, "1.23432e+30" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2688 { 1.234321234321234e31, "1.23432e+31" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2689 { 1.234321234321234e32, "1.23432e+32" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2690 { 1.234321234321234e33, "1.23432e+33" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2691 { 1.234321234321234e34, "1.23432e+34" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2692 { 1.234321234321234e35, "1.23432e+35" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2693 { 1.234321234321234e36, "1.23432e+36" } |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2694 }; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2695 size_t k; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2696 for (k = 0; k < SIZEOF (data); k++) |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2697 { |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2698 size_t length; |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2699 char *result = |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2700 my_asnprintf (NULL, &length, "%g", data[k].value); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2701 const char *expected = data[k].string; |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2702 ASSERT (result != NULL); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2703 ASSERT (strcmp (result, expected) == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2704 /* Some implementations produce exponents with 3 digits. */ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2705 || (expected[strlen (expected) - 4] == 'e' |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2706 && strlen (result) == strlen (expected) + 1 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2707 && memcmp (result, expected, strlen (expected) - 2) == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2708 && result[strlen (expected) - 2] == '0' |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2709 && strcmp (result + strlen (expected) - 1, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2710 expected + strlen (expected) - 2) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2711 == 0)); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2712 ASSERT (length == strlen (result)); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2713 free (result); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2714 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2715 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2716 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2717 { /* A negative number. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2718 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2719 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2720 my_asnprintf (NULL, &length, "%g %d", -0.03125, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2721 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2722 ASSERT (strcmp (result, "-0.03125 33") == 0); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2723 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2724 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2725 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2726 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2727 { /* Positive zero. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2728 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2729 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2730 my_asnprintf (NULL, &length, "%g %d", 0.0, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2731 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2732 ASSERT (strcmp (result, "0 33") == 0); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2733 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2734 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2735 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2736 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2737 { /* Negative zero. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2738 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2739 char *result = |
13834
108bbfd6f03b
frexp, tests: work around ICC bug with -zero
Eric Blake <eblake@redhat.com>
parents:
13200
diff
changeset
|
2740 my_asnprintf (NULL, &length, "%g %d", minus_zerod, 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2741 ASSERT (result != NULL); |
8852
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
2742 if (have_minus_zero ()) |
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
2743 ASSERT (strcmp (result, "-0 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2744 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2745 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2746 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2747 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2748 { /* Positive infinity. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2749 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2750 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
2751 my_asnprintf (NULL, &length, "%g %d", Infinityd (), 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2752 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2753 ASSERT (strcmp (result, "inf 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2754 || strcmp (result, "infinity 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2755 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2756 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2757 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2758 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2759 { /* Negative infinity. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2760 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2761 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
2762 my_asnprintf (NULL, &length, "%g %d", - Infinityd (), 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2763 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2764 ASSERT (strcmp (result, "-inf 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2765 || strcmp (result, "-infinity 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2766 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2767 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2768 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2769 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2770 { /* NaN. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2771 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2772 char *result = |
9854
baba3b346ab2
Use macros NaNf, NaNd, NaNl instead of NAN.
Bruno Haible <bruno@clisp.org>
parents:
9850
diff
changeset
|
2773 my_asnprintf (NULL, &length, "%g %d", NaNd (), 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2774 ASSERT (result != NULL); |
8850
d1fe16dfbfee
Avoid test failures on IRIX 6.5.
Bruno Haible <bruno@clisp.org>
parents:
8839
diff
changeset
|
2775 ASSERT (strlen (result) >= 3 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2776 && strisnan (result, 0, strlen (result) - 3, 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2777 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2778 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2779 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2780 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2781 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2782 { /* Width. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2783 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2784 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2785 my_asnprintf (NULL, &length, "%10g %d", 1.75, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2786 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2787 ASSERT (strcmp (result, " 1.75 33") == 0); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2788 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2789 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2790 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2791 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2792 { /* FLAG_LEFT. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2793 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2794 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2795 my_asnprintf (NULL, &length, "%-10g %d", 1.75, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2796 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2797 ASSERT (strcmp (result, "1.75 33") == 0); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2798 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2799 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2800 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2801 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2802 { /* FLAG_SHOWSIGN. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2803 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2804 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2805 my_asnprintf (NULL, &length, "%+g %d", 1.75, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2806 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2807 ASSERT (strcmp (result, "+1.75 33") == 0); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2808 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2809 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2810 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2811 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2812 { /* FLAG_SPACE. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2813 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2814 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2815 my_asnprintf (NULL, &length, "% g %d", 1.75, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2816 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2817 ASSERT (strcmp (result, " 1.75 33") == 0); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2818 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2819 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2820 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2821 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2822 { /* FLAG_ALT. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2823 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2824 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2825 my_asnprintf (NULL, &length, "%#g %d", 1.75, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2826 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2827 ASSERT (strcmp (result, "1.75000 33") == 0); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2828 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2829 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2830 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2831 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2832 { /* FLAG_ALT. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2833 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2834 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2835 my_asnprintf (NULL, &length, "%#.g %d", 1.75, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2836 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2837 ASSERT (strcmp (result, "2. 33") == 0); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2838 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2839 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2840 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2841 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2842 { /* FLAG_ALT. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2843 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2844 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2845 my_asnprintf (NULL, &length, "%#.g %d", 9.75, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2846 ASSERT (result != NULL); |
8839
5efc1d668039
Accomodate for implementations that produce 3 exponent digits in %e and %g.
Bruno Haible <bruno@clisp.org>
parents:
8836
diff
changeset
|
2847 ASSERT (strcmp (result, "1.e+01 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2848 || strcmp (result, "1.e+001 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2849 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2850 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2851 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2852 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2853 { /* FLAG_ZERO with finite number. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2854 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2855 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2856 my_asnprintf (NULL, &length, "%010g %d", 1234.0, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2857 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2858 ASSERT (strcmp (result, "0000001234 33") == 0); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2859 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2860 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2861 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2862 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2863 { /* FLAG_ZERO with infinite number. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2864 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2865 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
2866 my_asnprintf (NULL, &length, "%015g %d", - Infinityd (), 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2867 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2868 ASSERT (strcmp (result, " -inf 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2869 || strcmp (result, " -infinity 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2870 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2871 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2872 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2873 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2874 { /* FLAG_ZERO with NaN. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2875 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2876 char *result = |
9854
baba3b346ab2
Use macros NaNf, NaNd, NaNl instead of NAN.
Bruno Haible <bruno@clisp.org>
parents:
9850
diff
changeset
|
2877 my_asnprintf (NULL, &length, "%050g %d", NaNd (), 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2878 ASSERT (result != NULL); |
8870
4e1f2ea486b4
Allow for a longer printed representation of NaN.
Bruno Haible <bruno@clisp.org>
parents:
8865
diff
changeset
|
2879 ASSERT (strlen (result) == 50 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2880 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2881 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2882 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2883 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2884 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2885 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2886 { /* Precision. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2887 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2888 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2889 my_asnprintf (NULL, &length, "%.g %d", 1234.0, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2890 ASSERT (result != NULL); |
8839
5efc1d668039
Accomodate for implementations that produce 3 exponent digits in %e and %g.
Bruno Haible <bruno@clisp.org>
parents:
8836
diff
changeset
|
2891 ASSERT (strcmp (result, "1e+03 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2892 || strcmp (result, "1e+003 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2893 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2894 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2895 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2896 |
9938
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2897 { /* Precision with no rounding. */ |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2898 size_t length; |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2899 char *result = |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2900 my_asnprintf (NULL, &length, "%.5g %d", 999.951, 33, 44, 55); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2901 ASSERT (result != NULL); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2902 ASSERT (strcmp (result, "999.95 33") == 0); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2903 ASSERT (length == strlen (result)); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2904 free (result); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2905 } |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2906 |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2907 { /* Precision with rounding. */ |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2908 size_t length; |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2909 char *result = |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2910 my_asnprintf (NULL, &length, "%.5g %d", 999.996, 33, 44, 55); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2911 ASSERT (result != NULL); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2912 ASSERT (strcmp (result, "1000 33") == 0); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2913 ASSERT (length == strlen (result)); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2914 free (result); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2915 } |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
2916 |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2917 { /* A positive number. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2918 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2919 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2920 my_asnprintf (NULL, &length, "%Lg %d", 12.75L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2921 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2922 ASSERT (strcmp (result, "12.75 33") == 0); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2923 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2924 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2925 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2926 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2927 { /* A larger positive number. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2928 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2929 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2930 my_asnprintf (NULL, &length, "%Lg %d", 1234567.0L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2931 ASSERT (result != NULL); |
10458
1cc9cffb9615
Allow 3-digit exponents in %e and %g results on 'long double'.
Bruno Haible <bruno@clisp.org>
parents:
10394
diff
changeset
|
2932 ASSERT (strcmp (result, "1.23457e+06 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2933 || strcmp (result, "1.23457e+006 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2934 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2935 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2936 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2937 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2938 { /* Small and large positive numbers. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2939 static struct { long double value; const char *string; } data[] = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
2940 { |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2941 { 1.234321234321234e-37L, "1.23432e-37" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2942 { 1.234321234321234e-36L, "1.23432e-36" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2943 { 1.234321234321234e-35L, "1.23432e-35" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2944 { 1.234321234321234e-34L, "1.23432e-34" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2945 { 1.234321234321234e-33L, "1.23432e-33" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2946 { 1.234321234321234e-32L, "1.23432e-32" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2947 { 1.234321234321234e-31L, "1.23432e-31" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2948 { 1.234321234321234e-30L, "1.23432e-30" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2949 { 1.234321234321234e-29L, "1.23432e-29" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2950 { 1.234321234321234e-28L, "1.23432e-28" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2951 { 1.234321234321234e-27L, "1.23432e-27" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2952 { 1.234321234321234e-26L, "1.23432e-26" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2953 { 1.234321234321234e-25L, "1.23432e-25" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2954 { 1.234321234321234e-24L, "1.23432e-24" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2955 { 1.234321234321234e-23L, "1.23432e-23" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2956 { 1.234321234321234e-22L, "1.23432e-22" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2957 { 1.234321234321234e-21L, "1.23432e-21" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2958 { 1.234321234321234e-20L, "1.23432e-20" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2959 { 1.234321234321234e-19L, "1.23432e-19" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2960 { 1.234321234321234e-18L, "1.23432e-18" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2961 { 1.234321234321234e-17L, "1.23432e-17" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2962 { 1.234321234321234e-16L, "1.23432e-16" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2963 { 1.234321234321234e-15L, "1.23432e-15" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2964 { 1.234321234321234e-14L, "1.23432e-14" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2965 { 1.234321234321234e-13L, "1.23432e-13" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2966 { 1.234321234321234e-12L, "1.23432e-12" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2967 { 1.234321234321234e-11L, "1.23432e-11" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2968 { 1.234321234321234e-10L, "1.23432e-10" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2969 { 1.234321234321234e-9L, "1.23432e-09" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2970 { 1.234321234321234e-8L, "1.23432e-08" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2971 { 1.234321234321234e-7L, "1.23432e-07" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2972 { 1.234321234321234e-6L, "1.23432e-06" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2973 { 1.234321234321234e-5L, "1.23432e-05" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2974 { 1.234321234321234e-4L, "0.000123432" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2975 { 1.234321234321234e-3L, "0.00123432" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2976 { 1.234321234321234e-2L, "0.0123432" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2977 { 1.234321234321234e-1L, "0.123432" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2978 { 1.234321234321234L, "1.23432" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2979 { 1.234321234321234e1L, "12.3432" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2980 { 1.234321234321234e2L, "123.432" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2981 { 1.234321234321234e3L, "1234.32" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2982 { 1.234321234321234e4L, "12343.2" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2983 { 1.234321234321234e5L, "123432" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2984 { 1.234321234321234e6L, "1.23432e+06" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2985 { 1.234321234321234e7L, "1.23432e+07" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2986 { 1.234321234321234e8L, "1.23432e+08" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2987 { 1.234321234321234e9L, "1.23432e+09" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2988 { 1.234321234321234e10L, "1.23432e+10" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2989 { 1.234321234321234e11L, "1.23432e+11" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2990 { 1.234321234321234e12L, "1.23432e+12" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2991 { 1.234321234321234e13L, "1.23432e+13" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2992 { 1.234321234321234e14L, "1.23432e+14" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2993 { 1.234321234321234e15L, "1.23432e+15" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2994 { 1.234321234321234e16L, "1.23432e+16" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2995 { 1.234321234321234e17L, "1.23432e+17" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2996 { 1.234321234321234e18L, "1.23432e+18" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2997 { 1.234321234321234e19L, "1.23432e+19" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2998 { 1.234321234321234e20L, "1.23432e+20" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
2999 { 1.234321234321234e21L, "1.23432e+21" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3000 { 1.234321234321234e22L, "1.23432e+22" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3001 { 1.234321234321234e23L, "1.23432e+23" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3002 { 1.234321234321234e24L, "1.23432e+24" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3003 { 1.234321234321234e25L, "1.23432e+25" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3004 { 1.234321234321234e26L, "1.23432e+26" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3005 { 1.234321234321234e27L, "1.23432e+27" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3006 { 1.234321234321234e28L, "1.23432e+28" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3007 { 1.234321234321234e29L, "1.23432e+29" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3008 { 1.234321234321234e30L, "1.23432e+30" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3009 { 1.234321234321234e31L, "1.23432e+31" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3010 { 1.234321234321234e32L, "1.23432e+32" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3011 { 1.234321234321234e33L, "1.23432e+33" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3012 { 1.234321234321234e34L, "1.23432e+34" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3013 { 1.234321234321234e35L, "1.23432e+35" }, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3014 { 1.234321234321234e36L, "1.23432e+36" } |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3015 }; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3016 size_t k; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3017 for (k = 0; k < SIZEOF (data); k++) |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3018 { |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3019 size_t length; |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3020 char *result = |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3021 my_asnprintf (NULL, &length, "%Lg", data[k].value); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3022 const char *expected = data[k].string; |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3023 ASSERT (result != NULL); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3024 ASSERT (strcmp (result, expected) == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3025 /* Some implementations produce exponents with 3 digits. */ |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3026 || (expected[strlen (expected) - 4] == 'e' |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3027 && strlen (result) == strlen (expected) + 1 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3028 && memcmp (result, expected, strlen (expected) - 2) == 0 |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3029 && result[strlen (expected) - 2] == '0' |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3030 && strcmp (result + strlen (expected) - 1, |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3031 expected + strlen (expected) - 2) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3032 == 0)); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3033 ASSERT (length == strlen (result)); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3034 free (result); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3035 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3036 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3037 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3038 { /* A negative number. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3039 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3040 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3041 my_asnprintf (NULL, &length, "%Lg %d", -0.03125L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3042 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3043 ASSERT (strcmp (result, "-0.03125 33") == 0); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3044 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3045 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3046 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3047 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3048 { /* Positive zero. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3049 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3050 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3051 my_asnprintf (NULL, &length, "%Lg %d", 0.0L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3052 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3053 ASSERT (strcmp (result, "0 33") == 0); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3054 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3055 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3056 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3057 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3058 { /* Negative zero. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3059 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3060 char *result = |
10601
ca053fa79cd3
Use a more portable replacement expression for -0.0L.
Bruno Haible <bruno@clisp.org>
parents:
10458
diff
changeset
|
3061 my_asnprintf (NULL, &length, "%Lg %d", minus_zerol, 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3062 ASSERT (result != NULL); |
8852
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
3063 if (have_minus_zero ()) |
df0b5e8ea770
Avoid test failures on platforms where -0.0 and 0.0 are identical.
Bruno Haible <bruno@clisp.org>
parents:
8850
diff
changeset
|
3064 ASSERT (strcmp (result, "-0 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3065 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3066 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3067 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3068 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3069 { /* Positive infinity. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3070 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3071 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
3072 my_asnprintf (NULL, &length, "%Lg %d", Infinityl (), 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3073 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3074 ASSERT (strcmp (result, "inf 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3075 || strcmp (result, "infinity 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3076 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3077 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3078 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3079 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3080 { /* Negative infinity. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3081 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3082 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
3083 my_asnprintf (NULL, &length, "%Lg %d", - Infinityl (), 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3084 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3085 ASSERT (strcmp (result, "-inf 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3086 || strcmp (result, "-infinity 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3087 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3088 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3089 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3090 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3091 { /* NaN. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3092 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3093 char *result = |
9854
baba3b346ab2
Use macros NaNf, NaNd, NaNl instead of NAN.
Bruno Haible <bruno@clisp.org>
parents:
9850
diff
changeset
|
3094 my_asnprintf (NULL, &length, "%Lg %d", NaNl (), 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3095 ASSERT (result != NULL); |
8850
d1fe16dfbfee
Avoid test failures on IRIX 6.5.
Bruno Haible <bruno@clisp.org>
parents:
8839
diff
changeset
|
3096 ASSERT (strlen (result) >= 3 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3097 && strisnan (result, 0, strlen (result) - 3, 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3098 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3099 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3100 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3101 } |
15906
400649d35651
*printf-posix tests: Fix for platforms where 'long double' == 'double'.
Bruno Haible <bruno@clisp.org>
parents:
15595
diff
changeset
|
3102 #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 |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3103 { /* Quiet NaN. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3104 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3105 { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3106 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3107 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3108 my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3109 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3110 ASSERT (strlen (result) >= 3 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3111 && strisnan (result, 0, strlen (result) - 3, 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3112 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3113 ASSERT (length == strlen (result)); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3114 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3115 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3116 { |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3117 /* Signalling NaN. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3118 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3119 { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3120 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3121 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3122 my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3123 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3124 ASSERT (strlen (result) >= 3 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3125 && strisnan (result, 0, strlen (result) - 3, 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3126 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3127 ASSERT (length == strlen (result)); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3128 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3129 } |
17927
b941bb9e9efb
printf, isinf, etc.: noncanonical != NaN
Paul Eggert <eggert@cs.ucla.edu>
parents:
17848
diff
changeset
|
3130 /* asnprintf should print something for noncanonical values. */ |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3131 { /* Pseudo-NaN. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3132 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3133 { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3134 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3135 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3136 my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3137 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3138 ASSERT (length == strlen (result)); |
17927
b941bb9e9efb
printf, isinf, etc.: noncanonical != NaN
Paul Eggert <eggert@cs.ucla.edu>
parents:
17848
diff
changeset
|
3139 ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3140 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3141 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3142 { /* Pseudo-Infinity. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3143 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3144 { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3145 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3146 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3147 my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3148 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3149 ASSERT (length == strlen (result)); |
17927
b941bb9e9efb
printf, isinf, etc.: noncanonical != NaN
Paul Eggert <eggert@cs.ucla.edu>
parents:
17848
diff
changeset
|
3150 ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3151 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3152 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3153 { /* Pseudo-Zero. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3154 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3155 { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3156 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3157 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3158 my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3159 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3160 ASSERT (length == strlen (result)); |
17927
b941bb9e9efb
printf, isinf, etc.: noncanonical != NaN
Paul Eggert <eggert@cs.ucla.edu>
parents:
17848
diff
changeset
|
3161 ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3162 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3163 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3164 { /* Unnormalized number. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3165 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3166 { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3167 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3168 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3169 my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3170 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3171 ASSERT (length == strlen (result)); |
17927
b941bb9e9efb
printf, isinf, etc.: noncanonical != NaN
Paul Eggert <eggert@cs.ucla.edu>
parents:
17848
diff
changeset
|
3172 ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3173 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3174 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3175 { /* Pseudo-Denormal. */ |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3176 static union { unsigned int word[4]; long double value; } x = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3177 { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) }; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3178 size_t length; |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3179 char *result = |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3180 my_asnprintf (NULL, &length, "%Lg %d", x.value, 33, 44, 55); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3181 ASSERT (result != NULL); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3182 ASSERT (length == strlen (result)); |
17927
b941bb9e9efb
printf, isinf, etc.: noncanonical != NaN
Paul Eggert <eggert@cs.ucla.edu>
parents:
17848
diff
changeset
|
3183 ASSERT (3 < length && strcmp (result + length - 3, " 33") == 0); |
8919
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3184 free (result); |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3185 } |
42e2847583f9
Fix *printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64.
Bruno Haible <bruno@clisp.org>
parents:
8891
diff
changeset
|
3186 #endif |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3187 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3188 { /* Width. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3189 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3190 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3191 my_asnprintf (NULL, &length, "%10Lg %d", 1.75L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3192 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3193 ASSERT (strcmp (result, " 1.75 33") == 0); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3194 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3195 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3196 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3197 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3198 { /* FLAG_LEFT. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3199 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3200 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3201 my_asnprintf (NULL, &length, "%-10Lg %d", 1.75L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3202 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3203 ASSERT (strcmp (result, "1.75 33") == 0); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3204 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3205 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3206 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3207 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3208 { /* FLAG_SHOWSIGN. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3209 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3210 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3211 my_asnprintf (NULL, &length, "%+Lg %d", 1.75L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3212 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3213 ASSERT (strcmp (result, "+1.75 33") == 0); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3214 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3215 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3216 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3217 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3218 { /* FLAG_SPACE. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3219 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3220 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3221 my_asnprintf (NULL, &length, "% Lg %d", 1.75L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3222 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3223 ASSERT (strcmp (result, " 1.75 33") == 0); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3224 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3225 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3226 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3227 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3228 { /* FLAG_ALT. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3229 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3230 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3231 my_asnprintf (NULL, &length, "%#Lg %d", 1.75L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3232 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3233 ASSERT (strcmp (result, "1.75000 33") == 0); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3234 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3235 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3236 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3237 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3238 { /* FLAG_ALT. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3239 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3240 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3241 my_asnprintf (NULL, &length, "%#.Lg %d", 1.75L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3242 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3243 ASSERT (strcmp (result, "2. 33") == 0); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3244 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3245 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3246 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3247 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3248 { /* FLAG_ALT. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3249 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3250 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3251 my_asnprintf (NULL, &length, "%#.Lg %d", 9.75L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3252 ASSERT (result != NULL); |
10458
1cc9cffb9615
Allow 3-digit exponents in %e and %g results on 'long double'.
Bruno Haible <bruno@clisp.org>
parents:
10394
diff
changeset
|
3253 ASSERT (strcmp (result, "1.e+01 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3254 || strcmp (result, "1.e+001 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3255 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3256 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3257 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3258 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3259 { /* FLAG_ZERO with finite number. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3260 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3261 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3262 my_asnprintf (NULL, &length, "%010Lg %d", 1234.0L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3263 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3264 ASSERT (strcmp (result, "0000001234 33") == 0); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3265 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3266 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3267 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3268 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3269 { /* FLAG_ZERO with infinite number. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3270 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3271 char *result = |
15595
328819af1c02
Support for MSVC compiler: Avoid division by a literal 0.
Bruno Haible <bruno@clisp.org>
parents:
14079
diff
changeset
|
3272 my_asnprintf (NULL, &length, "%015Lg %d", - Infinityl (), 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3273 ASSERT (result != NULL); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3274 ASSERT (strcmp (result, " -inf 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3275 || strcmp (result, " -infinity 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3276 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3277 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3278 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3279 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3280 { /* FLAG_ZERO with NaN. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3281 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3282 char *result = |
9854
baba3b346ab2
Use macros NaNf, NaNd, NaNl instead of NAN.
Bruno Haible <bruno@clisp.org>
parents:
9850
diff
changeset
|
3283 my_asnprintf (NULL, &length, "%050Lg %d", NaNl (), 33, 44, 55); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3284 ASSERT (result != NULL); |
8870
4e1f2ea486b4
Allow for a longer printed representation of NaN.
Bruno Haible <bruno@clisp.org>
parents:
8865
diff
changeset
|
3285 ASSERT (strlen (result) == 50 + 3 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3286 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3287 && strcmp (result + strlen (result) - 3, " 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3288 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3289 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3290 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3291 |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3292 { /* Precision. */ |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3293 size_t length; |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3294 char *result = |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3295 my_asnprintf (NULL, &length, "%.Lg %d", 1234.0L, 33, 44, 55); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3296 ASSERT (result != NULL); |
10458
1cc9cffb9615
Allow 3-digit exponents in %e and %g results on 'long double'.
Bruno Haible <bruno@clisp.org>
parents:
10394
diff
changeset
|
3297 ASSERT (strcmp (result, "1e+03 33") == 0 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3298 || strcmp (result, "1e+003 33") == 0); |
8836
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3299 ASSERT (length == strlen (result)); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3300 free (result); |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3301 } |
07084ab003b8
Add tests for %e and %g directives.
Bruno Haible <bruno@clisp.org>
parents:
8834
diff
changeset
|
3302 |
9938
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
3303 { /* Precision with no rounding. */ |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
3304 size_t length; |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
3305 char *result = |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
3306 my_asnprintf (NULL, &length, "%.5Lg %d", 999.951L, 33, 44, 55); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
3307 ASSERT (result != NULL); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
3308 ASSERT (strcmp (result, "999.95 33") == 0); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
3309 ASSERT (length == strlen (result)); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
3310 free (result); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
3311 } |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
3312 |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
3313 { /* Precision with rounding. */ |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
3314 size_t length; |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
3315 char *result = |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
3316 my_asnprintf (NULL, &length, "%.5Lg %d", 999.996L, 33, 44, 55); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
3317 ASSERT (result != NULL); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
3318 ASSERT (strcmp (result, "1000 33") == 0); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
3319 ASSERT (length == strlen (result)); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
3320 free (result); |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
3321 } |
9f8c455639fc
Fix rounding when a precision is given.
Bruno Haible <bruno@clisp.org>
parents:
9889
diff
changeset
|
3322 |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3323 /* Test the support of the %n format directive. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3324 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3325 { |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3326 int count = -1; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3327 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3328 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3329 my_asnprintf (NULL, &length, "%d %n", 123, &count, 33, 44, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3330 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3331 ASSERT (strcmp (result, "123 ") == 0); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3332 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3333 ASSERT (count == 4); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3334 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3335 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3336 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3337 /* Test the support of the POSIX/XSI format strings with positions. */ |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3338 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3339 { |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3340 size_t length; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3341 char *result = |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3342 my_asnprintf (NULL, &length, "%2$d %1$d", 33, 55); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3343 ASSERT (result != NULL); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3344 ASSERT (strcmp (result, "55 33") == 0); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3345 ASSERT (length == strlen (result)); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3346 free (result); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3347 } |
8803
6c1d98929550
Work around lack of support of grouping flag.
Bruno Haible <bruno@clisp.org>
parents:
8754
diff
changeset
|
3348 |
6c1d98929550
Work around lack of support of grouping flag.
Bruno Haible <bruno@clisp.org>
parents:
8754
diff
changeset
|
3349 /* Test the support of the grouping flag. */ |
6c1d98929550
Work around lack of support of grouping flag.
Bruno Haible <bruno@clisp.org>
parents:
8754
diff
changeset
|
3350 |
6c1d98929550
Work around lack of support of grouping flag.
Bruno Haible <bruno@clisp.org>
parents:
8754
diff
changeset
|
3351 { |
6c1d98929550
Work around lack of support of grouping flag.
Bruno Haible <bruno@clisp.org>
parents:
8754
diff
changeset
|
3352 size_t length; |
6c1d98929550
Work around lack of support of grouping flag.
Bruno Haible <bruno@clisp.org>
parents:
8754
diff
changeset
|
3353 char *result = |
6c1d98929550
Work around lack of support of grouping flag.
Bruno Haible <bruno@clisp.org>
parents:
8754
diff
changeset
|
3354 my_asnprintf (NULL, &length, "%'d %d", 1234567, 99); |
6c1d98929550
Work around lack of support of grouping flag.
Bruno Haible <bruno@clisp.org>
parents:
8754
diff
changeset
|
3355 ASSERT (result != NULL); |
6c1d98929550
Work around lack of support of grouping flag.
Bruno Haible <bruno@clisp.org>
parents:
8754
diff
changeset
|
3356 ASSERT (result[strlen (result) - 1] == '9'); |
6c1d98929550
Work around lack of support of grouping flag.
Bruno Haible <bruno@clisp.org>
parents:
8754
diff
changeset
|
3357 ASSERT (length == strlen (result)); |
6c1d98929550
Work around lack of support of grouping flag.
Bruno Haible <bruno@clisp.org>
parents:
8754
diff
changeset
|
3358 free (result); |
6c1d98929550
Work around lack of support of grouping flag.
Bruno Haible <bruno@clisp.org>
parents:
8754
diff
changeset
|
3359 } |
9447
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3360 |
9674
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3361 /* Test the support of the left-adjust flag. */ |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3362 |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3363 { |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3364 size_t length; |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3365 char *result = |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3366 my_asnprintf (NULL, &length, "a%*sc", -3, "b"); |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3367 ASSERT (result != NULL); |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3368 ASSERT (strcmp (result, "ab c") == 0); |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3369 ASSERT (length == strlen (result)); |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3370 free (result); |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3371 } |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3372 |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3373 { |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3374 size_t length; |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3375 char *result = |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3376 my_asnprintf (NULL, &length, "a%-*sc", 3, "b"); |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3377 ASSERT (result != NULL); |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3378 ASSERT (strcmp (result, "ab c") == 0); |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3379 ASSERT (length == strlen (result)); |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3380 free (result); |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3381 } |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3382 |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3383 { |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3384 size_t length; |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3385 char *result = |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3386 my_asnprintf (NULL, &length, "a%-*sc", -3, "b"); |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3387 ASSERT (result != NULL); |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3388 ASSERT (strcmp (result, "ab c") == 0); |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3389 ASSERT (length == strlen (result)); |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3390 free (result); |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3391 } |
b69f1141e94f
Fix *printf behaviour regarding the left-adjust flag on HP-UX 10.20.
Bruno Haible <bruno@clisp.org>
parents:
9447
diff
changeset
|
3392 |
9447
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3393 /* Test the support of large precision. */ |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3394 |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3395 { |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3396 size_t length; |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3397 char *result = |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3398 my_asnprintf (NULL, &length, "%.4000d %d", 1234567, 99); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3399 size_t i; |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3400 ASSERT (result != NULL); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3401 for (i = 0; i < 4000 - 7; i++) |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3402 ASSERT (result[i] == '0'); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3403 ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3404 ASSERT (length == strlen (result)); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3405 free (result); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3406 } |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3407 |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3408 { |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3409 size_t length; |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3410 char *result = |
10394
4b3ac67aa7bc
vasnprintf-posix: handle large precision via %.*d
Eric Blake <ebb9@byu.net>
parents:
10296
diff
changeset
|
3411 my_asnprintf (NULL, &length, "%.*d %d", 4000, 1234567, 99); |
4b3ac67aa7bc
vasnprintf-posix: handle large precision via %.*d
Eric Blake <ebb9@byu.net>
parents:
10296
diff
changeset
|
3412 size_t i; |
4b3ac67aa7bc
vasnprintf-posix: handle large precision via %.*d
Eric Blake <ebb9@byu.net>
parents:
10296
diff
changeset
|
3413 ASSERT (result != NULL); |
4b3ac67aa7bc
vasnprintf-posix: handle large precision via %.*d
Eric Blake <ebb9@byu.net>
parents:
10296
diff
changeset
|
3414 for (i = 0; i < 4000 - 7; i++) |
4b3ac67aa7bc
vasnprintf-posix: handle large precision via %.*d
Eric Blake <ebb9@byu.net>
parents:
10296
diff
changeset
|
3415 ASSERT (result[i] == '0'); |
4b3ac67aa7bc
vasnprintf-posix: handle large precision via %.*d
Eric Blake <ebb9@byu.net>
parents:
10296
diff
changeset
|
3416 ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0); |
4b3ac67aa7bc
vasnprintf-posix: handle large precision via %.*d
Eric Blake <ebb9@byu.net>
parents:
10296
diff
changeset
|
3417 ASSERT (length == strlen (result)); |
4b3ac67aa7bc
vasnprintf-posix: handle large precision via %.*d
Eric Blake <ebb9@byu.net>
parents:
10296
diff
changeset
|
3418 free (result); |
4b3ac67aa7bc
vasnprintf-posix: handle large precision via %.*d
Eric Blake <ebb9@byu.net>
parents:
10296
diff
changeset
|
3419 } |
4b3ac67aa7bc
vasnprintf-posix: handle large precision via %.*d
Eric Blake <ebb9@byu.net>
parents:
10296
diff
changeset
|
3420 |
4b3ac67aa7bc
vasnprintf-posix: handle large precision via %.*d
Eric Blake <ebb9@byu.net>
parents:
10296
diff
changeset
|
3421 { |
4b3ac67aa7bc
vasnprintf-posix: handle large precision via %.*d
Eric Blake <ebb9@byu.net>
parents:
10296
diff
changeset
|
3422 size_t length; |
4b3ac67aa7bc
vasnprintf-posix: handle large precision via %.*d
Eric Blake <ebb9@byu.net>
parents:
10296
diff
changeset
|
3423 char *result = |
9447
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3424 my_asnprintf (NULL, &length, "%.4000d %d", -1234567, 99); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3425 size_t i; |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3426 ASSERT (result != NULL); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3427 ASSERT (result[0] == '-'); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3428 for (i = 0; i < 4000 - 7; i++) |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3429 ASSERT (result[1 + i] == '0'); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3430 ASSERT (strcmp (result + 1 + 4000 - 7, "1234567 99") == 0); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3431 ASSERT (length == strlen (result)); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3432 free (result); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3433 } |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3434 |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3435 { |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3436 size_t length; |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3437 char *result = |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3438 my_asnprintf (NULL, &length, "%.4000u %d", 1234567, 99); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3439 size_t i; |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3440 ASSERT (result != NULL); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3441 for (i = 0; i < 4000 - 7; i++) |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3442 ASSERT (result[i] == '0'); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3443 ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3444 ASSERT (length == strlen (result)); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3445 free (result); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3446 } |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3447 |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3448 { |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3449 size_t length; |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3450 char *result = |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3451 my_asnprintf (NULL, &length, "%.4000o %d", 1234567, 99); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3452 size_t i; |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3453 ASSERT (result != NULL); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3454 for (i = 0; i < 4000 - 7; i++) |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3455 ASSERT (result[i] == '0'); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3456 ASSERT (strcmp (result + 4000 - 7, "4553207 99") == 0); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3457 ASSERT (length == strlen (result)); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3458 free (result); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3459 } |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3460 |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3461 { |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3462 size_t length; |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3463 char *result = |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3464 my_asnprintf (NULL, &length, "%.4000x %d", 1234567, 99); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3465 size_t i; |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3466 ASSERT (result != NULL); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3467 for (i = 0; i < 4000 - 6; i++) |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3468 ASSERT (result[i] == '0'); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3469 ASSERT (strcmp (result + 4000 - 6, "12d687 99") == 0); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3470 ASSERT (length == strlen (result)); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3471 free (result); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3472 } |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3473 |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3474 { |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3475 size_t length; |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3476 char *result = |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3477 my_asnprintf (NULL, &length, "%#.4000x %d", 1234567, 99); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3478 size_t i; |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3479 ASSERT (result != NULL); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3480 ASSERT (result[0] == '0'); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3481 ASSERT (result[1] == 'x'); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3482 for (i = 0; i < 4000 - 6; i++) |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3483 ASSERT (result[2 + i] == '0'); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3484 ASSERT (strcmp (result + 2 + 4000 - 6, "12d687 99") == 0); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3485 ASSERT (length == strlen (result)); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3486 free (result); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3487 } |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3488 |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3489 { |
13908
4b4e2b0d175e
*printf-posix: Detect a bug on Solaris 10/x86.
Bruno Haible <bruno@clisp.org>
parents:
13885
diff
changeset
|
3490 size_t length; |
4b4e2b0d175e
*printf-posix: Detect a bug on Solaris 10/x86.
Bruno Haible <bruno@clisp.org>
parents:
13885
diff
changeset
|
3491 char *result = |
4b4e2b0d175e
*printf-posix: Detect a bug on Solaris 10/x86.
Bruno Haible <bruno@clisp.org>
parents:
13885
diff
changeset
|
3492 my_asnprintf (NULL, &length, "%.4000f %d", 1.0, 99); |
4b4e2b0d175e
*printf-posix: Detect a bug on Solaris 10/x86.
Bruno Haible <bruno@clisp.org>
parents:
13885
diff
changeset
|
3493 size_t i; |
4b4e2b0d175e
*printf-posix: Detect a bug on Solaris 10/x86.
Bruno Haible <bruno@clisp.org>
parents:
13885
diff
changeset
|
3494 ASSERT (result != NULL); |
4b4e2b0d175e
*printf-posix: Detect a bug on Solaris 10/x86.
Bruno Haible <bruno@clisp.org>
parents:
13885
diff
changeset
|
3495 ASSERT (result[0] == '1'); |
4b4e2b0d175e
*printf-posix: Detect a bug on Solaris 10/x86.
Bruno Haible <bruno@clisp.org>
parents:
13885
diff
changeset
|
3496 ASSERT (result[1] == '.'); |
4b4e2b0d175e
*printf-posix: Detect a bug on Solaris 10/x86.
Bruno Haible <bruno@clisp.org>
parents:
13885
diff
changeset
|
3497 for (i = 0; i < 4000; i++) |
4b4e2b0d175e
*printf-posix: Detect a bug on Solaris 10/x86.
Bruno Haible <bruno@clisp.org>
parents:
13885
diff
changeset
|
3498 ASSERT (result[2 + i] == '0'); |
4b4e2b0d175e
*printf-posix: Detect a bug on Solaris 10/x86.
Bruno Haible <bruno@clisp.org>
parents:
13885
diff
changeset
|
3499 ASSERT (strcmp (result + 2 + 4000, " 99") == 0); |
4b4e2b0d175e
*printf-posix: Detect a bug on Solaris 10/x86.
Bruno Haible <bruno@clisp.org>
parents:
13885
diff
changeset
|
3500 ASSERT (length == strlen (result)); |
4b4e2b0d175e
*printf-posix: Detect a bug on Solaris 10/x86.
Bruno Haible <bruno@clisp.org>
parents:
13885
diff
changeset
|
3501 free (result); |
4b4e2b0d175e
*printf-posix: Detect a bug on Solaris 10/x86.
Bruno Haible <bruno@clisp.org>
parents:
13885
diff
changeset
|
3502 } |
4b4e2b0d175e
*printf-posix: Detect a bug on Solaris 10/x86.
Bruno Haible <bruno@clisp.org>
parents:
13885
diff
changeset
|
3503 |
4b4e2b0d175e
*printf-posix: Detect a bug on Solaris 10/x86.
Bruno Haible <bruno@clisp.org>
parents:
13885
diff
changeset
|
3504 { |
14005
f585ecc144aa
*printf: Detect large precisions bug on Solaris 10/SPARC.
Bruno Haible <bruno@clisp.org>
parents:
13908
diff
changeset
|
3505 size_t length; |
f585ecc144aa
*printf: Detect large precisions bug on Solaris 10/SPARC.
Bruno Haible <bruno@clisp.org>
parents:
13908
diff
changeset
|
3506 char *result = |
f585ecc144aa
*printf: Detect large precisions bug on Solaris 10/SPARC.
Bruno Haible <bruno@clisp.org>
parents:
13908
diff
changeset
|
3507 my_asnprintf (NULL, &length, "%.511f %d", 1.0, 99); |
f585ecc144aa
*printf: Detect large precisions bug on Solaris 10/SPARC.
Bruno Haible <bruno@clisp.org>
parents:
13908
diff
changeset
|
3508 size_t i; |
f585ecc144aa
*printf: Detect large precisions bug on Solaris 10/SPARC.
Bruno Haible <bruno@clisp.org>
parents:
13908
diff
changeset
|
3509 ASSERT (result != NULL); |
f585ecc144aa
*printf: Detect large precisions bug on Solaris 10/SPARC.
Bruno Haible <bruno@clisp.org>
parents:
13908
diff
changeset
|
3510 ASSERT (result[0] == '1'); |
f585ecc144aa
*printf: Detect large precisions bug on Solaris 10/SPARC.
Bruno Haible <bruno@clisp.org>
parents:
13908
diff
changeset
|
3511 ASSERT (result[1] == '.'); |
f585ecc144aa
*printf: Detect large precisions bug on Solaris 10/SPARC.
Bruno Haible <bruno@clisp.org>
parents:
13908
diff
changeset
|
3512 for (i = 0; i < 511; i++) |
f585ecc144aa
*printf: Detect large precisions bug on Solaris 10/SPARC.
Bruno Haible <bruno@clisp.org>
parents:
13908
diff
changeset
|
3513 ASSERT (result[2 + i] == '0'); |
f585ecc144aa
*printf: Detect large precisions bug on Solaris 10/SPARC.
Bruno Haible <bruno@clisp.org>
parents:
13908
diff
changeset
|
3514 ASSERT (strcmp (result + 2 + 511, " 99") == 0); |
f585ecc144aa
*printf: Detect large precisions bug on Solaris 10/SPARC.
Bruno Haible <bruno@clisp.org>
parents:
13908
diff
changeset
|
3515 ASSERT (length == strlen (result)); |
f585ecc144aa
*printf: Detect large precisions bug on Solaris 10/SPARC.
Bruno Haible <bruno@clisp.org>
parents:
13908
diff
changeset
|
3516 free (result); |
f585ecc144aa
*printf: Detect large precisions bug on Solaris 10/SPARC.
Bruno Haible <bruno@clisp.org>
parents:
13908
diff
changeset
|
3517 } |
f585ecc144aa
*printf: Detect large precisions bug on Solaris 10/SPARC.
Bruno Haible <bruno@clisp.org>
parents:
13908
diff
changeset
|
3518 |
f585ecc144aa
*printf: Detect large precisions bug on Solaris 10/SPARC.
Bruno Haible <bruno@clisp.org>
parents:
13908
diff
changeset
|
3519 { |
9447
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3520 char input[5000]; |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3521 size_t length; |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3522 char *result; |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3523 size_t i; |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3524 |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3525 for (i = 0; i < sizeof (input) - 1; i++) |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3526 input[i] = 'a' + ((1000000 / (i + 1)) % 26); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3527 input[i] = '\0'; |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3528 result = my_asnprintf (NULL, &length, "%.4000s %d", input, 99); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3529 ASSERT (result != NULL); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3530 ASSERT (memcmp (result, input, 4000) == 0); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3531 ASSERT (strcmp (result + 4000, " 99") == 0); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3532 ASSERT (length == strlen (result)); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3533 free (result); |
6d73d8d1aecb
Add tests for large precisions.
Bruno Haible <bruno@clisp.org>
parents:
9309
diff
changeset
|
3534 } |
11207
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3535 |
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3536 /* Test the support of the %s format directive. */ |
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3537 |
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3538 /* To verify that these tests succeed, it is necessary to run them under |
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3539 a tool that checks against invalid memory accesses, such as ElectricFence |
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3540 or "valgrind --tool=memcheck". */ |
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3541 { |
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3542 size_t i; |
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3543 |
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3544 for (i = 1; i <= 8; i++) |
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3545 { |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3546 char *block; |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3547 size_t length; |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3548 char *result; |
11207
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3549 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3550 block = (char *) malloc (i); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3551 memcpy (block, "abcdefgh", i); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3552 result = my_asnprintf (NULL, &length, "%.*s", (int) i, block); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3553 ASSERT (result != NULL); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3554 ASSERT (memcmp (result, block, i) == 0); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3555 ASSERT (result[i] == '\0'); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3556 ASSERT (length == strlen (result)); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3557 free (result); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3558 free (block); |
11207
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3559 } |
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3560 } |
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3561 #if HAVE_WCHAR_T |
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3562 { |
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3563 size_t i; |
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3564 |
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3565 for (i = 1; i <= 8; i++) |
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3566 { |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3567 wchar_t *block; |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3568 size_t j; |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3569 size_t length; |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3570 char *result; |
11207
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3571 |
12421
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3572 block = (wchar_t *) malloc (i * sizeof (wchar_t)); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3573 for (j = 0; j < i; j++) |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3574 block[j] = "abcdefgh"[j]; |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3575 result = my_asnprintf (NULL, &length, "%.*ls", (int) i, block); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3576 ASSERT (result != NULL); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3577 ASSERT (memcmp (result, "abcdefgh", i) == 0); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3578 ASSERT (result[i] == '\0'); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3579 ASSERT (length == strlen (result)); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3580 free (result); |
e8d2c6fc33ad
Use spaces for indentation, not tabs.
Bruno Haible <bruno@clisp.org>
parents:
11207
diff
changeset
|
3581 free (block); |
11207
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3582 } |
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3583 } |
4daf474e9033
vasnprintf: Fix invalid read past end of memory block.
Bruno Haible <bruno@clisp.org>
parents:
11002
diff
changeset
|
3584 #endif |
13200
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3585 |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3586 #if HAVE_WCHAR_T |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3587 /* Test that converting an invalid wchar_t[] to char[] fails with EILSEQ. */ |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3588 { |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3589 static const wchar_t input[] = { (wchar_t) 1702057263, 114, 0 }; |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3590 size_t length; |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3591 char *result = my_asnprintf (NULL, &length, "%ls %d", input, 99); |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3592 if (result == NULL) |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3593 ASSERT (errno == EILSEQ); |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3594 else |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3595 free (result); |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3596 } |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3597 { |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3598 static const wchar_t input[] = { (wchar_t) 1702057263, 114, 0 }; |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3599 size_t length; |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3600 char *result = my_asnprintf (NULL, &length, "%3ls %d", input, 99); |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3601 if (result == NULL) |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3602 ASSERT (errno == EILSEQ); |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3603 else |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3604 free (result); |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3605 } |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3606 { |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3607 static const wchar_t input[] = { (wchar_t) 1702057263, 114, 0 }; |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3608 size_t length; |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3609 char *result = my_asnprintf (NULL, &length, "%.1ls %d", input, 99); |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3610 if (result == NULL) |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3611 ASSERT (errno == EILSEQ); |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3612 else |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3613 free (result); |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3614 } |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3615 { |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3616 static const wchar_t input[] = { (wchar_t) 1702057263, 114, 0 }; |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3617 size_t length; |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3618 char *result = my_asnprintf (NULL, &length, "%3.1ls %d", input, 99); |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3619 if (result == NULL) |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3620 ASSERT (errno == EILSEQ); |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3621 else |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3622 free (result); |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3623 } |
69f672943274
vasnprintf: Add more tests.
Bruno Haible <bruno@clisp.org>
parents:
12559
diff
changeset
|
3624 #endif |
13841
05717fb89fa4
vasnprintf: Support I flag on glibc systems.
Bruno Haible <bruno@clisp.org>
parents:
13834
diff
changeset
|
3625 |
13885 | 3626 #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)) && !defined __UCLIBC__ |
13841
05717fb89fa4
vasnprintf: Support I flag on glibc systems.
Bruno Haible <bruno@clisp.org>
parents:
13834
diff
changeset
|
3627 /* Test that the 'I' flag is supported. */ |
05717fb89fa4
vasnprintf: Support I flag on glibc systems.
Bruno Haible <bruno@clisp.org>
parents:
13834
diff
changeset
|
3628 { |
05717fb89fa4
vasnprintf: Support I flag on glibc systems.
Bruno Haible <bruno@clisp.org>
parents:
13834
diff
changeset
|
3629 size_t length; |
05717fb89fa4
vasnprintf: Support I flag on glibc systems.
Bruno Haible <bruno@clisp.org>
parents:
13834
diff
changeset
|
3630 char *result = |
05717fb89fa4
vasnprintf: Support I flag on glibc systems.
Bruno Haible <bruno@clisp.org>
parents:
13834
diff
changeset
|
3631 my_asnprintf (NULL, &length, "%Id %d", 1234567, 99); |
05717fb89fa4
vasnprintf: Support I flag on glibc systems.
Bruno Haible <bruno@clisp.org>
parents:
13834
diff
changeset
|
3632 ASSERT (result != NULL); |
05717fb89fa4
vasnprintf: Support I flag on glibc systems.
Bruno Haible <bruno@clisp.org>
parents:
13834
diff
changeset
|
3633 ASSERT (strcmp (result, "1234567 99") == 0); |
05717fb89fa4
vasnprintf: Support I flag on glibc systems.
Bruno Haible <bruno@clisp.org>
parents:
13834
diff
changeset
|
3634 ASSERT (length == strlen (result)); |
05717fb89fa4
vasnprintf: Support I flag on glibc systems.
Bruno Haible <bruno@clisp.org>
parents:
13834
diff
changeset
|
3635 free (result); |
05717fb89fa4
vasnprintf: Support I flag on glibc systems.
Bruno Haible <bruno@clisp.org>
parents:
13834
diff
changeset
|
3636 } |
05717fb89fa4
vasnprintf: Support I flag on glibc systems.
Bruno Haible <bruno@clisp.org>
parents:
13834
diff
changeset
|
3637 #endif |
8336
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3638 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3639 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3640 static char * |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3641 my_asnprintf (char *resultbuf, size_t *lengthp, const char *format, ...) |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3642 { |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3643 va_list args; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3644 char *ret; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3645 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3646 va_start (args, format); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3647 ret = vasnprintf (resultbuf, lengthp, format, args); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3648 va_end (args); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3649 return ret; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3650 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3651 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3652 static void |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3653 test_vasnprintf () |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3654 { |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3655 test_function (my_asnprintf); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3656 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3657 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3658 static void |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3659 test_asnprintf () |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3660 { |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3661 test_function (asnprintf); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3662 } |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3663 |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3664 int |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3665 main (int argc, char *argv[]) |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3666 { |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3667 test_vasnprintf (); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3668 test_asnprintf (); |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3669 return 0; |
493708637f61
Tests for module 'vasnprintf-posix'.
Bruno Haible <bruno@clisp.org>
parents:
diff
changeset
|
3670 } |