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