1 /* $NetBSD: t_strtod.c,v 1.34 2015/12/22 14:19:25 christos 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.34 2015/12/22 14:19:25 christos Exp $"); 36 37 #include <errno.h> 38 #include <math.h> 39 #include <stdio.h> 40 #include <stdlib.h> 41 #include <string.h> 42 43 #include <atf-c.h> 44 45 #include <fenv.h> 46 47 #if !defined(__vax__) 48 static const char * const inf_strings[] = 49 { "Inf", "INF", "-Inf", "-INF", "Infinity", "+Infinity", 50 "INFINITY", "-INFINITY", "InFiNiTy", "+InFiNiTy" }; 51 const char *nan_string = "NaN(x)y"; 52 #endif 53 54 #ifdef __FreeBSD__ 55 #define __HAVE_LONG_DOUBLE 56 #endif 57 58 ATF_TC(strtod_basic); 59 ATF_TC_HEAD(strtod_basic, tc) 60 { 61 atf_tc_set_md_var(tc, "descr", "A basic test of strtod(3)"); 62 } 63 64 ATF_TC_BODY(strtod_basic, tc) 65 { 66 static const size_t n = 1024 * 1000; 67 68 for (size_t i = 1; i < n; i = i + 1024) { 69 char buf[512]; 70 (void)snprintf(buf, sizeof(buf), "%zu.%zu", i, i + 1); 71 72 errno = 0; 73 double d = strtod(buf, NULL); 74 75 ATF_REQUIRE(d > 0.0); 76 ATF_REQUIRE(errno == 0); 77 } 78 } 79 80 ATF_TC(strtod_hex); 81 ATF_TC_HEAD(strtod_hex, tc) 82 { 83 atf_tc_set_md_var(tc, "descr", "A strtod(3) with hexadecimals"); 84 } 85 86 #ifdef __vax__ 87 #define SMALL_NUM 1.0e-38 88 #else 89 #define SMALL_NUM 1.0e-40 90 #endif 91 92 ATF_TC_BODY(strtod_hex, tc) 93 { 94 const char *str; 95 char *end; 96 volatile double d; 97 98 str = "-0x0"; 99 d = strtod(str, &end); /* -0.0 */ 100 101 ATF_REQUIRE(end == str + 4); 102 ATF_REQUIRE(signbit(d) != 0); 103 ATF_REQUIRE(fabs(d) < SMALL_NUM); 104 105 str = "-0x"; 106 d = strtod(str, &end); /* -0.0 */ 107 108 ATF_REQUIRE(end == str + 2); 109 ATF_REQUIRE(signbit(d) != 0); 110 ATF_REQUIRE(fabs(d) < SMALL_NUM); 111 } 112 113 ATF_TC(strtod_inf); 114 ATF_TC_HEAD(strtod_inf, tc) 115 { 116 atf_tc_set_md_var(tc, "descr", "A strtod(3) with INF (PR lib/33262)"); 117 } 118 119 ATF_TC_BODY(strtod_inf, tc) 120 { 121 #ifndef __vax__ 122 for (size_t i = 0; i < __arraycount(inf_strings); i++) { 123 volatile double d = strtod(inf_strings[i], NULL); 124 ATF_REQUIRE(isinf(d) != 0); 125 } 126 #else 127 atf_tc_skip("vax not supported"); 128 #endif 129 } 130 131 ATF_TC(strtof_inf); 132 ATF_TC_HEAD(strtof_inf, tc) 133 { 134 atf_tc_set_md_var(tc, "descr", "A strtof(3) with INF (PR lib/33262)"); 135 } 136 137 ATF_TC_BODY(strtof_inf, tc) 138 { 139 #ifndef __vax__ 140 for (size_t i = 0; i < __arraycount(inf_strings); i++) { 141 volatile float f = strtof(inf_strings[i], NULL); 142 ATF_REQUIRE(isinf(f) != 0); 143 } 144 #else 145 atf_tc_skip("vax not supported"); 146 #endif 147 } 148 149 ATF_TC(strtold_inf); 150 ATF_TC_HEAD(strtold_inf, tc) 151 { 152 atf_tc_set_md_var(tc, "descr", "A strtold(3) with INF (PR lib/33262)"); 153 } 154 155 ATF_TC_BODY(strtold_inf, tc) 156 { 157 #ifndef __vax__ 158 # ifdef __HAVE_LONG_DOUBLE 159 160 for (size_t i = 0; i < __arraycount(inf_strings); i++) { 161 volatile long double ld = strtold(inf_strings[i], NULL); 162 ATF_REQUIRE(isinf(ld) != 0); 163 } 164 # else 165 atf_tc_skip("Requires long double support"); 166 # endif 167 #else 168 atf_tc_skip("vax not supported"); 169 #endif 170 } 171 172 ATF_TC(strtod_nan); 173 ATF_TC_HEAD(strtod_nan, tc) 174 { 175 atf_tc_set_md_var(tc, "descr", "A strtod(3) with NaN"); 176 } 177 178 ATF_TC_BODY(strtod_nan, tc) 179 { 180 #ifndef __vax__ 181 char *end; 182 183 volatile double d = strtod(nan_string, &end); 184 ATF_REQUIRE(isnan(d) != 0); 185 ATF_REQUIRE(strcmp(end, "y") == 0); 186 #else 187 atf_tc_skip("vax not supported"); 188 #endif 189 } 190 191 ATF_TC(strtof_nan); 192 ATF_TC_HEAD(strtof_nan, tc) 193 { 194 atf_tc_set_md_var(tc, "descr", "A strtof(3) with NaN"); 195 } 196 197 ATF_TC_BODY(strtof_nan, tc) 198 { 199 #ifndef __vax__ 200 char *end; 201 202 volatile float f = strtof(nan_string, &end); 203 ATF_REQUIRE(isnanf(f) != 0); 204 ATF_REQUIRE(strcmp(end, "y") == 0); 205 #else 206 atf_tc_skip("vax not supported"); 207 #endif 208 } 209 210 ATF_TC(strtold_nan); 211 ATF_TC_HEAD(strtold_nan, tc) 212 { 213 atf_tc_set_md_var(tc, "descr", "A strtold(3) with NaN (PR lib/45020)"); 214 } 215 216 ATF_TC_BODY(strtold_nan, tc) 217 { 218 #ifndef __vax__ 219 # ifdef __HAVE_LONG_DOUBLE 220 221 char *end; 222 223 volatile long double ld = strtold(nan_string, &end); 224 ATF_REQUIRE(isnan(ld) != 0); 225 #ifdef __FreeBSD__ 226 ATF_REQUIRE(strcmp(end, "y") == 0); 227 #else 228 ATF_REQUIRE(__isnanl(ld) != 0); 229 #endif 230 ATF_REQUIRE(strcmp(end, "y") == 0); 231 # else 232 atf_tc_skip("Requires long double support"); 233 # endif 234 #else 235 atf_tc_skip("vax not supported"); 236 #endif 237 } 238 239 ATF_TC(strtod_round); 240 ATF_TC_HEAD(strtod_round, tc) 241 { 242 atf_tc_set_md_var(tc, "descr", "Test rouding in strtod(3)"); 243 } 244 245 ATF_TC_BODY(strtod_round, tc) 246 { 247 #ifdef __HAVE_FENV 248 249 /* 250 * Test that strtod(3) honors the current rounding mode. 251 * The used value is somewhere near 1 + DBL_EPSILON + FLT_EPSILON. 252 */ 253 const char *val = 254 "1.00000011920928977282585492503130808472633361816406"; 255 256 (void)fesetround(FE_UPWARD); 257 258 volatile double d1 = strtod(val, NULL); 259 260 (void)fesetround(FE_DOWNWARD); 261 262 volatile double d2 = strtod(val, NULL); 263 264 if (fabs(d1 - d2) > 0.0) 265 return; 266 else { 267 atf_tc_expect_fail("PR misc/44767"); 268 atf_tc_fail("strtod(3) did not honor fesetround(3)"); 269 } 270 #else 271 atf_tc_skip("Requires <fenv.h> support"); 272 #endif 273 } 274 275 ATF_TC(strtod_underflow); 276 ATF_TC_HEAD(strtod_underflow, tc) 277 { 278 atf_tc_set_md_var(tc, "descr", "Test underflow in strtod(3)"); 279 } 280 281 ATF_TC_BODY(strtod_underflow, tc) 282 { 283 284 const char *tmp = 285 "0.0000000000000000000000000000000000000000000000000000" 286 "000000000000000000000000000000000000000000000000000000" 287 "000000000000000000000000000000000000000000000000000000" 288 "000000000000000000000000000000000000000000000000000000" 289 "000000000000000000000000000000000000000000000000000000" 290 "000000000000000000000000000000000000000000000000000000" 291 "000000000000000000000000000000000000000000000000000000" 292 "000000000000000002"; 293 294 errno = 0; 295 volatile double d = strtod(tmp, NULL); 296 297 if (d != 0 || errno != ERANGE) 298 atf_tc_fail("strtod(3) did not detect underflow"); 299 } 300 301 /* 302 * Bug found by Geza Herman. 303 * See 304 * http://www.exploringbinary.com/a-bug-in-the-bigcomp-function-of-david-gays-strtod/ 305 */ 306 ATF_TC(strtod_gherman_bug); 307 ATF_TC_HEAD(strtod_gherman_bug, tc) 308 { 309 atf_tc_set_md_var(tc, "descr", "Test a bug found by Geza Herman"); 310 } 311 312 ATF_TC_BODY(strtod_gherman_bug, tc) 313 { 314 315 const char *str = 316 "1.8254370818746402660437411213933955878019332885742187"; 317 318 errno = 0; 319 volatile double d = strtod(str, NULL); 320 321 ATF_CHECK(d == 0x1.d34fd8378ea83p+0); 322 } 323 324 ATF_TP_ADD_TCS(tp) 325 { 326 327 ATF_TP_ADD_TC(tp, strtod_basic); 328 ATF_TP_ADD_TC(tp, strtod_hex); 329 ATF_TP_ADD_TC(tp, strtod_inf); 330 ATF_TP_ADD_TC(tp, strtof_inf); 331 ATF_TP_ADD_TC(tp, strtold_inf); 332 ATF_TP_ADD_TC(tp, strtod_nan); 333 ATF_TP_ADD_TC(tp, strtof_nan); 334 ATF_TP_ADD_TC(tp, strtold_nan); 335 ATF_TP_ADD_TC(tp, strtod_round); 336 ATF_TP_ADD_TC(tp, strtod_underflow); 337 ATF_TP_ADD_TC(tp, strtod_gherman_bug); 338 339 return atf_no_error(); 340 } 341