tests/lib/libm/t_ceil.c

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