/* Test for correct rounding of results of strtod and related
functions.
Copyright (C) 2012-2018 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
#define __STDC_WANT_IEC_60559_TYPES_EXT__
#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_f32(f,...) f
#define CHOOSE_d(f,d,...) d
#define CHOOSE_f64(f,d,...) d
#define CHOOSE_f32x(f,d,...) d
#define CHOOSE_f128(f,d,ld64i,ld64m,ld106,ld113,...) ld113
/* long double is special, and handled above. _Float16 would require
updates to the generator to generate appropriate expectations, and
updates to the test inputs to cover difficult rounding cases for
_Float16. */
#if __HAVE_FLOAT64X
# if FLT64X_MANT_DIG == 113 && FLT64X_MAX_EXP == 16384
# define CHOOSE_f64x(f,d,ld64i,ld64m,ld106,ld113,...) ld113
# elif (FLT64X_MANT_DIG == 64 \
&& FLT64X_MAX_EXP == 16384 \
&& FLT64X_MIN_EXP == -16381)
# define CHOOSE_f64x(f,d,ld64i,...) ld64i
# else
# error "unknown _Float64x format"
# endif
#endif
/* 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 and that for
overflow. */
#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, fdo, fn, fno, fz, fzo, fu, fuo, \
dx, dd, ddo, dn, dno, dz, dzo, du, duo, \
ld64ix, ld64id, ld64ido, ld64in, ld64ino, \
ld64iz, ld64izo, ld64iu, ld64iuo, \
ld64mx, ld64md, ld64mdo, ld64mn, ld64mno, \
ld64mz, ld64mzo, ld64mu, ld64muo, \
ld106x, ld106d, ld106do, ld106n, ld106no, \
ld106z, ld106zo, ld106u, ld106uo, \
ld113x, ld113d, ld113do, ld113n, ld113no, \
ld113z, ld113zo, ld113u, ld113uo) \
{ \
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) } \
}, \
{ \
{ XNTRY (fno, dno, ld64ino, ld64mno, ld106no, ld113no) }, \
{ XNTRY (fdo, ddo, ld64ido, ld64mdo, ld106do, ld113do) }, \
{ XNTRY (fzo, dzo, ld64izo, ld64mzo, ld106zo, ld113zo) }, \
{ XNTRY (fuo, duo, ld64iuo, ld64muo, ld106uo, ld113uo) } \
} \
}
struct test_exactness
{
STRUCT_FOREACH_FLOAT_BOOL
};
struct test_results
{
STRUCT_FOREACH_FLOAT_FTYPE
};
struct test_overflow
{
STRUCT_FOREACH_FLOAT_BOOL
};
struct test {
const CHAR *s;
struct test_exactness exact;
struct test_results r[4];
struct test_overflow o[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
#ifndef FE_OVERFLOW
# define FE_OVERFLOW 0
#endif
#define GEN_ONE_TEST(FSUF, FTYPE, FTOSTR, LSUF, CSUF) \
{ \
feclearexcept (FE_ALL_EXCEPT); \
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"); \
} \
} \
if (FE_OVERFLOW != 0) \
{ \
bool overflow_raised \
= fetestexcept (FE_OVERFLOW) != 0; \
if (overflow_raised != overflow->FSUF) \
{ \
printf (FNPFXS "to" #FSUF \
" (" STRM ") overflow %d " \
"not %d\n", s, overflow_raised, \
overflow->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 struct test_overflow *overflow,
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, &tests[i].o[modes[0].rnd_i],
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,
&tests[i].o[m->rnd_i], m->mode_name,
m->rnd_mode);
fesetround (save_round_mode);
}
}
}
return result;
}
#define TEST_FUNCTION do_test ()
#include "../test-skeleton.c"