lib/libc/tests/stdio/scanfloat_test.c

   1 /*-
   2  * Copyright (C) 2003, 2005 David Schultz <das@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 /*
  28  * Test for scanf() floating point formats.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include <fenv.h>
  35 #include <float.h>
  36 #include <locale.h>
  37 #include <math.h>
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41
  42 #include <atf-c.h>
  43
  44 #define eq(type, a, b)  _eq(type##_EPSILON, (a), (b))
  45 static int
  46 _eq(long double epsilon, long double a, long double b)
  47 {
  48         long double delta;
  49
  50         delta = fabsl(a - b);
  51         return (delta <= epsilon);
  52 }
  53
  54 ATF_TC_WITHOUT_HEAD(normalized_numbers);
  55 ATF_TC_BODY(normalized_numbers, tc)
  56 {
  57         char buf[128];
  58         long double ld = 0.0;
  59         double d = 0.0;
  60         float f = 0.0;
  61
  62         buf[0] = '\0';
  63         ATF_REQUIRE(setlocale(LC_NUMERIC, ""));
  64
  65         sscanf("3.141592", "%e", &f);
  66         ATF_REQUIRE(eq(FLT, f, 3.141592));
  67
  68         sscanf("3.141592653589793", "%lf", &d);
  69         ATF_REQUIRE(eq(DBL, d, 3.141592653589793));
  70
  71         sscanf("1.234568e+06", "%E", &f);
  72         ATF_REQUIRE(eq(FLT, f, 1.234568e+06));
  73
  74         sscanf("-1.234568e6", "%lF", &d);
  75         ATF_REQUIRE(eq(DBL, d, -1.234568e6));
  76
  77         sscanf("+1.234568e-52", "%LG", &ld);
  78         ATF_REQUIRE(eq(LDBL, ld, 1.234568e-52L));
  79
  80         sscanf("0.1", "%la", &d);
  81         ATF_REQUIRE(eq(DBL, d, 0.1));
  82
  83         sscanf("00.2", "%lA", &d);
  84         ATF_REQUIRE(eq(DBL, d, 0.2));
  85
  86         sscanf("123456", "%5le%s", &d, buf);
  87         ATF_REQUIRE(eq(DBL, d, 12345.));
  88         ATF_REQUIRE(strcmp(buf, "6") == 0);
  89
  90         sscanf("1.0Q", "%*5le%s", buf);
  91         ATF_REQUIRE(strcmp(buf, "Q") == 0);
  92
  93         sscanf("-1.23e", "%e%s", &f, buf);
  94         ATF_REQUIRE(eq(FLT, f, -1.23));
  95         ATF_REQUIRE(strcmp(buf, "e") == 0);
  96
  97         sscanf("1.25e+", "%le%s", &d, buf);
  98         ATF_REQUIRE(eq(DBL, d, 1.25));
  99         ATF_REQUIRE(strcmp(buf, "e+") == 0);
 100
 101         sscanf("1.23E4E5", "%le%s", &d, buf);
 102         ATF_REQUIRE(eq(DBL, d, 1.23e4));
 103         ATF_REQUIRE(strcmp(buf, "E5") == 0);
 104
 105         sscanf("12e6", "%le", &d);
 106         ATF_REQUIRE(eq(DBL, d, 12e6));
 107
 108         sscanf("1.a", "%le%s", &d, buf);
 109         ATF_REQUIRE(eq(DBL, d, 1.0));
 110         ATF_REQUIRE(strcmp(buf, "a") == 0);
 111
 112         sscanf(".0p4", "%le%s", &d, buf);
 113         ATF_REQUIRE(eq(DBL, d, 0.0));
 114         ATF_REQUIRE(strcmp(buf, "p4") == 0);
 115
 116         d = 0.25;
 117         ATF_REQUIRE(sscanf(".", "%le", &d) == 0);
 118         ATF_REQUIRE(d == 0.25);
 119
 120         sscanf("0x08", "%le", &d);
 121         ATF_REQUIRE(d == 0x8p0);
 122
 123         sscanf("0x90a.bcdefP+09a", "%le%s", &d, buf);
 124         ATF_REQUIRE(d == 0x90a.bcdefp+09);
 125         ATF_REQUIRE(strcmp(buf, "a") == 0);
 126
 127 #if (LDBL_MANT_DIG > DBL_MANT_DIG) && !defined(__i386__)
 128         sscanf("3.14159265358979323846", "%Lg", &ld);
 129         ATF_REQUIRE(eq(LDBL, ld, 3.14159265358979323846L));
 130
 131         sscanf("  0X.0123456789abcdefffp-3g", "%Le%s", &ld, buf);
 132         ATF_REQUIRE(ld == 0x0.0123456789abcdefffp-3L);
 133         ATF_REQUIRE(strcmp(buf, "g") == 0);
 134 #endif
 135
 136         sscanf("0xg", "%le%s", &d, buf);
 137         ATF_REQUIRE(d == 0.0);
 138         ATF_REQUIRE(strcmp(buf, "xg") == 0);
 139
 140         ATF_REQUIRE(setlocale(LC_NUMERIC, "ru_RU.ISO8859-5")); /* decimalpoint==, */
 141
 142         sscanf("1.23", "%le%s", &d, buf);
 143         ATF_REQUIRE(d == 1.0);
 144         ATF_REQUIRE(strcmp(buf, ".23") == 0);
 145
 146         sscanf("1,23", "%le", &d);
 147         ATF_REQUIRE(d == 1.23);
 148
 149         ATF_REQUIRE(setlocale(LC_NUMERIC, ""));
 150 }
 151
 152 ATF_TC_WITHOUT_HEAD(infinities_and_nans);
 153 ATF_TC_BODY(infinities_and_nans, tc)
 154 {
 155         char buf[128];
 156         long double ld = 0.0;
 157         double d = 0.0;
 158         float f = 0.0;
 159
 160         ATF_REQUIRE(setlocale(LC_NUMERIC, "C"));
 161
 162         sscanf("-Inf", "%le", &d);
 163         ATF_REQUIRE(d < 0.0 && isinf(d));
 164
 165         sscanf("iNfInItY and beyond", "%le%s", &d, buf);
 166         ATF_REQUIRE(d > 0.0 && isinf(d));
 167         ATF_REQUIRE(strcmp(buf, " and beyond"));
 168
 169         sscanf("NaN", "%le", &d);
 170         ATF_REQUIRE(isnan(d));
 171
 172         sscanf("NAN(123Y", "%le%s", &d, buf);
 173         ATF_REQUIRE(isnan(d));
 174         ATF_REQUIRE(strcmp(buf, "(123Y") == 0);
 175
 176         sscanf("nan(f00f)plugh", "%le%s", &d, buf);
 177         ATF_REQUIRE(isnan(d));
 178         ATF_REQUIRE(strcmp(buf, "plugh") == 0);
 179
 180         sscanf("-nan", "%le", &d);
 181         ATF_REQUIRE(isnan(d));
 182
 183         /* Only quiet NaNs should be returned. */
 184         sscanf("NaN", "%e", &f);
 185         sscanf("nan", "%le", &d);
 186         sscanf("nan", "%Le", &ld);
 187         feclearexcept(FE_ALL_EXCEPT);
 188         ATF_REQUIRE(f != f);
 189         ATF_REQUIRE(d != d);
 190         ATF_REQUIRE(ld != ld);
 191         ATF_REQUIRE(fetestexcept(FE_INVALID) == 0);
 192         sscanf("nan(1234)", "%e", &f);
 193         sscanf("nan(1234)", "%le", &d);
 194         sscanf("nan(1234)", "%Le", &ld);
 195         feclearexcept(FE_ALL_EXCEPT);
 196         ATF_REQUIRE(f != f);
 197         ATF_REQUIRE(d != d);
 198         ATF_REQUIRE(ld != ld);
 199         /* POSIX says we should only generate quiet NaNs. */
 200         ATF_REQUIRE(fetestexcept(FE_INVALID) == 0);
 201 }
 202
 203 ATF_TC_WITHOUT_HEAD(rounding_tests);
 204 ATF_TC_BODY(rounding_tests, tc)
 205 {
 206         long double ld = 0.0;
 207         double d = 0.0;
 208
 209         ATF_REQUIRE(setlocale(LC_NUMERIC, "C"));
 210
 211         fesetround(FE_DOWNWARD);
 212
 213         sscanf("1.999999999999999999999999999999999", "%le", &d);
 214         ATF_REQUIRE(d < 2.0);
 215         sscanf("0x1.ffffffffffffffp0", "%le", &d);
 216         ATF_REQUIRE(d < 2.0);
 217         sscanf("1.999999999999999999999999999999999", "%Le", &ld);
 218         ATF_REQUIRE(ld < 2.0);
 219
 220         sscanf("1.0571892669084007", "%le", &d);
 221         ATF_REQUIRE(d == 0x1.0ea3f4af0dc59p0);
 222         sscanf("-1.0571892669084007", "%le", &d);
 223         ATF_REQUIRE(d == -0x1.0ea3f4af0dc5ap0);
 224         sscanf("1.0571892669084010", "%le", &d);
 225         ATF_REQUIRE(d == 0x1.0ea3f4af0dc5ap0);
 226
 227         sscanf("0x1.23p-5000", "%le", &d);
 228         ATF_REQUIRE(d == 0.0);
 229
 230         sscanf("0x1.2345678p-1050", "%le", &d);
 231         ATF_REQUIRE(d == 0x1.234567p-1050);
 232
 233         fesetround(FE_UPWARD);
 234
 235         sscanf("1.0571892669084007", "%le", &d);
 236         ATF_REQUIRE(d == 0x1.0ea3f4af0dc5ap0);
 237         sscanf("-1.0571892669084007", "%le", &d);
 238         ATF_REQUIRE(d == -0x1.0ea3f4af0dc59p0);
 239         sscanf("1.0571892669084010", "%le", &d);
 240         ATF_REQUIRE(d == 0x1.0ea3f4af0dc5bp0);
 241
 242         sscanf("0x1.23p-5000", "%le", &d);
 243         ATF_REQUIRE(d == 0x1p-1074);
 244
 245         sscanf("0x1.2345678p-1050", "%le", &d);
 246         ATF_REQUIRE(d == 0x1.234568p-1050);
 247
 248         fesetround(FE_TOWARDZERO);
 249
 250         sscanf("1.0571892669084007", "%le", &d);
 251         ATF_REQUIRE(d == 0x1.0ea3f4af0dc59p0);
 252         sscanf("-1.0571892669084007", "%le", &d);
 253         ATF_REQUIRE(d == -0x1.0ea3f4af0dc59p0);
 254         sscanf("1.0571892669084010", "%le", &d);
 255         ATF_REQUIRE(d == 0x1.0ea3f4af0dc5ap0);
 256
 257         sscanf("0x1.23p-5000", "%le", &d);
 258         ATF_REQUIRE(d == 0.0);
 259
 260         sscanf("0x1.2345678p-1050", "%le", &d);
 261         ATF_REQUIRE(d == 0x1.234567p-1050);
 262
 263         fesetround(FE_TONEAREST);
 264
 265         /* 1.0571892669084007 is slightly closer to 0x1.0ea3f4af0dc59p0 */
 266         sscanf("1.0571892669084007", "%le", &d);
 267         ATF_REQUIRE(d == 0x1.0ea3f4af0dc59p0);
 268         sscanf("-1.0571892669084007", "%le", &d);
 269         ATF_REQUIRE(d == -0x1.0ea3f4af0dc59p0);
 270         sscanf("1.0571892669084010", "%le", &d);
 271         ATF_REQUIRE(d == 0x1.0ea3f4af0dc5bp0);
 272
 273         /* strtod() should round small numbers to 0. */
 274         sscanf("0x1.23p-5000", "%le", &d);
 275         ATF_REQUIRE(d == 0.0);
 276
 277         /* Extra digits in a denormal shouldn't break anything. */
 278         sscanf("0x1.2345678p-1050", "%le", &d);
 279         ATF_REQUIRE(d == 0x1.234568p-1050);
 280 }
 281
 282 ATF_TC_WITHOUT_HEAD(strtod);
 283 ATF_TC_BODY(strtod, tc)
 284 {
 285         char *endp;
 286
 287         ATF_REQUIRE(setlocale(LC_NUMERIC, "C"));
 288
 289         ATF_REQUIRE(strtod("0xy", &endp) == 0);
 290         ATF_REQUIRE(strcmp("xy", endp) == 0);
 291
 292         /* This used to cause an infinite loop and round the wrong way. */
 293         fesetround(FE_DOWNWARD);
 294         ATF_REQUIRE(strtof("3.5e38", &endp) == FLT_MAX);
 295         ATF_REQUIRE(strtod("2e308", &endp) == DBL_MAX);
 296         fesetround(FE_UPWARD);
 297         ATF_REQUIRE(strtof("3.5e38", &endp) == INFINITY);
 298         ATF_REQUIRE(strtod("2e308", &endp) == INFINITY);
 299         fesetround(FE_TOWARDZERO);
 300         ATF_REQUIRE(strtof("3.5e38", &endp) == FLT_MAX);
 301         ATF_REQUIRE(strtod("2e308", &endp) == DBL_MAX);
 302         fesetround(FE_TONEAREST);
 303         ATF_REQUIRE(strtof("3.5e38", &endp) == INFINITY);
 304         ATF_REQUIRE(strtod("2e308", &endp) == INFINITY);
 305 }
 306
 307 ATF_TP_ADD_TCS(tp)
 308 {
 309
 310         ATF_TP_ADD_TC(tp, normalized_numbers);
 311         ATF_TP_ADD_TC(tp, infinities_and_nans);
 312         ATF_TP_ADD_TC(tp, rounding_tests);
 313         ATF_TP_ADD_TC(tp, strtod);
 314
 315         return (atf_no_error());
 316 }