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