tests/lib/libc/stdlib/t_strtod.c

   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__)
  51 static const char * const inf_strings[] =
  52     { "Inf", "INF", "-Inf", "-INF", "Infinity", "+Infinity",
  53       "INFINITY", "-INFINITY", "InFiNiTy", "+InFiNiTy" };
  54 const char *nan_string = "NaN(x)y";
  55 #endif
  56
  57 ATF_TC(strtod_basic);
  58 ATF_TC_HEAD(strtod_basic, tc)
  59 {
  60         atf_tc_set_md_var(tc, "descr", "A basic test of strtod(3)");
  61 }
  62
  63 ATF_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
  79 ATF_TC(strtod_hex);
  80 ATF_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
  91 ATF_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
 112 ATF_TC(strtod_inf);
 113 ATF_TC_HEAD(strtod_inf, tc)
 114 {
 115         atf_tc_set_md_var(tc, "descr", "A strtod(3) with INF (PR lib/33262)");
 116 }
 117
 118 ATF_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
 130 ATF_TC(strtof_inf);
 131 ATF_TC_HEAD(strtof_inf, tc)
 132 {
 133         atf_tc_set_md_var(tc, "descr", "A strtof(3) with INF (PR lib/33262)");
 134 }
 135
 136 ATF_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
 148 ATF_TC(strtold_inf);
 149 ATF_TC_HEAD(strtold_inf, tc)
 150 {
 151         atf_tc_set_md_var(tc, "descr", "A strtold(3) with INF (PR lib/33262)");
 152 }
 153
 154 ATF_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
 171 ATF_TC(strtod_nan);
 172 ATF_TC_HEAD(strtod_nan, tc)
 173 {
 174         atf_tc_set_md_var(tc, "descr", "A strtod(3) with NaN");
 175 }
 176
 177 ATF_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
 190 ATF_TC(strtof_nan);
 191 ATF_TC_HEAD(strtof_nan, tc)
 192 {
 193         atf_tc_set_md_var(tc, "descr", "A strtof(3) with NaN");
 194 }
 195
 196 ATF_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
 209 ATF_TC(strtold_nan);
 210 ATF_TC_HEAD(strtold_nan, tc)
 211 {
 212         atf_tc_set_md_var(tc, "descr", "A strtold(3) with NaN (PR lib/45020)");
 213 }
 214
 215 ATF_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
 234 ATF_TC(strtod_round);
 235 ATF_TC_HEAD(strtod_round, tc)
 236 {
 237         atf_tc_set_md_var(tc, "descr", "Test rouding in strtod(3)");
 238 }
 239
 240 ATF_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
 270 ATF_TC(strtod_underflow);
 271 ATF_TC_HEAD(strtod_underflow, tc)
 272 {
 273         atf_tc_set_md_var(tc, "descr", "Test underflow in strtod(3)");
 274 }
 275
 276 ATF_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  */
 301 ATF_TC(strtod_gherman_bug);
 302 ATF_TC_HEAD(strtod_gherman_bug, tc)
 303 {
 304         atf_tc_set_md_var(tc, "descr", "Test a bug found by Geza Herman");
 305 }
 306
 307 ATF_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
 319 ATF_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 }