math/libm-test.inc

   1 /* Copyright (C) 1997-2013 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, finite, 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, nexttoward,
  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, cimag, clog, clog10, conj, cpow, cproj, creal,
  58    csin, csinh, csqrt, ctan, ctanh.
  59
  60    At the moment the following functions and macros aren't tested:
  61    drem (alias for remainder),
  62    lgamma_r,
  63    nan,
  64    pow10 (alias for exp10).
  65
  66    Parameter handling is primitive in the moment:
  67    --verbose=[0..3] for different levels of output:
  68    0: only error count
  69    1: basic report on failed tests (default)
  70    2: full report on all tests
  71    -v for full output (equals --verbose=3)
  72    -u for generation of an ULPs file
  73  */
  74
  75 /* "Philosophy":
  76
  77    This suite tests some aspects of the correct implementation of
  78    mathematical functions in libm.  Some simple, specific parameters
  79    are tested for correctness but there's no exhaustive
  80    testing.  Handling of specific inputs (e.g. infinity, not-a-number)
  81    is also tested.  Correct handling of exceptions is checked
  82    against.  These implemented tests should check all cases that are
  83    specified in ISO C99.
  84
  85    Exception testing: At the moment only divide-by-zero, invalid,
  86    overflow and underflow exceptions are tested.  Inexact exceptions
  87    aren't checked at the moment.
  88
  89    NaN values: There exist signalling and quiet NaNs.  This implementation
  90    only uses quiet NaN as parameter but does not differentiate
  91    between the two kinds of NaNs as result.  Where the sign of a NaN is
  92    significant, this is not tested.
  93
  94    Inline functions: Inlining functions should give an improvement in
  95    speed - but not in precission.  The inlined functions return
  96    reasonable values for a reasonable range of input values.  The
  97    result is not necessarily correct for all values and exceptions are
  98    not correctly raised in all cases.  Problematic input and return
  99    values are infinity, not-a-number and minus zero.  This suite
 100    therefore does not check these specific inputs and the exception
 101    handling for inlined mathematical functions - just the "reasonable"
 102    values are checked.
 103
 104    Beware: The tests might fail for any of the following reasons:
 105    - Tests are wrong
 106    - Functions are wrong
 107    - Floating Point Unit not working properly
 108    - Compiler has errors
 109
 110    With e.g. gcc 2.7.2.2 the test for cexp fails because of a compiler error.
 111
 112
 113    To Do: All parameter should be numbers that can be represented as
 114    exact floating point values.  Currently some values cannot be
 115    represented exactly and therefore the result is not the expected
 116    result.  For this we will use 36 digits so that numbers can be
 117    represented exactly.  */
 118
 119 #ifndef _GNU_SOURCE
 120 # define _GNU_SOURCE
 121 #endif
 122
 123 #include "libm-test-ulps.h"
 124 #include <complex.h>
 125 #include <math.h>
 126 #include <float.h>
 127 #include <fenv.h>
 128 #include <limits.h>
 129
 130 #include <errno.h>
 131 #include <stdlib.h>
 132 #include <stdio.h>
 133 #include <string.h>
 134 #include <argp.h>
 135 #include <tininess.h>
 136
 137 /* Allow platforms without all rounding modes to test properly,
 138    assuming they provide an __FE_UNDEFINED in <bits/fenv.h> which
 139    causes fesetround() to return failure.  */
 140 #ifndef FE_TONEAREST
 141 # define FE_TONEAREST   __FE_UNDEFINED
 142 #endif
 143 #ifndef FE_TOWARDZERO
 144 # define FE_TOWARDZERO  __FE_UNDEFINED
 145 #endif
 146 #ifndef FE_UPWARD
 147 # define FE_UPWARD      __FE_UNDEFINED
 148 #endif
 149 #ifndef FE_DOWNWARD
 150 # define FE_DOWNWARD    __FE_UNDEFINED
 151 #endif
 152
 153 /* Possible exceptions */
 154 #define NO_EXCEPTION                    0x0
 155 #define INVALID_EXCEPTION               0x1
 156 #define DIVIDE_BY_ZERO_EXCEPTION        0x2
 157 #define OVERFLOW_EXCEPTION              0x4
 158 #define UNDERFLOW_EXCEPTION             0x8
 159 /* The next flags signals that those exceptions are allowed but not required.   */
 160 #define INVALID_EXCEPTION_OK            0x10
 161 #define DIVIDE_BY_ZERO_EXCEPTION_OK     0x20
 162 #define OVERFLOW_EXCEPTION_OK           0x40
 163 #define UNDERFLOW_EXCEPTION_OK          0x80
 164 #define EXCEPTIONS_OK INVALID_EXCEPTION_OK+DIVIDE_BY_ZERO_EXCEPTION_OK
 165 /* Some special test flags, passed together with exceptions.  */
 166 #define IGNORE_ZERO_INF_SIGN            0x100
 167
 168 /* Values underflowing only for float.  */
 169 #ifdef TEST_FLOAT
 170 # define UNDERFLOW_EXCEPTION_FLOAT      UNDERFLOW_EXCEPTION
 171 # define UNDERFLOW_EXCEPTION_OK_FLOAT   UNDERFLOW_EXCEPTION_OK
 172 #else
 173 # define UNDERFLOW_EXCEPTION_FLOAT      0
 174 # define UNDERFLOW_EXCEPTION_OK_FLOAT   0
 175 #endif
 176 /* Values underflowing only for double or types with a larger least
 177    positive normal value.  */
 178 #if defined TEST_FLOAT || defined TEST_DOUBLE \
 179   || (defined TEST_LDOUBLE && LDBL_MIN_EXP >= DBL_MIN_EXP)
 180 # define UNDERFLOW_EXCEPTION_DOUBLE     UNDERFLOW_EXCEPTION
 181 #else
 182 # define UNDERFLOW_EXCEPTION_DOUBLE     0
 183 #endif
 184 /* Values underflowing only for IBM long double or types with a larger least
 185    positive normal value.  */
 186 #if defined TEST_FLOAT || (defined TEST_LDOUBLE && LDBL_MIN_EXP > DBL_MIN_EXP)
 187 # define UNDERFLOW_EXCEPTION_LDOUBLE_IBM        UNDERFLOW_EXCEPTION
 188 #else
 189 # define UNDERFLOW_EXCEPTION_LDOUBLE_IBM        0
 190 #endif
 191 /* Values underflowing on architectures detecting tininess before
 192    rounding, but not on those detecting tininess after rounding.  */
 193 #define UNDERFLOW_EXCEPTION_BEFORE_ROUNDING     (TININESS_AFTER_ROUNDING \
 194                                                  ? 0                    \
 195                                                  : UNDERFLOW_EXCEPTION)
 196
 197 /* Various constants (we must supply them precalculated for accuracy).  */
 198 #define M_PI_6l                 .52359877559829887307710723054658383L
 199 #define M_E2l                   7.389056098930650227230427460575008L
 200 #define M_E3l                   20.085536923187667740928529654581719L
 201 #define M_2_SQRT_PIl            3.5449077018110320545963349666822903L   /* 2 sqrt (M_PIl)  */
 202 #define M_SQRT_PIl              1.7724538509055160272981674833411451L   /* sqrt (M_PIl)  */
 203 #define M_LOG_SQRT_PIl          0.57236494292470008707171367567652933L  /* log(sqrt(M_PIl))  */
 204 #define M_LOG_2_SQRT_PIl        1.265512123484645396488945797134706L    /* log(2*sqrt(M_PIl))  */
 205 #define M_PI_34l                (M_PIl - M_PI_4l)               /* 3*pi/4 */
 206 #define M_PI_34_LOG10El         (M_PIl - M_PI_4l) * M_LOG10El
 207 #define M_PI2_LOG10El           M_PI_2l * M_LOG10El
 208 #define M_PI4_LOG10El           M_PI_4l * M_LOG10El
 209 #define M_PI_LOG10El            M_PIl * M_LOG10El
 210 #define M_SQRT_2_2              0.70710678118654752440084436210484903L /* sqrt (2) / 2 */
 211
 212 static FILE *ulps_file; /* File to document difference.  */
 213 static int output_ulps; /* Should ulps printed?  */
 214
 215 static int noErrors;    /* number of errors */
 216 static int noTests;     /* number of tests (without testing exceptions) */
 217 static int noExcTests;  /* number of tests for exception flags */
 218 static int noXFails;    /* number of expected failures.  */
 219 static int noXPasses;   /* number of unexpected passes.  */
 220
 221 static int verbose;
 222 static int output_max_error;    /* Should the maximal errors printed?  */
 223 static int output_points;       /* Should the single function results printed?  */
 224 static int ignore_max_ulp;      /* Should we ignore max_ulp?  */
 225
 226 static FLOAT minus_zero, plus_zero;
 227 static FLOAT plus_infty, minus_infty, nan_value, max_value, min_value;
 228 static FLOAT min_subnorm_value;
 229
 230 static FLOAT max_error, real_max_error, imag_max_error;
 231
 232
 233 #define BUILD_COMPLEX(real, imag) \
 234   ({ __complex__ FLOAT __retval;                                              \
 235      __real__ __retval = (real);                                              \
 236      __imag__ __retval = (imag);                                              \
 237      __retval; })
 238
 239 #define BUILD_COMPLEX_INT(real, imag) \
 240   ({ __complex__ int __retval;                                                \
 241      __real__ __retval = (real);                                              \
 242      __imag__ __retval = (imag);                                              \
 243      __retval; })
 244
 245
 246 #define MANT_DIG CHOOSE ((LDBL_MANT_DIG-1), (DBL_MANT_DIG-1), (FLT_MANT_DIG-1),  \
 247                          (LDBL_MANT_DIG-1), (DBL_MANT_DIG-1), (FLT_MANT_DIG-1))
 248
 249 static void
 250 init_max_error (void)
 251 {
 252   max_error = 0;
 253   real_max_error = 0;
 254   imag_max_error = 0;
 255   feclearexcept (FE_ALL_EXCEPT);
 256 }
 257
 258 static void
 259 set_max_error (FLOAT current, FLOAT *curr_max_error)
 260 {
 261   if (current > *curr_max_error)
 262     *curr_max_error = current;
 263 }
 264
 265
 266 /* Should the message print to screen?  This depends on the verbose flag,
 267    and the test status.  */
 268 static int
 269 print_screen (int ok, int xfail)
 270 {
 271   if (output_points
 272       && (verbose > 1
 273           || (verbose == 1 && ok == xfail)))
 274     return 1;
 275   return 0;
 276 }
 277
 278
 279 /* Should the message print to screen?  This depends on the verbose flag,
 280    and the test status.  */
 281 static int
 282 print_screen_max_error (int ok, int xfail)
 283 {
 284   if (output_max_error
 285       && (verbose > 1
 286           || ((verbose == 1) && (ok == xfail))))
 287     return 1;
 288   return 0;
 289 }
 290
 291 /* Update statistic counters.  */
 292 static void
 293 update_stats (int ok, int xfail)
 294 {
 295   ++noTests;
 296   if (ok && xfail)
 297     ++noXPasses;
 298   else if (!ok && xfail)
 299     ++noXFails;
 300   else if (!ok && !xfail)
 301     ++noErrors;
 302 }
 303
 304 static void
 305 print_ulps (const char *test_name, FLOAT ulp)
 306 {
 307   if (output_ulps)
 308     {
 309       fprintf (ulps_file, "Test \"%s\":\n", test_name);
 310       fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
 311                CHOOSE("ldouble", "double", "float",
 312                       "ildouble", "idouble", "ifloat"),
 313                FUNC(ceil) (ulp));
 314     }
 315 }
 316
 317 static void
 318 print_function_ulps (const char *function_name, FLOAT ulp)
 319 {
 320   if (output_ulps)
 321     {
 322       fprintf (ulps_file, "Function: \"%s\":\n", function_name);
 323       fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
 324                CHOOSE("ldouble", "double", "float",
 325                       "ildouble", "idouble", "ifloat"),
 326                FUNC(ceil) (ulp));
 327     }
 328 }
 329
 330
 331 static void
 332 print_complex_function_ulps (const char *function_name, FLOAT real_ulp,
 333                              FLOAT imag_ulp)
 334 {
 335   if (output_ulps)
 336     {
 337       if (real_ulp != 0.0)
 338         {
 339           fprintf (ulps_file, "Function: Real part of \"%s\":\n", function_name);
 340           fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
 341                    CHOOSE("ldouble", "double", "float",
 342                           "ildouble", "idouble", "ifloat"),
 343                    FUNC(ceil) (real_ulp));
 344         }
 345       if (imag_ulp != 0.0)
 346         {
 347           fprintf (ulps_file, "Function: Imaginary part of \"%s\":\n", function_name);
 348           fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
 349                    CHOOSE("ldouble", "double", "float",
 350                           "ildouble", "idouble", "ifloat"),
 351                    FUNC(ceil) (imag_ulp));
 352         }
 353
 354
 355     }
 356 }
 357
 358
 359
 360 /* Test if Floating-Point stack hasn't changed */
 361 static void
 362 fpstack_test (const char *test_name)
 363 {
 364 #ifdef i386
 365   static int old_stack;
 366   int sw;
 367
 368   asm ("fnstsw" : "=a" (sw));
 369   sw >>= 11;
 370   sw &= 7;
 371
 372   if (sw != old_stack)
 373     {
 374       printf ("FP-Stack wrong after test %s (%d, should be %d)\n",
 375               test_name, sw, old_stack);
 376       ++noErrors;
 377       old_stack = sw;
 378     }
 379 #endif
 380 }
 381
 382
 383 static void
 384 print_max_error (const char *func_name, FLOAT allowed, int xfail)
 385 {
 386   int ok = 0;
 387
 388   if (max_error == 0.0 || (max_error <= allowed && !ignore_max_ulp))
 389     {
 390       ok = 1;
 391     }
 392
 393   if (!ok)
 394     print_function_ulps (func_name, max_error);
 395
 396
 397   if (print_screen_max_error (ok, xfail))
 398     {
 399       printf ("Maximal error of `%s'\n", func_name);
 400       printf (" is      : %.0" PRINTF_NEXPR " ulp\n", FUNC(ceil) (max_error));
 401       printf (" accepted: %.0" PRINTF_NEXPR " ulp\n", FUNC(ceil) (allowed));
 402     }
 403
 404   update_stats (ok, xfail);
 405 }
 406
 407
 408 static void
 409 print_complex_max_error (const char *func_name, __complex__ FLOAT allowed,
 410                          __complex__ int xfail)
 411 {
 412   int ok = 0;
 413
 414   if ((real_max_error == 0 && imag_max_error == 0)
 415       || (real_max_error <= __real__ allowed
 416           && imag_max_error <= __imag__ allowed
 417           && !ignore_max_ulp))
 418     {
 419       ok = 1;
 420     }
 421
 422   if (!ok)
 423     print_complex_function_ulps (func_name, real_max_error, imag_max_error);
 424
 425
 426   if (print_screen_max_error (ok, xfail))
 427     {
 428       printf ("Maximal error of real part of: %s\n", func_name);
 429       printf (" is      : %.0" PRINTF_NEXPR " ulp\n",
 430               FUNC(ceil) (real_max_error));
 431       printf (" accepted: %.0" PRINTF_NEXPR " ulp\n",
 432               FUNC(ceil) (__real__ allowed));
 433       printf ("Maximal error of imaginary part of: %s\n", func_name);
 434       printf (" is      : %.0" PRINTF_NEXPR " ulp\n",
 435               FUNC(ceil) (imag_max_error));
 436       printf (" accepted: %.0" PRINTF_NEXPR " ulp\n",
 437               FUNC(ceil) (__imag__ allowed));
 438     }
 439
 440   update_stats (ok, xfail);
 441 }
 442
 443
 444 /* Test whether a given exception was raised.  */
 445 static void
 446 test_single_exception (const char *test_name,
 447                        int exception,
 448                        int exc_flag,
 449                        int fe_flag,
 450                        const char *flag_name)
 451 {
 452 #ifndef TEST_INLINE
 453   int ok = 1;
 454   if (exception & exc_flag)
 455     {
 456       if (fetestexcept (fe_flag))
 457         {
 458           if (print_screen (1, 0))
 459             printf ("Pass: %s: Exception \"%s\" set\n", test_name, flag_name);
 460         }
 461       else
 462         {
 463           ok = 0;
 464           if (print_screen (0, 0))
 465             printf ("Failure: %s: Exception \"%s\" not set\n",
 466                     test_name, flag_name);
 467         }
 468     }
 469   else
 470     {
 471       if (fetestexcept (fe_flag))
 472         {
 473           ok = 0;
 474           if (print_screen (0, 0))
 475             printf ("Failure: %s: Exception \"%s\" set\n",
 476                     test_name, flag_name);
 477         }
 478       else
 479         {
 480           if (print_screen (1, 0))
 481             printf ("%s: Exception \"%s\" not set\n", test_name,
 482                     flag_name);
 483         }
 484     }
 485   if (!ok)
 486     ++noErrors;
 487
 488 #endif
 489 }
 490
 491
 492 /* Test whether exceptions given by EXCEPTION are raised.  Ignore thereby
 493    allowed but not required exceptions.
 494 */
 495 static void
 496 test_exceptions (const char *test_name, int exception)
 497 {
 498   ++noExcTests;
 499 #ifdef FE_DIVBYZERO
 500   if ((exception & DIVIDE_BY_ZERO_EXCEPTION_OK) == 0)
 501     test_single_exception (test_name, exception,
 502                            DIVIDE_BY_ZERO_EXCEPTION, FE_DIVBYZERO,
 503                            "Divide by zero");
 504 #endif
 505 #ifdef FE_INVALID
 506   if ((exception & INVALID_EXCEPTION_OK) == 0)
 507     test_single_exception (test_name, exception, INVALID_EXCEPTION, FE_INVALID,
 508                          "Invalid operation");
 509 #endif
 510 #ifdef FE_OVERFLOW
 511   if ((exception & OVERFLOW_EXCEPTION_OK) == 0)
 512     test_single_exception (test_name, exception, OVERFLOW_EXCEPTION,
 513                            FE_OVERFLOW, "Overflow");
 514 #endif
 515 #ifdef FE_UNDERFLOW
 516   if ((exception & UNDERFLOW_EXCEPTION_OK) == 0)
 517     test_single_exception (test_name, exception, UNDERFLOW_EXCEPTION,
 518                            FE_UNDERFLOW, "Underflow");
 519 #endif
 520   feclearexcept (FE_ALL_EXCEPT);
 521 }
 522
 523
 524 static void
 525 check_float_internal (const char *test_name, FLOAT computed, FLOAT expected,
 526                       FLOAT max_ulp, int xfail, int exceptions,
 527                       FLOAT *curr_max_error)
 528 {
 529   int ok = 0;
 530   int print_diff = 0;
 531   FLOAT diff = 0;
 532   FLOAT ulp = 0;
 533
 534   test_exceptions (test_name, exceptions);
 535   if (isnan (computed) && isnan (expected))
 536     ok = 1;
 537   else if (isinf (computed) && isinf (expected))
 538     {
 539       /* Test for sign of infinities.  */
 540       if ((exceptions & IGNORE_ZERO_INF_SIGN) == 0
 541           && signbit (computed) != signbit (expected))
 542         {
 543           ok = 0;
 544           printf ("infinity has wrong sign.\n");
 545         }
 546       else
 547         ok = 1;
 548     }
 549   /* Don't calc ulp for NaNs or infinities.  */
 550   else if (isinf (computed) || isnan (computed) || isinf (expected) || isnan (expected))
 551     ok = 0;
 552   else
 553     {
 554       diff = FUNC(fabs) (computed - expected);
 555       switch (fpclassify (expected))
 556         {
 557         case FP_ZERO:
 558           /* ilogb (0) isn't allowed. */
 559           ulp = diff / FUNC(ldexp) (1.0, - MANT_DIG);
 560           break;
 561         case FP_NORMAL:
 562           ulp = diff / FUNC(ldexp) (1.0, FUNC(ilogb) (expected) - MANT_DIG);
 563           break;
 564         case FP_SUBNORMAL:
 565           /* 1ulp for a subnormal value, shifted by MANT_DIG, is the
 566              least normal value.  */
 567           ulp = (FUNC(ldexp) (diff, MANT_DIG) / min_value);
 568           break;
 569         default:
 570           /* It should never happen. */
 571           abort ();
 572           break;
 573         }
 574       set_max_error (ulp, curr_max_error);
 575       print_diff = 1;
 576       if ((exceptions & IGNORE_ZERO_INF_SIGN) == 0
 577           && computed == 0.0 && expected == 0.0
 578           && signbit(computed) != signbit (expected))
 579         ok = 0;
 580       else if (ulp <= 0.5 || (ulp <= max_ulp && !ignore_max_ulp))
 581         ok = 1;
 582       else
 583         {
 584           ok = 0;
 585           print_ulps (test_name, ulp);
 586         }
 587
 588     }
 589   if (print_screen (ok, xfail))
 590     {
 591       if (!ok)
 592         printf ("Failure: ");
 593       printf ("Test: %s\n", test_name);
 594       printf ("Result:\n");
 595       printf (" is:         % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
 596               computed, computed);
 597       printf (" should be:  % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
 598               expected, expected);
 599       if (print_diff)
 600         {
 601           printf (" difference: % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR
 602                   "\n", diff, diff);
 603           printf (" ulp       : % .4" PRINTF_NEXPR "\n", ulp);
 604           printf (" max.ulp   : % .4" PRINTF_NEXPR "\n", max_ulp);
 605         }
 606     }
 607   update_stats (ok, xfail);
 608
 609   fpstack_test (test_name);
 610 }
 611
 612
 613 static void
 614 check_float (const char *test_name, FLOAT computed, FLOAT expected,
 615              FLOAT max_ulp, int xfail, int exceptions)
 616 {
 617   check_float_internal (test_name, computed, expected, max_ulp, xfail,
 618                         exceptions, &max_error);
 619 }
 620
 621
 622 static void
 623 check_complex (const char *test_name, __complex__ FLOAT computed,
 624                __complex__ FLOAT expected,
 625                __complex__ FLOAT max_ulp, __complex__ int xfail,
 626                int exception)
 627 {
 628   FLOAT part_comp, part_exp, part_max_ulp;
 629   int part_xfail;
 630   char *str;
 631
 632   if (asprintf (&str, "Real part of: %s", test_name) == -1)
 633     abort ();
 634
 635   part_comp = __real__ computed;
 636   part_exp = __real__ expected;
 637   part_max_ulp = __real__ max_ulp;
 638   part_xfail = __real__ xfail;
 639
 640   check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
 641                         exception, &real_max_error);
 642   free (str);
 643
 644   if (asprintf (&str, "Imaginary part of: %s", test_name) == -1)
 645     abort ();
 646
 647   part_comp = __imag__ computed;
 648   part_exp = __imag__ expected;
 649   part_max_ulp = __imag__ max_ulp;
 650   part_xfail = __imag__ xfail;
 651
 652   /* Don't check again for exceptions, just pass through the
 653      zero/inf sign test.  */
 654   check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
 655                         exception & IGNORE_ZERO_INF_SIGN,
 656                         &imag_max_error);
 657   free (str);
 658 }
 659
 660
 661 /* Check that computed and expected values are equal (int values).  */
 662 static void
 663 check_int (const char *test_name, int computed, int expected, int max_ulp,
 664            int xfail, int exceptions)
 665 {
 666   int diff = computed - expected;
 667   int ok = 0;
 668
 669   test_exceptions (test_name, exceptions);
 670   noTests++;
 671   if (abs (diff) <= max_ulp)
 672     ok = 1;
 673
 674   if (!ok)
 675     print_ulps (test_name, diff);
 676
 677   if (print_screen (ok, xfail))
 678     {
 679       if (!ok)
 680         printf ("Failure: ");
 681       printf ("Test: %s\n", test_name);
 682       printf ("Result:\n");
 683       printf (" is:         %d\n", computed);
 684       printf (" should be:  %d\n", expected);
 685     }
 686
 687   update_stats (ok, xfail);
 688   fpstack_test (test_name);
 689 }
 690
 691
 692 /* Check that computed and expected values are equal (long int values).  */
 693 static void
 694 check_long (const char *test_name, long int computed, long int expected,
 695             long int max_ulp, int xfail, int exceptions)
 696 {
 697   long int diff = computed - expected;
 698   int ok = 0;
 699
 700   test_exceptions (test_name, exceptions);
 701   noTests++;
 702   if (labs (diff) <= max_ulp)
 703     ok = 1;
 704
 705   if (!ok)
 706     print_ulps (test_name, diff);
 707
 708   if (print_screen (ok, xfail))
 709     {
 710       if (!ok)
 711         printf ("Failure: ");
 712       printf ("Test: %s\n", test_name);
 713       printf ("Result:\n");
 714       printf (" is:         %ld\n", computed);
 715       printf (" should be:  %ld\n", expected);
 716     }
 717
 718   update_stats (ok, xfail);
 719   fpstack_test (test_name);
 720 }
 721
 722
 723 /* Check that computed value is true/false.  */
 724 static void
 725 check_bool (const char *test_name, int computed, int expected,
 726             long int max_ulp, int xfail, int exceptions)
 727 {
 728   int ok = 0;
 729
 730   test_exceptions (test_name, exceptions);
 731   noTests++;
 732   if ((computed == 0) == (expected == 0))
 733     ok = 1;
 734
 735   if (print_screen (ok, xfail))
 736     {
 737       if (!ok)
 738         printf ("Failure: ");
 739       printf ("Test: %s\n", test_name);
 740       printf ("Result:\n");
 741       printf (" is:         %d\n", computed);
 742       printf (" should be:  %d\n", expected);
 743     }
 744
 745   update_stats (ok, xfail);
 746   fpstack_test (test_name);
 747 }
 748
 749
 750 /* check that computed and expected values are equal (long int values) */
 751 static void
 752 check_longlong (const char *test_name, long long int computed,
 753                 long long int expected,
 754                 long long int max_ulp, int xfail,
 755                 int exceptions)
 756 {
 757   long long int diff = computed - expected;
 758   int ok = 0;
 759
 760   test_exceptions (test_name, exceptions);
 761   noTests++;
 762   if (llabs (diff) <= max_ulp)
 763     ok = 1;
 764
 765   if (!ok)
 766     print_ulps (test_name, diff);
 767
 768   if (print_screen (ok, xfail))
 769     {
 770       if (!ok)
 771         printf ("Failure:");
 772       printf ("Test: %s\n", test_name);
 773       printf ("Result:\n");
 774       printf (" is:         %lld\n", computed);
 775       printf (" should be:  %lld\n", expected);
 776     }
 777
 778   update_stats (ok, xfail);
 779   fpstack_test (test_name);
 780 }
 781
 782
 783
 784 /* This is to prevent messages from the SVID libm emulation.  */
 785 int
 786 matherr (struct exception *x __attribute__ ((unused)))
 787 {
 788   return 1;
 789 }
 790
 791
 792 /****************************************************************************
 793   Tests for single functions of libm.
 794   Please keep them alphabetically sorted!
 795 ****************************************************************************/
 796
 797 static void
 798 acos_test (void)
 799 {
 800   errno = 0;
 801   FUNC(acos) (0);
 802   if (errno == ENOSYS)
 803     /* Function not implemented.  */
 804     return;
 805
 806   START (acos);
 807
 808   TEST_f_f (acos, plus_infty, nan_value, INVALID_EXCEPTION);
 809   TEST_f_f (acos, minus_infty, nan_value, INVALID_EXCEPTION);
 810   TEST_f_f (acos, nan_value, nan_value);
 811
 812   /* |x| > 1: */
 813   TEST_f_f (acos, 1.125L, nan_value, INVALID_EXCEPTION);
 814   TEST_f_f (acos, -1.125L, nan_value, INVALID_EXCEPTION);
 815   TEST_f_f (acos, max_value, nan_value, INVALID_EXCEPTION);
 816   TEST_f_f (acos, -max_value, nan_value, INVALID_EXCEPTION);
 817
 818   TEST_f_f (acos, 0, M_PI_2l);
 819   TEST_f_f (acos, minus_zero, M_PI_2l);
 820   TEST_f_f (acos, 1, 0);
 821   TEST_f_f (acos, -1, M_PIl);
 822   TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 823   TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 824   TEST_f_f (acos, 0.75L, 0.722734247813415611178377352641333362L);
 825   TEST_f_f (acos, 2e-17L, 1.57079632679489659923132169163975144L);
 826   TEST_f_f (acos, 0.0625L, 1.50825556499840522843072005474337068L);
 827   TEST_f_f (acos, 0x0.ffffffp0L, 3.4526698471620358760324948263873649728491e-4L);
 828   TEST_f_f (acos, -0x0.ffffffp0L, 3.1412473866050770348750401337968641476999L);
 829 #ifndef TEST_FLOAT
 830   TEST_f_f (acos, 0x0.ffffffff8p0L, 1.5258789062648029736620564947844627548516e-5L);
 831   TEST_f_f (acos, -0x0.ffffffff8p0L, 3.1415773948007305904329067627145550395696L);
 832   TEST_f_f (acos, 0x0.ffffffffffffp0L, 8.4293697021788088529885473244391795127130e-8L);
 833   TEST_f_f (acos, -0x0.ffffffffffffp0L, 3.1415925692960962166745548533940296398054L);
 834 #endif
 835 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
 836   TEST_f_f (acos, 0x0.ffffffffffffffffp0L, 3.2927225399135962333718255320079907245059e-10L);
 837   TEST_f_f (acos, -0x0.ffffffffffffffffp0L, 3.1415926532605209844712837599423203309964L);
 838 #endif
 839   END (acos);
 840 }
 841
 842
 843 static void
 844 acos_test_tonearest (void)
 845 {
 846   int save_round_mode;
 847   errno = 0;
 848   FUNC(acos) (0);
 849   if (errno == ENOSYS)
 850     /* Function not implemented.  */
 851     return;
 852
 853   START (acos_tonearest);
 854
 855   save_round_mode = fegetround ();
 856
 857   if (!fesetround (FE_TONEAREST))
 858     {
 859       TEST_f_f (acos, 0, M_PI_2l);
 860       TEST_f_f (acos, minus_zero, M_PI_2l);
 861       TEST_f_f (acos, 1, 0);
 862       TEST_f_f (acos, -1, M_PIl);
 863       TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 864       TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 865     }
 866
 867   fesetround (save_round_mode);
 868
 869   END (acos_tonearest);
 870 }
 871
 872
 873 static void
 874 acos_test_towardzero (void)
 875 {
 876   int save_round_mode;
 877   errno = 0;
 878   FUNC(acos) (0);
 879   if (errno == ENOSYS)
 880     /* Function not implemented.  */
 881     return;
 882
 883   START (acos_towardzero);
 884
 885   save_round_mode = fegetround ();
 886
 887   if (!fesetround (FE_TOWARDZERO))
 888     {
 889       TEST_f_f (acos, 0, M_PI_2l);
 890       TEST_f_f (acos, minus_zero, M_PI_2l);
 891       TEST_f_f (acos, 1, 0);
 892       TEST_f_f (acos, -1, M_PIl);
 893       TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 894       TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 895     }
 896
 897   fesetround (save_round_mode);
 898
 899   END (acos_towardzero);
 900 }
 901
 902
 903 static void
 904 acos_test_downward (void)
 905 {
 906   int save_round_mode;
 907   errno = 0;
 908   FUNC(acos) (0);
 909   if (errno == ENOSYS)
 910     /* Function not implemented.  */
 911     return;
 912
 913   START (acos_downward);
 914
 915   save_round_mode = fegetround ();
 916
 917   if (!fesetround (FE_DOWNWARD))
 918     {
 919       TEST_f_f (acos, 0, M_PI_2l);
 920       TEST_f_f (acos, minus_zero, M_PI_2l);
 921       TEST_f_f (acos, 1, 0);
 922       TEST_f_f (acos, -1, M_PIl);
 923       TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 924       TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 925     }
 926
 927   fesetround (save_round_mode);
 928
 929   END (acos_downward);
 930 }
 931
 932
 933 static void
 934 acos_test_upward (void)
 935 {
 936   int save_round_mode;
 937   errno = 0;
 938   FUNC(acos) (0);
 939   if (errno == ENOSYS)
 940     /* Function not implemented.  */
 941     return;
 942
 943   START (acos_upward);
 944
 945   save_round_mode = fegetround ();
 946
 947   if (!fesetround (FE_UPWARD))
 948     {
 949       TEST_f_f (acos, 0, M_PI_2l);
 950       TEST_f_f (acos, minus_zero, M_PI_2l);
 951       TEST_f_f (acos, 1, 0);
 952       TEST_f_f (acos, -1, M_PIl);
 953       TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 954       TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 955     }
 956
 957   fesetround (save_round_mode);
 958
 959   END (acos_upward);
 960 }
 961
 962 static void
 963 acosh_test (void)
 964 {
 965   errno = 0;
 966   FUNC(acosh) (7);
 967   if (errno == ENOSYS)
 968     /* Function not implemented.  */
 969     return;
 970
 971   START (acosh);
 972
 973   TEST_f_f (acosh, plus_infty, plus_infty);
 974   TEST_f_f (acosh, minus_infty, nan_value, INVALID_EXCEPTION);
 975
 976   /* x < 1:  */
 977   TEST_f_f (acosh, -1.125L, nan_value, INVALID_EXCEPTION);
 978   TEST_f_f (acosh, -max_value, nan_value, INVALID_EXCEPTION);
 979
 980   TEST_f_f (acosh, 1, 0);
 981   TEST_f_f (acosh, 7, 2.63391579384963341725009269461593689L);
 982
 983   END (acosh);
 984 }
 985
 986 static void
 987 asin_test (void)
 988 {
 989   errno = 0;
 990   FUNC(asin) (0);
 991   if (errno == ENOSYS)
 992     /* Function not implemented.  */
 993     return;
 994
 995   START (asin);
 996
 997   TEST_f_f (asin, plus_infty, nan_value, INVALID_EXCEPTION);
 998   TEST_f_f (asin, minus_infty, nan_value, INVALID_EXCEPTION);
 999   TEST_f_f (asin, nan_value, nan_value);
1000
1001   /* asin x == NaN plus invalid exception for |x| > 1.  */
1002   TEST_f_f (asin, 1.125L, nan_value, INVALID_EXCEPTION);
1003   TEST_f_f (asin, -1.125L, nan_value, INVALID_EXCEPTION);
1004   TEST_f_f (asin, max_value, nan_value, INVALID_EXCEPTION);
1005   TEST_f_f (asin, -max_value, nan_value, INVALID_EXCEPTION);
1006
1007   TEST_f_f (asin, 0, 0);
1008   TEST_f_f (asin, minus_zero, minus_zero);
1009   TEST_f_f (asin, 0.5, M_PI_6l);
1010   TEST_f_f (asin, -0.5, -M_PI_6l);
1011   TEST_f_f (asin, 1.0, M_PI_2l);
1012   TEST_f_f (asin, -1.0, -M_PI_2l);
1013   TEST_f_f (asin, 0.75L, 0.848062078981481008052944338998418080L);
1014   TEST_f_f (asin, 0x0.ffffffp0L, 1.5704510598101804156437184421571127056013L);
1015   TEST_f_f (asin, -0x0.ffffffp0L, -1.5704510598101804156437184421571127056013L);
1016 #ifndef TEST_FLOAT
1017   TEST_f_f (asin, 0x0.ffffffff8p0L, 1.5707810680058339712015850710748035974710L);
1018   TEST_f_f (asin, -0x0.ffffffff8p0L, -1.5707810680058339712015850710748035974710L);
1019   TEST_f_f (asin, 0x0.ffffffffffffp0L, 1.5707962425011995974432331617542781977068L);
1020   TEST_f_f (asin, -0x0.ffffffffffffp0L, -1.5707962425011995974432331617542781977068L);
1021 #endif
1022 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
1023   TEST_f_f (asin, 0x0.ffffffffffffffffp0L, 1.5707963264656243652399620683025688888978L);
1024   TEST_f_f (asin, -0x0.ffffffffffffffffp0L, -1.5707963264656243652399620683025688888978L);
1025 #endif
1026
1027   END (asin);
1028 }
1029
1030
1031 static void
1032 asin_test_tonearest (void)
1033 {
1034   int save_round_mode;
1035   errno = 0;
1036   FUNC(asin) (0);
1037   if (errno == ENOSYS)
1038     /* Function not implemented.  */
1039     return;
1040
1041   START (asin_tonearest);
1042
1043   save_round_mode = fegetround ();
1044
1045   if (!fesetround (FE_TONEAREST))
1046     {
1047       TEST_f_f (asin, 0, 0);
1048       TEST_f_f (asin, minus_zero, minus_zero);
1049       TEST_f_f (asin, 0.5, M_PI_6l);
1050       TEST_f_f (asin, -0.5, -M_PI_6l);
1051       TEST_f_f (asin, 1.0, M_PI_2l);
1052       TEST_f_f (asin, -1.0, -M_PI_2l);
1053     }
1054
1055   fesetround (save_round_mode);
1056
1057   END (asin_tonearest);
1058 }
1059
1060
1061 static void
1062 asin_test_towardzero (void)
1063 {
1064   int save_round_mode;
1065   errno = 0;
1066   FUNC(asin) (0);
1067   if (errno == ENOSYS)
1068     /* Function not implemented.  */
1069     return;
1070
1071   START (asin_towardzero);
1072
1073   save_round_mode = fegetround ();
1074
1075   if (!fesetround (FE_TOWARDZERO))
1076     {
1077       TEST_f_f (asin, 0, 0);
1078       TEST_f_f (asin, minus_zero, minus_zero);
1079       TEST_f_f (asin, 0.5, M_PI_6l);
1080       TEST_f_f (asin, -0.5, -M_PI_6l);
1081       TEST_f_f (asin, 1.0, M_PI_2l);
1082       TEST_f_f (asin, -1.0, -M_PI_2l);
1083     }
1084
1085   fesetround (save_round_mode);
1086
1087   END (asin_towardzero);
1088 }
1089
1090
1091 static void
1092 asin_test_downward (void)
1093 {
1094   int save_round_mode;
1095   errno = 0;
1096   FUNC(asin) (0);
1097   if (errno == ENOSYS)
1098     /* Function not implemented.  */
1099     return;
1100
1101   START (asin_downward);
1102
1103   save_round_mode = fegetround ();
1104
1105   if (!fesetround (FE_DOWNWARD))
1106     {
1107       TEST_f_f (asin, 0, 0);
1108       TEST_f_f (asin, minus_zero, minus_zero);
1109       TEST_f_f (asin, 0.5, M_PI_6l);
1110       TEST_f_f (asin, -0.5, -M_PI_6l);
1111       TEST_f_f (asin, 1.0, M_PI_2l);
1112       TEST_f_f (asin, -1.0, -M_PI_2l);
1113     }
1114
1115   fesetround (save_round_mode);
1116
1117   END (asin_downward);
1118 }
1119
1120
1121 static void
1122 asin_test_upward (void)
1123 {
1124   int save_round_mode;
1125   errno = 0;
1126   FUNC(asin) (0);
1127   if (errno == ENOSYS)
1128     /* Function not implemented.  */
1129     return;
1130
1131   START (asin_upward);
1132
1133   save_round_mode = fegetround ();
1134
1135   if (!fesetround (FE_UPWARD))
1136     {
1137       TEST_f_f (asin, 0, 0);
1138       TEST_f_f (asin, minus_zero, minus_zero);
1139       TEST_f_f (asin, 0.5, M_PI_6l);
1140       TEST_f_f (asin, -0.5, -M_PI_6l);
1141       TEST_f_f (asin, 1.0, M_PI_2l);
1142       TEST_f_f (asin, -1.0, -M_PI_2l);
1143     }
1144
1145   fesetround (save_round_mode);
1146
1147   END (asin_upward);
1148 }
1149
1150 static void
1151 asinh_test (void)
1152 {
1153   errno = 0;
1154   FUNC(asinh) (0.7L);
1155   if (errno == ENOSYS)
1156     /* Function not implemented.  */
1157     return;
1158
1159   START (asinh);
1160
1161   TEST_f_f (asinh, 0, 0);
1162   TEST_f_f (asinh, minus_zero, minus_zero);
1163 #ifndef TEST_INLINE
1164   TEST_f_f (asinh, plus_infty, plus_infty);
1165   TEST_f_f (asinh, minus_infty, minus_infty);
1166 #endif
1167   TEST_f_f (asinh, nan_value, nan_value);
1168   TEST_f_f (asinh, 0.75L, 0.693147180559945309417232121458176568L);
1169
1170   END (asinh);
1171 }
1172
1173 static void
1174 atan_test (void)
1175 {
1176   errno = 0;
1177   FUNC(atan) (0);
1178   if (errno == ENOSYS)
1179     /* Function not implemented.  */
1180     return;
1181
1182   START (atan);
1183
1184   TEST_f_f (atan, 0, 0);
1185   TEST_f_f (atan, minus_zero, minus_zero);
1186
1187   TEST_f_f (atan, plus_infty, M_PI_2l);
1188   TEST_f_f (atan, minus_infty, -M_PI_2l);
1189   TEST_f_f (atan, nan_value, nan_value);
1190   TEST_f_f (atan, max_value, M_PI_2l);
1191   TEST_f_f (atan, -max_value, -M_PI_2l);
1192
1193   TEST_f_f (atan, 1, M_PI_4l);
1194   TEST_f_f (atan, -1, -M_PI_4l);
1195
1196   TEST_f_f (atan, 0.75L, 0.643501108793284386802809228717322638L);
1197
1198   TEST_f_f (atan, 0x1p-100L, 0x1p-100L);
1199 #ifndef TEST_FLOAT
1200   TEST_f_f (atan, 0x1p-600L, 0x1p-600L);
1201 #endif
1202 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
1203   TEST_f_f (atan, 0x1p-10000L, 0x1p-10000L);
1204 #endif
1205
1206   END (atan);
1207 }
1208
1209
1210
1211 static void
1212 atanh_test (void)
1213 {
1214   errno = 0;
1215   FUNC(atanh) (0.7L);
1216   if (errno == ENOSYS)
1217     /* Function not implemented.  */
1218     return;
1219
1220   START (atanh);
1221
1222
1223   TEST_f_f (atanh, 0, 0);
1224   TEST_f_f (atanh, minus_zero, minus_zero);
1225
1226   TEST_f_f (atanh, 1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
1227   TEST_f_f (atanh, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
1228   TEST_f_f (atanh, nan_value, nan_value);
1229
1230   /* atanh (x) == NaN plus invalid exception if |x| > 1.  */
1231   TEST_f_f (atanh, 1.125L, nan_value, INVALID_EXCEPTION);
1232   TEST_f_f (atanh, -1.125L, nan_value, INVALID_EXCEPTION);
1233   TEST_f_f (atanh, max_value, nan_value, INVALID_EXCEPTION);
1234   TEST_f_f (atanh, -max_value, nan_value, INVALID_EXCEPTION);
1235
1236   TEST_f_f (atanh, 0.75L, 0.972955074527656652552676371721589865L);
1237
1238   END (atanh);
1239 }
1240
1241 static void
1242 atan2_test (void)
1243 {
1244   errno = 0;
1245   FUNC(atan2) (-0, 1);
1246   if (errno == ENOSYS)
1247     /* Function not implemented.  */
1248     return;
1249
1250   START (atan2);
1251
1252   /* atan2 (0,x) == 0 for x > 0.  */
1253   TEST_ff_f (atan2, 0, 1, 0);
1254
1255   /* atan2 (-0,x) == -0 for x > 0.  */
1256   TEST_ff_f (atan2, minus_zero, 1, minus_zero);
1257
1258   TEST_ff_f (atan2, 0, 0, 0);
1259   TEST_ff_f (atan2, minus_zero, 0, minus_zero);
1260
1261   /* atan2 (+0,x) == +pi for x < 0.  */
1262   TEST_ff_f (atan2, 0, -1, M_PIl);
1263
1264   /* atan2 (-0,x) == -pi for x < 0.  */
1265   TEST_ff_f (atan2, minus_zero, -1, -M_PIl);
1266
1267   TEST_ff_f (atan2, 0, minus_zero, M_PIl);
1268   TEST_ff_f (atan2, minus_zero, minus_zero, -M_PIl);
1269
1270   /* atan2 (y,+0) == pi/2 for y > 0.  */
1271   TEST_ff_f (atan2, 1, 0, M_PI_2l);
1272
1273   /* atan2 (y,-0) == pi/2 for y > 0.  */
1274   TEST_ff_f (atan2, 1, minus_zero, M_PI_2l);
1275
1276   /* atan2 (y,+0) == -pi/2 for y < 0.  */
1277   TEST_ff_f (atan2, -1, 0, -M_PI_2l);
1278
1279   /* atan2 (y,-0) == -pi/2 for y < 0.  */
1280   TEST_ff_f (atan2, -1, minus_zero, -M_PI_2l);
1281
1282   /* atan2 (y,inf) == +0 for finite y > 0.  */
1283   TEST_ff_f (atan2, 1, plus_infty, 0);
1284
1285   /* atan2 (y,inf) == -0 for finite y < 0.  */
1286   TEST_ff_f (atan2, -1, plus_infty, minus_zero);
1287
1288   /* atan2(+inf, x) == pi/2 for finite x.  */
1289   TEST_ff_f (atan2, plus_infty, -1, M_PI_2l);
1290
1291   /* atan2(-inf, x) == -pi/2 for finite x.  */
1292   TEST_ff_f (atan2, minus_infty, 1, -M_PI_2l);
1293
1294   /* atan2 (y,-inf) == +pi for finite y > 0.  */
1295   TEST_ff_f (atan2, 1, minus_infty, M_PIl);
1296
1297   /* atan2 (y,-inf) == -pi for finite y < 0.  */
1298   TEST_ff_f (atan2, -1, minus_infty, -M_PIl);
1299
1300   TEST_ff_f (atan2, plus_infty, plus_infty, M_PI_4l);
1301   TEST_ff_f (atan2, minus_infty, plus_infty, -M_PI_4l);
1302   TEST_ff_f (atan2, plus_infty, minus_infty, M_PI_34l);
1303   TEST_ff_f (atan2, minus_infty, minus_infty, -M_PI_34l);
1304   TEST_ff_f (atan2, nan_value, nan_value, nan_value);
1305
1306   TEST_ff_f (atan2, max_value, max_value, M_PI_4l);
1307
1308   TEST_ff_f (atan2, max_value, min_value, M_PI_2l);
1309   TEST_ff_f (atan2, -max_value, -min_value, -M_PI_2l);
1310
1311   TEST_ff_f (atan2, 0.75L, 1, 0.643501108793284386802809228717322638L);
1312   TEST_ff_f (atan2, -0.75L, 1.0L, -0.643501108793284386802809228717322638L);
1313   TEST_ff_f (atan2, 0.75L, -1.0L, 2.49809154479650885165983415456218025L);
1314   TEST_ff_f (atan2, -0.75L, -1.0L, -2.49809154479650885165983415456218025L);
1315   TEST_ff_f (atan2, 0.390625L, .00029L, 1.57005392693128974780151246612928941L);
1316   TEST_ff_f (atan2, 1.390625L, 0.9296875L, 0.981498387184244311516296577615519772L);
1317
1318   TEST_ff_f (atan2, -0.00756827042671106339L, -.001792735857538728036L, -1.80338464113663849327153994379639112L);
1319 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
1320   TEST_ff_f (atan2, 0x1.00000000000001p0L, 0x1.00000000000001p0L, M_PI_4l);
1321 #endif
1322
1323   END (atan2);
1324 }
1325
1326 static void
1327 cabs_test (void)
1328 {
1329   errno = 0;
1330   FUNC(cabs) (BUILD_COMPLEX (0.7L, 12.4L));
1331   if (errno == ENOSYS)
1332     /* Function not implemented.  */
1333     return;
1334
1335   START (cabs);
1336
1337   /* cabs (x + iy) is specified as hypot (x,y) */
1338
1339   /* cabs (+inf + i x) == +inf.  */
1340   TEST_c_f (cabs, plus_infty, 1.0, plus_infty);
1341   /* cabs (-inf + i x) == +inf.  */
1342   TEST_c_f (cabs, minus_infty, 1.0, plus_infty);
1343
1344   TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
1345   TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
1346
1347   TEST_c_f (cabs, nan_value, nan_value, nan_value);
1348
1349   /* cabs (x,y) == cabs (y,x).  */
1350   TEST_c_f (cabs, 0.75L, 12.390625L, 12.4133028598606664302388810868156657L);
1351   /* cabs (x,y) == cabs (-x,y).  */
1352   TEST_c_f (cabs, -12.390625L, 0.75L, 12.4133028598606664302388810868156657L);
1353   /* cabs (x,y) == cabs (-y,x).  */
1354   TEST_c_f (cabs, -0.75L, 12.390625L, 12.4133028598606664302388810868156657L);
1355   /* cabs (x,y) == cabs (-x,-y).  */
1356   TEST_c_f (cabs, -12.390625L, -0.75L, 12.4133028598606664302388810868156657L);
1357   /* cabs (x,y) == cabs (-y,-x).  */
1358   TEST_c_f (cabs, -0.75L, -12.390625L, 12.4133028598606664302388810868156657L);
1359   /* cabs (x,0) == fabs (x).  */
1360   TEST_c_f (cabs, -0.75L, 0, 0.75L);
1361   TEST_c_f (cabs, 0.75L, 0, 0.75L);
1362   TEST_c_f (cabs, -1.0L, 0, 1.0L);
1363   TEST_c_f (cabs, 1.0L, 0, 1.0L);
1364   TEST_c_f (cabs, -5.7e7L, 0, 5.7e7L);
1365   TEST_c_f (cabs, 5.7e7L, 0, 5.7e7L);
1366
1367   TEST_c_f (cabs, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
1368
1369   END (cabs);
1370 }
1371
1372
1373 static void
1374 cacos_test (void)
1375 {
1376   errno = 0;
1377   FUNC(cacos) (BUILD_COMPLEX (0.7L, 1.2L));
1378   if (errno == ENOSYS)
1379     /* Function not implemented.  */
1380     return;
1381
1382   START (cacos);
1383
1384
1385   TEST_c_c (cacos, 0, 0, M_PI_2l, minus_zero);
1386   TEST_c_c (cacos, minus_zero, 0, M_PI_2l, minus_zero);
1387   TEST_c_c (cacos, minus_zero, minus_zero, M_PI_2l, 0.0);
1388   TEST_c_c (cacos, 0, minus_zero, M_PI_2l, 0.0);
1389
1390   TEST_c_c (cacos, minus_infty, plus_infty, M_PI_34l, minus_infty);
1391   TEST_c_c (cacos, minus_infty, minus_infty, M_PI_34l, plus_infty);
1392
1393   TEST_c_c (cacos, plus_infty, plus_infty, M_PI_4l, minus_infty);
1394   TEST_c_c (cacos, plus_infty, minus_infty, M_PI_4l, plus_infty);
1395
1396   TEST_c_c (cacos, -10.0, plus_infty, M_PI_2l, minus_infty);
1397   TEST_c_c (cacos, -10.0, minus_infty, M_PI_2l, plus_infty);
1398   TEST_c_c (cacos, 0, plus_infty, M_PI_2l, minus_infty);
1399   TEST_c_c (cacos, 0, minus_infty, M_PI_2l, plus_infty);
1400   TEST_c_c (cacos, 0.1L, plus_infty, M_PI_2l, minus_infty);
1401   TEST_c_c (cacos, 0.1L, minus_infty, M_PI_2l, plus_infty);
1402
1403   TEST_c_c (cacos, minus_infty, 0, M_PIl, minus_infty);
1404   TEST_c_c (cacos, minus_infty, minus_zero, M_PIl, plus_infty);
1405   TEST_c_c (cacos, minus_infty, 100, M_PIl, minus_infty);
1406   TEST_c_c (cacos, minus_infty, -100, M_PIl, plus_infty);
1407
1408   TEST_c_c (cacos, plus_infty, 0, 0.0, minus_infty);
1409   TEST_c_c (cacos, plus_infty, minus_zero, 0.0, plus_infty);
1410   TEST_c_c (cacos, plus_infty, 0.5, 0.0, minus_infty);
1411   TEST_c_c (cacos, plus_infty, -0.5, 0.0, plus_infty);
1412
1413   TEST_c_c (cacos, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1414   TEST_c_c (cacos, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1415
1416   TEST_c_c (cacos, 0, nan_value, M_PI_2l, nan_value);
1417   TEST_c_c (cacos, minus_zero, nan_value, M_PI_2l, nan_value);
1418
1419   TEST_c_c (cacos, nan_value, plus_infty, nan_value, minus_infty);
1420   TEST_c_c (cacos, nan_value, minus_infty, nan_value, plus_infty);
1421
1422   TEST_c_c (cacos, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1423   TEST_c_c (cacos, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1424
1425   TEST_c_c (cacos, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1426   TEST_c_c (cacos, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1427
1428   TEST_c_c (cacos, nan_value, nan_value, nan_value, nan_value);
1429
1430   TEST_c_c (cacos, plus_zero, -1.5L, M_PI_2l, 1.194763217287109304111930828519090523536L);
1431   TEST_c_c (cacos, minus_zero, -1.5L, M_PI_2l, 1.194763217287109304111930828519090523536L);
1432   TEST_c_c (cacos, plus_zero, -1.0L, M_PI_2l, 0.8813735870195430252326093249797923090282L);
1433   TEST_c_c (cacos, minus_zero, -1.0L, M_PI_2l, 0.8813735870195430252326093249797923090282L);
1434   TEST_c_c (cacos, plus_zero, -0.5L, M_PI_2l, 0.4812118250596034474977589134243684231352L);
1435   TEST_c_c (cacos, minus_zero, -0.5L, M_PI_2l, 0.4812118250596034474977589134243684231352L);
1436   TEST_c_c (cacos, plus_zero, 0.5L, M_PI_2l, -0.4812118250596034474977589134243684231352L);
1437   TEST_c_c (cacos, minus_zero, 0.5L, M_PI_2l, -0.4812118250596034474977589134243684231352L);
1438   TEST_c_c (cacos, plus_zero, 1.0L, M_PI_2l, -0.8813735870195430252326093249797923090282L);
1439   TEST_c_c (cacos, minus_zero, 1.0L, M_PI_2l, -0.8813735870195430252326093249797923090282L);
1440   TEST_c_c (cacos, plus_zero, 1.5L, M_PI_2l, -1.194763217287109304111930828519090523536L);
1441   TEST_c_c (cacos, minus_zero, 1.5L, M_PI_2l, -1.194763217287109304111930828519090523536L);
1442
1443   TEST_c_c (cacos, -1.5L, plus_zero, M_PIl, -0.9624236501192068949955178268487368462704L);
1444   TEST_c_c (cacos, -1.5L, minus_zero, M_PIl, 0.9624236501192068949955178268487368462704L);
1445   TEST_c_c (cacos, -1.0L, plus_zero, M_PIl, minus_zero);
1446   TEST_c_c (cacos, -1.0L, minus_zero, M_PIl, plus_zero);
1447   TEST_c_c (cacos, -0.5L, plus_zero, 2.094395102393195492308428922186335256131L, minus_zero);
1448   TEST_c_c (cacos, -0.5L, minus_zero, 2.094395102393195492308428922186335256131L, plus_zero);
1449   TEST_c_c (cacos, 0.5L, plus_zero, 1.047197551196597746154214461093167628066L, minus_zero);
1450   TEST_c_c (cacos, 0.5L, minus_zero, 1.047197551196597746154214461093167628066L, plus_zero);
1451   TEST_c_c (cacos, 1.0L, plus_zero, plus_zero, minus_zero);
1452   TEST_c_c (cacos, 1.0L, minus_zero, plus_zero, plus_zero);
1453   TEST_c_c (cacos, 1.5L, plus_zero, plus_zero, -0.9624236501192068949955178268487368462704L);
1454   TEST_c_c (cacos, 1.5L, minus_zero, plus_zero, 0.9624236501192068949955178268487368462704L);
1455
1456   TEST_c_c (cacos, 0.75L, 1.25L, 1.11752014915610270578240049553777969L, -1.13239363160530819522266333696834467L);
1457   TEST_c_c (cacos, -2, -3, 2.1414491111159960199416055713254211L, 1.9833870299165354323470769028940395L);
1458
1459   END (cacos, complex);
1460 }
1461
1462 static void
1463 cacosh_test (void)
1464 {
1465   errno = 0;
1466   FUNC(cacosh) (BUILD_COMPLEX (0.7L, 1.2L));
1467   if (errno == ENOSYS)
1468     /* Function not implemented.  */
1469     return;
1470
1471   START (cacosh);
1472
1473
1474   TEST_c_c (cacosh, 0, 0, 0.0, M_PI_2l);
1475   TEST_c_c (cacosh, minus_zero, 0, 0.0, M_PI_2l);
1476   TEST_c_c (cacosh, 0, minus_zero, 0.0, -M_PI_2l);
1477   TEST_c_c (cacosh, minus_zero, minus_zero, 0.0, -M_PI_2l);
1478   TEST_c_c (cacosh, minus_infty, plus_infty, plus_infty, M_PI_34l);
1479   TEST_c_c (cacosh, minus_infty, minus_infty, plus_infty, -M_PI_34l);
1480
1481   TEST_c_c (cacosh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1482   TEST_c_c (cacosh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1483
1484   TEST_c_c (cacosh, -10.0, plus_infty, plus_infty, M_PI_2l);
1485   TEST_c_c (cacosh, -10.0, minus_infty, plus_infty, -M_PI_2l);
1486   TEST_c_c (cacosh, 0, plus_infty, plus_infty, M_PI_2l);
1487   TEST_c_c (cacosh, 0, minus_infty, plus_infty, -M_PI_2l);
1488   TEST_c_c (cacosh, 0.1L, plus_infty, plus_infty, M_PI_2l);
1489   TEST_c_c (cacosh, 0.1L, minus_infty, plus_infty, -M_PI_2l);
1490
1491   TEST_c_c (cacosh, minus_infty, 0, plus_infty, M_PIl);
1492   TEST_c_c (cacosh, minus_infty, minus_zero, plus_infty, -M_PIl);
1493   TEST_c_c (cacosh, minus_infty, 100, plus_infty, M_PIl);
1494   TEST_c_c (cacosh, minus_infty, -100, plus_infty, -M_PIl);
1495
1496   TEST_c_c (cacosh, plus_infty, 0, plus_infty, 0.0);
1497   TEST_c_c (cacosh, plus_infty, minus_zero, plus_infty, minus_zero);
1498   TEST_c_c (cacosh, plus_infty, 0.5, plus_infty, 0.0);
1499   TEST_c_c (cacosh, plus_infty, -0.5, plus_infty, minus_zero);
1500
1501   TEST_c_c (cacosh, plus_infty, nan_value, plus_infty, nan_value);
1502   TEST_c_c (cacosh, minus_infty, nan_value, plus_infty, nan_value);
1503
1504   TEST_c_c (cacosh, 0, nan_value, nan_value, nan_value);
1505   TEST_c_c (cacosh, minus_zero, nan_value, nan_value, nan_value);
1506
1507   TEST_c_c (cacosh, nan_value, plus_infty, plus_infty, nan_value);
1508   TEST_c_c (cacosh, nan_value, minus_infty, plus_infty, nan_value);
1509
1510   TEST_c_c (cacosh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1511   TEST_c_c (cacosh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1512
1513   TEST_c_c (cacosh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1514   TEST_c_c (cacosh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1515
1516   TEST_c_c (cacosh, nan_value, nan_value, nan_value, nan_value);
1517
1518   TEST_c_c (cacosh, plus_zero, -1.5L, 1.194763217287109304111930828519090523536L, -M_PI_2l);
1519   TEST_c_c (cacosh, minus_zero, -1.5L, 1.194763217287109304111930828519090523536L, -M_PI_2l);
1520   TEST_c_c (cacosh, plus_zero, -1.0L, 0.8813735870195430252326093249797923090282L, -M_PI_2l);
1521   TEST_c_c (cacosh, minus_zero, -1.0L, 0.8813735870195430252326093249797923090282L, -M_PI_2l);
1522   TEST_c_c (cacosh, plus_zero, -0.5L, 0.4812118250596034474977589134243684231352L, -M_PI_2l);
1523   TEST_c_c (cacosh, minus_zero, -0.5L, 0.4812118250596034474977589134243684231352L, -M_PI_2l);
1524   TEST_c_c (cacosh, plus_zero, 0.5L, 0.4812118250596034474977589134243684231352L, M_PI_2l);
1525   TEST_c_c (cacosh, minus_zero, 0.5L, 0.4812118250596034474977589134243684231352L, M_PI_2l);
1526   TEST_c_c (cacosh, plus_zero, 1.0L, 0.8813735870195430252326093249797923090282L, M_PI_2l);
1527   TEST_c_c (cacosh, minus_zero, 1.0L, 0.8813735870195430252326093249797923090282L, M_PI_2l);
1528   TEST_c_c (cacosh, plus_zero, 1.5L, 1.194763217287109304111930828519090523536L, M_PI_2l);
1529   TEST_c_c (cacosh, minus_zero, 1.5L, 1.194763217287109304111930828519090523536L, M_PI_2l);
1530
1531   TEST_c_c (cacosh, -1.5L, plus_zero, 0.9624236501192068949955178268487368462704L, M_PIl);
1532   TEST_c_c (cacosh, -1.5L, minus_zero, 0.9624236501192068949955178268487368462704L, -M_PIl);
1533   TEST_c_c (cacosh, -1.0L, plus_zero, plus_zero, M_PIl);
1534   TEST_c_c (cacosh, -1.0L, minus_zero, plus_zero, -M_PIl);
1535   TEST_c_c (cacosh, -0.5L, plus_zero, plus_zero, 2.094395102393195492308428922186335256131L);
1536   TEST_c_c (cacosh, -0.5L, minus_zero, plus_zero, -2.094395102393195492308428922186335256131L);
1537   TEST_c_c (cacosh, 0.5L, plus_zero, plus_zero, 1.047197551196597746154214461093167628066L);
1538   TEST_c_c (cacosh, 0.5L, minus_zero, plus_zero, -1.047197551196597746154214461093167628066L);
1539   TEST_c_c (cacosh, 1.0L, plus_zero, plus_zero, plus_zero);
1540   TEST_c_c (cacosh, 1.0L, minus_zero, plus_zero, minus_zero);
1541   TEST_c_c (cacosh, 1.5L, plus_zero, 0.9624236501192068949955178268487368462704L, plus_zero);
1542   TEST_c_c (cacosh, 1.5L, minus_zero, 0.9624236501192068949955178268487368462704L, minus_zero);
1543
1544   TEST_c_c (cacosh, 0.75L, 1.25L, 1.13239363160530819522266333696834467L, 1.11752014915610270578240049553777969L);
1545   TEST_c_c (cacosh, -2, -3, 1.9833870299165354323470769028940395L, -2.1414491111159960199416055713254211L);
1546
1547   END (cacosh, complex);
1548 }
1549
1550
1551 static void
1552 carg_test (void)
1553 {
1554   START (carg);
1555
1556   /* carg (x + iy) is specified as atan2 (y, x) */
1557
1558   /* carg (x + i 0) == 0 for x > 0.  */
1559   TEST_c_f (carg, 2.0, 0, 0);
1560   /* carg (x - i 0) == -0 for x > 0.  */
1561   TEST_c_f (carg, 2.0, minus_zero, minus_zero);
1562
1563   TEST_c_f (carg, 0, 0, 0);
1564   TEST_c_f (carg, 0, minus_zero, minus_zero);
1565
1566   /* carg (x + i 0) == +pi for x < 0.  */
1567   TEST_c_f (carg, -2.0, 0, M_PIl);
1568
1569   /* carg (x - i 0) == -pi for x < 0.  */
1570   TEST_c_f (carg, -2.0, minus_zero, -M_PIl);
1571
1572   TEST_c_f (carg, minus_zero, 0, M_PIl);
1573   TEST_c_f (carg, minus_zero, minus_zero, -M_PIl);
1574
1575   /* carg (+0 + i y) == pi/2 for y > 0.  */
1576   TEST_c_f (carg, 0, 2.0, M_PI_2l);
1577
1578   /* carg (-0 + i y) == pi/2 for y > 0.  */
1579   TEST_c_f (carg, minus_zero, 2.0, M_PI_2l);
1580
1581   /* carg (+0 + i y) == -pi/2 for y < 0.  */
1582   TEST_c_f (carg, 0, -2.0, -M_PI_2l);
1583
1584   /* carg (-0 + i y) == -pi/2 for y < 0.  */
1585   TEST_c_f (carg, minus_zero, -2.0, -M_PI_2l);
1586
1587   /* carg (inf + i y) == +0 for finite y > 0.  */
1588   TEST_c_f (carg, plus_infty, 2.0, 0);
1589
1590   /* carg (inf + i y) == -0 for finite y < 0.  */
1591   TEST_c_f (carg, plus_infty, -2.0, minus_zero);
1592
1593   /* carg(x + i inf) == pi/2 for finite x.  */
1594   TEST_c_f (carg, 10.0, plus_infty, M_PI_2l);
1595
1596   /* carg(x - i inf) == -pi/2 for finite x.  */
1597   TEST_c_f (carg, 10.0, minus_infty, -M_PI_2l);
1598
1599   /* carg (-inf + i y) == +pi for finite y > 0.  */
1600   TEST_c_f (carg, minus_infty, 10.0, M_PIl);
1601
1602   /* carg (-inf + i y) == -pi for finite y < 0.  */
1603   TEST_c_f (carg, minus_infty, -10.0, -M_PIl);
1604
1605   TEST_c_f (carg, plus_infty, plus_infty, M_PI_4l);
1606
1607   TEST_c_f (carg, plus_infty, minus_infty, -M_PI_4l);
1608
1609   TEST_c_f (carg, minus_infty, plus_infty, 3 * M_PI_4l);
1610
1611   TEST_c_f (carg, minus_infty, minus_infty, -3 * M_PI_4l);
1612
1613   TEST_c_f (carg, nan_value, nan_value, nan_value);
1614
1615   END (carg);
1616 }
1617
1618 static void
1619 casin_test (void)
1620 {
1621   errno = 0;
1622   FUNC(casin) (BUILD_COMPLEX (0.7L, 1.2L));
1623   if (errno == ENOSYS)
1624     /* Function not implemented.  */
1625     return;
1626
1627   START (casin);
1628
1629   TEST_c_c (casin, 0, 0, 0.0, 0.0);
1630   TEST_c_c (casin, minus_zero, 0, minus_zero, 0.0);
1631   TEST_c_c (casin, 0, minus_zero, 0.0, minus_zero);
1632   TEST_c_c (casin, minus_zero, minus_zero, minus_zero, minus_zero);
1633
1634   TEST_c_c (casin, plus_infty, plus_infty, M_PI_4l, plus_infty);
1635   TEST_c_c (casin, plus_infty, minus_infty, M_PI_4l, minus_infty);
1636   TEST_c_c (casin, minus_infty, plus_infty, -M_PI_4l, plus_infty);
1637   TEST_c_c (casin, minus_infty, minus_infty, -M_PI_4l, minus_infty);
1638
1639   TEST_c_c (casin, -10.0, plus_infty, minus_zero, plus_infty);
1640   TEST_c_c (casin, -10.0, minus_infty, minus_zero, minus_infty);
1641   TEST_c_c (casin, 0, plus_infty, 0.0, plus_infty);
1642   TEST_c_c (casin, 0, minus_infty, 0.0, minus_infty);
1643   TEST_c_c (casin, minus_zero, plus_infty, minus_zero, plus_infty);
1644   TEST_c_c (casin, minus_zero, minus_infty, minus_zero, minus_infty);
1645   TEST_c_c (casin, 0.1L, plus_infty, 0.0, plus_infty);
1646   TEST_c_c (casin, 0.1L, minus_infty, 0.0, minus_infty);
1647
1648   TEST_c_c (casin, minus_infty, 0, -M_PI_2l, plus_infty);
1649   TEST_c_c (casin, minus_infty, minus_zero, -M_PI_2l, minus_infty);
1650   TEST_c_c (casin, minus_infty, 100, -M_PI_2l, plus_infty);
1651   TEST_c_c (casin, minus_infty, -100, -M_PI_2l, minus_infty);
1652
1653   TEST_c_c (casin, plus_infty, 0, M_PI_2l, plus_infty);
1654   TEST_c_c (casin, plus_infty, minus_zero, M_PI_2l, minus_infty);
1655   TEST_c_c (casin, plus_infty, 0.5, M_PI_2l, plus_infty);
1656   TEST_c_c (casin, plus_infty, -0.5, M_PI_2l, minus_infty);
1657
1658   TEST_c_c (casin, nan_value, plus_infty, nan_value, plus_infty);
1659   TEST_c_c (casin, nan_value, minus_infty, nan_value, minus_infty);
1660
1661   TEST_c_c (casin, 0.0, nan_value, 0.0, nan_value);
1662   TEST_c_c (casin, minus_zero, nan_value, minus_zero, nan_value);
1663
1664   TEST_c_c (casin, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1665   TEST_c_c (casin, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1666
1667   TEST_c_c (casin, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1668   TEST_c_c (casin, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1669
1670   TEST_c_c (casin, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1671   TEST_c_c (casin, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1672
1673   TEST_c_c (casin, nan_value, nan_value, nan_value, nan_value);
1674
1675   TEST_c_c (casin, plus_zero, -1.5L, plus_zero, -1.194763217287109304111930828519090523536L);
1676   TEST_c_c (casin, minus_zero, -1.5L, minus_zero, -1.194763217287109304111930828519090523536L);
1677   TEST_c_c (casin, plus_zero, -1.0L, plus_zero, -0.8813735870195430252326093249797923090282L);
1678   TEST_c_c (casin, minus_zero, -1.0L, minus_zero, -0.8813735870195430252326093249797923090282L);
1679   TEST_c_c (casin, plus_zero, -0.5L, plus_zero, -0.4812118250596034474977589134243684231352L);
1680   TEST_c_c (casin, minus_zero, -0.5L, minus_zero, -0.4812118250596034474977589134243684231352L);
1681   TEST_c_c (casin, plus_zero, 0.5L, plus_zero, 0.4812118250596034474977589134243684231352L);
1682   TEST_c_c (casin, minus_zero, 0.5L, minus_zero, 0.4812118250596034474977589134243684231352L);
1683   TEST_c_c (casin, plus_zero, 1.0L, plus_zero, 0.8813735870195430252326093249797923090282L);
1684   TEST_c_c (casin, minus_zero, 1.0L, minus_zero, 0.8813735870195430252326093249797923090282L);
1685   TEST_c_c (casin, plus_zero, 1.5L, plus_zero, 1.194763217287109304111930828519090523536L);
1686   TEST_c_c (casin, minus_zero, 1.5L, minus_zero, 1.194763217287109304111930828519090523536L);
1687
1688   TEST_c_c (casin, -1.5L, plus_zero, -M_PI_2l, 0.9624236501192068949955178268487368462704L);
1689   TEST_c_c (casin, -1.5L, minus_zero, -M_PI_2l, -0.9624236501192068949955178268487368462704L);
1690   TEST_c_c (casin, -1.0L, plus_zero, -M_PI_2l, plus_zero);
1691   TEST_c_c (casin, -1.0L, minus_zero, -M_PI_2l, minus_zero);
1692   TEST_c_c (casin, -0.5L, plus_zero, -0.5235987755982988730771072305465838140329L, plus_zero);
1693   TEST_c_c (casin, -0.5L, minus_zero, -0.5235987755982988730771072305465838140329L, minus_zero);
1694   TEST_c_c (casin, 0.5L, plus_zero, 0.5235987755982988730771072305465838140329L, plus_zero);
1695   TEST_c_c (casin, 0.5L, minus_zero, 0.5235987755982988730771072305465838140329L, minus_zero);
1696   TEST_c_c (casin, 1.0L, plus_zero, M_PI_2l, plus_zero);
1697   TEST_c_c (casin, 1.0L, minus_zero, M_PI_2l, minus_zero);
1698   TEST_c_c (casin, 1.5L, plus_zero, M_PI_2l, 0.9624236501192068949955178268487368462704L);
1699   TEST_c_c (casin, 1.5L, minus_zero, M_PI_2l, -0.9624236501192068949955178268487368462704L);
1700
1701   TEST_c_c (casin, 0.75L, 1.25L, 0.453276177638793913448921196101971749L, 1.13239363160530819522266333696834467L);
1702   TEST_c_c (casin, -2, -3, -0.57065278432109940071028387968566963L, -1.9833870299165354323470769028940395L);
1703
1704   END (casin, complex);
1705 }
1706
1707
1708 static void
1709 casinh_test (void)
1710 {
1711   errno = 0;
1712   FUNC(casinh) (BUILD_COMPLEX (0.7L, 1.2L));
1713   if (errno == ENOSYS)
1714     /* Function not implemented.  */
1715     return;
1716
1717   START (casinh);
1718
1719   TEST_c_c (casinh, 0, 0, 0.0, 0.0);
1720   TEST_c_c (casinh, minus_zero, 0, minus_zero, 0);
1721   TEST_c_c (casinh, 0, minus_zero, 0.0, minus_zero);
1722   TEST_c_c (casinh, minus_zero, minus_zero, minus_zero, minus_zero);
1723
1724   TEST_c_c (casinh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1725   TEST_c_c (casinh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1726   TEST_c_c (casinh, minus_infty, plus_infty, minus_infty, M_PI_4l);
1727   TEST_c_c (casinh, minus_infty, minus_infty, minus_infty, -M_PI_4l);
1728
1729   TEST_c_c (casinh, -10.0, plus_infty, minus_infty, M_PI_2l);
1730   TEST_c_c (casinh, -10.0, minus_infty, minus_infty, -M_PI_2l);
1731   TEST_c_c (casinh, 0, plus_infty, plus_infty, M_PI_2l);
1732   TEST_c_c (casinh, 0, minus_infty, plus_infty, -M_PI_2l);
1733   TEST_c_c (casinh, minus_zero, plus_infty, minus_infty, M_PI_2l);
1734   TEST_c_c (casinh, minus_zero, minus_infty, minus_infty, -M_PI_2l);
1735   TEST_c_c (casinh, 0.1L, plus_infty, plus_infty, M_PI_2l);
1736   TEST_c_c (casinh, 0.1L, minus_infty, plus_infty, -M_PI_2l);
1737
1738   TEST_c_c (casinh, minus_infty, 0, minus_infty, 0.0);
1739   TEST_c_c (casinh, minus_infty, minus_zero, minus_infty, minus_zero);
1740   TEST_c_c (casinh, minus_infty, 100, minus_infty, 0.0);
1741   TEST_c_c (casinh, minus_infty, -100, minus_infty, minus_zero);
1742
1743   TEST_c_c (casinh, plus_infty, 0, plus_infty, 0.0);
1744   TEST_c_c (casinh, plus_infty, minus_zero, plus_infty, minus_zero);
1745   TEST_c_c (casinh, plus_infty, 0.5, plus_infty, 0.0);
1746   TEST_c_c (casinh, plus_infty, -0.5, plus_infty, minus_zero);
1747
1748   TEST_c_c (casinh, plus_infty, nan_value, plus_infty, nan_value);
1749   TEST_c_c (casinh, minus_infty, nan_value, minus_infty, nan_value);
1750
1751   TEST_c_c (casinh, nan_value, 0, nan_value, 0.0);
1752   TEST_c_c (casinh, nan_value, minus_zero, nan_value, minus_zero);
1753
1754   TEST_c_c (casinh, nan_value, plus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1755   TEST_c_c (casinh, nan_value, minus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1756
1757   TEST_c_c (casinh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1758   TEST_c_c (casinh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1759
1760   TEST_c_c (casinh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1761   TEST_c_c (casinh, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1762
1763   TEST_c_c (casinh, nan_value, nan_value, nan_value, nan_value);
1764
1765   TEST_c_c (casinh, plus_zero, -1.5L, 0.9624236501192068949955178268487368462704L, -M_PI_2l);
1766   TEST_c_c (casinh, minus_zero, -1.5L, -0.9624236501192068949955178268487368462704L, -M_PI_2l);
1767   TEST_c_c (casinh, plus_zero, -1.0L, plus_zero, -M_PI_2l);
1768   TEST_c_c (casinh, minus_zero, -1.0L, minus_zero, -M_PI_2l);
1769   TEST_c_c (casinh, plus_zero, -0.5L, plus_zero, -0.5235987755982988730771072305465838140329L);
1770   TEST_c_c (casinh, minus_zero, -0.5L, minus_zero, -0.5235987755982988730771072305465838140329L);
1771   TEST_c_c (casinh, plus_zero, 0.5L, plus_zero, 0.5235987755982988730771072305465838140329L);
1772   TEST_c_c (casinh, minus_zero, 0.5L, minus_zero, 0.5235987755982988730771072305465838140329L);
1773   TEST_c_c (casinh, plus_zero, 1.0L, plus_zero, M_PI_2l);
1774   TEST_c_c (casinh, minus_zero, 1.0L, minus_zero, M_PI_2l);
1775   TEST_c_c (casinh, plus_zero, 1.5L, 0.9624236501192068949955178268487368462704L, M_PI_2l);
1776   TEST_c_c (casinh, minus_zero, 1.5L, -0.9624236501192068949955178268487368462704L, M_PI_2l);
1777
1778   TEST_c_c (casinh, -1.5L, plus_zero, -1.194763217287109304111930828519090523536L, plus_zero);
1779   TEST_c_c (casinh, -1.5L, minus_zero, -1.194763217287109304111930828519090523536L, minus_zero);
1780   TEST_c_c (casinh, -1.0L, plus_zero, -0.8813735870195430252326093249797923090282L, plus_zero);
1781   TEST_c_c (casinh, -1.0L, minus_zero, -0.8813735870195430252326093249797923090282L, minus_zero);
1782   TEST_c_c (casinh, -0.5L, plus_zero, -0.4812118250596034474977589134243684231352L, plus_zero);
1783   TEST_c_c (casinh, -0.5L, minus_zero, -0.4812118250596034474977589134243684231352L, minus_zero);
1784   TEST_c_c (casinh, 0.5L, plus_zero, 0.4812118250596034474977589134243684231352L, plus_zero);
1785   TEST_c_c (casinh, 0.5L, minus_zero, 0.4812118250596034474977589134243684231352L, minus_zero);
1786   TEST_c_c (casinh, 1.0L, plus_zero, 0.8813735870195430252326093249797923090282L, plus_zero);
1787   TEST_c_c (casinh, 1.0L, minus_zero, 0.8813735870195430252326093249797923090282L, minus_zero);
1788   TEST_c_c (casinh, 1.5L, plus_zero, 1.194763217287109304111930828519090523536L, plus_zero);
1789   TEST_c_c (casinh, 1.5L, minus_zero, 1.194763217287109304111930828519090523536L, minus_zero);
1790
1791   TEST_c_c (casinh, 0.75L, 1.25L, 1.03171853444778027336364058631006594L, 0.911738290968487636358489564316731207L);
1792   TEST_c_c (casinh, -2, -3, -1.9686379257930962917886650952454982L, -0.96465850440760279204541105949953237L);
1793
1794   END (casinh, complex);
1795 }
1796
1797
1798 static void
1799 catan_test (void)
1800 {
1801   errno = 0;
1802   FUNC(catan) (BUILD_COMPLEX (0.7L, 1.2L));
1803   if (errno == ENOSYS)
1804     /* Function not implemented.  */
1805     return;
1806
1807   START (catan);
1808
1809   TEST_c_c (catan, 0, 0, 0, 0);
1810   TEST_c_c (catan, minus_zero, 0, minus_zero, 0);
1811   TEST_c_c (catan, 0, minus_zero, 0, minus_zero);
1812   TEST_c_c (catan, minus_zero, minus_zero, minus_zero, minus_zero);
1813
1814   TEST_c_c (catan, plus_infty, plus_infty, M_PI_2l, 0);
1815   TEST_c_c (catan, plus_infty, minus_infty, M_PI_2l, minus_zero);
1816   TEST_c_c (catan, minus_infty, plus_infty, -M_PI_2l, 0);
1817   TEST_c_c (catan, minus_infty, minus_infty, -M_PI_2l, minus_zero);
1818
1819
1820   TEST_c_c (catan, plus_infty, -10.0, M_PI_2l, minus_zero);
1821   TEST_c_c (catan, minus_infty, -10.0, -M_PI_2l, minus_zero);
1822   TEST_c_c (catan, plus_infty, minus_zero, M_PI_2l, minus_zero);
1823   TEST_c_c (catan, minus_infty, minus_zero, -M_PI_2l, minus_zero);
1824   TEST_c_c (catan, plus_infty, 0.0, M_PI_2l, 0);
1825   TEST_c_c (catan, minus_infty, 0.0, -M_PI_2l, 0);
1826   TEST_c_c (catan, plus_infty, 0.1L, M_PI_2l, 0);
1827   TEST_c_c (catan, minus_infty, 0.1L, -M_PI_2l, 0);
1828
1829   TEST_c_c (catan, 0.0, minus_infty, M_PI_2l, minus_zero);
1830   TEST_c_c (catan, minus_zero, minus_infty, -M_PI_2l, minus_zero);
1831   TEST_c_c (catan, 100.0, minus_infty, M_PI_2l, minus_zero);
1832   TEST_c_c (catan, -100.0, minus_infty, -M_PI_2l, minus_zero);
1833
1834   TEST_c_c (catan, 0.0, plus_infty, M_PI_2l, 0);
1835   TEST_c_c (catan, minus_zero, plus_infty, -M_PI_2l, 0);
1836   TEST_c_c (catan, 0.5, plus_infty, M_PI_2l, 0);
1837   TEST_c_c (catan, -0.5, plus_infty, -M_PI_2l, 0);
1838
1839   TEST_c_c (catan, nan_value, 0.0, nan_value, 0);
1840   TEST_c_c (catan, nan_value, minus_zero, nan_value, minus_zero);
1841
1842   TEST_c_c (catan, nan_value, plus_infty, nan_value, 0);
1843   TEST_c_c (catan, nan_value, minus_infty, nan_value, minus_zero);
1844
1845   TEST_c_c (catan, 0.0, nan_value, nan_value, nan_value);
1846   TEST_c_c (catan, minus_zero, nan_value, nan_value, nan_value);
1847
1848   TEST_c_c (catan, plus_infty, nan_value, M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1849   TEST_c_c (catan, minus_infty, nan_value, -M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1850
1851   TEST_c_c (catan, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1852   TEST_c_c (catan, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1853
1854   TEST_c_c (catan, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1855   TEST_c_c (catan, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1856
1857   TEST_c_c (catan, nan_value, nan_value, nan_value, nan_value);
1858
1859   TEST_c_c (catan, 0.75L, 1.25L, 1.10714871779409050301706546017853704L, 0.549306144334054845697622618461262852L);
1860   TEST_c_c (catan, -2, -3, -1.4099210495965755225306193844604208L, -0.22907268296853876629588180294200276L);
1861
1862   END (catan, complex);
1863 }
1864
1865 static void
1866 catanh_test (void)
1867 {
1868   errno = 0;
1869   FUNC(catanh) (BUILD_COMPLEX (0.7L, 1.2L));
1870   if (errno == ENOSYS)
1871     /* Function not implemented.  */
1872     return;
1873
1874   START (catanh);
1875
1876   TEST_c_c (catanh, 0, 0, 0.0, 0.0);
1877   TEST_c_c (catanh, minus_zero, 0, minus_zero, 0.0);
1878   TEST_c_c (catanh, 0, minus_zero, 0.0, minus_zero);
1879   TEST_c_c (catanh, minus_zero, minus_zero, minus_zero, minus_zero);
1880
1881   TEST_c_c (catanh, plus_infty, plus_infty, 0.0, M_PI_2l);
1882   TEST_c_c (catanh, plus_infty, minus_infty, 0.0, -M_PI_2l);
1883   TEST_c_c (catanh, minus_infty, plus_infty, minus_zero, M_PI_2l);
1884   TEST_c_c (catanh, minus_infty, minus_infty, minus_zero, -M_PI_2l);
1885
1886   TEST_c_c (catanh, -10.0, plus_infty, minus_zero, M_PI_2l);
1887   TEST_c_c (catanh, -10.0, minus_infty, minus_zero, -M_PI_2l);
1888   TEST_c_c (catanh, minus_zero, plus_infty, minus_zero, M_PI_2l);
1889   TEST_c_c (catanh, minus_zero, minus_infty, minus_zero, -M_PI_2l);
1890   TEST_c_c (catanh, 0, plus_infty, 0.0, M_PI_2l);
1891   TEST_c_c (catanh, 0, minus_infty, 0.0, -M_PI_2l);
1892   TEST_c_c (catanh, 0.1L, plus_infty, 0.0, M_PI_2l);
1893   TEST_c_c (catanh, 0.1L, minus_infty, 0.0, -M_PI_2l);
1894
1895   TEST_c_c (catanh, minus_infty, 0, minus_zero, M_PI_2l);
1896   TEST_c_c (catanh, minus_infty, minus_zero, minus_zero, -M_PI_2l);
1897   TEST_c_c (catanh, minus_infty, 100, minus_zero, M_PI_2l);
1898   TEST_c_c (catanh, minus_infty, -100, minus_zero, -M_PI_2l);
1899
1900   TEST_c_c (catanh, plus_infty, 0, 0.0, M_PI_2l);
1901   TEST_c_c (catanh, plus_infty, minus_zero, 0.0, -M_PI_2l);
1902   TEST_c_c (catanh, plus_infty, 0.5, 0.0, M_PI_2l);
1903   TEST_c_c (catanh, plus_infty, -0.5, 0.0, -M_PI_2l);
1904
1905   TEST_c_c (catanh, 0, nan_value, 0.0, nan_value);
1906   TEST_c_c (catanh, minus_zero, nan_value, minus_zero, nan_value);
1907
1908   TEST_c_c (catanh, plus_infty, nan_value, 0.0, nan_value);
1909   TEST_c_c (catanh, minus_infty, nan_value, minus_zero, nan_value);
1910
1911   TEST_c_c (catanh, nan_value, 0, nan_value, nan_value);
1912   TEST_c_c (catanh, nan_value, minus_zero, nan_value, nan_value);
1913
1914   TEST_c_c (catanh, nan_value, plus_infty, 0.0, M_PI_2l, IGNORE_ZERO_INF_SIGN);
1915   TEST_c_c (catanh, nan_value, minus_infty, 0.0, -M_PI_2l, IGNORE_ZERO_INF_SIGN);
1916
1917   TEST_c_c (catanh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1918   TEST_c_c (catanh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1919
1920   TEST_c_c (catanh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1921   TEST_c_c (catanh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1922
1923   TEST_c_c (catanh, nan_value, nan_value, nan_value, nan_value);
1924
1925   TEST_c_c (catanh, 0.75L, 1.25L, 0.261492138795671927078652057366532140L, 0.996825126463918666098902241310446708L);
1926   TEST_c_c (catanh, -2, -3, -0.14694666622552975204743278515471595L, -1.3389725222944935611241935759091443L);
1927
1928   END (catanh, complex);
1929 }
1930
1931 static void
1932 cbrt_test (void)
1933 {
1934   errno = 0;
1935   FUNC(cbrt) (8);
1936   if (errno == ENOSYS)
1937     /* Function not implemented.  */
1938     return;
1939
1940   START (cbrt);
1941
1942   TEST_f_f (cbrt, 0.0, 0.0);
1943   TEST_f_f (cbrt, minus_zero, minus_zero);
1944
1945   TEST_f_f (cbrt, plus_infty, plus_infty);
1946   TEST_f_f (cbrt, minus_infty, minus_infty);
1947   TEST_f_f (cbrt, nan_value, nan_value);
1948
1949   TEST_f_f (cbrt, -0.001L, -0.1L);
1950   TEST_f_f (cbrt, 8, 2);
1951   TEST_f_f (cbrt, -27.0, -3.0);
1952   TEST_f_f (cbrt, 0.9921875L, 0.997389022060725270579075195353955217L);
1953   TEST_f_f (cbrt, 0.75L, 0.908560296416069829445605878163630251L);
1954
1955   END (cbrt);
1956 }
1957
1958
1959 static void
1960 ccos_test (void)
1961 {
1962   errno = 0;
1963   FUNC(ccos) (BUILD_COMPLEX (0, 0));
1964   if (errno == ENOSYS)
1965     /* Function not implemented.  */
1966     return;
1967
1968   START (ccos);
1969
1970   TEST_c_c (ccos, 0.0, 0.0, 1.0, minus_zero);
1971   TEST_c_c (ccos, minus_zero, 0.0, 1.0, 0.0);
1972   TEST_c_c (ccos, 0.0, minus_zero, 1.0, 0.0);
1973   TEST_c_c (ccos, minus_zero, minus_zero, 1.0, minus_zero);
1974
1975   TEST_c_c (ccos, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1976   TEST_c_c (ccos, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1977   TEST_c_c (ccos, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1978   TEST_c_c (ccos, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1979
1980   TEST_c_c (ccos, 0.0, plus_infty, plus_infty, minus_zero);
1981   TEST_c_c (ccos, 0.0, minus_infty, plus_infty, 0.0);
1982   TEST_c_c (ccos, minus_zero, plus_infty, plus_infty, 0.0);
1983   TEST_c_c (ccos, minus_zero, minus_infty, plus_infty, minus_zero);
1984
1985   TEST_c_c (ccos, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1986   TEST_c_c (ccos, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1987   TEST_c_c (ccos, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1988   TEST_c_c (ccos, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1989
1990   TEST_c_c (ccos, 4.625, plus_infty, minus_infty, plus_infty);
1991   TEST_c_c (ccos, 4.625, minus_infty, minus_infty, minus_infty);
1992   TEST_c_c (ccos, -4.625, plus_infty, minus_infty, minus_infty);
1993   TEST_c_c (ccos, -4.625, minus_infty, minus_infty, plus_infty);
1994
1995   TEST_c_c (ccos, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1996   TEST_c_c (ccos, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1997   TEST_c_c (ccos, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1998   TEST_c_c (ccos, minus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1999
2000   TEST_c_c (ccos, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2001   TEST_c_c (ccos, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2002
2003   TEST_c_c (ccos, nan_value, plus_infty, plus_infty, nan_value);
2004   TEST_c_c (ccos, nan_value, minus_infty, plus_infty, nan_value);
2005
2006   TEST_c_c (ccos, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2007   TEST_c_c (ccos, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2008
2009   TEST_c_c (ccos, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2010   TEST_c_c (ccos, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2011
2012   TEST_c_c (ccos, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2013   TEST_c_c (ccos, -10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2014
2015   TEST_c_c (ccos, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2016   TEST_c_c (ccos, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2017
2018   TEST_c_c (ccos, nan_value, nan_value, nan_value, nan_value);
2019
2020   TEST_c_c (ccos, 0.75L, 1.25L, 1.38173873063425888530729933139078645L, -1.09193013555397466170919531722024128L);
2021   TEST_c_c (ccos, -2, -3, -4.18962569096880723013255501961597373L, -9.10922789375533659797919726277886212L);
2022
2023   TEST_c_c (ccos, 0.75, 89.5, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
2024   TEST_c_c (ccos, 0.75, -89.5, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
2025   TEST_c_c (ccos, -0.75, 89.5, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
2026   TEST_c_c (ccos, -0.75, -89.5, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
2027
2028 #ifndef TEST_FLOAT
2029   TEST_c_c (ccos, 0.75, 710.5, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
2030   TEST_c_c (ccos, 0.75, -710.5, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
2031   TEST_c_c (ccos, -0.75, 710.5, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
2032   TEST_c_c (ccos, -0.75, -710.5, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
2033 #endif
2034
2035 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2036   TEST_c_c (ccos, 0.75, 11357.25, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
2037   TEST_c_c (ccos, 0.75, -11357.25, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
2038   TEST_c_c (ccos, -0.75, 11357.25, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
2039   TEST_c_c (ccos, -0.75, -11357.25, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
2040 #endif
2041
2042 #ifdef TEST_FLOAT
2043   TEST_c_c (ccos, 0x1p-149, 180, plus_infty, -1.043535896672617552965983803453927655332e33L, OVERFLOW_EXCEPTION);
2044 #endif
2045
2046 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2047   TEST_c_c (ccos, 0x1p-1074, 1440, plus_infty, -5.981479269486130556466515778180916082415e301L, OVERFLOW_EXCEPTION);
2048 #endif
2049
2050 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2051   TEST_c_c (ccos, 0x1p-16434L, 22730, plus_infty, -1.217853148905605987081057582351152052687e4924L, OVERFLOW_EXCEPTION);
2052 #endif
2053
2054   END (ccos, complex);
2055 }
2056
2057
2058 static void
2059 ccosh_test (void)
2060 {
2061   errno = 0;
2062   FUNC(ccosh) (BUILD_COMPLEX (0.7L, 1.2L));
2063   if (errno == ENOSYS)
2064     /* Function not implemented.  */
2065     return;
2066
2067   START (ccosh);
2068
2069   TEST_c_c (ccosh, 0.0, 0.0, 1.0, 0.0);
2070   TEST_c_c (ccosh, minus_zero, 0.0, 1.0, minus_zero);
2071   TEST_c_c (ccosh, 0.0, minus_zero, 1.0, minus_zero);
2072   TEST_c_c (ccosh, minus_zero, minus_zero, 1.0, 0.0);
2073
2074   TEST_c_c (ccosh, 0.0, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2075   TEST_c_c (ccosh, minus_zero, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2076   TEST_c_c (ccosh, 0.0, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2077   TEST_c_c (ccosh, minus_zero, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2078
2079   TEST_c_c (ccosh, plus_infty, 0.0, plus_infty, 0.0);
2080   TEST_c_c (ccosh, minus_infty, 0.0, plus_infty, minus_zero);
2081   TEST_c_c (ccosh, plus_infty, minus_zero, plus_infty, minus_zero);
2082   TEST_c_c (ccosh, minus_infty, minus_zero, plus_infty, 0.0);
2083
2084   TEST_c_c (ccosh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2085   TEST_c_c (ccosh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2086   TEST_c_c (ccosh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2087   TEST_c_c (ccosh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2088
2089   TEST_c_c (ccosh, plus_infty, 4.625, minus_infty, minus_infty);
2090   TEST_c_c (ccosh, minus_infty, 4.625, minus_infty, plus_infty);
2091   TEST_c_c (ccosh, plus_infty, -4.625, minus_infty, plus_infty);
2092   TEST_c_c (ccosh, minus_infty, -4.625, minus_infty, minus_infty);
2093
2094   TEST_c_c (ccosh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2095   TEST_c_c (ccosh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2096   TEST_c_c (ccosh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2097   TEST_c_c (ccosh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2098
2099   TEST_c_c (ccosh, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2100   TEST_c_c (ccosh, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2101
2102   TEST_c_c (ccosh, plus_infty, nan_value, plus_infty, nan_value);
2103   TEST_c_c (ccosh, minus_infty, nan_value, plus_infty, nan_value);
2104
2105   TEST_c_c (ccosh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2106   TEST_c_c (ccosh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2107
2108   TEST_c_c (ccosh, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2109   TEST_c_c (ccosh, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2110
2111   TEST_c_c (ccosh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2112   TEST_c_c (ccosh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2113
2114   TEST_c_c (ccosh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2115   TEST_c_c (ccosh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2116
2117   TEST_c_c (ccosh, nan_value, nan_value, nan_value, nan_value);
2118
2119   TEST_c_c (ccosh, 0.75L, 1.25L, 0.408242591877968807788852146397499084L, 0.780365930845853240391326216300863152L);
2120
2121   TEST_c_c (ccosh, -2, -3, -3.72454550491532256547397070325597253L, 0.511822569987384608834463849801875634L);
2122
2123   TEST_c_c (ccosh, 89.5, 0.75, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
2124   TEST_c_c (ccosh, -89.5, 0.75, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
2125   TEST_c_c (ccosh, 89.5, -0.75, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
2126   TEST_c_c (ccosh, -89.5, -0.75, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
2127
2128 #ifndef TEST_FLOAT
2129   TEST_c_c (ccosh, 710.5, 0.75, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
2130   TEST_c_c (ccosh, -710.5, 0.75, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
2131   TEST_c_c (ccosh, 710.5, -0.75, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
2132   TEST_c_c (ccosh, -710.5, -0.75, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
2133 #endif
2134
2135 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2136   TEST_c_c (ccosh, 11357.25, 0.75, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
2137   TEST_c_c (ccosh, -11357.25, 0.75, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
2138   TEST_c_c (ccosh, 11357.25, -0.75, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
2139   TEST_c_c (ccosh, -11357.25, -0.75, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
2140 #endif
2141
2142 #ifdef TEST_FLOAT
2143   TEST_c_c (ccosh, 180, 0x1p-149, plus_infty, 1.043535896672617552965983803453927655332e33L, OVERFLOW_EXCEPTION);
2144 #endif
2145
2146 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2147   TEST_c_c (ccosh, 1440, 0x1p-1074, plus_infty, 5.981479269486130556466515778180916082415e301L, OVERFLOW_EXCEPTION);
2148 #endif
2149
2150 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2151   TEST_c_c (ccosh, 22730, 0x1p-16434L, plus_infty, 1.217853148905605987081057582351152052687e4924L, OVERFLOW_EXCEPTION);
2152 #endif
2153
2154   END (ccosh, complex);
2155 }
2156
2157
2158 static void
2159 ceil_test (void)
2160 {
2161   START (ceil);
2162
2163   TEST_f_f (ceil, 0.0, 0.0);
2164   TEST_f_f (ceil, minus_zero, minus_zero);
2165   TEST_f_f (ceil, plus_infty, plus_infty);
2166   TEST_f_f (ceil, minus_infty, minus_infty);
2167   TEST_f_f (ceil, nan_value, nan_value);
2168
2169   TEST_f_f (ceil, M_PIl, 4.0);
2170   TEST_f_f (ceil, -M_PIl, -3.0);
2171   TEST_f_f (ceil, 0.1, 1.0);
2172   TEST_f_f (ceil, 0.25, 1.0);
2173   TEST_f_f (ceil, 0.625, 1.0);
2174   TEST_f_f (ceil, -0.1, minus_zero);
2175   TEST_f_f (ceil, -0.25, minus_zero);
2176   TEST_f_f (ceil, -0.625, minus_zero);
2177
2178 #ifdef TEST_LDOUBLE
2179   /* The result can only be represented in long double.  */
2180   TEST_f_f (ceil, 4503599627370495.5L, 4503599627370496.0L);
2181   TEST_f_f (ceil, 4503599627370496.25L, 4503599627370497.0L);
2182   TEST_f_f (ceil, 4503599627370496.5L, 4503599627370497.0L);
2183   TEST_f_f (ceil, 4503599627370496.75L, 4503599627370497.0L);
2184   TEST_f_f (ceil, 4503599627370497.5L, 4503599627370498.0L);
2185
2186   TEST_f_f (ceil, -4503599627370495.5L, -4503599627370495.0L);
2187   TEST_f_f (ceil, -4503599627370496.25L, -4503599627370496.0L);
2188   TEST_f_f (ceil, -4503599627370496.5L, -4503599627370496.0L);
2189   TEST_f_f (ceil, -4503599627370496.75L, -4503599627370496.0L);
2190   TEST_f_f (ceil, -4503599627370497.5L, -4503599627370497.0L);
2191
2192 # if LDBL_MANT_DIG > 100
2193   TEST_f_f (ceil, 4503599627370494.5000000000001L, 4503599627370495.0L);
2194   TEST_f_f (ceil, 4503599627370495.5000000000001L, 4503599627370496.0L);
2195   TEST_f_f (ceil, 4503599627370496.5000000000001L, 4503599627370497.0L);
2196   TEST_f_f (ceil, -4503599627370494.5000000000001L, -4503599627370494.0L);
2197   TEST_f_f (ceil, -4503599627370495.5000000000001L, -4503599627370495.0L);
2198   TEST_f_f (ceil, -4503599627370496.5000000000001L, -4503599627370496.0L);
2199 # endif
2200
2201   TEST_f_f (ceil, 9007199254740991.5L, 9007199254740992.0L);
2202   TEST_f_f (ceil, 9007199254740992.25L, 9007199254740993.0L);
2203   TEST_f_f (ceil, 9007199254740992.5L, 9007199254740993.0L);
2204   TEST_f_f (ceil, 9007199254740992.75L, 9007199254740993.0L);
2205   TEST_f_f (ceil, 9007199254740993.5L, 9007199254740994.0L);
2206
2207   TEST_f_f (ceil, -9007199254740991.5L, -9007199254740991.0L);
2208   TEST_f_f (ceil, -9007199254740992.25L, -9007199254740992.0L);
2209   TEST_f_f (ceil, -9007199254740992.5L, -9007199254740992.0L);
2210   TEST_f_f (ceil, -9007199254740992.75L, -9007199254740992.0L);
2211   TEST_f_f (ceil, -9007199254740993.5L, -9007199254740993.0L);
2212
2213 # if LDBL_MANT_DIG > 100
2214   TEST_f_f (ceil, 9007199254740991.0000000000001L, 9007199254740992.0L);
2215   TEST_f_f (ceil, 9007199254740992.0000000000001L, 9007199254740993.0L);
2216   TEST_f_f (ceil, 9007199254740993.0000000000001L, 9007199254740994.0L);
2217   TEST_f_f (ceil, 9007199254740991.5000000000001L, 9007199254740992.0L);
2218   TEST_f_f (ceil, 9007199254740992.5000000000001L, 9007199254740993.0L);
2219   TEST_f_f (ceil, 9007199254740993.5000000000001L, 9007199254740994.0L);
2220
2221   TEST_f_f (ceil, -9007199254740991.0000000000001L, -9007199254740991.0L);
2222   TEST_f_f (ceil, -9007199254740992.0000000000001L, -9007199254740992.0L);
2223   TEST_f_f (ceil, -9007199254740993.0000000000001L, -9007199254740993.0L);
2224   TEST_f_f (ceil, -9007199254740991.5000000000001L, -9007199254740991.0L);
2225   TEST_f_f (ceil, -9007199254740992.5000000000001L, -9007199254740992.0L);
2226   TEST_f_f (ceil, -9007199254740993.5000000000001L, -9007199254740993.0L);
2227 # endif
2228
2229   TEST_f_f (ceil, 72057594037927935.5L, 72057594037927936.0L);
2230   TEST_f_f (ceil, 72057594037927936.25L, 72057594037927937.0L);
2231   TEST_f_f (ceil, 72057594037927936.5L, 72057594037927937.0L);
2232   TEST_f_f (ceil, 72057594037927936.75L, 72057594037927937.0L);
2233   TEST_f_f (ceil, 72057594037927937.5L, 72057594037927938.0L);
2234
2235   TEST_f_f (ceil, -72057594037927935.5L, -72057594037927935.0L);
2236   TEST_f_f (ceil, -72057594037927936.25L, -72057594037927936.0L);
2237   TEST_f_f (ceil, -72057594037927936.5L, -72057594037927936.0L);
2238   TEST_f_f (ceil, -72057594037927936.75L, -72057594037927936.0L);
2239   TEST_f_f (ceil, -72057594037927937.5L, -72057594037927937.0L);
2240
2241   TEST_f_f (ceil, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
2242   TEST_f_f (ceil, 10141204801825835211973625643008.25L, 10141204801825835211973625643009.0L);
2243   TEST_f_f (ceil, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
2244   TEST_f_f (ceil, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
2245   TEST_f_f (ceil, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
2246 #endif
2247
2248   END (ceil);
2249 }
2250
2251
2252 static void
2253 cexp_test (void)
2254 {
2255   errno = 0;
2256   FUNC(cexp) (BUILD_COMPLEX (0, 0));
2257   if (errno == ENOSYS)
2258     /* Function not implemented.  */
2259     return;
2260
2261   START (cexp);
2262
2263   TEST_c_c (cexp, plus_zero, plus_zero, 1, 0.0);
2264   TEST_c_c (cexp, minus_zero, plus_zero, 1, 0.0);
2265   TEST_c_c (cexp, plus_zero, minus_zero, 1, minus_zero);
2266   TEST_c_c (cexp, minus_zero, minus_zero, 1, minus_zero);
2267
2268   TEST_c_c (cexp, plus_infty, plus_zero, plus_infty, 0.0);
2269   TEST_c_c (cexp, plus_infty, minus_zero, plus_infty, minus_zero);
2270
2271   TEST_c_c (cexp, minus_infty, plus_zero, 0.0, 0.0);
2272   TEST_c_c (cexp, minus_infty, minus_zero, 0.0, minus_zero);
2273
2274   TEST_c_c (cexp, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2275   TEST_c_c (cexp, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2276
2277   TEST_c_c (cexp, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2278   TEST_c_c (cexp, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2279
2280   TEST_c_c (cexp, 100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2281   TEST_c_c (cexp, -100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2282
2283   TEST_c_c (cexp, 100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2284   TEST_c_c (cexp, -100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2285
2286   TEST_c_c (cexp, minus_infty, 2.0, minus_zero, 0.0);
2287   TEST_c_c (cexp, minus_infty, 4.0, minus_zero, minus_zero);
2288   TEST_c_c (cexp, plus_infty, 2.0, minus_infty, plus_infty);
2289   TEST_c_c (cexp, plus_infty, 4.0, minus_infty, minus_infty);
2290
2291   TEST_c_c (cexp, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2292   TEST_c_c (cexp, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2293
2294   TEST_c_c (cexp, minus_infty, plus_infty, 0.0, 0.0, IGNORE_ZERO_INF_SIGN);
2295   TEST_c_c (cexp, minus_infty, minus_infty, 0.0, minus_zero, IGNORE_ZERO_INF_SIGN);
2296
2297   TEST_c_c (cexp, minus_infty, nan_value, 0, 0, IGNORE_ZERO_INF_SIGN);
2298
2299   TEST_c_c (cexp, plus_infty, nan_value, plus_infty, nan_value);
2300
2301   TEST_c_c (cexp, nan_value, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2302   TEST_c_c (cexp, nan_value, 1.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2303
2304   TEST_c_c (cexp, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2305   TEST_c_c (cexp, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2306   TEST_c_c (cexp, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2307   TEST_c_c (cexp, nan_value, nan_value, nan_value, nan_value);
2308
2309   TEST_c_c (cexp, 0.75L, 1.25L, 0.667537446429131586942201977015932112L, 2.00900045494094876258347228145863909L);
2310   TEST_c_c (cexp, -2.0, -3.0, -0.13398091492954261346140525546115575L, -0.019098516261135196432576240858800925L);
2311
2312   TEST_c_c (cexp, 0, 0x1p65, 0.99888622066058013610642172179340364209972L, -0.047183876212354673805106149805700013943218L);
2313   TEST_c_c (cexp, 0, -0x1p65, 0.99888622066058013610642172179340364209972L, 0.047183876212354673805106149805700013943218L);
2314   TEST_c_c (cexp, 50, 0x1p127, 4.053997150228616856622417636046265337193e21L, 3.232070315463388524466674772633810238819e21L);
2315
2316 #ifndef TEST_FLOAT
2317   TEST_c_c (cexp, 0, 1e22, 0.5232147853951389454975944733847094921409L, -0.8522008497671888017727058937530293682618L);
2318   TEST_c_c (cexp, 0, 0x1p1023, -0.826369834614147994500785680811743734805L, 0.5631277798508840134529434079444683477104L);
2319   TEST_c_c (cexp, 500, 0x1p1023, -1.159886268932754433233243794561351783426e217L, 7.904017694554466595359379965081774849708e216L);
2320 #endif
2321
2322 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2323   TEST_c_c (cexp, 0, 0x1p16383L, 0.9210843909921906206874509522505756251609L, 0.3893629985894208126948115852610595405563L);
2324   TEST_c_c (cexp, -10000, 0x1p16383L, 1.045876464564882298442774542991176546722e-4343L, 4.421154026488516836023811173959413420548e-4344L);
2325 #endif
2326
2327   TEST_c_c (cexp, 88.75, 0.75, 2.558360358486542817001900410314204322891e38L, 2.383359453227311447654736314679677655100e38L);
2328   TEST_c_c (cexp, -95, 0.75, 4.039714446238306526889476684000081624047e-42L, 3.763383677300535390271646960780570275931e-42L, UNDERFLOW_EXCEPTION_FLOAT);
2329
2330 #ifndef TEST_FLOAT
2331   TEST_c_c (cexp, 709.8125, 0.75, 1.355121963080879535248452862759108365762e308L, 1.262426823598609432507811340856186873507e308L);
2332   TEST_c_c (cexp, -720, 0.75, 1.486960657116368433685753325516638551722e-313L, 1.385247284245720590980701226843815229385e-313L, UNDERFLOW_EXCEPTION_DOUBLE);
2333 #endif
2334
2335 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2336   TEST_c_c (cexp, 11356.5625, 0.75, 9.052188470850960144814815984311663764287e4931L, 8.432986734191301036267148978260970230200e4931L);
2337   TEST_c_c (cexp, -11370, 0.75, 8.631121063182211587489310508568170739592e-4939L, 8.040721827809267291427062346918413482824e-4939L, UNDERFLOW_EXCEPTION);
2338 #endif
2339
2340 #ifdef TEST_FLOAT
2341   TEST_c_c (cexp, 180, 0x1p-149, plus_infty, 2.087071793345235105931967606907855310664e33L, OVERFLOW_EXCEPTION);
2342 #endif
2343
2344 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2345   TEST_c_c (cexp, 1440, 0x1p-1074, plus_infty, 1.196295853897226111293303155636183216483e302L, OVERFLOW_EXCEPTION);
2346 #endif
2347
2348 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2349   TEST_c_c (cexp, 22730, 0x1p-16434L, plus_infty, 2.435706297811211974162115164702304105374e4924L, OVERFLOW_EXCEPTION);
2350 #endif
2351
2352   TEST_c_c (cexp, 1e6, 0, plus_infty, 0, OVERFLOW_EXCEPTION);
2353   TEST_c_c (cexp, 1e6, min_value, plus_infty, plus_infty, OVERFLOW_EXCEPTION);
2354   TEST_c_c (cexp, 1e6, -min_value, plus_infty, minus_infty, OVERFLOW_EXCEPTION);
2355
2356   END (cexp, complex);
2357 }
2358
2359
2360 static void
2361 cimag_test (void)
2362 {
2363   START (cimag);
2364   TEST_c_f (cimag, 1.0, 0.0, 0.0);
2365   TEST_c_f (cimag, 1.0, minus_zero, minus_zero);
2366   TEST_c_f (cimag, 1.0, nan_value, nan_value);
2367   TEST_c_f (cimag, nan_value, nan_value, nan_value);
2368   TEST_c_f (cimag, 1.0, plus_infty, plus_infty);
2369   TEST_c_f (cimag, 1.0, minus_infty, minus_infty);
2370   TEST_c_f (cimag, 2.0, 3.0, 3.0);
2371
2372   END (cimag);
2373 }
2374
2375 static void
2376 clog_test (void)
2377 {
2378   errno = 0;
2379   FUNC(clog) (BUILD_COMPLEX (-2, -3));
2380   if (errno == ENOSYS)
2381     /* Function not implemented.  */
2382     return;
2383
2384   START (clog);
2385
2386   TEST_c_c (clog, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2387   TEST_c_c (clog, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2388
2389   TEST_c_c (clog, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
2390   TEST_c_c (clog, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
2391
2392   TEST_c_c (clog, minus_infty, plus_infty, plus_infty, M_PI_34l);
2393   TEST_c_c (clog, minus_infty, minus_infty, plus_infty, -M_PI_34l);
2394
2395   TEST_c_c (clog, plus_infty, plus_infty, plus_infty, M_PI_4l);
2396   TEST_c_c (clog, plus_infty, minus_infty, plus_infty, -M_PI_4l);
2397
2398   TEST_c_c (clog, 0, plus_infty, plus_infty, M_PI_2l);
2399   TEST_c_c (clog, 3, plus_infty, plus_infty, M_PI_2l);
2400   TEST_c_c (clog, minus_zero, plus_infty, plus_infty, M_PI_2l);
2401   TEST_c_c (clog, -3, plus_infty, plus_infty, M_PI_2l);
2402   TEST_c_c (clog, 0, minus_infty, plus_infty, -M_PI_2l);
2403   TEST_c_c (clog, 3, minus_infty, plus_infty, -M_PI_2l);
2404   TEST_c_c (clog, minus_zero, minus_infty, plus_infty, -M_PI_2l);
2405   TEST_c_c (clog, -3, minus_infty, plus_infty, -M_PI_2l);
2406
2407   TEST_c_c (clog, minus_infty, 0, plus_infty, M_PIl);
2408   TEST_c_c (clog, minus_infty, 1, plus_infty, M_PIl);
2409   TEST_c_c (clog, minus_infty, minus_zero, plus_infty, -M_PIl);
2410   TEST_c_c (clog, minus_infty, -1, plus_infty, -M_PIl);
2411
2412   TEST_c_c (clog, plus_infty, 0, plus_infty, 0.0);
2413   TEST_c_c (clog, plus_infty, 1, plus_infty, 0.0);
2414   TEST_c_c (clog, plus_infty, minus_zero, plus_infty, minus_zero);
2415   TEST_c_c (clog, plus_infty, -1, plus_infty, minus_zero);
2416
2417   TEST_c_c (clog, plus_infty, nan_value, plus_infty, nan_value);
2418   TEST_c_c (clog, minus_infty, nan_value, plus_infty, nan_value);
2419
2420   TEST_c_c (clog, nan_value, plus_infty, plus_infty, nan_value);
2421   TEST_c_c (clog, nan_value, minus_infty, plus_infty, nan_value);
2422
2423   TEST_c_c (clog, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2424   TEST_c_c (clog, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2425   TEST_c_c (clog, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2426   TEST_c_c (clog, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2427
2428   TEST_c_c (clog, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2429   TEST_c_c (clog, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2430   TEST_c_c (clog, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2431   TEST_c_c (clog, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2432
2433   TEST_c_c (clog, nan_value, nan_value, nan_value, nan_value);
2434
2435   TEST_c_c (clog, 0.75L, 1.25L, 0.376885901188190075998919126749298416L, 1.03037682652431246378774332703115153L);
2436   TEST_c_c (clog, -2, -3, 1.2824746787307683680267437207826593L, -2.1587989303424641704769327722648368L);
2437
2438   TEST_c_c (clog, 0x1.fffffep+127L, 0x1.fffffep+127L, 89.06941264234832570836679262104313101776L, M_PI_4l);
2439   TEST_c_c (clog, 0x1.fffffep+127L, 1.0L, 88.72283905206835305365817656031404273372L, 2.938736052218037251011746307725933020145e-39L, UNDERFLOW_EXCEPTION_FLOAT);
2440   TEST_c_c (clog, 0x1p-149L, 0x1p-149L, -102.9323563131518784484589700365392203592L, M_PI_4l);
2441   TEST_c_c (clog, 0x1p-147L, 0x1p-147L, -101.5460619520319878296245057936228672231L, M_PI_4l);
2442
2443 #ifndef TEST_FLOAT
2444   TEST_c_c (clog, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 710.1292864836639693869320059713862337880L, M_PI_4l);
2445   TEST_c_c (clog, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 709.8942846690411016323109979483151967689L, 0.4636476090008061606231772164674799632783L);
2446   TEST_c_c (clog, 0x1p-1074L, 0x1p-1074L, -744.0934983311012896593986823853525458290L, M_PI_4l);
2447   TEST_c_c (clog, 0x1p-1073L, 0x1p-1073L, -743.4003511505413443499814502638943692610L, M_PI_4l);
2448 #endif
2449
2450 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2451   TEST_c_c (clog, 0x1.fp+16383L, 0x1.fp+16383L, 11356.83823118610934184548269774874545400L, M_PI_4l);
2452   TEST_c_c (clog, 0x1.fp+16383L, 0x1p+16383L, 11356.60974243783798653123798337822335902L, 0.4764674194737066993385333770295162295856L);
2453   TEST_c_c (clog, 0x1p-16440L, 0x1p-16441L, -11395.22807662984378194141292922726786191L, 0.4636476090008061162142562314612144020285L);
2454 #endif
2455
2456   TEST_c_c (clog, 0x1p-149L, 0x1.fp+127L, 88.69109041335841930424871526389807508374L, M_PI_2l);
2457   TEST_c_c (clog, -0x1p-149L, 0x1.fp+127L, 88.69109041335841930424871526389807508374L, M_PI_2l);
2458   TEST_c_c (clog, 0x1p-149L, -0x1.fp+127L, 88.69109041335841930424871526389807508374L, -M_PI_2l);
2459   TEST_c_c (clog, -0x1p-149L, -0x1.fp+127L, 88.69109041335841930424871526389807508374L, -M_PI_2l);
2460   TEST_c_c (clog, -0x1.fp+127L, 0x1p-149L, 88.69109041335841930424871526389807508374L, M_PIl);
2461   TEST_c_c (clog, -0x1.fp+127L, -0x1p-149L, 88.69109041335841930424871526389807508374L, -M_PIl);
2462 #ifdef TEST_FLOAT
2463   TEST_c_c (clog, 0x1.fp+127L, 0x1p-149L, 88.69109041335841930424871526389807508374L, plus_zero, UNDERFLOW_EXCEPTION);
2464   TEST_c_c (clog, 0x1.fp+127L, -0x1p-149L, 88.69109041335841930424871526389807508374L, minus_zero, UNDERFLOW_EXCEPTION);
2465 #endif
2466
2467 #ifndef TEST_FLOAT
2468   TEST_c_c (clog, 0x1p-1074L, 0x1.fp+1023L, 709.7509641950694165420886960904242800794L, M_PI_2l);
2469   TEST_c_c (clog, -0x1p-1074L, 0x1.fp+1023L, 709.7509641950694165420886960904242800794L, M_PI_2l);
2470   TEST_c_c (clog, 0x1p-1074L, -0x1.fp+1023L, 709.7509641950694165420886960904242800794L, -M_PI_2l);
2471   TEST_c_c (clog, -0x1p-1074L, -0x1.fp+1023L, 709.7509641950694165420886960904242800794L, -M_PI_2l);
2472   TEST_c_c (clog, -0x1.fp+1023L, 0x1p-1074L, 709.7509641950694165420886960904242800794L, M_PIl);
2473   TEST_c_c (clog, -0x1.fp+1023L, -0x1p-1074L, 709.7509641950694165420886960904242800794L, -M_PIl);
2474 #endif
2475 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2476   TEST_c_c (clog, 0x1.fp+1023L, 0x1p-1074L, 709.7509641950694165420886960904242800794L, plus_zero, UNDERFLOW_EXCEPTION);
2477   TEST_c_c (clog, 0x1.fp+1023L, -0x1p-1074L, 709.7509641950694165420886960904242800794L, minus_zero, UNDERFLOW_EXCEPTION);
2478 #endif
2479
2480 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2481   TEST_c_c (clog, 0x1p-16445L, 0x1.fp+16383L, 11356.49165759582936919077408168801636572L, M_PI_2l);
2482   TEST_c_c (clog, -0x1p-16445L, 0x1.fp+16383L, 11356.49165759582936919077408168801636572L, M_PI_2l);
2483   TEST_c_c (clog, 0x1p-16445L, -0x1.fp+16383L, 11356.49165759582936919077408168801636572L, -M_PI_2l);
2484   TEST_c_c (clog, -0x1p-16445L, -0x1.fp+16383L, 11356.49165759582936919077408168801636572L, -M_PI_2l);
2485   TEST_c_c (clog, -0x1.fp+16383L, 0x1p-16445L, 11356.49165759582936919077408168801636572L, M_PIl);
2486   TEST_c_c (clog, -0x1.fp+16383L, -0x1p-16445L, 11356.49165759582936919077408168801636572L, -M_PIl);
2487   TEST_c_c (clog, 0x1.fp+16383L, 0x1p-16445L, 11356.49165759582936919077408168801636572L, plus_zero, UNDERFLOW_EXCEPTION);
2488   TEST_c_c (clog, 0x1.fp+16383L, -0x1p-16445L, 11356.49165759582936919077408168801636572L, minus_zero, UNDERFLOW_EXCEPTION);
2489 # if LDBL_MANT_DIG >= 113
2490   TEST_c_c (clog, 0x1p-16494L, 0x1.fp+16383L, 11356.49165759582936919077408168801636572L, M_PI_2l);
2491   TEST_c_c (clog, -0x1p-16494L, 0x1.fp+16383L, 11356.49165759582936919077408168801636572L, M_PI_2l);
2492   TEST_c_c (clog, 0x1p-16494L, -0x1.fp+16383L, 11356.49165759582936919077408168801636572L, -M_PI_2l);
2493   TEST_c_c (clog, -0x1p-16494L, -0x1.fp+16383L, 11356.49165759582936919077408168801636572L, -M_PI_2l);
2494   TEST_c_c (clog, -0x1.fp+16383L, 0x1p-16494L, 11356.49165759582936919077408168801636572L, M_PIl);
2495   TEST_c_c (clog, -0x1.fp+16383L, -0x1p-16494L, 11356.49165759582936919077408168801636572L, -M_PIl);
2496   TEST_c_c (clog, 0x1.fp+16383L, 0x1p-16494L, 11356.49165759582936919077408168801636572L, plus_zero, UNDERFLOW_EXCEPTION);
2497   TEST_c_c (clog, 0x1.fp+16383L, -0x1p-16494L, 11356.49165759582936919077408168801636572L, minus_zero, UNDERFLOW_EXCEPTION);
2498 # endif
2499 #endif
2500
2501   TEST_c_c (clog, 1.0L, 0x1.234566p-10L, 6.172834701221959432440126967147726538097e-7L, 1.111110564353742042376451655136933182201e-3L);
2502   TEST_c_c (clog, -1.0L, 0x1.234566p-20L, 5.886877547844618300918562490463748605537e-13L, 3.141591568520436206990380699322226378452L);
2503   TEST_c_c (clog, 0x1.234566p-30L, 1.0L, 5.614163921211322622623353961365728040115e-19L, 1.570796325735258575254858696548386439740L);
2504   TEST_c_c (clog, -0x1.234566p-40L, -1.0L, 5.354083939753840089583620652120903838944e-25L, -1.570796326795931422008642456283782656359L);
2505   TEST_c_c (clog, 0x1.234566p-50L, 1.0L, 5.106052341226425256332038420428899201070e-31L, 1.570796326794895608681734464330528755366L);
2506   TEST_c_c (clog, 0x1.234566p-60L, 1.0L, 4.869510976053643471080816669875627875933e-37L, 1.570796326794896618244456860363082279319L);
2507   TEST_c_c (clog, 0x1p-62L, 1.0L, 2.350988701644575015937473074444491355582e-38L, 1.570796326794896619014481257142650555297L);
2508   TEST_c_c (clog, 0x1p-63L, 1.0L, 5.877471754111437539843682686111228389059e-39L, 1.570796326794896619122901474391200998698L, UNDERFLOW_EXCEPTION_FLOAT);
2509   TEST_c_c (clog, 0x1p-64L, 1.0L, 1.469367938527859384960920671527807097271e-39L, 1.570796326794896619177111583015476220398L, UNDERFLOW_EXCEPTION_FLOAT);
2510 #ifndef TEST_FLOAT
2511   TEST_c_c (clog, 0x1p-510L, 1.0L, 4.450147717014402766180465434664808128438e-308L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
2512   TEST_c_c (clog, 0x1p-511L, 1.0L, 1.112536929253600691545116358666202032110e-308L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION_DOUBLE);
2513   TEST_c_c (clog, 0x1p-512L, 1.0L, 2.781342323134001728862790896665505080274e-309L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION_DOUBLE);
2514 #endif
2515 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2516   TEST_c_c (clog, 0x1p-8190L, 1.0L, 6.724206286224187012525355634643505205196e-4932L, 1.570796326794896619231321691639751442099L);
2517   TEST_c_c (clog, 0x1p-8191L, 1.0L, 1.681051571556046753131338908660876301299e-4932L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION);
2518   TEST_c_c (clog, 0x1p-8192L, 1.0L, 4.202628928890116882828347271652190753248e-4933L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION);
2519 #endif
2520
2521   TEST_c_c (clog, 0x1.000566p0L, 0x1.234p-10L, 8.298731898331237038231468223024422855654e-5L, 1.110938609507128729312743251313024793990e-3L);
2522   TEST_c_c (clog, 0x1.000566p0L, 0x1.234p-100L, 8.237022655933121125560939513260027133767e-5L, 8.974094312218060110948251664314290484113e-31L);
2523 #ifndef TEST_FLOAT
2524   TEST_c_c (clog, -0x1.0000000123456p0L, 0x1.2345678p-30L, 2.649094282537168795982991778475646793277e-10L, 3.141592652530155111500161671113150737892L);
2525   TEST_c_c (clog, -0x1.0000000123456p0L, 0x1.2345678p-1000L, 2.649094276923003995420209214900915462737e-10L, 3.141592653589793238462643383279502884197L);
2526 #endif
2527 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
2528   TEST_c_c (clog, 0x1.00000000000000123456789abcp0L, 0x1.23456789p-60L, 9.868649107778739757272772275265050767867e-19L, 9.868649106423871142816660980898339912137e-19L);
2529   TEST_c_c (clog, 0x1.00000000000000123456789abcp0L, 0x1.23456789p-1000L, 9.868649107778739752403260515979017248596e-19L, 1.061846605795612822522063052130030717368e-301L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
2530 #endif
2531
2532   TEST_c_c (clog, 0x0.ffffffp0L, 0x0.ffffffp-100L, -5.960464655174753498633255797994360530379e-8L, 7.888609052210118054117285652827862296732e-31L);
2533 #ifndef TEST_FLOAT
2534   TEST_c_c (clog, 0x0.fffffffffffff8p0L, 0x0.fffffffffffff8p-1000L, -1.110223024625156602053389888482372171810e-16L, 9.332636185032188789900895447238171696171e-302L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
2535 #endif
2536 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
2537   TEST_c_c (clog, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp-15000L, -5.421010862427522170184200798202494495630e-20L, 3.548665303440282824232502561095699343814e-4516L);
2538 #endif
2539
2540   TEST_c_c (clog, 0x1a6p-10L, 0x3a5p-10L, -1.4305135209763571252847059962654228661815e-06L, 1.1460277178115757370775644871674016684074L);
2541   TEST_c_c (clog, 0xf2p-10L, 0x3e3p-10L, 6.1988446308070710970664736815277450078106e-06L, 1.3322126499153926210226335249558203898460L);
2542   TEST_c_c (clog, 0x4d4ep-15L, 0x6605p-15L, -1.6298145321400412054744424587143483169412e-08L, 0.9223574537155056772124552172295398141249L);
2543   TEST_c_c (clog, 0x2818p-15L, 0x798fp-15L, 1.5366822245016167178749091974664853785194e-08L, 1.2522014929038946066987318471922169174157L);
2544   TEST_c_c (clog, 0x9b57bp-20L, 0xcb7b4p-20L, -3.9563019528687610863490232935890272740908e-11L, 0.9187593477446338910857133065497364950682L);
2545   TEST_c_c (clog, 0x2731p-20L, 0xfffd0p-20L, 4.4110493034041283943115971658295280288115e-11L, 1.5612279663766352262688735061954290528838L);
2546   TEST_c_c (clog, 0x2ede88p-23L, 0x771c3fp-23L, -4.4764192352906350039050902870893173560494e-13L, 1.1959106857549200806818600493552847793381L);
2547   TEST_c_c (clog, 0x11682p-23L, 0x7ffed1p-23L, 1.1723955140027907954461000991619077811832e-12L, 1.5622968405332756349813737986164832897108L);
2548   TEST_c_c (clog, 0xa1f2c1p-24L, 0xc643aep-24L, -1.0480505352462576151523512837107080269981e-13L, 0.8858771987699967480545613322309315260313L);
2549   TEST_c_c (clog, 0x659feap-24L, 0xeaf6f9p-24L, 3.7303493627403868207597214252239749960738e-14L, 1.1625816408046866464773042283673653469061L);
2550 #ifndef TEST_FLOAT
2551   TEST_c_c (clog, 0x4447d7175p-35L, 0x6c445e00ap-35L, -1.4823076576950255933915367361099865652625e-20L, 1.0081311552703893116404606212158840190615L);
2552   TEST_c_c (clog, 0x2dd46725bp-35L, 0x7783a1284p-35L, 4.4469229730850767799109418892826021157328e-20L, 1.2046235979300843056806465045930070146351L);
2553   TEST_c_c (clog, 0x164c74eea876p-45L, 0x16f393482f77p-45L, -3.0292258760486853327810377824479932031744e-26L, 0.7998237934177411746093524982030330293980L);
2554   TEST_c_c (clog, 0xfe961079616p-45L, 0x1bc37e09e6d1p-45L, 5.3718272201930019901317065495843842735179e-26L, 1.0503831592447830576186444373011142397404L);
2555   TEST_c_c (clog, 0xa4722f19346cp-51L, 0x7f9631c5e7f07p-51L, -6.2122796286154679676173624516405339768606e-30L, 1.4904138780720095276446375492434049214172L);
2556   TEST_c_c (clog, 0x10673dd0f2481p-51L, 0x7ef1d17cefbd2p-51L, 3.2047474274603604594851472963586149973093e-29L, 1.4422922682185099608731642353544207976604L);
2557   TEST_c_c (clog, 0x8ecbf810c4ae6p-52L, 0xd479468b09a37p-52L, -9.7375017988218644730510244778042114638107e-30L, 0.9790637929494922564724108399524154766631L);
2558   TEST_c_c (clog, 0x5b06b680ea2ccp-52L, 0xef452b965da9fp-52L, 8.3076914081087805757422664530653247447136e-30L, 1.2072712126771536614482822173033535043206L);
2559   TEST_c_c (clog, 0x659b70ab7971bp-53L, 0x1f5d111e08abecp-53L, -2.5083311595699359750201056724289010648701e-30L, 1.3710185432462268491534742969536240564640L);
2560   TEST_c_c (clog, 0x15cfbd1990d1ffp-53L, 0x176a3973e09a9ap-53L, 1.0168910106364605304135563536838075568606e-30L, 0.8208373755522359859870890246475340086663L);
2561   TEST_c_c (clog, 0x1367a310575591p-54L, 0x3cfcc0a0541f60p-54L, 5.0844550531823026520677817684239496041087e-32L, 1.2627468605458094918919206628466016525397L);
2562   TEST_c_c (clog, 0x55cb6d0c83af5p-55L, 0x7fe33c0c7c4e90p-55L, -5.2000108498455368032511404449795741611813e-32L, 1.5288921536982513453421343495466824420259L);
2563 #endif
2564 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
2565   TEST_c_c (clog, 0x298c62cb546588a7p-63L, 0x7911b1dfcc4ecdaep-63L, -1.1931267660846218205882675852805793644095e-36L, 1.2402109774337032400594953899784058127412L);
2566   TEST_c_c (clog, 0x4d9c37e2b5cb4533p-63L, 0x65c98be2385a042ep-63L, 6.4064442119814669184296141278612389400075e-37L, 0.9193591364645830864185131402313014890145L);
2567   TEST_c_c (clog, 0x602fd5037c4792efp-64L, 0xed3e2086dcca80b8p-64L, -2.3362950222592964220878638677292132852104e-37L, 1.1856121127236268105413184264288408265852L);
2568   TEST_c_c (clog, 0x6b10b4f3520217b6p-64L, 0xe8893cbb449253a1p-64L, 2.4244570985709679851855191080208817099132e-37L, 1.1393074519572050614551047548718495655972L);
2569   TEST_c_c (clog, 0x81b7efa81fc35ad1p-65L, 0x1ef4b835f1c79d812p-65L, -9.9182335850630508484862145328126979066934e-39L, 1.3146479888794807046338799047003947008804L);
2570 #endif
2571 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
2572   TEST_c_c (clog, 0x3f96469050f650869c2p-75L, 0x6f16b2c9c8b05988335p-75L, -1.0509738482436128031927971874674370984602e-45L, 1.0509191467640012308402149909370784281448L);
2573   TEST_c_c (clog, 0x3157fc1d73233e580c8p-75L, 0x761b52ccd435d7c7f5fp-75L, 1.3487497719126364307640897239165442763573e-43L, 1.1750493008528425228929764149024375035382L);
2574   TEST_c_c (clog, 0x155f8afc4c48685bf63610p-85L, 0x17d0cf2652cdbeb1294e19p-85L, -4.7775669192897997174762089350332738583822e-50L, 0.8393953487996880419413728440067635213372L);
2575   TEST_c_c (clog, 0x13836d58a13448d750b4b9p-85L, 0x195ca7bc3ab4f9161edbe6p-85L, 2.8398125044729578740243199963484494962411e-50L, 0.9149964976334130461795060758257083099706L);
2576   TEST_c_c (clog, 0x1df515eb171a808b9e400266p-95L, 0x7c71eb0cd4688dfe98581c77p-95L, -3.5048022044913950094635368750889659723004e-57L, 1.3345633256521815205858155673950177421079L);
2577   TEST_c_c (clog, 0xe33f66c9542ca25cc43c867p-95L, 0x7f35a68ebd3704a43c465864p-95L, 4.1101771307217268747345114262406964584250e-56L, 1.4596065864518742494094402406719567059585L);
2578   TEST_c_c (clog, 0x6771f22c64ed551b857c128b4cp-105L, 0x1f570e7a13cc3cf2f44fd793ea1p-105L, -1.4281333889622737316199756373421183559948e-62L, 1.3673546561165378090903506783353927980633L);
2579   TEST_c_c (clog, 0x15d8ab6ed05ca514086ac3a1e84p-105L, 0x1761e480aa094c0b10b34b09ce9p-105L, 1.0027319539522347477331743836657426754857e-62L, 0.8193464073721167323313606647411269414759L);
2580   TEST_c_c (clog, 0x187190c1a334497bdbde5a95f48p-106L, 0x3b25f08062d0a095c4cfbbc338dp-106L, -1.7471844652198029695350765775994001163767e-63L, 1.1789110097072986038243729592318526094314L);
2581   TEST_c_c (clog, 0x6241ef0da53f539f02fad67dabp-106L, 0x3fb46641182f7efd9caa769dac0p-106L, 4.3299788920664682288477984749202524623248e-63L, 1.4746938237585656250866370987773473745867L);
2582 #endif
2583 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 113
2584   TEST_c_c (clog, 0x3e1d0a105ac4ebeacd9c6952d34cp-112L, 0xf859b3d1b06d005dcbb5516d5479p-112L, -1.1683999374665377365054966073875064467108e-66L, 1.3257197596350832748781065387304444940172L);
2585   TEST_c_c (clog, 0x47017a2e36807acb1e5214b209dep-112L, 0xf5f4a550c9d75e3bb1839d865f0dp-112L, 1.5077923002544367932999503838191154621839e-65L, 1.2897445708311412721399861948957141824914L);
2586   TEST_c_c (clog, 0x148f818cb7a9258fca942ade2a0cap-113L, 0x18854a34780b8333ec53310ad7001p-113L, -7.1865869169568789348552370692485515571497e-67L, 0.8730167479365994646287897223471819363668L);
2587   TEST_c_c (clog, 0xfd95243681c055c2632286921092p-113L, 0x1bccabcd29ca2152860ec29e34ef7p-113L, 6.6255694866654064502633121109394710807528e-66L, 1.0526409614996288387567810726095850312049L);
2588   TEST_c_c (clog, 0xdb85c467ee2aadd5f425fe0f4b8dp-114L, 0x3e83162a0f95f1dcbf97dddf410eap-114L, 4.6017338806965821566734340588575402712716e-67L, 1.3547418904611758959096647942223384691728L);
2589   TEST_c_c (clog, 0x1415bcaf2105940d49a636e98ae59p-115L, 0x7e6a150adfcd1b0921d44b31f40f4p-115L, 2.5993421227864195179698176012564317527271e-67L, 1.4132318089683022770487383611430906982461L);
2590 #endif
2591
2592   END (clog, complex);
2593 }
2594
2595
2596 static void
2597 clog10_test (void)
2598 {
2599   errno = 0;
2600   FUNC(clog10) (BUILD_COMPLEX (0.7L, 1.2L));
2601   if (errno == ENOSYS)
2602     /* Function not implemented.  */
2603     return;
2604
2605   START (clog10);
2606
2607   TEST_c_c (clog10, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2608   TEST_c_c (clog10, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2609
2610   TEST_c_c (clog10, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
2611   TEST_c_c (clog10, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
2612
2613   TEST_c_c (clog10, minus_infty, plus_infty, plus_infty, M_PI_34_LOG10El);
2614
2615   TEST_c_c (clog10, plus_infty, plus_infty, plus_infty, M_PI4_LOG10El);
2616   TEST_c_c (clog10, plus_infty, minus_infty, plus_infty, -M_PI4_LOG10El);
2617
2618   TEST_c_c (clog10, 0, plus_infty, plus_infty, M_PI2_LOG10El);
2619   TEST_c_c (clog10, 3, plus_infty, plus_infty, M_PI2_LOG10El);
2620   TEST_c_c (clog10, minus_zero, plus_infty, plus_infty, M_PI2_LOG10El);
2621   TEST_c_c (clog10, -3, plus_infty, plus_infty, M_PI2_LOG10El);
2622   TEST_c_c (clog10, 0, minus_infty, plus_infty, -M_PI2_LOG10El);
2623   TEST_c_c (clog10, 3, minus_infty, plus_infty, -M_PI2_LOG10El);
2624   TEST_c_c (clog10, minus_zero, minus_infty, plus_infty, -M_PI2_LOG10El);
2625   TEST_c_c (clog10, -3, minus_infty, plus_infty, -M_PI2_LOG10El);
2626
2627   TEST_c_c (clog10, minus_infty, 0, plus_infty, M_PI_LOG10El);
2628   TEST_c_c (clog10, minus_infty, 1, plus_infty, M_PI_LOG10El);
2629   TEST_c_c (clog10, minus_infty, minus_zero, plus_infty, -M_PI_LOG10El);
2630   TEST_c_c (clog10, minus_infty, -1, plus_infty, -M_PI_LOG10El);
2631
2632   TEST_c_c (clog10, plus_infty, 0, plus_infty, 0.0);
2633   TEST_c_c (clog10, plus_infty, 1, plus_infty, 0.0);
2634   TEST_c_c (clog10, plus_infty, minus_zero, plus_infty, minus_zero);
2635   TEST_c_c (clog10, plus_infty, -1, plus_infty, minus_zero);
2636
2637   TEST_c_c (clog10, plus_infty, nan_value, plus_infty, nan_value);
2638   TEST_c_c (clog10, minus_infty, nan_value, plus_infty, nan_value);
2639
2640   TEST_c_c (clog10, nan_value, plus_infty, plus_infty, nan_value);
2641   TEST_c_c (clog10, nan_value, minus_infty, plus_infty, nan_value);
2642
2643   TEST_c_c (clog10, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2644   TEST_c_c (clog10, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2645   TEST_c_c (clog10, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2646   TEST_c_c (clog10, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2647
2648   TEST_c_c (clog10, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2649   TEST_c_c (clog10, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2650   TEST_c_c (clog10, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2651   TEST_c_c (clog10, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2652
2653   TEST_c_c (clog10, nan_value, nan_value, nan_value, nan_value);
2654
2655   TEST_c_c (clog10, 0.75L, 1.25L, 0.163679467193165171449476605077428975L, 0.447486970040493067069984724340855636L);
2656   TEST_c_c (clog10, -2, -3, 0.556971676153418384603252578971164214L, -0.937554462986374708541507952140189646L);
2657
2658   TEST_c_c (clog10, 0x1.fffffep+127L, 0x1.fffffep+127L, 38.68235441693561449174780668781319348761L, M_PI4_LOG10El);
2659   TEST_c_c (clog10, 0x1.fffffep+127L, 1.0L, 38.53183941910362389414093724045094697423L, 1.276276851248440096917018665609900318458e-39L, UNDERFLOW_EXCEPTION_FLOAT);
2660   TEST_c_c (clog10, 0x1p-149L, 0x1p-149L, -44.70295435610120748924022586658721447508L, M_PI4_LOG10El);
2661   TEST_c_c (clog10, 0x1p-147L, 0x1p-147L, -44.10089436477324509881274807713822842154L, M_PI4_LOG10El);
2662
2663 #ifndef TEST_FLOAT
2664   TEST_c_c (clog10, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 308.4052305577487344482591243175787477115L, M_PI4_LOG10El);
2665   TEST_c_c (clog10, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 308.3031705664207720674749211936626341569L, 0.2013595981366865903254995612594728746470L);
2666   TEST_c_c (clog10, 0x1p-1074L, 0x1p-1074L, -323.1557003452838130619487034867432642357L, M_PI4_LOG10El);
2667   TEST_c_c (clog10, 0x1p-1073L, 0x1p-1073L, -322.8546703496198318667349645920187712089L, M_PI4_LOG10El);
2668 #endif
2669
2670 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2671   TEST_c_c (clog10, 0x1.fp+16383L, 0x1.fp+16383L, 4932.212175672014259683102930239951947672L, M_PI4_LOG10El);
2672   TEST_c_c (clog10, 0x1.fp+16383L, 0x1p+16383L, 4932.112944269463028900262609694408579449L, 0.2069271710841128115912940666587802677383L);
2673   TEST_c_c (clog10, 0x1p-16440L, 0x1p-16441L, -4948.884673709346821106688037612752099609L, 0.2013595981366865710389502301937289472543L);
2674 #endif
2675
2676   TEST_c_c (clog10, 0x1p-149L, 0x1.fp+127L, 38.51805116050395969095658815123105801479L, 0.6821881769209206737428918127156778851051L);
2677   TEST_c_c (clog10, -0x1p-149L, 0x1.fp+127L, 38.51805116050395969095658815123105801479L, 0.6821881769209206737428918127156778851051L);
2678   TEST_c_c (clog10, 0x1p-149L, -0x1.fp+127L, 38.51805116050395969095658815123105801479L, -0.6821881769209206737428918127156778851051L);
2679   TEST_c_c (clog10, -0x1p-149L, -0x1.fp+127L, 38.51805116050395969095658815123105801479L, -0.6821881769209206737428918127156778851051L);
2680   TEST_c_c (clog10, -0x1.fp+127L, 0x1p-149L, 38.51805116050395969095658815123105801479L, 1.364376353841841347485783625431355770210L);
2681   TEST_c_c (clog10, -0x1.fp+127L, -0x1p-149L, 38.51805116050395969095658815123105801479L, -1.364376353841841347485783625431355770210L);
2682 #ifdef TEST_FLOAT
2683   TEST_c_c (clog10, 0x1.fp+127L, 0x1p-149L, 38.51805116050395969095658815123105801479L, plus_zero, UNDERFLOW_EXCEPTION);
2684   TEST_c_c (clog10, 0x1.fp+127L, -0x1p-149L, 38.51805116050395969095658815123105801479L, minus_zero, UNDERFLOW_EXCEPTION);
2685 #endif
2686
2687 #ifndef TEST_FLOAT
2688   TEST_c_c (clog10, 0x1p-1074L, 0x1.fp+1023L, 308.2409272754311106024666378243768099991L, 0.6821881769209206737428918127156778851051L);
2689   TEST_c_c (clog10, -0x1p-1074L, 0x1.fp+1023L, 308.2409272754311106024666378243768099991L, 0.6821881769209206737428918127156778851051L);
2690   TEST_c_c (clog10, 0x1p-1074L, -0x1.fp+1023L, 308.2409272754311106024666378243768099991L, -0.6821881769209206737428918127156778851051L);
2691   TEST_c_c (clog10, -0x1p-1074L, -0x1.fp+1023L, 308.2409272754311106024666378243768099991L, -0.6821881769209206737428918127156778851051L);
2692   TEST_c_c (clog10, -0x1.fp+1023L, 0x1p-1074L, 308.2409272754311106024666378243768099991L, 1.364376353841841347485783625431355770210L);
2693   TEST_c_c (clog10, -0x1.fp+1023L, -0x1p-1074L, 308.2409272754311106024666378243768099991L, -1.364376353841841347485783625431355770210L);
2694 #endif
2695 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2696   TEST_c_c (clog10, 0x1.fp+1023L, 0x1p-1074L, 308.2409272754311106024666378243768099991L, plus_zero, UNDERFLOW_EXCEPTION);
2697   TEST_c_c (clog10, 0x1.fp+1023L, -0x1p-1074L, 308.2409272754311106024666378243768099991L, minus_zero, UNDERFLOW_EXCEPTION);
2698 #endif
2699
2700 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2701   TEST_c_c (clog10, 0x1p-16445L, 0x1.fp+16383L, 4932.061660674182269085496060792589701158L, 0.6821881769209206737428918127156778851051L);
2702   TEST_c_c (clog10, -0x1p-16445L, 0x1.fp+16383L, 4932.061660674182269085496060792589701158L, 0.6821881769209206737428918127156778851051L);
2703   TEST_c_c (clog10, 0x1p-16445L, -0x1.fp+16383L, 4932.061660674182269085496060792589701158L, -0.6821881769209206737428918127156778851051L);
2704   TEST_c_c (clog10, -0x1p-16445L, -0x1.fp+16383L, 4932.061660674182269085496060792589701158L, -0.6821881769209206737428918127156778851051L);
2705   TEST_c_c (clog10, -0x1.fp+16383L, 0x1p-16445L, 4932.061660674182269085496060792589701158L, 1.364376353841841347485783625431355770210L);
2706   TEST_c_c (clog10, -0x1.fp+16383L, -0x1p-16445L, 4932.061660674182269085496060792589701158L, -1.364376353841841347485783625431355770210L);
2707   TEST_c_c (clog10, 0x1.fp+16383L, 0x1p-16445L, 4932.061660674182269085496060792589701158L, plus_zero, UNDERFLOW_EXCEPTION);
2708   TEST_c_c (clog10, 0x1.fp+16383L, -0x1p-16445L, 4932.061660674182269085496060792589701158L, minus_zero, UNDERFLOW_EXCEPTION);
2709 # if LDBL_MANT_DIG >= 113
2710   TEST_c_c (clog10, 0x1p-16494L, 0x1.fp+16383L, 4932.061660674182269085496060792589701158L, 0.6821881769209206737428918127156778851051L);
2711   TEST_c_c (clog10, -0x1p-16494L, 0x1.fp+16383L, 4932.061660674182269085496060792589701158L, 0.6821881769209206737428918127156778851051L);
2712   TEST_c_c (clog10, 0x1p-16494L, -0x1.fp+16383L, 4932.061660674182269085496060792589701158L, -0.6821881769209206737428918127156778851051L);
2713   TEST_c_c (clog10, -0x1p-16494L, -0x1.fp+16383L, 4932.061660674182269085496060792589701158L, -0.6821881769209206737428918127156778851051L);
2714   TEST_c_c (clog10, -0x1.fp+16383L, 0x1p-16494L, 4932.061660674182269085496060792589701158L, 1.364376353841841347485783625431355770210L);
2715   TEST_c_c (clog10, -0x1.fp+16383L, -0x1p-16494L, 4932.061660674182269085496060792589701158L, -1.364376353841841347485783625431355770210L);
2716   TEST_c_c (clog10, 0x1.fp+16383L, 0x1p-16494L, 4932.061660674182269085496060792589701158L, plus_zero, UNDERFLOW_EXCEPTION);
2717   TEST_c_c (clog10, 0x1.fp+16383L, -0x1p-16494L, 4932.061660674182269085496060792589701158L, minus_zero, UNDERFLOW_EXCEPTION);
2718 # endif
2719 #endif
2720
2721   TEST_c_c (clog10, 1.0L, 0x1.234566p-10L, 2.680828048441605163181684680300513080769e-7L, 4.825491868832381486767558728169977751564e-4L);
2722   TEST_c_c (clog10, -1.0L, 0x1.234566p-20L, 2.556638434669064077889576526006849923281e-13L, 1.364375882602207106407956770293808181427L);
2723   TEST_c_c (clog10, 0x1.234566p-30L, 1.0L, 2.438200411482400072282924063740535840474e-19L, 6.821881764607257184291586401763604544928e-1L);
2724   TEST_c_c (clog10, -0x1.234566p-40L, -1.0L, 2.325249110681915353442924915876654139373e-25L, -6.821881769213700828789403802671540158935e-1L);
2725   TEST_c_c (clog10, 0x1.234566p-50L, 1.0L, 2.217530356103816369479108963807448194409e-31L, 6.821881769209202348667823902864283966959e-1L);
2726   TEST_c_c (clog10, 0x1.234566p-60L, 1.0L, 2.114801746467415208319767917450504756866e-37L, 6.821881769209206733143018621078368211515e-1L);
2727   TEST_c_c (clog10, 0x1p-61L, 1.0L, 4.084085680564517578238994467153626207224e-38L, 6.821881769209206735545466044044889962925e-1L);
2728   TEST_c_c (clog10, 0x1p-62L, 1.0L, 1.021021420141129394559748616788406551878e-38L, 6.821881769209206736487192085600834406988e-1L, UNDERFLOW_EXCEPTION_FLOAT);
2729   TEST_c_c (clog10, 0x1p-63L, 1.0L, 2.552553550352823486399371541971016379740e-39L, 6.821881769209206736958055106378806629019e-1L, UNDERFLOW_EXCEPTION_FLOAT);
2730 #ifndef TEST_FLOAT
2731   TEST_c_c (clog10, 0x1p-509L, 1.0L, 7.730698388614835910296270976605350994446e-308L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
2732   TEST_c_c (clog10, 0x1p-510L, 1.0L, 1.932674597153708977574067744151337748612e-308L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION_DOUBLE);
2733   TEST_c_c (clog10, 0x1p-511L, 1.0L, 4.831686492884272443935169360378344371529e-309L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION_DOUBLE);
2734 #endif
2735 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2736   TEST_c_c (clog10, 0x1p-8189L, 1.0L, 1.168114274114528946314738738025008370069e-4931L, 6.821881769209206737428918127156778851051e-1L);
2737   TEST_c_c (clog10, 0x1p-8190L, 1.0L, 2.920285685286322365786846845062520925172e-4932L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION);
2738   TEST_c_c (clog10, 0x1p-8191L, 1.0L, 7.300714213215805914467117112656302312931e-4933L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION);
2739 #endif
2740
2741   TEST_c_c (clog10, 0x1.000566p0L, 0x1.234p-10L, 3.604093470239754109961125085078190708674e-5L, 4.824745078422174667425851670822596859720e-4L);
2742   TEST_c_c (clog10, 0x1.000566p0L, 0x1.234p-100L, 3.577293486783822178310971763308187385546e-5L, 3.897399639875661463735636919790792140598e-31L);
2743 #ifndef TEST_FLOAT
2744   TEST_c_c (clog10, -0x1.0000000123456p0L, 0x1.2345678p-30L, 1.150487028947346337782682105935961875822e-10L, 1.364376353381646356131680448946397884147L);
2745   TEST_c_c (clog10, -0x1.0000000123456p0L, 0x1.2345678p-1000L, 1.150487026509145544402795327729455391948e-10L, 1.364376353841841347485783625431355770210L);
2746 #endif
2747 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
2748   TEST_c_c (clog10, 0x1.00000000000000123456789abcp0L, 0x1.23456789p-60L, 4.285899851347756188767674032946882584784e-19L, 4.285899850759344225805480528847018395861e-19L);
2749   TEST_c_c (clog10, 0x1.00000000000000123456789abcp0L, 0x1.23456789p-1000L, 4.285899851347756186652871946325962330640e-19L, 4.611541215247321502041995872887317363241e-302L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
2750 #endif
2751
2752   TEST_c_c (clog10, 0x0.ffffffp0L, 0x0.ffffffp-100L, -2.588596909321764128428416045209904492216e-8L, 3.425979381266895667295625489912064603415e-31L);
2753 #ifndef TEST_FLOAT
2754   TEST_c_c (clog10, 0x0.fffffffffffff8p0L, 0x0.fffffffffffff8p-1000L, -4.821637332766435821255375046554377090472e-17L, 4.053112396770095089737411317782466262176e-302L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
2755 #endif
2756 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
2757   TEST_c_c (clog10, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp-15000L, -2.354315103889861110220423157644627849164e-20L, 1.541165759405643564697852372112893034397e-4516L);
2758 #endif
2759
2760   TEST_c_c (clog10, 0x1a6p-10L, 0x3a5p-10L, -6.2126412844802358329771948751248003038444e-07L, 0.4977135139537443711784513409096950995985L);
2761   TEST_c_c (clog10, 0xf2p-10L, 0x3e3p-10L, 2.6921240173351112953324592659528481616879e-06L, 0.5785726025799636431142862788413361783862L);
2762   TEST_c_c (clog10, 0x4d4ep-15L, 0x6605p-15L, -7.0781945783414996953799915941870192015212e-09L, 0.4005747524909781155537088181659175147564L);
2763   TEST_c_c (clog10, 0x2818p-15L, 0x798fp-15L, 6.6737261053986614395049481326819059203910e-09L, 0.5438241985991753781478398141908629586460L);
2764   TEST_c_c (clog10, 0x9b57bp-20L, 0xcb7b4p-20L, -1.7182001068739620267773842120965071561416e-11L, 0.3990121149225253562859800593935899629087L);
2765   TEST_c_c (clog10, 0x2731p-20L, 0xfffd0p-20L, 1.9156943718715958194239364991329064049438e-11L, 0.6780326907904082601285090019969008967595L);
2766   TEST_c_c (clog10, 0x2ede88p-23L, 0x771c3fp-23L, -1.9440841725722970687903291200493082253766e-13L, 0.5193774116724956222518530053006822210323L);
2767   TEST_c_c (clog10, 0x11682p-23L, 0x7ffed1p-23L, 5.0916490233953865181284669870035717560498e-13L, 0.6784968969384861816694467029319146542069L);
2768   TEST_c_c (clog10, 0xa1f2c1p-24L, 0xc643aep-24L, -4.5516256421319921959681423447271490869664e-14L, 0.3847315790697197749315054516562206543710L);
2769   TEST_c_c (clog10, 0x659feap-24L, 0xeaf6f9p-24L, 1.6200701438094619117335617123525612051457e-14L, 0.5049027913635038013499728086604870749732L);
2770 #ifndef TEST_FLOAT
2771   TEST_c_c (clog10, 0x4447d7175p-35L, 0x6c445e00ap-35L, -6.4375803621988389731799033530075237868110e-21L, 0.4378257977686804492768642780897650927167L);
2772   TEST_c_c (clog10, 0x2dd46725bp-35L, 0x7783a1284p-35L, 1.9312741086596516918394613098872836703188e-20L, 0.5231613813514771042838490538484014771862L);
2773   TEST_c_c (clog10, 0x164c74eea876p-45L, 0x16f393482f77p-45L, -1.3155760824064879362415202279780039150764e-26L, 0.3473590599762514228227328130640352044313L);
2774   TEST_c_c (clog10, 0xfe961079616p-45L, 0x1bc37e09e6d1p-45L, 2.3329549194675052736016290082882121135546e-26L, 0.4561756099441139182878993697611751382976L);
2775   TEST_c_c (clog10, 0xa4722f19346cp-51L, 0x7f9631c5e7f07p-51L, -2.6979587627476803379953050733225113494503e-30L, 0.6472785229986997177606324374555347813105L);
2776   TEST_c_c (clog10, 0x10673dd0f2481p-51L, 0x7ef1d17cefbd2p-51L, 1.3918041236396763648388478552321724382899e-29L, 0.6263795733790237053262025311642907438291L);
2777   TEST_c_c (clog10, 0x8ecbf810c4ae6p-52L, 0xd479468b09a37p-52L, -4.2289432987513243393180377141513840878196e-30L, 0.4252020027092323591068799049905597805296L);
2778   TEST_c_c (clog10, 0x5b06b680ea2ccp-52L, 0xef452b965da9fp-52L, 3.6079845358966994996207055940336690133424e-30L, 0.5243112258263349992771652393178033846555L);
2779   TEST_c_c (clog10, 0x659b70ab7971bp-53L, 0x1f5d111e08abecp-53L, -1.0893543813872082317104059174982092534059e-30L, 0.5954257879188711495921161433751775633232L);
2780   TEST_c_c (clog10, 0x15cfbd1990d1ffp-53L, 0x176a3973e09a9ap-53L, 4.4163015461643576961232672330852798804976e-31L, 0.3564851427422832755956993418877523303529L);
2781   TEST_c_c (clog10, 0x1367a310575591p-54L, 0x3cfcc0a0541f60p-54L, 2.2081507730821788480616336165447731164865e-32L, 0.5484039935757001196548030312819898864760L);
2782   TEST_c_c (clog10, 0x55cb6d0c83af5p-55L, 0x7fe33c0c7c4e90p-55L, -2.2583360179249556400630343805573865814771e-32L, 0.6639894257763289307423302343317622430835L);
2783 #endif
2784 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
2785   TEST_c_c (clog10, 0x298c62cb546588a7p-63L, 0x7911b1dfcc4ecdaep-63L, -5.1816837072162316773907242302011632570857e-37L, 0.5386167838952956925896424154370364458140L);
2786   TEST_c_c (clog10, 0x4d9c37e2b5cb4533p-63L, 0x65c98be2385a042ep-63L, 2.7822833698845776001753149807484078521508e-37L, 0.3992725998539071066769046272515417679815L);
2787   TEST_c_c (clog10, 0x602fd5037c4792efp-64L, 0xed3e2086dcca80b8p-64L, -1.0146400362652473358437501879334790111898e-37L, 0.5149047982335273098246594109614460842099L);
2788   TEST_c_c (clog10, 0x6b10b4f3520217b6p-64L, 0xe8893cbb449253a1p-64L, 1.0529283395205396881397407610630442563938e-37L, 0.4947949395762683446121140513971996916447L);
2789   TEST_c_c (clog10, 0x81b7efa81fc35ad1p-65L, 0x1ef4b835f1c79d812p-65L, -4.3074341162203896332989394770760901408798e-39L, 0.5709443672155660428417571212549720987784L);
2790 #endif
2791 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
2792   TEST_c_c (clog10, 0x3f96469050f650869c2p-75L, 0x6f16b2c9c8b05988335p-75L, -4.5643214291682663316715446865040356750881e-46L, 0.4564083863660793840592614609053162690362L);
2793   TEST_c_c (clog10, 0x3157fc1d73233e580c8p-75L, 0x761b52ccd435d7c7f5fp-75L, 5.8575458340992751256451490143468457830297e-44L, 0.5103174273246635294300470585396890237265L);
2794   TEST_c_c (clog10, 0x155f8afc4c48685bf63610p-85L, 0x17d0cf2652cdbeb1294e19p-85L, -2.0748709499710785084693619097712106753591e-50L, 0.3645447681189598740620098186365764884771L);
2795   TEST_c_c (clog10, 0x13836d58a13448d750b4b9p-85L, 0x195ca7bc3ab4f9161edbe6p-85L, 1.2333149003324592532859843519619084433953e-50L, 0.3973779298829931059309198145608711073016L);
2796   TEST_c_c (clog10, 0x1df515eb171a808b9e400266p-95L, 0x7c71eb0cd4688dfe98581c77p-95L, -1.5221162575729652613635150540947625639689e-57L, 0.5795934880811949230121092882659698986043L);
2797   TEST_c_c (clog10, 0xe33f66c9542ca25cc43c867p-95L, 0x7f35a68ebd3704a43c465864p-95L, 1.7850272475173865337808494725293124613817e-56L, 0.6338990862456906754888183278564382516852L);
2798   TEST_c_c (clog10, 0x6771f22c64ed551b857c128b4cp-105L, 0x1f570e7a13cc3cf2f44fd793ea1p-105L, -6.2023045024810589256360494043570293518879e-63L, 0.5938345819561308555003145899438513900776L);
2799   TEST_c_c (clog10, 0x15d8ab6ed05ca514086ac3a1e84p-105L, 0x1761e480aa094c0b10b34b09ce9p-105L, 4.3548095442952115860848857519953610343042e-63L, 0.3558376234889641500775150477035448866763L);
2800   TEST_c_c (clog10, 0x187190c1a334497bdbde5a95f48p-106L, 0x3b25f08062d0a095c4cfbbc338dp-106L, -7.5879257211204444302994221436282805900756e-64L, 0.5119945461708707332160859198685423099187L);
2801   TEST_c_c (clog10, 0x6241ef0da53f539f02fad67dabp-106L, 0x3fb46641182f7efd9caa769dac0p-106L, 1.8804859395820231849002915747252695375405e-63L, 0.6404513901551516189871978418046651877394L);
2802 #endif
2803 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 113
2804   TEST_c_c (clog10, 0x3e1d0a105ac4ebeacd9c6952d34cp-112L, 0xf859b3d1b06d005dcbb5516d5479p-112L, -5.0742964549782184008668435276046798273476e-67L, 0.5757527761596220360985719127090110408283L);
2805   TEST_c_c (clog10, 0x47017a2e36807acb1e5214b209dep-112L, 0xf5f4a550c9d75e3bb1839d865f0dp-112L, 6.5482587585671294601662599808612773010057e-66L, 0.5601289501766423782280643144987875760229L);
2806   TEST_c_c (clog10, 0x148f818cb7a9258fca942ade2a0cap-113L, 0x18854a34780b8333ec53310ad7001p-113L, -3.1210950417524756037077807411854181477733e-67L, 0.3791463562379872585396164879981280044658L);
2807   TEST_c_c (clog10, 0xfd95243681c055c2632286921092p-113L, 0x1bccabcd29ca2152860ec29e34ef7p-113L, 2.8774482675253468630312378575186855052697e-66L, 0.4571561610046221605554903008571429975493L);
2808   TEST_c_c (clog10, 0xdb85c467ee2aadd5f425fe0f4b8dp-114L, 0x3e83162a0f95f1dcbf97dddf410eap-114L, 1.9985076315737626043096596036300177494613e-67L, 0.5883569274304683249184005177865521205198L);
2809   TEST_c_c (clog10, 0x1415bcaf2105940d49a636e98ae59p-115L, 0x7e6a150adfcd1b0921d44b31f40f4p-115L, 1.1288799405048268615023706955013387413519e-67L, 0.6137587762850841972073301550420510507903L);
2810 #endif
2811
2812   END (clog10, complex);
2813 }
2814
2815
2816 static void
2817 conj_test (void)
2818 {
2819   START (conj);
2820   TEST_c_c (conj, 0.0, 0.0, 0.0, minus_zero);
2821   TEST_c_c (conj, 0.0, minus_zero, 0.0, 0.0);
2822   TEST_c_c (conj, nan_value, nan_value, nan_value, nan_value);
2823   TEST_c_c (conj, plus_infty, minus_infty, plus_infty, plus_infty);
2824   TEST_c_c (conj, plus_infty, plus_infty, plus_infty, minus_infty);
2825   TEST_c_c (conj, 1.0, 2.0, 1.0, -2.0);
2826   TEST_c_c (conj, 3.0, -4.0, 3.0, 4.0);
2827
2828   END (conj, complex);
2829 }
2830
2831
2832 static void
2833 copysign_test (void)
2834 {
2835   START (copysign);
2836
2837   TEST_ff_f (copysign, 0, 4, 0);
2838   TEST_ff_f (copysign, 0, -4, minus_zero);
2839   TEST_ff_f (copysign, minus_zero, 4, 0);
2840   TEST_ff_f (copysign, minus_zero, -4, minus_zero);
2841
2842   TEST_ff_f (copysign, plus_infty, 0, plus_infty);
2843   TEST_ff_f (copysign, plus_infty, minus_zero, minus_infty);
2844   TEST_ff_f (copysign, minus_infty, 0, plus_infty);
2845   TEST_ff_f (copysign, minus_infty, minus_zero, minus_infty);
2846
2847   TEST_ff_f (copysign, 0, plus_infty, 0);
2848   TEST_ff_f (copysign, 0, minus_zero, minus_zero);
2849   TEST_ff_f (copysign, minus_zero, plus_infty, 0);
2850   TEST_ff_f (copysign, minus_zero, minus_zero, minus_zero);
2851
2852   /* XXX More correctly we would have to check the sign of the NaN.  */
2853   TEST_ff_f (copysign, nan_value, 0, nan_value);
2854   TEST_ff_f (copysign, nan_value, minus_zero, nan_value);
2855   TEST_ff_f (copysign, -nan_value, 0, nan_value);
2856   TEST_ff_f (copysign, -nan_value, minus_zero, nan_value);
2857
2858   END (copysign);
2859 }
2860
2861
2862 static void
2863 cos_test (void)
2864 {
2865   errno = 0;
2866   FUNC(cos) (0);
2867   if (errno == ENOSYS)
2868     /* Function not implemented.  */
2869     return;
2870
2871   START (cos);
2872
2873   TEST_f_f (cos, 0, 1);
2874   TEST_f_f (cos, minus_zero, 1);
2875   errno = 0;
2876   TEST_f_f (cos, plus_infty, nan_value, INVALID_EXCEPTION);
2877   check_int ("errno for cos(+inf) == EDOM", errno, EDOM, 0, 0, 0);
2878   errno = 0;
2879   TEST_f_f (cos, minus_infty, nan_value, INVALID_EXCEPTION);
2880   check_int ("errno for cos(-inf) == EDOM", errno, EDOM, 0, 0, 0);
2881   errno = 0;
2882   TEST_f_f (cos, nan_value, nan_value);
2883   check_int ("errno for cos(NaN) unchanged", errno, 0, 0, 0, 0);
2884
2885   TEST_f_f (cos, M_PI_6l * 2.0, 0.5);
2886   TEST_f_f (cos, M_PI_6l * 4.0, -0.5);
2887   TEST_f_f (cos, M_PI_2l, 0);
2888
2889   TEST_f_f (cos, 0.75L, 0.731688868873820886311838753000084544L);
2890
2891   TEST_f_f (cos, 0x1p65, 0.99888622066058013610642172179340364209972L);
2892   TEST_f_f (cos, -0x1p65, 0.99888622066058013610642172179340364209972L);
2893
2894 #ifdef TEST_DOUBLE
2895   TEST_f_f (cos, 0.80190127184058835, 0.69534156199418473);
2896 #endif
2897
2898   TEST_f_f (cos, 0x1.442f74p+15, 2.4407839902314016628485779006274989801517e-06L);
2899
2900 #ifndef TEST_FLOAT
2901   TEST_f_f (cos, 1e22, 0.5232147853951389454975944733847094921409L);
2902   TEST_f_f (cos, 0x1p1023, -0.826369834614147994500785680811743734805L);
2903 #endif
2904
2905 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2906   TEST_f_f (cos, 0x1p16383L, 0.9210843909921906206874509522505756251609L);
2907 #endif
2908
2909   TEST_f_f (cos, 0x1p+120, -9.25879022854837867303861764107414946730833e-01L);
2910   TEST_f_f (cos, 0x1p+127, 7.81914638714960072263910298466369236613162e-01L);
2911   TEST_f_f (cos, 0x1.fffff8p+127, 9.98819362551949040703862043664101081064641e-01L);
2912   TEST_f_f (cos, 0x1.fffffep+127, 8.53021039830304158051791467692161107353094e-01L);
2913   TEST_f_f (cos, 0x1p+50, 8.68095904660550604334592502063501320395739e-01L);
2914   TEST_f_f (cos, 0x1p+28, -1.65568979490578758865468278195361551113358e-01L);
2915
2916   END (cos);
2917 }
2918
2919
2920 static void
2921 cos_test_tonearest (void)
2922 {
2923   int save_round_mode;
2924   errno = 0;
2925   FUNC(cos) (0);
2926   if (errno == ENOSYS)
2927     /* Function not implemented.  */
2928     return;
2929
2930   START (cos_tonearest);
2931
2932   save_round_mode = fegetround ();
2933
2934   if (!fesetround (FE_TONEAREST))
2935     {
2936       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2937       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2938       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2939       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2940       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2941       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2942       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2943       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2944       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2945       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2946     }
2947
2948   fesetround (save_round_mode);
2949
2950   END (cos_tonearest);
2951 }
2952
2953
2954 static void
2955 cos_test_towardzero (void)
2956 {
2957   int save_round_mode;
2958   errno = 0;
2959   FUNC(cos) (0);
2960   if (errno == ENOSYS)
2961     /* Function not implemented.  */
2962     return;
2963
2964   START (cos_towardzero);
2965
2966   save_round_mode = fegetround ();
2967
2968   if (!fesetround (FE_TOWARDZERO))
2969     {
2970       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2971       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2972       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2973       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2974       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2975       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2976       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2977       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2978       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2979       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2980     }
2981
2982   fesetround (save_round_mode);
2983
2984   END (cos_towardzero);
2985 }
2986
2987
2988 static void
2989 cos_test_downward (void)
2990 {
2991   int save_round_mode;
2992   errno = 0;
2993   FUNC(cos) (0);
2994   if (errno == ENOSYS)
2995     /* Function not implemented.  */
2996     return;
2997
2998   START (cos_downward);
2999
3000   save_round_mode = fegetround ();
3001
3002   if (!fesetround (FE_DOWNWARD))
3003     {
3004       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
3005       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
3006       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
3007       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
3008       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
3009       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
3010       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
3011       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
3012       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
3013       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
3014     }
3015
3016   fesetround (save_round_mode);
3017
3018   END (cos_downward);
3019 }
3020
3021
3022 static void
3023 cos_test_upward (void)
3024 {
3025   int save_round_mode;
3026   errno = 0;
3027   FUNC(cos) (0);
3028   if (errno == ENOSYS)
3029     /* Function not implemented.  */
3030     return;
3031
3032   START (cos_upward);
3033
3034   save_round_mode = fegetround ();
3035
3036   if (!fesetround (FE_UPWARD))
3037     {
3038       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
3039       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
3040       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
3041       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
3042       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
3043       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
3044       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
3045       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
3046       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
3047       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
3048     }
3049
3050   fesetround (save_round_mode);
3051
3052   END (cos_upward);
3053 }
3054
3055
3056 static void
3057 cosh_test (void)
3058 {
3059   errno = 0;
3060   FUNC(cosh) (0.7L);
3061   if (errno == ENOSYS)
3062     /* Function not implemented.  */
3063     return;
3064
3065   START (cosh);
3066   TEST_f_f (cosh, 0, 1);
3067   TEST_f_f (cosh, minus_zero, 1);
3068
3069 #ifndef TEST_INLINE
3070   TEST_f_f (cosh, plus_infty, plus_infty);
3071   TEST_f_f (cosh, minus_infty, plus_infty);
3072 #endif
3073   TEST_f_f (cosh, nan_value, nan_value);
3074
3075   TEST_f_f (cosh, 0.75L, 1.29468328467684468784170818539018176L);
3076
3077 #ifndef TEST_FLOAT
3078   TEST_f_f (cosh, 709.8893558127259666434838436543941497802734375L, 9.9999998999995070652573675944761818416035e+307L);
3079   TEST_f_f (cosh, -709.8893558127259666434838436543941497802734375L, 9.9999998999995070652573675944761818416035e+307L);
3080 #endif
3081
3082   END (cosh);
3083 }
3084
3085
3086 static void
3087 cosh_test_tonearest (void)
3088 {
3089   int save_round_mode;
3090   errno = 0;
3091   FUNC(cosh) (0);
3092   if (errno == ENOSYS)
3093     /* Function not implemented.  */
3094     return;
3095
3096   START (cosh_tonearest);
3097
3098   save_round_mode = fegetround ();
3099
3100   if (!fesetround (FE_TONEAREST))
3101     {
3102       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
3103       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
3104       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
3105     }
3106
3107   fesetround (save_round_mode);
3108
3109   END (cosh_tonearest);
3110 }
3111
3112
3113 static void
3114 cosh_test_towardzero (void)
3115 {
3116   int save_round_mode;
3117   errno = 0;
3118   FUNC(cosh) (0);
3119   if (errno == ENOSYS)
3120     /* Function not implemented.  */
3121     return;
3122
3123   START (cosh_towardzero);
3124
3125   save_round_mode = fegetround ();
3126
3127   if (!fesetround (FE_TOWARDZERO))
3128     {
3129       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
3130       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
3131       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
3132     }
3133
3134   fesetround (save_round_mode);
3135
3136   END (cosh_towardzero);
3137 }
3138
3139
3140 static void
3141 cosh_test_downward (void)
3142 {
3143   int save_round_mode;
3144   errno = 0;
3145   FUNC(cosh) (0);
3146   if (errno == ENOSYS)
3147     /* Function not implemented.  */
3148     return;
3149
3150   START (cosh_downward);
3151
3152   save_round_mode = fegetround ();
3153
3154   if (!fesetround (FE_DOWNWARD))
3155     {
3156       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
3157       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
3158       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
3159     }
3160
3161   fesetround (save_round_mode);
3162
3163   END (cosh_downward);
3164 }
3165
3166
3167 static void
3168 cosh_test_upward (void)
3169 {
3170   int save_round_mode;
3171   errno = 0;
3172   FUNC(cosh) (0);
3173   if (errno == ENOSYS)
3174     /* Function not implemented.  */
3175     return;
3176
3177   START (cosh_upward);
3178
3179   save_round_mode = fegetround ();
3180
3181   if (!fesetround (FE_UPWARD))
3182     {
3183       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
3184       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
3185       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
3186     }
3187
3188   fesetround (save_round_mode);
3189
3190   END (cosh_upward);
3191 }
3192
3193
3194 static void
3195 cpow_test (void)
3196 {
3197   errno = 0;
3198   FUNC(cpow) (BUILD_COMPLEX (1, 0), BUILD_COMPLEX (0, 0));
3199   if (errno == ENOSYS)
3200     /* Function not implemented.  */
3201     return;
3202
3203   START (cpow);
3204
3205   TEST_cc_c (cpow, 1, 0, 0, 0, 1.0, 0.0);
3206   TEST_cc_c (cpow, 2, 0, 10, 0, 1024.0, 0.0);
3207
3208   TEST_cc_c (cpow, M_El, 0, 0, 2 * M_PIl, 1.0, 0.0);
3209   TEST_cc_c (cpow, 2, 3, 4, 0, -119.0, -120.0);
3210
3211   TEST_cc_c (cpow, nan_value, nan_value, nan_value, nan_value, nan_value, nan_value);
3212
3213   TEST_cc_c (cpow, 0.75L, 1.25L, 0.75L, 1.25L, 0.117506293914473555420279832210420483L, 0.346552747708338676483025352060418001L);
3214   TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 1.0L, 0.0846958290317209430433805274189191353L, 0.513285749182902449043287190519090481L);
3215   TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 0.0L, 0.75L, 1.25L);
3216   TEST_cc_c (cpow, 0.75L, 1.25L, 0.0L, 1.0L, 0.331825439177608832276067945276730566L, 0.131338600281188544930936345230903032L);
3217
3218   END (cpow, complex);
3219 }
3220
3221
3222 static void
3223 cproj_test (void)
3224 {
3225   START (cproj);
3226   TEST_c_c (cproj, 0.0, 0.0, 0.0, 0.0);
3227   TEST_c_c (cproj, minus_zero, minus_zero, minus_zero, minus_zero);
3228   TEST_c_c (cproj, 0.0, minus_zero, 0.0, minus_zero);
3229   TEST_c_c (cproj, minus_zero, 0.0, minus_zero, 0.0);
3230
3231   TEST_c_c (cproj, nan_value, nan_value, nan_value, nan_value);
3232
3233   TEST_c_c (cproj, plus_infty, plus_infty, plus_infty, 0.0);
3234   TEST_c_c (cproj, plus_infty, minus_infty, plus_infty, minus_zero);
3235   TEST_c_c (cproj, minus_infty, plus_infty, plus_infty, 0.0);
3236   TEST_c_c (cproj, minus_infty, minus_infty, plus_infty, minus_zero);
3237
3238   TEST_c_c (cproj, 1.0, 0.0, 1.0, 0.0);
3239   TEST_c_c (cproj, 2.0, 3.0, 2.0, 3.0);
3240
3241   END (cproj, complex);
3242 }
3243
3244
3245 static void
3246 creal_test (void)
3247 {
3248   START (creal);
3249   TEST_c_f (creal, 0.0, 1.0, 0.0);
3250   TEST_c_f (creal, minus_zero, 1.0, minus_zero);
3251   TEST_c_f (creal, nan_value, 1.0, nan_value);
3252   TEST_c_f (creal, nan_value, nan_value, nan_value);
3253   TEST_c_f (creal, plus_infty, 1.0, plus_infty);
3254   TEST_c_f (creal, minus_infty, 1.0, minus_infty);
3255   TEST_c_f (creal, 2.0, 3.0, 2.0);
3256
3257   END (creal);
3258 }
3259
3260 static void
3261 csin_test (void)
3262 {
3263   errno = 0;
3264   FUNC(csin) (BUILD_COMPLEX (0.7L, 1.2L));
3265   if (errno == ENOSYS)
3266     /* Function not implemented.  */
3267     return;
3268
3269   START (csin);
3270
3271   TEST_c_c (csin, 0.0, 0.0, 0.0, 0.0);
3272   TEST_c_c (csin, minus_zero, 0.0, minus_zero, 0.0);
3273   TEST_c_c (csin, 0.0, minus_zero, 0, minus_zero);
3274   TEST_c_c (csin, minus_zero, minus_zero, minus_zero, minus_zero);
3275
3276   TEST_c_c (csin, 0.0, plus_infty, 0.0, plus_infty);
3277   TEST_c_c (csin, minus_zero, plus_infty, minus_zero, plus_infty);
3278   TEST_c_c (csin, 0.0, minus_infty, 0.0, minus_infty);
3279   TEST_c_c (csin, minus_zero, minus_infty, minus_zero, minus_infty);
3280
3281   TEST_c_c (csin, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3282   TEST_c_c (csin, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3283   TEST_c_c (csin, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3284   TEST_c_c (csin, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3285
3286   TEST_c_c (csin, plus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3287   TEST_c_c (csin, minus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3288   TEST_c_c (csin, plus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3289   TEST_c_c (csin, minus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3290
3291   TEST_c_c (csin, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
3292   TEST_c_c (csin, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
3293   TEST_c_c (csin, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
3294   TEST_c_c (csin, minus_infty, -6.75,  nan_value, nan_value, INVALID_EXCEPTION);
3295
3296   TEST_c_c (csin, 4.625, plus_infty, minus_infty, minus_infty);
3297   TEST_c_c (csin, 4.625, minus_infty, minus_infty, plus_infty);
3298   TEST_c_c (csin, -4.625, plus_infty, plus_infty, minus_infty);
3299   TEST_c_c (csin, -4.625, minus_infty, plus_infty, plus_infty);
3300
3301   TEST_c_c (csin, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
3302   TEST_c_c (csin, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
3303
3304   TEST_c_c (csin, nan_value, plus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
3305   TEST_c_c (csin, nan_value, minus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
3306
3307   TEST_c_c (csin, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3308   TEST_c_c (csin, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3309
3310   TEST_c_c (csin, 0.0, nan_value, 0.0, nan_value);
3311   TEST_c_c (csin, minus_zero, nan_value, minus_zero, nan_value);
3312
3313   TEST_c_c (csin, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3314   TEST_c_c (csin, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3315
3316   TEST_c_c (csin, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3317   TEST_c_c (csin, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3318
3319   TEST_c_c (csin, nan_value, nan_value, nan_value, nan_value);
3320
3321   TEST_c_c (csin, 0.75L, 1.25L, 1.28722291002649188575873510790565441L, 1.17210635989270256101081285116138863L);
3322   TEST_c_c (csin, -2, -3, -9.15449914691142957346729954460983256L, 4.16890695996656435075481305885375484L);
3323
3324   TEST_c_c (csin, 0.75, 89.5, 2.522786001038096774676288412995370563339e38L, 2.708024460708609732016532185663087200560e38L);
3325   TEST_c_c (csin, 0.75, -89.5, 2.522786001038096774676288412995370563339e38L, -2.708024460708609732016532185663087200560e38L);
3326   TEST_c_c (csin, -0.75, 89.5, -2.522786001038096774676288412995370563339e38L, 2.708024460708609732016532185663087200560e38L);
3327   TEST_c_c (csin, -0.75, -89.5, -2.522786001038096774676288412995370563339e38L, -2.708024460708609732016532185663087200560e38L);
3328
3329 #ifndef TEST_FLOAT
3330   TEST_c_c (csin, 0.75, 710.5, 1.255317763348154410745082950806112487736e308L, 1.347490911916428129246890157395342279438e308L);
3331   TEST_c_c (csin, 0.75, -710.5, 1.255317763348154410745082950806112487736e308L, -1.347490911916428129246890157395342279438e308L);
3332   TEST_c_c (csin, -0.75, 710.5, -1.255317763348154410745082950806112487736e308L, 1.347490911916428129246890157395342279438e308L);
3333   TEST_c_c (csin, -0.75, -710.5, -1.255317763348154410745082950806112487736e308L, -1.347490911916428129246890157395342279438e308L);
3334 #endif
3335
3336 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3337   TEST_c_c (csin, 0.75, 11357.25, 8.385498349388321535962327491346664141020e4931L, 9.001213196851067077465606717616495588201e4931L);
3338   TEST_c_c (csin, 0.75, -11357.25, 8.385498349388321535962327491346664141020e4931L, -9.001213196851067077465606717616495588201e4931L);
3339   TEST_c_c (csin, -0.75, 11357.25, -8.385498349388321535962327491346664141020e4931L, 9.001213196851067077465606717616495588201e4931L);
3340   TEST_c_c (csin, -0.75, -11357.25, -8.385498349388321535962327491346664141020e4931L, -9.001213196851067077465606717616495588201e4931L);
3341 #endif
3342
3343 #ifdef TEST_FLOAT
3344   TEST_c_c (csin, 0x1p-149, 180, 1.043535896672617552965983803453927655332e33L, plus_infty, OVERFLOW_EXCEPTION);
3345 #endif
3346
3347 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
3348   TEST_c_c (csin, 0x1p-1074, 1440, 5.981479269486130556466515778180916082415e301L, plus_infty, OVERFLOW_EXCEPTION);
3349 #endif
3350
3351 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3352   TEST_c_c (csin, 0x1p-16434L, 22730, 1.217853148905605987081057582351152052687e4924L, plus_infty, OVERFLOW_EXCEPTION);
3353 #endif
3354
3355   END (csin, complex);
3356 }
3357
3358
3359 static void
3360 csinh_test (void)
3361 {
3362   errno = 0;
3363   FUNC(csinh) (BUILD_COMPLEX (0.7L, 1.2L));
3364   if (errno == ENOSYS)
3365     /* Function not implemented.  */
3366     return;
3367
3368   START (csinh);
3369
3370   TEST_c_c (csinh, 0.0, 0.0, 0.0, 0.0);
3371   TEST_c_c (csinh, minus_zero, 0.0, minus_zero, 0.0);
3372   TEST_c_c (csinh, 0.0, minus_zero, 0.0, minus_zero);
3373   TEST_c_c (csinh, minus_zero, minus_zero, minus_zero, minus_zero);
3374
3375   TEST_c_c (csinh, 0.0, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3376   TEST_c_c (csinh, minus_zero, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3377   TEST_c_c (csinh, 0.0, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3378   TEST_c_c (csinh, minus_zero, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3379
3380   TEST_c_c (csinh, plus_infty, 0.0, plus_infty, 0.0);
3381   TEST_c_c (csinh, minus_infty, 0.0, minus_infty, 0.0);
3382   TEST_c_c (csinh, plus_infty, minus_zero, plus_infty, minus_zero);
3383   TEST_c_c (csinh, minus_infty, minus_zero, minus_infty, minus_zero);
3384
3385   TEST_c_c (csinh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3386   TEST_c_c (csinh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3387   TEST_c_c (csinh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3388   TEST_c_c (csinh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3389
3390   TEST_c_c (csinh, plus_infty, 4.625, minus_infty, minus_infty);
3391   TEST_c_c (csinh, minus_infty, 4.625, plus_infty, minus_infty);
3392   TEST_c_c (csinh, plus_infty, -4.625, minus_infty, plus_infty);
3393   TEST_c_c (csinh, minus_infty, -4.625, plus_infty, plus_infty);
3394
3395   TEST_c_c (csinh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3396   TEST_c_c (csinh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3397   TEST_c_c (csinh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3398   TEST_c_c (csinh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3399
3400   TEST_c_c (csinh, 0.0, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
3401   TEST_c_c (csinh, minus_zero, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
3402
3403   TEST_c_c (csinh, plus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
3404   TEST_c_c (csinh, minus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
3405
3406   TEST_c_c (csinh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3407   TEST_c_c (csinh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3408
3409   TEST_c_c (csinh, nan_value, 0.0, nan_value, 0.0);
3410   TEST_c_c (csinh, nan_value, minus_zero, nan_value, minus_zero);
3411
3412   TEST_c_c (csinh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3413   TEST_c_c (csinh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3414
3415   TEST_c_c (csinh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
3416   TEST_c_c (csinh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
3417
3418   TEST_c_c (csinh, nan_value, nan_value, nan_value, nan_value);
3419
3420   TEST_c_c (csinh, 0.75L, 1.25L, 0.259294854551162779153349830618433028L, 1.22863452409509552219214606515777594L);
3421   TEST_c_c (csinh, -2, -3, 3.59056458998577995201256544779481679L, -0.530921086248519805267040090660676560L);
3422
3423   TEST_c_c (csinh, 89.5, 0.75, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
3424   TEST_c_c (csinh, -89.5, 0.75, -2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
3425   TEST_c_c (csinh, 89.5, -0.75, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
3426   TEST_c_c (csinh, -89.5, -0.75, -2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
3427
3428 #ifndef TEST_FLOAT
3429   TEST_c_c (csinh, 710.5, 0.75, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
3430   TEST_c_c (csinh, -710.5, 0.75, -1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
3431   TEST_c_c (csinh, 710.5, -0.75, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
3432   TEST_c_c (csinh, -710.5, -0.75, -1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
3433 #endif
3434
3435 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3436   TEST_c_c (csinh, 11357.25, 0.75, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
3437   TEST_c_c (csinh, -11357.25, 0.75, -9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
3438   TEST_c_c (csinh, 11357.25, -0.75, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
3439   TEST_c_c (csinh, -11357.25, -0.75, -9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
3440 #endif
3441
3442 #ifdef TEST_FLOAT
3443   TEST_c_c (csinh, 180, 0x1p-149, plus_infty, 1.043535896672617552965983803453927655332e33L, OVERFLOW_EXCEPTION);
3444 #endif
3445
3446 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
3447   TEST_c_c (csinh, 1440, 0x1p-1074, plus_infty, 5.981479269486130556466515778180916082415e301L, OVERFLOW_EXCEPTION);
3448 #endif
3449
3450 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3451   TEST_c_c (csinh, 22730, 0x1p-16434L, plus_infty, 1.217853148905605987081057582351152052687e4924L, OVERFLOW_EXCEPTION);
3452 #endif
3453
3454   END (csinh, complex);
3455 }
3456
3457
3458 static void
3459 csqrt_test (void)
3460 {
3461   errno = 0;
3462   FUNC(csqrt) (BUILD_COMPLEX (-1, 0));
3463   if (errno == ENOSYS)
3464     /* Function not implemented.  */
3465     return;
3466
3467   START (csqrt);
3468
3469   TEST_c_c (csqrt, 0, 0, 0.0, 0.0);
3470   TEST_c_c (csqrt, 0, minus_zero, 0, minus_zero);
3471   TEST_c_c (csqrt, minus_zero, 0, 0.0, 0.0);
3472   TEST_c_c (csqrt, minus_zero, minus_zero, 0.0, minus_zero);
3473
3474   TEST_c_c (csqrt, minus_infty, 0, 0.0, plus_infty);
3475   TEST_c_c (csqrt, minus_infty, 6, 0.0, plus_infty);
3476   TEST_c_c (csqrt, minus_infty, minus_zero, 0.0, minus_infty);
3477   TEST_c_c (csqrt, minus_infty, -6, 0.0, minus_infty);
3478
3479   TEST_c_c (csqrt, plus_infty, 0, plus_infty, 0.0);
3480   TEST_c_c (csqrt, plus_infty, 6, plus_infty, 0.0);
3481   TEST_c_c (csqrt, plus_infty, minus_zero, plus_infty, minus_zero);
3482   TEST_c_c (csqrt, plus_infty, -6, plus_infty, minus_zero);
3483
3484   TEST_c_c (csqrt, 0, plus_infty, plus_infty, plus_infty);
3485   TEST_c_c (csqrt, 4, plus_infty, plus_infty, plus_infty);
3486   TEST_c_c (csqrt, plus_infty, plus_infty, plus_infty, plus_infty);
3487   TEST_c_c (csqrt, minus_zero, plus_infty, plus_infty, plus_infty);
3488   TEST_c_c (csqrt, -4, plus_infty, plus_infty, plus_infty);
3489   TEST_c_c (csqrt, minus_infty, plus_infty, plus_infty, plus_infty);
3490   TEST_c_c (csqrt, 0, minus_infty, plus_infty, minus_infty);
3491   TEST_c_c (csqrt, 4, minus_infty, plus_infty, minus_infty);
3492   TEST_c_c (csqrt, plus_infty, minus_infty, plus_infty, minus_infty);
3493   TEST_c_c (csqrt, minus_zero, minus_infty, plus_infty, minus_infty);
3494   TEST_c_c (csqrt, -4, minus_infty, plus_infty, minus_infty);
3495   TEST_c_c (csqrt, minus_infty, minus_infty, plus_infty, minus_infty);
3496
3497   TEST_c_c (csqrt, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
3498
3499   TEST_c_c (csqrt, plus_infty, nan_value, plus_infty, nan_value);
3500
3501   TEST_c_c (csqrt, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3502   TEST_c_c (csqrt, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3503   TEST_c_c (csqrt, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3504   TEST_c_c (csqrt, -1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3505
3506   TEST_c_c (csqrt, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3507   TEST_c_c (csqrt, nan_value, 8, nan_value, nan_value, INVALID_EXCEPTION_OK);
3508   TEST_c_c (csqrt, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
3509   TEST_c_c (csqrt, nan_value, -8, nan_value, nan_value, INVALID_EXCEPTION_OK);
3510
3511   TEST_c_c (csqrt, nan_value, nan_value, nan_value, nan_value);
3512
3513   TEST_c_c (csqrt, 16.0, -30.0, 5.0, -3.0);
3514   TEST_c_c (csqrt, -1, 0, 0.0, 1.0);
3515   TEST_c_c (csqrt, 0, 2, 1.0, 1.0);
3516   TEST_c_c (csqrt, 119, 120, 12.0, 5.0);
3517   TEST_c_c (csqrt, 0.75L, 1.25L, 1.05065169626078392338656675760808326L, 0.594868882070379067881984030639932657L);
3518   TEST_c_c (csqrt, -2, -3, 0.89597747612983812471573375529004348L, -1.6741492280355400404480393008490519L);
3519   TEST_c_c (csqrt, -2, 3, 0.89597747612983812471573375529004348L, 1.6741492280355400404480393008490519L);
3520   /* Principal square root should be returned (i.e., non-negative real
3521      part).  */
3522   TEST_c_c (csqrt, 0, -1, M_SQRT_2_2, -M_SQRT_2_2);
3523
3524   TEST_c_c (csqrt, 0x1.fffffep+127L, 0x1.fffffep+127L, 2.026714405498316804978751017492482558075e+19L, 8.394925938143272988211878516208015586281e+18L);
3525   TEST_c_c (csqrt, 0x1.fffffep+127L, 1.0L, 1.844674352395372953599975585936590505260e+19L, 2.710505511993121390769065968615872097053e-20L);
3526   TEST_c_c (csqrt, 0x1p-149L, 0x1p-149L, 4.112805464342778798097003462770175200803e-23L, 1.703579802732953750368659735601389709551e-23L);
3527   TEST_c_c (csqrt, 0x1p-147L, 0x1p-147L, 8.225610928685557596194006925540350401606e-23L, 3.407159605465907500737319471202779419102e-23L);
3528
3529   TEST_c_c (csqrt, plus_zero, 0x1p-149L, 2.646977960169688559588507814623881131411e-23L, 2.646977960169688559588507814623881131411e-23L);
3530   TEST_c_c (csqrt, 0x1p-50L, 0x1p-149L, 2.980232238769531250000000000000000000000e-8L, 2.350988701644575015937473074444491355637e-38L);
3531 #ifdef TEST_FLOAT
3532   TEST_c_c (csqrt, 0x1p+127L, 0x1p-149L, 1.304381782533278221234957180625250836888e19L, plus_zero, UNDERFLOW_EXCEPTION);
3533 #endif
3534   TEST_c_c (csqrt, 0x1p-149L, 0x1p+127L, 9.223372036854775808000000000000000000000e18L, 9.223372036854775808000000000000000000000e18L);
3535   TEST_c_c (csqrt, 0x1.000002p-126L, 0x1.000002p-126L, 1.191195773697904627170323731331667740087e-19L, 4.934094449071842328766868579214125217132e-20L);
3536   TEST_c_c (csqrt, -0x1.000002p-126L, -0x1.000002p-126L, 4.934094449071842328766868579214125217132e-20L, -1.191195773697904627170323731331667740087e-19L);
3537
3538 #ifndef TEST_FLOAT
3539   TEST_c_c (csqrt, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 1.473094556905565378990473658199034571917e+154L, 6.101757441282702188537080005372547713595e+153L);
3540   TEST_c_c (csqrt, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 1.379778091031440685006200821918878702861e+154L, 3.257214233483129514781233066898042490248e+153L);
3541   TEST_c_c (csqrt, 0x1p-1074L, 0x1p-1074L, 2.442109726130830256743814843868934877597e-162L, 1.011554969366634726113090867589031782487e-162L);
3542   TEST_c_c (csqrt, 0x1p-1073L, 0x1p-1073L, 3.453664695497464982856905711457966660085e-162L, 1.430554756764195530630723976279903095110e-162L);
3543
3544   TEST_c_c (csqrt, plus_zero, 0x1p-1074L, 1.571727784702628688909515672805082228285e-162L, 1.571727784702628688909515672805082228285e-162L);
3545   TEST_c_c (csqrt, 0x1p-500L, 0x1p-1074L, 5.527147875260444560247265192192255725514e-76L, 4.469444793151709302716387622440056066334e-249L);
3546 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
3547   TEST_c_c (csqrt, 0x1p+1023L, 0x1p-1074L, 9.480751908109176726832526455652159260085e153L, plus_zero, UNDERFLOW_EXCEPTION);
3548 #endif
3549   TEST_c_c (csqrt, 0x1p-1074L, 0x1p+1023L, 6.703903964971298549787012499102923063740e153L, 6.703903964971298549787012499102923063740e153L);
3550   TEST_c_c (csqrt, 0x1.0000000000001p-1022L, 0x1.0000000000001p-1022L, 1.638872094839911521020410942677082920935e-154L, 6.788430486774966350907249113759995429568e-155L);
3551   TEST_c_c (csqrt, -0x1.0000000000001p-1022L, -0x1.0000000000001p-1022L, 6.788430486774966350907249113759995429568e-155L, -1.638872094839911521020410942677082920935e-154L);
3552 #endif
3553
3554 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3555   TEST_c_c (csqrt, 0x1.fp+16383L, 0x1.fp+16383L, 1.179514222452201722651836720466795901016e+2466L, 4.885707879516577666702435054303191575148e+2465L);
3556   TEST_c_c (csqrt, 0x1.fp+16383L, 0x1p+16383L, 1.106698967236475180613254276996359485630e+2466L, 2.687568007603946993388538156299100955642e+2465L);
3557   TEST_c_c (csqrt, 0x1p-16440L, 0x1p-16441L, 3.514690655930285351254618340783294558136e-2475L,  8.297059146828716918029689466551384219370e-2476L);
3558
3559   TEST_c_c (csqrt, plus_zero, 0x1p-16445L, 4.269191686890197837775136325621239761720e-2476L, 4.269191686890197837775136325621239761720e-2476L);
3560   TEST_c_c (csqrt, 0x1p-5000L, 0x1p-16445L, 2.660791472672778409283210520357607795518e-753L, 6.849840675828785164910701384823702064234e-4199L);
3561   TEST_c_c (csqrt, 0x1p+16383L, 0x1p-16445L, 7.712754032630730034273323365543179095045e2465L, plus_zero, UNDERFLOW_EXCEPTION);
3562   TEST_c_c (csqrt, 0x1p-16445L, 0x1p+16383L, 5.453740678097079647314921223668914312241e2465L, 5.453740678097079647314921223668914312241e2465L);
3563   TEST_c_c (csqrt, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-16382L, 2.014551439675644900131815801350165472778e-2466L, 8.344545284118961664300307045791497724440e-2467L);
3564   TEST_c_c (csqrt, -0x1.0000000000000002p-16382L, -0x1.0000000000000002p-16382L, 8.344545284118961664300307045791497724440e-2467L, -2.014551439675644900131815801350165472778e-2466L);
3565
3566 # if LDBL_MANT_DIG >= 113
3567   TEST_c_c (csqrt, plus_zero, 0x1p-16494L, 1.799329752913293143453817328207572571442e-2483L, 1.799329752913293143453817328207572571442e-2483L);
3568   TEST_c_c (csqrt, 0x1p-5000L, 0x1p-16494L, 2.660791472672778409283210520357607795518e-753L, 1.216776133331049643422030716668249905907e-4213L);
3569   TEST_c_c (csqrt, 0x1p+16383L, 0x1p-16494L, 7.712754032630730034273323365543179095045e2465L, plus_zero, UNDERFLOW_EXCEPTION);
3570   TEST_c_c (csqrt, 0x1p-16494L, 0x1p+16383L, 5.453740678097079647314921223668914312241e2465L, 5.453740678097079647314921223668914312241e2465L);
3571   TEST_c_c (csqrt, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-16382L, 2.014551439675644900022606748976158925145e-2466L, 8.344545284118961663847948339519226074126e-2467L);
3572   TEST_c_c (csqrt, -0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-16382L, 8.344545284118961663847948339519226074126e-2467L, -2.014551439675644900022606748976158925145e-2466L);
3573 # endif
3574 #endif
3575
3576   END (csqrt, complex);
3577 }
3578
3579 static void
3580 ctan_test (void)
3581 {
3582   errno = 0;
3583   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3584   if (errno == ENOSYS)
3585     /* Function not implemented.  */
3586     return;
3587
3588   START (ctan);
3589
3590   TEST_c_c (ctan, 0, 0, 0.0, 0.0);
3591   TEST_c_c (ctan, 0, minus_zero, 0.0, minus_zero);
3592   TEST_c_c (ctan, minus_zero, 0, minus_zero, 0.0);
3593   TEST_c_c (ctan, minus_zero, minus_zero, minus_zero, minus_zero);
3594
3595   TEST_c_c (ctan, 0, plus_infty, 0.0, 1.0);
3596   TEST_c_c (ctan, 1, plus_infty, 0.0, 1.0);
3597   TEST_c_c (ctan, minus_zero, plus_infty, minus_zero, 1.0);
3598   TEST_c_c (ctan, -1, plus_infty, minus_zero, 1.0);
3599
3600   TEST_c_c (ctan, 0, minus_infty, 0.0, -1.0);
3601   TEST_c_c (ctan, 1, minus_infty, 0.0, -1.0);
3602   TEST_c_c (ctan, minus_zero, minus_infty, minus_zero, -1.0);
3603   TEST_c_c (ctan, -1, minus_infty, minus_zero, -1.0);
3604
3605   TEST_c_c (ctan, plus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
3606   TEST_c_c (ctan, plus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
3607   TEST_c_c (ctan, minus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
3608   TEST_c_c (ctan, minus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
3609   TEST_c_c (ctan, plus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
3610   TEST_c_c (ctan, plus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
3611   TEST_c_c (ctan, minus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
3612   TEST_c_c (ctan, minus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
3613
3614   TEST_c_c (ctan, nan_value, plus_infty, 0.0, 1.0, IGNORE_ZERO_INF_SIGN);
3615   TEST_c_c (ctan, nan_value, minus_infty, 0.0, -1.0, IGNORE_ZERO_INF_SIGN);
3616
3617   TEST_c_c (ctan, 0, nan_value, 0.0, nan_value);
3618   TEST_c_c (ctan, minus_zero, nan_value, minus_zero, nan_value);
3619
3620   TEST_c_c (ctan, 0.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3621   TEST_c_c (ctan, -4.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3622
3623   TEST_c_c (ctan, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3624   TEST_c_c (ctan, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
3625   TEST_c_c (ctan, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
3626   TEST_c_c (ctan, nan_value, -0.25, nan_value, nan_value, INVALID_EXCEPTION_OK);
3627
3628   TEST_c_c (ctan, nan_value, nan_value, nan_value, nan_value);
3629
3630   TEST_c_c (ctan, 0.75L, 1.25L, 0.160807785916206426725166058173438663L, 0.975363285031235646193581759755216379L);
3631   TEST_c_c (ctan, -2, -3, 0.376402564150424829275122113032269084e-2L, -1.00323862735360980144635859782192726L);
3632
3633   TEST_c_c (ctan, 1, 45, 1.490158918874345552942703234806348520895e-39L, 1.000000000000000000000000000000000000001L, UNDERFLOW_EXCEPTION_FLOAT);
3634   TEST_c_c (ctan, 1, 47, 2.729321264492904590777293425576722354636e-41L, 1.0, UNDERFLOW_EXCEPTION_FLOAT);
3635
3636 #ifndef TEST_FLOAT
3637   TEST_c_c (ctan, 1, 355, 8.140551093483276762350406321792653551513e-309L, 1.0, UNDERFLOW_EXCEPTION_DOUBLE);
3638   TEST_c_c (ctan, 1, 365, 1.677892637497921890115075995898773550884e-317L, 1.0, UNDERFLOW_EXCEPTION_DOUBLE);
3639 #endif
3640
3641 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3642   TEST_c_c (ctan, 1, 5680, 4.725214596136812019616700920476949798307e-4934L, 1.0, UNDERFLOW_EXCEPTION);
3643   TEST_c_c (ctan, 1, 5690, 9.739393181626937151720816611272607059057e-4943L, 1.0, UNDERFLOW_EXCEPTION);
3644 #endif
3645
3646   TEST_c_c (ctan, 0x3.243f6cp-1, 0, -2.287733242885645987394874673945769518150e7L, 0.0);
3647
3648   TEST_c_c (ctan, 0x1p127, 1, 0.2446359391192790896381501310437708987204L, 0.9101334047676183761532873794426475906201L);
3649
3650 #ifndef TEST_FLOAT
3651   TEST_c_c (ctan, 0x1p1023, 1, -0.2254627924997545057926782581695274244229L, 0.8786063118883068695462540226219865087189L);
3652 #endif
3653
3654 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3655   TEST_c_c (ctan, 0x1p16383L, 1, 0.1608598776370396607204448234354670036772L, 0.8133818522051542536316746743877629761488L);
3656 #endif
3657
3658   TEST_c_c (ctan, 50000, 50000, plus_zero, 1.0, UNDERFLOW_EXCEPTION);
3659   TEST_c_c (ctan, 50000, -50000, plus_zero, -1.0, UNDERFLOW_EXCEPTION);
3660   TEST_c_c (ctan, -50000, 50000, minus_zero, 1.0, UNDERFLOW_EXCEPTION);
3661   TEST_c_c (ctan, -50000, -50000, minus_zero, -1.0, UNDERFLOW_EXCEPTION);
3662
3663   END (ctan, complex);
3664 }
3665
3666
3667 static void
3668 ctan_test_tonearest (void)
3669 {
3670   int save_round_mode;
3671   errno = 0;
3672   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3673   if (errno == ENOSYS)
3674     /* Function not implemented.  */
3675     return;
3676
3677   START (ctan_tonearest);
3678
3679   save_round_mode = fegetround ();
3680
3681   if (!fesetround (FE_TONEAREST))
3682     {
3683       TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L);
3684
3685 #ifndef TEST_FLOAT
3686       TEST_c_c (ctan, 0x1.921fb54442d18p+0, 0x1p-1074, 1.633123935319536975596773704152891653086e16L, 1.317719414943508315995636961402669067843e-291L);
3687 #endif
3688
3689 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3690       TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L);
3691 #endif
3692     }
3693
3694   fesetround (save_round_mode);
3695
3696   END (ctan_tonearest, complex);
3697 }
3698
3699
3700 static void
3701 ctan_test_towardzero (void)
3702 {
3703   int save_round_mode;
3704   errno = 0;
3705   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3706   if (errno == ENOSYS)
3707     /* Function not implemented.  */
3708     return;
3709
3710   START (ctan_towardzero);
3711
3712   save_round_mode = fegetround ();
3713
3714   if (!fesetround (FE_TOWARDZERO))
3715     {
3716       TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L);
3717
3718 #ifndef TEST_FLOAT
3719       TEST_c_c (ctan, 0x1.921fb54442d18p+0, 0x1p-1074, 1.633123935319536975596773704152891653086e16L, 1.317719414943508315995636961402669067843e-291L);
3720 #endif
3721
3722 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3723       TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L);
3724 #endif
3725     }
3726
3727   fesetround (save_round_mode);
3728
3729   END (ctan_towardzero, complex);
3730 }
3731
3732
3733 static void
3734 ctan_test_downward (void)
3735 {
3736   int save_round_mode;
3737   errno = 0;
3738   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3739   if (errno == ENOSYS)
3740     /* Function not implemented.  */
3741     return;
3742
3743   START (ctan_downward);
3744
3745   save_round_mode = fegetround ();
3746
3747   if (!fesetround (FE_DOWNWARD))
3748     {
3749       TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L);
3750
3751 #ifndef TEST_FLOAT
3752       TEST_c_c (ctan, 0x1.921fb54442d18p+0, 0x1p-1074, 1.633123935319536975596773704152891653086e16L, 1.317719414943508315995636961402669067843e-291L);
3753 #endif
3754
3755 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3756       TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L);
3757 #endif
3758     }
3759
3760   fesetround (save_round_mode);
3761
3762   END (ctan_downward, complex);
3763 }
3764
3765
3766 static void
3767 ctan_test_upward (void)
3768 {
3769   int save_round_mode;
3770   errno = 0;
3771   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3772   if (errno == ENOSYS)
3773     /* Function not implemented.  */
3774     return;
3775
3776   START (ctan_upward);
3777
3778   save_round_mode = fegetround ();
3779
3780   if (!fesetround (FE_UPWARD))
3781     {
3782       TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L);
3783
3784 #ifndef TEST_FLOAT
3785       TEST_c_c (ctan, 0x1.921fb54442d18p+0, 0x1p-1074, 1.633123935319536975596773704152891653086e16L, 1.317719414943508315995636961402669067843e-291L);
3786 #endif
3787
3788 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3789       TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L);
3790 #endif
3791     }
3792
3793   fesetround (save_round_mode);
3794
3795   END (ctan_upward, complex);
3796 }
3797
3798
3799 static void
3800 ctanh_test (void)
3801 {
3802   errno = 0;
3803   FUNC(ctanh) (BUILD_COMPLEX (0, 0));
3804   if (errno == ENOSYS)
3805     /* Function not implemented.  */
3806     return;
3807
3808   START (ctanh);
3809
3810   TEST_c_c (ctanh, 0, 0, 0.0, 0.0);
3811   TEST_c_c (ctanh, 0, minus_zero, 0.0, minus_zero);
3812   TEST_c_c (ctanh, minus_zero, 0, minus_zero, 0.0);
3813   TEST_c_c (ctanh, minus_zero, minus_zero, minus_zero, minus_zero);
3814
3815   TEST_c_c (ctanh, plus_infty, 0, 1.0, 0.0);
3816   TEST_c_c (ctanh, plus_infty, 1, 1.0, 0.0);
3817   TEST_c_c (ctanh, plus_infty, minus_zero, 1.0, minus_zero);
3818   TEST_c_c (ctanh, plus_infty, -1, 1.0, minus_zero);
3819   TEST_c_c (ctanh, minus_infty, 0, -1.0, 0.0);
3820   TEST_c_c (ctanh, minus_infty, 1, -1.0, 0.0);
3821   TEST_c_c (ctanh, minus_infty, minus_zero, -1.0, minus_zero);
3822   TEST_c_c (ctanh, minus_infty, -1, -1.0, minus_zero);
3823
3824   TEST_c_c (ctanh, 0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3825   TEST_c_c (ctanh, 2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3826   TEST_c_c (ctanh, 0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3827   TEST_c_c (ctanh, 2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3828   TEST_c_c (ctanh, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3829   TEST_c_c (ctanh, -2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3830   TEST_c_c (ctanh, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3831   TEST_c_c (ctanh, -2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3832
3833   TEST_c_c (ctanh, plus_infty, nan_value, 1.0, 0.0, IGNORE_ZERO_INF_SIGN);
3834   TEST_c_c (ctanh, minus_infty, nan_value, -1.0, 0.0, IGNORE_ZERO_INF_SIGN);
3835
3836   TEST_c_c (ctanh, nan_value, 0, nan_value, 0.0);
3837   TEST_c_c (ctanh, nan_value, minus_zero, nan_value, minus_zero);
3838
3839   TEST_c_c (ctanh, nan_value, 0.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
3840   TEST_c_c (ctanh, nan_value, -4.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
3841
3842   TEST_c_c (ctanh, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3843   TEST_c_c (ctanh, 5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3844   TEST_c_c (ctanh, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3845   TEST_c_c (ctanh, -0.25, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3846
3847   TEST_c_c (ctanh, nan_value, nan_value, nan_value, nan_value);
3848
3849   TEST_c_c (ctanh, 0, M_PI_4l, 0.0, 1.0);
3850
3851   TEST_c_c (ctanh, 0.75L, 1.25L, 1.37260757053378320258048606571226857L, 0.385795952609750664177596760720790220L);
3852   TEST_c_c (ctanh, -2, -3, -0.965385879022133124278480269394560686L, 0.988437503832249372031403430350121098e-2L);
3853
3854   TEST_c_c (ctanh, 45, 1, 1.000000000000000000000000000000000000001L, 1.490158918874345552942703234806348520895e-39L, UNDERFLOW_EXCEPTION_FLOAT);
3855   TEST_c_c (ctanh, 47, 1, 1.0, 2.729321264492904590777293425576722354636e-41L, UNDERFLOW_EXCEPTION_FLOAT);
3856
3857 #ifndef TEST_FLOAT
3858   TEST_c_c (ctanh, 355, 1, 1.0, 8.140551093483276762350406321792653551513e-309L, UNDERFLOW_EXCEPTION_DOUBLE);
3859   TEST_c_c (ctanh, 365, 1, 1.0, 1.677892637497921890115075995898773550884e-317L, UNDERFLOW_EXCEPTION_DOUBLE);
3860 #endif
3861
3862 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3863   TEST_c_c (ctanh, 5680, 1, 1.0, 4.725214596136812019616700920476949798307e-4934L, UNDERFLOW_EXCEPTION);
3864   TEST_c_c (ctanh, 5690, 1, 1.0, 9.739393181626937151720816611272607059057e-4943L, UNDERFLOW_EXCEPTION);
3865 #endif
3866
3867   TEST_c_c (ctanh, 0, 0x3.243f6cp-1, 0.0, -2.287733242885645987394874673945769518150e7L);
3868
3869   TEST_c_c (ctanh, 1, 0x1p127, 0.9101334047676183761532873794426475906201L, 0.2446359391192790896381501310437708987204L);
3870
3871 #ifndef TEST_FLOAT
3872   TEST_c_c (ctanh, 1, 0x1p1023, 0.8786063118883068695462540226219865087189L, -0.2254627924997545057926782581695274244229L);
3873 #endif
3874
3875 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3876   TEST_c_c (ctanh, 1, 0x1p16383L, 0.8133818522051542536316746743877629761488L, 0.1608598776370396607204448234354670036772L);
3877 #endif
3878
3879   TEST_c_c (ctanh, 50000, 50000, 1.0, plus_zero, UNDERFLOW_EXCEPTION);
3880   TEST_c_c (ctanh, 50000, -50000, 1.0, minus_zero, UNDERFLOW_EXCEPTION);
3881   TEST_c_c (ctanh, -50000, 50000, -1.0, plus_zero, UNDERFLOW_EXCEPTION);
3882   TEST_c_c (ctanh, -50000, -50000, -1.0, minus_zero, UNDERFLOW_EXCEPTION);
3883
3884   END (ctanh, complex);
3885 }
3886
3887
3888 static void
3889 ctanh_test_tonearest (void)
3890 {
3891   int save_round_mode;
3892   errno = 0;
3893   FUNC(ctanh) (BUILD_COMPLEX (0.7L, 1.2L));
3894   if (errno == ENOSYS)
3895     /* Function not implemented.  */
3896     return;
3897
3898   START (ctanh_tonearest);
3899
3900   save_round_mode = fegetround ();
3901
3902   if (!fesetround (FE_TONEAREST))
3903     {
3904       TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L);
3905
3906 #ifndef TEST_FLOAT
3907       TEST_c_c (ctanh, 0x1p-1074, 0x1.921fb54442d18p+0, 1.317719414943508315995636961402669067843e-291L, 1.633123935319536975596773704152891653086e16L);
3908 #endif
3909
3910 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3911       TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L);
3912 #endif
3913     }
3914
3915   fesetround (save_round_mode);
3916
3917   END (ctanh_tonearest, complex);
3918 }
3919
3920
3921 static void
3922 ctanh_test_towardzero (void)
3923 {
3924   int save_round_mode;
3925   errno = 0;
3926   FUNC(ctanh) (BUILD_COMPLEX (0.7L, 1.2L));
3927   if (errno == ENOSYS)
3928     /* Function not implemented.  */
3929     return;
3930
3931   START (ctanh_towardzero);
3932
3933   save_round_mode = fegetround ();
3934
3935   if (!fesetround (FE_TOWARDZERO))
3936     {
3937       TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L);
3938
3939 #ifndef TEST_FLOAT
3940       TEST_c_c (ctanh, 0x1p-1074, 0x1.921fb54442d18p+0, 1.317719414943508315995636961402669067843e-291L, 1.633123935319536975596773704152891653086e16L);
3941 #endif
3942
3943 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3944       TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L);
3945 #endif
3946     }
3947
3948   fesetround (save_round_mode);
3949
3950   END (ctanh_towardzero, complex);
3951 }
3952
3953
3954 static void
3955 ctanh_test_downward (void)
3956 {
3957   int save_round_mode;
3958   errno = 0;
3959   FUNC(ctanh) (BUILD_COMPLEX (0.7L, 1.2L));
3960   if (errno == ENOSYS)
3961     /* Function not implemented.  */
3962     return;
3963
3964   START (ctanh_downward);
3965
3966   save_round_mode = fegetround ();
3967
3968   if (!fesetround (FE_DOWNWARD))
3969     {
3970       TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L);
3971
3972 #ifndef TEST_FLOAT
3973       TEST_c_c (ctanh, 0x1p-1074, 0x1.921fb54442d18p+0, 1.317719414943508315995636961402669067843e-291L, 1.633123935319536975596773704152891653086e16L);
3974 #endif
3975
3976 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3977       TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L);
3978 #endif
3979     }
3980
3981   fesetround (save_round_mode);
3982
3983   END (ctanh_downward, complex);
3984 }
3985
3986
3987 static void
3988 ctanh_test_upward (void)
3989 {
3990   int save_round_mode;
3991   errno = 0;
3992   FUNC(ctanh) (BUILD_COMPLEX (0.7L, 1.2L));
3993   if (errno == ENOSYS)
3994     /* Function not implemented.  */
3995     return;
3996
3997   START (ctanh_upward);
3998
3999   save_round_mode = fegetround ();
4000
4001   if (!fesetround (FE_UPWARD))
4002     {
4003       TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L);
4004
4005 #ifndef TEST_FLOAT
4006       TEST_c_c (ctanh, 0x1p-1074, 0x1.921fb54442d18p+0, 1.317719414943508315995636961402669067843e-291L, 1.633123935319536975596773704152891653086e16L);
4007 #endif
4008
4009 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
4010       TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L);
4011 #endif
4012     }
4013
4014   fesetround (save_round_mode);
4015
4016   END (ctanh_upward, complex);
4017 }
4018
4019
4020 static void
4021 erf_test (void)
4022 {
4023   errno = 0;
4024   FUNC(erf) (0);
4025   if (errno == ENOSYS)
4026     /* Function not implemented.  */
4027     return;
4028
4029   START (erf);
4030
4031   TEST_f_f (erf, 0, 0);
4032   TEST_f_f (erf, minus_zero, minus_zero);
4033   TEST_f_f (erf, plus_infty, 1);
4034   TEST_f_f (erf, minus_infty, -1);
4035   TEST_f_f (erf, nan_value, nan_value);
4036
4037   TEST_f_f (erf, 0.125L, 0.140316204801333817393029446521623398L);
4038   TEST_f_f (erf, 0.75L, 0.711155633653515131598937834591410777L);
4039   TEST_f_f (erf, 1.25L, 0.922900128256458230136523481197281140L);
4040   TEST_f_f (erf, 2.0L, 0.995322265018952734162069256367252929L);
4041   TEST_f_f (erf, 4.125L, 0.999999994576599200434933994687765914L);
4042   TEST_f_f (erf, 27.0L, 1.0L);
4043
4044   END (erf);
4045 }
4046
4047
4048 static void
4049 erfc_test (void)
4050 {
4051   errno = 0;
4052   FUNC(erfc) (0);
4053   if (errno == ENOSYS)
4054     /* Function not implemented.  */
4055     return;
4056
4057   START (erfc);
4058
4059   TEST_f_f (erfc, plus_infty, 0.0);
4060   TEST_f_f (erfc, minus_infty, 2.0);
4061   TEST_f_f (erfc, 0.0, 1.0);
4062   TEST_f_f (erfc, minus_zero, 1.0);
4063   TEST_f_f (erfc, nan_value, nan_value);
4064
4065   TEST_f_f (erfc, 0.125L, 0.859683795198666182606970553478376602L);
4066   TEST_f_f (erfc, 0.75L, 0.288844366346484868401062165408589223L);
4067   TEST_f_f (erfc, 1.25L, 0.0770998717435417698634765188027188596L);
4068   TEST_f_f (erfc, 2.0L, 0.00467773498104726583793074363274707139L);
4069   TEST_f_f (erfc, 0x1.f7303cp+1L, 2.705500297238986897105236321218861842255e-8L);
4070   TEST_f_f (erfc, 4.125L, 0.542340079956506600531223408575531062e-8L);
4071   TEST_f_f (erfc, 0x1.ffa002p+2L, 1.233585992097580296336099501489175967033e-29L);
4072   TEST_f_f (erfc, 0x1.ffffc8p+2L, 1.122671365033056305522366683719541099329e-29L);
4073 #ifdef TEST_LDOUBLE
4074   /* The result can only be represented in long double.  */
4075 # if LDBL_MIN_10_EXP < -319
4076   TEST_f_f (erfc, 27.0L, 0.523704892378925568501606768284954709e-318L);
4077 # endif
4078 # if LDBL_MANT_DIG >= 106
4079   TEST_f_f (erfc, 0x1.ffff56789abcdef0123456789a8p+2L, 1.123161416304655390092138725253789378459e-29L);
4080 # endif
4081 #endif
4082
4083   END (erfc);
4084 }
4085
4086
4087 static void
4088 exp_test (void)
4089 {
4090   errno = 0;
4091   FUNC(exp) (0);
4092   if (errno == ENOSYS)
4093     /* Function not implemented.  */
4094     return;
4095
4096   START (exp);
4097
4098   TEST_f_f (exp, 0, 1);
4099   TEST_f_f (exp, minus_zero, 1);
4100
4101 #ifndef TEST_INLINE
4102   TEST_f_f (exp, plus_infty, plus_infty);
4103   TEST_f_f (exp, minus_infty, 0);
4104 #endif
4105   TEST_f_f (exp, nan_value, nan_value);
4106   TEST_f_f (exp, 1, M_El);
4107
4108   TEST_f_f (exp, 2, M_E2l);
4109   TEST_f_f (exp, 3, M_E3l);
4110   TEST_f_f (exp, 0.75L, 2.11700001661267466854536981983709561L);
4111   TEST_f_f (exp, 50.0L, 5184705528587072464087.45332293348538L);
4112   TEST_f_f (exp, 88.72269439697265625L, 3.40233126623160774937554134772290447915e38L);
4113 #if defined TEST_LDOUBLE && __LDBL_MAX_EXP__ > 1024
4114   /* The result can only be represented in sane long double.  */
4115   TEST_f_f (exp, 1000.0L, 0.197007111401704699388887935224332313e435L);
4116 #endif
4117
4118 #if !(defined TEST_LDOUBLE && LDBL_MAX_EXP > 1024)
4119   TEST_f_f (exp, 710, plus_infty, OVERFLOW_EXCEPTION);
4120   TEST_f_f (exp, -1234, plus_zero, UNDERFLOW_EXCEPTION);
4121 #endif
4122   TEST_f_f (exp, 1e5, plus_infty, OVERFLOW_EXCEPTION);
4123   TEST_f_f (exp, max_value, plus_infty, OVERFLOW_EXCEPTION);
4124   TEST_f_f (exp, -max_value, 0, UNDERFLOW_EXCEPTION);
4125
4126   END (exp);
4127 }
4128
4129
4130 static void
4131 exp_test_tonearest (void)
4132 {
4133   int save_round_mode;
4134   errno = 0;
4135   FUNC(exp) (0);
4136   if (errno == ENOSYS)
4137     /* Function not implemented.  */
4138     return;
4139
4140   START (exp_tonearest);
4141
4142   save_round_mode = fegetround ();
4143
4144   if (!fesetround (FE_TONEAREST))
4145     {
4146       TEST_f_f (exp, 1, M_El);
4147       TEST_f_f (exp, 2, M_E2l);
4148       TEST_f_f (exp, 3, M_E3l);
4149     }
4150
4151   fesetround (save_round_mode);
4152
4153   END (exp_tonearest);
4154 }
4155
4156
4157 static void
4158 exp_test_towardzero (void)
4159 {
4160   int save_round_mode;
4161   errno = 0;
4162   FUNC(exp) (0);
4163   if (errno == ENOSYS)
4164     /* Function not implemented.  */
4165     return;
4166
4167   START (exp_towardzero);
4168
4169   save_round_mode = fegetround ();
4170
4171   if (!fesetround (FE_TOWARDZERO))
4172     {
4173       TEST_f_f (exp, 1, M_El);
4174       TEST_f_f (exp, 2, M_E2l);
4175       TEST_f_f (exp, 3, M_E3l);
4176     }
4177
4178   fesetround (save_round_mode);
4179
4180   END (exp_towardzero);
4181 }
4182
4183
4184 static void
4185 exp_test_downward (void)
4186 {
4187   int save_round_mode;
4188   errno = 0;
4189   FUNC(exp) (0);
4190   if (errno == ENOSYS)
4191     /* Function not implemented.  */
4192     return;
4193
4194   START (exp_downward);
4195
4196   save_round_mode = fegetround ();
4197
4198   if (!fesetround (FE_DOWNWARD))
4199     {
4200       TEST_f_f (exp, 1, M_El);
4201       TEST_f_f (exp, 2, M_E2l);
4202       TEST_f_f (exp, 3, M_E3l);
4203     }
4204
4205   fesetround (save_round_mode);
4206
4207   END (exp_downward);
4208 }
4209
4210
4211 static void
4212 exp_test_upward (void)
4213 {
4214   int save_round_mode;
4215   errno = 0;
4216   FUNC(exp) (0);
4217   if (errno == ENOSYS)
4218     /* Function not implemented.  */
4219     return;
4220
4221   START (exp_upward);
4222
4223   save_round_mode = fegetround ();
4224
4225   if (!fesetround (FE_UPWARD))
4226     {
4227       TEST_f_f (exp, 1, M_El);
4228       TEST_f_f (exp, 2, M_E2l);
4229       TEST_f_f (exp, 3, M_E3l);
4230     }
4231
4232   fesetround (save_round_mode);
4233
4234   END (exp_upward);
4235 }
4236
4237
4238 static void
4239 exp10_test (void)
4240 {
4241   errno = 0;
4242   FUNC(exp10) (0);
4243   if (errno == ENOSYS)
4244     /* Function not implemented.  */
4245     return;
4246
4247   START (exp10);
4248
4249   TEST_f_f (exp10, 0, 1);
4250   TEST_f_f (exp10, minus_zero, 1);
4251
4252   TEST_f_f (exp10, plus_infty, plus_infty);
4253   TEST_f_f (exp10, minus_infty, 0);
4254   TEST_f_f (exp10, nan_value, nan_value);
4255   TEST_f_f (exp10, 3, 1000);
4256   TEST_f_f (exp10, -1, 0.1L);
4257   TEST_f_f (exp10, 36, 1.0e36L);
4258   TEST_f_f (exp10, -36, 1.0e-36L);
4259 #ifndef TEST_FLOAT
4260   TEST_f_f (exp10, 305, 1.0e305L);
4261   TEST_f_f (exp10, -305, 1.0e-305L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
4262 #endif
4263 #if defined TEST_LDOUBLE && LDBL_MAX_10_EXP >= 4932
4264   TEST_f_f (exp10, 4932, 1.0e4932L);
4265   TEST_f_f (exp10, -4932, 1.0e-4932L, UNDERFLOW_EXCEPTION);
4266 #endif
4267   TEST_f_f (exp10, 1e6, plus_infty, OVERFLOW_EXCEPTION);
4268   TEST_f_f (exp10, -1e6, 0, UNDERFLOW_EXCEPTION);
4269   TEST_f_f (exp10, max_value, plus_infty, OVERFLOW_EXCEPTION);
4270   TEST_f_f (exp10, -max_value, 0, UNDERFLOW_EXCEPTION);
4271   TEST_f_f (exp10, 0.75L, 5.62341325190349080394951039776481231L);
4272
4273   END (exp10);
4274 }
4275
4276
4277 static void
4278 exp2_test (void)
4279 {
4280   errno = 0;
4281   FUNC(exp2) (0);
4282   if (errno == ENOSYS)
4283     /* Function not implemented.  */
4284     return;
4285
4286   START (exp2);
4287
4288   TEST_f_f (exp2, 0, 1);
4289   TEST_f_f (exp2, minus_zero, 1);
4290   TEST_f_f (exp2, plus_infty, plus_infty);
4291   TEST_f_f (exp2, minus_infty, 0);
4292   TEST_f_f (exp2, nan_value, nan_value);
4293
4294   TEST_f_f (exp2, 10, 1024);
4295   TEST_f_f (exp2, -1, 0.5);
4296   TEST_f_f (exp2, 1e6, plus_infty, OVERFLOW_EXCEPTION);
4297   TEST_f_f (exp2, -1e6, 0, UNDERFLOW_EXCEPTION);
4298   TEST_f_f (exp2, max_value, plus_infty, OVERFLOW_EXCEPTION);
4299   TEST_f_f (exp2, -max_value, 0, UNDERFLOW_EXCEPTION);
4300   TEST_f_f (exp2, 0.75L, 1.68179283050742908606225095246642979L);
4301
4302   TEST_f_f (exp2, 100.5, 1.792728671193156477399422023278661496394e+30L);
4303   TEST_f_f (exp2, 127, 0x1p127);
4304   TEST_f_f (exp2, -149, 0x1p-149);
4305
4306 #ifndef TEST_FLOAT
4307   TEST_f_f (exp2, 1000.25, 1.274245659452564874772384918171765416737e+301L);
4308   TEST_f_f (exp2, 1023, 0x1p1023);
4309   TEST_f_f (exp2, -1074, 0x1p-1074);
4310 #endif
4311
4312 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
4313   TEST_f_f (exp2, 16383, 0x1p16383L);
4314   TEST_f_f (exp2, -16400, 0x1p-16400L);
4315 #endif
4316
4317   END (exp2);
4318 }
4319
4320
4321 static void
4322 expm1_test (void)
4323 {
4324   errno = 0;
4325   FUNC(expm1) (0);
4326   if (errno == ENOSYS)
4327     /* Function not implemented.  */
4328     return;
4329
4330   START (expm1);
4331
4332   TEST_f_f (expm1, 0, 0);
4333   TEST_f_f (expm1, minus_zero, minus_zero);
4334
4335 #ifndef TEST_INLINE
4336   TEST_f_f (expm1, plus_infty, plus_infty);
4337   TEST_f_f (expm1, minus_infty, -1);
4338 #endif
4339   TEST_f_f (expm1, nan_value, nan_value);
4340
4341   TEST_f_f (expm1, 1, M_El - 1.0);
4342   TEST_f_f (expm1, 0.75L, 1.11700001661267466854536981983709561L);
4343
4344   TEST_f_f (expm1, 50.0L, 5.1847055285870724640864533229334853848275e+21L);
4345
4346 #ifndef TEST_FLOAT
4347   TEST_f_f (expm1, 127.0L, 1.4302079958348104463583671072905261080748e+55L);
4348   TEST_f_f (expm1, 500.0L, 1.4035922178528374107397703328409120821806e+217L);
4349 #endif
4350
4351 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
4352   TEST_f_f (expm1, 11356.25L, 9.05128237311923300051376115753226014206e+4931L);
4353 #endif
4354
4355   TEST_f_f (expm1, -10.0, -0.9999546000702375151484644084844394493898L);
4356   TEST_f_f (expm1, -16.0, -0.9999998874648252807408854862248209398728L);
4357   TEST_f_f (expm1, -17.0, -0.9999999586006228121483334034897228104472L);
4358   TEST_f_f (expm1, -18.0, -0.9999999847700202552873715638633707664826L);
4359   TEST_f_f (expm1, -36.0, -0.9999999999999997680477169756430611687736L);
4360   TEST_f_f (expm1, -37.0, -0.9999999999999999146695237425593420572195L);
4361   TEST_f_f (expm1, -38.0, -0.9999999999999999686086720795197037129104L);
4362   TEST_f_f (expm1, -44.0, -0.9999999999999999999221886775886620348429L);
4363   TEST_f_f (expm1, -45.0, -0.9999999999999999999713748141945060635553L);
4364   TEST_f_f (expm1, -46.0, -0.9999999999999999999894693826424461876212L);
4365   TEST_f_f (expm1, -73.0, -0.9999999999999999999999999999999802074012L);
4366   TEST_f_f (expm1, -74.0, -0.9999999999999999999999999999999927187098L);
4367   TEST_f_f (expm1, -75.0, -0.9999999999999999999999999999999973213630L);
4368   TEST_f_f (expm1, -78.0, -0.9999999999999999999999999999999998666385L);
4369   TEST_f_f (expm1, -79.0, -0.9999999999999999999999999999999999509391L);
4370   TEST_f_f (expm1, -80.0, -0.9999999999999999999999999999999999819515L);
4371   TEST_f_f (expm1, -100.0, -1.0);
4372   TEST_f_f (expm1, -1000.0, -1.0);
4373   TEST_f_f (expm1, -10000.0, -1.0);
4374   TEST_f_f (expm1, -100000.0, -1.0);
4375
4376   errno = 0;
4377   TEST_f_f (expm1, 100000.0, plus_infty, OVERFLOW_EXCEPTION);
4378   check_int ("errno for expm1(large) == ERANGE", errno, ERANGE, 0, 0, 0);
4379   TEST_f_f (expm1, max_value, plus_infty, OVERFLOW_EXCEPTION);
4380   TEST_f_f (expm1, -max_value, -1);
4381
4382   END (expm1);
4383 }
4384
4385
4386 static void
4387 fabs_test (void)
4388 {
4389   START (fabs);
4390
4391   TEST_f_f (fabs, 0, 0);
4392   TEST_f_f (fabs, minus_zero, 0);
4393
4394   TEST_f_f (fabs, plus_infty, plus_infty);
4395   TEST_f_f (fabs, minus_infty, plus_infty);
4396   TEST_f_f (fabs, nan_value, nan_value);
4397
4398   TEST_f_f (fabs, 38.0, 38.0);
4399   TEST_f_f (fabs, -M_El, M_El);
4400
4401   END (fabs);
4402 }
4403
4404
4405 static void
4406 fdim_test (void)
4407 {
4408   START (fdim);
4409
4410   TEST_ff_f (fdim, 0, 0, 0);
4411   TEST_ff_f (fdim, 9, 0, 9);
4412   TEST_ff_f (fdim, 0, 9, 0);
4413   TEST_ff_f (fdim, -9, 0, 0);
4414   TEST_ff_f (fdim, 0, -9, 9);
4415
4416   TEST_ff_f (fdim, plus_infty, 9, plus_infty);
4417   TEST_ff_f (fdim, plus_infty, -9, plus_infty);
4418   TEST_ff_f (fdim, minus_infty, 9, 0);
4419   TEST_ff_f (fdim, minus_infty, -9, 0);
4420   TEST_ff_f (fdim, 9, minus_infty, plus_infty);
4421   TEST_ff_f (fdim, -9, minus_infty, plus_infty);
4422   TEST_ff_f (fdim, 9, plus_infty, 0);
4423   TEST_ff_f (fdim, -9, plus_infty, 0);
4424
4425   TEST_ff_f (fdim, 0, nan_value, nan_value);
4426   TEST_ff_f (fdim, 9, nan_value, nan_value);
4427   TEST_ff_f (fdim, -9, nan_value, nan_value);
4428   TEST_ff_f (fdim, nan_value, 9, nan_value);
4429   TEST_ff_f (fdim, nan_value, -9, nan_value);
4430   TEST_ff_f (fdim, plus_infty, nan_value, nan_value);
4431   TEST_ff_f (fdim, minus_infty, nan_value, nan_value);
4432   TEST_ff_f (fdim, nan_value, plus_infty, nan_value);
4433   TEST_ff_f (fdim, nan_value, minus_infty, nan_value);
4434   TEST_ff_f (fdim, nan_value, nan_value, nan_value);
4435
4436   TEST_ff_f (fdim, plus_infty, plus_infty, 0);
4437
4438   END (fdim);
4439 }
4440
4441
4442 static void
4443 finite_test (void)
4444 {
4445   START (finite);
4446
4447   TEST_f_b (finite, 0, 1);
4448   TEST_f_b (finite, minus_zero, 1);
4449   TEST_f_b (finite, 10, 1);
4450   TEST_f_b (finite, min_subnorm_value, 1);
4451   TEST_f_b (finite, plus_infty, 0);
4452   TEST_f_b (finite, minus_infty, 0);
4453   TEST_f_b (finite, nan_value, 0);
4454
4455   END (finite);
4456 }
4457
4458
4459 static void
4460 floor_test (void)
4461 {
4462   START (floor);
4463
4464   TEST_f_f (floor, 0.0, 0.0);
4465   TEST_f_f (floor, minus_zero, minus_zero);
4466   TEST_f_f (floor, plus_infty, plus_infty);
4467   TEST_f_f (floor, minus_infty, minus_infty);
4468   TEST_f_f (floor, nan_value, nan_value);
4469
4470   TEST_f_f (floor, M_PIl, 3.0);
4471   TEST_f_f (floor, -M_PIl, -4.0);
4472
4473   TEST_f_f (floor, 0.1, 0.0);
4474   TEST_f_f (floor, 0.25, 0.0);
4475   TEST_f_f (floor, 0.625, 0.0);
4476   TEST_f_f (floor, -0.1, -1.0);
4477   TEST_f_f (floor, -0.25, -1.0);
4478   TEST_f_f (floor, -0.625, -1.0);
4479
4480 #ifdef TEST_LDOUBLE
4481   /* The result can only be represented in long double.  */
4482   TEST_f_f (floor, 4503599627370495.5L, 4503599627370495.0L);
4483   TEST_f_f (floor, 4503599627370496.25L, 4503599627370496.0L);
4484   TEST_f_f (floor, 4503599627370496.5L, 4503599627370496.0L);
4485   TEST_f_f (floor, 4503599627370496.75L, 4503599627370496.0L);
4486   TEST_f_f (floor, 4503599627370497.5L, 4503599627370497.0L);
4487 # if LDBL_MANT_DIG > 100
4488   TEST_f_f (floor, 4503599627370494.5000000000001L, 4503599627370494.0L);
4489   TEST_f_f (floor, 4503599627370495.5000000000001L, 4503599627370495.0L);
4490   TEST_f_f (floor, 4503599627370496.5000000000001L, 4503599627370496.0L);
4491 # endif
4492
4493   TEST_f_f (floor, -4503599627370495.5L, -4503599627370496.0L);
4494   TEST_f_f (floor, -4503599627370496.25L, -4503599627370497.0L);
4495   TEST_f_f (floor, -4503599627370496.5L, -4503599627370497.0L);
4496   TEST_f_f (floor, -4503599627370496.75L, -4503599627370497.0L);
4497   TEST_f_f (floor, -4503599627370497.5L, -4503599627370498.0L);
4498 # if LDBL_MANT_DIG > 100
4499   TEST_f_f (floor, -4503599627370494.5000000000001L, -4503599627370495.0L);
4500   TEST_f_f (floor, -4503599627370495.5000000000001L, -4503599627370496.0L);
4501   TEST_f_f (floor, -4503599627370496.5000000000001L, -4503599627370497.0L);
4502 # endif
4503
4504   TEST_f_f (floor, 9007199254740991.5L, 9007199254740991.0L);
4505   TEST_f_f (floor, 9007199254740992.25L, 9007199254740992.0L);
4506   TEST_f_f (floor, 9007199254740992.5L, 9007199254740992.0L);
4507   TEST_f_f (floor, 9007199254740992.75L, 9007199254740992.0L);
4508   TEST_f_f (floor, 9007199254740993.5L, 9007199254740993.0L);
4509
4510 # if LDBL_MANT_DIG > 100
4511   TEST_f_f (floor, 9007199254740991.0000000000001L, 9007199254740991.0L);
4512   TEST_f_f (floor, 9007199254740992.0000000000001L, 9007199254740992.0L);
4513   TEST_f_f (floor, 9007199254740993.0000000000001L, 9007199254740993.0L);
4514   TEST_f_f (floor, 9007199254740991.5000000000001L, 9007199254740991.0L);
4515   TEST_f_f (floor, 9007199254740992.5000000000001L, 9007199254740992.0L);
4516   TEST_f_f (floor, 9007199254740993.5000000000001L, 9007199254740993.0L);
4517 # endif
4518
4519   TEST_f_f (floor, -9007199254740991.5L, -9007199254740992.0L);
4520   TEST_f_f (floor, -9007199254740992.25L, -9007199254740993.0L);
4521   TEST_f_f (floor, -9007199254740992.5L, -9007199254740993.0L);
4522   TEST_f_f (floor, -9007199254740992.75L, -9007199254740993.0L);
4523   TEST_f_f (floor, -9007199254740993.5L, -9007199254740994.0L);
4524
4525 # if LDBL_MANT_DIG > 100
4526   TEST_f_f (floor, -9007199254740991.0000000000001L, -9007199254740992.0L);
4527   TEST_f_f (floor, -9007199254740992.0000000000001L, -9007199254740993.0L);
4528   TEST_f_f (floor, -9007199254740993.0000000000001L, -9007199254740994.0L);
4529   TEST_f_f (floor, -9007199254740991.5000000000001L, -9007199254740992.0L);
4530   TEST_f_f (floor, -9007199254740992.5000000000001L, -9007199254740993.0L);
4531   TEST_f_f (floor, -9007199254740993.5000000000001L, -9007199254740994.0L);
4532 # endif
4533
4534   TEST_f_f (floor, 72057594037927935.5L, 72057594037927935.0L);
4535   TEST_f_f (floor, 72057594037927936.25L, 72057594037927936.0L);
4536   TEST_f_f (floor, 72057594037927936.5L, 72057594037927936.0L);
4537   TEST_f_f (floor, 72057594037927936.75L, 72057594037927936.0L);
4538   TEST_f_f (floor, 72057594037927937.5L, 72057594037927937.0L);
4539
4540   TEST_f_f (floor, -72057594037927935.5L, -72057594037927936.0L);
4541   TEST_f_f (floor, -72057594037927936.25L, -72057594037927937.0L);
4542   TEST_f_f (floor, -72057594037927936.5L, -72057594037927937.0L);
4543   TEST_f_f (floor, -72057594037927936.75L, -72057594037927937.0L);
4544   TEST_f_f (floor, -72057594037927937.5L, -72057594037927938.0L);
4545
4546   TEST_f_f (floor, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
4547   TEST_f_f (floor, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
4548   TEST_f_f (floor, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
4549   TEST_f_f (floor, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
4550   TEST_f_f (floor, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
4551
4552   TEST_f_f (floor, 0xf.ffffffffffffff8p+47L, 0xf.fffffffffffep+47L);
4553   TEST_f_f (floor, -0x8.000000000000004p+48L, -0x8.000000000001p+48L);
4554 #endif
4555
4556   END (floor);
4557 }
4558
4559
4560 static void
4561 fma_test (void)
4562 {
4563   START (fma);
4564
4565   TEST_fff_f (fma, 1.0, 2.0, 3.0, 5.0);
4566   TEST_fff_f (fma, nan_value, 2.0, 3.0, nan_value);
4567   TEST_fff_f (fma, 1.0, nan_value, 3.0, nan_value);
4568   TEST_fff_f (fma, 1.0, 2.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
4569   TEST_fff_f (fma, plus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
4570   TEST_fff_f (fma, minus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
4571   TEST_fff_f (fma, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
4572   TEST_fff_f (fma, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
4573   TEST_fff_f (fma, plus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
4574   TEST_fff_f (fma, minus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
4575   TEST_fff_f (fma, 0.0, plus_infty, 1.0, nan_value, INVALID_EXCEPTION);
4576   TEST_fff_f (fma, 0.0, minus_infty, 1.0, nan_value, INVALID_EXCEPTION);
4577
4578   TEST_fff_f (fma, plus_infty, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
4579   TEST_fff_f (fma, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
4580   TEST_fff_f (fma, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
4581   TEST_fff_f (fma, minus_infty, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
4582   TEST_fff_f (fma, plus_infty, 3.5L, minus_infty, nan_value, INVALID_EXCEPTION);
4583   TEST_fff_f (fma, minus_infty, -7.5L, minus_infty, nan_value, INVALID_EXCEPTION);
4584   TEST_fff_f (fma, -13.5L, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
4585   TEST_fff_f (fma, minus_infty, 7.5L, plus_infty, nan_value, INVALID_EXCEPTION);
4586
4587   TEST_fff_f (fma, 1.25L, 0.75L, 0.0625L, 1.0L);
4588
4589   FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
4590                          LDBL_MAX, DBL_MAX, FLT_MAX);
4591   TEST_fff_f (fma, -fltmax, -fltmax, minus_infty, minus_infty);
4592   TEST_fff_f (fma, fltmax / 2, fltmax / 2, minus_infty, minus_infty);
4593   TEST_fff_f (fma, -fltmax, fltmax, plus_infty, plus_infty);
4594   TEST_fff_f (fma, fltmax / 2, -fltmax / 4, plus_infty, plus_infty);
4595   TEST_fff_f (fma, plus_infty, 4, plus_infty, plus_infty);
4596   TEST_fff_f (fma, 2, minus_infty, minus_infty, minus_infty);
4597   TEST_fff_f (fma, minus_infty, minus_infty, plus_infty, plus_infty);
4598   TEST_fff_f (fma, plus_infty, minus_infty, minus_infty, minus_infty);
4599
4600   TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero);
4601   TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, plus_zero);
4602   TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, plus_zero);
4603   TEST_fff_f (fma, plus_zero, minus_zero, minus_zero, minus_zero);
4604   TEST_fff_f (fma, minus_zero, plus_zero, plus_zero, plus_zero);
4605   TEST_fff_f (fma, minus_zero, plus_zero, minus_zero, minus_zero);
4606   TEST_fff_f (fma, minus_zero, minus_zero, plus_zero, plus_zero);
4607   TEST_fff_f (fma, minus_zero, minus_zero, minus_zero, plus_zero);
4608   TEST_fff_f (fma, 1.0, plus_zero, plus_zero, plus_zero);
4609   TEST_fff_f (fma, 1.0, plus_zero, minus_zero, plus_zero);
4610   TEST_fff_f (fma, 1.0, minus_zero, plus_zero, plus_zero);
4611   TEST_fff_f (fma, 1.0, minus_zero, minus_zero, minus_zero);
4612   TEST_fff_f (fma, -1.0, plus_zero, plus_zero, plus_zero);
4613   TEST_fff_f (fma, -1.0, plus_zero, minus_zero, minus_zero);
4614   TEST_fff_f (fma, -1.0, minus_zero, plus_zero, plus_zero);
4615   TEST_fff_f (fma, -1.0, minus_zero, minus_zero, plus_zero);
4616   TEST_fff_f (fma, plus_zero, 1.0, plus_zero, plus_zero);
4617   TEST_fff_f (fma, plus_zero, 1.0, minus_zero, plus_zero);
4618   TEST_fff_f (fma, plus_zero, -1.0, plus_zero, plus_zero);
4619   TEST_fff_f (fma, plus_zero, -1.0, minus_zero, minus_zero);
4620   TEST_fff_f (fma, minus_zero, 1.0, plus_zero, plus_zero);
4621   TEST_fff_f (fma, minus_zero, 1.0, minus_zero, minus_zero);
4622   TEST_fff_f (fma, minus_zero, -1.0, plus_zero, plus_zero);
4623   TEST_fff_f (fma, minus_zero, -1.0, minus_zero, plus_zero);
4624
4625   TEST_fff_f (fma, 1.0, 1.0, -1.0, plus_zero);
4626   TEST_fff_f (fma, 1.0, -1.0, 1.0, plus_zero);
4627   TEST_fff_f (fma, -1.0, 1.0, 1.0, plus_zero);
4628   TEST_fff_f (fma, -1.0, -1.0, -1.0, plus_zero);
4629
4630   TEST_fff_f (fma, min_value, min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4631   TEST_fff_f (fma, min_value, min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4632   TEST_fff_f (fma, min_value, -min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4633   TEST_fff_f (fma, min_value, -min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4634   TEST_fff_f (fma, -min_value, min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4635   TEST_fff_f (fma, -min_value, min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4636   TEST_fff_f (fma, -min_value, -min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4637   TEST_fff_f (fma, -min_value, -min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4638
4639   TEST_fff_f (fma, max_value, max_value, min_value, plus_infty, OVERFLOW_EXCEPTION);
4640   TEST_fff_f (fma, max_value, max_value, -min_value, plus_infty, OVERFLOW_EXCEPTION);
4641   TEST_fff_f (fma, max_value, -max_value, min_value, minus_infty, OVERFLOW_EXCEPTION);
4642   TEST_fff_f (fma, max_value, -max_value, -min_value, minus_infty, OVERFLOW_EXCEPTION);
4643   TEST_fff_f (fma, -max_value, max_value, min_value, minus_infty, OVERFLOW_EXCEPTION);
4644   TEST_fff_f (fma, -max_value, max_value, -min_value, minus_infty, OVERFLOW_EXCEPTION);
4645   TEST_fff_f (fma, -max_value, -max_value, min_value, plus_infty, OVERFLOW_EXCEPTION);
4646   TEST_fff_f (fma, -max_value, -max_value, -min_value, plus_infty, OVERFLOW_EXCEPTION);
4647
4648 #if defined (TEST_FLOAT) && FLT_MANT_DIG == 24
4649   TEST_fff_f (fma, 0x1.7ff8p+13, 0x1.000002p+0, 0x1.ffffp-24, 0x1.7ff802p+13);
4650   TEST_fff_f (fma, 0x1.fffp+0, 0x1.00001p+0, -0x1.fffp+0, 0x1.fffp-20);
4651   TEST_fff_f (fma, 0x1.9abcdep+127, 0x0.9abcdep-126, -0x1.f08948p+0, 0x1.bb421p-25);
4652   TEST_fff_f (fma, 0x1.9abcdep+100, 0x0.9abcdep-126, -0x1.f08948p-27, 0x1.bb421p-52);
4653   TEST_fff_f (fma, 0x1.fffffep+127, 0x1.001p+0, -0x1.fffffep+127, 0x1.fffffep+115);
4654   TEST_fff_f (fma, -0x1.fffffep+127, 0x1.fffffep+0, 0x1.fffffep+127, -0x1.fffffap+127);
4655   TEST_fff_f (fma, 0x1.fffffep+127, 2.0, -0x1.fffffep+127, 0x1.fffffep+127);
4656   TEST_fff_f (fma, 0x1.4p-126, 0x1.000004p-1, 0x1p-128, 0x1.c00004p-127, UNDERFLOW_EXCEPTION);
4657   TEST_fff_f (fma, -0x1.4p-126, 0x1.000004p-1, -0x1p-128, -0x1.c00004p-127, UNDERFLOW_EXCEPTION);
4658   TEST_fff_f (fma, 0x1.fffff8p-126, 0x1.000002p-1, 0x1p-149, 0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4659   TEST_fff_f (fma, -0x1.fffff8p-126, 0x1.000002p-1, -0x1p-149, -0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4660   TEST_fff_f (fma, 0x1p-149, 0x1p-1, 0x0.fffffep-126, 0x1p-126, UNDERFLOW_EXCEPTION);
4661   TEST_fff_f (fma, -0x1p-149, 0x1p-1, -0x0.fffffep-126, -0x1p-126, UNDERFLOW_EXCEPTION);
4662   TEST_fff_f (fma, 0x1p-149, 0x1.1p-1, 0x0.fffffep-126, 0x1p-126, UNDERFLOW_EXCEPTION);
4663   TEST_fff_f (fma, -0x1p-149, 0x1.1p-1, -0x0.fffffep-126, -0x1p-126, UNDERFLOW_EXCEPTION);
4664   TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p127, 0x1p127);
4665   TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p127, 0x1p127);
4666   TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p127, -0x1p127);
4667   TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p127, -0x1p127);
4668   TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-126, 0x1p-126);
4669   TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-126, 0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4670   TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-126, -0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4671   TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-126, -0x1p-126);
4672   TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4673   TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4674   TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4675   TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4676   TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-149, 0x1p-149, UNDERFLOW_EXCEPTION);
4677   TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-149, 0x1p-149, UNDERFLOW_EXCEPTION);
4678   TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-149, -0x1p-149, UNDERFLOW_EXCEPTION);
4679   TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-149, -0x1p-149, UNDERFLOW_EXCEPTION);
4680   TEST_fff_f (fma, 0x0.fffp0, 0x0.fffp0, -0x0.ffep0, 0x1p-24);
4681   TEST_fff_f (fma, 0x0.fffp0, -0x0.fffp0, 0x0.ffep0, -0x1p-24);
4682   TEST_fff_f (fma, -0x0.fffp0, 0x0.fffp0, 0x0.ffep0, -0x1p-24);
4683   TEST_fff_f (fma, -0x0.fffp0, -0x0.fffp0, -0x0.ffep0, 0x1p-24);
4684   TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p127, 0x1p127);
4685   TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p127, 0x1p127);
4686   TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p127, -0x1p127);
4687   TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p127, -0x1p127);
4688   TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p103, 0x1p103);
4689   TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p103, 0x1p103);
4690   TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p103, -0x1p103);
4691   TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p103, -0x1p103);
4692 #endif
4693 #if defined (TEST_DOUBLE) && DBL_MANT_DIG == 53
4694   TEST_fff_f (fma, 0x1.7fp+13, 0x1.0000000000001p+0, 0x1.ffep-48, 0x1.7f00000000001p+13);
4695   TEST_fff_f (fma, 0x1.fffp+0, 0x1.0000000000001p+0, -0x1.fffp+0, 0x1.fffp-52);
4696   TEST_fff_f (fma, 0x1.0000002p+0, 0x1.ffffffcp-1, 0x1p-300, 1.0);
4697   TEST_fff_f (fma, 0x1.0000002p+0, 0x1.ffffffcp-1, -0x1p-300, 0x1.fffffffffffffp-1);
4698   TEST_fff_f (fma, 0x1.deadbeef2feedp+1023, 0x0.deadbeef2feedp-1022, -0x1.a05f8c01a4bfbp+1, 0x1.0989687bc9da4p-53);
4699   TEST_fff_f (fma, 0x1.deadbeef2feedp+900, 0x0.deadbeef2feedp-1022, -0x1.a05f8c01a4bfbp-122, 0x1.0989687bc9da4p-176);
4700   TEST_fff_f (fma, 0x1.fffffffffffffp+1023, 0x1.001p+0, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+1011);
4701   TEST_fff_f (fma, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+0, 0x1.fffffffffffffp+1023, -0x1.ffffffffffffdp+1023);
4702   TEST_fff_f (fma, 0x1.fffffffffffffp+1023, 2.0, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+1023);
4703   TEST_fff_f (fma, 0x1.6a09e667f3bccp-538, 0x1.6a09e667f3bccp-538, 0.0, 0.0, UNDERFLOW_EXCEPTION);
4704   TEST_fff_f (fma, 0x1.deadbeef2feedp-495, 0x1.deadbeef2feedp-495, -0x1.bf86a5786a574p-989, 0x0.0000042625a1fp-1022, UNDERFLOW_EXCEPTION);
4705   TEST_fff_f (fma, 0x1.deadbeef2feedp-503, 0x1.deadbeef2feedp-503, -0x1.bf86a5786a574p-1005, 0x0.0000000004262p-1022, UNDERFLOW_EXCEPTION);
4706   TEST_fff_f (fma, 0x1p-537, 0x1p-538, 0x1p-1074, 0x0.0000000000002p-1022, UNDERFLOW_EXCEPTION);
4707   TEST_fff_f (fma, 0x1.7fffff8p-968, 0x1p-106, 0x0.000001p-1022, 0x0.0000010000001p-1022, UNDERFLOW_EXCEPTION);
4708   TEST_fff_f (fma, 0x1.4000004p-967, 0x1p-106, 0x0.000001p-1022, 0x0.0000010000003p-1022, UNDERFLOW_EXCEPTION);
4709   TEST_fff_f (fma, 0x1.4p-967, -0x1p-106, -0x0.000001p-1022, -0x0.0000010000002p-1022, UNDERFLOW_EXCEPTION);
4710   TEST_fff_f (fma, -0x1.19cab66d73e17p-959, 0x1.c7108a8c5ff51p-107, -0x0.80b0ad65d9b64p-1022, -0x0.80b0ad65d9d59p-1022, UNDERFLOW_EXCEPTION);
4711   TEST_fff_f (fma, -0x1.d2eaed6e8e9d3p-979, -0x1.4e066c62ac9ddp-63, -0x0.9245e6b003454p-1022, -0x0.9245c09c5fb5dp-1022, UNDERFLOW_EXCEPTION);
4712   TEST_fff_f (fma, 0x1.153d650bb9f06p-907, 0x1.2d01230d48407p-125, -0x0.b278d5acfc3cp-1022, -0x0.b22757123bbe9p-1022, UNDERFLOW_EXCEPTION);
4713   TEST_fff_f (fma, -0x1.fffffffffffffp-711, 0x1.fffffffffffffp-275, 0x1.fffffe00007ffp-983, 0x1.7ffffe00007ffp-983);
4714   TEST_fff_f (fma, 0x1.4p-1022, 0x1.0000000000002p-1, 0x1p-1024, 0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
4715   TEST_fff_f (fma, -0x1.4p-1022, 0x1.0000000000002p-1, -0x1p-1024, -0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
4716   TEST_fff_f (fma, 0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, 0x1p-1074, 0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4717   TEST_fff_f (fma, -0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, -0x1p-1074, -0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4718   TEST_fff_f (fma, 0x1p-1074, 0x1p-1, 0x0.fffffffffffffp-1022, 0x1p-1022, UNDERFLOW_EXCEPTION);
4719   TEST_fff_f (fma, -0x1p-1074, 0x1p-1, -0x0.fffffffffffffp-1022, -0x1p-1022, UNDERFLOW_EXCEPTION);
4720   TEST_fff_f (fma, 0x1p-1074, 0x1.1p-1, 0x0.fffffffffffffp-1022, 0x1p-1022, UNDERFLOW_EXCEPTION);
4721   TEST_fff_f (fma, -0x1p-1074, 0x1.1p-1, -0x0.fffffffffffffp-1022, -0x1p-1022, UNDERFLOW_EXCEPTION);
4722   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p1023, 0x1p1023);
4723   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p1023, 0x1p1023);
4724   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p1023, -0x1p1023);
4725   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p1023, -0x1p1023);
4726   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1022, 0x1p-1022);
4727   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1022, 0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4728   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1022, -0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4729   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1022, -0x1p-1022);
4730   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4731   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4732   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4733   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4734   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1074, 0x1p-1074, UNDERFLOW_EXCEPTION);
4735   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1074, 0x1p-1074, UNDERFLOW_EXCEPTION);
4736   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1074, -0x1p-1074, UNDERFLOW_EXCEPTION);
4737   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1074, -0x1p-1074, UNDERFLOW_EXCEPTION);
4738   TEST_fff_f (fma, 0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
4739   TEST_fff_f (fma, 0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
4740   TEST_fff_f (fma, -0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
4741   TEST_fff_f (fma, -0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
4742   TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p1023, 0x1p1023);
4743   TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p1023, 0x1p1023);
4744   TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p1023, -0x1p1023);
4745   TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p1023, -0x1p1023);
4746   TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p970, 0x1p970);
4747   TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p970, 0x1p970);
4748   TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p970, -0x1p970);
4749   TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p970, -0x1p970);
4750 #endif
4751 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 64
4752   TEST_fff_f (fma, -0x8.03fcp+3696L, 0xf.fffffffffffffffp-6140L, 0x8.3ffffffffffffffp-2450L, -0x8.01ecp-2440L);
4753   TEST_fff_f (fma, 0x9.fcp+2033L, -0x8.000e1f000ff800fp-3613L, -0xf.fffffffffffc0ffp-1579L, -0xd.fc119fb093ed092p-1577L);
4754   TEST_fff_f (fma, 0xc.7fc000003ffffffp-1194L, 0x8.1e0003fffffffffp+15327L, -0x8.fffep+14072L, 0xc.ae9f164020effffp+14136L);
4755   TEST_fff_f (fma, -0x8.0001fc000000003p+1798L, 0xcp-2230L, 0x8.f7e000000000007p-468L, -0xc.0002f9ffee10404p-429L);
4756   TEST_fff_f (fma, 0xc.0000000000007ffp+10130L, -0x8.000000000000001p+4430L, 0xc.07000000001ffffp+14513L, -0xb.fffffffffffd7e4p+14563L);
4757   TEST_fff_f (fma, 0xb.ffffp-4777L, 0x8.000000fffffffffp-11612L, -0x0.3800fff8p-16385L, 0x5.c7fe80c7ffeffffp-16385L, UNDERFLOW_EXCEPTION);
4758   TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000004p-1L, 0x1p-16384L, 0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
4759   TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000004p-1L, -0x1p-16384L, -0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
4760   TEST_fff_f (fma, 0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, 0x1p-16445L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4761   TEST_fff_f (fma, -0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, -0x1p-16445L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4762   TEST_fff_f (fma, 0x1p-16445L, 0x1p-1L, 0x0.fffffffffffffffep-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
4763   TEST_fff_f (fma, -0x1p-16445L, 0x1p-1L, -0x0.fffffffffffffffep-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
4764   TEST_fff_f (fma, 0x1p-16445L, 0x1.1p-1L, 0x0.fffffffffffffffep-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
4765   TEST_fff_f (fma, -0x1p-16445L, 0x1.1p-1L, -0x0.fffffffffffffffep-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
4766   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p16383L, 0x1p16383L);
4767   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p16383L, 0x1p16383L);
4768   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p16383L, -0x1p16383L);
4769   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p16383L, -0x1p16383L);
4770   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16382L, 0x1p-16382L);
4771   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4772   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4773   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16382L, -0x1p-16382L);
4774   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4775   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4776   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4777   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4778   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, UNDERFLOW_EXCEPTION);
4779   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16445L, 0x1p-16445L, UNDERFLOW_EXCEPTION);
4780   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, UNDERFLOW_EXCEPTION);
4781   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, -0x1p-16445L, UNDERFLOW_EXCEPTION);
4782   TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
4783   TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
4784   TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
4785   TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
4786   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16383L, 0x1p16383L);
4787   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16383L, 0x1p16383L);
4788   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16383L, -0x1p16383L);
4789   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16383L, -0x1p16383L);
4790   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16319L, 0x1p16319L);
4791   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16319L, 0x1p16319L);
4792   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16319L, -0x1p16319L);
4793   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16319L, -0x1p16319L);
4794 #endif
4795 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 113
4796   TEST_fff_f (fma, 0x1.bb2de33e02ccbbfa6e245a7c1f71p-2584L, -0x1.6b500daf0580d987f1bc0cadfcddp-13777L, 0x1.613cd91d9fed34b33820e5ab9d8dp-16378L, -0x1.3a79fb50eb9ce887cffa0f09bd9fp-16360L);
4797   TEST_fff_f (fma, -0x1.f949b880cacb0f0c61540105321dp-5954L, -0x1.3876cec84b4140f3bd6198731b7ep-10525L, -0x0.a5dc1c6cfbc498c54fb0b504bf19p-16382L, -0x0.a5dc1c6cfbc498c54fb0b5038abbp-16382L, UNDERFLOW_EXCEPTION);
4798   TEST_fff_f (fma, -0x1.0000fffffffffp-16221L, 0x1.0000001fffff8007fep-239L, 0x0.ff87ffffffffffffe000003fffffp-16382L, 0x0.ff87ffffffffffffdffc003bff7fp-16382L, UNDERFLOW_EXCEPTION);
4799   TEST_fff_f (fma, -0x1.ac79c9376ef447f3827c9e9de008p-2228L, -0x1.5ba830022b6139e21fbe7270cad8p-6314L, 0x1.e8282b6a26bb6a9daf5c8e73e9f9p-8616L, 0x1.22f14a0253878a730cd1aee373adp-8541L);
4800   TEST_fff_f (fma, -0x1.c69749ec574caaa2ab8e97ddb9f3p+2652L, 0x1.f34235ff9d095449c29b4831b62dp+3311L, 0x1.fbe4302df23354dbd0c4d3cfe606p+5879L, -0x1.bb473bfdfb7a6e18886ce6e57eafp+5964L);
4801   TEST_fff_f (fma, -0x1.ca8835fc6ecfb5398625fc891be5p-1686L, 0x1.621e1972bbe2180e5be9dd7d8df5p-7671L, -0x1.7d2d21b73b52cf20dec2a83902a4p-9395L, -0x1.3d2322191c9c88bc68a62ab8042cp-9356L);
4802   TEST_fff_f (fma, -0x1.55cff679ec49c2541fab41fc843ep-11819L, 0x1.e60e9f464f9e8df0509647c7c971p+12325L, 0x1.eaa2a7649d765c2f564f7a5beca7p+454L, -0x1.447e29fa7e406a285f4e350fcf86p+507L);
4803   TEST_fff_f (fma, 0x1.f0e7b1454908576f2537d863cf9bp+11432L, 0x1.cdce52f09d4ca76e68706f34b5d5p-1417L, -0x1.2e986187c70f146235ea2066e486p+9979L, 0x1.c030dad3cc5643f3dd0f5619f661p+10016L);
4804   TEST_fff_f (fma, 0x1.f102f7da4a57a3a4aab620e29452p-3098L, -0x1.cc06a4ff40248f9e2dcc4b6afd84p-11727L, 0x1.d512a11126b5ac8ed8973b8580c8p-14849L, -0x1.be8f1cf737ab4d1c31c54f5ec23bp-14824L);
4805   TEST_fff_f (fma, -0x1.fc47ac7434b993cd8dcb2b431f25p-3816L, 0x1.fbc9750da8468852d84558e1db6dp-5773L, -0x1.00a98abf783f75c40fe5b7a37d86p-9607L, -0x1.f81917b166f45e763cfcc057e2adp-9588L);
4806   TEST_fff_f (fma, 0x1.00000000000007ffffffffffffffp-9045L, -0x1.ffffffffffff80000001ffffffffp+4773L, -0x1.f8p-4316L, -0x1.00000000000f88000000fffffdffp-4271L);
4807   TEST_fff_f (fma, 0x1.4e922764c90701d4a2f21d01893dp-8683L, -0x1.955a12e2d7c9447c27fa022fc865p+212L, -0x1.e9634462eaef96528b90b6944578p-8521L, -0x1.08e1783184a371943d3598e10865p-8470L);
4808   TEST_fff_f (fma, 0x1.801181509c03bdbef10d6165588cp-15131L, 0x1.ad86f8e57d3d40bfa8007780af63p-368L, -0x1.6e9df0dab1c9f1d7a6043c390741p-15507L, 0x1.417c9b2b15e2ad57dc9e0e920844p-15498L);
4809   TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, 0x1p-16384L, 0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
4810   TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, -0x1p-16384L, -0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
4811   TEST_fff_f (fma, 0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, 0x1p-16494L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4812   TEST_fff_f (fma, -0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, -0x1p-16494L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4813   TEST_fff_f (fma, 0x1p-16494L, 0x1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
4814   TEST_fff_f (fma, -0x1p-16494L, 0x1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
4815   TEST_fff_f (fma, 0x1p-16494L, 0x1.1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
4816   TEST_fff_f (fma, -0x1p-16494L, 0x1.1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
4817   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p16383L, 0x1p16383L);
4818   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p16383L, 0x1p16383L);
4819   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p16383L, -0x1p16383L);
4820   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p16383L, -0x1p16383L);
4821   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16382L, 0x1p-16382L);
4822   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4823   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4824   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16382L, -0x1p-16382L);
4825   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
4826   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
4827   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
4828   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
4829   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, UNDERFLOW_EXCEPTION);
4830   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16494L, 0x1p-16494L, UNDERFLOW_EXCEPTION);
4831   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, UNDERFLOW_EXCEPTION);
4832   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, -0x1p-16494L, UNDERFLOW_EXCEPTION);
4833   TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
4834   TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
4835   TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
4836   TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
4837   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1p16383L);
4838   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1p16383L);
4839   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1p16383L);
4840   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1p16383L);
4841   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1p16319L);
4842   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1p16319L);
4843   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L);
4844   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L);
4845 #endif
4846
4847   END (fma);
4848 }
4849
4850
4851 static void
4852 fma_test_towardzero (void)
4853 {
4854   int save_round_mode;
4855   START (fma_towardzero);
4856
4857   save_round_mode = fegetround ();
4858
4859   if (!fesetround (FE_TOWARDZERO))
4860     {
4861       TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero);
4862       TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, plus_zero);
4863       TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, plus_zero);
4864       TEST_fff_f (fma, plus_zero, minus_zero, minus_zero, minus_zero);
4865       TEST_fff_f (fma, minus_zero, plus_zero, plus_zero, plus_zero);
4866       TEST_fff_f (fma, minus_zero, plus_zero, minus_zero, minus_zero);
4867       TEST_fff_f (fma, minus_zero, minus_zero, plus_zero, plus_zero);
4868       TEST_fff_f (fma, minus_zero, minus_zero, minus_zero, plus_zero);
4869       TEST_fff_f (fma, 1.0, plus_zero, plus_zero, plus_zero);
4870       TEST_fff_f (fma, 1.0, plus_zero, minus_zero, plus_zero);
4871       TEST_fff_f (fma, 1.0, minus_zero, plus_zero, plus_zero);
4872       TEST_fff_f (fma, 1.0, minus_zero, minus_zero, minus_zero);
4873       TEST_fff_f (fma, -1.0, plus_zero, plus_zero, plus_zero);
4874       TEST_fff_f (fma, -1.0, plus_zero, minus_zero, minus_zero);
4875       TEST_fff_f (fma, -1.0, minus_zero, plus_zero, plus_zero);
4876       TEST_fff_f (fma, -1.0, minus_zero, minus_zero, plus_zero);
4877       TEST_fff_f (fma, plus_zero, 1.0, plus_zero, plus_zero);
4878       TEST_fff_f (fma, plus_zero, 1.0, minus_zero, plus_zero);
4879       TEST_fff_f (fma, plus_zero, -1.0, plus_zero, plus_zero);
4880       TEST_fff_f (fma, plus_zero, -1.0, minus_zero, minus_zero);
4881       TEST_fff_f (fma, minus_zero, 1.0, plus_zero, plus_zero);
4882       TEST_fff_f (fma, minus_zero, 1.0, minus_zero, minus_zero);
4883       TEST_fff_f (fma, minus_zero, -1.0, plus_zero, plus_zero);
4884       TEST_fff_f (fma, minus_zero, -1.0, minus_zero, plus_zero);
4885
4886       TEST_fff_f (fma, 1.0, 1.0, -1.0, plus_zero);
4887       TEST_fff_f (fma, 1.0, -1.0, 1.0, plus_zero);
4888       TEST_fff_f (fma, -1.0, 1.0, 1.0, plus_zero);
4889       TEST_fff_f (fma, -1.0, -1.0, -1.0, plus_zero);
4890
4891       TEST_fff_f (fma, min_value, min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4892       TEST_fff_f (fma, min_value, min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4893       TEST_fff_f (fma, min_value, -min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4894       TEST_fff_f (fma, min_value, -min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4895       TEST_fff_f (fma, -min_value, min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4896       TEST_fff_f (fma, -min_value, min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4897       TEST_fff_f (fma, -min_value, -min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4898       TEST_fff_f (fma, -min_value, -min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4899
4900 #if !(defined TEST_LDOUBLE && LDBL_MANT_DIG == 106) /* Bug 13304.  */
4901       TEST_fff_f (fma, max_value, max_value, min_value, max_value, OVERFLOW_EXCEPTION);
4902       TEST_fff_f (fma, max_value, max_value, -min_value, max_value, OVERFLOW_EXCEPTION);
4903       TEST_fff_f (fma, max_value, -max_value, min_value, -max_value, OVERFLOW_EXCEPTION);
4904       TEST_fff_f (fma, max_value, -max_value, -min_value, -max_value, OVERFLOW_EXCEPTION);
4905       TEST_fff_f (fma, -max_value, max_value, min_value, -max_value, OVERFLOW_EXCEPTION);
4906       TEST_fff_f (fma, -max_value, max_value, -min_value, -max_value, OVERFLOW_EXCEPTION);
4907       TEST_fff_f (fma, -max_value, -max_value, min_value, max_value, OVERFLOW_EXCEPTION);
4908       TEST_fff_f (fma, -max_value, -max_value, -min_value, max_value, OVERFLOW_EXCEPTION);
4909 #endif
4910
4911 #if defined (TEST_FLOAT) && FLT_MANT_DIG == 24
4912       TEST_fff_f (fma, 0x1.4p-126, 0x1.000004p-1, 0x1p-128, 0x1.c00004p-127, UNDERFLOW_EXCEPTION);
4913       TEST_fff_f (fma, -0x1.4p-126, 0x1.000004p-1, -0x1p-128, -0x1.c00004p-127, UNDERFLOW_EXCEPTION);
4914       TEST_fff_f (fma, 0x1.fffff8p-126, 0x1.000002p-1, 0x1p-149, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4915       TEST_fff_f (fma, -0x1.fffff8p-126, 0x1.000002p-1, -0x1p-149, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4916       TEST_fff_f (fma, 0x1p-149, 0x1p-1, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4917       TEST_fff_f (fma, -0x1p-149, 0x1p-1, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4918       TEST_fff_f (fma, 0x1p-149, 0x1.1p-1, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4919       TEST_fff_f (fma, -0x1p-149, 0x1.1p-1, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4920       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p127, 0x1p127);
4921       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p127, 0x0.ffffffp127);
4922       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p127, -0x0.ffffffp127);
4923       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p127, -0x1p127);
4924       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-126, 0x1p-126);
4925       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4926       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4927       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-126, -0x1p-126);
4928       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4929       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x0.fffffep-126, 0x0.fffffcp-126, UNDERFLOW_EXCEPTION);
4930       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x0.fffffep-126, -0x0.fffffcp-126, UNDERFLOW_EXCEPTION);
4931       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4932       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-149, 0x1p-149, UNDERFLOW_EXCEPTION);
4933       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-149, plus_zero, UNDERFLOW_EXCEPTION);
4934       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-149, minus_zero, UNDERFLOW_EXCEPTION);
4935       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-149, -0x1p-149, UNDERFLOW_EXCEPTION);
4936       TEST_fff_f (fma, 0x0.fffp0, 0x0.fffp0, -0x0.ffep0, 0x1p-24);
4937       TEST_fff_f (fma, 0x0.fffp0, -0x0.fffp0, 0x0.ffep0, -0x1p-24);
4938       TEST_fff_f (fma, -0x0.fffp0, 0x0.fffp0, 0x0.ffep0, -0x1p-24);
4939       TEST_fff_f (fma, -0x0.fffp0, -0x0.fffp0, -0x0.ffep0, 0x1p-24);
4940       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p127, 0x1p127);
4941       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p127, 0x0.ffffffp127);
4942       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p127, -0x0.ffffffp127);
4943       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p127, -0x1p127);
4944       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p103, 0x1p103);
4945       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p103, 0x0.ffffffp103);
4946       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p103, -0x0.ffffffp103);
4947       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p103, -0x1p103);
4948 #endif
4949 #if defined (TEST_DOUBLE) && DBL_MANT_DIG == 53
4950       TEST_fff_f (fma, 0x1.4p-1022, 0x1.0000000000002p-1, 0x1p-1024, 0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
4951       TEST_fff_f (fma, -0x1.4p-1022, 0x1.0000000000002p-1, -0x1p-1024, -0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
4952       TEST_fff_f (fma, 0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, 0x1p-1074, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4953       TEST_fff_f (fma, -0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, -0x1p-1074, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4954       TEST_fff_f (fma, 0x1p-1074, 0x1p-1, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4955       TEST_fff_f (fma, -0x1p-1074, 0x1p-1, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4956       TEST_fff_f (fma, 0x1p-1074, 0x1.1p-1, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4957       TEST_fff_f (fma, -0x1p-1074, 0x1.1p-1, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4958       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p1023, 0x1p1023);
4959       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p1023, 0x0.fffffffffffff8p1023);
4960       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p1023, -0x0.fffffffffffff8p1023);
4961       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p1023, -0x1p1023);
4962       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1022, 0x1p-1022);
4963       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4964       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4965       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1022, -0x1p-1022);
4966       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4967       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.ffffffffffffep-1022, UNDERFLOW_EXCEPTION);
4968       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.ffffffffffffep-1022, UNDERFLOW_EXCEPTION);
4969       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4970       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1074, 0x1p-1074, UNDERFLOW_EXCEPTION);
4971       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1074, plus_zero, UNDERFLOW_EXCEPTION);
4972       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1074, minus_zero, UNDERFLOW_EXCEPTION);
4973       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1074, -0x1p-1074, UNDERFLOW_EXCEPTION);
4974       TEST_fff_f (fma, 0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
4975       TEST_fff_f (fma, 0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
4976       TEST_fff_f (fma, -0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
4977       TEST_fff_f (fma, -0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
4978       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p1023, 0x1p1023);
4979       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p1023, 0x0.fffffffffffff8p1023);
4980       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p1023, -0x0.fffffffffffff8p1023);
4981       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p1023, -0x1p1023);
4982       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p970, 0x1p970);
4983       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p970, 0x0.fffffffffffff8p970);
4984       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p970, -0x0.fffffffffffff8p970);
4985       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p970, -0x1p970);
4986 #endif
4987 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 64
4988       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000004p-1L, 0x1p-16384L, 0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
4989       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000004p-1L, -0x1p-16384L, -0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
4990       TEST_fff_f (fma, 0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4991       TEST_fff_f (fma, -0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4992       TEST_fff_f (fma, 0x1p-16445L, 0x1p-1L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4993       TEST_fff_f (fma, -0x1p-16445L, 0x1p-1L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4994       TEST_fff_f (fma, 0x1p-16445L, 0x1.1p-1L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4995       TEST_fff_f (fma, -0x1p-16445L, 0x1.1p-1L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4996       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p16383L, 0x1p16383L);
4997       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p16383L, 0x0.ffffffffffffffffp16383L);
4998       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p16383L, -0x0.ffffffffffffffffp16383L);
4999       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p16383L, -0x1p16383L);
5000       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16382L, 0x1p-16382L);
5001       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5002       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5003       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16382L, -0x1p-16382L);
5004       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5005       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffcp-16382L, UNDERFLOW_EXCEPTION);
5006       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffcp-16382L, UNDERFLOW_EXCEPTION);
5007       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5008       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, UNDERFLOW_EXCEPTION);
5009       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16445L, plus_zero, UNDERFLOW_EXCEPTION);
5010       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16445L, minus_zero, UNDERFLOW_EXCEPTION);
5011       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, -0x1p-16445L, UNDERFLOW_EXCEPTION);
5012       TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
5013       TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
5014       TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
5015       TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
5016       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16383L, 0x1p16383L);
5017       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16383L, 0x0.ffffffffffffffffp16383L);
5018       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16383L, -0x0.ffffffffffffffffp16383L);
5019       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16383L, -0x1p16383L);
5020       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16319L, 0x1p16319L);
5021       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16319L, 0x0.ffffffffffffffffp16319L);
5022       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16319L, -0x0.ffffffffffffffffp16319L);
5023       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16319L, -0x1p16319L);
5024 #endif
5025 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 113
5026       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, 0x1p-16384L, 0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
5027       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, -0x1p-16384L, -0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
5028       TEST_fff_f (fma, 0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5029       TEST_fff_f (fma, -0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5030       TEST_fff_f (fma, 0x1p-16494L, 0x1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5031       TEST_fff_f (fma, -0x1p-16494L, 0x1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5032       TEST_fff_f (fma, 0x1p-16494L, 0x1.1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5033       TEST_fff_f (fma, -0x1p-16494L, 0x1.1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5034       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p16383L, 0x1p16383L);
5035       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p16383L, 0x0.ffffffffffffffffffffffffffff8p16383L);
5036       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p16383L, -0x0.ffffffffffffffffffffffffffff8p16383L);
5037       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p16383L, -0x1p16383L);
5038       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16382L, 0x1p-16382L);
5039       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5040       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5041       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16382L, -0x1p-16382L);
5042       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5043       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.fffffffffffffffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5044       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.fffffffffffffffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5045       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5046       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, UNDERFLOW_EXCEPTION);
5047       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16494L, plus_zero, UNDERFLOW_EXCEPTION);
5048       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16494L, minus_zero, UNDERFLOW_EXCEPTION);
5049       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, -0x1p-16494L, UNDERFLOW_EXCEPTION);
5050       TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5051       TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5052       TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5053       TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5054       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1p16383L);
5055       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x0.ffffffffffffffffffffffffffff8p16383L);
5056       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x0.ffffffffffffffffffffffffffff8p16383L);
5057       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1p16383L);
5058       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1p16319L);
5059       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x0.ffffffffffffffffffffffffffff8p16319L);
5060       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x0.ffffffffffffffffffffffffffff8p16319L);
5061       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L);
5062 #endif
5063     }
5064
5065   fesetround (save_round_mode);
5066
5067   END (fma_towardzero);
5068 }
5069
5070
5071 static void
5072 fma_test_downward (void)
5073 {
5074   int save_round_mode;
5075   START (fma_downward);
5076
5077   save_round_mode = fegetround ();
5078
5079   if (!fesetround (FE_DOWNWARD))
5080     {
5081       TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero);
5082       TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, minus_zero);
5083       TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, minus_zero);
5084       TEST_fff_f (fma, plus_zero, minus_zero, minus_zero, minus_zero);
5085       TEST_fff_f (fma, minus_zero, plus_zero, plus_zero, minus_zero);
5086       TEST_fff_f (fma, minus_zero, plus_zero, minus_zero, minus_zero);
5087       TEST_fff_f (fma, minus_zero, minus_zero, plus_zero, plus_zero);
5088       TEST_fff_f (fma, minus_zero, minus_zero, minus_zero, minus_zero);
5089       TEST_fff_f (fma, 1.0, plus_zero, plus_zero, plus_zero);
5090       TEST_fff_f (fma, 1.0, plus_zero, minus_zero, minus_zero);
5091       TEST_fff_f (fma, 1.0, minus_zero, plus_zero, minus_zero);
5092       TEST_fff_f (fma, 1.0, minus_zero, minus_zero, minus_zero);
5093       TEST_fff_f (fma, -1.0, plus_zero, plus_zero, minus_zero);
5094       TEST_fff_f (fma, -1.0, plus_zero, minus_zero, minus_zero);
5095       TEST_fff_f (fma, -1.0, minus_zero, plus_zero, plus_zero);
5096       TEST_fff_f (fma, -1.0, minus_zero, minus_zero, minus_zero);
5097       TEST_fff_f (fma, plus_zero, 1.0, plus_zero, plus_zero);
5098       TEST_fff_f (fma, plus_zero, 1.0, minus_zero, minus_zero);
5099       TEST_fff_f (fma, plus_zero, -1.0, plus_zero, minus_zero);
5100       TEST_fff_f (fma, plus_zero, -1.0, minus_zero, minus_zero);
5101       TEST_fff_f (fma, minus_zero, 1.0, plus_zero, minus_zero);
5102       TEST_fff_f (fma, minus_zero, 1.0, minus_zero, minus_zero);
5103       TEST_fff_f (fma, minus_zero, -1.0, plus_zero, plus_zero);
5104       TEST_fff_f (fma, minus_zero, -1.0, minus_zero, minus_zero);
5105
5106       TEST_fff_f (fma, 1.0, 1.0, -1.0, minus_zero);
5107       TEST_fff_f (fma, 1.0, -1.0, 1.0, minus_zero);
5108       TEST_fff_f (fma, -1.0, 1.0, 1.0, minus_zero);
5109       TEST_fff_f (fma, -1.0, -1.0, -1.0, minus_zero);
5110
5111       TEST_fff_f (fma, min_value, min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
5112       TEST_fff_f (fma, min_value, min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
5113       TEST_fff_f (fma, min_value, -min_value, plus_zero, -min_subnorm_value, UNDERFLOW_EXCEPTION);
5114       TEST_fff_f (fma, min_value, -min_value, minus_zero, -min_subnorm_value, UNDERFLOW_EXCEPTION);
5115       TEST_fff_f (fma, -min_value, min_value, plus_zero, -min_subnorm_value, UNDERFLOW_EXCEPTION);
5116       TEST_fff_f (fma, -min_value, min_value, minus_zero, -min_subnorm_value, UNDERFLOW_EXCEPTION);
5117       TEST_fff_f (fma, -min_value, -min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
5118       TEST_fff_f (fma, -min_value, -min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
5119
5120 #if !(defined TEST_LDOUBLE && LDBL_MANT_DIG == 106) /* Bug 13304.  */
5121       TEST_fff_f (fma, max_value, max_value, min_value, max_value, OVERFLOW_EXCEPTION);
5122       TEST_fff_f (fma, max_value, max_value, -min_value, max_value, OVERFLOW_EXCEPTION);
5123       TEST_fff_f (fma, max_value, -max_value, min_value, minus_infty, OVERFLOW_EXCEPTION);
5124       TEST_fff_f (fma, max_value, -max_value, -min_value, minus_infty, OVERFLOW_EXCEPTION);
5125       TEST_fff_f (fma, -max_value, max_value, min_value, minus_infty, OVERFLOW_EXCEPTION);
5126       TEST_fff_f (fma, -max_value, max_value, -min_value, minus_infty, OVERFLOW_EXCEPTION);
5127       TEST_fff_f (fma, -max_value, -max_value, min_value, max_value, OVERFLOW_EXCEPTION);
5128       TEST_fff_f (fma, -max_value, -max_value, -min_value, max_value, OVERFLOW_EXCEPTION);
5129 #endif
5130
5131 #if defined (TEST_FLOAT) && FLT_MANT_DIG == 24
5132       TEST_fff_f (fma, 0x1.4p-126, 0x1.000004p-1, 0x1p-128, 0x1.c00004p-127, UNDERFLOW_EXCEPTION);
5133       TEST_fff_f (fma, -0x1.4p-126, 0x1.000004p-1, -0x1p-128, -0x1.c00008p-127, UNDERFLOW_EXCEPTION);
5134       TEST_fff_f (fma, 0x1.fffff8p-126, 0x1.000002p-1, 0x1p-149, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5135       TEST_fff_f (fma, -0x1.fffff8p-126, 0x1.000002p-1, -0x1p-149, -0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5136       TEST_fff_f (fma, 0x1p-149, 0x1p-1, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5137       TEST_fff_f (fma, -0x1p-149, 0x1p-1, -0x0.fffffep-126, -0x1p-126, UNDERFLOW_EXCEPTION);
5138       TEST_fff_f (fma, 0x1p-149, 0x1.1p-1, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5139       TEST_fff_f (fma, -0x1p-149, 0x1.1p-1, -0x0.fffffep-126, -0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5140       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p127, 0x1p127);
5141       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p127, 0x0.ffffffp127);
5142       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p127, -0x1p127);
5143       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p127, -0x1.000002p127);
5144       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-126, 0x1p-126);
5145       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5146       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-126, -0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5147       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-126, -0x1.000002p-126);
5148       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5149       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x0.fffffep-126, 0x0.fffffcp-126, UNDERFLOW_EXCEPTION);
5150       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5151       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x0.fffffep-126, -0x1p-126, UNDERFLOW_EXCEPTION);
5152       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-149, 0x1p-149, UNDERFLOW_EXCEPTION);
5153       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-149, plus_zero, UNDERFLOW_EXCEPTION);
5154       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-149, -0x1p-149, UNDERFLOW_EXCEPTION);
5155       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-149, -0x1p-148, UNDERFLOW_EXCEPTION);
5156       TEST_fff_f (fma, 0x0.fffp0, 0x0.fffp0, -0x0.ffep0, 0x1p-24);
5157       TEST_fff_f (fma, 0x0.fffp0, -0x0.fffp0, 0x0.ffep0, -0x1p-24);
5158       TEST_fff_f (fma, -0x0.fffp0, 0x0.fffp0, 0x0.ffep0, -0x1p-24);
5159       TEST_fff_f (fma, -0x0.fffp0, -0x0.fffp0, -0x0.ffep0, 0x1p-24);
5160       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p127, 0x1p127);
5161       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p127, 0x0.ffffffp127);
5162       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p127, -0x1p127);
5163       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p127, -0x1.000002p127);
5164       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p103, 0x1p103);
5165       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p103, 0x0.ffffffp103);
5166       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p103, -0x1p103);
5167       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p103, -0x1.000002p103);
5168 #endif
5169 #if defined (TEST_DOUBLE) && DBL_MANT_DIG == 53
5170       TEST_fff_f (fma, 0x1.4p-1022, 0x1.0000000000002p-1, 0x1p-1024, 0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
5171       TEST_fff_f (fma, -0x1.4p-1022, 0x1.0000000000002p-1, -0x1p-1024, -0x1.c000000000004p-1023, UNDERFLOW_EXCEPTION);
5172       TEST_fff_f (fma, 0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, 0x1p-1074, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5173       TEST_fff_f (fma, -0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, -0x1p-1074, -0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5174       TEST_fff_f (fma, 0x1p-1074, 0x1p-1, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5175       TEST_fff_f (fma, -0x1p-1074, 0x1p-1, -0x0.fffffffffffffp-1022, -0x1p-1022, UNDERFLOW_EXCEPTION);
5176       TEST_fff_f (fma, 0x1p-1074, 0x1.1p-1, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5177       TEST_fff_f (fma, -0x1p-1074, 0x1.1p-1, -0x0.fffffffffffffp-1022, -0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5178       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p1023, 0x1p1023);
5179       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p1023, 0x0.fffffffffffff8p1023);
5180       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p1023, -0x1p1023);
5181       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p1023, -0x1.0000000000001p1023);
5182       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1022, 0x1p-1022);
5183       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5184       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1022, -0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5185       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1022, -0x1.0000000000001p-1022);
5186       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5187       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.ffffffffffffep-1022, UNDERFLOW_EXCEPTION);
5188       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5189       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x0.fffffffffffffp-1022, -0x1p-1022, UNDERFLOW_EXCEPTION);
5190       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1074, 0x1p-1074, UNDERFLOW_EXCEPTION);
5191       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1074, plus_zero, UNDERFLOW_EXCEPTION);
5192       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1074, -0x1p-1074, UNDERFLOW_EXCEPTION);
5193       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1074, -0x1p-1073, UNDERFLOW_EXCEPTION);
5194       TEST_fff_f (fma, 0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
5195       TEST_fff_f (fma, 0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
5196       TEST_fff_f (fma, -0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
5197       TEST_fff_f (fma, -0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
5198       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p1023, 0x1p1023);
5199       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p1023, 0x0.fffffffffffff8p1023);
5200       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p1023, -0x1p1023);
5201       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p1023, -0x1.0000000000001p1023);
5202       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p970, 0x1p970);
5203       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p970, 0x0.fffffffffffff8p970);
5204       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p970, -0x1p970);
5205       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p970, -0x1.0000000000001p970);
5206 #endif
5207 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 64
5208       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000004p-1L, 0x1p-16384L, 0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
5209       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000004p-1L, -0x1p-16384L, -0x1.c000000000000008p-16383L, UNDERFLOW_EXCEPTION);
5210       TEST_fff_f (fma, 0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5211       TEST_fff_f (fma, -0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, -0x1p-16445L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5212       TEST_fff_f (fma, 0x1p-16445L, 0x1p-1L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5213       TEST_fff_f (fma, -0x1p-16445L, 0x1p-1L, -0x0.fffffffffffffffep-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
5214       TEST_fff_f (fma, 0x1p-16445L, 0x1.1p-1L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5215       TEST_fff_f (fma, -0x1p-16445L, 0x1.1p-1L, -0x0.fffffffffffffffep-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5216       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p16383L, 0x1p16383L);
5217       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p16383L, 0x0.ffffffffffffffffp16383L);
5218       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p16383L, -0x1p16383L);
5219       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p16383L, -0x1.0000000000000002p16383L);
5220       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16382L, 0x1p-16382L);
5221       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5222       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5223       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16382L, -0x1.0000000000000002p-16382L);
5224       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5225       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffcp-16382L, UNDERFLOW_EXCEPTION);
5226       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5227       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
5228       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, UNDERFLOW_EXCEPTION);
5229       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16445L, plus_zero, UNDERFLOW_EXCEPTION);
5230       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, UNDERFLOW_EXCEPTION);
5231       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, -0x1p-16444L, UNDERFLOW_EXCEPTION);
5232       TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
5233       TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
5234       TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
5235       TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
5236       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16383L, 0x1p16383L);
5237       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16383L, 0x0.ffffffffffffffffp16383L);
5238       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16383L, -0x1p16383L);
5239       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16383L, -0x1.0000000000000002p16383L);
5240       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16319L, 0x1p16319L);
5241       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16319L, 0x0.ffffffffffffffffp16319L);
5242       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16319L, -0x1p16319L);
5243       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16319L, -0x1.0000000000000002p16319L);
5244 #endif
5245 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 113
5246       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, 0x1p-16384L, 0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
5247       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, -0x1p-16384L, -0x1.c000000000000000000000000004p-16383L, UNDERFLOW_EXCEPTION);
5248       TEST_fff_f (fma, 0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5249       TEST_fff_f (fma, -0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, -0x1p-16494L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5250       TEST_fff_f (fma, 0x1p-16494L, 0x1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5251       TEST_fff_f (fma, -0x1p-16494L, 0x1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
5252       TEST_fff_f (fma, 0x1p-16494L, 0x1.1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5253       TEST_fff_f (fma, -0x1p-16494L, 0x1.1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5254       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p16383L, 0x1p16383L);
5255       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p16383L, 0x0.ffffffffffffffffffffffffffff8p16383L);
5256       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p16383L, -0x1p16383L);
5257       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p16383L, -0x1.0000000000000000000000000001p16383L);
5258       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16382L, 0x1p-16382L);
5259       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5260       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5261       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16382L, -0x1.0000000000000000000000000001p-16382L);
5262       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5263       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.fffffffffffffffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5264       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5265       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
5266       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, UNDERFLOW_EXCEPTION);
5267       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16494L, plus_zero, UNDERFLOW_EXCEPTION);
5268       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, UNDERFLOW_EXCEPTION);
5269       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, -0x1p-16493L, UNDERFLOW_EXCEPTION);
5270       TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5271       TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5272       TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5273       TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5274       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1p16383L);
5275       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x0.ffffffffffffffffffffffffffff8p16383L);
5276       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1p16383L);
5277       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1.0000000000000000000000000001p16383L);
5278       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1p16319L);
5279       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x0.ffffffffffffffffffffffffffff8p16319L);
5280       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L);
5281       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1.0000000000000000000000000001p16319L);
5282 #endif
5283     }
5284
5285   fesetround (save_round_mode);
5286
5287   END (fma_downward);
5288 }
5289
5290
5291 static void
5292 fma_test_upward (void)
5293 {
5294   int save_round_mode;
5295   START (fma_upward);
5296
5297   save_round_mode = fegetround ();
5298
5299   if (!fesetround (FE_UPWARD))
5300     {
5301       TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero);
5302       TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, plus_zero);
5303       TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, plus_zero);
5304       TEST_fff_f (fma, plus_zero, minus_zero, minus_zero, minus_zero);
5305       TEST_fff_f (fma, minus_zero, plus_zero, plus_zero, plus_zero);
5306       TEST_fff_f (fma, minus_zero, plus_zero, minus_zero, minus_zero);
5307       TEST_fff_f (fma, minus_zero, minus_zero, plus_zero, plus_zero);
5308       TEST_fff_f (fma, minus_zero, minus_zero, minus_zero, plus_zero);
5309       TEST_fff_f (fma, 1.0, plus_zero, plus_zero, plus_zero);
5310       TEST_fff_f (fma, 1.0, plus_zero, minus_zero, plus_zero);
5311       TEST_fff_f (fma, 1.0, minus_zero, plus_zero, plus_zero);
5312       TEST_fff_f (fma, 1.0, minus_zero, minus_zero, minus_zero);
5313       TEST_fff_f (fma, -1.0, plus_zero, plus_zero, plus_zero);
5314       TEST_fff_f (fma, -1.0, plus_zero, minus_zero, minus_zero);
5315       TEST_fff_f (fma, -1.0, minus_zero, plus_zero, plus_zero);
5316       TEST_fff_f (fma, -1.0, minus_zero, minus_zero, plus_zero);
5317       TEST_fff_f (fma, plus_zero, 1.0, plus_zero, plus_zero);
5318       TEST_fff_f (fma, plus_zero, 1.0, minus_zero, plus_zero);
5319       TEST_fff_f (fma, plus_zero, -1.0, plus_zero, plus_zero);
5320       TEST_fff_f (fma, plus_zero, -1.0, minus_zero, minus_zero);
5321       TEST_fff_f (fma, minus_zero, 1.0, plus_zero, plus_zero);
5322       TEST_fff_f (fma, minus_zero, 1.0, minus_zero, minus_zero);
5323       TEST_fff_f (fma, minus_zero, -1.0, plus_zero, plus_zero);
5324       TEST_fff_f (fma, minus_zero, -1.0, minus_zero, plus_zero);
5325
5326       TEST_fff_f (fma, 1.0, 1.0, -1.0, plus_zero);
5327       TEST_fff_f (fma, 1.0, -1.0, 1.0, plus_zero);
5328       TEST_fff_f (fma, -1.0, 1.0, 1.0, plus_zero);
5329       TEST_fff_f (fma, -1.0, -1.0, -1.0, plus_zero);
5330
5331       TEST_fff_f (fma, min_value, min_value, plus_zero, min_subnorm_value, UNDERFLOW_EXCEPTION);
5332       TEST_fff_f (fma, min_value, min_value, minus_zero, min_subnorm_value, UNDERFLOW_EXCEPTION);
5333       TEST_fff_f (fma, min_value, -min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
5334       TEST_fff_f (fma, min_value, -min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
5335       TEST_fff_f (fma, -min_value, min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
5336       TEST_fff_f (fma, -min_value, min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
5337       TEST_fff_f (fma, -min_value, -min_value, plus_zero, min_subnorm_value, UNDERFLOW_EXCEPTION);
5338       TEST_fff_f (fma, -min_value, -min_value, minus_zero, min_subnorm_value, UNDERFLOW_EXCEPTION);
5339
5340 #if !(defined TEST_LDOUBLE && LDBL_MANT_DIG == 106) /* Bug 13304.  */
5341       TEST_fff_f (fma, max_value, max_value, min_value, plus_infty, OVERFLOW_EXCEPTION);
5342       TEST_fff_f (fma, max_value, max_value, -min_value, plus_infty, OVERFLOW_EXCEPTION);
5343       TEST_fff_f (fma, max_value, -max_value, min_value, -max_value, OVERFLOW_EXCEPTION);
5344       TEST_fff_f (fma, max_value, -max_value, -min_value, -max_value, OVERFLOW_EXCEPTION);
5345       TEST_fff_f (fma, -max_value, max_value, min_value, -max_value, OVERFLOW_EXCEPTION);
5346       TEST_fff_f (fma, -max_value, max_value, -min_value, -max_value, OVERFLOW_EXCEPTION);
5347       TEST_fff_f (fma, -max_value, -max_value, min_value, plus_infty, OVERFLOW_EXCEPTION);
5348       TEST_fff_f (fma, -max_value, -max_value, -min_value, plus_infty, OVERFLOW_EXCEPTION);
5349 #endif
5350
5351 #if defined (TEST_FLOAT) && FLT_MANT_DIG == 24
5352       TEST_fff_f (fma, 0x1.4p-126, 0x1.000004p-1, 0x1p-128, 0x1.c00008p-127, UNDERFLOW_EXCEPTION);
5353       TEST_fff_f (fma, -0x1.4p-126, 0x1.000004p-1, -0x1p-128, -0x1.c00004p-127, UNDERFLOW_EXCEPTION);
5354       TEST_fff_f (fma, 0x1.fffff8p-126, 0x1.000002p-1, 0x1p-149, 0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5355       TEST_fff_f (fma, -0x1.fffff8p-126, 0x1.000002p-1, -0x1p-149, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5356       TEST_fff_f (fma, 0x1p-149, 0x1p-1, 0x0.fffffep-126, 0x1p-126, UNDERFLOW_EXCEPTION);
5357       TEST_fff_f (fma, -0x1p-149, 0x1p-1, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5358       TEST_fff_f (fma, 0x1p-149, 0x1.1p-1, 0x0.fffffep-126, 0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5359       TEST_fff_f (fma, -0x1p-149, 0x1.1p-1, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5360       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p127, 0x1.000002p127);
5361       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p127, 0x1p127);
5362       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p127, -0x0.ffffffp127);
5363       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p127, -0x1p127);
5364       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-126, 0x1.000002p-126);
5365       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-126, 0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5366       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5367       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-126, -0x1p-126);
5368       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x0.fffffep-126, 0x1p-126, UNDERFLOW_EXCEPTION);
5369       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5370       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x0.fffffep-126, -0x0.fffffcp-126, UNDERFLOW_EXCEPTION);
5371       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5372       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-149, 0x1p-148, UNDERFLOW_EXCEPTION);
5373       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-149, 0x1p-149, UNDERFLOW_EXCEPTION);
5374       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-149, minus_zero, UNDERFLOW_EXCEPTION);
5375       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-149, -0x1p-149, UNDERFLOW_EXCEPTION);
5376       TEST_fff_f (fma, 0x0.fffp0, 0x0.fffp0, -0x0.ffep0, 0x1p-24);
5377       TEST_fff_f (fma, 0x0.fffp0, -0x0.fffp0, 0x0.ffep0, -0x1p-24);
5378       TEST_fff_f (fma, -0x0.fffp0, 0x0.fffp0, 0x0.ffep0, -0x1p-24);
5379       TEST_fff_f (fma, -0x0.fffp0, -0x0.fffp0, -0x0.ffep0, 0x1p-24);
5380       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p127, 0x1.000002p127);
5381       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p127, 0x1p127);
5382       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p127, -0x0.ffffffp127);
5383       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p127, -0x1p127);
5384       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p103, 0x1.000002p103);
5385       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p103, 0x1p103);
5386       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p103, -0x0.ffffffp103);
5387       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p103, -0x1p103);
5388 #endif
5389 #if defined (TEST_DOUBLE) && DBL_MANT_DIG == 53
5390       TEST_fff_f (fma, 0x1.4p-1022, 0x1.0000000000002p-1, 0x1p-1024, 0x1.c000000000004p-1023, UNDERFLOW_EXCEPTION);
5391       TEST_fff_f (fma, -0x1.4p-1022, 0x1.0000000000002p-1, -0x1p-1024, -0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
5392       TEST_fff_f (fma, 0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, 0x1p-1074, 0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5393       TEST_fff_f (fma, -0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, -0x1p-1074, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5394       TEST_fff_f (fma, 0x1p-1074, 0x1p-1, 0x0.fffffffffffffp-1022, 0x1p-1022, UNDERFLOW_EXCEPTION);
5395       TEST_fff_f (fma, -0x1p-1074, 0x1p-1, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5396       TEST_fff_f (fma, 0x1p-1074, 0x1.1p-1, 0x0.fffffffffffffp-1022, 0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5397       TEST_fff_f (fma, -0x1p-1074, 0x1.1p-1, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5398       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p1023, 0x1.0000000000001p1023);
5399       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p1023, 0x1p1023);
5400       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p1023, -0x0.fffffffffffff8p1023);
5401       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p1023, -0x1p1023);
5402       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1022, 0x1.0000000000001p-1022);
5403       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1022, 0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5404       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5405       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1022, -0x1p-1022);
5406       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x0.fffffffffffffp-1022, 0x1p-1022, UNDERFLOW_EXCEPTION);
5407       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5408       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.ffffffffffffep-1022, UNDERFLOW_EXCEPTION);
5409       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5410       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1074, 0x1p-1073, UNDERFLOW_EXCEPTION);
5411       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1074, 0x1p-1074, UNDERFLOW_EXCEPTION);
5412       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1074, minus_zero, UNDERFLOW_EXCEPTION);
5413       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1074, -0x1p-1074, UNDERFLOW_EXCEPTION);
5414       TEST_fff_f (fma, 0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
5415       TEST_fff_f (fma, 0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
5416       TEST_fff_f (fma, -0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
5417       TEST_fff_f (fma, -0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
5418       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p1023, 0x1.0000000000001p1023);
5419       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p1023, 0x1p1023);
5420       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p1023, -0x0.fffffffffffff8p1023);
5421       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p1023, -0x1p1023);
5422       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p970, 0x1.0000000000001p970);
5423       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p970, 0x1p970);
5424       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p970, -0x0.fffffffffffff8p970);
5425       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p970, -0x1p970);
5426 #endif
5427 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 64
5428       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000004p-1L, 0x1p-16384L, 0x1.c000000000000008p-16383L, UNDERFLOW_EXCEPTION);
5429       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000004p-1L, -0x1p-16384L, -0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
5430       TEST_fff_f (fma, 0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, 0x1p-16445L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5431       TEST_fff_f (fma, -0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5432       TEST_fff_f (fma, 0x1p-16445L, 0x1p-1L, 0x0.fffffffffffffffep-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
5433       TEST_fff_f (fma, -0x1p-16445L, 0x1p-1L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5434       TEST_fff_f (fma, 0x1p-16445L, 0x1.1p-1L, 0x0.fffffffffffffffep-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5435       TEST_fff_f (fma, -0x1p-16445L, 0x1.1p-1L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5436       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p16383L, 0x1.0000000000000002p16383L);
5437       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p16383L, 0x1p16383L);
5438       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p16383L, -0x0.ffffffffffffffffp16383L);
5439       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p16383L, -0x1p16383L);
5440       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16382L, 0x1.0000000000000002p-16382L);
5441       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5442       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5443       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16382L, -0x1p-16382L);
5444       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
5445       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5446       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffcp-16382L, UNDERFLOW_EXCEPTION);
5447       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5448       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, 0x1p-16444L, UNDERFLOW_EXCEPTION);
5449       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16445L, 0x1p-16445L, UNDERFLOW_EXCEPTION);
5450       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16445L, minus_zero, UNDERFLOW_EXCEPTION);
5451       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, -0x1p-16445L, UNDERFLOW_EXCEPTION);
5452       TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
5453       TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
5454       TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
5455       TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
5456       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16383L, 0x1.0000000000000002p16383L);
5457       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16383L, 0x1p16383L);
5458       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16383L, -0x0.ffffffffffffffffp16383L);
5459       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16383L, -0x1p16383L);
5460       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16319L, 0x1.0000000000000002p16319L);
5461       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16319L, 0x1p16319L);
5462       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16319L, -0x0.ffffffffffffffffp16319L);
5463       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16319L, -0x1p16319L);
5464 #endif
5465 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 113
5466       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, 0x1p-16384L, 0x1.c000000000000000000000000004p-16383L, UNDERFLOW_EXCEPTION);
5467       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, -0x1p-16384L, -0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
5468       TEST_fff_f (fma, 0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, 0x1p-16494L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5469       TEST_fff_f (fma, -0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5470       TEST_fff_f (fma, 0x1p-16494L, 0x1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
5471       TEST_fff_f (fma, -0x1p-16494L, 0x1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5472       TEST_fff_f (fma, 0x1p-16494L, 0x1.1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5473       TEST_fff_f (fma, -0x1p-16494L, 0x1.1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5474       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p16383L, 0x1.0000000000000000000000000001p16383L);
5475       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p16383L, 0x1p16383L);
5476       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p16383L, -0x0.ffffffffffffffffffffffffffff8p16383L);
5477       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p16383L, -0x1p16383L);
5478       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16382L, 0x1.0000000000000000000000000001p-16382L);
5479       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5480       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5481       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16382L, -0x1p-16382L);
5482       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
5483       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5484       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.fffffffffffffffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5485       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5486       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, 0x1p-16493L, UNDERFLOW_EXCEPTION);
5487       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16494L, 0x1p-16494L, UNDERFLOW_EXCEPTION);
5488       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16494L, minus_zero, UNDERFLOW_EXCEPTION);
5489       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, -0x1p-16494L, UNDERFLOW_EXCEPTION);
5490       TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5491       TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5492       TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5493       TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5494       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1.0000000000000000000000000001p16383L);
5495       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1p16383L);
5496       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x0.ffffffffffffffffffffffffffff8p16383L);
5497       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1p16383L);
5498       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1.0000000000000000000000000001p16319L);
5499       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1p16319L);
5500       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x0.ffffffffffffffffffffffffffff8p16319L);
5501       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L);
5502 #endif
5503     }
5504
5505   fesetround (save_round_mode);
5506
5507   END (fma_upward);
5508 }
5509
5510
5511 static void
5512 fmax_test (void)
5513 {
5514   START (fmax);
5515
5516   TEST_ff_f (fmax, 0, 0, 0);
5517   TEST_ff_f (fmax, minus_zero, minus_zero, minus_zero);
5518   TEST_ff_f (fmax, 9, 0, 9);
5519   TEST_ff_f (fmax, 0, 9, 9);
5520   TEST_ff_f (fmax, -9, 0, 0);
5521   TEST_ff_f (fmax, 0, -9, 0);
5522
5523   TEST_ff_f (fmax, plus_infty, 9, plus_infty);
5524   TEST_ff_f (fmax, 0, plus_infty, plus_infty);
5525   TEST_ff_f (fmax, -9, plus_infty, plus_infty);
5526   TEST_ff_f (fmax, plus_infty, -9, plus_infty);
5527
5528   TEST_ff_f (fmax, minus_infty, 9, 9);
5529   TEST_ff_f (fmax, minus_infty, -9, -9);
5530   TEST_ff_f (fmax, 9, minus_infty, 9);
5531   TEST_ff_f (fmax, -9, minus_infty, -9);
5532
5533   TEST_ff_f (fmax, 0, nan_value, 0);
5534   TEST_ff_f (fmax, 9, nan_value, 9);
5535   TEST_ff_f (fmax, -9, nan_value, -9);
5536   TEST_ff_f (fmax, nan_value, 0, 0);
5537   TEST_ff_f (fmax, nan_value, 9, 9);
5538   TEST_ff_f (fmax, nan_value, -9, -9);
5539   TEST_ff_f (fmax, plus_infty, nan_value, plus_infty);
5540   TEST_ff_f (fmax, minus_infty, nan_value, minus_infty);
5541   TEST_ff_f (fmax, nan_value, plus_infty, plus_infty);
5542   TEST_ff_f (fmax, nan_value, minus_infty, minus_infty);
5543   TEST_ff_f (fmax, nan_value, nan_value, nan_value);
5544
5545   END (fmax);
5546 }
5547
5548
5549 static void
5550 fmin_test (void)
5551 {
5552   START (fmin);
5553
5554   TEST_ff_f (fmin, 0, 0, 0);
5555   TEST_ff_f (fmin, minus_zero, minus_zero, minus_zero);
5556   TEST_ff_f (fmin, 9, 0, 0);
5557   TEST_ff_f (fmin, 0, 9, 0);
5558   TEST_ff_f (fmin, -9, 0, -9);
5559   TEST_ff_f (fmin, 0, -9, -9);
5560
5561   TEST_ff_f (fmin, plus_infty, 9, 9);
5562   TEST_ff_f (fmin, 9, plus_infty, 9);
5563   TEST_ff_f (fmin, plus_infty, -9, -9);
5564   TEST_ff_f (fmin, -9, plus_infty, -9);
5565   TEST_ff_f (fmin, minus_infty, 9, minus_infty);
5566   TEST_ff_f (fmin, minus_infty, -9, minus_infty);
5567   TEST_ff_f (fmin, 9, minus_infty, minus_infty);
5568   TEST_ff_f (fmin, -9, minus_infty, minus_infty);
5569
5570   TEST_ff_f (fmin, 0, nan_value, 0);
5571   TEST_ff_f (fmin, 9, nan_value, 9);
5572   TEST_ff_f (fmin, -9, nan_value, -9);
5573   TEST_ff_f (fmin, nan_value, 0, 0);
5574   TEST_ff_f (fmin, nan_value, 9, 9);
5575   TEST_ff_f (fmin, nan_value, -9, -9);
5576   TEST_ff_f (fmin, plus_infty, nan_value, plus_infty);
5577   TEST_ff_f (fmin, minus_infty, nan_value, minus_infty);
5578   TEST_ff_f (fmin, nan_value, plus_infty, plus_infty);
5579   TEST_ff_f (fmin, nan_value, minus_infty, minus_infty);
5580   TEST_ff_f (fmin, nan_value, nan_value, nan_value);
5581
5582   END (fmin);
5583 }
5584
5585
5586 static void
5587 fmod_test (void)
5588 {
5589   errno = 0;
5590   FUNC(fmod) (6.5, 2.3L);
5591   if (errno == ENOSYS)
5592     /* Function not implemented.  */
5593     return;
5594
5595   START (fmod);
5596
5597   /* fmod (+0, y) == +0 for y != 0.  */
5598   TEST_ff_f (fmod, 0, 3, 0);
5599
5600   /* fmod (-0, y) == -0 for y != 0.  */
5601   TEST_ff_f (fmod, minus_zero, 3, minus_zero);
5602
5603   /* fmod (+inf, y) == NaN plus invalid exception.  */
5604   errno = 0;
5605   TEST_ff_f (fmod, plus_infty, 3, nan_value, INVALID_EXCEPTION);
5606   check_int ("errno for fmod(Inf,3) unchanged", errno, EDOM, 0, 0, 0);
5607   /* fmod (-inf, y) == NaN plus invalid exception.  */
5608   errno = 0;
5609   TEST_ff_f (fmod, minus_infty, 3, nan_value, INVALID_EXCEPTION);
5610   check_int ("errno for fmod(-Inf,3) unchanged", errno, EDOM, 0, 0, 0);
5611   /* fmod (x, +0) == NaN plus invalid exception.  */
5612   errno = 0;
5613   TEST_ff_f (fmod, 3, 0, nan_value, INVALID_EXCEPTION);
5614   check_int ("errno for fmod(3,0) unchanged", errno, EDOM, 0, 0, 0);
5615   /* fmod (x, -0) == NaN plus invalid exception.  */
5616   TEST_ff_f (fmod, 3, minus_zero, nan_value, INVALID_EXCEPTION);
5617
5618   /* fmod (x, +inf) == x for x not infinite.  */
5619   TEST_ff_f (fmod, 3.0, plus_infty, 3.0);
5620   /* fmod (x, -inf) == x for x not infinite.  */
5621   TEST_ff_f (fmod, 3.0, minus_infty, 3.0);
5622
5623   TEST_ff_f (fmod, nan_value, nan_value, nan_value);
5624
5625   TEST_ff_f (fmod, 6.5, 2.25L, 2.0L);
5626   TEST_ff_f (fmod, -6.5, 2.25L, -2.0L);
5627   TEST_ff_f (fmod, 6.5, -2.25L, 2.0L);
5628   TEST_ff_f (fmod, -6.5, -2.25L, -2.0L);
5629
5630   TEST_ff_f (fmod, 0x0.fffffep-126L, 0x1p-149L, plus_zero);
5631 #ifndef TEST_FLOAT
5632   TEST_ff_f (fmod, 0x0.fffffffffffffp-1022L, 0x1p-1074L, plus_zero);
5633 #endif
5634 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
5635   TEST_ff_f (fmod, 0x0.fffffffffffffffep-16382L, 0x1p-16445L, plus_zero);
5636 #endif
5637
5638   END (fmod);
5639 }
5640
5641
5642 static void
5643 fpclassify_test (void)
5644 {
5645   START (fpclassify);
5646
5647   TEST_f_i (fpclassify, nan_value, FP_NAN);
5648   TEST_f_i (fpclassify, plus_infty, FP_INFINITE);
5649   TEST_f_i (fpclassify, minus_infty, FP_INFINITE);
5650   TEST_f_i (fpclassify, plus_zero, FP_ZERO);
5651   TEST_f_i (fpclassify, minus_zero, FP_ZERO);
5652   TEST_f_i (fpclassify, 1000, FP_NORMAL);
5653   TEST_f_i (fpclassify, min_subnorm_value, FP_SUBNORMAL);
5654
5655   END (fpclassify);
5656 }
5657
5658
5659 static void
5660 frexp_test (void)
5661 {
5662   int x;
5663
5664   START (frexp);
5665
5666   TEST_fI_f1 (frexp, plus_infty, plus_infty, IGNORE);
5667   TEST_fI_f1 (frexp, minus_infty, minus_infty, IGNORE);
5668   TEST_fI_f1 (frexp, nan_value, nan_value, IGNORE);
5669
5670   TEST_fI_f1 (frexp, 0.0, 0.0, 0.0);
5671   TEST_fI_f1 (frexp, minus_zero, minus_zero, 0.0);
5672
5673   TEST_fI_f1 (frexp, 12.8L, 0.8L, 4);
5674   TEST_fI_f1 (frexp, -27.34L, -0.854375L, 5);
5675
5676   END (frexp);
5677 }
5678
5679
5680 static void
5681 gamma_test (void)
5682 {
5683   errno = 0;
5684   FUNC(gamma) (1);
5685
5686   if (errno == ENOSYS)
5687     /* Function not implemented.  */
5688     return;
5689
5690   START (gamma);
5691
5692   TEST_f_f (gamma, plus_infty, plus_infty);
5693   TEST_f_f (gamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5694   TEST_f_f (gamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5695   TEST_f_f (gamma, minus_infty, plus_infty);
5696   TEST_f_f (gamma, nan_value, nan_value);
5697
5698   TEST_f_f1 (gamma, 1, 0, 1);
5699   TEST_f_f1 (gamma, 3, M_LN2l, 1);
5700
5701   TEST_f_f1 (gamma, 0.5, M_LOG_SQRT_PIl, 1);
5702   TEST_f_f1 (gamma, -0.5, M_LOG_2_SQRT_PIl, -1);
5703
5704   END (gamma);
5705 }
5706
5707 static void
5708 hypot_test (void)
5709 {
5710   errno = 0;
5711   FUNC(hypot) (0.7L, 12.4L);
5712   if (errno == ENOSYS)
5713     /* Function not implemented.  */
5714     return;
5715
5716   START (hypot);
5717
5718   TEST_ff_f (hypot, plus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
5719   TEST_ff_f (hypot, minus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
5720
5721 #ifndef TEST_INLINE
5722   TEST_ff_f (hypot, plus_infty, nan_value, plus_infty);
5723   TEST_ff_f (hypot, minus_infty, nan_value, plus_infty);
5724   TEST_ff_f (hypot, nan_value, plus_infty, plus_infty);
5725   TEST_ff_f (hypot, nan_value, minus_infty, plus_infty);
5726 #endif
5727
5728   TEST_ff_f (hypot, nan_value, nan_value, nan_value);
5729
5730   /* hypot (x,y) == hypot (+-x, +-y)  */
5731   TEST_ff_f (hypot, 0.7L, 12.4L, 12.419742348374220601176836866763271L);
5732   TEST_ff_f (hypot, -0.7L, 12.4L, 12.419742348374220601176836866763271L);
5733   TEST_ff_f (hypot, 0.7L, -12.4L, 12.419742348374220601176836866763271L);
5734   TEST_ff_f (hypot, -0.7L, -12.4L, 12.419742348374220601176836866763271L);
5735   TEST_ff_f (hypot, 12.4L, 0.7L, 12.419742348374220601176836866763271L);
5736   TEST_ff_f (hypot, -12.4L, 0.7L, 12.419742348374220601176836866763271L);
5737   TEST_ff_f (hypot, 12.4L, -0.7L, 12.419742348374220601176836866763271L);
5738   TEST_ff_f (hypot, -12.4L, -0.7L, 12.419742348374220601176836866763271L);
5739
5740   /*  hypot (x,0) == fabs (x)  */
5741   TEST_ff_f (hypot, 0.75L, 0, 0.75L);
5742   TEST_ff_f (hypot, -0.75L, 0, 0.75L);
5743   TEST_ff_f (hypot, -5.7e7, 0, 5.7e7L);
5744
5745   TEST_ff_f (hypot, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
5746
5747   TEST_ff_f (hypot, 1.0L, 0x1p-61L, 1.0L);
5748 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
5749   TEST_ff_f (hypot, 0x1.23456789abcdef0123456789ab8p-500L, 0x1.23456789abcdef0123456789ab8p-500L, 4.9155782399407039128612180934736799735113e-151L);
5750 #endif
5751
5752 #if !(defined TEST_FLOAT && defined TEST_INLINE)
5753   TEST_ff_f (hypot, 0x3p125L, 0x4p125L, 0x5p125L);
5754   TEST_ff_f (hypot, 0x1.234566p-126L, 0x1.234566p-126L, 1.891441686191081936598531534017449451173e-38L);
5755 #endif
5756
5757 #if !defined TEST_FLOAT && !(defined TEST_DOUBLE && defined TEST_INLINE)
5758   TEST_ff_f (hypot, 0x3p1021L, 0x4p1021L, 0x5p1021L);
5759 #endif
5760
5761 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384 && !defined TEST_INLINE
5762   TEST_ff_f (hypot, 0x3p16381L, 0x4p16381L, 0x5p16381L);
5763 #endif
5764
5765   END (hypot);
5766 }
5767
5768
5769 static void
5770 ilogb_test (void)
5771 {
5772   START (ilogb);
5773
5774   TEST_f_i (ilogb, 1, 0);
5775   TEST_f_i (ilogb, M_El, 1);
5776   TEST_f_i (ilogb, 1024, 10);
5777   TEST_f_i (ilogb, -2000, 10);
5778
5779   /* ilogb (0.0) == FP_ILOGB0 plus invalid exception  */
5780   errno = 0;
5781   TEST_f_i (ilogb, 0.0, FP_ILOGB0, INVALID_EXCEPTION);
5782   check_int ("errno for ilogb(0.0) unchanged", errno, EDOM, 0, 0, 0);
5783   /* ilogb (NaN) == FP_ILOGBNAN plus invalid exception  */
5784   errno = 0;
5785   TEST_f_i (ilogb, nan_value, FP_ILOGBNAN, INVALID_EXCEPTION);
5786   check_int ("errno for ilogb(NaN) unchanged", errno, EDOM, 0, 0, 0);
5787   /* ilogb (inf) == INT_MAX plus invalid exception  */
5788   errno = 0;
5789   TEST_f_i (ilogb, plus_infty, INT_MAX, INVALID_EXCEPTION);
5790   check_int ("errno for ilogb(Inf) unchanged", errno, EDOM, 0, 0, 0);
5791   /* ilogb (-inf) == INT_MAX plus invalid exception  */
5792   errno = 0;
5793   TEST_f_i (ilogb, minus_infty, INT_MAX, INVALID_EXCEPTION);
5794   check_int ("errno for ilogb(-Inf) unchanged", errno, EDOM, 0, 0, 0);
5795
5796   END (ilogb);
5797 }
5798
5799 static void
5800 isfinite_test (void)
5801 {
5802   START (isfinite);
5803
5804   TEST_f_b (isfinite, 0, 1);
5805   TEST_f_b (isfinite, minus_zero, 1);
5806   TEST_f_b (isfinite, 10, 1);
5807   TEST_f_b (isfinite, min_subnorm_value, 1);
5808   TEST_f_b (isfinite, plus_infty, 0);
5809   TEST_f_b (isfinite, minus_infty, 0);
5810   TEST_f_b (isfinite, nan_value, 0);
5811
5812   END (isfinite);
5813 }
5814
5815 static void
5816 isgreater_test (void)
5817 {
5818   START (isgreater);
5819
5820   TEST_ff_i (isgreater, minus_zero, minus_zero, 0);
5821   TEST_ff_i (isgreater, minus_zero, plus_zero, 0);
5822   TEST_ff_i (isgreater, minus_zero, (FLOAT) 1, 0);
5823   TEST_ff_i (isgreater, minus_zero, nan_value, 0);
5824   TEST_ff_i (isgreater, plus_zero, minus_zero, 0);
5825   TEST_ff_i (isgreater, plus_zero, plus_zero, 0);
5826   TEST_ff_i (isgreater, plus_zero, (FLOAT) 1, 0);
5827   TEST_ff_i (isgreater, plus_zero, nan_value, 0);
5828   TEST_ff_i (isgreater, (FLOAT) 1, minus_zero, 1);
5829   TEST_ff_i (isgreater, (FLOAT) 1, plus_zero, 1);
5830   TEST_ff_i (isgreater, (FLOAT) 1, (FLOAT) 1, 0);
5831   TEST_ff_i (isgreater, (FLOAT) 1, nan_value, 0);
5832   TEST_ff_i (isgreater, nan_value, minus_zero, 0);
5833   TEST_ff_i (isgreater, nan_value, plus_zero, 0);
5834   TEST_ff_i (isgreater, nan_value, (FLOAT) 1, 0);
5835   TEST_ff_i (isgreater, nan_value, nan_value, 0);
5836
5837   END (isgreater);
5838 }
5839
5840 static void
5841 isgreaterequal_test (void)
5842 {
5843   START (isgreaterequal);
5844
5845   TEST_ff_i (isgreaterequal, minus_zero, minus_zero, 1);
5846   TEST_ff_i (isgreaterequal, minus_zero, plus_zero, 1);
5847   TEST_ff_i (isgreaterequal, minus_zero, (FLOAT) 1, 0);
5848   TEST_ff_i (isgreaterequal, minus_zero, nan_value, 0);
5849   TEST_ff_i (isgreaterequal, plus_zero, minus_zero, 1);
5850   TEST_ff_i (isgreaterequal, plus_zero, plus_zero, 1);
5851   TEST_ff_i (isgreaterequal, plus_zero, (FLOAT) 1, 0);
5852   TEST_ff_i (isgreaterequal, plus_zero, nan_value, 0);
5853   TEST_ff_i (isgreaterequal, (FLOAT) 1, minus_zero, 1);
5854   TEST_ff_i (isgreaterequal, (FLOAT) 1, plus_zero, 1);
5855   TEST_ff_i (isgreaterequal, (FLOAT) 1, (FLOAT) 1, 1);
5856   TEST_ff_i (isgreaterequal, (FLOAT) 1, nan_value, 0);
5857   TEST_ff_i (isgreaterequal, nan_value, minus_zero, 0);
5858   TEST_ff_i (isgreaterequal, nan_value, plus_zero, 0);
5859   TEST_ff_i (isgreaterequal, nan_value, (FLOAT) 1, 0);
5860   TEST_ff_i (isgreaterequal, nan_value, nan_value, 0);
5861
5862   END (isgreaterequal);
5863 }
5864
5865 static void
5866 isinf_test (void)
5867 {
5868   START (isinf);
5869
5870   TEST_f_b (isinf, 0, 0);
5871   TEST_f_b (isinf, minus_zero, 0);
5872   TEST_f_b (isinf, 10, 0);
5873   TEST_f_b (isinf, min_subnorm_value, 0);
5874   TEST_f_b (isinf, plus_infty, 1);
5875   TEST_f_b (isinf, minus_infty, 1);
5876   TEST_f_b (isinf, nan_value, 0);
5877
5878   END (isinf);
5879 }
5880
5881 static void
5882 isless_test (void)
5883 {
5884   START (isless);
5885
5886   TEST_ff_i (isless, minus_zero, minus_zero, 0);
5887   TEST_ff_i (isless, minus_zero, plus_zero, 0);
5888   TEST_ff_i (isless, minus_zero, (FLOAT) 1, 1);
5889   TEST_ff_i (isless, minus_zero, nan_value, 0);
5890   TEST_ff_i (isless, plus_zero, minus_zero, 0);
5891   TEST_ff_i (isless, plus_zero, plus_zero, 0);
5892   TEST_ff_i (isless, plus_zero, (FLOAT) 1, 1);
5893   TEST_ff_i (isless, plus_zero, nan_value, 0);
5894   TEST_ff_i (isless, (FLOAT) 1, minus_zero, 0);
5895   TEST_ff_i (isless, (FLOAT) 1, plus_zero, 0);
5896   TEST_ff_i (isless, (FLOAT) 1, (FLOAT) 1, 0);
5897   TEST_ff_i (isless, (FLOAT) 1, nan_value, 0);
5898   TEST_ff_i (isless, nan_value, minus_zero, 0);
5899   TEST_ff_i (isless, nan_value, plus_zero, 0);
5900   TEST_ff_i (isless, nan_value, (FLOAT) 1, 0);
5901   TEST_ff_i (isless, nan_value, nan_value, 0);
5902
5903   END (isless);
5904 }
5905
5906 static void
5907 islessequal_test (void)
5908 {
5909   START (islessequal);
5910
5911   TEST_ff_i (islessequal, minus_zero, minus_zero, 1);
5912   TEST_ff_i (islessequal, minus_zero, plus_zero, 1);
5913   TEST_ff_i (islessequal, minus_zero, (FLOAT) 1, 1);
5914   TEST_ff_i (islessequal, minus_zero, nan_value, 0);
5915   TEST_ff_i (islessequal, plus_zero, minus_zero, 1);
5916   TEST_ff_i (islessequal, plus_zero, plus_zero, 1);
5917   TEST_ff_i (islessequal, plus_zero, (FLOAT) 1, 1);
5918   TEST_ff_i (islessequal, plus_zero, nan_value, 0);
5919   TEST_ff_i (islessequal, (FLOAT) 1, minus_zero, 0);
5920   TEST_ff_i (islessequal, (FLOAT) 1, plus_zero, 0);
5921   TEST_ff_i (islessequal, (FLOAT) 1, (FLOAT) 1, 1);
5922   TEST_ff_i (islessequal, (FLOAT) 1, nan_value, 0);
5923   TEST_ff_i (islessequal, nan_value, minus_zero, 0);
5924   TEST_ff_i (islessequal, nan_value, plus_zero, 0);
5925   TEST_ff_i (islessequal, nan_value, (FLOAT) 1, 0);
5926   TEST_ff_i (islessequal, nan_value, nan_value, 0);
5927
5928   END (islessequal);
5929 }
5930
5931 static void
5932 islessgreater_test (void)
5933 {
5934   START (islessgreater);
5935
5936   TEST_ff_i (islessgreater, minus_zero, minus_zero, 0);
5937   TEST_ff_i (islessgreater, minus_zero, plus_zero, 0);
5938   TEST_ff_i (islessgreater, minus_zero, (FLOAT) 1, 1);
5939   TEST_ff_i (islessgreater, minus_zero, nan_value, 0);
5940   TEST_ff_i (islessgreater, plus_zero, minus_zero, 0);
5941   TEST_ff_i (islessgreater, plus_zero, plus_zero, 0);
5942   TEST_ff_i (islessgreater, plus_zero, (FLOAT) 1, 1);
5943   TEST_ff_i (islessgreater, plus_zero, nan_value, 0);
5944   TEST_ff_i (islessgreater, (FLOAT) 1, minus_zero, 1);
5945   TEST_ff_i (islessgreater, (FLOAT) 1, plus_zero, 1);
5946   TEST_ff_i (islessgreater, (FLOAT) 1, (FLOAT) 1, 0);
5947   TEST_ff_i (islessgreater, (FLOAT) 1, nan_value, 0);
5948   TEST_ff_i (islessgreater, nan_value, minus_zero, 0);
5949   TEST_ff_i (islessgreater, nan_value, plus_zero, 0);
5950   TEST_ff_i (islessgreater, nan_value, (FLOAT) 1, 0);
5951   TEST_ff_i (islessgreater, nan_value, nan_value, 0);
5952
5953   END (islessgreater);
5954 }
5955
5956 static void
5957 isnan_test (void)
5958 {
5959   START (isnan);
5960
5961   TEST_f_b (isnan, 0, 0);
5962   TEST_f_b (isnan, minus_zero, 0);
5963   TEST_f_b (isnan, 10, 0);
5964   TEST_f_b (isnan, min_subnorm_value, 0);
5965   TEST_f_b (isnan, plus_infty, 0);
5966   TEST_f_b (isnan, minus_infty, 0);
5967   TEST_f_b (isnan, nan_value, 1);
5968
5969   END (isnan);
5970 }
5971
5972 static void
5973 isnormal_test (void)
5974 {
5975   START (isnormal);
5976
5977   TEST_f_b (isnormal, 0, 0);
5978   TEST_f_b (isnormal, minus_zero, 0);
5979   TEST_f_b (isnormal, 10, 1);
5980   TEST_f_b (isnormal, min_subnorm_value, 0);
5981   TEST_f_b (isnormal, plus_infty, 0);
5982   TEST_f_b (isnormal, minus_infty, 0);
5983   TEST_f_b (isnormal, nan_value, 0);
5984
5985   END (isnormal);
5986 }
5987
5988 static void
5989 isunordered_test (void)
5990 {
5991   START (isunordered);
5992
5993   TEST_ff_i (isunordered, minus_zero, minus_zero, 0);
5994   TEST_ff_i (isunordered, minus_zero, plus_zero, 0);
5995   TEST_ff_i (isunordered, minus_zero, (FLOAT) 1, 0);
5996   TEST_ff_i (isunordered, minus_zero, nan_value, 1);
5997   TEST_ff_i (isunordered, plus_zero, minus_zero, 0);
5998   TEST_ff_i (isunordered, plus_zero, plus_zero, 0);
5999   TEST_ff_i (isunordered, plus_zero, (FLOAT) 1, 0);
6000   TEST_ff_i (isunordered, plus_zero, nan_value, 1);
6001   TEST_ff_i (isunordered, (FLOAT) 1, minus_zero, 0);
6002   TEST_ff_i (isunordered, (FLOAT) 1, plus_zero, 0);
6003   TEST_ff_i (isunordered, (FLOAT) 1, (FLOAT) 1, 0);
6004   TEST_ff_i (isunordered, (FLOAT) 1, nan_value, 1);
6005   TEST_ff_i (isunordered, nan_value, minus_zero, 1);
6006   TEST_ff_i (isunordered, nan_value, plus_zero, 1);
6007   TEST_ff_i (isunordered, nan_value, (FLOAT) 1, 1);
6008   TEST_ff_i (isunordered, nan_value, nan_value, 1);
6009
6010   END (isunordered);
6011 }
6012
6013 static void
6014 j0_test (void)
6015 {
6016   FLOAT s, c;
6017   errno = 0;
6018   FUNC (sincos) (0, &s, &c);
6019   if (errno == ENOSYS)
6020     /* Required function not implemented.  */
6021     return;
6022   FUNC(j0) (0);
6023   if (errno == ENOSYS)
6024     /* Function not implemented.  */
6025     return;
6026
6027   START (j0);
6028
6029   /* j0 is the Bessel function of the first kind of order 0 */
6030   TEST_f_f (j0, nan_value, nan_value);
6031   TEST_f_f (j0, plus_infty, 0);
6032   TEST_f_f (j0, -1.0, 0.765197686557966551449717526102663221L);
6033   TEST_f_f (j0, 0.0, 1.0);
6034   TEST_f_f (j0, 0.125L, 0.996097563041985204620768999453174712L);
6035   TEST_f_f (j0, 0.75L, 0.864242275166648623555731103820923211L);
6036   TEST_f_f (j0, 1.0, 0.765197686557966551449717526102663221L);
6037   TEST_f_f (j0, 1.5, 0.511827671735918128749051744283411720L);
6038   TEST_f_f (j0, 2.0, 0.223890779141235668051827454649948626L);
6039   TEST_f_f (j0, 8.0, 0.171650807137553906090869407851972001L);
6040   TEST_f_f (j0, 10.0, -0.245935764451348335197760862485328754L);
6041   TEST_f_f (j0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
6042   TEST_f_f (j0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
6043
6044   /* Bug 14155: spurious exception may occur.  */
6045   TEST_f_f (j0, 0x1.d7ce3ap+107L, 2.775523647291230802651040996274861694514e-17L, UNDERFLOW_EXCEPTION_OK);
6046
6047 #ifndef TEST_FLOAT
6048   /* Bug 14155: spurious exception may occur.  */
6049   TEST_f_f (j0, -0x1.001000001p+593L, -3.927269966354206207832593635798954916263e-90L, UNDERFLOW_EXCEPTION_OK);
6050 #endif
6051
6052   END (j0);
6053 }
6054
6055
6056 static void
6057 j1_test (void)
6058 {
6059   FLOAT s, c;
6060   errno = 0;
6061   FUNC (sincos) (0, &s, &c);
6062   if (errno == ENOSYS)
6063     /* Required function not implemented.  */
6064     return;
6065   FUNC(j1) (0);
6066   if (errno == ENOSYS)
6067     /* Function not implemented.  */
6068     return;
6069
6070   /* j1 is the Bessel function of the first kind of order 1 */
6071
6072   START (j1);
6073
6074   TEST_f_f (j1, nan_value, nan_value);
6075   TEST_f_f (j1, plus_infty, 0);
6076
6077   TEST_f_f (j1, -1.0, -0.440050585744933515959682203718914913L);
6078   TEST_f_f (j1, 0.0, 0.0);
6079   TEST_f_f (j1, 0.125L, 0.0623780091344946810942311355879361177L);
6080   TEST_f_f (j1, 0.75L, 0.349243602174862192523281016426251335L);
6081   TEST_f_f (j1, 1.0, 0.440050585744933515959682203718914913L);
6082   TEST_f_f (j1, 1.5, 0.557936507910099641990121213156089400L);
6083   TEST_f_f (j1, 2.0, 0.576724807756873387202448242269137087L);
6084   TEST_f_f (j1, 8.0, 0.234636346853914624381276651590454612L);
6085   TEST_f_f (j1, 10.0, 0.0434727461688614366697487680258592883L);
6086
6087   TEST_f_f (j1, 0x1.3ffp+74L, 1.818984347516051243459364437186082741567e-12L);
6088
6089 #ifndef TEST_FLOAT
6090   /* Bug 14155: spurious exception may occur.  */
6091   TEST_f_f (j1, 0x1.ff00000000002p+840L, 1.846591691699331493194965158699937660696e-127L, UNDERFLOW_EXCEPTION_OK);
6092 #endif
6093
6094   END (j1);
6095 }
6096
6097 static void
6098 jn_test (void)
6099 {
6100   FLOAT s, c;
6101   errno = 0;
6102   FUNC (sincos) (0, &s, &c);
6103   if (errno == ENOSYS)
6104     /* Required function not implemented.  */
6105     return;
6106   FUNC(jn) (1, 1);
6107   if (errno == ENOSYS)
6108     /* Function not implemented.  */
6109     return;
6110
6111   /* jn is the Bessel function of the first kind of order n.  */
6112   START (jn);
6113
6114   /* jn (0, x) == j0 (x)  */
6115   TEST_ff_f (jn, 0, nan_value, nan_value);
6116   TEST_ff_f (jn, 0, plus_infty, 0);
6117   TEST_ff_f (jn, 0, -1.0, 0.765197686557966551449717526102663221L);
6118   TEST_ff_f (jn, 0, 0.0, 1.0);
6119   TEST_ff_f (jn, 0, 0.125L, 0.996097563041985204620768999453174712L);
6120   TEST_ff_f (jn, 0, 0.75L, 0.864242275166648623555731103820923211L);
6121   TEST_ff_f (jn, 0, 1.0, 0.765197686557966551449717526102663221L);
6122   TEST_ff_f (jn, 0, 1.5, 0.511827671735918128749051744283411720L);
6123   TEST_ff_f (jn, 0, 2.0, 0.223890779141235668051827454649948626L);
6124   TEST_ff_f (jn, 0, 8.0, 0.171650807137553906090869407851972001L);
6125   TEST_ff_f (jn, 0, 10.0, -0.245935764451348335197760862485328754L);
6126   TEST_ff_f (jn, 0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
6127   TEST_ff_f (jn, 0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
6128
6129   /* jn (1, x) == j1 (x)  */
6130   TEST_ff_f (jn, 1, nan_value, nan_value);
6131   TEST_ff_f (jn, 1, plus_infty, 0);
6132   TEST_ff_f (jn, 1, -1.0, -0.440050585744933515959682203718914913L);
6133   TEST_ff_f (jn, 1, 0.0, 0.0);
6134   TEST_ff_f (jn, 1, 0.125L, 0.0623780091344946810942311355879361177L);
6135   TEST_ff_f (jn, 1, 0.75L, 0.349243602174862192523281016426251335L);
6136   TEST_ff_f (jn, 1, 1.0, 0.440050585744933515959682203718914913L);
6137   TEST_ff_f (jn, 1, 1.5, 0.557936507910099641990121213156089400L);
6138   TEST_ff_f (jn, 1, 2.0, 0.576724807756873387202448242269137087L);
6139   TEST_ff_f (jn, 1, 8.0, 0.234636346853914624381276651590454612L);
6140   TEST_ff_f (jn, 1, 10.0, 0.0434727461688614366697487680258592883L);
6141
6142   /* jn (3, x)  */
6143   TEST_ff_f (jn, 3, nan_value, nan_value);
6144   TEST_ff_f (jn, 3, plus_infty, 0);
6145
6146   TEST_ff_f (jn, 3, -1.0, -0.0195633539826684059189053216217515083L);
6147   TEST_ff_f (jn, 3, 0.0, 0.0);
6148   TEST_ff_f (jn, 3, 0.125L, 0.406503832554912875023029337653442868e-4L);
6149   TEST_ff_f (jn, 3, 0.75L, 0.848438342327410884392755236884386804e-2L);
6150   TEST_ff_f (jn, 3, 1.0, 0.0195633539826684059189053216217515083L);
6151   TEST_ff_f (jn, 3, 2.0, 0.128943249474402051098793332969239835L);
6152   TEST_ff_f (jn, 3, 10.0, 0.0583793793051868123429354784103409563L);
6153
6154   /*  jn (10, x)  */
6155   TEST_ff_f (jn, 10, nan_value, nan_value);
6156   TEST_ff_f (jn, 10, plus_infty, 0);
6157
6158   TEST_ff_f (jn, 10, -1.0, 0.263061512368745320699785368779050294e-9L);
6159   TEST_ff_f (jn, 10, 0.0, 0.0);
6160   TEST_ff_f (jn, 10, 0.125L, 0.250543369809369890173993791865771547e-18L);
6161   TEST_ff_f (jn, 10, 0.75L, 0.149621713117596814698712483621682835e-10L);
6162   TEST_ff_f (jn, 10, 1.0, 0.263061512368745320699785368779050294e-9L);
6163   TEST_ff_f (jn, 10, 2.0, 0.251538628271673670963516093751820639e-6L);
6164   TEST_ff_f (jn, 10, 10.0, 0.207486106633358857697278723518753428L);
6165
6166   /* BZ #11589 .*/
6167   TEST_ff_f (jn, 2, 2.4048255576957729L, 0.43175480701968038399746111312430703L);
6168   TEST_ff_f (jn, 3, 2.4048255576957729L, 0.19899990535769083404042146764530813L);
6169   TEST_ff_f (jn, 4, 2.4048255576957729L, 0.647466661641779720084932282551219891E-1L);
6170   TEST_ff_f (jn, 5, 2.4048255576957729L, 0.163892432048058525099230549946147698E-1L);
6171   TEST_ff_f (jn, 6, 2.4048255576957729L, 0.34048184720278336646673682895929161E-2L);
6172   TEST_ff_f (jn, 7, 2.4048255576957729L, 0.60068836573295394221291569249883076E-3L);
6173   TEST_ff_f (jn, 8, 2.4048255576957729L, 0.92165786705344923232879022467054148E-4L);
6174   TEST_ff_f (jn, 9, 2.4048255576957729L, 0.12517270977961513005428966643852564E-4L);
6175
6176   /* Bug 14155: spurious exception may occur.  */
6177   TEST_ff_f (jn, 2, 0x1.ffff62p+99L, -4.43860668048170034334926693188979974489e-16L, UNDERFLOW_EXCEPTION_OK);
6178
6179   END (jn);
6180 }
6181
6182
6183 static void
6184 ldexp_test (void)
6185 {
6186   TEST_ff_f (ldexp, 0, 0, 0);
6187   TEST_ff_f (ldexp, minus_zero, 0, minus_zero);
6188
6189   TEST_ff_f (ldexp, plus_infty, 1, plus_infty);
6190   TEST_ff_f (ldexp, minus_infty, 1, minus_infty);
6191   TEST_ff_f (ldexp, nan_value, 1, nan_value);
6192
6193   TEST_ff_f (ldexp, 0.8L, 4, 12.8L);
6194   TEST_ff_f (ldexp, -0.854375L, 5, -27.34L);
6195
6196   /* ldexp (x, 0) == x.  */
6197   TEST_ff_f (ldexp, 1.0L, 0L, 1.0L);
6198 }
6199
6200
6201 static void
6202 lgamma_test (void)
6203 {
6204   errno = 0;
6205   FUNC(lgamma) (0);
6206   if (errno == ENOSYS)
6207     /* Function not implemented.  */
6208     return;
6209
6210   START (lgamma);
6211
6212   TEST_f_f (lgamma, plus_infty, plus_infty);
6213   TEST_f_f (lgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6214   check_int ("signgam for lgamma(0) == 1", signgam, 1, 0, 0, 0);
6215   TEST_f_f (lgamma, minus_zero, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6216   check_int ("signgam for lgamma(-0) == -1", signgam, -1, 0, 0, 0);
6217   TEST_f_f (lgamma, nan_value, nan_value);
6218
6219   /* lgamma (x) == +inf plus divide by zero exception for integer x <= 0.  */
6220   errno = 0;
6221   TEST_f_f (lgamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6222   check_int ("errno for lgamma(-integer) == ERANGE", errno, ERANGE, 0, 0, 0);
6223   TEST_f_f (lgamma, minus_infty, plus_infty);
6224   TEST_f_f (lgamma, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6225   TEST_f_f (lgamma, max_value, plus_infty, OVERFLOW_EXCEPTION);
6226
6227   TEST_f_f1 (lgamma, 1, 0, 1);
6228
6229   TEST_f_f1 (lgamma, 3, M_LN2l, 1);
6230
6231   TEST_f_f1 (lgamma, 0.5, M_LOG_SQRT_PIl, 1);
6232   TEST_f_f1 (lgamma, -0.5, M_LOG_2_SQRT_PIl, -1);
6233   TEST_f_f1 (lgamma, 0.7L, 0.260867246531666514385732417016759578L, 1);
6234   TEST_f_f1 (lgamma, 1.2L, -0.853740900033158497197028392998854470e-1L, 1);
6235
6236   END (lgamma);
6237 }
6238
6239
6240 static void
6241 lrint_test (void)
6242 {
6243   /* XXX this test is incomplete.  We need to have a way to specifiy
6244      the rounding method and test the critical cases.  So far, only
6245      unproblematic numbers are tested.  */
6246
6247   START (lrint);
6248
6249   TEST_f_l (lrint, 0.0, 0);
6250   TEST_f_l (lrint, minus_zero, 0);
6251   TEST_f_l (lrint, 0.2L, 0);
6252   TEST_f_l (lrint, -0.2L, 0);
6253
6254   TEST_f_l (lrint, 1.4L, 1);
6255   TEST_f_l (lrint, -1.4L, -1);
6256
6257   TEST_f_l (lrint, 8388600.3L, 8388600);
6258   TEST_f_l (lrint, -8388600.3L, -8388600);
6259
6260   TEST_f_l (lrint, 1071930.0008, 1071930);
6261 #ifndef TEST_FLOAT
6262   TEST_f_l (lrint, 1073741824.01, 1073741824);
6263 # if LONG_MAX > 281474976710656
6264   TEST_f_l (lrint, 281474976710656.025, 281474976710656);
6265 # endif
6266 #endif
6267
6268   END (lrint);
6269 }
6270
6271
6272 static void
6273 lrint_test_tonearest (void)
6274 {
6275   int save_round_mode;
6276   START (lrint_tonearest);
6277
6278   save_round_mode = fegetround ();
6279
6280   if (!fesetround (FE_TONEAREST))
6281     {
6282       TEST_f_l (lrint, 0.0, 0);
6283       TEST_f_l (lrint, minus_zero, 0);
6284       TEST_f_l (lrint, 0.2L, 0);
6285       TEST_f_l (lrint, -0.2L, 0);
6286       TEST_f_l (lrint, 0.5L, 0);
6287       TEST_f_l (lrint, -0.5L, 0);
6288       TEST_f_l (lrint, 0.8L, 1);
6289       TEST_f_l (lrint, -0.8L, -1);
6290
6291       TEST_f_l (lrint, 1.4L, 1);
6292       TEST_f_l (lrint, -1.4L, -1);
6293
6294       TEST_f_l (lrint, 8388600.3L, 8388600);
6295       TEST_f_l (lrint, -8388600.3L, -8388600);
6296
6297       TEST_f_l (lrint, 1071930.0008, 1071930);
6298 #ifndef TEST_FLOAT
6299       TEST_f_l (lrint, 1073741824.01, 1073741824);
6300 # if LONG_MAX > 281474976710656
6301       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
6302 # endif
6303 #endif
6304     }
6305
6306   fesetround (save_round_mode);
6307
6308   END (lrint_tonearest);
6309 }
6310
6311
6312 static void
6313 lrint_test_towardzero (void)
6314 {
6315   int save_round_mode;
6316   START (lrint_towardzero);
6317
6318   save_round_mode = fegetround ();
6319
6320   if (!fesetround (FE_TOWARDZERO))
6321     {
6322       TEST_f_l (lrint, 0.0, 0);
6323       TEST_f_l (lrint, minus_zero, 0);
6324       TEST_f_l (lrint, 0.2L, 0);
6325       TEST_f_l (lrint, -0.2L, 0);
6326       TEST_f_l (lrint, 0.5L, 0);
6327       TEST_f_l (lrint, -0.5L, 0);
6328       TEST_f_l (lrint, 0.8L, 0);
6329       TEST_f_l (lrint, -0.8L, 0);
6330
6331       TEST_f_l (lrint, 1.4L, 1);
6332       TEST_f_l (lrint, -1.4L, -1);
6333
6334       TEST_f_l (lrint, 8388600.3L, 8388600);
6335       TEST_f_l (lrint, -8388600.3L, -8388600);
6336
6337       TEST_f_l (lrint, 1071930.0008, 1071930);
6338 #ifndef TEST_FLOAT
6339       TEST_f_l (lrint, 1073741824.01, 1073741824);
6340 # if LONG_MAX > 281474976710656
6341       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
6342 # endif
6343 #endif
6344     }
6345
6346   fesetround (save_round_mode);
6347
6348   END (lrint_towardzero);
6349 }
6350
6351
6352 static void
6353 lrint_test_downward (void)
6354 {
6355   int save_round_mode;
6356   START (lrint_downward);
6357
6358   save_round_mode = fegetround ();
6359
6360   if (!fesetround (FE_DOWNWARD))
6361     {
6362       TEST_f_l (lrint, 0.0, 0);
6363       TEST_f_l (lrint, minus_zero, 0);
6364       TEST_f_l (lrint, 0.2L, 0);
6365       TEST_f_l (lrint, -0.2L, -1);
6366       TEST_f_l (lrint, 0.5L, 0);
6367       TEST_f_l (lrint, -0.5L, -1);
6368       TEST_f_l (lrint, 0.8L, 0);
6369       TEST_f_l (lrint, -0.8L, -1);
6370
6371       TEST_f_l (lrint, 1.4L, 1);
6372       TEST_f_l (lrint, -1.4L, -2);
6373
6374       TEST_f_l (lrint, 8388600.3L, 8388600);
6375       TEST_f_l (lrint, -8388600.3L, -8388601);
6376
6377       TEST_f_l (lrint, 1071930.0008, 1071930);
6378 #ifndef TEST_FLOAT
6379       TEST_f_l (lrint, 1073741824.01, 1073741824);
6380 # if LONG_MAX > 281474976710656
6381       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
6382 # endif
6383 #endif
6384     }
6385
6386   fesetround (save_round_mode);
6387
6388   END (lrint_downward);
6389 }
6390
6391
6392 static void
6393 lrint_test_upward (void)
6394 {
6395   int save_round_mode;
6396   START (lrint_upward);
6397
6398   save_round_mode = fegetround ();
6399
6400   if (!fesetround (FE_UPWARD))
6401     {
6402       TEST_f_l (lrint, 0.0, 0);
6403       TEST_f_l (lrint, minus_zero, 0);
6404       TEST_f_l (lrint, 0.2L, 1);
6405       TEST_f_l (lrint, -0.2L, 0);
6406       TEST_f_l (lrint, 0.5L, 1);
6407       TEST_f_l (lrint, -0.5L, 0);
6408       TEST_f_l (lrint, 0.8L, 1);
6409       TEST_f_l (lrint, -0.8L, 0);
6410
6411       TEST_f_l (lrint, 1.4L, 2);
6412       TEST_f_l (lrint, -1.4L, -1);
6413
6414       TEST_f_l (lrint, 8388600.3L, 8388601);
6415       TEST_f_l (lrint, -8388600.3L, -8388600);
6416
6417 #ifndef TEST_FLOAT
6418       TEST_f_l (lrint, 1071930.0008, 1071931);
6419       TEST_f_l (lrint, 1073741824.01, 1073741825);
6420 # if LONG_MAX > 281474976710656 && defined (TEST_LDOUBLE)
6421       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
6422 # endif
6423 #endif
6424     }
6425
6426   fesetround (save_round_mode);
6427
6428   END (lrint_upward);
6429 }
6430
6431
6432 static void
6433 llrint_test (void)
6434 {
6435   /* XXX this test is incomplete.  We need to have a way to specifiy
6436      the rounding method and test the critical cases.  So far, only
6437      unproblematic numbers are tested.  */
6438
6439   START (llrint);
6440
6441   TEST_f_L (llrint, 0.0, 0);
6442   TEST_f_L (llrint, minus_zero, 0);
6443   TEST_f_L (llrint, 0.2L, 0);
6444   TEST_f_L (llrint, -0.2L, 0);
6445
6446   TEST_f_L (llrint, 1.4L, 1);
6447   TEST_f_L (llrint, -1.4L, -1);
6448
6449   TEST_f_L (llrint, 8388600.3L, 8388600);
6450   TEST_f_L (llrint, -8388600.3L, -8388600);
6451
6452   TEST_f_l (llrint, 1071930.0008, 1071930);
6453
6454   /* Test boundary conditions.  */
6455   /* 0x1FFFFF */
6456   TEST_f_L (llrint, 2097151.0,2097151LL);
6457   /* 0x800000 */
6458   TEST_f_L (llrint, 8388608.0, 8388608LL);
6459   /* 0x1000000 */
6460   TEST_f_L (llrint, 16777216.0, 16777216LL);
6461   /* 0x20000000000 */
6462   TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
6463   /* 0x40000000000 */
6464   TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
6465   /* 0x1000000000000 */
6466   TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
6467   /* 0x10000000000000 */
6468   TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
6469   /* 0x10000080000000 */
6470   TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
6471   /* 0x20000000000000 */
6472   TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
6473   /* 0x80000000000000 */
6474   TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
6475   /* 0x100000000000000 */
6476   TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
6477 #ifdef TEST_LDOUBLE
6478   /* The input can only be represented in long double.  */
6479   TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
6480   TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
6481   TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
6482   TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
6483   TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
6484
6485   TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
6486   TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
6487   TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
6488   TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
6489   TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
6490
6491 # if LDBL_MANT_DIG > 100
6492   TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
6493   TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
6494   TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
6495   TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
6496   TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
6497   TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
6498
6499   TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
6500   TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
6501   TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
6502   TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
6503   TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
6504   TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
6505 #endif
6506
6507   TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
6508   TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
6509   TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
6510   TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
6511   TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
6512
6513   TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
6514   TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
6515   TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
6516   TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
6517   TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
6518
6519 # if LDBL_MANT_DIG > 100
6520   TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
6521   TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
6522   TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
6523   TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
6524   TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
6525   TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
6526
6527   TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
6528   TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
6529   TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
6530   TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
6531   TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
6532   TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
6533 #endif
6534
6535   TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
6536   TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
6537   TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
6538   TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
6539   TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
6540
6541   TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
6542   TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
6543   TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
6544   TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
6545   TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
6546
6547 # if LDBL_MANT_DIG > 100
6548   TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
6549   TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
6550   TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
6551   TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
6552   TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
6553   TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
6554   TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
6555   TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
6556   TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
6557   TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
6558   TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
6559   TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
6560 # endif
6561 #endif
6562
6563   END (llrint);
6564 }
6565
6566 static void
6567 llrint_test_tonearest (void)
6568 {
6569   int save_round_mode;
6570   START (llrint_tonearest);
6571
6572   save_round_mode = fegetround ();
6573
6574   if (!fesetround (FE_TONEAREST))
6575     {
6576       TEST_f_L (llrint, 0.0, 0);
6577       TEST_f_L (llrint, minus_zero, 0);
6578       TEST_f_L (llrint, 0.2L, 0);
6579       TEST_f_L (llrint, -0.2L, 0);
6580
6581       TEST_f_L (llrint, 1.4L, 1);
6582       TEST_f_L (llrint, -1.4L, -1);
6583
6584       TEST_f_L (llrint, 8388600.3L, 8388600);
6585       TEST_f_L (llrint, -8388600.3L, -8388600);
6586
6587       TEST_f_l (llrint, 1071930.0008, 1071930);
6588
6589       /* Test boundary conditions.  */
6590       /* 0x1FFFFF */
6591       TEST_f_L (llrint, 2097151.0,2097151LL);
6592       /* 0x800000 */
6593       TEST_f_L (llrint, 8388608.0, 8388608LL);
6594       /* 0x1000000 */
6595       TEST_f_L (llrint, 16777216.0, 16777216LL);
6596       /* 0x20000000000 */
6597       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
6598       /* 0x40000000000 */
6599       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
6600       /* 0x1000000000000 */
6601       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
6602       /* 0x10000000000000 */
6603       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
6604       /* 0x10000080000000 */
6605       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
6606       /* 0x20000000000000 */
6607       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
6608       /* 0x80000000000000 */
6609       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
6610       /* 0x100000000000000 */
6611       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
6612 #ifdef TEST_LDOUBLE
6613       /* The input can only be represented in long double.  */
6614       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
6615       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
6616       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
6617       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
6618       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
6619
6620       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
6621       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
6622       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
6623       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
6624       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
6625
6626 # if LDBL_MANT_DIG > 100
6627       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
6628       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
6629       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
6630       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
6631       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
6632       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
6633
6634       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
6635       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
6636       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
6637       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
6638       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
6639       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
6640 #endif
6641
6642       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
6643       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
6644       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
6645       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
6646       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
6647
6648       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
6649       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
6650       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
6651       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
6652       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
6653
6654 # if LDBL_MANT_DIG > 100
6655       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
6656       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
6657       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
6658       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
6659       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
6660       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
6661
6662       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
6663       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
6664       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
6665       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
6666       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
6667       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
6668 #endif
6669
6670       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
6671       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
6672       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
6673       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
6674       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
6675
6676       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
6677       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
6678       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
6679       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
6680       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
6681
6682 # if LDBL_MANT_DIG > 100
6683       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
6684       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
6685       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
6686       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
6687       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
6688       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
6689       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
6690       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
6691       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
6692       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
6693       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
6694       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
6695 # endif
6696 #endif
6697     }
6698
6699   fesetround (save_round_mode);
6700
6701   END (llrint_tonearest);
6702 }
6703
6704 static void
6705 llrint_test_towardzero (void)
6706 {
6707   int save_round_mode;
6708   START (llrint_towardzero);
6709
6710   save_round_mode = fegetround ();
6711
6712   if (!fesetround (FE_TOWARDZERO))
6713     {
6714       TEST_f_L (llrint, 0.0, 0);
6715       TEST_f_L (llrint, minus_zero, 0);
6716       TEST_f_L (llrint, 0.2L, 0);
6717       TEST_f_L (llrint, -0.2L, 0);
6718
6719       TEST_f_L (llrint, 1.4L, 1);
6720       TEST_f_L (llrint, -1.4L, -1);
6721
6722       TEST_f_L (llrint, 8388600.3L, 8388600);
6723       TEST_f_L (llrint, -8388600.3L, -8388600);
6724
6725       TEST_f_l (llrint, 1071930.0008, 1071930);
6726
6727       /* Test boundary conditions.  */
6728       /* 0x1FFFFF */
6729       TEST_f_L (llrint, 2097151.0,2097151LL);
6730       /* 0x800000 */
6731       TEST_f_L (llrint, 8388608.0, 8388608LL);
6732       /* 0x1000000 */
6733       TEST_f_L (llrint, 16777216.0, 16777216LL);
6734       /* 0x20000000000 */
6735       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
6736       /* 0x40000000000 */
6737       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
6738       /* 0x1000000000000 */
6739       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
6740       /* 0x10000000000000 */
6741       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
6742       /* 0x10000080000000 */
6743       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
6744       /* 0x20000000000000 */
6745       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
6746       /* 0x80000000000000 */
6747       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
6748       /* 0x100000000000000 */
6749       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
6750 #ifdef TEST_LDOUBLE
6751       /* The input can only be represented in long double.  */
6752       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370495LL);
6753       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
6754       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
6755       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370496LL);
6756       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370497LL);
6757
6758       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370495LL);
6759       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
6760       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
6761       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370496LL);
6762       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370497LL);
6763
6764 # if LDBL_MANT_DIG > 100
6765       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
6766       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
6767       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
6768       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370494LL);
6769       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370495LL);
6770       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370496LL);
6771
6772       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
6773       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
6774       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
6775       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370494LL);
6776       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370495LL);
6777       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370496LL);
6778 #endif
6779
6780       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740991LL);
6781       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
6782       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
6783       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740992LL);
6784       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740993LL);
6785
6786       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740991LL);
6787       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
6788       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
6789       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740992LL);
6790       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740993LL);
6791
6792 # if LDBL_MANT_DIG > 100
6793       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
6794       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
6795       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
6796       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740991LL);
6797       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740992LL);
6798       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740993LL);
6799
6800       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
6801       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
6802       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
6803       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740991LL);
6804       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740992LL);
6805       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740993LL);
6806 #endif
6807
6808       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927935LL);
6809       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
6810       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
6811       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927936LL);
6812       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927937LL);
6813
6814       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927935LL);
6815       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
6816       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
6817       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927936LL);
6818       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927937LL);
6819
6820 # if LDBL_MANT_DIG > 100
6821       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775805LL);
6822       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775805LL);
6823       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
6824       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
6825       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
6826       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
6827       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
6828       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
6829       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775806LL);
6830       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775806LL);
6831       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
6832       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
6833 # endif
6834 #endif
6835     }
6836
6837   fesetround (save_round_mode);
6838
6839   END (llrint_towardzero);
6840 }
6841
6842 static void
6843 llrint_test_downward (void)
6844 {
6845   int save_round_mode;
6846   START (llrint_downward);
6847
6848   save_round_mode = fegetround ();
6849
6850   if (!fesetround (FE_DOWNWARD))
6851     {
6852       TEST_f_L (llrint, 0.0, 0);
6853       TEST_f_L (llrint, minus_zero, 0);
6854       TEST_f_L (llrint, 0.2L, 0);
6855       TEST_f_L (llrint, -0.2L, -1);
6856
6857       TEST_f_L (llrint, 1.4L, 1);
6858       TEST_f_L (llrint, -1.4L, -2);
6859
6860       TEST_f_L (llrint, 8388600.3L, 8388600);
6861       TEST_f_L (llrint, -8388600.3L, -8388601);
6862
6863       TEST_f_l (llrint, 1071930.0008, 1071930);
6864
6865       /* Test boundary conditions.  */
6866       /* 0x1FFFFF */
6867       TEST_f_L (llrint, 2097151.0,2097151LL);
6868       /* 0x800000 */
6869       TEST_f_L (llrint, 8388608.0, 8388608LL);
6870       /* 0x1000000 */
6871       TEST_f_L (llrint, 16777216.0, 16777216LL);
6872       /* 0x20000000000 */
6873       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
6874       /* 0x40000000000 */
6875       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
6876       /* 0x1000000000000 */
6877       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
6878       /* 0x10000000000000 */
6879       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
6880       /* 0x10000080000000 */
6881       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
6882       /* 0x20000000000000 */
6883       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
6884       /* 0x80000000000000 */
6885       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
6886       /* 0x100000000000000 */
6887       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
6888 #ifdef TEST_LDOUBLE
6889       /* The input can only be represented in long double.  */
6890       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370495LL);
6891       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
6892       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
6893       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370496LL);
6894       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370497LL);
6895
6896       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
6897       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
6898       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
6899       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370494LL);
6900       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370495LL);
6901       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370496LL);
6902
6903       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
6904       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370497LL);
6905       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370497LL);
6906       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
6907       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
6908
6909       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370496LL);
6910       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370497LL);
6911       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370498LL);
6912       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
6913       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
6914       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
6915
6916       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740991LL);
6917       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
6918       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
6919       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740992LL);
6920       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740993LL);
6921
6922       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
6923       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
6924       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
6925       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740991LL);
6926       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740992LL);
6927       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740993LL);
6928
6929       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
6930       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740993LL);
6931       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740993LL);
6932       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
6933       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
6934
6935       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740992LL);
6936       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740993LL);
6937       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740994LL);
6938       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
6939       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
6940       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
6941
6942       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927935LL);
6943       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
6944       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
6945       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927936LL);
6946       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927937LL);
6947
6948       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
6949       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927937LL);
6950       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927937LL);
6951       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
6952       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
6953
6954 # if LDBL_MANT_DIG > 100
6955       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775805LL);
6956       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
6957       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
6958       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
6959       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
6960       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775807LL);
6961       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
6962       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775807LL);
6963       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775806LL);
6964       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
6965       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
6966       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
6967 # endif
6968 #endif
6969     }
6970
6971   fesetround (save_round_mode);
6972
6973   END (llrint_downward);
6974 }
6975
6976 static void
6977 llrint_test_upward (void)
6978 {
6979   int save_round_mode;
6980   START (llrint_upward);
6981
6982   save_round_mode = fegetround ();
6983
6984   if (!fesetround (FE_UPWARD))
6985     {
6986       TEST_f_L (llrint, 0.0, 0);
6987       TEST_f_L (llrint, minus_zero, 0);
6988       TEST_f_L (llrint, 0.2L, 1);
6989       TEST_f_L (llrint, -0.2L, 0);
6990
6991       TEST_f_L (llrint, 1.4L, 2);
6992       TEST_f_L (llrint, -1.4L, -1);
6993
6994       TEST_f_L (llrint, 8388600.3L, 8388601);
6995       TEST_f_L (llrint, -8388600.3L, -8388600);
6996 #ifndef TEST_FLOAT
6997       TEST_f_l (llrint, 1071930.0008, 1071931);
6998 #endif
6999       /* Test boundary conditions.  */
7000       /* 0x1FFFFF */
7001       TEST_f_L (llrint, 2097151.0,2097151LL);
7002       /* 0x800000 */
7003       TEST_f_L (llrint, 8388608.0, 8388608LL);
7004       /* 0x1000000 */
7005       TEST_f_L (llrint, 16777216.0, 16777216LL);
7006       /* 0x20000000000 */
7007       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
7008       /* 0x40000000000 */
7009       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
7010       /* 0x1000000000000 */
7011       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
7012       /* 0x10000000000000 */
7013       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
7014       /* 0x10000080000000 */
7015       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
7016       /* 0x20000000000000 */
7017       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
7018       /* 0x80000000000000 */
7019       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
7020       /* 0x100000000000000 */
7021       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
7022 #ifdef TEST_LDOUBLE
7023       /* The input can only be represented in long double.  */
7024       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
7025       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370497LL);
7026       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370497LL);
7027       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
7028       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
7029
7030       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370496LL);
7031       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370497LL);
7032       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370498LL);
7033       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
7034       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
7035       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
7036
7037       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370495LL);
7038       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
7039       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
7040       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370496LL);
7041       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370497LL);
7042
7043       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
7044       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
7045       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
7046       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370494LL);
7047       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370495LL);
7048       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370496LL);
7049
7050       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
7051       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740993LL);
7052       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740993LL);
7053       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
7054       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
7055
7056       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740992LL);
7057       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740993LL);
7058       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740994LL);
7059       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
7060       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
7061       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
7062
7063       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740991LL);
7064       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
7065       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
7066       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740992LL);
7067       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740993LL);
7068
7069       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
7070       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
7071       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
7072       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740991LL);
7073       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740992LL);
7074       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740993LL);
7075
7076       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
7077       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927937LL);
7078       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927937LL);
7079       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
7080       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
7081
7082       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927935LL);
7083       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
7084       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
7085       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927936LL);
7086       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927937LL);
7087
7088 # if LDBL_MANT_DIG > 100
7089       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
7090       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775805LL);
7091       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
7092       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
7093       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775807LL);
7094       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
7095       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775807L);
7096       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
7097       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
7098       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775806LL);
7099       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
7100       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
7101 # endif
7102 #endif
7103     }
7104
7105   fesetround (save_round_mode);
7106
7107   END (llrint_upward);
7108 }
7109
7110
7111 static void
7112 log_test (void)
7113 {
7114   errno = 0;
7115   FUNC(log) (1);
7116   if (errno == ENOSYS)
7117     /* Function not implemented.  */
7118     return;
7119   START (log);
7120
7121   TEST_f_f (log, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7122   TEST_f_f (log, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7123
7124   TEST_f_f (log, 1, 0);
7125
7126   TEST_f_f (log, -1, nan_value, INVALID_EXCEPTION);
7127   TEST_f_f (log, -max_value, nan_value, INVALID_EXCEPTION);
7128   TEST_f_f (log, minus_infty, nan_value, INVALID_EXCEPTION);
7129   TEST_f_f (log, plus_infty, plus_infty);
7130   TEST_f_f (log, nan_value, nan_value);
7131
7132   TEST_f_f (log, M_El, 1);
7133   TEST_f_f (log, 1.0 / M_El, -1);
7134   TEST_f_f (log, 2, M_LN2l);
7135   TEST_f_f (log, 10, M_LN10l);
7136   TEST_f_f (log, 0.75L, -0.287682072451780927439219005993827432L);
7137
7138   END (log);
7139 }
7140
7141
7142 static void
7143 log10_test (void)
7144 {
7145   errno = 0;
7146   FUNC(log10) (1);
7147   if (errno == ENOSYS)
7148     /* Function not implemented.  */
7149     return;
7150
7151   START (log10);
7152
7153   TEST_f_f (log10, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7154   TEST_f_f (log10, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7155
7156   TEST_f_f (log10, 1, 0);
7157
7158   /* log10 (x) == NaN plus invalid exception if x < 0.  */
7159   TEST_f_f (log10, -1, nan_value, INVALID_EXCEPTION);
7160   TEST_f_f (log10, -max_value, nan_value, INVALID_EXCEPTION);
7161   TEST_f_f (log10, minus_infty, nan_value, INVALID_EXCEPTION);
7162
7163   TEST_f_f (log10, plus_infty, plus_infty);
7164   TEST_f_f (log10, nan_value, nan_value);
7165
7166   TEST_f_f (log10, 0.1L, -1);
7167   TEST_f_f (log10, 10.0, 1);
7168   TEST_f_f (log10, 100.0, 2);
7169   TEST_f_f (log10, 10000.0, 4);
7170   TEST_f_f (log10, M_El, M_LOG10El);
7171   TEST_f_f (log10, 0.75L, -0.124938736608299953132449886193870744L);
7172
7173   END (log10);
7174 }
7175
7176
7177 static void
7178 log1p_test (void)
7179 {
7180   errno = 0;
7181   FUNC(log1p) (0);
7182   if (errno == ENOSYS)
7183     /* Function not implemented.  */
7184     return;
7185
7186   START (log1p);
7187
7188   TEST_f_f (log1p, 0, 0);
7189   TEST_f_f (log1p, minus_zero, minus_zero);
7190
7191   TEST_f_f (log1p, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7192   TEST_f_f (log1p, -2, nan_value, INVALID_EXCEPTION);
7193   TEST_f_f (log1p, -max_value, nan_value, INVALID_EXCEPTION);
7194   TEST_f_f (log1p, minus_infty, nan_value, INVALID_EXCEPTION);
7195
7196   TEST_f_f (log1p, plus_infty, plus_infty);
7197   TEST_f_f (log1p, nan_value, nan_value);
7198
7199   TEST_f_f (log1p, M_El - 1.0, 1);
7200
7201   TEST_f_f (log1p, -0.25L, -0.287682072451780927439219005993827432L);
7202   TEST_f_f (log1p, -0.875, -2.07944154167983592825169636437452970L);
7203
7204   END (log1p);
7205 }
7206
7207
7208 static void
7209 log2_test (void)
7210 {
7211   errno = 0;
7212   FUNC(log2) (1);
7213   if (errno == ENOSYS)
7214     /* Function not implemented.  */
7215     return;
7216
7217   START (log2);
7218
7219   TEST_f_f (log2, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7220   TEST_f_f (log2, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7221
7222   TEST_f_f (log2, 1, 0);
7223
7224   TEST_f_f (log2, -1, nan_value, INVALID_EXCEPTION);
7225   TEST_f_f (log2, -max_value, nan_value, INVALID_EXCEPTION);
7226   TEST_f_f (log2, minus_infty, nan_value, INVALID_EXCEPTION);
7227
7228   TEST_f_f (log2, plus_infty, plus_infty);
7229   TEST_f_f (log2, nan_value, nan_value);
7230
7231   TEST_f_f (log2, M_El, M_LOG2El);
7232   TEST_f_f (log2, 2.0, 1);
7233   TEST_f_f (log2, 16.0, 4);
7234   TEST_f_f (log2, 256.0, 8);
7235   TEST_f_f (log2, 0.75L, -.415037499278843818546261056052183492L);
7236
7237   END (log2);
7238 }
7239
7240
7241 static void
7242 logb_test (void)
7243 {
7244   START (logb);
7245
7246   TEST_f_f (logb, plus_infty, plus_infty);
7247   TEST_f_f (logb, minus_infty, plus_infty);
7248
7249   TEST_f_f (logb, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7250
7251   TEST_f_f (logb, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7252   TEST_f_f (logb, nan_value, nan_value);
7253
7254   TEST_f_f (logb, 1, 0);
7255   TEST_f_f (logb, M_El, 1);
7256   TEST_f_f (logb, 1024, 10);
7257   TEST_f_f (logb, -2000, 10);
7258
7259   TEST_f_f (logb, 0x0.1p-127, -131);
7260   TEST_f_f (logb, 0x0.01p-127, -135);
7261   TEST_f_f (logb, 0x0.011p-127, -135);
7262 #ifndef TEST_FLOAT
7263   TEST_f_f (logb, 0x0.8p-1022, -1023);
7264   TEST_f_f (logb, 0x0.1p-1022, -1026);
7265   TEST_f_f (logb, 0x0.00111p-1022, -1034);
7266   TEST_f_f (logb, 0x0.00001p-1022, -1042);
7267   TEST_f_f (logb, 0x0.000011p-1022, -1042);
7268   TEST_f_f (logb, 0x0.0000000000001p-1022, -1074);
7269 #endif
7270 #if defined TEST_LDOUBLE && LDBL_MIN_EXP - LDBL_MANT_DIG <= -16400
7271   TEST_f_f (logb, 0x1p-16400L, -16400);
7272   TEST_f_f (logb, 0x.00000000001p-16382L, -16426);
7273 #endif
7274
7275   END (logb);
7276 }
7277
7278 static void
7279 logb_test_downward (void)
7280 {
7281   int save_round_mode;
7282   errno = 0;
7283
7284   FUNC(logb) (0);
7285   if (errno == ENOSYS)
7286     /* Function not implemented.  */
7287     return;
7288
7289   START (logb_downward);
7290
7291   save_round_mode = fegetround ();
7292
7293   if (!fesetround (FE_DOWNWARD))
7294     {
7295
7296       /* IEEE 754-2008 says (section 5.3.3) that "logB(1) is +0.".  Libm
7297          should not return -0 from logb in any rounding mode.  PowerPC32 has
7298          failed with this test for power4 logb (and logbl on all PowerPC
7299          platforms) in the past due to instruction selection.  GCC PR 52775
7300          provides the availability of the fcfid insn in 32-bit mode which
7301          eliminates the use of fsub in this instance and prevents the negative
7302          signed 0.0.  */
7303
7304       /* BZ #887  */
7305       TEST_f_f (logb, 1.000e+0, plus_zero);
7306     }
7307
7308   fesetround (save_round_mode);
7309
7310   END (logb_downward);
7311 }
7312
7313 static void
7314 lround_test (void)
7315 {
7316   START (lround);
7317
7318   TEST_f_l (lround, 0, 0);
7319   TEST_f_l (lround, minus_zero, 0);
7320   TEST_f_l (lround, 0.2L, 0.0);
7321   TEST_f_l (lround, -0.2L, 0);
7322   TEST_f_l (lround, 0.5, 1);
7323   TEST_f_l (lround, -0.5, -1);
7324   TEST_f_l (lround, 0.8L, 1);
7325   TEST_f_l (lround, -0.8L, -1);
7326   TEST_f_l (lround, 1.5, 2);
7327   TEST_f_l (lround, -1.5, -2);
7328   TEST_f_l (lround, 22514.5, 22515);
7329   TEST_f_l (lround, -22514.5, -22515);
7330   TEST_f_l (lround, 1071930.0008, 1071930);
7331 #ifndef TEST_FLOAT
7332   TEST_f_l (lround, 1073741824.01, 1073741824);
7333 # if LONG_MAX > 281474976710656
7334   TEST_f_l (lround, 281474976710656.025, 281474976710656);
7335   TEST_f_l (lround, 18014398509481974, 18014398509481974);
7336 # endif
7337   TEST_f_l (lround, 2097152.5, 2097153);
7338   TEST_f_l (lround, -2097152.5, -2097153);
7339   /* nextafter(0.5,-1)  */
7340   TEST_f_l (lround, 0x1.fffffffffffffp-2, 0);
7341   /* nextafter(-0.5,1)  */
7342   TEST_f_l (lround, -0x1.fffffffffffffp-2, 0);
7343 #else
7344   /* nextafter(0.5,-1)  */
7345   TEST_f_l (lround, 0x1.fffffp-2, 0);
7346   /* nextafter(-0.5,1)  */
7347   TEST_f_l (lround, -0x1.fffffp-2, 0);
7348   TEST_f_l (lround, 0x1.fffffep+23, 16777215);
7349   TEST_f_l (lround, -0x1.fffffep+23, -16777215);
7350 #endif
7351   END (lround);
7352 }
7353
7354
7355 static void
7356 llround_test (void)
7357 {
7358   START (llround);
7359
7360   TEST_f_L (llround, 0, 0);
7361   TEST_f_L (llround, minus_zero, 0);
7362   TEST_f_L (llround, 0.2L, 0.0);
7363   TEST_f_L (llround, -0.2L, 0);
7364   TEST_f_L (llround, 0.5, 1);
7365   TEST_f_L (llround, -0.5, -1);
7366   TEST_f_L (llround, 0.8L, 1);
7367   TEST_f_L (llround, -0.8L, -1);
7368   TEST_f_L (llround, 1.5, 2);
7369   TEST_f_L (llround, -1.5, -2);
7370   TEST_f_L (llround, 22514.5, 22515);
7371   TEST_f_L (llround, -22514.5, -22515);
7372   TEST_f_l (llround, 1071930.0008, 1071930);
7373 #ifndef TEST_FLOAT
7374   TEST_f_L (llround, 2097152.5, 2097153);
7375   TEST_f_L (llround, -2097152.5, -2097153);
7376   TEST_f_L (llround, 34359738368.5, 34359738369ll);
7377   TEST_f_L (llround, -34359738368.5, -34359738369ll);
7378   TEST_f_L (llround, -3.65309740835E17, -365309740835000000LL);
7379 #endif
7380
7381   /* Test boundary conditions.  */
7382   /* 0x1FFFFF */
7383   TEST_f_L (llround, 2097151.0, 2097151LL);
7384   /* 0x800000 */
7385   TEST_f_L (llround, 8388608.0, 8388608LL);
7386   /* 0x1000000 */
7387   TEST_f_L (llround, 16777216.0, 16777216LL);
7388   /* 0x20000000000 */
7389   TEST_f_L (llround, 2199023255552.0, 2199023255552LL);
7390   /* 0x40000000000 */
7391   TEST_f_L (llround, 4398046511104.0, 4398046511104LL);
7392   /* 0x1000000000000 */
7393   TEST_f_L (llround, 281474976710656.0, 281474976710656LL);
7394   /* 0x10000000000000 */
7395   TEST_f_L (llround, 4503599627370496.0, 4503599627370496LL);
7396   /* 0x10000080000000 */
7397   TEST_f_L (llround, 4503601774854144.0, 4503601774854144LL);
7398   /* 0x20000000000000 */
7399   TEST_f_L (llround, 9007199254740992.0, 9007199254740992LL);
7400   /* 0x80000000000000 */
7401   TEST_f_L (llround, 36028797018963968.0, 36028797018963968LL);
7402   /* 0x100000000000000 */
7403   TEST_f_L (llround, 72057594037927936.0, 72057594037927936LL);
7404
7405 #ifndef TEST_FLOAT
7406   /* 0x100000000 */
7407   TEST_f_L (llround, 4294967295.5, 4294967296LL);
7408   /* 0x200000000 */
7409   TEST_f_L (llround, 8589934591.5, 8589934592LL);
7410
7411   /* nextafter(0.5,-1)  */
7412   TEST_f_L (llround, 0x1.fffffffffffffp-2, 0);
7413   /* nextafter(-0.5,1)  */
7414   TEST_f_L (llround, -0x1.fffffffffffffp-2, 0);
7415   /* On PowerPC an exponent of '52' is the largest incrementally
7416    * representable sequence of whole-numbers in the 'double' range.  We test
7417    * lround to make sure that a guard bit set during the lround operation
7418    * hasn't forced an erroneous shift giving us an incorrect result.  The odd
7419    * numbers between +-(2^52+1 and 2^53-1) are affected since they have the
7420    * rightmost bit set.  */
7421   /* +-(2^52+1)  */
7422   TEST_f_L (llround, 0x1.0000000000001p+52,4503599627370497LL);
7423   TEST_f_L (llround, -0x1.0000000000001p+52,-4503599627370497LL);
7424   /* +-(2^53-1): Input is the last (positive and negative) incrementally
7425    * representable whole-number in the 'double' range that might round
7426    * erroneously.  */
7427   TEST_f_L (llround, 0x1.fffffffffffffp+52, 9007199254740991LL);
7428   TEST_f_L (llround, -0x1.fffffffffffffp+52, -9007199254740991LL);
7429 #else
7430   /* nextafter(0.5,-1)  */
7431   TEST_f_L (llround, 0x1.fffffep-2, 0);
7432   /* nextafter(-0.5,1)  */
7433   TEST_f_L (llround, -0x1.fffffep-2, 0);
7434   /* As above, on PowerPC an exponent of '23' is the largest incrementally
7435    * representable sequence of whole-numbers in the 'float' range.
7436    * Likewise, numbers between +-(2^23+1 and 2^24-1) are affected.  */
7437   TEST_f_L (llround, 0x1.000002p+23,8388609);
7438   TEST_f_L (llround, -0x1.000002p+23,-8388609);
7439   TEST_f_L (llround, 0x1.fffffep+23, 16777215);
7440   TEST_f_L (llround, -0x1.fffffep+23, -16777215);
7441 #endif
7442
7443
7444 #ifdef TEST_LDOUBLE
7445   /* The input can only be represented in long double.  */
7446   TEST_f_L (llround, 4503599627370495.5L, 4503599627370496LL);
7447   TEST_f_L (llround, 4503599627370496.25L, 4503599627370496LL);
7448   TEST_f_L (llround, 4503599627370496.5L, 4503599627370497LL);
7449   TEST_f_L (llround, 4503599627370496.75L, 4503599627370497LL);
7450   TEST_f_L (llround, 4503599627370497.5L, 4503599627370498LL);
7451
7452 # if LDBL_MANT_DIG > 100
7453   TEST_f_L (llround, 4503599627370495.4999999999999L, 4503599627370495LL);
7454   TEST_f_L (llround, 4503599627370496.4999999999999L, 4503599627370496LL);
7455   TEST_f_L (llround, 4503599627370497.4999999999999L, 4503599627370497LL);
7456   TEST_f_L (llround, 4503599627370494.5000000000001L, 4503599627370495LL);
7457   TEST_f_L (llround, 4503599627370495.5000000000001L, 4503599627370496LL);
7458   TEST_f_L (llround, 4503599627370496.5000000000001L, 4503599627370497LL);
7459
7460   TEST_f_L (llround, -4503599627370495.4999999999999L, -4503599627370495LL);
7461   TEST_f_L (llround, -4503599627370496.4999999999999L, -4503599627370496LL);
7462   TEST_f_L (llround, -4503599627370497.4999999999999L, -4503599627370497LL);
7463   TEST_f_L (llround, -4503599627370494.5000000000001L, -4503599627370495LL);
7464   TEST_f_L (llround, -4503599627370495.5000000000001L, -4503599627370496LL);
7465   TEST_f_L (llround, -4503599627370496.5000000000001L, -4503599627370497LL);
7466 # endif
7467
7468   TEST_f_L (llround, -4503599627370495.5L, -4503599627370496LL);
7469   TEST_f_L (llround, -4503599627370496.25L, -4503599627370496LL);
7470   TEST_f_L (llround, -4503599627370496.5L, -4503599627370497LL);
7471   TEST_f_L (llround, -4503599627370496.75L, -4503599627370497LL);
7472   TEST_f_L (llround, -4503599627370497.5L, -4503599627370498LL);
7473
7474   TEST_f_L (llround, 9007199254740991.5L, 9007199254740992LL);
7475   TEST_f_L (llround, 9007199254740992.25L, 9007199254740992LL);
7476   TEST_f_L (llround, 9007199254740992.5L, 9007199254740993LL);
7477   TEST_f_L (llround, 9007199254740992.75L, 9007199254740993LL);
7478   TEST_f_L (llround, 9007199254740993.5L, 9007199254740994LL);
7479
7480 # if LDBL_MANT_DIG > 100
7481   TEST_f_L (llround, 9007199254740991.4999999999999L, 9007199254740991LL);
7482   TEST_f_L (llround, 9007199254740992.4999999999999L, 9007199254740992LL);
7483   TEST_f_L (llround, 9007199254740993.4999999999999L, 9007199254740993LL);
7484   TEST_f_L (llround, 9007199254740991.5000000000001L, 9007199254740992LL);
7485   TEST_f_L (llround, 9007199254740992.5000000000001L, 9007199254740993LL);
7486   TEST_f_L (llround, 9007199254740993.5000000000001L, 9007199254740994LL);
7487
7488   TEST_f_L (llround, -9007199254740991.4999999999999L, -9007199254740991LL);
7489   TEST_f_L (llround, -9007199254740992.4999999999999L, -9007199254740992LL);
7490   TEST_f_L (llround, -9007199254740993.4999999999999L, -9007199254740993LL);
7491   TEST_f_L (llround, -9007199254740991.5000000000001L, -9007199254740992LL);
7492   TEST_f_L (llround, -9007199254740992.5000000000001L, -9007199254740993LL);
7493   TEST_f_L (llround, -9007199254740993.5000000000001L, -9007199254740994LL);
7494 # endif
7495
7496   TEST_f_L (llround, -9007199254740991.5L, -9007199254740992LL);
7497   TEST_f_L (llround, -9007199254740992.25L, -9007199254740992LL);
7498   TEST_f_L (llround, -9007199254740992.5L, -9007199254740993LL);
7499   TEST_f_L (llround, -9007199254740992.75L, -9007199254740993LL);
7500   TEST_f_L (llround, -9007199254740993.5L, -9007199254740994LL);
7501
7502   TEST_f_L (llround, 72057594037927935.5L, 72057594037927936LL);
7503   TEST_f_L (llround, 72057594037927936.25L, 72057594037927936LL);
7504   TEST_f_L (llround, 72057594037927936.5L, 72057594037927937LL);
7505   TEST_f_L (llround, 72057594037927936.75L, 72057594037927937LL);
7506   TEST_f_L (llround, 72057594037927937.5L, 72057594037927938LL);
7507
7508   TEST_f_L (llround, -72057594037927935.5L, -72057594037927936LL);
7509   TEST_f_L (llround, -72057594037927936.25L, -72057594037927936LL);
7510   TEST_f_L (llround, -72057594037927936.5L, -72057594037927937LL);
7511   TEST_f_L (llround, -72057594037927936.75L, -72057594037927937LL);
7512   TEST_f_L (llround, -72057594037927937.5L, -72057594037927938LL);
7513
7514   TEST_f_L (llround, 9223372036854775806.25L, 9223372036854775806LL);
7515   TEST_f_L (llround, -9223372036854775806.25L, -9223372036854775806LL);
7516   TEST_f_L (llround, 9223372036854775806.5L, 9223372036854775807LL);
7517   TEST_f_L (llround, -9223372036854775806.5L, -9223372036854775807LL);
7518   TEST_f_L (llround, 9223372036854775807.0L, 9223372036854775807LL);
7519   TEST_f_L (llround, -9223372036854775807.0L, -9223372036854775807LL);
7520 #endif
7521
7522   END (llround);
7523 }
7524
7525 static void
7526 modf_test (void)
7527 {
7528   FLOAT x;
7529
7530   START (modf);
7531
7532   TEST_fF_f1 (modf, plus_infty, 0, plus_infty);
7533   TEST_fF_f1 (modf, minus_infty, minus_zero, minus_infty);
7534   TEST_fF_f1 (modf, nan_value, nan_value, nan_value);
7535   TEST_fF_f1 (modf, 0, 0, 0);
7536   TEST_fF_f1 (modf, 1.5, 0.5, 1);
7537   TEST_fF_f1 (modf, 2.5, 0.5, 2);
7538   TEST_fF_f1 (modf, -2.5, -0.5, -2);
7539   TEST_fF_f1 (modf, 20, 0, 20);
7540   TEST_fF_f1 (modf, 21, 0, 21);
7541   TEST_fF_f1 (modf, 89.5, 0.5, 89);
7542
7543   END (modf);
7544 }
7545
7546
7547 static void
7548 nearbyint_test (void)
7549 {
7550   START (nearbyint);
7551
7552   TEST_f_f (nearbyint, 0.0, 0.0);
7553   TEST_f_f (nearbyint, minus_zero, minus_zero);
7554   TEST_f_f (nearbyint, plus_infty, plus_infty);
7555   TEST_f_f (nearbyint, minus_infty, minus_infty);
7556   TEST_f_f (nearbyint, nan_value, nan_value);
7557
7558   /* Subnormal values */
7559   TEST_f_f (nearbyint, -8.98847e+307, -8.98847e+307);
7560   TEST_f_f (nearbyint, -4.45015e-308, minus_zero);
7561
7562   /* Default rounding mode is round to nearest.  */
7563   TEST_f_f (nearbyint, 0.5, 0.0);
7564   TEST_f_f (nearbyint, 1.5, 2.0);
7565   TEST_f_f (nearbyint, -0.5, minus_zero);
7566   TEST_f_f (nearbyint, -1.5, -2.0);
7567
7568   TEST_f_f (nearbyint, 262144.75, 262145.0);
7569   TEST_f_f (nearbyint, 262142.75, 262143.0);
7570   TEST_f_f (nearbyint, 524286.75, 524287.0);
7571   TEST_f_f (nearbyint, 524288.75, 524289.0);
7572
7573   TEST_f_f (nearbyint, 1048576.75, 1048577.0);
7574   TEST_f_f (nearbyint, 2097152.75, 2097153.0);
7575   TEST_f_f (nearbyint, 2492472.75, 2492473.0);
7576   TEST_f_f (nearbyint, 2886220.75, 2886221.0);
7577   TEST_f_f (nearbyint, 3058792.75, 3058793.0);
7578   TEST_f_f (nearbyint, -1048576.75, -1048577.0);
7579   TEST_f_f (nearbyint, -2097152.75, -2097153.0);
7580   TEST_f_f (nearbyint, -2492472.75, -2492473.0);
7581   TEST_f_f (nearbyint, -2886220.75, -2886221.0);
7582   TEST_f_f (nearbyint, -3058792.75, -3058793.0);
7583 #ifndef TEST_FLOAT
7584   TEST_f_f (nearbyint, 70368744177664.75, 70368744177665.0);
7585   TEST_f_f (nearbyint, 140737488355328.75, 140737488355329.0);
7586   TEST_f_f (nearbyint, 281474976710656.75, 281474976710657.0);
7587   TEST_f_f (nearbyint, 562949953421312.75, 562949953421313.0);
7588   TEST_f_f (nearbyint, 1125899906842624.75, 1125899906842625.0);
7589   TEST_f_f (nearbyint, -70368744177664.75, -70368744177665.0);
7590   TEST_f_f (nearbyint, -140737488355328.75, -140737488355329.0);
7591   TEST_f_f (nearbyint, -281474976710656.75, -281474976710657.0);
7592   TEST_f_f (nearbyint, -562949953421312.75, -562949953421313.0);
7593   TEST_f_f (nearbyint, -1125899906842624.75, -1125899906842625.0);
7594 #endif
7595
7596   END (nearbyint);
7597 }
7598
7599 static void
7600 nextafter_test (void)
7601 {
7602
7603   START (nextafter);
7604
7605   TEST_ff_f (nextafter, 0, 0, 0);
7606   TEST_ff_f (nextafter, minus_zero, 0, 0);
7607   TEST_ff_f (nextafter, 0, minus_zero, minus_zero);
7608   TEST_ff_f (nextafter, minus_zero, minus_zero, minus_zero);
7609
7610   TEST_ff_f (nextafter, 9, 9, 9);
7611   TEST_ff_f (nextafter, -9, -9, -9);
7612   TEST_ff_f (nextafter, plus_infty, plus_infty, plus_infty);
7613   TEST_ff_f (nextafter, minus_infty, minus_infty, minus_infty);
7614
7615   TEST_ff_f (nextafter, nan_value, 1.1L, nan_value);
7616   TEST_ff_f (nextafter, 1.1L, nan_value, nan_value);
7617   TEST_ff_f (nextafter, nan_value, nan_value, nan_value);
7618
7619   FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
7620                          LDBL_MAX, DBL_MAX, FLT_MAX);
7621   TEST_ff_f (nextafter, fltmax, plus_infty, plus_infty, OVERFLOW_EXCEPTION);
7622   TEST_ff_f (nextafter, -fltmax, minus_infty, minus_infty, OVERFLOW_EXCEPTION);
7623
7624 #ifdef TEST_LDOUBLE
7625   // XXX Enable once gcc is fixed.
7626   //TEST_ff_f (nextafter, 0x0.00000040000000000000p-16385L, -0.1L, 0x0.0000003ffffffff00000p-16385L);
7627 #endif
7628
7629   /* XXX We need the hexadecimal FP number representation here for further
7630      tests.  */
7631
7632   END (nextafter);
7633 }
7634
7635
7636 static void
7637 nexttoward_test (void)
7638 {
7639   START (nexttoward);
7640   TEST_ff_f (nexttoward, 0, 0, 0);
7641   TEST_ff_f (nexttoward, minus_zero, 0, 0);
7642   TEST_ff_f (nexttoward, 0, minus_zero, minus_zero);
7643   TEST_ff_f (nexttoward, minus_zero, minus_zero, minus_zero);
7644
7645   TEST_ff_f (nexttoward, 9, 9, 9);
7646   TEST_ff_f (nexttoward, -9, -9, -9);
7647   TEST_ff_f (nexttoward, plus_infty, plus_infty, plus_infty);
7648   TEST_ff_f (nexttoward, minus_infty, minus_infty, minus_infty);
7649
7650   TEST_ff_f (nexttoward, nan_value, 1.1L, nan_value);
7651   TEST_ff_f (nexttoward, 1.1L, nan_value, nan_value);
7652   TEST_ff_f (nexttoward, nan_value, nan_value, nan_value);
7653
7654 #ifdef TEST_FLOAT
7655   TEST_ff_f (nexttoward, 1.0, 1.1L, 0x1.000002p0);
7656   TEST_ff_f (nexttoward, 1.0, LDBL_MAX, 0x1.000002p0);
7657   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000001p0, 0x1.000002p0);
7658   TEST_ff_f (nexttoward, 1.0, 0.9L, 0x0.ffffffp0);
7659   TEST_ff_f (nexttoward, 1.0, -LDBL_MAX, 0x0.ffffffp0);
7660   TEST_ff_f (nexttoward, 1.0, 0x0.fffffffffffff8p0, 0x0.ffffffp0);
7661   TEST_ff_f (nexttoward, -1.0, -1.1L, -0x1.000002p0);
7662   TEST_ff_f (nexttoward, -1.0, -LDBL_MAX, -0x1.000002p0);
7663   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000001p0, -0x1.000002p0);
7664   TEST_ff_f (nexttoward, -1.0, -0.9L, -0x0.ffffffp0);
7665   TEST_ff_f (nexttoward, -1.0, LDBL_MAX, -0x0.ffffffp0);
7666   TEST_ff_f (nexttoward, -1.0, -0x0.fffffffffffff8p0, -0x0.ffffffp0);
7667   TEST_ff_f (nexttoward, -0x1.3p-145, -0xap-148L, -0x1.4p-145, UNDERFLOW_EXCEPTION);
7668 # if LDBL_MANT_DIG >= 64
7669   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000002p0L, 0x1.000002p0);
7670   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffp0L, 0x0.ffffffp0);
7671   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000002p0L, -0x1.000002p0);
7672   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffp0L, -0x0.ffffffp0);
7673 # endif
7674 # if LDBL_MANT_DIG >= 106
7675   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000000000000000008p0L, 0x1.000002p0);
7676   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffcp0L, 0x0.ffffffp0);
7677   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000000000000000008p0L, -0x1.000002p0);
7678   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffcp0L, -0x0.ffffffp0);
7679 # endif
7680 # if LDBL_MANT_DIG >= 113
7681   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000000000000000000001p0L, 0x1.000002p0);
7682   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffp0);
7683   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000000000000000000001p0L, -0x1.000002p0);
7684   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffp0);
7685 # endif
7686 #endif
7687 #ifdef TEST_DOUBLE
7688   TEST_ff_f (nexttoward, 1.0, 1.1L, 0x1.0000000000001p0);
7689   TEST_ff_f (nexttoward, 1.0, LDBL_MAX, 0x1.0000000000001p0);
7690   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000001p0, 0x1.0000000000001p0);
7691   TEST_ff_f (nexttoward, 1.0, 0.9L, 0x0.fffffffffffff8p0);
7692   TEST_ff_f (nexttoward, 1.0, -LDBL_MAX, 0x0.fffffffffffff8p0);
7693   TEST_ff_f (nexttoward, 1.0, 0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0);
7694   TEST_ff_f (nexttoward, -1.0, -1.1L, -0x1.0000000000001p0);
7695   TEST_ff_f (nexttoward, -1.0, -LDBL_MAX, -0x1.0000000000001p0);
7696   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000001p0, -0x1.0000000000001p0);
7697   TEST_ff_f (nexttoward, -1.0, -0.9L, -0x0.fffffffffffff8p0);
7698   TEST_ff_f (nexttoward, -1.0, LDBL_MAX, -0x0.fffffffffffff8p0);
7699   TEST_ff_f (nexttoward, -1.0, -0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0);
7700   TEST_ff_f (nexttoward, -1.0, -0x8.00346dc5d6388p-3L, -0x1.0000000000001p0);
7701   TEST_ff_f (nexttoward, 0x1p-1074, 0x1p-1073L, 0x1p-1073, UNDERFLOW_EXCEPTION);
7702 # if LDBL_MANT_DIG >= 64
7703   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000002p0L, 0x1.0000000000001p0);
7704   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffp0L, 0x0.fffffffffffff8p0);
7705   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000002p0L, -0x1.0000000000001p0);
7706   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffp0L, -0x0.fffffffffffff8p0);
7707 # endif
7708 # if LDBL_MANT_DIG >= 106
7709   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000000000000000008p0L, 0x1.0000000000001p0);
7710   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffcp0L, 0x0.fffffffffffff8p0);
7711   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000000000000000008p0L, -0x1.0000000000001p0);
7712   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffcp0L, -0x0.fffffffffffff8p0);
7713 # endif
7714 # if LDBL_MANT_DIG >= 113
7715   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000000000000000000001p0L, 0x1.0000000000001p0);
7716   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.fffffffffffff8p0);
7717   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000000000000000000001p0L, -0x1.0000000000001p0);
7718   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.fffffffffffff8p0);
7719 # endif
7720 #endif
7721
7722   END (nexttoward);
7723 }
7724
7725
7726 static void
7727 pow_test (void)
7728 {
7729
7730   errno = 0;
7731   FUNC(pow) (0, 0);
7732   if (errno == ENOSYS)
7733     /* Function not implemented.  */
7734     return;
7735
7736   START (pow);
7737
7738   TEST_ff_f (pow, 0, 0, 1);
7739   TEST_ff_f (pow, 0, minus_zero, 1);
7740   TEST_ff_f (pow, minus_zero, 0, 1);
7741   TEST_ff_f (pow, minus_zero, minus_zero, 1);
7742
7743   TEST_ff_f (pow, 10, 0, 1);
7744   TEST_ff_f (pow, 10, minus_zero, 1);
7745   TEST_ff_f (pow, -10, 0, 1);
7746   TEST_ff_f (pow, -10, minus_zero, 1);
7747
7748   TEST_ff_f (pow, nan_value, 0, 1);
7749   TEST_ff_f (pow, nan_value, minus_zero, 1);
7750
7751
7752 #ifndef TEST_INLINE
7753   TEST_ff_f (pow, 1.1L, plus_infty, plus_infty);
7754   TEST_ff_f (pow, plus_infty, plus_infty, plus_infty);
7755   TEST_ff_f (pow, -1.1L, plus_infty, plus_infty);
7756   TEST_ff_f (pow, minus_infty, plus_infty, plus_infty);
7757
7758   TEST_ff_f (pow, 0.9L, plus_infty, 0);
7759   TEST_ff_f (pow, 1e-7L, plus_infty, 0);
7760   TEST_ff_f (pow, -0.9L, plus_infty, 0);
7761   TEST_ff_f (pow, -1e-7L, plus_infty, 0);
7762
7763   TEST_ff_f (pow, 1.1L, minus_infty, 0);
7764   TEST_ff_f (pow, plus_infty, minus_infty, 0);
7765   TEST_ff_f (pow, -1.1L, minus_infty, 0);
7766   TEST_ff_f (pow, minus_infty, minus_infty, 0);
7767
7768   TEST_ff_f (pow, 0.9L, minus_infty, plus_infty);
7769   TEST_ff_f (pow, 1e-7L, minus_infty, plus_infty);
7770   TEST_ff_f (pow, -0.9L, minus_infty, plus_infty);
7771   TEST_ff_f (pow, -1e-7L, minus_infty, plus_infty);
7772
7773   TEST_ff_f (pow, plus_infty, 1e-7L, plus_infty);
7774   TEST_ff_f (pow, plus_infty, 1, plus_infty);
7775   TEST_ff_f (pow, plus_infty, 1e7L, plus_infty);
7776   TEST_ff_f (pow, plus_infty, min_subnorm_value, plus_infty);
7777
7778   TEST_ff_f (pow, plus_infty, -1e-7L, 0);
7779   TEST_ff_f (pow, plus_infty, -1, 0);
7780   TEST_ff_f (pow, plus_infty, -1e7L, 0);
7781   TEST_ff_f (pow, plus_infty, -min_subnorm_value, 0);
7782
7783   TEST_ff_f (pow, minus_infty, 1, minus_infty);
7784   TEST_ff_f (pow, minus_infty, 11, minus_infty);
7785   TEST_ff_f (pow, minus_infty, 1001, minus_infty);
7786
7787   TEST_ff_f (pow, minus_infty, 2, plus_infty);
7788   TEST_ff_f (pow, minus_infty, 12, plus_infty);
7789   TEST_ff_f (pow, minus_infty, 1002, plus_infty);
7790   TEST_ff_f (pow, minus_infty, 0.1L, plus_infty);
7791   TEST_ff_f (pow, minus_infty, 1.1L, plus_infty);
7792   TEST_ff_f (pow, minus_infty, 11.1L, plus_infty);
7793   TEST_ff_f (pow, minus_infty, 1001.1L, plus_infty);
7794   TEST_ff_f (pow, minus_infty, min_subnorm_value, plus_infty);
7795
7796   TEST_ff_f (pow, minus_infty, -1, minus_zero);
7797   TEST_ff_f (pow, minus_infty, -11, minus_zero);
7798   TEST_ff_f (pow, minus_infty, -1001, minus_zero);
7799
7800   TEST_ff_f (pow, minus_infty, -2, 0);
7801   TEST_ff_f (pow, minus_infty, -12, 0);
7802   TEST_ff_f (pow, minus_infty, -1002, 0);
7803   TEST_ff_f (pow, minus_infty, -0.1L, 0);
7804   TEST_ff_f (pow, minus_infty, -1.1L, 0);
7805   TEST_ff_f (pow, minus_infty, -11.1L, 0);
7806   TEST_ff_f (pow, minus_infty, -1001.1L, 0);
7807   TEST_ff_f (pow, minus_infty, -min_subnorm_value, 0);
7808 #endif
7809
7810   TEST_ff_f (pow, nan_value, nan_value, nan_value);
7811   TEST_ff_f (pow, 0, nan_value, nan_value);
7812   TEST_ff_f (pow, 1, nan_value, 1);
7813   TEST_ff_f (pow, -1, nan_value, nan_value);
7814   TEST_ff_f (pow, nan_value, 1, nan_value);
7815   TEST_ff_f (pow, nan_value, -1, nan_value);
7816
7817   /* pow (x, NaN) == NaN.  */
7818   TEST_ff_f (pow, 3.0, nan_value, nan_value);
7819   TEST_ff_f (pow, minus_zero, nan_value, nan_value);
7820   TEST_ff_f (pow, plus_infty, nan_value, nan_value);
7821   TEST_ff_f (pow, -3.0, nan_value, nan_value);
7822   TEST_ff_f (pow, minus_infty, nan_value, nan_value);
7823
7824   TEST_ff_f (pow, nan_value, 3.0, nan_value);
7825   TEST_ff_f (pow, nan_value, -3.0, nan_value);
7826   TEST_ff_f (pow, nan_value, plus_infty, nan_value);
7827   TEST_ff_f (pow, nan_value, minus_infty, nan_value);
7828   TEST_ff_f (pow, nan_value, 2.5, nan_value);
7829   TEST_ff_f (pow, nan_value, -2.5, nan_value);
7830   TEST_ff_f (pow, nan_value, min_subnorm_value, nan_value);
7831   TEST_ff_f (pow, nan_value, -min_subnorm_value, nan_value);
7832
7833   TEST_ff_f (pow, 1, plus_infty, 1);
7834   TEST_ff_f (pow, -1, plus_infty, 1);
7835   TEST_ff_f (pow, 1, minus_infty, 1);
7836   TEST_ff_f (pow, -1, minus_infty, 1);
7837   TEST_ff_f (pow, 1, 1, 1);
7838   TEST_ff_f (pow, 1, -1, 1);
7839   TEST_ff_f (pow, 1, 1.25, 1);
7840   TEST_ff_f (pow, 1, -1.25, 1);
7841   TEST_ff_f (pow, 1, 0x1p62L, 1);
7842   TEST_ff_f (pow, 1, 0x1p63L, 1);
7843   TEST_ff_f (pow, 1, 0x1p64L, 1);
7844   TEST_ff_f (pow, 1, 0x1p72L, 1);
7845   TEST_ff_f (pow, 1, min_subnorm_value, 1);
7846   TEST_ff_f (pow, 1, -min_subnorm_value, 1);
7847
7848   /* pow (x, +-0) == 1.  */
7849   TEST_ff_f (pow, plus_infty, 0, 1);
7850   TEST_ff_f (pow, plus_infty, minus_zero, 1);
7851   TEST_ff_f (pow, minus_infty, 0, 1);
7852   TEST_ff_f (pow, minus_infty, minus_zero, 1);
7853   TEST_ff_f (pow, 32.75L, 0, 1);
7854   TEST_ff_f (pow, 32.75L, minus_zero, 1);
7855   TEST_ff_f (pow, -32.75L, 0, 1);
7856   TEST_ff_f (pow, -32.75L, minus_zero, 1);
7857   TEST_ff_f (pow, 0x1p72L, 0, 1);
7858   TEST_ff_f (pow, 0x1p72L, minus_zero, 1);
7859   TEST_ff_f (pow, 0x1p-72L, 0, 1);
7860   TEST_ff_f (pow, 0x1p-72L, minus_zero, 1);
7861
7862   TEST_ff_f (pow, -0.1L, 1.1L, nan_value, INVALID_EXCEPTION);
7863   TEST_ff_f (pow, -0.1L, -1.1L, nan_value, INVALID_EXCEPTION);
7864   TEST_ff_f (pow, -10.1L, 1.1L, nan_value, INVALID_EXCEPTION);
7865   TEST_ff_f (pow, -10.1L, -1.1L, nan_value, INVALID_EXCEPTION);
7866   TEST_ff_f (pow, -1.01L, min_subnorm_value, nan_value, INVALID_EXCEPTION);
7867   TEST_ff_f (pow, -1.01L, -min_subnorm_value, nan_value, INVALID_EXCEPTION);
7868   TEST_ff_f (pow, -1.0L, min_subnorm_value, nan_value, INVALID_EXCEPTION);
7869   TEST_ff_f (pow, -1.0L, -min_subnorm_value, nan_value, INVALID_EXCEPTION);
7870
7871   errno = 0;
7872   TEST_ff_f (pow, 0, -1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7873   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7874   errno = 0;
7875   TEST_ff_f (pow, 0, -11, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7876   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7877   errno = 0;
7878   TEST_ff_f (pow, 0, -0xffffff, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7879   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7880 #ifndef TEST_FLOAT
7881   errno = 0;
7882   TEST_ff_f (pow, 0, -0x1.fffffffffffffp+52L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7883   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7884 #endif
7885 #ifdef TEST_LDOUBLE
7886 # if LDBL_MANT_DIG >= 64
7887   errno = 0;
7888   TEST_ff_f (pow, 0, -0x1.fffffffffffffffep+63L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7889   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7890 # endif
7891 # if LDBL_MANT_DIG >= 106
7892   errno = 0;
7893   TEST_ff_f (pow, 0, -0x1.ffffffffffffffffffffffffff8p+105L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7894   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7895 # endif
7896 # if LDBL_MANT_DIG >= 113
7897   errno = 0;
7898   TEST_ff_f (pow, 0, -0x1.ffffffffffffffffffffffffffffp+112L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7899   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7900 # endif
7901 #endif
7902   TEST_ff_f (pow, minus_zero, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7903   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7904   errno = 0;
7905   TEST_ff_f (pow, minus_zero, -11L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7906   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7907   errno = 0;
7908   TEST_ff_f (pow, minus_zero, -0xffffff, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7909   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7910   errno = 0;
7911   TEST_ff_f (pow, minus_zero, -0x1fffffe, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7912   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7913 #ifndef TEST_FLOAT
7914   errno = 0;
7915   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffp+52L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7916   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7917   errno = 0;
7918   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffp+53L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7919   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7920 #endif
7921 #ifdef TEST_LDOUBLE
7922 # if LDBL_MANT_DIG >= 64
7923   errno = 0;
7924   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffffep+63L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7925   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7926   errno = 0;
7927   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffffep+64L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7928   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7929 # endif
7930 # if LDBL_MANT_DIG >= 106
7931   errno = 0;
7932   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7933   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7934   errno = 0;
7935   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7936   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7937 # endif
7938 # if LDBL_MANT_DIG >= 113
7939   errno = 0;
7940   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7941   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7942   errno = 0;
7943   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7944   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7945 # endif
7946 #endif
7947
7948   errno = 0;
7949   TEST_ff_f (pow, 0, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7950   check_int ("errno for pow(0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7951   errno = 0;
7952   TEST_ff_f (pow, 0, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7953   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7954   errno = 0;
7955   TEST_ff_f (pow, 0, -min_subnorm_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7956   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7957   errno = 0;
7958   TEST_ff_f (pow, 0, -0x1p24, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7959   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7960   errno = 0;
7961   TEST_ff_f (pow, 0, -0x1p127, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7962   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7963   errno = 0;
7964   TEST_ff_f (pow, 0, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7965   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7966   errno = 0;
7967   TEST_ff_f (pow, minus_zero, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7968   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7969   errno = 0;
7970   TEST_ff_f (pow, minus_zero, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7971   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7972   errno = 0;
7973   TEST_ff_f (pow, minus_zero, -min_subnorm_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7974   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7975   errno = 0;
7976   TEST_ff_f (pow, minus_zero, -0x1p24, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7977   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7978   errno = 0;
7979   TEST_ff_f (pow, minus_zero, -0x1p127, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7980   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7981   errno = 0;
7982   TEST_ff_f (pow, minus_zero, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7983   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7984
7985   TEST_ff_f (pow, 0x1p72L, 0x1p72L, plus_infty, OVERFLOW_EXCEPTION);
7986   TEST_ff_f (pow, 10, -0x1p72L, 0, UNDERFLOW_EXCEPTION);
7987   TEST_ff_f (pow, max_value, max_value, plus_infty, OVERFLOW_EXCEPTION);
7988   TEST_ff_f (pow, 10, -max_value, 0, UNDERFLOW_EXCEPTION);
7989
7990   TEST_ff_f (pow, 0, 1, 0);
7991   TEST_ff_f (pow, 0, 11, 0);
7992
7993   TEST_ff_f (pow, minus_zero, 1, minus_zero);
7994   TEST_ff_f (pow, minus_zero, 11, minus_zero);
7995
7996   TEST_ff_f (pow, 0, 2, 0);
7997   TEST_ff_f (pow, 0, 11.1L, 0);
7998
7999   TEST_ff_f (pow, minus_zero, 2, 0);
8000   TEST_ff_f (pow, minus_zero, 11.1L, 0);
8001   TEST_ff_f (pow, 0, plus_infty, 0);
8002   TEST_ff_f (pow, minus_zero, plus_infty, 0);
8003   TEST_ff_f (pow, 0, minus_infty, plus_infty, DIVIDE_BY_ZERO_EXCEPTION_OK);
8004   TEST_ff_f (pow, minus_zero, minus_infty, plus_infty, DIVIDE_BY_ZERO_EXCEPTION_OK);
8005
8006 #ifndef TEST_INLINE
8007   /* pow (x, +inf) == +inf for |x| > 1.  */
8008   TEST_ff_f (pow, 1.5, plus_infty, plus_infty);
8009
8010   /* pow (x, +inf) == +0 for |x| < 1.  */
8011   TEST_ff_f (pow, 0.5, plus_infty, 0.0);
8012
8013   /* pow (x, -inf) == +0 for |x| > 1.  */
8014   TEST_ff_f (pow, 1.5, minus_infty, 0.0);
8015
8016   /* pow (x, -inf) == +inf for |x| < 1.  */
8017   TEST_ff_f (pow, 0.5, minus_infty, plus_infty);
8018 #endif
8019
8020   /* pow (+inf, y) == +inf for y > 0.  */
8021   TEST_ff_f (pow, plus_infty, 2, plus_infty);
8022   TEST_ff_f (pow, plus_infty, 0xffffff, plus_infty);
8023 #ifndef TEST_FLOAT
8024   TEST_ff_f (pow, plus_infty, 0x1.fffffffffffffp+52L, plus_infty);
8025 #endif
8026 #ifdef TEST_LDOUBLE
8027 # if LDBL_MANT_DIG >= 64
8028   TEST_ff_f (pow, plus_infty, 0x1.fffffffffffffffep+63L, plus_infty);
8029 # endif
8030 # if LDBL_MANT_DIG >= 106
8031   TEST_ff_f (pow, plus_infty, 0x1.ffffffffffffffffffffffffff8p+105L, plus_infty);
8032 # endif
8033 # if LDBL_MANT_DIG >= 113
8034   TEST_ff_f (pow, plus_infty, 0x1.ffffffffffffffffffffffffffffp+112L, plus_infty);
8035 # endif
8036 #endif
8037   TEST_ff_f (pow, plus_infty, 0x1p24, plus_infty);
8038   TEST_ff_f (pow, plus_infty, 0x1p127, plus_infty);
8039   TEST_ff_f (pow, plus_infty, max_value, plus_infty);
8040
8041   /* pow (+inf, y) == +0 for y < 0.  */
8042   TEST_ff_f (pow, plus_infty, -1, 0.0);
8043   TEST_ff_f (pow, plus_infty, -0xffffff, 0.0);
8044 #ifndef TEST_FLOAT
8045   TEST_ff_f (pow, plus_infty, -0x1.fffffffffffffp+52L, 0.0);
8046 #endif
8047 #ifdef TEST_LDOUBLE
8048 # if LDBL_MANT_DIG >= 64
8049   TEST_ff_f (pow, plus_infty, -0x1.fffffffffffffffep+63L, 0.0);
8050 # endif
8051 # if LDBL_MANT_DIG >= 106
8052   TEST_ff_f (pow, plus_infty, -0x1.ffffffffffffffffffffffffff8p+105L, 0.0);
8053 # endif
8054 # if LDBL_MANT_DIG >= 113
8055   TEST_ff_f (pow, plus_infty, -0x1.ffffffffffffffffffffffffffffp+112L, 0.0);
8056 # endif
8057 #endif
8058   TEST_ff_f (pow, plus_infty, -0x1p24, 0.0);
8059   TEST_ff_f (pow, plus_infty, -0x1p127, 0.0);
8060   TEST_ff_f (pow, plus_infty, -max_value, 0.0);
8061
8062   /* pow (-inf, y) == -inf for y an odd integer > 0.  */
8063   TEST_ff_f (pow, minus_infty, 27, minus_infty);
8064   TEST_ff_f (pow, minus_infty, 0xffffff, minus_infty);
8065   TEST_ff_f (pow, minus_infty, 0x1fffffe, plus_infty);
8066 #ifndef TEST_FLOAT
8067   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffp+52L, minus_infty);
8068   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffp+53L, plus_infty);
8069 #endif
8070 #ifdef TEST_LDOUBLE
8071 # if LDBL_MANT_DIG >= 64
8072   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffffep+63L, minus_infty);
8073   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffffep+64L, plus_infty);
8074 # endif
8075 # if LDBL_MANT_DIG >= 106
8076   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty);
8077   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty);
8078 # endif
8079 # if LDBL_MANT_DIG >= 113
8080   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty);
8081   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty);
8082 # endif
8083 #endif
8084
8085   /* pow (-inf, y) == +inf for y > 0 and not an odd integer.  */
8086   TEST_ff_f (pow, minus_infty, 28, plus_infty);
8087   TEST_ff_f (pow, minus_infty, 0x1p24, plus_infty);
8088   TEST_ff_f (pow, minus_infty, 0x1p127, plus_infty);
8089   TEST_ff_f (pow, minus_infty, max_value, plus_infty);
8090
8091   /* pow (-inf, y) == -0 for y an odd integer < 0. */
8092   TEST_ff_f (pow, minus_infty, -3, minus_zero);
8093   TEST_ff_f (pow, minus_infty, -0xffffff, minus_zero);
8094   TEST_ff_f (pow, minus_infty, -0x1fffffe, plus_zero);
8095 #ifndef TEST_FLOAT
8096   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffp+52L, minus_zero);
8097   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffp+53L, plus_zero);
8098 #endif
8099 #ifdef TEST_LDOUBLE
8100 # if LDBL_MANT_DIG >= 64
8101   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffffep+63L, minus_zero);
8102   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffffep+64L, plus_zero);
8103 # endif
8104 # if LDBL_MANT_DIG >= 106
8105   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
8106   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
8107 # endif
8108 # if LDBL_MANT_DIG >= 113
8109   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
8110   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
8111 # endif
8112 #endif
8113   /* pow (-inf, y) == +0 for y < 0 and not an odd integer.  */
8114   TEST_ff_f (pow, minus_infty, -2.0, 0.0);
8115   TEST_ff_f (pow, minus_infty, -0x1p24, 0.0);
8116   TEST_ff_f (pow, minus_infty, -0x1p127, 0.0);
8117   TEST_ff_f (pow, minus_infty, -max_value, 0.0);
8118
8119   /* pow (+0, y) == +0 for y an odd integer > 0.  */
8120   TEST_ff_f (pow, 0.0, 27, 0.0);
8121   TEST_ff_f (pow, 0.0, 0xffffff, 0.0);
8122 #ifndef TEST_FLOAT
8123   TEST_ff_f (pow, 0.0, 0x1.fffffffffffffp+52L, 0.0);
8124 #endif
8125 #ifdef TEST_LDOUBLE
8126 # if LDBL_MANT_DIG >= 64
8127   TEST_ff_f (pow, 0.0, 0x1.fffffffffffffffep+63L, 0.0);
8128 # endif
8129 # if LDBL_MANT_DIG >= 106
8130   TEST_ff_f (pow, 0.0, 0x1.ffffffffffffffffffffffffff8p+105L, 0.0);
8131 # endif
8132 # if LDBL_MANT_DIG >= 113
8133   TEST_ff_f (pow, 0.0, 0x1.ffffffffffffffffffffffffffffp+112L, 0.0);
8134 # endif
8135 #endif
8136
8137   /* pow (-0, y) == -0 for y an odd integer > 0.  */
8138   TEST_ff_f (pow, minus_zero, 27, minus_zero);
8139   TEST_ff_f (pow, minus_zero, 0xffffff, minus_zero);
8140   TEST_ff_f (pow, minus_zero, 0x1fffffe, plus_zero);
8141 #ifndef TEST_FLOAT
8142   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffp+52L, minus_zero);
8143   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffp+53L, plus_zero);
8144 #endif
8145 #ifdef TEST_LDOUBLE
8146 # if LDBL_MANT_DIG >= 64
8147   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffffep+63L, minus_zero);
8148   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffffep+64L, plus_zero);
8149 # endif
8150 # if LDBL_MANT_DIG >= 106
8151   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
8152   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
8153 # endif
8154 # if LDBL_MANT_DIG >= 113
8155   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
8156   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
8157 # endif
8158 #endif
8159
8160   /* pow (+0, y) == +0 for y > 0 and not an odd integer.  */
8161   TEST_ff_f (pow, 0.0, 4, 0.0);
8162   TEST_ff_f (pow, 0.0, 0x1p24, 0.0);
8163   TEST_ff_f (pow, 0.0, 0x1p127, 0.0);
8164   TEST_ff_f (pow, 0.0, max_value, 0.0);
8165   TEST_ff_f (pow, 0.0, min_subnorm_value, 0.0);
8166
8167   /* pow (-0, y) == +0 for y > 0 and not an odd integer.  */
8168   TEST_ff_f (pow, minus_zero, 4, 0.0);
8169   TEST_ff_f (pow, minus_zero, 0x1p24, 0.0);
8170   TEST_ff_f (pow, minus_zero, 0x1p127, 0.0);
8171   TEST_ff_f (pow, minus_zero, max_value, 0.0);
8172   TEST_ff_f (pow, minus_zero, min_subnorm_value, 0.0);
8173
8174   TEST_ff_f (pow, 16, 0.25L, 2);
8175   TEST_ff_f (pow, 0x1p64L, 0.125L, 256);
8176   TEST_ff_f (pow, 2, 4, 16);
8177   TEST_ff_f (pow, 256, 8, 0x1p64L);
8178
8179   TEST_ff_f (pow, 0.75L, 1.25L, 0.697953644326574699205914060237425566L);
8180
8181 #if defined TEST_DOUBLE || defined TEST_LDOUBLE
8182   TEST_ff_f (pow, -7.49321e+133, -9.80818e+16, 0, UNDERFLOW_EXCEPTION);
8183 #endif
8184
8185   TEST_ff_f (pow, -1.0, -0xffffff, -1.0);
8186   TEST_ff_f (pow, -1.0, -0x1fffffe, 1.0);
8187 #ifndef TEST_FLOAT
8188   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffp+52L, -1.0);
8189   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffp+53L, 1.0);
8190 #endif
8191 #ifdef TEST_LDOUBLE
8192 # if LDBL_MANT_DIG >= 64
8193   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffffep+63L, -1.0);
8194   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffffep+64L, 1.0);
8195 # endif
8196 # if LDBL_MANT_DIG >= 106
8197   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffff8p+105L, -1.0);
8198   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffff8p+106L, 1.0);
8199 # endif
8200 # if LDBL_MANT_DIG >= 113
8201   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffffffp+112L, -1.0);
8202   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffffffp+113L, 1.0);
8203 # endif
8204 #endif
8205   TEST_ff_f (pow, -1.0, -max_value, 1.0);
8206
8207   TEST_ff_f (pow, -1.0, 0xffffff, -1.0);
8208   TEST_ff_f (pow, -1.0, 0x1fffffe, 1.0);
8209 #ifndef TEST_FLOAT
8210   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffp+52L, -1.0);
8211   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffp+53L, 1.0);
8212 #endif
8213 #ifdef TEST_LDOUBLE
8214 # if LDBL_MANT_DIG >= 64
8215   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffffep+63L, -1.0);
8216   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffffep+64L, 1.0);
8217 # endif
8218 # if LDBL_MANT_DIG >= 106
8219   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffff8p+105L, -1.0);
8220   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffff8p+106L, 1.0);
8221 # endif
8222 # if LDBL_MANT_DIG >= 113
8223   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffffffp+112L, -1.0);
8224   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffffffp+113L, 1.0);
8225 # endif
8226 #endif
8227   TEST_ff_f (pow, -1.0, max_value, 1.0);
8228
8229   TEST_ff_f (pow, -2.0, 126, 0x1p126);
8230   TEST_ff_f (pow, -2.0, 127, -0x1p127);
8231   /* Allow inexact results for float to be considered to underflow.  */
8232   TEST_ff_f (pow, -2.0, -126, 0x1p-126, UNDERFLOW_EXCEPTION_OK_FLOAT);
8233   TEST_ff_f (pow, -2.0, -127, -0x1p-127, UNDERFLOW_EXCEPTION_OK_FLOAT);
8234
8235   TEST_ff_f (pow, -2.0, -0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
8236   TEST_ff_f (pow, -2.0, -0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
8237 #ifndef TEST_FLOAT
8238   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
8239   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
8240 #endif
8241 #ifdef TEST_LDOUBLE
8242 # if LDBL_MANT_DIG >= 64
8243   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
8244   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
8245 # endif
8246 # if LDBL_MANT_DIG >= 106
8247   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
8248   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
8249 # endif
8250 # if LDBL_MANT_DIG >= 113
8251   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
8252   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
8253 # endif
8254 #endif
8255   TEST_ff_f (pow, -2.0, -max_value, plus_zero, UNDERFLOW_EXCEPTION);
8256
8257   TEST_ff_f (pow, -2.0, 0xffffff, minus_infty, OVERFLOW_EXCEPTION);
8258   TEST_ff_f (pow, -2.0, 0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
8259 #ifndef TEST_FLOAT
8260   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
8261   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
8262 #endif
8263 #ifdef TEST_LDOUBLE
8264 # if LDBL_MANT_DIG >= 64
8265   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
8266   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
8267 # endif
8268 # if LDBL_MANT_DIG >= 106
8269   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
8270   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
8271 # endif
8272 # if LDBL_MANT_DIG >= 113
8273   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
8274   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
8275 # endif
8276 #endif
8277   TEST_ff_f (pow, -2.0, max_value, plus_infty, OVERFLOW_EXCEPTION);
8278
8279   TEST_ff_f (pow, -max_value, 0.5, nan_value, INVALID_EXCEPTION);
8280   TEST_ff_f (pow, -max_value, 1.5, nan_value, INVALID_EXCEPTION);
8281   TEST_ff_f (pow, -max_value, 1000.5, nan_value, INVALID_EXCEPTION);
8282   TEST_ff_f (pow, -max_value, -2, plus_zero, UNDERFLOW_EXCEPTION);
8283   TEST_ff_f (pow, -max_value, -3, minus_zero, UNDERFLOW_EXCEPTION);
8284   TEST_ff_f (pow, -max_value, 2, plus_infty, OVERFLOW_EXCEPTION);
8285   TEST_ff_f (pow, -max_value, 3, minus_infty, OVERFLOW_EXCEPTION);
8286
8287   TEST_ff_f (pow, -max_value, -0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
8288   TEST_ff_f (pow, -max_value, -0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
8289 #ifndef TEST_FLOAT
8290   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
8291   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
8292 #endif
8293 #ifdef TEST_LDOUBLE
8294 # if LDBL_MANT_DIG >= 64
8295   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
8296   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
8297 # endif
8298 # if LDBL_MANT_DIG >= 106
8299   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
8300   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
8301 # endif
8302 # if LDBL_MANT_DIG >= 113
8303   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
8304   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
8305 # endif
8306 #endif
8307   TEST_ff_f (pow, -max_value, -max_value, plus_zero, UNDERFLOW_EXCEPTION);
8308
8309   TEST_ff_f (pow, -max_value, 0xffffff, minus_infty, OVERFLOW_EXCEPTION);
8310   TEST_ff_f (pow, -max_value, 0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
8311 #ifndef TEST_FLOAT
8312   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
8313   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
8314 #endif
8315 #ifdef TEST_LDOUBLE
8316 # if LDBL_MANT_DIG >= 64
8317   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
8318   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
8319 # endif
8320 # if LDBL_MANT_DIG >= 106
8321   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
8322   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
8323 # endif
8324 # if LDBL_MANT_DIG >= 113
8325   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
8326   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
8327 # endif
8328 #endif
8329   TEST_ff_f (pow, -max_value, max_value, plus_infty, OVERFLOW_EXCEPTION);
8330
8331   TEST_ff_f (pow, -0.5, 126, 0x1p-126);
8332   TEST_ff_f (pow, -0.5, 127, -0x1p-127);
8333   TEST_ff_f (pow, -0.5, -126, 0x1p126);
8334   TEST_ff_f (pow, -0.5, -127, -0x1p127);
8335
8336   TEST_ff_f (pow, -0.5, -0xffffff, minus_infty, OVERFLOW_EXCEPTION);
8337   TEST_ff_f (pow, -0.5, -0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
8338 #ifndef TEST_FLOAT
8339   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
8340   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
8341 #endif
8342 #ifdef TEST_LDOUBLE
8343 # if LDBL_MANT_DIG >= 64
8344   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
8345   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
8346 # endif
8347 # if LDBL_MANT_DIG >= 106
8348   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
8349   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
8350 # endif
8351 # if LDBL_MANT_DIG >= 113
8352   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
8353   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
8354 # endif
8355 #endif
8356   TEST_ff_f (pow, -0.5, -max_value, plus_infty, OVERFLOW_EXCEPTION);
8357
8358   TEST_ff_f (pow, -0.5, 0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
8359   TEST_ff_f (pow, -0.5, 0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
8360 #ifndef TEST_FLOAT
8361   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
8362   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
8363 #endif
8364 #ifdef TEST_LDOUBLE
8365 # if LDBL_MANT_DIG >= 64
8366   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
8367   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
8368 # endif
8369 # if LDBL_MANT_DIG >= 106
8370   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
8371   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
8372 # endif
8373 # if LDBL_MANT_DIG >= 113
8374   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
8375   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
8376 # endif
8377 #endif
8378   TEST_ff_f (pow, -0.5, max_value, plus_zero, UNDERFLOW_EXCEPTION);
8379
8380   TEST_ff_f (pow, -min_value, 0.5, nan_value, INVALID_EXCEPTION);
8381   TEST_ff_f (pow, -min_value, 1.5, nan_value, INVALID_EXCEPTION);
8382   TEST_ff_f (pow, -min_value, 1000.5, nan_value, INVALID_EXCEPTION);
8383   TEST_ff_f (pow, -min_value, -2, plus_infty, OVERFLOW_EXCEPTION);
8384   TEST_ff_f (pow, -min_value, -3, minus_infty, OVERFLOW_EXCEPTION);
8385   /* Allow inexact results to be considered to underflow.  */
8386   TEST_ff_f (pow, -min_value, 1, -min_value, UNDERFLOW_EXCEPTION_OK);
8387   TEST_ff_f (pow, -min_value, 2, plus_zero, UNDERFLOW_EXCEPTION);
8388   TEST_ff_f (pow, -min_value, 3, minus_zero, UNDERFLOW_EXCEPTION);
8389
8390   TEST_ff_f (pow, -min_value, -0xffffff, minus_infty, OVERFLOW_EXCEPTION);
8391   TEST_ff_f (pow, -min_value, -0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
8392 #ifndef TEST_FLOAT
8393   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
8394   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
8395 #endif
8396 #ifdef TEST_LDOUBLE
8397 # if LDBL_MANT_DIG >= 64
8398   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
8399   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
8400 # endif
8401 # if LDBL_MANT_DIG >= 106
8402   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
8403   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
8404 # endif
8405 # if LDBL_MANT_DIG >= 113
8406   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
8407   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
8408 # endif
8409 #endif
8410   TEST_ff_f (pow, -min_value, -max_value, plus_infty, OVERFLOW_EXCEPTION);
8411
8412   TEST_ff_f (pow, -min_value, 0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
8413   TEST_ff_f (pow, -min_value, 0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
8414 #ifndef TEST_FLOAT
8415   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
8416   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
8417 #endif
8418 #ifdef TEST_LDOUBLE
8419 # if LDBL_MANT_DIG >= 64
8420   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
8421   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
8422 # endif
8423 # if LDBL_MANT_DIG >= 106
8424   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
8425   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
8426 # endif
8427 # if LDBL_MANT_DIG >= 113
8428   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
8429   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
8430 # endif
8431 #endif
8432   TEST_ff_f (pow, -min_value, max_value, plus_zero, UNDERFLOW_EXCEPTION);
8433
8434   TEST_ff_f (pow, 0x0.ffffffp0, 10, 0.999999403953712118183885036774764444747L);
8435   TEST_ff_f (pow, 0x0.ffffffp0, 100, 0.999994039553108359406305079606228341585L);
8436   TEST_ff_f (pow, 0x0.ffffffp0, 1000, 0.9999403971297699052276650144650733772182L);
8437   TEST_ff_f (pow, 0x0.ffffffp0, 0x1p24, 0.3678794302077803437135155590023422899744L);
8438   TEST_ff_f (pow, 0x0.ffffffp0, 0x1p30, 1.603807831524924233828134753069728224044e-28L);
8439   TEST_ff_f (pow, 0x0.ffffffp0, 0x1.234566p30, 2.374884712135295099971443365381007297732e-32L);
8440   TEST_ff_f (pow, 0x0.ffffffp0, -10, 1.000000596046643153205170848674671339688L);
8441   TEST_ff_f (pow, 0x0.ffffffp0, -100, 1.000005960482418779499387594989252621451L);
8442   TEST_ff_f (pow, 0x0.ffffffp0, -1000, 1.000059606422943986382898964231519867906L);
8443   TEST_ff_f (pow, 0x0.ffffffp0, -0x1p24, 2.7182819094701610539628664526874952929416L);
8444   TEST_ff_f (pow, 0x0.ffffffp0, -0x1p30, 6.2351609734265057988914412331288163636075e+27L);
8445   TEST_ff_f (pow, 0x0.ffffffp0, -0x1.234566p30, 4.2107307141696353498921307077142537353515e+31L);
8446   TEST_ff_f (pow, 0x1.000002p0, 0x1p24, 7.3890552180866447284268641248075832310141L);
8447   TEST_ff_f (pow, 0x1.000002p0, 0x1.234566p29, 4.2107033006507495188536371520637025716256e+31L);
8448   TEST_ff_f (pow, 0x1.000002p0, -0x1.234566p29, 2.3749001736727769098946062325205705312166e-32L);
8449
8450 #if !defined TEST_FLOAT
8451   TEST_ff_f (pow, 0x0.fffffffffffff8p0L, 0x1.23456789abcdfp62L, 1.0118762747827252817436395051178295138220e-253L);
8452   TEST_ff_f (pow, 0x0.fffffffffffff8p0L, -0x1.23456789abcdfp62L, 9.8826311568054561811190162420900667121992e+252L);
8453   TEST_ff_f (pow, 0x1.0000000000001p0L, 0x1.23456789abcdfp61L, 9.8826311568044974397135026217687399395481e+252L);
8454   TEST_ff_f (pow, 0x1.0000000000001p0L, -0x1.23456789abcdfp61L, 1.0118762747828234466621210689458255908670e-253L);
8455 #endif
8456
8457 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64 && LDBL_MAX_EXP >= 16384
8458   TEST_ff_f (pow, 0x0.ffffffffffffffffp0L, 0x1.23456789abcdef0ep77L, 1.2079212226420368189981778807634890018840e-4048L);
8459   TEST_ff_f (pow, 0x0.ffffffffffffffffp0L, -0x1.23456789abcdef0ep77L, 8.2786855736563746280496724205839522148001e+4047L);
8460   TEST_ff_f (pow, 0x1.0000000000000002p0L, 0x1.23456789abcdef0ep76L, 8.2786855736563683535324500168799315131570e+4047L);
8461   TEST_ff_f (pow, 0x1.0000000000000002p0L, -0x1.23456789abcdef0ep76L, 1.2079212226420377344964713407722652880280e-4048L);
8462 #endif
8463
8464 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 113
8465   TEST_ff_f (pow, 0x0.ffffffffffffffffffffffffffff8p0L, 0x1.23456789abcdef0123456789abcdp126L, 1.2079212226420440237790185999151440179953e-4048L);
8466   TEST_ff_f (pow, 0x0.ffffffffffffffffffffffffffff8p0L, -0x1.23456789abcdef0123456789abcdp126L, 8.2786855736563252489063231915535105363602e+4047L);
8467   TEST_ff_f (pow, 0x1.0000000000000000000000000001p0L, 0x1.23456789abcdef0123456789abcdp125L, 8.2786855736563252489063231915423647547782e+4047L);
8468   TEST_ff_f (pow, 0x1.0000000000000000000000000001p0L, -0x1.23456789abcdef0123456789abcdp125L, 1.2079212226420440237790185999167702696503e-4048L);
8469 #endif
8470
8471 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
8472   TEST_ff_f (pow, 1e4932L, 0.75L, 1e3699L);
8473   TEST_ff_f (pow, 1e4928L, 0.75L, 1e3696L);
8474   TEST_ff_f (pow, 1e4924L, 0.75L, 1e3693L);
8475   TEST_ff_f (pow, 1e4920L, 0.75L, 1e3690L);
8476   TEST_ff_f (pow, 10.0L, 4932.0L, 1e4932L);
8477   TEST_ff_f (pow, 10.0L, 4931.0L, 1e4931L);
8478   TEST_ff_f (pow, 10.0L, 4930.0L, 1e4930L);
8479   TEST_ff_f (pow, 10.0L, 4929.0L, 1e4929L);
8480   TEST_ff_f (pow, 10.0L, -4931.0L, 1e-4931L);
8481   TEST_ff_f (pow, 10.0L, -4930.0L, 1e-4930L);
8482   TEST_ff_f (pow, 10.0L, -4929.0L, 1e-4929L);
8483   TEST_ff_f (pow, 1e27L, 182.0L, 1e4914L);
8484   TEST_ff_f (pow, 1e27L, -182.0L, 1e-4914L);
8485 #endif
8486
8487   TEST_ff_f (pow, min_subnorm_value, min_subnorm_value, 1.0L);
8488   TEST_ff_f (pow, min_subnorm_value, -min_subnorm_value, 1.0L);
8489   TEST_ff_f (pow, max_value, min_subnorm_value, 1.0L);
8490   TEST_ff_f (pow, max_value, -min_subnorm_value, 1.0L);
8491   TEST_ff_f (pow, 0.99L, min_subnorm_value, 1.0L);
8492   TEST_ff_f (pow, 0.99L, -min_subnorm_value, 1.0L);
8493   TEST_ff_f (pow, 1.01L, min_subnorm_value, 1.0L);
8494   TEST_ff_f (pow, 1.01L, -min_subnorm_value, 1.0L);
8495
8496   TEST_ff_f (pow, 2.0L, -100000.0L, plus_zero, UNDERFLOW_EXCEPTION);
8497
8498   END (pow);
8499 }
8500
8501
8502 static void
8503 pow_test_tonearest (void)
8504 {
8505   int save_round_mode;
8506   errno = 0;
8507   FUNC(pow) (0, 0);
8508   if (errno == ENOSYS)
8509     /* Function not implemented.  */
8510     return;
8511
8512   START (pow_tonearest);
8513
8514   save_round_mode = fegetround ();
8515
8516   if (!fesetround (FE_TONEAREST))
8517     {
8518       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
8519       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
8520     }
8521
8522   fesetround (save_round_mode);
8523
8524   END (pow_tonearest);
8525 }
8526
8527
8528 static void
8529 pow_test_towardzero (void)
8530 {
8531   int save_round_mode;
8532   errno = 0;
8533   FUNC(pow) (0, 0);
8534   if (errno == ENOSYS)
8535     /* Function not implemented.  */
8536     return;
8537
8538   START (pow_towardzero);
8539
8540   save_round_mode = fegetround ();
8541
8542   if (!fesetround (FE_TOWARDZERO))
8543     {
8544       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
8545       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
8546     }
8547
8548   fesetround (save_round_mode);
8549
8550   END (pow_towardzero);
8551 }
8552
8553
8554 static void
8555 pow_test_downward (void)
8556 {
8557   int save_round_mode;
8558   errno = 0;
8559   FUNC(pow) (0, 0);
8560   if (errno == ENOSYS)
8561     /* Function not implemented.  */
8562     return;
8563
8564   START (pow_downward);
8565
8566   save_round_mode = fegetround ();
8567
8568   if (!fesetround (FE_DOWNWARD))
8569     {
8570       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
8571       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
8572     }
8573
8574   fesetround (save_round_mode);
8575
8576   END (pow_downward);
8577 }
8578
8579
8580 static void
8581 pow_test_upward (void)
8582 {
8583   int save_round_mode;
8584   errno = 0;
8585   FUNC(pow) (0, 0);
8586   if (errno == ENOSYS)
8587     /* Function not implemented.  */
8588     return;
8589
8590   START (pow_upward);
8591
8592   save_round_mode = fegetround ();
8593
8594   if (!fesetround (FE_UPWARD))
8595     {
8596       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
8597       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
8598     }
8599
8600   fesetround (save_round_mode);
8601
8602   END (pow_upward);
8603 }
8604
8605
8606 static void
8607 remainder_test (void)
8608 {
8609   errno = 0;
8610   FUNC(remainder) (1.625, 1.0);
8611   if (errno == ENOSYS)
8612     /* Function not implemented.  */
8613     return;
8614
8615   START (remainder);
8616
8617   errno = 0;
8618   TEST_ff_f (remainder, 1, 0, nan_value, INVALID_EXCEPTION);
8619   check_int ("errno for remainder(1, 0) = EDOM ", errno, EDOM, 0, 0, 0);
8620   errno = 0;
8621   TEST_ff_f (remainder, 1, minus_zero, nan_value, INVALID_EXCEPTION);
8622   check_int ("errno for remainder(1, -0) = EDOM ", errno, EDOM, 0, 0, 0);
8623   errno = 0;
8624   TEST_ff_f (remainder, plus_infty, 1, nan_value, INVALID_EXCEPTION);
8625   check_int ("errno for remainder(INF, 1) = EDOM ", errno, EDOM, 0, 0, 0);
8626   errno = 0;
8627   TEST_ff_f (remainder, minus_infty, 1, nan_value, INVALID_EXCEPTION);
8628   check_int ("errno for remainder(-INF, 1) = EDOM ", errno, EDOM, 0, 0, 0);
8629   errno = 0;
8630   TEST_ff_f (remainder, nan_value, nan_value, nan_value);
8631   check_int ("errno for remainder(NAN, NAN) unchanged", errno, 0, 0, 0, 0);
8632   errno = 0;
8633   TEST_ff_f (remainder, 0, nan_value, nan_value);
8634   check_int ("errno for remainder(0, NAN) unchanged", errno, 0, 0, 0, 0);
8635   errno = 0;
8636   TEST_ff_f (remainder, nan_value, 0, nan_value);
8637   check_int ("errno for remainder(NaN, 0) unchanged", errno, 0, 0, 0, 0);
8638
8639   TEST_ff_f (remainder, 1.625, 1.0, -0.375);
8640   TEST_ff_f (remainder, -1.625, 1.0, 0.375);
8641   TEST_ff_f (remainder, 1.625, -1.0, -0.375);
8642   TEST_ff_f (remainder, -1.625, -1.0, 0.375);
8643   TEST_ff_f (remainder, 5.0, 2.0, 1.0);
8644   TEST_ff_f (remainder, 3.0, 2.0, -1.0);
8645
8646   END (remainder);
8647 }
8648
8649 static void
8650 remquo_test (void)
8651 {
8652   /* x is needed.  */
8653   int x;
8654
8655   errno = 0;
8656   FUNC(remquo) (1.625, 1.0, &x);
8657   if (errno == ENOSYS)
8658     /* Function not implemented.  */
8659     return;
8660
8661   START (remquo);
8662
8663   TEST_ffI_f1 (remquo, 1, 0, nan_value, IGNORE, INVALID_EXCEPTION);
8664   TEST_ffI_f1 (remquo, 1, minus_zero, nan_value, IGNORE, INVALID_EXCEPTION);
8665   TEST_ffI_f1 (remquo, plus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
8666   TEST_ffI_f1 (remquo, minus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
8667   TEST_ffI_f1 (remquo, nan_value, nan_value, nan_value, IGNORE);
8668
8669   TEST_ffI_f1 (remquo, 1.625, 1.0, -0.375, 2);
8670   TEST_ffI_f1 (remquo, -1.625, 1.0, 0.375, -2);
8671   TEST_ffI_f1 (remquo, 1.625, -1.0, -0.375, -2);
8672   TEST_ffI_f1 (remquo, -1.625, -1.0, 0.375, 2);
8673
8674   TEST_ffI_f1 (remquo, 5, 2, 1, 2);
8675   TEST_ffI_f1 (remquo, 3, 2, -1, 2);
8676
8677   END (remquo);
8678 }
8679
8680 static void
8681 rint_test (void)
8682 {
8683   START (rint);
8684
8685   TEST_f_f (rint, 0.0, 0.0);
8686   TEST_f_f (rint, minus_zero, minus_zero);
8687   TEST_f_f (rint, plus_infty, plus_infty);
8688   TEST_f_f (rint, minus_infty, minus_infty);
8689
8690   /* Default rounding mode is round to even.  */
8691   TEST_f_f (rint, 0.5, 0.0);
8692   TEST_f_f (rint, 1.5, 2.0);
8693   TEST_f_f (rint, 2.5, 2.0);
8694   TEST_f_f (rint, 3.5, 4.0);
8695   TEST_f_f (rint, 4.5, 4.0);
8696   TEST_f_f (rint, -0.5, -0.0);
8697   TEST_f_f (rint, -1.5, -2.0);
8698   TEST_f_f (rint, -2.5, -2.0);
8699   TEST_f_f (rint, -3.5, -4.0);
8700   TEST_f_f (rint, -4.5, -4.0);
8701   TEST_f_f (rint, 0.1, 0.0);
8702   TEST_f_f (rint, 0.25, 0.0);
8703   TEST_f_f (rint, 0.625, 1.0);
8704   TEST_f_f (rint, -0.1, -0.0);
8705   TEST_f_f (rint, -0.25, -0.0);
8706   TEST_f_f (rint, -0.625, -1.0);
8707   TEST_f_f (rint, 262144.75, 262145.0);
8708   TEST_f_f (rint, 262142.75, 262143.0);
8709   TEST_f_f (rint, 524286.75, 524287.0);
8710   TEST_f_f (rint, 524288.75, 524289.0);
8711   TEST_f_f (rint, 1048576.75, 1048577.0);
8712   TEST_f_f (rint, 2097152.75, 2097153.0);
8713   TEST_f_f (rint, -1048576.75, -1048577.0);
8714   TEST_f_f (rint, -2097152.75, -2097153.0);
8715 #ifndef TEST_FLOAT
8716   TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
8717   TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
8718   TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
8719   TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
8720   TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
8721   TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
8722   TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
8723   TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
8724   TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
8725   TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
8726 #endif
8727 #ifdef TEST_LDOUBLE
8728   /* The result can only be represented in long double.  */
8729   TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
8730   TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
8731   TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
8732   TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
8733   TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
8734
8735 # if LDBL_MANT_DIG > 100
8736   TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
8737   TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
8738   TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
8739 # endif
8740
8741   TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
8742   TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
8743   TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
8744   TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
8745   TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
8746
8747 # if LDBL_MANT_DIG > 100
8748   TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
8749   TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
8750   TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
8751
8752   TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
8753   TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
8754   TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
8755   TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
8756   TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
8757   TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
8758
8759   TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
8760   TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
8761   TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
8762   TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
8763   TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
8764   TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
8765 # endif
8766
8767   TEST_f_f (rint, 9007199254740991.5L, 9007199254740992.0L);
8768   TEST_f_f (rint, 9007199254740992.25L, 9007199254740992.0L);
8769   TEST_f_f (rint, 9007199254740992.5L, 9007199254740992.0L);
8770   TEST_f_f (rint, 9007199254740992.75L, 9007199254740993.0L);
8771   TEST_f_f (rint, 9007199254740993.5L, 9007199254740994.0L);
8772
8773   TEST_f_f (rint, -9007199254740991.5L, -9007199254740992.0L);
8774   TEST_f_f (rint, -9007199254740992.25L, -9007199254740992.0L);
8775   TEST_f_f (rint, -9007199254740992.5L, -9007199254740992.0L);
8776   TEST_f_f (rint, -9007199254740992.75L, -9007199254740993.0L);
8777   TEST_f_f (rint, -9007199254740993.5L, -9007199254740994.0L);
8778
8779   TEST_f_f (rint, 72057594037927935.5L, 72057594037927936.0L);
8780   TEST_f_f (rint, 72057594037927936.25L, 72057594037927936.0L);
8781   TEST_f_f (rint, 72057594037927936.5L, 72057594037927936.0L);
8782   TEST_f_f (rint, 72057594037927936.75L, 72057594037927937.0L);
8783   TEST_f_f (rint, 72057594037927937.5L, 72057594037927938.0L);
8784
8785   TEST_f_f (rint, -72057594037927935.5L, -72057594037927936.0L);
8786   TEST_f_f (rint, -72057594037927936.25L, -72057594037927936.0L);
8787   TEST_f_f (rint, -72057594037927936.5L, -72057594037927936.0L);
8788   TEST_f_f (rint, -72057594037927936.75L, -72057594037927937.0L);
8789   TEST_f_f (rint, -72057594037927937.5L, -72057594037927938.0L);
8790
8791   TEST_f_f (rint, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
8792   TEST_f_f (rint, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
8793   TEST_f_f (rint, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
8794   TEST_f_f (rint, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
8795   TEST_f_f (rint, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
8796 #endif
8797
8798   END (rint);
8799 }
8800
8801 static void
8802 rint_test_tonearest (void)
8803 {
8804   int save_round_mode;
8805   START (rint_tonearest);
8806
8807   save_round_mode = fegetround ();
8808
8809   if (!fesetround (FE_TONEAREST))
8810     {
8811       TEST_f_f (rint, 2.0, 2.0);
8812       TEST_f_f (rint, 1.5, 2.0);
8813       TEST_f_f (rint, 1.0, 1.0);
8814       TEST_f_f (rint, 0.5, 0.0);
8815       TEST_f_f (rint, 0.0, 0.0);
8816       TEST_f_f (rint, minus_zero, minus_zero);
8817       TEST_f_f (rint, -0.5, -0.0);
8818       TEST_f_f (rint, -1.0, -1.0);
8819       TEST_f_f (rint, -1.5, -2.0);
8820       TEST_f_f (rint, -2.0, -2.0);
8821       TEST_f_f (rint, 0.1, 0.0);
8822       TEST_f_f (rint, 0.25, 0.0);
8823       TEST_f_f (rint, 0.625, 1.0);
8824       TEST_f_f (rint, -0.1, -0.0);
8825       TEST_f_f (rint, -0.25, -0.0);
8826       TEST_f_f (rint, -0.625, -1.0);
8827       TEST_f_f (rint, 1048576.75, 1048577.0);
8828       TEST_f_f (rint, 2097152.75, 2097153.0);
8829       TEST_f_f (rint, -1048576.75, -1048577.0);
8830       TEST_f_f (rint, -2097152.75, -2097153.0);
8831 #ifndef TEST_FLOAT
8832       TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
8833       TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
8834       TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
8835       TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
8836       TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
8837       TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
8838       TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
8839       TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
8840       TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
8841       TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
8842 #endif
8843 #ifdef TEST_LDOUBLE
8844       /* The result can only be represented in long double.  */
8845       TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
8846       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
8847       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
8848       TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
8849       TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
8850 # if LDBL_MANT_DIG > 100
8851       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
8852       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
8853       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
8854 # endif
8855       TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
8856       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
8857       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
8858       TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
8859       TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
8860 # if LDBL_MANT_DIG > 100
8861       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
8862       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
8863       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
8864
8865       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
8866       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
8867       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
8868       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
8869       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
8870       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
8871
8872       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
8873       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
8874       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
8875       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
8876       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
8877       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
8878 # endif
8879 #endif
8880     }
8881
8882   fesetround (save_round_mode);
8883
8884   END (rint_tonearest);
8885 }
8886
8887 static void
8888 rint_test_towardzero (void)
8889 {
8890   int save_round_mode;
8891   START (rint_towardzero);
8892
8893   save_round_mode = fegetround ();
8894
8895   if (!fesetround (FE_TOWARDZERO))
8896     {
8897       TEST_f_f (rint, 2.0, 2.0);
8898       TEST_f_f (rint, 1.5, 1.0);
8899       TEST_f_f (rint, 1.0, 1.0);
8900       TEST_f_f (rint, 0.5, 0.0);
8901       TEST_f_f (rint, 0.0, 0.0);
8902       TEST_f_f (rint, minus_zero, minus_zero);
8903       TEST_f_f (rint, -0.5, -0.0);
8904       TEST_f_f (rint, -1.0, -1.0);
8905       TEST_f_f (rint, -1.5, -1.0);
8906       TEST_f_f (rint, -2.0, -2.0);
8907       TEST_f_f (rint, 0.1, 0.0);
8908       TEST_f_f (rint, 0.25, 0.0);
8909       TEST_f_f (rint, 0.625, 0.0);
8910       TEST_f_f (rint, -0.1, -0.0);
8911       TEST_f_f (rint, -0.25, -0.0);
8912       TEST_f_f (rint, -0.625, -0.0);
8913       TEST_f_f (rint, 1048576.75, 1048576.0);
8914       TEST_f_f (rint, 2097152.75, 2097152.0);
8915       TEST_f_f (rint, -1048576.75, -1048576.0);
8916       TEST_f_f (rint, -2097152.75, -2097152.0);
8917 #ifndef TEST_FLOAT
8918       TEST_f_f (rint, 70368744177664.75, 70368744177664.0);
8919       TEST_f_f (rint, 140737488355328.75, 140737488355328.0);
8920       TEST_f_f (rint, 281474976710656.75, 281474976710656.0);
8921       TEST_f_f (rint, 562949953421312.75, 562949953421312.0);
8922       TEST_f_f (rint, 1125899906842624.75, 1125899906842624.0);
8923       TEST_f_f (rint, -70368744177664.75, -70368744177664.0);
8924       TEST_f_f (rint, -140737488355328.75, -140737488355328.0);
8925       TEST_f_f (rint, -281474976710656.75, -281474976710656.0);
8926       TEST_f_f (rint, -562949953421312.75, -562949953421312.0);
8927       TEST_f_f (rint, -1125899906842624.75, -1125899906842624.0);
8928 #endif
8929 #ifdef TEST_LDOUBLE
8930       /* The result can only be represented in long double.  */
8931       TEST_f_f (rint, 4503599627370495.5L, 4503599627370495.0L);
8932       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
8933       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
8934       TEST_f_f (rint, 4503599627370496.75L, 4503599627370496.0L);
8935       TEST_f_f (rint, 4503599627370497.5L, 4503599627370497.0L);
8936 # if LDBL_MANT_DIG > 100
8937       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370494.0L);
8938       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370495.0L);
8939       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370496.0L);
8940 # endif
8941       TEST_f_f (rint, -4503599627370495.5L, -4503599627370495.0L);
8942       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
8943       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
8944       TEST_f_f (rint, -4503599627370496.75L, -4503599627370496.0L);
8945       TEST_f_f (rint, -4503599627370497.5L, -4503599627370497.0L);
8946 # if LDBL_MANT_DIG > 100
8947       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370494.0L);
8948       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370495.0L);
8949       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370496.0L);
8950
8951       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
8952       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
8953       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
8954       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740991.0L);
8955       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740992.0L);
8956       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740993.0L);
8957
8958       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
8959       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
8960       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
8961       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740991.0L);
8962       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740992.0L);
8963       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L);
8964 # endif
8965 #endif
8966     }
8967
8968   fesetround (save_round_mode);
8969
8970   END (rint_towardzero);
8971 }
8972
8973 static void
8974 rint_test_downward (void)
8975 {
8976   int save_round_mode;
8977   START (rint_downward);
8978
8979   save_round_mode = fegetround ();
8980
8981   if (!fesetround (FE_DOWNWARD))
8982     {
8983       TEST_f_f (rint, 2.0, 2.0);
8984       TEST_f_f (rint, 1.5, 1.0);
8985       TEST_f_f (rint, 1.0, 1.0);
8986       TEST_f_f (rint, 0.5, 0.0);
8987       TEST_f_f (rint, 0.0, 0.0);
8988       TEST_f_f (rint, minus_zero, minus_zero);
8989       TEST_f_f (rint, -0.5, -1.0);
8990       TEST_f_f (rint, -1.0, -1.0);
8991       TEST_f_f (rint, -1.5, -2.0);
8992       TEST_f_f (rint, -2.0, -2.0);
8993       TEST_f_f (rint, 0.1, 0.0);
8994       TEST_f_f (rint, 0.25, 0.0);
8995       TEST_f_f (rint, 0.625, 0.0);
8996       TEST_f_f (rint, -0.1, -1.0);
8997       TEST_f_f (rint, -0.25, -1.0);
8998       TEST_f_f (rint, -0.625, -1.0);
8999       TEST_f_f (rint, 1048576.75, 1048576.0);
9000       TEST_f_f (rint, 2097152.75, 2097152.0);
9001       TEST_f_f (rint, -1048576.75, -1048577.0);
9002       TEST_f_f (rint, -2097152.75, -2097153.0);
9003 #ifndef TEST_FLOAT
9004       TEST_f_f (rint, 70368744177664.75, 70368744177664.0);
9005       TEST_f_f (rint, 140737488355328.75, 140737488355328.0);
9006       TEST_f_f (rint, 281474976710656.75, 281474976710656.0);
9007       TEST_f_f (rint, 562949953421312.75, 562949953421312.0);
9008       TEST_f_f (rint, 1125899906842624.75, 1125899906842624.0);
9009       TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
9010       TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
9011       TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
9012       TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
9013       TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
9014 #endif
9015 #ifdef TEST_LDOUBLE
9016       /* The result can only be represented in long double.  */
9017       TEST_f_f (rint, 4503599627370495.5L, 4503599627370495.0L);
9018       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
9019       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
9020       TEST_f_f (rint, 4503599627370496.75L, 4503599627370496.0L);
9021       TEST_f_f (rint, 4503599627370497.5L, 4503599627370497.0L);
9022 # if LDBL_MANT_DIG > 100
9023       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370494.0L);
9024       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370495.0L);
9025       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370496.0L);
9026 # endif
9027       TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
9028       TEST_f_f (rint, -4503599627370496.25L, -4503599627370497.0L);
9029       TEST_f_f (rint, -4503599627370496.5L, -4503599627370497.0L);
9030       TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
9031       TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
9032 # if LDBL_MANT_DIG > 100
9033       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
9034       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
9035       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
9036
9037       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
9038       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
9039       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
9040       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740991.0L);
9041       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740992.0L);
9042       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740993.0L);
9043
9044       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740992.0L);
9045       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740993.0L);
9046       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740994.0L);
9047       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
9048       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
9049       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
9050 # endif
9051 #endif
9052     }
9053
9054   fesetround (save_round_mode);
9055
9056   END (rint_downward);
9057 }
9058
9059 static void
9060 rint_test_upward (void)
9061 {
9062   int save_round_mode;
9063   START (rint_upward);
9064
9065   save_round_mode = fegetround ();
9066
9067   if (!fesetround (FE_UPWARD))
9068     {
9069       TEST_f_f (rint, 2.0, 2.0);
9070       TEST_f_f (rint, 1.5, 2.0);
9071       TEST_f_f (rint, 1.0, 1.0);
9072       TEST_f_f (rint, 0.5, 1.0);
9073       TEST_f_f (rint, 0.0, 0.0);
9074       TEST_f_f (rint, minus_zero, minus_zero);
9075       TEST_f_f (rint, -0.5, -0.0);
9076       TEST_f_f (rint, -1.0, -1.0);
9077       TEST_f_f (rint, -1.5, -1.0);
9078       TEST_f_f (rint, -2.0, -2.0);
9079       TEST_f_f (rint, 0.1, 1.0);
9080       TEST_f_f (rint, 0.25, 1.0);
9081       TEST_f_f (rint, 0.625, 1.0);
9082       TEST_f_f (rint, -0.1, -0.0);
9083       TEST_f_f (rint, -0.25, -0.0);
9084       TEST_f_f (rint, -0.625, -0.0);
9085       TEST_f_f (rint, 1048576.75, 1048577.0);
9086       TEST_f_f (rint, 2097152.75, 2097153.0);
9087       TEST_f_f (rint, -1048576.75, -1048576.0);
9088       TEST_f_f (rint, -2097152.75, -2097152.0);
9089 #ifndef TEST_FLOAT
9090       TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
9091       TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
9092       TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
9093       TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
9094       TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
9095       TEST_f_f (rint, -70368744177664.75, -70368744177664.0);
9096       TEST_f_f (rint, -140737488355328.75, -140737488355328.0);
9097       TEST_f_f (rint, -281474976710656.75, -281474976710656.0);
9098       TEST_f_f (rint, -562949953421312.75, -562949953421312.0);
9099       TEST_f_f (rint, -1125899906842624.75, -1125899906842624.0);
9100 #endif
9101 #ifdef TEST_LDOUBLE
9102       /* The result can only be represented in long double.  */
9103       TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
9104       TEST_f_f (rint, 4503599627370496.25L, 4503599627370497.0L);
9105       TEST_f_f (rint, 4503599627370496.5L, 4503599627370497.0L);
9106       TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
9107       TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
9108 # if LDBL_MANT_DIG > 100
9109       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
9110       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
9111       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
9112 # endif
9113       TEST_f_f (rint, -4503599627370495.5L, -4503599627370495.0L);
9114       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
9115       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
9116       TEST_f_f (rint, -4503599627370496.75L, -4503599627370496.0L);
9117       TEST_f_f (rint, -4503599627370497.5L, -4503599627370497.0L);
9118 # if LDBL_MANT_DIG > 100
9119       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370494.0L);
9120       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370495.0L);
9121       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370496.0L);
9122
9123       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740992.0L);
9124       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740993.0L);
9125       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740994.0L);
9126       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
9127       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
9128       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
9129
9130       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
9131       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
9132       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
9133       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740991.0L);
9134       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740992.0L);
9135       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L);
9136 # endif
9137 #endif
9138     }
9139
9140   fesetround (save_round_mode);
9141
9142   END (rint_upward);
9143 }
9144
9145 static void
9146 round_test (void)
9147 {
9148   START (round);
9149
9150   TEST_f_f (round, 0, 0);
9151   TEST_f_f (round, minus_zero, minus_zero);
9152   TEST_f_f (round, 0.2L, 0.0);
9153   TEST_f_f (round, -0.2L, minus_zero);
9154   TEST_f_f (round, 0.5, 1.0);
9155   TEST_f_f (round, -0.5, -1.0);
9156   TEST_f_f (round, 0.8L, 1.0);
9157   TEST_f_f (round, -0.8L, -1.0);
9158   TEST_f_f (round, 1.5, 2.0);
9159   TEST_f_f (round, -1.5, -2.0);
9160   TEST_f_f (round, 0.1, 0.0);
9161   TEST_f_f (round, 0.25, 0.0);
9162   TEST_f_f (round, 0.625, 1.0);
9163   TEST_f_f (round, -0.1, -0.0);
9164   TEST_f_f (round, -0.25, -0.0);
9165   TEST_f_f (round, -0.625, -1.0);
9166   TEST_f_f (round, 2097152.5, 2097153);
9167   TEST_f_f (round, -2097152.5, -2097153);
9168
9169 #ifdef TEST_LDOUBLE
9170   /* The result can only be represented in long double.  */
9171   TEST_f_f (round, 4503599627370495.5L, 4503599627370496.0L);
9172   TEST_f_f (round, 4503599627370496.25L, 4503599627370496.0L);
9173   TEST_f_f (round, 4503599627370496.5L, 4503599627370497.0L);
9174   TEST_f_f (round, 4503599627370496.75L, 4503599627370497.0L);
9175   TEST_f_f (round, 4503599627370497.5L, 4503599627370498.0L);
9176 # if LDBL_MANT_DIG > 100
9177   TEST_f_f (round, 4503599627370494.5000000000001L, 4503599627370495.0L);
9178   TEST_f_f (round, 4503599627370495.5000000000001L, 4503599627370496.0L);
9179   TEST_f_f (round, 4503599627370496.5000000000001L, 4503599627370497.0L);
9180 # endif
9181
9182   TEST_f_f (round, -4503599627370495.5L, -4503599627370496.0L);
9183   TEST_f_f (round, -4503599627370496.25L, -4503599627370496.0L);
9184   TEST_f_f (round, -4503599627370496.5L, -4503599627370497.0L);
9185   TEST_f_f (round, -4503599627370496.75L, -4503599627370497.0L);
9186   TEST_f_f (round, -4503599627370497.5L, -4503599627370498.0L);
9187 # if LDBL_MANT_DIG > 100
9188   TEST_f_f (round, -4503599627370494.5000000000001L, -4503599627370495.0L);
9189   TEST_f_f (round, -4503599627370495.5000000000001L, -4503599627370496.0L);
9190   TEST_f_f (round, -4503599627370496.5000000000001L, -4503599627370497.0L);
9191 # endif
9192
9193   TEST_f_f (round, 9007199254740991.5L, 9007199254740992.0L);
9194   TEST_f_f (round, 9007199254740992.25L, 9007199254740992.0L);
9195   TEST_f_f (round, 9007199254740992.5L, 9007199254740993.0L);
9196   TEST_f_f (round, 9007199254740992.75L, 9007199254740993.0L);
9197   TEST_f_f (round, 9007199254740993.5L, 9007199254740994.0L);
9198
9199   TEST_f_f (round, -9007199254740991.5L, -9007199254740992.0L);
9200   TEST_f_f (round, -9007199254740992.25L, -9007199254740992.0L);
9201   TEST_f_f (round, -9007199254740992.5L, -9007199254740993.0L);
9202   TEST_f_f (round, -9007199254740992.75L, -9007199254740993.0L);
9203   TEST_f_f (round, -9007199254740993.5L, -9007199254740994.0L);
9204
9205 # if LDBL_MANT_DIG > 100
9206   TEST_f_f (round, 9007199254740991.0000000000001L, 9007199254740991.0L);
9207   TEST_f_f (round, 9007199254740992.0000000000001L, 9007199254740992.0L);
9208   TEST_f_f (round, 9007199254740993.0000000000001L, 9007199254740993.0L);
9209   TEST_f_f (round, 9007199254740991.5000000000001L, 9007199254740992.0L);
9210   TEST_f_f (round, 9007199254740992.5000000000001L, 9007199254740993.0L);
9211   TEST_f_f (round, 9007199254740993.5000000000001L, 9007199254740994.0L);
9212
9213   TEST_f_f (round, -9007199254740991.0000000000001L, -9007199254740991.0L);
9214   TEST_f_f (round, -9007199254740992.0000000000001L, -9007199254740992.0L);
9215   TEST_f_f (round, -9007199254740993.0000000000001L, -9007199254740993.0L);
9216   TEST_f_f (round, -9007199254740991.5000000000001L, -9007199254740992.0L);
9217   TEST_f_f (round, -9007199254740992.5000000000001L, -9007199254740993.0L);
9218   TEST_f_f (round, -9007199254740993.5000000000001L, -9007199254740994.0L);
9219 # endif
9220
9221   TEST_f_f (round, 72057594037927935.5L, 72057594037927936.0L);
9222   TEST_f_f (round, 72057594037927936.25L, 72057594037927936.0L);
9223   TEST_f_f (round, 72057594037927936.5L, 72057594037927937.0L);
9224   TEST_f_f (round, 72057594037927936.75L, 72057594037927937.0L);
9225   TEST_f_f (round, 72057594037927937.5L, 72057594037927938.0L);
9226
9227   TEST_f_f (round, -72057594037927935.5L, -72057594037927936.0L);
9228   TEST_f_f (round, -72057594037927936.25L, -72057594037927936.0L);
9229   TEST_f_f (round, -72057594037927936.5L, -72057594037927937.0L);
9230   TEST_f_f (round, -72057594037927936.75L, -72057594037927937.0L);
9231   TEST_f_f (round, -72057594037927937.5L, -72057594037927938.0L);
9232
9233   TEST_f_f (round, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
9234   TEST_f_f (round, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
9235   TEST_f_f (round, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
9236   TEST_f_f (round, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
9237   TEST_f_f (round, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
9238 #endif
9239
9240   END (round);
9241 }
9242
9243
9244 static void
9245 scalb_test (void)
9246 {
9247
9248   START (scalb);
9249
9250   TEST_ff_f (scalb, 2.0, 0.5, nan_value, INVALID_EXCEPTION);
9251   TEST_ff_f (scalb, 3.0, -2.5, nan_value, INVALID_EXCEPTION);
9252
9253   TEST_ff_f (scalb, 0, nan_value, nan_value);
9254   TEST_ff_f (scalb, 1, nan_value, nan_value);
9255
9256   TEST_ff_f (scalb, 1, 0, 1);
9257   TEST_ff_f (scalb, -1, 0, -1);
9258
9259   TEST_ff_f (scalb, 0, plus_infty, nan_value, INVALID_EXCEPTION);
9260   TEST_ff_f (scalb, minus_zero, plus_infty, nan_value, INVALID_EXCEPTION);
9261
9262   TEST_ff_f (scalb, 0, 2, 0);
9263   TEST_ff_f (scalb, minus_zero, -4, minus_zero);
9264   TEST_ff_f (scalb, 0, 0, 0);
9265   TEST_ff_f (scalb, minus_zero, 0, minus_zero);
9266   TEST_ff_f (scalb, 0, -1, 0);
9267   TEST_ff_f (scalb, minus_zero, -10, minus_zero);
9268   TEST_ff_f (scalb, 0, minus_infty, 0);
9269   TEST_ff_f (scalb, minus_zero, minus_infty, minus_zero);
9270
9271   TEST_ff_f (scalb, plus_infty, -1, plus_infty);
9272   TEST_ff_f (scalb, minus_infty, -10, minus_infty);
9273   TEST_ff_f (scalb, plus_infty, 0, plus_infty);
9274   TEST_ff_f (scalb, minus_infty, 0, minus_infty);
9275   TEST_ff_f (scalb, plus_infty, 2, plus_infty);
9276   TEST_ff_f (scalb, minus_infty, 100, minus_infty);
9277
9278   TEST_ff_f (scalb, 0.1L, minus_infty, 0.0);
9279   TEST_ff_f (scalb, -0.1L, minus_infty, minus_zero);
9280
9281   TEST_ff_f (scalb, 1, plus_infty, plus_infty);
9282   TEST_ff_f (scalb, -1, plus_infty, minus_infty);
9283   TEST_ff_f (scalb, plus_infty, plus_infty, plus_infty);
9284   TEST_ff_f (scalb, minus_infty, plus_infty, minus_infty);
9285
9286   TEST_ff_f (scalb, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
9287   TEST_ff_f (scalb, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
9288
9289   TEST_ff_f (scalb, nan_value, 1, nan_value);
9290   TEST_ff_f (scalb, 1, nan_value, nan_value);
9291   TEST_ff_f (scalb, nan_value, 0, nan_value);
9292   TEST_ff_f (scalb, 0, nan_value, nan_value);
9293   TEST_ff_f (scalb, nan_value, plus_infty, nan_value);
9294   TEST_ff_f (scalb, plus_infty, nan_value, nan_value);
9295   TEST_ff_f (scalb, nan_value, nan_value, nan_value);
9296
9297   TEST_ff_f (scalb, 0.8L, 4, 12.8L);
9298   TEST_ff_f (scalb, -0.854375L, 5, -27.34L);
9299
9300   END (scalb);
9301 }
9302
9303
9304 static void
9305 scalbn_test (void)
9306 {
9307
9308   START (scalbn);
9309
9310   TEST_fi_f (scalbn, 0, 0, 0);
9311   TEST_fi_f (scalbn, minus_zero, 0, minus_zero);
9312
9313   TEST_fi_f (scalbn, plus_infty, 1, plus_infty);
9314   TEST_fi_f (scalbn, minus_infty, 1, minus_infty);
9315   TEST_fi_f (scalbn, nan_value, 1, nan_value);
9316
9317   TEST_fi_f (scalbn, 0.8L, 4, 12.8L);
9318   TEST_fi_f (scalbn, -0.854375L, 5, -27.34L);
9319
9320   TEST_fi_f (scalbn, 1, 0L, 1);
9321
9322   TEST_fi_f (scalbn, 1, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9323   TEST_fi_f (scalbn, 1, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9324   TEST_fi_f (scalbn, max_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9325   TEST_fi_f (scalbn, max_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9326   TEST_fi_f (scalbn, min_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9327   TEST_fi_f (scalbn, min_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9328   TEST_fi_f (scalbn, min_value / 4, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9329   TEST_fi_f (scalbn, min_value / 4, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9330
9331   END (scalbn);
9332 }
9333
9334
9335 static void
9336 scalbln_test (void)
9337 {
9338
9339   START (scalbln);
9340
9341   TEST_fl_f (scalbln, 0, 0, 0);
9342   TEST_fl_f (scalbln, minus_zero, 0, minus_zero);
9343
9344   TEST_fl_f (scalbln, plus_infty, 1, plus_infty);
9345   TEST_fl_f (scalbln, minus_infty, 1, minus_infty);
9346   TEST_fl_f (scalbln, nan_value, 1, nan_value);
9347
9348   TEST_fl_f (scalbln, 0.8L, 4, 12.8L);
9349   TEST_fl_f (scalbln, -0.854375L, 5, -27.34L);
9350
9351   TEST_fl_f (scalbln, 1, 0L, 1);
9352
9353   TEST_fi_f (scalbln, 1, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9354   TEST_fi_f (scalbln, 1, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9355   TEST_fi_f (scalbln, max_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9356   TEST_fi_f (scalbln, max_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9357   TEST_fi_f (scalbln, min_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9358   TEST_fi_f (scalbln, min_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9359   TEST_fi_f (scalbln, min_value / 4, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9360   TEST_fi_f (scalbln, min_value / 4, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9361
9362   TEST_fi_f (scalbln, 1, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
9363   TEST_fi_f (scalbln, 1, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9364   TEST_fi_f (scalbln, max_value, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
9365   TEST_fi_f (scalbln, max_value, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9366   TEST_fi_f (scalbln, min_value, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
9367   TEST_fi_f (scalbln, min_value, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9368   TEST_fi_f (scalbln, min_value / 4, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
9369   TEST_fi_f (scalbln, min_value / 4, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9370
9371 #if LONG_MAX >= 0x100000000
9372   TEST_fi_f (scalbln, 1, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
9373   TEST_fi_f (scalbln, 1, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
9374   TEST_fi_f (scalbln, max_value, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
9375   TEST_fi_f (scalbln, max_value, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
9376   TEST_fi_f (scalbln, min_value, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
9377   TEST_fi_f (scalbln, min_value, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
9378   TEST_fi_f (scalbln, min_value / 4, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
9379   TEST_fi_f (scalbln, min_value / 4, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
9380 #endif
9381
9382   END (scalbn);
9383 }
9384
9385
9386 static void
9387 signbit_test (void)
9388 {
9389
9390   START (signbit);
9391
9392   TEST_f_b (signbit, 0, 0);
9393   TEST_f_b (signbit, minus_zero, 1);
9394   TEST_f_b (signbit, plus_infty, 0);
9395   TEST_f_b (signbit, minus_infty, 1);
9396
9397   /* signbit (x) != 0 for x < 0.  */
9398   TEST_f_b (signbit, -1, 1);
9399   /* signbit (x) == 0 for x >= 0.  */
9400   TEST_f_b (signbit, 1, 0);
9401
9402   END (signbit);
9403 }
9404
9405
9406 static void
9407 sin_test (void)
9408 {
9409   errno = 0;
9410   FUNC(sin) (0);
9411   if (errno == ENOSYS)
9412     /* Function not implemented.  */
9413     return;
9414
9415   START (sin);
9416
9417   TEST_f_f (sin, 0, 0);
9418   TEST_f_f (sin, minus_zero, minus_zero);
9419   errno = 0;
9420   TEST_f_f (sin, plus_infty, nan_value, INVALID_EXCEPTION);
9421   check_int ("errno for sin(+inf) == EDOM", errno, EDOM, 0, 0, 0);
9422   errno = 0;
9423   TEST_f_f (sin, minus_infty, nan_value, INVALID_EXCEPTION);
9424   check_int ("errno for sin(-inf) == EDOM", errno, EDOM, 0, 0, 0);
9425   errno = 0;
9426   TEST_f_f (sin, nan_value, nan_value);
9427   check_int ("errno for sin(NaN) unchanged", errno, 0, 0, 0, 0);
9428
9429   TEST_f_f (sin, M_PI_6l, 0.5);
9430   TEST_f_f (sin, -M_PI_6l, -0.5);
9431   TEST_f_f (sin, M_PI_2l, 1);
9432   TEST_f_f (sin, -M_PI_2l, -1);
9433   TEST_f_f (sin, 0.75L, 0.681638760023334166733241952779893935L);
9434
9435   TEST_f_f (sin, 0x1p65, -0.047183876212354673805106149805700013943218L);
9436   TEST_f_f (sin, -0x1p65, 0.047183876212354673805106149805700013943218L);
9437
9438   TEST_f_f (sin, 0x1.7f4134p+103, -6.6703229329788657073304190650534846045235e-08L);
9439
9440 #ifdef TEST_DOUBLE
9441   TEST_f_f (sin, 0.80190127184058835, 0.71867942238767868);
9442   TEST_f_f (sin, 2.522464e-1, 2.4957989804940911e-1);
9443 #endif
9444
9445 #ifndef TEST_FLOAT
9446   TEST_f_f (sin, 1e22, -0.8522008497671888017727058937530293682618L);
9447   TEST_f_f (sin, 0x1p1023, 0.5631277798508840134529434079444683477104L);
9448 #endif
9449
9450 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
9451   TEST_f_f (sin, 0x1p16383L, 0.3893629985894208126948115852610595405563L);
9452 #endif
9453
9454   TEST_f_f (sin, 0x1p+120, 3.77820109360752022655548470056922991960587e-01L);
9455   TEST_f_f (sin, 0x1p+127, 6.23385512955870240370428801097126489001833e-01L);
9456   TEST_f_f (sin, 0x1.fffff8p+127, 4.85786063130487339701113680434728152037092e-02L);
9457   TEST_f_f (sin, 0x1.fffffep+127, -5.21876523333658540551505357019806722935726e-01L);
9458   TEST_f_f (sin, 0x1p+50, 4.96396515208940840876821859865411368093356e-01L);
9459   TEST_f_f (sin, 0x1p+28, -9.86198211836975655703110310527108292055548e-01L);
9460
9461   END (sin);
9462
9463 }
9464
9465
9466 static void
9467 sin_test_tonearest (void)
9468 {
9469   int save_round_mode;
9470   errno = 0;
9471   FUNC(sin) (0);
9472   if (errno == ENOSYS)
9473     /* Function not implemented.  */
9474     return;
9475
9476   START (sin_tonearest);
9477
9478   save_round_mode = fegetround ();
9479
9480   if (!fesetround (FE_TONEAREST))
9481     {
9482       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
9483       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
9484       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
9485       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
9486       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
9487       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
9488       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
9489       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
9490       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
9491       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
9492     }
9493
9494   fesetround (save_round_mode);
9495
9496   END (sin_tonearest);
9497 }
9498
9499
9500 static void
9501 sin_test_towardzero (void)
9502 {
9503   int save_round_mode;
9504   errno = 0;
9505   FUNC(sin) (0);
9506   if (errno == ENOSYS)
9507     /* Function not implemented.  */
9508     return;
9509
9510   START (sin_towardzero);
9511
9512   save_round_mode = fegetround ();
9513
9514   if (!fesetround (FE_TOWARDZERO))
9515     {
9516       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
9517       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
9518       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
9519       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
9520       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
9521       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
9522       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
9523       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
9524       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
9525       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
9526     }
9527
9528   fesetround (save_round_mode);
9529
9530   END (sin_towardzero);
9531 }
9532
9533
9534 static void
9535 sin_test_downward (void)
9536 {
9537   int save_round_mode;
9538   errno = 0;
9539   FUNC(sin) (0);
9540   if (errno == ENOSYS)
9541     /* Function not implemented.  */
9542     return;
9543
9544   START (sin_downward);
9545
9546   save_round_mode = fegetround ();
9547
9548   if (!fesetround (FE_DOWNWARD))
9549     {
9550       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
9551       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
9552       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
9553       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
9554       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
9555       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
9556       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
9557       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
9558       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
9559       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
9560     }
9561
9562   fesetround (save_round_mode);
9563
9564   END (sin_downward);
9565 }
9566
9567
9568 static void
9569 sin_test_upward (void)
9570 {
9571   int save_round_mode;
9572   errno = 0;
9573   FUNC(sin) (0);
9574   if (errno == ENOSYS)
9575     /* Function not implemented.  */
9576     return;
9577
9578   START (sin_upward);
9579
9580   save_round_mode = fegetround ();
9581
9582   if (!fesetround (FE_UPWARD))
9583     {
9584       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
9585       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
9586       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
9587       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
9588       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
9589       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
9590       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
9591       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
9592       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
9593       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
9594     }
9595
9596   fesetround (save_round_mode);
9597
9598   END (sin_upward);
9599 }
9600
9601
9602 static void
9603 sincos_test (void)
9604 {
9605   FLOAT sin_res, cos_res;
9606
9607   errno = 0;
9608   FUNC(sincos) (0, &sin_res, &cos_res);
9609   if (errno == ENOSYS)
9610     /* Function not implemented.  */
9611     return;
9612
9613   START (sincos);
9614
9615   /* sincos is treated differently because it returns void.  */
9616   TEST_extra (sincos, 0, 0, 1);
9617
9618   TEST_extra (sincos, minus_zero, minus_zero, 1);
9619   TEST_extra (sincos, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
9620   TEST_extra (sincos, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
9621   TEST_extra (sincos, nan_value, nan_value, nan_value);
9622
9623   TEST_extra (sincos, M_PI_2l, 1, 0);
9624   TEST_extra (sincos, M_PI_6l, 0.5, 0.86602540378443864676372317075293616L);
9625   TEST_extra (sincos, M_PI_6l*2.0, 0.86602540378443864676372317075293616L, 0.5);
9626   TEST_extra (sincos, 0.75L, 0.681638760023334166733241952779893935L, 0.731688868873820886311838753000084544L);
9627
9628   TEST_extra (sincos, 0x1p65, -0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L);
9629   TEST_extra (sincos, -0x1p65, 0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L);
9630
9631 #ifdef TEST_DOUBLE
9632   TEST_extra (sincos, 0.80190127184058835, 0.71867942238767868, 0.69534156199418473);
9633 #endif
9634
9635 #ifndef TEST_FLOAT
9636   TEST_extra (sincos, 1e22, -0.8522008497671888017727058937530293682618L, 0.5232147853951389454975944733847094921409L);
9637   TEST_extra (sincos, 0x1p1023, 0.5631277798508840134529434079444683477104L, -0.826369834614147994500785680811743734805L);
9638 #endif
9639
9640 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
9641   TEST_extra (sincos, 0x1p16383L, 0.3893629985894208126948115852610595405563L, 0.9210843909921906206874509522505756251609L);
9642 #endif
9643
9644   TEST_extra (sincos, 0x1p+120, 3.77820109360752022655548470056922991960587e-01L, -9.25879022854837867303861764107414946730833e-01L);
9645   TEST_extra (sincos, 0x1p+127, 6.23385512955870240370428801097126489001833e-01L, 7.81914638714960072263910298466369236613162e-01L);
9646   TEST_extra (sincos, 0x1.fffff8p+127, 4.85786063130487339701113680434728152037092e-02L, 9.98819362551949040703862043664101081064641e-01L);
9647   TEST_extra (sincos, 0x1.fffffep+127, -5.21876523333658540551505357019806722935726e-01L, 8.53021039830304158051791467692161107353094e-01L);
9648   TEST_extra (sincos, 0x1p+50, 4.96396515208940840876821859865411368093356e-01L, 8.68095904660550604334592502063501320395739e-01L);
9649   TEST_extra (sincos, 0x1p+28, -9.86198211836975655703110310527108292055548e-01L, -1.65568979490578758865468278195361551113358e-01L);
9650
9651   END (sincos);
9652 }
9653
9654 static void
9655 sinh_test (void)
9656 {
9657   errno = 0;
9658   FUNC(sinh) (0.7L);
9659   if (errno == ENOSYS)
9660     /* Function not implemented.  */
9661     return;
9662
9663   START (sinh);
9664   TEST_f_f (sinh, 0, 0);
9665   TEST_f_f (sinh, minus_zero, minus_zero);
9666
9667 #ifndef TEST_INLINE
9668   TEST_f_f (sinh, plus_infty, plus_infty);
9669   TEST_f_f (sinh, minus_infty, minus_infty);
9670 #endif
9671   TEST_f_f (sinh, nan_value, nan_value);
9672
9673   TEST_f_f (sinh, 0.75L, 0.822316731935829980703661634446913849L);
9674   TEST_f_f (sinh, 0x8p-32L, 1.86264514923095703232705808926175479e-9L);
9675
9676   END (sinh);
9677 }
9678
9679
9680 static void
9681 sinh_test_tonearest (void)
9682 {
9683   int save_round_mode;
9684   errno = 0;
9685   FUNC(sinh) (0);
9686   if (errno == ENOSYS)
9687     /* Function not implemented.  */
9688     return;
9689
9690   START (sinh_tonearest);
9691
9692   save_round_mode = fegetround ();
9693
9694   if (!fesetround (FE_TONEAREST))
9695     {
9696       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
9697       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
9698       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
9699     }
9700
9701   fesetround (save_round_mode);
9702
9703   END (sinh_tonearest);
9704 }
9705
9706
9707 static void
9708 sinh_test_towardzero (void)
9709 {
9710   int save_round_mode;
9711   errno = 0;
9712   FUNC(sinh) (0);
9713   if (errno == ENOSYS)
9714     /* Function not implemented.  */
9715     return;
9716
9717   START (sinh_towardzero);
9718
9719   save_round_mode = fegetround ();
9720
9721   if (!fesetround (FE_TOWARDZERO))
9722     {
9723       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
9724       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
9725       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
9726     }
9727
9728   fesetround (save_round_mode);
9729
9730   END (sinh_towardzero);
9731 }
9732
9733
9734 static void
9735 sinh_test_downward (void)
9736 {
9737   int save_round_mode;
9738   errno = 0;
9739   FUNC(sinh) (0);
9740   if (errno == ENOSYS)
9741     /* Function not implemented.  */
9742     return;
9743
9744   START (sinh_downward);
9745
9746   save_round_mode = fegetround ();
9747
9748   if (!fesetround (FE_DOWNWARD))
9749     {
9750       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
9751       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
9752       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
9753     }
9754
9755   fesetround (save_round_mode);
9756
9757   END (sinh_downward);
9758 }
9759
9760
9761 static void
9762 sinh_test_upward (void)
9763 {
9764   int save_round_mode;
9765   errno = 0;
9766   FUNC(sinh) (0);
9767   if (errno == ENOSYS)
9768     /* Function not implemented.  */
9769     return;
9770
9771   START (sinh_upward);
9772
9773   save_round_mode = fegetround ();
9774
9775   if (!fesetround (FE_UPWARD))
9776     {
9777       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
9778       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
9779       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
9780     }
9781
9782   fesetround (save_round_mode);
9783
9784   END (sinh_upward);
9785 }
9786
9787
9788 static void
9789 sqrt_test (void)
9790 {
9791   errno = 0;
9792   FUNC(sqrt) (1);
9793   if (errno == ENOSYS)
9794     /* Function not implemented.  */
9795     return;
9796
9797   START (sqrt);
9798
9799   TEST_f_f (sqrt, 0, 0);
9800   TEST_f_f (sqrt, nan_value, nan_value);
9801   TEST_f_f (sqrt, plus_infty, plus_infty);
9802
9803   TEST_f_f (sqrt, minus_zero, minus_zero);
9804
9805   /* sqrt (x) == NaN plus invalid exception for x < 0.  */
9806   TEST_f_f (sqrt, -1, nan_value, INVALID_EXCEPTION);
9807   TEST_f_f (sqrt, -max_value, nan_value, INVALID_EXCEPTION);
9808   TEST_f_f (sqrt, minus_infty, nan_value, INVALID_EXCEPTION);
9809   TEST_f_f (sqrt, nan_value, nan_value);
9810
9811   TEST_f_f (sqrt, 2209, 47);
9812   TEST_f_f (sqrt, 4, 2);
9813   TEST_f_f (sqrt, 2, M_SQRT2l);
9814   TEST_f_f (sqrt, 0.25, 0.5);
9815   TEST_f_f (sqrt, 6642.25, 81.5);
9816   TEST_f_f (sqrt, 15190.5625L, 123.25L);
9817   TEST_f_f (sqrt, 0.75L, 0.866025403784438646763723170752936183L);
9818
9819   END (sqrt);
9820 }
9821
9822
9823 static void
9824 tan_test (void)
9825 {
9826   errno = 0;
9827   FUNC(tan) (0);
9828   if (errno == ENOSYS)
9829     /* Function not implemented.  */
9830     return;
9831
9832   START (tan);
9833
9834   TEST_f_f (tan, 0, 0);
9835   TEST_f_f (tan, minus_zero, minus_zero);
9836   errno = 0;
9837   TEST_f_f (tan, plus_infty, nan_value, INVALID_EXCEPTION);
9838   check_int ("errno for tan(Inf) == EDOM", errno, EDOM, 0, 0, 0);
9839   errno = 0;
9840   TEST_f_f (tan, minus_infty, nan_value, INVALID_EXCEPTION);
9841   check_int ("errno for tan(-Inf) == EDOM", errno, EDOM, 0, 0, 0);
9842   errno = 0;
9843   TEST_f_f (tan, nan_value, nan_value);
9844   check_int ("errno for tan(NaN) == 0", errno, 0, 0, 0, 0);
9845
9846   TEST_f_f (tan, M_PI_4l, 1);
9847   TEST_f_f (tan, 0.75L, 0.931596459944072461165202756573936428L);
9848
9849   TEST_f_f (tan, 0x1p65, -0.0472364872359047946798414219288370688827L);
9850   TEST_f_f (tan, -0x1p65, 0.0472364872359047946798414219288370688827L);
9851
9852   TEST_f_f (tan, 0xc.9p-4, 0.9995162902115457818029468900654150261381L);
9853   TEST_f_f (tan, 0xc.908p-4, 0.9997603425502441410973077452249560802034L);
9854   TEST_f_f (tan, 0xc.90cp-4, 0.9998823910588060302788513970802357770031L);
9855   TEST_f_f (tan, 0xc.90ep-4, 0.9999434208994808753305784795924711152508L);
9856   TEST_f_f (tan, 0xc.90fp-4, 0.9999739372166156702433266059635165160515L);
9857   TEST_f_f (tan, 0xc.90f8p-4, 0.9999891957244072765118898375645469865764L);
9858   TEST_f_f (tan, 0xc.90fcp-4, 0.9999968250656122402859679132395522927393L);
9859   TEST_f_f (tan, 0xc.90fdp-4, 0.9999987324100083358016192309006353329444L);
9860   TEST_f_f (tan, 0xc.90fd8p-4, 0.9999996860835706212861509874451585282616L);
9861   TEST_f_f (tan, 0xc.90fdap-4, 0.9999999245021033010474530133665235922808L);
9862   TEST_f_f (tan, 0xc.ap-4, 1.0073556597407272165371804539701396631519L);
9863   TEST_f_f (tan, 0xc.98p-4, 1.0034282930863044654045449407466962736255L);
9864   TEST_f_f (tan, 0xc.94p-4, 1.0014703786820082237342656561856877993328L);
9865   TEST_f_f (tan, 0xc.92p-4, 1.0004928571392300571266638743539017593717L);
9866   TEST_f_f (tan, 0xc.91p-4, 1.0000044544650244953647966900221905361131L);
9867   TEST_f_f (tan, 0xc.90fep-4, 1.0000006397580424009014454926842136804016L);
9868   TEST_f_f (tan, 0xc.90fdcp-4, 1.0000001629206928242190327320047489394217L);
9869   TEST_f_f (tan, 0xc.90fdbp-4, 1.0000000437113909572052640953950483705005L);
9870
9871   TEST_f_f (tan, -0xc.9p-4, -0.9995162902115457818029468900654150261381L);
9872   TEST_f_f (tan, -0xc.908p-4, -0.9997603425502441410973077452249560802034L);
9873   TEST_f_f (tan, -0xc.90cp-4, -0.9998823910588060302788513970802357770031L);
9874   TEST_f_f (tan, -0xc.90ep-4, -0.9999434208994808753305784795924711152508L);
9875   TEST_f_f (tan, -0xc.90fp-4, -0.9999739372166156702433266059635165160515L);
9876   TEST_f_f (tan, -0xc.90f8p-4, -0.9999891957244072765118898375645469865764L);
9877   TEST_f_f (tan, -0xc.90fcp-4, -0.9999968250656122402859679132395522927393L);
9878   TEST_f_f (tan, -0xc.90fdp-4, -0.9999987324100083358016192309006353329444L);
9879   TEST_f_f (tan, -0xc.90fd8p-4, -0.9999996860835706212861509874451585282616L);
9880   TEST_f_f (tan, -0xc.90fdap-4, -0.9999999245021033010474530133665235922808L);
9881   TEST_f_f (tan, -0xc.ap-4, -1.0073556597407272165371804539701396631519L);
9882   TEST_f_f (tan, -0xc.98p-4, -1.0034282930863044654045449407466962736255L);
9883   TEST_f_f (tan, -0xc.94p-4, -1.0014703786820082237342656561856877993328L);
9884   TEST_f_f (tan, -0xc.92p-4, -1.0004928571392300571266638743539017593717L);
9885   TEST_f_f (tan, -0xc.91p-4, -1.0000044544650244953647966900221905361131L);
9886   TEST_f_f (tan, -0xc.90fep-4, -1.0000006397580424009014454926842136804016L);
9887   TEST_f_f (tan, -0xc.90fdcp-4, -1.0000001629206928242190327320047489394217L);
9888   TEST_f_f (tan, -0xc.90fdbp-4, -1.0000000437113909572052640953950483705005L);
9889
9890 #ifndef TEST_FLOAT
9891   TEST_f_f (tan, 1e22, -1.628778225606898878549375936939548513545L);
9892   TEST_f_f (tan, 0x1p1023, -0.6814476476066215012854144040167365190368L);
9893 #endif
9894
9895 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
9896   TEST_f_f (tan, 0x1p16383L, 0.422722393732022337800504160054440141575L);
9897 #endif
9898
9899   END (tan);
9900 }
9901
9902
9903 static void
9904 tan_test_tonearest (void)
9905 {
9906   int save_round_mode;
9907   errno = 0;
9908   FUNC(tan) (0);
9909   if (errno == ENOSYS)
9910     /* Function not implemented.  */
9911     return;
9912
9913   START (tan_tonearest);
9914
9915   save_round_mode = fegetround ();
9916
9917   if (!fesetround (FE_TONEAREST))
9918     {
9919       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
9920       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
9921       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
9922       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
9923       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
9924       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
9925       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
9926       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
9927       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
9928       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
9929     }
9930
9931   fesetround (save_round_mode);
9932
9933   END (tan_tonearest);
9934 }
9935
9936
9937 static void
9938 tan_test_towardzero (void)
9939 {
9940   int save_round_mode;
9941   errno = 0;
9942   FUNC(tan) (0);
9943   if (errno == ENOSYS)
9944     /* Function not implemented.  */
9945     return;
9946
9947   START (tan_towardzero);
9948
9949   save_round_mode = fegetround ();
9950
9951   if (!fesetround (FE_TOWARDZERO))
9952     {
9953       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
9954       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
9955       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
9956       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
9957       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
9958       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
9959       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
9960       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
9961       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
9962       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
9963     }
9964
9965   fesetround (save_round_mode);
9966
9967   END (tan_towardzero);
9968 }
9969
9970
9971 static void
9972 tan_test_downward (void)
9973 {
9974   int save_round_mode;
9975   errno = 0;
9976   FUNC(tan) (0);
9977   if (errno == ENOSYS)
9978     /* Function not implemented.  */
9979     return;
9980
9981   START (tan_downward);
9982
9983   save_round_mode = fegetround ();
9984
9985   if (!fesetround (FE_DOWNWARD))
9986     {
9987       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
9988       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
9989       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
9990       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
9991       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
9992       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
9993       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
9994       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
9995       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
9996       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
9997     }
9998
9999   fesetround (save_round_mode);
10000
10001   END (tan_downward);
10002 }
10003
10004
10005 static void
10006 tan_test_upward (void)
10007 {
10008   int save_round_mode;
10009   errno = 0;
10010   FUNC(tan) (0);
10011   if (errno == ENOSYS)
10012     /* Function not implemented.  */
10013     return;
10014
10015   START (tan_upward);
10016
10017   save_round_mode = fegetround ();
10018
10019   if (!fesetround (FE_UPWARD))
10020     {
10021       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
10022       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
10023       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
10024       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
10025       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
10026       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
10027       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
10028       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
10029       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
10030       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
10031     }
10032
10033   fesetround (save_round_mode);
10034
10035   END (tan_upward);
10036 }
10037
10038
10039 static void
10040 tanh_test (void)
10041 {
10042   errno = 0;
10043   FUNC(tanh) (0.7L);
10044   if (errno == ENOSYS)
10045     /* Function not implemented.  */
10046     return;
10047
10048   START (tanh);
10049
10050   TEST_f_f (tanh, 0, 0);
10051   TEST_f_f (tanh, minus_zero, minus_zero);
10052
10053 #ifndef TEST_INLINE
10054   TEST_f_f (tanh, plus_infty, 1);
10055   TEST_f_f (tanh, minus_infty, -1);
10056 #endif
10057   TEST_f_f (tanh, nan_value, nan_value);
10058
10059   TEST_f_f (tanh, 0.75L, 0.635148952387287319214434357312496495L);
10060   TEST_f_f (tanh, -0.75L, -0.635148952387287319214434357312496495L);
10061
10062   TEST_f_f (tanh, 1.0L, 0.7615941559557648881194582826047935904L);
10063   TEST_f_f (tanh, -1.0L, -0.7615941559557648881194582826047935904L);
10064
10065   /* 2^-57  */
10066   TEST_f_f (tanh, 0x1p-57L, 6.938893903907228377647697925567626953125e-18L);
10067
10068   END (tanh);
10069 }
10070
10071 static void
10072 tgamma_test (void)
10073 {
10074   errno = 0;
10075   FUNC(tgamma) (1);
10076   if (errno == ENOSYS)
10077     /* Function not implemented.  */
10078     return;
10079
10080   START (tgamma);
10081
10082   TEST_f_f (tgamma, plus_infty, plus_infty);
10083   TEST_f_f (tgamma, max_value, plus_infty, OVERFLOW_EXCEPTION);
10084   TEST_f_f (tgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
10085   TEST_f_f (tgamma, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
10086   /* tgamma (x) == NaN plus invalid exception for integer x <= 0.  */
10087   TEST_f_f (tgamma, -2, nan_value, INVALID_EXCEPTION);
10088   TEST_f_f (tgamma, -max_value, nan_value, INVALID_EXCEPTION);
10089   TEST_f_f (tgamma, minus_infty, nan_value, INVALID_EXCEPTION);
10090   TEST_f_f (tgamma, nan_value, nan_value);
10091
10092   TEST_f_f (tgamma, 0.5, M_SQRT_PIl);
10093   TEST_f_f (tgamma, -0.5, -M_2_SQRT_PIl);
10094
10095   TEST_f_f (tgamma, 1, 1);
10096   TEST_f_f (tgamma, 4, 6);
10097
10098   TEST_f_f (tgamma, 0.7L, 1.29805533264755778568117117915281162L);
10099   TEST_f_f (tgamma, 1.2L, 0.918168742399760610640951655185830401L);
10100
10101   END (tgamma);
10102 }
10103
10104
10105 static void
10106 trunc_test (void)
10107 {
10108   START (trunc);
10109
10110   TEST_f_f (trunc, plus_infty, plus_infty);
10111   TEST_f_f (trunc, minus_infty, minus_infty);
10112   TEST_f_f (trunc, nan_value, nan_value);
10113
10114   TEST_f_f (trunc, 0, 0);
10115   TEST_f_f (trunc, minus_zero, minus_zero);
10116   TEST_f_f (trunc, 0.1, 0);
10117   TEST_f_f (trunc, 0.25, 0);
10118   TEST_f_f (trunc, 0.625, 0);
10119   TEST_f_f (trunc, -0.1, minus_zero);
10120   TEST_f_f (trunc, -0.25, minus_zero);
10121   TEST_f_f (trunc, -0.625, minus_zero);
10122   TEST_f_f (trunc, 1, 1);
10123   TEST_f_f (trunc, -1, -1);
10124   TEST_f_f (trunc, 1.625, 1);
10125   TEST_f_f (trunc, -1.625, -1);
10126
10127   TEST_f_f (trunc, 1048580.625L, 1048580L);
10128   TEST_f_f (trunc, -1048580.625L, -1048580L);
10129
10130   TEST_f_f (trunc, 8388610.125L, 8388610.0L);
10131   TEST_f_f (trunc, -8388610.125L, -8388610.0L);
10132
10133   TEST_f_f (trunc, 4294967296.625L, 4294967296.0L);
10134   TEST_f_f (trunc, -4294967296.625L, -4294967296.0L);
10135
10136 #ifdef TEST_LDOUBLE
10137   /* The result can only be represented in long double.  */
10138   TEST_f_f (trunc, 4503599627370495.5L, 4503599627370495.0L);
10139   TEST_f_f (trunc, 4503599627370496.25L, 4503599627370496.0L);
10140   TEST_f_f (trunc, 4503599627370496.5L, 4503599627370496.0L);
10141   TEST_f_f (trunc, 4503599627370496.75L, 4503599627370496.0L);
10142   TEST_f_f (trunc, 4503599627370497.5L, 4503599627370497.0L);
10143
10144 # if LDBL_MANT_DIG > 100
10145   TEST_f_f (trunc, 4503599627370494.5000000000001L, 4503599627370494.0L);
10146   TEST_f_f (trunc, 4503599627370495.5000000000001L, 4503599627370495.0L);
10147   TEST_f_f (trunc, 4503599627370496.5000000000001L, 4503599627370496.0L);
10148 # endif
10149
10150   TEST_f_f (trunc, -4503599627370495.5L, -4503599627370495.0L);
10151   TEST_f_f (trunc, -4503599627370496.25L, -4503599627370496.0L);
10152   TEST_f_f (trunc, -4503599627370496.5L, -4503599627370496.0L);
10153   TEST_f_f (trunc, -4503599627370496.75L, -4503599627370496.0L);
10154   TEST_f_f (trunc, -4503599627370497.5L, -4503599627370497.0L);
10155
10156 # if LDBL_MANT_DIG > 100
10157   TEST_f_f (trunc, -4503599627370494.5000000000001L, -4503599627370494.0L);
10158   TEST_f_f (trunc, -4503599627370495.5000000000001L, -4503599627370495.0L);
10159   TEST_f_f (trunc, -4503599627370496.5000000000001L, -4503599627370496.0L);
10160 # endif
10161
10162   TEST_f_f (trunc, 9007199254740991.5L, 9007199254740991.0L);
10163   TEST_f_f (trunc, 9007199254740992.25L, 9007199254740992.0L);
10164   TEST_f_f (trunc, 9007199254740992.5L, 9007199254740992.0L);
10165   TEST_f_f (trunc, 9007199254740992.75L, 9007199254740992.0L);
10166   TEST_f_f (trunc, 9007199254740993.5L, 9007199254740993.0L);
10167
10168 # if LDBL_MANT_DIG > 100
10169   TEST_f_f (trunc, 9007199254740991.0000000000001L, 9007199254740991.0L);
10170   TEST_f_f (trunc, 9007199254740992.0000000000001L, 9007199254740992.0L);
10171   TEST_f_f (trunc, 9007199254740993.0000000000001L, 9007199254740993.0L);
10172   TEST_f_f (trunc, 9007199254740991.5000000000001L, 9007199254740991.0L);
10173   TEST_f_f (trunc, 9007199254740992.5000000000001L, 9007199254740992.0L);
10174   TEST_f_f (trunc, 9007199254740993.5000000000001L, 9007199254740993.0L);
10175 # endif
10176
10177   TEST_f_f (trunc, -9007199254740991.5L, -9007199254740991.0L);
10178   TEST_f_f (trunc, -9007199254740992.25L, -9007199254740992.0L);
10179   TEST_f_f (trunc, -9007199254740992.5L, -9007199254740992.0L);
10180   TEST_f_f (trunc, -9007199254740992.75L, -9007199254740992.0L);
10181   TEST_f_f (trunc, -9007199254740993.5L, -9007199254740993.0L);
10182
10183 # if LDBL_MANT_DIG > 100
10184   TEST_f_f (trunc, -9007199254740991.0000000000001L, -9007199254740991.0L);
10185   TEST_f_f (trunc, -9007199254740992.0000000000001L, -9007199254740992.0L);
10186   TEST_f_f (trunc, -9007199254740993.0000000000001L, -9007199254740993.0L);
10187   TEST_f_f (trunc, -9007199254740991.5000000000001L, -9007199254740991.0L);
10188   TEST_f_f (trunc, -9007199254740992.5000000000001L, -9007199254740992.0L);
10189   TEST_f_f (trunc, -9007199254740993.5000000000001L, -9007199254740993.0L);
10190 # endif
10191
10192   TEST_f_f (trunc, 72057594037927935.5L, 72057594037927935.0L);
10193   TEST_f_f (trunc, 72057594037927936.25L, 72057594037927936.0L);
10194   TEST_f_f (trunc, 72057594037927936.5L, 72057594037927936.0L);
10195   TEST_f_f (trunc, 72057594037927936.75L, 72057594037927936.0L);
10196   TEST_f_f (trunc, 72057594037927937.5L, 72057594037927937.0L);
10197
10198   TEST_f_f (trunc, -72057594037927935.5L, -72057594037927935.0L);
10199   TEST_f_f (trunc, -72057594037927936.25L, -72057594037927936.0L);
10200   TEST_f_f (trunc, -72057594037927936.5L, -72057594037927936.0L);
10201   TEST_f_f (trunc, -72057594037927936.75L, -72057594037927936.0L);
10202   TEST_f_f (trunc, -72057594037927937.5L, -72057594037927937.0L);
10203
10204   TEST_f_f (trunc, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
10205   TEST_f_f (trunc, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
10206   TEST_f_f (trunc, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
10207   TEST_f_f (trunc, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
10208   TEST_f_f (trunc, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
10209 #endif
10210
10211   END (trunc);
10212 }
10213
10214 static void
10215 y0_test (void)
10216 {
10217   FLOAT s, c;
10218   errno = 0;
10219   FUNC (sincos) (0, &s, &c);
10220   if (errno == ENOSYS)
10221     /* Required function not implemented.  */
10222     return;
10223   FUNC(y0) (1);
10224   if (errno == ENOSYS)
10225     /* Function not implemented.  */
10226     return;
10227
10228   /* y0 is the Bessel function of the second kind of order 0 */
10229   START (y0);
10230
10231   TEST_f_f (y0, -1.0, minus_infty, INVALID_EXCEPTION);
10232   TEST_f_f (y0, -max_value, minus_infty, INVALID_EXCEPTION);
10233   TEST_f_f (y0, 0.0, minus_infty);
10234   TEST_f_f (y0, nan_value, nan_value);
10235   TEST_f_f (y0, plus_infty, 0);
10236
10237   TEST_f_f (y0, 0.125L, -1.38968062514384052915582277745018693L);
10238   TEST_f_f (y0, 0.75L, -0.137172769385772397522814379396581855L);
10239   TEST_f_f (y0, 1.0, 0.0882569642156769579829267660235151628L);
10240   TEST_f_f (y0, 1.5, 0.382448923797758843955068554978089862L);
10241   TEST_f_f (y0, 2.0, 0.510375672649745119596606592727157873L);
10242   TEST_f_f (y0, 8.0, 0.223521489387566220527323400498620359L);
10243   TEST_f_f (y0, 10.0, 0.0556711672835993914244598774101900481L);
10244
10245   TEST_f_f (y0, 0x1.3ffp+74L, 1.818984347516051243459467456433028748678e-12L);
10246
10247 #ifndef TEST_FLOAT
10248   /* Bug 14155: spurious exception may occur.  */
10249   TEST_f_f (y0, 0x1.ff00000000002p+840L, 1.846591691699331493194965158699937660696e-127L, UNDERFLOW_EXCEPTION_OK);
10250 #endif
10251
10252   TEST_f_f (y0, 0x1p-10L, -4.4865150767109739412411806297168793661098L);
10253   TEST_f_f (y0, 0x1p-20L, -8.8992283012125827603076426611387876938160L);
10254   TEST_f_f (y0, 0x1p-30L, -1.3311940304267782826037118027401817264906e+1L);
10255   TEST_f_f (y0, 0x1p-40L, -1.7724652307320814696990854700366226762563e+1L);
10256   TEST_f_f (y0, 0x1p-50L, -2.2137364310373846564919987139743760738155e+1L);
10257   TEST_f_f (y0, 0x1p-60L, -2.6550076313426878432849115782108205929120e+1L);
10258   TEST_f_f (y0, 0x1p-70L, -3.0962788316479910300778244424468159753887e+1L);
10259   TEST_f_f (y0, 0x1p-80L, -3.5375500319532942168707373066828113573541e+1L);
10260   TEST_f_f (y0, 0x1p-90L, -3.9788212322585974036636501709188067393195e+1L);
10261   TEST_f_f (y0, 0x1p-100L, -4.420092432563900590456563035154802121284e+1L);
10262   TEST_f_f (y0, 0x1p-110L, -4.861363632869203777249475899390797503250e+1L);
10263
10264   END (y0);
10265 }
10266
10267
10268 static void
10269 y1_test (void)
10270 {
10271   FLOAT s, c;
10272   errno = 0;
10273   FUNC (sincos) (0, &s, &c);
10274   if (errno == ENOSYS)
10275     /* Required function not implemented.  */
10276     return;
10277   FUNC(y1) (1);
10278   if (errno == ENOSYS)
10279     /* Function not implemented.  */
10280     return;
10281
10282   /* y1 is the Bessel function of the second kind of order 1 */
10283   START (y1);
10284
10285   TEST_f_f (y1, -1.0, minus_infty, INVALID_EXCEPTION);
10286   TEST_f_f (y1, -max_value, minus_infty, INVALID_EXCEPTION);
10287   TEST_f_f (y1, 0.0, minus_infty);
10288   TEST_f_f (y1, plus_infty, 0);
10289   TEST_f_f (y1, nan_value, nan_value);
10290
10291   TEST_f_f (y1, 0.125L, -5.19993611253477499595928744876579921L);
10292   TEST_f_f (y1, 0.75L, -1.03759455076928541973767132140642198L);
10293   TEST_f_f (y1, 1.0, -0.781212821300288716547150000047964821L);
10294   TEST_f_f (y1, 1.5, -0.412308626973911295952829820633445323L);
10295   TEST_f_f (y1, 2.0, -0.107032431540937546888370772277476637L);
10296   TEST_f_f (y1, 8.0, -0.158060461731247494255555266187483550L);
10297   TEST_f_f (y1, 10.0, 0.249015424206953883923283474663222803L);
10298
10299   /* Bug 14155: spurious exception may occur.  */
10300   TEST_f_f (y1, 0x1.27e204p+99L, -8.881610148467797208469612080785210013461e-16L, UNDERFLOW_EXCEPTION_OK);
10301
10302 #ifndef TEST_FLOAT
10303   /* Bug 14155: spurious exception may occur.  */
10304   TEST_f_f (y1, 0x1.001000001p+593L, 3.927269966354206207832593635798954916263e-90L, UNDERFLOW_EXCEPTION_OK);
10305 #endif
10306
10307   TEST_f_f (y1, 0x1p-10L, -6.5190099301063115047395187618929589514382e+02L);
10308   TEST_f_f (y1, 0x1p-20L, -6.6754421443450423911167962313100637952285e+05L);
10309   TEST_f_f (y1, 0x1p-30L, -6.8356527557643159612937462812258975438856e+08L);
10310   TEST_f_f (y1, 0x1p-40L, -6.9997084219026594793707805777425993547887e+11L);
10311   TEST_f_f (y1, 0x1p-50L, -7.1677014240283233068755952926181262431559e+14L);
10312   TEST_f_f (y1, 0x1p-60L, -7.3397262582050030662406095795388448059822e+17L);
10313   TEST_f_f (y1, 0x1p-70L, -7.5158796884019231398303842094477769620063e+20L);
10314   TEST_f_f (y1, 0x1p-80L, -7.6962608009235692951863134304745236090943e+23L);
10315   TEST_f_f (y1, 0x1p-90L, -7.8809710601457349582707849528059121757126e+26L);
10316   TEST_f_f (y1, 0x1p-100L, -8.0701143655892325972692837916732540679297e+29L);
10317   TEST_f_f (y1, 0x1p-110L, -8.2637971103633741796037466026734121655600e+32L);
10318
10319   END (y1);
10320 }
10321
10322
10323 static void
10324 yn_test (void)
10325 {
10326   FLOAT s, c;
10327   errno = 0;
10328   FUNC (sincos) (0, &s, &c);
10329   if (errno == ENOSYS)
10330     /* Required function not implemented.  */
10331     return;
10332   FUNC(yn) (1, 1);
10333   if (errno == ENOSYS)
10334     /* Function not implemented.  */
10335     return;
10336
10337   /* yn is the Bessel function of the second kind of order n */
10338   START (yn);
10339
10340   /* yn (0, x) == y0 (x)  */
10341   TEST_ff_f (yn, 0, -1.0, minus_infty, INVALID_EXCEPTION);
10342   TEST_ff_f (yn, 0, -max_value, minus_infty, INVALID_EXCEPTION);
10343   TEST_ff_f (yn, 0, 0.0, minus_infty);
10344   TEST_ff_f (yn, 0, nan_value, nan_value);
10345   TEST_ff_f (yn, 0, plus_infty, 0);
10346
10347   TEST_ff_f (yn, 0, 0.125L, -1.38968062514384052915582277745018693L);
10348   TEST_ff_f (yn, 0, 0.75L, -0.137172769385772397522814379396581855L);
10349   TEST_ff_f (yn, 0, 1.0, 0.0882569642156769579829267660235151628L);
10350   TEST_ff_f (yn, 0, 1.5, 0.382448923797758843955068554978089862L);
10351   TEST_ff_f (yn, 0, 2.0, 0.510375672649745119596606592727157873L);
10352   TEST_ff_f (yn, 0, 8.0, 0.223521489387566220527323400498620359L);
10353   TEST_ff_f (yn, 0, 10.0, 0.0556711672835993914244598774101900481L);
10354
10355   /* yn (1, x) == y1 (x)  */
10356   TEST_ff_f (yn, 1, -1.0, minus_infty, INVALID_EXCEPTION);
10357   TEST_ff_f (yn, 1, 0.0, minus_infty);
10358   TEST_ff_f (yn, 1, plus_infty, 0);
10359   TEST_ff_f (yn, 1, nan_value, nan_value);
10360
10361   TEST_ff_f (yn, 1, 0.125L, -5.19993611253477499595928744876579921L);
10362   TEST_ff_f (yn, 1, 0.75L, -1.03759455076928541973767132140642198L);
10363   TEST_ff_f (yn, 1, 1.0, -0.781212821300288716547150000047964821L);
10364   TEST_ff_f (yn, 1, 1.5, -0.412308626973911295952829820633445323L);
10365   TEST_ff_f (yn, 1, 2.0, -0.107032431540937546888370772277476637L);
10366   TEST_ff_f (yn, 1, 8.0, -0.158060461731247494255555266187483550L);
10367   TEST_ff_f (yn, 1, 10.0, 0.249015424206953883923283474663222803L);
10368
10369   /* yn (3, x)  */
10370   TEST_ff_f (yn, 3, plus_infty, 0);
10371   TEST_ff_f (yn, 3, nan_value, nan_value);
10372
10373   TEST_ff_f (yn, 3, 0.125L, -2612.69757350066712600220955744091741L);
10374   TEST_ff_f (yn, 3, 0.75L, -12.9877176234475433186319774484809207L);
10375   TEST_ff_f (yn, 3, 1.0, -5.82151760596472884776175706442981440L);
10376   TEST_ff_f (yn, 3, 2.0, -1.12778377684042778608158395773179238L);
10377   TEST_ff_f (yn, 3, 10.0, -0.251362657183837329779204747654240998L);
10378
10379   /* yn (10, x)  */
10380   TEST_ff_f (yn, 10, plus_infty, 0);
10381   TEST_ff_f (yn, 10, nan_value, nan_value);
10382
10383   TEST_ff_f (yn, 10, 0.125L, -127057845771019398.252538486899753195L);
10384   TEST_ff_f (yn, 10, 0.75L, -2133501638.90573424452445412893839236L);
10385   TEST_ff_f (yn, 10, 1.0, -121618014.278689189288130426667971145L);
10386   TEST_ff_f (yn, 10, 2.0, -129184.542208039282635913145923304214L);
10387   TEST_ff_f (yn, 10, 10.0, -0.359814152183402722051986577343560609L);
10388
10389   /* Check whether yn returns correct value for LDBL_MIN, DBL_MIN,
10390      and FLT_MIN.  See Bug 14173.  */
10391   TEST_ff_f (yn, 10, min_value, minus_infty, OVERFLOW_EXCEPTION);
10392
10393   errno = 0;
10394   TEST_ff_f (yn, 10, min_value, minus_infty, OVERFLOW_EXCEPTION);
10395   check_int ("errno for yn(10,-min) == ERANGE", errno, ERANGE, 0, 0, 0);
10396
10397   END (yn);
10398 }
10399
10400
10401 static void
10402 significand_test (void)
10403 {
10404   /* significand returns the mantissa of the exponential representation.  */
10405   START (significand);
10406
10407   TEST_f_f (significand, 4.0, 1.0);
10408   TEST_f_f (significand, 6.0, 1.5);
10409   TEST_f_f (significand, 8.0, 1.0);
10410
10411   END (significand);
10412 }
10413
10414
10415 static void
10416 initialize (void)
10417 {
10418   fpstack_test ("start *init*");
10419   plus_zero = 0.0;
10420   nan_value = plus_zero / plus_zero;    /* Suppress GCC warning */
10421
10422   minus_zero = FUNC(copysign) (0.0, -1.0);
10423   plus_infty = CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF,
10424                        HUGE_VALL, HUGE_VAL, HUGE_VALF);
10425   minus_infty = CHOOSE (-HUGE_VALL, -HUGE_VAL, -HUGE_VALF,
10426                         -HUGE_VALL, -HUGE_VAL, -HUGE_VALF);
10427   max_value = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
10428                       LDBL_MAX, DBL_MAX, FLT_MAX);
10429   min_value = CHOOSE (LDBL_MIN, DBL_MIN, FLT_MIN,
10430                       LDBL_MIN, DBL_MIN, FLT_MIN);
10431   min_subnorm_value = CHOOSE (__LDBL_DENORM_MIN__,
10432                               __DBL_DENORM_MIN__,
10433                               __FLT_DENORM_MIN__,
10434                               __LDBL_DENORM_MIN__,
10435                               __DBL_DENORM_MIN__,
10436                               __FLT_DENORM_MIN__);
10437
10438   (void) &plus_zero;
10439   (void) &nan_value;
10440   (void) &minus_zero;
10441   (void) &plus_infty;
10442   (void) &minus_infty;
10443   (void) &max_value;
10444   (void) &min_value;
10445   (void) &min_subnorm_value;
10446
10447   /* Clear all exceptions.  From now on we must not get random exceptions.  */
10448   feclearexcept (FE_ALL_EXCEPT);
10449
10450   /* Test to make sure we start correctly.  */
10451   fpstack_test ("end *init*");
10452 }
10453
10454 /* Definitions of arguments for argp functions.  */
10455 static const struct argp_option options[] =
10456 {
10457   { "verbose", 'v', "NUMBER", 0, "Level of verbosity (0..3)"},
10458   { "ulps-file", 'u', NULL, 0, "Output ulps to file ULPs"},
10459   { "no-max-error", 'f', NULL, 0,
10460     "Don't output maximal errors of functions"},
10461   { "no-points", 'p', NULL, 0,
10462     "Don't output results of functions invocations"},
10463   { "ignore-max-ulp", 'i', "yes/no", 0,
10464     "Ignore given maximal errors"},
10465   { NULL, 0, NULL, 0, NULL }
10466 };
10467
10468 /* Short description of program.  */
10469 static const char doc[] = "Math test suite: " TEST_MSG ;
10470
10471 /* Prototype for option handler.  */
10472 static error_t parse_opt (int key, char *arg, struct argp_state *state);
10473
10474 /* Data structure to communicate with argp functions.  */
10475 static struct argp argp =
10476 {
10477   options, parse_opt, NULL, doc,
10478 };
10479
10480
10481 /* Handle program arguments.  */
10482 static error_t
10483 parse_opt (int key, char *arg, struct argp_state *state)
10484 {
10485   switch (key)
10486     {
10487     case 'f':
10488       output_max_error = 0;
10489       break;
10490     case 'i':
10491       if (strcmp (arg, "yes") == 0)
10492         ignore_max_ulp = 1;
10493       else if (strcmp (arg, "no") == 0)
10494         ignore_max_ulp = 0;
10495       break;
10496     case 'p':
10497       output_points = 0;
10498       break;
10499     case 'u':
10500       output_ulps = 1;
10501       break;
10502     case 'v':
10503       if (optarg)
10504         verbose = (unsigned int) strtoul (optarg, NULL, 0);
10505       else
10506         verbose = 3;
10507       break;
10508     default:
10509       return ARGP_ERR_UNKNOWN;
10510     }
10511   return 0;
10512 }
10513
10514 #if 0
10515 /* function to check our ulp calculation.  */
10516 void
10517 check_ulp (void)
10518 {
10519   int i;
10520
10521   FLOAT u, diff, ulp;
10522   /* This gives one ulp.  */
10523   u = FUNC(nextafter) (10, 20);
10524   check_equal (10.0, u, 1, &diff, &ulp);
10525   printf ("One ulp: % .4" PRINTF_NEXPR "\n", ulp);
10526
10527   /* This gives one more ulp.  */
10528   u = FUNC(nextafter) (u, 20);
10529   check_equal (10.0, u, 2, &diff, &ulp);
10530   printf ("two ulp: % .4" PRINTF_NEXPR "\n", ulp);
10531
10532   /* And now calculate 100 ulp.  */
10533   for (i = 2; i < 100; i++)
10534     u = FUNC(nextafter) (u, 20);
10535   check_equal (10.0, u, 100, &diff, &ulp);
10536   printf ("100 ulp: % .4" PRINTF_NEXPR "\n", ulp);
10537 }
10538 #endif
10539
10540 int
10541 main (int argc, char **argv)
10542 {
10543
10544   int remaining;
10545
10546   verbose = 1;
10547   output_ulps = 0;
10548   output_max_error = 1;
10549   output_points = 1;
10550   /* XXX set to 0 for releases.  */
10551   ignore_max_ulp = 0;
10552
10553   /* Parse and process arguments.  */
10554   argp_parse (&argp, argc, argv, 0, &remaining, NULL);
10555
10556   if (remaining != argc)
10557     {
10558       fprintf (stderr, "wrong number of arguments");
10559       argp_help (&argp, stdout, ARGP_HELP_SEE, program_invocation_short_name);
10560       exit (EXIT_FAILURE);
10561     }
10562
10563   if (output_ulps)
10564     {
10565       ulps_file = fopen ("ULPs", "a");
10566       if (ulps_file == NULL)
10567         {
10568           perror ("can't open file `ULPs' for writing: ");
10569           exit (1);
10570         }
10571     }
10572
10573
10574   initialize ();
10575   printf (TEST_MSG);
10576
10577 #if 0
10578   check_ulp ();
10579 #endif
10580
10581   /* Keep the tests a wee bit ordered (according to ISO C99).  */
10582   /* Classification macros:  */
10583   finite_test ();
10584   fpclassify_test ();
10585   isfinite_test ();
10586   isinf_test ();
10587   isnan_test ();
10588   isnormal_test ();
10589   signbit_test ();
10590
10591   /* Trigonometric functions:  */
10592   acos_test ();
10593   acos_test_tonearest ();
10594   acos_test_towardzero ();
10595   acos_test_downward ();
10596   acos_test_upward ();
10597   asin_test ();
10598   asin_test_tonearest ();
10599   asin_test_towardzero ();
10600   asin_test_downward ();
10601   asin_test_upward ();
10602   atan_test ();
10603   atan2_test ();
10604   cos_test ();
10605   cos_test_tonearest ();
10606   cos_test_towardzero ();
10607   cos_test_downward ();
10608   cos_test_upward ();
10609   sin_test ();
10610   sin_test_tonearest ();
10611   sin_test_towardzero ();
10612   sin_test_downward ();
10613   sin_test_upward ();
10614   sincos_test ();
10615   tan_test ();
10616   tan_test_tonearest ();
10617   tan_test_towardzero ();
10618   tan_test_downward ();
10619   tan_test_upward ();
10620
10621   /* Hyperbolic functions:  */
10622   acosh_test ();
10623   asinh_test ();
10624   atanh_test ();
10625   cosh_test ();
10626   cosh_test_tonearest ();
10627   cosh_test_towardzero ();
10628   cosh_test_downward ();
10629   cosh_test_upward ();
10630   sinh_test ();
10631   sinh_test_tonearest ();
10632   sinh_test_towardzero ();
10633   sinh_test_downward ();
10634   sinh_test_upward ();
10635   tanh_test ();
10636
10637   /* Exponential and logarithmic functions:  */
10638   exp_test ();
10639   exp_test_tonearest ();
10640   exp_test_towardzero ();
10641   exp_test_downward ();
10642   exp_test_upward ();
10643   exp10_test ();
10644   exp2_test ();
10645   expm1_test ();
10646   frexp_test ();
10647   ldexp_test ();
10648   log_test ();
10649   log10_test ();
10650   log1p_test ();
10651   log2_test ();
10652   logb_test ();
10653   logb_test_downward ();
10654   modf_test ();
10655   ilogb_test ();
10656   scalb_test ();
10657   scalbn_test ();
10658   scalbln_test ();
10659   significand_test ();
10660
10661   /* Power and absolute value functions:  */
10662   cbrt_test ();
10663   fabs_test ();
10664   hypot_test ();
10665   pow_test ();
10666   pow_test_tonearest ();
10667   pow_test_towardzero ();
10668   pow_test_downward ();
10669   pow_test_upward ();
10670   sqrt_test ();
10671
10672   /* Error and gamma functions:  */
10673   erf_test ();
10674   erfc_test ();
10675   gamma_test ();
10676   lgamma_test ();
10677   tgamma_test ();
10678
10679   /* Nearest integer functions:  */
10680   ceil_test ();
10681   floor_test ();
10682   nearbyint_test ();
10683   rint_test ();
10684   rint_test_tonearest ();
10685   rint_test_towardzero ();
10686   rint_test_downward ();
10687   rint_test_upward ();
10688   lrint_test ();
10689   lrint_test_tonearest ();
10690   lrint_test_towardzero ();
10691   lrint_test_downward ();
10692   lrint_test_upward ();
10693   llrint_test ();
10694   llrint_test_tonearest ();
10695   llrint_test_towardzero ();
10696   llrint_test_downward ();
10697   llrint_test_upward ();
10698   round_test ();
10699   lround_test ();
10700   llround_test ();
10701   trunc_test ();
10702
10703   /* Remainder functions:  */
10704   fmod_test ();
10705   remainder_test ();
10706   remquo_test ();
10707
10708   /* Manipulation functions:  */
10709   copysign_test ();
10710   nextafter_test ();
10711   nexttoward_test ();
10712
10713   /* maximum, minimum and positive difference functions */
10714   fdim_test ();
10715   fmax_test ();
10716   fmin_test ();
10717
10718   /* Multiply and add:  */
10719   fma_test ();
10720   fma_test_towardzero ();
10721   fma_test_downward ();
10722   fma_test_upward ();
10723
10724   /* Comparison macros:  */
10725   isgreater_test ();
10726   isgreaterequal_test ();
10727   isless_test ();
10728   islessequal_test ();
10729   islessgreater_test ();
10730   isunordered_test ();
10731
10732   /* Complex functions:  */
10733   cabs_test ();
10734   cacos_test ();
10735   cacosh_test ();
10736   carg_test ();
10737   casin_test ();
10738   casinh_test ();
10739   catan_test ();
10740   catanh_test ();
10741   ccos_test ();
10742   ccosh_test ();
10743   cexp_test ();
10744   cimag_test ();
10745   clog10_test ();
10746   clog_test ();
10747   conj_test ();
10748   cpow_test ();
10749   cproj_test ();
10750   creal_test ();
10751   csin_test ();
10752   csinh_test ();
10753   csqrt_test ();
10754   ctan_test ();
10755   ctan_test_tonearest ();
10756   ctan_test_towardzero ();
10757   ctan_test_downward ();
10758   ctan_test_upward ();
10759   ctanh_test ();
10760   ctanh_test_tonearest ();
10761   ctanh_test_towardzero ();
10762   ctanh_test_downward ();
10763   ctanh_test_upward ();
10764
10765   /* Bessel functions:  */
10766   j0_test ();
10767   j1_test ();
10768   jn_test ();
10769   y0_test ();
10770   y1_test ();
10771   yn_test ();
10772
10773   if (output_ulps)
10774     fclose (ulps_file);
10775
10776   printf ("\nTest suite completed:\n");
10777   printf ("  %d test cases plus %d tests for exception flags executed.\n",
10778           noTests, noExcTests);
10779   if (noXFails)
10780     printf ("  %d expected failures occurred.\n", noXFails);
10781   if (noXPasses)
10782     printf ("  %d unexpected passes occurred.\n", noXPasses);
10783   if (noErrors)
10784     {
10785       printf ("  %d errors occurred.\n", noErrors);
10786       return 1;
10787     }
10788   printf ("  All tests passed successfully.\n");
10789
10790   return 0;
10791 }
10792
10793 /*
10794  * Local Variables:
10795  * mode:c
10796  * End:
10797  */