diff --git a/lib/msun/tests/Makefile b/lib/msun/tests/Makefile index 85a558bb0733..309f49c6dddd 100644 --- a/lib/msun/tests/Makefile +++ b/lib/msun/tests/Makefile @@ -1,112 +1,110 @@ # $FreeBSD$ .include TESTSRC= ${SRCTOP}/contrib/netbsd-tests/lib/libm # All architectures on FreeBSD have fenv.h CFLAGS+= -DHAVE_FENV_H # For isqemu.h CFLAGS+= -I${TESTSRC:H}/libc/gen # Define __HAVE_LONG_DOUBLE for architectures whose long double has greater # precision than their double. .if ${MACHINE_CPUARCH} == "aarch64" || \ ${MACHINE_CPUARCH} == "amd64" || \ ${MACHINE_CPUARCH} == "i386" || \ ${MACHINE_CPUARCH} == "riscv" CFLAGS+= -D__HAVE_LONG_DOUBLE .endif # Avoid builtins, to force the compiler to emit calls to the libm # functions, and not calculate any results in advance. CFLAGS+= -fno-builtin NETBSD_ATF_TESTS_C= acos_test NETBSD_ATF_TESTS_C+= asin_test NETBSD_ATF_TESTS_C+= atan_test NETBSD_ATF_TESTS_C+= bit_test # TODO: NETBSD_ATF_TESTS_CXX+= cabsl_test NETBSD_ATF_TESTS_C+= cbrt_test NETBSD_ATF_TESTS_C+= ceil_test NETBSD_ATF_TESTS_C+= casinh_test NETBSD_ATF_TESTS_C+= cos_test NETBSD_ATF_TESTS_C+= cosh_test NETBSD_ATF_TESTS_C+= erf_test NETBSD_ATF_TESTS_C+= exp_test NETBSD_ATF_TESTS_C+= fmod_test NETBSD_ATF_TESTS_C+= fe_round_test NETBSD_ATF_TESTS_C+= hypot_test NETBSD_ATF_TESTS_C+= infinity_test NETBSD_ATF_TESTS_C+= ilogb_test NETBSD_ATF_TESTS_C+= ldexp_test NETBSD_ATF_TESTS_C+= log_test NETBSD_ATF_TESTS_C+= pow_test NETBSD_ATF_TESTS_C+= precision_test NETBSD_ATF_TESTS_C+= round_test NETBSD_ATF_TESTS_C+= scalbn_test NETBSD_ATF_TESTS_C+= sin_test NETBSD_ATF_TESTS_C+= sinh_test NETBSD_ATF_TESTS_C+= sqrt_test NETBSD_ATF_TESTS_C+= tan_test NETBSD_ATF_TESTS_C+= tanh_test -TAP_TESTS_C+= cexp_test -TAP_TESTS_C+= conj_test +ATF_TESTS_C+= cexp_test +ATF_TESTS_C+= conj_test .if ${MACHINE_CPUARCH} != "aarch64" # Hits an assert in llvm when building for arm64: # https://llvm.org/bugs/show_bug.cgi?id=26081 -TAP_TESTS_C+= csqrt_test +ATF_TESTS_C+= csqrt_test .endif ATF_TESTS_C+= ctrig_test -TAP_TESTS_C+= exponential_test -TAP_TESTS_C+= fenv_test -TAP_TESTS_C+= fma_test -TAP_TESTS_C+= fmaxmin_test -TAP_TESTS_C+= ilogb2_test -TAP_TESTS_C+= invtrig_test -TAP_TESTS_C+= invctrig_test -TAP_TESTS_C+= logarithm_test -TAP_TESTS_C+= lrint_test -# XXX: the testcase crashes on all platforms, but only on head -# (bug 205451) -#TAP_TESTS_C+= lround_test -TAP_TESTS_C+= nan_test -TAP_TESTS_C+= nearbyint_test -TAP_TESTS_C+= next_test -TAP_TESTS_C+= rem_test +ATF_TESTS_C+= exponential_test +ATF_TESTS_C+= fenv_test +ATF_TESTS_C+= fma_test +ATF_TESTS_C+= fmaxmin_test +ATF_TESTS_C+= ilogb2_test +ATF_TESTS_C+= invtrig_test +ATF_TESTS_C+= invctrig_test +ATF_TESTS_C+= logarithm_test +ATF_TESTS_C+= lrint_test +ATF_TESTS_C+= lround_test +ATF_TESTS_C+= nan_test +ATF_TESTS_C+= nearbyint_test +ATF_TESTS_C+= next_test +ATF_TESTS_C+= rem_test ATF_TESTS_C+= trig_test .if !empty(PROG) && !empty(TAP_TESTS_C:M${PROG}) CFLAGS+= -O0 .endif #COPTS+= -Wfloat-equal IGNORE_PRAGMA= SRCS.ilogb2_test= ilogb_test.c LIBADD+= m WARNS?= 1 # Copied from lib/msun/Makefile .if ${MACHINE_CPUARCH} == "i386" ARCH_SUBDIR= i387 .else ARCH_SUBDIR= ${MACHINE_CPUARCH} .endif .include "../${ARCH_SUBDIR}/Makefile.inc" # XXX: for some odd reason float.h doesn't tell the full story about what the # precision is. CFLAGS+= -DLDBL_PREC=${LDBL_PREC} CFLAGS.fe_round_test+= -D__HAVE_FENV .include .include diff --git a/lib/msun/tests/cexp_test.c b/lib/msun/tests/cexp_test.c index 8e342f8e0070..3a0f5dc39a5e 100644 --- a/lib/msun/tests/cexp_test.c +++ b/lib/msun/tests/cexp_test.c @@ -1,326 +1,304 @@ /*- * Copyright (c) 2008-2011 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Tests for corner cases in cexp*(). */ #include __FBSDID("$FreeBSD$"); #include -#include #include #include #include #include #include #include "test-utils.h" #pragma STDC FENV_ACCESS ON #pragma STDC CX_LIMITED_RANGE OFF /* * Test that a function returns the correct value and sets the * exception flags correctly. The exceptmask specifies which * exceptions we should check. We need to be lenient for several * reasons, but mainly because on some architectures it's impossible * to raise FE_OVERFLOW without raising FE_INEXACT. In some cases, * whether cexp() raises an invalid exception is unspecified. * * These are macros instead of functions so that assert provides more * meaningful error messages. * * XXX The volatile here is to avoid gcc's bogus constant folding and work * around the lack of support for the FENV_ACCESS pragma. */ #define test_t(type, func, z, result, exceptmask, excepts, checksign) \ do { \ volatile long double complex _d = z; \ volatile type complex _r = result; \ - assert(feclearexcept(FE_ALL_EXCEPT) == 0); \ - assert(cfpequal_cs((func)(_d), (_r), (checksign))); \ - assert(((void)(func), fetestexcept(exceptmask) == (excepts))); \ + ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT)); \ + ATF_CHECK(cfpequal_cs((func)(_d), (_r), (checksign))); \ + CHECK_FP_EXCEPTIONS_MSG(excepts, exceptmask, "for %s(%s)", \ + #func, #z); \ } while (0) #define test(func, z, result, exceptmask, excepts, checksign) \ test_t(double, func, z, result, exceptmask, excepts, checksign) #define test_f(func, z, result, exceptmask, excepts, checksign) \ test_t(float, func, z, result, exceptmask, excepts, checksign) /* Test within a given tolerance. */ #define test_tol(func, z, result, tol) do { \ volatile long double complex _d = z; \ - assert(cfpequal_tol((func)(_d), (result), (tol), \ + ATF_CHECK(cfpequal_tol((func)(_d), (result), (tol), \ FPE_ABS_ZERO | CS_BOTH)); \ } while (0) /* Test all the functions that compute cexp(x). */ #define testall(x, result, exceptmask, excepts, checksign) do { \ test(cexp, x, result, exceptmask, excepts, checksign); \ test_f(cexpf, x, result, exceptmask, excepts, checksign); \ } while (0) /* * Test all the functions that compute cexp(x), within a given tolerance. * The tolerance is specified in ulps. */ #define testall_tol(x, result, tol) do { \ test_tol(cexp, x, result, tol * DBL_ULP()); \ test_tol(cexpf, x, result, tol * FLT_ULP()); \ } while (0) /* Various finite non-zero numbers to test. */ static const float finites[] = { -42.0e20, -1.0, -1.0e-10, -0.0, 0.0, 1.0e-10, 1.0, 42.0e20 }; /* Tests for 0 */ -static void -test_zero(void) +ATF_TC_WITHOUT_HEAD(zero); +ATF_TC_BODY(zero, tc) { /* cexp(0) = 1, no exceptions raised */ testall(0.0, 1.0, ALL_STD_EXCEPT, 0, 1); testall(-0.0, 1.0, ALL_STD_EXCEPT, 0, 1); testall(CMPLXL(0.0, -0.0), CMPLXL(1.0, -0.0), ALL_STD_EXCEPT, 0, 1); testall(CMPLXL(-0.0, -0.0), CMPLXL(1.0, -0.0), ALL_STD_EXCEPT, 0, 1); } /* * Tests for NaN. The signs of the results are indeterminate unless the * imaginary part is 0. */ -static void -test_nan(void) +ATF_TC_WITHOUT_HEAD(nan); +ATF_TC_BODY(nan, tc) { unsigned i; /* cexp(x + NaNi) = NaN + NaNi and optionally raises invalid */ /* cexp(NaN + yi) = NaN + NaNi and optionally raises invalid (|y|>0) */ for (i = 0; i < nitems(finites); i++) { - printf("# Run %d..\n", i); testall(CMPLXL(finites[i], NAN), CMPLXL(NAN, NAN), ALL_STD_EXCEPT & ~FE_INVALID, 0, 0); if (finites[i] == 0.0) continue; /* XXX FE_INEXACT shouldn't be raised here */ testall(CMPLXL(NAN, finites[i]), CMPLXL(NAN, NAN), ALL_STD_EXCEPT & ~(FE_INVALID | FE_INEXACT), 0, 0); } /* cexp(NaN +- 0i) = NaN +- 0i */ testall(CMPLXL(NAN, 0.0), CMPLXL(NAN, 0.0), ALL_STD_EXCEPT, 0, 1); testall(CMPLXL(NAN, -0.0), CMPLXL(NAN, -0.0), ALL_STD_EXCEPT, 0, 1); /* cexp(inf + NaN i) = inf + nan i */ testall(CMPLXL(INFINITY, NAN), CMPLXL(INFINITY, NAN), ALL_STD_EXCEPT, 0, 0); /* cexp(-inf + NaN i) = 0 */ testall(CMPLXL(-INFINITY, NAN), CMPLXL(0.0, 0.0), ALL_STD_EXCEPT, 0, 0); /* cexp(NaN + NaN i) = NaN + NaN i */ testall(CMPLXL(NAN, NAN), CMPLXL(NAN, NAN), ALL_STD_EXCEPT, 0, 0); } -static void -test_inf(void) +ATF_TC_WITHOUT_HEAD(inf); +ATF_TC_BODY(inf, tc) { unsigned i; /* cexp(x + inf i) = NaN + NaNi and raises invalid */ for (i = 0; i < nitems(finites); i++) { - printf("# Run %d..\n", i); testall(CMPLXL(finites[i], INFINITY), CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 1); } /* cexp(-inf + yi) = 0 * (cos(y) + sin(y)i) */ /* XXX shouldn't raise an inexact exception */ testall(CMPLXL(-INFINITY, M_PI_4), CMPLXL(0.0, 0.0), ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1); testall(CMPLXL(-INFINITY, 3 * M_PI_4), CMPLXL(-0.0, 0.0), ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1); testall(CMPLXL(-INFINITY, 5 * M_PI_4), CMPLXL(-0.0, -0.0), ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1); testall(CMPLXL(-INFINITY, 7 * M_PI_4), CMPLXL(0.0, -0.0), ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1); testall(CMPLXL(-INFINITY, 0.0), CMPLXL(0.0, 0.0), ALL_STD_EXCEPT, 0, 1); testall(CMPLXL(-INFINITY, -0.0), CMPLXL(0.0, -0.0), ALL_STD_EXCEPT, 0, 1); /* cexp(inf + yi) = inf * (cos(y) + sin(y)i) (except y=0) */ /* XXX shouldn't raise an inexact exception */ testall(CMPLXL(INFINITY, M_PI_4), CMPLXL(INFINITY, INFINITY), ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1); testall(CMPLXL(INFINITY, 3 * M_PI_4), CMPLXL(-INFINITY, INFINITY), ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1); testall(CMPLXL(INFINITY, 5 * M_PI_4), CMPLXL(-INFINITY, -INFINITY), ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1); testall(CMPLXL(INFINITY, 7 * M_PI_4), CMPLXL(INFINITY, -INFINITY), ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1); /* cexp(inf + 0i) = inf + 0i */ testall(CMPLXL(INFINITY, 0.0), CMPLXL(INFINITY, 0.0), ALL_STD_EXCEPT, 0, 1); testall(CMPLXL(INFINITY, -0.0), CMPLXL(INFINITY, -0.0), ALL_STD_EXCEPT, 0, 1); } -static void -test_reals(void) +ATF_TC_WITHOUT_HEAD(reals); +ATF_TC_BODY(reals, tc) { unsigned i; for (i = 0; i < nitems(finites); i++) { /* XXX could check exceptions more meticulously */ - printf("# Run %d..\n", i); test(cexp, CMPLXL(finites[i], 0.0), CMPLXL(exp(finites[i]), 0.0), FE_INVALID | FE_DIVBYZERO, 0, 1); test(cexp, CMPLXL(finites[i], -0.0), CMPLXL(exp(finites[i]), -0.0), FE_INVALID | FE_DIVBYZERO, 0, 1); test_f(cexpf, CMPLXL(finites[i], 0.0), CMPLXL(expf(finites[i]), 0.0), FE_INVALID | FE_DIVBYZERO, 0, 1); test_f(cexpf, CMPLXL(finites[i], -0.0), CMPLXL(expf(finites[i]), -0.0), FE_INVALID | FE_DIVBYZERO, 0, 1); } } -static void -test_imaginaries(void) +ATF_TC_WITHOUT_HEAD(imaginaries); +ATF_TC_BODY(imaginaries, tc) { unsigned i; for (i = 0; i < nitems(finites); i++) { - printf("# Run %d..\n", i); test(cexp, CMPLXL(0.0, finites[i]), CMPLXL(cos(finites[i]), sin(finites[i])), ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1); test(cexp, CMPLXL(-0.0, finites[i]), CMPLXL(cos(finites[i]), sin(finites[i])), ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1); test_f(cexpf, CMPLXL(0.0, finites[i]), CMPLXL(cosf(finites[i]), sinf(finites[i])), ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1); test_f(cexpf, CMPLXL(-0.0, finites[i]), CMPLXL(cosf(finites[i]), sinf(finites[i])), ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1); } } -static void -test_small(void) +ATF_TC_WITHOUT_HEAD(small); +ATF_TC_BODY(small, tc) { static const double tests[] = { /* csqrt(a + bI) = x + yI */ /* a b x y */ 1.0, M_PI_4, M_SQRT2 * 0.5 * M_E, M_SQRT2 * 0.5 * M_E, -1.0, M_PI_4, M_SQRT2 * 0.5 / M_E, M_SQRT2 * 0.5 / M_E, 2.0, M_PI_2, 0.0, M_E * M_E, M_LN2, M_PI, -2.0, 0.0, }; double a, b; double x, y; unsigned i; for (i = 0; i < nitems(tests); i += 4) { - printf("# Run %d..\n", i); a = tests[i]; b = tests[i + 1]; x = tests[i + 2]; y = tests[i + 3]; test_tol(cexp, CMPLXL(a, b), CMPLXL(x, y), 3 * DBL_ULP()); /* float doesn't have enough precision to pass these tests */ if (x == 0 || y == 0) continue; test_tol(cexpf, CMPLXL(a, b), CMPLXL(x, y), 1 * FLT_ULP()); } } /* Test inputs with a real part r that would overflow exp(r). */ -static void -test_large(void) +ATF_TC_WITHOUT_HEAD(large); +ATF_TC_BODY(large, tc) { test_tol(cexp, CMPLXL(709.79, 0x1p-1074), CMPLXL(INFINITY, 8.94674309915433533273e-16), DBL_ULP()); test_tol(cexp, CMPLXL(1000, 0x1p-1074), CMPLXL(INFINITY, 9.73344457300016401328e+110), DBL_ULP()); test_tol(cexp, CMPLXL(1400, 0x1p-1074), CMPLXL(INFINITY, 5.08228858149196559681e+284), DBL_ULP()); test_tol(cexp, CMPLXL(900, 0x1.23456789abcdep-1020), CMPLXL(INFINITY, 7.42156649354218408074e+83), DBL_ULP()); test_tol(cexp, CMPLXL(1300, 0x1.23456789abcdep-1020), CMPLXL(INFINITY, 3.87514844965996756704e+257), DBL_ULP()); test_tol(cexpf, CMPLXL(88.73, 0x1p-149), CMPLXL(INFINITY, 4.80265603e-07), 2 * FLT_ULP()); test_tol(cexpf, CMPLXL(90, 0x1p-149), CMPLXL(INFINITY, 1.7101492622e-06f), 2 * FLT_ULP()); test_tol(cexpf, CMPLXL(192, 0x1p-149), CMPLXL(INFINITY, 3.396809344e+38f), 2 * FLT_ULP()); test_tol(cexpf, CMPLXL(120, 0x1.234568p-120), CMPLXL(INFINITY, 1.1163382522e+16f), 2 * FLT_ULP()); test_tol(cexpf, CMPLXL(170, 0x1.234568p-120), CMPLXL(INFINITY, 5.7878851079e+37f), 2 * FLT_ULP()); } -int -main(void) +ATF_TP_ADD_TCS(tp) { - - printf("1..7\n"); - - test_zero(); - printf("ok 1 - cexp zero\n"); - - test_nan(); - printf("ok 2 - cexp nan\n"); - - test_inf(); - printf("ok 3 - cexp inf\n"); - - test_reals(); - printf("ok 4 - cexp reals\n"); - - test_imaginaries(); - printf("ok 5 - cexp imaginaries\n"); - - test_small(); - printf("ok 6 - cexp small\n"); - - test_large(); - printf("ok 7 - cexp large\n"); - - return (0); + ATF_TP_ADD_TC(tp, zero); + ATF_TP_ADD_TC(tp, nan); + ATF_TP_ADD_TC(tp, inf); + ATF_TP_ADD_TC(tp, reals); + ATF_TP_ADD_TC(tp, imaginaries); + ATF_TP_ADD_TC(tp, small); + ATF_TP_ADD_TC(tp, large); + + return (atf_no_error()); } diff --git a/lib/msun/tests/conj_test.c b/lib/msun/tests/conj_test.c index 960fed5074b5..5e9868939277 100644 --- a/lib/msun/tests/conj_test.c +++ b/lib/msun/tests/conj_test.c @@ -1,139 +1,122 @@ /*- * Copyright (c) 2008 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Tests for conj{,f,l}() */ #include __FBSDID("$FreeBSD$"); -#include #include #include #include #include #include "test-utils.h" #pragma STDC CX_LIMITED_RANGE OFF /* Make sure gcc doesn't use builtin versions of these or honor __pure2. */ static float complex (*libconjf)(float complex) = conjf; static double complex (*libconj)(double complex) = conj; static long double complex (*libconjl)(long double complex) = conjl; static float (*libcrealf)(float complex) = crealf; static double (*libcreal)(double complex) = creal; static long double (*libcreall)(long double complex) = creall; static float (*libcimagf)(float complex) = cimagf; static double (*libcimag)(double complex) = cimag; static long double (*libcimagl)(long double complex) = cimagl; static const double tests[] = { /* a + bI */ 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, -1.0, 0.0, 1.0, -0.0, 0.0, -1.0, 2.0, 4.0, 0.0, INFINITY, 0.0, -INFINITY, INFINITY, 0.0, NAN, 1.0, 1.0, NAN, NAN, NAN, -INFINITY, INFINITY, }; -int -main(void) +ATF_TC_WITHOUT_HEAD(main); +ATF_TC_BODY(main, tc) { static const int ntests = sizeof(tests) / sizeof(tests[0]) / 2; complex float in; complex long double expected; int i; - printf("1..%d\n", ntests * 3); - for (i = 0; i < ntests; i++) { __real__ expected = __real__ in = tests[2 * i]; __imag__ in = tests[2 * i + 1]; __imag__ expected = -cimag(in); - assert(fpequal(libcrealf(in), __real__ in)); - assert(fpequal(libcreal(in), __real__ in)); - assert(fpequal(libcreall(in), __real__ in)); - assert(fpequal(libcimagf(in), __imag__ in)); - assert(fpequal(libcimag(in), __imag__ in)); - assert(fpequal(libcimagl(in), __imag__ in)); + ATF_REQUIRE(fpequal(libcrealf(in), __real__ in)); + ATF_REQUIRE(fpequal(libcreal(in), __real__ in)); + ATF_REQUIRE(fpequal(libcreall(in), __real__ in)); + ATF_REQUIRE(fpequal(libcimagf(in), __imag__ in)); + ATF_REQUIRE(fpequal(libcimag(in), __imag__ in)); + ATF_REQUIRE(fpequal(libcimagl(in), __imag__ in)); - feclearexcept(FE_ALL_EXCEPT); - if (!cfpequal(libconjf(in), expected)) { - printf("not ok %d\t# conjf(%#.2g + %#.2gI): " - "wrong value\n", - 3 * i + 1, creal(in), cimag(in)); - } else if (fetestexcept(FE_ALL_EXCEPT)) { - printf("not ok %d\t# conjf(%#.2g + %#.2gI): " - "threw an exception\n", - 3 * i + 1, creal(in), cimag(in)); - } else { - printf("ok %d\t\t# conjf(%#.2g + %#.2gI)\n", - 3 * i + 1, creal(in), cimag(in)); - } + ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT)); + ATF_REQUIRE_MSG( + cfpequal(libconjf(in), expected), + "conjf(%#.2g + %#.2gI): wrong value", creal(in), cimag(in) + ); + ATF_REQUIRE_EQ_MSG(0, fetestexcept(FE_ALL_EXCEPT), + "conj(%#.2g + %#.2gI): threw an exception: %#x", creal(in), + cimag(in), fetestexcept(FE_ALL_EXCEPT)); - feclearexcept(FE_ALL_EXCEPT); - if (!cfpequal(libconj(in), expected)) { - printf("not ok %d\t# conj(%#.2g + %#.2gI): " - "wrong value\n", - 3 * i + 2, creal(in), cimag(in)); - } else if (fetestexcept(FE_ALL_EXCEPT)) { - printf("not ok %d\t# conj(%#.2g + %#.2gI): " - "threw an exception\n", - 3 * i + 2, creal(in), cimag(in)); - } else { - printf("ok %d\t\t# conj(%#.2g + %#.2gI)\n", - 3 * i + 2, creal(in), cimag(in)); - } + ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT)); + ATF_REQUIRE_MSG(cfpequal(libconj(in), expected), + "conj(%#.2g + %#.2gI): wrong value", creal(in), cimag(in)); + ATF_REQUIRE_EQ_MSG(0, fetestexcept(FE_ALL_EXCEPT), + "conj(%#.2g + %#.2gI): threw an exception: %#x", creal(in), + cimag(in), fetestexcept(FE_ALL_EXCEPT)); - feclearexcept(FE_ALL_EXCEPT); - if (!cfpequal(libconjl(in), expected)) { - printf("not ok %d\t# conjl(%#.2g + %#.2gI): " - "wrong value\n", - 3 * i + 3, creal(in), cimag(in)); - } else if (fetestexcept(FE_ALL_EXCEPT)) { - printf("not ok %d\t# conjl(%#.2g + %#.2gI): " - "threw an exception\n", - 3 * i + 3, creal(in), cimag(in)); - } else { - printf("ok %d\t\t# conjl(%#.2g + %#.2gI)\n", - 3 * i + 3, creal(in), cimag(in)); - } + ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT)); + ATF_REQUIRE_MSG(cfpequal(libconjl(in), expected), + "conjl(%#.2g + %#.2gI): wrong value", creal(in), cimag(in)); + ATF_REQUIRE_EQ_MSG(0, fetestexcept(FE_ALL_EXCEPT), + "conjl(%#.2g + %#.2gI): threw an exception: %#x", creal(in), + cimag(in), fetestexcept(FE_ALL_EXCEPT)); } +} + +ATF_TP_ADD_TCS(tp) +{ + ATF_TP_ADD_TC(tp, main); - return (0); + return (atf_no_error()); } diff --git a/lib/msun/tests/csqrt_test.c b/lib/msun/tests/csqrt_test.c index 9f596ed67596..a84605a379de 100644 --- a/lib/msun/tests/csqrt_test.c +++ b/lib/msun/tests/csqrt_test.c @@ -1,376 +1,369 @@ /*- * Copyright (c) 2007 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Tests for csqrt{,f}() */ #include __FBSDID("$FreeBSD$"); #include -#include #include #include #include #include #include "test-utils.h" /* * This is a test hook that can point to csqrtl(), _csqrt(), or to _csqrtf(). * The latter two convert to float or double, respectively, and test csqrtf() * and csqrt() with the same arguments. */ static long double complex (*t_csqrt)(long double complex); static long double complex _csqrtf(long double complex d) { return (csqrtf((float complex)d)); } static long double complex _csqrt(long double complex d) { return (csqrt((double complex)d)); } #pragma STDC CX_LIMITED_RANGE OFF /* * Compare d1 and d2 using special rules: NaN == NaN and +0 != -0. * Fail an assertion if they differ. */ static void assert_equal(long double complex d1, long double complex d2) { - assert(cfpequal(d1, d2)); + ATF_CHECK(cfpequal(d1, d2)); } /* * Test csqrt for some finite arguments where the answer is exact. * (We do not test if it produces correctly rounded answers when the * result is inexact, nor do we check whether it throws spurious * exceptions.) */ static void test_finite(void) { static const double tests[] = { /* csqrt(a + bI) = x + yI */ /* a b x y */ 0, 8, 2, 2, 0, -8, 2, -2, 4, 0, 2, 0, -4, 0, 0, 2, 3, 4, 2, 1, 3, -4, 2, -1, -3, 4, 1, 2, -3, -4, 1, -2, 5, 12, 3, 2, 7, 24, 4, 3, 9, 40, 5, 4, 11, 60, 6, 5, 13, 84, 7, 6, 33, 56, 7, 4, 39, 80, 8, 5, 65, 72, 9, 4, 987, 9916, 74, 67, 5289, 6640, 83, 40, 460766389075.0, 16762287900.0, 678910, 12345 }; /* * We also test some multiples of the above arguments. This * array defines which multiples we use. Note that these have * to be small enough to not cause overflow for float precision * with all of the constants in the above table. */ static const double mults[] = { 1, 2, 3, 13, 16, 0x1.p30, 0x1.p-30, }; double a, b; double x, y; unsigned i, j; for (i = 0; i < nitems(tests); i += 4) { for (j = 0; j < nitems(mults); j++) { a = tests[i] * mults[j] * mults[j]; b = tests[i + 1] * mults[j] * mults[j]; x = tests[i + 2] * mults[j]; y = tests[i + 3] * mults[j]; - assert(t_csqrt(CMPLXL(a, b)) == CMPLXL(x, y)); + ATF_CHECK(t_csqrt(CMPLXL(a, b)) == CMPLXL(x, y)); } } } /* * Test the handling of +/- 0. */ static void test_zeros(void) { assert_equal(t_csqrt(CMPLXL(0.0, 0.0)), CMPLXL(0.0, 0.0)); assert_equal(t_csqrt(CMPLXL(-0.0, 0.0)), CMPLXL(0.0, 0.0)); assert_equal(t_csqrt(CMPLXL(0.0, -0.0)), CMPLXL(0.0, -0.0)); assert_equal(t_csqrt(CMPLXL(-0.0, -0.0)), CMPLXL(0.0, -0.0)); } /* * Test the handling of infinities when the other argument is not NaN. */ static void test_infinities(void) { static const double vals[] = { 0.0, -0.0, 42.0, -42.0, INFINITY, -INFINITY, }; unsigned i; for (i = 0; i < nitems(vals); i++) { if (isfinite(vals[i])) { assert_equal(t_csqrt(CMPLXL(-INFINITY, vals[i])), CMPLXL(0.0, copysignl(INFINITY, vals[i]))); assert_equal(t_csqrt(CMPLXL(INFINITY, vals[i])), CMPLXL(INFINITY, copysignl(0.0, vals[i]))); } assert_equal(t_csqrt(CMPLXL(vals[i], INFINITY)), CMPLXL(INFINITY, INFINITY)); assert_equal(t_csqrt(CMPLXL(vals[i], -INFINITY)), CMPLXL(INFINITY, -INFINITY)); } } /* * Test the handling of NaNs. */ static void test_nans(void) { - assert(creall(t_csqrt(CMPLXL(INFINITY, NAN))) == INFINITY); - assert(isnan(cimagl(t_csqrt(CMPLXL(INFINITY, NAN))))); + ATF_CHECK(creall(t_csqrt(CMPLXL(INFINITY, NAN))) == INFINITY); + ATF_CHECK(isnan(cimagl(t_csqrt(CMPLXL(INFINITY, NAN))))); - assert(isnan(creall(t_csqrt(CMPLXL(-INFINITY, NAN))))); - assert(isinf(cimagl(t_csqrt(CMPLXL(-INFINITY, NAN))))); + ATF_CHECK(isnan(creall(t_csqrt(CMPLXL(-INFINITY, NAN))))); + ATF_CHECK(isinf(cimagl(t_csqrt(CMPLXL(-INFINITY, NAN))))); assert_equal(t_csqrt(CMPLXL(NAN, INFINITY)), CMPLXL(INFINITY, INFINITY)); assert_equal(t_csqrt(CMPLXL(NAN, -INFINITY)), CMPLXL(INFINITY, -INFINITY)); assert_equal(t_csqrt(CMPLXL(0.0, NAN)), CMPLXL(NAN, NAN)); assert_equal(t_csqrt(CMPLXL(-0.0, NAN)), CMPLXL(NAN, NAN)); assert_equal(t_csqrt(CMPLXL(42.0, NAN)), CMPLXL(NAN, NAN)); assert_equal(t_csqrt(CMPLXL(-42.0, NAN)), CMPLXL(NAN, NAN)); assert_equal(t_csqrt(CMPLXL(NAN, 0.0)), CMPLXL(NAN, NAN)); assert_equal(t_csqrt(CMPLXL(NAN, -0.0)), CMPLXL(NAN, NAN)); assert_equal(t_csqrt(CMPLXL(NAN, 42.0)), CMPLXL(NAN, NAN)); assert_equal(t_csqrt(CMPLXL(NAN, -42.0)), CMPLXL(NAN, NAN)); assert_equal(t_csqrt(CMPLXL(NAN, NAN)), CMPLXL(NAN, NAN)); } /* * Test whether csqrt(a + bi) works for inputs that are large enough to * cause overflow in hypot(a, b) + a. Each of the tests is scaled up to * near MAX_EXP. */ static void test_overflow(int maxexp) { long double a, b; long double complex result; int exp, i; - assert(maxexp > 0 && maxexp % 2 == 0); + ATF_CHECK(maxexp > 0 && maxexp % 2 == 0); for (i = 0; i < 4; i++) { exp = maxexp - 2 * i; /* csqrt(115 + 252*I) == 14 + 9*I */ a = ldexpl(115 * 0x1p-8, exp); b = ldexpl(252 * 0x1p-8, exp); result = t_csqrt(CMPLXL(a, b)); - assert(creall(result) == ldexpl(14 * 0x1p-4, exp / 2)); - assert(cimagl(result) == ldexpl(9 * 0x1p-4, exp / 2)); + ATF_CHECK_EQ(creall(result), ldexpl(14 * 0x1p-4, exp / 2)); + ATF_CHECK_EQ(cimagl(result), ldexpl(9 * 0x1p-4, exp / 2)); /* csqrt(-11 + 60*I) = 5 + 6*I */ a = ldexpl(-11 * 0x1p-6, exp); b = ldexpl(60 * 0x1p-6, exp); result = t_csqrt(CMPLXL(a, b)); - assert(creall(result) == ldexpl(5 * 0x1p-3, exp / 2)); - assert(cimagl(result) == ldexpl(6 * 0x1p-3, exp / 2)); + ATF_CHECK_EQ(creall(result), ldexpl(5 * 0x1p-3, exp / 2)); + ATF_CHECK_EQ(cimagl(result), ldexpl(6 * 0x1p-3, exp / 2)); /* csqrt(225 + 0*I) == 15 + 0*I */ a = ldexpl(225 * 0x1p-8, exp); b = 0; result = t_csqrt(CMPLXL(a, b)); - assert(creall(result) == ldexpl(15 * 0x1p-4, exp / 2)); - assert(cimagl(result) == 0); + ATF_CHECK_EQ(creall(result), ldexpl(15 * 0x1p-4, exp / 2)); + ATF_CHECK_EQ(cimagl(result), 0); } } /* * Test that precision is maintained for some large squares. Set all or * some bits in the lower mantdig/2 bits, square the number, and try to * recover the sqrt. Note: * (x + xI)**2 = 2xxI */ static void test_precision(int maxexp, int mantdig) { long double b, x; long double complex result; uint64_t mantbits, sq_mantbits; int exp, i; - assert(maxexp > 0 && maxexp % 2 == 0); - assert(mantdig <= 64); + ATF_CHECK(maxexp > 0 && maxexp % 2 == 0); + ATF_CHECK(mantdig <= 64); mantdig = rounddown(mantdig, 2); for (exp = 0; exp <= maxexp; exp += 2) { mantbits = ((uint64_t)1 << (mantdig / 2 )) - 1; for (i = 0; i < 100 && mantbits > ((uint64_t)1 << (mantdig / 2 - 1)); i++, mantbits--) { sq_mantbits = mantbits * mantbits; /* * sq_mantibts is a mantdig-bit number. Divide by * 2**mantdig to normalize it to [0.5, 1), where, * note, the binary power will be -1. Raise it by * 2**exp for the test. exp is even. Lower it by * one to reach a final binary power which is also * even. The result should be exactly * representable, given that mantdig is less than or * equal to the available precision. */ b = ldexpl((long double)sq_mantbits, exp - 1 - mantdig); x = ldexpl(mantbits, (exp - 2 - mantdig) / 2); - assert(b == x * x * 2); + ATF_CHECK_EQ(b, x * x * 2); result = t_csqrt(CMPLXL(0, b)); - assert(creall(result) == x); - assert(cimagl(result) == x); + ATF_CHECK_EQ(x, creall(result)); + ATF_CHECK_EQ(x, cimagl(result)); } } } -int -main(void) +ATF_TC_WITHOUT_HEAD(csqrt); +ATF_TC_BODY(csqrt, tc) { - - printf("1..18\n"); - /* Test csqrt() */ t_csqrt = _csqrt; test_finite(); - printf("ok 1 - csqrt\n"); test_zeros(); - printf("ok 2 - csqrt\n"); test_infinities(); - printf("ok 3 - csqrt\n"); test_nans(); - printf("ok 4 - csqrt\n"); test_overflow(DBL_MAX_EXP); - printf("ok 5 - csqrt\n"); test_precision(DBL_MAX_EXP, DBL_MANT_DIG); - printf("ok 6 - csqrt\n"); +} +ATF_TC_WITHOUT_HEAD(csqrtf); +ATF_TC_BODY(csqrtf, tc) +{ /* Now test csqrtf() */ t_csqrt = _csqrtf; test_finite(); - printf("ok 7 - csqrt\n"); test_zeros(); - printf("ok 8 - csqrt\n"); test_infinities(); - printf("ok 9 - csqrt\n"); test_nans(); - printf("ok 10 - csqrt\n"); test_overflow(FLT_MAX_EXP); - printf("ok 11 - csqrt\n"); test_precision(FLT_MAX_EXP, FLT_MANT_DIG); - printf("ok 12 - csqrt\n"); +} +ATF_TC_WITHOUT_HEAD(csqrtl); +ATF_TC_BODY(csqrtl, tc) +{ /* Now test csqrtl() */ t_csqrt = csqrtl; test_finite(); - printf("ok 13 - csqrt\n"); test_zeros(); - printf("ok 14 - csqrt\n"); test_infinities(); - printf("ok 15 - csqrt\n"); test_nans(); - printf("ok 16 - csqrt\n"); test_overflow(LDBL_MAX_EXP); - printf("ok 17 - csqrt\n"); test_precision(LDBL_MAX_EXP, #ifndef __i386__ LDBL_MANT_DIG #else DBL_MANT_DIG #endif ); - printf("ok 18 - csqrt\n"); +} + +ATF_TP_ADD_TCS(tp) +{ + ATF_TP_ADD_TC(tp, csqrt); + ATF_TP_ADD_TC(tp, csqrtf); + ATF_TP_ADD_TC(tp, csqrtl); - return (0); + return (atf_no_error()); } diff --git a/lib/msun/tests/ctrig_test.c b/lib/msun/tests/ctrig_test.c index 2499e53ab4d5..f3951c575ceb 100644 --- a/lib/msun/tests/ctrig_test.c +++ b/lib/msun/tests/ctrig_test.c @@ -1,495 +1,493 @@ /*- * Copyright (c) 2008-2011 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Tests for csin[h](), ccos[h](), and ctan[h](). */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include -#include - #include "test-utils.h" #pragma STDC FENV_ACCESS ON #pragma STDC CX_LIMITED_RANGE OFF /* * Test that a function returns the correct value and sets the * exception flags correctly. The exceptmask specifies which * exceptions we should check. We need to be lenient for several * reasons, but mainly because on some architectures it's impossible * to raise FE_OVERFLOW without raising FE_INEXACT. * * These are macros instead of functions so that assert provides more * meaningful error messages. * * XXX The volatile here is to avoid gcc's bogus constant folding and work * around the lack of support for the FENV_ACCESS pragma. */ #define test_p(func, z, result, exceptmask, excepts, checksign) \ do { \ volatile long double complex _d = z; \ debug(" testing %s(%Lg + %Lg I) == %Lg + %Lg I\n", #func, \ creall(_d), cimagl(_d), creall(result), cimagl(result)); \ ATF_CHECK(feclearexcept(FE_ALL_EXCEPT) == 0); \ volatile long double complex _r = (func)(_d); \ ATF_CHECK_MSG(cfpequal_cs(_r, (result), (checksign)), \ "%s (%Lg + %Lg I) != expected (%Lg + %Lg I)", \ __XSTRING((func)(_d)), creall(_r), cimagl(_r), \ creall(result), cimagl(result)); \ volatile int _e = fetestexcept(exceptmask); \ ATF_CHECK_MSG(_e == (excepts), \ "%s fetestexcept(%s) (%#x) != %#x", __XSTRING(func), \ __XSTRING(exceptmask), _e, (excepts)); \ } while (0) /* * Test within a given tolerance. The tolerance indicates relative error * in ulps. If result is 0, however, it measures absolute error in units * of _EPSILON. */ #define test_p_tol(func, z, result, tol) do { \ volatile long double complex _d = z; \ debug(" testing %s(%Lg + %Lg I) ~= %Lg + %Lg I\n", #func, \ creall(_d), cimagl(_d), creall(result), cimagl(result)); \ ATF_CHECK(cfpequal_tol((func)(_d), (result), (tol), FPE_ABS_ZERO)); \ } while (0) /* These wrappers apply the identities f(conj(z)) = conj(f(z)). */ #define test(func, z, result, exceptmask, excepts, checksign) do { \ test_p(func, z, result, exceptmask, excepts, checksign); \ test_p(func, conjl(z), conjl(result), exceptmask, excepts, checksign); \ } while (0) #define test_tol(func, z, result, tol) do { \ test_p_tol(func, z, result, tol); \ test_p_tol(func, conjl(z), conjl(result), tol); \ } while (0) #define test_odd_tol(func, z, result, tol) do { \ test_tol(func, z, result, tol); \ test_tol(func, -(z), -(result), tol); \ } while (0) #define test_even_tol(func, z, result, tol) do { \ test_tol(func, z, result, tol); \ test_tol(func, -(z), result, tol); \ } while (0) /* Test the given function in all precisions. */ #define testall(func, x, result, exceptmask, excepts, checksign) do { \ test(func, x, result, exceptmask, excepts, checksign); \ test(func##f, x, result, exceptmask, excepts, checksign); \ } while (0) #define testall_odd(func, x, result, exceptmask, excepts, checksign) do { \ testall(func, x, result, exceptmask, excepts, checksign); \ testall(func, -x, -result, exceptmask, excepts, checksign); \ } while (0) #define testall_even(func, x, result, exceptmask, excepts, checksign) do { \ testall(func, x, result, exceptmask, excepts, checksign); \ testall(func, -x, result, exceptmask, excepts, checksign); \ } while (0) /* * Test the given function in all precisions, within a given tolerance. * The tolerance is specified in ulps. */ #define testall_tol(func, x, result, tol) do { \ test_tol(func, x, result, tol * DBL_ULP()); \ test_tol(func##f, x, result, tol * FLT_ULP()); \ } while (0) #define testall_odd_tol(func, x, result, tol) do { \ test_odd_tol(func, x, result, tol * DBL_ULP()); \ test_odd_tol(func##f, x, result, tol * FLT_ULP()); \ } while (0) #define testall_even_tol(func, x, result, tol) do { \ test_even_tol(func, x, result, tol * DBL_ULP()); \ test_even_tol(func##f, x, result, tol * FLT_ULP()); \ } while (0) ATF_TC(test_zero_input); ATF_TC_HEAD(test_zero_input, tc) { atf_tc_set_md_var(tc, "descr", "test 0 input"); } ATF_TC_BODY(test_zero_input, tc) { long double complex zero = CMPLXL(0.0, 0.0); /* csinh(0) = ctanh(0) = 0; ccosh(0) = 1 (no exceptions raised) */ testall_odd(csinh, zero, zero, ALL_STD_EXCEPT, 0, CS_BOTH); testall_odd(csin, zero, zero, ALL_STD_EXCEPT, 0, CS_BOTH); testall_even(ccosh, zero, 1.0, ALL_STD_EXCEPT, 0, CS_BOTH); testall_even(ccos, zero, CMPLXL(1.0, -0.0), ALL_STD_EXCEPT, 0, CS_BOTH); testall_odd(ctanh, zero, zero, ALL_STD_EXCEPT, 0, CS_BOTH); testall_odd(ctan, zero, zero, ALL_STD_EXCEPT, 0, CS_BOTH); } ATF_TC(test_nan_inputs); ATF_TC_HEAD(test_nan_inputs, tc) { atf_tc_set_md_var(tc, "descr", "test NaN inputs"); } ATF_TC_BODY(test_nan_inputs, tc) { long double complex nan_nan = CMPLXL(NAN, NAN); long double complex z; /* * IN CSINH CCOSH CTANH * NaN,NaN NaN,NaN NaN,NaN NaN,NaN * finite,NaN NaN,NaN [inval] NaN,NaN [inval] NaN,NaN [inval] * NaN,finite NaN,NaN [inval] NaN,NaN [inval] NaN,NaN [inval] * NaN,Inf NaN,NaN [inval] NaN,NaN [inval] NaN,NaN [inval] * Inf,NaN +-Inf,NaN Inf,NaN 1,+-0 * 0,NaN +-0,NaN NaN,+-0 +-0,NaN * NaN,0 NaN,0 NaN,+-0 NaN,+-0 */ z = nan_nan; testall_odd(csinh, z, nan_nan, ALL_STD_EXCEPT, 0, 0); testall_even(ccosh, z, nan_nan, ALL_STD_EXCEPT, 0, 0); testall_odd(ctanh, z, nan_nan, ALL_STD_EXCEPT, 0, 0); testall_odd(csin, z, nan_nan, ALL_STD_EXCEPT, 0, 0); testall_even(ccos, z, nan_nan, ALL_STD_EXCEPT, 0, 0); testall_odd(ctan, z, nan_nan, ALL_STD_EXCEPT, 0, 0); z = CMPLXL(42, NAN); testall_odd(csinh, z, nan_nan, OPT_INVALID, 0, 0); testall_even(ccosh, z, nan_nan, OPT_INVALID, 0, 0); /* XXX We allow a spurious inexact exception here. */ testall_odd(ctanh, z, nan_nan, OPT_INVALID & ~FE_INEXACT, 0, 0); testall_odd(csin, z, nan_nan, OPT_INVALID, 0, 0); testall_even(ccos, z, nan_nan, OPT_INVALID, 0, 0); testall_odd(ctan, z, nan_nan, OPT_INVALID, 0, 0); z = CMPLXL(NAN, 42); testall_odd(csinh, z, nan_nan, OPT_INVALID, 0, 0); testall_even(ccosh, z, nan_nan, OPT_INVALID, 0, 0); testall_odd(ctanh, z, nan_nan, OPT_INVALID, 0, 0); testall_odd(csin, z, nan_nan, OPT_INVALID, 0, 0); testall_even(ccos, z, nan_nan, OPT_INVALID, 0, 0); /* XXX We allow a spurious inexact exception here. */ testall_odd(ctan, z, nan_nan, OPT_INVALID & ~FE_INEXACT, 0, 0); z = CMPLXL(NAN, INFINITY); testall_odd(csinh, z, nan_nan, OPT_INVALID, 0, 0); testall_even(ccosh, z, nan_nan, OPT_INVALID, 0, 0); testall_odd(ctanh, z, nan_nan, OPT_INVALID, 0, 0); testall_odd(csin, z, CMPLXL(NAN, INFINITY), ALL_STD_EXCEPT, 0, 0); testall_even(ccos, z, CMPLXL(INFINITY, NAN), ALL_STD_EXCEPT, 0, CS_IMAG); testall_odd(ctan, z, CMPLXL(0, 1), ALL_STD_EXCEPT, 0, CS_IMAG); z = CMPLXL(INFINITY, NAN); testall_odd(csinh, z, CMPLXL(INFINITY, NAN), ALL_STD_EXCEPT, 0, 0); testall_even(ccosh, z, CMPLXL(INFINITY, NAN), ALL_STD_EXCEPT, 0, CS_REAL); testall_odd(ctanh, z, CMPLXL(1, 0), ALL_STD_EXCEPT, 0, CS_REAL); testall_odd(csin, z, nan_nan, OPT_INVALID, 0, 0); testall_even(ccos, z, nan_nan, OPT_INVALID, 0, 0); testall_odd(ctan, z, nan_nan, OPT_INVALID, 0, 0); z = CMPLXL(0, NAN); testall_odd(csinh, z, CMPLXL(0, NAN), ALL_STD_EXCEPT, 0, CS_REAL); testall_even(ccosh, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, 0); testall_odd(ctanh, z, CMPLXL(0, NAN), OPT_INVALID, 0, CS_REAL); testall_odd(csin, z, CMPLXL(0, NAN), ALL_STD_EXCEPT, 0, CS_REAL); testall_even(ccos, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, 0); testall_odd(ctan, z, CMPLXL(0, NAN), ALL_STD_EXCEPT, 0, CS_REAL); z = CMPLXL(NAN, 0); testall_odd(csinh, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, CS_IMAG); testall_even(ccosh, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, 0); testall_odd(ctanh, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, CS_IMAG); testall_odd(csin, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, 0); testall_even(ccos, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, 0); testall_odd(ctan, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, CS_IMAG); } ATF_TC(test_inf_inputs); ATF_TC_HEAD(test_inf_inputs, tc) { atf_tc_set_md_var(tc, "descr", "test infinity inputs"); } ATF_TC_BODY(test_inf_inputs, tc) { static const long double finites[] = { 0, M_PI / 4, 3 * M_PI / 4, 5 * M_PI / 4, }; long double complex z, c, s; unsigned i; /* * IN CSINH CCOSH CTANH * Inf,Inf +-Inf,NaN inval +-Inf,NaN inval 1,+-0 * Inf,finite Inf cis(finite) Inf cis(finite) 1,0 sin(2 finite) * 0,Inf +-0,NaN inval NaN,+-0 inval +-0,NaN * finite,Inf NaN,NaN inval NaN,NaN inval NaN,NaN inval */ z = CMPLXL(INFINITY, INFINITY); testall_odd(csinh, z, CMPLXL(INFINITY, NAN), ALL_STD_EXCEPT, FE_INVALID, 0); testall_even(ccosh, z, CMPLXL(INFINITY, NAN), ALL_STD_EXCEPT, FE_INVALID, 0); testall_odd(ctanh, z, CMPLXL(1, 0), ALL_STD_EXCEPT, 0, CS_REAL); testall_odd(csin, z, CMPLXL(NAN, INFINITY), ALL_STD_EXCEPT, FE_INVALID, 0); testall_even(ccos, z, CMPLXL(INFINITY, NAN), ALL_STD_EXCEPT, FE_INVALID, 0); testall_odd(ctan, z, CMPLXL(0, 1), ALL_STD_EXCEPT, 0, CS_REAL); /* XXX We allow spurious inexact exceptions here (hard to avoid). */ for (i = 0; i < nitems(finites); i++) { z = CMPLXL(INFINITY, finites[i]); c = INFINITY * cosl(finites[i]); s = finites[i] == 0 ? finites[i] : INFINITY * sinl(finites[i]); testall_odd(csinh, z, CMPLXL(c, s), OPT_INEXACT, 0, CS_BOTH); testall_even(ccosh, z, CMPLXL(c, s), OPT_INEXACT, 0, CS_BOTH); testall_odd(ctanh, z, CMPLXL(1, 0 * sin(finites[i] * 2)), OPT_INEXACT, 0, CS_BOTH); z = CMPLXL(finites[i], INFINITY); testall_odd(csin, z, CMPLXL(s, c), OPT_INEXACT, 0, CS_BOTH); testall_even(ccos, z, CMPLXL(c, -s), OPT_INEXACT, 0, CS_BOTH); testall_odd(ctan, z, CMPLXL(0 * sin(finites[i] * 2), 1), OPT_INEXACT, 0, CS_BOTH); } z = CMPLXL(0, INFINITY); testall_odd(csinh, z, CMPLXL(0, NAN), ALL_STD_EXCEPT, FE_INVALID, 0); testall_even(ccosh, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, FE_INVALID, 0); testall_odd(ctanh, z, CMPLXL(0, NAN), ALL_STD_EXCEPT, FE_INVALID, CS_REAL); z = CMPLXL(INFINITY, 0); testall_odd(csin, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, FE_INVALID, 0); testall_even(ccos, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, FE_INVALID, 0); testall_odd(ctan, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, FE_INVALID, CS_IMAG); z = CMPLXL(42, INFINITY); testall_odd(csinh, z, CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 0); testall_even(ccosh, z, CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 0); /* XXX We allow a spurious inexact exception here. */ testall_odd(ctanh, z, CMPLXL(NAN, NAN), OPT_INEXACT, FE_INVALID, 0); z = CMPLXL(INFINITY, 42); testall_odd(csin, z, CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 0); testall_even(ccos, z, CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 0); /* XXX We allow a spurious inexact exception here. */ testall_odd(ctan, z, CMPLXL(NAN, NAN), OPT_INEXACT, FE_INVALID, 0); } ATF_TC(test_axes); ATF_TC_HEAD(test_axes, tc) { atf_tc_set_md_var(tc, "descr", "test along the real/imaginary axes"); } ATF_TC_BODY(test_axes, tc) { static const long double nums[] = { M_PI / 4, M_PI / 2, 3 * M_PI / 4, 5 * M_PI / 4, 3 * M_PI / 2, 7 * M_PI / 4, }; long double complex z; unsigned i; for (i = 0; i < nitems(nums); i++) { /* Real axis */ z = CMPLXL(nums[i], 0.0); test_odd_tol(csinh, z, CMPLXL(sinh(nums[i]), 0), DBL_ULP()); test_even_tol(ccosh, z, CMPLXL(cosh(nums[i]), 0), DBL_ULP()); test_odd_tol(ctanh, z, CMPLXL(tanh(nums[i]), 0), DBL_ULP()); test_odd_tol(csin, z, CMPLXL(sin(nums[i]), copysign(0, cos(nums[i]))), DBL_ULP()); test_even_tol(ccos, z, CMPLXL(cos(nums[i]), -copysign(0, sin(nums[i]))), DBL_ULP()); test_odd_tol(ctan, z, CMPLXL(tan(nums[i]), 0), DBL_ULP()); test_odd_tol(csinhf, z, CMPLXL(sinhf(nums[i]), 0), FLT_ULP()); test_even_tol(ccoshf, z, CMPLXL(coshf(nums[i]), 0), FLT_ULP()); printf("%a %a\n", creal(z), cimag(z)); printf("%a %a\n", creal(ctanhf(z)), cimag(ctanhf(z))); printf("%a\n", nextafterf(tanhf(nums[i]), INFINITY)); test_odd_tol(ctanhf, z, CMPLXL(tanhf(nums[i]), 0), 1.3 * FLT_ULP()); test_odd_tol(csinf, z, CMPLXL(sinf(nums[i]), copysign(0, cosf(nums[i]))), FLT_ULP()); test_even_tol(ccosf, z, CMPLXL(cosf(nums[i]), -copysign(0, sinf(nums[i]))), 2 * FLT_ULP()); test_odd_tol(ctanf, z, CMPLXL(tanf(nums[i]), 0), FLT_ULP()); /* Imaginary axis */ z = CMPLXL(0.0, nums[i]); test_odd_tol(csinh, z, CMPLXL(copysign(0, cos(nums[i])), sin(nums[i])), DBL_ULP()); test_even_tol(ccosh, z, CMPLXL(cos(nums[i]), copysign(0, sin(nums[i]))), DBL_ULP()); test_odd_tol(ctanh, z, CMPLXL(0, tan(nums[i])), DBL_ULP()); test_odd_tol(csin, z, CMPLXL(0, sinh(nums[i])), DBL_ULP()); test_even_tol(ccos, z, CMPLXL(cosh(nums[i]), -0.0), DBL_ULP()); test_odd_tol(ctan, z, CMPLXL(0, tanh(nums[i])), DBL_ULP()); test_odd_tol(csinhf, z, CMPLXL(copysign(0, cosf(nums[i])), sinf(nums[i])), FLT_ULP()); test_even_tol(ccoshf, z, CMPLXL(cosf(nums[i]), copysign(0, sinf(nums[i]))), FLT_ULP()); test_odd_tol(ctanhf, z, CMPLXL(0, tanf(nums[i])), FLT_ULP()); test_odd_tol(csinf, z, CMPLXL(0, sinhf(nums[i])), FLT_ULP()); test_even_tol(ccosf, z, CMPLXL(coshf(nums[i]), -0.0), FLT_ULP()); test_odd_tol(ctanf, z, CMPLXL(0, tanhf(nums[i])), 1.3 * FLT_ULP()); } } ATF_TC(test_small_inputs); ATF_TC_HEAD(test_small_inputs, tc) { atf_tc_set_md_var(tc, "descr", "test underflow inputs"); } ATF_TC_BODY(test_small_inputs, tc) { /* * z = 0.5 + i Pi/4 * sinh(z) = (sinh(0.5) + i cosh(0.5)) * sqrt(2)/2 * cosh(z) = (cosh(0.5) + i sinh(0.5)) * sqrt(2)/2 * tanh(z) = (2cosh(0.5)sinh(0.5) + i) / (2 cosh(0.5)**2 - 1) * z = -0.5 + i Pi/2 * sinh(z) = cosh(0.5) * cosh(z) = -i sinh(0.5) * tanh(z) = -coth(0.5) * z = 1.0 + i 3Pi/4 * sinh(z) = (-sinh(1) + i cosh(1)) * sqrt(2)/2 * cosh(z) = (-cosh(1) + i sinh(1)) * sqrt(2)/2 * tanh(z) = (2cosh(1)sinh(1) - i) / (2cosh(1)**2 - 1) */ static const struct { long double a, b; long double sinh_a, sinh_b; long double cosh_a, cosh_b; long double tanh_a, tanh_b; } tests[] = { { 0.5L, 0.78539816339744830961566084581987572L, 0.36847002415910435172083660522240710L, 0.79735196663945774996093142586179334L, 0.79735196663945774996093142586179334L, 0.36847002415910435172083660522240710L, 0.76159415595576488811945828260479359L, 0.64805427366388539957497735322615032L }, { -0.5L, 1.57079632679489661923132169163975144L, 0.0L, 1.12762596520638078522622516140267201L, 0.0L, -0.52109530549374736162242562641149156L, -2.16395341373865284877000401021802312L, 0.0L }, { 1.0L, 2.35619449019234492884698253745962716L, -0.83099273328405698212637979852748608L, 1.09112278079550143030545602018565236L, -1.09112278079550143030545602018565236L, 0.83099273328405698212637979852748609L, 0.96402758007581688394641372410092315L, -0.26580222883407969212086273981988897L } }; long double complex z; unsigned i; for (i = 0; i < nitems(tests); i++) { z = CMPLXL(tests[i].a, tests[i].b); testall_odd_tol(csinh, z, CMPLXL(tests[i].sinh_a, tests[i].sinh_b), 1.1); testall_even_tol(ccosh, z, CMPLXL(tests[i].cosh_a, tests[i].cosh_b), 1.1); testall_odd_tol(ctanh, z, CMPLXL(tests[i].tanh_a, tests[i].tanh_b), 1.4); } } ATF_TC(test_large_inputs); ATF_TC_HEAD(test_large_inputs, tc) { atf_tc_set_md_var(tc, "descr", "Test inputs that might cause overflow in a sloppy implementation"); } ATF_TC_BODY(test_large_inputs, tc) { long double complex z; /* tanh() uses a threshold around x=22, so check both sides. */ z = CMPLXL(21, 0.78539816339744830961566084581987572L); testall_odd_tol(ctanh, z, CMPLXL(1.0, 1.14990445285871196133287617611468468e-18L), 1.2); z++; testall_odd_tol(ctanh, z, CMPLXL(1.0, 1.55622644822675930314266334585597964e-19L), 1); z = CMPLXL(355, 0.78539816339744830961566084581987572L); test_odd_tol(ctanh, z, CMPLXL(1.0, 8.95257245135025991216632140458264468e-309L), DBL_ULP()); z = CMPLXL(30, 0x1p1023L); test_odd_tol(ctanh, z, CMPLXL(1.0, -1.62994325413993477997492170229268382e-26L), DBL_ULP()); z = CMPLXL(1, 0x1p1023L); test_odd_tol(ctanh, z, CMPLXL(0.878606311888306869546254022621986509L, -0.225462792499754505792678258169527424L), DBL_ULP()); z = CMPLXL(710.6, 0.78539816339744830961566084581987572L); test_odd_tol(csinh, z, CMPLXL(1.43917579766621073533185387499658944e308L, 1.43917579766621073533185387499658944e308L), DBL_ULP()); test_even_tol(ccosh, z, CMPLXL(1.43917579766621073533185387499658944e308L, 1.43917579766621073533185387499658944e308L), DBL_ULP()); z = CMPLXL(1500, 0.78539816339744830961566084581987572L); testall_odd(csinh, z, CMPLXL(INFINITY, INFINITY), OPT_INEXACT, FE_OVERFLOW, CS_BOTH); testall_even(ccosh, z, CMPLXL(INFINITY, INFINITY), OPT_INEXACT, FE_OVERFLOW, CS_BOTH); } ATF_TP_ADD_TCS(tp) { ATF_TP_ADD_TC(tp, test_zero_input); ATF_TP_ADD_TC(tp, test_nan_inputs); ATF_TP_ADD_TC(tp, test_inf_inputs); ATF_TP_ADD_TC(tp, test_axes); ATF_TP_ADD_TC(tp, test_small_inputs); ATF_TP_ADD_TC(tp, test_large_inputs); return (atf_no_error()); } diff --git a/lib/msun/tests/exponential_test.c b/lib/msun/tests/exponential_test.c index 5b39d29fa5bf..14cedf8f9190 100644 --- a/lib/msun/tests/exponential_test.c +++ b/lib/msun/tests/exponential_test.c @@ -1,169 +1,187 @@ /*- * Copyright (c) 2008 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Tests for corner cases in exp*(). */ #include __FBSDID("$FreeBSD$"); -#include #include #include #include #include #ifdef __i386__ #include #endif #include "test-utils.h" #pragma STDC FENV_ACCESS ON /* * Test that a function returns the correct value and sets the * exception flags correctly. The exceptmask specifies which * exceptions we should check. We need to be lenient for several * reasoons, but mainly because on some architectures it's impossible * to raise FE_OVERFLOW without raising FE_INEXACT. * * These are macros instead of functions so that assert provides more * meaningful error messages. * * XXX The volatile here is to avoid gcc's bogus constant folding and work * around the lack of support for the FENV_ACCESS pragma. */ #define test(func, x, result, exceptmask, excepts) do { \ volatile long double _d = x; \ - assert(feclearexcept(FE_ALL_EXCEPT) == 0); \ - assert(fpequal((func)(_d), (result))); \ - assert(((void)(func), fetestexcept(exceptmask) == (excepts))); \ + ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT)); \ + ATF_CHECK(fpequal((func)(_d), (result))); \ + CHECK_FP_EXCEPTIONS_MSG(excepts, exceptmask, "for %s(%s)", \ + #func, #x); \ } while (0) /* Test all the functions that compute b^x. */ #define _testall0(x, result, exceptmask, excepts) do { \ test(exp, x, result, exceptmask, excepts); \ test(expf, x, result, exceptmask, excepts); \ test(exp2, x, result, exceptmask, excepts); \ test(exp2f, x, result, exceptmask, excepts); \ } while (0) /* Skip over exp2l on platforms that don't support it. */ #if LDBL_PREC == 53 #define testall0 _testall0 #else #define testall0(x, result, exceptmask, excepts) do { \ _testall0(x, result, exceptmask, excepts); \ test(exp2l, x, result, exceptmask, excepts); \ } while (0) #endif /* Test all the functions that compute b^x - 1. */ #define testall1(x, result, exceptmask, excepts) do { \ test(expm1, x, result, exceptmask, excepts); \ test(expm1f, x, result, exceptmask, excepts); \ } while (0) static void run_generic_tests(void) { /* exp(0) == 1, no exceptions raised */ testall0(0.0, 1.0, ALL_STD_EXCEPT, 0); testall1(0.0, 0.0, ALL_STD_EXCEPT, 0); testall0(-0.0, 1.0, ALL_STD_EXCEPT, 0); testall1(-0.0, -0.0, ALL_STD_EXCEPT, 0); /* exp(NaN) == NaN, no exceptions raised */ testall0(NAN, NAN, ALL_STD_EXCEPT, 0); testall1(NAN, NAN, ALL_STD_EXCEPT, 0); /* exp(Inf) == Inf, no exceptions raised */ testall0(INFINITY, INFINITY, ALL_STD_EXCEPT, 0); testall1(INFINITY, INFINITY, ALL_STD_EXCEPT, 0); /* exp(-Inf) == 0, no exceptions raised */ testall0(-INFINITY, 0.0, ALL_STD_EXCEPT, 0); testall1(-INFINITY, -1.0, ALL_STD_EXCEPT, 0); #if !defined(__i386__) /* exp(big) == Inf, overflow exception */ testall0(50000.0, INFINITY, ALL_STD_EXCEPT & ~FE_INEXACT, FE_OVERFLOW); testall1(50000.0, INFINITY, ALL_STD_EXCEPT & ~FE_INEXACT, FE_OVERFLOW); /* exp(small) == 0, underflow and inexact exceptions */ testall0(-50000.0, 0.0, ALL_STD_EXCEPT, FE_UNDERFLOW | FE_INEXACT); #endif testall1(-50000.0, -1.0, ALL_STD_EXCEPT, FE_INEXACT); } -static void -run_exp2_tests(void) + +/* + * We should insist that exp2() return exactly the correct + * result and not raise an inexact exception for integer + * arguments. + */ +ATF_TC_WITHOUT_HEAD(exp2f); +ATF_TC_BODY(exp2f, tc) { - unsigned i; - - /* - * We should insist that exp2() return exactly the correct - * result and not raise an inexact exception for integer - * arguments. - */ - feclearexcept(FE_ALL_EXCEPT); - for (i = FLT_MIN_EXP - FLT_MANT_DIG; i < FLT_MAX_EXP; i++) { - assert(exp2f(i) == ldexpf(1.0, i)); - assert(fetestexcept(ALL_STD_EXCEPT) == 0); - } - for (i = DBL_MIN_EXP - DBL_MANT_DIG; i < DBL_MAX_EXP; i++) { - assert(exp2(i) == ldexp(1.0, i)); - assert(fetestexcept(ALL_STD_EXCEPT) == 0); - } - for (i = LDBL_MIN_EXP - LDBL_MANT_DIG; i < LDBL_MAX_EXP; i++) { - assert(exp2l(i) == ldexpl(1.0, i)); - assert(fetestexcept(ALL_STD_EXCEPT) == 0); + ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT)); + for (int i = FLT_MIN_EXP - FLT_MANT_DIG; i < FLT_MAX_EXP; i++) { + ATF_CHECK_EQ(exp2f(i), ldexpf(1.0, i)); + CHECK_FP_EXCEPTIONS(0, ALL_STD_EXCEPT); } } -int -main(void) +ATF_TC_WITHOUT_HEAD(exp2); +ATF_TC_BODY(exp2, tc) { + ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT)); + for (int i = DBL_MIN_EXP - DBL_MANT_DIG; i < DBL_MAX_EXP; i++) { + ATF_CHECK_EQ(exp2(i), ldexp(1.0, i)); + CHECK_FP_EXCEPTIONS(0, ALL_STD_EXCEPT); + } +} - printf("1..3\n"); +ATF_TC_WITHOUT_HEAD(exp2l); +ATF_TC_BODY(exp2l, tc) +{ + ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT)); + for (int i = LDBL_MIN_EXP - LDBL_MANT_DIG; i < LDBL_MAX_EXP; i++) { + ATF_CHECK_EQ(exp2l(i), ldexpl(1.0, i)); + CHECK_FP_EXCEPTIONS(0, ALL_STD_EXCEPT); + } +} +ATF_TC_WITHOUT_HEAD(generic); +ATF_TC_BODY(generic, tc) +{ run_generic_tests(); - printf("ok 1 - exponential\n"); +} #ifdef __i386__ +ATF_TC_WITHOUT_HEAD(generic_fp_pe); +ATF_TC_BODY(generic_fp_pe, tc) +{ fpsetprec(FP_PE); run_generic_tests(); +} #endif - printf("ok 2 - exponential\n"); - run_exp2_tests(); - printf("ok 3 - exponential\n"); +ATF_TP_ADD_TCS(tp) +{ + ATF_TP_ADD_TC(tp, generic); +#ifdef __i386__ + ATF_TP_ADD_TC(tp, generic_fp_pe); +#endif + ATF_TP_ADD_TC(tp, exp2); + ATF_TP_ADD_TC(tp, exp2f); + ATF_TP_ADD_TC(tp, exp2l); - return (0); + return (atf_no_error()); } diff --git a/lib/msun/tests/fenv_test.c b/lib/msun/tests/fenv_test.c index 62abfefb4a8a..b80b591cf52b 100644 --- a/lib/msun/tests/fenv_test.c +++ b/lib/msun/tests/fenv_test.c @@ -1,565 +1,543 @@ /*- * Copyright (c) 2004 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Test the correctness and C99-compliance of various fenv.h features. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include #include #include "test-utils.h" #define NEXCEPTS (sizeof(std_excepts) / sizeof(std_excepts[0])) static const int std_excepts[] = { FE_INVALID, FE_DIVBYZERO, FE_OVERFLOW, FE_UNDERFLOW, FE_INEXACT, }; /* init_exceptsets() initializes this to the power set of std_excepts[] */ static int std_except_sets[1 << NEXCEPTS]; #pragma STDC FENV_ACCESS ON /* * Initialize std_except_sets[] to the power set of std_excepts[] */ -static void -init_exceptsets(void) +static __attribute__((constructor)) void +do_setup(void) { unsigned i, j, sr; + /* Avoid double output after fork() */ + setvbuf(stdout, NULL, _IONBF, 0); + for (i = 0; i < 1 << NEXCEPTS; i++) { for (sr = i, j = 0; sr != 0; sr >>= 1, j++) std_except_sets[i] |= std_excepts[j] & ((~sr & 1) - 1); } } /* * Raise a floating-point exception without relying on the standard * library routines, which we are trying to test. * * XXX We can't raise an {over,under}flow without also raising an * inexact exception. */ static void raiseexcept(int excepts) { volatile double d; /* * With a compiler that supports the FENV_ACCESS pragma * properly, simple expressions like '0.0 / 0.0' should * be sufficient to generate traps. Unfortunately, we * need to bring a volatile variable into the equation * to prevent incorrect optimizations. */ if (excepts & FE_INVALID) { d = 0.0; d = 0.0 / d; } if (excepts & FE_DIVBYZERO) { d = 0.0; d = 1.0 / d; } if (excepts & FE_OVERFLOW) { d = DBL_MAX; d *= 2.0; } if (excepts & FE_UNDERFLOW) { d = DBL_MIN; d /= DBL_MAX; } if (excepts & FE_INEXACT) { d = DBL_MIN; d += 1.0; } /* * On the x86 (and some other architectures?) the FPU and * integer units are decoupled. We need to execute an FWAIT * or a floating-point instruction to get synchronous exceptions. */ d = 1.0; d += 1.0; } /* * Determine the current rounding mode without relying on the fenv * routines. This function may raise an inexact exception. */ static int getround(void) { volatile double d; /* * This test works just as well with 0.0 - 0.0, except on ia64 * where 0.0 - 0.0 gives the wrong sign when rounding downwards. */ d = 1.0; d -= 1.0; if (copysign(1.0, d) < 0.0) return (FE_DOWNWARD); d = 1.0; if (d + (DBL_EPSILON * 3.0 / 4.0) == 1.0) return (FE_TOWARDZERO); if (d + (DBL_EPSILON * 1.0 / 4.0) > 1.0) return (FE_UPWARD); return (FE_TONEAREST); } static void trap_handler(int sig) { - assert(sig == SIGFPE); + ATF_CHECK_EQ(SIGFPE, sig); _exit(0); } /* * This tests checks the default FP environment, so it must be first. * The memcmp() test below may be too much to ask for, since there * could be multiple machine-specific default environments. */ -static void -test_dfl_env(void) +ATF_TC_WITHOUT_HEAD(dfl_env); +ATF_TC_BODY(dfl_env, tc) { #ifndef NO_STRICT_DFL_ENV fenv_t env; fegetenv(&env); #ifdef __amd64__ /* * Compare the fields that the AMD [1] and Intel [2] specs say will be * set once fnstenv returns. * * Not all amd64 capable processors implement the fnstenv instruction * by zero'ing out the env.__x87.__other field (example: AMD Opteron * 6308). The AMD64/x64 specs aren't explicit on what the * env.__x87.__other field will contain after fnstenv is executed, so * the values in env.__x87.__other could be filled with arbitrary * data depending on how the CPU implements fnstenv. * * 1. http://support.amd.com/TechDocs/26569_APM_v5.pdf * 2. http://www.intel.com/Assets/en_US/PDF/manual/253666.pdf */ - assert(memcmp(&env.__mxcsr, &FE_DFL_ENV->__mxcsr, + ATF_CHECK(memcmp(&env.__mxcsr, &FE_DFL_ENV->__mxcsr, sizeof(env.__mxcsr)) == 0); - assert(memcmp(&env.__x87.__control, &FE_DFL_ENV->__x87.__control, + ATF_CHECK(memcmp(&env.__x87.__control, &FE_DFL_ENV->__x87.__control, sizeof(env.__x87.__control)) == 0); - assert(memcmp(&env.__x87.__status, &FE_DFL_ENV->__x87.__status, + ATF_CHECK(memcmp(&env.__x87.__status, &FE_DFL_ENV->__x87.__status, sizeof(env.__x87.__status)) == 0); - assert(memcmp(&env.__x87.__tag, &FE_DFL_ENV->__x87.__tag, + ATF_CHECK(memcmp(&env.__x87.__tag, &FE_DFL_ENV->__x87.__tag, sizeof(env.__x87.__tag)) == 0); #else - assert(memcmp(&env, FE_DFL_ENV, sizeof(env)) == 0); + ATF_CHECK_EQ(0, memcmp(&env, FE_DFL_ENV, sizeof(env))); #endif #endif - assert(fetestexcept(FE_ALL_EXCEPT) == 0); + ATF_CHECK_EQ(0, fetestexcept(FE_ALL_EXCEPT)); } /* * Test fetestexcept() and feclearexcept(). */ -static void -test_fetestclearexcept(void) +ATF_TC_WITHOUT_HEAD(fetestclearexcept); +ATF_TC_BODY(fetestclearexcept, tc) { int excepts, i; for (i = 0; i < 1 << NEXCEPTS; i++) - assert(fetestexcept(std_except_sets[i]) == 0); + ATF_CHECK_EQ(0, fetestexcept(std_except_sets[i])); for (i = 0; i < 1 << NEXCEPTS; i++) { excepts = std_except_sets[i]; /* FE_ALL_EXCEPT might be special-cased, as on i386. */ raiseexcept(excepts); - assert(fetestexcept(excepts) == excepts); - assert(feclearexcept(FE_ALL_EXCEPT) == 0); - assert(fetestexcept(FE_ALL_EXCEPT) == 0); + ATF_CHECK_EQ(excepts, fetestexcept(excepts)); + ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT)); + ATF_CHECK_EQ(0, fetestexcept(FE_ALL_EXCEPT)); raiseexcept(excepts); - assert(fetestexcept(excepts) == excepts); + ATF_CHECK_EQ(excepts, fetestexcept(excepts)); if ((excepts & (FE_UNDERFLOW | FE_OVERFLOW)) != 0) { excepts |= FE_INEXACT; - assert((fetestexcept(ALL_STD_EXCEPT) | FE_INEXACT) == - excepts); + ATF_CHECK_EQ(excepts, (fetestexcept(ALL_STD_EXCEPT) | FE_INEXACT)); } else { - assert(fetestexcept(ALL_STD_EXCEPT) == excepts); + ATF_CHECK_EQ(excepts, fetestexcept(ALL_STD_EXCEPT)); } - assert(feclearexcept(excepts) == 0); - assert(fetestexcept(ALL_STD_EXCEPT) == 0); + ATF_CHECK_EQ(0, feclearexcept(excepts)); + ATF_CHECK_EQ(0, fetestexcept(ALL_STD_EXCEPT)); } } /* * Test fegetexceptflag() and fesetexceptflag(). * * Prerequisites: fetestexcept(), feclearexcept() */ -static void -test_fegsetexceptflag(void) +ATF_TC_WITHOUT_HEAD(fegsetexceptflag); +ATF_TC_BODY(fegsetexceptflag, tc) { fexcept_t flag; int excepts, i; - assert(fetestexcept(FE_ALL_EXCEPT) == 0); + ATF_CHECK_EQ(0, fetestexcept(FE_ALL_EXCEPT)); for (i = 0; i < 1 << NEXCEPTS; i++) { excepts = std_except_sets[i]; - assert(fegetexceptflag(&flag, excepts) == 0); + ATF_CHECK_EQ(0, fegetexceptflag(&flag, excepts)); raiseexcept(ALL_STD_EXCEPT); - assert(fesetexceptflag(&flag, excepts) == 0); - assert(fetestexcept(ALL_STD_EXCEPT) == - (ALL_STD_EXCEPT ^ excepts)); - - assert(fegetexceptflag(&flag, FE_ALL_EXCEPT) == 0); - assert(feclearexcept(FE_ALL_EXCEPT) == 0); - assert(fesetexceptflag(&flag, excepts) == 0); - assert(fetestexcept(ALL_STD_EXCEPT) == 0); - assert(fesetexceptflag(&flag, ALL_STD_EXCEPT ^ excepts) == 0); - assert(fetestexcept(ALL_STD_EXCEPT) == - (ALL_STD_EXCEPT ^ excepts)); - - assert(feclearexcept(FE_ALL_EXCEPT) == 0); + ATF_CHECK_EQ(0, fesetexceptflag(&flag, excepts)); + ATF_CHECK_EQ((ALL_STD_EXCEPT ^ excepts), fetestexcept(ALL_STD_EXCEPT)); + + ATF_CHECK_EQ(0, fegetexceptflag(&flag, FE_ALL_EXCEPT)); + ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT)); + ATF_CHECK_EQ(0, fesetexceptflag(&flag, excepts)); + ATF_CHECK_EQ(0, fetestexcept(ALL_STD_EXCEPT)); + ATF_CHECK_EQ(0, fesetexceptflag(&flag, ALL_STD_EXCEPT ^ excepts)); + ATF_CHECK_EQ((ALL_STD_EXCEPT ^ excepts), fetestexcept(ALL_STD_EXCEPT)); + + ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT)); } } /* * Test feraiseexcept(). * * Prerequisites: fetestexcept(), feclearexcept() */ -static void -test_feraiseexcept(void) +ATF_TC_WITHOUT_HEAD(feraiseexcept); +ATF_TC_BODY(feraiseexcept, tc) { int excepts, i; for (i = 0; i < 1 << NEXCEPTS; i++) { excepts = std_except_sets[i]; - assert(fetestexcept(FE_ALL_EXCEPT) == 0); - assert(feraiseexcept(excepts) == 0); + ATF_CHECK_EQ(0, fetestexcept(FE_ALL_EXCEPT)); + ATF_CHECK_EQ(0, feraiseexcept(excepts)); if ((excepts & (FE_UNDERFLOW | FE_OVERFLOW)) != 0) { excepts |= FE_INEXACT; - assert((fetestexcept(ALL_STD_EXCEPT) | FE_INEXACT) == - excepts); + ATF_CHECK_EQ(excepts, (fetestexcept(ALL_STD_EXCEPT) | FE_INEXACT)); } else { - assert(fetestexcept(ALL_STD_EXCEPT) == excepts); + ATF_CHECK_EQ(excepts, fetestexcept(ALL_STD_EXCEPT)); } - assert(feclearexcept(FE_ALL_EXCEPT) == 0); + ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT)); } - assert(feraiseexcept(FE_INVALID | FE_DIVBYZERO) == 0); - assert(fetestexcept(ALL_STD_EXCEPT) == (FE_INVALID | FE_DIVBYZERO)); - assert(feraiseexcept(FE_OVERFLOW | FE_UNDERFLOW | FE_INEXACT) == 0); - assert(fetestexcept(ALL_STD_EXCEPT) == ALL_STD_EXCEPT); - assert(feclearexcept(FE_ALL_EXCEPT) == 0); + ATF_CHECK_EQ(0, feraiseexcept(FE_INVALID | FE_DIVBYZERO)); + ATF_CHECK_EQ((FE_INVALID | FE_DIVBYZERO), fetestexcept(ALL_STD_EXCEPT)); + ATF_CHECK_EQ(0, feraiseexcept(FE_OVERFLOW | FE_UNDERFLOW | FE_INEXACT)); + ATF_CHECK_EQ(ALL_STD_EXCEPT, fetestexcept(ALL_STD_EXCEPT)); + ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT)); } /* * Test fegetround() and fesetround(). */ -static void -test_fegsetround(void) +ATF_TC_WITHOUT_HEAD(fegsetround); +ATF_TC_BODY(fegsetround, tc) { - assert(fegetround() == FE_TONEAREST); - assert(getround() == FE_TONEAREST); - assert(FLT_ROUNDS == 1); + ATF_CHECK_EQ(FE_TONEAREST, fegetround()); + ATF_CHECK_EQ(FE_TONEAREST, getround()); + ATF_CHECK_EQ(1, FLT_ROUNDS); - assert(fesetround(FE_DOWNWARD) == 0); - assert(fegetround() == FE_DOWNWARD); - assert(getround() == FE_DOWNWARD); - assert(FLT_ROUNDS == 3); + ATF_CHECK_EQ(0, fesetround(FE_DOWNWARD)); + ATF_CHECK_EQ(FE_DOWNWARD, fegetround()); + ATF_CHECK_EQ(FE_DOWNWARD, getround()); + ATF_CHECK_EQ(3, FLT_ROUNDS); - assert(fesetround(FE_UPWARD) == 0); - assert(getround() == FE_UPWARD); - assert(fegetround() == FE_UPWARD); - assert(FLT_ROUNDS == 2); + ATF_CHECK_EQ(0, fesetround(FE_UPWARD)); + ATF_CHECK_EQ(FE_UPWARD, getround()); + ATF_CHECK_EQ(FE_UPWARD, fegetround()); + ATF_CHECK_EQ(2, FLT_ROUNDS); - assert(fesetround(FE_TOWARDZERO) == 0); - assert(getround() == FE_TOWARDZERO); - assert(fegetround() == FE_TOWARDZERO); - assert(FLT_ROUNDS == 0); + ATF_CHECK_EQ(0, fesetround(FE_TOWARDZERO)); + ATF_CHECK_EQ(FE_TOWARDZERO, getround()); + ATF_CHECK_EQ(FE_TOWARDZERO, fegetround()); + ATF_CHECK_EQ(0, FLT_ROUNDS); - assert(fesetround(FE_TONEAREST) == 0); - assert(getround() == FE_TONEAREST); - assert(FLT_ROUNDS == 1); + ATF_CHECK_EQ(0, fesetround(FE_TONEAREST)); + ATF_CHECK_EQ(FE_TONEAREST, getround()); + ATF_CHECK_EQ(1, FLT_ROUNDS); - assert(feclearexcept(FE_ALL_EXCEPT) == 0); + ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT)); } /* * Test fegetenv() and fesetenv(). * * Prerequisites: fetestexcept(), feclearexcept(), fegetround(), fesetround() */ -static void -test_fegsetenv(void) +ATF_TC_WITHOUT_HEAD(fegsetenv); +ATF_TC_BODY(fegsetenv, tc) { fenv_t env1, env2; int excepts, i; for (i = 0; i < 1 << NEXCEPTS; i++) { excepts = std_except_sets[i]; - assert(fetestexcept(FE_ALL_EXCEPT) == 0); - assert(fegetround() == FE_TONEAREST); - assert(fegetenv(&env1) == 0); + ATF_CHECK_EQ(0, fetestexcept(FE_ALL_EXCEPT)); + ATF_CHECK_EQ(FE_TONEAREST, fegetround()); + ATF_CHECK_EQ(0, fegetenv(&env1)); /* * fe[gs]etenv() should be able to save and restore * exception flags without the spurious inexact * exceptions that afflict raiseexcept(). */ raiseexcept(excepts); if ((excepts & (FE_UNDERFLOW | FE_OVERFLOW)) != 0 && (excepts & FE_INEXACT) == 0) - assert(feclearexcept(FE_INEXACT) == 0); + ATF_CHECK_EQ(0, feclearexcept(FE_INEXACT)); fesetround(FE_DOWNWARD); - assert(fegetenv(&env2) == 0); - assert(fesetenv(&env1) == 0); - assert(fetestexcept(FE_ALL_EXCEPT) == 0); - assert(fegetround() == FE_TONEAREST); + ATF_CHECK_EQ(0, fegetenv(&env2)); + ATF_CHECK_EQ(0, fesetenv(&env1)); + ATF_CHECK_EQ(0, fetestexcept(FE_ALL_EXCEPT)); + ATF_CHECK_EQ(FE_TONEAREST, fegetround()); - assert(fesetenv(&env2) == 0); + ATF_CHECK_EQ(0, fesetenv(&env2)); /* * Some platforms like powerpc may set extra exception bits. Since * only standard exceptions are tested, mask against ALL_STD_EXCEPT */ - assert((fetestexcept(FE_ALL_EXCEPT) & ALL_STD_EXCEPT) == excepts); + ATF_CHECK_EQ(excepts, (fetestexcept(FE_ALL_EXCEPT) & ALL_STD_EXCEPT)); - assert(fegetround() == FE_DOWNWARD); - assert(fesetenv(&env1) == 0); - assert(fetestexcept(FE_ALL_EXCEPT) == 0); - assert(fegetround() == FE_TONEAREST); + ATF_CHECK_EQ(FE_DOWNWARD, fegetround()); + ATF_CHECK_EQ(0, fesetenv(&env1)); + ATF_CHECK_EQ(0, fetestexcept(FE_ALL_EXCEPT)); + ATF_CHECK_EQ(FE_TONEAREST, fegetround()); } } /* * Test fegetexcept(), fedisableexcept(), and feenableexcept(). * * Prerequisites: fetestexcept(), feraiseexcept() */ -static void -test_masking(void) +ATF_TC_WITHOUT_HEAD(masking); +ATF_TC_BODY(masking, tc) { struct sigaction act; int except, pass, raise, status; unsigned i; - assert((fegetexcept() & ALL_STD_EXCEPT) == 0); - assert((feenableexcept(FE_INVALID|FE_OVERFLOW) & ALL_STD_EXCEPT) == 0); - assert((feenableexcept(FE_UNDERFLOW) & ALL_STD_EXCEPT) == - (FE_INVALID | FE_OVERFLOW)); - assert((fedisableexcept(FE_OVERFLOW) & ALL_STD_EXCEPT) == - (FE_INVALID | FE_OVERFLOW | FE_UNDERFLOW)); - assert((fegetexcept() & ALL_STD_EXCEPT) == (FE_INVALID | FE_UNDERFLOW)); - assert((fedisableexcept(FE_ALL_EXCEPT) & ALL_STD_EXCEPT) == - (FE_INVALID | FE_UNDERFLOW)); - assert((fegetexcept() & ALL_STD_EXCEPT) == 0); + ATF_CHECK_EQ(0, (fegetexcept() & ALL_STD_EXCEPT)); + ATF_CHECK_EQ(0, (feenableexcept(FE_INVALID|FE_OVERFLOW) & ALL_STD_EXCEPT)); + ATF_CHECK_EQ((FE_INVALID | FE_OVERFLOW), (feenableexcept(FE_UNDERFLOW) & ALL_STD_EXCEPT)); + ATF_CHECK_EQ((FE_INVALID | FE_OVERFLOW | FE_UNDERFLOW), (fedisableexcept(FE_OVERFLOW) & ALL_STD_EXCEPT)); + ATF_CHECK_EQ((FE_INVALID | FE_UNDERFLOW), (fegetexcept() & ALL_STD_EXCEPT)); + ATF_CHECK_EQ((FE_INVALID | FE_UNDERFLOW), (fedisableexcept(FE_ALL_EXCEPT) & ALL_STD_EXCEPT)); + ATF_CHECK_EQ(0, (fegetexcept() & ALL_STD_EXCEPT)); sigemptyset(&act.sa_mask); act.sa_flags = 0; act.sa_handler = trap_handler; for (pass = 0; pass < 2; pass++) { for (i = 0; i < NEXCEPTS; i++) { except = std_excepts[i]; /* over/underflow may also raise inexact */ if (except == FE_INEXACT) raise = FE_DIVBYZERO | FE_INVALID; else raise = ALL_STD_EXCEPT ^ except; /* * We need to fork a child process because * there isn't a portable way to recover from * a floating-point exception. */ switch(fork()) { case 0: /* child */ - assert((fegetexcept() & ALL_STD_EXCEPT) == 0); - assert((feenableexcept(except) - & ALL_STD_EXCEPT) == 0); - assert(fegetexcept() == except); + ATF_CHECK_EQ(0, (fegetexcept() & ALL_STD_EXCEPT)); + ATF_REQUIRE_EQ(0, (feenableexcept(except) & ALL_STD_EXCEPT)); + ATF_CHECK_EQ(except, fegetexcept()); raiseexcept(raise); - assert(feraiseexcept(raise) == 0); - assert(fetestexcept(ALL_STD_EXCEPT) == raise); + ATF_CHECK_EQ(0, feraiseexcept(raise)); + ATF_CHECK_EQ(raise, fetestexcept(ALL_STD_EXCEPT)); - assert(sigaction(SIGFPE, &act, NULL) == 0); + ATF_CHECK_EQ(0, sigaction(SIGFPE, &act, NULL)); switch (pass) { case 0: raiseexcept(except); case 1: feraiseexcept(except); default: - assert(0); + ATF_REQUIRE(0); } - assert(0); + ATF_REQUIRE(0); default: /* parent */ - assert(wait(&status) > 0); + ATF_REQUIRE(wait(&status) > 0); /* * Avoid assert() here so that it's possible * to examine a failed child's core dump. */ if (!WIFEXITED(status)) errx(1, "child aborted\n"); - assert(WEXITSTATUS(status) == 0); + ATF_CHECK_EQ(0, WEXITSTATUS(status)); break; case -1: /* error */ - assert(0); + ATF_REQUIRE(0); } } } - assert(fetestexcept(FE_ALL_EXCEPT) == 0); + ATF_CHECK_EQ(0, fetestexcept(FE_ALL_EXCEPT)); } /* * Test feholdexcept() and feupdateenv(). * * Prerequisites: fetestexcept(), fegetround(), fesetround(), * fedisableexcept(), feenableexcept() */ -static void -test_feholdupdate(void) +ATF_TC_WITHOUT_HEAD(feholdupdate); +ATF_TC_BODY(feholdupdate, tc) { fenv_t env; struct sigaction act; int except, pass, status, raise; unsigned i; sigemptyset(&act.sa_mask); act.sa_flags = 0; act.sa_handler = trap_handler; for (pass = 0; pass < 2; pass++) { for (i = 0; i < NEXCEPTS; i++) { except = std_excepts[i]; /* over/underflow may also raise inexact */ if (except == FE_INEXACT) raise = FE_DIVBYZERO | FE_INVALID; else raise = ALL_STD_EXCEPT ^ except; /* * We need to fork a child process because * there isn't a portable way to recover from * a floating-point exception. */ switch(fork()) { case 0: /* child */ /* * We don't want to cause a fatal exception in * the child until the second pass, so we can * check other properties of feupdateenv(). */ if (pass == 1) - assert((feenableexcept(except) & - ALL_STD_EXCEPT) == 0); + ATF_REQUIRE_EQ(0, feenableexcept(except) & ALL_STD_EXCEPT); raiseexcept(raise); - assert(fesetround(FE_DOWNWARD) == 0); - assert(feholdexcept(&env) == 0); - assert(fetestexcept(FE_ALL_EXCEPT) == 0); + ATF_CHECK_EQ(0, fesetround(FE_DOWNWARD)); + ATF_CHECK_EQ(0, feholdexcept(&env)); + ATF_CHECK_EQ(0, fetestexcept(FE_ALL_EXCEPT)); raiseexcept(except); - assert(fesetround(FE_UPWARD) == 0); + ATF_CHECK_EQ(0, fesetround(FE_UPWARD)); if (pass == 1) - assert(sigaction(SIGFPE, &act, NULL) == - 0); - assert(feupdateenv(&env) == 0); - assert(fegetround() == FE_DOWNWARD); - assert(fetestexcept(ALL_STD_EXCEPT) == - (except | raise)); - - assert(pass == 0); + ATF_CHECK_EQ(0, sigaction(SIGFPE, &act, NULL)); + ATF_CHECK_EQ(0, feupdateenv(&env)); + ATF_CHECK_EQ(FE_DOWNWARD, fegetround()); + ATF_CHECK_EQ((except | raise), fetestexcept(ALL_STD_EXCEPT)); + + ATF_CHECK_EQ(0, pass); _exit(0); default: /* parent */ - assert(wait(&status) > 0); + ATF_REQUIRE(wait(&status) > 0); /* * Avoid assert() here so that it's possible * to examine a failed child's core dump. */ if (!WIFEXITED(status)) errx(1, "child aborted\n"); - assert(WEXITSTATUS(status) == 0); + ATF_CHECK_EQ(0, WEXITSTATUS(status)); break; case -1: /* error */ - assert(0); + ATF_REQUIRE(0); } } } - assert(fetestexcept(FE_ALL_EXCEPT) == 0); + ATF_CHECK_EQ(0, fetestexcept(FE_ALL_EXCEPT)); } -int -main(void) +ATF_TP_ADD_TCS(tp) { - /* Avoid double output after fork() */ - setvbuf(stdout, NULL, _IONBF, 0); - - printf("1..8\n"); - init_exceptsets(); - test_dfl_env(); - printf("ok 1 - fenv\n"); - test_fetestclearexcept(); - printf("ok 2 - fenv\n"); - test_fegsetexceptflag(); - printf("ok 3 - fenv\n"); - test_feraiseexcept(); - printf("ok 4 - fenv\n"); - test_fegsetround(); - printf("ok 5 - fenv\n"); - test_fegsetenv(); - printf("ok 6 - fenv\n"); - test_masking(); - printf("ok 7 - fenv\n"); - test_feholdupdate(); - printf("ok 8 - fenv\n"); - - return (0); + ATF_TP_ADD_TC(tp, dfl_env); + ATF_TP_ADD_TC(tp, fetestclearexcept); + ATF_TP_ADD_TC(tp, fegsetexceptflag); + ATF_TP_ADD_TC(tp, feraiseexcept); + ATF_TP_ADD_TC(tp, fegsetround); + ATF_TP_ADD_TC(tp, fegsetenv); + ATF_TP_ADD_TC(tp, masking); + ATF_TP_ADD_TC(tp, feholdupdate); + + return (atf_no_error()); } diff --git a/lib/msun/tests/fma_test.c b/lib/msun/tests/fma_test.c index 8b654665700f..e601c3e248b2 100644 --- a/lib/msun/tests/fma_test.c +++ b/lib/msun/tests/fma_test.c @@ -1,544 +1,554 @@ /*- * Copyright (c) 2008 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Tests for fma{,f,l}(). */ #include __FBSDID("$FreeBSD$"); #include -#include #include #include #include #include #include #include "test-utils.h" #pragma STDC FENV_ACCESS ON /* * Test that a function returns the correct value and sets the * exception flags correctly. The exceptmask specifies which * exceptions we should check. We need to be lenient for several * reasons, but mainly because on some architectures it's impossible * to raise FE_OVERFLOW without raising FE_INEXACT. * * These are macros instead of functions so that assert provides more * meaningful error messages. */ #define test(func, x, y, z, result, exceptmask, excepts) do { \ volatile long double _vx = (x), _vy = (y), _vz = (z); \ - assert(feclearexcept(FE_ALL_EXCEPT) == 0); \ - assert(fpequal((func)(_vx, _vy, _vz), (result))); \ - assert(((void)(func), fetestexcept(exceptmask) == (excepts))); \ + ATF_CHECK(feclearexcept(FE_ALL_EXCEPT) == 0); \ + ATF_CHECK(fpequal((func)(_vx, _vy, _vz), (result))); \ + CHECK_FP_EXCEPTIONS_MSG(excepts, exceptmask, "for %s(%s)", \ + #func, #x); \ } while (0) #define testall(x, y, z, result, exceptmask, excepts) do { \ test(fma, (double)(x), (double)(y), (double)(z), \ (double)(result), (exceptmask), (excepts)); \ test(fmaf, (float)(x), (float)(y), (float)(z), \ (float)(result), (exceptmask), (excepts)); \ test(fmal, (x), (y), (z), (result), (exceptmask), (excepts)); \ } while (0) /* Test in all rounding modes. */ #define testrnd(func, x, y, z, rn, ru, rd, rz, exceptmask, excepts) do { \ fesetround(FE_TONEAREST); \ test((func), (x), (y), (z), (rn), (exceptmask), (excepts)); \ fesetround(FE_UPWARD); \ test((func), (x), (y), (z), (ru), (exceptmask), (excepts)); \ fesetround(FE_DOWNWARD); \ test((func), (x), (y), (z), (rd), (exceptmask), (excepts)); \ fesetround(FE_TOWARDZERO); \ test((func), (x), (y), (z), (rz), (exceptmask), (excepts)); \ } while (0) /* * This is needed because clang constant-folds fma in ways that are incorrect * in rounding modes other than FE_TONEAREST. */ static volatile double one = 1.0; static void test_zeroes(void) { const int rd = (fegetround() == FE_DOWNWARD); testall(0.0, 0.0, 0.0, 0.0, ALL_STD_EXCEPT, 0); testall(1.0, 0.0, 0.0, 0.0, ALL_STD_EXCEPT, 0); testall(0.0, 1.0, 0.0, 0.0, ALL_STD_EXCEPT, 0); testall(0.0, 0.0, 1.0, 1.0, ALL_STD_EXCEPT, 0); testall(-0.0, 0.0, 0.0, rd ? -0.0 : 0.0, ALL_STD_EXCEPT, 0); testall(0.0, -0.0, 0.0, rd ? -0.0 : 0.0, ALL_STD_EXCEPT, 0); testall(-0.0, -0.0, 0.0, 0.0, ALL_STD_EXCEPT, 0); testall(0.0, 0.0, -0.0, rd ? -0.0 : 0.0, ALL_STD_EXCEPT, 0); testall(-0.0, -0.0, -0.0, rd ? -0.0 : 0.0, ALL_STD_EXCEPT, 0); testall(-0.0, 0.0, -0.0, -0.0, ALL_STD_EXCEPT, 0); testall(0.0, -0.0, -0.0, -0.0, ALL_STD_EXCEPT, 0); testall(-one, one, one, rd ? -0.0 : 0.0, ALL_STD_EXCEPT, 0); testall(one, -one, one, rd ? -0.0 : 0.0, ALL_STD_EXCEPT, 0); testall(-one, -one, -one, rd ? -0.0 : 0.0, ALL_STD_EXCEPT, 0); switch (fegetround()) { case FE_TONEAREST: case FE_TOWARDZERO: test(fmaf, -FLT_MIN, FLT_MIN, 0.0, -0.0, ALL_STD_EXCEPT, FE_INEXACT | FE_UNDERFLOW); test(fma, -DBL_MIN, DBL_MIN, 0.0, -0.0, ALL_STD_EXCEPT, FE_INEXACT | FE_UNDERFLOW); test(fmal, -LDBL_MIN, LDBL_MIN, 0.0, -0.0, ALL_STD_EXCEPT, FE_INEXACT | FE_UNDERFLOW); } } static void test_infinities(void) { - testall(INFINITY, 1.0, -1.0, INFINITY, ALL_STD_EXCEPT, 0); testall(-1.0, INFINITY, 0.0, -INFINITY, ALL_STD_EXCEPT, 0); testall(0.0, 0.0, INFINITY, INFINITY, ALL_STD_EXCEPT, 0); testall(1.0, 1.0, INFINITY, INFINITY, ALL_STD_EXCEPT, 0); testall(1.0, 1.0, -INFINITY, -INFINITY, ALL_STD_EXCEPT, 0); testall(INFINITY, -INFINITY, 1.0, -INFINITY, ALL_STD_EXCEPT, 0); testall(INFINITY, INFINITY, 1.0, INFINITY, ALL_STD_EXCEPT, 0); testall(-INFINITY, -INFINITY, INFINITY, INFINITY, ALL_STD_EXCEPT, 0); testall(0.0, INFINITY, 1.0, NAN, ALL_STD_EXCEPT, FE_INVALID); testall(INFINITY, 0.0, -0.0, NAN, ALL_STD_EXCEPT, FE_INVALID); /* The invalid exception is optional in this case. */ testall(INFINITY, 0.0, NAN, NAN, ALL_STD_EXCEPT & ~FE_INVALID, 0); testall(INFINITY, INFINITY, -INFINITY, NAN, ALL_STD_EXCEPT, FE_INVALID); testall(-INFINITY, INFINITY, INFINITY, NAN, ALL_STD_EXCEPT, FE_INVALID); testall(INFINITY, -1.0, INFINITY, NAN, ALL_STD_EXCEPT, FE_INVALID); test(fmaf, FLT_MAX, FLT_MAX, -INFINITY, -INFINITY, ALL_STD_EXCEPT, 0); test(fma, DBL_MAX, DBL_MAX, -INFINITY, -INFINITY, ALL_STD_EXCEPT, 0); test(fmal, LDBL_MAX, LDBL_MAX, -INFINITY, -INFINITY, ALL_STD_EXCEPT, 0); test(fmaf, FLT_MAX, -FLT_MAX, INFINITY, INFINITY, ALL_STD_EXCEPT, 0); test(fma, DBL_MAX, -DBL_MAX, INFINITY, INFINITY, ALL_STD_EXCEPT, 0); test(fmal, LDBL_MAX, -LDBL_MAX, INFINITY, INFINITY, ALL_STD_EXCEPT, 0); } static void test_nans(void) { - testall(NAN, 0.0, 0.0, NAN, ALL_STD_EXCEPT, 0); testall(1.0, NAN, 1.0, NAN, ALL_STD_EXCEPT, 0); testall(1.0, -1.0, NAN, NAN, ALL_STD_EXCEPT, 0); testall(0.0, 0.0, NAN, NAN, ALL_STD_EXCEPT, 0); testall(NAN, NAN, NAN, NAN, ALL_STD_EXCEPT, 0); /* x*y should not raise an inexact/overflow/underflow if z is NaN. */ testall(M_PI, M_PI, NAN, NAN, ALL_STD_EXCEPT, 0); test(fmaf, FLT_MIN, FLT_MIN, NAN, NAN, ALL_STD_EXCEPT, 0); test(fma, DBL_MIN, DBL_MIN, NAN, NAN, ALL_STD_EXCEPT, 0); test(fmal, LDBL_MIN, LDBL_MIN, NAN, NAN, ALL_STD_EXCEPT, 0); test(fmaf, FLT_MAX, FLT_MAX, NAN, NAN, ALL_STD_EXCEPT, 0); test(fma, DBL_MAX, DBL_MAX, NAN, NAN, ALL_STD_EXCEPT, 0); test(fmal, LDBL_MAX, LDBL_MAX, NAN, NAN, ALL_STD_EXCEPT, 0); } /* * Tests for cases where z is very small compared to x*y. */ static void test_small_z(void) { - /* x*y positive, z positive */ if (fegetround() == FE_UPWARD) { test(fmaf, one, one, 0x1.0p-100, 1.0 + FLT_EPSILON, ALL_STD_EXCEPT, FE_INEXACT); test(fma, one, one, 0x1.0p-200, 1.0 + DBL_EPSILON, ALL_STD_EXCEPT, FE_INEXACT); test(fmal, one, one, 0x1.0p-200, 1.0 + LDBL_EPSILON, ALL_STD_EXCEPT, FE_INEXACT); } else { testall(0x1.0p100, one, 0x1.0p-100, 0x1.0p100, ALL_STD_EXCEPT, FE_INEXACT); } /* x*y negative, z negative */ if (fegetround() == FE_DOWNWARD) { test(fmaf, -one, one, -0x1.0p-100, -(1.0 + FLT_EPSILON), ALL_STD_EXCEPT, FE_INEXACT); test(fma, -one, one, -0x1.0p-200, -(1.0 + DBL_EPSILON), ALL_STD_EXCEPT, FE_INEXACT); test(fmal, -one, one, -0x1.0p-200, -(1.0 + LDBL_EPSILON), ALL_STD_EXCEPT, FE_INEXACT); } else { testall(0x1.0p100, -one, -0x1.0p-100, -0x1.0p100, ALL_STD_EXCEPT, FE_INEXACT); } /* x*y positive, z negative */ if (fegetround() == FE_DOWNWARD || fegetround() == FE_TOWARDZERO) { test(fmaf, one, one, -0x1.0p-100, 1.0 - FLT_EPSILON / 2, ALL_STD_EXCEPT, FE_INEXACT); test(fma, one, one, -0x1.0p-200, 1.0 - DBL_EPSILON / 2, ALL_STD_EXCEPT, FE_INEXACT); test(fmal, one, one, -0x1.0p-200, 1.0 - LDBL_EPSILON / 2, ALL_STD_EXCEPT, FE_INEXACT); } else { testall(0x1.0p100, one, -0x1.0p-100, 0x1.0p100, ALL_STD_EXCEPT, FE_INEXACT); } /* x*y negative, z positive */ if (fegetround() == FE_UPWARD || fegetround() == FE_TOWARDZERO) { test(fmaf, -one, one, 0x1.0p-100, -1.0 + FLT_EPSILON / 2, ALL_STD_EXCEPT, FE_INEXACT); test(fma, -one, one, 0x1.0p-200, -1.0 + DBL_EPSILON / 2, ALL_STD_EXCEPT, FE_INEXACT); test(fmal, -one, one, 0x1.0p-200, -1.0 + LDBL_EPSILON / 2, ALL_STD_EXCEPT, FE_INEXACT); } else { testall(-0x1.0p100, one, 0x1.0p-100, -0x1.0p100, ALL_STD_EXCEPT, FE_INEXACT); } } /* * Tests for cases where z is very large compared to x*y. */ static void test_big_z(void) { - /* z positive, x*y positive */ if (fegetround() == FE_UPWARD) { test(fmaf, 0x1.0p-50, 0x1.0p-50, 1.0, 1.0 + FLT_EPSILON, ALL_STD_EXCEPT, FE_INEXACT); test(fma, 0x1.0p-100, 0x1.0p-100, 1.0, 1.0 + DBL_EPSILON, ALL_STD_EXCEPT, FE_INEXACT); test(fmal, 0x1.0p-100, 0x1.0p-100, 1.0, 1.0 + LDBL_EPSILON, ALL_STD_EXCEPT, FE_INEXACT); } else { testall(-0x1.0p-50, -0x1.0p-50, 0x1.0p100, 0x1.0p100, ALL_STD_EXCEPT, FE_INEXACT); } /* z negative, x*y negative */ if (fegetround() == FE_DOWNWARD) { test(fmaf, -0x1.0p-50, 0x1.0p-50, -1.0, -(1.0 + FLT_EPSILON), ALL_STD_EXCEPT, FE_INEXACT); test(fma, -0x1.0p-100, 0x1.0p-100, -1.0, -(1.0 + DBL_EPSILON), ALL_STD_EXCEPT, FE_INEXACT); test(fmal, -0x1.0p-100, 0x1.0p-100, -1.0, -(1.0 + LDBL_EPSILON), ALL_STD_EXCEPT, FE_INEXACT); } else { testall(0x1.0p-50, -0x1.0p-50, -0x1.0p100, -0x1.0p100, ALL_STD_EXCEPT, FE_INEXACT); } /* z negative, x*y positive */ if (fegetround() == FE_UPWARD || fegetround() == FE_TOWARDZERO) { test(fmaf, -0x1.0p-50, -0x1.0p-50, -1.0, -1.0 + FLT_EPSILON / 2, ALL_STD_EXCEPT, FE_INEXACT); test(fma, -0x1.0p-100, -0x1.0p-100, -1.0, -1.0 + DBL_EPSILON / 2, ALL_STD_EXCEPT, FE_INEXACT); test(fmal, -0x1.0p-100, -0x1.0p-100, -1.0, -1.0 + LDBL_EPSILON / 2, ALL_STD_EXCEPT, FE_INEXACT); } else { testall(0x1.0p-50, 0x1.0p-50, -0x1.0p100, -0x1.0p100, ALL_STD_EXCEPT, FE_INEXACT); } /* z positive, x*y negative */ if (fegetround() == FE_DOWNWARD || fegetround() == FE_TOWARDZERO) { test(fmaf, 0x1.0p-50, -0x1.0p-50, 1.0, 1.0 - FLT_EPSILON / 2, ALL_STD_EXCEPT, FE_INEXACT); test(fma, 0x1.0p-100, -0x1.0p-100, 1.0, 1.0 - DBL_EPSILON / 2, ALL_STD_EXCEPT, FE_INEXACT); test(fmal, 0x1.0p-100, -0x1.0p-100, 1.0, 1.0 - LDBL_EPSILON / 2, ALL_STD_EXCEPT, FE_INEXACT); } else { testall(-0x1.0p-50, 0x1.0p-50, 0x1.0p100, 0x1.0p100, ALL_STD_EXCEPT, FE_INEXACT); } } static void test_accuracy(void) { /* ilogb(x*y) - ilogb(z) = 20 */ testrnd(fmaf, -0x1.c139d8p-51, -0x1.600e7ap32, 0x1.26558cp-38, 0x1.34e48ap-18, 0x1.34e48cp-18, 0x1.34e48ap-18, 0x1.34e48ap-18, ALL_STD_EXCEPT, FE_INEXACT); testrnd(fma, -0x1.c139d7b84f1a3p-51, -0x1.600e7a2a16484p32, 0x1.26558cac31580p-38, 0x1.34e48a78aae97p-18, 0x1.34e48a78aae97p-18, 0x1.34e48a78aae96p-18, 0x1.34e48a78aae96p-18, ALL_STD_EXCEPT, FE_INEXACT); #if LDBL_MANT_DIG == 113 testrnd(fmal, -0x1.c139d7b84f1a3079263afcc5bae3p-51L, -0x1.600e7a2a164840edbe2e7d301a72p32L, 0x1.26558cac315807eb07e448042101p-38L, 0x1.34e48a78aae96c76ed36077dd387p-18L, 0x1.34e48a78aae96c76ed36077dd388p-18L, 0x1.34e48a78aae96c76ed36077dd387p-18L, 0x1.34e48a78aae96c76ed36077dd387p-18L, ALL_STD_EXCEPT, FE_INEXACT); #elif LDBL_MANT_DIG == 64 testrnd(fmal, -0x1.c139d7b84f1a307ap-51L, -0x1.600e7a2a164840eep32L, 0x1.26558cac315807ecp-38L, 0x1.34e48a78aae96c78p-18L, 0x1.34e48a78aae96c78p-18L, 0x1.34e48a78aae96c76p-18L, 0x1.34e48a78aae96c76p-18L, ALL_STD_EXCEPT, FE_INEXACT); #elif LDBL_MANT_DIG == 53 testrnd(fmal, -0x1.c139d7b84f1a3p-51L, -0x1.600e7a2a16484p32L, 0x1.26558cac31580p-38L, 0x1.34e48a78aae97p-18L, 0x1.34e48a78aae97p-18L, 0x1.34e48a78aae96p-18L, 0x1.34e48a78aae96p-18L, ALL_STD_EXCEPT, FE_INEXACT); #endif /* ilogb(x*y) - ilogb(z) = -40 */ testrnd(fmaf, 0x1.98210ap53, 0x1.9556acp-24, 0x1.d87da4p70, 0x1.d87da4p70, 0x1.d87da6p70, 0x1.d87da4p70, 0x1.d87da4p70, ALL_STD_EXCEPT, FE_INEXACT); testrnd(fma, 0x1.98210ac83fe2bp53, 0x1.9556ac1475f0fp-24, 0x1.d87da3aafc60ep70, 0x1.d87da3aafda40p70, 0x1.d87da3aafda40p70, 0x1.d87da3aafda3fp70, 0x1.d87da3aafda3fp70, ALL_STD_EXCEPT, FE_INEXACT); #if LDBL_MANT_DIG == 113 testrnd(fmal, 0x1.98210ac83fe2a8f65b6278b74cebp53L, 0x1.9556ac1475f0f28968b61d0de65ap-24L, 0x1.d87da3aafc60d830aa4c6d73b749p70L, 0x1.d87da3aafda3f36a69eb86488224p70L, 0x1.d87da3aafda3f36a69eb86488225p70L, 0x1.d87da3aafda3f36a69eb86488224p70L, 0x1.d87da3aafda3f36a69eb86488224p70L, ALL_STD_EXCEPT, FE_INEXACT); #elif LDBL_MANT_DIG == 64 testrnd(fmal, 0x1.98210ac83fe2a8f6p53L, 0x1.9556ac1475f0f28ap-24L, 0x1.d87da3aafc60d83p70L, 0x1.d87da3aafda3f36ap70L, 0x1.d87da3aafda3f36ap70L, 0x1.d87da3aafda3f368p70L, 0x1.d87da3aafda3f368p70L, ALL_STD_EXCEPT, FE_INEXACT); #elif LDBL_MANT_DIG == 53 testrnd(fmal, 0x1.98210ac83fe2bp53L, 0x1.9556ac1475f0fp-24L, 0x1.d87da3aafc60ep70L, 0x1.d87da3aafda40p70L, 0x1.d87da3aafda40p70L, 0x1.d87da3aafda3fp70L, 0x1.d87da3aafda3fp70L, ALL_STD_EXCEPT, FE_INEXACT); #endif /* ilogb(x*y) - ilogb(z) = 0 */ testrnd(fmaf, 0x1.31ad02p+100, 0x1.2fbf7ap-42, -0x1.c3e106p+58, -0x1.64c27cp+56, -0x1.64c27ap+56, -0x1.64c27cp+56, -0x1.64c27ap+56, ALL_STD_EXCEPT, FE_INEXACT); testrnd(fma, 0x1.31ad012ede8aap+100, 0x1.2fbf79c839067p-42, -0x1.c3e106929056ep+58, -0x1.64c282b970a5fp+56, -0x1.64c282b970a5ep+56, -0x1.64c282b970a5fp+56, -0x1.64c282b970a5ep+56, ALL_STD_EXCEPT, FE_INEXACT); #if LDBL_MANT_DIG == 113 testrnd(fmal, 0x1.31ad012ede8aa282fa1c19376d16p+100L, 0x1.2fbf79c839066f0f5c68f6d2e814p-42L, -0x1.c3e106929056ec19de72bfe64215p+58L, -0x1.64c282b970a612598fc025ca8cddp+56L, -0x1.64c282b970a612598fc025ca8cddp+56L, -0x1.64c282b970a612598fc025ca8cdep+56L, -0x1.64c282b970a612598fc025ca8cddp+56L, ALL_STD_EXCEPT, FE_INEXACT); #elif LDBL_MANT_DIG == 64 testrnd(fmal, 0x1.31ad012ede8aa4eap+100L, 0x1.2fbf79c839066aeap-42L, -0x1.c3e106929056e61p+58L, -0x1.64c282b970a60298p+56L, -0x1.64c282b970a60298p+56L, -0x1.64c282b970a6029ap+56L, -0x1.64c282b970a60298p+56L, ALL_STD_EXCEPT, FE_INEXACT); #elif LDBL_MANT_DIG == 53 testrnd(fmal, 0x1.31ad012ede8aap+100L, 0x1.2fbf79c839067p-42L, -0x1.c3e106929056ep+58L, -0x1.64c282b970a5fp+56L, -0x1.64c282b970a5ep+56L, -0x1.64c282b970a5fp+56L, -0x1.64c282b970a5ep+56L, ALL_STD_EXCEPT, FE_INEXACT); #endif /* x*y (rounded) ~= -z */ /* XXX spurious inexact exceptions */ testrnd(fmaf, 0x1.bbffeep-30, -0x1.1d164cp-74, 0x1.ee7296p-104, -0x1.c46ea8p-128, -0x1.c46ea8p-128, -0x1.c46ea8p-128, -0x1.c46ea8p-128, ALL_STD_EXCEPT & ~FE_INEXACT, 0); testrnd(fma, 0x1.bbffeea6fc7d6p-30, 0x1.1d164c6cbf078p-74, -0x1.ee72993aff948p-104, -0x1.71f72ac7d9d8p-159, -0x1.71f72ac7d9d8p-159, -0x1.71f72ac7d9d8p-159, -0x1.71f72ac7d9d8p-159, ALL_STD_EXCEPT & ~FE_INEXACT, 0); #if LDBL_MANT_DIG == 113 testrnd(fmal, 0x1.bbffeea6fc7d65927d147f437675p-30L, 0x1.1d164c6cbf078b7a22607d1cd6a2p-74L, -0x1.ee72993aff94973876031bec0944p-104L, 0x1.64e086175b3a2adc36e607058814p-217L, 0x1.64e086175b3a2adc36e607058814p-217L, 0x1.64e086175b3a2adc36e607058814p-217L, 0x1.64e086175b3a2adc36e607058814p-217L, ALL_STD_EXCEPT & ~FE_INEXACT, 0); #elif LDBL_MANT_DIG == 64 testrnd(fmal, 0x1.bbffeea6fc7d6592p-30L, 0x1.1d164c6cbf078b7ap-74L, -0x1.ee72993aff949736p-104L, 0x1.af190e7a1ee6ad94p-168L, 0x1.af190e7a1ee6ad94p-168L, 0x1.af190e7a1ee6ad94p-168L, 0x1.af190e7a1ee6ad94p-168L, ALL_STD_EXCEPT & ~FE_INEXACT, 0); #elif LDBL_MANT_DIG == 53 testrnd(fmal, 0x1.bbffeea6fc7d6p-30L, 0x1.1d164c6cbf078p-74L, -0x1.ee72993aff948p-104L, -0x1.71f72ac7d9d8p-159L, -0x1.71f72ac7d9d8p-159L, -0x1.71f72ac7d9d8p-159L, -0x1.71f72ac7d9d8p-159L, ALL_STD_EXCEPT & ~FE_INEXACT, 0); #endif } static void test_double_rounding(void) { /* * a = 0x1.8000000000001p0 * b = 0x1.8000000000001p0 * c = -0x0.0000000000000000000000000080...1p+1 * a * b = 0x1.2000000000001800000000000080p+1 * * The correct behavior is to round DOWN to 0x1.2000000000001p+1 in * round-to-nearest mode. An implementation that computes a*b+c in * double+double precision, however, will get 0x1.20000000000018p+1, * and then round UP. */ fesetround(FE_TONEAREST); test(fma, 0x1.8000000000001p0, 0x1.8000000000001p0, -0x1.0000000000001p-104, 0x1.2000000000001p+1, ALL_STD_EXCEPT, FE_INEXACT); fesetround(FE_DOWNWARD); test(fma, 0x1.8000000000001p0, 0x1.8000000000001p0, -0x1.0000000000001p-104, 0x1.2000000000001p+1, ALL_STD_EXCEPT, FE_INEXACT); fesetround(FE_UPWARD); test(fma, 0x1.8000000000001p0, 0x1.8000000000001p0, -0x1.0000000000001p-104, 0x1.2000000000002p+1, ALL_STD_EXCEPT, FE_INEXACT); fesetround(FE_TONEAREST); test(fmaf, 0x1.800002p+0, 0x1.800002p+0, -0x1.000002p-46, 0x1.200002p+1, ALL_STD_EXCEPT, FE_INEXACT); fesetround(FE_DOWNWARD); test(fmaf, 0x1.800002p+0, 0x1.800002p+0, -0x1.000002p-46, 0x1.200002p+1, ALL_STD_EXCEPT, FE_INEXACT); fesetround(FE_UPWARD); test(fmaf, 0x1.800002p+0, 0x1.800002p+0, -0x1.000002p-46, 0x1.200004p+1, ALL_STD_EXCEPT, FE_INEXACT); fesetround(FE_TONEAREST); #if LDBL_MANT_DIG == 64 test(fmal, 0x1.4p+0L, 0x1.0000000000000004p+0L, 0x1p-128L, 0x1.4000000000000006p+0L, ALL_STD_EXCEPT, FE_INEXACT); #elif LDBL_MANT_DIG == 113 test(fmal, 0x1.8000000000000000000000000001p+0L, 0x1.8000000000000000000000000001p+0L, -0x1.0000000000000000000000000001p-224L, 0x1.2000000000000000000000000001p+1L, ALL_STD_EXCEPT, FE_INEXACT); #endif } -int -main(void) -{ - int rmodes[] = { FE_TONEAREST, FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO }; - unsigned i, j; - -#if defined(__i386__) - printf("1..0 # SKIP all testcases fail on i386\n"); - exit(0); -#endif - - j = 1; - - printf("1..19\n"); +static const int rmodes[] = { + FE_TONEAREST, FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO +}; - for (i = 0; i < nitems(rmodes); i++, j++) { +ATF_TC_WITHOUT_HEAD(zeroes); +ATF_TC_BODY(zeroes, tc) +{ + for (size_t i = 0; i < nitems(rmodes); i++) { printf("rmode = %d\n", rmodes[i]); fesetround(rmodes[i]); test_zeroes(); - printf("ok %d - fma zeroes\n", j); } +} - for (i = 0; i < nitems(rmodes); i++, j++) { +ATF_TC_WITHOUT_HEAD(infinities); +ATF_TC_BODY(infinities, tc) +{ #if defined(__amd64__) - printf("ok %d # SKIP testcase fails assertion on " - "amd64\n", j); - continue; -#else + if (atf_tc_get_config_var_as_bool_wd(tc, "ci", false)) + atf_tc_expect_fail("https://bugs.freebsd.org/205448"); +#endif + for (size_t i = 0; i < nitems(rmodes); i++) { printf("rmode = %d\n", rmodes[i]); fesetround(rmodes[i]); test_infinities(); - printf("ok %d - fma infinities\n", j); -#endif } +} +ATF_TC_WITHOUT_HEAD(nans); +ATF_TC_BODY(nans, tc) +{ fesetround(FE_TONEAREST); test_nans(); - printf("ok %d - fma NaNs\n", j); - j++; +} + - for (i = 0; i < nitems(rmodes); i++, j++) { +ATF_TC_WITHOUT_HEAD(small_z); +ATF_TC_BODY(small_z, tc) +{ + for (size_t i = 0; i < nitems(rmodes); i++) { printf("rmode = %d\n", rmodes[i]); fesetround(rmodes[i]); test_small_z(); - printf("ok %d - fma small z\n", j); } +} + - for (i = 0; i < nitems(rmodes); i++, j++) { +ATF_TC_WITHOUT_HEAD(big_z); +ATF_TC_BODY(big_z, tc) +{ + for (size_t i = 0; i < nitems(rmodes); i++) { printf("rmode = %d\n", rmodes[i]); fesetround(rmodes[i]); test_big_z(); - printf("ok %d - fma big z\n", j); } +} +ATF_TC_WITHOUT_HEAD(accuracy); +ATF_TC_BODY(accuracy, tc) +{ fesetround(FE_TONEAREST); test_accuracy(); - printf("ok %d - fma accuracy\n", j); - j++; +} +ATF_TC_WITHOUT_HEAD(double_rounding); +ATF_TC_BODY(double_rounding, tc) { test_double_rounding(); - printf("ok %d - fma double rounding\n", j); - j++; +} +ATF_TP_ADD_TCS(tp) +{ + ATF_TP_ADD_TC(tp, zeroes); + ATF_TP_ADD_TC(tp, infinities); + ATF_TP_ADD_TC(tp, nans); + ATF_TP_ADD_TC(tp, small_z); + ATF_TP_ADD_TC(tp, big_z); + ATF_TP_ADD_TC(tp, accuracy); + ATF_TP_ADD_TC(tp, double_rounding); /* * TODO: * - Tests for subnormals * - Cancellation tests (e.g., z = (double)x*y, but x*y is inexact) */ - - return (0); + return (atf_no_error()); } diff --git a/lib/msun/tests/fmaxmin_test.c b/lib/msun/tests/fmaxmin_test.c index 581fc25467d7..a89c10cc2554 100644 --- a/lib/msun/tests/fmaxmin_test.c +++ b/lib/msun/tests/fmaxmin_test.c @@ -1,154 +1,204 @@ /*- * Copyright (c) 2008 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Tests for fmax{,f,l}() and fmin{,f,l}. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include "test-utils.h" #pragma STDC FENV_ACCESS ON /* * Test whether func(x, y) has the expected result, and make sure no * exceptions are raised. */ -#define TEST(func, type, x, y, expected) do { \ +#define TEST(func, type, x, y, expected, rmode) do { \ type __x = (x); /* convert before we clear exceptions */ \ type __y = (y); \ - feclearexcept(ALL_STD_EXCEPT); \ + ATF_REQUIRE_EQ(0, feclearexcept(ALL_STD_EXCEPT)); \ long double __result = func((__x), (__y)); \ - if (fetestexcept(ALL_STD_EXCEPT)) { \ - fprintf(stderr, #func "(%.20Lg, %.20Lg) raised 0x%x\n", \ - (x), (y), fetestexcept(FE_ALL_EXCEPT)); \ - ok = 0; \ - } \ - if (!fpequal(__result, (expected))) { \ - fprintf(stderr, #func "(%.20Lg, %.20Lg) = %.20Lg, " \ - "expected %.20Lg\n", (x), (y), __result, (expected)); \ - ok = 0; \ - } \ + CHECK_FP_EXCEPTIONS_MSG(0, ALL_STD_EXCEPT, \ + #func "(%.20Lg, %.20Lg) rmode%d", (x), (y), rmode); \ + ATF_CHECK_MSG(fpequal(__result, (expected)), \ + #func "(%.20Lg, %.20Lg) rmode%d = %.20Lg, expected %.20Lg\n", \ + (x), (y), rmode, __result, (expected)); \ } while (0) -static int -testall_r(long double big, long double small) +static void +testall_r(long double big, long double small, int rmode) { - int ok; - long double expected_max = isnan(big) ? small : big; long double expected_min = isnan(small) ? big : small; - ok = 1; - - TEST(fmaxf, float, big, small, expected_max); - TEST(fmaxf, float, small, big, expected_max); - TEST(fmax, double, big, small, expected_max); - TEST(fmax, double, small, big, expected_max); - TEST(fmaxl, long double, big, small, expected_max); - TEST(fmaxl, long double, small, big, expected_max); - TEST(fminf, float, big, small, expected_min); - TEST(fminf, float, small, big, expected_min); - TEST(fmin, double, big, small, expected_min); - TEST(fmin, double, small, big, expected_min); - TEST(fminl, long double, big, small, expected_min); - TEST(fminl, long double, small, big, expected_min); - - return (ok); + TEST(fmaxf, float, big, small, expected_max, rmode); + TEST(fmaxf, float, small, big, expected_max, rmode); + TEST(fmax, double, big, small, expected_max, rmode); + TEST(fmax, double, small, big, expected_max, rmode); + TEST(fmaxl, long double, big, small, expected_max, rmode); + TEST(fmaxl, long double, small, big, expected_max, rmode); + TEST(fminf, float, big, small, expected_min, rmode); + TEST(fminf, float, small, big, expected_min, rmode); + TEST(fmin, double, big, small, expected_min, rmode); + TEST(fmin, double, small, big, expected_min, rmode); + TEST(fminl, long double, big, small, expected_min, rmode); + TEST(fminl, long double, small, big, expected_min, rmode); } -static const char *comment = NULL; - /* * Test all the functions: fmaxf, fmax, fmaxl, fminf, fmin, and fminl, * in all rounding modes and with the arguments in different orders. * The input 'big' must be >= 'small'. */ static void -testall(int testnum, long double big, long double small) +testall(long double big, long double small) { static const int rmodes[] = { FE_TONEAREST, FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO }; int i; for (i = 0; i < 4; i++) { fesetround(rmodes[i]); - if (!testall_r(big, small)) { - fprintf(stderr, "FAILURE in rounding mode %d\n", - rmodes[i]); - break; - } + testall_r(big, small, rmodes[i]); } - printf("%sok %d - big = %.20Lg, small = %.20Lg%s\n", - (i == 4) ? "" : "not ", testnum, big, small, - comment == NULL ? "" : comment); } /* Clang 3.8.0+ fails the invariants for testcase 6, 7, 10, and 11. */ #if defined(__clang__) && \ ((__clang_major__ > 3)) || \ ((__clang_major__ == 3 && __clang_minor__ >= 8)) #define affected_by_bug_208703 #endif -int -main(void) +ATF_TC_WITHOUT_HEAD(test1); +ATF_TC_BODY(test1, tc) +{ + testall(1.0, 0.0); +} + +ATF_TC_WITHOUT_HEAD(test2); +ATF_TC_BODY(test2, tc) +{ + testall(42.0, nextafterf(42.0, -INFINITY)); +} +ATF_TC_WITHOUT_HEAD(test3); +ATF_TC_BODY(test3, tc) +{ + testall(nextafterf(42.0, INFINITY), 42.0); +} + +ATF_TC_WITHOUT_HEAD(test4); +ATF_TC_BODY(test4, tc) +{ + testall(-5.0, -5.0); +} + +ATF_TC_WITHOUT_HEAD(test5); +ATF_TC_BODY(test5, tc) +{ + testall(-3.0, -4.0); +} + +ATF_TC_WITHOUT_HEAD(test6); +ATF_TC_BODY(test6, tc) +{ +#ifdef affected_by_bug_208703 + atf_tc_expect_fail("fails invariant with clang 3.8+ (bug 208703)"); +#endif + testall(1.0, NAN); +} +ATF_TC_WITHOUT_HEAD(test7); +ATF_TC_BODY(test7, tc) +{ +#ifdef affected_by_bug_208703 + atf_tc_expect_fail("fails invariant with clang 3.8+ (bug 208703)"); +#endif + testall(INFINITY, NAN); +} + +ATF_TC_WITHOUT_HEAD(test8); +ATF_TC_BODY(test8, tc) { + testall(INFINITY, 1.0); +} - printf("1..12\n"); +ATF_TC_WITHOUT_HEAD(test9); +ATF_TC_BODY(test9, tc) +{ + testall(-3.0, -INFINITY); +} - testall(1, 1.0, 0.0); - testall(2, 42.0, nextafterf(42.0, -INFINITY)); - testall(3, nextafterf(42.0, INFINITY), 42.0); - testall(4, -5.0, -5.0); - testall(5, -3.0, -4.0); +ATF_TC_WITHOUT_HEAD(test10); +ATF_TC_BODY(test10, tc) +{ #ifdef affected_by_bug_208703 - comment = "# TODO: testcase 6-7 fails invariant with clang 3.8+ (bug 208703)"; + atf_tc_expect_fail("fails invariant with clang 3.8+ (bug 208703)"); #endif - testall(6, 1.0, NAN); - testall(7, INFINITY, NAN); - comment = NULL; - testall(8, INFINITY, 1.0); - testall(9, -3.0, -INFINITY); - testall(10, 3.0, -INFINITY); + testall(3.0, -INFINITY); +} + +ATF_TC_WITHOUT_HEAD(test11); +ATF_TC_BODY(test11, tc) +{ #ifdef affected_by_bug_208703 - comment = "# TODO: testcase 11-12 fails invariant with clang 3.8+ (bug 208703)"; + atf_tc_expect_fail("fails invariant with clang 3.8+ (bug 208703)"); #endif - testall(11, NAN, NAN); + testall(NAN, NAN); +} +ATF_TC_WITHOUT_HEAD(test12); +ATF_TC_BODY(test12, tc) +{ /* This test isn't strictly required to work by C99. */ - testall(12, 0.0, -0.0); - comment = NULL; + testall(0.0, -0.0); +} - return (0); + +ATF_TP_ADD_TCS(tp) +{ + ATF_TP_ADD_TC(tp, test1); + ATF_TP_ADD_TC(tp, test2); + ATF_TP_ADD_TC(tp, test3); + ATF_TP_ADD_TC(tp, test4); + ATF_TP_ADD_TC(tp, test5); + ATF_TP_ADD_TC(tp, test6); + ATF_TP_ADD_TC(tp, test7); + ATF_TP_ADD_TC(tp, test8); + ATF_TP_ADD_TC(tp, test9); + ATF_TP_ADD_TC(tp, test10); + ATF_TP_ADD_TC(tp, test11); + ATF_TP_ADD_TC(tp, test12); + + return (atf_no_error()); } diff --git a/lib/msun/tests/ilogb_test.c b/lib/msun/tests/ilogb_test.c index a1440c4a20a4..c1d6e6d06955 100644 --- a/lib/msun/tests/ilogb_test.c +++ b/lib/msun/tests/ilogb_test.c @@ -1,83 +1,103 @@ /*- * Copyright (c) 2004 Stefan Farfeleder * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ -#include #include #include #include #include #include -int -main(void) +#include "test-utils.h" + +ATF_TC_WITHOUT_HEAD(ilogb); +ATF_TC_BODY(ilogb, tc) { char buf[128], *end; double d; - float f; - long double ld; int e, i; - printf("1..3\n"); - assert(ilogb(0) == FP_ILOGB0); - assert(ilogb(NAN) == FP_ILOGBNAN); - assert(ilogb(INFINITY) == INT_MAX); + ATF_CHECK_EQ(FP_ILOGB0, ilogb(0)); + ATF_CHECK_EQ(FP_ILOGBNAN, ilogb(NAN)); + ATF_CHECK_EQ(INT_MAX, ilogb(INFINITY)); for (e = DBL_MIN_EXP - DBL_MANT_DIG; e < DBL_MAX_EXP; e++) { snprintf(buf, sizeof(buf), "0x1.p%d", e); d = strtod(buf, &end); - assert(*end == '\0'); + ATF_CHECK_EQ('\0', *end); i = ilogb(d); - assert(i == e); + ATF_CHECK_EQ_MSG(e, i, "ilogb(%g) returned %d not %d", d, i, e); } - printf("ok 1 - ilogb\n"); +} + +ATF_TC_WITHOUT_HEAD(ilogbf); +ATF_TC_BODY(ilogbf, tc) +{ + char buf[128], *end; + float f; + int e, i; - assert(ilogbf(0) == FP_ILOGB0); - assert(ilogbf(NAN) == FP_ILOGBNAN); - assert(ilogbf(INFINITY) == INT_MAX); + ATF_CHECK_EQ(FP_ILOGB0, ilogbf(0)); + ATF_CHECK_EQ(FP_ILOGBNAN, ilogbf(NAN)); + ATF_CHECK_EQ(INT_MAX, ilogbf(INFINITY)); for (e = FLT_MIN_EXP - FLT_MANT_DIG; e < FLT_MAX_EXP; e++) { snprintf(buf, sizeof(buf), "0x1.p%d", e); f = strtof(buf, &end); - assert(*end == '\0'); + ATF_CHECK_EQ('\0', *end); i = ilogbf(f); - assert(i == e); + ATF_CHECK_EQ_MSG(e, i, "ilogbf(%g) returned %d not %d", f, i, + e); } - printf("ok 2 - ilogbf\n"); +} - assert(ilogbl(0) == FP_ILOGB0); - assert(ilogbl(NAN) == FP_ILOGBNAN); - assert(ilogbl(INFINITY) == INT_MAX); +ATF_TC_WITHOUT_HEAD(ilogbl); +ATF_TC_BODY(ilogbl, tc) +{ + char buf[128], *end; + long double ld; + int e, i; + + ATF_CHECK_EQ(FP_ILOGB0, ilogbl(0)); + ATF_CHECK_EQ(FP_ILOGBNAN, ilogbl(NAN)); + ATF_CHECK_EQ(INT_MAX, ilogbl(INFINITY)); for (e = LDBL_MIN_EXP - LDBL_MANT_DIG; e < LDBL_MAX_EXP; e++) { snprintf(buf, sizeof(buf), "0x1.p%d", e); ld = strtold(buf, &end); - assert(*end == '\0'); + ATF_CHECK_EQ('\0', *end); i = ilogbl(ld); - assert(i == e); + ATF_CHECK_EQ_MSG(e, i, "ilogbl(%Lg) returned %d not %d", ld, i, + e); } - printf("ok 3 - ilogbl\n"); +} + +ATF_TP_ADD_TCS(tp) +{ + ATF_TP_ADD_TC(tp, ilogb); + ATF_TP_ADD_TC(tp, ilogbf); + ATF_TP_ADD_TC(tp, ilogbl); - return (0); + return (atf_no_error()); } diff --git a/lib/msun/tests/invctrig_test.c b/lib/msun/tests/invctrig_test.c index 7856605a8bc3..537d73d1319c 100644 --- a/lib/msun/tests/invctrig_test.c +++ b/lib/msun/tests/invctrig_test.c @@ -1,368 +1,352 @@ /*- * Copyright (c) 2008-2013 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Tests for casin[h](), cacos[h](), and catan[h](). */ #include __FBSDID("$FreeBSD$"); #include -#include #include #include #include #include #include #include "test-utils.h" #pragma STDC FENV_ACCESS ON #pragma STDC CX_LIMITED_RANGE OFF /* * Test that a function returns the correct value and sets the * exception flags correctly. The exceptmask specifies which * exceptions we should check. We need to be lenient for several * reasons, but mainly because on some architectures it's impossible * to raise FE_OVERFLOW without raising FE_INEXACT. * * These are macros instead of functions so that assert provides more * meaningful error messages. * * XXX The volatile here is to avoid gcc's bogus constant folding and work * around the lack of support for the FENV_ACCESS pragma. */ #define test_p(func, z, result, exceptmask, excepts, checksign) do { \ volatile long double complex _d = z; \ debug(" testing %s(%Lg + %Lg I) == %Lg + %Lg I\n", #func, \ creall(_d), cimagl(_d), creall(result), cimagl(result)); \ - assert(feclearexcept(FE_ALL_EXCEPT) == 0); \ - assert(cfpequal_cs((func)(_d), (result), (checksign))); \ - assert(((void)(func), fetestexcept(exceptmask) == (excepts))); \ + ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT)); \ + ATF_CHECK(cfpequal_cs((func)(_d), (result), (checksign))); \ + CHECK_FP_EXCEPTIONS_MSG(excepts, exceptmask, "for %s(%s)", \ + #func, #z); \ } while (0) /* * Test within a given tolerance. The tolerance indicates relative error * in ulps. */ #define test_p_tol(func, z, result, tol) do { \ volatile long double complex _d = z; \ debug(" testing %s(%Lg + %Lg I) ~= %Lg + %Lg I\n", #func, \ creall(_d), cimagl(_d), creall(result), cimagl(result)); \ - assert(cfpequal_tol((func)(_d), (result), (tol), CS_BOTH)); \ + ATF_CHECK(cfpequal_tol((func)(_d), (result), (tol), CS_BOTH)); \ } while (0) /* These wrappers apply the identities f(conj(z)) = conj(f(z)). */ #define test(func, z, result, exceptmask, excepts, checksign) do { \ test_p(func, z, result, exceptmask, excepts, checksign); \ test_p(func, conjl(z), conjl(result), exceptmask, excepts, checksign); \ } while (0) #define test_tol(func, z, result, tol) do { \ test_p_tol(func, z, result, tol); \ test_p_tol(func, conjl(z), conjl(result), tol); \ } while (0) /* Test the given function in all precisions. */ #define testall(func, x, result, exceptmask, excepts, checksign) do { \ test(func, x, result, exceptmask, excepts, checksign); \ test(func##f, x, result, exceptmask, excepts, checksign); \ } while (0) #define testall_odd(func, x, result, exceptmask, excepts, checksign) do { \ testall(func, x, result, exceptmask, excepts, checksign); \ testall(func, -(x), -result, exceptmask, excepts, checksign); \ } while (0) #define testall_even(func, x, result, exceptmask, excepts, checksign) do { \ testall(func, x, result, exceptmask, excepts, checksign); \ testall(func, -(x), result, exceptmask, excepts, checksign); \ } while (0) /* * Test the given function in all precisions, within a given tolerance. * The tolerance is specified in ulps. */ #define testall_tol(func, x, result, tol) do { \ test_tol(func, x, result, (tol) * DBL_ULP()); \ test_tol(func##f, x, result, (tol) * FLT_ULP()); \ } while (0) #define testall_odd_tol(func, x, result, tol) do { \ testall_tol(func, x, result, tol); \ testall_tol(func, -(x), -result, tol); \ } while (0) #define testall_even_tol(func, x, result, tol) do { \ testall_tol(func, x, result, tol); \ testall_tol(func, -(x), result, tol); \ } while (0) static const long double pi = 3.14159265358979323846264338327950280L, c3pi = 9.42477796076937971538793014983850839L; /* Tests for 0 */ -static void -test_zero(void) +ATF_TC_WITHOUT_HEAD(zero); +ATF_TC_BODY(zero, tc) { long double complex zero = CMPLXL(0.0, 0.0); testall_tol(cacosh, zero, CMPLXL(0.0, pi / 2), 1); testall_tol(cacosh, -zero, CMPLXL(0.0, -pi / 2), 1); testall_tol(cacos, zero, CMPLXL(pi / 2, -0.0), 1); testall_tol(cacos, -zero, CMPLXL(pi / 2, 0.0), 1); testall_odd(casinh, zero, zero, ALL_STD_EXCEPT, 0, CS_BOTH); testall_odd(casin, zero, zero, ALL_STD_EXCEPT, 0, CS_BOTH); testall_odd(catanh, zero, zero, ALL_STD_EXCEPT, 0, CS_BOTH); testall_odd(catan, zero, zero, ALL_STD_EXCEPT, 0, CS_BOTH); } /* * Tests for NaN inputs. */ -static void -test_nan(void) +ATF_TC_WITHOUT_HEAD(nan); +ATF_TC_BODY(nan, tc) { long double complex nan_nan = CMPLXL(NAN, NAN); long double complex z; /* * IN CACOSH CACOS CASINH CATANH * NaN,NaN NaN,NaN NaN,NaN NaN,NaN NaN,NaN * finite,NaN NaN,NaN* NaN,NaN* NaN,NaN* NaN,NaN* * NaN,finite NaN,NaN* NaN,NaN* NaN,NaN* NaN,NaN* * NaN,Inf Inf,NaN NaN,-Inf ?Inf,NaN ?0,pi/2 * +-Inf,NaN Inf,NaN NaN,?Inf +-Inf,NaN +-0,NaN * +-0,NaN NaN,NaN* pi/2,NaN NaN,NaN* +-0,NaN * NaN,0 NaN,NaN* NaN,NaN* NaN,0 NaN,NaN* * * * = raise invalid */ z = nan_nan; testall(cacosh, z, nan_nan, ALL_STD_EXCEPT, 0, 0); testall(cacos, z, nan_nan, ALL_STD_EXCEPT, 0, 0); testall(casinh, z, nan_nan, ALL_STD_EXCEPT, 0, 0); testall(casin, z, nan_nan, ALL_STD_EXCEPT, 0, 0); testall(catanh, z, nan_nan, ALL_STD_EXCEPT, 0, 0); testall(catan, z, nan_nan, ALL_STD_EXCEPT, 0, 0); z = CMPLXL(0.5, NAN); testall(cacosh, z, nan_nan, OPT_INVALID, 0, 0); testall(cacos, z, nan_nan, OPT_INVALID, 0, 0); testall(casinh, z, nan_nan, OPT_INVALID, 0, 0); testall(casin, z, nan_nan, OPT_INVALID, 0, 0); testall(catanh, z, nan_nan, OPT_INVALID, 0, 0); testall(catan, z, nan_nan, OPT_INVALID, 0, 0); z = CMPLXL(NAN, 0.5); testall(cacosh, z, nan_nan, OPT_INVALID, 0, 0); testall(cacos, z, nan_nan, OPT_INVALID, 0, 0); testall(casinh, z, nan_nan, OPT_INVALID, 0, 0); testall(casin, z, nan_nan, OPT_INVALID, 0, 0); testall(catanh, z, nan_nan, OPT_INVALID, 0, 0); testall(catan, z, nan_nan, OPT_INVALID, 0, 0); z = CMPLXL(NAN, INFINITY); testall(cacosh, z, CMPLXL(INFINITY, NAN), ALL_STD_EXCEPT, 0, CS_REAL); testall(cacosh, -z, CMPLXL(INFINITY, NAN), ALL_STD_EXCEPT, 0, CS_REAL); testall(cacos, z, CMPLXL(NAN, -INFINITY), ALL_STD_EXCEPT, 0, CS_IMAG); testall(casinh, z, CMPLXL(INFINITY, NAN), ALL_STD_EXCEPT, 0, 0); testall(casin, z, CMPLXL(NAN, INFINITY), ALL_STD_EXCEPT, 0, CS_IMAG); testall_tol(catanh, z, CMPLXL(0.0, pi / 2), 1); testall(catan, z, CMPLXL(NAN, 0.0), ALL_STD_EXCEPT, 0, CS_IMAG); z = CMPLXL(INFINITY, NAN); testall_even(cacosh, z, CMPLXL(INFINITY, NAN), ALL_STD_EXCEPT, 0, CS_REAL); testall_even(cacos, z, CMPLXL(NAN, INFINITY), ALL_STD_EXCEPT, 0, 0); testall_odd(casinh, z, CMPLXL(INFINITY, NAN), ALL_STD_EXCEPT, 0, CS_REAL); testall_odd(casin, z, CMPLXL(NAN, INFINITY), ALL_STD_EXCEPT, 0, 0); testall_odd(catanh, z, CMPLXL(0.0, NAN), ALL_STD_EXCEPT, 0, CS_REAL); testall_odd_tol(catan, z, CMPLXL(pi / 2, 0.0), 1); z = CMPLXL(0.0, NAN); /* XXX We allow a spurious inexact exception here. */ testall_even(cacosh, z, nan_nan, OPT_INVALID & ~FE_INEXACT, 0, 0); testall_even_tol(cacos, z, CMPLXL(pi / 2, NAN), 1); testall_odd(casinh, z, nan_nan, OPT_INVALID, 0, 0); testall_odd(casin, z, CMPLXL(0.0, NAN), ALL_STD_EXCEPT, 0, CS_REAL); testall_odd(catanh, z, CMPLXL(0.0, NAN), OPT_INVALID, 0, CS_REAL); testall_odd(catan, z, nan_nan, OPT_INVALID, 0, 0); z = CMPLXL(NAN, 0.0); testall(cacosh, z, nan_nan, OPT_INVALID, 0, 0); testall(cacos, z, nan_nan, OPT_INVALID, 0, 0); testall(casinh, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, CS_IMAG); testall(casin, z, nan_nan, OPT_INVALID, 0, 0); testall(catanh, z, nan_nan, OPT_INVALID, 0, CS_IMAG); testall(catan, z, CMPLXL(NAN, 0.0), ALL_STD_EXCEPT, 0, 0); } -static void -test_inf(void) +ATF_TC_WITHOUT_HEAD(inf); +ATF_TC_BODY(inf, tc) { long double complex z; /* * IN CACOSH CACOS CASINH CATANH * Inf,Inf Inf,pi/4 pi/4,-Inf Inf,pi/4 0,pi/2 * -Inf,Inf Inf,3pi/4 3pi/4,-Inf --- --- * Inf,finite Inf,0 0,-Inf Inf,0 0,pi/2 * -Inf,finite Inf,pi pi,-Inf --- --- * finite,Inf Inf,pi/2 pi/2,-Inf Inf,pi/2 0,pi/2 */ z = CMPLXL(INFINITY, INFINITY); testall_tol(cacosh, z, CMPLXL(INFINITY, pi / 4), 1); testall_tol(cacosh, -z, CMPLXL(INFINITY, -c3pi / 4), 1); testall_tol(cacos, z, CMPLXL(pi / 4, -INFINITY), 1); testall_tol(cacos, -z, CMPLXL(c3pi / 4, INFINITY), 1); testall_odd_tol(casinh, z, CMPLXL(INFINITY, pi / 4), 1); testall_odd_tol(casin, z, CMPLXL(pi / 4, INFINITY), 1); testall_odd_tol(catanh, z, CMPLXL(0, pi / 2), 1); testall_odd_tol(catan, z, CMPLXL(pi / 2, 0), 1); z = CMPLXL(INFINITY, 0.5); /* XXX We allow a spurious inexact exception here. */ testall(cacosh, z, CMPLXL(INFINITY, 0), OPT_INEXACT, 0, CS_BOTH); testall_tol(cacosh, -z, CMPLXL(INFINITY, -pi), 1); testall(cacos, z, CMPLXL(0, -INFINITY), OPT_INEXACT, 0, CS_BOTH); testall_tol(cacos, -z, CMPLXL(pi, INFINITY), 1); testall_odd(casinh, z, CMPLXL(INFINITY, 0), OPT_INEXACT, 0, CS_BOTH); testall_odd_tol(casin, z, CMPLXL(pi / 2, INFINITY), 1); testall_odd_tol(catanh, z, CMPLXL(0, pi / 2), 1); testall_odd_tol(catan, z, CMPLXL(pi / 2, 0), 1); z = CMPLXL(0.5, INFINITY); testall_tol(cacosh, z, CMPLXL(INFINITY, pi / 2), 1); testall_tol(cacosh, -z, CMPLXL(INFINITY, -pi / 2), 1); testall_tol(cacos, z, CMPLXL(pi / 2, -INFINITY), 1); testall_tol(cacos, -z, CMPLXL(pi / 2, INFINITY), 1); testall_odd_tol(casinh, z, CMPLXL(INFINITY, pi / 2), 1); /* XXX We allow a spurious inexact exception here. */ testall_odd(casin, z, CMPLXL(0.0, INFINITY), OPT_INEXACT, 0, CS_BOTH); testall_odd_tol(catanh, z, CMPLXL(0, pi / 2), 1); testall_odd_tol(catan, z, CMPLXL(pi / 2, 0), 1); } /* Tests along the real and imaginary axes. */ -static void -test_axes(void) +ATF_TC_WITHOUT_HEAD(axes); +ATF_TC_BODY(axes, tc) { static const long double nums[] = { -2, -1, -0.5, 0.5, 1, 2 }; long double complex z; unsigned i; for (i = 0; i < nitems(nums); i++) { /* Real axis */ z = CMPLXL(nums[i], 0.0); if (fabsl(nums[i]) <= 1) { testall_tol(cacosh, z, CMPLXL(0.0, acos(nums[i])), 1); testall_tol(cacos, z, CMPLXL(acosl(nums[i]), -0.0), 1); testall_tol(casin, z, CMPLXL(asinl(nums[i]), 0.0), 1); testall_tol(catanh, z, CMPLXL(atanh(nums[i]), 0.0), 1); } else { testall_tol(cacosh, z, CMPLXL(acosh(fabsl(nums[i])), (nums[i] < 0) ? pi : 0), 1); testall_tol(cacos, z, CMPLXL((nums[i] < 0) ? pi : 0, -acosh(fabsl(nums[i]))), 1); testall_tol(casin, z, CMPLXL(copysign(pi / 2, nums[i]), acosh(fabsl(nums[i]))), 1); testall_tol(catanh, z, CMPLXL(atanh(1 / nums[i]), pi / 2), 1); } testall_tol(casinh, z, CMPLXL(asinh(nums[i]), 0.0), 1); testall_tol(catan, z, CMPLXL(atan(nums[i]), 0), 1); /* TODO: Test the imaginary axis. */ } } -static void -test_small(void) +ATF_TC_WITHOUT_HEAD(small); +ATF_TC_BODY(small, tc) { /* * z = 0.75 + i 0.25 * acos(z) = Pi/4 - i ln(2)/2 * asin(z) = Pi/4 + i ln(2)/2 * atan(z) = atan(4)/2 + i ln(17/9)/4 */ complex long double z; complex long double acos_z; complex long double asin_z; complex long double atan_z; z = CMPLXL(0.75L, 0.25L); acos_z = CMPLXL(pi / 4, -0.34657359027997265470861606072908828L); asin_z = CMPLXL(pi / 4, 0.34657359027997265470861606072908828L); atan_z = CMPLXL(0.66290883183401623252961960521423782L, 0.15899719167999917436476103600701878L); testall_tol(cacos, z, acos_z, 2); testall_odd_tol(casin, z, asin_z, 2); testall_odd_tol(catan, z, atan_z, 2); } /* Test inputs that might cause overflow in a sloppy implementation. */ -static void -test_large(void) +ATF_TC_WITHOUT_HEAD(large); +ATF_TC_BODY(large, tc) { - /* TODO: Write these tests */ } -int -main(void) +ATF_TP_ADD_TCS(tp) { - - printf("1..6\n"); - - test_zero(); - printf("ok 1 - invctrig zero\n"); - - test_nan(); - printf("ok 2 - invctrig nan\n"); - - test_inf(); - printf("ok 3 - invctrig inf\n"); - - test_axes(); - printf("ok 4 - invctrig axes\n"); - - test_small(); - printf("ok 5 - invctrig small\n"); - - test_large(); - printf("ok 6 - invctrig large\n"); - - return (0); + ATF_TP_ADD_TC(tp, zero); + ATF_TP_ADD_TC(tp, nan); + ATF_TP_ADD_TC(tp, inf); + ATF_TP_ADD_TC(tp, axes); + ATF_TP_ADD_TC(tp, small); + ATF_TP_ADD_TC(tp, large); + + return (atf_no_error()); } diff --git a/lib/msun/tests/invtrig_test.c b/lib/msun/tests/invtrig_test.c index 3c24d61ecce9..9376ecea8658 100644 --- a/lib/msun/tests/invtrig_test.c +++ b/lib/msun/tests/invtrig_test.c @@ -1,478 +1,457 @@ /*- * Copyright (c) 2008 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Tests for corner cases in the inverse trigonometric functions. Some * accuracy tests are included as well, but these are very basic * sanity checks, not intended to be comprehensive. */ #include __FBSDID("$FreeBSD$"); -#include #include #include #include #include #include "test-utils.h" #pragma STDC FENV_ACCESS ON /* * Test that a function returns the correct value and sets the * exception flags correctly. A tolerance specifying the maximum * relative error allowed may be specified. For the 'testall' * functions, the tolerance is specified in ulps. * * These are macros instead of functions so that assert provides more * meaningful error messages. */ #define test_tol(func, x, result, tol, excepts) do { \ volatile long double _in = (x), _out = (result); \ - assert(feclearexcept(FE_ALL_EXCEPT) == 0); \ - assert(fpequal_tol(func(_in), _out, (tol), CS_BOTH)); \ - assert(((void)func, fetestexcept(ALL_STD_EXCEPT) == (excepts))); \ + ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT)); \ + ATF_CHECK(fpequal_tol(func(_in), _out, (tol), CS_BOTH)); \ + CHECK_FP_EXCEPTIONS_MSG(excepts, ALL_STD_EXCEPT, "for %s(%s)", \ + #func, #x); \ } while (0) #define test(func, x, result, excepts) \ test_tol(func, (x), (result), 0, (excepts)) #define _testall_tol(prefix, x, result, tol, excepts) do { \ test_tol(prefix, (double)(x), (double)(result), \ (tol) * ldexp(1.0, 1 - DBL_MANT_DIG), (excepts)); \ test_tol(prefix##f, (float)(x), (float)(result), \ (tol) * ldexpf(1.0, 1 - FLT_MANT_DIG), (excepts)); \ } while (0) #if LDBL_PREC == 53 #define testall_tol _testall_tol #else #define testall_tol(prefix, x, result, tol, excepts) do { \ _testall_tol(prefix, x, result, tol, excepts); \ test_tol(prefix##l, (x), (result), \ (tol) * ldexpl(1.0, 1 - LDBL_MANT_DIG), (excepts)); \ } while (0) #endif #define testall(prefix, x, result, excepts) \ testall_tol(prefix, (x), (result), 0, (excepts)) #define test2_tol(func, y, x, result, tol, excepts) do { \ volatile long double _iny = (y), _inx = (x), _out = (result); \ - assert(feclearexcept(FE_ALL_EXCEPT) == 0); \ - assert(fpequal_tol(func(_iny, _inx), _out, (tol), CS_BOTH)); \ - assert(((void)func, fetestexcept(ALL_STD_EXCEPT) == (excepts))); \ + ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT)); \ + ATF_CHECK(fpequal_tol(func(_iny, _inx), _out, (tol), CS_BOTH)); \ + CHECK_FP_EXCEPTIONS_MSG(excepts, ALL_STD_EXCEPT, "for %s(%s)", \ + #func, #x); \ } while (0) #define test2(func, y, x, result, excepts) \ test2_tol(func, (y), (x), (result), 0, (excepts)) #define _testall2_tol(prefix, y, x, result, tol, excepts) do { \ test2_tol(prefix, (double)(y), (double)(x), (double)(result), \ (tol) * ldexp(1.0, 1 - DBL_MANT_DIG), (excepts)); \ test2_tol(prefix##f, (float)(y), (float)(x), (float)(result), \ (tol) * ldexpf(1.0, 1 - FLT_MANT_DIG), (excepts)); \ } while (0) #if LDBL_PREC == 53 #define testall2_tol _testall2_tol #else #define testall2_tol(prefix, y, x, result, tol, excepts) do { \ _testall2_tol(prefix, y, x, result, tol, excepts); \ test2_tol(prefix##l, (y), (x), (result), \ (tol) * ldexpl(1.0, 1 - LDBL_MANT_DIG), (excepts)); \ } while (0) #endif #define testall2(prefix, y, x, result, excepts) \ testall2_tol(prefix, (y), (x), (result), 0, (excepts)) static long double pi = 3.14159265358979323846264338327950280e+00L, pio3 = 1.04719755119659774615421446109316766e+00L, c3pi = 9.42477796076937971538793014983850839e+00L, c7pi = 2.19911485751285526692385036829565196e+01L, c5pio3 = 5.23598775598298873077107230546583851e+00L, sqrt2m1 = 4.14213562373095048801688724209698081e-01L; /* * Test special case inputs in asin(), acos() and atan(): signed * zeroes, infinities, and NaNs. */ -static void -test_special(void) +ATF_TC_WITHOUT_HEAD(special); +ATF_TC_BODY(special, tc) { testall(asin, 0.0, 0.0, 0); testall(acos, 0.0, pi / 2, FE_INEXACT); testall(atan, 0.0, 0.0, 0); testall(asin, -0.0, -0.0, 0); testall(acos, -0.0, pi / 2, FE_INEXACT); testall(atan, -0.0, -0.0, 0); testall(asin, INFINITY, NAN, FE_INVALID); testall(acos, INFINITY, NAN, FE_INVALID); testall(atan, INFINITY, pi / 2, FE_INEXACT); testall(asin, -INFINITY, NAN, FE_INVALID); testall(acos, -INFINITY, NAN, FE_INVALID); testall(atan, -INFINITY, -pi / 2, FE_INEXACT); testall(asin, NAN, NAN, 0); testall(acos, NAN, NAN, 0); testall(atan, NAN, NAN, 0); } /* * Test special case inputs in atan2(), where the exact value of y/x is * zero or non-finite. */ -static void -test_special_atan2(void) +ATF_TC_WITHOUT_HEAD(special_atan2); +ATF_TC_BODY(special_atan2, tc) { long double z; int e; testall2(atan2, 0.0, -0.0, pi, FE_INEXACT); testall2(atan2, -0.0, -0.0, -pi, FE_INEXACT); testall2(atan2, 0.0, 0.0, 0.0, 0); testall2(atan2, -0.0, 0.0, -0.0, 0); testall2(atan2, INFINITY, -INFINITY, c3pi / 4, FE_INEXACT); testall2(atan2, -INFINITY, -INFINITY, -c3pi / 4, FE_INEXACT); testall2(atan2, INFINITY, INFINITY, pi / 4, FE_INEXACT); testall2(atan2, -INFINITY, INFINITY, -pi / 4, FE_INEXACT); /* Tests with one input in the range (0, Inf]. */ z = 1.23456789L; for (e = FLT_MIN_EXP - FLT_MANT_DIG; e <= FLT_MAX_EXP; e++) { test2(atan2f, 0.0, ldexpf(z, e), 0.0, 0); test2(atan2f, -0.0, ldexpf(z, e), -0.0, 0); test2(atan2f, 0.0, ldexpf(-z, e), (float)pi, FE_INEXACT); test2(atan2f, -0.0, ldexpf(-z, e), (float)-pi, FE_INEXACT); test2(atan2f, ldexpf(z, e), 0.0, (float)pi / 2, FE_INEXACT); test2(atan2f, ldexpf(z, e), -0.0, (float)pi / 2, FE_INEXACT); test2(atan2f, ldexpf(-z, e), 0.0, (float)-pi / 2, FE_INEXACT); test2(atan2f, ldexpf(-z, e), -0.0, (float)-pi / 2, FE_INEXACT); } for (e = DBL_MIN_EXP - DBL_MANT_DIG; e <= DBL_MAX_EXP; e++) { test2(atan2, 0.0, ldexp(z, e), 0.0, 0); test2(atan2, -0.0, ldexp(z, e), -0.0, 0); test2(atan2, 0.0, ldexp(-z, e), (double)pi, FE_INEXACT); test2(atan2, -0.0, ldexp(-z, e), (double)-pi, FE_INEXACT); test2(atan2, ldexp(z, e), 0.0, (double)pi / 2, FE_INEXACT); test2(atan2, ldexp(z, e), -0.0, (double)pi / 2, FE_INEXACT); test2(atan2, ldexp(-z, e), 0.0, (double)-pi / 2, FE_INEXACT); test2(atan2, ldexp(-z, e), -0.0, (double)-pi / 2, FE_INEXACT); } for (e = LDBL_MIN_EXP - LDBL_MANT_DIG; e <= LDBL_MAX_EXP; e++) { test2(atan2l, 0.0, ldexpl(z, e), 0.0, 0); test2(atan2l, -0.0, ldexpl(z, e), -0.0, 0); test2(atan2l, 0.0, ldexpl(-z, e), pi, FE_INEXACT); test2(atan2l, -0.0, ldexpl(-z, e), -pi, FE_INEXACT); test2(atan2l, ldexpl(z, e), 0.0, pi / 2, FE_INEXACT); test2(atan2l, ldexpl(z, e), -0.0, pi / 2, FE_INEXACT); test2(atan2l, ldexpl(-z, e), 0.0, -pi / 2, FE_INEXACT); test2(atan2l, ldexpl(-z, e), -0.0, -pi / 2, FE_INEXACT); } /* Tests with one input in the range (0, Inf). */ for (e = FLT_MIN_EXP - FLT_MANT_DIG; e <= FLT_MAX_EXP - 1; e++) { test2(atan2f, ldexpf(z, e), INFINITY, 0.0, 0); test2(atan2f, ldexpf(-z,e), INFINITY, -0.0, 0); test2(atan2f, ldexpf(z, e), -INFINITY, (float)pi, FE_INEXACT); test2(atan2f, ldexpf(-z,e), -INFINITY, (float)-pi, FE_INEXACT); test2(atan2f, INFINITY, ldexpf(z,e), (float)pi/2, FE_INEXACT); test2(atan2f, INFINITY, ldexpf(-z,e), (float)pi/2, FE_INEXACT); test2(atan2f, -INFINITY, ldexpf(z,e), (float)-pi/2,FE_INEXACT); test2(atan2f, -INFINITY, ldexpf(-z,e),(float)-pi/2,FE_INEXACT); } for (e = DBL_MIN_EXP - DBL_MANT_DIG; e <= DBL_MAX_EXP - 1; e++) { test2(atan2, ldexp(z, e), INFINITY, 0.0, 0); test2(atan2, ldexp(-z,e), INFINITY, -0.0, 0); test2(atan2, ldexp(z, e), -INFINITY, (double)pi, FE_INEXACT); test2(atan2, ldexp(-z,e), -INFINITY, (double)-pi, FE_INEXACT); test2(atan2, INFINITY, ldexp(z,e), (double)pi/2, FE_INEXACT); test2(atan2, INFINITY, ldexp(-z,e), (double)pi/2, FE_INEXACT); test2(atan2, -INFINITY, ldexp(z,e), (double)-pi/2,FE_INEXACT); test2(atan2, -INFINITY, ldexp(-z,e),(double)-pi/2,FE_INEXACT); } for (e = LDBL_MIN_EXP - LDBL_MANT_DIG; e <= LDBL_MAX_EXP - 1; e++) { test2(atan2l, ldexpl(z, e), INFINITY, 0.0, 0); test2(atan2l, ldexpl(-z,e), INFINITY, -0.0, 0); test2(atan2l, ldexpl(z, e), -INFINITY, pi, FE_INEXACT); test2(atan2l, ldexpl(-z,e), -INFINITY, -pi, FE_INEXACT); test2(atan2l, INFINITY, ldexpl(z, e), pi / 2, FE_INEXACT); test2(atan2l, INFINITY, ldexpl(-z, e), pi / 2, FE_INEXACT); test2(atan2l, -INFINITY, ldexpl(z, e), -pi / 2, FE_INEXACT); test2(atan2l, -INFINITY, ldexpl(-z, e), -pi / 2, FE_INEXACT); } } /* * Test various inputs to asin(), acos() and atan() and verify that the * results are accurate to within 1 ulp. */ -static void -test_accuracy(void) +ATF_TC_WITHOUT_HEAD(accuracy); +ATF_TC_BODY(accuracy, tc) { /* We expect correctly rounded results for these basic cases. */ testall(asin, 1.0, pi / 2, FE_INEXACT); testall(acos, 1.0, 0, 0); testall(atan, 1.0, pi / 4, FE_INEXACT); testall(asin, -1.0, -pi / 2, FE_INEXACT); testall(acos, -1.0, pi, FE_INEXACT); testall(atan, -1.0, -pi / 4, FE_INEXACT); /* * Here we expect answers to be within 1 ulp, although inexactness * in the input, combined with double rounding, could cause larger * errors. */ testall_tol(asin, sqrtl(2) / 2, pi / 4, 1, FE_INEXACT); testall_tol(acos, sqrtl(2) / 2, pi / 4, 1, FE_INEXACT); testall_tol(asin, -sqrtl(2) / 2, -pi / 4, 1, FE_INEXACT); testall_tol(acos, -sqrtl(2) / 2, c3pi / 4, 1, FE_INEXACT); testall_tol(asin, sqrtl(3) / 2, pio3, 1, FE_INEXACT); testall_tol(acos, sqrtl(3) / 2, pio3 / 2, 1, FE_INEXACT); testall_tol(atan, sqrtl(3), pio3, 1, FE_INEXACT); testall_tol(asin, -sqrtl(3) / 2, -pio3, 1, FE_INEXACT); testall_tol(acos, -sqrtl(3) / 2, c5pio3 / 2, 1, FE_INEXACT); testall_tol(atan, -sqrtl(3), -pio3, 1, FE_INEXACT); testall_tol(atan, sqrt2m1, pi / 8, 1, FE_INEXACT); testall_tol(atan, -sqrt2m1, -pi / 8, 1, FE_INEXACT); } /* * Test inputs to atan2() where x is a power of 2. These are easy cases * because y/x is exact. */ -static void -test_p2x_atan2(void) +ATF_TC_WITHOUT_HEAD(p2x_atan2); +ATF_TC_BODY(p2x_atan2, tc) { testall2(atan2, 1.0, 1.0, pi / 4, FE_INEXACT); testall2(atan2, 1.0, -1.0, c3pi / 4, FE_INEXACT); testall2(atan2, -1.0, 1.0, -pi / 4, FE_INEXACT); testall2(atan2, -1.0, -1.0, -c3pi / 4, FE_INEXACT); testall2_tol(atan2, sqrt2m1 * 2, 2.0, pi / 8, 1, FE_INEXACT); testall2_tol(atan2, sqrt2m1 * 2, -2.0, c7pi / 8, 1, FE_INEXACT); testall2_tol(atan2, -sqrt2m1 * 2, 2.0, -pi / 8, 1, FE_INEXACT); testall2_tol(atan2, -sqrt2m1 * 2, -2.0, -c7pi / 8, 1, FE_INEXACT); testall2_tol(atan2, sqrtl(3) * 0.5, 0.5, pio3, 1, FE_INEXACT); testall2_tol(atan2, sqrtl(3) * 0.5, -0.5, pio3 * 2, 1, FE_INEXACT); testall2_tol(atan2, -sqrtl(3) * 0.5, 0.5, -pio3, 1, FE_INEXACT); testall2_tol(atan2, -sqrtl(3) * 0.5, -0.5, -pio3 * 2, 1, FE_INEXACT); } /* * Test inputs very close to 0. */ -static void -test_tiny(void) +ATF_TC_WITHOUT_HEAD(tiny); +ATF_TC_BODY(tiny, tc) { float tiny = 0x1.23456p-120f; testall(asin, tiny, tiny, FE_INEXACT); testall(acos, tiny, pi / 2, FE_INEXACT); testall(atan, tiny, tiny, FE_INEXACT); testall(asin, -tiny, -tiny, FE_INEXACT); testall(acos, -tiny, pi / 2, FE_INEXACT); testall(atan, -tiny, -tiny, FE_INEXACT); /* Test inputs to atan2() that would cause y/x to underflow. */ test2(atan2f, 0x1.0p-100, 0x1.0p100, 0.0, FE_INEXACT | FE_UNDERFLOW); test2(atan2, 0x1.0p-1000, 0x1.0p1000, 0.0, FE_INEXACT | FE_UNDERFLOW); test2(atan2l, ldexpl(1.0, 100 - LDBL_MAX_EXP), ldexpl(1.0, LDBL_MAX_EXP - 100), 0.0, FE_INEXACT | FE_UNDERFLOW); test2(atan2f, -0x1.0p-100, 0x1.0p100, -0.0, FE_INEXACT | FE_UNDERFLOW); test2(atan2, -0x1.0p-1000, 0x1.0p1000, -0.0, FE_INEXACT | FE_UNDERFLOW); test2(atan2l, -ldexpl(1.0, 100 - LDBL_MAX_EXP), ldexpl(1.0, LDBL_MAX_EXP - 100), -0.0, FE_INEXACT | FE_UNDERFLOW); test2(atan2f, 0x1.0p-100, -0x1.0p100, (float)pi, FE_INEXACT); test2(atan2, 0x1.0p-1000, -0x1.0p1000, (double)pi, FE_INEXACT); test2(atan2l, ldexpl(1.0, 100 - LDBL_MAX_EXP), -ldexpl(1.0, LDBL_MAX_EXP - 100), pi, FE_INEXACT); test2(atan2f, -0x1.0p-100, -0x1.0p100, (float)-pi, FE_INEXACT); test2(atan2, -0x1.0p-1000, -0x1.0p1000, (double)-pi, FE_INEXACT); test2(atan2l, -ldexpl(1.0, 100 - LDBL_MAX_EXP), -ldexpl(1.0, LDBL_MAX_EXP - 100), -pi, FE_INEXACT); } /* * Test very large inputs to atan(). */ -static void -test_atan_huge(void) +ATF_TC_WITHOUT_HEAD(atan_huge); +ATF_TC_BODY(atan_huge, tc) { float huge = 0x1.23456p120; testall(atan, huge, pi / 2, FE_INEXACT); testall(atan, -huge, -pi / 2, FE_INEXACT); /* Test inputs to atan2() that would cause y/x to overflow. */ test2(atan2f, 0x1.0p100, 0x1.0p-100, (float)pi / 2, FE_INEXACT); test2(atan2, 0x1.0p1000, 0x1.0p-1000, (double)pi / 2, FE_INEXACT); test2(atan2l, ldexpl(1.0, LDBL_MAX_EXP - 100), ldexpl(1.0, 100 - LDBL_MAX_EXP), pi / 2, FE_INEXACT); test2(atan2f, -0x1.0p100, 0x1.0p-100, (float)-pi / 2, FE_INEXACT); test2(atan2, -0x1.0p1000, 0x1.0p-1000, (double)-pi / 2, FE_INEXACT); test2(atan2l, -ldexpl(1.0, LDBL_MAX_EXP - 100), ldexpl(1.0, 100 - LDBL_MAX_EXP), -pi / 2, FE_INEXACT); test2(atan2f, 0x1.0p100, -0x1.0p-100, (float)pi / 2, FE_INEXACT); test2(atan2, 0x1.0p1000, -0x1.0p-1000, (double)pi / 2, FE_INEXACT); test2(atan2l, ldexpl(1.0, LDBL_MAX_EXP - 100), -ldexpl(1.0, 100 - LDBL_MAX_EXP), pi / 2, FE_INEXACT); test2(atan2f, -0x1.0p100, -0x1.0p-100, (float)-pi / 2, FE_INEXACT); test2(atan2, -0x1.0p1000, -0x1.0p-1000, (double)-pi / 2, FE_INEXACT); test2(atan2l, -ldexpl(1.0, LDBL_MAX_EXP - 100), -ldexpl(1.0, 100 - LDBL_MAX_EXP), -pi / 2, FE_INEXACT); } /* * Test that sin(asin(x)) == x, and similarly for acos() and atan(). * You need to have a working sinl(), cosl(), and tanl() for these * tests to pass. */ static long double sinasinf(float x) { return (sinl(asinf(x))); } static long double sinasin(double x) { return (sinl(asin(x))); } static long double sinasinl(long double x) { return (sinl(asinl(x))); } static long double cosacosf(float x) { return (cosl(acosf(x))); } static long double cosacos(double x) { return (cosl(acos(x))); } static long double cosacosl(long double x) { return (cosl(acosl(x))); } static long double tanatanf(float x) { return (tanl(atanf(x))); } static long double tanatan(double x) { return (tanl(atan(x))); } static long double tanatanl(long double x) { return (tanl(atanl(x))); } -static void -test_inverse(void) +ATF_TC_WITHOUT_HEAD(inverse); +ATF_TC_BODY(inverse, tc) { float i; for (i = -1; i <= 1; i += 0x1.0p-12f) { testall_tol(sinasin, i, i, 2, i == 0 ? 0 : FE_INEXACT); /* The relative error for cosacos is very large near x=0. */ if (fabsf(i) > 0x1.0p-4f) testall_tol(cosacos, i, i, 16, i == 1 ? 0 : FE_INEXACT); testall_tol(tanatan, i, i, 2, i == 0 ? 0 : FE_INEXACT); } } -int -main(void) +ATF_TP_ADD_TCS(tp) { - -#if defined(__i386__) - printf("1..0 # SKIP fails all assertions on i386\n"); - return (0); -#endif - - printf("1..7\n"); - - test_special(); - printf("ok 1 - special\n"); - - test_special_atan2(); - printf("ok 2 - atan2 special\n"); - - test_accuracy(); - printf("ok 3 - accuracy\n"); - - test_p2x_atan2(); - printf("ok 4 - atan2 p2x\n"); - - test_tiny(); - printf("ok 5 - tiny inputs\n"); - - test_atan_huge(); - printf("ok 6 - atan huge inputs\n"); - - test_inverse(); - printf("ok 7 - inverse\n"); - - return (0); + ATF_TP_ADD_TC(tp, special); + ATF_TP_ADD_TC(tp, special_atan2); + ATF_TP_ADD_TC(tp, accuracy); + ATF_TP_ADD_TC(tp, p2x_atan2); + ATF_TP_ADD_TC(tp, tiny); + ATF_TP_ADD_TC(tp, atan_huge); + ATF_TP_ADD_TC(tp, inverse); + + return (atf_no_error()); } diff --git a/lib/msun/tests/logarithm_test.c b/lib/msun/tests/logarithm_test.c index 43911f63b281..0a6728681a30 100644 --- a/lib/msun/tests/logarithm_test.c +++ b/lib/msun/tests/logarithm_test.c @@ -1,287 +1,264 @@ /*- * Copyright (c) 2008-2010 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Tests for corner cases in log*(). */ #include __FBSDID("$FreeBSD$"); #include -#include #include #include #include #include #ifdef __i386__ #include #endif #include "test-utils.h" #pragma STDC FENV_ACCESS ON /* * Test that a function returns the correct value and sets the * exception flags correctly. The exceptmask specifies which * exceptions we should check. We need to be lenient for several * reasoons, but mainly because on some architectures it's impossible * to raise FE_OVERFLOW without raising FE_INEXACT. * * These are macros instead of functions so that assert provides more * meaningful error messages. * * XXX The volatile here is to avoid gcc's bogus constant folding and work * around the lack of support for the FENV_ACCESS pragma. */ -#define test(func, x, result, exceptmask, excepts) do { \ - volatile long double _d = x; \ - assert(feclearexcept(FE_ALL_EXCEPT) == 0); \ - assert(fpequal((func)(_d), (result))); \ - assert(((void)(func), fetestexcept(exceptmask) == (excepts))); \ -} while (0) - -#define test(func, x, result, exceptmask, excepts) do { \ - volatile long double _d = x; \ - assert(feclearexcept(FE_ALL_EXCEPT) == 0); \ - assert(fpequal((func)(_d), (result))); \ - assert(((void)(func), fetestexcept(exceptmask) == (excepts))); \ +#define test(func, x, result, exceptmask, excepts) do { \ + volatile long double _d = x; \ + ATF_CHECK_EQ(0, feclearexcept(FE_ALL_EXCEPT)); \ + ATF_CHECK(fpequal((func)(_d), (result))); \ + CHECK_FP_EXCEPTIONS_MSG(excepts, exceptmask, "for %s(%s)", \ + #func, #x); \ } while (0) #define test_tol(func, z, result, tol) do { \ volatile long double _d = z; \ debug(" testing %6s(%15La) ~= % .36Le\n", #func, _d, result); \ - assert(fpequal_tol((func)(_d), (result), (tol), CS_BOTH)); \ + ATF_CHECK(fpequal_tol((func)(_d), (result), (tol), CS_BOTH)); \ } while (0) /* Test all the functions that compute log(x). */ #define testall0(x, result, exceptmask, excepts) do { \ test(log, x, result, exceptmask, excepts); \ test(logf, x, result, exceptmask, excepts); \ test(logl, x, result, exceptmask, excepts); \ test(log2, x, result, exceptmask, excepts); \ test(log2f, x, result, exceptmask, excepts); \ test(log2l, x, result, exceptmask, excepts); \ test(log10, x, result, exceptmask, excepts); \ test(log10f, x, result, exceptmask, excepts); \ test(log10l, x, result, exceptmask, excepts); \ } while (0) /* Test all the functions that compute log(1+x). */ #define testall1(x, result, exceptmask, excepts) do { \ test(log1p, x, result, exceptmask, excepts); \ test(log1pf, x, result, exceptmask, excepts); \ test(log1pl, x, result, exceptmask, excepts); \ } while (0) -static void -run_generic_tests(void) +ATF_TC_WITHOUT_HEAD(generic_tests); +ATF_TC_BODY(generic_tests, tc) { /* log(1) == 0, no exceptions raised */ testall0(1.0, 0.0, ALL_STD_EXCEPT, 0); testall1(0.0, 0.0, ALL_STD_EXCEPT, 0); testall1(-0.0, -0.0, ALL_STD_EXCEPT, 0); /* log(NaN) == NaN, no exceptions raised */ testall0(NAN, NAN, ALL_STD_EXCEPT, 0); testall1(NAN, NAN, ALL_STD_EXCEPT, 0); /* log(Inf) == Inf, no exceptions raised */ testall0(INFINITY, INFINITY, ALL_STD_EXCEPT, 0); testall1(INFINITY, INFINITY, ALL_STD_EXCEPT, 0); /* log(x) == NaN for x < 0, invalid exception raised */ testall0(-INFINITY, NAN, ALL_STD_EXCEPT, FE_INVALID); testall1(-INFINITY, NAN, ALL_STD_EXCEPT, FE_INVALID); testall0(-1.0, NAN, ALL_STD_EXCEPT, FE_INVALID); testall1(-1.5, NAN, ALL_STD_EXCEPT, FE_INVALID); /* log(0) == -Inf, divide-by-zero exception */ testall0(0.0, -INFINITY, ALL_STD_EXCEPT & ~FE_INEXACT, FE_DIVBYZERO); testall0(-0.0, -INFINITY, ALL_STD_EXCEPT & ~FE_INEXACT, FE_DIVBYZERO); testall1(-1.0, -INFINITY, ALL_STD_EXCEPT & ~FE_INEXACT, FE_DIVBYZERO); } -static void -run_log2_tests(void) +ATF_TC_WITHOUT_HEAD(log2_tests); +ATF_TC_BODY(log2_tests, tc) { unsigned i; /* * We should insist that log2() return exactly the correct * result and not raise an inexact exception for powers of 2. */ - assert(feclearexcept(FE_ALL_EXCEPT) == 0); + ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT)); for (i = FLT_MIN_EXP - FLT_MANT_DIG; i < FLT_MAX_EXP; i++) { - assert(log2f(ldexpf(1.0, i)) == i); - assert(fetestexcept(ALL_STD_EXCEPT) == 0); + ATF_CHECK_EQ(i, log2f(ldexpf(1.0, i))); + CHECK_FP_EXCEPTIONS(0, ALL_STD_EXCEPT); } for (i = DBL_MIN_EXP - DBL_MANT_DIG; i < DBL_MAX_EXP; i++) { - assert(log2(ldexp(1.0, i)) == i); - assert(fetestexcept(ALL_STD_EXCEPT) == 0); + ATF_CHECK_EQ(i, log2(ldexp(1.0, i))); + CHECK_FP_EXCEPTIONS(0, ALL_STD_EXCEPT); } for (i = LDBL_MIN_EXP - LDBL_MANT_DIG; i < LDBL_MAX_EXP; i++) { - assert(log2l(ldexpl(1.0, i)) == i); -#if 0 - /* XXX This test does not pass yet. */ - assert(fetestexcept(ALL_STD_EXCEPT) == 0); -#endif + ATF_CHECK_EQ(i, log2l(ldexpl(1.0, i))); + CHECK_FP_EXCEPTIONS(0, ALL_STD_EXCEPT); } } -static void -run_roundingmode_tests(void) +ATF_TC_WITHOUT_HEAD(roundingmode_tests); +ATF_TC_BODY(roundingmode_tests, tc) { /* * Corner cases in other rounding modes. */ fesetround(FE_DOWNWARD); /* These are still positive per IEEE 754R */ #if 0 testall0(1.0, 0.0, ALL_STD_EXCEPT, 0); #else /* logl, log2l, and log10l don't pass yet. */ test(log, 1.0, 0.0, ALL_STD_EXCEPT, 0); test(logf, 1.0, 0.0, ALL_STD_EXCEPT, 0); test(log2, 1.0, 0.0, ALL_STD_EXCEPT, 0); test(log2f, 1.0, 0.0, ALL_STD_EXCEPT, 0); test(log10, 1.0, 0.0, ALL_STD_EXCEPT, 0); test(log10f, 1.0, 0.0, ALL_STD_EXCEPT, 0); #endif testall1(0.0, 0.0, ALL_STD_EXCEPT, 0); fesetround(FE_TOWARDZERO); testall0(1.0, 0.0, ALL_STD_EXCEPT, 0); testall1(0.0, 0.0, ALL_STD_EXCEPT, 0); fesetround(FE_UPWARD); testall0(1.0, 0.0, ALL_STD_EXCEPT, 0); testall1(0.0, 0.0, ALL_STD_EXCEPT, 0); /* log1p(-0.0) == -0.0 even when rounding upwards */ testall1(-0.0, -0.0, ALL_STD_EXCEPT, 0); fesetround(FE_TONEAREST); } -static void -run_accuracy_tests(void) +ATF_TC_WITHOUT_HEAD(accuracy_tests); +ATF_TC_BODY(accuracy_tests, tc) { static const struct { float x; long double log2x; long double logex; long double log10x; } tests[] = { { 0x1p-120 + 0x1p-140, -1.19999998624139449158861798943319717e2L, -8.31776607135195754708796206665656732e1L, -3.61235990655024477716980559136055915e1L, }, { 1.0 - 0x1p-20, -1.37586186296463416424364914705656460e-6L, -9.53674771153890007250243736279163253e-7L, -4.14175690642480911859354110516159131e-7L, }, { 1.0 + 0x1p-20, 1.37586055084113820105668028340371476e-6L, 9.53673861659188233908415514963336144e-7L, 4.14175295653950611453333571759200697e-7L }, { 19.75, 4.30378074817710292442728634194115348e0L, 2.98315349134713087533848129856505779e0L, 1.29556709996247903756734359702926363e0L }, { 19.75 * 0x1p100, 1.043037807481771029244272863419411534e2L, 7.229787154734166181706169344438271459e1L, 3.139856666636059855894123306947856631e1L }, }; unsigned i; for (i = 0; i < nitems(tests); i++) { test_tol(log2, tests[i].x, tests[i].log2x, DBL_ULP()); test_tol(log2f, tests[i].x, tests[i].log2x, FLT_ULP()); test_tol(log2l, tests[i].x, tests[i].log2x, LDBL_ULP()); test_tol(log, tests[i].x, tests[i].logex, DBL_ULP()); test_tol(logf, tests[i].x, tests[i].logex, FLT_ULP()); test_tol(logl, tests[i].x, tests[i].logex, LDBL_ULP()); test_tol(log10, tests[i].x, tests[i].log10x, DBL_ULP()); test_tol(log10f, tests[i].x, tests[i].log10x, FLT_ULP()); test_tol(log10l, tests[i].x, tests[i].log10x, LDBL_ULP()); if (tests[i].x >= 0.5) { test_tol(log1p, tests[i].x - 1, tests[i].logex, DBL_ULP()); test_tol(log1pf, tests[i].x - 1, tests[i].logex, FLT_ULP()); test_tol(log1pl, tests[i].x - 1, tests[i].logex, LDBL_ULP()); } } } -static void -run_log1p_accuracy_tests(void) +ATF_TC_WITHOUT_HEAD(log1p_accuracy_tests); +ATF_TC_BODY(log1p_accuracy_tests, tc) { - test_tol(log1pf, 0x0.333333p0F, 1.82321546859847114303367992804596800640e-1L, FLT_ULP()); test_tol(log1p, 0x0.3333333333333p0, 1.82321556793954589204283870982629267635e-1L, DBL_ULP()); test_tol(log1pl, 0x0.33333333333333332p0L, 1.82321556793954626202683007050468762914e-1L, LDBL_ULP()); test_tol(log1pf, -0x0.333333p0F, -2.23143536413048672940940199918017467652e-1L, FLT_ULP()); test_tol(log1p, -0x0.3333333333333p0, -2.23143551314209700255143859052009022937e-1L, DBL_ULP()); test_tol(log1pl, -0x0.33333333333333332p0L, -2.23143551314209755752742563153765697950e-1L, LDBL_ULP()); } -int -main(void) +ATF_TP_ADD_TCS(tp) { - printf("1..5\n"); - - run_generic_tests(); - printf("ok 1 - logarithm\n"); - - run_log2_tests(); - printf("ok 2 - logarithm\n"); - - run_roundingmode_tests(); - printf("ok 3 - logarithm\n"); - - run_accuracy_tests(); - printf("ok 4 - logarithm\n"); - - run_log1p_accuracy_tests(); - printf("ok 5 - logarithm\n"); + ATF_TP_ADD_TC(tp, generic_tests); + ATF_TP_ADD_TC(tp, log2_tests); + ATF_TP_ADD_TC(tp, roundingmode_tests); + ATF_TP_ADD_TC(tp, accuracy_tests); + ATF_TP_ADD_TC(tp, log1p_accuracy_tests); - return (0); + return (atf_no_error()); } diff --git a/lib/msun/tests/lrint_test.c b/lib/msun/tests/lrint_test.c index 321e1fdb5887..2606f88a41a3 100644 --- a/lib/msun/tests/lrint_test.c +++ b/lib/msun/tests/lrint_test.c @@ -1,152 +1,149 @@ /*- * Copyright (c) 2005-2008 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Test for lrint(), lrintf(), llrint(), and llrintf(). */ #include __FBSDID("$FreeBSD$"); -#include #include #include #include #include #ifdef __i386__ #include #endif #include "test-utils.h" /* * XXX The volatile here is to avoid gcc's bogus constant folding and work * around the lack of support for the FENV_ACCESS pragma. */ #define test(func, x, result, excepts) do { \ volatile double _d = x; \ - assert(feclearexcept(FE_ALL_EXCEPT) == 0); \ - assert((func)(_d) == (result) || fetestexcept(FE_INVALID)); \ - assert((fetestexcept(FE_ALL_EXCEPT) & ALL_STD_EXCEPT) \ - == (excepts)); \ + ATF_CHECK(feclearexcept(FE_ALL_EXCEPT) == 0); \ + ATF_CHECK((func)(_d) == (result) || fetestexcept(FE_INVALID)); \ + CHECK_FP_EXCEPTIONS_MSG(excepts, FE_ALL_EXCEPT & ALL_STD_EXCEPT,\ + "for %s(%s)", #func, #x); \ } while (0) #define testall(x, result, excepts) do { \ test(lrint, x, result, excepts); \ test(lrintf, x, result, excepts); \ test(lrintl, x, result, excepts); \ test(llrint, x, result, excepts); \ test(llrintf, x, result, excepts); \ test(llrintl, x, result, excepts); \ } while (0) #define IGNORE 0 #pragma STDC FENV_ACCESS ON static void run_tests(void) { - - assert(fesetround(FE_DOWNWARD) == 0); + ATF_REQUIRE_EQ(0, fesetround(FE_DOWNWARD)); testall(0.75, 0, FE_INEXACT); testall(-0.5, -1, FE_INEXACT); - assert(fesetround(FE_TONEAREST) == 0); + ATF_REQUIRE_EQ(0, fesetround(FE_TONEAREST)); testall(0.0, 0, 0); testall(0.25, 0, FE_INEXACT); testall(0.5, 0, FE_INEXACT); testall(-2.5, -2, FE_INEXACT); testall(1.0, 1, 0); testall(0x12345000p0, 0x12345000, 0); testall(0x1234.fp0, 0x1235, FE_INEXACT); testall(INFINITY, IGNORE, FE_INVALID); testall(NAN, IGNORE, FE_INVALID); #if (LONG_MAX == 0x7fffffffl) - assert(fesetround(FE_UPWARD) == 0); + ATF_REQUIRE_EQ(0, fesetround(FE_UPWARD)); test(lrint, 0x7fffffff.8p0, IGNORE, FE_INVALID); - test(lrint, -0x80000000.4p0, -0x80000000l, FE_INEXACT); + test(lrint, -0x80000000.4p0, (long)-0x80000000l, FE_INEXACT); - assert(fesetround(FE_DOWNWARD) == 0); + ATF_REQUIRE_EQ(0, fesetround(FE_DOWNWARD)); test(lrint, -0x80000000.8p0, IGNORE, FE_INVALID); test(lrint, 0x80000000.0p0, IGNORE, FE_INVALID); test(lrint, 0x7fffffff.4p0, 0x7fffffffl, FE_INEXACT); test(lrintf, 0x80000000.0p0f, IGNORE, FE_INVALID); test(lrintf, 0x7fffff80.0p0f, 0x7fffff80l, 0); - assert(fesetround(FE_TOWARDZERO) == 0); + ATF_REQUIRE_EQ(0, fesetround(FE_TOWARDZERO)); test(lrint, 0x7fffffff.8p0, 0x7fffffffl, FE_INEXACT); test(lrint, -0x80000000.8p0, -0x80000000l, FE_INEXACT); test(lrint, 0x80000000.0p0, IGNORE, FE_INVALID); test(lrintf, 0x80000000.0p0f, IGNORE, FE_INVALID); test(lrintf, 0x7fffff80.0p0f, 0x7fffff80l, 0); #elif (LONG_MAX == 0x7fffffffffffffffll) - assert(fesetround(FE_TONEAREST) == 0); + ATF_REQUIRE_EQ(0, fesetround(FE_TONEAREST)); test(lrint, 0x8000000000000000.0p0, IGNORE, FE_INVALID); test(lrintf, 0x8000000000000000.0p0f, IGNORE, FE_INVALID); test(lrint, 0x7ffffffffffffc00.0p0, 0x7ffffffffffffc00l, 0); test(lrintf, 0x7fffff8000000000.0p0f, 0x7fffff8000000000l, 0); test(lrint, -0x8000000000000800.0p0, IGNORE, FE_INVALID); test(lrintf, -0x8000010000000000.0p0f, IGNORE, FE_INVALID); - test(lrint, -0x8000000000000000.0p0, -0x8000000000000000l, 0); - test(lrintf, -0x8000000000000000.0p0f, -0x8000000000000000l, 0); + test(lrint, -0x8000000000000000.0p0, (long long)-0x8000000000000000ul, 0); + test(lrintf, -0x8000000000000000.0p0f, (long long)-0x8000000000000000ul, 0); #else #error "Unsupported long size" #endif #if (LLONG_MAX == 0x7fffffffffffffffLL) - assert(fesetround(FE_TONEAREST) == 0); + ATF_REQUIRE_EQ(0, fesetround(FE_TONEAREST)); test(llrint, 0x8000000000000000.0p0, IGNORE, FE_INVALID); test(llrintf, 0x8000000000000000.0p0f, IGNORE, FE_INVALID); test(llrint, 0x7ffffffffffffc00.0p0, 0x7ffffffffffffc00ll, 0); test(llrintf, 0x7fffff8000000000.0p0f, 0x7fffff8000000000ll, 0); test(llrint, -0x8000000000000800.0p0, IGNORE, FE_INVALID); test(llrintf, -0x8000010000000000.0p0f, IGNORE, FE_INVALID); - test(llrint, -0x8000000000000000.0p0, -0x8000000000000000ll, 0); - test(llrintf, -0x8000000000000000.0p0f, -0x8000000000000000ll, 0); + test(llrint, -0x8000000000000000.0p0, (long long)-0x8000000000000000ull, 0); + test(llrintf, -0x8000000000000000.0p0f, (long long)-0x8000000000000000ull, 0); #else #error "Unsupported long long size" #endif } -int -main(void) +ATF_TC_WITHOUT_HEAD(lrint); +ATF_TC_BODY(lrint, tc) { - - printf("1..1\n"); - run_tests(); #ifdef __i386__ fpsetprec(FP_PE); run_tests(); #endif +} - printf("ok 1 - lrint\n"); - - return (0); +ATF_TP_ADD_TCS(tp) +{ + ATF_TP_ADD_TC(tp, lrint); + return (atf_no_error()); } diff --git a/lib/msun/tests/lround_test.c b/lib/msun/tests/lround_test.c index 2a373670f911..b2a046917c71 100644 --- a/lib/msun/tests/lround_test.c +++ b/lib/msun/tests/lround_test.c @@ -1,115 +1,126 @@ /*- * Copyright (c) 2005 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Test for lround(), lroundf(), llround(), and llroundf(). */ #include __FBSDID("$FreeBSD$"); -#include #include #include #include #include +#include "test-utils.h" + +#define IGNORE 0x12345 + /* * XXX The volatile here is to avoid gcc's bogus constant folding and work * around the lack of support for the FENV_ACCESS pragma. */ -#define test(func, x, result, excepts) do { \ - volatile double _d = x; \ - assert(feclearexcept(FE_ALL_EXCEPT) == 0); \ - assert((func)(_d) == (result) || fetestexcept(FE_INVALID)); \ - assert(fetestexcept(FE_ALL_EXCEPT) == (excepts)); \ +#define test(func, x, result, excepts) do { \ + volatile double _d = x; \ + ATF_REQUIRE_EQ(0, feclearexcept(FE_ALL_EXCEPT)); \ + volatile double _r = (func)(_d); \ + CHECK_FP_EXCEPTIONS_MSG(excepts, FE_ALL_EXCEPT, "for %s(%s)", \ + #func, #x); \ + if ((excepts & FE_INVALID) != 0) { \ + ATF_REQUIRE_EQ(result, IGNORE); \ + ATF_CHECK_EQ_MSG(FE_INVALID, fetestexcept(FE_INVALID), \ + "FE_INVALID not set correctly for %s(%s)", #func, #x); \ + } else { \ + ATF_REQUIRE_MSG(result != IGNORE, "Expected can't be IGNORE!"); \ + ATF_REQUIRE_EQ(result, (__STRING(func(_d)), _r)); \ + } \ } while (0) #define testall(x, result, excepts) do { \ test(lround, x, result, excepts); \ test(lroundf, x, result, excepts); \ test(llround, x, result, excepts); \ test(llroundf, x, result, excepts); \ } while (0) -#define IGNORE 0 - #pragma STDC FENV_ACCESS ON -int -main(int argc, char *argv[]) +ATF_TC_WITHOUT_HEAD(main); +ATF_TC_BODY(main, tc) { - - printf("1..1\n"); - + atf_tc_expect_fail("https://bugs.freebsd.org/205451"); testall(0.0, 0, 0); testall(0.25, 0, FE_INEXACT); testall(0.5, 1, FE_INEXACT); testall(-0.5, -1, FE_INEXACT); testall(1.0, 1, 0); testall(0x12345000p0, 0x12345000, 0); testall(0x1234.fp0, 0x1235, FE_INEXACT); testall(INFINITY, IGNORE, FE_INVALID); testall(NAN, IGNORE, FE_INVALID); #if (LONG_MAX == 0x7fffffffl) test(lround, 0x7fffffff.8p0, IGNORE, FE_INVALID); test(lround, -0x80000000.8p0, IGNORE, FE_INVALID); test(lround, 0x80000000.0p0, IGNORE, FE_INVALID); test(lround, 0x7fffffff.4p0, 0x7fffffffl, FE_INEXACT); test(lround, -0x80000000.4p0, -0x80000000l, FE_INEXACT); test(lroundf, 0x80000000.0p0f, IGNORE, FE_INVALID); test(lroundf, 0x7fffff80.0p0f, 0x7fffff80l, 0); #elif (LONG_MAX == 0x7fffffffffffffffll) test(lround, 0x8000000000000000.0p0, IGNORE, FE_INVALID); test(lroundf, 0x8000000000000000.0p0f, IGNORE, FE_INVALID); test(lround, 0x7ffffffffffffc00.0p0, 0x7ffffffffffffc00l, 0); test(lroundf, 0x7fffff8000000000.0p0f, 0x7fffff8000000000l, 0); test(lround, -0x8000000000000800.0p0, IGNORE, FE_INVALID); test(lroundf, -0x8000010000000000.0p0f, IGNORE, FE_INVALID); - test(lround, -0x8000000000000000.0p0, -0x8000000000000000l, 0); - test(lroundf, -0x8000000000000000.0p0f, -0x8000000000000000l, 0); + test(lround, -0x8000000000000000.0p0, (long)-0x8000000000000000l, 0); + test(lroundf, -0x8000000000000000.0p0f, (long)-0x8000000000000000l, 0); #else #error "Unsupported long size" #endif #if (LLONG_MAX == 0x7fffffffffffffffLL) test(llround, 0x8000000000000000.0p0, IGNORE, FE_INVALID); test(llroundf, 0x8000000000000000.0p0f, IGNORE, FE_INVALID); test(llround, 0x7ffffffffffffc00.0p0, 0x7ffffffffffffc00ll, 0); test(llroundf, 0x7fffff8000000000.0p0f, 0x7fffff8000000000ll, 0); test(llround, -0x8000000000000800.0p0, IGNORE, FE_INVALID); test(llroundf, -0x8000010000000000.0p0f, IGNORE, FE_INVALID); - test(llround, -0x8000000000000000.0p0, -0x8000000000000000ll, 0); - test(llroundf, -0x8000000000000000.0p0f, -0x8000000000000000ll, 0); + test(llround, -0x8000000000000000.0p0, (long long)-0x8000000000000000ll, 0); + test(llroundf, -0x8000000000000000.0p0f, (long long)-0x8000000000000000ll, 0); #else #error "Unsupported long long size" #endif +} - printf("ok 1 - lround\n"); +ATF_TP_ADD_TCS(tp) +{ + ATF_TP_ADD_TC(tp, main); - return (0); + return (atf_no_error()); } diff --git a/lib/msun/tests/lround_test.t b/lib/msun/tests/lround_test.t deleted file mode 100644 index 8bdfd03be81b..000000000000 --- a/lib/msun/tests/lround_test.t +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -# $FreeBSD$ - -cd `dirname $0` - -executable=`basename $0 .t` - -make $executable 2>&1 > /dev/null - -exec ./$executable diff --git a/lib/msun/tests/nan_test.c b/lib/msun/tests/nan_test.c index d78f6f4b9d01..8913596f6e15 100644 --- a/lib/msun/tests/nan_test.c +++ b/lib/msun/tests/nan_test.c @@ -1,122 +1,123 @@ /*- * Copyright (C) 2007 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Test for nan(), nanf(), and nanl(). We also test that strtod("nan(...)") * and sscanf("nan(...)", ...) work identically. */ #include __FBSDID("$FreeBSD$"); #include -#include #include #include #include #include #include #include #include +#include "test-utils.h" + static void testnan(const char *nan_format) { char nan_str[128]; char *end; long double ald[4]; double ad[4]; float af[4]; unsigned i; snprintf(nan_str, sizeof(nan_str), "nan(%s)", nan_format); for (i = 0; i < nitems(ad); i++) { /* * x86 has an 80-bit long double stored in 96 bits, * so we need to initialize the memory for the memcmp() * checks below to work. */ bzero(&af[i], sizeof(float)); bzero(&ad[i], sizeof(double)); bzero(&ald[i], sizeof(long double)); } af[0] = nanf(nan_format); - assert(isnan(af[0])); + ATF_REQUIRE(isnan(af[0])); af[1] = strtof(nan_str, &end); - assert(end == nan_str + strlen(nan_str)); - assert(sscanf(nan_str, "%e", &af[2]) == 1); - assert(memcmp(&af[0], &af[1], sizeof(float)) == 0); - assert(memcmp(&af[1], &af[2], sizeof(float)) == 0); + ATF_REQUIRE(end == nan_str + strlen(nan_str)); + ATF_REQUIRE(sscanf(nan_str, "%e", &af[2]) == 1); + ATF_REQUIRE(memcmp(&af[0], &af[1], sizeof(float)) == 0); + ATF_REQUIRE(memcmp(&af[1], &af[2], sizeof(float)) == 0); if (*nan_format == '\0') { /* nanf("") == strtof("nan") */ af[3] = strtof("nan", NULL); - assert(memcmp(&af[2], &af[3], sizeof(float)) == 0); + ATF_REQUIRE(memcmp(&af[2], &af[3], sizeof(float)) == 0); } ad[0] = nan(nan_format); - assert(isnan(ad[0])); + ATF_REQUIRE(isnan(ad[0])); ad[1] = strtod(nan_str, &end); - assert(end == nan_str + strlen(nan_str)); - assert(sscanf(nan_str, "%le", &ad[2]) == 1); - assert(memcmp(&ad[0], &ad[1], sizeof(double)) == 0); - assert(memcmp(&ad[1], &ad[2], sizeof(double)) == 0); + ATF_REQUIRE(end == nan_str + strlen(nan_str)); + ATF_REQUIRE(sscanf(nan_str, "%le", &ad[2]) == 1); + ATF_REQUIRE(memcmp(&ad[0], &ad[1], sizeof(double)) == 0); + ATF_REQUIRE(memcmp(&ad[1], &ad[2], sizeof(double)) == 0); if (*nan_format == '\0') { /* nan("") == strtod("nan") */ ad[3] = strtod("nan", NULL); - assert(memcmp(&ad[2], &ad[3], sizeof(double)) == 0); + ATF_REQUIRE(memcmp(&ad[2], &ad[3], sizeof(double)) == 0); } ald[0] = nanl(nan_format); - assert(isnan(ald[0])); + ATF_REQUIRE(isnan(ald[0])); ald[1] = strtold(nan_str, &end); - assert(end == nan_str + strlen(nan_str)); - assert(sscanf(nan_str, "%Le", &ald[2]) == 1); - assert(memcmp(&ald[0], &ald[1], sizeof(long double)) == 0); - assert(memcmp(&ald[1], &ald[2], sizeof(long double)) == 0); + ATF_REQUIRE(end == nan_str + strlen(nan_str)); + ATF_REQUIRE(sscanf(nan_str, "%Le", &ald[2]) == 1); + ATF_REQUIRE(memcmp(&ald[0], &ald[1], sizeof(long double)) == 0); + ATF_REQUIRE(memcmp(&ald[1], &ald[2], sizeof(long double)) == 0); if (*nan_format == '\0') { /* nanl("") == strtold("nan") */ ald[3] = strtold("nan", NULL); - assert(memcmp(&ald[2], &ald[3], sizeof(long double)) == 0); + ATF_REQUIRE(memcmp(&ald[2], &ald[3], sizeof(long double)) == 0); } } -int -main(void) +ATF_TC_WITHOUT_HEAD(nan); +ATF_TC_BODY(nan, tc) { - - printf("1..1\n"); - /* Die if a signalling NaN is returned */ feenableexcept(FE_INVALID); testnan("0x1234"); testnan(""); +} - printf("ok 1 - nan\n"); +ATF_TP_ADD_TCS(tp) +{ + ATF_TP_ADD_TC(tp, nan); - return (0); + return (atf_no_error()); } diff --git a/lib/msun/tests/nearbyint_test.c b/lib/msun/tests/nearbyint_test.c index eebe5c99a071..6bcf6694fe90 100644 --- a/lib/msun/tests/nearbyint_test.c +++ b/lib/msun/tests/nearbyint_test.c @@ -1,175 +1,171 @@ /*- * Copyright (c) 2010 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Tests for nearbyint{,f,l}() * * TODO: * - adapt tests for rint(3) * - tests for harder values (more mantissa bits than float) */ #include __FBSDID("$FreeBSD$"); #include -#include #include #include #include #include "test-utils.h" -static int testnum; - static const int rmodes[] = { FE_TONEAREST, FE_DOWNWARD, FE_UPWARD, FE_TOWARDZERO, }; /* Make sure we're testing the library, not some broken compiler built-ins. */ static double (*libnearbyint)(double) = nearbyint; static float (*libnearbyintf)(float) = nearbyintf; static long double (*libnearbyintl)(long double) = nearbyintl; #define nearbyintf libnearbyintf #define nearbyint libnearbyint #define nearbyintl libnearbyintl static const struct { float in; float out[3]; /* one answer per rounding mode except towardzero */ } tests[] = { /* input output (expected) */ { 0.0, { 0.0, 0.0, 0.0 }}, { 0.5, { 0.0, 0.0, 1.0 }}, { M_PI, { 3.0, 3.0, 4.0 }}, { 65536.5, { 65536, 65536, 65537 }}, { INFINITY, { INFINITY, INFINITY, INFINITY }}, { NAN, { NAN, NAN, NAN }}, }; /* Get the appropriate result for the current rounding mode. */ static float get_output(int testindex, int rmodeindex, int negative) { double out; if (negative) { /* swap downwards and upwards if input is negative */ if (rmodeindex == 1) rmodeindex = 2; else if (rmodeindex == 2) rmodeindex = 1; } if (rmodeindex == 3) /* FE_TOWARDZERO uses the value for downwards */ rmodeindex = 1; out = tests[testindex].out[rmodeindex]; return (negative ? -out : out); } static void test_nearby(int testindex) { float in, out; unsigned i; for (i = 0; i < sizeof(rmodes) / sizeof(rmodes[0]); i++) { - fesetround(rmodes[i]); - feclearexcept(ALL_STD_EXCEPT); + ATF_REQUIRE_EQ(0, fesetround(rmodes[i])); + ATF_REQUIRE_EQ(0, feclearexcept(ALL_STD_EXCEPT)); in = tests[testindex].in; out = get_output(testindex, i, 0); - assert(fpequal(out, libnearbyintf(in))); - assert(fpequal(out, nearbyint(in))); - assert(fpequal(out, nearbyintl(in))); - assert(fetestexcept(ALL_STD_EXCEPT) == 0); + ATF_CHECK(fpequal(out, libnearbyintf(in))); + ATF_CHECK(fpequal(out, nearbyint(in))); + ATF_CHECK(fpequal(out, nearbyintl(in))); + CHECK_FP_EXCEPTIONS(0, ALL_STD_EXCEPT); in = -tests[testindex].in; out = get_output(testindex, i, 1); - assert(fpequal(out, nearbyintf(in))); - assert(fpequal(out, nearbyint(in))); - assert(fpequal(out, nearbyintl(in))); - assert(fetestexcept(ALL_STD_EXCEPT) == 0); + ATF_CHECK(fpequal(out, nearbyintf(in))); + ATF_CHECK(fpequal(out, nearbyint(in))); + ATF_CHECK(fpequal(out, nearbyintl(in))); + CHECK_FP_EXCEPTIONS(0, ALL_STD_EXCEPT); } - - printf("ok %d\t\t# nearbyint(+%g)\n", testnum++, in); } static void test_modf(int testindex) { float in, out; float ipartf, ipart_expected; double ipart; long double ipartl; unsigned i; for (i = 0; i < sizeof(rmodes) / sizeof(rmodes[0]); i++) { - fesetround(rmodes[i]); - feclearexcept(ALL_STD_EXCEPT); + ATF_REQUIRE_EQ(0, fesetround(rmodes[i])); + ATF_REQUIRE_EQ(0, feclearexcept(ALL_STD_EXCEPT)); in = tests[testindex].in; ipart_expected = tests[testindex].out[1]; out = copysignf( isinf(ipart_expected) ? 0.0 : in - ipart_expected, in); ipartl = ipart = ipartf = 42.0; - assert(fpequal(out, modff(in, &ipartf))); - assert(fpequal(ipart_expected, ipartf)); - assert(fpequal(out, modf(in, &ipart))); - assert(fpequal(ipart_expected, ipart)); - assert(fpequal(out, modfl(in, &ipartl))); - assert(fpequal(ipart_expected, ipartl)); - assert(fetestexcept(ALL_STD_EXCEPT) == 0); + ATF_CHECK(fpequal(out, modff(in, &ipartf))); + ATF_CHECK(fpequal(ipart_expected, ipartf)); + ATF_CHECK(fpequal(out, modf(in, &ipart))); + ATF_CHECK(fpequal(ipart_expected, ipart)); + ATF_CHECK(fpequal(out, modfl(in, &ipartl))); + ATF_CHECK(fpequal(ipart_expected, ipartl)); + CHECK_FP_EXCEPTIONS(0, ALL_STD_EXCEPT); in = -in; ipart_expected = -ipart_expected; out = -out; ipartl = ipart = ipartf = 42.0; - assert(fpequal(out, modff(in, &ipartf))); - assert(fpequal(ipart_expected, ipartf)); - assert(fpequal(out, modf(in, &ipart))); - assert(fpequal(ipart_expected, ipart)); - assert(fpequal(out, modfl(in, &ipartl))); - assert(fpequal(ipart_expected, ipartl)); - assert(fetestexcept(ALL_STD_EXCEPT) == 0); + ATF_CHECK(fpequal(out, modff(in, &ipartf))); + ATF_CHECK(fpequal(ipart_expected, ipartf)); + ATF_CHECK(fpequal(out, modf(in, &ipart))); + ATF_CHECK(fpequal(ipart_expected, ipart)); + ATF_CHECK(fpequal(out, modfl(in, &ipartl))); + ATF_CHECK(fpequal(ipart_expected, ipartl)); + CHECK_FP_EXCEPTIONS(0, ALL_STD_EXCEPT); } - - printf("ok %d\t\t# modf(+%g)\n", testnum++, in); } -int -main(void) +ATF_TC_WITHOUT_HEAD(nearbyint); +ATF_TC_BODY(nearbyint, tc) { unsigned i; - printf("1..%zu\n", (size_t)(nitems(tests) * 2)); - testnum = 1; for (i = 0; i < nitems(tests); i++) { test_nearby(i); test_modf(i); } +} + +ATF_TP_ADD_TCS(tp) +{ + ATF_TP_ADD_TC(tp, nearbyint); - return (0); + return (atf_no_error()); } diff --git a/lib/msun/tests/next_test.c b/lib/msun/tests/next_test.c index 26eaacfb24c7..5801dc0e3589 100644 --- a/lib/msun/tests/next_test.c +++ b/lib/msun/tests/next_test.c @@ -1,265 +1,287 @@ /*- * Copyright (c) 2005 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Test the correctness of nextafter{,f,l} and nexttoward{,f,l}. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #ifdef __i386__ #include #endif #include "test-utils.h" #define test(exp, ans, ex) do { \ double __ans = (ans); \ feclearexcept(ALL_STD_EXCEPT); \ _testl(#exp, __LINE__, (exp), __ans, (ex)); \ } while (0) #define testf(exp, ans, ex) do { \ float __ans = (ans); \ feclearexcept(ALL_STD_EXCEPT); \ _testl(#exp, __LINE__, (exp), __ans, (ex)); \ } while (0) #define testl(exp, ans, ex) do { \ long double __ans = (ans); \ feclearexcept(ALL_STD_EXCEPT); \ _testl(#exp, __LINE__, (exp), __ans, (ex)); \ } while (0) #define testboth(arg1, arg2, ans, ex, prec) do { \ test##prec(nextafter##prec((arg1), (arg2)), (ans), (ex)); \ test##prec(nexttoward##prec((arg1), (arg2)), (ans), (ex)); \ } while (0) #define testall(arg1, arg2, ans, ex) do { \ testboth((arg1), (arg2), (ans), (ex), ); \ testboth((arg1), (arg2), (ans), (ex), f); \ testboth((arg1), (arg2), (ans), (ex), l); \ } while (0) static void _testl(const char *, int, long double, long double, int); static double idd(double); static float idf(float); -int -main(void) -{ - static const int ex_under = FE_UNDERFLOW | FE_INEXACT; /* shorthand */ - static const int ex_over = FE_OVERFLOW | FE_INEXACT; - long double ldbl_small, ldbl_eps, ldbl_max; +static const int ex_under = FE_UNDERFLOW | FE_INEXACT; /* shorthand */ +static const int ex_over = FE_OVERFLOW | FE_INEXACT; +static const long double ldbl_eps = LDBL_EPSILON; + - printf("1..5\n"); + +ATF_TC_WITHOUT_HEAD(zeros); +ATF_TC_BODY(zeros, tc) +{ + long double ldbl_small; #ifdef __i386__ fpsetprec(FP_PE); #endif /* * We can't use a compile-time constant here because gcc on * FreeBSD/i386 assumes long doubles are truncated to the * double format. */ ldbl_small = ldexpl(1.0, LDBL_MIN_EXP - LDBL_MANT_DIG); - ldbl_eps = LDBL_EPSILON; - ldbl_max = ldexpl(1.0 - ldbl_eps / 2, LDBL_MAX_EXP); /* * Special cases involving zeroes. */ #define ztest(prec) \ test##prec(copysign##prec(1.0, nextafter##prec(0.0, -0.0)), -1.0, 0); \ test##prec(copysign##prec(1.0, nextafter##prec(-0.0, 0.0)), 1.0, 0); \ test##prec(copysign##prec(1.0, nexttoward##prec(0.0, -0.0)), -1.0, 0);\ test##prec(copysign##prec(1.0, nexttoward##prec(-0.0, 0.0)), 1.0, 0) ztest(); ztest(f); ztest(l); #undef ztest #define stest(next, eps, prec) \ test##prec(next(-0.0, 42.0), eps, ex_under); \ test##prec(next(0.0, -42.0), -eps, ex_under); \ test##prec(next(0.0, INFINITY), eps, ex_under); \ test##prec(next(-0.0, -INFINITY), -eps, ex_under) stest(nextafter, 0x1p-1074, ); stest(nextafterf, 0x1p-149f, f); stest(nextafterl, ldbl_small, l); stest(nexttoward, 0x1p-1074, ); stest(nexttowardf, 0x1p-149f, f); stest(nexttowardl, ldbl_small, l); #undef stest +} - printf("ok 1 - next\n"); - +ATF_TC_WITHOUT_HEAD(eq_and_nan); +ATF_TC_BODY(eq_and_nan, tc) +{ /* * `x == y' and NaN tests */ testall(42.0, 42.0, 42.0, 0); testall(-42.0, -42.0, -42.0, 0); testall(INFINITY, INFINITY, INFINITY, 0); testall(-INFINITY, -INFINITY, -INFINITY, 0); testall(NAN, 42.0, NAN, 0); testall(42.0, NAN, NAN, 0); testall(NAN, NAN, NAN, 0); +} - printf("ok 2 - next\n"); - +ATF_TC_WITHOUT_HEAD(ordinary); +ATF_TC_BODY(ordinary, tc) +{ /* * Tests where x is an ordinary normalized number */ testboth(1.0, 2.0, 1.0 + DBL_EPSILON, 0, ); - testboth(1.0, -INFINITY, 1.0 - DBL_EPSILON/2, 0, ); + testboth(1.0, -INFINITY, 1.0 - DBL_EPSILON / 2, 0, ); testboth(1.0, 2.0, 1.0 + FLT_EPSILON, 0, f); - testboth(1.0, -INFINITY, 1.0 - FLT_EPSILON/2, 0, f); + testboth(1.0, -INFINITY, 1.0 - FLT_EPSILON / 2, 0, f); testboth(1.0, 2.0, 1.0 + ldbl_eps, 0, l); - testboth(1.0, -INFINITY, 1.0 - ldbl_eps/2, 0, l); + testboth(1.0, -INFINITY, 1.0 - ldbl_eps / 2, 0, l); - testboth(-1.0, 2.0, -1.0 + DBL_EPSILON/2, 0, ); + testboth(-1.0, 2.0, -1.0 + DBL_EPSILON / 2, 0, ); testboth(-1.0, -INFINITY, -1.0 - DBL_EPSILON, 0, ); - testboth(-1.0, 2.0, -1.0 + FLT_EPSILON/2, 0, f); + testboth(-1.0, 2.0, -1.0 + FLT_EPSILON / 2, 0, f); testboth(-1.0, -INFINITY, -1.0 - FLT_EPSILON, 0, f); - testboth(-1.0, 2.0, -1.0 + ldbl_eps/2, 0, l); + testboth(-1.0, 2.0, -1.0 + ldbl_eps / 2, 0, l); testboth(-1.0, -INFINITY, -1.0 - ldbl_eps, 0, l); /* Cases where nextafter(...) != nexttoward(...) */ test(nexttoward(1.0, 1.0 + ldbl_eps), 1.0 + DBL_EPSILON, 0); testf(nexttowardf(1.0, 1.0 + ldbl_eps), 1.0 + FLT_EPSILON, 0); testl(nexttowardl(1.0, 1.0 + ldbl_eps), 1.0 + ldbl_eps, 0); +} - printf("ok 3 - next\n"); - +ATF_TC_WITHOUT_HEAD(boundaries); +ATF_TC_BODY(boundaries, tc) +{ /* * Tests at word boundaries, normalization boundaries, etc. */ testboth(0x1.87654ffffffffp+0, INFINITY, 0x1.87655p+0, 0, ); testboth(0x1.87655p+0, -INFINITY, 0x1.87654ffffffffp+0, 0, ); testboth(0x1.fffffffffffffp+0, INFINITY, 0x1p1, 0, ); testboth(0x1p1, -INFINITY, 0x1.fffffffffffffp+0, 0, ); testboth(0x0.fffffffffffffp-1022, INFINITY, 0x1p-1022, 0, ); testboth(0x1p-1022, -INFINITY, 0x0.fffffffffffffp-1022, ex_under, ); testboth(0x1.fffffep0f, INFINITY, 0x1p1, 0, f); testboth(0x1p1, -INFINITY, 0x1.fffffep0f, 0, f); testboth(0x0.fffffep-126f, INFINITY, 0x1p-126f, 0, f); testboth(0x1p-126f, -INFINITY, 0x0.fffffep-126f, ex_under, f); #if LDBL_MANT_DIG == 53 testboth(0x1.87654ffffffffp+0L, INFINITY, 0x1.87655p+0L, 0, l); testboth(0x1.87655p+0L, -INFINITY, 0x1.87654ffffffffp+0L, 0, l); testboth(0x1.fffffffffffffp+0L, INFINITY, 0x1p1L, 0, l); testboth(0x1p1L, -INFINITY, 0x1.fffffffffffffp+0L, 0, l); testboth(0x0.fffffffffffffp-1022L, INFINITY, 0x1p-1022L, 0, l); testboth(0x1p-1022L, -INFINITY, 0x0.fffffffffffffp-1022L, ex_under, l); #elif LDBL_MANT_DIG == 64 && !defined(__i386) testboth(0x1.87654321fffffffep+0L, INFINITY, 0x1.87654322p+0L, 0, l); testboth(0x1.87654322p+0L, -INFINITY, 0x1.87654321fffffffep+0L, 0, l); testboth(0x1.fffffffffffffffep0L, INFINITY, 0x1p1L, 0, l); testboth(0x1p1L, -INFINITY, 0x1.fffffffffffffffep0L, 0, l); testboth(0x0.fffffffffffffffep-16382L, INFINITY, 0x1p-16382L, 0, l); testboth(0x1p-16382L, -INFINITY, 0x0.fffffffffffffffep-16382L, ex_under, l); #elif LDBL_MANT_DIG == 113 testboth(0x1.876543210987ffffffffffffffffp+0L, INFINITY, 0x1.876543210988p+0, 0, l); testboth(0x1.876543210988p+0L, -INFINITY, 0x1.876543210987ffffffffffffffffp+0L, 0, l); testboth(0x1.ffffffffffffffffffffffffffffp0L, INFINITY, 0x1p1L, 0, l); testboth(0x1p1L, -INFINITY, 0x1.ffffffffffffffffffffffffffffp0L, 0, l); testboth(0x0.ffffffffffffffffffffffffffffp-16382L, INFINITY, 0x1p-16382L, 0, l); testboth(0x1p-16382L, -INFINITY, 0x0.ffffffffffffffffffffffffffffp-16382L, ex_under, l); #endif +} - printf("ok 4 - next\n"); +ATF_TC_WITHOUT_HEAD(overflow); +ATF_TC_BODY(overflow, tc) +{ + long double ldbl_max; + /* + * We can't use a compile-time constant here because gcc on + * FreeBSD/i386 assumes long doubles are truncated to the + * double format. + */ + ldbl_max = ldexpl(1.0 - ldbl_eps / 2, LDBL_MAX_EXP); /* * Overflow tests */ test(idd(nextafter(DBL_MAX, INFINITY)), INFINITY, ex_over); test(idd(nextafter(INFINITY, 0.0)), DBL_MAX, 0); test(idd(nexttoward(DBL_MAX, DBL_MAX * 2.0L)), INFINITY, ex_over); #if LDBL_MANT_DIG > 53 test(idd(nexttoward(INFINITY, DBL_MAX * 2.0L)), DBL_MAX, 0); #endif testf(idf(nextafterf(FLT_MAX, INFINITY)), INFINITY, ex_over); testf(idf(nextafterf(INFINITY, 0.0)), FLT_MAX, 0); testf(idf(nexttowardf(FLT_MAX, FLT_MAX * 2.0)), INFINITY, ex_over); testf(idf(nexttowardf(INFINITY, FLT_MAX * 2.0)), FLT_MAX, 0); testboth(ldbl_max, INFINITY, INFINITY, ex_over, l); testboth(INFINITY, 0.0, ldbl_max, 0, l); - - printf("ok 5 - next\n"); - - return (0); } static void _testl(const char *exp, int line, long double actual, long double expected, int except) { int actual_except; actual_except = fetestexcept(ALL_STD_EXCEPT); if (!fpequal(actual, expected)) { - fprintf(stderr, "%d: %s returned %La, expecting %La\n", - line, exp, actual, expected); - abort(); + atf_tc_fail_check(__FILE__, line, + "%s returned %La, expecting %La\n", exp, actual, expected); } if (actual_except != except) { - fprintf(stderr, "%d: %s raised 0x%x, expecting 0x%x\n", - line, exp, actual_except, except); - abort(); + atf_tc_fail_check(__FILE__, line, + "%s raised 0x%x, expecting 0x%x\n", exp, actual_except, + except); } } /* * The idd() and idf() routines ensure that doubles and floats are * converted to their respective types instead of stored in the FPU * with extra precision. */ static double idd(double x) { return (x); } static float idf(float x) { return (x); } + +ATF_TP_ADD_TCS(tp) +{ + ATF_TP_ADD_TC(tp, zeros); + ATF_TP_ADD_TC(tp, ordinary); + ATF_TP_ADD_TC(tp, eq_and_nan); + ATF_TP_ADD_TC(tp, boundaries); + ATF_TP_ADD_TC(tp, overflow); + + return (atf_no_error()); +} diff --git a/lib/msun/tests/rem_test.c b/lib/msun/tests/rem_test.c index f652ada07d6b..96c3822aba9d 100644 --- a/lib/msun/tests/rem_test.c +++ b/lib/msun/tests/rem_test.c @@ -1,207 +1,214 @@ /*- * Copyright (c) 2005-2008 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Test for remainder functions: remainder, remainderf, remainderl, * remquo, remquof, and remquol. * Missing tests: fmod, fmodf. */ #include __FBSDID("$FreeBSD$"); -#include #include #include #include #include #include +#include "test-utils.h" + static void test_invalid(long double, long double); static void testl(long double, long double, long double, int); static void testd(double, double, double, int); static void testf(float, float, float, int); #define test(x, y, e_r, e_q) do { \ testl(x, y, e_r, e_q); \ testd(x, y, e_r, e_q); \ testf(x, y, e_r, e_q); \ } while (0) -int -main(void) +ATF_TC_WITHOUT_HEAD(rem1); +ATF_TC_BODY(rem1, tc) { - - printf("1..3\n"); - test_invalid(0.0, 0.0); test_invalid(1.0, 0.0); test_invalid(INFINITY, 0.0); test_invalid(INFINITY, 1.0); test_invalid(-INFINITY, 1.0); test_invalid(NAN, 1.0); test_invalid(1.0, NAN); test(4, 4, 0, 1); test(0, 3.0, 0, 0); testd(0x1p-1074, 1, 0x1p-1074, 0); testf(0x1p-149, 1, 0x1p-149, 0); test(3.0, 4, -1, 1); test(3.0, -4, -1, -1); testd(275 * 1193040, 275, 0, 1193040); - test(4.5 * 7.5, 4.5, -2.25, 8); /* we should get the even one */ + test(4.5 * 7.5, 4.5, -2.25, 8); /* we should get the even one */ testf(0x1.9044f6p-1, 0x1.ce662ep-1, -0x1.f109cp-4, 1); #if LDBL_MANT_DIG > 53 testl(-0x1.23456789abcdefp-2000L, 0x1.fedcba987654321p-2000L, - 0x1.b72ea61d950c862p-2001L, -1); + 0x1.b72ea61d950c862p-2001L, -1); #endif +} - printf("ok 1 - rem\n"); - +ATF_TC_WITHOUT_HEAD(rem2); +ATF_TC_BODY(rem2, tc) +{ /* * The actual quotient here is 864062210.50000003..., but * double-precision division gets -8.64062210.5, which rounds * the wrong way. This test ensures that remquo() is smart * enough to get the low-order bit right. */ testd(-0x1.98260f22fc6dep-302, 0x1.fb3167c430a13p-332, 0x1.fb3165b82de72p-333, -864062211); /* Even harder cases with greater exponent separation */ test(0x1.fp100, 0x1.ep-40, -0x1.cp-41, 143165577); - testd(-0x1.abcdefp120, 0x1.87654321p-120, - -0x1.69c78ec4p-121, -63816414); - - printf("ok 2 - rem\n"); + testd(-0x1.abcdefp120, 0x1.87654321p-120, -0x1.69c78ec4p-121, + -63816414); +} +ATF_TC_WITHOUT_HEAD(rem3); +ATF_TC_BODY(rem3, tc) +{ test(0x1.66666cp+120, 0x1p+71, 0.0, 1476395008); testd(-0x1.0000000000003p+0, 0x1.0000000000003p+0, -0.0, -1); testl(-0x1.0000000000003p+0, 0x1.0000000000003p+0, -0.0, -1); testd(-0x1.0000000000001p-749, 0x1.4p-1072, 0x1p-1074, -1288490189); testl(-0x1.0000000000001p-749, 0x1.4p-1072, 0x1p-1074, -1288490189); - - printf("ok 3 - rem\n"); - - return (0); } static void test_invalid(long double x, long double y) { int q; q = 0xdeadbeef; - assert(isnan(remainder(x, y))); - assert(isnan(remquo(x, y, &q))); + ATF_CHECK(isnan(remainder(x, y))); + ATF_CHECK(isnan(remquo(x, y, &q))); #ifdef STRICT - assert(q == 0xdeadbeef); + ATF_CHECK(q == 0xdeadbeef); #endif - assert(isnan(remainderf(x, y))); - assert(isnan(remquof(x, y, &q))); + ATF_CHECK(isnan(remainderf(x, y))); + ATF_CHECK(isnan(remquof(x, y, &q))); #ifdef STRICT - assert(q == 0xdeadbeef); + ATF_CHECK(q == 0xdeadbeef); #endif - assert(isnan(remainderl(x, y))); - assert(isnan(remquol(x, y, &q))); + ATF_CHECK(isnan(remainderl(x, y))); + ATF_CHECK(isnan(remquol(x, y, &q))); #ifdef STRICT - assert(q == 0xdeadbeef); + ATF_CHECK(q == 0xdeadbeef); #endif } /* 0x012345 ==> 0x01ffff */ static inline int mask(int x) { return ((unsigned)~0 >> (32 - fls(x))); } static void testl(long double x, long double y, long double expected_rem, int expected_quo) { int q; long double rem; q = random(); rem = remainderl(x, y); - assert(rem == expected_rem); - assert(!signbit(rem) == !signbit(expected_rem)); + ATF_CHECK(rem == expected_rem); + ATF_CHECK(!signbit(rem) == !signbit(expected_rem)); rem = remquol(x, y, &q); - assert(rem == expected_rem); - assert(!signbit(rem) == !signbit(expected_rem)); - assert((q ^ expected_quo) >= 0); /* sign(q) == sign(expected_quo) */ - assert((q & 0x7) == (expected_quo & 0x7)); + ATF_CHECK(rem == expected_rem); + ATF_CHECK(!signbit(rem) == !signbit(expected_rem)); + ATF_CHECK((q ^ expected_quo) >= 0); /* sign(q) == sign(expected_quo) */ + ATF_CHECK((q & 0x7) == (expected_quo & 0x7)); if (q != 0) { - assert((q > 0) ^ !(expected_quo > 0)); + ATF_CHECK((q > 0) ^ !(expected_quo > 0)); q = abs(q); - assert(q == (abs(expected_quo) & mask(q))); + ATF_CHECK(q == (abs(expected_quo) & mask(q))); } } static void testd(double x, double y, double expected_rem, int expected_quo) { int q; double rem; q = random(); rem = remainder(x, y); - assert(rem == expected_rem); - assert(!signbit(rem) == !signbit(expected_rem)); + ATF_CHECK(rem == expected_rem); + ATF_CHECK(!signbit(rem) == !signbit(expected_rem)); rem = remquo(x, y, &q); - assert(rem == expected_rem); - assert(!signbit(rem) == !signbit(expected_rem)); - assert((q ^ expected_quo) >= 0); /* sign(q) == sign(expected_quo) */ - assert((q & 0x7) == (expected_quo & 0x7)); + ATF_CHECK(rem == expected_rem); + ATF_CHECK(!signbit(rem) == !signbit(expected_rem)); + ATF_CHECK((q ^ expected_quo) >= 0); /* sign(q) == sign(expected_quo) */ + ATF_CHECK((q & 0x7) == (expected_quo & 0x7)); if (q != 0) { - assert((q > 0) ^ !(expected_quo > 0)); + ATF_CHECK((q > 0) ^ !(expected_quo > 0)); q = abs(q); - assert(q == (abs(expected_quo) & mask(q))); + ATF_CHECK(q == (abs(expected_quo) & mask(q))); } } static void testf(float x, float y, float expected_rem, int expected_quo) { int q; float rem; q = random(); rem = remainderf(x, y); - assert(rem == expected_rem); - assert(!signbit(rem) == !signbit(expected_rem)); + ATF_CHECK(rem == expected_rem); + ATF_CHECK(!signbit(rem) == !signbit(expected_rem)); rem = remquof(x, y, &q); - assert(rem == expected_rem); - assert(!signbit(rem) == !signbit(expected_rem)); - assert((q ^ expected_quo) >= 0); /* sign(q) == sign(expected_quo) */ - assert((q & 0x7) == (expected_quo & 0x7)); + ATF_CHECK(rem == expected_rem); + ATF_CHECK(!signbit(rem) == !signbit(expected_rem)); + ATF_CHECK((q ^ expected_quo) >= 0); /* sign(q) == sign(expected_quo) */ + ATF_CHECK((q & 0x7) == (expected_quo & 0x7)); if (q != 0) { - assert((q > 0) ^ !(expected_quo > 0)); + ATF_CHECK((q > 0) ^ !(expected_quo > 0)); q = abs(q); - assert((q & mask(q)) == (abs(expected_quo) & mask(q))); + ATF_CHECK((q & mask(q)) == (abs(expected_quo) & mask(q))); } } + +ATF_TP_ADD_TCS(tp) +{ + ATF_TP_ADD_TC(tp, rem1); + ATF_TP_ADD_TC(tp, rem2); + ATF_TP_ADD_TC(tp, rem3); + + return (atf_no_error()); +} diff --git a/lib/msun/tests/test-utils.h b/lib/msun/tests/test-utils.h index 023a8f84fb1d..a20e30a2440a 100644 --- a/lib/msun/tests/test-utils.h +++ b/lib/msun/tests/test-utils.h @@ -1,182 +1,193 @@ /*- * Copyright (c) 2005-2013 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #ifndef _TEST_UTILS_H_ #define _TEST_UTILS_H_ #include #include +#include + /* * Implementations are permitted to define additional exception flags * not specified in the standard, so it is not necessarily true that * FE_ALL_EXCEPT == ALL_STD_EXCEPT. */ #define ALL_STD_EXCEPT (FE_DIVBYZERO | FE_INEXACT | FE_INVALID | \ FE_OVERFLOW | FE_UNDERFLOW) #define OPT_INVALID (ALL_STD_EXCEPT & ~FE_INVALID) #define OPT_INEXACT (ALL_STD_EXCEPT & ~FE_INEXACT) #define FLT_ULP() ldexpl(1.0, 1 - FLT_MANT_DIG) #define DBL_ULP() ldexpl(1.0, 1 - DBL_MANT_DIG) #define LDBL_ULP() ldexpl(1.0, 1 - LDBL_MANT_DIG) /* * Flags that control the behavior of various fpequal* functions. * XXX This is messy due to merging various notions of "close enough" * that are best suited for different functions. * * CS_REAL * CS_IMAG * CS_BOTH * (cfpequal_cs, fpequal_tol, cfpequal_tol) Whether to check the sign of * the real part of the result, the imaginary part, or both. * * FPE_ABS_ZERO * (fpequal_tol, cfpequal_tol) If set, treats the tolerance as an absolute * tolerance when the expected value is 0. This is useful when there is * round-off error in the input, e.g., cos(Pi/2) ~= 0. */ #define CS_REAL 0x01 #define CS_IMAG 0x02 #define CS_BOTH (CS_REAL | CS_IMAG) #define FPE_ABS_ZERO 0x04 #ifdef DEBUG #define debug(...) printf(__VA_ARGS__) #else #define debug(...) (void)0 #endif /* * XXX The ancient version of gcc in the base system doesn't support CMPLXL, * but we can fake it most of the time. */ #ifndef CMPLXL static inline long double complex CMPLXL(long double x, long double y) { long double complex z; __real__ z = x; __imag__ z = y; return (z); } #endif static int fpequal(long double, long double) __used; static int cfpequal(long double complex, long double complex) __used; static int cfpequal_cs(long double complex, long double complex, int) __used; static int cfpequal_tol(long double complex, long double complex, long double, unsigned int) __used; /* * Compare d1 and d2 using special rules: NaN == NaN and +0 != -0. * Fail an assertion if they differ. */ static int fpequal(long double d1, long double d2) { if (d1 != d2) return (isnan(d1) && isnan(d2)); return (copysignl(1.0, d1) == copysignl(1.0, d2)); } /* * Determine whether x and y are equal, with two special rules: * +0.0 != -0.0 * NaN == NaN * If checksign is 0, we compare the absolute values instead. */ static int fpequal_cs(long double x, long double y, int checksign) { if (isnan(x) && isnan(y)) return (1); if (checksign) return (x == y && !signbit(x) == !signbit(y)); else return (fabsl(x) == fabsl(y)); } static int fpequal_tol(long double x, long double y, long double tol, unsigned int flags) { fenv_t env; int ret; if (isnan(x) && isnan(y)) return (1); if (!signbit(x) != !signbit(y) && (flags & CS_BOTH)) return (0); if (x == y) return (1); if (tol == 0) return (0); /* Hard case: need to check the tolerance. */ feholdexcept(&env); /* * For our purposes here, if y=0, we interpret tol as an absolute * tolerance. This is to account for roundoff in the input, e.g., * cos(Pi/2) ~= 0. */ if ((flags & FPE_ABS_ZERO) && y == 0.0) ret = fabsl(x - y) <= fabsl(tol); else ret = fabsl(x - y) <= fabsl(y * tol); fesetenv(&env); return (ret); } static int cfpequal(long double complex d1, long double complex d2) { return (fpequal(creall(d1), creall(d2)) && fpequal(cimagl(d1), cimagl(d2))); } static int cfpequal_cs(long double complex x, long double complex y, int checksign) { return (fpequal_cs(creal(x), creal(y), checksign) && fpequal_cs(cimag(x), cimag(y), checksign)); } static int cfpequal_tol(long double complex x, long double complex y, long double tol, unsigned int flags) { return (fpequal_tol(creal(x), creal(y), tol, flags) && fpequal_tol(cimag(x), cimag(y), tol, flags)); } +#define CHECK_FP_EXCEPTIONS(excepts, exceptmask) \ + ATF_CHECK_EQ_MSG((excepts), fetestexcept(exceptmask), \ + "unexpected exception flags: %#x not %#x", \ + fetestexcept(exceptmask), (excepts)) +#define CHECK_FP_EXCEPTIONS_MSG(excepts, exceptmask, fmt, ...) \ + ATF_CHECK_EQ_MSG((excepts), fetestexcept(exceptmask), \ + "unexpected exception flags: got %#x not %#x " fmt, \ + fetestexcept(exceptmask), (excepts), __VA_ARGS__) + #endif /* _TEST_UTILS_H_ */ diff --git a/lib/msun/tests/trig_test.c b/lib/msun/tests/trig_test.c index b725b0b9eb55..55fd97ef4eef 100644 --- a/lib/msun/tests/trig_test.c +++ b/lib/msun/tests/trig_test.c @@ -1,285 +1,283 @@ /*- * Copyright (c) 2008 David Schultz * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Tests for corner cases in trigonometric functions. Some accuracy tests * are included as well, but these are very basic sanity checks, not * intended to be comprehensive. * * The program for generating representable numbers near multiples of pi is * available at http://www.cs.berkeley.edu/~wkahan/testpi/ . */ #include __FBSDID("$FreeBSD$"); #include -#include #include #include #include #include -#include - #include "test-utils.h" #pragma STDC FENV_ACCESS ON /* * Test that a function returns the correct value and sets the * exception flags correctly. The exceptmask specifies which * exceptions we should check. We need to be lenient for several * reasons, but mainly because on some architectures it's impossible * to raise FE_OVERFLOW without raising FE_INEXACT. * * These are macros instead of functions so that assert provides more * meaningful error messages. * * XXX The volatile here is to avoid gcc's bogus constant folding and work * around the lack of support for the FENV_ACCESS pragma. */ #define test(func, x, result, exceptmask, excepts) do { \ volatile long double _d = x; \ ATF_CHECK(feclearexcept(FE_ALL_EXCEPT) == 0); \ - ATF_CHECK(fpequal((func)(_d), (result))); \ - ATF_CHECK(((void)(func), fetestexcept(exceptmask) == (excepts))); \ + ATF_CHECK(fpequal((func)(_d), (result))); \ + CHECK_FP_EXCEPTIONS_MSG(excepts, exceptmask, "for %s(%s)", \ + #func, #x); \ } while (0) #define testall(prefix, x, result, exceptmask, excepts) do { \ test(prefix, x, (double)result, exceptmask, excepts); \ test(prefix##f, x, (float)result, exceptmask, excepts); \ test(prefix##l, x, result, exceptmask, excepts); \ } while (0) #define testdf(prefix, x, result, exceptmask, excepts) do { \ test(prefix, x, (double)result, exceptmask, excepts); \ test(prefix##f, x, (float)result, exceptmask, excepts); \ } while (0) ATF_TC(special); ATF_TC_HEAD(special, tc) { atf_tc_set_md_var(tc, "descr", "test special cases in sin(), cos(), and tan()"); } ATF_TC_BODY(special, tc) { /* Values at 0 should be exact. */ testall(tan, 0.0, 0.0, ALL_STD_EXCEPT, 0); testall(tan, -0.0, -0.0, ALL_STD_EXCEPT, 0); testall(cos, 0.0, 1.0, ALL_STD_EXCEPT, 0); testall(cos, -0.0, 1.0, ALL_STD_EXCEPT, 0); testall(sin, 0.0, 0.0, ALL_STD_EXCEPT, 0); testall(sin, -0.0, -0.0, ALL_STD_EXCEPT, 0); /* func(+-Inf) == NaN */ testall(tan, INFINITY, NAN, ALL_STD_EXCEPT, FE_INVALID); testall(sin, INFINITY, NAN, ALL_STD_EXCEPT, FE_INVALID); testall(cos, INFINITY, NAN, ALL_STD_EXCEPT, FE_INVALID); testall(tan, -INFINITY, NAN, ALL_STD_EXCEPT, FE_INVALID); testall(sin, -INFINITY, NAN, ALL_STD_EXCEPT, FE_INVALID); testall(cos, -INFINITY, NAN, ALL_STD_EXCEPT, FE_INVALID); /* func(NaN) == NaN */ testall(tan, NAN, NAN, ALL_STD_EXCEPT, 0); testall(sin, NAN, NAN, ALL_STD_EXCEPT, 0); testall(cos, NAN, NAN, ALL_STD_EXCEPT, 0); } #ifndef __i386__ ATF_TC(reduction); ATF_TC_HEAD(reduction, tc) { atf_tc_set_md_var(tc, "descr", "tests to ensure argument reduction for large arguments is accurate"); } ATF_TC_BODY(reduction, tc) { /* floats very close to odd multiples of pi */ static const float f_pi_odd[] = { 85563208.0f, 43998769152.0f, 9.2763667655669323e+25f, 1.5458357838905804e+29f, }; /* doubles very close to odd multiples of pi */ static const double d_pi_odd[] = { 3.1415926535897931, 91.106186954104004, 642615.9188844458, 3397346.5699258847, 6134899525417045.0, 3.0213551960457761e+43, 1.2646209897993783e+295, 6.2083625380677099e+307, }; /* long doubles very close to odd multiples of pi */ #if LDBL_MANT_DIG == 64 static const long double ld_pi_odd[] = { 1.1891886960373841596e+101L, 1.07999475322710967206e+2087L, 6.522151627890431836e+2147L, 8.9368974898260328229e+2484L, 9.2961044110572205863e+2555L, 4.90208421886578286e+3189L, 1.5275546401232615884e+3317L, 1.7227465626338900093e+3565L, 2.4160090594000745334e+3808L, 9.8477555741888350649e+4314L, 1.6061597222105160737e+4326L, }; #endif unsigned i; #if defined(__amd64__) && defined(__clang__) && __clang_major__ >= 7 && \ __clang_major__ < 10 && __FreeBSD_cc_version < 1300002 atf_tc_expect_fail("test fails with clang 7-9 - bug 234040"); #endif for (i = 0; i < nitems(f_pi_odd); i++) { ATF_CHECK(fabs(sinf(f_pi_odd[i])) < FLT_EPSILON); ATF_CHECK(cosf(f_pi_odd[i]) == -1.0); ATF_CHECK(fabs(tan(f_pi_odd[i])) < FLT_EPSILON); ATF_CHECK(fabs(sinf(-f_pi_odd[i])) < FLT_EPSILON); ATF_CHECK(cosf(-f_pi_odd[i]) == -1.0); ATF_CHECK(fabs(tanf(-f_pi_odd[i])) < FLT_EPSILON); ATF_CHECK(fabs(sinf(f_pi_odd[i] * 2)) < FLT_EPSILON); ATF_CHECK(cosf(f_pi_odd[i] * 2) == 1.0); ATF_CHECK(fabs(tanf(f_pi_odd[i] * 2)) < FLT_EPSILON); ATF_CHECK(fabs(sinf(-f_pi_odd[i] * 2)) < FLT_EPSILON); ATF_CHECK(cosf(-f_pi_odd[i] * 2) == 1.0); ATF_CHECK(fabs(tanf(-f_pi_odd[i] * 2)) < FLT_EPSILON); } for (i = 0; i < nitems(d_pi_odd); i++) { ATF_CHECK(fabs(sin(d_pi_odd[i])) < 2 * DBL_EPSILON); ATF_CHECK(cos(d_pi_odd[i]) == -1.0); ATF_CHECK(fabs(tan(d_pi_odd[i])) < 2 * DBL_EPSILON); ATF_CHECK(fabs(sin(-d_pi_odd[i])) < 2 * DBL_EPSILON); ATF_CHECK(cos(-d_pi_odd[i]) == -1.0); ATF_CHECK(fabs(tan(-d_pi_odd[i])) < 2 * DBL_EPSILON); ATF_CHECK(fabs(sin(d_pi_odd[i] * 2)) < 2 * DBL_EPSILON); ATF_CHECK(cos(d_pi_odd[i] * 2) == 1.0); ATF_CHECK(fabs(tan(d_pi_odd[i] * 2)) < 2 * DBL_EPSILON); ATF_CHECK(fabs(sin(-d_pi_odd[i] * 2)) < 2 * DBL_EPSILON); ATF_CHECK(cos(-d_pi_odd[i] * 2) == 1.0); ATF_CHECK(fabs(tan(-d_pi_odd[i] * 2)) < 2 * DBL_EPSILON); } #if LDBL_MANT_DIG == 64 /* XXX: || LDBL_MANT_DIG == 113 */ for (i = 0; i < nitems(ld_pi_odd); i++) { ATF_CHECK(fabsl(sinl(ld_pi_odd[i])) < LDBL_EPSILON); ATF_CHECK(cosl(ld_pi_odd[i]) == -1.0); ATF_CHECK(fabsl(tanl(ld_pi_odd[i])) < LDBL_EPSILON); ATF_CHECK(fabsl(sinl(-ld_pi_odd[i])) < LDBL_EPSILON); ATF_CHECK(cosl(-ld_pi_odd[i]) == -1.0); ATF_CHECK(fabsl(tanl(-ld_pi_odd[i])) < LDBL_EPSILON); ATF_CHECK(fabsl(sinl(ld_pi_odd[i] * 2)) < LDBL_EPSILON); ATF_CHECK(cosl(ld_pi_odd[i] * 2) == 1.0); ATF_CHECK(fabsl(tanl(ld_pi_odd[i] * 2)) < LDBL_EPSILON); ATF_CHECK(fabsl(sinl(-ld_pi_odd[i] * 2)) < LDBL_EPSILON); ATF_CHECK(cosl(-ld_pi_odd[i] * 2) == 1.0); ATF_CHECK(fabsl(tanl(-ld_pi_odd[i] * 2)) < LDBL_EPSILON); } #endif } ATF_TC(accuracy); ATF_TC_HEAD(accuracy, tc) { atf_tc_set_md_var(tc, "descr", "tests the accuracy of these functions over the primary range"); } ATF_TC_BODY(accuracy, tc) { /* For small args, sin(x) = tan(x) = x, and cos(x) = 1. */ testall(sin, 0xd.50ee515fe4aea16p-114L, 0xd.50ee515fe4aea16p-114L, ALL_STD_EXCEPT, FE_INEXACT); testall(tan, 0xd.50ee515fe4aea16p-114L, 0xd.50ee515fe4aea16p-114L, ALL_STD_EXCEPT, FE_INEXACT); testall(cos, 0xd.50ee515fe4aea16p-114L, 1.0, ALL_STD_EXCEPT, FE_INEXACT); /* * These tests should pass for f32, d64, and ld80 as long as * the error is <= 0.75 ulp (round to nearest) */ #if LDBL_MANT_DIG <= 64 #define testacc testall #else #define testacc testdf #endif testacc(sin, 0.17255452780841205174L, 0.17169949801444412683L, ALL_STD_EXCEPT, FE_INEXACT); testacc(sin, -0.75431944555904520893L, -0.68479288156557286353L, ALL_STD_EXCEPT, FE_INEXACT); testacc(cos, 0.70556358769838947292L, 0.76124620693117771850L, ALL_STD_EXCEPT, FE_INEXACT); testacc(cos, -0.34061437849088045332L, 0.94254960031831729956L, ALL_STD_EXCEPT, FE_INEXACT); testacc(tan, -0.15862817413325692897L, -0.15997221861309522115L, ALL_STD_EXCEPT, FE_INEXACT); testacc(tan, 0.38374784931303813530L, 0.40376500259976759951L, ALL_STD_EXCEPT, FE_INEXACT); /* * XXX missing: * - tests for ld128 * - tests for other rounding modes (probably won't pass for now) * - tests for large numbers that get reduced to hi+lo with lo!=0 */ } #endif ATF_TP_ADD_TCS(tp) { ATF_TP_ADD_TC(tp, special); #ifndef __i386__ ATF_TP_ADD_TC(tp, accuracy); ATF_TP_ADD_TC(tp, reduction); #endif return (atf_no_error()); }