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