contrib/netbsd-tests/lib/libc/stdlib/t_strtod.c

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