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 */ 44ATF_TC(log10_base); 45ATF_TC_HEAD(log10_base, tc) 46{ 47 atf_tc_set_md_var(tc, "descr", "Test log10(10) == 1"); 48} 49 50ATF_TC_BODY(log10_base, tc) 51{ 52 ATF_CHECK(log10(10.0) == 1.0); 53} 54 55ATF_TC(log10_nan); 56ATF_TC_HEAD(log10_nan, tc) 57{ 58 atf_tc_set_md_var(tc, "descr", "Test log10(NaN) == NaN"); 59} 60 61ATF_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 69ATF_TC(log10_inf_neg); 70ATF_TC_HEAD(log10_inf_neg, tc) 71{ 72 atf_tc_set_md_var(tc, "descr", "Test log10(-Inf) == NaN"); 73} 74 75ATF_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 83ATF_TC(log10_inf_pos); 84ATF_TC_HEAD(log10_inf_pos, tc) 85{ 86 atf_tc_set_md_var(tc, "descr", "Test log10(+Inf) == +Inf"); 87} 88 89ATF_TC_BODY(log10_inf_pos, tc) 90{ 91 const double x = 1.0L / 0.0L; 92 93 ATF_CHECK(log10(x) == x); 94} 95 96ATF_TC(log10_one_pos); 97ATF_TC_HEAD(log10_one_pos, tc) 98{ 99 atf_tc_set_md_var(tc, "descr", "Test log10(1.0) == +0.0"); 100} 101 102ATF_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 112ATF_TC(log10_zero_neg); 113ATF_TC_HEAD(log10_zero_neg, tc) 114{ 115 atf_tc_set_md_var(tc, "descr", "Test log10(-0.0) == -HUGE_VAL"); 116} 117 118ATF_TC_BODY(log10_zero_neg, tc) 119{ 120 const double x = -0.0L; 121 122 ATF_CHECK(log10(x) == -HUGE_VAL); 123} 124 125ATF_TC(log10_zero_pos); 126ATF_TC_HEAD(log10_zero_pos, tc) 127{ 128 atf_tc_set_md_var(tc, "descr", "Test log10(+0.0) == -HUGE_VAL"); 129} 130 131ATF_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 */ 141ATF_TC(log10f_base); 142ATF_TC_HEAD(log10f_base, tc) 143{ 144 atf_tc_set_md_var(tc, "descr", "Test log10f(10) == 1"); 145} 146 147ATF_TC_BODY(log10f_base, tc) 148{ 149 ATF_CHECK(log10f(10.0) == 1.0); 150} 151 152ATF_TC(log10f_nan); 153ATF_TC_HEAD(log10f_nan, tc) 154{ 155 atf_tc_set_md_var(tc, "descr", "Test log10f(NaN) == NaN"); 156} 157 158ATF_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 166ATF_TC(log10f_inf_neg); 167ATF_TC_HEAD(log10f_inf_neg, tc) 168{ 169 atf_tc_set_md_var(tc, "descr", "Test log10f(-Inf) == NaN"); 170} 171 172ATF_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 180ATF_TC(log10f_inf_pos); 181ATF_TC_HEAD(log10f_inf_pos, tc) 182{ 183 atf_tc_set_md_var(tc, "descr", "Test log10f(+Inf) == +Inf"); 184} 185 186ATF_TC_BODY(log10f_inf_pos, tc) 187{ 188 const float x = 1.0L / 0.0L; 189 190 ATF_CHECK(log10f(x) == x); 191} 192 193ATF_TC(log10f_one_pos); 194ATF_TC_HEAD(log10f_one_pos, tc) 195{ 196 atf_tc_set_md_var(tc, "descr", "Test log10f(1.0) == +0.0"); 197} 198 199ATF_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 209ATF_TC(log10f_zero_neg); 210ATF_TC_HEAD(log10f_zero_neg, tc) 211{ 212 atf_tc_set_md_var(tc, "descr", "Test log10f(-0.0) == -HUGE_VALF"); 213} 214 215ATF_TC_BODY(log10f_zero_neg, tc) 216{ 217 const float x = -0.0L; 218 219 ATF_CHECK(log10f(x) == -HUGE_VALF); 220} 221 222ATF_TC(log10f_zero_pos); 223ATF_TC_HEAD(log10f_zero_pos, tc) 224{ 225 atf_tc_set_md_var(tc, "descr", "Test log10f(+0.0) == -HUGE_VALF"); 226} 227 228ATF_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 */ 238ATF_TC(log1p_nan); 239ATF_TC_HEAD(log1p_nan, tc) 240{ 241 atf_tc_set_md_var(tc, "descr", "Test log1p(NaN) == NaN"); 242} 243 244ATF_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 252ATF_TC(log1p_inf_neg); 253ATF_TC_HEAD(log1p_inf_neg, tc) 254{ 255 atf_tc_set_md_var(tc, "descr", "Test log1p(-Inf) == NaN"); 256} 257 258ATF_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 266ATF_TC(log1p_inf_pos); 267ATF_TC_HEAD(log1p_inf_pos, tc) 268{ 269 atf_tc_set_md_var(tc, "descr", "Test log1p(+Inf) == +Inf"); 270} 271 272ATF_TC_BODY(log1p_inf_pos, tc) 273{ 274 const double x = 1.0L / 0.0L; 275 276 ATF_CHECK(log1p(x) == x); 277} 278 279ATF_TC(log1p_one_neg); 280ATF_TC_HEAD(log1p_one_neg, tc) 281{ 282 atf_tc_set_md_var(tc, "descr", "Test log1p(-1.0) == -HUGE_VAL"); 283} 284 285ATF_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 293ATF_TC(log1p_zero_neg); 294ATF_TC_HEAD(log1p_zero_neg, tc) 295{ 296 atf_tc_set_md_var(tc, "descr", "Test log1p(-0.0) == -0.0"); 297} 298 299ATF_TC_BODY(log1p_zero_neg, tc) 300{ 301 const double x = -0.0L; 302 303 ATF_CHECK(log1p(x) == x); 304} 305 306ATF_TC(log1p_zero_pos); 307ATF_TC_HEAD(log1p_zero_pos, tc) 308{ 309 atf_tc_set_md_var(tc, "descr", "Test log1p(+0.0) == +0.0"); 310} 311 312ATF_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 */ 322ATF_TC(log1pf_nan); 323ATF_TC_HEAD(log1pf_nan, tc) 324{ 325 atf_tc_set_md_var(tc, "descr", "Test log1pf(NaN) == NaN"); 326} 327 328ATF_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 336ATF_TC(log1pf_inf_neg); 337ATF_TC_HEAD(log1pf_inf_neg, tc) 338{ 339 atf_tc_set_md_var(tc, "descr", "Test log1pf(-Inf) == NaN"); 340} 341 342ATF_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 350ATF_TC(log1pf_inf_pos); 351ATF_TC_HEAD(log1pf_inf_pos, tc) 352{ 353 atf_tc_set_md_var(tc, "descr", "Test log1pf(+Inf) == +Inf"); 354} 355 356ATF_TC_BODY(log1pf_inf_pos, tc) 357{ 358 const float x = 1.0L / 0.0L; 359 360 ATF_CHECK(log1pf(x) == x); 361} 362 363ATF_TC(log1pf_one_neg); 364ATF_TC_HEAD(log1pf_one_neg, tc) 365{ 366 atf_tc_set_md_var(tc, "descr", "Test log1pf(-1.0) == -HUGE_VALF"); 367} 368 369ATF_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 377ATF_TC(log1pf_zero_neg); 378ATF_TC_HEAD(log1pf_zero_neg, tc) 379{ 380 atf_tc_set_md_var(tc, "descr", "Test log1pf(-0.0) == -0.0"); 381} 382 383ATF_TC_BODY(log1pf_zero_neg, tc) 384{ 385 const float x = -0.0L; 386 387 ATF_CHECK(log1pf(x) == x); 388} 389 390ATF_TC(log1pf_zero_pos); 391ATF_TC_HEAD(log1pf_zero_pos, tc) 392{ 393 atf_tc_set_md_var(tc, "descr", "Test log1pf(+0.0) == +0.0"); 394} 395 396ATF_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 */ 406ATF_TC(log2_base); 407ATF_TC_HEAD(log2_base, tc) 408{ 409 atf_tc_set_md_var(tc, "descr", "Test log2(2) == 1"); 410} 411 412ATF_TC_BODY(log2_base, tc) 413{ 414 ATF_CHECK(log2(2.0) == 1.0); 415} 416 417ATF_TC(log2_nan); 418ATF_TC_HEAD(log2_nan, tc) 419{ 420 atf_tc_set_md_var(tc, "descr", "Test log2(NaN) == NaN"); 421} 422 423ATF_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 431ATF_TC(log2_inf_neg); 432ATF_TC_HEAD(log2_inf_neg, tc) 433{ 434 atf_tc_set_md_var(tc, "descr", "Test log2(-Inf) == NaN"); 435} 436 437ATF_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 445ATF_TC(log2_inf_pos); 446ATF_TC_HEAD(log2_inf_pos, tc) 447{ 448 atf_tc_set_md_var(tc, "descr", "Test log2(+Inf) == +Inf"); 449} 450 451ATF_TC_BODY(log2_inf_pos, tc) 452{ 453 const double x = 1.0L / 0.0L; 454 455 ATF_CHECK(log2(x) == x); 456} 457 458ATF_TC(log2_one_pos); 459ATF_TC_HEAD(log2_one_pos, tc) 460{ 461 atf_tc_set_md_var(tc, "descr", "Test log2(1.0) == +0.0"); 462} 463 464ATF_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 474ATF_TC(log2_zero_neg); 475ATF_TC_HEAD(log2_zero_neg, tc) 476{ 477 atf_tc_set_md_var(tc, "descr", "Test log2(-0.0) == -HUGE_VAL"); 478} 479 480ATF_TC_BODY(log2_zero_neg, tc) 481{ 482 const double x = -0.0L; 483 484 ATF_CHECK(log2(x) == -HUGE_VAL); 485} 486 487ATF_TC(log2_zero_pos); 488ATF_TC_HEAD(log2_zero_pos, tc) 489{ 490 atf_tc_set_md_var(tc, "descr", "Test log2(+0.0) == -HUGE_VAL"); 491} 492 493ATF_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 */ 503ATF_TC(log2f_base); 504ATF_TC_HEAD(log2f_base, tc) 505{ 506 atf_tc_set_md_var(tc, "descr", "Test log2f(2) == 1"); 507} 508 509ATF_TC_BODY(log2f_base, tc) 510{ 511 ATF_CHECK(log2f(2.0) == 1.0); 512} 513 514ATF_TC(log2f_nan); 515ATF_TC_HEAD(log2f_nan, tc) 516{ 517 atf_tc_set_md_var(tc, "descr", "Test log2f(NaN) == NaN"); 518} 519 520ATF_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 528ATF_TC(log2f_inf_neg); 529ATF_TC_HEAD(log2f_inf_neg, tc) 530{ 531 atf_tc_set_md_var(tc, "descr", "Test log2f(-Inf) == NaN"); 532} 533 534ATF_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 542ATF_TC(log2f_inf_pos); 543ATF_TC_HEAD(log2f_inf_pos, tc) 544{ 545 atf_tc_set_md_var(tc, "descr", "Test log2f(+Inf) == +Inf"); 546} 547 548ATF_TC_BODY(log2f_inf_pos, tc) 549{ 550 const float x = 1.0L / 0.0L; 551 552 ATF_CHECK(log2f(x) == x); 553} 554 555ATF_TC(log2f_one_pos); 556ATF_TC_HEAD(log2f_one_pos, tc) 557{ 558 atf_tc_set_md_var(tc, "descr", "Test log2f(1.0) == +0.0"); 559} 560 561ATF_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 571ATF_TC(log2f_zero_neg); 572ATF_TC_HEAD(log2f_zero_neg, tc) 573{ 574 atf_tc_set_md_var(tc, "descr", "Test log2f(-0.0) == -HUGE_VALF"); 575} 576 577ATF_TC_BODY(log2f_zero_neg, tc) 578{ 579 const float x = -0.0L; 580 581 ATF_CHECK(log2f(x) == -HUGE_VALF); 582} 583 584ATF_TC(log2f_zero_pos); 585ATF_TC_HEAD(log2f_zero_pos, tc) 586{ 587 atf_tc_set_md_var(tc, "descr", "Test log2f(+0.0) == -HUGE_VALF"); 588} 589 590ATF_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 */ 600ATF_TC(log_base); 601ATF_TC_HEAD(log_base, tc) 602{ 603 atf_tc_set_md_var(tc, "descr", "Test log(e) == 1"); 604} 605 606ATF_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 614ATF_TC(log_nan); 615ATF_TC_HEAD(log_nan, tc) 616{ 617 atf_tc_set_md_var(tc, "descr", "Test log(NaN) == NaN"); 618} 619 620ATF_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 628ATF_TC(log_inf_neg); 629ATF_TC_HEAD(log_inf_neg, tc) 630{ 631 atf_tc_set_md_var(tc, "descr", "Test log(-Inf) == NaN"); 632} 633 634ATF_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 642ATF_TC(log_inf_pos); 643ATF_TC_HEAD(log_inf_pos, tc) 644{ 645 atf_tc_set_md_var(tc, "descr", "Test log(+Inf) == +Inf"); 646} 647 648ATF_TC_BODY(log_inf_pos, tc) 649{ 650 const double x = 1.0L / 0.0L; 651 652 ATF_CHECK(log(x) == x); 653} 654 655ATF_TC(log_one_pos); 656ATF_TC_HEAD(log_one_pos, tc) 657{ 658 atf_tc_set_md_var(tc, "descr", "Test log(1.0) == +0.0"); 659} 660 661ATF_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 671ATF_TC(log_zero_neg); 672ATF_TC_HEAD(log_zero_neg, tc) 673{ 674 atf_tc_set_md_var(tc, "descr", "Test log(-0.0) == -HUGE_VAL"); 675} 676 677ATF_TC_BODY(log_zero_neg, tc) 678{ 679 const double x = -0.0L; 680 681 ATF_CHECK(log(x) == -HUGE_VAL); 682} 683 684ATF_TC(log_zero_pos); 685ATF_TC_HEAD(log_zero_pos, tc) 686{ 687 atf_tc_set_md_var(tc, "descr", "Test log(+0.0) == -HUGE_VAL"); 688} 689 690ATF_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 */ 700ATF_TC(logf_base); 701ATF_TC_HEAD(logf_base, tc) 702{ 703 atf_tc_set_md_var(tc, "descr", "Test logf(e) == 1"); 704} 705 706ATF_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 715ATF_TC(logf_nan); 716ATF_TC_HEAD(logf_nan, tc) 717{ 718 atf_tc_set_md_var(tc, "descr", "Test logf(NaN) == NaN"); 719} 720 721ATF_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 729ATF_TC(logf_inf_neg); 730ATF_TC_HEAD(logf_inf_neg, tc) 731{ 732 atf_tc_set_md_var(tc, "descr", "Test logf(-Inf) == NaN"); 733} 734 735ATF_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 743ATF_TC(logf_inf_pos); 744ATF_TC_HEAD(logf_inf_pos, tc) 745{ 746 atf_tc_set_md_var(tc, "descr", "Test logf(+Inf) == +Inf"); 747} 748 749ATF_TC_BODY(logf_inf_pos, tc) 750{ 751 const float x = 1.0L / 0.0L; 752 753 ATF_CHECK(logf(x) == x); 754} 755 756ATF_TC(logf_one_pos); 757ATF_TC_HEAD(logf_one_pos, tc) 758{ 759 atf_tc_set_md_var(tc, "descr", "Test logf(1.0) == +0.0"); 760} 761 762ATF_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 772ATF_TC(logf_zero_neg); 773ATF_TC_HEAD(logf_zero_neg, tc) 774{ 775 atf_tc_set_md_var(tc, "descr", "Test logf(-0.0) == -HUGE_VALF"); 776} 777 778ATF_TC_BODY(logf_zero_neg, tc) 779{ 780 const float x = -0.0L; 781 782 ATF_CHECK(logf(x) == -HUGE_VALF); 783} 784 785ATF_TC(logf_zero_pos); 786ATF_TC_HEAD(logf_zero_pos, tc) 787{ 788 atf_tc_set_md_var(tc, "descr", "Test logf(+0.0) == -HUGE_VALF"); 789} 790 791ATF_TC_BODY(logf_zero_pos, tc) 792{ 793 const float x = 0.0L; 794 795 ATF_CHECK(logf(x) == -HUGE_VALF); 796} 797 798ATF_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