This is the mail archive of the
libc-alpha@sourceware.org
mailing list for the glibc project.
Integrate errno testing better in libm-test.inc
- From: "Joseph S. Myers" <joseph at codesourcery dot com>
- To: <libc-alpha at sourceware dot org>
- Date: Mon, 29 Apr 2013 14:43:03 +0000
- Subject: Integrate errno testing better in libm-test.inc
At present, tests for errno setting in libm-test.inc use ad hoc calls
to check_int after another test, with errno being set to 0 manually
before the test.
This patch changes these tests to use flags ERRNO_UNCHANGED,
ERRNO_EDOM and ERRNO_ERANGE, like the tests for exceptions. In
principle I think most tests should describe the logical error
condition, e.g. OVERFLOW_ERROR, UNDERFLOW_ERROR, DOMAIN_ERROR or
POLE_ERROR, which would map to a combination of exception and errno
flags, rather than describing exception and errno handling separately
like this (and the default would be unchanged errno expected, unless
flags said a given errno value is permitted), but for now the existing
errno tests are just converted directly to use the new flags. Tested
x86_64.
Converting to describe logical errors would probably be easier if more
of the known problems with errno setting were fixed. Is anyone
interested in going through those bugs (6785, 6786, 6787, 6792, 6793,
6795, 6796, 6797, 6798, 6799, 6801, 6802, 6803, 6804, 6807, 6809, 6810
- about a third of the open "math" bugs)? I expect most of them
should be straightforward to fix, and you can ask architecture
maintainers for help fixing architecture-specific versions of the
functions as needed.
2013-04-29 Joseph Myers <joseph@codesourcery.com>
* math/libm-test.inc (ERRNO_UNCHANGED): New macro.
(ERRNO_EDOM): Likewise.
(ERRNO_ERANGE): Likewise.
(noErrnoTests): New variable.
(init_max_error): Set errno to 0.
(test_single_errno): New function.
(test_errno): Likewise.
(check_float_internal): Call test_errno. Set errno to 0.
(check_complex): Refer to errno tests in comment.
(check_int): Call test_errno. Set errno to 0.
(check_long): Likewise.
(check_bool): Likewise.
(check_longlong): Likewise.
(cos_test): Use ERRNO_* flags for errno tests instead of
check_int.
(expm1_test): Likewise.
(fmod_test): Likewise.
(ilogb_test): Likewise.
(lgamma_test): Likewise.
(pow_test): Likewise.
(remainder_test): Likewise.
(sin_test): Likewise.
(tan_test): Likewise.
(yn_test): Likewise.
(initialize): Set errno to 0.
(main): Print number of errno tests.
* math/gen-libm-test.pl (parse_args): Allow ERRNO flags on tests.
diff --git a/math/gen-libm-test.pl b/math/gen-libm-test.pl
index aa60d9d..f6ed1a8 100755
--- a/math/gen-libm-test.pl
+++ b/math/gen-libm-test.pl
@@ -295,7 +295,7 @@ sub parse_args {
# consistency check
if ($current_arg == $#args) {
die ("wrong number of arguments")
- unless ($args[$current_arg] =~ /EXCEPTION|IGNORE_ZERO_INF_SIGN/);
+ unless ($args[$current_arg] =~ /EXCEPTION|ERRNO|IGNORE_ZERO_INF_SIGN/);
} elsif ($current_arg < $#args) {
die ("wrong number of arguments");
} elsif ($current_arg > ($#args+1)) {
diff --git a/math/libm-test.inc b/math/libm-test.inc
index a54c3b3..b82c592 100644
--- a/math/libm-test.inc
+++ b/math/libm-test.inc
@@ -163,6 +163,10 @@
#define EXCEPTIONS_OK INVALID_EXCEPTION_OK+DIVIDE_BY_ZERO_EXCEPTION_OK
/* Some special test flags, passed together with exceptions. */
#define IGNORE_ZERO_INF_SIGN 0x100
+/* Indicate errno settings required or disallowed. */
+#define ERRNO_UNCHANGED 0x200
+#define ERRNO_EDOM 0x400
+#define ERRNO_ERANGE 0x800
/* Values underflowing only for float. */
#ifdef TEST_FLOAT
@@ -218,6 +222,7 @@ static char *output_dir; /* Directory where generated files will be written. */
static int noErrors; /* number of errors */
static int noTests; /* number of tests (without testing exceptions) */
static int noExcTests; /* number of tests for exception flags */
+static int noErrnoTests;/* number of tests for errno values */
static int noXFails; /* number of expected failures. */
static int noXPasses; /* number of unexpected passes. */
@@ -256,6 +261,7 @@ init_max_error (void)
real_max_error = 0;
imag_max_error = 0;
feclearexcept (FE_ALL_EXCEPT);
+ errno = 0;
}
static void
@@ -536,6 +542,40 @@ test_exceptions (const char *test_name, int exception)
feclearexcept (FE_ALL_EXCEPT);
}
+/* Test whether errno for TEST_NAME, set to ERRNO_VALUE, has value
+ EXPECTED_VALUE (description EXPECTED_NAME). */
+static void
+test_single_errno (const char *test_name, int errno_value,
+ int expected_value, const char *expected_name)
+{
+ if (errno_value == expected_value)
+ {
+ if (print_screen (1, 0))
+ printf ("Pass: %s: errno set to %d (%s)\n", test_name, errno_value,
+ expected_name);
+ }
+ else
+ {
+ ++noErrors;
+ if (print_screen (0, 0))
+ printf ("Failure: %s: errno set to %d, expected %d (%s)\n",
+ test_name, errno_value, expected_value, expected_name);
+ }
+}
+
+/* Test whether errno (value ERRNO_VALUE) has been for TEST_NAME set
+ as required by EXCEPTIONS. */
+static void
+test_errno (const char *test_name, int errno_value, int exceptions)
+{
+ ++noErrnoTests;
+ if (exceptions & ERRNO_UNCHANGED)
+ test_single_errno (test_name, errno_value, 0, "unchanged");
+ if (exceptions & ERRNO_EDOM)
+ test_single_errno (test_name, errno_value, EDOM, "EDOM");
+ if (exceptions & ERRNO_ERANGE)
+ test_single_errno (test_name, errno_value, ERANGE, "ERANGE");
+}
static void
check_float_internal (const char *test_name, FLOAT computed, FLOAT expected,
@@ -546,8 +586,10 @@ check_float_internal (const char *test_name, FLOAT computed, FLOAT expected,
int print_diff = 0;
FLOAT diff = 0;
FLOAT ulp = 0;
+ int errno_value = errno;
test_exceptions (test_name, exceptions);
+ test_errno (test_name, errno_value, exceptions);
if (issignaling (computed) && issignaling (expected))
ok = 1;
else if (issignaling (computed) || issignaling (expected))
@@ -628,6 +670,7 @@ check_float_internal (const char *test_name, FLOAT computed, FLOAT expected,
update_stats (ok, xfail);
fpstack_test (test_name);
+ errno = 0;
}
@@ -670,7 +713,7 @@ check_complex (const char *test_name, __complex__ FLOAT computed,
part_max_ulp = __imag__ max_ulp;
part_xfail = __imag__ xfail;
- /* Don't check again for exceptions, just pass through the
+ /* Don't check again for exceptions or errno, just pass through the
zero/inf sign test. */
check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
exception & IGNORE_ZERO_INF_SIGN,
@@ -686,8 +729,10 @@ check_int (const char *test_name, int computed, int expected, int max_ulp,
{
int diff = computed - expected;
int ok = 0;
+ int errno_value = errno;
test_exceptions (test_name, exceptions);
+ test_errno (test_name, errno_value, exceptions);
noTests++;
if (abs (diff) <= max_ulp)
ok = 1;
@@ -707,6 +752,7 @@ check_int (const char *test_name, int computed, int expected, int max_ulp,
update_stats (ok, xfail);
fpstack_test (test_name);
+ errno = 0;
}
@@ -717,8 +763,10 @@ check_long (const char *test_name, long int computed, long int expected,
{
long int diff = computed - expected;
int ok = 0;
+ int errno_value = errno;
test_exceptions (test_name, exceptions);
+ test_errno (test_name, errno_value, exceptions);
noTests++;
if (labs (diff) <= max_ulp)
ok = 1;
@@ -738,6 +786,7 @@ check_long (const char *test_name, long int computed, long int expected,
update_stats (ok, xfail);
fpstack_test (test_name);
+ errno = 0;
}
@@ -747,8 +796,10 @@ check_bool (const char *test_name, int computed, int expected,
long int max_ulp, int xfail, int exceptions)
{
int ok = 0;
+ int errno_value = errno;
test_exceptions (test_name, exceptions);
+ test_errno (test_name, errno_value, exceptions);
noTests++;
if ((computed == 0) == (expected == 0))
ok = 1;
@@ -765,6 +816,7 @@ check_bool (const char *test_name, int computed, int expected,
update_stats (ok, xfail);
fpstack_test (test_name);
+ errno = 0;
}
@@ -777,8 +829,10 @@ check_longlong (const char *test_name, long long int computed,
{
long long int diff = computed - expected;
int ok = 0;
+ int errno_value = errno;
test_exceptions (test_name, exceptions);
+ test_errno (test_name, errno_value, exceptions);
noTests++;
if (llabs (diff) <= max_ulp)
ok = 1;
@@ -798,6 +852,7 @@ check_longlong (const char *test_name, long long int computed,
update_stats (ok, xfail);
fpstack_test (test_name);
+ errno = 0;
}
@@ -5584,15 +5639,9 @@ cos_test (void)
TEST_f_f (cos, 0, 1);
TEST_f_f (cos, minus_zero, 1);
- errno = 0;
- TEST_f_f (cos, plus_infty, qnan_value, INVALID_EXCEPTION);
- check_int ("errno for cos(+inf) == EDOM", errno, EDOM, 0, 0, 0);
- errno = 0;
- TEST_f_f (cos, minus_infty, qnan_value, INVALID_EXCEPTION);
- check_int ("errno for cos(-inf) == EDOM", errno, EDOM, 0, 0, 0);
- errno = 0;
- TEST_f_f (cos, qnan_value, qnan_value);
- check_int ("errno for cos(qNaN) unchanged", errno, 0, 0, 0, 0);
+ TEST_f_f (cos, plus_infty, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM);
+ TEST_f_f (cos, minus_infty, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM);
+ TEST_f_f (cos, qnan_value, qnan_value, ERRNO_UNCHANGED);
TEST_f_f (cos, M_PI_6l * 2.0, 0.5);
TEST_f_f (cos, M_PI_6l * 4.0, -0.5);
@@ -7118,9 +7167,7 @@ expm1_test (void)
TEST_f_f (expm1, -10000.0, -1.0);
TEST_f_f (expm1, -100000.0, -1.0);
- errno = 0;
- TEST_f_f (expm1, 100000.0, plus_infty, OVERFLOW_EXCEPTION);
- check_int ("errno for expm1(large) == ERANGE", errno, ERANGE, 0, 0, 0);
+ TEST_f_f (expm1, 100000.0, plus_infty, OVERFLOW_EXCEPTION|ERRNO_ERANGE);
TEST_f_f (expm1, max_value, plus_infty, OVERFLOW_EXCEPTION);
TEST_f_f (expm1, -max_value, -1);
@@ -8346,17 +8393,11 @@ fmod_test (void)
TEST_ff_f (fmod, minus_zero, 3, minus_zero);
/* fmod (+inf, y) == qNaN plus invalid exception. */
- errno = 0;
- TEST_ff_f (fmod, plus_infty, 3, qnan_value, INVALID_EXCEPTION);
- check_int ("errno for fmod(Inf,3) unchanged", errno, EDOM, 0, 0, 0);
+ TEST_ff_f (fmod, plus_infty, 3, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM);
/* fmod (-inf, y) == qNaN plus invalid exception. */
- errno = 0;
- TEST_ff_f (fmod, minus_infty, 3, qnan_value, INVALID_EXCEPTION);
- check_int ("errno for fmod(-Inf,3) unchanged", errno, EDOM, 0, 0, 0);
+ TEST_ff_f (fmod, minus_infty, 3, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM);
/* fmod (x, +0) == qNaN plus invalid exception. */
- errno = 0;
- TEST_ff_f (fmod, 3, 0, qnan_value, INVALID_EXCEPTION);
- check_int ("errno for fmod(3,0) unchanged", errno, EDOM, 0, 0, 0);
+ TEST_ff_f (fmod, 3, 0, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM);
/* fmod (x, -0) == qNaN plus invalid exception. */
TEST_ff_f (fmod, 3, minus_zero, qnan_value, INVALID_EXCEPTION);
@@ -8522,21 +8563,13 @@ ilogb_test (void)
TEST_f_i (ilogb, -2000, 10);
/* ilogb (0.0) == FP_ILOGB0 plus invalid exception */
- errno = 0;
- TEST_f_i (ilogb, 0.0, FP_ILOGB0, INVALID_EXCEPTION);
- check_int ("errno for ilogb(0.0) unchanged", errno, EDOM, 0, 0, 0);
+ TEST_f_i (ilogb, 0.0, FP_ILOGB0, INVALID_EXCEPTION|ERRNO_EDOM);
/* ilogb (qNaN) == FP_ILOGBNAN plus invalid exception */
- errno = 0;
- TEST_f_i (ilogb, qnan_value, FP_ILOGBNAN, INVALID_EXCEPTION);
- check_int ("errno for ilogb(qNaN) unchanged", errno, EDOM, 0, 0, 0);
+ TEST_f_i (ilogb, qnan_value, FP_ILOGBNAN, INVALID_EXCEPTION|ERRNO_EDOM);
/* ilogb (inf) == INT_MAX plus invalid exception */
- errno = 0;
- TEST_f_i (ilogb, plus_infty, INT_MAX, INVALID_EXCEPTION);
- check_int ("errno for ilogb(Inf) unchanged", errno, EDOM, 0, 0, 0);
+ TEST_f_i (ilogb, plus_infty, INT_MAX, INVALID_EXCEPTION|ERRNO_EDOM);
/* ilogb (-inf) == INT_MAX plus invalid exception */
- errno = 0;
- TEST_f_i (ilogb, minus_infty, INT_MAX, INVALID_EXCEPTION);
- check_int ("errno for ilogb(-Inf) unchanged", errno, EDOM, 0, 0, 0);
+ TEST_f_i (ilogb, minus_infty, INT_MAX, INVALID_EXCEPTION|ERRNO_EDOM);
END (ilogb);
}
@@ -8991,9 +9024,7 @@ lgamma_test (void)
TEST_f_f (lgamma, qnan_value, qnan_value);
/* lgamma (x) == +inf plus divide by zero exception for integer x <= 0. */
- errno = 0;
- TEST_f_f (lgamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for lgamma(-integer) == ERANGE", errno, ERANGE, 0, 0, 0);
+ TEST_f_f (lgamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
TEST_f_f (lgamma, minus_infty, plus_infty);
TEST_f_f (lgamma, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
TEST_f_f (lgamma, max_value, plus_infty, OVERFLOW_EXCEPTION);
@@ -10648,119 +10679,58 @@ pow_test (void)
TEST_ff_f (pow, -1.0L, min_subnorm_value, qnan_value, INVALID_EXCEPTION);
TEST_ff_f (pow, -1.0L, -min_subnorm_value, qnan_value, INVALID_EXCEPTION);
- errno = 0;
- TEST_ff_f (pow, 0, -1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
- errno = 0;
- TEST_ff_f (pow, 0, -11, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
- errno = 0;
- TEST_ff_f (pow, 0, -0xffffff, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
+ TEST_ff_f (pow, 0, -1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
+ TEST_ff_f (pow, 0, -11, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
+ TEST_ff_f (pow, 0, -0xffffff, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
#ifndef TEST_FLOAT
- errno = 0;
- TEST_ff_f (pow, 0, -0x1.fffffffffffffp+52L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
+ TEST_ff_f (pow, 0, -0x1.fffffffffffffp+52L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
#endif
#ifdef TEST_LDOUBLE
# if LDBL_MANT_DIG >= 64
- errno = 0;
- TEST_ff_f (pow, 0, -0x1.fffffffffffffffep+63L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
+ TEST_ff_f (pow, 0, -0x1.fffffffffffffffep+63L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
# endif
# if LDBL_MANT_DIG >= 106
- errno = 0;
- TEST_ff_f (pow, 0, -0x1.ffffffffffffffffffffffffff8p+105L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
+ TEST_ff_f (pow, 0, -0x1.ffffffffffffffffffffffffff8p+105L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
# endif
# if LDBL_MANT_DIG >= 113
- errno = 0;
- TEST_ff_f (pow, 0, -0x1.ffffffffffffffffffffffffffffp+112L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
+ TEST_ff_f (pow, 0, -0x1.ffffffffffffffffffffffffffffp+112L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
# endif
#endif
- TEST_ff_f (pow, minus_zero, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
- errno = 0;
- TEST_ff_f (pow, minus_zero, -11L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
- errno = 0;
- TEST_ff_f (pow, minus_zero, -0xffffff, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
- errno = 0;
- TEST_ff_f (pow, minus_zero, -0x1fffffe, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
+ TEST_ff_f (pow, minus_zero, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
+ TEST_ff_f (pow, minus_zero, -11L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
+ TEST_ff_f (pow, minus_zero, -0xffffff, minus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
+ TEST_ff_f (pow, minus_zero, -0x1fffffe, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
#ifndef TEST_FLOAT
- errno = 0;
- TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffp+52L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
- errno = 0;
- TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffp+53L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
+ TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffp+52L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
+ TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffp+53L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
#endif
#ifdef TEST_LDOUBLE
# if LDBL_MANT_DIG >= 64
- errno = 0;
- TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffffep+63L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
- errno = 0;
- TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffffep+64L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
+ TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffffep+63L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
+ TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffffep+64L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
# endif
# if LDBL_MANT_DIG >= 106
- errno = 0;
- TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
- errno = 0;
- TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
+ TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
+ TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
# endif
# if LDBL_MANT_DIG >= 113
- errno = 0;
- TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
- errno = 0;
- TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
+ TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
+ TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
# endif
#endif
- errno = 0;
- TEST_ff_f (pow, 0, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
- errno = 0;
- TEST_ff_f (pow, 0, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
- errno = 0;
- TEST_ff_f (pow, 0, -min_subnorm_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
- errno = 0;
- TEST_ff_f (pow, 0, -0x1p24, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
- errno = 0;
- TEST_ff_f (pow, 0, -0x1p127, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
- errno = 0;
- TEST_ff_f (pow, 0, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
- errno = 0;
- TEST_ff_f (pow, minus_zero, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
- errno = 0;
- TEST_ff_f (pow, minus_zero, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
- errno = 0;
- TEST_ff_f (pow, minus_zero, -min_subnorm_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
- errno = 0;
- TEST_ff_f (pow, minus_zero, -0x1p24, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
- errno = 0;
- TEST_ff_f (pow, minus_zero, -0x1p127, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
- errno = 0;
- TEST_ff_f (pow, minus_zero, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
- check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
+ TEST_ff_f (pow, 0, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
+ TEST_ff_f (pow, 0, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
+ TEST_ff_f (pow, 0, -min_subnorm_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
+ TEST_ff_f (pow, 0, -0x1p24, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
+ TEST_ff_f (pow, 0, -0x1p127, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
+ TEST_ff_f (pow, 0, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
+ TEST_ff_f (pow, minus_zero, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
+ TEST_ff_f (pow, minus_zero, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
+ TEST_ff_f (pow, minus_zero, -min_subnorm_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
+ TEST_ff_f (pow, minus_zero, -0x1p24, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
+ TEST_ff_f (pow, minus_zero, -0x1p127, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
+ TEST_ff_f (pow, minus_zero, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE);
TEST_ff_f (pow, 0x1p72L, 0x1p72L, plus_infty, OVERFLOW_EXCEPTION);
TEST_ff_f (pow, 10, -0x1p72L, 0, UNDERFLOW_EXCEPTION);
@@ -11394,52 +11364,22 @@ remainder_test (void)
START (remainder);
- errno = 0;
- TEST_ff_f (remainder, 1, 0, qnan_value, INVALID_EXCEPTION);
- check_int ("errno for remainder(1, 0) = EDOM ", errno, EDOM, 0, 0, 0);
- errno = 0;
- TEST_ff_f (remainder, 1, minus_zero, qnan_value, INVALID_EXCEPTION);
- check_int ("errno for remainder(1, -0) = EDOM ", errno, EDOM, 0, 0, 0);
- errno = 0;
- TEST_ff_f (remainder, plus_infty, minus_zero, qnan_value, INVALID_EXCEPTION);
- check_int ("errno for remainder(INF, -0) = EDOM ", errno, EDOM, 0, 0, 0);
- errno = 0;
- TEST_ff_f (remainder, plus_infty, 0, qnan_value, INVALID_EXCEPTION);
- check_int ("errno for remainder(INF, 0) = EDOM ", errno, EDOM, 0, 0, 0);
- errno = 0;
- TEST_ff_f (remainder, plus_infty, 1, qnan_value, INVALID_EXCEPTION);
- check_int ("errno for remainder(INF, 1) = EDOM ", errno, EDOM, 0, 0, 0);
- errno = 0;
- TEST_ff_f (remainder, plus_infty, 2, qnan_value, INVALID_EXCEPTION);
- check_int ("errno for remainder(INF, 2) = EDOM ", errno, EDOM, 0, 0, 0);
- errno = 0;
- TEST_ff_f (remainder, minus_infty, minus_zero, qnan_value, INVALID_EXCEPTION);
- check_int ("errno for remainder(-INF, -0) = EDOM ", errno, EDOM, 0, 0, 0);
- errno = 0;
- TEST_ff_f (remainder, minus_infty, 0, qnan_value, INVALID_EXCEPTION);
- check_int ("errno for remainder(-INF, 0) = EDOM ", errno, EDOM, 0, 0, 0);
- errno = 0;
- TEST_ff_f (remainder, minus_infty, 1, qnan_value, INVALID_EXCEPTION);
- check_int ("errno for remainder(-INF, 1) = EDOM ", errno, EDOM, 0, 0, 0);
- errno = 0;
- TEST_ff_f (remainder, minus_infty, 2, qnan_value, INVALID_EXCEPTION);
- check_int ("errno for remainder(-INF, 2) = EDOM ", errno, EDOM, 0, 0, 0);
- errno = 0;
- TEST_ff_f (remainder, qnan_value, qnan_value, qnan_value);
- check_int ("errno for remainder(qNAN, qNAN) unchanged", errno, 0, 0, 0, 0);
- errno = 0;
- TEST_ff_f (remainder, 0, qnan_value, qnan_value);
- check_int ("errno for remainder(0, qNAN) unchanged", errno, 0, 0, 0, 0);
- errno = 0;
- TEST_ff_f (remainder, qnan_value, 0, qnan_value);
- check_int ("errno for remainder(qNaN, 0) unchanged", errno, 0, 0, 0, 0);
-
- errno = 0;
- TEST_ff_f (remainder, 7.0, plus_infty, 7.0);
- check_int ("errno for remainder(7.0, INF) unchanged", errno, 0, 0, 0, 0);
- errno = 0;
- TEST_ff_f (remainder, 7.0, minus_infty, 7.0);
- check_int ("errno for remainder(7.0, -INF) unchanged", errno, 0, 0, 0, 0);
+ TEST_ff_f (remainder, 1, 0, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM);
+ TEST_ff_f (remainder, 1, minus_zero, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM);
+ TEST_ff_f (remainder, plus_infty, minus_zero, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM);
+ TEST_ff_f (remainder, plus_infty, 0, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM);
+ TEST_ff_f (remainder, plus_infty, 1, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM);
+ TEST_ff_f (remainder, plus_infty, 2, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM);
+ TEST_ff_f (remainder, minus_infty, minus_zero, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM);
+ TEST_ff_f (remainder, minus_infty, 0, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM);
+ TEST_ff_f (remainder, minus_infty, 1, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM);
+ TEST_ff_f (remainder, minus_infty, 2, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM);
+ TEST_ff_f (remainder, qnan_value, qnan_value, qnan_value, ERRNO_UNCHANGED);
+ TEST_ff_f (remainder, 0, qnan_value, qnan_value, ERRNO_UNCHANGED);
+ TEST_ff_f (remainder, qnan_value, 0, qnan_value, ERRNO_UNCHANGED);
+
+ TEST_ff_f (remainder, 7.0, plus_infty, 7.0, ERRNO_UNCHANGED);
+ TEST_ff_f (remainder, 7.0, minus_infty, 7.0, ERRNO_UNCHANGED);
TEST_ff_f (remainder, 1.625, 1.0, -0.375);
TEST_ff_f (remainder, -1.625, 1.0, 0.375);
@@ -12226,15 +12166,9 @@ sin_test (void)
TEST_f_f (sin, 0, 0);
TEST_f_f (sin, minus_zero, minus_zero);
- errno = 0;
- TEST_f_f (sin, plus_infty, qnan_value, INVALID_EXCEPTION);
- check_int ("errno for sin(+inf) == EDOM", errno, EDOM, 0, 0, 0);
- errno = 0;
- TEST_f_f (sin, minus_infty, qnan_value, INVALID_EXCEPTION);
- check_int ("errno for sin(-inf) == EDOM", errno, EDOM, 0, 0, 0);
- errno = 0;
- TEST_f_f (sin, qnan_value, qnan_value);
- check_int ("errno for sin(qNaN) unchanged", errno, 0, 0, 0, 0);
+ TEST_f_f (sin, plus_infty, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM);
+ TEST_f_f (sin, minus_infty, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM);
+ TEST_f_f (sin, qnan_value, qnan_value, ERRNO_UNCHANGED);
TEST_f_f (sin, M_PI_6l, 0.5);
TEST_f_f (sin, -M_PI_6l, -0.5);
@@ -12666,15 +12600,9 @@ tan_test (void)
TEST_f_f (tan, 0, 0);
TEST_f_f (tan, minus_zero, minus_zero);
- errno = 0;
- TEST_f_f (tan, plus_infty, qnan_value, INVALID_EXCEPTION);
- check_int ("errno for tan(Inf) == EDOM", errno, EDOM, 0, 0, 0);
- errno = 0;
- TEST_f_f (tan, minus_infty, qnan_value, INVALID_EXCEPTION);
- check_int ("errno for tan(-Inf) == EDOM", errno, EDOM, 0, 0, 0);
- errno = 0;
- TEST_f_f (tan, qnan_value, qnan_value);
- check_int ("errno for tan(qNaN) == 0", errno, 0, 0, 0, 0);
+ TEST_f_f (tan, plus_infty, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM);
+ TEST_f_f (tan, minus_infty, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM);
+ TEST_f_f (tan, qnan_value, qnan_value, ERRNO_UNCHANGED);
TEST_f_f (tan, M_PI_4l, 1);
TEST_f_f (tan, 0.75L, 0.931596459944072461165202756573936428L);
@@ -13232,9 +13160,7 @@ yn_test (void)
and FLT_MIN. See Bug 14173. */
TEST_ff_f (yn, 10, min_value, minus_infty, OVERFLOW_EXCEPTION);
- errno = 0;
- TEST_ff_f (yn, 10, min_value, minus_infty, OVERFLOW_EXCEPTION);
- check_int ("errno for yn(10,-min) == ERANGE", errno, ERANGE, 0, 0, 0);
+ TEST_ff_f (yn, 10, min_value, minus_infty, OVERFLOW_EXCEPTION|ERRNO_ERANGE);
END (yn);
}
@@ -13291,6 +13217,7 @@ initialize (void)
/* Clear all exceptions. From now on we must not get random exceptions. */
feclearexcept (FE_ALL_EXCEPT);
+ errno = 0;
/* Test to make sure we start correctly. */
fpstack_test ("end *init*");
@@ -13641,8 +13568,9 @@ main (int argc, char **argv)
fclose (ulps_file);
printf ("\nTest suite completed:\n");
- printf (" %d test cases plus %d tests for exception flags executed.\n",
- noTests, noExcTests);
+ printf (" %d test cases plus %d tests for exception flags and\n"
+ " %d tests for errno executed.\n",
+ noTests, noExcTests, noErrnoTests);
if (noXFails)
printf (" %d expected failures occurred.\n", noXFails);
if (noXPasses)
--
Joseph S. Myers
joseph@codesourcery.com