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