math/libm-test.inc

   1 /* Copyright (C) 1997-2006, 2007, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Andreas Jaeger <aj@suse.de>, 1997.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 /* Part of testsuite for libm.
  20
  21    This file is processed by a perl script.  The resulting file has to
  22    be included by a master file that defines:
  23
  24    Macros:
  25    FUNC(function): converts general function name (like cos) to
  26    name with correct suffix (e.g. cosl or cosf)
  27    MATHCONST(x):   like FUNC but for constants (e.g convert 0.0 to 0.0L)
  28    FLOAT:          floating point type to test
  29    - TEST_MSG:     informal message to be displayed
  30    CHOOSE(Clongdouble,Cdouble,Cfloat,Cinlinelongdouble,Cinlinedouble,Cinlinefloat):
  31    chooses one of the parameters as delta for testing
  32    equality
  33    PRINTF_EXPR     Floating point conversion specification to print a variable
  34    of type FLOAT with printf.  PRINTF_EXPR just contains
  35    the specifier, not the percent and width arguments,
  36    e.g. "f".
  37    PRINTF_XEXPR    Like PRINTF_EXPR, but print in hexadecimal format.
  38    PRINTF_NEXPR Like PRINTF_EXPR, but print nice.  */
  39
  40 /* This testsuite has currently tests for:
  41    acos, acosh, asin, asinh, atan, atan2, atanh,
  42    cbrt, ceil, copysign, cos, cosh, erf, erfc, exp, exp10, exp2, expm1,
  43    fabs, fdim, floor, fma, fmax, fmin, fmod, fpclassify,
  44    frexp, gamma, hypot,
  45    ilogb, isfinite, isinf, isnan, isnormal,
  46    isless, islessequal, isgreater, isgreaterequal, islessgreater, isunordered,
  47    j0, j1, jn,
  48    ldexp, lgamma, log, log10, log1p, log2, logb,
  49    modf, nearbyint, nextafter,
  50    pow, remainder, remquo, rint, lrint, llrint,
  51    round, lround, llround,
  52    scalb, scalbn, scalbln, signbit, sin, sincos, sinh, sqrt, tan, tanh, tgamma, trunc,
  53    y0, y1, yn, significand
  54
  55    and for the following complex math functions:
  56    cabs, cacos, cacosh, carg, casin, casinh, catan, catanh,
  57    ccos, ccosh, cexp, clog, cpow, cproj, csin, csinh, csqrt, ctan, ctanh.
  58
  59    At the moment the following functions aren't tested:
  60    drem, nan
  61
  62    Parameter handling is primitive in the moment:
  63    --verbose=[0..3] for different levels of output:
  64    0: only error count
  65    1: basic report on failed tests (default)
  66    2: full report on all tests
  67    -v for full output (equals --verbose=3)
  68    -u for generation of an ULPs file
  69  */
  70
  71 /* "Philosophy":
  72
  73    This suite tests some aspects of the correct implementation of
  74    mathematical functions in libm.  Some simple, specific parameters
  75    are tested for correctness but there's no exhaustive
  76    testing.  Handling of specific inputs (e.g. infinity, not-a-number)
  77    is also tested.  Correct handling of exceptions is checked
  78    against.  These implemented tests should check all cases that are
  79    specified in ISO C99.
  80
  81    Exception testing: At the moment only divide-by-zero, invalid and
  82    overflow exceptions are tested.  Underflow and inexact exceptions
  83    aren't checked at the moment.
  84
  85    NaN values: There exist signalling and quiet NaNs.  This implementation
  86    only uses quiet NaN as parameter but does not differenciate
  87    between the two kinds of NaNs as result.
  88
  89    Inline functions: Inlining functions should give an improvement in
  90    speed - but not in precission.  The inlined functions return
  91    reasonable values for a reasonable range of input values.  The
  92    result is not necessarily correct for all values and exceptions are
  93    not correctly raised in all cases.  Problematic input and return
  94    values are infinity, not-a-number and minus zero.  This suite
  95    therefore does not check these specific inputs and the exception
  96    handling for inlined mathematical functions - just the "reasonable"
  97    values are checked.
  98
  99    Beware: The tests might fail for any of the following reasons:
 100    - Tests are wrong
 101    - Functions are wrong
 102    - Floating Point Unit not working properly
 103    - Compiler has errors
 104
 105    With e.g. gcc 2.7.2.2 the test for cexp fails because of a compiler error.
 106
 107
 108    To Do: All parameter should be numbers that can be represented as
 109    exact floating point values.  Currently some values cannot be
 110    represented exactly and therefore the result is not the expected
 111    result.  For this we will use 36 digits so that numbers can be
 112    represented exactly.  */
 113
 114 #ifndef _GNU_SOURCE
 115 # define _GNU_SOURCE
 116 #endif
 117
 118 #include "libm-test-ulps.h"
 119 #include <complex.h>
 120 #include <math.h>
 121 #include <float.h>
 122 #include <fenv.h>
 123 #include <limits.h>
 124
 125 #include <errno.h>
 126 #include <stdlib.h>
 127 #include <stdio.h>
 128 #include <string.h>
 129 #include <argp.h>
 130
 131 /* Possible exceptions */
 132 #define NO_EXCEPTION                    0x0
 133 #define INVALID_EXCEPTION               0x1
 134 #define DIVIDE_BY_ZERO_EXCEPTION        0x2
 135 #define OVERFLOW_EXCEPTION              0x4
 136 /* The next flags signals that those exceptions are allowed but not required.   */
 137 #define INVALID_EXCEPTION_OK            0x8
 138 #define DIVIDE_BY_ZERO_EXCEPTION_OK     0x10
 139 #define OVERFLOW_EXCEPTION_OK           0x20
 140 #define EXCEPTIONS_OK INVALID_EXCEPTION_OK+DIVIDE_BY_ZERO_EXCEPTION_OK
 141 /* Some special test flags, passed togther with exceptions.  */
 142 #define IGNORE_ZERO_INF_SIGN            0x40
 143
 144 /* Various constants (we must supply them precalculated for accuracy).  */
 145 #define M_PI_6l                 .52359877559829887307710723054658383L
 146 #define M_E2l                   7.389056098930650227230427460575008L
 147 #define M_E3l                   20.085536923187667740928529654581719L
 148 #define M_2_SQRT_PIl            3.5449077018110320545963349666822903L   /* 2 sqrt (M_PIl)  */
 149 #define M_SQRT_PIl              1.7724538509055160272981674833411451L   /* sqrt (M_PIl)  */
 150 #define M_LOG_SQRT_PIl          0.57236494292470008707171367567652933L  /* log(sqrt(M_PIl))  */
 151 #define M_LOG_2_SQRT_PIl        1.265512123484645396488945797134706L    /* log(2*sqrt(M_PIl))  */
 152 #define M_PI_34l                (M_PIl - M_PI_4l)               /* 3*pi/4 */
 153 #define M_PI_34_LOG10El         (M_PIl - M_PI_4l) * M_LOG10El
 154 #define M_PI2_LOG10El           M_PI_2l * M_LOG10El
 155 #define M_PI4_LOG10El           M_PI_4l * M_LOG10El
 156 #define M_PI_LOG10El            M_PIl * M_LOG10El
 157 #define M_SQRT_2_2              0.70710678118654752440084436210484903L /* sqrt (2) / 2 */
 158
 159 static FILE *ulps_file; /* File to document difference.  */
 160 static int output_ulps; /* Should ulps printed?  */
 161
 162 static int noErrors;    /* number of errors */
 163 static int noTests;     /* number of tests (without testing exceptions) */
 164 static int noExcTests;  /* number of tests for exception flags */
 165 static int noXFails;    /* number of expected failures.  */
 166 static int noXPasses;   /* number of unexpected passes.  */
 167
 168 static int verbose;
 169 static int output_max_error;    /* Should the maximal errors printed?  */
 170 static int output_points;       /* Should the single function results printed?  */
 171 static int ignore_max_ulp;      /* Should we ignore max_ulp?  */
 172
 173 static FLOAT minus_zero, plus_zero;
 174 static FLOAT plus_infty, minus_infty, nan_value, max_value, min_value;
 175
 176 static FLOAT max_error, real_max_error, imag_max_error;
 177
 178
 179 #define BUILD_COMPLEX(real, imag) \
 180   ({ __complex__ FLOAT __retval;                                              \
 181      __real__ __retval = (real);                                              \
 182      __imag__ __retval = (imag);                                              \
 183      __retval; })
 184
 185 #define BUILD_COMPLEX_INT(real, imag) \
 186   ({ __complex__ int __retval;                                                \
 187      __real__ __retval = (real);                                              \
 188      __imag__ __retval = (imag);                                              \
 189      __retval; })
 190
 191
 192 #define MANT_DIG CHOOSE ((LDBL_MANT_DIG-1), (DBL_MANT_DIG-1), (FLT_MANT_DIG-1),  \
 193                          (LDBL_MANT_DIG-1), (DBL_MANT_DIG-1), (FLT_MANT_DIG-1))
 194
 195 static void
 196 init_max_error (void)
 197 {
 198   max_error = 0;
 199   real_max_error = 0;
 200   imag_max_error = 0;
 201   feclearexcept (FE_ALL_EXCEPT);
 202 }
 203
 204 static void
 205 set_max_error (FLOAT current, FLOAT *curr_max_error)
 206 {
 207   if (current > *curr_max_error)
 208     *curr_max_error = current;
 209 }
 210
 211
 212 /* Should the message print to screen?  This depends on the verbose flag,
 213    and the test status.  */
 214 static int
 215 print_screen (int ok, int xfail)
 216 {
 217   if (output_points
 218       && (verbose > 1
 219           || (verbose == 1 && ok == xfail)))
 220     return 1;
 221   return 0;
 222 }
 223
 224
 225 /* Should the message print to screen?  This depends on the verbose flag,
 226    and the test status.  */
 227 static int
 228 print_screen_max_error (int ok, int xfail)
 229 {
 230   if (output_max_error
 231       && (verbose > 1
 232           || ((verbose == 1) && (ok == xfail))))
 233     return 1;
 234   return 0;
 235 }
 236
 237 /* Update statistic counters.  */
 238 static void
 239 update_stats (int ok, int xfail)
 240 {
 241   ++noTests;
 242   if (ok && xfail)
 243     ++noXPasses;
 244   else if (!ok && xfail)
 245     ++noXFails;
 246   else if (!ok && !xfail)
 247     ++noErrors;
 248 }
 249
 250 static void
 251 print_ulps (const char *test_name, FLOAT ulp)
 252 {
 253   if (output_ulps)
 254     {
 255       fprintf (ulps_file, "Test \"%s\":\n", test_name);
 256       fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
 257                CHOOSE("ldouble", "double", "float",
 258                       "ildouble", "idouble", "ifloat"),
 259                FUNC(ceil) (ulp));
 260     }
 261 }
 262
 263 static void
 264 print_function_ulps (const char *function_name, FLOAT ulp)
 265 {
 266   if (output_ulps)
 267     {
 268       fprintf (ulps_file, "Function: \"%s\":\n", function_name);
 269       fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
 270                CHOOSE("ldouble", "double", "float",
 271                       "ildouble", "idouble", "ifloat"),
 272                FUNC(ceil) (ulp));
 273     }
 274 }
 275
 276
 277 static void
 278 print_complex_function_ulps (const char *function_name, FLOAT real_ulp,
 279                              FLOAT imag_ulp)
 280 {
 281   if (output_ulps)
 282     {
 283       if (real_ulp != 0.0)
 284         {
 285           fprintf (ulps_file, "Function: Real part of \"%s\":\n", function_name);
 286           fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
 287                    CHOOSE("ldouble", "double", "float",
 288                           "ildouble", "idouble", "ifloat"),
 289                    FUNC(ceil) (real_ulp));
 290         }
 291       if (imag_ulp != 0.0)
 292         {
 293           fprintf (ulps_file, "Function: Imaginary part of \"%s\":\n", function_name);
 294           fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
 295                    CHOOSE("ldouble", "double", "float",
 296                           "ildouble", "idouble", "ifloat"),
 297                    FUNC(ceil) (imag_ulp));
 298         }
 299
 300
 301     }
 302 }
 303
 304
 305
 306 /* Test if Floating-Point stack hasn't changed */
 307 static void
 308 fpstack_test (const char *test_name)
 309 {
 310 #ifdef i386
 311   static int old_stack;
 312   int sw;
 313
 314   asm ("fnstsw" : "=a" (sw));
 315   sw >>= 11;
 316   sw &= 7;
 317
 318   if (sw != old_stack)
 319     {
 320       printf ("FP-Stack wrong after test %s (%d, should be %d)\n",
 321               test_name, sw, old_stack);
 322       ++noErrors;
 323       old_stack = sw;
 324     }
 325 #endif
 326 }
 327
 328
 329 static void
 330 print_max_error (const char *func_name, FLOAT allowed, int xfail)
 331 {
 332   int ok = 0;
 333
 334   if (max_error == 0.0 || (max_error <= allowed && !ignore_max_ulp))
 335     {
 336       ok = 1;
 337     }
 338
 339   if (!ok)
 340     print_function_ulps (func_name, max_error);
 341
 342
 343   if (print_screen_max_error (ok, xfail))
 344     {
 345       printf ("Maximal error of `%s'\n", func_name);
 346       printf (" is      : %.0" PRINTF_NEXPR " ulp\n", FUNC(ceil) (max_error));
 347       printf (" accepted: %.0" PRINTF_NEXPR " ulp\n", FUNC(ceil) (allowed));
 348     }
 349
 350   update_stats (ok, xfail);
 351 }
 352
 353
 354 static void
 355 print_complex_max_error (const char *func_name, __complex__ FLOAT allowed,
 356                          __complex__ int xfail)
 357 {
 358   int ok = 0;
 359
 360   if ((real_max_error == 0 && imag_max_error == 0)
 361       || (real_max_error <= __real__ allowed
 362           && imag_max_error <= __imag__ allowed
 363           && !ignore_max_ulp))
 364     {
 365       ok = 1;
 366     }
 367
 368   if (!ok)
 369     print_complex_function_ulps (func_name, real_max_error, imag_max_error);
 370
 371
 372   if (print_screen_max_error (ok, xfail))
 373     {
 374       printf ("Maximal error of real part of: %s\n", func_name);
 375       printf (" is      : %.0" PRINTF_NEXPR " ulp\n",
 376               FUNC(ceil) (real_max_error));
 377       printf (" accepted: %.0" PRINTF_NEXPR " ulp\n",
 378               FUNC(ceil) (__real__ allowed));
 379       printf ("Maximal error of imaginary part of: %s\n", func_name);
 380       printf (" is      : %.0" PRINTF_NEXPR " ulp\n",
 381               FUNC(ceil) (imag_max_error));
 382       printf (" accepted: %.0" PRINTF_NEXPR " ulp\n",
 383               FUNC(ceil) (__imag__ allowed));
 384     }
 385
 386   update_stats (ok, xfail);
 387 }
 388
 389
 390 /* Test whether a given exception was raised.  */
 391 static void
 392 test_single_exception (const char *test_name,
 393                        int exception,
 394                        int exc_flag,
 395                        int fe_flag,
 396                        const char *flag_name)
 397 {
 398 #ifndef TEST_INLINE
 399   int ok = 1;
 400   if (exception & exc_flag)
 401     {
 402       if (fetestexcept (fe_flag))
 403         {
 404           if (print_screen (1, 0))
 405             printf ("Pass: %s: Exception \"%s\" set\n", test_name, flag_name);
 406         }
 407       else
 408         {
 409           ok = 0;
 410           if (print_screen (0, 0))
 411             printf ("Failure: %s: Exception \"%s\" not set\n",
 412                     test_name, flag_name);
 413         }
 414     }
 415   else
 416     {
 417       if (fetestexcept (fe_flag))
 418         {
 419           ok = 0;
 420           if (print_screen (0, 0))
 421             printf ("Failure: %s: Exception \"%s\" set\n",
 422                     test_name, flag_name);
 423         }
 424       else
 425         {
 426           if (print_screen (1, 0))
 427             printf ("%s: Exception \"%s\" not set\n", test_name,
 428                     flag_name);
 429         }
 430     }
 431   if (!ok)
 432     ++noErrors;
 433
 434 #endif
 435 }
 436
 437
 438 /* Test whether exceptions given by EXCEPTION are raised.  Ignore thereby
 439    allowed but not required exceptions.
 440 */
 441 static void
 442 test_exceptions (const char *test_name, int exception)
 443 {
 444   ++noExcTests;
 445 #ifdef FE_DIVBYZERO
 446   if ((exception & DIVIDE_BY_ZERO_EXCEPTION_OK) == 0)
 447     test_single_exception (test_name, exception,
 448                            DIVIDE_BY_ZERO_EXCEPTION, FE_DIVBYZERO,
 449                            "Divide by zero");
 450 #endif
 451 #ifdef FE_INVALID
 452   if ((exception & INVALID_EXCEPTION_OK) == 0)
 453     test_single_exception (test_name, exception, INVALID_EXCEPTION, FE_INVALID,
 454                          "Invalid operation");
 455 #endif
 456 #ifdef FE_OVERFLOW
 457   if ((exception & OVERFLOW_EXCEPTION_OK) == 0)
 458     test_single_exception (test_name, exception, OVERFLOW_EXCEPTION,
 459                            FE_OVERFLOW, "Overflow");
 460 #endif
 461   feclearexcept (FE_ALL_EXCEPT);
 462 }
 463
 464
 465 static void
 466 check_float_internal (const char *test_name, FLOAT computed, FLOAT expected,
 467                       FLOAT max_ulp, int xfail, int exceptions,
 468                       FLOAT *curr_max_error)
 469 {
 470   int ok = 0;
 471   int print_diff = 0;
 472   FLOAT diff = 0;
 473   FLOAT ulp = 0;
 474
 475   test_exceptions (test_name, exceptions);
 476   if (isnan (computed) && isnan (expected))
 477     ok = 1;
 478   else if (isinf (computed) && isinf (expected))
 479     {
 480       /* Test for sign of infinities.  */
 481       if ((exceptions & IGNORE_ZERO_INF_SIGN) == 0
 482           && signbit (computed) != signbit (expected))
 483         {
 484           ok = 0;
 485           printf ("infinity has wrong sign.\n");
 486         }
 487       else
 488         ok = 1;
 489     }
 490   /* Don't calc ulp for NaNs or infinities.  */
 491   else if (isinf (computed) || isnan (computed) || isinf (expected) || isnan (expected))
 492     ok = 0;
 493   else
 494     {
 495       diff = FUNC(fabs) (computed - expected);
 496       switch (fpclassify (expected))
 497         {
 498         case FP_ZERO:
 499           /* ilogb (0) isn't allowed. */
 500           ulp = diff / FUNC(ldexp) (1.0, - MANT_DIG);
 501           break;
 502         case FP_NORMAL:
 503           ulp = diff / FUNC(ldexp) (1.0, FUNC(ilogb) (expected) - MANT_DIG);
 504           break;
 505         case FP_SUBNORMAL:
 506           ulp = (FUNC(ldexp) (diff, MANT_DIG)
 507                  / FUNC(ldexp) (1.0, FUNC(ilogb) (expected)));
 508           break;
 509         default:
 510           /* It should never happen. */
 511           abort ();
 512           break;
 513         }
 514       set_max_error (ulp, curr_max_error);
 515       print_diff = 1;
 516       if ((exceptions & IGNORE_ZERO_INF_SIGN) == 0
 517           && computed == 0.0 && expected == 0.0
 518           && signbit(computed) != signbit (expected))
 519         ok = 0;
 520       else if (ulp <= 0.5 || (ulp <= max_ulp && !ignore_max_ulp))
 521         ok = 1;
 522       else
 523         {
 524           ok = 0;
 525           print_ulps (test_name, ulp);
 526         }
 527
 528     }
 529   if (print_screen (ok, xfail))
 530     {
 531       if (!ok)
 532         printf ("Failure: ");
 533       printf ("Test: %s\n", test_name);
 534       printf ("Result:\n");
 535       printf (" is:         % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
 536               computed, computed);
 537       printf (" should be:  % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
 538               expected, expected);
 539       if (print_diff)
 540         {
 541           printf (" difference: % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR
 542                   "\n", diff, diff);
 543           printf (" ulp       : % .4" PRINTF_NEXPR "\n", ulp);
 544           printf (" max.ulp   : % .4" PRINTF_NEXPR "\n", max_ulp);
 545         }
 546     }
 547   update_stats (ok, xfail);
 548
 549   fpstack_test (test_name);
 550 }
 551
 552
 553 static void
 554 check_float (const char *test_name, FLOAT computed, FLOAT expected,
 555              FLOAT max_ulp, int xfail, int exceptions)
 556 {
 557   check_float_internal (test_name, computed, expected, max_ulp, xfail,
 558                         exceptions, &max_error);
 559 }
 560
 561
 562 static void
 563 check_complex (const char *test_name, __complex__ FLOAT computed,
 564                __complex__ FLOAT expected,
 565                __complex__ FLOAT max_ulp, __complex__ int xfail,
 566                int exception)
 567 {
 568   FLOAT part_comp, part_exp, part_max_ulp;
 569   int part_xfail;
 570   char str[200];
 571
 572   sprintf (str, "Real part of: %s", test_name);
 573   part_comp = __real__ computed;
 574   part_exp = __real__ expected;
 575   part_max_ulp = __real__ max_ulp;
 576   part_xfail = __real__ xfail;
 577
 578   check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
 579                         exception, &real_max_error);
 580
 581   sprintf (str, "Imaginary part of: %s", test_name);
 582   part_comp = __imag__ computed;
 583   part_exp = __imag__ expected;
 584   part_max_ulp = __imag__ max_ulp;
 585   part_xfail = __imag__ xfail;
 586
 587   /* Don't check again for exceptions, just pass through the
 588      zero/inf sign test.  */
 589   check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
 590                         exception & IGNORE_ZERO_INF_SIGN,
 591                         &imag_max_error);
 592 }
 593
 594
 595 /* Check that computed and expected values are equal (int values).  */
 596 static void
 597 check_int (const char *test_name, int computed, int expected, int max_ulp,
 598            int xfail, int exceptions)
 599 {
 600   int diff = computed - expected;
 601   int ok = 0;
 602
 603   test_exceptions (test_name, exceptions);
 604   noTests++;
 605   if (abs (diff) <= max_ulp)
 606     ok = 1;
 607
 608   if (!ok)
 609     print_ulps (test_name, diff);
 610
 611   if (print_screen (ok, xfail))
 612     {
 613       if (!ok)
 614         printf ("Failure: ");
 615       printf ("Test: %s\n", test_name);
 616       printf ("Result:\n");
 617       printf (" is:         %d\n", computed);
 618       printf (" should be:  %d\n", expected);
 619     }
 620
 621   update_stats (ok, xfail);
 622   fpstack_test (test_name);
 623 }
 624
 625
 626 /* Check that computed and expected values are equal (long int values).  */
 627 static void
 628 check_long (const char *test_name, long int computed, long int expected,
 629             long int max_ulp, int xfail, int exceptions)
 630 {
 631   long int diff = computed - expected;
 632   int ok = 0;
 633
 634   test_exceptions (test_name, exceptions);
 635   noTests++;
 636   if (labs (diff) <= max_ulp)
 637     ok = 1;
 638
 639   if (!ok)
 640     print_ulps (test_name, diff);
 641
 642   if (print_screen (ok, xfail))
 643     {
 644       if (!ok)
 645         printf ("Failure: ");
 646       printf ("Test: %s\n", test_name);
 647       printf ("Result:\n");
 648       printf (" is:         %ld\n", computed);
 649       printf (" should be:  %ld\n", expected);
 650     }
 651
 652   update_stats (ok, xfail);
 653   fpstack_test (test_name);
 654 }
 655
 656
 657 /* Check that computed value is true/false.  */
 658 static void
 659 check_bool (const char *test_name, int computed, int expected,
 660             long int max_ulp, int xfail, int exceptions)
 661 {
 662   int ok = 0;
 663
 664   test_exceptions (test_name, exceptions);
 665   noTests++;
 666   if ((computed == 0) == (expected == 0))
 667     ok = 1;
 668
 669   if (print_screen (ok, xfail))
 670     {
 671       if (!ok)
 672         printf ("Failure: ");
 673       printf ("Test: %s\n", test_name);
 674       printf ("Result:\n");
 675       printf (" is:         %d\n", computed);
 676       printf (" should be:  %d\n", expected);
 677     }
 678
 679   update_stats (ok, xfail);
 680   fpstack_test (test_name);
 681 }
 682
 683
 684 /* check that computed and expected values are equal (long int values) */
 685 static void
 686 check_longlong (const char *test_name, long long int computed,
 687                 long long int expected,
 688                 long long int max_ulp, int xfail,
 689                 int exceptions)
 690 {
 691   long long int diff = computed - expected;
 692   int ok = 0;
 693
 694   test_exceptions (test_name, exceptions);
 695   noTests++;
 696   if (llabs (diff) <= max_ulp)
 697     ok = 1;
 698
 699   if (!ok)
 700     print_ulps (test_name, diff);
 701
 702   if (print_screen (ok, xfail))
 703     {
 704       if (!ok)
 705         printf ("Failure:");
 706       printf ("Test: %s\n", test_name);
 707       printf ("Result:\n");
 708       printf (" is:         %lld\n", computed);
 709       printf (" should be:  %lld\n", expected);
 710     }
 711
 712   update_stats (ok, xfail);
 713   fpstack_test (test_name);
 714 }
 715
 716
 717
 718 /* This is to prevent messages from the SVID libm emulation.  */
 719 int
 720 matherr (struct exception *x __attribute__ ((unused)))
 721 {
 722   return 1;
 723 }
 724
 725
 726 /****************************************************************************
 727   Tests for single functions of libm.
 728   Please keep them alphabetically sorted!
 729 ****************************************************************************/
 730
 731 static void
 732 acos_test (void)
 733 {
 734   errno = 0;
 735   FUNC(acos) (0);
 736   if (errno == ENOSYS)
 737     /* Function not implemented.  */
 738     return;
 739
 740   START (acos);
 741
 742   TEST_f_f (acos, plus_infty, nan_value, INVALID_EXCEPTION);
 743   TEST_f_f (acos, minus_infty, nan_value, INVALID_EXCEPTION);
 744   TEST_f_f (acos, nan_value, nan_value);
 745
 746   /* |x| > 1: */
 747   TEST_f_f (acos, 1.125L, nan_value, INVALID_EXCEPTION);
 748   TEST_f_f (acos, -1.125L, nan_value, INVALID_EXCEPTION);
 749   TEST_f_f (acos, max_value, nan_value, INVALID_EXCEPTION);
 750   TEST_f_f (acos, -max_value, nan_value, INVALID_EXCEPTION);
 751
 752   TEST_f_f (acos, 0, M_PI_2l);
 753   TEST_f_f (acos, minus_zero, M_PI_2l);
 754   TEST_f_f (acos, 1, 0);
 755   TEST_f_f (acos, -1, M_PIl);
 756   TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 757   TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 758   TEST_f_f (acos, 0.75L, 0.722734247813415611178377352641333362L);
 759   TEST_f_f (acos, 2e-17L, 1.57079632679489659923132169163975144L);
 760   TEST_f_f (acos, 0.0625L, 1.50825556499840522843072005474337068L);
 761   END (acos);
 762 }
 763
 764 static void
 765 acosh_test (void)
 766 {
 767   errno = 0;
 768   FUNC(acosh) (7);
 769   if (errno == ENOSYS)
 770     /* Function not implemented.  */
 771     return;
 772
 773   START (acosh);
 774
 775   TEST_f_f (acosh, plus_infty, plus_infty);
 776   TEST_f_f (acosh, minus_infty, nan_value, INVALID_EXCEPTION);
 777
 778   /* x < 1:  */
 779   TEST_f_f (acosh, -1.125L, nan_value, INVALID_EXCEPTION);
 780   TEST_f_f (acosh, -max_value, nan_value, INVALID_EXCEPTION);
 781
 782   TEST_f_f (acosh, 1, 0);
 783   TEST_f_f (acosh, 7, 2.63391579384963341725009269461593689L);
 784
 785   END (acosh);
 786 }
 787
 788 static void
 789 asin_test (void)
 790 {
 791   errno = 0;
 792   FUNC(asin) (0);
 793   if (errno == ENOSYS)
 794     /* Function not implemented.  */
 795     return;
 796
 797   START (asin);
 798
 799   TEST_f_f (asin, plus_infty, nan_value, INVALID_EXCEPTION);
 800   TEST_f_f (asin, minus_infty, nan_value, INVALID_EXCEPTION);
 801   TEST_f_f (asin, nan_value, nan_value);
 802
 803   /* asin x == NaN plus invalid exception for |x| > 1.  */
 804   TEST_f_f (asin, 1.125L, nan_value, INVALID_EXCEPTION);
 805   TEST_f_f (asin, -1.125L, nan_value, INVALID_EXCEPTION);
 806   TEST_f_f (asin, max_value, nan_value, INVALID_EXCEPTION);
 807   TEST_f_f (asin, -max_value, nan_value, INVALID_EXCEPTION);
 808
 809   TEST_f_f (asin, 0, 0);
 810   TEST_f_f (asin, minus_zero, minus_zero);
 811   TEST_f_f (asin, 0.5, M_PI_6l);
 812   TEST_f_f (asin, -0.5, -M_PI_6l);
 813   TEST_f_f (asin, 1.0, M_PI_2l);
 814   TEST_f_f (asin, -1.0, -M_PI_2l);
 815   TEST_f_f (asin, 0.75L, 0.848062078981481008052944338998418080L);
 816
 817   END (asin);
 818 }
 819
 820 static void
 821 asinh_test (void)
 822 {
 823   errno = 0;
 824   FUNC(asinh) (0.7L);
 825   if (errno == ENOSYS)
 826     /* Function not implemented.  */
 827     return;
 828
 829   START (asinh);
 830
 831   TEST_f_f (asinh, 0, 0);
 832   TEST_f_f (asinh, minus_zero, minus_zero);
 833 #ifndef TEST_INLINE
 834   TEST_f_f (asinh, plus_infty, plus_infty);
 835   TEST_f_f (asinh, minus_infty, minus_infty);
 836 #endif
 837   TEST_f_f (asinh, nan_value, nan_value);
 838   TEST_f_f (asinh, 0.75L, 0.693147180559945309417232121458176568L);
 839
 840   END (asinh);
 841 }
 842
 843 static void
 844 atan_test (void)
 845 {
 846   errno = 0;
 847   FUNC(atan) (0);
 848   if (errno == ENOSYS)
 849     /* Function not implemented.  */
 850     return;
 851
 852   START (atan);
 853
 854   TEST_f_f (atan, 0, 0);
 855   TEST_f_f (atan, minus_zero, minus_zero);
 856
 857   TEST_f_f (atan, plus_infty, M_PI_2l);
 858   TEST_f_f (atan, minus_infty, -M_PI_2l);
 859   TEST_f_f (atan, nan_value, nan_value);
 860
 861   TEST_f_f (atan, 1, M_PI_4l);
 862   TEST_f_f (atan, -1, -M_PI_4l);
 863
 864   TEST_f_f (atan, 0.75L, 0.643501108793284386802809228717322638L);
 865
 866   END (atan);
 867 }
 868
 869
 870
 871 static void
 872 atanh_test (void)
 873 {
 874   errno = 0;
 875   FUNC(atanh) (0.7L);
 876   if (errno == ENOSYS)
 877     /* Function not implemented.  */
 878     return;
 879
 880   START (atanh);
 881
 882
 883   TEST_f_f (atanh, 0, 0);
 884   TEST_f_f (atanh, minus_zero, minus_zero);
 885
 886   TEST_f_f (atanh, 1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
 887   TEST_f_f (atanh, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
 888   TEST_f_f (atanh, nan_value, nan_value);
 889
 890   /* atanh (x) == NaN plus invalid exception if |x| > 1.  */
 891   TEST_f_f (atanh, 1.125L, nan_value, INVALID_EXCEPTION);
 892   TEST_f_f (atanh, -1.125L, nan_value, INVALID_EXCEPTION);
 893   TEST_f_f (atanh, max_value, nan_value, INVALID_EXCEPTION);
 894   TEST_f_f (atanh, -max_value, nan_value, INVALID_EXCEPTION);
 895
 896   TEST_f_f (atanh, 0.75L, 0.972955074527656652552676371721589865L);
 897
 898   END (atanh);
 899 }
 900
 901 static void
 902 atan2_test (void)
 903 {
 904   errno = 0;
 905   FUNC(atan2) (-0, 1);
 906   if (errno == ENOSYS)
 907     /* Function not implemented.  */
 908     return;
 909
 910   START (atan2);
 911
 912   /* atan2 (0,x) == 0 for x > 0.  */
 913   TEST_ff_f (atan2, 0, 1, 0);
 914
 915   /* atan2 (-0,x) == -0 for x > 0.  */
 916   TEST_ff_f (atan2, minus_zero, 1, minus_zero);
 917
 918   TEST_ff_f (atan2, 0, 0, 0);
 919   TEST_ff_f (atan2, minus_zero, 0, minus_zero);
 920
 921   /* atan2 (+0,x) == +pi for x < 0.  */
 922   TEST_ff_f (atan2, 0, -1, M_PIl);
 923
 924   /* atan2 (-0,x) == -pi for x < 0.  */
 925   TEST_ff_f (atan2, minus_zero, -1, -M_PIl);
 926
 927   TEST_ff_f (atan2, 0, minus_zero, M_PIl);
 928   TEST_ff_f (atan2, minus_zero, minus_zero, -M_PIl);
 929
 930   /* atan2 (y,+0) == pi/2 for y > 0.  */
 931   TEST_ff_f (atan2, 1, 0, M_PI_2l);
 932
 933   /* atan2 (y,-0) == pi/2 for y > 0.  */
 934   TEST_ff_f (atan2, 1, minus_zero, M_PI_2l);
 935
 936   /* atan2 (y,+0) == -pi/2 for y < 0.  */
 937   TEST_ff_f (atan2, -1, 0, -M_PI_2l);
 938
 939   /* atan2 (y,-0) == -pi/2 for y < 0.  */
 940   TEST_ff_f (atan2, -1, minus_zero, -M_PI_2l);
 941
 942   /* atan2 (y,inf) == +0 for finite y > 0.  */
 943   TEST_ff_f (atan2, 1, plus_infty, 0);
 944
 945   /* atan2 (y,inf) == -0 for finite y < 0.  */
 946   TEST_ff_f (atan2, -1, plus_infty, minus_zero);
 947
 948   /* atan2(+inf, x) == pi/2 for finite x.  */
 949   TEST_ff_f (atan2, plus_infty, -1, M_PI_2l);
 950
 951   /* atan2(-inf, x) == -pi/2 for finite x.  */
 952   TEST_ff_f (atan2, minus_infty, 1, -M_PI_2l);
 953
 954   /* atan2 (y,-inf) == +pi for finite y > 0.  */
 955   TEST_ff_f (atan2, 1, minus_infty, M_PIl);
 956
 957   /* atan2 (y,-inf) == -pi for finite y < 0.  */
 958   TEST_ff_f (atan2, -1, minus_infty, -M_PIl);
 959
 960   TEST_ff_f (atan2, plus_infty, plus_infty, M_PI_4l);
 961   TEST_ff_f (atan2, minus_infty, plus_infty, -M_PI_4l);
 962   TEST_ff_f (atan2, plus_infty, minus_infty, M_PI_34l);
 963   TEST_ff_f (atan2, minus_infty, minus_infty, -M_PI_34l);
 964   TEST_ff_f (atan2, nan_value, nan_value, nan_value);
 965
 966   TEST_ff_f (atan2, max_value, max_value, M_PI_4l);
 967
 968   TEST_ff_f (atan2, 0.75L, 1, 0.643501108793284386802809228717322638L);
 969   TEST_ff_f (atan2, -0.75L, 1.0L, -0.643501108793284386802809228717322638L);
 970   TEST_ff_f (atan2, 0.75L, -1.0L, 2.49809154479650885165983415456218025L);
 971   TEST_ff_f (atan2, -0.75L, -1.0L, -2.49809154479650885165983415456218025L);
 972   TEST_ff_f (atan2, 0.390625L, .00029L, 1.57005392693128974780151246612928941L);
 973   TEST_ff_f (atan2, 1.390625L, 0.9296875L, 0.981498387184244311516296577615519772L);
 974
 975   TEST_ff_f (atan2, -0.00756827042671106339L, -.001792735857538728036L, -1.80338464113663849327153994379639112L);
 976
 977   END (atan2);
 978 }
 979
 980 static void
 981 cabs_test (void)
 982 {
 983   errno = 0;
 984   FUNC(cabs) (BUILD_COMPLEX (0.7L, 12.4L));
 985   if (errno == ENOSYS)
 986     /* Function not implemented.  */
 987     return;
 988
 989   START (cabs);
 990
 991   /* cabs (x + iy) is specified as hypot (x,y) */
 992
 993   /* cabs (+inf + i x) == +inf.  */
 994   TEST_c_f (cabs, plus_infty, 1.0, plus_infty);
 995   /* cabs (-inf + i x) == +inf.  */
 996   TEST_c_f (cabs, minus_infty, 1.0, plus_infty);
 997
 998   TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
 999   TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
1000
1001   TEST_c_f (cabs, nan_value, nan_value, nan_value);
1002
1003   /* cabs (x,y) == cabs (y,x).  */
1004   TEST_c_f (cabs, 0.75L, 12.390625L, 12.4133028598606664302388810868156657L);
1005   /* cabs (x,y) == cabs (-x,y).  */
1006   TEST_c_f (cabs, -12.390625L, 0.75L, 12.4133028598606664302388810868156657L);
1007   /* cabs (x,y) == cabs (-y,x).  */
1008   TEST_c_f (cabs, -0.75L, 12.390625L, 12.4133028598606664302388810868156657L);
1009   /* cabs (x,y) == cabs (-x,-y).  */
1010   TEST_c_f (cabs, -12.390625L, -0.75L, 12.4133028598606664302388810868156657L);
1011   /* cabs (x,y) == cabs (-y,-x).  */
1012   TEST_c_f (cabs, -0.75L, -12.390625L, 12.4133028598606664302388810868156657L);
1013   /* cabs (x,0) == fabs (x).  */
1014   TEST_c_f (cabs, -0.75L, 0, 0.75L);
1015   TEST_c_f (cabs, 0.75L, 0, 0.75L);
1016   TEST_c_f (cabs, -1.0L, 0, 1.0L);
1017   TEST_c_f (cabs, 1.0L, 0, 1.0L);
1018   TEST_c_f (cabs, -5.7e7L, 0, 5.7e7L);
1019   TEST_c_f (cabs, 5.7e7L, 0, 5.7e7L);
1020
1021   TEST_c_f (cabs, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
1022
1023   END (cabs);
1024 }
1025
1026
1027 static void
1028 cacos_test (void)
1029 {
1030   errno = 0;
1031   FUNC(cacos) (BUILD_COMPLEX (0.7L, 1.2L));
1032   if (errno == ENOSYS)
1033     /* Function not implemented.  */
1034     return;
1035
1036   START (cacos);
1037
1038
1039   TEST_c_c (cacos, 0, 0, M_PI_2l, minus_zero);
1040   TEST_c_c (cacos, minus_zero, 0, M_PI_2l, minus_zero);
1041   TEST_c_c (cacos, minus_zero, minus_zero, M_PI_2l, 0.0);
1042   TEST_c_c (cacos, 0, minus_zero, M_PI_2l, 0.0);
1043
1044   TEST_c_c (cacos, minus_infty, plus_infty, M_PI_34l, minus_infty);
1045   TEST_c_c (cacos, minus_infty, minus_infty, M_PI_34l, plus_infty);
1046
1047   TEST_c_c (cacos, plus_infty, plus_infty, M_PI_4l, minus_infty);
1048   TEST_c_c (cacos, plus_infty, minus_infty, M_PI_4l, plus_infty);
1049
1050   TEST_c_c (cacos, -10.0, plus_infty, M_PI_2l, minus_infty);
1051   TEST_c_c (cacos, -10.0, minus_infty, M_PI_2l, plus_infty);
1052   TEST_c_c (cacos, 0, plus_infty, M_PI_2l, minus_infty);
1053   TEST_c_c (cacos, 0, minus_infty, M_PI_2l, plus_infty);
1054   TEST_c_c (cacos, 0.1L, plus_infty, M_PI_2l, minus_infty);
1055   TEST_c_c (cacos, 0.1L, minus_infty, M_PI_2l, plus_infty);
1056
1057   TEST_c_c (cacos, minus_infty, 0, M_PIl, minus_infty);
1058   TEST_c_c (cacos, minus_infty, minus_zero, M_PIl, plus_infty);
1059   TEST_c_c (cacos, minus_infty, 100, M_PIl, minus_infty);
1060   TEST_c_c (cacos, minus_infty, -100, M_PIl, plus_infty);
1061
1062   TEST_c_c (cacos, plus_infty, 0, 0.0, minus_infty);
1063   TEST_c_c (cacos, plus_infty, minus_zero, 0.0, plus_infty);
1064   TEST_c_c (cacos, plus_infty, 0.5, 0.0, minus_infty);
1065   TEST_c_c (cacos, plus_infty, -0.5, 0.0, plus_infty);
1066
1067   TEST_c_c (cacos, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1068   TEST_c_c (cacos, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1069
1070   TEST_c_c (cacos, 0, nan_value, M_PI_2l, nan_value);
1071   TEST_c_c (cacos, minus_zero, nan_value, M_PI_2l, nan_value);
1072
1073   TEST_c_c (cacos, nan_value, plus_infty, nan_value, minus_infty);
1074   TEST_c_c (cacos, nan_value, minus_infty, nan_value, plus_infty);
1075
1076   TEST_c_c (cacos, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1077   TEST_c_c (cacos, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1078
1079   TEST_c_c (cacos, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1080   TEST_c_c (cacos, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1081
1082   TEST_c_c (cacos, nan_value, nan_value, nan_value, nan_value);
1083
1084   TEST_c_c (cacos, plus_zero, -1.5L, M_PI_2l, 1.194763217287109304111930828519090523536L);
1085   TEST_c_c (cacos, minus_zero, -1.5L, M_PI_2l, 1.194763217287109304111930828519090523536L);
1086   TEST_c_c (cacos, plus_zero, -1.0L, M_PI_2l, 0.8813735870195430252326093249797923090282L);
1087   TEST_c_c (cacos, minus_zero, -1.0L, M_PI_2l, 0.8813735870195430252326093249797923090282L);
1088   TEST_c_c (cacos, plus_zero, -0.5L, M_PI_2l, 0.4812118250596034474977589134243684231352L);
1089   TEST_c_c (cacos, minus_zero, -0.5L, M_PI_2l, 0.4812118250596034474977589134243684231352L);
1090   TEST_c_c (cacos, plus_zero, 0.5L, M_PI_2l, -0.4812118250596034474977589134243684231352L);
1091   TEST_c_c (cacos, minus_zero, 0.5L, M_PI_2l, -0.4812118250596034474977589134243684231352L);
1092   TEST_c_c (cacos, plus_zero, 1.0L, M_PI_2l, -0.8813735870195430252326093249797923090282L);
1093   TEST_c_c (cacos, minus_zero, 1.0L, M_PI_2l, -0.8813735870195430252326093249797923090282L);
1094   TEST_c_c (cacos, plus_zero, 1.5L, M_PI_2l, -1.194763217287109304111930828519090523536L);
1095   TEST_c_c (cacos, minus_zero, 1.5L, M_PI_2l, -1.194763217287109304111930828519090523536L);
1096
1097   TEST_c_c (cacos, -1.5L, plus_zero, M_PIl, -0.9624236501192068949955178268487368462704L);
1098   TEST_c_c (cacos, -1.5L, minus_zero, M_PIl, 0.9624236501192068949955178268487368462704L);
1099   TEST_c_c (cacos, -1.0L, plus_zero, M_PIl, minus_zero);
1100   TEST_c_c (cacos, -1.0L, minus_zero, M_PIl, plus_zero);
1101   TEST_c_c (cacos, -0.5L, plus_zero, 2.094395102393195492308428922186335256131L, minus_zero);
1102   TEST_c_c (cacos, -0.5L, minus_zero, 2.094395102393195492308428922186335256131L, plus_zero);
1103   TEST_c_c (cacos, 0.5L, plus_zero, 1.047197551196597746154214461093167628066L, minus_zero);
1104   TEST_c_c (cacos, 0.5L, minus_zero, 1.047197551196597746154214461093167628066L, plus_zero);
1105   TEST_c_c (cacos, 1.0L, plus_zero, plus_zero, minus_zero);
1106   TEST_c_c (cacos, 1.0L, minus_zero, plus_zero, plus_zero);
1107   TEST_c_c (cacos, 1.5L, plus_zero, plus_zero, -0.9624236501192068949955178268487368462704L);
1108   TEST_c_c (cacos, 1.5L, minus_zero, plus_zero, 0.9624236501192068949955178268487368462704L);
1109
1110   TEST_c_c (cacos, 0.75L, 1.25L, 1.11752014915610270578240049553777969L, -1.13239363160530819522266333696834467L);
1111   TEST_c_c (cacos, -2, -3, 2.1414491111159960199416055713254211L, 1.9833870299165354323470769028940395L);
1112
1113   END (cacos, complex);
1114 }
1115
1116 static void
1117 cacosh_test (void)
1118 {
1119   errno = 0;
1120   FUNC(cacosh) (BUILD_COMPLEX (0.7L, 1.2L));
1121   if (errno == ENOSYS)
1122     /* Function not implemented.  */
1123     return;
1124
1125   START (cacosh);
1126
1127
1128   TEST_c_c (cacosh, 0, 0, 0.0, M_PI_2l);
1129   TEST_c_c (cacosh, minus_zero, 0, 0.0, M_PI_2l);
1130   TEST_c_c (cacosh, 0, minus_zero, 0.0, -M_PI_2l);
1131   TEST_c_c (cacosh, minus_zero, minus_zero, 0.0, -M_PI_2l);
1132   TEST_c_c (cacosh, minus_infty, plus_infty, plus_infty, M_PI_34l);
1133   TEST_c_c (cacosh, minus_infty, minus_infty, plus_infty, -M_PI_34l);
1134
1135   TEST_c_c (cacosh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1136   TEST_c_c (cacosh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1137
1138   TEST_c_c (cacosh, -10.0, plus_infty, plus_infty, M_PI_2l);
1139   TEST_c_c (cacosh, -10.0, minus_infty, plus_infty, -M_PI_2l);
1140   TEST_c_c (cacosh, 0, plus_infty, plus_infty, M_PI_2l);
1141   TEST_c_c (cacosh, 0, minus_infty, plus_infty, -M_PI_2l);
1142   TEST_c_c (cacosh, 0.1L, plus_infty, plus_infty, M_PI_2l);
1143   TEST_c_c (cacosh, 0.1L, minus_infty, plus_infty, -M_PI_2l);
1144
1145   TEST_c_c (cacosh, minus_infty, 0, plus_infty, M_PIl);
1146   TEST_c_c (cacosh, minus_infty, minus_zero, plus_infty, -M_PIl);
1147   TEST_c_c (cacosh, minus_infty, 100, plus_infty, M_PIl);
1148   TEST_c_c (cacosh, minus_infty, -100, plus_infty, -M_PIl);
1149
1150   TEST_c_c (cacosh, plus_infty, 0, plus_infty, 0.0);
1151   TEST_c_c (cacosh, plus_infty, minus_zero, plus_infty, minus_zero);
1152   TEST_c_c (cacosh, plus_infty, 0.5, plus_infty, 0.0);
1153   TEST_c_c (cacosh, plus_infty, -0.5, plus_infty, minus_zero);
1154
1155   TEST_c_c (cacosh, plus_infty, nan_value, plus_infty, nan_value);
1156   TEST_c_c (cacosh, minus_infty, nan_value, plus_infty, nan_value);
1157
1158   TEST_c_c (cacosh, 0, nan_value, nan_value, nan_value);
1159   TEST_c_c (cacosh, minus_zero, nan_value, nan_value, nan_value);
1160
1161   TEST_c_c (cacosh, nan_value, plus_infty, plus_infty, nan_value);
1162   TEST_c_c (cacosh, nan_value, minus_infty, plus_infty, nan_value);
1163
1164   TEST_c_c (cacosh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1165   TEST_c_c (cacosh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1166
1167   TEST_c_c (cacosh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1168   TEST_c_c (cacosh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1169
1170   TEST_c_c (cacosh, nan_value, nan_value, nan_value, nan_value);
1171
1172   TEST_c_c (cacosh, plus_zero, -1.5L, 1.194763217287109304111930828519090523536L, -M_PI_2l);
1173   TEST_c_c (cacosh, minus_zero, -1.5L, 1.194763217287109304111930828519090523536L, -M_PI_2l);
1174   TEST_c_c (cacosh, plus_zero, -1.0L, 0.8813735870195430252326093249797923090282L, -M_PI_2l);
1175   TEST_c_c (cacosh, minus_zero, -1.0L, 0.8813735870195430252326093249797923090282L, -M_PI_2l);
1176   TEST_c_c (cacosh, plus_zero, -0.5L, 0.4812118250596034474977589134243684231352L, -M_PI_2l);
1177   TEST_c_c (cacosh, minus_zero, -0.5L, 0.4812118250596034474977589134243684231352L, -M_PI_2l);
1178   TEST_c_c (cacosh, plus_zero, 0.5L, 0.4812118250596034474977589134243684231352L, M_PI_2l);
1179   TEST_c_c (cacosh, minus_zero, 0.5L, 0.4812118250596034474977589134243684231352L, M_PI_2l);
1180   TEST_c_c (cacosh, plus_zero, 1.0L, 0.8813735870195430252326093249797923090282L, M_PI_2l);
1181   TEST_c_c (cacosh, minus_zero, 1.0L, 0.8813735870195430252326093249797923090282L, M_PI_2l);
1182   TEST_c_c (cacosh, plus_zero, 1.5L, 1.194763217287109304111930828519090523536L, M_PI_2l);
1183   TEST_c_c (cacosh, minus_zero, 1.5L, 1.194763217287109304111930828519090523536L, M_PI_2l);
1184
1185   TEST_c_c (cacosh, -1.5L, plus_zero, 0.9624236501192068949955178268487368462704L, M_PIl);
1186   TEST_c_c (cacosh, -1.5L, minus_zero, 0.9624236501192068949955178268487368462704L, -M_PIl);
1187   TEST_c_c (cacosh, -1.0L, plus_zero, plus_zero, M_PIl);
1188   TEST_c_c (cacosh, -1.0L, minus_zero, plus_zero, -M_PIl);
1189   TEST_c_c (cacosh, -0.5L, plus_zero, plus_zero, 2.094395102393195492308428922186335256131L);
1190   TEST_c_c (cacosh, -0.5L, minus_zero, plus_zero, -2.094395102393195492308428922186335256131L);
1191   TEST_c_c (cacosh, 0.5L, plus_zero, plus_zero, 1.047197551196597746154214461093167628066L);
1192   TEST_c_c (cacosh, 0.5L, minus_zero, plus_zero, -1.047197551196597746154214461093167628066L);
1193   TEST_c_c (cacosh, 1.0L, plus_zero, plus_zero, plus_zero);
1194   TEST_c_c (cacosh, 1.0L, minus_zero, plus_zero, minus_zero);
1195   TEST_c_c (cacosh, 1.5L, plus_zero, 0.9624236501192068949955178268487368462704L, plus_zero);
1196   TEST_c_c (cacosh, 1.5L, minus_zero, 0.9624236501192068949955178268487368462704L, minus_zero);
1197
1198   TEST_c_c (cacosh, 0.75L, 1.25L, 1.13239363160530819522266333696834467L, 1.11752014915610270578240049553777969L);
1199   TEST_c_c (cacosh, -2, -3, 1.9833870299165354323470769028940395L, -2.1414491111159960199416055713254211L);
1200
1201   END (cacosh, complex);
1202 }
1203
1204
1205 static void
1206 carg_test (void)
1207 {
1208   START (carg);
1209
1210   /* carg (x + iy) is specified as atan2 (y, x) */
1211
1212   /* carg (x + i 0) == 0 for x > 0.  */
1213   TEST_c_f (carg, 2.0, 0, 0);
1214   /* carg (x - i 0) == -0 for x > 0.  */
1215   TEST_c_f (carg, 2.0, minus_zero, minus_zero);
1216
1217   TEST_c_f (carg, 0, 0, 0);
1218   TEST_c_f (carg, 0, minus_zero, minus_zero);
1219
1220   /* carg (x + i 0) == +pi for x < 0.  */
1221   TEST_c_f (carg, -2.0, 0, M_PIl);
1222
1223   /* carg (x - i 0) == -pi for x < 0.  */
1224   TEST_c_f (carg, -2.0, minus_zero, -M_PIl);
1225
1226   TEST_c_f (carg, minus_zero, 0, M_PIl);
1227   TEST_c_f (carg, minus_zero, minus_zero, -M_PIl);
1228
1229   /* carg (+0 + i y) == pi/2 for y > 0.  */
1230   TEST_c_f (carg, 0, 2.0, M_PI_2l);
1231
1232   /* carg (-0 + i y) == pi/2 for y > 0.  */
1233   TEST_c_f (carg, minus_zero, 2.0, M_PI_2l);
1234
1235   /* carg (+0 + i y) == -pi/2 for y < 0.  */
1236   TEST_c_f (carg, 0, -2.0, -M_PI_2l);
1237
1238   /* carg (-0 + i y) == -pi/2 for y < 0.  */
1239   TEST_c_f (carg, minus_zero, -2.0, -M_PI_2l);
1240
1241   /* carg (inf + i y) == +0 for finite y > 0.  */
1242   TEST_c_f (carg, plus_infty, 2.0, 0);
1243
1244   /* carg (inf + i y) == -0 for finite y < 0.  */
1245   TEST_c_f (carg, plus_infty, -2.0, minus_zero);
1246
1247   /* carg(x + i inf) == pi/2 for finite x.  */
1248   TEST_c_f (carg, 10.0, plus_infty, M_PI_2l);
1249
1250   /* carg(x - i inf) == -pi/2 for finite x.  */
1251   TEST_c_f (carg, 10.0, minus_infty, -M_PI_2l);
1252
1253   /* carg (-inf + i y) == +pi for finite y > 0.  */
1254   TEST_c_f (carg, minus_infty, 10.0, M_PIl);
1255
1256   /* carg (-inf + i y) == -pi for finite y < 0.  */
1257   TEST_c_f (carg, minus_infty, -10.0, -M_PIl);
1258
1259   TEST_c_f (carg, plus_infty, plus_infty, M_PI_4l);
1260
1261   TEST_c_f (carg, plus_infty, minus_infty, -M_PI_4l);
1262
1263   TEST_c_f (carg, minus_infty, plus_infty, 3 * M_PI_4l);
1264
1265   TEST_c_f (carg, minus_infty, minus_infty, -3 * M_PI_4l);
1266
1267   TEST_c_f (carg, nan_value, nan_value, nan_value);
1268
1269   END (carg);
1270 }
1271
1272 static void
1273 casin_test (void)
1274 {
1275   errno = 0;
1276   FUNC(casin) (BUILD_COMPLEX (0.7L, 1.2L));
1277   if (errno == ENOSYS)
1278     /* Function not implemented.  */
1279     return;
1280
1281   START (casin);
1282
1283   TEST_c_c (casin, 0, 0, 0.0, 0.0);
1284   TEST_c_c (casin, minus_zero, 0, minus_zero, 0.0);
1285   TEST_c_c (casin, 0, minus_zero, 0.0, minus_zero);
1286   TEST_c_c (casin, minus_zero, minus_zero, minus_zero, minus_zero);
1287
1288   TEST_c_c (casin, plus_infty, plus_infty, M_PI_4l, plus_infty);
1289   TEST_c_c (casin, plus_infty, minus_infty, M_PI_4l, minus_infty);
1290   TEST_c_c (casin, minus_infty, plus_infty, -M_PI_4l, plus_infty);
1291   TEST_c_c (casin, minus_infty, minus_infty, -M_PI_4l, minus_infty);
1292
1293   TEST_c_c (casin, -10.0, plus_infty, minus_zero, plus_infty);
1294   TEST_c_c (casin, -10.0, minus_infty, minus_zero, minus_infty);
1295   TEST_c_c (casin, 0, plus_infty, 0.0, plus_infty);
1296   TEST_c_c (casin, 0, minus_infty, 0.0, minus_infty);
1297   TEST_c_c (casin, minus_zero, plus_infty, minus_zero, plus_infty);
1298   TEST_c_c (casin, minus_zero, minus_infty, minus_zero, minus_infty);
1299   TEST_c_c (casin, 0.1L, plus_infty, 0.0, plus_infty);
1300   TEST_c_c (casin, 0.1L, minus_infty, 0.0, minus_infty);
1301
1302   TEST_c_c (casin, minus_infty, 0, -M_PI_2l, plus_infty);
1303   TEST_c_c (casin, minus_infty, minus_zero, -M_PI_2l, minus_infty);
1304   TEST_c_c (casin, minus_infty, 100, -M_PI_2l, plus_infty);
1305   TEST_c_c (casin, minus_infty, -100, -M_PI_2l, minus_infty);
1306
1307   TEST_c_c (casin, plus_infty, 0, M_PI_2l, plus_infty);
1308   TEST_c_c (casin, plus_infty, minus_zero, M_PI_2l, minus_infty);
1309   TEST_c_c (casin, plus_infty, 0.5, M_PI_2l, plus_infty);
1310   TEST_c_c (casin, plus_infty, -0.5, M_PI_2l, minus_infty);
1311
1312   TEST_c_c (casin, nan_value, plus_infty, nan_value, plus_infty);
1313   TEST_c_c (casin, nan_value, minus_infty, nan_value, minus_infty);
1314
1315   TEST_c_c (casin, 0.0, nan_value, 0.0, nan_value);
1316   TEST_c_c (casin, minus_zero, nan_value, minus_zero, nan_value);
1317
1318   TEST_c_c (casin, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1319   TEST_c_c (casin, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1320
1321   TEST_c_c (casin, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1322   TEST_c_c (casin, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1323
1324   TEST_c_c (casin, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1325   TEST_c_c (casin, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1326
1327   TEST_c_c (casin, nan_value, nan_value, nan_value, nan_value);
1328
1329   TEST_c_c (casin, plus_zero, -1.5L, plus_zero, -1.194763217287109304111930828519090523536L);
1330   TEST_c_c (casin, minus_zero, -1.5L, minus_zero, -1.194763217287109304111930828519090523536L);
1331   TEST_c_c (casin, plus_zero, -1.0L, plus_zero, -0.8813735870195430252326093249797923090282L);
1332   TEST_c_c (casin, minus_zero, -1.0L, minus_zero, -0.8813735870195430252326093249797923090282L);
1333   TEST_c_c (casin, plus_zero, -0.5L, plus_zero, -0.4812118250596034474977589134243684231352L);
1334   TEST_c_c (casin, minus_zero, -0.5L, minus_zero, -0.4812118250596034474977589134243684231352L);
1335   TEST_c_c (casin, plus_zero, 0.5L, plus_zero, 0.4812118250596034474977589134243684231352L);
1336   TEST_c_c (casin, minus_zero, 0.5L, minus_zero, 0.4812118250596034474977589134243684231352L);
1337   TEST_c_c (casin, plus_zero, 1.0L, plus_zero, 0.8813735870195430252326093249797923090282L);
1338   TEST_c_c (casin, minus_zero, 1.0L, minus_zero, 0.8813735870195430252326093249797923090282L);
1339   TEST_c_c (casin, plus_zero, 1.5L, plus_zero, 1.194763217287109304111930828519090523536L);
1340   TEST_c_c (casin, minus_zero, 1.5L, minus_zero, 1.194763217287109304111930828519090523536L);
1341
1342   TEST_c_c (casin, -1.5L, plus_zero, -M_PI_2l, 0.9624236501192068949955178268487368462704L);
1343   TEST_c_c (casin, -1.5L, minus_zero, -M_PI_2l, -0.9624236501192068949955178268487368462704L);
1344   TEST_c_c (casin, -1.0L, plus_zero, -M_PI_2l, plus_zero);
1345   TEST_c_c (casin, -1.0L, minus_zero, -M_PI_2l, minus_zero);
1346   TEST_c_c (casin, -0.5L, plus_zero, -0.5235987755982988730771072305465838140329L, plus_zero);
1347   TEST_c_c (casin, -0.5L, minus_zero, -0.5235987755982988730771072305465838140329L, minus_zero);
1348   TEST_c_c (casin, 0.5L, plus_zero, 0.5235987755982988730771072305465838140329L, plus_zero);
1349   TEST_c_c (casin, 0.5L, minus_zero, 0.5235987755982988730771072305465838140329L, minus_zero);
1350   TEST_c_c (casin, 1.0L, plus_zero, M_PI_2l, plus_zero);
1351   TEST_c_c (casin, 1.0L, minus_zero, M_PI_2l, minus_zero);
1352   TEST_c_c (casin, 1.5L, plus_zero, M_PI_2l, 0.9624236501192068949955178268487368462704L);
1353   TEST_c_c (casin, 1.5L, minus_zero, M_PI_2l, -0.9624236501192068949955178268487368462704L);
1354
1355   TEST_c_c (casin, 0.75L, 1.25L, 0.453276177638793913448921196101971749L, 1.13239363160530819522266333696834467L);
1356   TEST_c_c (casin, -2, -3, -0.57065278432109940071028387968566963L, -1.9833870299165354323470769028940395L);
1357
1358   END (casin, complex);
1359 }
1360
1361
1362 static void
1363 casinh_test (void)
1364 {
1365   errno = 0;
1366   FUNC(casinh) (BUILD_COMPLEX (0.7L, 1.2L));
1367   if (errno == ENOSYS)
1368     /* Function not implemented.  */
1369     return;
1370
1371   START (casinh);
1372
1373   TEST_c_c (casinh, 0, 0, 0.0, 0.0);
1374   TEST_c_c (casinh, minus_zero, 0, minus_zero, 0);
1375   TEST_c_c (casinh, 0, minus_zero, 0.0, minus_zero);
1376   TEST_c_c (casinh, minus_zero, minus_zero, minus_zero, minus_zero);
1377
1378   TEST_c_c (casinh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1379   TEST_c_c (casinh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1380   TEST_c_c (casinh, minus_infty, plus_infty, minus_infty, M_PI_4l);
1381   TEST_c_c (casinh, minus_infty, minus_infty, minus_infty, -M_PI_4l);
1382
1383   TEST_c_c (casinh, -10.0, plus_infty, minus_infty, M_PI_2l);
1384   TEST_c_c (casinh, -10.0, minus_infty, minus_infty, -M_PI_2l);
1385   TEST_c_c (casinh, 0, plus_infty, plus_infty, M_PI_2l);
1386   TEST_c_c (casinh, 0, minus_infty, plus_infty, -M_PI_2l);
1387   TEST_c_c (casinh, minus_zero, plus_infty, minus_infty, M_PI_2l);
1388   TEST_c_c (casinh, minus_zero, minus_infty, minus_infty, -M_PI_2l);
1389   TEST_c_c (casinh, 0.1L, plus_infty, plus_infty, M_PI_2l);
1390   TEST_c_c (casinh, 0.1L, minus_infty, plus_infty, -M_PI_2l);
1391
1392   TEST_c_c (casinh, minus_infty, 0, minus_infty, 0.0);
1393   TEST_c_c (casinh, minus_infty, minus_zero, minus_infty, minus_zero);
1394   TEST_c_c (casinh, minus_infty, 100, minus_infty, 0.0);
1395   TEST_c_c (casinh, minus_infty, -100, minus_infty, minus_zero);
1396
1397   TEST_c_c (casinh, plus_infty, 0, plus_infty, 0.0);
1398   TEST_c_c (casinh, plus_infty, minus_zero, plus_infty, minus_zero);
1399   TEST_c_c (casinh, plus_infty, 0.5, plus_infty, 0.0);
1400   TEST_c_c (casinh, plus_infty, -0.5, plus_infty, minus_zero);
1401
1402   TEST_c_c (casinh, plus_infty, nan_value, plus_infty, nan_value);
1403   TEST_c_c (casinh, minus_infty, nan_value, minus_infty, nan_value);
1404
1405   TEST_c_c (casinh, nan_value, 0, nan_value, 0.0);
1406   TEST_c_c (casinh, nan_value, minus_zero, nan_value, minus_zero);
1407
1408   TEST_c_c (casinh, nan_value, plus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1409   TEST_c_c (casinh, nan_value, minus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1410
1411   TEST_c_c (casinh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1412   TEST_c_c (casinh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1413
1414   TEST_c_c (casinh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1415   TEST_c_c (casinh, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1416
1417   TEST_c_c (casinh, nan_value, nan_value, nan_value, nan_value);
1418
1419   TEST_c_c (casinh, plus_zero, -1.5L, 0.9624236501192068949955178268487368462704L, -M_PI_2l);
1420   TEST_c_c (casinh, minus_zero, -1.5L, -0.9624236501192068949955178268487368462704L, -M_PI_2l);
1421   TEST_c_c (casinh, plus_zero, -1.0L, plus_zero, -M_PI_2l);
1422   TEST_c_c (casinh, minus_zero, -1.0L, minus_zero, -M_PI_2l);
1423   TEST_c_c (casinh, plus_zero, -0.5L, plus_zero, -0.5235987755982988730771072305465838140329L);
1424   TEST_c_c (casinh, minus_zero, -0.5L, minus_zero, -0.5235987755982988730771072305465838140329L);
1425   TEST_c_c (casinh, plus_zero, 0.5L, plus_zero, 0.5235987755982988730771072305465838140329L);
1426   TEST_c_c (casinh, minus_zero, 0.5L, minus_zero, 0.5235987755982988730771072305465838140329L);
1427   TEST_c_c (casinh, plus_zero, 1.0L, plus_zero, M_PI_2l);
1428   TEST_c_c (casinh, minus_zero, 1.0L, minus_zero, M_PI_2l);
1429   TEST_c_c (casinh, plus_zero, 1.5L, 0.9624236501192068949955178268487368462704L, M_PI_2l);
1430   TEST_c_c (casinh, minus_zero, 1.5L, -0.9624236501192068949955178268487368462704L, M_PI_2l);
1431
1432   TEST_c_c (casinh, -1.5L, plus_zero, -1.194763217287109304111930828519090523536L, plus_zero);
1433   TEST_c_c (casinh, -1.5L, minus_zero, -1.194763217287109304111930828519090523536L, minus_zero);
1434   TEST_c_c (casinh, -1.0L, plus_zero, -0.8813735870195430252326093249797923090282L, plus_zero);
1435   TEST_c_c (casinh, -1.0L, minus_zero, -0.8813735870195430252326093249797923090282L, minus_zero);
1436   TEST_c_c (casinh, -0.5L, plus_zero, -0.4812118250596034474977589134243684231352L, plus_zero);
1437   TEST_c_c (casinh, -0.5L, minus_zero, -0.4812118250596034474977589134243684231352L, minus_zero);
1438   TEST_c_c (casinh, 0.5L, plus_zero, 0.4812118250596034474977589134243684231352L, plus_zero);
1439   TEST_c_c (casinh, 0.5L, minus_zero, 0.4812118250596034474977589134243684231352L, minus_zero);
1440   TEST_c_c (casinh, 1.0L, plus_zero, 0.8813735870195430252326093249797923090282L, plus_zero);
1441   TEST_c_c (casinh, 1.0L, minus_zero, 0.8813735870195430252326093249797923090282L, minus_zero);
1442   TEST_c_c (casinh, 1.5L, plus_zero, 1.194763217287109304111930828519090523536L, plus_zero);
1443   TEST_c_c (casinh, 1.5L, minus_zero, 1.194763217287109304111930828519090523536L, minus_zero);
1444
1445   TEST_c_c (casinh, 0.75L, 1.25L, 1.03171853444778027336364058631006594L, 0.911738290968487636358489564316731207L);
1446   TEST_c_c (casinh, -2, -3, -1.9686379257930962917886650952454982L, -0.96465850440760279204541105949953237L);
1447
1448   END (casinh, complex);
1449 }
1450
1451
1452 static void
1453 catan_test (void)
1454 {
1455   errno = 0;
1456   FUNC(catan) (BUILD_COMPLEX (0.7L, 1.2L));
1457   if (errno == ENOSYS)
1458     /* Function not implemented.  */
1459     return;
1460
1461   START (catan);
1462
1463   TEST_c_c (catan, 0, 0, 0, 0);
1464   TEST_c_c (catan, minus_zero, 0, minus_zero, 0);
1465   TEST_c_c (catan, 0, minus_zero, 0, minus_zero);
1466   TEST_c_c (catan, minus_zero, minus_zero, minus_zero, minus_zero);
1467
1468   TEST_c_c (catan, plus_infty, plus_infty, M_PI_2l, 0);
1469   TEST_c_c (catan, plus_infty, minus_infty, M_PI_2l, minus_zero);
1470   TEST_c_c (catan, minus_infty, plus_infty, -M_PI_2l, 0);
1471   TEST_c_c (catan, minus_infty, minus_infty, -M_PI_2l, minus_zero);
1472
1473
1474   TEST_c_c (catan, plus_infty, -10.0, M_PI_2l, minus_zero);
1475   TEST_c_c (catan, minus_infty, -10.0, -M_PI_2l, minus_zero);
1476   TEST_c_c (catan, plus_infty, minus_zero, M_PI_2l, minus_zero);
1477   TEST_c_c (catan, minus_infty, minus_zero, -M_PI_2l, minus_zero);
1478   TEST_c_c (catan, plus_infty, 0.0, M_PI_2l, 0);
1479   TEST_c_c (catan, minus_infty, 0.0, -M_PI_2l, 0);
1480   TEST_c_c (catan, plus_infty, 0.1L, M_PI_2l, 0);
1481   TEST_c_c (catan, minus_infty, 0.1L, -M_PI_2l, 0);
1482
1483   TEST_c_c (catan, 0.0, minus_infty, M_PI_2l, minus_zero);
1484   TEST_c_c (catan, minus_zero, minus_infty, -M_PI_2l, minus_zero);
1485   TEST_c_c (catan, 100.0, minus_infty, M_PI_2l, minus_zero);
1486   TEST_c_c (catan, -100.0, minus_infty, -M_PI_2l, minus_zero);
1487
1488   TEST_c_c (catan, 0.0, plus_infty, M_PI_2l, 0);
1489   TEST_c_c (catan, minus_zero, plus_infty, -M_PI_2l, 0);
1490   TEST_c_c (catan, 0.5, plus_infty, M_PI_2l, 0);
1491   TEST_c_c (catan, -0.5, plus_infty, -M_PI_2l, 0);
1492
1493   TEST_c_c (catan, nan_value, 0.0, nan_value, 0);
1494   TEST_c_c (catan, nan_value, minus_zero, nan_value, minus_zero);
1495
1496   TEST_c_c (catan, nan_value, plus_infty, nan_value, 0);
1497   TEST_c_c (catan, nan_value, minus_infty, nan_value, minus_zero);
1498
1499   TEST_c_c (catan, 0.0, nan_value, nan_value, nan_value);
1500   TEST_c_c (catan, minus_zero, nan_value, nan_value, nan_value);
1501
1502   TEST_c_c (catan, plus_infty, nan_value, M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1503   TEST_c_c (catan, minus_infty, nan_value, -M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1504
1505   TEST_c_c (catan, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1506   TEST_c_c (catan, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1507
1508   TEST_c_c (catan, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1509   TEST_c_c (catan, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1510
1511   TEST_c_c (catan, nan_value, nan_value, nan_value, nan_value);
1512
1513   TEST_c_c (catan, 0.75L, 1.25L, 1.10714871779409050301706546017853704L, 0.549306144334054845697622618461262852L);
1514   TEST_c_c (catan, -2, -3, -1.4099210495965755225306193844604208L, -0.22907268296853876629588180294200276L);
1515
1516   END (catan, complex);
1517 }
1518
1519 static void
1520 catanh_test (void)
1521 {
1522   errno = 0;
1523   FUNC(catanh) (BUILD_COMPLEX (0.7L, 1.2L));
1524   if (errno == ENOSYS)
1525     /* Function not implemented.  */
1526     return;
1527
1528   START (catanh);
1529
1530   TEST_c_c (catanh, 0, 0, 0.0, 0.0);
1531   TEST_c_c (catanh, minus_zero, 0, minus_zero, 0.0);
1532   TEST_c_c (catanh, 0, minus_zero, 0.0, minus_zero);
1533   TEST_c_c (catanh, minus_zero, minus_zero, minus_zero, minus_zero);
1534
1535   TEST_c_c (catanh, plus_infty, plus_infty, 0.0, M_PI_2l);
1536   TEST_c_c (catanh, plus_infty, minus_infty, 0.0, -M_PI_2l);
1537   TEST_c_c (catanh, minus_infty, plus_infty, minus_zero, M_PI_2l);
1538   TEST_c_c (catanh, minus_infty, minus_infty, minus_zero, -M_PI_2l);
1539
1540   TEST_c_c (catanh, -10.0, plus_infty, minus_zero, M_PI_2l);
1541   TEST_c_c (catanh, -10.0, minus_infty, minus_zero, -M_PI_2l);
1542   TEST_c_c (catanh, minus_zero, plus_infty, minus_zero, M_PI_2l);
1543   TEST_c_c (catanh, minus_zero, minus_infty, minus_zero, -M_PI_2l);
1544   TEST_c_c (catanh, 0, plus_infty, 0.0, M_PI_2l);
1545   TEST_c_c (catanh, 0, minus_infty, 0.0, -M_PI_2l);
1546   TEST_c_c (catanh, 0.1L, plus_infty, 0.0, M_PI_2l);
1547   TEST_c_c (catanh, 0.1L, minus_infty, 0.0, -M_PI_2l);
1548
1549   TEST_c_c (catanh, minus_infty, 0, minus_zero, M_PI_2l);
1550   TEST_c_c (catanh, minus_infty, minus_zero, minus_zero, -M_PI_2l);
1551   TEST_c_c (catanh, minus_infty, 100, minus_zero, M_PI_2l);
1552   TEST_c_c (catanh, minus_infty, -100, minus_zero, -M_PI_2l);
1553
1554   TEST_c_c (catanh, plus_infty, 0, 0.0, M_PI_2l);
1555   TEST_c_c (catanh, plus_infty, minus_zero, 0.0, -M_PI_2l);
1556   TEST_c_c (catanh, plus_infty, 0.5, 0.0, M_PI_2l);
1557   TEST_c_c (catanh, plus_infty, -0.5, 0.0, -M_PI_2l);
1558
1559   TEST_c_c (catanh, 0, nan_value, 0.0, nan_value);
1560   TEST_c_c (catanh, minus_zero, nan_value, minus_zero, nan_value);
1561
1562   TEST_c_c (catanh, plus_infty, nan_value, 0.0, nan_value);
1563   TEST_c_c (catanh, minus_infty, nan_value, minus_zero, nan_value);
1564
1565   TEST_c_c (catanh, nan_value, 0, nan_value, nan_value);
1566   TEST_c_c (catanh, nan_value, minus_zero, nan_value, nan_value);
1567
1568   TEST_c_c (catanh, nan_value, plus_infty, 0.0, M_PI_2l, IGNORE_ZERO_INF_SIGN);
1569   TEST_c_c (catanh, nan_value, minus_infty, 0.0, -M_PI_2l, IGNORE_ZERO_INF_SIGN);
1570
1571   TEST_c_c (catanh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1572   TEST_c_c (catanh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1573
1574   TEST_c_c (catanh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1575   TEST_c_c (catanh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1576
1577   TEST_c_c (catanh, nan_value, nan_value, nan_value, nan_value);
1578
1579   TEST_c_c (catanh, 0.75L, 1.25L, 0.261492138795671927078652057366532140L, 0.996825126463918666098902241310446708L);
1580   TEST_c_c (catanh, -2, -3, -0.14694666622552975204743278515471595L, -1.3389725222944935611241935759091443L);
1581
1582   END (catanh, complex);
1583 }
1584
1585 static void
1586 cbrt_test (void)
1587 {
1588   errno = 0;
1589   FUNC(cbrt) (8);
1590   if (errno == ENOSYS)
1591     /* Function not implemented.  */
1592     return;
1593
1594   START (cbrt);
1595
1596   TEST_f_f (cbrt, 0.0, 0.0);
1597   TEST_f_f (cbrt, minus_zero, minus_zero);
1598
1599   TEST_f_f (cbrt, plus_infty, plus_infty);
1600   TEST_f_f (cbrt, minus_infty, minus_infty);
1601   TEST_f_f (cbrt, nan_value, nan_value);
1602
1603   TEST_f_f (cbrt, -0.001L, -0.1L);
1604   TEST_f_f (cbrt, 8, 2);
1605   TEST_f_f (cbrt, -27.0, -3.0);
1606   TEST_f_f (cbrt, 0.9921875L, 0.997389022060725270579075195353955217L);
1607   TEST_f_f (cbrt, 0.75L, 0.908560296416069829445605878163630251L);
1608
1609   END (cbrt);
1610 }
1611
1612
1613 static void
1614 ccos_test (void)
1615 {
1616   errno = 0;
1617   FUNC(ccos) (BUILD_COMPLEX (0, 0));
1618   if (errno == ENOSYS)
1619     /* Function not implemented.  */
1620     return;
1621
1622   START (ccos);
1623
1624   TEST_c_c (ccos, 0.0, 0.0, 1.0, minus_zero);
1625   TEST_c_c (ccos, minus_zero, 0.0, 1.0, 0.0);
1626   TEST_c_c (ccos, 0.0, minus_zero, 1.0, 0.0);
1627   TEST_c_c (ccos, minus_zero, minus_zero, 1.0, minus_zero);
1628
1629   TEST_c_c (ccos, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1630   TEST_c_c (ccos, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1631   TEST_c_c (ccos, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1632   TEST_c_c (ccos, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1633
1634   TEST_c_c (ccos, 0.0, plus_infty, plus_infty, minus_zero);
1635   TEST_c_c (ccos, 0.0, minus_infty, plus_infty, 0.0);
1636   TEST_c_c (ccos, minus_zero, plus_infty, plus_infty, 0.0);
1637   TEST_c_c (ccos, minus_zero, minus_infty, plus_infty, minus_zero);
1638
1639   TEST_c_c (ccos, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1640   TEST_c_c (ccos, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1641   TEST_c_c (ccos, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1642   TEST_c_c (ccos, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1643
1644   TEST_c_c (ccos, 4.625, plus_infty, minus_infty, plus_infty);
1645   TEST_c_c (ccos, 4.625, minus_infty, minus_infty, minus_infty);
1646   TEST_c_c (ccos, -4.625, plus_infty, minus_infty, minus_infty);
1647   TEST_c_c (ccos, -4.625, minus_infty, minus_infty, plus_infty);
1648
1649   TEST_c_c (ccos, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1650   TEST_c_c (ccos, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1651   TEST_c_c (ccos, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1652   TEST_c_c (ccos, minus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1653
1654   TEST_c_c (ccos, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1655   TEST_c_c (ccos, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1656
1657   TEST_c_c (ccos, nan_value, plus_infty, plus_infty, nan_value);
1658   TEST_c_c (ccos, nan_value, minus_infty, plus_infty, nan_value);
1659
1660   TEST_c_c (ccos, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1661   TEST_c_c (ccos, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1662
1663   TEST_c_c (ccos, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1664   TEST_c_c (ccos, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1665
1666   TEST_c_c (ccos, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1667   TEST_c_c (ccos, -10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1668
1669   TEST_c_c (ccos, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1670   TEST_c_c (ccos, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1671
1672   TEST_c_c (ccos, nan_value, nan_value, nan_value, nan_value);
1673
1674   TEST_c_c (ccos, 0.75L, 1.25L, 1.38173873063425888530729933139078645L, -1.09193013555397466170919531722024128L);
1675   TEST_c_c (ccos, -2, -3, -4.18962569096880723013255501961597373L, -9.10922789375533659797919726277886212L);
1676
1677   END (ccos, complex);
1678 }
1679
1680
1681 static void
1682 ccosh_test (void)
1683 {
1684   errno = 0;
1685   FUNC(ccosh) (BUILD_COMPLEX (0.7L, 1.2L));
1686   if (errno == ENOSYS)
1687     /* Function not implemented.  */
1688     return;
1689
1690   START (ccosh);
1691
1692   TEST_c_c (ccosh, 0.0, 0.0, 1.0, 0.0);
1693   TEST_c_c (ccosh, minus_zero, 0.0, 1.0, minus_zero);
1694   TEST_c_c (ccosh, 0.0, minus_zero, 1.0, minus_zero);
1695   TEST_c_c (ccosh, minus_zero, minus_zero, 1.0, 0.0);
1696
1697   TEST_c_c (ccosh, 0.0, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1698   TEST_c_c (ccosh, minus_zero, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1699   TEST_c_c (ccosh, 0.0, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1700   TEST_c_c (ccosh, minus_zero, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1701
1702   TEST_c_c (ccosh, plus_infty, 0.0, plus_infty, 0.0);
1703   TEST_c_c (ccosh, minus_infty, 0.0, plus_infty, minus_zero);
1704   TEST_c_c (ccosh, plus_infty, minus_zero, plus_infty, minus_zero);
1705   TEST_c_c (ccosh, minus_infty, minus_zero, plus_infty, 0.0);
1706
1707   TEST_c_c (ccosh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1708   TEST_c_c (ccosh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1709   TEST_c_c (ccosh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1710   TEST_c_c (ccosh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1711
1712   TEST_c_c (ccosh, plus_infty, 4.625, minus_infty, minus_infty);
1713   TEST_c_c (ccosh, minus_infty, 4.625, minus_infty, plus_infty);
1714   TEST_c_c (ccosh, plus_infty, -4.625, minus_infty, plus_infty);
1715   TEST_c_c (ccosh, minus_infty, -4.625, minus_infty, minus_infty);
1716
1717   TEST_c_c (ccosh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1718   TEST_c_c (ccosh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1719   TEST_c_c (ccosh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1720   TEST_c_c (ccosh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1721
1722   TEST_c_c (ccosh, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1723   TEST_c_c (ccosh, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1724
1725   TEST_c_c (ccosh, plus_infty, nan_value, plus_infty, nan_value);
1726   TEST_c_c (ccosh, minus_infty, nan_value, plus_infty, nan_value);
1727
1728   TEST_c_c (ccosh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1729   TEST_c_c (ccosh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1730
1731   TEST_c_c (ccosh, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1732   TEST_c_c (ccosh, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1733
1734   TEST_c_c (ccosh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1735   TEST_c_c (ccosh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1736
1737   TEST_c_c (ccosh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1738   TEST_c_c (ccosh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1739
1740   TEST_c_c (ccosh, nan_value, nan_value, nan_value, nan_value);
1741
1742   TEST_c_c (ccosh, 0.75L, 1.25L, 0.408242591877968807788852146397499084L, 0.780365930845853240391326216300863152L);
1743
1744   TEST_c_c (ccosh, -2, -3, -3.72454550491532256547397070325597253L, 0.511822569987384608834463849801875634L);
1745
1746   END (ccosh, complex);
1747 }
1748
1749
1750 static void
1751 ceil_test (void)
1752 {
1753   START (ceil);
1754
1755   TEST_f_f (ceil, 0.0, 0.0);
1756   TEST_f_f (ceil, minus_zero, minus_zero);
1757   TEST_f_f (ceil, plus_infty, plus_infty);
1758   TEST_f_f (ceil, minus_infty, minus_infty);
1759   TEST_f_f (ceil, nan_value, nan_value);
1760
1761   TEST_f_f (ceil, M_PIl, 4.0);
1762   TEST_f_f (ceil, -M_PIl, -3.0);
1763   TEST_f_f (ceil, 0.1, 1.0);
1764   TEST_f_f (ceil, 0.25, 1.0);
1765   TEST_f_f (ceil, 0.625, 1.0);
1766   TEST_f_f (ceil, -0.1, minus_zero);
1767   TEST_f_f (ceil, -0.25, minus_zero);
1768   TEST_f_f (ceil, -0.625, minus_zero);
1769
1770 #ifdef TEST_LDOUBLE
1771   /* The result can only be represented in long double.  */
1772   TEST_f_f (ceil, 4503599627370495.5L, 4503599627370496.0L);
1773   TEST_f_f (ceil, 4503599627370496.25L, 4503599627370497.0L);
1774   TEST_f_f (ceil, 4503599627370496.5L, 4503599627370497.0L);
1775   TEST_f_f (ceil, 4503599627370496.75L, 4503599627370497.0L);
1776   TEST_f_f (ceil, 4503599627370497.5L, 4503599627370498.0L);
1777
1778   TEST_f_f (ceil, -4503599627370495.5L, -4503599627370495.0L);
1779   TEST_f_f (ceil, -4503599627370496.25L, -4503599627370496.0L);
1780   TEST_f_f (ceil, -4503599627370496.5L, -4503599627370496.0L);
1781   TEST_f_f (ceil, -4503599627370496.75L, -4503599627370496.0L);
1782   TEST_f_f (ceil, -4503599627370497.5L, -4503599627370497.0L);
1783
1784 # if LDBL_MANT_DIG > 100
1785   TEST_f_f (ceil, 4503599627370494.5000000000001L, 4503599627370495.0L);
1786   TEST_f_f (ceil, 4503599627370495.5000000000001L, 4503599627370496.0L);
1787   TEST_f_f (ceil, 4503599627370496.5000000000001L, 4503599627370497.0L);
1788   TEST_f_f (ceil, -4503599627370494.5000000000001L, -4503599627370494.0L);
1789   TEST_f_f (ceil, -4503599627370495.5000000000001L, -4503599627370495.0L);
1790   TEST_f_f (ceil, -4503599627370496.5000000000001L, -4503599627370496.0L);
1791 # endif
1792
1793   TEST_f_f (ceil, 9007199254740991.5L, 9007199254740992.0L);
1794   TEST_f_f (ceil, 9007199254740992.25L, 9007199254740993.0L);
1795   TEST_f_f (ceil, 9007199254740992.5L, 9007199254740993.0L);
1796   TEST_f_f (ceil, 9007199254740992.75L, 9007199254740993.0L);
1797   TEST_f_f (ceil, 9007199254740993.5L, 9007199254740994.0L);
1798
1799   TEST_f_f (ceil, -9007199254740991.5L, -9007199254740991.0L);
1800   TEST_f_f (ceil, -9007199254740992.25L, -9007199254740992.0L);
1801   TEST_f_f (ceil, -9007199254740992.5L, -9007199254740992.0L);
1802   TEST_f_f (ceil, -9007199254740992.75L, -9007199254740992.0L);
1803   TEST_f_f (ceil, -9007199254740993.5L, -9007199254740993.0L);
1804
1805 # if LDBL_MANT_DIG > 100
1806   TEST_f_f (ceil, 9007199254740991.0000000000001L, 9007199254740992.0L);
1807   TEST_f_f (ceil, 9007199254740992.0000000000001L, 9007199254740993.0L);
1808   TEST_f_f (ceil, 9007199254740993.0000000000001L, 9007199254740994.0L);
1809   TEST_f_f (ceil, 9007199254740991.5000000000001L, 9007199254740992.0L);
1810   TEST_f_f (ceil, 9007199254740992.5000000000001L, 9007199254740993.0L);
1811   TEST_f_f (ceil, 9007199254740993.5000000000001L, 9007199254740994.0L);
1812
1813   TEST_f_f (ceil, -9007199254740991.0000000000001L, -9007199254740991.0L);
1814   TEST_f_f (ceil, -9007199254740992.0000000000001L, -9007199254740992.0L);
1815   TEST_f_f (ceil, -9007199254740993.0000000000001L, -9007199254740993.0L);
1816   TEST_f_f (ceil, -9007199254740991.5000000000001L, -9007199254740991.0L);
1817   TEST_f_f (ceil, -9007199254740992.5000000000001L, -9007199254740992.0L);
1818   TEST_f_f (ceil, -9007199254740993.5000000000001L, -9007199254740993.0L);
1819 # endif
1820
1821   TEST_f_f (ceil, 72057594037927935.5L, 72057594037927936.0L);
1822   TEST_f_f (ceil, 72057594037927936.25L, 72057594037927937.0L);
1823   TEST_f_f (ceil, 72057594037927936.5L, 72057594037927937.0L);
1824   TEST_f_f (ceil, 72057594037927936.75L, 72057594037927937.0L);
1825   TEST_f_f (ceil, 72057594037927937.5L, 72057594037927938.0L);
1826
1827   TEST_f_f (ceil, -72057594037927935.5L, -72057594037927935.0L);
1828   TEST_f_f (ceil, -72057594037927936.25L, -72057594037927936.0L);
1829   TEST_f_f (ceil, -72057594037927936.5L, -72057594037927936.0L);
1830   TEST_f_f (ceil, -72057594037927936.75L, -72057594037927936.0L);
1831   TEST_f_f (ceil, -72057594037927937.5L, -72057594037927937.0L);
1832
1833   TEST_f_f (ceil, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
1834   TEST_f_f (ceil, 10141204801825835211973625643008.25L, 10141204801825835211973625643009.0L);
1835   TEST_f_f (ceil, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
1836   TEST_f_f (ceil, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
1837   TEST_f_f (ceil, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
1838 #endif
1839
1840   END (ceil);
1841 }
1842
1843
1844 static void
1845 cexp_test (void)
1846 {
1847   errno = 0;
1848   FUNC(cexp) (BUILD_COMPLEX (0, 0));
1849   if (errno == ENOSYS)
1850     /* Function not implemented.  */
1851     return;
1852
1853   START (cexp);
1854
1855   TEST_c_c (cexp, plus_zero, plus_zero, 1, 0.0);
1856   TEST_c_c (cexp, minus_zero, plus_zero, 1, 0.0);
1857   TEST_c_c (cexp, plus_zero, minus_zero, 1, minus_zero);
1858   TEST_c_c (cexp, minus_zero, minus_zero, 1, minus_zero);
1859
1860   TEST_c_c (cexp, plus_infty, plus_zero, plus_infty, 0.0);
1861   TEST_c_c (cexp, plus_infty, minus_zero, plus_infty, minus_zero);
1862
1863   TEST_c_c (cexp, minus_infty, plus_zero, 0.0, 0.0);
1864   TEST_c_c (cexp, minus_infty, minus_zero, 0.0, minus_zero);
1865
1866   TEST_c_c (cexp, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1867   TEST_c_c (cexp, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1868
1869   TEST_c_c (cexp, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1870   TEST_c_c (cexp, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1871
1872   TEST_c_c (cexp, 100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1873   TEST_c_c (cexp, -100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1874
1875   TEST_c_c (cexp, 100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1876   TEST_c_c (cexp, -100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1877
1878   TEST_c_c (cexp, minus_infty, 2.0, minus_zero, 0.0);
1879   TEST_c_c (cexp, minus_infty, 4.0, minus_zero, minus_zero);
1880   TEST_c_c (cexp, plus_infty, 2.0, minus_infty, plus_infty);
1881   TEST_c_c (cexp, plus_infty, 4.0, minus_infty, minus_infty);
1882
1883   TEST_c_c (cexp, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1884   TEST_c_c (cexp, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1885
1886   TEST_c_c (cexp, minus_infty, plus_infty, 0.0, 0.0, IGNORE_ZERO_INF_SIGN);
1887   TEST_c_c (cexp, minus_infty, minus_infty, 0.0, minus_zero, IGNORE_ZERO_INF_SIGN);
1888
1889   TEST_c_c (cexp, minus_infty, nan_value, 0, 0, IGNORE_ZERO_INF_SIGN);
1890
1891   TEST_c_c (cexp, plus_infty, nan_value, plus_infty, nan_value);
1892
1893   TEST_c_c (cexp, nan_value, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1894   TEST_c_c (cexp, nan_value, 1.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1895
1896   TEST_c_c (cexp, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1897   TEST_c_c (cexp, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1898   TEST_c_c (cexp, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1899   TEST_c_c (cexp, nan_value, nan_value, nan_value, nan_value);
1900
1901   TEST_c_c (cexp, 0.75L, 1.25L, 0.667537446429131586942201977015932112L, 2.00900045494094876258347228145863909L);
1902   TEST_c_c (cexp, -2.0, -3.0, -0.13398091492954261346140525546115575L, -0.019098516261135196432576240858800925L);
1903
1904   TEST_c_c (cexp, 0, 0x1p65, 0.99888622066058013610642172179340364209972L, -0.047183876212354673805106149805700013943218L);
1905   TEST_c_c (cexp, 0, -0x1p65, 0.99888622066058013610642172179340364209972L, 0.047183876212354673805106149805700013943218L);
1906   TEST_c_c (cexp, 50, 0x1p127, 4.053997150228616856622417636046265337193e21L, 3.232070315463388524466674772633810238819e21L);
1907
1908 #ifndef TEST_FLOAT
1909   TEST_c_c (cexp, 0, 1e22, 0.5232147853951389454975944733847094921409L, -0.8522008497671888017727058937530293682618L);
1910   TEST_c_c (cexp, 0, 0x1p1023, -0.826369834614147994500785680811743734805L, 0.5631277798508840134529434079444683477104L);
1911   TEST_c_c (cexp, 500, 0x1p1023, -1.159886268932754433233243794561351783426e217L, 7.904017694554466595359379965081774849708e216L);
1912 #endif
1913
1914 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
1915   TEST_c_c (cexp, 0, 0x1p16383L, 0.9210843909921906206874509522505756251609L, 0.3893629985894208126948115852610595405563L);
1916   TEST_c_c (cexp, -10000, 0x1p16383L, 1.045876464564882298442774542991176546722e-4343L, 4.421154026488516836023811173959413420548e-4344L);
1917 #endif
1918
1919   TEST_c_c (cexp, 88.75, 0.75, 2.558360358486542817001900410314204322891e38L, 2.383359453227311447654736314679677655100e38L);
1920   TEST_c_c (cexp, -95, 0.75, 4.039714446238306526889476684000081624047e-42L, 3.763383677300535390271646960780570275931e-42L);
1921
1922 #ifndef TEST_FLOAT
1923   TEST_c_c (cexp, 709.8125, 0.75, 1.355121963080879535248452862759108365762e308L, 1.262426823598609432507811340856186873507e308L);
1924   TEST_c_c (cexp, -720, 0.75, 1.486960657116368433685753325516638551722e-313L, 1.385247284245720590980701226843815229385e-313L);
1925 #endif
1926
1927 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
1928   TEST_c_c (cexp, 11356.5625, 0.75, 9.052188470850960144814815984311663764287e4931L, 8.432986734191301036267148978260970230200e4931L);
1929   TEST_c_c (cexp, -11370, 0.75, 8.631121063182211587489310508568170739592e-4939L, 8.040721827809267291427062346918413482824e-4939L);
1930 #endif
1931
1932 #ifdef TEST_FLOAT
1933   TEST_c_c (cexp, 180, 0x1p-149, plus_infty, 2.087071793345235105931967606907855310664e33L, OVERFLOW_EXCEPTION);
1934 #endif
1935
1936 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
1937   TEST_c_c (cexp, 1440, 0x1p-1074, plus_infty, 1.196295853897226111293303155636183216483e302L, OVERFLOW_EXCEPTION);
1938 #endif
1939
1940 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
1941   TEST_c_c (cexp, 22730, 0x1p-16434L, plus_infty, 2.435706297811211974162115164702304105374e4924L, OVERFLOW_EXCEPTION);
1942 #endif
1943
1944   TEST_c_c (cexp, 1e6, 0, plus_infty, 0, OVERFLOW_EXCEPTION);
1945   TEST_c_c (cexp, 1e6, min_value, plus_infty, plus_infty, OVERFLOW_EXCEPTION);
1946   TEST_c_c (cexp, 1e6, -min_value, plus_infty, minus_infty, OVERFLOW_EXCEPTION);
1947
1948   END (cexp, complex);
1949 }
1950
1951
1952 static void
1953 cimag_test (void)
1954 {
1955   START (cimag);
1956   TEST_c_f (cimag, 1.0, 0.0, 0.0);
1957   TEST_c_f (cimag, 1.0, minus_zero, minus_zero);
1958   TEST_c_f (cimag, 1.0, nan_value, nan_value);
1959   TEST_c_f (cimag, nan_value, nan_value, nan_value);
1960   TEST_c_f (cimag, 1.0, plus_infty, plus_infty);
1961   TEST_c_f (cimag, 1.0, minus_infty, minus_infty);
1962   TEST_c_f (cimag, 2.0, 3.0, 3.0);
1963
1964   END (cimag);
1965 }
1966
1967 static void
1968 clog_test (void)
1969 {
1970   errno = 0;
1971   FUNC(clog) (BUILD_COMPLEX (-2, -3));
1972   if (errno == ENOSYS)
1973     /* Function not implemented.  */
1974     return;
1975
1976   START (clog);
1977
1978   TEST_c_c (clog, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1979   TEST_c_c (clog, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1980
1981   TEST_c_c (clog, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
1982   TEST_c_c (clog, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
1983
1984   TEST_c_c (clog, minus_infty, plus_infty, plus_infty, M_PI_34l);
1985   TEST_c_c (clog, minus_infty, minus_infty, plus_infty, -M_PI_34l);
1986
1987   TEST_c_c (clog, plus_infty, plus_infty, plus_infty, M_PI_4l);
1988   TEST_c_c (clog, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1989
1990   TEST_c_c (clog, 0, plus_infty, plus_infty, M_PI_2l);
1991   TEST_c_c (clog, 3, plus_infty, plus_infty, M_PI_2l);
1992   TEST_c_c (clog, minus_zero, plus_infty, plus_infty, M_PI_2l);
1993   TEST_c_c (clog, -3, plus_infty, plus_infty, M_PI_2l);
1994   TEST_c_c (clog, 0, minus_infty, plus_infty, -M_PI_2l);
1995   TEST_c_c (clog, 3, minus_infty, plus_infty, -M_PI_2l);
1996   TEST_c_c (clog, minus_zero, minus_infty, plus_infty, -M_PI_2l);
1997   TEST_c_c (clog, -3, minus_infty, plus_infty, -M_PI_2l);
1998
1999   TEST_c_c (clog, minus_infty, 0, plus_infty, M_PIl);
2000   TEST_c_c (clog, minus_infty, 1, plus_infty, M_PIl);
2001   TEST_c_c (clog, minus_infty, minus_zero, plus_infty, -M_PIl);
2002   TEST_c_c (clog, minus_infty, -1, plus_infty, -M_PIl);
2003
2004   TEST_c_c (clog, plus_infty, 0, plus_infty, 0.0);
2005   TEST_c_c (clog, plus_infty, 1, plus_infty, 0.0);
2006   TEST_c_c (clog, plus_infty, minus_zero, plus_infty, minus_zero);
2007   TEST_c_c (clog, plus_infty, -1, plus_infty, minus_zero);
2008
2009   TEST_c_c (clog, plus_infty, nan_value, plus_infty, nan_value);
2010   TEST_c_c (clog, minus_infty, nan_value, plus_infty, nan_value);
2011
2012   TEST_c_c (clog, nan_value, plus_infty, plus_infty, nan_value);
2013   TEST_c_c (clog, nan_value, minus_infty, plus_infty, nan_value);
2014
2015   TEST_c_c (clog, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2016   TEST_c_c (clog, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2017   TEST_c_c (clog, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2018   TEST_c_c (clog, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2019
2020   TEST_c_c (clog, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2021   TEST_c_c (clog, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2022   TEST_c_c (clog, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2023   TEST_c_c (clog, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2024
2025   TEST_c_c (clog, nan_value, nan_value, nan_value, nan_value);
2026
2027   TEST_c_c (clog, 0.75L, 1.25L, 0.376885901188190075998919126749298416L, 1.03037682652431246378774332703115153L);
2028   TEST_c_c (clog, -2, -3, 1.2824746787307683680267437207826593L, -2.1587989303424641704769327722648368L);
2029
2030   TEST_c_c (clog, 0x1.fffffep+127L, 0x1.fffffep+127L, 89.06941264234832570836679262104313101776L, M_PI_4l);
2031   TEST_c_c (clog, 0x1.fffffep+127L, 1.0L, 88.72283905206835305365817656031404273372L, 2.938736052218037251011746307725933020145e-39L);
2032   TEST_c_c (clog, 0x1p-149L, 0x1p-149L, -102.9323563131518784484589700365392203592L, M_PI_4l);
2033   TEST_c_c (clog, 0x1p-147L, 0x1p-147L, -101.5460619520319878296245057936228672231L, M_PI_4l);
2034
2035 #ifndef TEST_FLOAT
2036   TEST_c_c (clog, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 710.1292864836639693869320059713862337880L, M_PI_4l);
2037   TEST_c_c (clog, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 709.8942846690411016323109979483151967689L, 0.4636476090008061606231772164674799632783L);
2038   TEST_c_c (clog, 0x1p-1074L, 0x1p-1074L, -744.0934983311012896593986823853525458290L, M_PI_4l);
2039   TEST_c_c (clog, 0x1p-1073L, 0x1p-1073L, -743.4003511505413443499814502638943692610L, M_PI_4l);
2040 #endif
2041
2042 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2043   TEST_c_c (clog, 0x1.fp+16383L, 0x1.fp+16383L, 11356.83823118610934184548269774874545400L, M_PI_4l);
2044   TEST_c_c (clog, 0x1.fp+16383L, 0x1p+16383L, 11356.60974243783798653123798337822335902L, 0.4764674194737066993385333770295162295856L);
2045   TEST_c_c (clog, 0x1p-16440L, 0x1p-16441L, -11395.22807662984378194141292922726786191L, 0.4636476090008061162142562314612144020285L);
2046 #endif
2047
2048   END (clog, complex);
2049 }
2050
2051
2052 static void
2053 clog10_test (void)
2054 {
2055   errno = 0;
2056   FUNC(clog10) (BUILD_COMPLEX (0.7L, 1.2L));
2057   if (errno == ENOSYS)
2058     /* Function not implemented.  */
2059     return;
2060
2061   START (clog10);
2062
2063   TEST_c_c (clog10, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2064   TEST_c_c (clog10, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2065
2066   TEST_c_c (clog10, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
2067   TEST_c_c (clog10, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
2068
2069   TEST_c_c (clog10, minus_infty, plus_infty, plus_infty, M_PI_34_LOG10El);
2070
2071   TEST_c_c (clog10, plus_infty, plus_infty, plus_infty, M_PI4_LOG10El);
2072   TEST_c_c (clog10, plus_infty, minus_infty, plus_infty, -M_PI4_LOG10El);
2073
2074   TEST_c_c (clog10, 0, plus_infty, plus_infty, M_PI2_LOG10El);
2075   TEST_c_c (clog10, 3, plus_infty, plus_infty, M_PI2_LOG10El);
2076   TEST_c_c (clog10, minus_zero, plus_infty, plus_infty, M_PI2_LOG10El);
2077   TEST_c_c (clog10, -3, plus_infty, plus_infty, M_PI2_LOG10El);
2078   TEST_c_c (clog10, 0, minus_infty, plus_infty, -M_PI2_LOG10El);
2079   TEST_c_c (clog10, 3, minus_infty, plus_infty, -M_PI2_LOG10El);
2080   TEST_c_c (clog10, minus_zero, minus_infty, plus_infty, -M_PI2_LOG10El);
2081   TEST_c_c (clog10, -3, minus_infty, plus_infty, -M_PI2_LOG10El);
2082
2083   TEST_c_c (clog10, minus_infty, 0, plus_infty, M_PI_LOG10El);
2084   TEST_c_c (clog10, minus_infty, 1, plus_infty, M_PI_LOG10El);
2085   TEST_c_c (clog10, minus_infty, minus_zero, plus_infty, -M_PI_LOG10El);
2086   TEST_c_c (clog10, minus_infty, -1, plus_infty, -M_PI_LOG10El);
2087
2088   TEST_c_c (clog10, plus_infty, 0, plus_infty, 0.0);
2089   TEST_c_c (clog10, plus_infty, 1, plus_infty, 0.0);
2090   TEST_c_c (clog10, plus_infty, minus_zero, plus_infty, minus_zero);
2091   TEST_c_c (clog10, plus_infty, -1, plus_infty, minus_zero);
2092
2093   TEST_c_c (clog10, plus_infty, nan_value, plus_infty, nan_value);
2094   TEST_c_c (clog10, minus_infty, nan_value, plus_infty, nan_value);
2095
2096   TEST_c_c (clog10, nan_value, plus_infty, plus_infty, nan_value);
2097   TEST_c_c (clog10, nan_value, minus_infty, plus_infty, nan_value);
2098
2099   TEST_c_c (clog10, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2100   TEST_c_c (clog10, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2101   TEST_c_c (clog10, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2102   TEST_c_c (clog10, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2103
2104   TEST_c_c (clog10, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2105   TEST_c_c (clog10, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2106   TEST_c_c (clog10, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2107   TEST_c_c (clog10, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2108
2109   TEST_c_c (clog10, nan_value, nan_value, nan_value, nan_value);
2110
2111   TEST_c_c (clog10, 0.75L, 1.25L, 0.163679467193165171449476605077428975L, 0.447486970040493067069984724340855636L);
2112   TEST_c_c (clog10, -2, -3, 0.556971676153418384603252578971164214L, -0.937554462986374708541507952140189646L);
2113
2114   TEST_c_c (clog10, 0x1.fffffep+127L, 0x1.fffffep+127L, 38.68235441693561449174780668781319348761L, M_PI4_LOG10El);
2115   TEST_c_c (clog10, 0x1.fffffep+127L, 1.0L, 38.53183941910362389414093724045094697423L, 1.276276851248440096917018665609900318458e-39L);
2116   TEST_c_c (clog10, 0x1p-149L, 0x1p-149L, -44.70295435610120748924022586658721447508L, M_PI4_LOG10El);
2117   TEST_c_c (clog10, 0x1p-147L, 0x1p-147L, -44.10089436477324509881274807713822842154L, M_PI4_LOG10El);
2118
2119 #ifndef TEST_FLOAT
2120   TEST_c_c (clog10, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 308.4052305577487344482591243175787477115L, M_PI4_LOG10El);
2121   TEST_c_c (clog10, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 308.3031705664207720674749211936626341569L, 0.2013595981366865903254995612594728746470L);
2122   TEST_c_c (clog10, 0x1p-1074L, 0x1p-1074L, -323.1557003452838130619487034867432642357L, M_PI4_LOG10El);
2123   TEST_c_c (clog10, 0x1p-1073L, 0x1p-1073L, -322.8546703496198318667349645920187712089L, M_PI4_LOG10El);
2124 #endif
2125
2126 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2127   TEST_c_c (clog10, 0x1.fp+16383L, 0x1.fp+16383L, 4932.212175672014259683102930239951947672L, M_PI4_LOG10El);
2128   TEST_c_c (clog10, 0x1.fp+16383L, 0x1p+16383L, 4932.112944269463028900262609694408579449L, 0.2069271710841128115912940666587802677383L);
2129   TEST_c_c (clog10, 0x1p-16440L, 0x1p-16441L, -4948.884673709346821106688037612752099609L, 0.2013595981366865710389502301937289472543L);
2130 #endif
2131
2132   END (clog10, complex);
2133 }
2134
2135
2136 static void
2137 conj_test (void)
2138 {
2139   START (conj);
2140   TEST_c_c (conj, 0.0, 0.0, 0.0, minus_zero);
2141   TEST_c_c (conj, 0.0, minus_zero, 0.0, 0.0);
2142   TEST_c_c (conj, nan_value, nan_value, nan_value, nan_value);
2143   TEST_c_c (conj, plus_infty, minus_infty, plus_infty, plus_infty);
2144   TEST_c_c (conj, plus_infty, plus_infty, plus_infty, minus_infty);
2145   TEST_c_c (conj, 1.0, 2.0, 1.0, -2.0);
2146   TEST_c_c (conj, 3.0, -4.0, 3.0, 4.0);
2147
2148   END (conj, complex);
2149 }
2150
2151
2152 static void
2153 copysign_test (void)
2154 {
2155   START (copysign);
2156
2157   TEST_ff_f (copysign, 0, 4, 0);
2158   TEST_ff_f (copysign, 0, -4, minus_zero);
2159   TEST_ff_f (copysign, minus_zero, 4, 0);
2160   TEST_ff_f (copysign, minus_zero, -4, minus_zero);
2161
2162   TEST_ff_f (copysign, plus_infty, 0, plus_infty);
2163   TEST_ff_f (copysign, plus_infty, minus_zero, minus_infty);
2164   TEST_ff_f (copysign, minus_infty, 0, plus_infty);
2165   TEST_ff_f (copysign, minus_infty, minus_zero, minus_infty);
2166
2167   TEST_ff_f (copysign, 0, plus_infty, 0);
2168   TEST_ff_f (copysign, 0, minus_zero, minus_zero);
2169   TEST_ff_f (copysign, minus_zero, plus_infty, 0);
2170   TEST_ff_f (copysign, minus_zero, minus_zero, minus_zero);
2171
2172   /* XXX More correctly we would have to check the sign of the NaN.  */
2173   TEST_ff_f (copysign, nan_value, 0, nan_value);
2174   TEST_ff_f (copysign, nan_value, minus_zero, nan_value);
2175   TEST_ff_f (copysign, -nan_value, 0, nan_value);
2176   TEST_ff_f (copysign, -nan_value, minus_zero, nan_value);
2177
2178   END (copysign);
2179 }
2180
2181
2182 static void
2183 cos_test (void)
2184 {
2185   errno = 0;
2186   FUNC(cos) (0);
2187   if (errno == ENOSYS)
2188     /* Function not implemented.  */
2189     return;
2190
2191   START (cos);
2192
2193   TEST_f_f (cos, 0, 1);
2194   TEST_f_f (cos, minus_zero, 1);
2195   errno = 0;
2196   TEST_f_f (cos, plus_infty, nan_value, INVALID_EXCEPTION);
2197   check_int ("errno for cos(+inf) == EDOM", errno, EDOM, 0, 0, 0);
2198   errno = 0;
2199   TEST_f_f (cos, minus_infty, nan_value, INVALID_EXCEPTION);
2200   check_int ("errno for cos(-inf) == EDOM", errno, EDOM, 0, 0, 0);
2201   errno = 0;
2202   TEST_f_f (cos, nan_value, nan_value);
2203   check_int ("errno for cos(NaN) unchanged", errno, 0, 0, 0, 0);
2204
2205   TEST_f_f (cos, M_PI_6l * 2.0, 0.5);
2206   TEST_f_f (cos, M_PI_6l * 4.0, -0.5);
2207   TEST_f_f (cos, M_PI_2l, 0);
2208
2209   TEST_f_f (cos, 0.75L, 0.731688868873820886311838753000084544L);
2210
2211   TEST_f_f (cos, 0x1p65, 0.99888622066058013610642172179340364209972L);
2212   TEST_f_f (cos, -0x1p65, 0.99888622066058013610642172179340364209972L);
2213
2214 #ifdef TEST_DOUBLE
2215   TEST_f_f (cos, 0.80190127184058835, 0.69534156199418473);
2216 #endif
2217
2218 #ifndef TEST_FLOAT
2219   TEST_f_f (cos, 1e22, 0.5232147853951389454975944733847094921409L);
2220   TEST_f_f (cos, 0x1p1023, -0.826369834614147994500785680811743734805L);
2221 #endif
2222
2223 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2224   TEST_f_f (cos, 0x1p16383L, 0.9210843909921906206874509522505756251609L);
2225 #endif
2226
2227   END (cos);
2228 }
2229
2230
2231 static void
2232 cos_test_tonearest (void)
2233 {
2234   int save_round_mode;
2235   errno = 0;
2236   FUNC(cos) (0);
2237   if (errno == ENOSYS)
2238     /* Function not implemented.  */
2239     return;
2240
2241   START (cos_tonearest);
2242
2243   save_round_mode = fegetround ();
2244
2245   if (!fesetround (FE_TONEAREST))
2246     {
2247       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2248       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2249       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2250       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2251       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2252       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2253       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2254       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2255       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2256       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2257     }
2258
2259   fesetround (save_round_mode);
2260
2261   END (cos_tonearest);
2262 }
2263
2264
2265 static void
2266 cos_test_towardzero (void)
2267 {
2268   int save_round_mode;
2269   errno = 0;
2270   FUNC(cos) (0);
2271   if (errno == ENOSYS)
2272     /* Function not implemented.  */
2273     return;
2274
2275   START (cos_towardzero);
2276
2277   save_round_mode = fegetround ();
2278
2279   if (!fesetround (FE_TOWARDZERO))
2280     {
2281       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2282       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2283       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2284       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2285       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2286       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2287       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2288       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2289       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2290       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2291     }
2292
2293   fesetround (save_round_mode);
2294
2295   END (cos_towardzero);
2296 }
2297
2298
2299 static void
2300 cos_test_downward (void)
2301 {
2302   int save_round_mode;
2303   errno = 0;
2304   FUNC(cos) (0);
2305   if (errno == ENOSYS)
2306     /* Function not implemented.  */
2307     return;
2308
2309   START (cos_downward);
2310
2311   save_round_mode = fegetround ();
2312
2313   if (!fesetround (FE_DOWNWARD))
2314     {
2315       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2316       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2317       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2318       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2319       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2320       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2321       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2322       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2323       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2324       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2325     }
2326
2327   fesetround (save_round_mode);
2328
2329   END (cos_downward);
2330 }
2331
2332
2333 static void
2334 cos_test_upward (void)
2335 {
2336   int save_round_mode;
2337   errno = 0;
2338   FUNC(cos) (0);
2339   if (errno == ENOSYS)
2340     /* Function not implemented.  */
2341     return;
2342
2343   START (cos_upward);
2344
2345   save_round_mode = fegetround ();
2346
2347   if (!fesetround (FE_UPWARD))
2348     {
2349       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2350       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2351       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2352       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2353       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2354       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2355       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2356       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2357       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2358       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2359     }
2360
2361   fesetround (save_round_mode);
2362
2363   END (cos_upward);
2364 }
2365
2366
2367 static void
2368 cosh_test (void)
2369 {
2370   errno = 0;
2371   FUNC(cosh) (0.7L);
2372   if (errno == ENOSYS)
2373     /* Function not implemented.  */
2374     return;
2375
2376   START (cosh);
2377   TEST_f_f (cosh, 0, 1);
2378   TEST_f_f (cosh, minus_zero, 1);
2379
2380 #ifndef TEST_INLINE
2381   TEST_f_f (cosh, plus_infty, plus_infty);
2382   TEST_f_f (cosh, minus_infty, plus_infty);
2383 #endif
2384   TEST_f_f (cosh, nan_value, nan_value);
2385
2386   TEST_f_f (cosh, 0.75L, 1.29468328467684468784170818539018176L);
2387
2388   END (cosh);
2389 }
2390
2391
2392 static void
2393 cosh_test_tonearest (void)
2394 {
2395   int save_round_mode;
2396   errno = 0;
2397   FUNC(cosh) (0);
2398   if (errno == ENOSYS)
2399     /* Function not implemented.  */
2400     return;
2401
2402   START (cosh_tonearest);
2403
2404   save_round_mode = fegetround ();
2405
2406   if (!fesetround (FE_TONEAREST))
2407     {
2408       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
2409       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
2410       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
2411     }
2412
2413   fesetround (save_round_mode);
2414
2415   END (cosh_tonearest);
2416 }
2417
2418
2419 static void
2420 cosh_test_towardzero (void)
2421 {
2422   int save_round_mode;
2423   errno = 0;
2424   FUNC(cosh) (0);
2425   if (errno == ENOSYS)
2426     /* Function not implemented.  */
2427     return;
2428
2429   START (cosh_towardzero);
2430
2431   save_round_mode = fegetround ();
2432
2433   if (!fesetround (FE_TOWARDZERO))
2434     {
2435       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
2436       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
2437       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
2438     }
2439
2440   fesetround (save_round_mode);
2441
2442   END (cosh_towardzero);
2443 }
2444
2445
2446 static void
2447 cosh_test_downward (void)
2448 {
2449   int save_round_mode;
2450   errno = 0;
2451   FUNC(cosh) (0);
2452   if (errno == ENOSYS)
2453     /* Function not implemented.  */
2454     return;
2455
2456   START (cosh_downward);
2457
2458   save_round_mode = fegetround ();
2459
2460   if (!fesetround (FE_DOWNWARD))
2461     {
2462       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
2463       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
2464       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
2465     }
2466
2467   fesetround (save_round_mode);
2468
2469   END (cosh_downward);
2470 }
2471
2472
2473 static void
2474 cosh_test_upward (void)
2475 {
2476   int save_round_mode;
2477   errno = 0;
2478   FUNC(cosh) (0);
2479   if (errno == ENOSYS)
2480     /* Function not implemented.  */
2481     return;
2482
2483   START (cosh_upward);
2484
2485   save_round_mode = fegetround ();
2486
2487   if (!fesetround (FE_UPWARD))
2488     {
2489       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
2490       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
2491       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
2492     }
2493
2494   fesetround (save_round_mode);
2495
2496   END (cosh_upward);
2497 }
2498
2499
2500 static void
2501 cpow_test (void)
2502 {
2503   errno = 0;
2504   FUNC(cpow) (BUILD_COMPLEX (1, 0), BUILD_COMPLEX (0, 0));
2505   if (errno == ENOSYS)
2506     /* Function not implemented.  */
2507     return;
2508
2509   START (cpow);
2510
2511   TEST_cc_c (cpow, 1, 0, 0, 0, 1.0, 0.0);
2512   TEST_cc_c (cpow, 2, 0, 10, 0, 1024.0, 0.0);
2513
2514   TEST_cc_c (cpow, M_El, 0, 0, 2 * M_PIl, 1.0, 0.0);
2515   TEST_cc_c (cpow, 2, 3, 4, 0, -119.0, -120.0);
2516
2517   TEST_cc_c (cpow, nan_value, nan_value, nan_value, nan_value, nan_value, nan_value);
2518
2519   TEST_cc_c (cpow, 0.75L, 1.25L, 0.75L, 1.25L, 0.117506293914473555420279832210420483L, 0.346552747708338676483025352060418001L);
2520   TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 1.0L, 0.0846958290317209430433805274189191353L, 0.513285749182902449043287190519090481L);
2521   TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 0.0L, 0.75L, 1.25L);
2522   TEST_cc_c (cpow, 0.75L, 1.25L, 0.0L, 1.0L, 0.331825439177608832276067945276730566L, 0.131338600281188544930936345230903032L);
2523
2524   END (cpow, complex);
2525 }
2526
2527
2528 static void
2529 cproj_test (void)
2530 {
2531   START (cproj);
2532   TEST_c_c (cproj, 0.0, 0.0, 0.0, 0.0);
2533   TEST_c_c (cproj, minus_zero, minus_zero, minus_zero, minus_zero);
2534   TEST_c_c (cproj, 0.0, minus_zero, 0.0, minus_zero);
2535   TEST_c_c (cproj, minus_zero, 0.0, minus_zero, 0.0);
2536
2537   TEST_c_c (cproj, nan_value, nan_value, nan_value, nan_value);
2538
2539   TEST_c_c (cproj, plus_infty, plus_infty, plus_infty, 0.0);
2540   TEST_c_c (cproj, plus_infty, minus_infty, plus_infty, minus_zero);
2541   TEST_c_c (cproj, minus_infty, plus_infty, plus_infty, 0.0);
2542   TEST_c_c (cproj, minus_infty, minus_infty, plus_infty, minus_zero);
2543
2544   TEST_c_c (cproj, 1.0, 0.0, 1.0, 0.0);
2545   TEST_c_c (cproj, 2.0, 3.0, 2.0, 3.0);
2546
2547   END (cproj, complex);
2548 }
2549
2550
2551 static void
2552 creal_test (void)
2553 {
2554   START (creal);
2555   TEST_c_f (creal, 0.0, 1.0, 0.0);
2556   TEST_c_f (creal, minus_zero, 1.0, minus_zero);
2557   TEST_c_f (creal, nan_value, 1.0, nan_value);
2558   TEST_c_f (creal, nan_value, nan_value, nan_value);
2559   TEST_c_f (creal, plus_infty, 1.0, plus_infty);
2560   TEST_c_f (creal, minus_infty, 1.0, minus_infty);
2561   TEST_c_f (creal, 2.0, 3.0, 2.0);
2562
2563   END (creal);
2564 }
2565
2566 static void
2567 csin_test (void)
2568 {
2569   errno = 0;
2570   FUNC(csin) (BUILD_COMPLEX (0.7L, 1.2L));
2571   if (errno == ENOSYS)
2572     /* Function not implemented.  */
2573     return;
2574
2575   START (csin);
2576
2577   TEST_c_c (csin, 0.0, 0.0, 0.0, 0.0);
2578   TEST_c_c (csin, minus_zero, 0.0, minus_zero, 0.0);
2579   TEST_c_c (csin, 0.0, minus_zero, 0, minus_zero);
2580   TEST_c_c (csin, minus_zero, minus_zero, minus_zero, minus_zero);
2581
2582   TEST_c_c (csin, 0.0, plus_infty, 0.0, plus_infty);
2583   TEST_c_c (csin, minus_zero, plus_infty, minus_zero, plus_infty);
2584   TEST_c_c (csin, 0.0, minus_infty, 0.0, minus_infty);
2585   TEST_c_c (csin, minus_zero, minus_infty, minus_zero, minus_infty);
2586
2587   TEST_c_c (csin, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2588   TEST_c_c (csin, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2589   TEST_c_c (csin, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2590   TEST_c_c (csin, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2591
2592   TEST_c_c (csin, plus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2593   TEST_c_c (csin, minus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2594   TEST_c_c (csin, plus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2595   TEST_c_c (csin, minus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2596
2597   TEST_c_c (csin, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
2598   TEST_c_c (csin, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
2599   TEST_c_c (csin, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
2600   TEST_c_c (csin, minus_infty, -6.75,  nan_value, nan_value, INVALID_EXCEPTION);
2601
2602   TEST_c_c (csin, 4.625, plus_infty, minus_infty, minus_infty);
2603   TEST_c_c (csin, 4.625, minus_infty, minus_infty, plus_infty);
2604   TEST_c_c (csin, -4.625, plus_infty, plus_infty, minus_infty);
2605   TEST_c_c (csin, -4.625, minus_infty, plus_infty, plus_infty);
2606
2607   TEST_c_c (csin, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2608   TEST_c_c (csin, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2609
2610   TEST_c_c (csin, nan_value, plus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2611   TEST_c_c (csin, nan_value, minus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2612
2613   TEST_c_c (csin, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2614   TEST_c_c (csin, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2615
2616   TEST_c_c (csin, 0.0, nan_value, 0.0, nan_value);
2617   TEST_c_c (csin, minus_zero, nan_value, minus_zero, nan_value);
2618
2619   TEST_c_c (csin, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2620   TEST_c_c (csin, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2621
2622   TEST_c_c (csin, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2623   TEST_c_c (csin, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2624
2625   TEST_c_c (csin, nan_value, nan_value, nan_value, nan_value);
2626
2627   TEST_c_c (csin, 0.75L, 1.25L, 1.28722291002649188575873510790565441L, 1.17210635989270256101081285116138863L);
2628   TEST_c_c (csin, -2, -3, -9.15449914691142957346729954460983256L, 4.16890695996656435075481305885375484L);
2629
2630   END (csin, complex);
2631 }
2632
2633
2634 static void
2635 csinh_test (void)
2636 {
2637   errno = 0;
2638   FUNC(csinh) (BUILD_COMPLEX (0.7L, 1.2L));
2639   if (errno == ENOSYS)
2640     /* Function not implemented.  */
2641     return;
2642
2643   START (csinh);
2644
2645   TEST_c_c (csinh, 0.0, 0.0, 0.0, 0.0);
2646   TEST_c_c (csinh, minus_zero, 0.0, minus_zero, 0.0);
2647   TEST_c_c (csinh, 0.0, minus_zero, 0.0, minus_zero);
2648   TEST_c_c (csinh, minus_zero, minus_zero, minus_zero, minus_zero);
2649
2650   TEST_c_c (csinh, 0.0, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2651   TEST_c_c (csinh, minus_zero, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2652   TEST_c_c (csinh, 0.0, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2653   TEST_c_c (csinh, minus_zero, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2654
2655   TEST_c_c (csinh, plus_infty, 0.0, plus_infty, 0.0);
2656   TEST_c_c (csinh, minus_infty, 0.0, minus_infty, 0.0);
2657   TEST_c_c (csinh, plus_infty, minus_zero, plus_infty, minus_zero);
2658   TEST_c_c (csinh, minus_infty, minus_zero, minus_infty, minus_zero);
2659
2660   TEST_c_c (csinh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2661   TEST_c_c (csinh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2662   TEST_c_c (csinh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2663   TEST_c_c (csinh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2664
2665   TEST_c_c (csinh, plus_infty, 4.625, minus_infty, minus_infty);
2666   TEST_c_c (csinh, minus_infty, 4.625, plus_infty, minus_infty);
2667   TEST_c_c (csinh, plus_infty, -4.625, minus_infty, plus_infty);
2668   TEST_c_c (csinh, minus_infty, -4.625, plus_infty, plus_infty);
2669
2670   TEST_c_c (csinh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2671   TEST_c_c (csinh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2672   TEST_c_c (csinh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2673   TEST_c_c (csinh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2674
2675   TEST_c_c (csinh, 0.0, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
2676   TEST_c_c (csinh, minus_zero, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
2677
2678   TEST_c_c (csinh, plus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
2679   TEST_c_c (csinh, minus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
2680
2681   TEST_c_c (csinh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2682   TEST_c_c (csinh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2683
2684   TEST_c_c (csinh, nan_value, 0.0, nan_value, 0.0);
2685   TEST_c_c (csinh, nan_value, minus_zero, nan_value, minus_zero);
2686
2687   TEST_c_c (csinh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2688   TEST_c_c (csinh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2689
2690   TEST_c_c (csinh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2691   TEST_c_c (csinh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2692
2693   TEST_c_c (csinh, nan_value, nan_value, nan_value, nan_value);
2694
2695   TEST_c_c (csinh, 0.75L, 1.25L, 0.259294854551162779153349830618433028L, 1.22863452409509552219214606515777594L);
2696   TEST_c_c (csinh, -2, -3, 3.59056458998577995201256544779481679L, -0.530921086248519805267040090660676560L);
2697
2698   END (csinh, complex);
2699 }
2700
2701
2702 static void
2703 csqrt_test (void)
2704 {
2705   errno = 0;
2706   FUNC(csqrt) (BUILD_COMPLEX (-1, 0));
2707   if (errno == ENOSYS)
2708     /* Function not implemented.  */
2709     return;
2710
2711   START (csqrt);
2712
2713   TEST_c_c (csqrt, 0, 0, 0.0, 0.0);
2714   TEST_c_c (csqrt, 0, minus_zero, 0, minus_zero);
2715   TEST_c_c (csqrt, minus_zero, 0, 0.0, 0.0);
2716   TEST_c_c (csqrt, minus_zero, minus_zero, 0.0, minus_zero);
2717
2718   TEST_c_c (csqrt, minus_infty, 0, 0.0, plus_infty);
2719   TEST_c_c (csqrt, minus_infty, 6, 0.0, plus_infty);
2720   TEST_c_c (csqrt, minus_infty, minus_zero, 0.0, minus_infty);
2721   TEST_c_c (csqrt, minus_infty, -6, 0.0, minus_infty);
2722
2723   TEST_c_c (csqrt, plus_infty, 0, plus_infty, 0.0);
2724   TEST_c_c (csqrt, plus_infty, 6, plus_infty, 0.0);
2725   TEST_c_c (csqrt, plus_infty, minus_zero, plus_infty, minus_zero);
2726   TEST_c_c (csqrt, plus_infty, -6, plus_infty, minus_zero);
2727
2728   TEST_c_c (csqrt, 0, plus_infty, plus_infty, plus_infty);
2729   TEST_c_c (csqrt, 4, plus_infty, plus_infty, plus_infty);
2730   TEST_c_c (csqrt, plus_infty, plus_infty, plus_infty, plus_infty);
2731   TEST_c_c (csqrt, minus_zero, plus_infty, plus_infty, plus_infty);
2732   TEST_c_c (csqrt, -4, plus_infty, plus_infty, plus_infty);
2733   TEST_c_c (csqrt, minus_infty, plus_infty, plus_infty, plus_infty);
2734   TEST_c_c (csqrt, 0, minus_infty, plus_infty, minus_infty);
2735   TEST_c_c (csqrt, 4, minus_infty, plus_infty, minus_infty);
2736   TEST_c_c (csqrt, plus_infty, minus_infty, plus_infty, minus_infty);
2737   TEST_c_c (csqrt, minus_zero, minus_infty, plus_infty, minus_infty);
2738   TEST_c_c (csqrt, -4, minus_infty, plus_infty, minus_infty);
2739   TEST_c_c (csqrt, minus_infty, minus_infty, plus_infty, minus_infty);
2740
2741   TEST_c_c (csqrt, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2742
2743   TEST_c_c (csqrt, plus_infty, nan_value, plus_infty, nan_value);
2744
2745   TEST_c_c (csqrt, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2746   TEST_c_c (csqrt, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2747   TEST_c_c (csqrt, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2748   TEST_c_c (csqrt, -1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2749
2750   TEST_c_c (csqrt, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2751   TEST_c_c (csqrt, nan_value, 8, nan_value, nan_value, INVALID_EXCEPTION_OK);
2752   TEST_c_c (csqrt, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2753   TEST_c_c (csqrt, nan_value, -8, nan_value, nan_value, INVALID_EXCEPTION_OK);
2754
2755   TEST_c_c (csqrt, nan_value, nan_value, nan_value, nan_value);
2756
2757   TEST_c_c (csqrt, 16.0, -30.0, 5.0, -3.0);
2758   TEST_c_c (csqrt, -1, 0, 0.0, 1.0);
2759   TEST_c_c (csqrt, 0, 2, 1.0, 1.0);
2760   TEST_c_c (csqrt, 119, 120, 12.0, 5.0);
2761   TEST_c_c (csqrt, 0.75L, 1.25L, 1.05065169626078392338656675760808326L, 0.594868882070379067881984030639932657L);
2762   TEST_c_c (csqrt, -2, -3, 0.89597747612983812471573375529004348L, -1.6741492280355400404480393008490519L);
2763   TEST_c_c (csqrt, -2, 3, 0.89597747612983812471573375529004348L, 1.6741492280355400404480393008490519L);
2764   /* Principal square root should be returned (i.e., non-negative real
2765      part).  */
2766   TEST_c_c (csqrt, 0, -1, M_SQRT_2_2, -M_SQRT_2_2);
2767
2768   TEST_c_c (csqrt, 0x1.fffffep+127L, 0x1.fffffep+127L, 2.026714405498316804978751017492482558075e+19L, 8.394925938143272988211878516208015586281e+18L);
2769   TEST_c_c (csqrt, 0x1.fffffep+127L, 1.0L, 1.844674352395372953599975585936590505260e+19L, 2.710505511993121390769065968615872097053e-20L);
2770   TEST_c_c (csqrt, 0x1p-149L, 0x1p-149L, 4.112805464342778798097003462770175200803e-23L, 1.703579802732953750368659735601389709551e-23L);
2771   TEST_c_c (csqrt, 0x1p-147L, 0x1p-147L, 8.225610928685557596194006925540350401606e-23L, 3.407159605465907500737319471202779419102e-23L);
2772
2773 #ifndef TEST_FLOAT
2774   TEST_c_c (csqrt, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 1.473094556905565378990473658199034571917e+154L, 6.101757441282702188537080005372547713595e+153L);
2775   TEST_c_c (csqrt, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 1.379778091031440685006200821918878702861e+154L, 3.257214233483129514781233066898042490248e+153L);
2776   TEST_c_c (csqrt, 0x1p-1074L, 0x1p-1074L, 2.442109726130830256743814843868934877597e-162L, 1.011554969366634726113090867589031782487e-162L);
2777   TEST_c_c (csqrt, 0x1p-1073L, 0x1p-1073L, 3.453664695497464982856905711457966660085e-162L, 1.430554756764195530630723976279903095110e-162L);
2778 #endif
2779
2780 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2781   TEST_c_c (csqrt, 0x1.fp+16383L, 0x1.fp+16383L, 1.179514222452201722651836720466795901016e+2466L, 4.885707879516577666702435054303191575148e+2465L);
2782   TEST_c_c (csqrt, 0x1.fp+16383L, 0x1p+16383L, 1.106698967236475180613254276996359485630e+2466L, 2.687568007603946993388538156299100955642e+2465L);
2783   TEST_c_c (csqrt, 0x1p-16440L, 0x1p-16441L, 3.514690655930285351254618340783294558136e-2475L,  8.297059146828716918029689466551384219370e-2476L);
2784 #endif
2785
2786   END (csqrt, complex);
2787 }
2788
2789 static void
2790 ctan_test (void)
2791 {
2792   errno = 0;
2793   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
2794   if (errno == ENOSYS)
2795     /* Function not implemented.  */
2796     return;
2797
2798   START (ctan);
2799
2800   TEST_c_c (ctan, 0, 0, 0.0, 0.0);
2801   TEST_c_c (ctan, 0, minus_zero, 0.0, minus_zero);
2802   TEST_c_c (ctan, minus_zero, 0, minus_zero, 0.0);
2803   TEST_c_c (ctan, minus_zero, minus_zero, minus_zero, minus_zero);
2804
2805   TEST_c_c (ctan, 0, plus_infty, 0.0, 1.0);
2806   TEST_c_c (ctan, 1, plus_infty, 0.0, 1.0);
2807   TEST_c_c (ctan, minus_zero, plus_infty, minus_zero, 1.0);
2808   TEST_c_c (ctan, -1, plus_infty, minus_zero, 1.0);
2809
2810   TEST_c_c (ctan, 0, minus_infty, 0.0, -1.0);
2811   TEST_c_c (ctan, 1, minus_infty, 0.0, -1.0);
2812   TEST_c_c (ctan, minus_zero, minus_infty, minus_zero, -1.0);
2813   TEST_c_c (ctan, -1, minus_infty, minus_zero, -1.0);
2814
2815   TEST_c_c (ctan, plus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
2816   TEST_c_c (ctan, plus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
2817   TEST_c_c (ctan, minus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
2818   TEST_c_c (ctan, minus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
2819   TEST_c_c (ctan, plus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
2820   TEST_c_c (ctan, plus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
2821   TEST_c_c (ctan, minus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
2822   TEST_c_c (ctan, minus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
2823
2824   TEST_c_c (ctan, nan_value, plus_infty, 0.0, 1.0, IGNORE_ZERO_INF_SIGN);
2825   TEST_c_c (ctan, nan_value, minus_infty, 0.0, -1.0, IGNORE_ZERO_INF_SIGN);
2826
2827   TEST_c_c (ctan, 0, nan_value, 0.0, nan_value);
2828   TEST_c_c (ctan, minus_zero, nan_value, minus_zero, nan_value);
2829
2830   TEST_c_c (ctan, 0.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2831   TEST_c_c (ctan, -4.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2832
2833   TEST_c_c (ctan, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2834   TEST_c_c (ctan, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2835   TEST_c_c (ctan, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2836   TEST_c_c (ctan, nan_value, -0.25, nan_value, nan_value, INVALID_EXCEPTION_OK);
2837
2838   TEST_c_c (ctan, nan_value, nan_value, nan_value, nan_value);
2839
2840   TEST_c_c (ctan, 0.75L, 1.25L, 0.160807785916206426725166058173438663L, 0.975363285031235646193581759755216379L);
2841   TEST_c_c (ctan, -2, -3, 0.376402564150424829275122113032269084e-2L, -1.00323862735360980144635859782192726L);
2842
2843   TEST_c_c (ctan, 1, 45, 1.490158918874345552942703234806348520895e-39L, 1.000000000000000000000000000000000000001L);
2844   TEST_c_c (ctan, 1, 47, 2.729321264492904590777293425576722354636e-41L, 1.0);
2845
2846 #ifndef TEST_FLOAT
2847   TEST_c_c (ctan, 1, 355, 8.140551093483276762350406321792653551513e-309L, 1.0);
2848   TEST_c_c (ctan, 1, 365, 1.677892637497921890115075995898773550884e-317L, 1.0);
2849 #endif
2850
2851 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2852   TEST_c_c (ctan, 1, 5680, 4.725214596136812019616700920476949798307e-4934L, 1.0);
2853   TEST_c_c (ctan, 1, 5690, 9.739393181626937151720816611272607059057e-4943L, 1.0);
2854 #endif
2855
2856   TEST_c_c (ctan, 0x3.243f6cp-1, 0, -2.287733242885645987394874673945769518150e7L, 0.0);
2857
2858   TEST_c_c (ctan, 0x1p127, 1, 0.2446359391192790896381501310437708987204L, 0.9101334047676183761532873794426475906201L);
2859
2860 #ifndef TEST_FLOAT
2861   TEST_c_c (ctan, 0x1p1023, 1, -0.2254627924997545057926782581695274244229L, 0.8786063118883068695462540226219865087189L);
2862 #endif
2863
2864 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2865   TEST_c_c (ctan, 0x1p16383L, 1, 0.1608598776370396607204448234354670036772L, 0.8133818522051542536316746743877629761488L);
2866 #endif
2867
2868   TEST_c_c (ctan, 50000, 50000, plus_zero, 1.0);
2869   TEST_c_c (ctan, 50000, -50000, plus_zero, -1.0);
2870   TEST_c_c (ctan, -50000, 50000, minus_zero, 1.0);
2871   TEST_c_c (ctan, -50000, -50000, minus_zero, -1.0);
2872
2873   END (ctan, complex);
2874 }
2875
2876
2877 static void
2878 ctanh_test (void)
2879 {
2880   errno = 0;
2881   FUNC(ctanh) (BUILD_COMPLEX (0, 0));
2882   if (errno == ENOSYS)
2883     /* Function not implemented.  */
2884     return;
2885
2886   START (ctanh);
2887
2888   TEST_c_c (ctanh, 0, 0, 0.0, 0.0);
2889   TEST_c_c (ctanh, 0, minus_zero, 0.0, minus_zero);
2890   TEST_c_c (ctanh, minus_zero, 0, minus_zero, 0.0);
2891   TEST_c_c (ctanh, minus_zero, minus_zero, minus_zero, minus_zero);
2892
2893   TEST_c_c (ctanh, plus_infty, 0, 1.0, 0.0);
2894   TEST_c_c (ctanh, plus_infty, 1, 1.0, 0.0);
2895   TEST_c_c (ctanh, plus_infty, minus_zero, 1.0, minus_zero);
2896   TEST_c_c (ctanh, plus_infty, -1, 1.0, minus_zero);
2897   TEST_c_c (ctanh, minus_infty, 0, -1.0, 0.0);
2898   TEST_c_c (ctanh, minus_infty, 1, -1.0, 0.0);
2899   TEST_c_c (ctanh, minus_infty, minus_zero, -1.0, minus_zero);
2900   TEST_c_c (ctanh, minus_infty, -1, -1.0, minus_zero);
2901
2902   TEST_c_c (ctanh, 0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2903   TEST_c_c (ctanh, 2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2904   TEST_c_c (ctanh, 0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2905   TEST_c_c (ctanh, 2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2906   TEST_c_c (ctanh, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2907   TEST_c_c (ctanh, -2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2908   TEST_c_c (ctanh, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2909   TEST_c_c (ctanh, -2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2910
2911   TEST_c_c (ctanh, plus_infty, nan_value, 1.0, 0.0, IGNORE_ZERO_INF_SIGN);
2912   TEST_c_c (ctanh, minus_infty, nan_value, -1.0, 0.0, IGNORE_ZERO_INF_SIGN);
2913
2914   TEST_c_c (ctanh, nan_value, 0, nan_value, 0.0);
2915   TEST_c_c (ctanh, nan_value, minus_zero, nan_value, minus_zero);
2916
2917   TEST_c_c (ctanh, nan_value, 0.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2918   TEST_c_c (ctanh, nan_value, -4.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2919
2920   TEST_c_c (ctanh, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2921   TEST_c_c (ctanh, 5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2922   TEST_c_c (ctanh, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2923   TEST_c_c (ctanh, -0.25, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2924
2925   TEST_c_c (ctanh, nan_value, nan_value, nan_value, nan_value);
2926
2927   TEST_c_c (ctanh, 0, M_PI_4l, 0.0, 1.0);
2928
2929   TEST_c_c (ctanh, 0.75L, 1.25L, 1.37260757053378320258048606571226857L, 0.385795952609750664177596760720790220L);
2930   TEST_c_c (ctanh, -2, -3, -0.965385879022133124278480269394560686L, 0.988437503832249372031403430350121098e-2L);
2931
2932   TEST_c_c (ctanh, 45, 1, 1.000000000000000000000000000000000000001L, 1.490158918874345552942703234806348520895e-39L);
2933   TEST_c_c (ctanh, 47, 1, 1.0, 2.729321264492904590777293425576722354636e-41L);
2934
2935 #ifndef TEST_FLOAT
2936   TEST_c_c (ctanh, 355, 1, 1.0, 8.140551093483276762350406321792653551513e-309L);
2937   TEST_c_c (ctanh, 365, 1, 1.0, 1.677892637497921890115075995898773550884e-317L);
2938 #endif
2939
2940 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2941   TEST_c_c (ctanh, 5680, 1, 1.0, 4.725214596136812019616700920476949798307e-4934L);
2942   TEST_c_c (ctanh, 5690, 1, 1.0, 9.739393181626937151720816611272607059057e-4943L);
2943 #endif
2944
2945   TEST_c_c (ctanh, 0, 0x3.243f6cp-1, 0.0, -2.287733242885645987394874673945769518150e7L);
2946
2947   TEST_c_c (ctanh, 1, 0x1p127, 0.9101334047676183761532873794426475906201L, 0.2446359391192790896381501310437708987204L);
2948
2949 #ifndef TEST_FLOAT
2950   TEST_c_c (ctanh, 1, 0x1p1023, 0.8786063118883068695462540226219865087189L, -0.2254627924997545057926782581695274244229L);
2951 #endif
2952
2953 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2954   TEST_c_c (ctanh, 1, 0x1p16383L, 0.8133818522051542536316746743877629761488L, 0.1608598776370396607204448234354670036772L);
2955 #endif
2956
2957   TEST_c_c (ctanh, 50000, 50000, 1.0, plus_zero);
2958   TEST_c_c (ctanh, 50000, -50000, 1.0, minus_zero);
2959   TEST_c_c (ctanh, -50000, 50000, -1.0, plus_zero);
2960   TEST_c_c (ctanh, -50000, -50000, -1.0, minus_zero);
2961
2962   END (ctanh, complex);
2963 }
2964
2965
2966 static void
2967 erf_test (void)
2968 {
2969   errno = 0;
2970   FUNC(erf) (0);
2971   if (errno == ENOSYS)
2972     /* Function not implemented.  */
2973     return;
2974
2975   START (erf);
2976
2977   TEST_f_f (erf, 0, 0);
2978   TEST_f_f (erf, minus_zero, minus_zero);
2979   TEST_f_f (erf, plus_infty, 1);
2980   TEST_f_f (erf, minus_infty, -1);
2981   TEST_f_f (erf, nan_value, nan_value);
2982
2983   TEST_f_f (erf, 0.125L, 0.140316204801333817393029446521623398L);
2984   TEST_f_f (erf, 0.75L, 0.711155633653515131598937834591410777L);
2985   TEST_f_f (erf, 1.25L, 0.922900128256458230136523481197281140L);
2986   TEST_f_f (erf, 2.0L, 0.995322265018952734162069256367252929L);
2987   TEST_f_f (erf, 4.125L, 0.999999994576599200434933994687765914L);
2988   TEST_f_f (erf, 27.0L, 1.0L);
2989
2990   END (erf);
2991 }
2992
2993
2994 static void
2995 erfc_test (void)
2996 {
2997   errno = 0;
2998   FUNC(erfc) (0);
2999   if (errno == ENOSYS)
3000     /* Function not implemented.  */
3001     return;
3002
3003   START (erfc);
3004
3005   TEST_f_f (erfc, plus_infty, 0.0);
3006   TEST_f_f (erfc, minus_infty, 2.0);
3007   TEST_f_f (erfc, 0.0, 1.0);
3008   TEST_f_f (erfc, minus_zero, 1.0);
3009   TEST_f_f (erfc, nan_value, nan_value);
3010
3011   TEST_f_f (erfc, 0.125L, 0.859683795198666182606970553478376602L);
3012   TEST_f_f (erfc, 0.75L, 0.288844366346484868401062165408589223L);
3013   TEST_f_f (erfc, 1.25L, 0.0770998717435417698634765188027188596L);
3014   TEST_f_f (erfc, 2.0L, 0.00467773498104726583793074363274707139L);
3015   TEST_f_f (erfc, 0x1.f7303cp+1L, 2.705500297238986897105236321218861842255e-8L);
3016   TEST_f_f (erfc, 4.125L, 0.542340079956506600531223408575531062e-8L);
3017   TEST_f_f (erfc, 0x1.ffa002p+2L, 1.233585992097580296336099501489175967033e-29L);
3018   TEST_f_f (erfc, 0x1.ffffc8p+2L, 1.122671365033056305522366683719541099329e-29L);
3019 #ifdef TEST_LDOUBLE
3020   /* The result can only be represented in long double.  */
3021 # if LDBL_MIN_10_EXP < -319
3022   TEST_f_f (erfc, 27.0L, 0.523704892378925568501606768284954709e-318L);
3023 # endif
3024 # if LDBL_MANT_DIG >= 106
3025   TEST_f_f (erfc, 0x1.ffff56789abcdef0123456789a8p+2L, 1.123161416304655390092138725253789378459e-29L);
3026 # endif
3027 #endif
3028
3029   END (erfc);
3030 }
3031
3032
3033 static void
3034 exp_test (void)
3035 {
3036   errno = 0;
3037   FUNC(exp) (0);
3038   if (errno == ENOSYS)
3039     /* Function not implemented.  */
3040     return;
3041
3042   START (exp);
3043
3044   TEST_f_f (exp, 0, 1);
3045   TEST_f_f (exp, minus_zero, 1);
3046
3047 #ifndef TEST_INLINE
3048   TEST_f_f (exp, plus_infty, plus_infty);
3049   TEST_f_f (exp, minus_infty, 0);
3050 #endif
3051   TEST_f_f (exp, nan_value, nan_value);
3052   TEST_f_f (exp, 1, M_El);
3053
3054   TEST_f_f (exp, 2, M_E2l);
3055   TEST_f_f (exp, 3, M_E3l);
3056   TEST_f_f (exp, 0.75L, 2.11700001661267466854536981983709561L);
3057   TEST_f_f (exp, 50.0L, 5184705528587072464087.45332293348538L);
3058   TEST_f_f (exp, 88.72269439697265625L, 3.40233126623160774937554134772290447915e38L);
3059 #if defined TEST_LDOUBLE && __LDBL_MAX_EXP__ > 1024
3060   /* The result can only be represented in sane long double.  */
3061   TEST_f_f (exp, 1000.0L, 0.197007111401704699388887935224332313e435L);
3062 #endif
3063
3064   /* Bug 13922: OVERFLOW exception may be missing.  */
3065   TEST_f_f (exp, max_value, plus_infty, OVERFLOW_EXCEPTION_OK);
3066   TEST_f_f (exp, -max_value, 0);
3067
3068   END (exp);
3069 }
3070
3071
3072 static void
3073 exp_test_tonearest (void)
3074 {
3075   int save_round_mode;
3076   errno = 0;
3077   FUNC(exp) (0);
3078   if (errno == ENOSYS)
3079     /* Function not implemented.  */
3080     return;
3081
3082   START (exp_tonearest);
3083
3084   save_round_mode = fegetround ();
3085
3086   if (!fesetround (FE_TONEAREST))
3087     {
3088       TEST_f_f (exp, 1, M_El);
3089       TEST_f_f (exp, 2, M_E2l);
3090       TEST_f_f (exp, 3, M_E3l);
3091     }
3092
3093   fesetround (save_round_mode);
3094
3095   END (exp_tonearest);
3096 }
3097
3098
3099 static void
3100 exp_test_towardzero (void)
3101 {
3102   int save_round_mode;
3103   errno = 0;
3104   FUNC(exp) (0);
3105   if (errno == ENOSYS)
3106     /* Function not implemented.  */
3107     return;
3108
3109   START (exp_towardzero);
3110
3111   save_round_mode = fegetround ();
3112
3113   if (!fesetround (FE_TOWARDZERO))
3114     {
3115       TEST_f_f (exp, 1, M_El);
3116       TEST_f_f (exp, 2, M_E2l);
3117       TEST_f_f (exp, 3, M_E3l);
3118     }
3119
3120   fesetround (save_round_mode);
3121
3122   END (exp_towardzero);
3123 }
3124
3125
3126 static void
3127 exp_test_downward (void)
3128 {
3129   int save_round_mode;
3130   errno = 0;
3131   FUNC(exp) (0);
3132   if (errno == ENOSYS)
3133     /* Function not implemented.  */
3134     return;
3135
3136   START (exp_downward);
3137
3138   save_round_mode = fegetround ();
3139
3140   if (!fesetround (FE_DOWNWARD))
3141     {
3142       TEST_f_f (exp, 1, M_El);
3143       TEST_f_f (exp, 2, M_E2l);
3144       TEST_f_f (exp, 3, M_E3l);
3145     }
3146
3147   fesetround (save_round_mode);
3148
3149   END (exp_downward);
3150 }
3151
3152
3153 static void
3154 exp_test_upward (void)
3155 {
3156   int save_round_mode;
3157   errno = 0;
3158   FUNC(exp) (0);
3159   if (errno == ENOSYS)
3160     /* Function not implemented.  */
3161     return;
3162
3163   START (exp_upward);
3164
3165   save_round_mode = fegetround ();
3166
3167   if (!fesetround (FE_UPWARD))
3168     {
3169       TEST_f_f (exp, 1, M_El);
3170       TEST_f_f (exp, 2, M_E2l);
3171       TEST_f_f (exp, 3, M_E3l);
3172     }
3173
3174   fesetround (save_round_mode);
3175
3176   END (exp_upward);
3177 }
3178
3179
3180 static void
3181 exp10_test (void)
3182 {
3183   errno = 0;
3184   FUNC(exp10) (0);
3185   if (errno == ENOSYS)
3186     /* Function not implemented.  */
3187     return;
3188
3189   START (exp10);
3190
3191   TEST_f_f (exp10, 0, 1);
3192   TEST_f_f (exp10, minus_zero, 1);
3193
3194   TEST_f_f (exp10, plus_infty, plus_infty);
3195   TEST_f_f (exp10, minus_infty, 0);
3196   TEST_f_f (exp10, nan_value, nan_value);
3197   TEST_f_f (exp10, 3, 1000);
3198   TEST_f_f (exp10, -1, 0.1L);
3199   TEST_f_f (exp10, 1e6, plus_infty, OVERFLOW_EXCEPTION);
3200   TEST_f_f (exp10, -1e6, 0);
3201 #ifndef TEST_LDOUBLE /* Bug 13914: spurious exceptions.  */
3202   TEST_f_f (exp10, max_value, plus_infty, OVERFLOW_EXCEPTION);
3203   /* Bug 13924: spurious OVERFLOW exception may be present.  */
3204   TEST_f_f (exp10, -max_value, 0, OVERFLOW_EXCEPTION_OK);
3205 #endif
3206   TEST_f_f (exp10, 0.75L, 5.62341325190349080394951039776481231L);
3207
3208   END (exp10);
3209 }
3210
3211
3212 static void
3213 exp2_test (void)
3214 {
3215   errno = 0;
3216   FUNC(exp2) (0);
3217   if (errno == ENOSYS)
3218     /* Function not implemented.  */
3219     return;
3220
3221   START (exp2);
3222
3223   TEST_f_f (exp2, 0, 1);
3224   TEST_f_f (exp2, minus_zero, 1);
3225   TEST_f_f (exp2, plus_infty, plus_infty);
3226   TEST_f_f (exp2, minus_infty, 0);
3227   TEST_f_f (exp2, nan_value, nan_value);
3228
3229   TEST_f_f (exp2, 10, 1024);
3230   TEST_f_f (exp2, -1, 0.5);
3231   TEST_f_f (exp2, 1e6, plus_infty, OVERFLOW_EXCEPTION);
3232   TEST_f_f (exp2, -1e6, 0);
3233   TEST_f_f (exp2, max_value, plus_infty, OVERFLOW_EXCEPTION);
3234   TEST_f_f (exp2, -max_value, 0);
3235   TEST_f_f (exp2, 0.75L, 1.68179283050742908606225095246642979L);
3236
3237   TEST_f_f (exp2, 100.5, 1.792728671193156477399422023278661496394e+30L);
3238   TEST_f_f (exp2, 127, 0x1p127);
3239   TEST_f_f (exp2, -149, 0x1p-149);
3240
3241 #ifndef TEST_FLOAT
3242   TEST_f_f (exp2, 1000.25, 1.274245659452564874772384918171765416737e+301L);
3243   TEST_f_f (exp2, 1023, 0x1p1023);
3244   TEST_f_f (exp2, -1074, 0x1p-1074);
3245 #endif
3246
3247 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3248   TEST_f_f (exp2, 16383, 0x1p16383L);
3249   TEST_f_f (exp2, -16400, 0x1p-16400L);
3250 #endif
3251
3252   END (exp2);
3253 }
3254
3255
3256 static void
3257 expm1_test (void)
3258 {
3259   errno = 0;
3260   FUNC(expm1) (0);
3261   if (errno == ENOSYS)
3262     /* Function not implemented.  */
3263     return;
3264
3265   START (expm1);
3266
3267   TEST_f_f (expm1, 0, 0);
3268   TEST_f_f (expm1, minus_zero, minus_zero);
3269
3270 #ifndef TEST_INLINE
3271   TEST_f_f (expm1, plus_infty, plus_infty);
3272   TEST_f_f (expm1, minus_infty, -1);
3273 #endif
3274   TEST_f_f (expm1, nan_value, nan_value);
3275
3276   TEST_f_f (expm1, 1, M_El - 1.0);
3277   TEST_f_f (expm1, 0.75L, 1.11700001661267466854536981983709561L);
3278
3279 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3280   TEST_f_f (expm1, 11356.25L, 9.05128237311923300051376115753226014206e+4931L);
3281 #endif
3282
3283   errno = 0;
3284   /* Bug 13787: OVERFLOW exception may be missing.  */
3285   TEST_f_f (expm1, 100000.0, plus_infty, OVERFLOW_EXCEPTION_OK);
3286   check_int ("errno for expm1(large) == ERANGE", errno, ERANGE, 0, 0, 0);
3287   /* Bug 13787: OVERFLOW exception may be missing.  */
3288   TEST_f_f (expm1, max_value, plus_infty, OVERFLOW_EXCEPTION_OK);
3289 #ifndef TEST_LDOUBLE /* Bug 13923.  */
3290   TEST_f_f (expm1, -max_value, -1);
3291 #endif
3292
3293   END (expm1);
3294 }
3295
3296
3297 static void
3298 fabs_test (void)
3299 {
3300   START (fabs);
3301
3302   TEST_f_f (fabs, 0, 0);
3303   TEST_f_f (fabs, minus_zero, 0);
3304
3305   TEST_f_f (fabs, plus_infty, plus_infty);
3306   TEST_f_f (fabs, minus_infty, plus_infty);
3307   TEST_f_f (fabs, nan_value, nan_value);
3308
3309   TEST_f_f (fabs, 38.0, 38.0);
3310   TEST_f_f (fabs, -M_El, M_El);
3311
3312   END (fabs);
3313 }
3314
3315
3316 static void
3317 fdim_test (void)
3318 {
3319   START (fdim);
3320
3321   TEST_ff_f (fdim, 0, 0, 0);
3322   TEST_ff_f (fdim, 9, 0, 9);
3323   TEST_ff_f (fdim, 0, 9, 0);
3324   TEST_ff_f (fdim, -9, 0, 0);
3325   TEST_ff_f (fdim, 0, -9, 9);
3326
3327   TEST_ff_f (fdim, plus_infty, 9, plus_infty);
3328   TEST_ff_f (fdim, plus_infty, -9, plus_infty);
3329   TEST_ff_f (fdim, minus_infty, 9, 0);
3330   TEST_ff_f (fdim, minus_infty, -9, 0);
3331   TEST_ff_f (fdim, 9, minus_infty, plus_infty);
3332   TEST_ff_f (fdim, -9, minus_infty, plus_infty);
3333   TEST_ff_f (fdim, 9, plus_infty, 0);
3334   TEST_ff_f (fdim, -9, plus_infty, 0);
3335
3336   TEST_ff_f (fdim, 0, nan_value, nan_value);
3337   TEST_ff_f (fdim, 9, nan_value, nan_value);
3338   TEST_ff_f (fdim, -9, nan_value, nan_value);
3339   TEST_ff_f (fdim, nan_value, 9, nan_value);
3340   TEST_ff_f (fdim, nan_value, -9, nan_value);
3341   TEST_ff_f (fdim, plus_infty, nan_value, nan_value);
3342   TEST_ff_f (fdim, minus_infty, nan_value, nan_value);
3343   TEST_ff_f (fdim, nan_value, plus_infty, nan_value);
3344   TEST_ff_f (fdim, nan_value, minus_infty, nan_value);
3345   TEST_ff_f (fdim, nan_value, nan_value, nan_value);
3346
3347   TEST_ff_f (fdim, plus_infty, plus_infty, 0);
3348
3349   END (fdim);
3350 }
3351
3352
3353 static void
3354 floor_test (void)
3355 {
3356   START (floor);
3357
3358   TEST_f_f (floor, 0.0, 0.0);
3359   TEST_f_f (floor, minus_zero, minus_zero);
3360   TEST_f_f (floor, plus_infty, plus_infty);
3361   TEST_f_f (floor, minus_infty, minus_infty);
3362   TEST_f_f (floor, nan_value, nan_value);
3363
3364   TEST_f_f (floor, M_PIl, 3.0);
3365   TEST_f_f (floor, -M_PIl, -4.0);
3366
3367   TEST_f_f (floor, 0.1, 0.0);
3368   TEST_f_f (floor, 0.25, 0.0);
3369   TEST_f_f (floor, 0.625, 0.0);
3370   TEST_f_f (floor, -0.1, -1.0);
3371   TEST_f_f (floor, -0.25, -1.0);
3372   TEST_f_f (floor, -0.625, -1.0);
3373
3374 #ifdef TEST_LDOUBLE
3375   /* The result can only be represented in long double.  */
3376   TEST_f_f (floor, 4503599627370495.5L, 4503599627370495.0L);
3377   TEST_f_f (floor, 4503599627370496.25L, 4503599627370496.0L);
3378   TEST_f_f (floor, 4503599627370496.5L, 4503599627370496.0L);
3379   TEST_f_f (floor, 4503599627370496.75L, 4503599627370496.0L);
3380   TEST_f_f (floor, 4503599627370497.5L, 4503599627370497.0L);
3381 # if LDBL_MANT_DIG > 100
3382   TEST_f_f (floor, 4503599627370494.5000000000001L, 4503599627370494.0L);
3383   TEST_f_f (floor, 4503599627370495.5000000000001L, 4503599627370495.0L);
3384   TEST_f_f (floor, 4503599627370496.5000000000001L, 4503599627370496.0L);
3385 # endif
3386
3387   TEST_f_f (floor, -4503599627370495.5L, -4503599627370496.0L);
3388   TEST_f_f (floor, -4503599627370496.25L, -4503599627370497.0L);
3389   TEST_f_f (floor, -4503599627370496.5L, -4503599627370497.0L);
3390   TEST_f_f (floor, -4503599627370496.75L, -4503599627370497.0L);
3391   TEST_f_f (floor, -4503599627370497.5L, -4503599627370498.0L);
3392 # if LDBL_MANT_DIG > 100
3393   TEST_f_f (floor, -4503599627370494.5000000000001L, -4503599627370495.0L);
3394   TEST_f_f (floor, -4503599627370495.5000000000001L, -4503599627370496.0L);
3395   TEST_f_f (floor, -4503599627370496.5000000000001L, -4503599627370497.0L);
3396 # endif
3397
3398   TEST_f_f (floor, 9007199254740991.5L, 9007199254740991.0L);
3399   TEST_f_f (floor, 9007199254740992.25L, 9007199254740992.0L);
3400   TEST_f_f (floor, 9007199254740992.5L, 9007199254740992.0L);
3401   TEST_f_f (floor, 9007199254740992.75L, 9007199254740992.0L);
3402   TEST_f_f (floor, 9007199254740993.5L, 9007199254740993.0L);
3403
3404 # if LDBL_MANT_DIG > 100
3405   TEST_f_f (floor, 9007199254740991.0000000000001L, 9007199254740991.0L);
3406   TEST_f_f (floor, 9007199254740992.0000000000001L, 9007199254740992.0L);
3407   TEST_f_f (floor, 9007199254740993.0000000000001L, 9007199254740993.0L);
3408   TEST_f_f (floor, 9007199254740991.5000000000001L, 9007199254740991.0L);
3409   TEST_f_f (floor, 9007199254740992.5000000000001L, 9007199254740992.0L);
3410   TEST_f_f (floor, 9007199254740993.5000000000001L, 9007199254740993.0L);
3411 # endif
3412
3413   TEST_f_f (floor, -9007199254740991.5L, -9007199254740992.0L);
3414   TEST_f_f (floor, -9007199254740992.25L, -9007199254740993.0L);
3415   TEST_f_f (floor, -9007199254740992.5L, -9007199254740993.0L);
3416   TEST_f_f (floor, -9007199254740992.75L, -9007199254740993.0L);
3417   TEST_f_f (floor, -9007199254740993.5L, -9007199254740994.0L);
3418
3419 # if LDBL_MANT_DIG > 100
3420   TEST_f_f (floor, -9007199254740991.0000000000001L, -9007199254740992.0L);
3421   TEST_f_f (floor, -9007199254740992.0000000000001L, -9007199254740993.0L);
3422   TEST_f_f (floor, -9007199254740993.0000000000001L, -9007199254740994.0L);
3423   TEST_f_f (floor, -9007199254740991.5000000000001L, -9007199254740992.0L);
3424   TEST_f_f (floor, -9007199254740992.5000000000001L, -9007199254740993.0L);
3425   TEST_f_f (floor, -9007199254740993.5000000000001L, -9007199254740994.0L);
3426 # endif
3427
3428   TEST_f_f (floor, 72057594037927935.5L, 72057594037927935.0L);
3429   TEST_f_f (floor, 72057594037927936.25L, 72057594037927936.0L);
3430   TEST_f_f (floor, 72057594037927936.5L, 72057594037927936.0L);
3431   TEST_f_f (floor, 72057594037927936.75L, 72057594037927936.0L);
3432   TEST_f_f (floor, 72057594037927937.5L, 72057594037927937.0L);
3433
3434   TEST_f_f (floor, -72057594037927935.5L, -72057594037927936.0L);
3435   TEST_f_f (floor, -72057594037927936.25L, -72057594037927937.0L);
3436   TEST_f_f (floor, -72057594037927936.5L, -72057594037927937.0L);
3437   TEST_f_f (floor, -72057594037927936.75L, -72057594037927937.0L);
3438   TEST_f_f (floor, -72057594037927937.5L, -72057594037927938.0L);
3439
3440   TEST_f_f (floor, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
3441   TEST_f_f (floor, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
3442   TEST_f_f (floor, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
3443   TEST_f_f (floor, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
3444   TEST_f_f (floor, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
3445
3446   TEST_f_f (floor, 0xf.ffffffffffffff8p+47L, 0xf.fffffffffffep+47L);
3447   TEST_f_f (floor, -0x8.000000000000004p+48L, -0x8.000000000001p+48L);
3448 #endif
3449
3450   END (floor);
3451 }
3452
3453
3454 static void
3455 fma_test (void)
3456 {
3457   START (fma);
3458
3459   TEST_fff_f (fma, 1.0, 2.0, 3.0, 5.0);
3460   TEST_fff_f (fma, nan_value, 2.0, 3.0, nan_value);
3461   TEST_fff_f (fma, 1.0, nan_value, 3.0, nan_value);
3462   TEST_fff_f (fma, 1.0, 2.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3463   TEST_fff_f (fma, plus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3464   TEST_fff_f (fma, minus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3465   TEST_fff_f (fma, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
3466   TEST_fff_f (fma, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
3467   TEST_fff_f (fma, plus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
3468   TEST_fff_f (fma, minus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
3469   TEST_fff_f (fma, 0.0, plus_infty, 1.0, nan_value, INVALID_EXCEPTION);
3470   TEST_fff_f (fma, 0.0, minus_infty, 1.0, nan_value, INVALID_EXCEPTION);
3471
3472   TEST_fff_f (fma, plus_infty, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
3473   TEST_fff_f (fma, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
3474   TEST_fff_f (fma, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
3475   TEST_fff_f (fma, minus_infty, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
3476   TEST_fff_f (fma, plus_infty, 3.5L, minus_infty, nan_value, INVALID_EXCEPTION);
3477   TEST_fff_f (fma, minus_infty, -7.5L, minus_infty, nan_value, INVALID_EXCEPTION);
3478   TEST_fff_f (fma, -13.5L, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
3479   TEST_fff_f (fma, minus_infty, 7.5L, plus_infty, nan_value, INVALID_EXCEPTION);
3480
3481   TEST_fff_f (fma, 1.25L, 0.75L, 0.0625L, 1.0L);
3482
3483   FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
3484                          LDBL_MAX, DBL_MAX, FLT_MAX);
3485   TEST_fff_f (fma, -fltmax, -fltmax, minus_infty, minus_infty);
3486   TEST_fff_f (fma, fltmax / 2, fltmax / 2, minus_infty, minus_infty);
3487   TEST_fff_f (fma, -fltmax, fltmax, plus_infty, plus_infty);
3488   TEST_fff_f (fma, fltmax / 2, -fltmax / 4, plus_infty, plus_infty);
3489   TEST_fff_f (fma, plus_infty, 4, plus_infty, plus_infty);
3490   TEST_fff_f (fma, 2, minus_infty, minus_infty, minus_infty);
3491   TEST_fff_f (fma, minus_infty, minus_infty, plus_infty, plus_infty);
3492   TEST_fff_f (fma, plus_infty, minus_infty, minus_infty, minus_infty);
3493
3494 #if defined (TEST_FLOAT) && FLT_MANT_DIG == 24
3495   TEST_fff_f (fma, 0x1.7ff8p+13, 0x1.000002p+0, 0x1.ffffp-24, 0x1.7ff802p+13);
3496   TEST_fff_f (fma, 0x1.fffp+0, 0x1.00001p+0, -0x1.fffp+0, 0x1.fffp-20);
3497   TEST_fff_f (fma, 0x1.9abcdep+127, 0x0.9abcdep-126, -0x1.f08948p+0, 0x1.bb421p-25);
3498   TEST_fff_f (fma, 0x1.9abcdep+100, 0x0.9abcdep-126, -0x1.f08948p-27, 0x1.bb421p-52);
3499   TEST_fff_f (fma, 0x1.fffffep+127, 0x1.001p+0, -0x1.fffffep+127, 0x1.fffffep+115);
3500   TEST_fff_f (fma, -0x1.fffffep+127, 0x1.fffffep+0, 0x1.fffffep+127, -0x1.fffffap+127);
3501   TEST_fff_f (fma, 0x1.fffffep+127, 2.0, -0x1.fffffep+127, 0x1.fffffep+127);
3502 #endif
3503 #if defined (TEST_DOUBLE) && DBL_MANT_DIG == 53
3504   TEST_fff_f (fma, 0x1.7fp+13, 0x1.0000000000001p+0, 0x1.ffep-48, 0x1.7f00000000001p+13);
3505   TEST_fff_f (fma, 0x1.fffp+0, 0x1.0000000000001p+0, -0x1.fffp+0, 0x1.fffp-52);
3506   TEST_fff_f (fma, 0x1.0000002p+0, 0x1.ffffffcp-1, 0x1p-300, 1.0);
3507   TEST_fff_f (fma, 0x1.0000002p+0, 0x1.ffffffcp-1, -0x1p-300, 0x1.fffffffffffffp-1);
3508   TEST_fff_f (fma, 0x1.deadbeef2feedp+1023, 0x0.deadbeef2feedp-1022, -0x1.a05f8c01a4bfbp+1, 0x1.0989687bc9da4p-53);
3509   TEST_fff_f (fma, 0x1.deadbeef2feedp+900, 0x0.deadbeef2feedp-1022, -0x1.a05f8c01a4bfbp-122, 0x1.0989687bc9da4p-176);
3510   TEST_fff_f (fma, 0x1.fffffffffffffp+1023, 0x1.001p+0, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+1011);
3511   TEST_fff_f (fma, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+0, 0x1.fffffffffffffp+1023, -0x1.ffffffffffffdp+1023);
3512   TEST_fff_f (fma, 0x1.fffffffffffffp+1023, 2.0, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+1023);
3513   TEST_fff_f (fma, 0x1.6a09e667f3bccp-538, 0x1.6a09e667f3bccp-538, 0.0, 0.0);
3514   TEST_fff_f (fma, 0x1.deadbeef2feedp-495, 0x1.deadbeef2feedp-495, -0x1.bf86a5786a574p-989, 0x0.0000042625a1fp-1022);
3515   TEST_fff_f (fma, 0x1.deadbeef2feedp-503, 0x1.deadbeef2feedp-503, -0x1.bf86a5786a574p-1005, 0x0.0000000004262p-1022);
3516   TEST_fff_f (fma, 0x1p-537, 0x1p-538, 0x1p-1074, 0x0.0000000000002p-1022);
3517   TEST_fff_f (fma, 0x1.7fffff8p-968, 0x1p-106, 0x0.000001p-1022, 0x0.0000010000001p-1022);
3518   TEST_fff_f (fma, 0x1.4000004p-967, 0x1p-106, 0x0.000001p-1022, 0x0.0000010000003p-1022);
3519   TEST_fff_f (fma, 0x1.4p-967, -0x1p-106, -0x0.000001p-1022, -0x0.0000010000002p-1022);
3520   TEST_fff_f (fma, -0x1.19cab66d73e17p-959, 0x1.c7108a8c5ff51p-107, -0x0.80b0ad65d9b64p-1022, -0x0.80b0ad65d9d59p-1022);
3521   TEST_fff_f (fma, -0x1.d2eaed6e8e9d3p-979, -0x1.4e066c62ac9ddp-63, -0x0.9245e6b003454p-1022, -0x0.9245c09c5fb5dp-1022);
3522   TEST_fff_f (fma, 0x1.153d650bb9f06p-907, 0x1.2d01230d48407p-125, -0x0.b278d5acfc3cp-1022, -0x0.b22757123bbe9p-1022);
3523   TEST_fff_f (fma, -0x1.fffffffffffffp-711, 0x1.fffffffffffffp-275, 0x1.fffffe00007ffp-983, 0x1.7ffffe00007ffp-983);
3524 #endif
3525 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 64
3526   TEST_fff_f (fma, -0x8.03fcp+3696L, 0xf.fffffffffffffffp-6140L, 0x8.3ffffffffffffffp-2450L, -0x8.01ecp-2440L);
3527   TEST_fff_f (fma, 0x9.fcp+2033L, -0x8.000e1f000ff800fp-3613L, -0xf.fffffffffffc0ffp-1579L, -0xd.fc119fb093ed092p-1577L);
3528   TEST_fff_f (fma, 0xc.7fc000003ffffffp-1194L, 0x8.1e0003fffffffffp+15327L, -0x8.fffep+14072L, 0xc.ae9f164020effffp+14136L);
3529   TEST_fff_f (fma, -0x8.0001fc000000003p+1798L, 0xcp-2230L, 0x8.f7e000000000007p-468L, -0xc.0002f9ffee10404p-429L);
3530   TEST_fff_f (fma, 0xc.0000000000007ffp+10130L, -0x8.000000000000001p+4430L, 0xc.07000000001ffffp+14513L, -0xb.fffffffffffd7e4p+14563L);
3531   TEST_fff_f (fma, 0xb.ffffp-4777L, 0x8.000000fffffffffp-11612L, -0x0.3800fff8p-16385L, 0x5.c7fe80c7ffeffffp-16385L);
3532 #endif
3533 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 113
3534   TEST_fff_f (fma, 0x1.bb2de33e02ccbbfa6e245a7c1f71p-2584L, -0x1.6b500daf0580d987f1bc0cadfcddp-13777L, 0x1.613cd91d9fed34b33820e5ab9d8dp-16378L, -0x1.3a79fb50eb9ce887cffa0f09bd9fp-16360L);
3535   TEST_fff_f (fma, -0x1.f949b880cacb0f0c61540105321dp-5954L, -0x1.3876cec84b4140f3bd6198731b7ep-10525L, -0x0.a5dc1c6cfbc498c54fb0b504bf19p-16382L, -0x0.a5dc1c6cfbc498c54fb0b5038abbp-16382L);
3536   TEST_fff_f (fma, -0x1.0000fffffffffp-16221L, 0x1.0000001fffff8007fep-239L, 0x0.ff87ffffffffffffe000003fffffp-16382L, 0x0.ff87ffffffffffffdffc003bff7fp-16382L);
3537   TEST_fff_f (fma, -0x1.ac79c9376ef447f3827c9e9de008p-2228L, -0x1.5ba830022b6139e21fbe7270cad8p-6314L, 0x1.e8282b6a26bb6a9daf5c8e73e9f9p-8616L, 0x1.22f14a0253878a730cd1aee373adp-8541L);
3538   TEST_fff_f (fma, -0x1.c69749ec574caaa2ab8e97ddb9f3p+2652L, 0x1.f34235ff9d095449c29b4831b62dp+3311L, 0x1.fbe4302df23354dbd0c4d3cfe606p+5879L, -0x1.bb473bfdfb7a6e18886ce6e57eafp+5964L);
3539   TEST_fff_f (fma, -0x1.ca8835fc6ecfb5398625fc891be5p-1686L, 0x1.621e1972bbe2180e5be9dd7d8df5p-7671L, -0x1.7d2d21b73b52cf20dec2a83902a4p-9395L, -0x1.3d2322191c9c88bc68a62ab8042cp-9356L);
3540   TEST_fff_f (fma, -0x1.55cff679ec49c2541fab41fc843ep-11819L, 0x1.e60e9f464f9e8df0509647c7c971p+12325L, 0x1.eaa2a7649d765c2f564f7a5beca7p+454L, -0x1.447e29fa7e406a285f4e350fcf86p+507L);
3541   TEST_fff_f (fma, 0x1.f0e7b1454908576f2537d863cf9bp+11432L, 0x1.cdce52f09d4ca76e68706f34b5d5p-1417L, -0x1.2e986187c70f146235ea2066e486p+9979L, 0x1.c030dad3cc5643f3dd0f5619f661p+10016L);
3542   TEST_fff_f (fma, 0x1.f102f7da4a57a3a4aab620e29452p-3098L, -0x1.cc06a4ff40248f9e2dcc4b6afd84p-11727L, 0x1.d512a11126b5ac8ed8973b8580c8p-14849L, -0x1.be8f1cf737ab4d1c31c54f5ec23bp-14824L);
3543   TEST_fff_f (fma, -0x1.fc47ac7434b993cd8dcb2b431f25p-3816L, 0x1.fbc9750da8468852d84558e1db6dp-5773L, -0x1.00a98abf783f75c40fe5b7a37d86p-9607L, -0x1.f81917b166f45e763cfcc057e2adp-9588L);
3544   TEST_fff_f (fma, 0x1.00000000000007ffffffffffffffp-9045L, -0x1.ffffffffffff80000001ffffffffp+4773L, -0x1.f8p-4316L, -0x1.00000000000f88000000fffffdffp-4271L);
3545   TEST_fff_f (fma, 0x1.4e922764c90701d4a2f21d01893dp-8683L, -0x1.955a12e2d7c9447c27fa022fc865p+212L, -0x1.e9634462eaef96528b90b6944578p-8521L, -0x1.08e1783184a371943d3598e10865p-8470L);
3546   TEST_fff_f (fma, 0x1.801181509c03bdbef10d6165588cp-15131L, 0x1.ad86f8e57d3d40bfa8007780af63p-368L, -0x1.6e9df0dab1c9f1d7a6043c390741p-15507L, 0x1.417c9b2b15e2ad57dc9e0e920844p-15498L);
3547 #endif
3548
3549   END (fma);
3550 }
3551
3552
3553 static void
3554 fmax_test (void)
3555 {
3556   START (fmax);
3557
3558   TEST_ff_f (fmax, 0, 0, 0);
3559   TEST_ff_f (fmax, minus_zero, minus_zero, minus_zero);
3560   TEST_ff_f (fmax, 9, 0, 9);
3561   TEST_ff_f (fmax, 0, 9, 9);
3562   TEST_ff_f (fmax, -9, 0, 0);
3563   TEST_ff_f (fmax, 0, -9, 0);
3564
3565   TEST_ff_f (fmax, plus_infty, 9, plus_infty);
3566   TEST_ff_f (fmax, 0, plus_infty, plus_infty);
3567   TEST_ff_f (fmax, -9, plus_infty, plus_infty);
3568   TEST_ff_f (fmax, plus_infty, -9, plus_infty);
3569
3570   TEST_ff_f (fmax, minus_infty, 9, 9);
3571   TEST_ff_f (fmax, minus_infty, -9, -9);
3572   TEST_ff_f (fmax, 9, minus_infty, 9);
3573   TEST_ff_f (fmax, -9, minus_infty, -9);
3574
3575   TEST_ff_f (fmax, 0, nan_value, 0);
3576   TEST_ff_f (fmax, 9, nan_value, 9);
3577   TEST_ff_f (fmax, -9, nan_value, -9);
3578   TEST_ff_f (fmax, nan_value, 0, 0);
3579   TEST_ff_f (fmax, nan_value, 9, 9);
3580   TEST_ff_f (fmax, nan_value, -9, -9);
3581   TEST_ff_f (fmax, plus_infty, nan_value, plus_infty);
3582   TEST_ff_f (fmax, minus_infty, nan_value, minus_infty);
3583   TEST_ff_f (fmax, nan_value, plus_infty, plus_infty);
3584   TEST_ff_f (fmax, nan_value, minus_infty, minus_infty);
3585   TEST_ff_f (fmax, nan_value, nan_value, nan_value);
3586
3587   END (fmax);
3588 }
3589
3590
3591 static void
3592 fmin_test (void)
3593 {
3594   START (fmin);
3595
3596   TEST_ff_f (fmin, 0, 0, 0);
3597   TEST_ff_f (fmin, minus_zero, minus_zero, minus_zero);
3598   TEST_ff_f (fmin, 9, 0, 0);
3599   TEST_ff_f (fmin, 0, 9, 0);
3600   TEST_ff_f (fmin, -9, 0, -9);
3601   TEST_ff_f (fmin, 0, -9, -9);
3602
3603   TEST_ff_f (fmin, plus_infty, 9, 9);
3604   TEST_ff_f (fmin, 9, plus_infty, 9);
3605   TEST_ff_f (fmin, plus_infty, -9, -9);
3606   TEST_ff_f (fmin, -9, plus_infty, -9);
3607   TEST_ff_f (fmin, minus_infty, 9, minus_infty);
3608   TEST_ff_f (fmin, minus_infty, -9, minus_infty);
3609   TEST_ff_f (fmin, 9, minus_infty, minus_infty);
3610   TEST_ff_f (fmin, -9, minus_infty, minus_infty);
3611
3612   TEST_ff_f (fmin, 0, nan_value, 0);
3613   TEST_ff_f (fmin, 9, nan_value, 9);
3614   TEST_ff_f (fmin, -9, nan_value, -9);
3615   TEST_ff_f (fmin, nan_value, 0, 0);
3616   TEST_ff_f (fmin, nan_value, 9, 9);
3617   TEST_ff_f (fmin, nan_value, -9, -9);
3618   TEST_ff_f (fmin, plus_infty, nan_value, plus_infty);
3619   TEST_ff_f (fmin, minus_infty, nan_value, minus_infty);
3620   TEST_ff_f (fmin, nan_value, plus_infty, plus_infty);
3621   TEST_ff_f (fmin, nan_value, minus_infty, minus_infty);
3622   TEST_ff_f (fmin, nan_value, nan_value, nan_value);
3623
3624   END (fmin);
3625 }
3626
3627
3628 static void
3629 fmod_test (void)
3630 {
3631   errno = 0;
3632   FUNC(fmod) (6.5, 2.3L);
3633   if (errno == ENOSYS)
3634     /* Function not implemented.  */
3635     return;
3636
3637   START (fmod);
3638
3639   /* fmod (+0, y) == +0 for y != 0.  */
3640   TEST_ff_f (fmod, 0, 3, 0);
3641
3642   /* fmod (-0, y) == -0 for y != 0.  */
3643   TEST_ff_f (fmod, minus_zero, 3, minus_zero);
3644
3645   /* fmod (+inf, y) == NaN plus invalid exception.  */
3646   errno = 0;
3647   TEST_ff_f (fmod, plus_infty, 3, nan_value, INVALID_EXCEPTION);
3648   check_int ("errno for fmod(Inf,3) unchanged", errno, EDOM, 0, 0, 0);
3649   /* fmod (-inf, y) == NaN plus invalid exception.  */
3650   errno = 0;
3651   TEST_ff_f (fmod, minus_infty, 3, nan_value, INVALID_EXCEPTION);
3652   check_int ("errno for fmod(-Inf,3) unchanged", errno, EDOM, 0, 0, 0);
3653   /* fmod (x, +0) == NaN plus invalid exception.  */
3654   errno = 0;
3655   TEST_ff_f (fmod, 3, 0, nan_value, INVALID_EXCEPTION);
3656   check_int ("errno for fmod(3,0) unchanged", errno, EDOM, 0, 0, 0);
3657   /* fmod (x, -0) == NaN plus invalid exception.  */
3658   TEST_ff_f (fmod, 3, minus_zero, nan_value, INVALID_EXCEPTION);
3659
3660   /* fmod (x, +inf) == x for x not infinite.  */
3661   TEST_ff_f (fmod, 3.0, plus_infty, 3.0);
3662   /* fmod (x, -inf) == x for x not infinite.  */
3663   TEST_ff_f (fmod, 3.0, minus_infty, 3.0);
3664
3665   TEST_ff_f (fmod, nan_value, nan_value, nan_value);
3666
3667   TEST_ff_f (fmod, 6.5, 2.25L, 2.0L);
3668   TEST_ff_f (fmod, -6.5, 2.25L, -2.0L);
3669   TEST_ff_f (fmod, 6.5, -2.25L, 2.0L);
3670   TEST_ff_f (fmod, -6.5, -2.25L, -2.0L);
3671
3672   END (fmod);
3673 }
3674
3675
3676 static void
3677 fpclassify_test (void)
3678 {
3679   START (fpclassify);
3680
3681   TEST_f_i (fpclassify, nan_value, FP_NAN);
3682   TEST_f_i (fpclassify, plus_infty, FP_INFINITE);
3683   TEST_f_i (fpclassify, minus_infty, FP_INFINITE);
3684   TEST_f_i (fpclassify, plus_zero, FP_ZERO);
3685   TEST_f_i (fpclassify, minus_zero, FP_ZERO);
3686   TEST_f_i (fpclassify, 1000, FP_NORMAL);
3687
3688   END (fpclassify);
3689 }
3690
3691
3692 static void
3693 frexp_test (void)
3694 {
3695   int x;
3696
3697   START (frexp);
3698
3699   TEST_fI_f1 (frexp, plus_infty, plus_infty, IGNORE);
3700   TEST_fI_f1 (frexp, minus_infty, minus_infty, IGNORE);
3701   TEST_fI_f1 (frexp, nan_value, nan_value, IGNORE);
3702
3703   TEST_fI_f1 (frexp, 0.0, 0.0, 0.0);
3704   TEST_fI_f1 (frexp, minus_zero, minus_zero, 0.0);
3705
3706   TEST_fI_f1 (frexp, 12.8L, 0.8L, 4);
3707   TEST_fI_f1 (frexp, -27.34L, -0.854375L, 5);
3708
3709   END (frexp);
3710 }
3711
3712
3713 static void
3714 gamma_test (void)
3715 {
3716   errno = 0;
3717   FUNC(gamma) (1);
3718
3719   if (errno == ENOSYS)
3720     /* Function not implemented.  */
3721     return;
3722   feclearexcept (FE_ALL_EXCEPT);
3723
3724   START (gamma);
3725
3726   TEST_f_f (gamma, plus_infty, plus_infty);
3727   TEST_f_f (gamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3728   TEST_f_f (gamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3729   TEST_f_f (gamma, minus_infty, plus_infty);
3730   TEST_f_f (gamma, nan_value, nan_value);
3731
3732   TEST_f_f1 (gamma, 1, 0, 1);
3733   TEST_f_f1 (gamma, 3, M_LN2l, 1);
3734
3735   TEST_f_f1 (gamma, 0.5, M_LOG_SQRT_PIl, 1);
3736   TEST_f_f1 (gamma, -0.5, M_LOG_2_SQRT_PIl, -1);
3737
3738   END (gamma);
3739 }
3740
3741 static void
3742 hypot_test (void)
3743 {
3744   errno = 0;
3745   FUNC(hypot) (0.7L, 12.4L);
3746   if (errno == ENOSYS)
3747     /* Function not implemented.  */
3748     return;
3749
3750   START (hypot);
3751
3752   TEST_ff_f (hypot, plus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
3753   TEST_ff_f (hypot, minus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
3754
3755 #ifndef TEST_INLINE
3756   TEST_ff_f (hypot, plus_infty, nan_value, plus_infty);
3757   TEST_ff_f (hypot, minus_infty, nan_value, plus_infty);
3758   TEST_ff_f (hypot, nan_value, plus_infty, plus_infty);
3759   TEST_ff_f (hypot, nan_value, minus_infty, plus_infty);
3760 #endif
3761
3762   TEST_ff_f (hypot, nan_value, nan_value, nan_value);
3763
3764   /* hypot (x,y) == hypot (+-x, +-y)  */
3765   TEST_ff_f (hypot, 0.7L, 12.4L, 12.419742348374220601176836866763271L);
3766   TEST_ff_f (hypot, -0.7L, 12.4L, 12.419742348374220601176836866763271L);
3767   TEST_ff_f (hypot, 0.7L, -12.4L, 12.419742348374220601176836866763271L);
3768   TEST_ff_f (hypot, -0.7L, -12.4L, 12.419742348374220601176836866763271L);
3769   TEST_ff_f (hypot, 12.4L, 0.7L, 12.419742348374220601176836866763271L);
3770   TEST_ff_f (hypot, -12.4L, 0.7L, 12.419742348374220601176836866763271L);
3771   TEST_ff_f (hypot, 12.4L, -0.7L, 12.419742348374220601176836866763271L);
3772   TEST_ff_f (hypot, -12.4L, -0.7L, 12.419742348374220601176836866763271L);
3773
3774   /*  hypot (x,0) == fabs (x)  */
3775   TEST_ff_f (hypot, 0.75L, 0, 0.75L);
3776   TEST_ff_f (hypot, -0.75L, 0, 0.75L);
3777   TEST_ff_f (hypot, -5.7e7, 0, 5.7e7L);
3778
3779   TEST_ff_f (hypot, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
3780
3781 #if !(defined TEST_FLOAT && defined TEST_INLINE)
3782   TEST_ff_f (hypot, 0x3p125L, 0x4p125L, 0x5p125L);
3783   TEST_ff_f (hypot, 0x1.234566p-126L, 0x1.234566p-126L, 1.891441686191081936598531534017449451173e-38L);
3784 #endif
3785
3786 #ifndef TEST_FLOAT
3787   TEST_ff_f (hypot, 0x3p1021L, 0x4p1021L, 0x5p1021L);
3788 #endif
3789
3790 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384 && !defined TEST_INLINE
3791   TEST_ff_f (hypot, 0x3p16381L, 0x4p16381L, 0x5p16381L);
3792 #endif
3793
3794   END (hypot);
3795 }
3796
3797
3798 static void
3799 ilogb_test (void)
3800 {
3801   START (ilogb);
3802
3803   TEST_f_i (ilogb, 1, 0);
3804   TEST_f_i (ilogb, M_El, 1);
3805   TEST_f_i (ilogb, 1024, 10);
3806   TEST_f_i (ilogb, -2000, 10);
3807
3808   /* ilogb (0.0) == FP_ILOGB0 plus invalid exception  */
3809   errno = 0;
3810   TEST_f_i (ilogb, 0.0, FP_ILOGB0, INVALID_EXCEPTION);
3811   check_int ("errno for ilogb(0.0) unchanged", errno, EDOM, 0, 0, 0);
3812   /* ilogb (NaN) == FP_ILOGBNAN plus invalid exception  */
3813   errno = 0;
3814   TEST_f_i (ilogb, nan_value, FP_ILOGBNAN, INVALID_EXCEPTION);
3815   check_int ("errno for ilogb(NaN) unchanged", errno, EDOM, 0, 0, 0);
3816   /* ilogb (inf) == INT_MAX plus invalid exception  */
3817   errno = 0;
3818   TEST_f_i (ilogb, plus_infty, INT_MAX, INVALID_EXCEPTION);
3819   check_int ("errno for ilogb(Inf) unchanged", errno, EDOM, 0, 0, 0);
3820   /* ilogb (-inf) == INT_MAX plus invalid exception  */
3821   errno = 0;
3822   TEST_f_i (ilogb, minus_infty, INT_MAX, INVALID_EXCEPTION);
3823   check_int ("errno for ilogb(-Inf) unchanged", errno, EDOM, 0, 0, 0);
3824
3825   END (ilogb);
3826 }
3827
3828 static void
3829 isfinite_test (void)
3830 {
3831   START (isfinite);
3832
3833   TEST_f_b (isfinite, 0, 1);
3834   TEST_f_b (isfinite, minus_zero, 1);
3835   TEST_f_b (isfinite, 10, 1);
3836   TEST_f_b (isfinite, plus_infty, 0);
3837   TEST_f_b (isfinite, minus_infty, 0);
3838   TEST_f_b (isfinite, nan_value, 0);
3839
3840   END (isfinite);
3841 }
3842
3843 static void
3844 isnormal_test (void)
3845 {
3846   START (isnormal);
3847
3848   TEST_f_b (isnormal, 0, 0);
3849   TEST_f_b (isnormal, minus_zero, 0);
3850   TEST_f_b (isnormal, 10, 1);
3851   TEST_f_b (isnormal, plus_infty, 0);
3852   TEST_f_b (isnormal, minus_infty, 0);
3853   TEST_f_b (isnormal, nan_value, 0);
3854
3855   END (isnormal);
3856 }
3857
3858 static void
3859 j0_test (void)
3860 {
3861   FLOAT s, c;
3862   errno = 0;
3863   FUNC (sincos) (0, &s, &c);
3864   if (errno == ENOSYS)
3865     /* Required function not implemented.  */
3866     return;
3867   FUNC(j0) (0);
3868   if (errno == ENOSYS)
3869     /* Function not implemented.  */
3870     return;
3871
3872   START (j0);
3873
3874   /* j0 is the Bessel function of the first kind of order 0 */
3875   TEST_f_f (j0, nan_value, nan_value);
3876   TEST_f_f (j0, plus_infty, 0);
3877   TEST_f_f (j0, -1.0, 0.765197686557966551449717526102663221L);
3878   TEST_f_f (j0, 0.0, 1.0);
3879   TEST_f_f (j0, 0.125L, 0.996097563041985204620768999453174712L);
3880   TEST_f_f (j0, 0.75L, 0.864242275166648623555731103820923211L);
3881   TEST_f_f (j0, 1.0, 0.765197686557966551449717526102663221L);
3882   TEST_f_f (j0, 1.5, 0.511827671735918128749051744283411720L);
3883   TEST_f_f (j0, 2.0, 0.223890779141235668051827454649948626L);
3884   TEST_f_f (j0, 8.0, 0.171650807137553906090869407851972001L);
3885   TEST_f_f (j0, 10.0, -0.245935764451348335197760862485328754L);
3886   TEST_f_f (j0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
3887   TEST_f_f (j0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
3888
3889   TEST_f_f (j0, 0x1.d7ce3ap+107L, 2.775523647291230802651040996274861694514e-17L);
3890
3891 #ifndef TEST_FLOAT
3892   TEST_f_f (j0, -0x1.001000001p+593L, -3.927269966354206207832593635798954916263e-90L);
3893 #endif
3894
3895   END (j0);
3896 }
3897
3898
3899 static void
3900 j1_test (void)
3901 {
3902   FLOAT s, c;
3903   errno = 0;
3904   FUNC (sincos) (0, &s, &c);
3905   if (errno == ENOSYS)
3906     /* Required function not implemented.  */
3907     return;
3908   FUNC(j1) (0);
3909   if (errno == ENOSYS)
3910     /* Function not implemented.  */
3911     return;
3912
3913   /* j1 is the Bessel function of the first kind of order 1 */
3914
3915   START (j1);
3916
3917   TEST_f_f (j1, nan_value, nan_value);
3918   TEST_f_f (j1, plus_infty, 0);
3919
3920   TEST_f_f (j1, -1.0, -0.440050585744933515959682203718914913L);
3921   TEST_f_f (j1, 0.0, 0.0);
3922   TEST_f_f (j1, 0.125L, 0.0623780091344946810942311355879361177L);
3923   TEST_f_f (j1, 0.75L, 0.349243602174862192523281016426251335L);
3924   TEST_f_f (j1, 1.0, 0.440050585744933515959682203718914913L);
3925   TEST_f_f (j1, 1.5, 0.557936507910099641990121213156089400L);
3926   TEST_f_f (j1, 2.0, 0.576724807756873387202448242269137087L);
3927   TEST_f_f (j1, 8.0, 0.234636346853914624381276651590454612L);
3928   TEST_f_f (j1, 10.0, 0.0434727461688614366697487680258592883L);
3929
3930   TEST_f_f (j1, 0x1.3ffp+74L, 1.818984347516051243459364437186082741567e-12L);
3931
3932 #ifndef TEST_FLOAT
3933   TEST_f_f (j1, 0x1.ff00000000002p+840L, 1.846591691699331493194965158699937660696e-127L);
3934 #endif
3935
3936   END (j1);
3937 }
3938
3939 static void
3940 jn_test (void)
3941 {
3942   FLOAT s, c;
3943   errno = 0;
3944   FUNC (sincos) (0, &s, &c);
3945   if (errno == ENOSYS)
3946     /* Required function not implemented.  */
3947     return;
3948   FUNC(jn) (1, 1);
3949   if (errno == ENOSYS)
3950     /* Function not implemented.  */
3951     return;
3952
3953   /* jn is the Bessel function of the first kind of order n.  */
3954   START (jn);
3955
3956   /* jn (0, x) == j0 (x)  */
3957   TEST_ff_f (jn, 0, nan_value, nan_value);
3958   TEST_ff_f (jn, 0, plus_infty, 0);
3959   TEST_ff_f (jn, 0, -1.0, 0.765197686557966551449717526102663221L);
3960   TEST_ff_f (jn, 0, 0.0, 1.0);
3961   TEST_ff_f (jn, 0, 0.125L, 0.996097563041985204620768999453174712L);
3962   TEST_ff_f (jn, 0, 0.75L, 0.864242275166648623555731103820923211L);
3963   TEST_ff_f (jn, 0, 1.0, 0.765197686557966551449717526102663221L);
3964   TEST_ff_f (jn, 0, 1.5, 0.511827671735918128749051744283411720L);
3965   TEST_ff_f (jn, 0, 2.0, 0.223890779141235668051827454649948626L);
3966   TEST_ff_f (jn, 0, 8.0, 0.171650807137553906090869407851972001L);
3967   TEST_ff_f (jn, 0, 10.0, -0.245935764451348335197760862485328754L);
3968   TEST_ff_f (jn, 0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
3969   TEST_ff_f (jn, 0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
3970
3971   /* jn (1, x) == j1 (x)  */
3972   TEST_ff_f (jn, 1, nan_value, nan_value);
3973   TEST_ff_f (jn, 1, plus_infty, 0);
3974   TEST_ff_f (jn, 1, -1.0, -0.440050585744933515959682203718914913L);
3975   TEST_ff_f (jn, 1, 0.0, 0.0);
3976   TEST_ff_f (jn, 1, 0.125L, 0.0623780091344946810942311355879361177L);
3977   TEST_ff_f (jn, 1, 0.75L, 0.349243602174862192523281016426251335L);
3978   TEST_ff_f (jn, 1, 1.0, 0.440050585744933515959682203718914913L);
3979   TEST_ff_f (jn, 1, 1.5, 0.557936507910099641990121213156089400L);
3980   TEST_ff_f (jn, 1, 2.0, 0.576724807756873387202448242269137087L);
3981   TEST_ff_f (jn, 1, 8.0, 0.234636346853914624381276651590454612L);
3982   TEST_ff_f (jn, 1, 10.0, 0.0434727461688614366697487680258592883L);
3983
3984   /* jn (3, x)  */
3985   TEST_ff_f (jn, 3, nan_value, nan_value);
3986   TEST_ff_f (jn, 3, plus_infty, 0);
3987
3988   TEST_ff_f (jn, 3, -1.0, -0.0195633539826684059189053216217515083L);
3989   TEST_ff_f (jn, 3, 0.0, 0.0);
3990   TEST_ff_f (jn, 3, 0.125L, 0.406503832554912875023029337653442868e-4L);
3991   TEST_ff_f (jn, 3, 0.75L, 0.848438342327410884392755236884386804e-2L);
3992   TEST_ff_f (jn, 3, 1.0, 0.0195633539826684059189053216217515083L);
3993   TEST_ff_f (jn, 3, 2.0, 0.128943249474402051098793332969239835L);
3994   TEST_ff_f (jn, 3, 10.0, 0.0583793793051868123429354784103409563L);
3995
3996   /*  jn (10, x)  */
3997   TEST_ff_f (jn, 10, nan_value, nan_value);
3998   TEST_ff_f (jn, 10, plus_infty, 0);
3999
4000   TEST_ff_f (jn, 10, -1.0, 0.263061512368745320699785368779050294e-9L);
4001   TEST_ff_f (jn, 10, 0.0, 0.0);
4002   TEST_ff_f (jn, 10, 0.125L, 0.250543369809369890173993791865771547e-18L);
4003   TEST_ff_f (jn, 10, 0.75L, 0.149621713117596814698712483621682835e-10L);
4004   TEST_ff_f (jn, 10, 1.0, 0.263061512368745320699785368779050294e-9L);
4005   TEST_ff_f (jn, 10, 2.0, 0.251538628271673670963516093751820639e-6L);
4006   TEST_ff_f (jn, 10, 10.0, 0.207486106633358857697278723518753428L);
4007
4008   /* BZ #11589 .*/
4009   TEST_ff_f (jn, 2, 2.4048255576957729L, 0.43175480701968038399746111312430703L);
4010   TEST_ff_f (jn, 3, 2.4048255576957729L, 0.19899990535769083404042146764530813L);
4011   TEST_ff_f (jn, 4, 2.4048255576957729L, 0.647466661641779720084932282551219891E-1L);
4012   TEST_ff_f (jn, 5, 2.4048255576957729L, 0.163892432048058525099230549946147698E-1L);
4013   TEST_ff_f (jn, 6, 2.4048255576957729L, 0.34048184720278336646673682895929161E-2L);
4014   TEST_ff_f (jn, 7, 2.4048255576957729L, 0.60068836573295394221291569249883076E-3L);
4015   TEST_ff_f (jn, 8, 2.4048255576957729L, 0.92165786705344923232879022467054148E-4L);
4016   TEST_ff_f (jn, 9, 2.4048255576957729L, 0.12517270977961513005428966643852564E-4L);
4017
4018   TEST_ff_f (jn, 2, 0x1.ffff62p+99L, -4.43860668048170034334926693188979974489e-16L);
4019
4020   END (jn);
4021 }
4022
4023
4024 static void
4025 ldexp_test (void)
4026 {
4027   TEST_ff_f (ldexp, 0, 0, 0);
4028   TEST_ff_f (ldexp, minus_zero, 0, minus_zero);
4029
4030   TEST_ff_f (ldexp, plus_infty, 1, plus_infty);
4031   TEST_ff_f (ldexp, minus_infty, 1, minus_infty);
4032   TEST_ff_f (ldexp, nan_value, 1, nan_value);
4033
4034   TEST_ff_f (ldexp, 0.8L, 4, 12.8L);
4035   TEST_ff_f (ldexp, -0.854375L, 5, -27.34L);
4036
4037   /* ldexp (x, 0) == x.  */
4038   TEST_ff_f (ldexp, 1.0L, 0L, 1.0L);
4039 }
4040
4041
4042 static void
4043 lgamma_test (void)
4044 {
4045   errno = 0;
4046   FUNC(lgamma) (0);
4047   if (errno == ENOSYS)
4048     /* Function not implemented.  */
4049     return;
4050   feclearexcept (FE_ALL_EXCEPT);
4051
4052   START (lgamma);
4053
4054   TEST_f_f (lgamma, plus_infty, plus_infty);
4055   TEST_f_f (lgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4056   check_int ("signgam for lgamma(0) == 1", signgam, 1, 0, 0, 0);
4057   TEST_f_f (lgamma, minus_zero, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4058   check_int ("signgam for lgamma(-0) == -1", signgam, -1, 0, 0, 0);
4059   TEST_f_f (lgamma, nan_value, nan_value);
4060
4061   /* lgamma (x) == +inf plus divide by zero exception for integer x <= 0.  */
4062   errno = 0;
4063   TEST_f_f (lgamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4064   check_int ("errno for lgamma(-integer) == ERANGE", errno, ERANGE, 0, 0, 0);
4065   TEST_f_f (lgamma, minus_infty, plus_infty);
4066   TEST_f_f (lgamma, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4067   TEST_f_f (lgamma, max_value, plus_infty, OVERFLOW_EXCEPTION);
4068
4069   TEST_f_f1 (lgamma, 1, 0, 1);
4070
4071   TEST_f_f1 (lgamma, 3, M_LN2l, 1);
4072
4073   TEST_f_f1 (lgamma, 0.5, M_LOG_SQRT_PIl, 1);
4074   TEST_f_f1 (lgamma, -0.5, M_LOG_2_SQRT_PIl, -1);
4075   TEST_f_f1 (lgamma, 0.7L, 0.260867246531666514385732417016759578L, 1);
4076   TEST_f_f1 (lgamma, 1.2L, -0.853740900033158497197028392998854470e-1L, 1);
4077
4078   END (lgamma);
4079 }
4080
4081
4082 static void
4083 lrint_test (void)
4084 {
4085   /* XXX this test is incomplete.  We need to have a way to specifiy
4086      the rounding method and test the critical cases.  So far, only
4087      unproblematic numbers are tested.  */
4088
4089   START (lrint);
4090
4091   TEST_f_l (lrint, 0.0, 0);
4092   TEST_f_l (lrint, minus_zero, 0);
4093   TEST_f_l (lrint, 0.2L, 0);
4094   TEST_f_l (lrint, -0.2L, 0);
4095
4096   TEST_f_l (lrint, 1.4L, 1);
4097   TEST_f_l (lrint, -1.4L, -1);
4098
4099   TEST_f_l (lrint, 8388600.3L, 8388600);
4100   TEST_f_l (lrint, -8388600.3L, -8388600);
4101
4102   TEST_f_l (lrint, 1071930.0008, 1071930);
4103 #ifndef TEST_FLOAT
4104   TEST_f_l (lrint, 1073741824.01, 1073741824);
4105 # if LONG_MAX > 281474976710656
4106   TEST_f_l (lrint, 281474976710656.025, 281474976710656);
4107 # endif
4108 #endif
4109
4110   END (lrint);
4111 }
4112
4113
4114 static void
4115 lrint_test_tonearest (void)
4116 {
4117   int save_round_mode;
4118   START (lrint_tonearest);
4119
4120   save_round_mode = fegetround ();
4121
4122   if (!fesetround (FE_TONEAREST))
4123     {
4124       TEST_f_l (lrint, 0.0, 0);
4125       TEST_f_l (lrint, minus_zero, 0);
4126       TEST_f_l (lrint, 0.2L, 0);
4127       TEST_f_l (lrint, -0.2L, 0);
4128       TEST_f_l (lrint, 0.5L, 0);
4129       TEST_f_l (lrint, -0.5L, 0);
4130       TEST_f_l (lrint, 0.8L, 1);
4131       TEST_f_l (lrint, -0.8L, -1);
4132
4133       TEST_f_l (lrint, 1.4L, 1);
4134       TEST_f_l (lrint, -1.4L, -1);
4135
4136       TEST_f_l (lrint, 8388600.3L, 8388600);
4137       TEST_f_l (lrint, -8388600.3L, -8388600);
4138
4139       TEST_f_l (lrint, 1071930.0008, 1071930);
4140 #ifndef TEST_FLOAT
4141       TEST_f_l (lrint, 1073741824.01, 1073741824);
4142 # if LONG_MAX > 281474976710656
4143       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
4144 # endif
4145 #endif
4146     }
4147
4148   fesetround (save_round_mode);
4149
4150   END (lrint_tonearest);
4151 }
4152
4153
4154 static void
4155 lrint_test_towardzero (void)
4156 {
4157   int save_round_mode;
4158   START (lrint_towardzero);
4159
4160   save_round_mode = fegetround ();
4161
4162   if (!fesetround (FE_TOWARDZERO))
4163     {
4164       TEST_f_l (lrint, 0.0, 0);
4165       TEST_f_l (lrint, minus_zero, 0);
4166       TEST_f_l (lrint, 0.2L, 0);
4167       TEST_f_l (lrint, -0.2L, 0);
4168       TEST_f_l (lrint, 0.5L, 0);
4169       TEST_f_l (lrint, -0.5L, 0);
4170       TEST_f_l (lrint, 0.8L, 0);
4171       TEST_f_l (lrint, -0.8L, 0);
4172
4173       TEST_f_l (lrint, 1.4L, 1);
4174       TEST_f_l (lrint, -1.4L, -1);
4175
4176       TEST_f_l (lrint, 8388600.3L, 8388600);
4177       TEST_f_l (lrint, -8388600.3L, -8388600);
4178
4179       TEST_f_l (lrint, 1071930.0008, 1071930);
4180 #ifndef TEST_FLOAT
4181       TEST_f_l (lrint, 1073741824.01, 1073741824);
4182 # if LONG_MAX > 281474976710656
4183       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
4184 # endif
4185 #endif
4186     }
4187
4188   fesetround (save_round_mode);
4189
4190   END (lrint_towardzero);
4191 }
4192
4193
4194 static void
4195 lrint_test_downward (void)
4196 {
4197   int save_round_mode;
4198   START (lrint_downward);
4199
4200   save_round_mode = fegetround ();
4201
4202   if (!fesetround (FE_DOWNWARD))
4203     {
4204       TEST_f_l (lrint, 0.0, 0);
4205       TEST_f_l (lrint, minus_zero, 0);
4206       TEST_f_l (lrint, 0.2L, 0);
4207       TEST_f_l (lrint, -0.2L, -1);
4208       TEST_f_l (lrint, 0.5L, 0);
4209       TEST_f_l (lrint, -0.5L, -1);
4210       TEST_f_l (lrint, 0.8L, 0);
4211       TEST_f_l (lrint, -0.8L, -1);
4212
4213       TEST_f_l (lrint, 1.4L, 1);
4214       TEST_f_l (lrint, -1.4L, -2);
4215
4216       TEST_f_l (lrint, 8388600.3L, 8388600);
4217       TEST_f_l (lrint, -8388600.3L, -8388601);
4218
4219       TEST_f_l (lrint, 1071930.0008, 1071930);
4220 #ifndef TEST_FLOAT
4221       TEST_f_l (lrint, 1073741824.01, 1073741824);
4222 # if LONG_MAX > 281474976710656
4223       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
4224 # endif
4225 #endif
4226     }
4227
4228   fesetround (save_round_mode);
4229
4230   END (lrint_downward);
4231 }
4232
4233
4234 static void
4235 lrint_test_upward (void)
4236 {
4237   int save_round_mode;
4238   START (lrint_upward);
4239
4240   save_round_mode = fegetround ();
4241
4242   if (!fesetround (FE_UPWARD))
4243     {
4244       TEST_f_l (lrint, 0.0, 0);
4245       TEST_f_l (lrint, minus_zero, 0);
4246       TEST_f_l (lrint, 0.2L, 1);
4247       TEST_f_l (lrint, -0.2L, 0);
4248       TEST_f_l (lrint, 0.5L, 1);
4249       TEST_f_l (lrint, -0.5L, 0);
4250       TEST_f_l (lrint, 0.8L, 1);
4251       TEST_f_l (lrint, -0.8L, 0);
4252
4253       TEST_f_l (lrint, 1.4L, 2);
4254       TEST_f_l (lrint, -1.4L, -1);
4255
4256       TEST_f_l (lrint, 8388600.3L, 8388601);
4257       TEST_f_l (lrint, -8388600.3L, -8388600);
4258
4259 #ifndef TEST_FLOAT
4260       TEST_f_l (lrint, 1071930.0008, 1071931);
4261       TEST_f_l (lrint, 1073741824.01, 1073741825);
4262 # if LONG_MAX > 281474976710656 && defined (TEST_LDOUBLE)
4263       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
4264 # endif
4265 #endif
4266     }
4267
4268   fesetround (save_round_mode);
4269
4270   END (lrint_upward);
4271 }
4272
4273
4274 static void
4275 llrint_test (void)
4276 {
4277   /* XXX this test is incomplete.  We need to have a way to specifiy
4278      the rounding method and test the critical cases.  So far, only
4279      unproblematic numbers are tested.  */
4280
4281   START (llrint);
4282
4283   TEST_f_L (llrint, 0.0, 0);
4284   TEST_f_L (llrint, minus_zero, 0);
4285   TEST_f_L (llrint, 0.2L, 0);
4286   TEST_f_L (llrint, -0.2L, 0);
4287
4288   TEST_f_L (llrint, 1.4L, 1);
4289   TEST_f_L (llrint, -1.4L, -1);
4290
4291   TEST_f_L (llrint, 8388600.3L, 8388600);
4292   TEST_f_L (llrint, -8388600.3L, -8388600);
4293
4294   TEST_f_l (llrint, 1071930.0008, 1071930);
4295
4296   /* Test boundary conditions.  */
4297   /* 0x1FFFFF */
4298   TEST_f_L (llrint, 2097151.0,2097151LL);
4299   /* 0x800000 */
4300   TEST_f_L (llrint, 8388608.0, 8388608LL);
4301   /* 0x1000000 */
4302   TEST_f_L (llrint, 16777216.0, 16777216LL);
4303   /* 0x20000000000 */
4304   TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
4305   /* 0x40000000000 */
4306   TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
4307   /* 0x1000000000000 */
4308   TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
4309   /* 0x10000000000000 */
4310   TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
4311   /* 0x10000080000000 */
4312   TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
4313   /* 0x20000000000000 */
4314   TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
4315   /* 0x80000000000000 */
4316   TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
4317   /* 0x100000000000000 */
4318   TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
4319 #ifdef TEST_LDOUBLE
4320   /* The input can only be represented in long double.  */
4321   TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
4322   TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
4323   TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
4324   TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
4325   TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
4326
4327   TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
4328   TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
4329   TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
4330   TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
4331   TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
4332
4333 # if LDBL_MANT_DIG > 100
4334   TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
4335   TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
4336   TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
4337   TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
4338   TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
4339   TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
4340
4341   TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
4342   TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
4343   TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
4344   TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
4345   TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
4346   TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
4347 #endif
4348
4349   TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
4350   TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
4351   TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
4352   TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
4353   TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
4354
4355   TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
4356   TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
4357   TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
4358   TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
4359   TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
4360
4361 # if LDBL_MANT_DIG > 100
4362   TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
4363   TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
4364   TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
4365   TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
4366   TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
4367   TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
4368
4369   TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
4370   TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
4371   TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
4372   TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
4373   TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
4374   TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
4375 #endif
4376
4377   TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
4378   TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
4379   TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
4380   TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
4381   TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
4382
4383   TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
4384   TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
4385   TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
4386   TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
4387   TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
4388
4389 # if LDBL_MANT_DIG > 100
4390   TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
4391   TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
4392   TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
4393   TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
4394   TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
4395   TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
4396   TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
4397   TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
4398   TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
4399   TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
4400   TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
4401   TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
4402 # endif
4403 #endif
4404
4405   END (llrint);
4406 }
4407
4408 static void
4409 llrint_test_tonearest (void)
4410 {
4411   int save_round_mode;
4412   START (llrint_tonearest);
4413
4414   save_round_mode = fegetround ();
4415
4416   if (!fesetround (FE_TONEAREST))
4417     {
4418       TEST_f_L (llrint, 0.0, 0);
4419       TEST_f_L (llrint, minus_zero, 0);
4420       TEST_f_L (llrint, 0.2L, 0);
4421       TEST_f_L (llrint, -0.2L, 0);
4422
4423       TEST_f_L (llrint, 1.4L, 1);
4424       TEST_f_L (llrint, -1.4L, -1);
4425
4426       TEST_f_L (llrint, 8388600.3L, 8388600);
4427       TEST_f_L (llrint, -8388600.3L, -8388600);
4428
4429       TEST_f_l (llrint, 1071930.0008, 1071930);
4430
4431       /* Test boundary conditions.  */
4432       /* 0x1FFFFF */
4433       TEST_f_L (llrint, 2097151.0,2097151LL);
4434       /* 0x800000 */
4435       TEST_f_L (llrint, 8388608.0, 8388608LL);
4436       /* 0x1000000 */
4437       TEST_f_L (llrint, 16777216.0, 16777216LL);
4438       /* 0x20000000000 */
4439       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
4440       /* 0x40000000000 */
4441       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
4442       /* 0x1000000000000 */
4443       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
4444       /* 0x10000000000000 */
4445       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
4446       /* 0x10000080000000 */
4447       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
4448       /* 0x20000000000000 */
4449       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
4450       /* 0x80000000000000 */
4451       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
4452       /* 0x100000000000000 */
4453       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
4454 #ifdef TEST_LDOUBLE
4455       /* The input can only be represented in long double.  */
4456       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
4457       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
4458       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
4459       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
4460       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
4461
4462       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
4463       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
4464       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
4465       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
4466       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
4467
4468 # if LDBL_MANT_DIG > 100
4469       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
4470       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
4471       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
4472       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
4473       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
4474       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
4475
4476       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
4477       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
4478       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
4479       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
4480       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
4481       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
4482 #endif
4483
4484       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
4485       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
4486       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
4487       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
4488       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
4489
4490       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
4491       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
4492       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
4493       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
4494       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
4495
4496 # if LDBL_MANT_DIG > 100
4497       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
4498       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
4499       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
4500       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
4501       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
4502       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
4503
4504       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
4505       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
4506       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
4507       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
4508       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
4509       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
4510 #endif
4511
4512       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
4513       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
4514       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
4515       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
4516       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
4517
4518       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
4519       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
4520       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
4521       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
4522       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
4523
4524 # if LDBL_MANT_DIG > 100
4525       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
4526       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
4527       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
4528       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
4529       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
4530       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
4531       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
4532       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
4533       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
4534       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
4535       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
4536       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
4537 # endif
4538 #endif
4539     }
4540
4541   fesetround (save_round_mode);
4542
4543   END (llrint_tonearest);
4544 }
4545
4546 static void
4547 llrint_test_towardzero (void)
4548 {
4549   int save_round_mode;
4550   START (llrint_towardzero);
4551
4552   save_round_mode = fegetround ();
4553
4554   if (!fesetround (FE_TOWARDZERO))
4555     {
4556       TEST_f_L (llrint, 0.0, 0);
4557       TEST_f_L (llrint, minus_zero, 0);
4558       TEST_f_L (llrint, 0.2L, 0);
4559       TEST_f_L (llrint, -0.2L, 0);
4560
4561       TEST_f_L (llrint, 1.4L, 1);
4562       TEST_f_L (llrint, -1.4L, -1);
4563
4564       TEST_f_L (llrint, 8388600.3L, 8388600);
4565       TEST_f_L (llrint, -8388600.3L, -8388600);
4566
4567       TEST_f_l (llrint, 1071930.0008, 1071930);
4568
4569       /* Test boundary conditions.  */
4570       /* 0x1FFFFF */
4571       TEST_f_L (llrint, 2097151.0,2097151LL);
4572       /* 0x800000 */
4573       TEST_f_L (llrint, 8388608.0, 8388608LL);
4574       /* 0x1000000 */
4575       TEST_f_L (llrint, 16777216.0, 16777216LL);
4576       /* 0x20000000000 */
4577       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
4578       /* 0x40000000000 */
4579       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
4580       /* 0x1000000000000 */
4581       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
4582       /* 0x10000000000000 */
4583       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
4584       /* 0x10000080000000 */
4585       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
4586       /* 0x20000000000000 */
4587       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
4588       /* 0x80000000000000 */
4589       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
4590       /* 0x100000000000000 */
4591       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
4592 #ifdef TEST_LDOUBLE
4593       /* The input can only be represented in long double.  */
4594       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370495LL);
4595       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
4596       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
4597       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370496LL);
4598       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370497LL);
4599
4600       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370495LL);
4601       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
4602       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
4603       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370496LL);
4604       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370497LL);
4605
4606 # if LDBL_MANT_DIG > 100
4607       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
4608       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
4609       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
4610       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370494LL);
4611       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370495LL);
4612       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370496LL);
4613
4614       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
4615       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
4616       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
4617       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370494LL);
4618       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370495LL);
4619       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370496LL);
4620 #endif
4621
4622       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740991LL);
4623       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
4624       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
4625       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740992LL);
4626       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740993LL);
4627
4628       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740991LL);
4629       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
4630       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
4631       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740992LL);
4632       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740993LL);
4633
4634 # if LDBL_MANT_DIG > 100
4635       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
4636       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
4637       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
4638       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740991LL);
4639       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740992LL);
4640       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740993LL);
4641
4642       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
4643       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
4644       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
4645       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740991LL);
4646       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740992LL);
4647       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740993LL);
4648 #endif
4649
4650       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927935LL);
4651       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
4652       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
4653       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927936LL);
4654       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927937LL);
4655
4656       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927935LL);
4657       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
4658       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
4659       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927936LL);
4660       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927937LL);
4661
4662 # if LDBL_MANT_DIG > 100
4663       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775805LL);
4664       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775805LL);
4665       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
4666       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
4667       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
4668       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
4669       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
4670       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
4671       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775806LL);
4672       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775806LL);
4673       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
4674       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
4675 # endif
4676 #endif
4677     }
4678
4679   fesetround (save_round_mode);
4680
4681   END (llrint_towardzero);
4682 }
4683
4684 static void
4685 llrint_test_downward (void)
4686 {
4687   int save_round_mode;
4688   START (llrint_downward);
4689
4690   save_round_mode = fegetround ();
4691
4692   if (!fesetround (FE_DOWNWARD))
4693     {
4694       TEST_f_L (llrint, 0.0, 0);
4695       TEST_f_L (llrint, minus_zero, 0);
4696       TEST_f_L (llrint, 0.2L, 0);
4697       TEST_f_L (llrint, -0.2L, -1);
4698
4699       TEST_f_L (llrint, 1.4L, 1);
4700       TEST_f_L (llrint, -1.4L, -2);
4701
4702       TEST_f_L (llrint, 8388600.3L, 8388600);
4703       TEST_f_L (llrint, -8388600.3L, -8388601);
4704
4705       TEST_f_l (llrint, 1071930.0008, 1071930);
4706
4707       /* Test boundary conditions.  */
4708       /* 0x1FFFFF */
4709       TEST_f_L (llrint, 2097151.0,2097151LL);
4710       /* 0x800000 */
4711       TEST_f_L (llrint, 8388608.0, 8388608LL);
4712       /* 0x1000000 */
4713       TEST_f_L (llrint, 16777216.0, 16777216LL);
4714       /* 0x20000000000 */
4715       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
4716       /* 0x40000000000 */
4717       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
4718       /* 0x1000000000000 */
4719       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
4720       /* 0x10000000000000 */
4721       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
4722       /* 0x10000080000000 */
4723       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
4724       /* 0x20000000000000 */
4725       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
4726       /* 0x80000000000000 */
4727       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
4728       /* 0x100000000000000 */
4729       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
4730 #ifdef TEST_LDOUBLE
4731       /* The input can only be represented in long double.  */
4732       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370495LL);
4733       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
4734       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
4735       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370496LL);
4736       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370497LL);
4737
4738       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
4739       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
4740       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
4741       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370494LL);
4742       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370495LL);
4743       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370496LL);
4744
4745       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
4746       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370497LL);
4747       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370497LL);
4748       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
4749       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
4750
4751       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370496LL);
4752       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370497LL);
4753       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370498LL);
4754       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
4755       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
4756       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
4757
4758       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740991LL);
4759       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
4760       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
4761       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740992LL);
4762       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740993LL);
4763
4764       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
4765       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
4766       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
4767       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740991LL);
4768       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740992LL);
4769       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740993LL);
4770
4771       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
4772       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740993LL);
4773       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740993LL);
4774       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
4775       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
4776
4777       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740992LL);
4778       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740993LL);
4779       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740994LL);
4780       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
4781       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
4782       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
4783
4784       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927935LL);
4785       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
4786       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
4787       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927936LL);
4788       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927937LL);
4789
4790       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
4791       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927937LL);
4792       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927937LL);
4793       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
4794       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
4795
4796 # if LDBL_MANT_DIG > 100
4797       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775805LL);
4798       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
4799       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
4800       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
4801       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
4802       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775807LL);
4803       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
4804       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775807LL);
4805       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775806LL);
4806       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
4807       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
4808       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
4809 # endif
4810 #endif
4811     }
4812
4813   fesetround (save_round_mode);
4814
4815   END (llrint_downward);
4816 }
4817
4818 static void
4819 llrint_test_upward (void)
4820 {
4821   int save_round_mode;
4822   START (llrint_upward);
4823
4824   save_round_mode = fegetround ();
4825
4826   if (!fesetround (FE_UPWARD))
4827     {
4828       TEST_f_L (llrint, 0.0, 0);
4829       TEST_f_L (llrint, minus_zero, 0);
4830       TEST_f_L (llrint, 0.2L, 1);
4831       TEST_f_L (llrint, -0.2L, 0);
4832
4833       TEST_f_L (llrint, 1.4L, 2);
4834       TEST_f_L (llrint, -1.4L, -1);
4835
4836       TEST_f_L (llrint, 8388600.3L, 8388601);
4837       TEST_f_L (llrint, -8388600.3L, -8388600);
4838 #ifndef TEST_FLOAT
4839       TEST_f_l (llrint, 1071930.0008, 1071931);
4840 #endif
4841       /* Test boundary conditions.  */
4842       /* 0x1FFFFF */
4843       TEST_f_L (llrint, 2097151.0,2097151LL);
4844       /* 0x800000 */
4845       TEST_f_L (llrint, 8388608.0, 8388608LL);
4846       /* 0x1000000 */
4847       TEST_f_L (llrint, 16777216.0, 16777216LL);
4848       /* 0x20000000000 */
4849       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
4850       /* 0x40000000000 */
4851       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
4852       /* 0x1000000000000 */
4853       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
4854       /* 0x10000000000000 */
4855       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
4856       /* 0x10000080000000 */
4857       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
4858       /* 0x20000000000000 */
4859       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
4860       /* 0x80000000000000 */
4861       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
4862       /* 0x100000000000000 */
4863       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
4864 #ifdef TEST_LDOUBLE
4865       /* The input can only be represented in long double.  */
4866       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
4867       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370497LL);
4868       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370497LL);
4869       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
4870       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
4871
4872       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370496LL);
4873       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370497LL);
4874       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370498LL);
4875       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
4876       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
4877       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
4878
4879       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370495LL);
4880       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
4881       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
4882       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370496LL);
4883       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370497LL);
4884
4885       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
4886       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
4887       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
4888       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370494LL);
4889       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370495LL);
4890       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370496LL);
4891
4892       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
4893       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740993LL);
4894       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740993LL);
4895       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
4896       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
4897
4898       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740992LL);
4899       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740993LL);
4900       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740994LL);
4901       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
4902       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
4903       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
4904
4905       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740991LL);
4906       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
4907       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
4908       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740992LL);
4909       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740993LL);
4910
4911       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
4912       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
4913       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
4914       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740991LL);
4915       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740992LL);
4916       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740993LL);
4917
4918       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
4919       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927937LL);
4920       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927937LL);
4921       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
4922       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
4923
4924       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927935LL);
4925       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
4926       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
4927       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927936LL);
4928       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927937LL);
4929
4930 # if LDBL_MANT_DIG > 100
4931       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
4932       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775805LL);
4933       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
4934       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
4935       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775807LL);
4936       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
4937       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775807L);
4938       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
4939       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
4940       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775806LL);
4941       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
4942       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
4943 # endif
4944 #endif
4945     }
4946
4947   fesetround (save_round_mode);
4948
4949   END (llrint_upward);
4950 }
4951
4952
4953 static void
4954 log_test (void)
4955 {
4956   errno = 0;
4957   FUNC(log) (1);
4958   if (errno == ENOSYS)
4959     /* Function not implemented.  */
4960     return;
4961   START (log);
4962
4963   TEST_f_f (log, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4964   TEST_f_f (log, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4965
4966   TEST_f_f (log, 1, 0);
4967
4968   TEST_f_f (log, -1, nan_value, INVALID_EXCEPTION);
4969   TEST_f_f (log, -max_value, nan_value, INVALID_EXCEPTION);
4970   TEST_f_f (log, minus_infty, nan_value, INVALID_EXCEPTION);
4971   TEST_f_f (log, plus_infty, plus_infty);
4972   TEST_f_f (log, nan_value, nan_value);
4973
4974   TEST_f_f (log, M_El, 1);
4975   TEST_f_f (log, 1.0 / M_El, -1);
4976   TEST_f_f (log, 2, M_LN2l);
4977   TEST_f_f (log, 10, M_LN10l);
4978   TEST_f_f (log, 0.75L, -0.287682072451780927439219005993827432L);
4979
4980   END (log);
4981 }
4982
4983
4984 static void
4985 log10_test (void)
4986 {
4987   errno = 0;
4988   FUNC(log10) (1);
4989   if (errno == ENOSYS)
4990     /* Function not implemented.  */
4991     return;
4992
4993   START (log10);
4994
4995   TEST_f_f (log10, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4996   TEST_f_f (log10, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4997
4998   TEST_f_f (log10, 1, 0);
4999
5000   /* log10 (x) == NaN plus invalid exception if x < 0.  */
5001   TEST_f_f (log10, -1, nan_value, INVALID_EXCEPTION);
5002   TEST_f_f (log10, -max_value, nan_value, INVALID_EXCEPTION);
5003   TEST_f_f (log10, minus_infty, nan_value, INVALID_EXCEPTION);
5004
5005   TEST_f_f (log10, plus_infty, plus_infty);
5006   TEST_f_f (log10, nan_value, nan_value);
5007
5008   TEST_f_f (log10, 0.1L, -1);
5009   TEST_f_f (log10, 10.0, 1);
5010   TEST_f_f (log10, 100.0, 2);
5011   TEST_f_f (log10, 10000.0, 4);
5012   TEST_f_f (log10, M_El, M_LOG10El);
5013   TEST_f_f (log10, 0.75L, -0.124938736608299953132449886193870744L);
5014
5015   END (log10);
5016 }
5017
5018
5019 static void
5020 log1p_test (void)
5021 {
5022   errno = 0;
5023   FUNC(log1p) (0);
5024   if (errno == ENOSYS)
5025     /* Function not implemented.  */
5026     return;
5027
5028   START (log1p);
5029
5030   TEST_f_f (log1p, 0, 0);
5031   TEST_f_f (log1p, minus_zero, minus_zero);
5032
5033   TEST_f_f (log1p, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5034   TEST_f_f (log1p, -2, nan_value, INVALID_EXCEPTION);
5035   TEST_f_f (log1p, -max_value, nan_value, INVALID_EXCEPTION);
5036   TEST_f_f (log1p, minus_infty, nan_value, INVALID_EXCEPTION);
5037
5038   TEST_f_f (log1p, plus_infty, plus_infty);
5039   TEST_f_f (log1p, nan_value, nan_value);
5040
5041   TEST_f_f (log1p, M_El - 1.0, 1);
5042
5043   TEST_f_f (log1p, -0.25L, -0.287682072451780927439219005993827432L);
5044   TEST_f_f (log1p, -0.875, -2.07944154167983592825169636437452970L);
5045
5046   END (log1p);
5047 }
5048
5049
5050 static void
5051 log2_test (void)
5052 {
5053   errno = 0;
5054   FUNC(log2) (1);
5055   if (errno == ENOSYS)
5056     /* Function not implemented.  */
5057     return;
5058
5059   START (log2);
5060
5061   TEST_f_f (log2, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5062   TEST_f_f (log2, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5063
5064   TEST_f_f (log2, 1, 0);
5065
5066   TEST_f_f (log2, -1, nan_value, INVALID_EXCEPTION);
5067   TEST_f_f (log2, -max_value, nan_value, INVALID_EXCEPTION);
5068   TEST_f_f (log2, minus_infty, nan_value, INVALID_EXCEPTION);
5069
5070   TEST_f_f (log2, plus_infty, plus_infty);
5071   TEST_f_f (log2, nan_value, nan_value);
5072
5073   TEST_f_f (log2, M_El, M_LOG2El);
5074   TEST_f_f (log2, 2.0, 1);
5075   TEST_f_f (log2, 16.0, 4);
5076   TEST_f_f (log2, 256.0, 8);
5077   TEST_f_f (log2, 0.75L, -.415037499278843818546261056052183492L);
5078
5079   END (log2);
5080 }
5081
5082
5083 static void
5084 logb_test (void)
5085 {
5086   START (logb);
5087
5088   TEST_f_f (logb, plus_infty, plus_infty);
5089   TEST_f_f (logb, minus_infty, plus_infty);
5090
5091   TEST_f_f (logb, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5092
5093   TEST_f_f (logb, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5094   TEST_f_f (logb, nan_value, nan_value);
5095
5096   TEST_f_f (logb, 1, 0);
5097   TEST_f_f (logb, M_El, 1);
5098   TEST_f_f (logb, 1024, 10);
5099   TEST_f_f (logb, -2000, 10);
5100
5101   END (logb);
5102 }
5103
5104 static void
5105 logb_test_downward (void)
5106 {
5107   int save_round_mode;
5108   errno = 0;
5109
5110   FUNC(logb) (0);
5111   if (errno == ENOSYS)
5112     /* Function not implemented.  */
5113     return;
5114
5115   START (logb_downward);
5116
5117   save_round_mode = fegetround ();
5118
5119   if (!fesetround (FE_DOWNWARD))
5120     {
5121
5122       /* IEEE 754-2008 says (section 5.3.3) that "logB(1) is +0.".  Libm
5123          should not return -0 from logb in any rounding mode.  PowerPC32 has
5124          failed with this test for power4 logb (and logbl on all PowerPC
5125          platforms) in the past due to instruction selection.  GCC PR 52775
5126          provides the availability of the fcfid insn in 32-bit mode which
5127          eliminates the use of fsub in this instance and prevents the negative
5128          signed 0.0.  */
5129
5130       /* BZ #887  */
5131       TEST_f_f (logb, 1.000e+0, plus_zero);
5132     }
5133
5134   fesetround (save_round_mode);
5135
5136   END (logb_downward);
5137 }
5138
5139 static void
5140 lround_test (void)
5141 {
5142   START (lround);
5143
5144   TEST_f_l (lround, 0, 0);
5145   TEST_f_l (lround, minus_zero, 0);
5146   TEST_f_l (lround, 0.2L, 0.0);
5147   TEST_f_l (lround, -0.2L, 0);
5148   TEST_f_l (lround, 0.5, 1);
5149   TEST_f_l (lround, -0.5, -1);
5150   TEST_f_l (lround, 0.8L, 1);
5151   TEST_f_l (lround, -0.8L, -1);
5152   TEST_f_l (lround, 1.5, 2);
5153   TEST_f_l (lround, -1.5, -2);
5154   TEST_f_l (lround, 22514.5, 22515);
5155   TEST_f_l (lround, -22514.5, -22515);
5156   TEST_f_l (lround, 1071930.0008, 1071930);
5157 #ifndef TEST_FLOAT
5158   TEST_f_l (lround, 1073741824.01, 1073741824);
5159 # if LONG_MAX > 281474976710656
5160   TEST_f_l (lround, 281474976710656.025, 281474976710656);
5161   TEST_f_l (lround, 18014398509481974, 18014398509481974);
5162 # endif
5163   TEST_f_l (lround, 2097152.5, 2097153);
5164   TEST_f_l (lround, -2097152.5, -2097153);
5165   /* nextafter(0.5,-1)  */
5166   TEST_f_l (lround, 0x1.fffffffffffffp-2, 0);
5167   /* nextafter(-0.5,1)  */
5168   TEST_f_l (lround, -0x1.fffffffffffffp-2, 0);
5169 #else
5170   /* nextafter(0.5,-1)  */
5171   TEST_f_l (lround, 0x1.fffffp-2, 0);
5172   /* nextafter(-0.5,1)  */
5173   TEST_f_l (lround, -0x1.fffffp-2, 0);
5174   TEST_f_l (lround, 0x1.fffffep+23, 16777215);
5175   TEST_f_l (lround, -0x1.fffffep+23, -16777215);
5176 #endif
5177   END (lround);
5178 }
5179
5180
5181 static void
5182 llround_test (void)
5183 {
5184   START (llround);
5185
5186   TEST_f_L (llround, 0, 0);
5187   TEST_f_L (llround, minus_zero, 0);
5188   TEST_f_L (llround, 0.2L, 0.0);
5189   TEST_f_L (llround, -0.2L, 0);
5190   TEST_f_L (llround, 0.5, 1);
5191   TEST_f_L (llround, -0.5, -1);
5192   TEST_f_L (llround, 0.8L, 1);
5193   TEST_f_L (llround, -0.8L, -1);
5194   TEST_f_L (llround, 1.5, 2);
5195   TEST_f_L (llround, -1.5, -2);
5196   TEST_f_L (llround, 22514.5, 22515);
5197   TEST_f_L (llround, -22514.5, -22515);
5198   TEST_f_l (llround, 1071930.0008, 1071930);
5199 #ifndef TEST_FLOAT
5200   TEST_f_L (llround, 2097152.5, 2097153);
5201   TEST_f_L (llround, -2097152.5, -2097153);
5202   TEST_f_L (llround, 34359738368.5, 34359738369ll);
5203   TEST_f_L (llround, -34359738368.5, -34359738369ll);
5204   TEST_f_L (llround, -3.65309740835E17, -365309740835000000LL);
5205 #endif
5206
5207   /* Test boundary conditions.  */
5208   /* 0x1FFFFF */
5209   TEST_f_L (llround, 2097151.0, 2097151LL);
5210   /* 0x800000 */
5211   TEST_f_L (llround, 8388608.0, 8388608LL);
5212   /* 0x1000000 */
5213   TEST_f_L (llround, 16777216.0, 16777216LL);
5214   /* 0x20000000000 */
5215   TEST_f_L (llround, 2199023255552.0, 2199023255552LL);
5216   /* 0x40000000000 */
5217   TEST_f_L (llround, 4398046511104.0, 4398046511104LL);
5218   /* 0x1000000000000 */
5219   TEST_f_L (llround, 281474976710656.0, 281474976710656LL);
5220   /* 0x10000000000000 */
5221   TEST_f_L (llround, 4503599627370496.0, 4503599627370496LL);
5222   /* 0x10000080000000 */
5223   TEST_f_L (llround, 4503601774854144.0, 4503601774854144LL);
5224   /* 0x20000000000000 */
5225   TEST_f_L (llround, 9007199254740992.0, 9007199254740992LL);
5226   /* 0x80000000000000 */
5227   TEST_f_L (llround, 36028797018963968.0, 36028797018963968LL);
5228   /* 0x100000000000000 */
5229   TEST_f_L (llround, 72057594037927936.0, 72057594037927936LL);
5230
5231 #ifndef TEST_FLOAT
5232   /* 0x100000000 */
5233   TEST_f_L (llround, 4294967295.5, 4294967296LL);
5234   /* 0x200000000 */
5235   TEST_f_L (llround, 8589934591.5, 8589934592LL);
5236
5237   /* nextafter(0.5,-1)  */
5238   TEST_f_L (llround, 0x1.fffffffffffffp-2, 0);
5239   /* nextafter(-0.5,1)  */
5240   TEST_f_L (llround, -0x1.fffffffffffffp-2, 0);
5241   /* On PowerPC an exponent of '52' is the largest incrementally
5242    * representable sequence of whole-numbers in the 'double' range.  We test
5243    * lround to make sure that a guard bit set during the lround operation
5244    * hasn't forced an erroneous shift giving us an incorrect result.  The odd
5245    * numbers between +-(2^52+1 and 2^53-1) are affected since they have the
5246    * rightmost bit set.  */
5247   /* +-(2^52+1)  */
5248   TEST_f_L (llround, 0x1.0000000000001p+52,4503599627370497LL);
5249   TEST_f_L (llround, -0x1.0000000000001p+52,-4503599627370497LL);
5250   /* +-(2^53-1): Input is the last (positive and negative) incrementally
5251    * representable whole-number in the 'double' range that might round
5252    * erroneously.  */
5253   TEST_f_L (llround, 0x1.fffffffffffffp+52, 9007199254740991LL);
5254   TEST_f_L (llround, -0x1.fffffffffffffp+52, -9007199254740991LL);
5255 #else
5256   /* nextafter(0.5,-1)  */
5257   TEST_f_L (llround, 0x1.fffffep-2, 0);
5258   /* nextafter(-0.5,1)  */
5259   TEST_f_L (llround, -0x1.fffffep-2, 0);
5260   /* As above, on PowerPC an exponent of '23' is the largest incrementally
5261    * representable sequence of whole-numbers in the 'float' range.
5262    * Likewise, numbers between +-(2^23+1 and 2^24-1) are affected.  */
5263   TEST_f_L (llround, 0x1.000002p+23,8388609);
5264   TEST_f_L (llround, -0x1.000002p+23,-8388609);
5265   TEST_f_L (llround, 0x1.fffffep+23, 16777215);
5266   TEST_f_L (llround, -0x1.fffffep+23, -16777215);
5267 #endif
5268
5269
5270 #ifdef TEST_LDOUBLE
5271   /* The input can only be represented in long double.  */
5272   TEST_f_L (llround, 4503599627370495.5L, 4503599627370496LL);
5273   TEST_f_L (llround, 4503599627370496.25L, 4503599627370496LL);
5274   TEST_f_L (llround, 4503599627370496.5L, 4503599627370497LL);
5275   TEST_f_L (llround, 4503599627370496.75L, 4503599627370497LL);
5276   TEST_f_L (llround, 4503599627370497.5L, 4503599627370498LL);
5277
5278 # if LDBL_MANT_DIG > 100
5279   TEST_f_L (llround, 4503599627370495.4999999999999L, 4503599627370495LL);
5280   TEST_f_L (llround, 4503599627370496.4999999999999L, 4503599627370496LL);
5281   TEST_f_L (llround, 4503599627370497.4999999999999L, 4503599627370497LL);
5282   TEST_f_L (llround, 4503599627370494.5000000000001L, 4503599627370495LL);
5283   TEST_f_L (llround, 4503599627370495.5000000000001L, 4503599627370496LL);
5284   TEST_f_L (llround, 4503599627370496.5000000000001L, 4503599627370497LL);
5285
5286   TEST_f_L (llround, -4503599627370495.4999999999999L, -4503599627370495LL);
5287   TEST_f_L (llround, -4503599627370496.4999999999999L, -4503599627370496LL);
5288   TEST_f_L (llround, -4503599627370497.4999999999999L, -4503599627370497LL);
5289   TEST_f_L (llround, -4503599627370494.5000000000001L, -4503599627370495LL);
5290   TEST_f_L (llround, -4503599627370495.5000000000001L, -4503599627370496LL);
5291   TEST_f_L (llround, -4503599627370496.5000000000001L, -4503599627370497LL);
5292 # endif
5293
5294   TEST_f_L (llround, -4503599627370495.5L, -4503599627370496LL);
5295   TEST_f_L (llround, -4503599627370496.25L, -4503599627370496LL);
5296   TEST_f_L (llround, -4503599627370496.5L, -4503599627370497LL);
5297   TEST_f_L (llround, -4503599627370496.75L, -4503599627370497LL);
5298   TEST_f_L (llround, -4503599627370497.5L, -4503599627370498LL);
5299
5300   TEST_f_L (llround, 9007199254740991.5L, 9007199254740992LL);
5301   TEST_f_L (llround, 9007199254740992.25L, 9007199254740992LL);
5302   TEST_f_L (llround, 9007199254740992.5L, 9007199254740993LL);
5303   TEST_f_L (llround, 9007199254740992.75L, 9007199254740993LL);
5304   TEST_f_L (llround, 9007199254740993.5L, 9007199254740994LL);
5305
5306 # if LDBL_MANT_DIG > 100
5307   TEST_f_L (llround, 9007199254740991.4999999999999L, 9007199254740991LL);
5308   TEST_f_L (llround, 9007199254740992.4999999999999L, 9007199254740992LL);
5309   TEST_f_L (llround, 9007199254740993.4999999999999L, 9007199254740993LL);
5310   TEST_f_L (llround, 9007199254740991.5000000000001L, 9007199254740992LL);
5311   TEST_f_L (llround, 9007199254740992.5000000000001L, 9007199254740993LL);
5312   TEST_f_L (llround, 9007199254740993.5000000000001L, 9007199254740994LL);
5313
5314   TEST_f_L (llround, -9007199254740991.4999999999999L, -9007199254740991LL);
5315   TEST_f_L (llround, -9007199254740992.4999999999999L, -9007199254740992LL);
5316   TEST_f_L (llround, -9007199254740993.4999999999999L, -9007199254740993LL);
5317   TEST_f_L (llround, -9007199254740991.5000000000001L, -9007199254740992LL);
5318   TEST_f_L (llround, -9007199254740992.5000000000001L, -9007199254740993LL);
5319   TEST_f_L (llround, -9007199254740993.5000000000001L, -9007199254740994LL);
5320 # endif
5321
5322   TEST_f_L (llround, -9007199254740991.5L, -9007199254740992LL);
5323   TEST_f_L (llround, -9007199254740992.25L, -9007199254740992LL);
5324   TEST_f_L (llround, -9007199254740992.5L, -9007199254740993LL);
5325   TEST_f_L (llround, -9007199254740992.75L, -9007199254740993LL);
5326   TEST_f_L (llround, -9007199254740993.5L, -9007199254740994LL);
5327
5328   TEST_f_L (llround, 72057594037927935.5L, 72057594037927936LL);
5329   TEST_f_L (llround, 72057594037927936.25L, 72057594037927936LL);
5330   TEST_f_L (llround, 72057594037927936.5L, 72057594037927937LL);
5331   TEST_f_L (llround, 72057594037927936.75L, 72057594037927937LL);
5332   TEST_f_L (llround, 72057594037927937.5L, 72057594037927938LL);
5333
5334   TEST_f_L (llround, -72057594037927935.5L, -72057594037927936LL);
5335   TEST_f_L (llround, -72057594037927936.25L, -72057594037927936LL);
5336   TEST_f_L (llround, -72057594037927936.5L, -72057594037927937LL);
5337   TEST_f_L (llround, -72057594037927936.75L, -72057594037927937LL);
5338   TEST_f_L (llround, -72057594037927937.5L, -72057594037927938LL);
5339
5340   TEST_f_L (llround, 9223372036854775806.25L, 9223372036854775806LL);
5341   TEST_f_L (llround, -9223372036854775806.25L, -9223372036854775806LL);
5342   TEST_f_L (llround, 9223372036854775806.5L, 9223372036854775807LL);
5343   TEST_f_L (llround, -9223372036854775806.5L, -9223372036854775807LL);
5344   TEST_f_L (llround, 9223372036854775807.0L, 9223372036854775807LL);
5345   TEST_f_L (llround, -9223372036854775807.0L, -9223372036854775807LL);
5346 #endif
5347
5348   END (llround);
5349 }
5350
5351 static void
5352 modf_test (void)
5353 {
5354   FLOAT x;
5355
5356   START (modf);
5357
5358   TEST_fF_f1 (modf, plus_infty, 0, plus_infty);
5359   TEST_fF_f1 (modf, minus_infty, minus_zero, minus_infty);
5360   TEST_fF_f1 (modf, nan_value, nan_value, nan_value);
5361   TEST_fF_f1 (modf, 0, 0, 0);
5362   TEST_fF_f1 (modf, 1.5, 0.5, 1);
5363   TEST_fF_f1 (modf, 2.5, 0.5, 2);
5364   TEST_fF_f1 (modf, -2.5, -0.5, -2);
5365   TEST_fF_f1 (modf, 20, 0, 20);
5366   TEST_fF_f1 (modf, 21, 0, 21);
5367   TEST_fF_f1 (modf, 89.5, 0.5, 89);
5368
5369   END (modf);
5370 }
5371
5372
5373 static void
5374 nearbyint_test (void)
5375 {
5376   START (nearbyint);
5377
5378   TEST_f_f (nearbyint, 0.0, 0.0);
5379   TEST_f_f (nearbyint, minus_zero, minus_zero);
5380   TEST_f_f (nearbyint, plus_infty, plus_infty);
5381   TEST_f_f (nearbyint, minus_infty, minus_infty);
5382   TEST_f_f (nearbyint, nan_value, nan_value);
5383
5384   /* Subnormal values */
5385   TEST_f_f (nearbyint, -8.98847e+307, -8.98847e+307);
5386   TEST_f_f (nearbyint, -4.45015e-308, minus_zero);
5387
5388   /* Default rounding mode is round to nearest.  */
5389   TEST_f_f (nearbyint, 0.5, 0.0);
5390   TEST_f_f (nearbyint, 1.5, 2.0);
5391   TEST_f_f (nearbyint, -0.5, minus_zero);
5392   TEST_f_f (nearbyint, -1.5, -2.0);
5393
5394   TEST_f_f (nearbyint, 262144.75, 262145.0);
5395   TEST_f_f (nearbyint, 262142.75, 262143.0);
5396   TEST_f_f (nearbyint, 524286.75, 524287.0);
5397   TEST_f_f (nearbyint, 524288.75, 524289.0);
5398
5399   TEST_f_f (nearbyint, 1048576.75, 1048577.0);
5400   TEST_f_f (nearbyint, 2097152.75, 2097153.0);
5401   TEST_f_f (nearbyint, 2492472.75, 2492473.0);
5402   TEST_f_f (nearbyint, 2886220.75, 2886221.0);
5403   TEST_f_f (nearbyint, 3058792.75, 3058793.0);
5404   TEST_f_f (nearbyint, -1048576.75, -1048577.0);
5405   TEST_f_f (nearbyint, -2097152.75, -2097153.0);
5406   TEST_f_f (nearbyint, -2492472.75, -2492473.0);
5407   TEST_f_f (nearbyint, -2886220.75, -2886221.0);
5408   TEST_f_f (nearbyint, -3058792.75, -3058793.0);
5409 #ifndef TEST_FLOAT
5410   TEST_f_f (nearbyint, 70368744177664.75, 70368744177665.0);
5411   TEST_f_f (nearbyint, 140737488355328.75, 140737488355329.0);
5412   TEST_f_f (nearbyint, 281474976710656.75, 281474976710657.0);
5413   TEST_f_f (nearbyint, 562949953421312.75, 562949953421313.0);
5414   TEST_f_f (nearbyint, 1125899906842624.75, 1125899906842625.0);
5415   TEST_f_f (nearbyint, -70368744177664.75, -70368744177665.0);
5416   TEST_f_f (nearbyint, -140737488355328.75, -140737488355329.0);
5417   TEST_f_f (nearbyint, -281474976710656.75, -281474976710657.0);
5418   TEST_f_f (nearbyint, -562949953421312.75, -562949953421313.0);
5419   TEST_f_f (nearbyint, -1125899906842624.75, -1125899906842625.0);
5420 #endif
5421
5422   END (nearbyint);
5423 }
5424
5425 static void
5426 nextafter_test (void)
5427 {
5428
5429   START (nextafter);
5430
5431   TEST_ff_f (nextafter, 0, 0, 0);
5432   TEST_ff_f (nextafter, minus_zero, 0, 0);
5433   TEST_ff_f (nextafter, 0, minus_zero, minus_zero);
5434   TEST_ff_f (nextafter, minus_zero, minus_zero, minus_zero);
5435
5436   TEST_ff_f (nextafter, 9, 9, 9);
5437   TEST_ff_f (nextafter, -9, -9, -9);
5438   TEST_ff_f (nextafter, plus_infty, plus_infty, plus_infty);
5439   TEST_ff_f (nextafter, minus_infty, minus_infty, minus_infty);
5440
5441   TEST_ff_f (nextafter, nan_value, 1.1L, nan_value);
5442   TEST_ff_f (nextafter, 1.1L, nan_value, nan_value);
5443   TEST_ff_f (nextafter, nan_value, nan_value, nan_value);
5444
5445   FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
5446                          LDBL_MAX, DBL_MAX, FLT_MAX);
5447   TEST_ff_f (nextafter, fltmax, plus_infty, plus_infty, OVERFLOW_EXCEPTION);
5448   TEST_ff_f (nextafter, -fltmax, minus_infty, minus_infty, OVERFLOW_EXCEPTION);
5449
5450 #ifdef TEST_LDOUBLE
5451   // XXX Enable once gcc is fixed.
5452   //TEST_ff_f (nextafter, 0x0.00000040000000000000p-16385L, -0.1L, 0x0.0000003ffffffff00000p-16385L);
5453 #endif
5454
5455   /* XXX We need the hexadecimal FP number representation here for further
5456      tests.  */
5457
5458   END (nextafter);
5459 }
5460
5461
5462 static void
5463 nexttoward_test (void)
5464 {
5465   START (nexttoward);
5466   TEST_ff_f (nexttoward, 0, 0, 0);
5467   TEST_ff_f (nexttoward, minus_zero, 0, 0);
5468   TEST_ff_f (nexttoward, 0, minus_zero, minus_zero);
5469   TEST_ff_f (nexttoward, minus_zero, minus_zero, minus_zero);
5470
5471   TEST_ff_f (nexttoward, 9, 9, 9);
5472   TEST_ff_f (nexttoward, -9, -9, -9);
5473   TEST_ff_f (nexttoward, plus_infty, plus_infty, plus_infty);
5474   TEST_ff_f (nexttoward, minus_infty, minus_infty, minus_infty);
5475
5476   TEST_ff_f (nexttoward, nan_value, 1.1L, nan_value);
5477   TEST_ff_f (nexttoward, 1.1L, nan_value, nan_value);
5478   TEST_ff_f (nexttoward, nan_value, nan_value, nan_value);
5479
5480   /* XXX We need the hexadecimal FP number representation here for further
5481      tests.  */
5482
5483   END (nexttoward);
5484 }
5485
5486
5487 static void
5488 pow_test (void)
5489 {
5490
5491   errno = 0;
5492   FUNC(pow) (0, 0);
5493   if (errno == ENOSYS)
5494     /* Function not implemented.  */
5495     return;
5496
5497   START (pow);
5498
5499   TEST_ff_f (pow, 0, 0, 1);
5500   TEST_ff_f (pow, 0, minus_zero, 1);
5501   TEST_ff_f (pow, minus_zero, 0, 1);
5502   TEST_ff_f (pow, minus_zero, minus_zero, 1);
5503
5504   TEST_ff_f (pow, 10, 0, 1);
5505   TEST_ff_f (pow, 10, minus_zero, 1);
5506   TEST_ff_f (pow, -10, 0, 1);
5507   TEST_ff_f (pow, -10, minus_zero, 1);
5508
5509   TEST_ff_f (pow, nan_value, 0, 1);
5510   TEST_ff_f (pow, nan_value, minus_zero, 1);
5511
5512
5513 #ifndef TEST_INLINE
5514   TEST_ff_f (pow, 1.1L, plus_infty, plus_infty);
5515   TEST_ff_f (pow, plus_infty, plus_infty, plus_infty);
5516   TEST_ff_f (pow, -1.1L, plus_infty, plus_infty);
5517   TEST_ff_f (pow, minus_infty, plus_infty, plus_infty);
5518
5519   TEST_ff_f (pow, 0.9L, plus_infty, 0);
5520   TEST_ff_f (pow, 1e-7L, plus_infty, 0);
5521   TEST_ff_f (pow, -0.9L, plus_infty, 0);
5522   TEST_ff_f (pow, -1e-7L, plus_infty, 0);
5523
5524   TEST_ff_f (pow, 1.1L, minus_infty, 0);
5525   TEST_ff_f (pow, plus_infty, minus_infty, 0);
5526   TEST_ff_f (pow, -1.1L, minus_infty, 0);
5527   TEST_ff_f (pow, minus_infty, minus_infty, 0);
5528
5529   TEST_ff_f (pow, 0.9L, minus_infty, plus_infty);
5530   TEST_ff_f (pow, 1e-7L, minus_infty, plus_infty);
5531   TEST_ff_f (pow, -0.9L, minus_infty, plus_infty);
5532   TEST_ff_f (pow, -1e-7L, minus_infty, plus_infty);
5533
5534   TEST_ff_f (pow, plus_infty, 1e-7L, plus_infty);
5535   TEST_ff_f (pow, plus_infty, 1, plus_infty);
5536   TEST_ff_f (pow, plus_infty, 1e7L, plus_infty);
5537
5538   TEST_ff_f (pow, plus_infty, -1e-7L, 0);
5539   TEST_ff_f (pow, plus_infty, -1, 0);
5540   TEST_ff_f (pow, plus_infty, -1e7L, 0);
5541
5542   TEST_ff_f (pow, minus_infty, 1, minus_infty);
5543   TEST_ff_f (pow, minus_infty, 11, minus_infty);
5544   TEST_ff_f (pow, minus_infty, 1001, minus_infty);
5545
5546   TEST_ff_f (pow, minus_infty, 2, plus_infty);
5547   TEST_ff_f (pow, minus_infty, 12, plus_infty);
5548   TEST_ff_f (pow, minus_infty, 1002, plus_infty);
5549   TEST_ff_f (pow, minus_infty, 0.1L, plus_infty);
5550   TEST_ff_f (pow, minus_infty, 1.1L, plus_infty);
5551   TEST_ff_f (pow, minus_infty, 11.1L, plus_infty);
5552   TEST_ff_f (pow, minus_infty, 1001.1L, plus_infty);
5553
5554   TEST_ff_f (pow, minus_infty, -1, minus_zero);
5555   TEST_ff_f (pow, minus_infty, -11, minus_zero);
5556   TEST_ff_f (pow, minus_infty, -1001, minus_zero);
5557
5558   TEST_ff_f (pow, minus_infty, -2, 0);
5559   TEST_ff_f (pow, minus_infty, -12, 0);
5560   TEST_ff_f (pow, minus_infty, -1002, 0);
5561   TEST_ff_f (pow, minus_infty, -0.1L, 0);
5562   TEST_ff_f (pow, minus_infty, -1.1L, 0);
5563   TEST_ff_f (pow, minus_infty, -11.1L, 0);
5564   TEST_ff_f (pow, minus_infty, -1001.1L, 0);
5565 #endif
5566
5567   TEST_ff_f (pow, nan_value, nan_value, nan_value);
5568   TEST_ff_f (pow, 0, nan_value, nan_value);
5569   TEST_ff_f (pow, 1, nan_value, 1);
5570   TEST_ff_f (pow, -1, nan_value, nan_value);
5571   TEST_ff_f (pow, nan_value, 1, nan_value);
5572   TEST_ff_f (pow, nan_value, -1, nan_value);
5573
5574   /* pow (x, NaN) == NaN.  */
5575   TEST_ff_f (pow, 3.0, nan_value, nan_value);
5576   TEST_ff_f (pow, minus_zero, nan_value, nan_value);
5577   TEST_ff_f (pow, plus_infty, nan_value, nan_value);
5578   TEST_ff_f (pow, -3.0, nan_value, nan_value);
5579   TEST_ff_f (pow, minus_infty, nan_value, nan_value);
5580
5581   TEST_ff_f (pow, nan_value, 3.0, nan_value);
5582   TEST_ff_f (pow, nan_value, -3.0, nan_value);
5583   TEST_ff_f (pow, nan_value, plus_infty, nan_value);
5584   TEST_ff_f (pow, nan_value, minus_infty, nan_value);
5585   TEST_ff_f (pow, nan_value, 2.5, nan_value);
5586   TEST_ff_f (pow, nan_value, -2.5, nan_value);
5587
5588   TEST_ff_f (pow, 1, plus_infty, 1);
5589   TEST_ff_f (pow, -1, plus_infty, 1);
5590   TEST_ff_f (pow, 1, minus_infty, 1);
5591   TEST_ff_f (pow, -1, minus_infty, 1);
5592   TEST_ff_f (pow, 1, 1, 1);
5593   TEST_ff_f (pow, 1, -1, 1);
5594   TEST_ff_f (pow, 1, 1.25, 1);
5595   TEST_ff_f (pow, 1, -1.25, 1);
5596   TEST_ff_f (pow, 1, 0x1p62L, 1);
5597   TEST_ff_f (pow, 1, 0x1p63L, 1);
5598   TEST_ff_f (pow, 1, 0x1p64L, 1);
5599   TEST_ff_f (pow, 1, 0x1p72L, 1);
5600
5601   /* pow (x, +-0) == 1.  */
5602   TEST_ff_f (pow, plus_infty, 0, 1);
5603   TEST_ff_f (pow, plus_infty, minus_zero, 1);
5604   TEST_ff_f (pow, minus_infty, 0, 1);
5605   TEST_ff_f (pow, minus_infty, minus_zero, 1);
5606   TEST_ff_f (pow, 32.75L, 0, 1);
5607   TEST_ff_f (pow, 32.75L, minus_zero, 1);
5608   TEST_ff_f (pow, -32.75L, 0, 1);
5609   TEST_ff_f (pow, -32.75L, minus_zero, 1);
5610   TEST_ff_f (pow, 0x1p72L, 0, 1);
5611   TEST_ff_f (pow, 0x1p72L, minus_zero, 1);
5612   TEST_ff_f (pow, 0x1p-72L, 0, 1);
5613   TEST_ff_f (pow, 0x1p-72L, minus_zero, 1);
5614
5615   TEST_ff_f (pow, -0.1L, 1.1L, nan_value, INVALID_EXCEPTION);
5616   TEST_ff_f (pow, -0.1L, -1.1L, nan_value, INVALID_EXCEPTION);
5617   TEST_ff_f (pow, -10.1L, 1.1L, nan_value, INVALID_EXCEPTION);
5618   TEST_ff_f (pow, -10.1L, -1.1L, nan_value, INVALID_EXCEPTION);
5619
5620   errno = 0;
5621   TEST_ff_f (pow, 0, -1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5622   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5623   errno = 0;
5624   TEST_ff_f (pow, 0, -11, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5625   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5626   errno = 0;
5627   TEST_ff_f (pow, 0, -0xffffff, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5628   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5629 #ifndef TEST_FLOAT
5630   errno = 0;
5631   TEST_ff_f (pow, 0, -0x1.fffffffffffffp+52L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5632   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5633 #endif
5634 #ifdef TEST_LDOUBLE
5635 # if LDBL_MANT_DIG >= 64
5636   errno = 0;
5637   TEST_ff_f (pow, 0, -0x1.fffffffffffffffep+63L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5638   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5639 # endif
5640 # if LDBL_MANT_DIG >= 106
5641   errno = 0;
5642   TEST_ff_f (pow, 0, -0x1.ffffffffffffffffffffffffff8p+105L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5643   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5644 # endif
5645 # if LDBL_MANT_DIG >= 113
5646   errno = 0;
5647   TEST_ff_f (pow, 0, -0x1.ffffffffffffffffffffffffffffp+112L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5648   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5649 # endif
5650 #endif
5651   TEST_ff_f (pow, minus_zero, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5652   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5653   errno = 0;
5654   TEST_ff_f (pow, minus_zero, -11L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5655   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5656   errno = 0;
5657   TEST_ff_f (pow, minus_zero, -0xffffff, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5658   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5659   errno = 0;
5660   TEST_ff_f (pow, minus_zero, -0x1fffffe, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5661   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
5662 #ifndef TEST_FLOAT
5663   errno = 0;
5664   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffp+52L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5665   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5666   errno = 0;
5667   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffp+53L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5668   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
5669 #endif
5670 #ifdef TEST_LDOUBLE
5671 # if LDBL_MANT_DIG >= 64
5672   errno = 0;
5673   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffffep+63L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5674   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5675   errno = 0;
5676   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffffep+64L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5677   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
5678 # endif
5679 # if LDBL_MANT_DIG >= 106
5680   errno = 0;
5681   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5682   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5683   errno = 0;
5684   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5685   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
5686 # endif
5687 # if LDBL_MANT_DIG >= 113
5688   errno = 0;
5689   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5690   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5691   errno = 0;
5692   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5693   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
5694 # endif
5695 #endif
5696
5697   errno = 0;
5698   TEST_ff_f (pow, 0, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5699   check_int ("errno for pow(0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
5700   errno = 0;
5701   TEST_ff_f (pow, 0, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5702   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
5703   errno = 0;
5704   TEST_ff_f (pow, 0, -0x1p24, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5705   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
5706   errno = 0;
5707   TEST_ff_f (pow, 0, -0x1p127, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5708   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
5709   errno = 0;
5710   TEST_ff_f (pow, 0, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5711   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
5712   errno = 0;
5713   TEST_ff_f (pow, minus_zero, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5714   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
5715   errno = 0;
5716   TEST_ff_f (pow, minus_zero, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5717   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
5718   errno = 0;
5719   TEST_ff_f (pow, minus_zero, -0x1p24, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5720   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
5721   errno = 0;
5722   TEST_ff_f (pow, minus_zero, -0x1p127, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5723   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
5724   errno = 0;
5725   TEST_ff_f (pow, minus_zero, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5726   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
5727
5728   TEST_ff_f (pow, 0x1p72L, 0x1p72L, plus_infty, OVERFLOW_EXCEPTION);
5729   TEST_ff_f (pow, 10, -0x1p72L, 0);
5730   TEST_ff_f (pow, max_value, max_value, plus_infty, OVERFLOW_EXCEPTION);
5731   TEST_ff_f (pow, 10, -max_value, 0);
5732
5733   TEST_ff_f (pow, 0, 1, 0);
5734   TEST_ff_f (pow, 0, 11, 0);
5735
5736   TEST_ff_f (pow, minus_zero, 1, minus_zero);
5737   TEST_ff_f (pow, minus_zero, 11, minus_zero);
5738
5739   TEST_ff_f (pow, 0, 2, 0);
5740   TEST_ff_f (pow, 0, 11.1L, 0);
5741
5742   TEST_ff_f (pow, minus_zero, 2, 0);
5743   TEST_ff_f (pow, minus_zero, 11.1L, 0);
5744   TEST_ff_f (pow, 0, plus_infty, 0);
5745   TEST_ff_f (pow, minus_zero, plus_infty, 0);
5746
5747 #ifndef TEST_INLINE
5748   /* pow (x, +inf) == +inf for |x| > 1.  */
5749   TEST_ff_f (pow, 1.5, plus_infty, plus_infty);
5750
5751   /* pow (x, +inf) == +0 for |x| < 1.  */
5752   TEST_ff_f (pow, 0.5, plus_infty, 0.0);
5753
5754   /* pow (x, -inf) == +0 for |x| > 1.  */
5755   TEST_ff_f (pow, 1.5, minus_infty, 0.0);
5756
5757   /* pow (x, -inf) == +inf for |x| < 1.  */
5758   TEST_ff_f (pow, 0.5, minus_infty, plus_infty);
5759 #endif
5760
5761   /* pow (+inf, y) == +inf for y > 0.  */
5762   TEST_ff_f (pow, plus_infty, 2, plus_infty);
5763   TEST_ff_f (pow, plus_infty, 0xffffff, plus_infty);
5764 #ifndef TEST_FLOAT
5765   TEST_ff_f (pow, plus_infty, 0x1.fffffffffffffp+52L, plus_infty);
5766 #endif
5767 #ifdef TEST_LDOUBLE
5768 # if LDBL_MANT_DIG >= 64
5769   TEST_ff_f (pow, plus_infty, 0x1.fffffffffffffffep+63L, plus_infty);
5770 # endif
5771 # if LDBL_MANT_DIG >= 106
5772   TEST_ff_f (pow, plus_infty, 0x1.ffffffffffffffffffffffffff8p+105L, plus_infty);
5773 # endif
5774 # if LDBL_MANT_DIG >= 113
5775   TEST_ff_f (pow, plus_infty, 0x1.ffffffffffffffffffffffffffffp+112L, plus_infty);
5776 # endif
5777 #endif
5778   TEST_ff_f (pow, plus_infty, 0x1p24, plus_infty);
5779   TEST_ff_f (pow, plus_infty, 0x1p127, plus_infty);
5780   TEST_ff_f (pow, plus_infty, max_value, plus_infty);
5781
5782   /* pow (+inf, y) == +0 for y < 0.  */
5783   TEST_ff_f (pow, plus_infty, -1, 0.0);
5784   TEST_ff_f (pow, plus_infty, -0xffffff, 0.0);
5785 #ifndef TEST_FLOAT
5786   TEST_ff_f (pow, plus_infty, -0x1.fffffffffffffp+52L, 0.0);
5787 #endif
5788 #ifdef TEST_LDOUBLE
5789 # if LDBL_MANT_DIG >= 64
5790   TEST_ff_f (pow, plus_infty, -0x1.fffffffffffffffep+63L, 0.0);
5791 # endif
5792 # if LDBL_MANT_DIG >= 106
5793   TEST_ff_f (pow, plus_infty, -0x1.ffffffffffffffffffffffffff8p+105L, 0.0);
5794 # endif
5795 # if LDBL_MANT_DIG >= 113
5796   TEST_ff_f (pow, plus_infty, -0x1.ffffffffffffffffffffffffffffp+112L, 0.0);
5797 # endif
5798 #endif
5799   TEST_ff_f (pow, plus_infty, -0x1p24, 0.0);
5800   TEST_ff_f (pow, plus_infty, -0x1p127, 0.0);
5801   TEST_ff_f (pow, plus_infty, -max_value, 0.0);
5802
5803   /* pow (-inf, y) == -inf for y an odd integer > 0.  */
5804   TEST_ff_f (pow, minus_infty, 27, minus_infty);
5805   TEST_ff_f (pow, minus_infty, 0xffffff, minus_infty);
5806   TEST_ff_f (pow, minus_infty, 0x1fffffe, plus_infty);
5807 #ifndef TEST_FLOAT
5808   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffp+52L, minus_infty);
5809   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffp+53L, plus_infty);
5810 #endif
5811 #ifdef TEST_LDOUBLE
5812 # if LDBL_MANT_DIG >= 64
5813   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffffep+63L, minus_infty);
5814   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffffep+64L, plus_infty);
5815 # endif
5816 # if LDBL_MANT_DIG >= 106
5817   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty);
5818   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty);
5819 # endif
5820 # if LDBL_MANT_DIG >= 113
5821   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty);
5822   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty);
5823 # endif
5824 #endif
5825
5826   /* pow (-inf, y) == +inf for y > 0 and not an odd integer.  */
5827   TEST_ff_f (pow, minus_infty, 28, plus_infty);
5828   TEST_ff_f (pow, minus_infty, 0x1p24, plus_infty);
5829   TEST_ff_f (pow, minus_infty, 0x1p127, plus_infty);
5830   TEST_ff_f (pow, minus_infty, max_value, plus_infty);
5831
5832   /* pow (-inf, y) == -0 for y an odd integer < 0. */
5833   TEST_ff_f (pow, minus_infty, -3, minus_zero);
5834   TEST_ff_f (pow, minus_infty, -0xffffff, minus_zero);
5835   TEST_ff_f (pow, minus_infty, -0x1fffffe, plus_zero);
5836 #ifndef TEST_FLOAT
5837   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffp+52L, minus_zero);
5838   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffp+53L, plus_zero);
5839 #endif
5840 #ifdef TEST_LDOUBLE
5841 # if LDBL_MANT_DIG >= 64
5842   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffffep+63L, minus_zero);
5843   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffffep+64L, plus_zero);
5844 # endif
5845 # if LDBL_MANT_DIG >= 106
5846   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
5847   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
5848 # endif
5849 # if LDBL_MANT_DIG >= 113
5850   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
5851   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
5852 # endif
5853 #endif
5854   /* pow (-inf, y) == +0 for y < 0 and not an odd integer.  */
5855   TEST_ff_f (pow, minus_infty, -2.0, 0.0);
5856   TEST_ff_f (pow, minus_infty, -0x1p24, 0.0);
5857   TEST_ff_f (pow, minus_infty, -0x1p127, 0.0);
5858   TEST_ff_f (pow, minus_infty, -max_value, 0.0);
5859
5860   /* pow (+0, y) == +0 for y an odd integer > 0.  */
5861   TEST_ff_f (pow, 0.0, 27, 0.0);
5862   TEST_ff_f (pow, 0.0, 0xffffff, 0.0);
5863 #ifndef TEST_FLOAT
5864   TEST_ff_f (pow, 0.0, 0x1.fffffffffffffp+52L, 0.0);
5865 #endif
5866 #ifdef TEST_LDOUBLE
5867 # if LDBL_MANT_DIG >= 64
5868   TEST_ff_f (pow, 0.0, 0x1.fffffffffffffffep+63L, 0.0);
5869 # endif
5870 # if LDBL_MANT_DIG >= 106
5871   TEST_ff_f (pow, 0.0, 0x1.ffffffffffffffffffffffffff8p+105L, 0.0);
5872 # endif
5873 # if LDBL_MANT_DIG >= 113
5874   TEST_ff_f (pow, 0.0, 0x1.ffffffffffffffffffffffffffffp+112L, 0.0);
5875 # endif
5876 #endif
5877
5878   /* pow (-0, y) == -0 for y an odd integer > 0.  */
5879   TEST_ff_f (pow, minus_zero, 27, minus_zero);
5880   TEST_ff_f (pow, minus_zero, 0xffffff, minus_zero);
5881   TEST_ff_f (pow, minus_zero, 0x1fffffe, plus_zero);
5882 #ifndef TEST_FLOAT
5883   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffp+52L, minus_zero);
5884   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffp+53L, plus_zero);
5885 #endif
5886 #ifdef TEST_LDOUBLE
5887 # if LDBL_MANT_DIG >= 64
5888   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffffep+63L, minus_zero);
5889   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffffep+64L, plus_zero);
5890 # endif
5891 # if LDBL_MANT_DIG >= 106
5892   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
5893   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
5894 # endif
5895 # if LDBL_MANT_DIG >= 113
5896   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
5897   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
5898 # endif
5899 #endif
5900
5901   /* pow (+0, y) == +0 for y > 0 and not an odd integer.  */
5902   TEST_ff_f (pow, 0.0, 4, 0.0);
5903   TEST_ff_f (pow, 0.0, 0x1p24, 0.0);
5904   TEST_ff_f (pow, 0.0, 0x1p127, 0.0);
5905   TEST_ff_f (pow, 0.0, max_value, 0.0);
5906
5907   /* pow (-0, y) == +0 for y > 0 and not an odd integer.  */
5908   TEST_ff_f (pow, minus_zero, 4, 0.0);
5909   TEST_ff_f (pow, minus_zero, 0x1p24, 0.0);
5910   TEST_ff_f (pow, minus_zero, 0x1p127, 0.0);
5911   TEST_ff_f (pow, minus_zero, max_value, 0.0);
5912
5913   TEST_ff_f (pow, 16, 0.25L, 2);
5914   TEST_ff_f (pow, 0x1p64L, 0.125L, 256);
5915   TEST_ff_f (pow, 2, 4, 16);
5916   TEST_ff_f (pow, 256, 8, 0x1p64L);
5917
5918   TEST_ff_f (pow, 0.75L, 1.25L, 0.697953644326574699205914060237425566L);
5919
5920 #if defined TEST_DOUBLE || defined TEST_LDOUBLE
5921   TEST_ff_f (pow, -7.49321e+133, -9.80818e+16, 0);
5922 #endif
5923
5924   TEST_ff_f (pow, -1.0, -0xffffff, -1.0);
5925   TEST_ff_f (pow, -1.0, -0x1fffffe, 1.0);
5926 #ifndef TEST_FLOAT
5927   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffp+52L, -1.0);
5928   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffp+53L, 1.0);
5929 #endif
5930 #ifdef TEST_LDOUBLE
5931 # if LDBL_MANT_DIG >= 64
5932   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffffep+63L, -1.0);
5933   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffffep+64L, 1.0);
5934 # endif
5935 # if LDBL_MANT_DIG >= 106
5936   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffff8p+105L, -1.0);
5937   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffff8p+106L, 1.0);
5938 # endif
5939 # if LDBL_MANT_DIG >= 113
5940   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffffffp+112L, -1.0);
5941   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffffffp+113L, 1.0);
5942 # endif
5943 #endif
5944   TEST_ff_f (pow, -1.0, -max_value, 1.0);
5945
5946   TEST_ff_f (pow, -1.0, 0xffffff, -1.0);
5947   TEST_ff_f (pow, -1.0, 0x1fffffe, 1.0);
5948 #ifndef TEST_FLOAT
5949   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffp+52L, -1.0);
5950   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffp+53L, 1.0);
5951 #endif
5952 #ifdef TEST_LDOUBLE
5953 # if LDBL_MANT_DIG >= 64
5954   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffffep+63L, -1.0);
5955   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffffep+64L, 1.0);
5956 # endif
5957 # if LDBL_MANT_DIG >= 106
5958   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffff8p+105L, -1.0);
5959   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffff8p+106L, 1.0);
5960 # endif
5961 # if LDBL_MANT_DIG >= 113
5962   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffffffp+112L, -1.0);
5963   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffffffp+113L, 1.0);
5964 # endif
5965 #endif
5966   TEST_ff_f (pow, -1.0, max_value, 1.0);
5967
5968   TEST_ff_f (pow, -2.0, 126, 0x1p126);
5969   TEST_ff_f (pow, -2.0, 127, -0x1p127);
5970   TEST_ff_f (pow, -2.0, -126, 0x1p-126);
5971   TEST_ff_f (pow, -2.0, -127, -0x1p-127);
5972
5973   TEST_ff_f (pow, -2.0, -0xffffff, minus_zero);
5974   TEST_ff_f (pow, -2.0, -0x1fffffe, plus_zero);
5975 #ifndef TEST_FLOAT
5976   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffp+52L, minus_zero);
5977   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffp+53L, plus_zero);
5978 #endif
5979 #ifdef TEST_LDOUBLE
5980 # if LDBL_MANT_DIG >= 64
5981   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffffep+63L, minus_zero);
5982   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffffep+64L, plus_zero);
5983 # endif
5984 # if LDBL_MANT_DIG >= 106
5985   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
5986   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
5987 # endif
5988 # if LDBL_MANT_DIG >= 113
5989   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
5990   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
5991 # endif
5992 #endif
5993   TEST_ff_f (pow, -2.0, -max_value, plus_zero);
5994
5995   TEST_ff_f (pow, -2.0, 0xffffff, minus_infty, OVERFLOW_EXCEPTION);
5996   TEST_ff_f (pow, -2.0, 0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
5997 #ifndef TEST_FLOAT
5998   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
5999   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
6000 #endif
6001 #ifdef TEST_LDOUBLE
6002 # if LDBL_MANT_DIG >= 64
6003   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
6004   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
6005 # endif
6006 # if LDBL_MANT_DIG >= 106
6007   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
6008   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
6009 # endif
6010 # if LDBL_MANT_DIG >= 113
6011   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
6012   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
6013 # endif
6014 #endif
6015   TEST_ff_f (pow, -2.0, max_value, plus_infty, OVERFLOW_EXCEPTION);
6016
6017   TEST_ff_f (pow, -max_value, 0.5, nan_value, INVALID_EXCEPTION);
6018   TEST_ff_f (pow, -max_value, 1.5, nan_value, INVALID_EXCEPTION);
6019   TEST_ff_f (pow, -max_value, 1000.5, nan_value, INVALID_EXCEPTION);
6020   TEST_ff_f (pow, -max_value, -2, plus_zero);
6021   TEST_ff_f (pow, -max_value, -3, minus_zero);
6022   TEST_ff_f (pow, -max_value, 2, plus_infty, OVERFLOW_EXCEPTION);
6023   TEST_ff_f (pow, -max_value, 3, minus_infty, OVERFLOW_EXCEPTION);
6024
6025   TEST_ff_f (pow, -max_value, -0xffffff, minus_zero);
6026   TEST_ff_f (pow, -max_value, -0x1fffffe, plus_zero);
6027 #ifndef TEST_FLOAT
6028   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffp+52L, minus_zero);
6029   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffp+53L, plus_zero);
6030 #endif
6031 #ifdef TEST_LDOUBLE
6032 # if LDBL_MANT_DIG >= 64
6033   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffffep+63L, minus_zero);
6034   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffffep+64L, plus_zero);
6035 # endif
6036 # if LDBL_MANT_DIG >= 106
6037   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
6038   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
6039 # endif
6040 # if LDBL_MANT_DIG >= 113
6041   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
6042   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
6043 # endif
6044 #endif
6045   TEST_ff_f (pow, -max_value, -max_value, plus_zero);
6046
6047   TEST_ff_f (pow, -max_value, 0xffffff, minus_infty, OVERFLOW_EXCEPTION);
6048   TEST_ff_f (pow, -max_value, 0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
6049 #ifndef TEST_FLOAT
6050   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
6051   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
6052 #endif
6053 #ifdef TEST_LDOUBLE
6054 # if LDBL_MANT_DIG >= 64
6055   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
6056   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
6057 # endif
6058 # if LDBL_MANT_DIG >= 106
6059   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
6060   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
6061 # endif
6062 # if LDBL_MANT_DIG >= 113
6063   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
6064   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
6065 # endif
6066 #endif
6067   TEST_ff_f (pow, -max_value, max_value, plus_infty, OVERFLOW_EXCEPTION);
6068
6069   TEST_ff_f (pow, -0.5, 126, 0x1p-126);
6070   TEST_ff_f (pow, -0.5, 127, -0x1p-127);
6071   TEST_ff_f (pow, -0.5, -126, 0x1p126);
6072   TEST_ff_f (pow, -0.5, -127, -0x1p127);
6073
6074   TEST_ff_f (pow, -0.5, -0xffffff, minus_infty, OVERFLOW_EXCEPTION);
6075   TEST_ff_f (pow, -0.5, -0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
6076 #ifndef TEST_FLOAT
6077   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
6078   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
6079 #endif
6080 #ifdef TEST_LDOUBLE
6081 # if LDBL_MANT_DIG >= 64
6082   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
6083   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
6084 # endif
6085 # if LDBL_MANT_DIG >= 106
6086   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
6087   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
6088 # endif
6089 # if LDBL_MANT_DIG >= 113
6090   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
6091   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
6092 # endif
6093 #endif
6094   TEST_ff_f (pow, -0.5, -max_value, plus_infty, OVERFLOW_EXCEPTION);
6095
6096   TEST_ff_f (pow, -0.5, 0xffffff, minus_zero);
6097   TEST_ff_f (pow, -0.5, 0x1fffffe, plus_zero);
6098 #ifndef TEST_FLOAT
6099   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffp+52L, minus_zero);
6100   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffp+53L, plus_zero);
6101 #endif
6102 #ifdef TEST_LDOUBLE
6103 # if LDBL_MANT_DIG >= 64
6104   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffffep+63L, minus_zero);
6105   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffffep+64L, plus_zero);
6106 # endif
6107 # if LDBL_MANT_DIG >= 106
6108   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
6109   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
6110 # endif
6111 # if LDBL_MANT_DIG >= 113
6112   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
6113   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
6114 # endif
6115 #endif
6116   TEST_ff_f (pow, -0.5, max_value, plus_zero);
6117
6118   TEST_ff_f (pow, -min_value, 0.5, nan_value, INVALID_EXCEPTION);
6119   TEST_ff_f (pow, -min_value, 1.5, nan_value, INVALID_EXCEPTION);
6120   TEST_ff_f (pow, -min_value, 1000.5, nan_value, INVALID_EXCEPTION);
6121   TEST_ff_f (pow, -min_value, -2, plus_infty, OVERFLOW_EXCEPTION);
6122   TEST_ff_f (pow, -min_value, -3, minus_infty, OVERFLOW_EXCEPTION);
6123   TEST_ff_f (pow, -min_value, 1, -min_value);
6124   TEST_ff_f (pow, -min_value, 2, plus_zero);
6125   TEST_ff_f (pow, -min_value, 3, minus_zero);
6126
6127   TEST_ff_f (pow, -min_value, -0xffffff, minus_infty, OVERFLOW_EXCEPTION);
6128   TEST_ff_f (pow, -min_value, -0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
6129 #ifndef TEST_FLOAT
6130   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
6131   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
6132 #endif
6133 #ifdef TEST_LDOUBLE
6134 # if LDBL_MANT_DIG >= 64
6135   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
6136   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
6137 # endif
6138 # if LDBL_MANT_DIG >= 106
6139   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
6140   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
6141 # endif
6142 # if LDBL_MANT_DIG >= 113
6143   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
6144   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
6145 # endif
6146 #endif
6147   TEST_ff_f (pow, -min_value, -max_value, plus_infty, OVERFLOW_EXCEPTION);
6148
6149   TEST_ff_f (pow, -min_value, 0xffffff, minus_zero);
6150   TEST_ff_f (pow, -min_value, 0x1fffffe, plus_zero);
6151 #ifndef TEST_FLOAT
6152   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffp+52L, minus_zero);
6153   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffp+53L, plus_zero);
6154 #endif
6155 #ifdef TEST_LDOUBLE
6156 # if LDBL_MANT_DIG >= 64
6157   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffffep+63L, minus_zero);
6158   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffffep+64L, plus_zero);
6159 # endif
6160 # if LDBL_MANT_DIG >= 106
6161   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
6162   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
6163 # endif
6164 # if LDBL_MANT_DIG >= 113
6165   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
6166   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
6167 # endif
6168 #endif
6169   TEST_ff_f (pow, -min_value, max_value, plus_zero);
6170
6171 #ifndef TEST_LDOUBLE /* Bug 13881.  */
6172   TEST_ff_f (pow, 0x0.ffffffp0, 10, 0.999999403953712118183885036774764444747L);
6173   TEST_ff_f (pow, 0x0.ffffffp0, 100, 0.999994039553108359406305079606228341585L);
6174   TEST_ff_f (pow, 0x0.ffffffp0, 1000, 0.9999403971297699052276650144650733772182L);
6175   TEST_ff_f (pow, 0x0.ffffffp0, 0x1p24, 0.3678794302077803437135155590023422899744L);
6176   TEST_ff_f (pow, 0x0.ffffffp0, 0x1p30, 1.603807831524924233828134753069728224044e-28L);
6177   TEST_ff_f (pow, 0x0.ffffffp0, 0x1.234566p30, 2.374884712135295099971443365381007297732e-32L);
6178   TEST_ff_f (pow, 0x0.ffffffp0, -10, 1.000000596046643153205170848674671339688L);
6179   TEST_ff_f (pow, 0x0.ffffffp0, -100, 1.000005960482418779499387594989252621451L);
6180   TEST_ff_f (pow, 0x0.ffffffp0, -1000, 1.000059606422943986382898964231519867906L);
6181   TEST_ff_f (pow, 0x0.ffffffp0, -0x1p24, 2.7182819094701610539628664526874952929416L);
6182   TEST_ff_f (pow, 0x0.ffffffp0, -0x1p30, 6.2351609734265057988914412331288163636075e+27L);
6183   TEST_ff_f (pow, 0x0.ffffffp0, -0x1.234566p30, 4.2107307141696353498921307077142537353515e+31L);
6184   TEST_ff_f (pow, 0x1.000002p0, 0x1p24, 7.3890552180866447284268641248075832310141L);
6185   TEST_ff_f (pow, 0x1.000002p0, 0x1.234566p29, 4.2107033006507495188536371520637025716256e+31L);
6186   TEST_ff_f (pow, 0x1.000002p0, -0x1.234566p29, 2.3749001736727769098946062325205705312166e-32L);
6187 #endif
6188
6189   /* Bug 13881: powl inaccurate so these tests disabled for long double.  */
6190 #if !defined TEST_FLOAT && !defined TEST_LDOUBLE
6191   TEST_ff_f (pow, 0x0.fffffffffffff8p0L, 0x1.23456789abcdfp62L, 1.0118762747827252817436395051178295138220e-253L);
6192   TEST_ff_f (pow, 0x0.fffffffffffff8p0L, -0x1.23456789abcdfp62L, 9.8826311568054561811190162420900667121992e+252L);
6193   TEST_ff_f (pow, 0x1.0000000000001p0L, 0x1.23456789abcdfp61L, 9.8826311568044974397135026217687399395481e+252L);
6194   TEST_ff_f (pow, 0x1.0000000000001p0L, -0x1.23456789abcdfp61L, 1.0118762747828234466621210689458255908670e-253L);
6195 #endif
6196
6197   END (pow);
6198 }
6199
6200
6201 static void
6202 pow_test_tonearest (void)
6203 {
6204   int save_round_mode;
6205   errno = 0;
6206   FUNC(pow) (0, 0);
6207   if (errno == ENOSYS)
6208     /* Function not implemented.  */
6209     return;
6210
6211   START (pow_tonearest);
6212
6213   save_round_mode = fegetround ();
6214
6215   if (!fesetround (FE_TONEAREST))
6216     {
6217       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
6218       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
6219     }
6220
6221   fesetround (save_round_mode);
6222
6223   END (pow_tonearest);
6224 }
6225
6226
6227 static void
6228 pow_test_towardzero (void)
6229 {
6230   int save_round_mode;
6231   errno = 0;
6232   FUNC(pow) (0, 0);
6233   if (errno == ENOSYS)
6234     /* Function not implemented.  */
6235     return;
6236
6237   START (pow_towardzero);
6238
6239   save_round_mode = fegetround ();
6240
6241   if (!fesetround (FE_TOWARDZERO))
6242     {
6243       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
6244       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
6245     }
6246
6247   fesetround (save_round_mode);
6248
6249   END (pow_towardzero);
6250 }
6251
6252
6253 static void
6254 pow_test_downward (void)
6255 {
6256   int save_round_mode;
6257   errno = 0;
6258   FUNC(pow) (0, 0);
6259   if (errno == ENOSYS)
6260     /* Function not implemented.  */
6261     return;
6262
6263   START (pow_downward);
6264
6265   save_round_mode = fegetround ();
6266
6267   if (!fesetround (FE_DOWNWARD))
6268     {
6269       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
6270       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
6271     }
6272
6273   fesetround (save_round_mode);
6274
6275   END (pow_downward);
6276 }
6277
6278
6279 static void
6280 pow_test_upward (void)
6281 {
6282   int save_round_mode;
6283   errno = 0;
6284   FUNC(pow) (0, 0);
6285   if (errno == ENOSYS)
6286     /* Function not implemented.  */
6287     return;
6288
6289   START (pow_upward);
6290
6291   save_round_mode = fegetround ();
6292
6293   if (!fesetround (FE_UPWARD))
6294     {
6295       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
6296       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
6297     }
6298
6299   fesetround (save_round_mode);
6300
6301   END (pow_upward);
6302 }
6303
6304
6305 static void
6306 remainder_test (void)
6307 {
6308   errno = 0;
6309   FUNC(remainder) (1.625, 1.0);
6310   if (errno == ENOSYS)
6311     /* Function not implemented.  */
6312     return;
6313
6314   START (remainder);
6315
6316   errno = 0;
6317   TEST_ff_f (remainder, 1, 0, nan_value, INVALID_EXCEPTION);
6318   check_int ("errno for remainder(1, 0) = EDOM ", errno, EDOM, 0, 0, 0);
6319   errno = 0;
6320   TEST_ff_f (remainder, 1, minus_zero, nan_value, INVALID_EXCEPTION);
6321   check_int ("errno for remainder(1, -0) = EDOM ", errno, EDOM, 0, 0, 0);
6322   errno = 0;
6323   TEST_ff_f (remainder, plus_infty, 1, nan_value, INVALID_EXCEPTION);
6324   check_int ("errno for remainder(INF, 1) = EDOM ", errno, EDOM, 0, 0, 0);
6325   errno = 0;
6326   TEST_ff_f (remainder, minus_infty, 1, nan_value, INVALID_EXCEPTION);
6327   check_int ("errno for remainder(-INF, 1) = EDOM ", errno, EDOM, 0, 0, 0);
6328   errno = 0;
6329   TEST_ff_f (remainder, nan_value, nan_value, nan_value);
6330   check_int ("errno for remainder(NAN, NAN) unchanged", errno, 0, 0, 0, 0);
6331   errno = 0;
6332   TEST_ff_f (remainder, 0, nan_value, nan_value);
6333   check_int ("errno for remainder(0, NAN) unchanged", errno, 0, 0, 0, 0);
6334   errno = 0;
6335   TEST_ff_f (remainder, nan_value, 0, nan_value);
6336   check_int ("errno for remainder(NaN, 0) unchanged", errno, 0, 0, 0, 0);
6337
6338   TEST_ff_f (remainder, 1.625, 1.0, -0.375);
6339   TEST_ff_f (remainder, -1.625, 1.0, 0.375);
6340   TEST_ff_f (remainder, 1.625, -1.0, -0.375);
6341   TEST_ff_f (remainder, -1.625, -1.0, 0.375);
6342   TEST_ff_f (remainder, 5.0, 2.0, 1.0);
6343   TEST_ff_f (remainder, 3.0, 2.0, -1.0);
6344
6345   END (remainder);
6346 }
6347
6348 static void
6349 remquo_test (void)
6350 {
6351   /* x is needed.  */
6352   int x;
6353
6354   errno = 0;
6355   FUNC(remquo) (1.625, 1.0, &x);
6356   if (errno == ENOSYS)
6357     /* Function not implemented.  */
6358     return;
6359
6360   START (remquo);
6361
6362   TEST_ffI_f1 (remquo, 1, 0, nan_value, IGNORE, INVALID_EXCEPTION);
6363   TEST_ffI_f1 (remquo, 1, minus_zero, nan_value, IGNORE, INVALID_EXCEPTION);
6364   TEST_ffI_f1 (remquo, plus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
6365   TEST_ffI_f1 (remquo, minus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
6366   TEST_ffI_f1 (remquo, nan_value, nan_value, nan_value, IGNORE);
6367
6368   TEST_ffI_f1 (remquo, 1.625, 1.0, -0.375, 2);
6369   TEST_ffI_f1 (remquo, -1.625, 1.0, 0.375, -2);
6370   TEST_ffI_f1 (remquo, 1.625, -1.0, -0.375, -2);
6371   TEST_ffI_f1 (remquo, -1.625, -1.0, 0.375, 2);
6372
6373   TEST_ffI_f1 (remquo, 5, 2, 1, 2);
6374   TEST_ffI_f1 (remquo, 3, 2, -1, 2);
6375
6376   END (remquo);
6377 }
6378
6379 static void
6380 rint_test (void)
6381 {
6382   START (rint);
6383
6384   TEST_f_f (rint, 0.0, 0.0);
6385   TEST_f_f (rint, minus_zero, minus_zero);
6386   TEST_f_f (rint, plus_infty, plus_infty);
6387   TEST_f_f (rint, minus_infty, minus_infty);
6388
6389   /* Default rounding mode is round to even.  */
6390   TEST_f_f (rint, 0.5, 0.0);
6391   TEST_f_f (rint, 1.5, 2.0);
6392   TEST_f_f (rint, 2.5, 2.0);
6393   TEST_f_f (rint, 3.5, 4.0);
6394   TEST_f_f (rint, 4.5, 4.0);
6395   TEST_f_f (rint, -0.5, -0.0);
6396   TEST_f_f (rint, -1.5, -2.0);
6397   TEST_f_f (rint, -2.5, -2.0);
6398   TEST_f_f (rint, -3.5, -4.0);
6399   TEST_f_f (rint, -4.5, -4.0);
6400   TEST_f_f (rint, 0.1, 0.0);
6401   TEST_f_f (rint, 0.25, 0.0);
6402   TEST_f_f (rint, 0.625, 1.0);
6403   TEST_f_f (rint, -0.1, -0.0);
6404   TEST_f_f (rint, -0.25, -0.0);
6405   TEST_f_f (rint, -0.625, -1.0);
6406   TEST_f_f (rint, 262144.75, 262145.0);
6407   TEST_f_f (rint, 262142.75, 262143.0);
6408   TEST_f_f (rint, 524286.75, 524287.0);
6409   TEST_f_f (rint, 524288.75, 524289.0);
6410   TEST_f_f (rint, 1048576.75, 1048577.0);
6411   TEST_f_f (rint, 2097152.75, 2097153.0);
6412   TEST_f_f (rint, -1048576.75, -1048577.0);
6413   TEST_f_f (rint, -2097152.75, -2097153.0);
6414 #ifndef TEST_FLOAT
6415   TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
6416   TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
6417   TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
6418   TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
6419   TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
6420   TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
6421   TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
6422   TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
6423   TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
6424   TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
6425 #endif
6426 #ifdef TEST_LDOUBLE
6427   /* The result can only be represented in long double.  */
6428   TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
6429   TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
6430   TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
6431   TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
6432   TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
6433
6434 # if LDBL_MANT_DIG > 100
6435   TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
6436   TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
6437   TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
6438 # endif
6439
6440   TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
6441   TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
6442   TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
6443   TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
6444   TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
6445
6446 # if LDBL_MANT_DIG > 100
6447   TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
6448   TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
6449   TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
6450
6451   TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
6452   TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
6453   TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
6454   TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
6455   TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
6456   TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
6457
6458   TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
6459   TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
6460   TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
6461   TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
6462   TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
6463   TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
6464 # endif
6465
6466   TEST_f_f (rint, 9007199254740991.5L, 9007199254740992.0L);
6467   TEST_f_f (rint, 9007199254740992.25L, 9007199254740992.0L);
6468   TEST_f_f (rint, 9007199254740992.5L, 9007199254740992.0L);
6469   TEST_f_f (rint, 9007199254740992.75L, 9007199254740993.0L);
6470   TEST_f_f (rint, 9007199254740993.5L, 9007199254740994.0L);
6471
6472   TEST_f_f (rint, -9007199254740991.5L, -9007199254740992.0L);
6473   TEST_f_f (rint, -9007199254740992.25L, -9007199254740992.0L);
6474   TEST_f_f (rint, -9007199254740992.5L, -9007199254740992.0L);
6475   TEST_f_f (rint, -9007199254740992.75L, -9007199254740993.0L);
6476   TEST_f_f (rint, -9007199254740993.5L, -9007199254740994.0L);
6477
6478   TEST_f_f (rint, 72057594037927935.5L, 72057594037927936.0L);
6479   TEST_f_f (rint, 72057594037927936.25L, 72057594037927936.0L);
6480   TEST_f_f (rint, 72057594037927936.5L, 72057594037927936.0L);
6481   TEST_f_f (rint, 72057594037927936.75L, 72057594037927937.0L);
6482   TEST_f_f (rint, 72057594037927937.5L, 72057594037927938.0L);
6483
6484   TEST_f_f (rint, -72057594037927935.5L, -72057594037927936.0L);
6485   TEST_f_f (rint, -72057594037927936.25L, -72057594037927936.0L);
6486   TEST_f_f (rint, -72057594037927936.5L, -72057594037927936.0L);
6487   TEST_f_f (rint, -72057594037927936.75L, -72057594037927937.0L);
6488   TEST_f_f (rint, -72057594037927937.5L, -72057594037927938.0L);
6489
6490   TEST_f_f (rint, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
6491   TEST_f_f (rint, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
6492   TEST_f_f (rint, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
6493   TEST_f_f (rint, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
6494   TEST_f_f (rint, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
6495 #endif
6496
6497   END (rint);
6498 }
6499
6500 static void
6501 rint_test_tonearest (void)
6502 {
6503   int save_round_mode;
6504   START (rint_tonearest);
6505
6506   save_round_mode = fegetround ();
6507
6508   if (!fesetround (FE_TONEAREST))
6509     {
6510       TEST_f_f (rint, 2.0, 2.0);
6511       TEST_f_f (rint, 1.5, 2.0);
6512       TEST_f_f (rint, 1.0, 1.0);
6513       TEST_f_f (rint, 0.5, 0.0);
6514       TEST_f_f (rint, 0.0, 0.0);
6515       TEST_f_f (rint, minus_zero, minus_zero);
6516       TEST_f_f (rint, -0.5, -0.0);
6517       TEST_f_f (rint, -1.0, -1.0);
6518       TEST_f_f (rint, -1.5, -2.0);
6519       TEST_f_f (rint, -2.0, -2.0);
6520       TEST_f_f (rint, 0.1, 0.0);
6521       TEST_f_f (rint, 0.25, 0.0);
6522       TEST_f_f (rint, 0.625, 1.0);
6523       TEST_f_f (rint, -0.1, -0.0);
6524       TEST_f_f (rint, -0.25, -0.0);
6525       TEST_f_f (rint, -0.625, -1.0);
6526       TEST_f_f (rint, 1048576.75, 1048577.0);
6527       TEST_f_f (rint, 2097152.75, 2097153.0);
6528       TEST_f_f (rint, -1048576.75, -1048577.0);
6529       TEST_f_f (rint, -2097152.75, -2097153.0);
6530 #ifndef TEST_FLOAT
6531       TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
6532       TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
6533       TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
6534       TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
6535       TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
6536       TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
6537       TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
6538       TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
6539       TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
6540       TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
6541 #endif
6542 #ifdef TEST_LDOUBLE
6543       /* The result can only be represented in long double.  */
6544       TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
6545       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
6546       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
6547       TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
6548       TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
6549 # if LDBL_MANT_DIG > 100
6550       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
6551       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
6552       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
6553 # endif
6554       TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
6555       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
6556       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
6557       TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
6558       TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
6559 # if LDBL_MANT_DIG > 100
6560       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
6561       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
6562       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
6563
6564       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
6565       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
6566       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
6567       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
6568       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
6569       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
6570
6571       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
6572       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
6573       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
6574       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
6575       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
6576       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
6577 # endif
6578 #endif
6579     }
6580
6581   fesetround (save_round_mode);
6582
6583   END (rint_tonearest);
6584 }
6585
6586 static void
6587 rint_test_towardzero (void)
6588 {
6589   int save_round_mode;
6590   START (rint_towardzero);
6591
6592   save_round_mode = fegetround ();
6593
6594   if (!fesetround (FE_TOWARDZERO))
6595     {
6596       TEST_f_f (rint, 2.0, 2.0);
6597       TEST_f_f (rint, 1.5, 1.0);
6598       TEST_f_f (rint, 1.0, 1.0);
6599       TEST_f_f (rint, 0.5, 0.0);
6600       TEST_f_f (rint, 0.0, 0.0);
6601       TEST_f_f (rint, minus_zero, minus_zero);
6602       TEST_f_f (rint, -0.5, -0.0);
6603       TEST_f_f (rint, -1.0, -1.0);
6604       TEST_f_f (rint, -1.5, -1.0);
6605       TEST_f_f (rint, -2.0, -2.0);
6606       TEST_f_f (rint, 0.1, 0.0);
6607       TEST_f_f (rint, 0.25, 0.0);
6608       TEST_f_f (rint, 0.625, 0.0);
6609       TEST_f_f (rint, -0.1, -0.0);
6610       TEST_f_f (rint, -0.25, -0.0);
6611       TEST_f_f (rint, -0.625, -0.0);
6612       TEST_f_f (rint, 1048576.75, 1048576.0);
6613       TEST_f_f (rint, 2097152.75, 2097152.0);
6614       TEST_f_f (rint, -1048576.75, -1048576.0);
6615       TEST_f_f (rint, -2097152.75, -2097152.0);
6616 #ifndef TEST_FLOAT
6617       TEST_f_f (rint, 70368744177664.75, 70368744177664.0);
6618       TEST_f_f (rint, 140737488355328.75, 140737488355328.0);
6619       TEST_f_f (rint, 281474976710656.75, 281474976710656.0);
6620       TEST_f_f (rint, 562949953421312.75, 562949953421312.0);
6621       TEST_f_f (rint, 1125899906842624.75, 1125899906842624.0);
6622       TEST_f_f (rint, -70368744177664.75, -70368744177664.0);
6623       TEST_f_f (rint, -140737488355328.75, -140737488355328.0);
6624       TEST_f_f (rint, -281474976710656.75, -281474976710656.0);
6625       TEST_f_f (rint, -562949953421312.75, -562949953421312.0);
6626       TEST_f_f (rint, -1125899906842624.75, -1125899906842624.0);
6627 #endif
6628 #ifdef TEST_LDOUBLE
6629       /* The result can only be represented in long double.  */
6630       TEST_f_f (rint, 4503599627370495.5L, 4503599627370495.0L);
6631       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
6632       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
6633       TEST_f_f (rint, 4503599627370496.75L, 4503599627370496.0L);
6634       TEST_f_f (rint, 4503599627370497.5L, 4503599627370497.0L);
6635 # if LDBL_MANT_DIG > 100
6636       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370494.0L);
6637       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370495.0L);
6638       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370496.0L);
6639 # endif
6640       TEST_f_f (rint, -4503599627370495.5L, -4503599627370495.0L);
6641       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
6642       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
6643       TEST_f_f (rint, -4503599627370496.75L, -4503599627370496.0L);
6644       TEST_f_f (rint, -4503599627370497.5L, -4503599627370497.0L);
6645 # if LDBL_MANT_DIG > 100
6646       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370494.0L);
6647       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370495.0L);
6648       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370496.0L);
6649
6650       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
6651       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
6652       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
6653       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740991.0L);
6654       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740992.0L);
6655       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740993.0L);
6656
6657       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
6658       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
6659       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
6660       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740991.0L);
6661       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740992.0L);
6662       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L);
6663 # endif
6664 #endif
6665     }
6666
6667   fesetround (save_round_mode);
6668
6669   END (rint_towardzero);
6670 }
6671
6672 static void
6673 rint_test_downward (void)
6674 {
6675   int save_round_mode;
6676   START (rint_downward);
6677
6678   save_round_mode = fegetround ();
6679
6680   if (!fesetround (FE_DOWNWARD))
6681     {
6682       TEST_f_f (rint, 2.0, 2.0);
6683       TEST_f_f (rint, 1.5, 1.0);
6684       TEST_f_f (rint, 1.0, 1.0);
6685       TEST_f_f (rint, 0.5, 0.0);
6686       TEST_f_f (rint, 0.0, 0.0);
6687       TEST_f_f (rint, minus_zero, minus_zero);
6688       TEST_f_f (rint, -0.5, -1.0);
6689       TEST_f_f (rint, -1.0, -1.0);
6690       TEST_f_f (rint, -1.5, -2.0);
6691       TEST_f_f (rint, -2.0, -2.0);
6692       TEST_f_f (rint, 0.1, 0.0);
6693       TEST_f_f (rint, 0.25, 0.0);
6694       TEST_f_f (rint, 0.625, 0.0);
6695       TEST_f_f (rint, -0.1, -1.0);
6696       TEST_f_f (rint, -0.25, -1.0);
6697       TEST_f_f (rint, -0.625, -1.0);
6698       TEST_f_f (rint, 1048576.75, 1048576.0);
6699       TEST_f_f (rint, 2097152.75, 2097152.0);
6700       TEST_f_f (rint, -1048576.75, -1048577.0);
6701       TEST_f_f (rint, -2097152.75, -2097153.0);
6702 #ifndef TEST_FLOAT
6703       TEST_f_f (rint, 70368744177664.75, 70368744177664.0);
6704       TEST_f_f (rint, 140737488355328.75, 140737488355328.0);
6705       TEST_f_f (rint, 281474976710656.75, 281474976710656.0);
6706       TEST_f_f (rint, 562949953421312.75, 562949953421312.0);
6707       TEST_f_f (rint, 1125899906842624.75, 1125899906842624.0);
6708       TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
6709       TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
6710       TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
6711       TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
6712       TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
6713 #endif
6714 #ifdef TEST_LDOUBLE
6715       /* The result can only be represented in long double.  */
6716       TEST_f_f (rint, 4503599627370495.5L, 4503599627370495.0L);
6717       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
6718       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
6719       TEST_f_f (rint, 4503599627370496.75L, 4503599627370496.0L);
6720       TEST_f_f (rint, 4503599627370497.5L, 4503599627370497.0L);
6721 # if LDBL_MANT_DIG > 100
6722       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370494.0L);
6723       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370495.0L);
6724       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370496.0L);
6725 # endif
6726       TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
6727       TEST_f_f (rint, -4503599627370496.25L, -4503599627370497.0L);
6728       TEST_f_f (rint, -4503599627370496.5L, -4503599627370497.0L);
6729       TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
6730       TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
6731 # if LDBL_MANT_DIG > 100
6732       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
6733       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
6734       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
6735
6736       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
6737       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
6738       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
6739       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740991.0L);
6740       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740992.0L);
6741       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740993.0L);
6742
6743       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740992.0L);
6744       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740993.0L);
6745       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740994.0L);
6746       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
6747       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
6748       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
6749 # endif
6750 #endif
6751     }
6752
6753   fesetround (save_round_mode);
6754
6755   END (rint_downward);
6756 }
6757
6758 static void
6759 rint_test_upward (void)
6760 {
6761   int save_round_mode;
6762   START (rint_upward);
6763
6764   save_round_mode = fegetround ();
6765
6766   if (!fesetround (FE_UPWARD))
6767     {
6768       TEST_f_f (rint, 2.0, 2.0);
6769       TEST_f_f (rint, 1.5, 2.0);
6770       TEST_f_f (rint, 1.0, 1.0);
6771       TEST_f_f (rint, 0.5, 1.0);
6772       TEST_f_f (rint, 0.0, 0.0);
6773       TEST_f_f (rint, minus_zero, minus_zero);
6774       TEST_f_f (rint, -0.5, -0.0);
6775       TEST_f_f (rint, -1.0, -1.0);
6776       TEST_f_f (rint, -1.5, -1.0);
6777       TEST_f_f (rint, -2.0, -2.0);
6778       TEST_f_f (rint, 0.1, 1.0);
6779       TEST_f_f (rint, 0.25, 1.0);
6780       TEST_f_f (rint, 0.625, 1.0);
6781       TEST_f_f (rint, -0.1, -0.0);
6782       TEST_f_f (rint, -0.25, -0.0);
6783       TEST_f_f (rint, -0.625, -0.0);
6784       TEST_f_f (rint, 1048576.75, 1048577.0);
6785       TEST_f_f (rint, 2097152.75, 2097153.0);
6786       TEST_f_f (rint, -1048576.75, -1048576.0);
6787       TEST_f_f (rint, -2097152.75, -2097152.0);
6788 #ifndef TEST_FLOAT
6789       TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
6790       TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
6791       TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
6792       TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
6793       TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
6794       TEST_f_f (rint, -70368744177664.75, -70368744177664.0);
6795       TEST_f_f (rint, -140737488355328.75, -140737488355328.0);
6796       TEST_f_f (rint, -281474976710656.75, -281474976710656.0);
6797       TEST_f_f (rint, -562949953421312.75, -562949953421312.0);
6798       TEST_f_f (rint, -1125899906842624.75, -1125899906842624.0);
6799 #endif
6800 #ifdef TEST_LDOUBLE
6801       /* The result can only be represented in long double.  */
6802       TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
6803       TEST_f_f (rint, 4503599627370496.25L, 4503599627370497.0L);
6804       TEST_f_f (rint, 4503599627370496.5L, 4503599627370497.0L);
6805       TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
6806       TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
6807 # if LDBL_MANT_DIG > 100
6808       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
6809       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
6810       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
6811 # endif
6812       TEST_f_f (rint, -4503599627370495.5L, -4503599627370495.0L);
6813       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
6814       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
6815       TEST_f_f (rint, -4503599627370496.75L, -4503599627370496.0L);
6816       TEST_f_f (rint, -4503599627370497.5L, -4503599627370497.0L);
6817 # if LDBL_MANT_DIG > 100
6818       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370494.0L);
6819       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370495.0L);
6820       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370496.0L);
6821
6822       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740992.0L);
6823       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740993.0L);
6824       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740994.0L);
6825       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
6826       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
6827       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
6828
6829       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
6830       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
6831       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
6832       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740991.0L);
6833       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740992.0L);
6834       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L);
6835 # endif
6836 #endif
6837     }
6838
6839   fesetround (save_round_mode);
6840
6841   END (rint_upward);
6842 }
6843
6844 static void
6845 round_test (void)
6846 {
6847   START (round);
6848
6849   TEST_f_f (round, 0, 0);
6850   TEST_f_f (round, minus_zero, minus_zero);
6851   TEST_f_f (round, 0.2L, 0.0);
6852   TEST_f_f (round, -0.2L, minus_zero);
6853   TEST_f_f (round, 0.5, 1.0);
6854   TEST_f_f (round, -0.5, -1.0);
6855   TEST_f_f (round, 0.8L, 1.0);
6856   TEST_f_f (round, -0.8L, -1.0);
6857   TEST_f_f (round, 1.5, 2.0);
6858   TEST_f_f (round, -1.5, -2.0);
6859   TEST_f_f (round, 0.1, 0.0);
6860   TEST_f_f (round, 0.25, 0.0);
6861   TEST_f_f (round, 0.625, 1.0);
6862   TEST_f_f (round, -0.1, -0.0);
6863   TEST_f_f (round, -0.25, -0.0);
6864   TEST_f_f (round, -0.625, -1.0);
6865   TEST_f_f (round, 2097152.5, 2097153);
6866   TEST_f_f (round, -2097152.5, -2097153);
6867
6868 #ifdef TEST_LDOUBLE
6869   /* The result can only be represented in long double.  */
6870   TEST_f_f (round, 4503599627370495.5L, 4503599627370496.0L);
6871   TEST_f_f (round, 4503599627370496.25L, 4503599627370496.0L);
6872   TEST_f_f (round, 4503599627370496.5L, 4503599627370497.0L);
6873   TEST_f_f (round, 4503599627370496.75L, 4503599627370497.0L);
6874   TEST_f_f (round, 4503599627370497.5L, 4503599627370498.0L);
6875 # if LDBL_MANT_DIG > 100
6876   TEST_f_f (round, 4503599627370494.5000000000001L, 4503599627370495.0L);
6877   TEST_f_f (round, 4503599627370495.5000000000001L, 4503599627370496.0L);
6878   TEST_f_f (round, 4503599627370496.5000000000001L, 4503599627370497.0L);
6879 # endif
6880
6881   TEST_f_f (round, -4503599627370495.5L, -4503599627370496.0L);
6882   TEST_f_f (round, -4503599627370496.25L, -4503599627370496.0L);
6883   TEST_f_f (round, -4503599627370496.5L, -4503599627370497.0L);
6884   TEST_f_f (round, -4503599627370496.75L, -4503599627370497.0L);
6885   TEST_f_f (round, -4503599627370497.5L, -4503599627370498.0L);
6886 # if LDBL_MANT_DIG > 100
6887   TEST_f_f (round, -4503599627370494.5000000000001L, -4503599627370495.0L);
6888   TEST_f_f (round, -4503599627370495.5000000000001L, -4503599627370496.0L);
6889   TEST_f_f (round, -4503599627370496.5000000000001L, -4503599627370497.0L);
6890 # endif
6891
6892   TEST_f_f (round, 9007199254740991.5L, 9007199254740992.0L);
6893   TEST_f_f (round, 9007199254740992.25L, 9007199254740992.0L);
6894   TEST_f_f (round, 9007199254740992.5L, 9007199254740993.0L);
6895   TEST_f_f (round, 9007199254740992.75L, 9007199254740993.0L);
6896   TEST_f_f (round, 9007199254740993.5L, 9007199254740994.0L);
6897
6898   TEST_f_f (round, -9007199254740991.5L, -9007199254740992.0L);
6899   TEST_f_f (round, -9007199254740992.25L, -9007199254740992.0L);
6900   TEST_f_f (round, -9007199254740992.5L, -9007199254740993.0L);
6901   TEST_f_f (round, -9007199254740992.75L, -9007199254740993.0L);
6902   TEST_f_f (round, -9007199254740993.5L, -9007199254740994.0L);
6903
6904 # if LDBL_MANT_DIG > 100
6905   TEST_f_f (round, 9007199254740991.0000000000001L, 9007199254740991.0L);
6906   TEST_f_f (round, 9007199254740992.0000000000001L, 9007199254740992.0L);
6907   TEST_f_f (round, 9007199254740993.0000000000001L, 9007199254740993.0L);
6908   TEST_f_f (round, 9007199254740991.5000000000001L, 9007199254740992.0L);
6909   TEST_f_f (round, 9007199254740992.5000000000001L, 9007199254740993.0L);
6910   TEST_f_f (round, 9007199254740993.5000000000001L, 9007199254740994.0L);
6911
6912   TEST_f_f (round, -9007199254740991.0000000000001L, -9007199254740991.0L);
6913   TEST_f_f (round, -9007199254740992.0000000000001L, -9007199254740992.0L);
6914   TEST_f_f (round, -9007199254740993.0000000000001L, -9007199254740993.0L);
6915   TEST_f_f (round, -9007199254740991.5000000000001L, -9007199254740992.0L);
6916   TEST_f_f (round, -9007199254740992.5000000000001L, -9007199254740993.0L);
6917   TEST_f_f (round, -9007199254740993.5000000000001L, -9007199254740994.0L);
6918 # endif
6919
6920   TEST_f_f (round, 72057594037927935.5L, 72057594037927936.0L);
6921   TEST_f_f (round, 72057594037927936.25L, 72057594037927936.0L);
6922   TEST_f_f (round, 72057594037927936.5L, 72057594037927937.0L);
6923   TEST_f_f (round, 72057594037927936.75L, 72057594037927937.0L);
6924   TEST_f_f (round, 72057594037927937.5L, 72057594037927938.0L);
6925
6926   TEST_f_f (round, -72057594037927935.5L, -72057594037927936.0L);
6927   TEST_f_f (round, -72057594037927936.25L, -72057594037927936.0L);
6928   TEST_f_f (round, -72057594037927936.5L, -72057594037927937.0L);
6929   TEST_f_f (round, -72057594037927936.75L, -72057594037927937.0L);
6930   TEST_f_f (round, -72057594037927937.5L, -72057594037927938.0L);
6931
6932   TEST_f_f (round, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
6933   TEST_f_f (round, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
6934   TEST_f_f (round, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
6935   TEST_f_f (round, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
6936   TEST_f_f (round, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
6937 #endif
6938
6939   END (round);
6940 }
6941
6942
6943 static void
6944 scalb_test (void)
6945 {
6946
6947   START (scalb);
6948
6949   TEST_ff_f (scalb, 2.0, 0.5, nan_value, INVALID_EXCEPTION);
6950   TEST_ff_f (scalb, 3.0, -2.5, nan_value, INVALID_EXCEPTION);
6951
6952   TEST_ff_f (scalb, 0, nan_value, nan_value);
6953   TEST_ff_f (scalb, 1, nan_value, nan_value);
6954
6955   TEST_ff_f (scalb, 1, 0, 1);
6956   TEST_ff_f (scalb, -1, 0, -1);
6957
6958   TEST_ff_f (scalb, 0, plus_infty, nan_value, INVALID_EXCEPTION);
6959   TEST_ff_f (scalb, minus_zero, plus_infty, nan_value, INVALID_EXCEPTION);
6960
6961   TEST_ff_f (scalb, 0, 2, 0);
6962   TEST_ff_f (scalb, minus_zero, -4, minus_zero);
6963   TEST_ff_f (scalb, 0, 0, 0);
6964   TEST_ff_f (scalb, minus_zero, 0, minus_zero);
6965   TEST_ff_f (scalb, 0, -1, 0);
6966   TEST_ff_f (scalb, minus_zero, -10, minus_zero);
6967   TEST_ff_f (scalb, 0, minus_infty, 0);
6968   TEST_ff_f (scalb, minus_zero, minus_infty, minus_zero);
6969
6970   TEST_ff_f (scalb, plus_infty, -1, plus_infty);
6971   TEST_ff_f (scalb, minus_infty, -10, minus_infty);
6972   TEST_ff_f (scalb, plus_infty, 0, plus_infty);
6973   TEST_ff_f (scalb, minus_infty, 0, minus_infty);
6974   TEST_ff_f (scalb, plus_infty, 2, plus_infty);
6975   TEST_ff_f (scalb, minus_infty, 100, minus_infty);
6976
6977   TEST_ff_f (scalb, 0.1L, minus_infty, 0.0);
6978   TEST_ff_f (scalb, -0.1L, minus_infty, minus_zero);
6979
6980   TEST_ff_f (scalb, 1, plus_infty, plus_infty);
6981   TEST_ff_f (scalb, -1, plus_infty, minus_infty);
6982   TEST_ff_f (scalb, plus_infty, plus_infty, plus_infty);
6983   TEST_ff_f (scalb, minus_infty, plus_infty, minus_infty);
6984
6985   TEST_ff_f (scalb, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
6986   TEST_ff_f (scalb, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
6987
6988   TEST_ff_f (scalb, nan_value, 1, nan_value);
6989   TEST_ff_f (scalb, 1, nan_value, nan_value);
6990   TEST_ff_f (scalb, nan_value, 0, nan_value);
6991   TEST_ff_f (scalb, 0, nan_value, nan_value);
6992   TEST_ff_f (scalb, nan_value, plus_infty, nan_value);
6993   TEST_ff_f (scalb, plus_infty, nan_value, nan_value);
6994   TEST_ff_f (scalb, nan_value, nan_value, nan_value);
6995
6996   TEST_ff_f (scalb, 0.8L, 4, 12.8L);
6997   TEST_ff_f (scalb, -0.854375L, 5, -27.34L);
6998
6999   END (scalb);
7000 }
7001
7002
7003 static void
7004 scalbn_test (void)
7005 {
7006
7007   START (scalbn);
7008
7009   TEST_fi_f (scalbn, 0, 0, 0);
7010   TEST_fi_f (scalbn, minus_zero, 0, minus_zero);
7011
7012   TEST_fi_f (scalbn, plus_infty, 1, plus_infty);
7013   TEST_fi_f (scalbn, minus_infty, 1, minus_infty);
7014   TEST_fi_f (scalbn, nan_value, 1, nan_value);
7015
7016   TEST_fi_f (scalbn, 0.8L, 4, 12.8L);
7017   TEST_fi_f (scalbn, -0.854375L, 5, -27.34L);
7018
7019   TEST_fi_f (scalbn, 1, 0L, 1);
7020
7021   TEST_fi_f (scalbn, 1, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
7022   TEST_fi_f (scalbn, 1, INT_MIN, plus_zero);
7023   TEST_fi_f (scalbn, max_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
7024   TEST_fi_f (scalbn, max_value, INT_MIN, plus_zero);
7025   TEST_fi_f (scalbn, min_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
7026   TEST_fi_f (scalbn, min_value, INT_MIN, plus_zero);
7027   TEST_fi_f (scalbn, min_value / 4, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
7028   TEST_fi_f (scalbn, min_value / 4, INT_MIN, plus_zero);
7029
7030   END (scalbn);
7031 }
7032
7033
7034 static void
7035 scalbln_test (void)
7036 {
7037
7038   START (scalbln);
7039
7040   TEST_fl_f (scalbln, 0, 0, 0);
7041   TEST_fl_f (scalbln, minus_zero, 0, minus_zero);
7042
7043   TEST_fl_f (scalbln, plus_infty, 1, plus_infty);
7044   TEST_fl_f (scalbln, minus_infty, 1, minus_infty);
7045   TEST_fl_f (scalbln, nan_value, 1, nan_value);
7046
7047   TEST_fl_f (scalbln, 0.8L, 4, 12.8L);
7048   TEST_fl_f (scalbln, -0.854375L, 5, -27.34L);
7049
7050   TEST_fl_f (scalbln, 1, 0L, 1);
7051
7052   TEST_fi_f (scalbln, 1, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
7053   TEST_fi_f (scalbln, 1, INT_MIN, plus_zero);
7054   TEST_fi_f (scalbln, max_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
7055   TEST_fi_f (scalbln, max_value, INT_MIN, plus_zero);
7056   TEST_fi_f (scalbln, min_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
7057   TEST_fi_f (scalbln, min_value, INT_MIN, plus_zero);
7058   TEST_fi_f (scalbln, min_value / 4, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
7059   TEST_fi_f (scalbln, min_value / 4, INT_MIN, plus_zero);
7060
7061   TEST_fi_f (scalbln, 1, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
7062   TEST_fi_f (scalbln, 1, LONG_MIN, plus_zero);
7063   TEST_fi_f (scalbln, max_value, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
7064   TEST_fi_f (scalbln, max_value, LONG_MIN, plus_zero);
7065   TEST_fi_f (scalbln, min_value, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
7066   TEST_fi_f (scalbln, min_value, LONG_MIN, plus_zero);
7067   TEST_fi_f (scalbln, min_value / 4, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
7068   TEST_fi_f (scalbln, min_value / 4, LONG_MIN, plus_zero);
7069
7070 #if LONG_MAX >= 0x100000000
7071   TEST_fi_f (scalbln, 1, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
7072   TEST_fi_f (scalbln, 1, -0x88000000L, plus_zero);
7073   TEST_fi_f (scalbln, max_value, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
7074   TEST_fi_f (scalbln, max_value, -0x88000000L, plus_zero);
7075   TEST_fi_f (scalbln, min_value, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
7076   TEST_fi_f (scalbln, min_value, -0x88000000L, plus_zero);
7077   TEST_fi_f (scalbln, min_value / 4, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
7078   TEST_fi_f (scalbln, min_value / 4, -0x88000000L, plus_zero);
7079 #endif
7080
7081   END (scalbn);
7082 }
7083
7084
7085 static void
7086 signbit_test (void)
7087 {
7088
7089   START (signbit);
7090
7091   TEST_f_b (signbit, 0, 0);
7092   TEST_f_b (signbit, minus_zero, 1);
7093   TEST_f_b (signbit, plus_infty, 0);
7094   TEST_f_b (signbit, minus_infty, 1);
7095
7096   /* signbit (x) != 0 for x < 0.  */
7097   TEST_f_b (signbit, -1, 1);
7098   /* signbit (x) == 0 for x >= 0.  */
7099   TEST_f_b (signbit, 1, 0);
7100
7101   END (signbit);
7102 }
7103
7104
7105 static void
7106 sin_test (void)
7107 {
7108   errno = 0;
7109   FUNC(sin) (0);
7110   if (errno == ENOSYS)
7111     /* Function not implemented.  */
7112     return;
7113
7114   START (sin);
7115
7116   TEST_f_f (sin, 0, 0);
7117   TEST_f_f (sin, minus_zero, minus_zero);
7118   errno = 0;
7119   TEST_f_f (sin, plus_infty, nan_value, INVALID_EXCEPTION);
7120   check_int ("errno for sin(+inf) == EDOM", errno, EDOM, 0, 0, 0);
7121   errno = 0;
7122   TEST_f_f (sin, minus_infty, nan_value, INVALID_EXCEPTION);
7123   check_int ("errno for sin(-inf) == EDOM", errno, EDOM, 0, 0, 0);
7124   errno = 0;
7125   TEST_f_f (sin, nan_value, nan_value);
7126   check_int ("errno for sin(NaN) unchanged", errno, 0, 0, 0, 0);
7127
7128   TEST_f_f (sin, M_PI_6l, 0.5);
7129   TEST_f_f (sin, -M_PI_6l, -0.5);
7130   TEST_f_f (sin, M_PI_2l, 1);
7131   TEST_f_f (sin, -M_PI_2l, -1);
7132   TEST_f_f (sin, 0.75L, 0.681638760023334166733241952779893935L);
7133
7134   TEST_f_f (sin, 0x1p65, -0.047183876212354673805106149805700013943218L);
7135   TEST_f_f (sin, -0x1p65, 0.047183876212354673805106149805700013943218L);
7136
7137 #ifdef TEST_DOUBLE
7138   TEST_f_f (sin, 0.80190127184058835, 0.71867942238767868);
7139   TEST_f_f (sin, 2.522464e-1, 2.4957989804940911e-1);
7140 #endif
7141
7142 #ifndef TEST_FLOAT
7143   TEST_f_f (sin, 1e22, -0.8522008497671888017727058937530293682618L);
7144   TEST_f_f (sin, 0x1p1023, 0.5631277798508840134529434079444683477104L);
7145 #endif
7146
7147 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
7148   TEST_f_f (sin, 0x1p16383L, 0.3893629985894208126948115852610595405563L);
7149 #endif
7150
7151   END (sin);
7152
7153 }
7154
7155
7156 static void
7157 sin_test_tonearest (void)
7158 {
7159   int save_round_mode;
7160   errno = 0;
7161   FUNC(sin) (0);
7162   if (errno == ENOSYS)
7163     /* Function not implemented.  */
7164     return;
7165
7166   START (sin_tonearest);
7167
7168   save_round_mode = fegetround ();
7169
7170   if (!fesetround (FE_TONEAREST))
7171     {
7172       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
7173       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
7174       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
7175       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
7176       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
7177       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
7178       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
7179       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
7180       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
7181       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
7182     }
7183
7184   fesetround (save_round_mode);
7185
7186   END (sin_tonearest);
7187 }
7188
7189
7190 static void
7191 sin_test_towardzero (void)
7192 {
7193   int save_round_mode;
7194   errno = 0;
7195   FUNC(sin) (0);
7196   if (errno == ENOSYS)
7197     /* Function not implemented.  */
7198     return;
7199
7200   START (sin_towardzero);
7201
7202   save_round_mode = fegetround ();
7203
7204   if (!fesetround (FE_TOWARDZERO))
7205     {
7206       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
7207       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
7208       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
7209       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
7210       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
7211       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
7212       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
7213       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
7214       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
7215       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
7216     }
7217
7218   fesetround (save_round_mode);
7219
7220   END (sin_towardzero);
7221 }
7222
7223
7224 static void
7225 sin_test_downward (void)
7226 {
7227   int save_round_mode;
7228   errno = 0;
7229   FUNC(sin) (0);
7230   if (errno == ENOSYS)
7231     /* Function not implemented.  */
7232     return;
7233
7234   START (sin_downward);
7235
7236   save_round_mode = fegetround ();
7237
7238   if (!fesetround (FE_DOWNWARD))
7239     {
7240       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
7241       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
7242       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
7243       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
7244       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
7245       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
7246       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
7247       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
7248       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
7249       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
7250     }
7251
7252   fesetround (save_round_mode);
7253
7254   END (sin_downward);
7255 }
7256
7257
7258 static void
7259 sin_test_upward (void)
7260 {
7261   int save_round_mode;
7262   errno = 0;
7263   FUNC(sin) (0);
7264   if (errno == ENOSYS)
7265     /* Function not implemented.  */
7266     return;
7267
7268   START (sin_upward);
7269
7270   save_round_mode = fegetround ();
7271
7272   if (!fesetround (FE_UPWARD))
7273     {
7274       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
7275       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
7276       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
7277       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
7278       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
7279       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
7280       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
7281       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
7282       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
7283       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
7284     }
7285
7286   fesetround (save_round_mode);
7287
7288   END (sin_upward);
7289 }
7290
7291
7292 static void
7293 sincos_test (void)
7294 {
7295   FLOAT sin_res, cos_res;
7296
7297   errno = 0;
7298   FUNC(sincos) (0, &sin_res, &cos_res);
7299   if (errno == ENOSYS)
7300     /* Function not implemented.  */
7301     return;
7302
7303   START (sincos);
7304
7305   /* sincos is treated differently because it returns void.  */
7306   TEST_extra (sincos, 0, 0, 1);
7307
7308   TEST_extra (sincos, minus_zero, minus_zero, 1);
7309   TEST_extra (sincos, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
7310   TEST_extra (sincos, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
7311   TEST_extra (sincos, nan_value, nan_value, nan_value);
7312
7313   TEST_extra (sincos, M_PI_2l, 1, 0);
7314   TEST_extra (sincos, M_PI_6l, 0.5, 0.86602540378443864676372317075293616L);
7315   TEST_extra (sincos, M_PI_6l*2.0, 0.86602540378443864676372317075293616L, 0.5);
7316   TEST_extra (sincos, 0.75L, 0.681638760023334166733241952779893935L, 0.731688868873820886311838753000084544L);
7317
7318   TEST_extra (sincos, 0x1p65, -0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L);
7319   TEST_extra (sincos, -0x1p65, 0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L);
7320
7321 #ifdef TEST_DOUBLE
7322   TEST_extra (sincos, 0.80190127184058835, 0.71867942238767868, 0.69534156199418473);
7323 #endif
7324
7325 #ifndef TEST_FLOAT
7326   TEST_extra (sincos, 1e22, -0.8522008497671888017727058937530293682618L, 0.5232147853951389454975944733847094921409L);
7327   TEST_extra (sincos, 0x1p1023, 0.5631277798508840134529434079444683477104L, -0.826369834614147994500785680811743734805L);
7328 #endif
7329
7330 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
7331   TEST_extra (sincos, 0x1p16383L, 0.3893629985894208126948115852610595405563L, 0.9210843909921906206874509522505756251609L);
7332 #endif
7333
7334   END (sincos);
7335 }
7336
7337 static void
7338 sinh_test (void)
7339 {
7340   errno = 0;
7341   FUNC(sinh) (0.7L);
7342   if (errno == ENOSYS)
7343     /* Function not implemented.  */
7344     return;
7345
7346   START (sinh);
7347   TEST_f_f (sinh, 0, 0);
7348   TEST_f_f (sinh, minus_zero, minus_zero);
7349
7350 #ifndef TEST_INLINE
7351   TEST_f_f (sinh, plus_infty, plus_infty);
7352   TEST_f_f (sinh, minus_infty, minus_infty);
7353 #endif
7354   TEST_f_f (sinh, nan_value, nan_value);
7355
7356   TEST_f_f (sinh, 0.75L, 0.822316731935829980703661634446913849L);
7357   TEST_f_f (sinh, 0x8p-32L, 1.86264514923095703232705808926175479e-9L);
7358
7359   END (sinh);
7360 }
7361
7362
7363 static void
7364 sinh_test_tonearest (void)
7365 {
7366   int save_round_mode;
7367   errno = 0;
7368   FUNC(sinh) (0);
7369   if (errno == ENOSYS)
7370     /* Function not implemented.  */
7371     return;
7372
7373   START (sinh_tonearest);
7374
7375   save_round_mode = fegetround ();
7376
7377   if (!fesetround (FE_TONEAREST))
7378     {
7379       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
7380       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
7381       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
7382     }
7383
7384   fesetround (save_round_mode);
7385
7386   END (sinh_tonearest);
7387 }
7388
7389
7390 static void
7391 sinh_test_towardzero (void)
7392 {
7393   int save_round_mode;
7394   errno = 0;
7395   FUNC(sinh) (0);
7396   if (errno == ENOSYS)
7397     /* Function not implemented.  */
7398     return;
7399
7400   START (sinh_towardzero);
7401
7402   save_round_mode = fegetround ();
7403
7404   if (!fesetround (FE_TOWARDZERO))
7405     {
7406       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
7407       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
7408       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
7409     }
7410
7411   fesetround (save_round_mode);
7412
7413   END (sinh_towardzero);
7414 }
7415
7416
7417 static void
7418 sinh_test_downward (void)
7419 {
7420   int save_round_mode;
7421   errno = 0;
7422   FUNC(sinh) (0);
7423   if (errno == ENOSYS)
7424     /* Function not implemented.  */
7425     return;
7426
7427   START (sinh_downward);
7428
7429   save_round_mode = fegetround ();
7430
7431   if (!fesetround (FE_DOWNWARD))
7432     {
7433       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
7434       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
7435       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
7436     }
7437
7438   fesetround (save_round_mode);
7439
7440   END (sinh_downward);
7441 }
7442
7443
7444 static void
7445 sinh_test_upward (void)
7446 {
7447   int save_round_mode;
7448   errno = 0;
7449   FUNC(sinh) (0);
7450   if (errno == ENOSYS)
7451     /* Function not implemented.  */
7452     return;
7453
7454   START (sinh_upward);
7455
7456   save_round_mode = fegetround ();
7457
7458   if (!fesetround (FE_UPWARD))
7459     {
7460       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
7461       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
7462       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
7463     }
7464
7465   fesetround (save_round_mode);
7466
7467   END (sinh_upward);
7468 }
7469
7470
7471 static void
7472 sqrt_test (void)
7473 {
7474   errno = 0;
7475   FUNC(sqrt) (1);
7476   if (errno == ENOSYS)
7477     /* Function not implemented.  */
7478     return;
7479
7480   START (sqrt);
7481
7482   TEST_f_f (sqrt, 0, 0);
7483   TEST_f_f (sqrt, nan_value, nan_value);
7484   TEST_f_f (sqrt, plus_infty, plus_infty);
7485
7486   TEST_f_f (sqrt, minus_zero, minus_zero);
7487
7488   /* sqrt (x) == NaN plus invalid exception for x < 0.  */
7489   TEST_f_f (sqrt, -1, nan_value, INVALID_EXCEPTION);
7490   TEST_f_f (sqrt, -max_value, nan_value, INVALID_EXCEPTION);
7491   TEST_f_f (sqrt, minus_infty, nan_value, INVALID_EXCEPTION);
7492   TEST_f_f (sqrt, nan_value, nan_value);
7493
7494   TEST_f_f (sqrt, 2209, 47);
7495   TEST_f_f (sqrt, 4, 2);
7496   TEST_f_f (sqrt, 2, M_SQRT2l);
7497   TEST_f_f (sqrt, 0.25, 0.5);
7498   TEST_f_f (sqrt, 6642.25, 81.5);
7499   TEST_f_f (sqrt, 15190.5625L, 123.25L);
7500   TEST_f_f (sqrt, 0.75L, 0.866025403784438646763723170752936183L);
7501
7502   END (sqrt);
7503 }
7504
7505
7506 static void
7507 tan_test (void)
7508 {
7509   errno = 0;
7510   FUNC(tan) (0);
7511   if (errno == ENOSYS)
7512     /* Function not implemented.  */
7513     return;
7514
7515   START (tan);
7516
7517   TEST_f_f (tan, 0, 0);
7518   TEST_f_f (tan, minus_zero, minus_zero);
7519   errno = 0;
7520   TEST_f_f (tan, plus_infty, nan_value, INVALID_EXCEPTION);
7521   check_int ("errno for tan(Inf) == EDOM", errno, EDOM, 0, 0, 0);
7522   errno = 0;
7523   TEST_f_f (tan, minus_infty, nan_value, INVALID_EXCEPTION);
7524   check_int ("errno for tan(-Inf) == EDOM", errno, EDOM, 0, 0, 0);
7525   errno = 0;
7526   TEST_f_f (tan, nan_value, nan_value);
7527   check_int ("errno for tan(NaN) == 0", errno, 0, 0, 0, 0);
7528
7529   TEST_f_f (tan, M_PI_4l, 1);
7530   TEST_f_f (tan, 0.75L, 0.931596459944072461165202756573936428L);
7531
7532   TEST_f_f (tan, 0x1p65, -0.0472364872359047946798414219288370688827L);
7533   TEST_f_f (tan, -0x1p65, 0.0472364872359047946798414219288370688827L);
7534
7535 #ifndef TEST_FLOAT
7536   TEST_f_f (tan, 1e22, -1.628778225606898878549375936939548513545L);
7537   TEST_f_f (tan, 0x1p1023, -0.6814476476066215012854144040167365190368L);
7538 #endif
7539
7540 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
7541   TEST_f_f (tan, 0x1p16383L, 0.422722393732022337800504160054440141575L);
7542 #endif
7543
7544   END (tan);
7545 }
7546
7547
7548 static void
7549 tan_test_tonearest (void)
7550 {
7551   int save_round_mode;
7552   errno = 0;
7553   FUNC(tan) (0);
7554   if (errno == ENOSYS)
7555     /* Function not implemented.  */
7556     return;
7557
7558   START (tan_tonearest);
7559
7560   save_round_mode = fegetround ();
7561
7562   if (!fesetround (FE_TONEAREST))
7563     {
7564       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
7565       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
7566       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
7567       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
7568       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
7569       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
7570       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
7571       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
7572       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
7573       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
7574     }
7575
7576   fesetround (save_round_mode);
7577
7578   END (tan_tonearest);
7579 }
7580
7581
7582 static void
7583 tan_test_towardzero (void)
7584 {
7585   int save_round_mode;
7586   errno = 0;
7587   FUNC(tan) (0);
7588   if (errno == ENOSYS)
7589     /* Function not implemented.  */
7590     return;
7591
7592   START (tan_towardzero);
7593
7594   save_round_mode = fegetround ();
7595
7596   if (!fesetround (FE_TOWARDZERO))
7597     {
7598       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
7599       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
7600       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
7601       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
7602       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
7603       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
7604       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
7605       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
7606       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
7607       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
7608     }
7609
7610   fesetround (save_round_mode);
7611
7612   END (tan_towardzero);
7613 }
7614
7615
7616 static void
7617 tan_test_downward (void)
7618 {
7619   int save_round_mode;
7620   errno = 0;
7621   FUNC(tan) (0);
7622   if (errno == ENOSYS)
7623     /* Function not implemented.  */
7624     return;
7625
7626   START (tan_downward);
7627
7628   save_round_mode = fegetround ();
7629
7630   if (!fesetround (FE_DOWNWARD))
7631     {
7632       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
7633       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
7634       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
7635       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
7636       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
7637       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
7638       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
7639       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
7640       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
7641       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
7642     }
7643
7644   fesetround (save_round_mode);
7645
7646   END (tan_downward);
7647 }
7648
7649
7650 static void
7651 tan_test_upward (void)
7652 {
7653   int save_round_mode;
7654   errno = 0;
7655   FUNC(tan) (0);
7656   if (errno == ENOSYS)
7657     /* Function not implemented.  */
7658     return;
7659
7660   START (tan_upward);
7661
7662   save_round_mode = fegetround ();
7663
7664   if (!fesetround (FE_UPWARD))
7665     {
7666       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
7667       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
7668       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
7669       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
7670       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
7671       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
7672       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
7673       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
7674       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
7675       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
7676     }
7677
7678   fesetround (save_round_mode);
7679
7680   END (tan_upward);
7681 }
7682
7683
7684 static void
7685 tanh_test (void)
7686 {
7687   errno = 0;
7688   FUNC(tanh) (0.7L);
7689   if (errno == ENOSYS)
7690     /* Function not implemented.  */
7691     return;
7692
7693   START (tanh);
7694
7695   TEST_f_f (tanh, 0, 0);
7696   TEST_f_f (tanh, minus_zero, minus_zero);
7697
7698 #ifndef TEST_INLINE
7699   TEST_f_f (tanh, plus_infty, 1);
7700   TEST_f_f (tanh, minus_infty, -1);
7701 #endif
7702   TEST_f_f (tanh, nan_value, nan_value);
7703
7704   TEST_f_f (tanh, 0.75L, 0.635148952387287319214434357312496495L);
7705   TEST_f_f (tanh, -0.75L, -0.635148952387287319214434357312496495L);
7706
7707   TEST_f_f (tanh, 1.0L, 0.7615941559557648881194582826047935904L);
7708   TEST_f_f (tanh, -1.0L, -0.7615941559557648881194582826047935904L);
7709
7710   /* 2^-57  */
7711   TEST_f_f (tanh, 0x1p-57L, 6.938893903907228377647697925567626953125e-18L);
7712
7713   END (tanh);
7714 }
7715
7716 static void
7717 tgamma_test (void)
7718 {
7719   errno = 0;
7720   FUNC(tgamma) (1);
7721   if (errno == ENOSYS)
7722     /* Function not implemented.  */
7723     return;
7724   feclearexcept (FE_ALL_EXCEPT);
7725
7726   START (tgamma);
7727
7728   TEST_f_f (tgamma, plus_infty, plus_infty);
7729   TEST_f_f (tgamma, max_value, plus_infty, OVERFLOW_EXCEPTION);
7730   TEST_f_f (tgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7731   TEST_f_f (tgamma, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7732   /* tgamma (x) == NaN plus invalid exception for integer x <= 0.  */
7733   TEST_f_f (tgamma, -2, nan_value, INVALID_EXCEPTION);
7734   TEST_f_f (tgamma, -max_value, nan_value, INVALID_EXCEPTION);
7735   TEST_f_f (tgamma, minus_infty, nan_value, INVALID_EXCEPTION);
7736   TEST_f_f (tgamma, nan_value, nan_value);
7737
7738   TEST_f_f (tgamma, 0.5, M_SQRT_PIl);
7739   TEST_f_f (tgamma, -0.5, -M_2_SQRT_PIl);
7740
7741   TEST_f_f (tgamma, 1, 1);
7742   TEST_f_f (tgamma, 4, 6);
7743
7744   TEST_f_f (tgamma, 0.7L, 1.29805533264755778568117117915281162L);
7745   TEST_f_f (tgamma, 1.2L, 0.918168742399760610640951655185830401L);
7746
7747   END (tgamma);
7748 }
7749
7750
7751 static void
7752 trunc_test (void)
7753 {
7754   START (trunc);
7755
7756   TEST_f_f (trunc, plus_infty, plus_infty);
7757   TEST_f_f (trunc, minus_infty, minus_infty);
7758   TEST_f_f (trunc, nan_value, nan_value);
7759
7760   TEST_f_f (trunc, 0, 0);
7761   TEST_f_f (trunc, minus_zero, minus_zero);
7762   TEST_f_f (trunc, 0.1, 0);
7763   TEST_f_f (trunc, 0.25, 0);
7764   TEST_f_f (trunc, 0.625, 0);
7765   TEST_f_f (trunc, -0.1, minus_zero);
7766   TEST_f_f (trunc, -0.25, minus_zero);
7767   TEST_f_f (trunc, -0.625, minus_zero);
7768   TEST_f_f (trunc, 1, 1);
7769   TEST_f_f (trunc, -1, -1);
7770   TEST_f_f (trunc, 1.625, 1);
7771   TEST_f_f (trunc, -1.625, -1);
7772
7773   TEST_f_f (trunc, 1048580.625L, 1048580L);
7774   TEST_f_f (trunc, -1048580.625L, -1048580L);
7775
7776   TEST_f_f (trunc, 8388610.125L, 8388610.0L);
7777   TEST_f_f (trunc, -8388610.125L, -8388610.0L);
7778
7779   TEST_f_f (trunc, 4294967296.625L, 4294967296.0L);
7780   TEST_f_f (trunc, -4294967296.625L, -4294967296.0L);
7781
7782 #ifdef TEST_LDOUBLE
7783   /* The result can only be represented in long double.  */
7784   TEST_f_f (trunc, 4503599627370495.5L, 4503599627370495.0L);
7785   TEST_f_f (trunc, 4503599627370496.25L, 4503599627370496.0L);
7786   TEST_f_f (trunc, 4503599627370496.5L, 4503599627370496.0L);
7787   TEST_f_f (trunc, 4503599627370496.75L, 4503599627370496.0L);
7788   TEST_f_f (trunc, 4503599627370497.5L, 4503599627370497.0L);
7789
7790 # if LDBL_MANT_DIG > 100
7791   TEST_f_f (trunc, 4503599627370494.5000000000001L, 4503599627370494.0L);
7792   TEST_f_f (trunc, 4503599627370495.5000000000001L, 4503599627370495.0L);
7793   TEST_f_f (trunc, 4503599627370496.5000000000001L, 4503599627370496.0L);
7794 # endif
7795
7796   TEST_f_f (trunc, -4503599627370495.5L, -4503599627370495.0L);
7797   TEST_f_f (trunc, -4503599627370496.25L, -4503599627370496.0L);
7798   TEST_f_f (trunc, -4503599627370496.5L, -4503599627370496.0L);
7799   TEST_f_f (trunc, -4503599627370496.75L, -4503599627370496.0L);
7800   TEST_f_f (trunc, -4503599627370497.5L, -4503599627370497.0L);
7801
7802 # if LDBL_MANT_DIG > 100
7803   TEST_f_f (trunc, -4503599627370494.5000000000001L, -4503599627370494.0L);
7804   TEST_f_f (trunc, -4503599627370495.5000000000001L, -4503599627370495.0L);
7805   TEST_f_f (trunc, -4503599627370496.5000000000001L, -4503599627370496.0L);
7806 # endif
7807
7808   TEST_f_f (trunc, 9007199254740991.5L, 9007199254740991.0L);
7809   TEST_f_f (trunc, 9007199254740992.25L, 9007199254740992.0L);
7810   TEST_f_f (trunc, 9007199254740992.5L, 9007199254740992.0L);
7811   TEST_f_f (trunc, 9007199254740992.75L, 9007199254740992.0L);
7812   TEST_f_f (trunc, 9007199254740993.5L, 9007199254740993.0L);
7813
7814 # if LDBL_MANT_DIG > 100
7815   TEST_f_f (trunc, 9007199254740991.0000000000001L, 9007199254740991.0L);
7816   TEST_f_f (trunc, 9007199254740992.0000000000001L, 9007199254740992.0L);
7817   TEST_f_f (trunc, 9007199254740993.0000000000001L, 9007199254740993.0L);
7818   TEST_f_f (trunc, 9007199254740991.5000000000001L, 9007199254740991.0L);
7819   TEST_f_f (trunc, 9007199254740992.5000000000001L, 9007199254740992.0L);
7820   TEST_f_f (trunc, 9007199254740993.5000000000001L, 9007199254740993.0L);
7821 # endif
7822
7823   TEST_f_f (trunc, -9007199254740991.5L, -9007199254740991.0L);
7824   TEST_f_f (trunc, -9007199254740992.25L, -9007199254740992.0L);
7825   TEST_f_f (trunc, -9007199254740992.5L, -9007199254740992.0L);
7826   TEST_f_f (trunc, -9007199254740992.75L, -9007199254740992.0L);
7827   TEST_f_f (trunc, -9007199254740993.5L, -9007199254740993.0L);
7828
7829 # if LDBL_MANT_DIG > 100
7830   TEST_f_f (trunc, -9007199254740991.0000000000001L, -9007199254740991.0L);
7831   TEST_f_f (trunc, -9007199254740992.0000000000001L, -9007199254740992.0L);
7832   TEST_f_f (trunc, -9007199254740993.0000000000001L, -9007199254740993.0L);
7833   TEST_f_f (trunc, -9007199254740991.5000000000001L, -9007199254740991.0L);
7834   TEST_f_f (trunc, -9007199254740992.5000000000001L, -9007199254740992.0L);
7835   TEST_f_f (trunc, -9007199254740993.5000000000001L, -9007199254740993.0L);
7836 # endif
7837
7838   TEST_f_f (trunc, 72057594037927935.5L, 72057594037927935.0L);
7839   TEST_f_f (trunc, 72057594037927936.25L, 72057594037927936.0L);
7840   TEST_f_f (trunc, 72057594037927936.5L, 72057594037927936.0L);
7841   TEST_f_f (trunc, 72057594037927936.75L, 72057594037927936.0L);
7842   TEST_f_f (trunc, 72057594037927937.5L, 72057594037927937.0L);
7843
7844   TEST_f_f (trunc, -72057594037927935.5L, -72057594037927935.0L);
7845   TEST_f_f (trunc, -72057594037927936.25L, -72057594037927936.0L);
7846   TEST_f_f (trunc, -72057594037927936.5L, -72057594037927936.0L);
7847   TEST_f_f (trunc, -72057594037927936.75L, -72057594037927936.0L);
7848   TEST_f_f (trunc, -72057594037927937.5L, -72057594037927937.0L);
7849
7850   TEST_f_f (trunc, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
7851   TEST_f_f (trunc, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
7852   TEST_f_f (trunc, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
7853   TEST_f_f (trunc, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
7854   TEST_f_f (trunc, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
7855 #endif
7856
7857   END (trunc);
7858 }
7859
7860 static void
7861 y0_test (void)
7862 {
7863   FLOAT s, c;
7864   errno = 0;
7865   FUNC (sincos) (0, &s, &c);
7866   if (errno == ENOSYS)
7867     /* Required function not implemented.  */
7868     return;
7869   FUNC(y0) (1);
7870   if (errno == ENOSYS)
7871     /* Function not implemented.  */
7872     return;
7873
7874   /* y0 is the Bessel function of the second kind of order 0 */
7875   START (y0);
7876
7877   TEST_f_f (y0, -1.0, minus_infty, INVALID_EXCEPTION);
7878   TEST_f_f (y0, -max_value, minus_infty, INVALID_EXCEPTION);
7879   TEST_f_f (y0, 0.0, minus_infty);
7880   TEST_f_f (y0, nan_value, nan_value);
7881   TEST_f_f (y0, plus_infty, 0);
7882
7883   TEST_f_f (y0, 0.125L, -1.38968062514384052915582277745018693L);
7884   TEST_f_f (y0, 0.75L, -0.137172769385772397522814379396581855L);
7885   TEST_f_f (y0, 1.0, 0.0882569642156769579829267660235151628L);
7886   TEST_f_f (y0, 1.5, 0.382448923797758843955068554978089862L);
7887   TEST_f_f (y0, 2.0, 0.510375672649745119596606592727157873L);
7888   TEST_f_f (y0, 8.0, 0.223521489387566220527323400498620359L);
7889   TEST_f_f (y0, 10.0, 0.0556711672835993914244598774101900481L);
7890
7891   TEST_f_f (y0, 0x1.3ffp+74L, 1.818984347516051243459467456433028748678e-12L);
7892
7893 #ifndef TEST_FLOAT
7894   TEST_f_f (y0, 0x1.ff00000000002p+840L, 1.846591691699331493194965158699937660696e-127L);
7895 #endif
7896
7897   END (y0);
7898 }
7899
7900
7901 static void
7902 y1_test (void)
7903 {
7904   FLOAT s, c;
7905   errno = 0;
7906   FUNC (sincos) (0, &s, &c);
7907   if (errno == ENOSYS)
7908     /* Required function not implemented.  */
7909     return;
7910   FUNC(y1) (1);
7911   if (errno == ENOSYS)
7912     /* Function not implemented.  */
7913     return;
7914
7915   /* y1 is the Bessel function of the second kind of order 1 */
7916   START (y1);
7917
7918   TEST_f_f (y1, -1.0, minus_infty, INVALID_EXCEPTION);
7919   TEST_f_f (y1, -max_value, minus_infty, INVALID_EXCEPTION);
7920   TEST_f_f (y1, 0.0, minus_infty);
7921   TEST_f_f (y1, plus_infty, 0);
7922   TEST_f_f (y1, nan_value, nan_value);
7923
7924   TEST_f_f (y1, 0.125L, -5.19993611253477499595928744876579921L);
7925   TEST_f_f (y1, 0.75L, -1.03759455076928541973767132140642198L);
7926   TEST_f_f (y1, 1.0, -0.781212821300288716547150000047964821L);
7927   TEST_f_f (y1, 1.5, -0.412308626973911295952829820633445323L);
7928   TEST_f_f (y1, 2.0, -0.107032431540937546888370772277476637L);
7929   TEST_f_f (y1, 8.0, -0.158060461731247494255555266187483550L);
7930   TEST_f_f (y1, 10.0, 0.249015424206953883923283474663222803L);
7931
7932   TEST_f_f (y1, 0x1.27e204p+99L, -8.881610148467797208469612080785210013461e-16L);
7933
7934 #ifndef TEST_FLOAT
7935   TEST_f_f (y1, 0x1.001000001p+593L, 3.927269966354206207832593635798954916263e-90L);
7936 #endif
7937
7938   END (y1);
7939 }
7940
7941
7942 static void
7943 yn_test (void)
7944 {
7945   FLOAT s, c;
7946   errno = 0;
7947   FUNC (sincos) (0, &s, &c);
7948   if (errno == ENOSYS)
7949     /* Required function not implemented.  */
7950     return;
7951   FUNC(yn) (1, 1);
7952   if (errno == ENOSYS)
7953     /* Function not implemented.  */
7954     return;
7955
7956   /* yn is the Bessel function of the second kind of order n */
7957   START (yn);
7958
7959   /* yn (0, x) == y0 (x)  */
7960   TEST_ff_f (yn, 0, -1.0, minus_infty, INVALID_EXCEPTION);
7961   TEST_ff_f (yn, 0, -max_value, minus_infty, INVALID_EXCEPTION);
7962   TEST_ff_f (yn, 0, 0.0, minus_infty);
7963   TEST_ff_f (yn, 0, nan_value, nan_value);
7964   TEST_ff_f (yn, 0, plus_infty, 0);
7965
7966   TEST_ff_f (yn, 0, 0.125L, -1.38968062514384052915582277745018693L);
7967   TEST_ff_f (yn, 0, 0.75L, -0.137172769385772397522814379396581855L);
7968   TEST_ff_f (yn, 0, 1.0, 0.0882569642156769579829267660235151628L);
7969   TEST_ff_f (yn, 0, 1.5, 0.382448923797758843955068554978089862L);
7970   TEST_ff_f (yn, 0, 2.0, 0.510375672649745119596606592727157873L);
7971   TEST_ff_f (yn, 0, 8.0, 0.223521489387566220527323400498620359L);
7972   TEST_ff_f (yn, 0, 10.0, 0.0556711672835993914244598774101900481L);
7973
7974   /* yn (1, x) == y1 (x)  */
7975   TEST_ff_f (yn, 1, -1.0, minus_infty, INVALID_EXCEPTION);
7976   TEST_ff_f (yn, 1, 0.0, minus_infty);
7977   TEST_ff_f (yn, 1, plus_infty, 0);
7978   TEST_ff_f (yn, 1, nan_value, nan_value);
7979
7980   TEST_ff_f (yn, 1, 0.125L, -5.19993611253477499595928744876579921L);
7981   TEST_ff_f (yn, 1, 0.75L, -1.03759455076928541973767132140642198L);
7982   TEST_ff_f (yn, 1, 1.0, -0.781212821300288716547150000047964821L);
7983   TEST_ff_f (yn, 1, 1.5, -0.412308626973911295952829820633445323L);
7984   TEST_ff_f (yn, 1, 2.0, -0.107032431540937546888370772277476637L);
7985   TEST_ff_f (yn, 1, 8.0, -0.158060461731247494255555266187483550L);
7986   TEST_ff_f (yn, 1, 10.0, 0.249015424206953883923283474663222803L);
7987
7988   /* yn (3, x)  */
7989   TEST_ff_f (yn, 3, plus_infty, 0);
7990   TEST_ff_f (yn, 3, nan_value, nan_value);
7991
7992   TEST_ff_f (yn, 3, 0.125L, -2612.69757350066712600220955744091741L);
7993   TEST_ff_f (yn, 3, 0.75L, -12.9877176234475433186319774484809207L);
7994   TEST_ff_f (yn, 3, 1.0, -5.82151760596472884776175706442981440L);
7995   TEST_ff_f (yn, 3, 2.0, -1.12778377684042778608158395773179238L);
7996   TEST_ff_f (yn, 3, 10.0, -0.251362657183837329779204747654240998L);
7997
7998   /* yn (10, x)  */
7999   TEST_ff_f (yn, 10, plus_infty, 0);
8000   TEST_ff_f (yn, 10, nan_value, nan_value);
8001
8002   TEST_ff_f (yn, 10, 0.125L, -127057845771019398.252538486899753195L);
8003   TEST_ff_f (yn, 10, 0.75L, -2133501638.90573424452445412893839236L);
8004   TEST_ff_f (yn, 10, 1.0, -121618014.278689189288130426667971145L);
8005   TEST_ff_f (yn, 10, 2.0, -129184.542208039282635913145923304214L);
8006   TEST_ff_f (yn, 10, 10.0, -0.359814152183402722051986577343560609L);
8007
8008   END (yn);
8009
8010 }
8011
8012
8013 static void
8014 significand_test (void)
8015 {
8016   /* significand returns the mantissa of the exponential representation.  */
8017   START (significand);
8018
8019   TEST_f_f (significand, 4.0, 1.0);
8020   TEST_f_f (significand, 6.0, 1.5);
8021   TEST_f_f (significand, 8.0, 1.0);
8022
8023   END (significand);
8024 }
8025
8026
8027 static void
8028 initialize (void)
8029 {
8030   fpstack_test ("start *init*");
8031   plus_zero = 0.0;
8032   nan_value = plus_zero / plus_zero;    /* Suppress GCC warning */
8033
8034   minus_zero = FUNC(copysign) (0.0, -1.0);
8035   plus_infty = CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF,
8036                        HUGE_VALL, HUGE_VAL, HUGE_VALF);
8037   minus_infty = CHOOSE (-HUGE_VALL, -HUGE_VAL, -HUGE_VALF,
8038                         -HUGE_VALL, -HUGE_VAL, -HUGE_VALF);
8039   max_value = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
8040                       LDBL_MAX, DBL_MAX, FLT_MAX);
8041   min_value = CHOOSE (LDBL_MIN, DBL_MIN, FLT_MIN,
8042                       LDBL_MIN, DBL_MIN, FLT_MIN);
8043
8044   (void) &plus_zero;
8045   (void) &nan_value;
8046   (void) &minus_zero;
8047   (void) &plus_infty;
8048   (void) &minus_infty;
8049   (void) &max_value;
8050   (void) &min_value;
8051
8052   /* Clear all exceptions.  From now on we must not get random exceptions.  */
8053   feclearexcept (FE_ALL_EXCEPT);
8054
8055   /* Test to make sure we start correctly.  */
8056   fpstack_test ("end *init*");
8057 }
8058
8059 /* Definitions of arguments for argp functions.  */
8060 static const struct argp_option options[] =
8061 {
8062   { "verbose", 'v', "NUMBER", 0, "Level of verbosity (0..3)"},
8063   { "ulps-file", 'u', NULL, 0, "Output ulps to file ULPs"},
8064   { "no-max-error", 'f', NULL, 0,
8065     "Don't output maximal errors of functions"},
8066   { "no-points", 'p', NULL, 0,
8067     "Don't output results of functions invocations"},
8068   { "ignore-max-ulp", 'i', "yes/no", 0,
8069     "Ignore given maximal errors"},
8070   { NULL, 0, NULL, 0, NULL }
8071 };
8072
8073 /* Short description of program.  */
8074 static const char doc[] = "Math test suite: " TEST_MSG ;
8075
8076 /* Prototype for option handler.  */
8077 static error_t parse_opt (int key, char *arg, struct argp_state *state);
8078
8079 /* Data structure to communicate with argp functions.  */
8080 static struct argp argp =
8081 {
8082   options, parse_opt, NULL, doc,
8083 };
8084
8085
8086 /* Handle program arguments.  */
8087 static error_t
8088 parse_opt (int key, char *arg, struct argp_state *state)
8089 {
8090   switch (key)
8091     {
8092     case 'f':
8093       output_max_error = 0;
8094       break;
8095     case 'i':
8096       if (strcmp (arg, "yes") == 0)
8097         ignore_max_ulp = 1;
8098       else if (strcmp (arg, "no") == 0)
8099         ignore_max_ulp = 0;
8100       break;
8101     case 'p':
8102       output_points = 0;
8103       break;
8104     case 'u':
8105       output_ulps = 1;
8106       break;
8107     case 'v':
8108       if (optarg)
8109         verbose = (unsigned int) strtoul (optarg, NULL, 0);
8110       else
8111         verbose = 3;
8112       break;
8113     default:
8114       return ARGP_ERR_UNKNOWN;
8115     }
8116   return 0;
8117 }
8118
8119 #if 0
8120 /* function to check our ulp calculation.  */
8121 void
8122 check_ulp (void)
8123 {
8124   int i;
8125
8126   FLOAT u, diff, ulp;
8127   /* This gives one ulp.  */
8128   u = FUNC(nextafter) (10, 20);
8129   check_equal (10.0, u, 1, &diff, &ulp);
8130   printf ("One ulp: % .4" PRINTF_NEXPR "\n", ulp);
8131
8132   /* This gives one more ulp.  */
8133   u = FUNC(nextafter) (u, 20);
8134   check_equal (10.0, u, 2, &diff, &ulp);
8135   printf ("two ulp: % .4" PRINTF_NEXPR "\n", ulp);
8136
8137   /* And now calculate 100 ulp.  */
8138   for (i = 2; i < 100; i++)
8139     u = FUNC(nextafter) (u, 20);
8140   check_equal (10.0, u, 100, &diff, &ulp);
8141   printf ("100 ulp: % .4" PRINTF_NEXPR "\n", ulp);
8142 }
8143 #endif
8144
8145 int
8146 main (int argc, char **argv)
8147 {
8148
8149   int remaining;
8150
8151   verbose = 1;
8152   output_ulps = 0;
8153   output_max_error = 1;
8154   output_points = 1;
8155   /* XXX set to 0 for releases.  */
8156   ignore_max_ulp = 0;
8157
8158   /* Parse and process arguments.  */
8159   argp_parse (&argp, argc, argv, 0, &remaining, NULL);
8160
8161   if (remaining != argc)
8162     {
8163       fprintf (stderr, "wrong number of arguments");
8164       argp_help (&argp, stdout, ARGP_HELP_SEE, program_invocation_short_name);
8165       exit (EXIT_FAILURE);
8166     }
8167
8168   if (output_ulps)
8169     {
8170       ulps_file = fopen ("ULPs", "a");
8171       if (ulps_file == NULL)
8172         {
8173           perror ("can't open file `ULPs' for writing: ");
8174           exit (1);
8175         }
8176     }
8177
8178
8179   initialize ();
8180   printf (TEST_MSG);
8181
8182 #if 0
8183   check_ulp ();
8184 #endif
8185
8186   /* Keep the tests a wee bit ordered (according to ISO C99).  */
8187   /* Classification macros:  */
8188   fpclassify_test ();
8189   isfinite_test ();
8190   isnormal_test ();
8191   signbit_test ();
8192
8193   /* Trigonometric functions:  */
8194   acos_test ();
8195   asin_test ();
8196   atan_test ();
8197   atan2_test ();
8198   cos_test ();
8199   cos_test_tonearest ();
8200   cos_test_towardzero ();
8201   cos_test_downward ();
8202   cos_test_upward ();
8203   sin_test ();
8204   sin_test_tonearest ();
8205   sin_test_towardzero ();
8206   sin_test_downward ();
8207   sin_test_upward ();
8208   sincos_test ();
8209   tan_test ();
8210   tan_test_tonearest ();
8211   tan_test_towardzero ();
8212   tan_test_downward ();
8213   tan_test_upward ();
8214
8215   /* Hyperbolic functions:  */
8216   acosh_test ();
8217   asinh_test ();
8218   atanh_test ();
8219   cosh_test ();
8220   cosh_test_tonearest ();
8221   cosh_test_towardzero ();
8222   cosh_test_downward ();
8223   cosh_test_upward ();
8224   sinh_test ();
8225   sinh_test_tonearest ();
8226   sinh_test_towardzero ();
8227   sinh_test_downward ();
8228   sinh_test_upward ();
8229   tanh_test ();
8230
8231   /* Exponential and logarithmic functions:  */
8232   exp_test ();
8233   exp_test_tonearest ();
8234   exp_test_towardzero ();
8235   exp_test_downward ();
8236   exp_test_upward ();
8237   exp10_test ();
8238   exp2_test ();
8239   expm1_test ();
8240   frexp_test ();
8241   ldexp_test ();
8242   log_test ();
8243   log10_test ();
8244   log1p_test ();
8245   log2_test ();
8246   logb_test ();
8247   logb_test_downward ();
8248   modf_test ();
8249   ilogb_test ();
8250   scalb_test ();
8251   scalbn_test ();
8252   scalbln_test ();
8253   significand_test ();
8254
8255   /* Power and absolute value functions:  */
8256   cbrt_test ();
8257   fabs_test ();
8258   hypot_test ();
8259   pow_test ();
8260   pow_test_tonearest ();
8261   pow_test_towardzero ();
8262   pow_test_downward ();
8263   pow_test_upward ();
8264   sqrt_test ();
8265
8266   /* Error and gamma functions:  */
8267   erf_test ();
8268   erfc_test ();
8269   gamma_test ();
8270   lgamma_test ();
8271   tgamma_test ();
8272
8273   /* Nearest integer functions:  */
8274   ceil_test ();
8275   floor_test ();
8276   nearbyint_test ();
8277   rint_test ();
8278   rint_test_tonearest ();
8279   rint_test_towardzero ();
8280   rint_test_downward ();
8281   rint_test_upward ();
8282   lrint_test ();
8283   lrint_test_tonearest ();
8284   lrint_test_towardzero ();
8285   lrint_test_downward ();
8286   lrint_test_upward ();
8287   llrint_test ();
8288   llrint_test_tonearest ();
8289   llrint_test_towardzero ();
8290   llrint_test_downward ();
8291   llrint_test_upward ();
8292   round_test ();
8293   lround_test ();
8294   llround_test ();
8295   trunc_test ();
8296
8297   /* Remainder functions:  */
8298   fmod_test ();
8299   remainder_test ();
8300   remquo_test ();
8301
8302   /* Manipulation functions:  */
8303   copysign_test ();
8304   nextafter_test ();
8305   nexttoward_test ();
8306
8307   /* maximum, minimum and positive difference functions */
8308   fdim_test ();
8309   fmax_test ();
8310   fmin_test ();
8311
8312   /* Multiply and add:  */
8313   fma_test ();
8314
8315   /* Complex functions:  */
8316   cabs_test ();
8317   cacos_test ();
8318   cacosh_test ();
8319   carg_test ();
8320   casin_test ();
8321   casinh_test ();
8322   catan_test ();
8323   catanh_test ();
8324   ccos_test ();
8325   ccosh_test ();
8326   cexp_test ();
8327   cimag_test ();
8328   clog10_test ();
8329   clog_test ();
8330   conj_test ();
8331   cpow_test ();
8332   cproj_test ();
8333   creal_test ();
8334   csin_test ();
8335   csinh_test ();
8336   csqrt_test ();
8337   ctan_test ();
8338   ctanh_test ();
8339
8340   /* Bessel functions:  */
8341   j0_test ();
8342   j1_test ();
8343   jn_test ();
8344   y0_test ();
8345   y1_test ();
8346   yn_test ();
8347
8348   if (output_ulps)
8349     fclose (ulps_file);
8350
8351   printf ("\nTest suite completed:\n");
8352   printf ("  %d test cases plus %d tests for exception flags executed.\n",
8353           noTests, noExcTests);
8354   if (noXFails)
8355     printf ("  %d expected failures occurred.\n", noXFails);
8356   if (noXPasses)
8357     printf ("  %d unexpected passes occurred.\n", noXPasses);
8358   if (noErrors)
8359     {
8360       printf ("  %d errors occurred.\n", noErrors);
8361       return 1;
8362     }
8363   printf ("  All tests passed successfully.\n");
8364
8365   return 0;
8366 }
8367
8368 /*
8369  * Local Variables:
8370  * mode:c
8371  * End:
8372  */