tests/lib/libm/t_log.c

   1 /* $NetBSD: t_log.c,v 1.8 2012/04/08 09:36:04 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.8 2012/04/08 09:36:04 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         ATF_CHECK(log1pf(x) == x);
 413 #endif
 414 }
 415
 416 ATF_TC(log1pf_one_neg);
 417 ATF_TC_HEAD(log1pf_one_neg, tc)
 418 {
 419         atf_tc_set_md_var(tc, "descr", "Test log1pf(-1.0) == -HUGE_VALF");
 420 }
 421
 422 ATF_TC_BODY(log1pf_one_neg, tc)
 423 {
 424 #ifndef __vax__
 425         const float x = log1pf(-1.0);
 426
 427         if (x != -HUGE_VALF) {
 428                 atf_tc_expect_fail("PR lib/45362");
 429                 atf_tc_fail("log1pf(-1.0) != -HUGE_VALF");
 430         }
 431 #endif
 432 }
 433
 434 ATF_TC(log1pf_zero_neg);
 435 ATF_TC_HEAD(log1pf_zero_neg, tc)
 436 {
 437         atf_tc_set_md_var(tc, "descr", "Test log1pf(-0.0) == -0.0");
 438 }
 439
 440 ATF_TC_BODY(log1pf_zero_neg, tc)
 441 {
 442 #ifndef __vax__
 443         const float x = -0.0L;
 444
 445         ATF_CHECK(log1pf(x) == x);
 446 #endif
 447 }
 448
 449 ATF_TC(log1pf_zero_pos);
 450 ATF_TC_HEAD(log1pf_zero_pos, tc)
 451 {
 452         atf_tc_set_md_var(tc, "descr", "Test log1pf(+0.0) == +0.0");
 453 }
 454
 455 ATF_TC_BODY(log1pf_zero_pos, tc)
 456 {
 457 #ifndef __vax__
 458         const float x = 0.0L;
 459
 460         ATF_CHECK(log1pf(x) == x);
 461 #endif
 462 }
 463
 464 /*
 465  * log2(3)
 466  */
 467 ATF_TC(log2_base);
 468 ATF_TC_HEAD(log2_base, tc)
 469 {
 470         atf_tc_set_md_var(tc, "descr", "Test log2(2) == 1");
 471 }
 472
 473 ATF_TC_BODY(log2_base, tc)
 474 {
 475         ATF_CHECK(log2(2.0) == 1.0);
 476 }
 477
 478 ATF_TC(log2_nan);
 479 ATF_TC_HEAD(log2_nan, tc)
 480 {
 481         atf_tc_set_md_var(tc, "descr", "Test log2(NaN) == NaN");
 482 }
 483
 484 ATF_TC_BODY(log2_nan, tc)
 485 {
 486 #ifndef __vax__
 487         const double x = 0.0L / 0.0L;
 488
 489         ATF_CHECK(isnan(x) != 0);
 490         ATF_CHECK(isnan(log2(x)) != 0);
 491 #endif
 492 }
 493
 494 ATF_TC(log2_inf_neg);
 495 ATF_TC_HEAD(log2_inf_neg, tc)
 496 {
 497         atf_tc_set_md_var(tc, "descr", "Test log2(-Inf) == NaN");
 498 }
 499
 500 ATF_TC_BODY(log2_inf_neg, tc)
 501 {
 502 #ifndef __vax__
 503         const double x = -1.0L / 0.0L;
 504         const double y = log2(x);
 505
 506         ATF_CHECK(isnan(y) != 0);
 507 #endif
 508 }
 509
 510 ATF_TC(log2_inf_pos);
 511 ATF_TC_HEAD(log2_inf_pos, tc)
 512 {
 513         atf_tc_set_md_var(tc, "descr", "Test log2(+Inf) == +Inf");
 514 }
 515
 516 ATF_TC_BODY(log2_inf_pos, tc)
 517 {
 518 #ifndef __vax__
 519         const double x = 1.0L / 0.0L;
 520
 521         ATF_CHECK(log2(x) == x);
 522 #endif
 523 }
 524
 525 ATF_TC(log2_one_pos);
 526 ATF_TC_HEAD(log2_one_pos, tc)
 527 {
 528         atf_tc_set_md_var(tc, "descr", "Test log2(1.0) == +0.0");
 529 }
 530
 531 ATF_TC_BODY(log2_one_pos, tc)
 532 {
 533 #ifndef __vax__
 534         const double x = log2(1.0);
 535         const double y = 0.0L;
 536
 537         ATF_CHECK(x == y);
 538         ATF_CHECK(signbit(x) == 0);
 539         ATF_CHECK(signbit(y) == 0);
 540 #endif
 541 }
 542
 543 ATF_TC(log2_zero_neg);
 544 ATF_TC_HEAD(log2_zero_neg, tc)
 545 {
 546         atf_tc_set_md_var(tc, "descr", "Test log2(-0.0) == -HUGE_VAL");
 547 }
 548
 549 ATF_TC_BODY(log2_zero_neg, tc)
 550 {
 551 #ifndef __vax__
 552         const double x = -0.0L;
 553
 554         ATF_CHECK(log2(x) == -HUGE_VAL);
 555 #endif
 556 }
 557
 558 ATF_TC(log2_zero_pos);
 559 ATF_TC_HEAD(log2_zero_pos, tc)
 560 {
 561         atf_tc_set_md_var(tc, "descr", "Test log2(+0.0) == -HUGE_VAL");
 562 }
 563
 564 ATF_TC_BODY(log2_zero_pos, tc)
 565 {
 566 #ifndef __vax__
 567         const double x = 0.0L;
 568
 569         ATF_CHECK(log2(x) == -HUGE_VAL);
 570 #endif
 571 }
 572
 573 /*
 574  * log2f(3)
 575  */
 576 ATF_TC(log2f_base);
 577 ATF_TC_HEAD(log2f_base, tc)
 578 {
 579         atf_tc_set_md_var(tc, "descr", "Test log2f(2) == 1");
 580 }
 581
 582 ATF_TC_BODY(log2f_base, tc)
 583 {
 584         ATF_CHECK(log2f(2.0) == 1.0);
 585 }
 586
 587 ATF_TC(log2f_nan);
 588 ATF_TC_HEAD(log2f_nan, tc)
 589 {
 590         atf_tc_set_md_var(tc, "descr", "Test log2f(NaN) == NaN");
 591 }
 592
 593 ATF_TC_BODY(log2f_nan, tc)
 594 {
 595 #ifndef __vax__
 596         const float x = 0.0L / 0.0L;
 597
 598         ATF_CHECK(isnan(x) != 0);
 599         ATF_CHECK(isnan(log2f(x)) != 0);
 600 #endif
 601 }
 602
 603 ATF_TC(log2f_inf_neg);
 604 ATF_TC_HEAD(log2f_inf_neg, tc)
 605 {
 606         atf_tc_set_md_var(tc, "descr", "Test log2f(-Inf) == NaN");
 607 }
 608
 609 ATF_TC_BODY(log2f_inf_neg, tc)
 610 {
 611 #ifndef __vax__
 612         const float x = -1.0L / 0.0L;
 613         const float y = log2f(x);
 614
 615         ATF_CHECK(isnan(y) != 0);
 616 #endif
 617 }
 618
 619 ATF_TC(log2f_inf_pos);
 620 ATF_TC_HEAD(log2f_inf_pos, tc)
 621 {
 622         atf_tc_set_md_var(tc, "descr", "Test log2f(+Inf) == +Inf");
 623 }
 624
 625 ATF_TC_BODY(log2f_inf_pos, tc)
 626 {
 627 #ifndef __vax__
 628         const float x = 1.0L / 0.0L;
 629
 630         if (strcmp(atf_config_get("atf_arch"), "alpha") == 0)
 631                 atf_tc_expect_fail("PR port-alpha/46301");
 632
 633         ATF_CHECK(log2f(x) == x);
 634 #endif
 635 }
 636
 637 ATF_TC(log2f_one_pos);
 638 ATF_TC_HEAD(log2f_one_pos, tc)
 639 {
 640         atf_tc_set_md_var(tc, "descr", "Test log2f(1.0) == +0.0");
 641 }
 642
 643 ATF_TC_BODY(log2f_one_pos, tc)
 644 {
 645 #ifndef __vax__
 646         const float x = log2f(1.0);
 647         const float y = 0.0L;
 648
 649         ATF_CHECK(x == y);
 650         ATF_CHECK(signbit(x) == 0);
 651         ATF_CHECK(signbit(y) == 0);
 652 #endif
 653 }
 654
 655 ATF_TC(log2f_zero_neg);
 656 ATF_TC_HEAD(log2f_zero_neg, tc)
 657 {
 658         atf_tc_set_md_var(tc, "descr", "Test log2f(-0.0) == -HUGE_VALF");
 659 }
 660
 661 ATF_TC_BODY(log2f_zero_neg, tc)
 662 {
 663 #ifndef __vax__
 664         const float x = -0.0L;
 665
 666         ATF_CHECK(log2f(x) == -HUGE_VALF);
 667 #endif
 668 }
 669
 670 ATF_TC(log2f_zero_pos);
 671 ATF_TC_HEAD(log2f_zero_pos, tc)
 672 {
 673         atf_tc_set_md_var(tc, "descr", "Test log2f(+0.0) == -HUGE_VALF");
 674 }
 675
 676 ATF_TC_BODY(log2f_zero_pos, tc)
 677 {
 678 #ifndef __vax__
 679         const float x = 0.0L;
 680
 681         ATF_CHECK(log2f(x) == -HUGE_VALF);
 682 #endif
 683 }
 684
 685 /*
 686  * log(3)
 687  */
 688 ATF_TC(log_base);
 689 ATF_TC_HEAD(log_base, tc)
 690 {
 691         atf_tc_set_md_var(tc, "descr", "Test log(e) == 1");
 692 }
 693
 694 ATF_TC_BODY(log_base, tc)
 695 {
 696         const double eps = 1.0e-38;
 697
 698         if (fabs(log(M_E) - 1.0) > eps)
 699                 atf_tc_fail_nonfatal("log(e) != 1");
 700 }
 701
 702 ATF_TC(log_nan);
 703 ATF_TC_HEAD(log_nan, tc)
 704 {
 705         atf_tc_set_md_var(tc, "descr", "Test log(NaN) == NaN");
 706 }
 707
 708 ATF_TC_BODY(log_nan, tc)
 709 {
 710 #ifndef __vax__
 711         const double x = 0.0L / 0.0L;
 712
 713         ATF_CHECK(isnan(x) != 0);
 714         ATF_CHECK(isnan(log(x)) != 0);
 715 #endif
 716 }
 717
 718 ATF_TC(log_inf_neg);
 719 ATF_TC_HEAD(log_inf_neg, tc)
 720 {
 721         atf_tc_set_md_var(tc, "descr", "Test log(-Inf) == NaN");
 722 }
 723
 724 ATF_TC_BODY(log_inf_neg, tc)
 725 {
 726 #ifndef __vax__
 727         const double x = -1.0L / 0.0L;
 728         const double y = log(x);
 729
 730         ATF_CHECK(isnan(y) != 0);
 731 #endif
 732 }
 733
 734 ATF_TC(log_inf_pos);
 735 ATF_TC_HEAD(log_inf_pos, tc)
 736 {
 737         atf_tc_set_md_var(tc, "descr", "Test log(+Inf) == +Inf");
 738 }
 739
 740 ATF_TC_BODY(log_inf_pos, tc)
 741 {
 742 #ifndef __vax__
 743         const double x = 1.0L / 0.0L;
 744
 745         ATF_CHECK(log(x) == x);
 746 #endif
 747 }
 748
 749 ATF_TC(log_one_pos);
 750 ATF_TC_HEAD(log_one_pos, tc)
 751 {
 752         atf_tc_set_md_var(tc, "descr", "Test log(1.0) == +0.0");
 753 }
 754
 755 ATF_TC_BODY(log_one_pos, tc)
 756 {
 757 #ifndef __vax__
 758         const double x = log(1.0);
 759         const double y = 0.0L;
 760
 761         ATF_CHECK(x == y);
 762         ATF_CHECK(signbit(x) == 0);
 763         ATF_CHECK(signbit(y) == 0);
 764 #endif
 765 }
 766
 767 ATF_TC(log_zero_neg);
 768 ATF_TC_HEAD(log_zero_neg, tc)
 769 {
 770         atf_tc_set_md_var(tc, "descr", "Test log(-0.0) == -HUGE_VAL");
 771 }
 772
 773 ATF_TC_BODY(log_zero_neg, tc)
 774 {
 775 #ifndef __vax__
 776         const double x = -0.0L;
 777
 778         ATF_CHECK(log(x) == -HUGE_VAL);
 779 #endif
 780 }
 781
 782 ATF_TC(log_zero_pos);
 783 ATF_TC_HEAD(log_zero_pos, tc)
 784 {
 785         atf_tc_set_md_var(tc, "descr", "Test log(+0.0) == -HUGE_VAL");
 786 }
 787
 788 ATF_TC_BODY(log_zero_pos, tc)
 789 {
 790 #ifndef __vax__
 791         const double x = 0.0L;
 792
 793         ATF_CHECK(log(x) == -HUGE_VAL);
 794 #endif
 795 }
 796
 797 /*
 798  * logf(3)
 799  */
 800 ATF_TC(logf_base);
 801 ATF_TC_HEAD(logf_base, tc)
 802 {
 803         atf_tc_set_md_var(tc, "descr", "Test logf(e) == 1");
 804 }
 805
 806 ATF_TC_BODY(logf_base, tc)
 807 {
 808         const float eps = 1.0e-7;
 809
 810         if (fabsf(logf(M_E) - 1.0) > eps)
 811                 atf_tc_fail_nonfatal("logf(e) != 1");
 812 }
 813
 814 ATF_TC(logf_nan);
 815 ATF_TC_HEAD(logf_nan, tc)
 816 {
 817         atf_tc_set_md_var(tc, "descr", "Test logf(NaN) == NaN");
 818 }
 819
 820 ATF_TC_BODY(logf_nan, tc)
 821 {
 822 #ifndef __vax__
 823         const float x = 0.0L / 0.0L;
 824
 825         ATF_CHECK(isnan(x) != 0);
 826         ATF_CHECK(isnan(logf(x)) != 0);
 827 #endif
 828 }
 829
 830 ATF_TC(logf_inf_neg);
 831 ATF_TC_HEAD(logf_inf_neg, tc)
 832 {
 833         atf_tc_set_md_var(tc, "descr", "Test logf(-Inf) == NaN");
 834 }
 835
 836 ATF_TC_BODY(logf_inf_neg, tc)
 837 {
 838 #ifndef __vax__
 839         const float x = -1.0L / 0.0L;
 840         const float y = logf(x);
 841
 842         ATF_CHECK(isnan(y) != 0);
 843 #endif
 844 }
 845
 846 ATF_TC(logf_inf_pos);
 847 ATF_TC_HEAD(logf_inf_pos, tc)
 848 {
 849         atf_tc_set_md_var(tc, "descr", "Test logf(+Inf) == +Inf");
 850 }
 851
 852 ATF_TC_BODY(logf_inf_pos, tc)
 853 {
 854 #ifndef __vax__
 855         const float x = 1.0L / 0.0L;
 856
 857         if (strcmp(atf_config_get("atf_arch"), "alpha") == 0)
 858                 atf_tc_expect_fail("PR port-alpha/46301");
 859
 860         ATF_CHECK(logf(x) == x);
 861 #endif
 862 }
 863
 864 ATF_TC(logf_one_pos);
 865 ATF_TC_HEAD(logf_one_pos, tc)
 866 {
 867         atf_tc_set_md_var(tc, "descr", "Test logf(1.0) == +0.0");
 868 }
 869
 870 ATF_TC_BODY(logf_one_pos, tc)
 871 {
 872 #ifndef __vax__
 873         const float x = logf(1.0);
 874         const float y = 0.0L;
 875
 876         ATF_CHECK(x == y);
 877         ATF_CHECK(signbit(x) == 0);
 878         ATF_CHECK(signbit(y) == 0);
 879 #endif
 880 }
 881
 882 ATF_TC(logf_zero_neg);
 883 ATF_TC_HEAD(logf_zero_neg, tc)
 884 {
 885         atf_tc_set_md_var(tc, "descr", "Test logf(-0.0) == -HUGE_VALF");
 886 }
 887
 888 ATF_TC_BODY(logf_zero_neg, tc)
 889 {
 890 #ifndef __vax__
 891         const float x = -0.0L;
 892
 893         ATF_CHECK(logf(x) == -HUGE_VALF);
 894 #endif
 895 }
 896
 897 ATF_TC(logf_zero_pos);
 898 ATF_TC_HEAD(logf_zero_pos, tc)
 899 {
 900         atf_tc_set_md_var(tc, "descr", "Test logf(+0.0) == -HUGE_VALF");
 901 }
 902
 903 ATF_TC_BODY(logf_zero_pos, tc)
 904 {
 905 #ifndef __vax__
 906         const float x = 0.0L;
 907
 908         ATF_CHECK(logf(x) == -HUGE_VALF);
 909 #endif
 910 }
 911
 912 ATF_TP_ADD_TCS(tp)
 913 {
 914
 915         ATF_TP_ADD_TC(tp, log10_base);
 916         ATF_TP_ADD_TC(tp, log10_nan);
 917         ATF_TP_ADD_TC(tp, log10_inf_neg);
 918         ATF_TP_ADD_TC(tp, log10_inf_pos);
 919         ATF_TP_ADD_TC(tp, log10_one_pos);
 920         ATF_TP_ADD_TC(tp, log10_zero_neg);
 921         ATF_TP_ADD_TC(tp, log10_zero_pos);
 922
 923         ATF_TP_ADD_TC(tp, log10f_base);
 924         ATF_TP_ADD_TC(tp, log10f_nan);
 925         ATF_TP_ADD_TC(tp, log10f_inf_neg);
 926         ATF_TP_ADD_TC(tp, log10f_inf_pos);
 927         ATF_TP_ADD_TC(tp, log10f_one_pos);
 928         ATF_TP_ADD_TC(tp, log10f_zero_neg);
 929         ATF_TP_ADD_TC(tp, log10f_zero_pos);
 930
 931         ATF_TP_ADD_TC(tp, log1p_nan);
 932         ATF_TP_ADD_TC(tp, log1p_inf_neg);
 933         ATF_TP_ADD_TC(tp, log1p_inf_pos);
 934         ATF_TP_ADD_TC(tp, log1p_one_neg);
 935         ATF_TP_ADD_TC(tp, log1p_zero_neg);
 936         ATF_TP_ADD_TC(tp, log1p_zero_pos);
 937
 938         ATF_TP_ADD_TC(tp, log1pf_nan);
 939         ATF_TP_ADD_TC(tp, log1pf_inf_neg);
 940         ATF_TP_ADD_TC(tp, log1pf_inf_pos);
 941         ATF_TP_ADD_TC(tp, log1pf_one_neg);
 942         ATF_TP_ADD_TC(tp, log1pf_zero_neg);
 943         ATF_TP_ADD_TC(tp, log1pf_zero_pos);
 944
 945         ATF_TP_ADD_TC(tp, log2_base);
 946         ATF_TP_ADD_TC(tp, log2_nan);
 947         ATF_TP_ADD_TC(tp, log2_inf_neg);
 948         ATF_TP_ADD_TC(tp, log2_inf_pos);
 949         ATF_TP_ADD_TC(tp, log2_one_pos);
 950         ATF_TP_ADD_TC(tp, log2_zero_neg);
 951         ATF_TP_ADD_TC(tp, log2_zero_pos);
 952
 953         ATF_TP_ADD_TC(tp, log2f_base);
 954         ATF_TP_ADD_TC(tp, log2f_nan);
 955         ATF_TP_ADD_TC(tp, log2f_inf_neg);
 956         ATF_TP_ADD_TC(tp, log2f_inf_pos);
 957         ATF_TP_ADD_TC(tp, log2f_one_pos);
 958         ATF_TP_ADD_TC(tp, log2f_zero_neg);
 959         ATF_TP_ADD_TC(tp, log2f_zero_pos);
 960
 961         ATF_TP_ADD_TC(tp, log_base);
 962         ATF_TP_ADD_TC(tp, log_nan);
 963         ATF_TP_ADD_TC(tp, log_inf_neg);
 964         ATF_TP_ADD_TC(tp, log_inf_pos);
 965         ATF_TP_ADD_TC(tp, log_one_pos);
 966         ATF_TP_ADD_TC(tp, log_zero_neg);
 967         ATF_TP_ADD_TC(tp, log_zero_pos);
 968
 969         ATF_TP_ADD_TC(tp, logf_base);
 970         ATF_TP_ADD_TC(tp, logf_nan);
 971         ATF_TP_ADD_TC(tp, logf_inf_neg);
 972         ATF_TP_ADD_TC(tp, logf_inf_pos);
 973         ATF_TP_ADD_TC(tp, logf_one_pos);
 974         ATF_TP_ADD_TC(tp, logf_zero_neg);
 975         ATF_TP_ADD_TC(tp, logf_zero_pos);
 976
 977         return atf_no_error();
 978 }