 @@ -1,14 +1,14 @@
-/* $NetBSD: t_scalbn.c,v 1.7 2011/09/13 07:07:32 jruoho Exp $ */
+/* $NetBSD: t_scalbn.c,v 1.8 2013/05/20 12:21:42 martin Exp $ */
 /*-
  * Copyright (c) 2011 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jukka Ruohonen.
+ *
  * 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.
 @@ -19,38 +19,88 @@
  * 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 <sys/cdefs.h>
-__RCSID("$NetBSD: t_scalbn.c,v 1.7 2011/09/13 07:07:32 jruoho Exp $");
+__RCSID("$NetBSD: t_scalbn.c,v 1.8 2013/05/20 12:21:42 martin Exp $");
 #include <math.h>
 #include <limits.h>
 #include <float.h>
 #include <errno.h>
 #include <atf-c.h>
 static const int exps[] = { 0, 1, -1, 100, -100 };
 /* tests here do not require specific precision, so we just use double */
 struct testcase {
 	int exp;
 	double inval;
 	double result;
 	int error;
 };
 struct testcase test_vals[] = {
 	{ 0,		1.00085,	1.00085,	0 },
 	{ 0,		0.99755,	0.99755,	0 },
 	{ 0,		-1.00085,	-1.00085,	0 },
 	{ 0,		-0.99755,	-0.99755,	0 },
 	{ 1,		1.00085,	2.0* 1.00085,	0 },
 	{ 1,		0.99755,	2.0* 0.99755,	0 },
 	{ 1,		-1.00085,	2.0* -1.00085,	0 },
 	{ 1,		-0.99755,	2.0* -0.99755,	0 },
 	/*
 	 * We could add more corner test cases here, but we would have to
 	 * add some ifdefs for the exact format and use a reliable
 	 * generator program - bail for now and only do trivial stuff above.
 	 */
 };
 /*
  * scalbn(3)
  */
 ATF_TC(scalbn_val);
 ATF_TC_HEAD(scalbn_val, tc)
+{
 	atf_tc_set_md_var(tc, "descr", "Test scalbn() for a few values");
+}
 ATF_TC_BODY(scalbn_val, tc)
+{
 	const struct testcase *tests = test_vals;
 	const size_t tcnt = __arraycount(test_vals);
 	size_t i;
 	double rv;
 	for (i = 0; i < tcnt; i++) {
 		rv = scalbn(tests[i].inval, tests[i].exp);
 		ATF_CHECK_EQ_MSG(errno, tests[i].error,
 		    "test %zu: errno %d instead of %d", i, errno,
 		    tests[i].error);
 		ATF_CHECK_MSG(fabs(rv-tests[i].result)<2.0*DBL_EPSILON,
 		    "test %zu: return value %g instead of %g (difference %g)",
 		    i, rv, tests[i].result, tests[i].result-rv);
+	}
+}
 ATF_TC(scalbn_nan);
 ATF_TC_HEAD(scalbn_nan, tc)
+{
 	atf_tc_set_md_var(tc, "descr", "Test scalbn(NaN, n) == NaN");
+}
 ATF_TC_BODY(scalbn_nan, tc)
+{
 #ifndef __vax__
 	const double x = 0.0L / 0.0L;
 	double y;
 	size_t i;
 @@ -103,27 +153,29 @@ ATF_TC_HEAD(scalbn_ldexp, tc)
 	atf_tc_set_md_var(tc, "descr", "Test scalbn(x, n) == ldexp(x, n)");
+}
 ATF_TC_BODY(scalbn_ldexp, tc)
+{
 #ifndef __vax__
 #if FLT_RADIX == 2
 	const double x = 2.91288191221812821;
 	double y;
 	size_t i;
 	for (i = 0; i < __arraycount(exps); i++) {
 		y = scalbn(x, exps[i]);
-		ATF_CHECK(y == ldexp(x, exps[i]));
+		ATF_CHECK_MSG(y == ldexp(x, exps[i]), "test %zu: exponent=%d, "
 		    "y=%g, expected %g (diff: %g)", i, exps[i], y,
 		    ldexp(x, exps[i]), y - ldexp(x, exps[i]));
+	}
 #endif
 #endif
+}
 ATF_TC(scalbn_zero_neg);
 ATF_TC_HEAD(scalbn_zero_neg, tc)
+{
 	atf_tc_set_md_var(tc, "descr", "Test scalbn(-0.0, n) == -0.0");
+}
 ATF_TC_BODY(scalbn_zero_neg, tc)
+{
 @@ -158,26 +210,50 @@ ATF_TC_BODY(scalbn_zero_pos, tc)
 	ATF_REQUIRE(signbit(x) == 0);
 	for (i = 0; i < __arraycount(exps); i++) {
 		y = scalbn(x, exps[i]);
 		ATF_CHECK(x == y);
 		ATF_CHECK(signbit(y) == 0);
+	}
 #endif
+}
 /*
  * scalbnf(3)
  */
 ATF_TC(scalbnf_val);
 ATF_TC_HEAD(scalbnf_val, tc)
+{
 	atf_tc_set_md_var(tc, "descr", "Test scalbnf() for a few values");
+}
 ATF_TC_BODY(scalbnf_val, tc)
+{
 	const struct testcase *tests = test_vals;
 	const size_t tcnt = __arraycount(test_vals);
 	size_t i;
 	double rv;
 	for (i = 0; i < tcnt; i++) {
 		rv = scalbnf(tests[i].inval, tests[i].exp);
 		ATF_CHECK_EQ_MSG(errno, tests[i].error,
 		    "test %zu: errno %d instead of %d", i, errno,
 		    tests[i].error);
 		ATF_CHECK_MSG(fabs(rv-tests[i].result)<2.0*FLT_EPSILON,
 		    "test %zu: return value %g instead of %g (difference %g)",
 		    i, rv, tests[i].result, tests[i].result-rv);
+	}
+}
 ATF_TC(scalbnf_nan);
 ATF_TC_HEAD(scalbnf_nan, tc)
+{
 	atf_tc_set_md_var(tc, "descr", "Test scalbnf(NaN, n) == NaN");
+}
 ATF_TC_BODY(scalbnf_nan, tc)
+{
 #ifndef __vax__
 	const float x = 0.0L / 0.0L;
 	float y;
 	size_t i;
 @@ -230,27 +306,29 @@ ATF_TC_HEAD(scalbnf_ldexpf, tc)
 	atf_tc_set_md_var(tc, "descr", "Test scalbnf(x, n) == ldexpf(x, n)");
+}
 ATF_TC_BODY(scalbnf_ldexpf, tc)
+{
 #ifndef __vax__
 #if FLT_RADIX == 2
 	const float x = 2.91288191221812821;
 	float y;
 	size_t i;
 	for (i = 0; i < __arraycount(exps); i++) {
 		y = scalbnf(x, exps[i]);
-		ATF_CHECK(y == ldexpf(x, exps[i]));
+		ATF_CHECK_MSG(y == ldexpf(x, exps[i]),
 		    "test %zu: exponent=%d, y=%g ldexpf returns %g (diff: %g)",
 		    i, exps[i], y, ldexpf(x, exps[i]), y-ldexpf(x, exps[i]));
+	}
 #endif
 #endif
+}
 ATF_TC(scalbnf_zero_neg);
 ATF_TC_HEAD(scalbnf_zero_neg, tc)
+{
 	atf_tc_set_md_var(tc, "descr", "Test scalbnf(-0.0, n) == -0.0");
+}
 ATF_TC_BODY(scalbnf_zero_neg, tc)
+{
 @@ -285,26 +363,54 @@ ATF_TC_BODY(scalbnf_zero_pos, tc)
 	ATF_REQUIRE(signbit(x) == 0);
 	for (i = 0; i < __arraycount(exps); i++) {
 		y = scalbnf(x, exps[i]);
 		ATF_CHECK(x == y);
 		ATF_CHECK(signbit(y) == 0);
+	}
 #endif
+}
 /*
  * scalbnl(3)
  */
 ATF_TC(scalbnl_val);
 ATF_TC_HEAD(scalbnl_val, tc)
+{
 	atf_tc_set_md_var(tc, "descr", "Test scalbnl() for a few values");
+}
 ATF_TC_BODY(scalbnl_val, tc)
+{
 #ifndef __HAVE_LONG_DOUBLE
 	atf_tc_skip("Requires long double support");
 #else
 	const struct testcase *tests = test_vals;
 	const size_t tcnt = __arraycount(test_vals);
 	size_t i;
 	long double rv;
 	for (i = 0; i < tcnt; i++) {
 		rv = scalbnl(tests[i].inval, tests[i].exp);
 		ATF_CHECK_EQ_MSG(errno, tests[i].error,
 		    "test %zu: errno %d instead of %d", i, errno,
 		    tests[i].error);
 		ATF_CHECK_MSG(fabsl(rv-(long double)tests[i].result)<2.0*LDBL_EPSILON,
 		    "test %zu: return value %Lg instead of %Lg (difference %Lg)",
 		    i, rv, (long double)tests[i].result, (long double)tests[i].result-rv);
+	}
 #endif
+}
 ATF_TC(scalbnl_nan);
 ATF_TC_HEAD(scalbnl_nan, tc)
+{
 	atf_tc_set_md_var(tc, "descr", "Test scalbnl(NaN, n) == NaN");
+}
 ATF_TC_BODY(scalbnl_nan, tc)
+{
 #ifndef __vax__
 #ifndef __HAVE_LONG_DOUBLE
 	atf_tc_skip("Requires long double support");
 #else
 	const long double x = 0.0L / 0.0L;
 @@ -413,36 +519,39 @@ ATF_TC_BODY(scalbnl_zero_pos, tc)
 	for (i = 0; i < __arraycount(exps); i++) {
 		y = scalbnl(x, exps[i]);
 		ATF_CHECK(x == y);
 		ATF_CHECK(signbit(y) == 0);
+	}
 #endif
 #endif
+}
 ATF_TP_ADD_TCS(tp)
+{
 	ATF_TP_ADD_TC(tp, scalbn_val);
 	ATF_TP_ADD_TC(tp, scalbn_nan);
 	ATF_TP_ADD_TC(tp, scalbn_inf_neg);
 	ATF_TP_ADD_TC(tp, scalbn_inf_pos);
 	ATF_TP_ADD_TC(tp, scalbn_ldexp);
 	ATF_TP_ADD_TC(tp, scalbn_zero_neg);
 	ATF_TP_ADD_TC(tp, scalbn_zero_pos);
 	ATF_TP_ADD_TC(tp, scalbnf_val);
 	ATF_TP_ADD_TC(tp, scalbnf_nan);
 	ATF_TP_ADD_TC(tp, scalbnf_inf_neg);
 	ATF_TP_ADD_TC(tp, scalbnf_inf_pos);
 	ATF_TP_ADD_TC(tp, scalbnf_ldexpf);
 	ATF_TP_ADD_TC(tp, scalbnf_zero_neg);
 	ATF_TP_ADD_TC(tp, scalbnf_zero_pos);
 	ATF_TP_ADD_TC(tp, scalbnl_val);
 	ATF_TP_ADD_TC(tp, scalbnl_nan);
 	ATF_TP_ADD_TC(tp, scalbnl_inf_neg);
 	ATF_TP_ADD_TC(tp, scalbnl_inf_pos);
 /*	ATF_TP_ADD_TC(tp, scalbnl_ldexp);	*/
 	ATF_TP_ADD_TC(tp, scalbnl_zero_neg);
 	ATF_TP_ADD_TC(tp, scalbnl_zero_pos);
 	return atf_no_error();
+}