Home | History | Annotate | Line # | Download | only in libm
t_scalbn.c revision 1.1
      1 /* $NetBSD: t_scalbn.c,v 1.1 2011/09/12 15:27:40 jruoho Exp $ */
      2 
      3 /*-
      4  * Copyright (c) 2011 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Jukka Ruohonen.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29  * POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 #include <sys/cdefs.h>
     32 __RCSID("$NetBSD: t_scalbn.c,v 1.1 2011/09/12 15:27:40 jruoho Exp $");
     33 
     34 #include <math.h>
     35 #include <limits.h>
     36 
     37 #include <atf-c.h>
     38 
     39 static const int exps[] = { 0, 1, -1, 100, -100 };
     40 
     41 /*
     42  * scalbn(3)
     43  */
     44 ATF_TC(scalbn_nan);
     45 ATF_TC_HEAD(scalbn_nan, tc)
     46 {
     47 	atf_tc_set_md_var(tc, "descr", "Test NaN with scalbn(3)");
     48 }
     49 
     50 ATF_TC_BODY(scalbn_nan, tc)
     51 {
     52 	const double x = 0.0L / 0.0L;
     53 	double y;
     54 	size_t i;
     55 
     56 	for (i = 0; i < __arraycount(exps); i++) {
     57 		y = scalbn(x, exps[i]);
     58 		ATF_CHECK(isnan(y) != 0);
     59 	}
     60 }
     61 
     62 ATF_TC(scalbn_inf_neg);
     63 ATF_TC_HEAD(scalbn_inf_neg, tc)
     64 {
     65 	atf_tc_set_md_var(tc, "descr", "Test -Inf with scalbn(3)");
     66 }
     67 
     68 ATF_TC_BODY(scalbn_inf_neg, tc)
     69 {
     70 	const double x = -1.0L / 0.0L;
     71 	size_t i;
     72 
     73 	for (i = 0; i < __arraycount(exps); i++)
     74 		ATF_CHECK(scalbn(x, exps[i]) == x);
     75 }
     76 
     77 ATF_TC(scalbn_inf_pos);
     78 ATF_TC_HEAD(scalbn_inf_pos, tc)
     79 {
     80 	atf_tc_set_md_var(tc, "descr", "Test +Inf with scalbn(3)");
     81 }
     82 
     83 ATF_TC_BODY(scalbn_inf_pos, tc)
     84 {
     85 	const double x = 1.0L / 0.0L;
     86 	size_t i;
     87 
     88 	for (i = 0; i < __arraycount(exps); i++)
     89 		ATF_CHECK(scalbn(x, exps[i]) == x);
     90 }
     91 
     92 ATF_TC(scalbn_zero_neg);
     93 ATF_TC_HEAD(scalbn_zero_neg, tc)
     94 {
     95 	atf_tc_set_md_var(tc, "descr", "Test -0.0 with scalbn(3)");
     96 }
     97 
     98 ATF_TC_BODY(scalbn_zero_neg, tc)
     99 {
    100 	const double x = -0.0L;
    101 	size_t i;
    102 
    103 	for (i = 0; i < __arraycount(exps); i++)
    104 		ATF_CHECK(scalbn(x, exps[i]) == x);
    105 }
    106 
    107 ATF_TC(scalbn_zero_pos);
    108 ATF_TC_HEAD(scalbn_zero_pos, tc)
    109 {
    110 	atf_tc_set_md_var(tc, "descr", "Test +0.0 with scalbn(3)");
    111 }
    112 
    113 ATF_TC_BODY(scalbn_zero_pos, tc)
    114 {
    115 	const double x = 0.0L;
    116 	size_t i;
    117 
    118 	for (i = 0; i < __arraycount(exps); i++)
    119 		ATF_CHECK(scalbn(x, exps[i]) == x);
    120 }
    121 
    122 /*
    123  * scalbnf(3)
    124  */
    125 ATF_TC(scalbnf_nan);
    126 ATF_TC_HEAD(scalbnf_nan, tc)
    127 {
    128 	atf_tc_set_md_var(tc, "descr", "Test NaN with scalbnf(3)");
    129 }
    130 
    131 ATF_TC_BODY(scalbnf_nan, tc)
    132 {
    133 	const float x = 0.0L / 0.0L;
    134 	float y;
    135 	size_t i;
    136 
    137 	for (i = 0; i < __arraycount(exps); i++) {
    138 		y = scalbnf(x, exps[i]);
    139 		ATF_CHECK(isnan(y) != 0);
    140 	}
    141 }
    142 
    143 ATF_TC(scalbnf_inf_neg);
    144 ATF_TC_HEAD(scalbnf_inf_neg, tc)
    145 {
    146 	atf_tc_set_md_var(tc, "descr", "Test -Inf with scalbnf(3)");
    147 }
    148 
    149 ATF_TC_BODY(scalbnf_inf_neg, tc)
    150 {
    151 	const float x = -1.0L / 0.0L;
    152 	size_t i;
    153 
    154 	for (i = 0; i < __arraycount(exps); i++)
    155 		ATF_CHECK(scalbnf(x, exps[i]) == x);
    156 }
    157 
    158 ATF_TC(scalbnf_inf_pos);
    159 ATF_TC_HEAD(scalbnf_inf_pos, tc)
    160 {
    161 	atf_tc_set_md_var(tc, "descr", "Test +Inf with scalbnf(3)");
    162 }
    163 
    164 ATF_TC_BODY(scalbnf_inf_pos, tc)
    165 {
    166 	const float x = 1.0L / 0.0L;
    167 	size_t i;
    168 
    169 	for (i = 0; i < __arraycount(exps); i++)
    170 		ATF_CHECK(scalbnf(x, exps[i]) == x);
    171 }
    172 
    173 ATF_TC(scalbnf_zero_neg);
    174 ATF_TC_HEAD(scalbnf_zero_neg, tc)
    175 {
    176 	atf_tc_set_md_var(tc, "descr", "Test -0.0 with scalbnf(3)");
    177 }
    178 
    179 ATF_TC_BODY(scalbnf_zero_neg, tc)
    180 {
    181 	const float x = -0.0L;
    182 	size_t i;
    183 
    184 	for (i = 0; i < __arraycount(exps); i++)
    185 		ATF_CHECK(scalbnf(x, exps[i]) == x);
    186 }
    187 
    188 ATF_TC(scalbnf_zero_pos);
    189 ATF_TC_HEAD(scalbnf_zero_pos, tc)
    190 {
    191 	atf_tc_set_md_var(tc, "descr", "Test +0.0 with scalbnf(3)");
    192 }
    193 
    194 ATF_TC_BODY(scalbnf_zero_pos, tc)
    195 {
    196 	const float x = 0.0L;
    197 	size_t i;
    198 
    199 	for (i = 0; i < __arraycount(exps); i++)
    200 		ATF_CHECK(scalbnf(x, exps[i]) == x);
    201 }
    202 
    203 /*
    204  * scalbnl(3)
    205  */
    206 ATF_TC(scalbnl_nan);
    207 ATF_TC_HEAD(scalbnl_nan, tc)
    208 {
    209 	atf_tc_set_md_var(tc, "descr", "Test NaN with scalbnl(3)");
    210 }
    211 
    212 ATF_TC_BODY(scalbnl_nan, tc)
    213 {
    214 #ifndef __HAVE_LONG_DOUBLE
    215 	atf_tc_skip("Requires long double support");
    216 #else
    217 	const long double x = 0.0L / 0.0L;
    218 	long double y;
    219 	size_t i;
    220 
    221 	for (i = 0; i < __arraycount(exps); i++) {
    222 		y = scalbnl(x, exps[i]);
    223 		ATF_CHECK(isnan(y) != 0);
    224 	}
    225 #endif
    226 }
    227 
    228 ATF_TC(scalbnl_inf_neg);
    229 ATF_TC_HEAD(scalbnl_inf_neg, tc)
    230 {
    231 	atf_tc_set_md_var(tc, "descr", "Test -Inf with scalbnl(3)");
    232 }
    233 
    234 ATF_TC_BODY(scalbnl_inf_neg, tc)
    235 {
    236 #ifndef __HAVE_LONG_DOUBLE
    237 	atf_tc_skip("Requires long double support");
    238 #else
    239 	const long double x = -1.0L / 0.0L;
    240 	size_t i;
    241 
    242 	for (i = 0; i < __arraycount(exps); i++)
    243 		ATF_CHECK(scalbnl(x, exps[i]) == x);
    244 #endif
    245 }
    246 
    247 ATF_TC(scalbnl_inf_pos);
    248 ATF_TC_HEAD(scalbnl_inf_pos, tc)
    249 {
    250 	atf_tc_set_md_var(tc, "descr", "Test +Inf with scalbnl(3)");
    251 }
    252 
    253 ATF_TC_BODY(scalbnl_inf_pos, tc)
    254 {
    255 #ifndef __HAVE_LONG_DOUBLE
    256 	atf_tc_skip("Requires long double support");
    257 #else
    258 	const long double x = 1.0L / 0.0L;
    259 	size_t i;
    260 
    261 	for (i = 0; i < __arraycount(exps); i++)
    262 		ATF_CHECK(scalbnl(x, exps[i]) == x);
    263 #endif
    264 }
    265 
    266 ATF_TC(scalbnl_zero_neg);
    267 ATF_TC_HEAD(scalbnl_zero_neg, tc)
    268 {
    269 	atf_tc_set_md_var(tc, "descr", "Test -0.0 with scalbnl(3)");
    270 }
    271 
    272 ATF_TC_BODY(scalbnl_zero_neg, tc)
    273 {
    274 #ifndef __HAVE_LONG_DOUBLE
    275 	atf_tc_skip("Requires long double support");
    276 #else
    277 	const long double x = -0.0L;
    278 	size_t i;
    279 
    280 	for (i = 0; i < __arraycount(exps); i++)
    281 		ATF_CHECK(scalbnl(x, exps[i]) == x);
    282 #endif
    283 }
    284 
    285 ATF_TC(scalbnl_zero_pos);
    286 ATF_TC_HEAD(scalbnl_zero_pos, tc)
    287 {
    288 	atf_tc_set_md_var(tc, "descr", "Test +0.0 with scalbnl(3)");
    289 }
    290 
    291 ATF_TC_BODY(scalbnl_zero_pos, tc)
    292 {
    293 #ifndef __HAVE_LONG_DOUBLE
    294 	atf_tc_skip("Requires long double support");
    295 #else
    296 	const long double x = 0.0L;
    297 	size_t i;
    298 
    299 	for (i = 0; i < __arraycount(exps); i++)
    300 		ATF_CHECK(scalbnl(x, exps[i]) == x);
    301 #endif
    302 }
    303 
    304 ATF_TP_ADD_TCS(tp)
    305 {
    306 
    307 	ATF_TP_ADD_TC(tp, scalbn_nan);
    308 	ATF_TP_ADD_TC(tp, scalbn_inf_neg);
    309 	ATF_TP_ADD_TC(tp, scalbn_inf_pos);
    310 	ATF_TP_ADD_TC(tp, scalbn_zero_neg);
    311 	ATF_TP_ADD_TC(tp, scalbn_zero_pos);
    312 
    313 	ATF_TP_ADD_TC(tp, scalbnf_nan);
    314 	ATF_TP_ADD_TC(tp, scalbnf_inf_neg);
    315 	ATF_TP_ADD_TC(tp, scalbnf_inf_pos);
    316 	ATF_TP_ADD_TC(tp, scalbnf_zero_neg);
    317 	ATF_TP_ADD_TC(tp, scalbnf_zero_pos);
    318 
    319 	ATF_TP_ADD_TC(tp, scalbnl_nan);
    320 	ATF_TP_ADD_TC(tp, scalbnl_inf_neg);
    321 	ATF_TP_ADD_TC(tp, scalbnl_inf_pos);
    322 	ATF_TP_ADD_TC(tp, scalbnl_zero_neg);
    323 	ATF_TP_ADD_TC(tp, scalbnl_zero_pos);
    324 
    325 	return atf_no_error();
    326 }
    327