tests/lib/libc/stdlib/t_strtod.c

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