/* Test for correct rounding of results of strtod and related functions. Copyright (C) 2012-2017 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ /* Defining _LIBC_TEST ensures long double math functions are declared in the headers. */ #define _LIBC_TEST 1 #include <fenv.h> #include <float.h> #include <math.h> #include <stdbool.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <math-tests.h> #include "tst-strtod.h" /* Non-standard macros expected to be externally defined: L_(str): Pastes the appropriate modifier to a string literal str. FNPFX: Expands to the correct prefix for the strtod equivalent of type CHAR. (e.g str or wcs). CHAR: Expands to the string type being tested (e.g wchar_t or char). STRM: Expands to a string literal suitable for printing CHAR* via printf (e.g "%s" or "%ls"). */ #define _CONCAT(a, b) a ## b #define CONCAT(a, b) _CONCAT (a, b) #define STRTO(x) CONCAT (CONCAT (FNPFX, to), x) #if LDBL_MANT_DIG == 106 && LDBL_MAX_EXP == 1024 /* This is a stupid hack for IBM long double. This test ignores inexact values for long double due to the limitations of the format. This ensures rounding tests are ignored. */ # undef ROUNDING_TESTS_long_double # define ROUNDING_TESTS_long_double(x) 0 #endif /* Generator to create an FTYPE member variabled named FSUF used to populate struct member variables. */ #define FTYPE_MEMBER(FSUF, FTYPE, FTOSTR, LSUF, CSUF) \ FTYPE FSUF; /* Likewise, but each member is of type bool. */ #define BOOL_MEMBER(FSUF, FTYPE, FTOSTR, LSUF, CSUF) \ bool FSUF; #define STRUCT_FOREACH_FLOAT_FTYPE GEN_TEST_STRTOD_FOREACH (FTYPE_MEMBER) #define STRUCT_FOREACH_FLOAT_BOOL GEN_TEST_STRTOD_FOREACH (BOOL_MEMBER) /* Define the long double choose (CHOOSE_ld) macro to select the appropriate generated long double value from the generated test data. */ #if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024 /* This is for the long double == double format. */ # define CHOOSE_ld(f,d,...) d #elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 && LDBL_MIN_EXP == -16381 /* This is for the Intel extended float format. */ # define CHOOSE_ld(f,d,ld64i,...) ld64i #elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 && LDBL_MIN_EXP == -16382 /* This is for the Motorola extended float format. */ # define CHOOSE_ld(f,d,ld64i,ld64m,...) ld64m #elif LDBL_MANT_DIG == 106 && LDBL_MAX_EXP == 1024 /* This is for the IBM extended double format. */ # define CHOOSE_ld(f,d,ld64i,ld64m,ld106,...) ld106 #elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384 /* This is for the IEEE binary128 format. */ # define CHOOSE_ld(f,d,ld64i,ld64m,ld106,ld113,...) ld113 #else # error "unknown long double format" #endif /* Add type specific choosing macros below. */ #define CHOOSE_f(f,...) f #define CHOOSE_d(f,d,...) d #define CHOOSE_f128(f,d,ld64i,ld64m,ld106,ld113,...) ld113 /* long double is special, and handled above. */ /* Selector for expected result field of a given type. */ #define _ENTRY(FSUF, FTYPE, FTOSTR, LSUF, CSUF, ...) \ CONCAT (CHOOSE_ ## FSUF (__VA_ARGS__), LSUF), #define ENTRY(...) \ GEN_TEST_STRTOD_FOREACH (_ENTRY, __VA_ARGS__) /* Selector for boolean exact tag of expected results. */ #define _XNTRY(FSUF, FTYPE, FTOSTR, LSUF, CSUF, ...) \ CHOOSE_ ## FSUF (__VA_ARGS__), #define XNTRY(...) \ GEN_TEST_STRTOD_FOREACH (_XNTRY, __VA_ARGS__) /* This is hacky way around the seemingly unavoidable macro expansion of the INFINITY or HUGE_VAL like macros in the above. It is assumed the compiler will implicitly convert the infinity correctly. */ #define INF INFINITY + 0.0 /* This macro is used in conjunction with the output from the gen-tst-strtod-round utility to select the appropriately rounded long double value for a given format. */ #define TEST(s, \ fx, fd, fn, fz, fu, \ dx, dd, dn, dz, du, \ ld64ix, ld64id, ld64in, ld64iz, ld64iu, \ ld64mx, ld64md, ld64mn, ld64mz, ld64mu, \ ld106x, ld106d, ld106n, ld106z, ld106u, \ ld113x, ld113d, ld113n, ld113z, ld113u) \ { \ L_ (s), \ { XNTRY (fx, dx, ld64ix, ld64mx, ld106x, ld113x) }, \ { \ { ENTRY (fn, dn, ld64in, ld64mn, ld106n, ld113n) }, \ { ENTRY (fd, dd, ld64id, ld64md, ld106d, ld113d) }, \ { ENTRY (fz, dz, ld64iz, ld64mz, ld106z, ld113z) }, \ { ENTRY (fu, du, ld64iu, ld64mu, ld106u, ld113u) } \ } \ } struct test_exactness { STRUCT_FOREACH_FLOAT_BOOL }; struct test_results { STRUCT_FOREACH_FLOAT_FTYPE }; struct test { const CHAR *s; struct test_exactness exact; struct test_results r[4]; }; /* Include the generated test data. */ #include "tst-strtod-round-data.h" #define STRX(x) #x #define STR(x) STRX (x) #define FNPFXS STR (FNPFX) #ifndef FE_INEXACT # define FE_INEXACT 0 #endif #define GEN_ONE_TEST(FSUF, FTYPE, FTOSTR, LSUF, CSUF) \ { \ feclearexcept (FE_INEXACT); \ FTYPE f = STRTO (FSUF) (s, NULL); \ if (f != expected->FSUF \ || (copysign ## CSUF) (1.0 ## LSUF, f) \ != (copysign ## CSUF) (1.0 ## LSUF, expected->FSUF)) \ { \ char efstr[FSTRLENMAX]; \ char fstr[FSTRLENMAX]; \ FTOSTR (efstr, FSTRLENMAX, "%a", expected->FSUF); \ FTOSTR (fstr, FSTRLENMAX, "%a", f); \ printf (FNPFXS "to" #FSUF " (" STRM ") returned %s not " \ "%s (%s)\n", s, fstr, efstr, mode_name); \ if (ROUNDING_TESTS (FTYPE, rnd_mode) || exact->FSUF) \ result = 1; \ else \ printf ("ignoring this inexact result\n"); \ } \ else if (FE_INEXACT != 0) \ { \ bool inexact_raised = fetestexcept (FE_INEXACT) != 0; \ if (inexact_raised != !exact->FSUF) \ { \ printf (FNPFXS "to" #FSUF " (" STRM ") inexact %d " \ "not %d\n", s, inexact_raised, !exact->FSUF); \ if (EXCEPTION_TESTS (FTYPE)) \ result = 1; \ else \ printf ("ignoring this exception error\n"); \ } \ } \ } static int test_in_one_mode (const CHAR *s, const struct test_results *expected, const struct test_exactness *exact, const char *mode_name, int rnd_mode) { int result = 0; GEN_TEST_STRTOD_FOREACH (GEN_ONE_TEST) return result; } static const struct fetestmodes { const char *mode_name; int rnd_mode; int rnd_i; /* Corresponding index into r array of struct test. */ } modes[] = { { "default rounding mode", FE_TONEAREST, 0 }, #ifdef FE_DOWNWARD { "FE_DOWNWARD", FE_DOWNWARD, 1 }, #endif #ifdef FE_TOWARDZERO { "FE_TOWARDZERO", FE_TOWARDZERO, 2 }, #endif #ifdef FE_UPWARD { "FE_UPWARD", FE_UPWARD, 3 }, #endif {} }; static int do_test (void) { int save_round_mode __attribute__ ((unused)) = fegetround (); int result = 0; for (size_t i = 0; i < sizeof (tests) / sizeof (tests[0]); i++) { result |= test_in_one_mode (tests[i].s, &tests[i].r[modes[0].rnd_i], &tests[i].exact, modes[0].mode_name, modes[0].rnd_mode); for (const struct fetestmodes *m = &modes[1]; m->mode_name != NULL; m++) { if (!fesetround (m->rnd_mode)) { result |= test_in_one_mode (tests[i].s, &tests[i].r[m->rnd_i], &tests[i].exact, m->mode_name, m->rnd_mode); fesetround (save_round_mode); } } } return result; } #define TEST_FUNCTION do_test () #include "../test-skeleton.c"