1 /* $NetBSD: t_ceil.c,v 1.10 2014/03/03 10:39:08 martin 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_ceil.c,v 1.10 2014/03/03 10:39:08 martin Exp $"); 33 34 #include <atf-c.h> 35 #include <math.h> 36 #include <limits.h> 37 #include <stdio.h> 38 39 #ifdef __vax__ 40 #define SMALL_NUM 1.0e-38 41 #else 42 #define SMALL_NUM 1.0e-40 43 #endif 44 45 /* 46 * ceil(3) 47 */ 48 ATF_TC(ceil_basic); 49 ATF_TC_HEAD(ceil_basic, tc) 50 { 51 atf_tc_set_md_var(tc, "descr", "A basic test of ceil(3)"); 52 } 53 54 ATF_TC_BODY(ceil_basic, tc) 55 { 56 const double x = 0.999999999999999; 57 const double y = 0.000000000000001; 58 59 ATF_CHECK(fabs(ceil(x) - 1) < SMALL_NUM); 60 ATF_CHECK(fabs(ceil(y) - 1) < SMALL_NUM); 61 } 62 63 ATF_TC(ceil_nan); 64 ATF_TC_HEAD(ceil_nan, tc) 65 { 66 atf_tc_set_md_var(tc, "descr", "Test ceil(NaN) == NaN"); 67 } 68 69 ATF_TC_BODY(ceil_nan, tc) 70 { 71 const double x = 0.0L / 0.0L; 72 73 ATF_CHECK(isnan(ceil(x)) != 0); 74 } 75 76 ATF_TC(ceil_inf_neg); 77 ATF_TC_HEAD(ceil_inf_neg, tc) 78 { 79 atf_tc_set_md_var(tc, "descr", "Test ceil(-Inf) == -Inf"); 80 } 81 82 ATF_TC_BODY(ceil_inf_neg, tc) 83 { 84 const double x = -1.0L / 0.0L; 85 double y = ceil(x); 86 87 if (isinf(y) == 0 || signbit(y) == 0) 88 atf_tc_fail_nonfatal("ceil(-Inf) != -Inf"); 89 } 90 91 ATF_TC(ceil_inf_pos); 92 ATF_TC_HEAD(ceil_inf_pos, tc) 93 { 94 atf_tc_set_md_var(tc, "descr", "Test ceil(+Inf) == +Inf"); 95 } 96 97 ATF_TC_BODY(ceil_inf_pos, tc) 98 { 99 const double x = 1.0L / 0.0L; 100 double y = ceil(x); 101 102 if (isinf(y) == 0 || signbit(y) != 0) 103 atf_tc_fail_nonfatal("ceil(+Inf) != +Inf"); 104 } 105 106 ATF_TC(ceil_zero_neg); 107 ATF_TC_HEAD(ceil_zero_neg, tc) 108 { 109 atf_tc_set_md_var(tc, "descr", "Test ceil(-0.0) == -0.0"); 110 } 111 112 ATF_TC_BODY(ceil_zero_neg, tc) 113 { 114 const double x = -0.0L; 115 double y = ceil(x); 116 117 if (fabs(y) > 0.0 || signbit(y) == 0) 118 atf_tc_fail_nonfatal("ceil(-0.0) != -0.0"); 119 } 120 121 ATF_TC(ceil_zero_pos); 122 ATF_TC_HEAD(ceil_zero_pos, tc) 123 { 124 atf_tc_set_md_var(tc, "descr", "Test ceil(+0.0) == +0.0"); 125 } 126 127 ATF_TC_BODY(ceil_zero_pos, tc) 128 { 129 const double x = 0.0L; 130 double y = ceil(x); 131 132 if (fabs(y) > 0.0 || signbit(y) != 0) 133 atf_tc_fail_nonfatal("ceil(+0.0) != +0.0"); 134 } 135 136 /* 137 * ceilf(3) 138 */ 139 ATF_TC(ceilf_basic); 140 ATF_TC_HEAD(ceilf_basic, tc) 141 { 142 atf_tc_set_md_var(tc, "descr", "A basic test of ceilf(3)"); 143 } 144 145 ATF_TC_BODY(ceilf_basic, tc) 146 { 147 const float x = 0.9999999; 148 const float y = 0.0000001; 149 150 ATF_CHECK(fabsf(ceilf(x) - 1) < SMALL_NUM); 151 ATF_CHECK(fabsf(ceilf(y) - 1) < SMALL_NUM); 152 } 153 154 ATF_TC(ceilf_nan); 155 ATF_TC_HEAD(ceilf_nan, tc) 156 { 157 atf_tc_set_md_var(tc, "descr", "Test ceilf(NaN) == NaN"); 158 } 159 160 ATF_TC_BODY(ceilf_nan, tc) 161 { 162 const float x = 0.0L / 0.0L; 163 164 ATF_CHECK(isnan(ceilf(x)) != 0); 165 } 166 167 ATF_TC(ceilf_inf_neg); 168 ATF_TC_HEAD(ceilf_inf_neg, tc) 169 { 170 atf_tc_set_md_var(tc, "descr", "Test ceilf(-Inf) == -Inf"); 171 } 172 173 ATF_TC_BODY(ceilf_inf_neg, tc) 174 { 175 const float x = -1.0L / 0.0L; 176 float y = ceilf(x); 177 178 if (isinf(y) == 0 || signbit(y) == 0) 179 atf_tc_fail_nonfatal("ceilf(-Inf) != -Inf"); 180 } 181 182 ATF_TC(ceilf_inf_pos); 183 ATF_TC_HEAD(ceilf_inf_pos, tc) 184 { 185 atf_tc_set_md_var(tc, "descr", "Test ceilf(+Inf) == +Inf"); 186 } 187 188 ATF_TC_BODY(ceilf_inf_pos, tc) 189 { 190 const float x = 1.0L / 0.0L; 191 float y = ceilf(x); 192 193 if (isinf(y) == 0 || signbit(y) != 0) 194 atf_tc_fail_nonfatal("ceilf(+Inf) != +Inf"); 195 } 196 197 ATF_TC(ceilf_zero_neg); 198 ATF_TC_HEAD(ceilf_zero_neg, tc) 199 { 200 atf_tc_set_md_var(tc, "descr", "Test ceilf(-0.0) == -0.0"); 201 } 202 203 ATF_TC_BODY(ceilf_zero_neg, tc) 204 { 205 const float x = -0.0L; 206 float y = ceilf(x); 207 208 if (fabsf(y) > 0.0 || signbit(y) == 0) 209 atf_tc_fail_nonfatal("ceilf(-0.0) != -0.0"); 210 } 211 212 ATF_TC(ceilf_zero_pos); 213 ATF_TC_HEAD(ceilf_zero_pos, tc) 214 { 215 atf_tc_set_md_var(tc, "descr", "Test ceilf(+0.0) == +0.0"); 216 } 217 218 ATF_TC_BODY(ceilf_zero_pos, tc) 219 { 220 const float x = 0.0L; 221 float y = ceilf(x); 222 223 if (fabsf(y) > 0.0 || signbit(y) != 0) 224 atf_tc_fail_nonfatal("ceilf(+0.0) != +0.0"); 225 } 226 227 /* 228 * ceill(3) 229 */ 230 ATF_TC(ceill_basic); 231 ATF_TC_HEAD(ceill_basic, tc) 232 { 233 atf_tc_set_md_var(tc, "descr", "A basic test of ceill(3)"); 234 } 235 236 ATF_TC_BODY(ceill_basic, tc) 237 { 238 const long double x = 0.9999999; 239 const long double y = 0.0000001; 240 241 ATF_CHECK(fabsl(ceill(x) - 1) < SMALL_NUM); 242 ATF_CHECK(fabsl(ceill(y) - 1) < SMALL_NUM); 243 } 244 245 ATF_TC(ceill_nan); 246 ATF_TC_HEAD(ceill_nan, tc) 247 { 248 atf_tc_set_md_var(tc, "descr", "Test ceill(NaN) == NaN"); 249 } 250 251 ATF_TC_BODY(ceill_nan, tc) 252 { 253 const long double x = 0.0L / 0.0L; 254 255 ATF_CHECK(isnan(ceill(x)) != 0); 256 } 257 258 ATF_TC(ceill_inf_neg); 259 ATF_TC_HEAD(ceill_inf_neg, tc) 260 { 261 atf_tc_set_md_var(tc, "descr", "Test ceill(-Inf) == -Inf"); 262 } 263 264 ATF_TC_BODY(ceill_inf_neg, tc) 265 { 266 const long double x = -1.0L / 0.0L; 267 long double y = ceill(x); 268 269 if (isinf(y) == 0 || signbit(y) == 0) 270 atf_tc_fail_nonfatal("ceill(-Inf) != -Inf"); 271 } 272 273 ATF_TC(ceill_inf_pos); 274 ATF_TC_HEAD(ceill_inf_pos, tc) 275 { 276 atf_tc_set_md_var(tc, "descr", "Test ceill(+Inf) == +Inf"); 277 } 278 279 ATF_TC_BODY(ceill_inf_pos, tc) 280 { 281 const long double x = 1.0L / 0.0L; 282 long double y = ceill(x); 283 284 if (isinf(y) == 0 || signbit(y) != 0) 285 atf_tc_fail_nonfatal("ceill(+Inf) != +Inf"); 286 } 287 288 ATF_TC(ceill_zero_neg); 289 ATF_TC_HEAD(ceill_zero_neg, tc) 290 { 291 atf_tc_set_md_var(tc, "descr", "Test ceill(-0.0) == -0.0"); 292 } 293 294 ATF_TC_BODY(ceill_zero_neg, tc) 295 { 296 const long double x = -0.0L; 297 long double y = ceill(x); 298 299 if (fabsl(y) > 0.0 || signbit(y) == 0) 300 atf_tc_fail_nonfatal("ceill(-0.0) != -0.0"); 301 } 302 303 ATF_TC(ceill_zero_pos); 304 ATF_TC_HEAD(ceill_zero_pos, tc) 305 { 306 atf_tc_set_md_var(tc, "descr", "Test ceill(+0.0) == +0.0"); 307 } 308 309 ATF_TC_BODY(ceill_zero_pos, tc) 310 { 311 const long double x = 0.0L; 312 long double y = ceill(x); 313 314 if (fabsl(y) > 0.0 || signbit(y) != 0) 315 atf_tc_fail_nonfatal("ceill(+0.0) != +0.0"); 316 } 317 318 /* 319 * floor(3) 320 */ 321 ATF_TC(floor_basic); 322 ATF_TC_HEAD(floor_basic, tc) 323 { 324 atf_tc_set_md_var(tc, "descr", "A basic test of floor(3)"); 325 } 326 327 ATF_TC_BODY(floor_basic, tc) 328 { 329 const double x = 0.999999999999999; 330 const double y = 0.000000000000001; 331 332 ATF_CHECK(floor(x) < SMALL_NUM); 333 ATF_CHECK(floor(y) < SMALL_NUM); 334 } 335 336 ATF_TC(floor_nan); 337 ATF_TC_HEAD(floor_nan, tc) 338 { 339 atf_tc_set_md_var(tc, "descr", "Test floor(NaN) == NaN"); 340 } 341 342 ATF_TC_BODY(floor_nan, tc) 343 { 344 const double x = 0.0L / 0.0L; 345 346 ATF_CHECK(isnan(floor(x)) != 0); 347 } 348 349 ATF_TC(floor_inf_neg); 350 ATF_TC_HEAD(floor_inf_neg, tc) 351 { 352 atf_tc_set_md_var(tc, "descr", "Test floor(-Inf) == -Inf"); 353 } 354 355 ATF_TC_BODY(floor_inf_neg, tc) 356 { 357 const double x = -1.0L / 0.0L; 358 double y = floor(x); 359 360 if (isinf(y) == 0 || signbit(y) == 0) 361 atf_tc_fail_nonfatal("floor(-Inf) != -Inf"); 362 } 363 364 ATF_TC(floor_inf_pos); 365 ATF_TC_HEAD(floor_inf_pos, tc) 366 { 367 atf_tc_set_md_var(tc, "descr", "Test floor(+Inf) == +Inf"); 368 } 369 370 ATF_TC_BODY(floor_inf_pos, tc) 371 { 372 const double x = 1.0L / 0.0L; 373 double y = floor(x); 374 375 if (isinf(y) == 0 || signbit(y) != 0) 376 atf_tc_fail_nonfatal("floor(+Inf) != +Inf"); 377 } 378 379 ATF_TC(floor_zero_neg); 380 ATF_TC_HEAD(floor_zero_neg, tc) 381 { 382 atf_tc_set_md_var(tc, "descr", "Test floor(-0.0) == -0.0"); 383 } 384 385 ATF_TC_BODY(floor_zero_neg, tc) 386 { 387 const double x = -0.0L; 388 double y = floor(x); 389 390 if (fabs(y) > 0.0 || signbit(y) == 0) 391 atf_tc_fail_nonfatal("floor(-0.0) != -0.0"); 392 } 393 394 ATF_TC(floor_zero_pos); 395 ATF_TC_HEAD(floor_zero_pos, tc) 396 { 397 atf_tc_set_md_var(tc, "descr", "Test floor(+0.0) == +0.0"); 398 } 399 400 ATF_TC_BODY(floor_zero_pos, tc) 401 { 402 const double x = 0.0L; 403 double y = floor(x); 404 405 if (fabs(y) > 0.0 || signbit(y) != 0) 406 atf_tc_fail_nonfatal("floor(+0.0) != +0.0"); 407 } 408 409 /* 410 * floorf(3) 411 */ 412 ATF_TC(floorf_basic); 413 ATF_TC_HEAD(floorf_basic, tc) 414 { 415 atf_tc_set_md_var(tc, "descr", "A basic test of floorf(3)"); 416 } 417 418 ATF_TC_BODY(floorf_basic, tc) 419 { 420 const float x = 0.9999999; 421 const float y = 0.0000001; 422 423 ATF_CHECK(floorf(x) < SMALL_NUM); 424 ATF_CHECK(floorf(y) < SMALL_NUM); 425 } 426 427 ATF_TC(floorf_nan); 428 ATF_TC_HEAD(floorf_nan, tc) 429 { 430 atf_tc_set_md_var(tc, "descr", "Test floorf(NaN) == NaN"); 431 } 432 433 ATF_TC_BODY(floorf_nan, tc) 434 { 435 const float x = 0.0L / 0.0L; 436 437 ATF_CHECK(isnan(floorf(x)) != 0); 438 } 439 440 ATF_TC(floorf_inf_neg); 441 ATF_TC_HEAD(floorf_inf_neg, tc) 442 { 443 atf_tc_set_md_var(tc, "descr", "Test floorf(-Inf) == -Inf"); 444 } 445 446 ATF_TC_BODY(floorf_inf_neg, tc) 447 { 448 const float x = -1.0L / 0.0L; 449 float y = floorf(x); 450 451 if (isinf(y) == 0 || signbit(y) == 0) 452 atf_tc_fail_nonfatal("floorf(-Inf) != -Inf"); 453 } 454 455 ATF_TC(floorf_inf_pos); 456 ATF_TC_HEAD(floorf_inf_pos, tc) 457 { 458 atf_tc_set_md_var(tc, "descr", "Test floorf(+Inf) == +Inf"); 459 } 460 461 ATF_TC_BODY(floorf_inf_pos, tc) 462 { 463 const float x = 1.0L / 0.0L; 464 float y = floorf(x); 465 466 if (isinf(y) == 0 || signbit(y) != 0) 467 atf_tc_fail_nonfatal("floorf(+Inf) != +Inf"); 468 } 469 470 ATF_TC(floorf_zero_neg); 471 ATF_TC_HEAD(floorf_zero_neg, tc) 472 { 473 atf_tc_set_md_var(tc, "descr", "Test floorf(-0.0) == -0.0"); 474 } 475 476 ATF_TC_BODY(floorf_zero_neg, tc) 477 { 478 const float x = -0.0L; 479 float y = floorf(x); 480 481 if (fabsf(y) > 0.0 || signbit(y) == 0) 482 atf_tc_fail_nonfatal("floorf(-0.0) != -0.0"); 483 } 484 485 ATF_TC(floorf_zero_pos); 486 ATF_TC_HEAD(floorf_zero_pos, tc) 487 { 488 atf_tc_set_md_var(tc, "descr", "Test floorf(+0.0) == +0.0"); 489 } 490 491 ATF_TC_BODY(floorf_zero_pos, tc) 492 { 493 const float x = 0.0L; 494 float y = floorf(x); 495 496 if (fabsf(y) > 0.0 || signbit(y) != 0) 497 atf_tc_fail_nonfatal("floorf(+0.0) != +0.0"); 498 } 499 500 /* 501 * floorl(3) 502 */ 503 ATF_TC(floorl_basic); 504 ATF_TC_HEAD(floorl_basic, tc) 505 { 506 atf_tc_set_md_var(tc, "descr", "A basic test of floorl(3)"); 507 } 508 509 ATF_TC_BODY(floorl_basic, tc) 510 { 511 const long double x = 0.9999999; 512 const long double y = 0.0000001; 513 514 ATF_CHECK(floorl(x) < SMALL_NUM); 515 ATF_CHECK(floorl(y) < SMALL_NUM); 516 } 517 518 ATF_TC(floorl_nan); 519 ATF_TC_HEAD(floorl_nan, tc) 520 { 521 atf_tc_set_md_var(tc, "descr", "Test floorl(NaN) == NaN"); 522 } 523 524 ATF_TC_BODY(floorl_nan, tc) 525 { 526 const long double x = 0.0L / 0.0L; 527 528 ATF_CHECK(isnan(floorl(x)) != 0); 529 } 530 531 ATF_TC(floorl_inf_neg); 532 ATF_TC_HEAD(floorl_inf_neg, tc) 533 { 534 atf_tc_set_md_var(tc, "descr", "Test floorl(-Inf) == -Inf"); 535 } 536 537 ATF_TC_BODY(floorl_inf_neg, tc) 538 { 539 const long double x = -1.0L / 0.0L; 540 long double y = floorl(x); 541 542 if (isinf(y) == 0 || signbit(y) == 0) 543 atf_tc_fail_nonfatal("floorl(-Inf) != -Inf"); 544 } 545 546 ATF_TC(floorl_inf_pos); 547 ATF_TC_HEAD(floorl_inf_pos, tc) 548 { 549 atf_tc_set_md_var(tc, "descr", "Test floorl(+Inf) == +Inf"); 550 } 551 552 ATF_TC_BODY(floorl_inf_pos, tc) 553 { 554 const long double x = 1.0L / 0.0L; 555 long double y = floorl(x); 556 557 if (isinf(y) == 0 || signbit(y) != 0) 558 atf_tc_fail_nonfatal("floorl(+Inf) != +Inf"); 559 } 560 561 ATF_TC(floorl_zero_neg); 562 ATF_TC_HEAD(floorl_zero_neg, tc) 563 { 564 atf_tc_set_md_var(tc, "descr", "Test floorl(-0.0) == -0.0"); 565 } 566 567 ATF_TC_BODY(floorl_zero_neg, tc) 568 { 569 const long double x = -0.0L; 570 long double y = floorl(x); 571 572 if (fabsl(y) > 0.0 || signbit(y) == 0) 573 atf_tc_fail_nonfatal("floorl(-0.0) != -0.0"); 574 } 575 576 ATF_TC(floorl_zero_pos); 577 ATF_TC_HEAD(floorl_zero_pos, tc) 578 { 579 atf_tc_set_md_var(tc, "descr", "Test floorl(+0.0) == +0.0"); 580 } 581 582 ATF_TC_BODY(floorl_zero_pos, tc) 583 { 584 const long double x = 0.0L; 585 long double y = floorl(x); 586 587 if (fabsl(y) > 0.0 || signbit(y) != 0) 588 atf_tc_fail_nonfatal("floorl(+0.0) != +0.0"); 589 } 590 591 /* 592 * trunc(3) 593 */ 594 ATF_TC(trunc_basic); 595 ATF_TC_HEAD(trunc_basic, tc) 596 { 597 atf_tc_set_md_var(tc, "descr", "A basic test of trunc(3)"); 598 } 599 600 ATF_TC_BODY(trunc_basic, tc) 601 { 602 const double x = 0.999999999999999; 603 const double y = 0.000000000000001; 604 605 ATF_CHECK(trunc(x) < SMALL_NUM); 606 ATF_CHECK(trunc(y) < SMALL_NUM); 607 } 608 609 ATF_TC(trunc_nan); 610 ATF_TC_HEAD(trunc_nan, tc) 611 { 612 atf_tc_set_md_var(tc, "descr", "Test trunc(NaN) == NaN"); 613 } 614 615 ATF_TC_BODY(trunc_nan, tc) 616 { 617 const double x = 0.0L / 0.0L; 618 619 ATF_CHECK(isnan(trunc(x)) != 0); 620 } 621 622 ATF_TC(trunc_inf_neg); 623 ATF_TC_HEAD(trunc_inf_neg, tc) 624 { 625 atf_tc_set_md_var(tc, "descr", "Test trunc(-Inf) == -Inf"); 626 } 627 628 ATF_TC_BODY(trunc_inf_neg, tc) 629 { 630 const double x = -1.0L / 0.0L; 631 double y = trunc(x); 632 633 if (isinf(y) == 0 || signbit(y) == 0) 634 atf_tc_fail_nonfatal("trunc(-Inf) != -Inf"); 635 } 636 637 ATF_TC(trunc_inf_pos); 638 ATF_TC_HEAD(trunc_inf_pos, tc) 639 { 640 atf_tc_set_md_var(tc, "descr", "Test trunc(+Inf) == +Inf"); 641 } 642 643 ATF_TC_BODY(trunc_inf_pos, tc) 644 { 645 const double x = 1.0L / 0.0L; 646 double y = trunc(x); 647 648 if (isinf(y) == 0 || signbit(y) != 0) 649 atf_tc_fail_nonfatal("trunc(+Inf) != +Inf"); 650 } 651 652 ATF_TC(trunc_zero_neg); 653 ATF_TC_HEAD(trunc_zero_neg, tc) 654 { 655 atf_tc_set_md_var(tc, "descr", "Test trunc(-0.0) == -0.0"); 656 } 657 658 ATF_TC_BODY(trunc_zero_neg, tc) 659 { 660 const double x = -0.0L; 661 double y = trunc(x); 662 663 if (fabs(y) > 0.0 || signbit(y) == 0) 664 atf_tc_fail_nonfatal("trunc(-0.0) != -0.0"); 665 } 666 667 ATF_TC(trunc_zero_pos); 668 ATF_TC_HEAD(trunc_zero_pos, tc) 669 { 670 atf_tc_set_md_var(tc, "descr", "Test trunc(+0.0) == +0.0"); 671 } 672 673 ATF_TC_BODY(trunc_zero_pos, tc) 674 { 675 const double x = 0.0L; 676 double y = trunc(x); 677 678 if (fabs(y) > 0.0 || signbit(y) != 0) 679 atf_tc_fail_nonfatal("trunc(+0.0) != +0.0"); 680 } 681 682 /* 683 * truncf(3) 684 */ 685 ATF_TC(truncf_basic); 686 ATF_TC_HEAD(truncf_basic, tc) 687 { 688 atf_tc_set_md_var(tc, "descr", "A basic test of truncf(3)"); 689 } 690 691 ATF_TC_BODY(truncf_basic, tc) 692 { 693 const float x = 0.9999999; 694 const float y = 0.0000001; 695 696 ATF_CHECK(truncf(x) < SMALL_NUM); 697 ATF_CHECK(truncf(y) < SMALL_NUM); 698 } 699 700 ATF_TC(truncf_nan); 701 ATF_TC_HEAD(truncf_nan, tc) 702 { 703 atf_tc_set_md_var(tc, "descr", "Test truncf(NaN) == NaN"); 704 } 705 706 ATF_TC_BODY(truncf_nan, tc) 707 { 708 const float x = 0.0L / 0.0L; 709 710 ATF_CHECK(isnan(truncf(x)) != 0); 711 } 712 713 ATF_TC(truncf_inf_neg); 714 ATF_TC_HEAD(truncf_inf_neg, tc) 715 { 716 atf_tc_set_md_var(tc, "descr", "Test truncf(-Inf) == -Inf"); 717 } 718 719 ATF_TC_BODY(truncf_inf_neg, tc) 720 { 721 const float x = -1.0L / 0.0L; 722 float y = truncf(x); 723 724 if (isinf(y) == 0 || signbit(y) == 0) 725 atf_tc_fail_nonfatal("truncf(-Inf) != -Inf"); 726 } 727 728 ATF_TC(truncf_inf_pos); 729 ATF_TC_HEAD(truncf_inf_pos, tc) 730 { 731 atf_tc_set_md_var(tc, "descr", "Test truncf(+Inf) == +Inf"); 732 } 733 734 ATF_TC_BODY(truncf_inf_pos, tc) 735 { 736 const float x = 1.0L / 0.0L; 737 float y = truncf(x); 738 739 if (isinf(y) == 0 || signbit(y) != 0) 740 atf_tc_fail_nonfatal("truncf(+Inf) != +Inf"); 741 } 742 743 ATF_TC(truncf_zero_neg); 744 ATF_TC_HEAD(truncf_zero_neg, tc) 745 { 746 atf_tc_set_md_var(tc, "descr", "Test truncf(-0.0) == -0.0"); 747 } 748 749 ATF_TC_BODY(truncf_zero_neg, tc) 750 { 751 const float x = -0.0L; 752 float y = truncf(x); 753 754 if (fabsf(y) > 0.0 || signbit(y) == 0) 755 atf_tc_fail_nonfatal("truncf(-0.0) != -0.0"); 756 } 757 758 ATF_TC(truncf_zero_pos); 759 ATF_TC_HEAD(truncf_zero_pos, tc) 760 { 761 atf_tc_set_md_var(tc, "descr", "Test truncf(+0.0) == +0.0"); 762 } 763 764 ATF_TC_BODY(truncf_zero_pos, tc) 765 { 766 const float x = 0.0L; 767 float y = truncf(x); 768 769 if (fabsf(y) > 0.0 || signbit(y) != 0) 770 atf_tc_fail_nonfatal("truncf(+0.0) != +0.0"); 771 } 772 773 /* 774 * truncl(3) 775 */ 776 ATF_TC(truncl_basic); 777 ATF_TC_HEAD(truncl_basic, tc) 778 { 779 atf_tc_set_md_var(tc, "descr", "A basic test of truncl(3)"); 780 } 781 782 ATF_TC_BODY(truncl_basic, tc) 783 { 784 const long double x = 0.9999999; 785 const long double y = 0.0000001; 786 787 ATF_CHECK(truncl(x) < SMALL_NUM); 788 ATF_CHECK(truncl(y) < SMALL_NUM); 789 } 790 791 ATF_TC(truncl_nan); 792 ATF_TC_HEAD(truncl_nan, tc) 793 { 794 atf_tc_set_md_var(tc, "descr", "Test truncl(NaN) == NaN"); 795 } 796 797 ATF_TC_BODY(truncl_nan, tc) 798 { 799 const long double x = 0.0L / 0.0L; 800 801 ATF_CHECK(isnan(truncl(x)) != 0); 802 } 803 804 ATF_TC(truncl_inf_neg); 805 ATF_TC_HEAD(truncl_inf_neg, tc) 806 { 807 atf_tc_set_md_var(tc, "descr", "Test truncl(-Inf) == -Inf"); 808 } 809 810 ATF_TC_BODY(truncl_inf_neg, tc) 811 { 812 const long double x = -1.0L / 0.0L; 813 long double y = truncl(x); 814 815 if (isinf(y) == 0 || signbit(y) == 0) 816 atf_tc_fail_nonfatal("truncl(-Inf) != -Inf"); 817 } 818 819 ATF_TC(truncl_inf_pos); 820 ATF_TC_HEAD(truncl_inf_pos, tc) 821 { 822 atf_tc_set_md_var(tc, "descr", "Test truncl(+Inf) == +Inf"); 823 } 824 825 ATF_TC_BODY(truncl_inf_pos, tc) 826 { 827 const long double x = 1.0L / 0.0L; 828 long double y = truncl(x); 829 830 if (isinf(y) == 0 || signbit(y) != 0) 831 atf_tc_fail_nonfatal("truncl(+Inf) != +Inf"); 832 } 833 834 ATF_TC(truncl_zero_neg); 835 ATF_TC_HEAD(truncl_zero_neg, tc) 836 { 837 atf_tc_set_md_var(tc, "descr", "Test truncl(-0.0) == -0.0"); 838 } 839 840 ATF_TC_BODY(truncl_zero_neg, tc) 841 { 842 const long double x = -0.0L; 843 long double y = truncl(x); 844 845 if (fabsl(y) > 0.0 || signbit(y) == 0) 846 atf_tc_fail_nonfatal("truncl(-0.0) != -0.0"); 847 } 848 849 ATF_TC(truncl_zero_pos); 850 ATF_TC_HEAD(truncl_zero_pos, tc) 851 { 852 atf_tc_set_md_var(tc, "descr", "Test truncl(+0.0) == +0.0"); 853 } 854 855 ATF_TC_BODY(truncl_zero_pos, tc) 856 { 857 const long double x = 0.0L; 858 long double y = truncl(x); 859 860 if (fabsl(y) > 0.0 || signbit(y) != 0) 861 atf_tc_fail_nonfatal("truncl(+0.0) != +0.0"); 862 } 863 864 ATF_TP_ADD_TCS(tp) 865 { 866 867 ATF_TP_ADD_TC(tp, ceil_basic); 868 ATF_TP_ADD_TC(tp, ceil_nan); 869 ATF_TP_ADD_TC(tp, ceil_inf_neg); 870 ATF_TP_ADD_TC(tp, ceil_inf_pos); 871 ATF_TP_ADD_TC(tp, ceil_zero_neg); 872 ATF_TP_ADD_TC(tp, ceil_zero_pos); 873 874 ATF_TP_ADD_TC(tp, ceilf_basic); 875 ATF_TP_ADD_TC(tp, ceilf_nan); 876 ATF_TP_ADD_TC(tp, ceilf_inf_neg); 877 ATF_TP_ADD_TC(tp, ceilf_inf_pos); 878 ATF_TP_ADD_TC(tp, ceilf_zero_neg); 879 ATF_TP_ADD_TC(tp, ceilf_zero_pos); 880 881 ATF_TP_ADD_TC(tp, ceill_basic); 882 ATF_TP_ADD_TC(tp, ceill_nan); 883 ATF_TP_ADD_TC(tp, ceill_inf_neg); 884 ATF_TP_ADD_TC(tp, ceill_inf_pos); 885 ATF_TP_ADD_TC(tp, ceill_zero_neg); 886 ATF_TP_ADD_TC(tp, ceill_zero_pos); 887 888 ATF_TP_ADD_TC(tp, floor_basic); 889 ATF_TP_ADD_TC(tp, floor_nan); 890 ATF_TP_ADD_TC(tp, floor_inf_neg); 891 ATF_TP_ADD_TC(tp, floor_inf_pos); 892 ATF_TP_ADD_TC(tp, floor_zero_neg); 893 ATF_TP_ADD_TC(tp, floor_zero_pos); 894 895 ATF_TP_ADD_TC(tp, floorf_basic); 896 ATF_TP_ADD_TC(tp, floorf_nan); 897 ATF_TP_ADD_TC(tp, floorf_inf_neg); 898 ATF_TP_ADD_TC(tp, floorf_inf_pos); 899 ATF_TP_ADD_TC(tp, floorf_zero_neg); 900 ATF_TP_ADD_TC(tp, floorf_zero_pos); 901 902 ATF_TP_ADD_TC(tp, floorl_basic); 903 ATF_TP_ADD_TC(tp, floorl_nan); 904 ATF_TP_ADD_TC(tp, floorl_inf_neg); 905 ATF_TP_ADD_TC(tp, floorl_inf_pos); 906 ATF_TP_ADD_TC(tp, floorl_zero_neg); 907 ATF_TP_ADD_TC(tp, floorl_zero_pos); 908 909 ATF_TP_ADD_TC(tp, trunc_basic); 910 ATF_TP_ADD_TC(tp, trunc_nan); 911 ATF_TP_ADD_TC(tp, trunc_inf_neg); 912 ATF_TP_ADD_TC(tp, trunc_inf_pos); 913 ATF_TP_ADD_TC(tp, trunc_zero_neg); 914 ATF_TP_ADD_TC(tp, trunc_zero_pos); 915 916 ATF_TP_ADD_TC(tp, truncf_basic); 917 ATF_TP_ADD_TC(tp, truncf_nan); 918 ATF_TP_ADD_TC(tp, truncf_inf_neg); 919 ATF_TP_ADD_TC(tp, truncf_inf_pos); 920 ATF_TP_ADD_TC(tp, truncf_zero_neg); 921 ATF_TP_ADD_TC(tp, truncf_zero_pos); 922 923 ATF_TP_ADD_TC(tp, truncl_basic); 924 ATF_TP_ADD_TC(tp, truncl_nan); 925 ATF_TP_ADD_TC(tp, truncl_inf_neg); 926 ATF_TP_ADD_TC(tp, truncl_inf_pos); 927 ATF_TP_ADD_TC(tp, truncl_zero_neg); 928 ATF_TP_ADD_TC(tp, truncl_zero_pos); 929 930 return atf_no_error(); 931 } 932