1 /*        $NetBSD: t_strtod.c,v 1.39 2025/04/07 02:28:00 riastradh Exp $ */
2 
3 /*-
4  * Copyright (c) 2011 The NetBSD Foundation, Inc.
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to The NetBSD Foundation
8  * by Jukka Ruohonen.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29  * POSSIBILITY OF SUCH DAMAGE.
30  */
31 
32 /* Public domain, Otto Moerbeek <otto@drijf.net>, 2006. */
33 
34 #include <sys/cdefs.h>
35 __RCSID("$NetBSD: t_strtod.c,v 1.39 2025/04/07 02:28:00 riastradh Exp $");
36 
37 #include <errno.h>
38 #include <fenv.h>
39 #include <float.h>
40 #include <math.h>
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44 
45 #include <atf-c.h>
46 
47 static const char * const inf_strings[] =
48     { "Inf", "INF", "-Inf", "-INF", "Infinity", "+Infinity",
49       "INFINITY", "-INFINITY", "InFiNiTy", "+InFiNiTy" };
50 const char * const nan_string = "NaN(x)y";
51 
52 ATF_TC(strtod_basic);
ATF_TC_HEAD(strtod_basic,tc)53 ATF_TC_HEAD(strtod_basic, tc)
54 {
55           atf_tc_set_md_var(tc, "descr", "A basic test of strtod(3)");
56 }
57 
ATF_TC_BODY(strtod_basic,tc)58 ATF_TC_BODY(strtod_basic, tc)
59 {
60           static const size_t n = 1024 * 1000;
61 
62           for (size_t i = 1; i < n; i = i + 1024) {
63                     char buf[512];
64                     (void)snprintf(buf, sizeof(buf), "%zu.%zu", i, i + 1);
65 
66                     errno = 0;
67                     double d = strtod(buf, NULL);
68 
69                     ATF_CHECK_MSG(d > 0, "i=%zu buf=\"%s\" d=%g errno=%d",
70                         i, buf, d, errno);
71                     ATF_CHECK_EQ_MSG(errno, 0, "i=%zu buf=\"%s\" d=%g errno=%d",
72                         i, buf, d, errno);
73           }
74 }
75 
76 ATF_TC(strtold_basic);
ATF_TC_HEAD(strtold_basic,tc)77 ATF_TC_HEAD(strtold_basic, tc)
78 {
79           atf_tc_set_md_var(tc, "descr", "Some examples of strtold(3)");
80 }
81 
ATF_TC_BODY(strtold_basic,tc)82 ATF_TC_BODY(strtold_basic, tc)
83 {
84           static const struct {
85                     const char *str;
86                     long double val;
87           } testcases[] = {
88                     { "0x0p0", 0.0L },
89                     { "0x1.234p0", 0x1234 / 4096.0L },
90                     { "0x1.234p0", 0x1234 / 4096.0L },
91 #if FLT_RADIX == 2 && LDBL_MAX_EXP == 16384 && LDBL_MANT_DIG == 64
92                     { "2.16", 0x8.a3d70a3d70a3d71p-2L },
93 #endif
94           };
95 
96           for (size_t i = 0, n = __arraycount(testcases); i < n; i++) {
97                     char *end;
98                     errno = 0;
99                     long double val = strtold(testcases[i].str, &end);
100 
101                     ATF_CHECK_MSG(
102                         errno == 0 && *end == '\0' && val == testcases[i].val,
103                         "'%s' want %La have %La errno %d end '%s'",
104                         testcases[i].str, testcases[i].val, val, errno, end);
105           }
106 }
107 
108 ATF_TC(strtod_hex);
ATF_TC_HEAD(strtod_hex,tc)109 ATF_TC_HEAD(strtod_hex, tc)
110 {
111           atf_tc_set_md_var(tc, "descr", "A strtod(3) with hexadecimals");
112 }
113 
ATF_TC_BODY(strtod_hex,tc)114 ATF_TC_BODY(strtod_hex, tc)
115 {
116           const char *str;
117           char *end;
118           volatile double d;
119 
120           str = "-0x0";
121           d = strtod(str, &end);        /* -0.0 */
122 
123           ATF_CHECK_EQ_MSG(end, str + 4, "str=%p end=%p", str, end);
124           ATF_CHECK_MSG(signbit(d) != 0, "d=%g=%a signbit=%d", d, d, signbit(d));
125           ATF_CHECK_EQ_MSG(fabs(d), 0, "d=%g=%a, fabs(d)=%g=%a",
126               d, d, fabs(d), fabs(d));
127 
128           str = "-0x";
129           d = strtod(str, &end);        /* -0.0 */
130 
131           ATF_CHECK_EQ_MSG(end, str + 2, "str=%p end=%p", str, end);
132           ATF_CHECK_MSG(signbit(d) != 0, "d=%g=%a signbit=%d", d, d, signbit(d));
133           ATF_CHECK_EQ_MSG(fabs(d), 0, "d=%g=%a fabs(d)=%g=%a",
134               d, d, fabs(d), fabs(d));
135 }
136 
137 ATF_TC(strtod_inf);
ATF_TC_HEAD(strtod_inf,tc)138 ATF_TC_HEAD(strtod_inf, tc)
139 {
140           atf_tc_set_md_var(tc, "descr", "A strtod(3) with INF (PR lib/33262)");
141 }
142 
ATF_TC_BODY(strtod_inf,tc)143 ATF_TC_BODY(strtod_inf, tc)
144 {
145 
146           if (!isinf(INFINITY))
147                     atf_tc_skip("no infinities on this architecture");
148 
149           for (size_t i = 0; i < __arraycount(inf_strings); i++) {
150                     volatile double d = strtod(inf_strings[i], NULL);
151                     ATF_CHECK_MSG(isinf(d), "inf_strings[%zu]=\"%s\" d=%g=%a",
152                         i, inf_strings[i], d, d);
153           }
154 }
155 
156 ATF_TC(strtof_inf);
ATF_TC_HEAD(strtof_inf,tc)157 ATF_TC_HEAD(strtof_inf, tc)
158 {
159           atf_tc_set_md_var(tc, "descr", "A strtof(3) with INF (PR lib/33262)");
160 }
161 
ATF_TC_BODY(strtof_inf,tc)162 ATF_TC_BODY(strtof_inf, tc)
163 {
164 
165           if (!isinf(INFINITY))
166                     atf_tc_skip("no infinities on this architecture");
167 
168           for (size_t i = 0; i < __arraycount(inf_strings); i++) {
169                     volatile float f = strtof(inf_strings[i], NULL);
170                     ATF_CHECK_MSG(isinf(f), "inf_strings[%zu]=\"%s\" f=%g=%a",
171                         i, inf_strings[i], f, f);
172                     ATF_CHECK_MSG(isinff(f), "inf_strings[%zu]=\"%s\" f=%g=%a",
173                         i, inf_strings[i], f, f);
174           }
175 }
176 
177 ATF_TC(strtold_inf);
ATF_TC_HEAD(strtold_inf,tc)178 ATF_TC_HEAD(strtold_inf, tc)
179 {
180           atf_tc_set_md_var(tc, "descr", "A strtold(3) with INF (PR lib/33262)");
181 }
182 
ATF_TC_BODY(strtold_inf,tc)183 ATF_TC_BODY(strtold_inf, tc)
184 {
185 
186           if (!isinf(INFINITY))
187                     atf_tc_skip("no infinities on this architecture");
188 
189           for (size_t i = 0; i < __arraycount(inf_strings); i++) {
190                     volatile long double ld = strtold(inf_strings[i], NULL);
191                     ATF_CHECK_MSG(isinf(ld), "inf_strings[%zu]=\"%s\" ld=%Lg=%La",
192                         i, inf_strings[i], ld, ld);
193           }
194 }
195 
196 ATF_TC(strtod_nan);
ATF_TC_HEAD(strtod_nan,tc)197 ATF_TC_HEAD(strtod_nan, tc)
198 {
199           atf_tc_set_md_var(tc, "descr", "A strtod(3) with NaN");
200 }
201 
ATF_TC_BODY(strtod_nan,tc)202 ATF_TC_BODY(strtod_nan, tc)
203 {
204           char *end;
205 
206 #ifndef NAN
207           atf_tc_skip("no NaNs on this architecture");
208 #endif
209 
210           volatile double d = strtod(nan_string, &end);
211           ATF_CHECK_MSG(isnan(d), "nan_string=\"%s\" d=%g=%a", nan_string, d, d);
212           ATF_CHECK_MSG(strcmp(end, "y") == 0, "nan_string=\"%s\"@%p end=%p",
213               nan_string, nan_string, end);
214 }
215 
216 ATF_TC(strtof_nan);
ATF_TC_HEAD(strtof_nan,tc)217 ATF_TC_HEAD(strtof_nan, tc)
218 {
219           atf_tc_set_md_var(tc, "descr", "A strtof(3) with NaN");
220 }
221 
ATF_TC_BODY(strtof_nan,tc)222 ATF_TC_BODY(strtof_nan, tc)
223 {
224           char *end;
225 
226 #ifndef NAN
227           atf_tc_skip("no NaNs on this architecture");
228 #endif
229 
230           volatile float f = strtof(nan_string, &end);
231           ATF_CHECK_MSG(isnan(f), "nan_string=\"%s\" f=%g=%a", nan_string, f, f);
232           ATF_CHECK_MSG(isnanf(f), "nan_string=\"%s\" f=%g=%a", nan_string,
233               f, f);
234           ATF_CHECK_MSG(strcmp(end, "y") == 0, "nan_string=\"%s\"@%p end=%p",
235               nan_string, nan_string, end);
236 }
237 
238 ATF_TC(strtold_nan);
ATF_TC_HEAD(strtold_nan,tc)239 ATF_TC_HEAD(strtold_nan, tc)
240 {
241           atf_tc_set_md_var(tc, "descr", "A strtold(3) with NaN (PR lib/45020)");
242 }
243 
ATF_TC_BODY(strtold_nan,tc)244 ATF_TC_BODY(strtold_nan, tc)
245 {
246           char *end;
247 
248 #ifndef NAN
249           atf_tc_skip("no NaNs on this architecture");
250 #endif
251 
252           volatile long double ld = strtold(nan_string, &end);
253           ATF_CHECK_MSG(isnan(ld), "nan_string=\"%s\" ld=%Lg=%La",
254               nan_string, ld, ld);
255           ATF_CHECK_MSG(isnanf(ld), "nan_string=\"%s\" ld=%Lg=%La",
256               nan_string, ld, ld);
257           ATF_CHECK_MSG(strcmp(end, "y") == 0, "nan_string=\"%s\"@%p end=%p",
258               nan_string, nan_string, end);
259 }
260 
261 ATF_TC(strtod_round);
ATF_TC_HEAD(strtod_round,tc)262 ATF_TC_HEAD(strtod_round, tc)
263 {
264           atf_tc_set_md_var(tc, "descr", "Test rounding in strtod(3)");
265 }
266 
ATF_TC_BODY(strtod_round,tc)267 ATF_TC_BODY(strtod_round, tc)
268 {
269 #ifdef __HAVE_FENV
270 
271           /*
272            * Test that strtod(3) honors the current rounding mode.
273            * The used value is somewhere near 1 + DBL_EPSILON + FLT_EPSILON.
274            */
275           const char *val =
276               "1.00000011920928977282585492503130808472633361816406";
277 
278           (void)fesetround(FE_UPWARD);
279           volatile double d1 = strtod(val, NULL);
280           (void)fesetround(FE_DOWNWARD);
281           volatile double d2 = strtod(val, NULL);
282           ATF_CHECK_MSG(d1 > d2, "d1=%g=%a d2=%g=%a", d1, d1, d2, d2);
283 #else
284           atf_tc_skip("Requires <fenv.h> support");
285 #endif
286 }
287 
288 ATF_TC(strtod_underflow);
ATF_TC_HEAD(strtod_underflow,tc)289 ATF_TC_HEAD(strtod_underflow, tc)
290 {
291           atf_tc_set_md_var(tc, "descr", "Test underflow in strtod(3)");
292 }
293 
ATF_TC_BODY(strtod_underflow,tc)294 ATF_TC_BODY(strtod_underflow, tc)
295 {
296 
297           const char *tmp =
298               "0.0000000000000000000000000000000000000000000000000000"
299               "000000000000000000000000000000000000000000000000000000"
300               "000000000000000000000000000000000000000000000000000000"
301               "000000000000000000000000000000000000000000000000000000"
302               "000000000000000000000000000000000000000000000000000000"
303               "000000000000000000000000000000000000000000000000000000"
304               "000000000000000000000000000000000000000000000000000000"
305               "000000000000000002";
306 
307           errno = 0;
308           volatile double d = strtod(tmp, NULL);
309 
310           if (d != 0 || errno != ERANGE)
311                     atf_tc_fail("strtod(3) did not detect underflow");
312 }
313 
314 /*
315  * Bug found by Geza Herman.
316  * See
317  * http://www.exploringbinary.com/a-bug-in-the-bigcomp-function-of-david-gays-strtod/
318  */
319 ATF_TC(strtod_gherman_bug);
ATF_TC_HEAD(strtod_gherman_bug,tc)320 ATF_TC_HEAD(strtod_gherman_bug, tc)
321 {
322           atf_tc_set_md_var(tc, "descr", "Test a bug found by Geza Herman");
323 }
324 
ATF_TC_BODY(strtod_gherman_bug,tc)325 ATF_TC_BODY(strtod_gherman_bug, tc)
326 {
327           /*
328            * Input is _just barely below_ halfway from one binary64
329            * (p=53) floating-point number 0x1.d34fd8378ea83p+0 to the
330            * next one 0x1.d34fd8378ea84p+0:
331            *
332            *                                                       v
333            * 1.110100110100111111011000001101111000111010101000001101111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110..._2
334            */
335           const char *volatile str =
336               "1.8254370818746402660437411213933955878019332885742187";
337           int error;
338 
339           errno = 0;
340           volatile double d = strtod(str, NULL);
341           error = errno;
342           ATF_CHECK_MSG(error == 0, "errno=%d (%s)", error, strerror(error));
343 
344 #if DBL_MANT_DIG == 53
345           ATF_CHECK_EQ_MSG(d, 0x1.d34fd8378ea83p+0, "d=%g=%a", d, d);
346 #elif DBL_MANT_DIG == 56
347           /* a.k.a. 0xe.9a7ec1bc7541cp-3 */
348           ATF_CHECK_EQ_MSG(d, 0x1.d34fd8378ea838p+0, "d=%g=%a", d, d);
349 #else
350 #  error Unknown DBL_MANT_DIG value!
351 #endif
352 
353 #if DBL_MANT_DIG >= 56
354           /*
355            * Same deal, but VAX D (p=56) between 0xe.9a7ec1bc7541fp-3 and
356            * 0xe.9a7ec1bc75420p-3 (a.k.a. 0x1.d34fd8378ea83ep+0 and
357            * 0x1.d34fd8378ea840p+0, respectively):
358            *
359            *                                                          v
360            * 1.11010011010011111101100000110111100011101010100000111110111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110..._2
361            *
362            * (Not actually sure if this would have triggered the bug!
363            * Maybe someone with a VAX can try and find out.)
364            */
365           str = "1.8254370818746403631882557760945928748697042465209960";
366 
367           errno = 0;
368           d = strtod(str, NULL);
369           error = errno;
370           ATF_CHECK_MSG(error == 0, "errno=%d (%s)", error, strerror(error));
371 
372           /* a.k.a. 0x1.d34fd8378ea83ep+0 */
373           ATF_CHECK_EQ_MSG(d, 0xe.9a7ec1bc7541fp-3, "d=%g=%a", d, d);
374 #endif
375 }
376 
ATF_TP_ADD_TCS(tp)377 ATF_TP_ADD_TCS(tp)
378 {
379 
380           ATF_TP_ADD_TC(tp, strtod_basic);
381           ATF_TP_ADD_TC(tp, strtold_basic);
382           ATF_TP_ADD_TC(tp, strtod_hex);
383           ATF_TP_ADD_TC(tp, strtod_inf);
384           ATF_TP_ADD_TC(tp, strtof_inf);
385           ATF_TP_ADD_TC(tp, strtold_inf);
386           ATF_TP_ADD_TC(tp, strtod_nan);
387           ATF_TP_ADD_TC(tp, strtof_nan);
388           ATF_TP_ADD_TC(tp, strtold_nan);
389           ATF_TP_ADD_TC(tp, strtod_round);
390           ATF_TP_ADD_TC(tp, strtod_underflow);
391           ATF_TP_ADD_TC(tp, strtod_gherman_bug);
392 
393           return atf_no_error();
394 }
395