t_ceil.c revision 1.8
1 /* $NetBSD: t_ceil.c,v 1.8 2013/11/11 23:57:34 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.8 2013/11/11 23:57:34 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 ATF_TP_ADD_TCS(tp) 652 { 653 654 ATF_TP_ADD_TC(tp, ceil_basic); 655 ATF_TP_ADD_TC(tp, ceil_nan); 656 ATF_TP_ADD_TC(tp, ceil_inf_neg); 657 ATF_TP_ADD_TC(tp, ceil_inf_pos); 658 ATF_TP_ADD_TC(tp, ceil_zero_neg); 659 ATF_TP_ADD_TC(tp, ceil_zero_pos); 660 661 ATF_TP_ADD_TC(tp, ceilf_basic); 662 ATF_TP_ADD_TC(tp, ceilf_nan); 663 ATF_TP_ADD_TC(tp, ceilf_inf_neg); 664 ATF_TP_ADD_TC(tp, ceilf_inf_pos); 665 ATF_TP_ADD_TC(tp, ceilf_zero_neg); 666 ATF_TP_ADD_TC(tp, ceilf_zero_pos); 667 668 ATF_TP_ADD_TC(tp, ceill_basic); 669 ATF_TP_ADD_TC(tp, ceill_nan); 670 ATF_TP_ADD_TC(tp, ceill_inf_neg); 671 ATF_TP_ADD_TC(tp, ceill_inf_pos); 672 ATF_TP_ADD_TC(tp, ceill_zero_neg); 673 ATF_TP_ADD_TC(tp, ceill_zero_pos); 674 675 ATF_TP_ADD_TC(tp, floor_basic); 676 ATF_TP_ADD_TC(tp, floor_nan); 677 ATF_TP_ADD_TC(tp, floor_inf_neg); 678 ATF_TP_ADD_TC(tp, floor_inf_pos); 679 ATF_TP_ADD_TC(tp, floor_zero_neg); 680 ATF_TP_ADD_TC(tp, floor_zero_pos); 681 682 ATF_TP_ADD_TC(tp, floorf_basic); 683 ATF_TP_ADD_TC(tp, floorf_nan); 684 ATF_TP_ADD_TC(tp, floorf_inf_neg); 685 ATF_TP_ADD_TC(tp, floorf_inf_pos); 686 ATF_TP_ADD_TC(tp, floorf_zero_neg); 687 ATF_TP_ADD_TC(tp, floorf_zero_pos); 688 689 ATF_TP_ADD_TC(tp, floorl_basic); 690 ATF_TP_ADD_TC(tp, floorl_nan); 691 ATF_TP_ADD_TC(tp, floorl_inf_neg); 692 ATF_TP_ADD_TC(tp, floorl_inf_pos); 693 ATF_TP_ADD_TC(tp, floorl_zero_neg); 694 ATF_TP_ADD_TC(tp, floorl_zero_pos); 695 696 return atf_no_error(); 697 } 698
Indexes created Tue Sep 30 11:09:46 GMT 2025