Module Name: src Committed By: pgoyette Date: Sun Jan 2 03:51:21 UTC 2011
Modified Files: src/tests/lib/libc: Makefile Added Files: src/tests/lib/libc/ieeefp: Makefile Makefile.inc t_except.c t_nan_inf.c t_round.c t_subnormal.c Log Message: Atf-ify several of the ieeefp tests. Note that t_round is currently mostly disabled, due to PR/44293. Also, testfloat has not been converted. To generate a diff of this commit: cvs rdiff -u -r1.15 -r1.16 src/tests/lib/libc/Makefile cvs rdiff -u -r0 -r1.1 src/tests/lib/libc/ieeefp/Makefile \ src/tests/lib/libc/ieeefp/Makefile.inc \ src/tests/lib/libc/ieeefp/t_except.c \ src/tests/lib/libc/ieeefp/t_nan_inf.c src/tests/lib/libc/ieeefp/t_round.c \ src/tests/lib/libc/ieeefp/t_subnormal.c Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.
Modified files: Index: src/tests/lib/libc/Makefile diff -u src/tests/lib/libc/Makefile:1.15 src/tests/lib/libc/Makefile:1.16 --- src/tests/lib/libc/Makefile:1.15 Fri Dec 31 14:36:11 2010 +++ src/tests/lib/libc/Makefile Sun Jan 2 03:51:20 2011 @@ -1,10 +1,14 @@ -# $NetBSD: Makefile,v 1.15 2010/12/31 14:36:11 pgoyette Exp $ +# $NetBSD: Makefile,v 1.16 2011/01/02 03:51:20 pgoyette Exp $ .include <bsd.own.mk> .include <bsd.sys.mk> TESTS_SUBDIRS+= gen hash setjmp stdlib stdio string +.if ${MACHINE_ARCH} != "vax" && ${MACHINE_ARCH} != "m68000" +TESTS_SUBDIRS+= ieeefp +.endif + .if ${HAS_SSP} == "yes" TESTS_SUBDIRS+= ssp .endif Added files: Index: src/tests/lib/libc/ieeefp/Makefile diff -u /dev/null src/tests/lib/libc/ieeefp/Makefile:1.1 --- /dev/null Sun Jan 2 03:51:21 2011 +++ src/tests/lib/libc/ieeefp/Makefile Sun Jan 2 03:51:21 2011 @@ -0,0 +1,14 @@ +# $NetBSD: Makefile,v 1.1 2011/01/02 03:51:21 pgoyette Exp $ + +.include <bsd.own.mk> + +TESTSDIR= ${TESTSBASE}/lib/libc/ieeefp + +TESTS_C+= t_except +TESTS_C+= t_nan_inf +TESTS_C+= t_round +TESTS_C+= t_subnormal + +LDADD.t_subnormal+=-lm + +.include <bsd.test.mk> Index: src/tests/lib/libc/ieeefp/Makefile.inc diff -u /dev/null src/tests/lib/libc/ieeefp/Makefile.inc:1.1 --- /dev/null Sun Jan 2 03:51:21 2011 +++ src/tests/lib/libc/ieeefp/Makefile.inc Sun Jan 2 03:51:21 2011 @@ -0,0 +1,6 @@ +# $NetBSD: Makefile.inc,v 1.1 2011/01/02 03:51:21 pgoyette Exp $ +# + +.if ${MACHINE_ARCH} == "alpha" +COPTS+= -mieee +.endif Index: src/tests/lib/libc/ieeefp/t_except.c diff -u /dev/null src/tests/lib/libc/ieeefp/t_except.c:1.1 --- /dev/null Sun Jan 2 03:51:21 2011 +++ src/tests/lib/libc/ieeefp/t_except.c Sun Jan 2 03:51:21 2011 @@ -0,0 +1,312 @@ +/* $NetBSD: t_except.c,v 1.1 2011/01/02 03:51:21 pgoyette Exp $ */ + +/*- + * Copyright (c) 1995 The NetBSD Foundation, Inc. + * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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. + */ + +#include <atf-c.h> +#include <atf-c/config.h> + +#include <stdio.h> +#include <signal.h> +#include <assert.h> +#include <ieeefp.h> +#include <float.h> +#include <setjmp.h> +#include <stdlib.h> +#include <string.h> + +void sigfpe(int, siginfo_t *, void *); +volatile sig_atomic_t signal_caught; +volatile int sicode; + +#ifdef USE_FLOAT +#define FPTYPE float +#else +#ifdef USE_LONGDOUBLE +#define FPTYPE long double +#else +#define FPTYPE double +#endif +#endif +static volatile const float f_one = 1.0; +static volatile const float f_zero = 0.0; +static volatile const double d_one = 1.0; +static volatile const double d_zero = 0.0; +static volatile const long double ld_one = 1.0; +static volatile const long double ld_zero = 0.0; + +static volatile const float f_huge = FLT_MAX; +static volatile const float f_tiny = FLT_MIN; +static volatile const double d_huge = DBL_MAX; +static volatile const double d_tiny = DBL_MIN; +static volatile const long double ld_huge = LDBL_MAX; +static volatile const long double ld_tiny = LDBL_MIN; + +static volatile float f_x; +static volatile double d_x; +static volatile long double ld_x; + +/* trip divide by zero */ +static void +f_dz(void) +{ + + f_x = f_one / f_zero; +} + +static void +d_dz(void) +{ + + d_x = d_one / d_zero; +} + +static void +ld_dz(void) +{ + + ld_x = ld_one / ld_zero; +} + +/* trip invalid operation */ +static void +d_inv(void) +{ + + d_x = d_zero / d_zero; +} + +static void +ld_inv(void) +{ + + ld_x = ld_zero / ld_zero; +} + +static void +f_inv(void) +{ + + f_x = f_zero / f_zero; +} + +/* trip overflow */ +static void +f_ofl(void) +{ + + f_x = f_huge * f_huge; +} + +static void +d_ofl(void) +{ + + d_x = d_huge * d_huge; +} + +static void +ld_ofl(void) +{ + + ld_x = ld_huge * ld_huge; +} + +/* trip underflow */ +static void +f_ufl(void) +{ + + f_x = f_tiny * f_tiny; +} + +static void +d_ufl(void) +{ + + d_x = d_tiny * d_tiny; +} + +static void +ld_ufl(void) +{ + + ld_x = ld_tiny * ld_tiny; +} + +struct ops { + void (*op)(void); + fp_except mask; + int sicode; +}; + +static struct ops float_ops[] = { + { f_dz, FP_X_DZ, FPE_FLTDIV }, + { f_inv, FP_X_INV, FPE_FLTINV }, + { f_ofl, FP_X_OFL, FPE_FLTOVF }, + { f_ufl, FP_X_UFL, FPE_FLTUND }, + { NULL, 0, 0 } +}; + +static struct ops double_ops[] = { + { d_dz, FP_X_DZ, FPE_FLTDIV }, + { d_inv, FP_X_INV, FPE_FLTINV }, + { d_ofl, FP_X_OFL, FPE_FLTOVF }, + { d_ufl, FP_X_UFL, FPE_FLTUND }, + { NULL, 0, 0 } +}; + +static struct ops long_double_ops[] = { + { ld_dz, FP_X_DZ, FPE_FLTDIV }, + { ld_inv, FP_X_INV, FPE_FLTINV }, + { ld_ofl, FP_X_OFL, FPE_FLTOVF }, + { ld_ufl, FP_X_UFL, FPE_FLTUND }, + { NULL, 0, 0 } +}; + +static sigjmp_buf b; + +static void +masked(struct ops *test_ops) +{ + struct sigaction sa; + fp_except ex1, ex2; + + /* mask all exceptions, clear history */ + fpsetmask(0); + fpsetsticky(0); + + /* set up signal handler */ + sa.sa_sigaction = sigfpe; + sigemptyset(&sa.sa_mask); + sa.sa_flags = SA_SIGINFO; + sigaction(SIGFPE, &sa, 0); + signal_caught = 0; + + /* + * exceptions masked, check whether "sticky" bits are set correctly + */ + while (test_ops->op != NULL) { + (*test_ops->op)(); + ex1 = fpgetsticky(); + ATF_CHECK_EQ(ex1 & test_ops->mask, test_ops->mask); + ATF_CHECK_EQ(signal_caught, 0); + + /* check correct fpsetsticky() behaviour */ + ex2 = fpsetsticky(0); + ATF_CHECK_EQ(fpgetsticky(), 0); + ATF_CHECK_EQ(ex1, ex2); + test_ops++; + } +} + +/* force delayed exceptions to be delivered */ +#define BARRIER() fpsetmask(0); f_x = f_one * f_one + +static void +unmasked(struct ops *test_ops) +{ + struct sigaction sa; + int r; + + /* mask all exceptions, clear history */ + fpsetmask(0); + fpsetsticky(0); + + /* set up signal handler */ + sa.sa_sigaction = sigfpe; + sigemptyset(&sa.sa_mask); + sa.sa_flags = SA_SIGINFO; + sigaction(SIGFPE, &sa, 0); + signal_caught = 0; + + /* + * exception unmasked, check SIGFPE delivery and correct siginfo + */ + while (test_ops->op != NULL) { + fpsetmask(test_ops->mask); + r = sigsetjmp(b, 1); + if (!r) { + (*test_ops->op)(); + BARRIER(); + } + ATF_CHECK_EQ(signal_caught, 1); + ATF_CHECK_EQ(sicode, test_ops->sicode); + signal_caught = 0; + test_ops++; + } +} + +void +sigfpe(int s, siginfo_t *si, void *c) +{ + signal_caught = 1; + sicode = si->si_code; + siglongjmp(b, 1); +} + +#define TEST(m, t) \ + ATF_TC(m##_##t); \ + \ + ATF_TC_HEAD(m##_##t, tc) \ + { \ + \ + atf_tc_set_md_var(tc, "descr", \ + "Test " ___STRING(m) " exceptions for " \ + ___STRING(t) "values"); \ + } \ + \ + ATF_TC_BODY(m##_##t, tc) \ + { \ + \ + m(t##_ops); \ + } + +TEST(masked, float) +TEST(masked, double) +TEST(masked, long_double) +TEST(unmasked, float) +TEST(unmasked, double) +TEST(unmasked, long_double) + +ATF_TP_ADD_TCS(tp) +{ + const char *arch; + + arch = atf_config_get("atf_machine"); + if (strcmp("vax", arch) == 0 || strcmp("m68000", arch) == 0) + printf("Test not applicable on %s", arch); + else { + ATF_TP_ADD_TC(tp, masked_float); + ATF_TP_ADD_TC(tp, masked_double); + ATF_TP_ADD_TC(tp, masked_long_double); + ATF_TP_ADD_TC(tp, unmasked_float); + ATF_TP_ADD_TC(tp, unmasked_double); + ATF_TP_ADD_TC(tp, unmasked_long_double); + } + + return atf_no_error(); +} Index: src/tests/lib/libc/ieeefp/t_nan_inf.c diff -u /dev/null src/tests/lib/libc/ieeefp/t_nan_inf.c:1.1 --- /dev/null Sun Jan 2 03:51:21 2011 +++ src/tests/lib/libc/ieeefp/t_nan_inf.c Sun Jan 2 03:51:21 2011 @@ -0,0 +1,66 @@ +/* $NetBSD: t_nan_inf.c,v 1.1 2011/01/02 03:51:21 pgoyette Exp $ */ + +/* + * This file is in the Public Domain. + * + * The nan test is blatently copied by Simon Burge from the infinity + * test by Ben Harris. + */ + +#include <atf-c.h> +#include <atf-c/config.h> + +#include <math.h> +#include <string.h> + +ATF_TC(isnan); + +ATF_TC_HEAD(isnan, tc) +{ + + atf_tc_set_md_var(tc, "descr", "Verify that isnan(3) works"); +} + +ATF_TC_BODY(isnan, tc) +{ + + /* NAN is meant to be a (float) NaN. */ + ATF_CHECK(isnan(NAN)); + ATF_CHECK(isnan((double)NAN)); +} + +ATF_TC(isinf); + +ATF_TC_HEAD(isinf, tc) +{ + + atf_tc_set_md_var(tc, "descr", "Verify that isinf(3) works"); +} + +ATF_TC_BODY(isinf, tc) +{ + + /* HUGE_VAL is meant to be an infinity. */ + ATF_CHECK(isinf(HUGE_VAL)); + + /* HUGE_VALF is the float analog of HUGE_VAL. */ + ATF_CHECK(isinf(HUGE_VALF)); + + /* HUGE_VALL is the long double analog of HUGE_VAL. */ + ATF_CHECK(isinf(HUGE_VALL)); +} + +ATF_TP_ADD_TCS(tp) +{ + const char *arch; + + arch = atf_config_get("atf_machine"); + if (strcmp("vax", arch) == 0 || strcmp("m68000", arch) == 0) + atf_tc_skip("Test not applicable on %s", arch); + else { + ATF_TP_ADD_TC(tp, isnan); + ATF_TP_ADD_TC(tp, isinf); + } + + return atf_no_error(); +} Index: src/tests/lib/libc/ieeefp/t_round.c diff -u /dev/null src/tests/lib/libc/ieeefp/t_round.c:1.1 --- /dev/null Sun Jan 2 03:51:21 2011 +++ src/tests/lib/libc/ieeefp/t_round.c Sun Jan 2 03:51:21 2011 @@ -0,0 +1,78 @@ +/* $NetBSD: t_round.c,v 1.1 2011/01/02 03:51:21 pgoyette Exp $ */ + +/* + * Written by J.T. Conklin, Apr 18, 1995 + * Public domain. + */ + +#include <atf-c.h> +#include <atf-c/config.h> + +#include <ieeefp.h> +#include <float.h> +#include <stdlib.h> +#include <string.h> + +ATF_TC(fpround); + +ATF_TC_HEAD(fpround, tc) +{ + + atf_tc_set_md_var(tc, "descr", + "Minimal testing of fpgetround(3) and fpsetround(3)"); +} + +ATF_TC_BODY(fpround, tc) +{ + + /* + * This test would be better if it actually performed some + * calculations to verify the selected rounding mode. But + * this is probably acceptable since the fp{get,set}round + * functions usually just get or set the processors fpu + * control word. + */ + + ATF_CHECK_EQ(fpgetround(), FP_RN); + ATF_CHECK_EQ(FLT_ROUNDS, 1); + + /* + * At least on one port (amd64), fpsetround() doesn't have any visible + * effect. So disable checking for the non-default modes for now. + * See PR port-amd64/44293 + */ +#ifdef NOTYET + ATF_CHECK_EQ(fpsetround(FP_RP), FP_RN); + ATF_CHECK_EQ(fpgetround(), FP_RP); + ATF_CHECK_EQ(FLT_ROUNDS, 2); + + ATF_CHECK_EQ(fpsetround(FP_RM), FP_RP); + ATF_CHECK_EQ(fpgetround(), FP_RM); + ATF_CHECK_EQ(FLT_ROUNDS, 3); + + ATF_CHECK_EQ(fpsetround(FP_RZ), FP_RM); + ATF_CHECK_EQ(fpgetround(), FP_RZ); + ATF_CHECK_EQ(FLT_ROUNDS, 0); + + ATF_CHECK_EQ(fpsetround(FP_RN), FP_RZ); +#else /* NOTYET */ + ATF_CHECK_EQ(fpsetround(FP_RN), FP_RN); +#endif /* NOTYET */ + + ATF_CHECK_EQ(fpgetround(), FP_RN); + ATF_CHECK_EQ(FLT_ROUNDS, 1); +} + +ATF_TP_ADD_TCS(tp) +{ + const char *arch; + + arch = atf_config_get("atf_machine"); + if (strcmp("vax", arch) == 0 || strcmp("m68000", arch) == 0) + atf_tc_skip("Test not applicable on %s", arch); + else { + ATF_TP_ADD_TC(tp, fpround); + } + + return atf_no_error(); +} Index: src/tests/lib/libc/ieeefp/t_subnormal.c diff -u /dev/null src/tests/lib/libc/ieeefp/t_subnormal.c:1.1 --- /dev/null Sun Jan 2 03:51:21 2011 +++ src/tests/lib/libc/ieeefp/t_subnormal.c Sun Jan 2 03:51:21 2011 @@ -0,0 +1,200 @@ +/* $NetBSD: t_subnormal.c,v 1.1 2011/01/02 03:51:21 pgoyette Exp $ */ + +/*- + * Copyright (c) 2011 The NetBSD Foundation, Inc. + * All rights reserved. + * + * This code is derived from software contributed to The NetBSD Foundation + * by + * + * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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. + */ + +#include <atf-c.h> +#include <atf-c/config.h> + +#include <assert.h> +#include <float.h> +#include <math.h> +#include <stdio.h> +#include <string.h> + +ATF_TC(test_float); + +ATF_TC_HEAD(test_float, tc) +{ + + atf_tc_set_md_var(tc, "descr", "Test float operations"); +} + +ATF_TC_BODY(test_float, tc) +{ + float d0, d1, d2, f, ip; + int e, i; + + d0 = FLT_MIN; + ATF_REQUIRE_EQ(fpclassify(d0), FP_NORMAL); + f = frexpf(d0, &e); + ATF_REQUIRE_EQ(e, FLT_MIN_EXP); + ATF_REQUIRE_EQ(f, 0.5); + d1 = d0; + + /* shift a "1" bit through the mantissa (skip the implicit bit) */ + for (i = 1; i < FLT_MANT_DIG; i++) { + d1 /= 2; + ATF_REQUIRE_EQ(fpclassify(d1), FP_SUBNORMAL); + ATF_REQUIRE(d1 > 0 && d1 < d0); + + d2 = ldexpf(d0, -i); + ATF_REQUIRE_EQ(d2, d1); + + d2 = modff(d1, &ip); + ATF_REQUIRE_EQ(d2, d1); + ATF_REQUIRE_EQ(ip, 0); + + f = frexpf(d1, &e); + ATF_REQUIRE_EQ(e, FLT_MIN_EXP - i); + ATF_REQUIRE_EQ(f, 0.5); + } + + d1 /= 2; + ATF_REQUIRE_EQ(fpclassify(d1), FP_ZERO); + f = frexpf(d1, &e); + ATF_REQUIRE_EQ(e, 0); + ATF_REQUIRE_EQ(f, 0); +} + +ATF_TC(test_double); + +ATF_TC_HEAD(test_double, tc) +{ + + atf_tc_set_md_var(tc, "descr", "Test double operations"); +} + +ATF_TC_BODY(test_double, tc) +{ + double d0, d1, d2, f, ip; + int e, i; + + d0 = DBL_MIN; + ATF_REQUIRE_EQ(fpclassify(d0), FP_NORMAL); + f = frexp(d0, &e); + ATF_REQUIRE_EQ(e, DBL_MIN_EXP); + ATF_REQUIRE_EQ(f, 0.5); + d1 = d0; + + /* shift a "1" bit through the mantissa (skip the implicit bit) */ + for (i = 1; i < DBL_MANT_DIG; i++) { + d1 /= 2; + ATF_REQUIRE_EQ(fpclassify(d1), FP_SUBNORMAL); + ATF_REQUIRE(d1 > 0 && d1 < d0); + + d2 = ldexp(d0, -i); + ATF_REQUIRE_EQ(d2, d1); + + d2 = modf(d1, &ip); + ATF_REQUIRE_EQ(d2, d1); + ATF_REQUIRE_EQ(ip, 0); + + f = frexp(d1, &e); + ATF_REQUIRE_EQ(e, DBL_MIN_EXP - i); + ATF_REQUIRE_EQ(f, 0.5); + } + + d1 /= 2; + ATF_REQUIRE_EQ(fpclassify(d1), FP_ZERO); + f = frexp(d1, &e); + ATF_REQUIRE_EQ(e, 0); + ATF_REQUIRE_EQ(f, 0); +} + +/* + * XXX NetBSD doesn't have long-double flavors of frexp, ldexp, and modf, + * XXX so this test is disabled. + */ + +#ifdef TEST_LONG_DOUBLE + +ATF_TC(test_long_double); + +ATF_TC_HEAD(test_long_double, tc) +{ + + atf_tc_set_md_var(tc, "descr", "Test long_double operations"); +} + +ATF_TC_BODY(test_long_double, tc) +{ + long double d0, d1, d2, f, ip; + int e, i; + + d0 = LDBL_MIN; + ATF_REQUIRE_EQ(fpclassify(d0), FP_NORMAL); + f = frexpl(d0, &e); + ATF_REQUIRE_EQ(e, LDBL_MIN_EXP); + ATF_REQUIRE_EQ(f, 0.5); + d1 = d0; + + /* shift a "1" bit through the mantissa (skip the implicit bit) */ + for (i = 1; i < LDBL_MANT_DIG; i++) { + d1 /= 2; + ATF_REQUIRE_EQ(fpclassify(d1), FP_SUBNORMAL); + ATF_REQUIRE(d1 > 0 && d1 < d0); + + d2 = ldexpl(d0, -i); + ATF_REQUIRE_EQ(d2, d1); + + d2 = modfl(d1, &ip); + ATF_REQUIRE_EQ(d2, d1); + ATF_REQUIRE_EQ(ip, 0); + + f = frexpl(d1, &e); + ATF_REQUIRE_EQ(e, LDBL_MIN_EXP - i); + ATF_REQUIRE_EQ(f, 0.5); + } + + d1 /= 2; + ATF_REQUIRE_EQ(fpclassify(d1), FP_ZERO); + f = frexpl(d1, &e); + ATF_REQUIRE_EQ(e, 0); + ATF_REQUIRE_EQ(f, 0); +} +#endif /* TEST_LONG_DOUBLE */ + +ATF_TP_ADD_TCS(tp) +{ + const char *arch; + + arch = atf_config_get("atf_arch"); + if (strcmp("vax", arch) == 0 || strcmp("m68000", arch) == 0) + printf("Test not applicable on %s\n", arch); + else { + ATF_TP_ADD_TC(tp, test_float); + ATF_TP_ADD_TC(tp, test_double); +#ifdef TEST_LONG_DOUBLE + ATF_TP_ADD_TC(tp, test_long_double); +#endif /* TEST_LONG_DOUBLE */ + } + + return atf_no_error(); +}