t_scalbn.c revision 1.3
1 /* $NetBSD: t_scalbn.c,v 1.3 2011/09/12 16:28:37 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.3 2011/09/12 16:28:37 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 #ifndef __vax__ 53 const double x = 0.0L / 0.0L; 54 double y; 55 size_t i; 56 57 ATF_REQUIRE(isnan(x) != 0); 58 59 for (i = 0; i < __arraycount(exps); i++) { 60 y = scalbn(x, exps[i]); 61 ATF_CHECK(isnan(y) != 0); 62 } 63 #endif 64 } 65 66 ATF_TC(scalbn_inf_neg); 67 ATF_TC_HEAD(scalbn_inf_neg, tc) 68 { 69 atf_tc_set_md_var(tc, "descr", "Test -Inf with scalbn(3)"); 70 } 71 72 ATF_TC_BODY(scalbn_inf_neg, tc) 73 { 74 #ifndef __vax__ 75 const double x = -1.0L / 0.0L; 76 size_t i; 77 78 for (i = 0; i < __arraycount(exps); i++) 79 ATF_CHECK(scalbn(x, exps[i]) == x); 80 #endif 81 } 82 83 ATF_TC(scalbn_inf_pos); 84 ATF_TC_HEAD(scalbn_inf_pos, tc) 85 { 86 atf_tc_set_md_var(tc, "descr", "Test +Inf with scalbn(3)"); 87 } 88 89 ATF_TC_BODY(scalbn_inf_pos, tc) 90 { 91 #ifndef __vax__ 92 const double x = 1.0L / 0.0L; 93 size_t i; 94 95 for (i = 0; i < __arraycount(exps); i++) 96 ATF_CHECK(scalbn(x, exps[i]) == x); 97 #endif 98 } 99 100 ATF_TC(scalbn_zero_neg); 101 ATF_TC_HEAD(scalbn_zero_neg, tc) 102 { 103 atf_tc_set_md_var(tc, "descr", "Test -0.0 with scalbn(3)"); 104 } 105 106 ATF_TC_BODY(scalbn_zero_neg, tc) 107 { 108 #ifndef __vax__ 109 const double x = -0.0L; 110 double y; 111 size_t i; 112 113 ATF_REQUIRE(signbit(x) != 0); 114 115 for (i = 0; i < __arraycount(exps); i++) { 116 y = scalbn(x, exps[i]); 117 ATF_CHECK(x == y); 118 ATF_CHECK(signbit(y) != 0); 119 } 120 #endif 121 } 122 123 ATF_TC(scalbn_zero_pos); 124 ATF_TC_HEAD(scalbn_zero_pos, tc) 125 { 126 atf_tc_set_md_var(tc, "descr", "Test +0.0 with scalbn(3)"); 127 } 128 129 ATF_TC_BODY(scalbn_zero_pos, tc) 130 { 131 #ifndef __vax__ 132 const double x = 0.0L; 133 double y; 134 size_t i; 135 136 ATF_REQUIRE(signbit(x) == 0); 137 138 for (i = 0; i < __arraycount(exps); i++) { 139 y = scalbn(x, exps[i]); 140 ATF_CHECK(x == y); 141 ATF_CHECK(signbit(y) == 0); 142 } 143 #endif 144 } 145 146 /* 147 * scalbnf(3) 148 */ 149 ATF_TC(scalbnf_nan); 150 ATF_TC_HEAD(scalbnf_nan, tc) 151 { 152 atf_tc_set_md_var(tc, "descr", "Test NaN with scalbnf(3)"); 153 } 154 155 ATF_TC_BODY(scalbnf_nan, tc) 156 { 157 #ifndef __vax__ 158 const float x = 0.0L / 0.0L; 159 float y; 160 size_t i; 161 162 ATF_REQUIRE(isnan(x) != 0); 163 164 for (i = 0; i < __arraycount(exps); i++) { 165 y = scalbnf(x, exps[i]); 166 ATF_CHECK(isnan(y) != 0); 167 } 168 #endif 169 } 170 171 ATF_TC(scalbnf_inf_neg); 172 ATF_TC_HEAD(scalbnf_inf_neg, tc) 173 { 174 atf_tc_set_md_var(tc, "descr", "Test -Inf with scalbnf(3)"); 175 } 176 177 ATF_TC_BODY(scalbnf_inf_neg, tc) 178 { 179 #ifndef __vax__ 180 const float x = -1.0L / 0.0L; 181 size_t i; 182 183 for (i = 0; i < __arraycount(exps); i++) 184 ATF_CHECK(scalbnf(x, exps[i]) == x); 185 #endif 186 } 187 188 ATF_TC(scalbnf_inf_pos); 189 ATF_TC_HEAD(scalbnf_inf_pos, tc) 190 { 191 atf_tc_set_md_var(tc, "descr", "Test +Inf with scalbnf(3)"); 192 } 193 194 ATF_TC_BODY(scalbnf_inf_pos, tc) 195 { 196 #ifndef __vax__ 197 const float x = 1.0L / 0.0L; 198 size_t i; 199 200 for (i = 0; i < __arraycount(exps); i++) 201 ATF_CHECK(scalbnf(x, exps[i]) == x); 202 #endif 203 } 204 205 ATF_TC(scalbnf_zero_neg); 206 ATF_TC_HEAD(scalbnf_zero_neg, tc) 207 { 208 atf_tc_set_md_var(tc, "descr", "Test -0.0 with scalbnf(3)"); 209 } 210 211 ATF_TC_BODY(scalbnf_zero_neg, tc) 212 { 213 #ifndef __vax__ 214 const float x = -0.0L; 215 float y; 216 size_t i; 217 218 ATF_REQUIRE(signbit(x) != 0); 219 220 for (i = 0; i < __arraycount(exps); i++) { 221 y = scalbnf(x, exps[i]); 222 ATF_CHECK(x == y); 223 ATF_CHECK(signbit(y) != 0); 224 } 225 #endif 226 } 227 228 ATF_TC(scalbnf_zero_pos); 229 ATF_TC_HEAD(scalbnf_zero_pos, tc) 230 { 231 atf_tc_set_md_var(tc, "descr", "Test +0.0 with scalbnf(3)"); 232 } 233 234 ATF_TC_BODY(scalbnf_zero_pos, tc) 235 { 236 #ifndef __vax__ 237 const float x = 0.0L; 238 float y; 239 size_t i; 240 241 ATF_REQUIRE(signbit(x) == 0); 242 243 for (i = 0; i < __arraycount(exps); i++) { 244 y = scalbnf(x, exps[i]); 245 ATF_CHECK(x == y); 246 ATF_CHECK(signbit(y) == 0); 247 } 248 #endif 249 } 250 251 /* 252 * scalbnl(3) 253 */ 254 ATF_TC(scalbnl_nan); 255 ATF_TC_HEAD(scalbnl_nan, tc) 256 { 257 atf_tc_set_md_var(tc, "descr", "Test NaN with scalbnl(3)"); 258 } 259 260 ATF_TC_BODY(scalbnl_nan, tc) 261 { 262 #ifndef __vax__ 263 #ifndef __HAVE_LONG_DOUBLE 264 atf_tc_skip("Requires long double support"); 265 #else 266 const long double x = 0.0L / 0.0L; 267 long double y; 268 size_t i; 269 270 ATF_REQUIRE(isnan(x) != 0); 271 272 for (i = 0; i < __arraycount(exps); i++) { 273 y = scalbnl(x, exps[i]); 274 ATF_CHECK(isnan(y) != 0); 275 } 276 #endif 277 #endif 278 } 279 280 ATF_TC(scalbnl_inf_neg); 281 ATF_TC_HEAD(scalbnl_inf_neg, tc) 282 { 283 atf_tc_set_md_var(tc, "descr", "Test -Inf with scalbnl(3)"); 284 } 285 286 ATF_TC_BODY(scalbnl_inf_neg, tc) 287 { 288 #ifndef __vax__ 289 #ifndef __HAVE_LONG_DOUBLE 290 atf_tc_skip("Requires long double support"); 291 #else 292 const long double x = -1.0L / 0.0L; 293 size_t i; 294 295 for (i = 0; i < __arraycount(exps); i++) 296 ATF_CHECK(scalbnl(x, exps[i]) == x); 297 #endif 298 #endif 299 } 300 301 ATF_TC(scalbnl_inf_pos); 302 ATF_TC_HEAD(scalbnl_inf_pos, tc) 303 { 304 atf_tc_set_md_var(tc, "descr", "Test +Inf with scalbnl(3)"); 305 } 306 307 ATF_TC_BODY(scalbnl_inf_pos, tc) 308 { 309 #ifndef __vax__ 310 #ifndef __HAVE_LONG_DOUBLE 311 atf_tc_skip("Requires long double support"); 312 #else 313 const long double x = 1.0L / 0.0L; 314 size_t i; 315 316 for (i = 0; i < __arraycount(exps); i++) 317 ATF_CHECK(scalbnl(x, exps[i]) == x); 318 #endif 319 #endif 320 } 321 322 ATF_TC(scalbnl_zero_neg); 323 ATF_TC_HEAD(scalbnl_zero_neg, tc) 324 { 325 atf_tc_set_md_var(tc, "descr", "Test -0.0 with scalbnl(3)"); 326 } 327 328 ATF_TC_BODY(scalbnl_zero_neg, tc) 329 { 330 #ifndef __vax__ 331 #ifndef __HAVE_LONG_DOUBLE 332 atf_tc_skip("Requires long double support"); 333 #else 334 const long double x = -0.0L; 335 long double y; 336 size_t i; 337 338 ATF_REQUIRE(signbit(x) != 0); 339 340 for (i = 0; i < __arraycount(exps); i++) { 341 y = scalbnl(x, exps[i]); 342 ATF_CHECK(x == y); 343 ATF_CHECK(signbit(y) != 0); 344 } 345 #endif 346 #endif 347 } 348 349 ATF_TC(scalbnl_zero_pos); 350 ATF_TC_HEAD(scalbnl_zero_pos, tc) 351 { 352 atf_tc_set_md_var(tc, "descr", "Test +0.0 with scalbnl(3)"); 353 } 354 355 ATF_TC_BODY(scalbnl_zero_pos, tc) 356 { 357 #ifndef __vax__ 358 #ifndef __HAVE_LONG_DOUBLE 359 atf_tc_skip("Requires long double support"); 360 #else 361 const long double x = 0.0L; 362 long double y; 363 size_t i; 364 365 ATF_REQUIRE(signbit(x) == 0); 366 367 for (i = 0; i < __arraycount(exps); i++) { 368 y = scalbnl(x, exps[i]); 369 ATF_CHECK(x == y); 370 ATF_CHECK(signbit(y) == 0); 371 } 372 #endif 373 #endif 374 } 375 376 ATF_TP_ADD_TCS(tp) 377 { 378 379 ATF_TP_ADD_TC(tp, scalbn_nan); 380 ATF_TP_ADD_TC(tp, scalbn_inf_neg); 381 ATF_TP_ADD_TC(tp, scalbn_inf_pos); 382 ATF_TP_ADD_TC(tp, scalbn_zero_neg); 383 ATF_TP_ADD_TC(tp, scalbn_zero_pos); 384 385 ATF_TP_ADD_TC(tp, scalbnf_nan); 386 ATF_TP_ADD_TC(tp, scalbnf_inf_neg); 387 ATF_TP_ADD_TC(tp, scalbnf_inf_pos); 388 ATF_TP_ADD_TC(tp, scalbnf_zero_neg); 389 ATF_TP_ADD_TC(tp, scalbnf_zero_pos); 390 391 ATF_TP_ADD_TC(tp, scalbnl_nan); 392 ATF_TP_ADD_TC(tp, scalbnl_inf_neg); 393 ATF_TP_ADD_TC(tp, scalbnl_inf_pos); 394 ATF_TP_ADD_TC(tp, scalbnl_zero_neg); 395 ATF_TP_ADD_TC(tp, scalbnl_zero_pos); 396 397 return atf_no_error(); 398 } 399
Indexes created Tue Sep 30 11:09:46 GMT 2025