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

   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 ATF_TC(strtod_basic);
  55 ATF_TC_HEAD(strtod_basic, tc)
  56 {
  57         atf_tc_set_md_var(tc, "descr", "A basic test of strtod(3)");
  58 }
  59
  60 ATF_TC_BODY(strtod_basic, tc)
  61 {
  62         static const size_t n = 1024 * 1000;
  63
  64         for (size_t i = 1; i < n; i = i + 1024) {
  65                 char buf[512];
  66                 (void)snprintf(buf, sizeof(buf), "%zu.%zu", i, i + 1);
  67
  68                 errno = 0;
  69                 double d = strtod(buf, NULL);
  70
  71                 ATF_REQUIRE(d > 0.0);
  72                 ATF_REQUIRE(errno == 0);
  73         }
  74 }
  75
  76 ATF_TC(strtod_hex);
  77 ATF_TC_HEAD(strtod_hex, tc)
  78 {
  79         atf_tc_set_md_var(tc, "descr", "A strtod(3) with hexadecimals");
  80 }
  81
  82 #ifdef __vax__
  83 #define SMALL_NUM       1.0e-38
  84 #else
  85 #define SMALL_NUM       1.0e-40
  86 #endif
  87
  88 ATF_TC_BODY(strtod_hex, tc)
  89 {
  90         const char *str;
  91         char *end;
  92         volatile double d;
  93
  94         str = "-0x0";
  95         d = strtod(str, &end);  /* -0.0 */
  96
  97         ATF_REQUIRE(end == str + 4);
  98         ATF_REQUIRE(signbit(d) != 0);
  99         ATF_REQUIRE(fabs(d) < SMALL_NUM);
 100
 101         str = "-0x";
 102         d = strtod(str, &end);  /* -0.0 */
 103
 104         ATF_REQUIRE(end == str + 2);
 105         ATF_REQUIRE(signbit(d) != 0);
 106         ATF_REQUIRE(fabs(d) < SMALL_NUM);
 107 }
 108
 109 ATF_TC(strtod_inf);
 110 ATF_TC_HEAD(strtod_inf, tc)
 111 {
 112         atf_tc_set_md_var(tc, "descr", "A strtod(3) with INF (PR lib/33262)");
 113 }
 114
 115 ATF_TC_BODY(strtod_inf, tc)
 116 {
 117 #ifndef __vax__
 118         for (size_t i = 0; i < __arraycount(inf_strings); i++) {
 119                 volatile double d = strtod(inf_strings[i], NULL);
 120                 ATF_REQUIRE(isinf(d) != 0);
 121         }
 122 #else
 123         atf_tc_skip("vax not supported");
 124 #endif
 125 }
 126
 127 ATF_TC(strtof_inf);
 128 ATF_TC_HEAD(strtof_inf, tc)
 129 {
 130         atf_tc_set_md_var(tc, "descr", "A strtof(3) with INF (PR lib/33262)");
 131 }
 132
 133 ATF_TC_BODY(strtof_inf, tc)
 134 {
 135 #ifndef __vax__
 136         for (size_t i = 0; i < __arraycount(inf_strings); i++) {
 137                 volatile float f = strtof(inf_strings[i], NULL);
 138                 ATF_REQUIRE(isinf(f) != 0);
 139         }
 140 #else
 141         atf_tc_skip("vax not supported");
 142 #endif
 143 }
 144
 145 ATF_TC(strtold_inf);
 146 ATF_TC_HEAD(strtold_inf, tc)
 147 {
 148         atf_tc_set_md_var(tc, "descr", "A strtold(3) with INF (PR lib/33262)");
 149 }
 150
 151 ATF_TC_BODY(strtold_inf, tc)
 152 {
 153 #ifndef __vax__
 154 #   ifdef __HAVE_LONG_DOUBLE
 155
 156         for (size_t i = 0; i < __arraycount(inf_strings); i++) {
 157                 volatile long double ld = strtold(inf_strings[i], NULL);
 158                 ATF_REQUIRE(isinf(ld) != 0);
 159         }
 160 #   else
 161         atf_tc_skip("Requires long double support");
 162 #   endif
 163 #else
 164         atf_tc_skip("vax not supported");
 165 #endif
 166 }
 167
 168 ATF_TC(strtod_nan);
 169 ATF_TC_HEAD(strtod_nan, tc)
 170 {
 171         atf_tc_set_md_var(tc, "descr", "A strtod(3) with NaN");
 172 }
 173
 174 ATF_TC_BODY(strtod_nan, tc)
 175 {
 176 #ifndef __vax__
 177         char *end;
 178
 179         volatile double d = strtod(nan_string, &end);
 180         ATF_REQUIRE(isnan(d) != 0);
 181         ATF_REQUIRE(strcmp(end, "y") == 0);
 182 #else
 183         atf_tc_skip("vax not supported");
 184 #endif
 185 }
 186
 187 ATF_TC(strtof_nan);
 188 ATF_TC_HEAD(strtof_nan, tc)
 189 {
 190         atf_tc_set_md_var(tc, "descr", "A strtof(3) with NaN");
 191 }
 192
 193 ATF_TC_BODY(strtof_nan, tc)
 194 {
 195 #ifndef __vax__
 196         char *end;
 197
 198         volatile float f = strtof(nan_string, &end);
 199         ATF_REQUIRE(isnanf(f) != 0);
 200         ATF_REQUIRE(strcmp(end, "y") == 0);
 201 #else
 202         atf_tc_skip("vax not supported");
 203 #endif
 204 }
 205
 206 ATF_TC(strtold_nan);
 207 ATF_TC_HEAD(strtold_nan, tc)
 208 {
 209         atf_tc_set_md_var(tc, "descr", "A strtold(3) with NaN (PR lib/45020)");
 210 }
 211
 212 ATF_TC_BODY(strtold_nan, tc)
 213 {
 214 #ifndef __vax__
 215 #   ifdef __HAVE_LONG_DOUBLE
 216
 217         char *end;
 218
 219         volatile long double ld = strtold(nan_string, &end);
 220         ATF_REQUIRE(isnan(ld) != 0);
 221 #ifndef __FreeBSD__
 222         ATF_REQUIRE(__isnanl(ld) != 0);
 223 #endif
 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 }