math/libm-test.inc

   1 /* Copyright (C) 1997-2006, 2007, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Andreas Jaeger <aj@suse.de>, 1997.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 /* Part of testsuite for libm.
  20
  21    This file is processed by a perl script.  The resulting file has to
  22    be included by a master file that defines:
  23
  24    Macros:
  25    FUNC(function): converts general function name (like cos) to
  26    name with correct suffix (e.g. cosl or cosf)
  27    MATHCONST(x):   like FUNC but for constants (e.g convert 0.0 to 0.0L)
  28    FLOAT:          floating point type to test
  29    - TEST_MSG:     informal message to be displayed
  30    CHOOSE(Clongdouble,Cdouble,Cfloat,Cinlinelongdouble,Cinlinedouble,Cinlinefloat):
  31    chooses one of the parameters as delta for testing
  32    equality
  33    PRINTF_EXPR     Floating point conversion specification to print a variable
  34    of type FLOAT with printf.  PRINTF_EXPR just contains
  35    the specifier, not the percent and width arguments,
  36    e.g. "f".
  37    PRINTF_XEXPR    Like PRINTF_EXPR, but print in hexadecimal format.
  38    PRINTF_NEXPR Like PRINTF_EXPR, but print nice.  */
  39
  40 /* This testsuite has currently tests for:
  41    acos, acosh, asin, asinh, atan, atan2, atanh,
  42    cbrt, ceil, copysign, cos, cosh, erf, erfc, exp, exp10, exp2, expm1,
  43    fabs, fdim, 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   END (atan);
1199 }
1200
1201
1202
1203 static void
1204 atanh_test (void)
1205 {
1206   errno = 0;
1207   FUNC(atanh) (0.7L);
1208   if (errno == ENOSYS)
1209     /* Function not implemented.  */
1210     return;
1211
1212   START (atanh);
1213
1214
1215   TEST_f_f (atanh, 0, 0);
1216   TEST_f_f (atanh, minus_zero, minus_zero);
1217
1218   TEST_f_f (atanh, 1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
1219   TEST_f_f (atanh, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
1220   TEST_f_f (atanh, nan_value, nan_value);
1221
1222   /* atanh (x) == NaN plus invalid exception if |x| > 1.  */
1223   TEST_f_f (atanh, 1.125L, nan_value, INVALID_EXCEPTION);
1224   TEST_f_f (atanh, -1.125L, nan_value, INVALID_EXCEPTION);
1225   TEST_f_f (atanh, max_value, nan_value, INVALID_EXCEPTION);
1226   TEST_f_f (atanh, -max_value, nan_value, INVALID_EXCEPTION);
1227
1228   TEST_f_f (atanh, 0.75L, 0.972955074527656652552676371721589865L);
1229
1230   END (atanh);
1231 }
1232
1233 static void
1234 atan2_test (void)
1235 {
1236   errno = 0;
1237   FUNC(atan2) (-0, 1);
1238   if (errno == ENOSYS)
1239     /* Function not implemented.  */
1240     return;
1241
1242   START (atan2);
1243
1244   /* atan2 (0,x) == 0 for x > 0.  */
1245   TEST_ff_f (atan2, 0, 1, 0);
1246
1247   /* atan2 (-0,x) == -0 for x > 0.  */
1248   TEST_ff_f (atan2, minus_zero, 1, minus_zero);
1249
1250   TEST_ff_f (atan2, 0, 0, 0);
1251   TEST_ff_f (atan2, minus_zero, 0, minus_zero);
1252
1253   /* atan2 (+0,x) == +pi for x < 0.  */
1254   TEST_ff_f (atan2, 0, -1, M_PIl);
1255
1256   /* atan2 (-0,x) == -pi for x < 0.  */
1257   TEST_ff_f (atan2, minus_zero, -1, -M_PIl);
1258
1259   TEST_ff_f (atan2, 0, minus_zero, M_PIl);
1260   TEST_ff_f (atan2, minus_zero, minus_zero, -M_PIl);
1261
1262   /* atan2 (y,+0) == pi/2 for y > 0.  */
1263   TEST_ff_f (atan2, 1, 0, M_PI_2l);
1264
1265   /* atan2 (y,-0) == pi/2 for y > 0.  */
1266   TEST_ff_f (atan2, 1, minus_zero, M_PI_2l);
1267
1268   /* atan2 (y,+0) == -pi/2 for y < 0.  */
1269   TEST_ff_f (atan2, -1, 0, -M_PI_2l);
1270
1271   /* atan2 (y,-0) == -pi/2 for y < 0.  */
1272   TEST_ff_f (atan2, -1, minus_zero, -M_PI_2l);
1273
1274   /* atan2 (y,inf) == +0 for finite y > 0.  */
1275   TEST_ff_f (atan2, 1, plus_infty, 0);
1276
1277   /* atan2 (y,inf) == -0 for finite y < 0.  */
1278   TEST_ff_f (atan2, -1, plus_infty, minus_zero);
1279
1280   /* atan2(+inf, x) == pi/2 for finite x.  */
1281   TEST_ff_f (atan2, plus_infty, -1, M_PI_2l);
1282
1283   /* atan2(-inf, x) == -pi/2 for finite x.  */
1284   TEST_ff_f (atan2, minus_infty, 1, -M_PI_2l);
1285
1286   /* atan2 (y,-inf) == +pi for finite y > 0.  */
1287   TEST_ff_f (atan2, 1, minus_infty, M_PIl);
1288
1289   /* atan2 (y,-inf) == -pi for finite y < 0.  */
1290   TEST_ff_f (atan2, -1, minus_infty, -M_PIl);
1291
1292   TEST_ff_f (atan2, plus_infty, plus_infty, M_PI_4l);
1293   TEST_ff_f (atan2, minus_infty, plus_infty, -M_PI_4l);
1294   TEST_ff_f (atan2, plus_infty, minus_infty, M_PI_34l);
1295   TEST_ff_f (atan2, minus_infty, minus_infty, -M_PI_34l);
1296   TEST_ff_f (atan2, nan_value, nan_value, nan_value);
1297
1298   TEST_ff_f (atan2, max_value, max_value, M_PI_4l);
1299
1300   TEST_ff_f (atan2, max_value, min_value, M_PI_2l);
1301   TEST_ff_f (atan2, -max_value, -min_value, -M_PI_2l);
1302
1303   TEST_ff_f (atan2, 0.75L, 1, 0.643501108793284386802809228717322638L);
1304   TEST_ff_f (atan2, -0.75L, 1.0L, -0.643501108793284386802809228717322638L);
1305   TEST_ff_f (atan2, 0.75L, -1.0L, 2.49809154479650885165983415456218025L);
1306   TEST_ff_f (atan2, -0.75L, -1.0L, -2.49809154479650885165983415456218025L);
1307   TEST_ff_f (atan2, 0.390625L, .00029L, 1.57005392693128974780151246612928941L);
1308   TEST_ff_f (atan2, 1.390625L, 0.9296875L, 0.981498387184244311516296577615519772L);
1309
1310   TEST_ff_f (atan2, -0.00756827042671106339L, -.001792735857538728036L, -1.80338464113663849327153994379639112L);
1311 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
1312   TEST_ff_f (atan2, 0x1.00000000000001p0L, 0x1.00000000000001p0L, M_PI_4l);
1313 #endif
1314
1315   END (atan2);
1316 }
1317
1318 static void
1319 cabs_test (void)
1320 {
1321   errno = 0;
1322   FUNC(cabs) (BUILD_COMPLEX (0.7L, 12.4L));
1323   if (errno == ENOSYS)
1324     /* Function not implemented.  */
1325     return;
1326
1327   START (cabs);
1328
1329   /* cabs (x + iy) is specified as hypot (x,y) */
1330
1331   /* cabs (+inf + i x) == +inf.  */
1332   TEST_c_f (cabs, plus_infty, 1.0, plus_infty);
1333   /* cabs (-inf + i x) == +inf.  */
1334   TEST_c_f (cabs, minus_infty, 1.0, plus_infty);
1335
1336   TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
1337   TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
1338
1339   TEST_c_f (cabs, nan_value, nan_value, nan_value);
1340
1341   /* cabs (x,y) == cabs (y,x).  */
1342   TEST_c_f (cabs, 0.75L, 12.390625L, 12.4133028598606664302388810868156657L);
1343   /* cabs (x,y) == cabs (-x,y).  */
1344   TEST_c_f (cabs, -12.390625L, 0.75L, 12.4133028598606664302388810868156657L);
1345   /* cabs (x,y) == cabs (-y,x).  */
1346   TEST_c_f (cabs, -0.75L, 12.390625L, 12.4133028598606664302388810868156657L);
1347   /* cabs (x,y) == cabs (-x,-y).  */
1348   TEST_c_f (cabs, -12.390625L, -0.75L, 12.4133028598606664302388810868156657L);
1349   /* cabs (x,y) == cabs (-y,-x).  */
1350   TEST_c_f (cabs, -0.75L, -12.390625L, 12.4133028598606664302388810868156657L);
1351   /* cabs (x,0) == fabs (x).  */
1352   TEST_c_f (cabs, -0.75L, 0, 0.75L);
1353   TEST_c_f (cabs, 0.75L, 0, 0.75L);
1354   TEST_c_f (cabs, -1.0L, 0, 1.0L);
1355   TEST_c_f (cabs, 1.0L, 0, 1.0L);
1356   TEST_c_f (cabs, -5.7e7L, 0, 5.7e7L);
1357   TEST_c_f (cabs, 5.7e7L, 0, 5.7e7L);
1358
1359   TEST_c_f (cabs, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
1360
1361   END (cabs);
1362 }
1363
1364
1365 static void
1366 cacos_test (void)
1367 {
1368   errno = 0;
1369   FUNC(cacos) (BUILD_COMPLEX (0.7L, 1.2L));
1370   if (errno == ENOSYS)
1371     /* Function not implemented.  */
1372     return;
1373
1374   START (cacos);
1375
1376
1377   TEST_c_c (cacos, 0, 0, M_PI_2l, minus_zero);
1378   TEST_c_c (cacos, minus_zero, 0, M_PI_2l, minus_zero);
1379   TEST_c_c (cacos, minus_zero, minus_zero, M_PI_2l, 0.0);
1380   TEST_c_c (cacos, 0, minus_zero, M_PI_2l, 0.0);
1381
1382   TEST_c_c (cacos, minus_infty, plus_infty, M_PI_34l, minus_infty);
1383   TEST_c_c (cacos, minus_infty, minus_infty, M_PI_34l, plus_infty);
1384
1385   TEST_c_c (cacos, plus_infty, plus_infty, M_PI_4l, minus_infty);
1386   TEST_c_c (cacos, plus_infty, minus_infty, M_PI_4l, plus_infty);
1387
1388   TEST_c_c (cacos, -10.0, plus_infty, M_PI_2l, minus_infty);
1389   TEST_c_c (cacos, -10.0, minus_infty, M_PI_2l, plus_infty);
1390   TEST_c_c (cacos, 0, plus_infty, M_PI_2l, minus_infty);
1391   TEST_c_c (cacos, 0, minus_infty, M_PI_2l, plus_infty);
1392   TEST_c_c (cacos, 0.1L, plus_infty, M_PI_2l, minus_infty);
1393   TEST_c_c (cacos, 0.1L, minus_infty, M_PI_2l, plus_infty);
1394
1395   TEST_c_c (cacos, minus_infty, 0, M_PIl, minus_infty);
1396   TEST_c_c (cacos, minus_infty, minus_zero, M_PIl, plus_infty);
1397   TEST_c_c (cacos, minus_infty, 100, M_PIl, minus_infty);
1398   TEST_c_c (cacos, minus_infty, -100, M_PIl, plus_infty);
1399
1400   TEST_c_c (cacos, plus_infty, 0, 0.0, minus_infty);
1401   TEST_c_c (cacos, plus_infty, minus_zero, 0.0, plus_infty);
1402   TEST_c_c (cacos, plus_infty, 0.5, 0.0, minus_infty);
1403   TEST_c_c (cacos, plus_infty, -0.5, 0.0, plus_infty);
1404
1405   TEST_c_c (cacos, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1406   TEST_c_c (cacos, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1407
1408   TEST_c_c (cacos, 0, nan_value, M_PI_2l, nan_value);
1409   TEST_c_c (cacos, minus_zero, nan_value, M_PI_2l, nan_value);
1410
1411   TEST_c_c (cacos, nan_value, plus_infty, nan_value, minus_infty);
1412   TEST_c_c (cacos, nan_value, minus_infty, nan_value, plus_infty);
1413
1414   TEST_c_c (cacos, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1415   TEST_c_c (cacos, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1416
1417   TEST_c_c (cacos, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1418   TEST_c_c (cacos, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1419
1420   TEST_c_c (cacos, nan_value, nan_value, nan_value, nan_value);
1421
1422   TEST_c_c (cacos, plus_zero, -1.5L, M_PI_2l, 1.194763217287109304111930828519090523536L);
1423   TEST_c_c (cacos, minus_zero, -1.5L, M_PI_2l, 1.194763217287109304111930828519090523536L);
1424   TEST_c_c (cacos, plus_zero, -1.0L, M_PI_2l, 0.8813735870195430252326093249797923090282L);
1425   TEST_c_c (cacos, minus_zero, -1.0L, M_PI_2l, 0.8813735870195430252326093249797923090282L);
1426   TEST_c_c (cacos, plus_zero, -0.5L, M_PI_2l, 0.4812118250596034474977589134243684231352L);
1427   TEST_c_c (cacos, minus_zero, -0.5L, M_PI_2l, 0.4812118250596034474977589134243684231352L);
1428   TEST_c_c (cacos, plus_zero, 0.5L, M_PI_2l, -0.4812118250596034474977589134243684231352L);
1429   TEST_c_c (cacos, minus_zero, 0.5L, M_PI_2l, -0.4812118250596034474977589134243684231352L);
1430   TEST_c_c (cacos, plus_zero, 1.0L, M_PI_2l, -0.8813735870195430252326093249797923090282L);
1431   TEST_c_c (cacos, minus_zero, 1.0L, M_PI_2l, -0.8813735870195430252326093249797923090282L);
1432   TEST_c_c (cacos, plus_zero, 1.5L, M_PI_2l, -1.194763217287109304111930828519090523536L);
1433   TEST_c_c (cacos, minus_zero, 1.5L, M_PI_2l, -1.194763217287109304111930828519090523536L);
1434
1435   TEST_c_c (cacos, -1.5L, plus_zero, M_PIl, -0.9624236501192068949955178268487368462704L);
1436   TEST_c_c (cacos, -1.5L, minus_zero, M_PIl, 0.9624236501192068949955178268487368462704L);
1437   TEST_c_c (cacos, -1.0L, plus_zero, M_PIl, minus_zero);
1438   TEST_c_c (cacos, -1.0L, minus_zero, M_PIl, plus_zero);
1439   TEST_c_c (cacos, -0.5L, plus_zero, 2.094395102393195492308428922186335256131L, minus_zero);
1440   TEST_c_c (cacos, -0.5L, minus_zero, 2.094395102393195492308428922186335256131L, plus_zero);
1441   TEST_c_c (cacos, 0.5L, plus_zero, 1.047197551196597746154214461093167628066L, minus_zero);
1442   TEST_c_c (cacos, 0.5L, minus_zero, 1.047197551196597746154214461093167628066L, plus_zero);
1443   TEST_c_c (cacos, 1.0L, plus_zero, plus_zero, minus_zero);
1444   TEST_c_c (cacos, 1.0L, minus_zero, plus_zero, plus_zero);
1445   TEST_c_c (cacos, 1.5L, plus_zero, plus_zero, -0.9624236501192068949955178268487368462704L);
1446   TEST_c_c (cacos, 1.5L, minus_zero, plus_zero, 0.9624236501192068949955178268487368462704L);
1447
1448   TEST_c_c (cacos, 0.75L, 1.25L, 1.11752014915610270578240049553777969L, -1.13239363160530819522266333696834467L);
1449   TEST_c_c (cacos, -2, -3, 2.1414491111159960199416055713254211L, 1.9833870299165354323470769028940395L);
1450
1451   END (cacos, complex);
1452 }
1453
1454 static void
1455 cacosh_test (void)
1456 {
1457   errno = 0;
1458   FUNC(cacosh) (BUILD_COMPLEX (0.7L, 1.2L));
1459   if (errno == ENOSYS)
1460     /* Function not implemented.  */
1461     return;
1462
1463   START (cacosh);
1464
1465
1466   TEST_c_c (cacosh, 0, 0, 0.0, M_PI_2l);
1467   TEST_c_c (cacosh, minus_zero, 0, 0.0, M_PI_2l);
1468   TEST_c_c (cacosh, 0, minus_zero, 0.0, -M_PI_2l);
1469   TEST_c_c (cacosh, minus_zero, minus_zero, 0.0, -M_PI_2l);
1470   TEST_c_c (cacosh, minus_infty, plus_infty, plus_infty, M_PI_34l);
1471   TEST_c_c (cacosh, minus_infty, minus_infty, plus_infty, -M_PI_34l);
1472
1473   TEST_c_c (cacosh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1474   TEST_c_c (cacosh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1475
1476   TEST_c_c (cacosh, -10.0, plus_infty, plus_infty, M_PI_2l);
1477   TEST_c_c (cacosh, -10.0, minus_infty, plus_infty, -M_PI_2l);
1478   TEST_c_c (cacosh, 0, plus_infty, plus_infty, M_PI_2l);
1479   TEST_c_c (cacosh, 0, minus_infty, plus_infty, -M_PI_2l);
1480   TEST_c_c (cacosh, 0.1L, plus_infty, plus_infty, M_PI_2l);
1481   TEST_c_c (cacosh, 0.1L, minus_infty, plus_infty, -M_PI_2l);
1482
1483   TEST_c_c (cacosh, minus_infty, 0, plus_infty, M_PIl);
1484   TEST_c_c (cacosh, minus_infty, minus_zero, plus_infty, -M_PIl);
1485   TEST_c_c (cacosh, minus_infty, 100, plus_infty, M_PIl);
1486   TEST_c_c (cacosh, minus_infty, -100, plus_infty, -M_PIl);
1487
1488   TEST_c_c (cacosh, plus_infty, 0, plus_infty, 0.0);
1489   TEST_c_c (cacosh, plus_infty, minus_zero, plus_infty, minus_zero);
1490   TEST_c_c (cacosh, plus_infty, 0.5, plus_infty, 0.0);
1491   TEST_c_c (cacosh, plus_infty, -0.5, plus_infty, minus_zero);
1492
1493   TEST_c_c (cacosh, plus_infty, nan_value, plus_infty, nan_value);
1494   TEST_c_c (cacosh, minus_infty, nan_value, plus_infty, nan_value);
1495
1496   TEST_c_c (cacosh, 0, nan_value, nan_value, nan_value);
1497   TEST_c_c (cacosh, minus_zero, nan_value, nan_value, nan_value);
1498
1499   TEST_c_c (cacosh, nan_value, plus_infty, plus_infty, nan_value);
1500   TEST_c_c (cacosh, nan_value, minus_infty, plus_infty, nan_value);
1501
1502   TEST_c_c (cacosh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1503   TEST_c_c (cacosh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1504
1505   TEST_c_c (cacosh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1506   TEST_c_c (cacosh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1507
1508   TEST_c_c (cacosh, nan_value, nan_value, nan_value, nan_value);
1509
1510   TEST_c_c (cacosh, plus_zero, -1.5L, 1.194763217287109304111930828519090523536L, -M_PI_2l);
1511   TEST_c_c (cacosh, minus_zero, -1.5L, 1.194763217287109304111930828519090523536L, -M_PI_2l);
1512   TEST_c_c (cacosh, plus_zero, -1.0L, 0.8813735870195430252326093249797923090282L, -M_PI_2l);
1513   TEST_c_c (cacosh, minus_zero, -1.0L, 0.8813735870195430252326093249797923090282L, -M_PI_2l);
1514   TEST_c_c (cacosh, plus_zero, -0.5L, 0.4812118250596034474977589134243684231352L, -M_PI_2l);
1515   TEST_c_c (cacosh, minus_zero, -0.5L, 0.4812118250596034474977589134243684231352L, -M_PI_2l);
1516   TEST_c_c (cacosh, plus_zero, 0.5L, 0.4812118250596034474977589134243684231352L, M_PI_2l);
1517   TEST_c_c (cacosh, minus_zero, 0.5L, 0.4812118250596034474977589134243684231352L, M_PI_2l);
1518   TEST_c_c (cacosh, plus_zero, 1.0L, 0.8813735870195430252326093249797923090282L, M_PI_2l);
1519   TEST_c_c (cacosh, minus_zero, 1.0L, 0.8813735870195430252326093249797923090282L, M_PI_2l);
1520   TEST_c_c (cacosh, plus_zero, 1.5L, 1.194763217287109304111930828519090523536L, M_PI_2l);
1521   TEST_c_c (cacosh, minus_zero, 1.5L, 1.194763217287109304111930828519090523536L, M_PI_2l);
1522
1523   TEST_c_c (cacosh, -1.5L, plus_zero, 0.9624236501192068949955178268487368462704L, M_PIl);
1524   TEST_c_c (cacosh, -1.5L, minus_zero, 0.9624236501192068949955178268487368462704L, -M_PIl);
1525   TEST_c_c (cacosh, -1.0L, plus_zero, plus_zero, M_PIl);
1526   TEST_c_c (cacosh, -1.0L, minus_zero, plus_zero, -M_PIl);
1527   TEST_c_c (cacosh, -0.5L, plus_zero, plus_zero, 2.094395102393195492308428922186335256131L);
1528   TEST_c_c (cacosh, -0.5L, minus_zero, plus_zero, -2.094395102393195492308428922186335256131L);
1529   TEST_c_c (cacosh, 0.5L, plus_zero, plus_zero, 1.047197551196597746154214461093167628066L);
1530   TEST_c_c (cacosh, 0.5L, minus_zero, plus_zero, -1.047197551196597746154214461093167628066L);
1531   TEST_c_c (cacosh, 1.0L, plus_zero, plus_zero, plus_zero);
1532   TEST_c_c (cacosh, 1.0L, minus_zero, plus_zero, minus_zero);
1533   TEST_c_c (cacosh, 1.5L, plus_zero, 0.9624236501192068949955178268487368462704L, plus_zero);
1534   TEST_c_c (cacosh, 1.5L, minus_zero, 0.9624236501192068949955178268487368462704L, minus_zero);
1535
1536   TEST_c_c (cacosh, 0.75L, 1.25L, 1.13239363160530819522266333696834467L, 1.11752014915610270578240049553777969L);
1537   TEST_c_c (cacosh, -2, -3, 1.9833870299165354323470769028940395L, -2.1414491111159960199416055713254211L);
1538
1539   END (cacosh, complex);
1540 }
1541
1542
1543 static void
1544 carg_test (void)
1545 {
1546   START (carg);
1547
1548   /* carg (x + iy) is specified as atan2 (y, x) */
1549
1550   /* carg (x + i 0) == 0 for x > 0.  */
1551   TEST_c_f (carg, 2.0, 0, 0);
1552   /* carg (x - i 0) == -0 for x > 0.  */
1553   TEST_c_f (carg, 2.0, minus_zero, minus_zero);
1554
1555   TEST_c_f (carg, 0, 0, 0);
1556   TEST_c_f (carg, 0, minus_zero, minus_zero);
1557
1558   /* carg (x + i 0) == +pi for x < 0.  */
1559   TEST_c_f (carg, -2.0, 0, M_PIl);
1560
1561   /* carg (x - i 0) == -pi for x < 0.  */
1562   TEST_c_f (carg, -2.0, minus_zero, -M_PIl);
1563
1564   TEST_c_f (carg, minus_zero, 0, M_PIl);
1565   TEST_c_f (carg, minus_zero, minus_zero, -M_PIl);
1566
1567   /* carg (+0 + i y) == pi/2 for y > 0.  */
1568   TEST_c_f (carg, 0, 2.0, M_PI_2l);
1569
1570   /* carg (-0 + i y) == pi/2 for y > 0.  */
1571   TEST_c_f (carg, minus_zero, 2.0, M_PI_2l);
1572
1573   /* carg (+0 + i y) == -pi/2 for y < 0.  */
1574   TEST_c_f (carg, 0, -2.0, -M_PI_2l);
1575
1576   /* carg (-0 + i y) == -pi/2 for y < 0.  */
1577   TEST_c_f (carg, minus_zero, -2.0, -M_PI_2l);
1578
1579   /* carg (inf + i y) == +0 for finite y > 0.  */
1580   TEST_c_f (carg, plus_infty, 2.0, 0);
1581
1582   /* carg (inf + i y) == -0 for finite y < 0.  */
1583   TEST_c_f (carg, plus_infty, -2.0, minus_zero);
1584
1585   /* carg(x + i inf) == pi/2 for finite x.  */
1586   TEST_c_f (carg, 10.0, plus_infty, M_PI_2l);
1587
1588   /* carg(x - i inf) == -pi/2 for finite x.  */
1589   TEST_c_f (carg, 10.0, minus_infty, -M_PI_2l);
1590
1591   /* carg (-inf + i y) == +pi for finite y > 0.  */
1592   TEST_c_f (carg, minus_infty, 10.0, M_PIl);
1593
1594   /* carg (-inf + i y) == -pi for finite y < 0.  */
1595   TEST_c_f (carg, minus_infty, -10.0, -M_PIl);
1596
1597   TEST_c_f (carg, plus_infty, plus_infty, M_PI_4l);
1598
1599   TEST_c_f (carg, plus_infty, minus_infty, -M_PI_4l);
1600
1601   TEST_c_f (carg, minus_infty, plus_infty, 3 * M_PI_4l);
1602
1603   TEST_c_f (carg, minus_infty, minus_infty, -3 * M_PI_4l);
1604
1605   TEST_c_f (carg, nan_value, nan_value, nan_value);
1606
1607   END (carg);
1608 }
1609
1610 static void
1611 casin_test (void)
1612 {
1613   errno = 0;
1614   FUNC(casin) (BUILD_COMPLEX (0.7L, 1.2L));
1615   if (errno == ENOSYS)
1616     /* Function not implemented.  */
1617     return;
1618
1619   START (casin);
1620
1621   TEST_c_c (casin, 0, 0, 0.0, 0.0);
1622   TEST_c_c (casin, minus_zero, 0, minus_zero, 0.0);
1623   TEST_c_c (casin, 0, minus_zero, 0.0, minus_zero);
1624   TEST_c_c (casin, minus_zero, minus_zero, minus_zero, minus_zero);
1625
1626   TEST_c_c (casin, plus_infty, plus_infty, M_PI_4l, plus_infty);
1627   TEST_c_c (casin, plus_infty, minus_infty, M_PI_4l, minus_infty);
1628   TEST_c_c (casin, minus_infty, plus_infty, -M_PI_4l, plus_infty);
1629   TEST_c_c (casin, minus_infty, minus_infty, -M_PI_4l, minus_infty);
1630
1631   TEST_c_c (casin, -10.0, plus_infty, minus_zero, plus_infty);
1632   TEST_c_c (casin, -10.0, minus_infty, minus_zero, minus_infty);
1633   TEST_c_c (casin, 0, plus_infty, 0.0, plus_infty);
1634   TEST_c_c (casin, 0, minus_infty, 0.0, minus_infty);
1635   TEST_c_c (casin, minus_zero, plus_infty, minus_zero, plus_infty);
1636   TEST_c_c (casin, minus_zero, minus_infty, minus_zero, minus_infty);
1637   TEST_c_c (casin, 0.1L, plus_infty, 0.0, plus_infty);
1638   TEST_c_c (casin, 0.1L, minus_infty, 0.0, minus_infty);
1639
1640   TEST_c_c (casin, minus_infty, 0, -M_PI_2l, plus_infty);
1641   TEST_c_c (casin, minus_infty, minus_zero, -M_PI_2l, minus_infty);
1642   TEST_c_c (casin, minus_infty, 100, -M_PI_2l, plus_infty);
1643   TEST_c_c (casin, minus_infty, -100, -M_PI_2l, minus_infty);
1644
1645   TEST_c_c (casin, plus_infty, 0, M_PI_2l, plus_infty);
1646   TEST_c_c (casin, plus_infty, minus_zero, M_PI_2l, minus_infty);
1647   TEST_c_c (casin, plus_infty, 0.5, M_PI_2l, plus_infty);
1648   TEST_c_c (casin, plus_infty, -0.5, M_PI_2l, minus_infty);
1649
1650   TEST_c_c (casin, nan_value, plus_infty, nan_value, plus_infty);
1651   TEST_c_c (casin, nan_value, minus_infty, nan_value, minus_infty);
1652
1653   TEST_c_c (casin, 0.0, nan_value, 0.0, nan_value);
1654   TEST_c_c (casin, minus_zero, nan_value, minus_zero, nan_value);
1655
1656   TEST_c_c (casin, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1657   TEST_c_c (casin, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1658
1659   TEST_c_c (casin, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1660   TEST_c_c (casin, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1661
1662   TEST_c_c (casin, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1663   TEST_c_c (casin, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1664
1665   TEST_c_c (casin, nan_value, nan_value, nan_value, nan_value);
1666
1667   TEST_c_c (casin, plus_zero, -1.5L, plus_zero, -1.194763217287109304111930828519090523536L);
1668   TEST_c_c (casin, minus_zero, -1.5L, minus_zero, -1.194763217287109304111930828519090523536L);
1669   TEST_c_c (casin, plus_zero, -1.0L, plus_zero, -0.8813735870195430252326093249797923090282L);
1670   TEST_c_c (casin, minus_zero, -1.0L, minus_zero, -0.8813735870195430252326093249797923090282L);
1671   TEST_c_c (casin, plus_zero, -0.5L, plus_zero, -0.4812118250596034474977589134243684231352L);
1672   TEST_c_c (casin, minus_zero, -0.5L, minus_zero, -0.4812118250596034474977589134243684231352L);
1673   TEST_c_c (casin, plus_zero, 0.5L, plus_zero, 0.4812118250596034474977589134243684231352L);
1674   TEST_c_c (casin, minus_zero, 0.5L, minus_zero, 0.4812118250596034474977589134243684231352L);
1675   TEST_c_c (casin, plus_zero, 1.0L, plus_zero, 0.8813735870195430252326093249797923090282L);
1676   TEST_c_c (casin, minus_zero, 1.0L, minus_zero, 0.8813735870195430252326093249797923090282L);
1677   TEST_c_c (casin, plus_zero, 1.5L, plus_zero, 1.194763217287109304111930828519090523536L);
1678   TEST_c_c (casin, minus_zero, 1.5L, minus_zero, 1.194763217287109304111930828519090523536L);
1679
1680   TEST_c_c (casin, -1.5L, plus_zero, -M_PI_2l, 0.9624236501192068949955178268487368462704L);
1681   TEST_c_c (casin, -1.5L, minus_zero, -M_PI_2l, -0.9624236501192068949955178268487368462704L);
1682   TEST_c_c (casin, -1.0L, plus_zero, -M_PI_2l, plus_zero);
1683   TEST_c_c (casin, -1.0L, minus_zero, -M_PI_2l, minus_zero);
1684   TEST_c_c (casin, -0.5L, plus_zero, -0.5235987755982988730771072305465838140329L, plus_zero);
1685   TEST_c_c (casin, -0.5L, minus_zero, -0.5235987755982988730771072305465838140329L, minus_zero);
1686   TEST_c_c (casin, 0.5L, plus_zero, 0.5235987755982988730771072305465838140329L, plus_zero);
1687   TEST_c_c (casin, 0.5L, minus_zero, 0.5235987755982988730771072305465838140329L, minus_zero);
1688   TEST_c_c (casin, 1.0L, plus_zero, M_PI_2l, plus_zero);
1689   TEST_c_c (casin, 1.0L, minus_zero, M_PI_2l, minus_zero);
1690   TEST_c_c (casin, 1.5L, plus_zero, M_PI_2l, 0.9624236501192068949955178268487368462704L);
1691   TEST_c_c (casin, 1.5L, minus_zero, M_PI_2l, -0.9624236501192068949955178268487368462704L);
1692
1693   TEST_c_c (casin, 0.75L, 1.25L, 0.453276177638793913448921196101971749L, 1.13239363160530819522266333696834467L);
1694   TEST_c_c (casin, -2, -3, -0.57065278432109940071028387968566963L, -1.9833870299165354323470769028940395L);
1695
1696   END (casin, complex);
1697 }
1698
1699
1700 static void
1701 casinh_test (void)
1702 {
1703   errno = 0;
1704   FUNC(casinh) (BUILD_COMPLEX (0.7L, 1.2L));
1705   if (errno == ENOSYS)
1706     /* Function not implemented.  */
1707     return;
1708
1709   START (casinh);
1710
1711   TEST_c_c (casinh, 0, 0, 0.0, 0.0);
1712   TEST_c_c (casinh, minus_zero, 0, minus_zero, 0);
1713   TEST_c_c (casinh, 0, minus_zero, 0.0, minus_zero);
1714   TEST_c_c (casinh, minus_zero, minus_zero, minus_zero, minus_zero);
1715
1716   TEST_c_c (casinh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1717   TEST_c_c (casinh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1718   TEST_c_c (casinh, minus_infty, plus_infty, minus_infty, M_PI_4l);
1719   TEST_c_c (casinh, minus_infty, minus_infty, minus_infty, -M_PI_4l);
1720
1721   TEST_c_c (casinh, -10.0, plus_infty, minus_infty, M_PI_2l);
1722   TEST_c_c (casinh, -10.0, minus_infty, minus_infty, -M_PI_2l);
1723   TEST_c_c (casinh, 0, plus_infty, plus_infty, M_PI_2l);
1724   TEST_c_c (casinh, 0, minus_infty, plus_infty, -M_PI_2l);
1725   TEST_c_c (casinh, minus_zero, plus_infty, minus_infty, M_PI_2l);
1726   TEST_c_c (casinh, minus_zero, minus_infty, minus_infty, -M_PI_2l);
1727   TEST_c_c (casinh, 0.1L, plus_infty, plus_infty, M_PI_2l);
1728   TEST_c_c (casinh, 0.1L, minus_infty, plus_infty, -M_PI_2l);
1729
1730   TEST_c_c (casinh, minus_infty, 0, minus_infty, 0.0);
1731   TEST_c_c (casinh, minus_infty, minus_zero, minus_infty, minus_zero);
1732   TEST_c_c (casinh, minus_infty, 100, minus_infty, 0.0);
1733   TEST_c_c (casinh, minus_infty, -100, minus_infty, minus_zero);
1734
1735   TEST_c_c (casinh, plus_infty, 0, plus_infty, 0.0);
1736   TEST_c_c (casinh, plus_infty, minus_zero, plus_infty, minus_zero);
1737   TEST_c_c (casinh, plus_infty, 0.5, plus_infty, 0.0);
1738   TEST_c_c (casinh, plus_infty, -0.5, plus_infty, minus_zero);
1739
1740   TEST_c_c (casinh, plus_infty, nan_value, plus_infty, nan_value);
1741   TEST_c_c (casinh, minus_infty, nan_value, minus_infty, nan_value);
1742
1743   TEST_c_c (casinh, nan_value, 0, nan_value, 0.0);
1744   TEST_c_c (casinh, nan_value, minus_zero, nan_value, minus_zero);
1745
1746   TEST_c_c (casinh, nan_value, plus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1747   TEST_c_c (casinh, nan_value, minus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1748
1749   TEST_c_c (casinh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1750   TEST_c_c (casinh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1751
1752   TEST_c_c (casinh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1753   TEST_c_c (casinh, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1754
1755   TEST_c_c (casinh, nan_value, nan_value, nan_value, nan_value);
1756
1757   TEST_c_c (casinh, plus_zero, -1.5L, 0.9624236501192068949955178268487368462704L, -M_PI_2l);
1758   TEST_c_c (casinh, minus_zero, -1.5L, -0.9624236501192068949955178268487368462704L, -M_PI_2l);
1759   TEST_c_c (casinh, plus_zero, -1.0L, plus_zero, -M_PI_2l);
1760   TEST_c_c (casinh, minus_zero, -1.0L, minus_zero, -M_PI_2l);
1761   TEST_c_c (casinh, plus_zero, -0.5L, plus_zero, -0.5235987755982988730771072305465838140329L);
1762   TEST_c_c (casinh, minus_zero, -0.5L, minus_zero, -0.5235987755982988730771072305465838140329L);
1763   TEST_c_c (casinh, plus_zero, 0.5L, plus_zero, 0.5235987755982988730771072305465838140329L);
1764   TEST_c_c (casinh, minus_zero, 0.5L, minus_zero, 0.5235987755982988730771072305465838140329L);
1765   TEST_c_c (casinh, plus_zero, 1.0L, plus_zero, M_PI_2l);
1766   TEST_c_c (casinh, minus_zero, 1.0L, minus_zero, M_PI_2l);
1767   TEST_c_c (casinh, plus_zero, 1.5L, 0.9624236501192068949955178268487368462704L, M_PI_2l);
1768   TEST_c_c (casinh, minus_zero, 1.5L, -0.9624236501192068949955178268487368462704L, M_PI_2l);
1769
1770   TEST_c_c (casinh, -1.5L, plus_zero, -1.194763217287109304111930828519090523536L, plus_zero);
1771   TEST_c_c (casinh, -1.5L, minus_zero, -1.194763217287109304111930828519090523536L, minus_zero);
1772   TEST_c_c (casinh, -1.0L, plus_zero, -0.8813735870195430252326093249797923090282L, plus_zero);
1773   TEST_c_c (casinh, -1.0L, minus_zero, -0.8813735870195430252326093249797923090282L, minus_zero);
1774   TEST_c_c (casinh, -0.5L, plus_zero, -0.4812118250596034474977589134243684231352L, plus_zero);
1775   TEST_c_c (casinh, -0.5L, minus_zero, -0.4812118250596034474977589134243684231352L, minus_zero);
1776   TEST_c_c (casinh, 0.5L, plus_zero, 0.4812118250596034474977589134243684231352L, plus_zero);
1777   TEST_c_c (casinh, 0.5L, minus_zero, 0.4812118250596034474977589134243684231352L, minus_zero);
1778   TEST_c_c (casinh, 1.0L, plus_zero, 0.8813735870195430252326093249797923090282L, plus_zero);
1779   TEST_c_c (casinh, 1.0L, minus_zero, 0.8813735870195430252326093249797923090282L, minus_zero);
1780   TEST_c_c (casinh, 1.5L, plus_zero, 1.194763217287109304111930828519090523536L, plus_zero);
1781   TEST_c_c (casinh, 1.5L, minus_zero, 1.194763217287109304111930828519090523536L, minus_zero);
1782
1783   TEST_c_c (casinh, 0.75L, 1.25L, 1.03171853444778027336364058631006594L, 0.911738290968487636358489564316731207L);
1784   TEST_c_c (casinh, -2, -3, -1.9686379257930962917886650952454982L, -0.96465850440760279204541105949953237L);
1785
1786   END (casinh, complex);
1787 }
1788
1789
1790 static void
1791 catan_test (void)
1792 {
1793   errno = 0;
1794   FUNC(catan) (BUILD_COMPLEX (0.7L, 1.2L));
1795   if (errno == ENOSYS)
1796     /* Function not implemented.  */
1797     return;
1798
1799   START (catan);
1800
1801   TEST_c_c (catan, 0, 0, 0, 0);
1802   TEST_c_c (catan, minus_zero, 0, minus_zero, 0);
1803   TEST_c_c (catan, 0, minus_zero, 0, minus_zero);
1804   TEST_c_c (catan, minus_zero, minus_zero, minus_zero, minus_zero);
1805
1806   TEST_c_c (catan, plus_infty, plus_infty, M_PI_2l, 0);
1807   TEST_c_c (catan, plus_infty, minus_infty, M_PI_2l, minus_zero);
1808   TEST_c_c (catan, minus_infty, plus_infty, -M_PI_2l, 0);
1809   TEST_c_c (catan, minus_infty, minus_infty, -M_PI_2l, minus_zero);
1810
1811
1812   TEST_c_c (catan, plus_infty, -10.0, M_PI_2l, minus_zero);
1813   TEST_c_c (catan, minus_infty, -10.0, -M_PI_2l, minus_zero);
1814   TEST_c_c (catan, plus_infty, minus_zero, M_PI_2l, minus_zero);
1815   TEST_c_c (catan, minus_infty, minus_zero, -M_PI_2l, minus_zero);
1816   TEST_c_c (catan, plus_infty, 0.0, M_PI_2l, 0);
1817   TEST_c_c (catan, minus_infty, 0.0, -M_PI_2l, 0);
1818   TEST_c_c (catan, plus_infty, 0.1L, M_PI_2l, 0);
1819   TEST_c_c (catan, minus_infty, 0.1L, -M_PI_2l, 0);
1820
1821   TEST_c_c (catan, 0.0, minus_infty, M_PI_2l, minus_zero);
1822   TEST_c_c (catan, minus_zero, minus_infty, -M_PI_2l, minus_zero);
1823   TEST_c_c (catan, 100.0, minus_infty, M_PI_2l, minus_zero);
1824   TEST_c_c (catan, -100.0, minus_infty, -M_PI_2l, minus_zero);
1825
1826   TEST_c_c (catan, 0.0, plus_infty, M_PI_2l, 0);
1827   TEST_c_c (catan, minus_zero, plus_infty, -M_PI_2l, 0);
1828   TEST_c_c (catan, 0.5, plus_infty, M_PI_2l, 0);
1829   TEST_c_c (catan, -0.5, plus_infty, -M_PI_2l, 0);
1830
1831   TEST_c_c (catan, nan_value, 0.0, nan_value, 0);
1832   TEST_c_c (catan, nan_value, minus_zero, nan_value, minus_zero);
1833
1834   TEST_c_c (catan, nan_value, plus_infty, nan_value, 0);
1835   TEST_c_c (catan, nan_value, minus_infty, nan_value, minus_zero);
1836
1837   TEST_c_c (catan, 0.0, nan_value, nan_value, nan_value);
1838   TEST_c_c (catan, minus_zero, nan_value, nan_value, nan_value);
1839
1840   TEST_c_c (catan, plus_infty, nan_value, M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1841   TEST_c_c (catan, minus_infty, nan_value, -M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1842
1843   TEST_c_c (catan, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1844   TEST_c_c (catan, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1845
1846   TEST_c_c (catan, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1847   TEST_c_c (catan, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1848
1849   TEST_c_c (catan, nan_value, nan_value, nan_value, nan_value);
1850
1851   TEST_c_c (catan, 0.75L, 1.25L, 1.10714871779409050301706546017853704L, 0.549306144334054845697622618461262852L);
1852   TEST_c_c (catan, -2, -3, -1.4099210495965755225306193844604208L, -0.22907268296853876629588180294200276L);
1853
1854   END (catan, complex);
1855 }
1856
1857 static void
1858 catanh_test (void)
1859 {
1860   errno = 0;
1861   FUNC(catanh) (BUILD_COMPLEX (0.7L, 1.2L));
1862   if (errno == ENOSYS)
1863     /* Function not implemented.  */
1864     return;
1865
1866   START (catanh);
1867
1868   TEST_c_c (catanh, 0, 0, 0.0, 0.0);
1869   TEST_c_c (catanh, minus_zero, 0, minus_zero, 0.0);
1870   TEST_c_c (catanh, 0, minus_zero, 0.0, minus_zero);
1871   TEST_c_c (catanh, minus_zero, minus_zero, minus_zero, minus_zero);
1872
1873   TEST_c_c (catanh, plus_infty, plus_infty, 0.0, M_PI_2l);
1874   TEST_c_c (catanh, plus_infty, minus_infty, 0.0, -M_PI_2l);
1875   TEST_c_c (catanh, minus_infty, plus_infty, minus_zero, M_PI_2l);
1876   TEST_c_c (catanh, minus_infty, minus_infty, minus_zero, -M_PI_2l);
1877
1878   TEST_c_c (catanh, -10.0, plus_infty, minus_zero, M_PI_2l);
1879   TEST_c_c (catanh, -10.0, minus_infty, minus_zero, -M_PI_2l);
1880   TEST_c_c (catanh, minus_zero, plus_infty, minus_zero, M_PI_2l);
1881   TEST_c_c (catanh, minus_zero, minus_infty, minus_zero, -M_PI_2l);
1882   TEST_c_c (catanh, 0, plus_infty, 0.0, M_PI_2l);
1883   TEST_c_c (catanh, 0, minus_infty, 0.0, -M_PI_2l);
1884   TEST_c_c (catanh, 0.1L, plus_infty, 0.0, M_PI_2l);
1885   TEST_c_c (catanh, 0.1L, minus_infty, 0.0, -M_PI_2l);
1886
1887   TEST_c_c (catanh, minus_infty, 0, minus_zero, M_PI_2l);
1888   TEST_c_c (catanh, minus_infty, minus_zero, minus_zero, -M_PI_2l);
1889   TEST_c_c (catanh, minus_infty, 100, minus_zero, M_PI_2l);
1890   TEST_c_c (catanh, minus_infty, -100, minus_zero, -M_PI_2l);
1891
1892   TEST_c_c (catanh, plus_infty, 0, 0.0, M_PI_2l);
1893   TEST_c_c (catanh, plus_infty, minus_zero, 0.0, -M_PI_2l);
1894   TEST_c_c (catanh, plus_infty, 0.5, 0.0, M_PI_2l);
1895   TEST_c_c (catanh, plus_infty, -0.5, 0.0, -M_PI_2l);
1896
1897   TEST_c_c (catanh, 0, nan_value, 0.0, nan_value);
1898   TEST_c_c (catanh, minus_zero, nan_value, minus_zero, nan_value);
1899
1900   TEST_c_c (catanh, plus_infty, nan_value, 0.0, nan_value);
1901   TEST_c_c (catanh, minus_infty, nan_value, minus_zero, nan_value);
1902
1903   TEST_c_c (catanh, nan_value, 0, nan_value, nan_value);
1904   TEST_c_c (catanh, nan_value, minus_zero, nan_value, nan_value);
1905
1906   TEST_c_c (catanh, nan_value, plus_infty, 0.0, M_PI_2l, IGNORE_ZERO_INF_SIGN);
1907   TEST_c_c (catanh, nan_value, minus_infty, 0.0, -M_PI_2l, IGNORE_ZERO_INF_SIGN);
1908
1909   TEST_c_c (catanh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1910   TEST_c_c (catanh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1911
1912   TEST_c_c (catanh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1913   TEST_c_c (catanh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1914
1915   TEST_c_c (catanh, nan_value, nan_value, nan_value, nan_value);
1916
1917   TEST_c_c (catanh, 0.75L, 1.25L, 0.261492138795671927078652057366532140L, 0.996825126463918666098902241310446708L);
1918   TEST_c_c (catanh, -2, -3, -0.14694666622552975204743278515471595L, -1.3389725222944935611241935759091443L);
1919
1920   END (catanh, complex);
1921 }
1922
1923 static void
1924 cbrt_test (void)
1925 {
1926   errno = 0;
1927   FUNC(cbrt) (8);
1928   if (errno == ENOSYS)
1929     /* Function not implemented.  */
1930     return;
1931
1932   START (cbrt);
1933
1934   TEST_f_f (cbrt, 0.0, 0.0);
1935   TEST_f_f (cbrt, minus_zero, minus_zero);
1936
1937   TEST_f_f (cbrt, plus_infty, plus_infty);
1938   TEST_f_f (cbrt, minus_infty, minus_infty);
1939   TEST_f_f (cbrt, nan_value, nan_value);
1940
1941   TEST_f_f (cbrt, -0.001L, -0.1L);
1942   TEST_f_f (cbrt, 8, 2);
1943   TEST_f_f (cbrt, -27.0, -3.0);
1944   TEST_f_f (cbrt, 0.9921875L, 0.997389022060725270579075195353955217L);
1945   TEST_f_f (cbrt, 0.75L, 0.908560296416069829445605878163630251L);
1946
1947   END (cbrt);
1948 }
1949
1950
1951 static void
1952 ccos_test (void)
1953 {
1954   errno = 0;
1955   FUNC(ccos) (BUILD_COMPLEX (0, 0));
1956   if (errno == ENOSYS)
1957     /* Function not implemented.  */
1958     return;
1959
1960   START (ccos);
1961
1962   TEST_c_c (ccos, 0.0, 0.0, 1.0, minus_zero);
1963   TEST_c_c (ccos, minus_zero, 0.0, 1.0, 0.0);
1964   TEST_c_c (ccos, 0.0, minus_zero, 1.0, 0.0);
1965   TEST_c_c (ccos, minus_zero, minus_zero, 1.0, minus_zero);
1966
1967   TEST_c_c (ccos, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1968   TEST_c_c (ccos, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1969   TEST_c_c (ccos, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1970   TEST_c_c (ccos, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1971
1972   TEST_c_c (ccos, 0.0, plus_infty, plus_infty, minus_zero);
1973   TEST_c_c (ccos, 0.0, minus_infty, plus_infty, 0.0);
1974   TEST_c_c (ccos, minus_zero, plus_infty, plus_infty, 0.0);
1975   TEST_c_c (ccos, minus_zero, minus_infty, plus_infty, minus_zero);
1976
1977   TEST_c_c (ccos, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1978   TEST_c_c (ccos, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1979   TEST_c_c (ccos, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1980   TEST_c_c (ccos, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1981
1982   TEST_c_c (ccos, 4.625, plus_infty, minus_infty, plus_infty);
1983   TEST_c_c (ccos, 4.625, minus_infty, minus_infty, minus_infty);
1984   TEST_c_c (ccos, -4.625, plus_infty, minus_infty, minus_infty);
1985   TEST_c_c (ccos, -4.625, minus_infty, minus_infty, plus_infty);
1986
1987   TEST_c_c (ccos, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1988   TEST_c_c (ccos, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1989   TEST_c_c (ccos, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1990   TEST_c_c (ccos, minus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1991
1992   TEST_c_c (ccos, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1993   TEST_c_c (ccos, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1994
1995   TEST_c_c (ccos, nan_value, plus_infty, plus_infty, nan_value);
1996   TEST_c_c (ccos, nan_value, minus_infty, plus_infty, nan_value);
1997
1998   TEST_c_c (ccos, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1999   TEST_c_c (ccos, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2000
2001   TEST_c_c (ccos, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2002   TEST_c_c (ccos, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2003
2004   TEST_c_c (ccos, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2005   TEST_c_c (ccos, -10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2006
2007   TEST_c_c (ccos, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2008   TEST_c_c (ccos, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2009
2010   TEST_c_c (ccos, nan_value, nan_value, nan_value, nan_value);
2011
2012   TEST_c_c (ccos, 0.75L, 1.25L, 1.38173873063425888530729933139078645L, -1.09193013555397466170919531722024128L);
2013   TEST_c_c (ccos, -2, -3, -4.18962569096880723013255501961597373L, -9.10922789375533659797919726277886212L);
2014
2015   TEST_c_c (ccos, 0.75, 89.5, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
2016   TEST_c_c (ccos, 0.75, -89.5, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
2017   TEST_c_c (ccos, -0.75, 89.5, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
2018   TEST_c_c (ccos, -0.75, -89.5, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
2019
2020 #ifndef TEST_FLOAT
2021   TEST_c_c (ccos, 0.75, 710.5, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
2022   TEST_c_c (ccos, 0.75, -710.5, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
2023   TEST_c_c (ccos, -0.75, 710.5, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
2024   TEST_c_c (ccos, -0.75, -710.5, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
2025 #endif
2026
2027 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2028   TEST_c_c (ccos, 0.75, 11357.25, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
2029   TEST_c_c (ccos, 0.75, -11357.25, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
2030   TEST_c_c (ccos, -0.75, 11357.25, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
2031   TEST_c_c (ccos, -0.75, -11357.25, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
2032 #endif
2033
2034 #ifdef TEST_FLOAT
2035   TEST_c_c (ccos, 0x1p-149, 180, plus_infty, -1.043535896672617552965983803453927655332e33L, OVERFLOW_EXCEPTION);
2036 #endif
2037
2038 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2039   TEST_c_c (ccos, 0x1p-1074, 1440, plus_infty, -5.981479269486130556466515778180916082415e301L, OVERFLOW_EXCEPTION);
2040 #endif
2041
2042 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2043   TEST_c_c (ccos, 0x1p-16434L, 22730, plus_infty, -1.217853148905605987081057582351152052687e4924L, OVERFLOW_EXCEPTION);
2044 #endif
2045
2046   END (ccos, complex);
2047 }
2048
2049
2050 static void
2051 ccosh_test (void)
2052 {
2053   errno = 0;
2054   FUNC(ccosh) (BUILD_COMPLEX (0.7L, 1.2L));
2055   if (errno == ENOSYS)
2056     /* Function not implemented.  */
2057     return;
2058
2059   START (ccosh);
2060
2061   TEST_c_c (ccosh, 0.0, 0.0, 1.0, 0.0);
2062   TEST_c_c (ccosh, minus_zero, 0.0, 1.0, minus_zero);
2063   TEST_c_c (ccosh, 0.0, minus_zero, 1.0, minus_zero);
2064   TEST_c_c (ccosh, minus_zero, minus_zero, 1.0, 0.0);
2065
2066   TEST_c_c (ccosh, 0.0, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2067   TEST_c_c (ccosh, minus_zero, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2068   TEST_c_c (ccosh, 0.0, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2069   TEST_c_c (ccosh, minus_zero, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2070
2071   TEST_c_c (ccosh, plus_infty, 0.0, plus_infty, 0.0);
2072   TEST_c_c (ccosh, minus_infty, 0.0, plus_infty, minus_zero);
2073   TEST_c_c (ccosh, plus_infty, minus_zero, plus_infty, minus_zero);
2074   TEST_c_c (ccosh, minus_infty, minus_zero, plus_infty, 0.0);
2075
2076   TEST_c_c (ccosh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2077   TEST_c_c (ccosh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2078   TEST_c_c (ccosh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2079   TEST_c_c (ccosh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2080
2081   TEST_c_c (ccosh, plus_infty, 4.625, minus_infty, minus_infty);
2082   TEST_c_c (ccosh, minus_infty, 4.625, minus_infty, plus_infty);
2083   TEST_c_c (ccosh, plus_infty, -4.625, minus_infty, plus_infty);
2084   TEST_c_c (ccosh, minus_infty, -4.625, minus_infty, minus_infty);
2085
2086   TEST_c_c (ccosh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2087   TEST_c_c (ccosh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2088   TEST_c_c (ccosh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2089   TEST_c_c (ccosh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2090
2091   TEST_c_c (ccosh, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2092   TEST_c_c (ccosh, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2093
2094   TEST_c_c (ccosh, plus_infty, nan_value, plus_infty, nan_value);
2095   TEST_c_c (ccosh, minus_infty, nan_value, plus_infty, nan_value);
2096
2097   TEST_c_c (ccosh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2098   TEST_c_c (ccosh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2099
2100   TEST_c_c (ccosh, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2101   TEST_c_c (ccosh, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2102
2103   TEST_c_c (ccosh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2104   TEST_c_c (ccosh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2105
2106   TEST_c_c (ccosh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2107   TEST_c_c (ccosh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2108
2109   TEST_c_c (ccosh, nan_value, nan_value, nan_value, nan_value);
2110
2111   TEST_c_c (ccosh, 0.75L, 1.25L, 0.408242591877968807788852146397499084L, 0.780365930845853240391326216300863152L);
2112
2113   TEST_c_c (ccosh, -2, -3, -3.72454550491532256547397070325597253L, 0.511822569987384608834463849801875634L);
2114
2115   TEST_c_c (ccosh, 89.5, 0.75, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
2116   TEST_c_c (ccosh, -89.5, 0.75, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
2117   TEST_c_c (ccosh, 89.5, -0.75, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
2118   TEST_c_c (ccosh, -89.5, -0.75, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
2119
2120 #ifndef TEST_FLOAT
2121   TEST_c_c (ccosh, 710.5, 0.75, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
2122   TEST_c_c (ccosh, -710.5, 0.75, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
2123   TEST_c_c (ccosh, 710.5, -0.75, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
2124   TEST_c_c (ccosh, -710.5, -0.75, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
2125 #endif
2126
2127 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2128   TEST_c_c (ccosh, 11357.25, 0.75, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
2129   TEST_c_c (ccosh, -11357.25, 0.75, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
2130   TEST_c_c (ccosh, 11357.25, -0.75, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
2131   TEST_c_c (ccosh, -11357.25, -0.75, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
2132 #endif
2133
2134 #ifdef TEST_FLOAT
2135   TEST_c_c (ccosh, 180, 0x1p-149, plus_infty, 1.043535896672617552965983803453927655332e33L, OVERFLOW_EXCEPTION);
2136 #endif
2137
2138 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2139   TEST_c_c (ccosh, 1440, 0x1p-1074, plus_infty, 5.981479269486130556466515778180916082415e301L, OVERFLOW_EXCEPTION);
2140 #endif
2141
2142 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2143   TEST_c_c (ccosh, 22730, 0x1p-16434L, plus_infty, 1.217853148905605987081057582351152052687e4924L, OVERFLOW_EXCEPTION);
2144 #endif
2145
2146   END (ccosh, complex);
2147 }
2148
2149
2150 static void
2151 ceil_test (void)
2152 {
2153   START (ceil);
2154
2155   TEST_f_f (ceil, 0.0, 0.0);
2156   TEST_f_f (ceil, minus_zero, minus_zero);
2157   TEST_f_f (ceil, plus_infty, plus_infty);
2158   TEST_f_f (ceil, minus_infty, minus_infty);
2159   TEST_f_f (ceil, nan_value, nan_value);
2160
2161   TEST_f_f (ceil, M_PIl, 4.0);
2162   TEST_f_f (ceil, -M_PIl, -3.0);
2163   TEST_f_f (ceil, 0.1, 1.0);
2164   TEST_f_f (ceil, 0.25, 1.0);
2165   TEST_f_f (ceil, 0.625, 1.0);
2166   TEST_f_f (ceil, -0.1, minus_zero);
2167   TEST_f_f (ceil, -0.25, minus_zero);
2168   TEST_f_f (ceil, -0.625, minus_zero);
2169
2170 #ifdef TEST_LDOUBLE
2171   /* The result can only be represented in long double.  */
2172   TEST_f_f (ceil, 4503599627370495.5L, 4503599627370496.0L);
2173   TEST_f_f (ceil, 4503599627370496.25L, 4503599627370497.0L);
2174   TEST_f_f (ceil, 4503599627370496.5L, 4503599627370497.0L);
2175   TEST_f_f (ceil, 4503599627370496.75L, 4503599627370497.0L);
2176   TEST_f_f (ceil, 4503599627370497.5L, 4503599627370498.0L);
2177
2178   TEST_f_f (ceil, -4503599627370495.5L, -4503599627370495.0L);
2179   TEST_f_f (ceil, -4503599627370496.25L, -4503599627370496.0L);
2180   TEST_f_f (ceil, -4503599627370496.5L, -4503599627370496.0L);
2181   TEST_f_f (ceil, -4503599627370496.75L, -4503599627370496.0L);
2182   TEST_f_f (ceil, -4503599627370497.5L, -4503599627370497.0L);
2183
2184 # if LDBL_MANT_DIG > 100
2185   TEST_f_f (ceil, 4503599627370494.5000000000001L, 4503599627370495.0L);
2186   TEST_f_f (ceil, 4503599627370495.5000000000001L, 4503599627370496.0L);
2187   TEST_f_f (ceil, 4503599627370496.5000000000001L, 4503599627370497.0L);
2188   TEST_f_f (ceil, -4503599627370494.5000000000001L, -4503599627370494.0L);
2189   TEST_f_f (ceil, -4503599627370495.5000000000001L, -4503599627370495.0L);
2190   TEST_f_f (ceil, -4503599627370496.5000000000001L, -4503599627370496.0L);
2191 # endif
2192
2193   TEST_f_f (ceil, 9007199254740991.5L, 9007199254740992.0L);
2194   TEST_f_f (ceil, 9007199254740992.25L, 9007199254740993.0L);
2195   TEST_f_f (ceil, 9007199254740992.5L, 9007199254740993.0L);
2196   TEST_f_f (ceil, 9007199254740992.75L, 9007199254740993.0L);
2197   TEST_f_f (ceil, 9007199254740993.5L, 9007199254740994.0L);
2198
2199   TEST_f_f (ceil, -9007199254740991.5L, -9007199254740991.0L);
2200   TEST_f_f (ceil, -9007199254740992.25L, -9007199254740992.0L);
2201   TEST_f_f (ceil, -9007199254740992.5L, -9007199254740992.0L);
2202   TEST_f_f (ceil, -9007199254740992.75L, -9007199254740992.0L);
2203   TEST_f_f (ceil, -9007199254740993.5L, -9007199254740993.0L);
2204
2205 # if LDBL_MANT_DIG > 100
2206   TEST_f_f (ceil, 9007199254740991.0000000000001L, 9007199254740992.0L);
2207   TEST_f_f (ceil, 9007199254740992.0000000000001L, 9007199254740993.0L);
2208   TEST_f_f (ceil, 9007199254740993.0000000000001L, 9007199254740994.0L);
2209   TEST_f_f (ceil, 9007199254740991.5000000000001L, 9007199254740992.0L);
2210   TEST_f_f (ceil, 9007199254740992.5000000000001L, 9007199254740993.0L);
2211   TEST_f_f (ceil, 9007199254740993.5000000000001L, 9007199254740994.0L);
2212
2213   TEST_f_f (ceil, -9007199254740991.0000000000001L, -9007199254740991.0L);
2214   TEST_f_f (ceil, -9007199254740992.0000000000001L, -9007199254740992.0L);
2215   TEST_f_f (ceil, -9007199254740993.0000000000001L, -9007199254740993.0L);
2216   TEST_f_f (ceil, -9007199254740991.5000000000001L, -9007199254740991.0L);
2217   TEST_f_f (ceil, -9007199254740992.5000000000001L, -9007199254740992.0L);
2218   TEST_f_f (ceil, -9007199254740993.5000000000001L, -9007199254740993.0L);
2219 # endif
2220
2221   TEST_f_f (ceil, 72057594037927935.5L, 72057594037927936.0L);
2222   TEST_f_f (ceil, 72057594037927936.25L, 72057594037927937.0L);
2223   TEST_f_f (ceil, 72057594037927936.5L, 72057594037927937.0L);
2224   TEST_f_f (ceil, 72057594037927936.75L, 72057594037927937.0L);
2225   TEST_f_f (ceil, 72057594037927937.5L, 72057594037927938.0L);
2226
2227   TEST_f_f (ceil, -72057594037927935.5L, -72057594037927935.0L);
2228   TEST_f_f (ceil, -72057594037927936.25L, -72057594037927936.0L);
2229   TEST_f_f (ceil, -72057594037927936.5L, -72057594037927936.0L);
2230   TEST_f_f (ceil, -72057594037927936.75L, -72057594037927936.0L);
2231   TEST_f_f (ceil, -72057594037927937.5L, -72057594037927937.0L);
2232
2233   TEST_f_f (ceil, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
2234   TEST_f_f (ceil, 10141204801825835211973625643008.25L, 10141204801825835211973625643009.0L);
2235   TEST_f_f (ceil, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
2236   TEST_f_f (ceil, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
2237   TEST_f_f (ceil, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
2238 #endif
2239
2240   END (ceil);
2241 }
2242
2243
2244 static void
2245 cexp_test (void)
2246 {
2247   errno = 0;
2248   FUNC(cexp) (BUILD_COMPLEX (0, 0));
2249   if (errno == ENOSYS)
2250     /* Function not implemented.  */
2251     return;
2252
2253   START (cexp);
2254
2255   TEST_c_c (cexp, plus_zero, plus_zero, 1, 0.0);
2256   TEST_c_c (cexp, minus_zero, plus_zero, 1, 0.0);
2257   TEST_c_c (cexp, plus_zero, minus_zero, 1, minus_zero);
2258   TEST_c_c (cexp, minus_zero, minus_zero, 1, minus_zero);
2259
2260   TEST_c_c (cexp, plus_infty, plus_zero, plus_infty, 0.0);
2261   TEST_c_c (cexp, plus_infty, minus_zero, plus_infty, minus_zero);
2262
2263   TEST_c_c (cexp, minus_infty, plus_zero, 0.0, 0.0);
2264   TEST_c_c (cexp, minus_infty, minus_zero, 0.0, minus_zero);
2265
2266   TEST_c_c (cexp, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2267   TEST_c_c (cexp, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2268
2269   TEST_c_c (cexp, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2270   TEST_c_c (cexp, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2271
2272   TEST_c_c (cexp, 100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2273   TEST_c_c (cexp, -100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2274
2275   TEST_c_c (cexp, 100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2276   TEST_c_c (cexp, -100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2277
2278   TEST_c_c (cexp, minus_infty, 2.0, minus_zero, 0.0);
2279   TEST_c_c (cexp, minus_infty, 4.0, minus_zero, minus_zero);
2280   TEST_c_c (cexp, plus_infty, 2.0, minus_infty, plus_infty);
2281   TEST_c_c (cexp, plus_infty, 4.0, minus_infty, minus_infty);
2282
2283   TEST_c_c (cexp, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2284   TEST_c_c (cexp, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2285
2286   TEST_c_c (cexp, minus_infty, plus_infty, 0.0, 0.0, IGNORE_ZERO_INF_SIGN);
2287   TEST_c_c (cexp, minus_infty, minus_infty, 0.0, minus_zero, IGNORE_ZERO_INF_SIGN);
2288
2289   TEST_c_c (cexp, minus_infty, nan_value, 0, 0, IGNORE_ZERO_INF_SIGN);
2290
2291   TEST_c_c (cexp, plus_infty, nan_value, plus_infty, nan_value);
2292
2293   TEST_c_c (cexp, nan_value, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2294   TEST_c_c (cexp, nan_value, 1.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2295
2296   TEST_c_c (cexp, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2297   TEST_c_c (cexp, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2298   TEST_c_c (cexp, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2299   TEST_c_c (cexp, nan_value, nan_value, nan_value, nan_value);
2300
2301   TEST_c_c (cexp, 0.75L, 1.25L, 0.667537446429131586942201977015932112L, 2.00900045494094876258347228145863909L);
2302   TEST_c_c (cexp, -2.0, -3.0, -0.13398091492954261346140525546115575L, -0.019098516261135196432576240858800925L);
2303
2304   TEST_c_c (cexp, 0, 0x1p65, 0.99888622066058013610642172179340364209972L, -0.047183876212354673805106149805700013943218L);
2305   TEST_c_c (cexp, 0, -0x1p65, 0.99888622066058013610642172179340364209972L, 0.047183876212354673805106149805700013943218L);
2306   TEST_c_c (cexp, 50, 0x1p127, 4.053997150228616856622417636046265337193e21L, 3.232070315463388524466674772633810238819e21L);
2307
2308 #ifndef TEST_FLOAT
2309   TEST_c_c (cexp, 0, 1e22, 0.5232147853951389454975944733847094921409L, -0.8522008497671888017727058937530293682618L);
2310   TEST_c_c (cexp, 0, 0x1p1023, -0.826369834614147994500785680811743734805L, 0.5631277798508840134529434079444683477104L);
2311   TEST_c_c (cexp, 500, 0x1p1023, -1.159886268932754433233243794561351783426e217L, 7.904017694554466595359379965081774849708e216L);
2312 #endif
2313
2314 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2315   TEST_c_c (cexp, 0, 0x1p16383L, 0.9210843909921906206874509522505756251609L, 0.3893629985894208126948115852610595405563L);
2316   TEST_c_c (cexp, -10000, 0x1p16383L, 1.045876464564882298442774542991176546722e-4343L, 4.421154026488516836023811173959413420548e-4344L);
2317 #endif
2318
2319   TEST_c_c (cexp, 88.75, 0.75, 2.558360358486542817001900410314204322891e38L, 2.383359453227311447654736314679677655100e38L);
2320   TEST_c_c (cexp, -95, 0.75, 4.039714446238306526889476684000081624047e-42L, 3.763383677300535390271646960780570275931e-42L, UNDERFLOW_EXCEPTION_FLOAT);
2321
2322 #ifndef TEST_FLOAT
2323   TEST_c_c (cexp, 709.8125, 0.75, 1.355121963080879535248452862759108365762e308L, 1.262426823598609432507811340856186873507e308L);
2324   TEST_c_c (cexp, -720, 0.75, 1.486960657116368433685753325516638551722e-313L, 1.385247284245720590980701226843815229385e-313L, UNDERFLOW_EXCEPTION_DOUBLE);
2325 #endif
2326
2327 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2328   TEST_c_c (cexp, 11356.5625, 0.75, 9.052188470850960144814815984311663764287e4931L, 8.432986734191301036267148978260970230200e4931L);
2329   TEST_c_c (cexp, -11370, 0.75, 8.631121063182211587489310508568170739592e-4939L, 8.040721827809267291427062346918413482824e-4939L, UNDERFLOW_EXCEPTION);
2330 #endif
2331
2332 #ifdef TEST_FLOAT
2333   TEST_c_c (cexp, 180, 0x1p-149, plus_infty, 2.087071793345235105931967606907855310664e33L, OVERFLOW_EXCEPTION);
2334 #endif
2335
2336 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2337   TEST_c_c (cexp, 1440, 0x1p-1074, plus_infty, 1.196295853897226111293303155636183216483e302L, OVERFLOW_EXCEPTION);
2338 #endif
2339
2340 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2341   TEST_c_c (cexp, 22730, 0x1p-16434L, plus_infty, 2.435706297811211974162115164702304105374e4924L, OVERFLOW_EXCEPTION);
2342 #endif
2343
2344   TEST_c_c (cexp, 1e6, 0, plus_infty, 0, OVERFLOW_EXCEPTION);
2345   TEST_c_c (cexp, 1e6, min_value, plus_infty, plus_infty, OVERFLOW_EXCEPTION);
2346   TEST_c_c (cexp, 1e6, -min_value, plus_infty, minus_infty, OVERFLOW_EXCEPTION);
2347
2348   END (cexp, complex);
2349 }
2350
2351
2352 static void
2353 cimag_test (void)
2354 {
2355   START (cimag);
2356   TEST_c_f (cimag, 1.0, 0.0, 0.0);
2357   TEST_c_f (cimag, 1.0, minus_zero, minus_zero);
2358   TEST_c_f (cimag, 1.0, nan_value, nan_value);
2359   TEST_c_f (cimag, nan_value, nan_value, nan_value);
2360   TEST_c_f (cimag, 1.0, plus_infty, plus_infty);
2361   TEST_c_f (cimag, 1.0, minus_infty, minus_infty);
2362   TEST_c_f (cimag, 2.0, 3.0, 3.0);
2363
2364   END (cimag);
2365 }
2366
2367 static void
2368 clog_test (void)
2369 {
2370   errno = 0;
2371   FUNC(clog) (BUILD_COMPLEX (-2, -3));
2372   if (errno == ENOSYS)
2373     /* Function not implemented.  */
2374     return;
2375
2376   START (clog);
2377
2378   TEST_c_c (clog, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2379   TEST_c_c (clog, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2380
2381   TEST_c_c (clog, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
2382   TEST_c_c (clog, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
2383
2384   TEST_c_c (clog, minus_infty, plus_infty, plus_infty, M_PI_34l);
2385   TEST_c_c (clog, minus_infty, minus_infty, plus_infty, -M_PI_34l);
2386
2387   TEST_c_c (clog, plus_infty, plus_infty, plus_infty, M_PI_4l);
2388   TEST_c_c (clog, plus_infty, minus_infty, plus_infty, -M_PI_4l);
2389
2390   TEST_c_c (clog, 0, plus_infty, plus_infty, M_PI_2l);
2391   TEST_c_c (clog, 3, plus_infty, plus_infty, M_PI_2l);
2392   TEST_c_c (clog, minus_zero, plus_infty, plus_infty, M_PI_2l);
2393   TEST_c_c (clog, -3, plus_infty, plus_infty, M_PI_2l);
2394   TEST_c_c (clog, 0, minus_infty, plus_infty, -M_PI_2l);
2395   TEST_c_c (clog, 3, minus_infty, plus_infty, -M_PI_2l);
2396   TEST_c_c (clog, minus_zero, minus_infty, plus_infty, -M_PI_2l);
2397   TEST_c_c (clog, -3, minus_infty, plus_infty, -M_PI_2l);
2398
2399   TEST_c_c (clog, minus_infty, 0, plus_infty, M_PIl);
2400   TEST_c_c (clog, minus_infty, 1, plus_infty, M_PIl);
2401   TEST_c_c (clog, minus_infty, minus_zero, plus_infty, -M_PIl);
2402   TEST_c_c (clog, minus_infty, -1, plus_infty, -M_PIl);
2403
2404   TEST_c_c (clog, plus_infty, 0, plus_infty, 0.0);
2405   TEST_c_c (clog, plus_infty, 1, plus_infty, 0.0);
2406   TEST_c_c (clog, plus_infty, minus_zero, plus_infty, minus_zero);
2407   TEST_c_c (clog, plus_infty, -1, plus_infty, minus_zero);
2408
2409   TEST_c_c (clog, plus_infty, nan_value, plus_infty, nan_value);
2410   TEST_c_c (clog, minus_infty, nan_value, plus_infty, nan_value);
2411
2412   TEST_c_c (clog, nan_value, plus_infty, plus_infty, nan_value);
2413   TEST_c_c (clog, nan_value, minus_infty, plus_infty, nan_value);
2414
2415   TEST_c_c (clog, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2416   TEST_c_c (clog, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2417   TEST_c_c (clog, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2418   TEST_c_c (clog, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2419
2420   TEST_c_c (clog, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2421   TEST_c_c (clog, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2422   TEST_c_c (clog, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2423   TEST_c_c (clog, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2424
2425   TEST_c_c (clog, nan_value, nan_value, nan_value, nan_value);
2426
2427   TEST_c_c (clog, 0.75L, 1.25L, 0.376885901188190075998919126749298416L, 1.03037682652431246378774332703115153L);
2428   TEST_c_c (clog, -2, -3, 1.2824746787307683680267437207826593L, -2.1587989303424641704769327722648368L);
2429
2430   TEST_c_c (clog, 0x1.fffffep+127L, 0x1.fffffep+127L, 89.06941264234832570836679262104313101776L, M_PI_4l);
2431   TEST_c_c (clog, 0x1.fffffep+127L, 1.0L, 88.72283905206835305365817656031404273372L, 2.938736052218037251011746307725933020145e-39L, UNDERFLOW_EXCEPTION_FLOAT);
2432   TEST_c_c (clog, 0x1p-149L, 0x1p-149L, -102.9323563131518784484589700365392203592L, M_PI_4l);
2433   TEST_c_c (clog, 0x1p-147L, 0x1p-147L, -101.5460619520319878296245057936228672231L, M_PI_4l);
2434
2435 #ifndef TEST_FLOAT
2436   TEST_c_c (clog, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 710.1292864836639693869320059713862337880L, M_PI_4l);
2437   TEST_c_c (clog, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 709.8942846690411016323109979483151967689L, 0.4636476090008061606231772164674799632783L);
2438   TEST_c_c (clog, 0x1p-1074L, 0x1p-1074L, -744.0934983311012896593986823853525458290L, M_PI_4l);
2439   TEST_c_c (clog, 0x1p-1073L, 0x1p-1073L, -743.4003511505413443499814502638943692610L, M_PI_4l);
2440 #endif
2441
2442 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2443   TEST_c_c (clog, 0x1.fp+16383L, 0x1.fp+16383L, 11356.83823118610934184548269774874545400L, M_PI_4l);
2444   TEST_c_c (clog, 0x1.fp+16383L, 0x1p+16383L, 11356.60974243783798653123798337822335902L, 0.4764674194737066993385333770295162295856L);
2445   TEST_c_c (clog, 0x1p-16440L, 0x1p-16441L, -11395.22807662984378194141292922726786191L, 0.4636476090008061162142562314612144020285L);
2446 #endif
2447
2448   TEST_c_c (clog, 0x1p-149L, 0x1.fp+127L, 88.69109041335841930424871526389807508374L, M_PI_2l);
2449   TEST_c_c (clog, -0x1p-149L, 0x1.fp+127L, 88.69109041335841930424871526389807508374L, M_PI_2l);
2450   TEST_c_c (clog, 0x1p-149L, -0x1.fp+127L, 88.69109041335841930424871526389807508374L, -M_PI_2l);
2451   TEST_c_c (clog, -0x1p-149L, -0x1.fp+127L, 88.69109041335841930424871526389807508374L, -M_PI_2l);
2452   TEST_c_c (clog, -0x1.fp+127L, 0x1p-149L, 88.69109041335841930424871526389807508374L, M_PIl);
2453   TEST_c_c (clog, -0x1.fp+127L, -0x1p-149L, 88.69109041335841930424871526389807508374L, -M_PIl);
2454 #ifdef TEST_FLOAT
2455   TEST_c_c (clog, 0x1.fp+127L, 0x1p-149L, 88.69109041335841930424871526389807508374L, plus_zero, UNDERFLOW_EXCEPTION);
2456   TEST_c_c (clog, 0x1.fp+127L, -0x1p-149L, 88.69109041335841930424871526389807508374L, minus_zero, UNDERFLOW_EXCEPTION);
2457 #endif
2458
2459 #ifndef TEST_FLOAT
2460   TEST_c_c (clog, 0x1p-1074L, 0x1.fp+1023L, 709.7509641950694165420886960904242800794L, M_PI_2l);
2461   TEST_c_c (clog, -0x1p-1074L, 0x1.fp+1023L, 709.7509641950694165420886960904242800794L, M_PI_2l);
2462   TEST_c_c (clog, 0x1p-1074L, -0x1.fp+1023L, 709.7509641950694165420886960904242800794L, -M_PI_2l);
2463   TEST_c_c (clog, -0x1p-1074L, -0x1.fp+1023L, 709.7509641950694165420886960904242800794L, -M_PI_2l);
2464   TEST_c_c (clog, -0x1.fp+1023L, 0x1p-1074L, 709.7509641950694165420886960904242800794L, M_PIl);
2465   TEST_c_c (clog, -0x1.fp+1023L, -0x1p-1074L, 709.7509641950694165420886960904242800794L, -M_PIl);
2466 #endif
2467 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2468   TEST_c_c (clog, 0x1.fp+1023L, 0x1p-1074L, 709.7509641950694165420886960904242800794L, plus_zero, UNDERFLOW_EXCEPTION);
2469   TEST_c_c (clog, 0x1.fp+1023L, -0x1p-1074L, 709.7509641950694165420886960904242800794L, minus_zero, UNDERFLOW_EXCEPTION);
2470 #endif
2471
2472 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2473   TEST_c_c (clog, 0x1p-16445L, 0x1.fp+16383L, 11356.49165759582936919077408168801636572L, M_PI_2l);
2474   TEST_c_c (clog, -0x1p-16445L, 0x1.fp+16383L, 11356.49165759582936919077408168801636572L, M_PI_2l);
2475   TEST_c_c (clog, 0x1p-16445L, -0x1.fp+16383L, 11356.49165759582936919077408168801636572L, -M_PI_2l);
2476   TEST_c_c (clog, -0x1p-16445L, -0x1.fp+16383L, 11356.49165759582936919077408168801636572L, -M_PI_2l);
2477   TEST_c_c (clog, -0x1.fp+16383L, 0x1p-16445L, 11356.49165759582936919077408168801636572L, M_PIl);
2478   TEST_c_c (clog, -0x1.fp+16383L, -0x1p-16445L, 11356.49165759582936919077408168801636572L, -M_PIl);
2479   TEST_c_c (clog, 0x1.fp+16383L, 0x1p-16445L, 11356.49165759582936919077408168801636572L, plus_zero, UNDERFLOW_EXCEPTION);
2480   TEST_c_c (clog, 0x1.fp+16383L, -0x1p-16445L, 11356.49165759582936919077408168801636572L, minus_zero, UNDERFLOW_EXCEPTION);
2481 # if LDBL_MANT_DIG >= 113
2482   TEST_c_c (clog, 0x1p-16494L, 0x1.fp+16383L, 11356.49165759582936919077408168801636572L, M_PI_2l);
2483   TEST_c_c (clog, -0x1p-16494L, 0x1.fp+16383L, 11356.49165759582936919077408168801636572L, M_PI_2l);
2484   TEST_c_c (clog, 0x1p-16494L, -0x1.fp+16383L, 11356.49165759582936919077408168801636572L, -M_PI_2l);
2485   TEST_c_c (clog, -0x1p-16494L, -0x1.fp+16383L, 11356.49165759582936919077408168801636572L, -M_PI_2l);
2486   TEST_c_c (clog, -0x1.fp+16383L, 0x1p-16494L, 11356.49165759582936919077408168801636572L, M_PIl);
2487   TEST_c_c (clog, -0x1.fp+16383L, -0x1p-16494L, 11356.49165759582936919077408168801636572L, -M_PIl);
2488   TEST_c_c (clog, 0x1.fp+16383L, 0x1p-16494L, 11356.49165759582936919077408168801636572L, plus_zero, UNDERFLOW_EXCEPTION);
2489   TEST_c_c (clog, 0x1.fp+16383L, -0x1p-16494L, 11356.49165759582936919077408168801636572L, minus_zero, UNDERFLOW_EXCEPTION);
2490 # endif
2491 #endif
2492
2493   TEST_c_c (clog, 1.0L, 0x1.234566p-10L, 6.172834701221959432440126967147726538097e-7L, 1.111110564353742042376451655136933182201e-3L);
2494   TEST_c_c (clog, -1.0L, 0x1.234566p-20L, 5.886877547844618300918562490463748605537e-13L, 3.141591568520436206990380699322226378452L);
2495   TEST_c_c (clog, 0x1.234566p-30L, 1.0L, 5.614163921211322622623353961365728040115e-19L, 1.570796325735258575254858696548386439740L);
2496   TEST_c_c (clog, -0x1.234566p-40L, -1.0L, 5.354083939753840089583620652120903838944e-25L, -1.570796326795931422008642456283782656359L);
2497   TEST_c_c (clog, 0x1.234566p-50L, 1.0L, 5.106052341226425256332038420428899201070e-31L, 1.570796326794895608681734464330528755366L);
2498   TEST_c_c (clog, 0x1.234566p-60L, 1.0L, 4.869510976053643471080816669875627875933e-37L, 1.570796326794896618244456860363082279319L);
2499   TEST_c_c (clog, 0x1p-62L, 1.0L, 2.350988701644575015937473074444491355582e-38L, 1.570796326794896619014481257142650555297L);
2500   TEST_c_c (clog, 0x1p-63L, 1.0L, 5.877471754111437539843682686111228389059e-39L, 1.570796326794896619122901474391200998698L, UNDERFLOW_EXCEPTION_FLOAT);
2501   TEST_c_c (clog, 0x1p-64L, 1.0L, 1.469367938527859384960920671527807097271e-39L, 1.570796326794896619177111583015476220398L, UNDERFLOW_EXCEPTION_FLOAT);
2502 #ifndef TEST_FLOAT
2503   TEST_c_c (clog, 0x1p-510L, 1.0L, 4.450147717014402766180465434664808128438e-308L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
2504   TEST_c_c (clog, 0x1p-511L, 1.0L, 1.112536929253600691545116358666202032110e-308L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION_DOUBLE);
2505   TEST_c_c (clog, 0x1p-512L, 1.0L, 2.781342323134001728862790896665505080274e-309L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION_DOUBLE);
2506 #endif
2507 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2508   TEST_c_c (clog, 0x1p-8190L, 1.0L, 6.724206286224187012525355634643505205196e-4932L, 1.570796326794896619231321691639751442099L);
2509   TEST_c_c (clog, 0x1p-8191L, 1.0L, 1.681051571556046753131338908660876301299e-4932L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION);
2510   TEST_c_c (clog, 0x1p-8192L, 1.0L, 4.202628928890116882828347271652190753248e-4933L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION);
2511 #endif
2512
2513   TEST_c_c (clog, 0x1.000566p0L, 0x1.234p-10L, 8.298731898331237038231468223024422855654e-5L, 1.110938609507128729312743251313024793990e-3L);
2514   TEST_c_c (clog, 0x1.000566p0L, 0x1.234p-100L, 8.237022655933121125560939513260027133767e-5L, 8.974094312218060110948251664314290484113e-31L);
2515 #ifndef TEST_FLOAT
2516   TEST_c_c (clog, -0x1.0000000123456p0L, 0x1.2345678p-30L, 2.649094282537168795982991778475646793277e-10L, 3.141592652530155111500161671113150737892L);
2517   TEST_c_c (clog, -0x1.0000000123456p0L, 0x1.2345678p-1000L, 2.649094276923003995420209214900915462737e-10L, 3.141592653589793238462643383279502884197L);
2518 #endif
2519 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
2520   TEST_c_c (clog, 0x1.00000000000000123456789abcp0L, 0x1.23456789p-60L, 9.868649107778739757272772275265050767867e-19L, 9.868649106423871142816660980898339912137e-19L);
2521   TEST_c_c (clog, 0x1.00000000000000123456789abcp0L, 0x1.23456789p-1000L, 9.868649107778739752403260515979017248596e-19L, 1.061846605795612822522063052130030717368e-301L);
2522 #endif
2523
2524   TEST_c_c (clog, 0x0.ffffffp0L, 0x0.ffffffp-100L, -5.960464655174753498633255797994360530379e-8L, 7.888609052210118054117285652827862296732e-31L);
2525 #ifndef TEST_FLOAT
2526   TEST_c_c (clog, 0x0.fffffffffffff8p0L, 0x0.fffffffffffff8p-1000L, -1.110223024625156602053389888482372171810e-16L, 9.332636185032188789900895447238171696171e-302L);
2527 #endif
2528 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
2529   TEST_c_c (clog, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp-15000L, -5.421010862427522170184200798202494495630e-20L, 3.548665303440282824232502561095699343814e-4516L);
2530 #endif
2531
2532   TEST_c_c (clog, 0x1a6p-10L, 0x3a5p-10L, -1.4305135209763571252847059962654228661815e-06L, 1.1460277178115757370775644871674016684074L);
2533   TEST_c_c (clog, 0xf2p-10L, 0x3e3p-10L, 6.1988446308070710970664736815277450078106e-06L, 1.3322126499153926210226335249558203898460L);
2534   TEST_c_c (clog, 0x4d4ep-15L, 0x6605p-15L, -1.6298145321400412054744424587143483169412e-08L, 0.9223574537155056772124552172295398141249L);
2535   TEST_c_c (clog, 0x2818p-15L, 0x798fp-15L, 1.5366822245016167178749091974664853785194e-08L, 1.2522014929038946066987318471922169174157L);
2536   TEST_c_c (clog, 0x9b57bp-20L, 0xcb7b4p-20L, -3.9563019528687610863490232935890272740908e-11L, 0.9187593477446338910857133065497364950682L);
2537   TEST_c_c (clog, 0x2731p-20L, 0xfffd0p-20L, 4.4110493034041283943115971658295280288115e-11L, 1.5612279663766352262688735061954290528838L);
2538   TEST_c_c (clog, 0x2ede88p-23L, 0x771c3fp-23L, -4.4764192352906350039050902870893173560494e-13L, 1.1959106857549200806818600493552847793381L);
2539   TEST_c_c (clog, 0x11682p-23L, 0x7ffed1p-23L, 1.1723955140027907954461000991619077811832e-12L, 1.5622968405332756349813737986164832897108L);
2540   TEST_c_c (clog, 0xa1f2c1p-24L, 0xc643aep-24L, -1.0480505352462576151523512837107080269981e-13L, 0.8858771987699967480545613322309315260313L);
2541   TEST_c_c (clog, 0x659feap-24L, 0xeaf6f9p-24L, 3.7303493627403868207597214252239749960738e-14L, 1.1625816408046866464773042283673653469061L);
2542 #ifndef TEST_FLOAT
2543   TEST_c_c (clog, 0x4447d7175p-35L, 0x6c445e00ap-35L, -1.4823076576950255933915367361099865652625e-20L, 1.0081311552703893116404606212158840190615L);
2544   TEST_c_c (clog, 0x2dd46725bp-35L, 0x7783a1284p-35L, 4.4469229730850767799109418892826021157328e-20L, 1.2046235979300843056806465045930070146351L);
2545   TEST_c_c (clog, 0x164c74eea876p-45L, 0x16f393482f77p-45L, -3.0292258760486853327810377824479932031744e-26L, 0.7998237934177411746093524982030330293980L);
2546   TEST_c_c (clog, 0xfe961079616p-45L, 0x1bc37e09e6d1p-45L, 5.3718272201930019901317065495843842735179e-26L, 1.0503831592447830576186444373011142397404L);
2547   TEST_c_c (clog, 0xa4722f19346cp-51L, 0x7f9631c5e7f07p-51L, -6.2122796286154679676173624516405339768606e-30L, 1.4904138780720095276446375492434049214172L);
2548   TEST_c_c (clog, 0x10673dd0f2481p-51L, 0x7ef1d17cefbd2p-51L, 3.2047474274603604594851472963586149973093e-29L, 1.4422922682185099608731642353544207976604L);
2549   TEST_c_c (clog, 0x8ecbf810c4ae6p-52L, 0xd479468b09a37p-52L, -9.7375017988218644730510244778042114638107e-30L, 0.9790637929494922564724108399524154766631L);
2550   TEST_c_c (clog, 0x5b06b680ea2ccp-52L, 0xef452b965da9fp-52L, 8.3076914081087805757422664530653247447136e-30L, 1.2072712126771536614482822173033535043206L);
2551   TEST_c_c (clog, 0x659b70ab7971bp-53L, 0x1f5d111e08abecp-53L, -2.5083311595699359750201056724289010648701e-30L, 1.3710185432462268491534742969536240564640L);
2552   TEST_c_c (clog, 0x15cfbd1990d1ffp-53L, 0x176a3973e09a9ap-53L, 1.0168910106364605304135563536838075568606e-30L, 0.8208373755522359859870890246475340086663L);
2553   TEST_c_c (clog, 0x1367a310575591p-54L, 0x3cfcc0a0541f60p-54L, 5.0844550531823026520677817684239496041087e-32L, 1.2627468605458094918919206628466016525397L);
2554   TEST_c_c (clog, 0x55cb6d0c83af5p-55L, 0x7fe33c0c7c4e90p-55L, -5.2000108498455368032511404449795741611813e-32L, 1.5288921536982513453421343495466824420259L);
2555 #endif
2556 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
2557   TEST_c_c (clog, 0x298c62cb546588a7p-63L, 0x7911b1dfcc4ecdaep-63L, -1.1931267660846218205882675852805793644095e-36L, 1.2402109774337032400594953899784058127412L);
2558   TEST_c_c (clog, 0x4d9c37e2b5cb4533p-63L, 0x65c98be2385a042ep-63L, 6.4064442119814669184296141278612389400075e-37L, 0.9193591364645830864185131402313014890145L);
2559   TEST_c_c (clog, 0x602fd5037c4792efp-64L, 0xed3e2086dcca80b8p-64L, -2.3362950222592964220878638677292132852104e-37L, 1.1856121127236268105413184264288408265852L);
2560   TEST_c_c (clog, 0x6b10b4f3520217b6p-64L, 0xe8893cbb449253a1p-64L, 2.4244570985709679851855191080208817099132e-37L, 1.1393074519572050614551047548718495655972L);
2561   TEST_c_c (clog, 0x81b7efa81fc35ad1p-65L, 0x1ef4b835f1c79d812p-65L, -9.9182335850630508484862145328126979066934e-39L, 1.3146479888794807046338799047003947008804L);
2562 #endif
2563 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
2564   TEST_c_c (clog, 0x3f96469050f650869c2p-75L, 0x6f16b2c9c8b05988335p-75L, -1.0509738482436128031927971874674370984602e-45L, 1.0509191467640012308402149909370784281448L);
2565   TEST_c_c (clog, 0x3157fc1d73233e580c8p-75L, 0x761b52ccd435d7c7f5fp-75L, 1.3487497719126364307640897239165442763573e-43L, 1.1750493008528425228929764149024375035382L);
2566   TEST_c_c (clog, 0x155f8afc4c48685bf63610p-85L, 0x17d0cf2652cdbeb1294e19p-85L, -4.7775669192897997174762089350332738583822e-50L, 0.8393953487996880419413728440067635213372L);
2567   TEST_c_c (clog, 0x13836d58a13448d750b4b9p-85L, 0x195ca7bc3ab4f9161edbe6p-85L, 2.8398125044729578740243199963484494962411e-50L, 0.9149964976334130461795060758257083099706L);
2568   TEST_c_c (clog, 0x1df515eb171a808b9e400266p-95L, 0x7c71eb0cd4688dfe98581c77p-95L, -3.5048022044913950094635368750889659723004e-57L, 1.3345633256521815205858155673950177421079L);
2569   TEST_c_c (clog, 0xe33f66c9542ca25cc43c867p-95L, 0x7f35a68ebd3704a43c465864p-95L, 4.1101771307217268747345114262406964584250e-56L, 1.4596065864518742494094402406719567059585L);
2570   TEST_c_c (clog, 0x6771f22c64ed551b857c128b4cp-105L, 0x1f570e7a13cc3cf2f44fd793ea1p-105L, -1.4281333889622737316199756373421183559948e-62L, 1.3673546561165378090903506783353927980633L);
2571   TEST_c_c (clog, 0x15d8ab6ed05ca514086ac3a1e84p-105L, 0x1761e480aa094c0b10b34b09ce9p-105L, 1.0027319539522347477331743836657426754857e-62L, 0.8193464073721167323313606647411269414759L);
2572   TEST_c_c (clog, 0x187190c1a334497bdbde5a95f48p-106L, 0x3b25f08062d0a095c4cfbbc338dp-106L, -1.7471844652198029695350765775994001163767e-63L, 1.1789110097072986038243729592318526094314L);
2573   TEST_c_c (clog, 0x6241ef0da53f539f02fad67dabp-106L, 0x3fb46641182f7efd9caa769dac0p-106L, 4.3299788920664682288477984749202524623248e-63L, 1.4746938237585656250866370987773473745867L);
2574 #endif
2575 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 113
2576   TEST_c_c (clog, 0x3e1d0a105ac4ebeacd9c6952d34cp-112L, 0xf859b3d1b06d005dcbb5516d5479p-112L, -1.1683999374665377365054966073875064467108e-66L, 1.3257197596350832748781065387304444940172L);
2577   TEST_c_c (clog, 0x47017a2e36807acb1e5214b209dep-112L, 0xf5f4a550c9d75e3bb1839d865f0dp-112L, 1.5077923002544367932999503838191154621839e-65L, 1.2897445708311412721399861948957141824914L);
2578   TEST_c_c (clog, 0x148f818cb7a9258fca942ade2a0cap-113L, 0x18854a34780b8333ec53310ad7001p-113L, -7.1865869169568789348552370692485515571497e-67L, 0.8730167479365994646287897223471819363668L);
2579   TEST_c_c (clog, 0xfd95243681c055c2632286921092p-113L, 0x1bccabcd29ca2152860ec29e34ef7p-113L, 6.6255694866654064502633121109394710807528e-66L, 1.0526409614996288387567810726095850312049L);
2580   TEST_c_c (clog, 0xdb85c467ee2aadd5f425fe0f4b8dp-114L, 0x3e83162a0f95f1dcbf97dddf410eap-114L, 4.6017338806965821566734340588575402712716e-67L, 1.3547418904611758959096647942223384691728L);
2581   TEST_c_c (clog, 0x1415bcaf2105940d49a636e98ae59p-115L, 0x7e6a150adfcd1b0921d44b31f40f4p-115L, 2.5993421227864195179698176012564317527271e-67L, 1.4132318089683022770487383611430906982461L);
2582 #endif
2583
2584   END (clog, complex);
2585 }
2586
2587
2588 static void
2589 clog10_test (void)
2590 {
2591   errno = 0;
2592   FUNC(clog10) (BUILD_COMPLEX (0.7L, 1.2L));
2593   if (errno == ENOSYS)
2594     /* Function not implemented.  */
2595     return;
2596
2597   START (clog10);
2598
2599   TEST_c_c (clog10, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2600   TEST_c_c (clog10, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2601
2602   TEST_c_c (clog10, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
2603   TEST_c_c (clog10, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
2604
2605   TEST_c_c (clog10, minus_infty, plus_infty, plus_infty, M_PI_34_LOG10El);
2606
2607   TEST_c_c (clog10, plus_infty, plus_infty, plus_infty, M_PI4_LOG10El);
2608   TEST_c_c (clog10, plus_infty, minus_infty, plus_infty, -M_PI4_LOG10El);
2609
2610   TEST_c_c (clog10, 0, plus_infty, plus_infty, M_PI2_LOG10El);
2611   TEST_c_c (clog10, 3, plus_infty, plus_infty, M_PI2_LOG10El);
2612   TEST_c_c (clog10, minus_zero, plus_infty, plus_infty, M_PI2_LOG10El);
2613   TEST_c_c (clog10, -3, plus_infty, plus_infty, M_PI2_LOG10El);
2614   TEST_c_c (clog10, 0, minus_infty, plus_infty, -M_PI2_LOG10El);
2615   TEST_c_c (clog10, 3, minus_infty, plus_infty, -M_PI2_LOG10El);
2616   TEST_c_c (clog10, minus_zero, minus_infty, plus_infty, -M_PI2_LOG10El);
2617   TEST_c_c (clog10, -3, minus_infty, plus_infty, -M_PI2_LOG10El);
2618
2619   TEST_c_c (clog10, minus_infty, 0, plus_infty, M_PI_LOG10El);
2620   TEST_c_c (clog10, minus_infty, 1, plus_infty, M_PI_LOG10El);
2621   TEST_c_c (clog10, minus_infty, minus_zero, plus_infty, -M_PI_LOG10El);
2622   TEST_c_c (clog10, minus_infty, -1, plus_infty, -M_PI_LOG10El);
2623
2624   TEST_c_c (clog10, plus_infty, 0, plus_infty, 0.0);
2625   TEST_c_c (clog10, plus_infty, 1, plus_infty, 0.0);
2626   TEST_c_c (clog10, plus_infty, minus_zero, plus_infty, minus_zero);
2627   TEST_c_c (clog10, plus_infty, -1, plus_infty, minus_zero);
2628
2629   TEST_c_c (clog10, plus_infty, nan_value, plus_infty, nan_value);
2630   TEST_c_c (clog10, minus_infty, nan_value, plus_infty, nan_value);
2631
2632   TEST_c_c (clog10, nan_value, plus_infty, plus_infty, nan_value);
2633   TEST_c_c (clog10, nan_value, minus_infty, plus_infty, nan_value);
2634
2635   TEST_c_c (clog10, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2636   TEST_c_c (clog10, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2637   TEST_c_c (clog10, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2638   TEST_c_c (clog10, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2639
2640   TEST_c_c (clog10, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2641   TEST_c_c (clog10, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2642   TEST_c_c (clog10, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2643   TEST_c_c (clog10, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2644
2645   TEST_c_c (clog10, nan_value, nan_value, nan_value, nan_value);
2646
2647   TEST_c_c (clog10, 0.75L, 1.25L, 0.163679467193165171449476605077428975L, 0.447486970040493067069984724340855636L);
2648   TEST_c_c (clog10, -2, -3, 0.556971676153418384603252578971164214L, -0.937554462986374708541507952140189646L);
2649
2650   TEST_c_c (clog10, 0x1.fffffep+127L, 0x1.fffffep+127L, 38.68235441693561449174780668781319348761L, M_PI4_LOG10El);
2651   TEST_c_c (clog10, 0x1.fffffep+127L, 1.0L, 38.53183941910362389414093724045094697423L, 1.276276851248440096917018665609900318458e-39L, UNDERFLOW_EXCEPTION_FLOAT);
2652   TEST_c_c (clog10, 0x1p-149L, 0x1p-149L, -44.70295435610120748924022586658721447508L, M_PI4_LOG10El);
2653   TEST_c_c (clog10, 0x1p-147L, 0x1p-147L, -44.10089436477324509881274807713822842154L, M_PI4_LOG10El);
2654
2655 #ifndef TEST_FLOAT
2656   TEST_c_c (clog10, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 308.4052305577487344482591243175787477115L, M_PI4_LOG10El);
2657   TEST_c_c (clog10, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 308.3031705664207720674749211936626341569L, 0.2013595981366865903254995612594728746470L);
2658   TEST_c_c (clog10, 0x1p-1074L, 0x1p-1074L, -323.1557003452838130619487034867432642357L, M_PI4_LOG10El);
2659   TEST_c_c (clog10, 0x1p-1073L, 0x1p-1073L, -322.8546703496198318667349645920187712089L, M_PI4_LOG10El);
2660 #endif
2661
2662 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2663   TEST_c_c (clog10, 0x1.fp+16383L, 0x1.fp+16383L, 4932.212175672014259683102930239951947672L, M_PI4_LOG10El);
2664   TEST_c_c (clog10, 0x1.fp+16383L, 0x1p+16383L, 4932.112944269463028900262609694408579449L, 0.2069271710841128115912940666587802677383L);
2665   TEST_c_c (clog10, 0x1p-16440L, 0x1p-16441L, -4948.884673709346821106688037612752099609L, 0.2013595981366865710389502301937289472543L);
2666 #endif
2667
2668   TEST_c_c (clog10, 0x1p-149L, 0x1.fp+127L, 38.51805116050395969095658815123105801479L, 0.6821881769209206737428918127156778851051L);
2669   TEST_c_c (clog10, -0x1p-149L, 0x1.fp+127L, 38.51805116050395969095658815123105801479L, 0.6821881769209206737428918127156778851051L);
2670   TEST_c_c (clog10, 0x1p-149L, -0x1.fp+127L, 38.51805116050395969095658815123105801479L, -0.6821881769209206737428918127156778851051L);
2671   TEST_c_c (clog10, -0x1p-149L, -0x1.fp+127L, 38.51805116050395969095658815123105801479L, -0.6821881769209206737428918127156778851051L);
2672   TEST_c_c (clog10, -0x1.fp+127L, 0x1p-149L, 38.51805116050395969095658815123105801479L, 1.364376353841841347485783625431355770210L);
2673   TEST_c_c (clog10, -0x1.fp+127L, -0x1p-149L, 38.51805116050395969095658815123105801479L, -1.364376353841841347485783625431355770210L);
2674 #ifdef TEST_FLOAT
2675   TEST_c_c (clog10, 0x1.fp+127L, 0x1p-149L, 38.51805116050395969095658815123105801479L, plus_zero, UNDERFLOW_EXCEPTION);
2676   TEST_c_c (clog10, 0x1.fp+127L, -0x1p-149L, 38.51805116050395969095658815123105801479L, minus_zero, UNDERFLOW_EXCEPTION);
2677 #endif
2678
2679 #ifndef TEST_FLOAT
2680   TEST_c_c (clog10, 0x1p-1074L, 0x1.fp+1023L, 308.2409272754311106024666378243768099991L, 0.6821881769209206737428918127156778851051L);
2681   TEST_c_c (clog10, -0x1p-1074L, 0x1.fp+1023L, 308.2409272754311106024666378243768099991L, 0.6821881769209206737428918127156778851051L);
2682   TEST_c_c (clog10, 0x1p-1074L, -0x1.fp+1023L, 308.2409272754311106024666378243768099991L, -0.6821881769209206737428918127156778851051L);
2683   TEST_c_c (clog10, -0x1p-1074L, -0x1.fp+1023L, 308.2409272754311106024666378243768099991L, -0.6821881769209206737428918127156778851051L);
2684   TEST_c_c (clog10, -0x1.fp+1023L, 0x1p-1074L, 308.2409272754311106024666378243768099991L, 1.364376353841841347485783625431355770210L);
2685   TEST_c_c (clog10, -0x1.fp+1023L, -0x1p-1074L, 308.2409272754311106024666378243768099991L, -1.364376353841841347485783625431355770210L);
2686 #endif
2687 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2688   TEST_c_c (clog10, 0x1.fp+1023L, 0x1p-1074L, 308.2409272754311106024666378243768099991L, plus_zero, UNDERFLOW_EXCEPTION);
2689   TEST_c_c (clog10, 0x1.fp+1023L, -0x1p-1074L, 308.2409272754311106024666378243768099991L, minus_zero, UNDERFLOW_EXCEPTION);
2690 #endif
2691
2692 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2693   TEST_c_c (clog10, 0x1p-16445L, 0x1.fp+16383L, 4932.061660674182269085496060792589701158L, 0.6821881769209206737428918127156778851051L);
2694   TEST_c_c (clog10, -0x1p-16445L, 0x1.fp+16383L, 4932.061660674182269085496060792589701158L, 0.6821881769209206737428918127156778851051L);
2695   TEST_c_c (clog10, 0x1p-16445L, -0x1.fp+16383L, 4932.061660674182269085496060792589701158L, -0.6821881769209206737428918127156778851051L);
2696   TEST_c_c (clog10, -0x1p-16445L, -0x1.fp+16383L, 4932.061660674182269085496060792589701158L, -0.6821881769209206737428918127156778851051L);
2697   TEST_c_c (clog10, -0x1.fp+16383L, 0x1p-16445L, 4932.061660674182269085496060792589701158L, 1.364376353841841347485783625431355770210L);
2698   TEST_c_c (clog10, -0x1.fp+16383L, -0x1p-16445L, 4932.061660674182269085496060792589701158L, -1.364376353841841347485783625431355770210L);
2699   TEST_c_c (clog10, 0x1.fp+16383L, 0x1p-16445L, 4932.061660674182269085496060792589701158L, plus_zero, UNDERFLOW_EXCEPTION);
2700   TEST_c_c (clog10, 0x1.fp+16383L, -0x1p-16445L, 4932.061660674182269085496060792589701158L, minus_zero, UNDERFLOW_EXCEPTION);
2701 # if LDBL_MANT_DIG >= 113
2702   TEST_c_c (clog10, 0x1p-16494L, 0x1.fp+16383L, 4932.061660674182269085496060792589701158L, 0.6821881769209206737428918127156778851051L);
2703   TEST_c_c (clog10, -0x1p-16494L, 0x1.fp+16383L, 4932.061660674182269085496060792589701158L, 0.6821881769209206737428918127156778851051L);
2704   TEST_c_c (clog10, 0x1p-16494L, -0x1.fp+16383L, 4932.061660674182269085496060792589701158L, -0.6821881769209206737428918127156778851051L);
2705   TEST_c_c (clog10, -0x1p-16494L, -0x1.fp+16383L, 4932.061660674182269085496060792589701158L, -0.6821881769209206737428918127156778851051L);
2706   TEST_c_c (clog10, -0x1.fp+16383L, 0x1p-16494L, 4932.061660674182269085496060792589701158L, 1.364376353841841347485783625431355770210L);
2707   TEST_c_c (clog10, -0x1.fp+16383L, -0x1p-16494L, 4932.061660674182269085496060792589701158L, -1.364376353841841347485783625431355770210L);
2708   TEST_c_c (clog10, 0x1.fp+16383L, 0x1p-16494L, 4932.061660674182269085496060792589701158L, plus_zero, UNDERFLOW_EXCEPTION);
2709   TEST_c_c (clog10, 0x1.fp+16383L, -0x1p-16494L, 4932.061660674182269085496060792589701158L, minus_zero, UNDERFLOW_EXCEPTION);
2710 # endif
2711 #endif
2712
2713   TEST_c_c (clog10, 1.0L, 0x1.234566p-10L, 2.680828048441605163181684680300513080769e-7L, 4.825491868832381486767558728169977751564e-4L);
2714   TEST_c_c (clog10, -1.0L, 0x1.234566p-20L, 2.556638434669064077889576526006849923281e-13L, 1.364375882602207106407956770293808181427L);
2715   TEST_c_c (clog10, 0x1.234566p-30L, 1.0L, 2.438200411482400072282924063740535840474e-19L, 6.821881764607257184291586401763604544928e-1L);
2716   TEST_c_c (clog10, -0x1.234566p-40L, -1.0L, 2.325249110681915353442924915876654139373e-25L, -6.821881769213700828789403802671540158935e-1L);
2717   TEST_c_c (clog10, 0x1.234566p-50L, 1.0L, 2.217530356103816369479108963807448194409e-31L, 6.821881769209202348667823902864283966959e-1L);
2718   TEST_c_c (clog10, 0x1.234566p-60L, 1.0L, 2.114801746467415208319767917450504756866e-37L, 6.821881769209206733143018621078368211515e-1L);
2719   TEST_c_c (clog10, 0x1p-61L, 1.0L, 4.084085680564517578238994467153626207224e-38L, 6.821881769209206735545466044044889962925e-1L);
2720   TEST_c_c (clog10, 0x1p-62L, 1.0L, 1.021021420141129394559748616788406551878e-38L, 6.821881769209206736487192085600834406988e-1L, UNDERFLOW_EXCEPTION_FLOAT);
2721   TEST_c_c (clog10, 0x1p-63L, 1.0L, 2.552553550352823486399371541971016379740e-39L, 6.821881769209206736958055106378806629019e-1L, UNDERFLOW_EXCEPTION_FLOAT);
2722 #ifndef TEST_FLOAT
2723   TEST_c_c (clog10, 0x1p-509L, 1.0L, 7.730698388614835910296270976605350994446e-308L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
2724   TEST_c_c (clog10, 0x1p-510L, 1.0L, 1.932674597153708977574067744151337748612e-308L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION_DOUBLE);
2725   TEST_c_c (clog10, 0x1p-511L, 1.0L, 4.831686492884272443935169360378344371529e-309L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION_DOUBLE);
2726 #endif
2727 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2728   TEST_c_c (clog10, 0x1p-8189L, 1.0L, 1.168114274114528946314738738025008370069e-4931L, 6.821881769209206737428918127156778851051e-1L);
2729   TEST_c_c (clog10, 0x1p-8190L, 1.0L, 2.920285685286322365786846845062520925172e-4932L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION);
2730   TEST_c_c (clog10, 0x1p-8191L, 1.0L, 7.300714213215805914467117112656302312931e-4933L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION);
2731 #endif
2732
2733   TEST_c_c (clog10, 0x1.000566p0L, 0x1.234p-10L, 3.604093470239754109961125085078190708674e-5L, 4.824745078422174667425851670822596859720e-4L);
2734   TEST_c_c (clog10, 0x1.000566p0L, 0x1.234p-100L, 3.577293486783822178310971763308187385546e-5L, 3.897399639875661463735636919790792140598e-31L);
2735 #ifndef TEST_FLOAT
2736   TEST_c_c (clog10, -0x1.0000000123456p0L, 0x1.2345678p-30L, 1.150487028947346337782682105935961875822e-10L, 1.364376353381646356131680448946397884147L);
2737   TEST_c_c (clog10, -0x1.0000000123456p0L, 0x1.2345678p-1000L, 1.150487026509145544402795327729455391948e-10L, 1.364376353841841347485783625431355770210L);
2738 #endif
2739 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
2740   TEST_c_c (clog10, 0x1.00000000000000123456789abcp0L, 0x1.23456789p-60L, 4.285899851347756188767674032946882584784e-19L, 4.285899850759344225805480528847018395861e-19L);
2741   TEST_c_c (clog10, 0x1.00000000000000123456789abcp0L, 0x1.23456789p-1000L, 4.285899851347756186652871946325962330640e-19L, 4.611541215247321502041995872887317363241e-302L);
2742 #endif
2743
2744   TEST_c_c (clog10, 0x0.ffffffp0L, 0x0.ffffffp-100L, -2.588596909321764128428416045209904492216e-8L, 3.425979381266895667295625489912064603415e-31L);
2745 #ifndef TEST_FLOAT
2746   TEST_c_c (clog10, 0x0.fffffffffffff8p0L, 0x0.fffffffffffff8p-1000L, -4.821637332766435821255375046554377090472e-17L, 4.053112396770095089737411317782466262176e-302L);
2747 #endif
2748 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
2749   TEST_c_c (clog10, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp-15000L, -2.354315103889861110220423157644627849164e-20L, 1.541165759405643564697852372112893034397e-4516L);
2750 #endif
2751
2752   TEST_c_c (clog10, 0x1a6p-10L, 0x3a5p-10L, -6.2126412844802358329771948751248003038444e-07L, 0.4977135139537443711784513409096950995985L);
2753   TEST_c_c (clog10, 0xf2p-10L, 0x3e3p-10L, 2.6921240173351112953324592659528481616879e-06L, 0.5785726025799636431142862788413361783862L);
2754   TEST_c_c (clog10, 0x4d4ep-15L, 0x6605p-15L, -7.0781945783414996953799915941870192015212e-09L, 0.4005747524909781155537088181659175147564L);
2755   TEST_c_c (clog10, 0x2818p-15L, 0x798fp-15L, 6.6737261053986614395049481326819059203910e-09L, 0.5438241985991753781478398141908629586460L);
2756   TEST_c_c (clog10, 0x9b57bp-20L, 0xcb7b4p-20L, -1.7182001068739620267773842120965071561416e-11L, 0.3990121149225253562859800593935899629087L);
2757   TEST_c_c (clog10, 0x2731p-20L, 0xfffd0p-20L, 1.9156943718715958194239364991329064049438e-11L, 0.6780326907904082601285090019969008967595L);
2758   TEST_c_c (clog10, 0x2ede88p-23L, 0x771c3fp-23L, -1.9440841725722970687903291200493082253766e-13L, 0.5193774116724956222518530053006822210323L);
2759   TEST_c_c (clog10, 0x11682p-23L, 0x7ffed1p-23L, 5.0916490233953865181284669870035717560498e-13L, 0.6784968969384861816694467029319146542069L);
2760   TEST_c_c (clog10, 0xa1f2c1p-24L, 0xc643aep-24L, -4.5516256421319921959681423447271490869664e-14L, 0.3847315790697197749315054516562206543710L);
2761   TEST_c_c (clog10, 0x659feap-24L, 0xeaf6f9p-24L, 1.6200701438094619117335617123525612051457e-14L, 0.5049027913635038013499728086604870749732L);
2762 #ifndef TEST_FLOAT
2763   TEST_c_c (clog10, 0x4447d7175p-35L, 0x6c445e00ap-35L, -6.4375803621988389731799033530075237868110e-21L, 0.4378257977686804492768642780897650927167L);
2764   TEST_c_c (clog10, 0x2dd46725bp-35L, 0x7783a1284p-35L, 1.9312741086596516918394613098872836703188e-20L, 0.5231613813514771042838490538484014771862L);
2765   TEST_c_c (clog10, 0x164c74eea876p-45L, 0x16f393482f77p-45L, -1.3155760824064879362415202279780039150764e-26L, 0.3473590599762514228227328130640352044313L);
2766   TEST_c_c (clog10, 0xfe961079616p-45L, 0x1bc37e09e6d1p-45L, 2.3329549194675052736016290082882121135546e-26L, 0.4561756099441139182878993697611751382976L);
2767   TEST_c_c (clog10, 0xa4722f19346cp-51L, 0x7f9631c5e7f07p-51L, -2.6979587627476803379953050733225113494503e-30L, 0.6472785229986997177606324374555347813105L);
2768   TEST_c_c (clog10, 0x10673dd0f2481p-51L, 0x7ef1d17cefbd2p-51L, 1.3918041236396763648388478552321724382899e-29L, 0.6263795733790237053262025311642907438291L);
2769   TEST_c_c (clog10, 0x8ecbf810c4ae6p-52L, 0xd479468b09a37p-52L, -4.2289432987513243393180377141513840878196e-30L, 0.4252020027092323591068799049905597805296L);
2770   TEST_c_c (clog10, 0x5b06b680ea2ccp-52L, 0xef452b965da9fp-52L, 3.6079845358966994996207055940336690133424e-30L, 0.5243112258263349992771652393178033846555L);
2771   TEST_c_c (clog10, 0x659b70ab7971bp-53L, 0x1f5d111e08abecp-53L, -1.0893543813872082317104059174982092534059e-30L, 0.5954257879188711495921161433751775633232L);
2772   TEST_c_c (clog10, 0x15cfbd1990d1ffp-53L, 0x176a3973e09a9ap-53L, 4.4163015461643576961232672330852798804976e-31L, 0.3564851427422832755956993418877523303529L);
2773   TEST_c_c (clog10, 0x1367a310575591p-54L, 0x3cfcc0a0541f60p-54L, 2.2081507730821788480616336165447731164865e-32L, 0.5484039935757001196548030312819898864760L);
2774   TEST_c_c (clog10, 0x55cb6d0c83af5p-55L, 0x7fe33c0c7c4e90p-55L, -2.2583360179249556400630343805573865814771e-32L, 0.6639894257763289307423302343317622430835L);
2775 #endif
2776 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
2777   TEST_c_c (clog10, 0x298c62cb546588a7p-63L, 0x7911b1dfcc4ecdaep-63L, -5.1816837072162316773907242302011632570857e-37L, 0.5386167838952956925896424154370364458140L);
2778   TEST_c_c (clog10, 0x4d9c37e2b5cb4533p-63L, 0x65c98be2385a042ep-63L, 2.7822833698845776001753149807484078521508e-37L, 0.3992725998539071066769046272515417679815L);
2779   TEST_c_c (clog10, 0x602fd5037c4792efp-64L, 0xed3e2086dcca80b8p-64L, -1.0146400362652473358437501879334790111898e-37L, 0.5149047982335273098246594109614460842099L);
2780   TEST_c_c (clog10, 0x6b10b4f3520217b6p-64L, 0xe8893cbb449253a1p-64L, 1.0529283395205396881397407610630442563938e-37L, 0.4947949395762683446121140513971996916447L);
2781   TEST_c_c (clog10, 0x81b7efa81fc35ad1p-65L, 0x1ef4b835f1c79d812p-65L, -4.3074341162203896332989394770760901408798e-39L, 0.5709443672155660428417571212549720987784L);
2782 #endif
2783 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
2784   TEST_c_c (clog10, 0x3f96469050f650869c2p-75L, 0x6f16b2c9c8b05988335p-75L, -4.5643214291682663316715446865040356750881e-46L, 0.4564083863660793840592614609053162690362L);
2785   TEST_c_c (clog10, 0x3157fc1d73233e580c8p-75L, 0x761b52ccd435d7c7f5fp-75L, 5.8575458340992751256451490143468457830297e-44L, 0.5103174273246635294300470585396890237265L);
2786   TEST_c_c (clog10, 0x155f8afc4c48685bf63610p-85L, 0x17d0cf2652cdbeb1294e19p-85L, -2.0748709499710785084693619097712106753591e-50L, 0.3645447681189598740620098186365764884771L);
2787   TEST_c_c (clog10, 0x13836d58a13448d750b4b9p-85L, 0x195ca7bc3ab4f9161edbe6p-85L, 1.2333149003324592532859843519619084433953e-50L, 0.3973779298829931059309198145608711073016L);
2788   TEST_c_c (clog10, 0x1df515eb171a808b9e400266p-95L, 0x7c71eb0cd4688dfe98581c77p-95L, -1.5221162575729652613635150540947625639689e-57L, 0.5795934880811949230121092882659698986043L);
2789   TEST_c_c (clog10, 0xe33f66c9542ca25cc43c867p-95L, 0x7f35a68ebd3704a43c465864p-95L, 1.7850272475173865337808494725293124613817e-56L, 0.6338990862456906754888183278564382516852L);
2790   TEST_c_c (clog10, 0x6771f22c64ed551b857c128b4cp-105L, 0x1f570e7a13cc3cf2f44fd793ea1p-105L, -6.2023045024810589256360494043570293518879e-63L, 0.5938345819561308555003145899438513900776L);
2791   TEST_c_c (clog10, 0x15d8ab6ed05ca514086ac3a1e84p-105L, 0x1761e480aa094c0b10b34b09ce9p-105L, 4.3548095442952115860848857519953610343042e-63L, 0.3558376234889641500775150477035448866763L);
2792   TEST_c_c (clog10, 0x187190c1a334497bdbde5a95f48p-106L, 0x3b25f08062d0a095c4cfbbc338dp-106L, -7.5879257211204444302994221436282805900756e-64L, 0.5119945461708707332160859198685423099187L);
2793   TEST_c_c (clog10, 0x6241ef0da53f539f02fad67dabp-106L, 0x3fb46641182f7efd9caa769dac0p-106L, 1.8804859395820231849002915747252695375405e-63L, 0.6404513901551516189871978418046651877394L);
2794 #endif
2795 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 113
2796   TEST_c_c (clog10, 0x3e1d0a105ac4ebeacd9c6952d34cp-112L, 0xf859b3d1b06d005dcbb5516d5479p-112L, -5.0742964549782184008668435276046798273476e-67L, 0.5757527761596220360985719127090110408283L);
2797   TEST_c_c (clog10, 0x47017a2e36807acb1e5214b209dep-112L, 0xf5f4a550c9d75e3bb1839d865f0dp-112L, 6.5482587585671294601662599808612773010057e-66L, 0.5601289501766423782280643144987875760229L);
2798   TEST_c_c (clog10, 0x148f818cb7a9258fca942ade2a0cap-113L, 0x18854a34780b8333ec53310ad7001p-113L, -3.1210950417524756037077807411854181477733e-67L, 0.3791463562379872585396164879981280044658L);
2799   TEST_c_c (clog10, 0xfd95243681c055c2632286921092p-113L, 0x1bccabcd29ca2152860ec29e34ef7p-113L, 2.8774482675253468630312378575186855052697e-66L, 0.4571561610046221605554903008571429975493L);
2800   TEST_c_c (clog10, 0xdb85c467ee2aadd5f425fe0f4b8dp-114L, 0x3e83162a0f95f1dcbf97dddf410eap-114L, 1.9985076315737626043096596036300177494613e-67L, 0.5883569274304683249184005177865521205198L);
2801   TEST_c_c (clog10, 0x1415bcaf2105940d49a636e98ae59p-115L, 0x7e6a150adfcd1b0921d44b31f40f4p-115L, 1.1288799405048268615023706955013387413519e-67L, 0.6137587762850841972073301550420510507903L);
2802 #endif
2803
2804   END (clog10, complex);
2805 }
2806
2807
2808 static void
2809 conj_test (void)
2810 {
2811   START (conj);
2812   TEST_c_c (conj, 0.0, 0.0, 0.0, minus_zero);
2813   TEST_c_c (conj, 0.0, minus_zero, 0.0, 0.0);
2814   TEST_c_c (conj, nan_value, nan_value, nan_value, nan_value);
2815   TEST_c_c (conj, plus_infty, minus_infty, plus_infty, plus_infty);
2816   TEST_c_c (conj, plus_infty, plus_infty, plus_infty, minus_infty);
2817   TEST_c_c (conj, 1.0, 2.0, 1.0, -2.0);
2818   TEST_c_c (conj, 3.0, -4.0, 3.0, 4.0);
2819
2820   END (conj, complex);
2821 }
2822
2823
2824 static void
2825 copysign_test (void)
2826 {
2827   START (copysign);
2828
2829   TEST_ff_f (copysign, 0, 4, 0);
2830   TEST_ff_f (copysign, 0, -4, minus_zero);
2831   TEST_ff_f (copysign, minus_zero, 4, 0);
2832   TEST_ff_f (copysign, minus_zero, -4, minus_zero);
2833
2834   TEST_ff_f (copysign, plus_infty, 0, plus_infty);
2835   TEST_ff_f (copysign, plus_infty, minus_zero, minus_infty);
2836   TEST_ff_f (copysign, minus_infty, 0, plus_infty);
2837   TEST_ff_f (copysign, minus_infty, minus_zero, minus_infty);
2838
2839   TEST_ff_f (copysign, 0, plus_infty, 0);
2840   TEST_ff_f (copysign, 0, minus_zero, minus_zero);
2841   TEST_ff_f (copysign, minus_zero, plus_infty, 0);
2842   TEST_ff_f (copysign, minus_zero, minus_zero, minus_zero);
2843
2844   /* XXX More correctly we would have to check the sign of the NaN.  */
2845   TEST_ff_f (copysign, nan_value, 0, nan_value);
2846   TEST_ff_f (copysign, nan_value, minus_zero, nan_value);
2847   TEST_ff_f (copysign, -nan_value, 0, nan_value);
2848   TEST_ff_f (copysign, -nan_value, minus_zero, nan_value);
2849
2850   END (copysign);
2851 }
2852
2853
2854 static void
2855 cos_test (void)
2856 {
2857   errno = 0;
2858   FUNC(cos) (0);
2859   if (errno == ENOSYS)
2860     /* Function not implemented.  */
2861     return;
2862
2863   START (cos);
2864
2865   TEST_f_f (cos, 0, 1);
2866   TEST_f_f (cos, minus_zero, 1);
2867   errno = 0;
2868   TEST_f_f (cos, plus_infty, nan_value, INVALID_EXCEPTION);
2869   check_int ("errno for cos(+inf) == EDOM", errno, EDOM, 0, 0, 0);
2870   errno = 0;
2871   TEST_f_f (cos, minus_infty, nan_value, INVALID_EXCEPTION);
2872   check_int ("errno for cos(-inf) == EDOM", errno, EDOM, 0, 0, 0);
2873   errno = 0;
2874   TEST_f_f (cos, nan_value, nan_value);
2875   check_int ("errno for cos(NaN) unchanged", errno, 0, 0, 0, 0);
2876
2877   TEST_f_f (cos, M_PI_6l * 2.0, 0.5);
2878   TEST_f_f (cos, M_PI_6l * 4.0, -0.5);
2879   TEST_f_f (cos, M_PI_2l, 0);
2880
2881   TEST_f_f (cos, 0.75L, 0.731688868873820886311838753000084544L);
2882
2883   TEST_f_f (cos, 0x1p65, 0.99888622066058013610642172179340364209972L);
2884   TEST_f_f (cos, -0x1p65, 0.99888622066058013610642172179340364209972L);
2885
2886 #ifdef TEST_DOUBLE
2887   TEST_f_f (cos, 0.80190127184058835, 0.69534156199418473);
2888 #endif
2889
2890   TEST_f_f (cos, 0x1.442f74p+15, 2.4407839902314016628485779006274989801517e-06L);
2891
2892 #ifndef TEST_FLOAT
2893   TEST_f_f (cos, 1e22, 0.5232147853951389454975944733847094921409L);
2894   TEST_f_f (cos, 0x1p1023, -0.826369834614147994500785680811743734805L);
2895 #endif
2896
2897 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2898   TEST_f_f (cos, 0x1p16383L, 0.9210843909921906206874509522505756251609L);
2899 #endif
2900
2901   TEST_f_f (cos, 0x1p+120, -9.25879022854837867303861764107414946730833e-01L);
2902   TEST_f_f (cos, 0x1p+127, 7.81914638714960072263910298466369236613162e-01L);
2903   TEST_f_f (cos, 0x1.fffff8p+127, 9.98819362551949040703862043664101081064641e-01L);
2904   TEST_f_f (cos, 0x1.fffffep+127, 8.53021039830304158051791467692161107353094e-01L);
2905   TEST_f_f (cos, 0x1p+50, 8.68095904660550604334592502063501320395739e-01L);
2906   TEST_f_f (cos, 0x1p+28, -1.65568979490578758865468278195361551113358e-01L);
2907
2908   END (cos);
2909 }
2910
2911
2912 static void
2913 cos_test_tonearest (void)
2914 {
2915   int save_round_mode;
2916   errno = 0;
2917   FUNC(cos) (0);
2918   if (errno == ENOSYS)
2919     /* Function not implemented.  */
2920     return;
2921
2922   START (cos_tonearest);
2923
2924   save_round_mode = fegetround ();
2925
2926   if (!fesetround (FE_TONEAREST))
2927     {
2928       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2929       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2930       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2931       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2932       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2933       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2934       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2935       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2936       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2937       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2938     }
2939
2940   fesetround (save_round_mode);
2941
2942   END (cos_tonearest);
2943 }
2944
2945
2946 static void
2947 cos_test_towardzero (void)
2948 {
2949   int save_round_mode;
2950   errno = 0;
2951   FUNC(cos) (0);
2952   if (errno == ENOSYS)
2953     /* Function not implemented.  */
2954     return;
2955
2956   START (cos_towardzero);
2957
2958   save_round_mode = fegetround ();
2959
2960   if (!fesetround (FE_TOWARDZERO))
2961     {
2962       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2963       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2964       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2965       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2966       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2967       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2968       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2969       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2970       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2971       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2972     }
2973
2974   fesetround (save_round_mode);
2975
2976   END (cos_towardzero);
2977 }
2978
2979
2980 static void
2981 cos_test_downward (void)
2982 {
2983   int save_round_mode;
2984   errno = 0;
2985   FUNC(cos) (0);
2986   if (errno == ENOSYS)
2987     /* Function not implemented.  */
2988     return;
2989
2990   START (cos_downward);
2991
2992   save_round_mode = fegetround ();
2993
2994   if (!fesetround (FE_DOWNWARD))
2995     {
2996       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2997       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2998       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2999       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
3000       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
3001       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
3002       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
3003       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
3004       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
3005       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
3006     }
3007
3008   fesetround (save_round_mode);
3009
3010   END (cos_downward);
3011 }
3012
3013
3014 static void
3015 cos_test_upward (void)
3016 {
3017   int save_round_mode;
3018   errno = 0;
3019   FUNC(cos) (0);
3020   if (errno == ENOSYS)
3021     /* Function not implemented.  */
3022     return;
3023
3024   START (cos_upward);
3025
3026   save_round_mode = fegetround ();
3027
3028   if (!fesetround (FE_UPWARD))
3029     {
3030       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
3031       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
3032       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
3033       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
3034       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
3035       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
3036       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
3037       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
3038       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
3039       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
3040     }
3041
3042   fesetround (save_round_mode);
3043
3044   END (cos_upward);
3045 }
3046
3047
3048 static void
3049 cosh_test (void)
3050 {
3051   errno = 0;
3052   FUNC(cosh) (0.7L);
3053   if (errno == ENOSYS)
3054     /* Function not implemented.  */
3055     return;
3056
3057   START (cosh);
3058   TEST_f_f (cosh, 0, 1);
3059   TEST_f_f (cosh, minus_zero, 1);
3060
3061 #ifndef TEST_INLINE
3062   TEST_f_f (cosh, plus_infty, plus_infty);
3063   TEST_f_f (cosh, minus_infty, plus_infty);
3064 #endif
3065   TEST_f_f (cosh, nan_value, nan_value);
3066
3067   TEST_f_f (cosh, 0.75L, 1.29468328467684468784170818539018176L);
3068
3069 #ifndef TEST_FLOAT
3070   TEST_f_f (cosh, 709.8893558127259666434838436543941497802734375L, 9.9999998999995070652573675944761818416035e+307L);
3071   TEST_f_f (cosh, -709.8893558127259666434838436543941497802734375L, 9.9999998999995070652573675944761818416035e+307L);
3072 #endif
3073
3074   END (cosh);
3075 }
3076
3077
3078 static void
3079 cosh_test_tonearest (void)
3080 {
3081   int save_round_mode;
3082   errno = 0;
3083   FUNC(cosh) (0);
3084   if (errno == ENOSYS)
3085     /* Function not implemented.  */
3086     return;
3087
3088   START (cosh_tonearest);
3089
3090   save_round_mode = fegetround ();
3091
3092   if (!fesetround (FE_TONEAREST))
3093     {
3094       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
3095       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
3096       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
3097     }
3098
3099   fesetround (save_round_mode);
3100
3101   END (cosh_tonearest);
3102 }
3103
3104
3105 static void
3106 cosh_test_towardzero (void)
3107 {
3108   int save_round_mode;
3109   errno = 0;
3110   FUNC(cosh) (0);
3111   if (errno == ENOSYS)
3112     /* Function not implemented.  */
3113     return;
3114
3115   START (cosh_towardzero);
3116
3117   save_round_mode = fegetround ();
3118
3119   if (!fesetround (FE_TOWARDZERO))
3120     {
3121       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
3122       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
3123       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
3124     }
3125
3126   fesetround (save_round_mode);
3127
3128   END (cosh_towardzero);
3129 }
3130
3131
3132 static void
3133 cosh_test_downward (void)
3134 {
3135   int save_round_mode;
3136   errno = 0;
3137   FUNC(cosh) (0);
3138   if (errno == ENOSYS)
3139     /* Function not implemented.  */
3140     return;
3141
3142   START (cosh_downward);
3143
3144   save_round_mode = fegetround ();
3145
3146   if (!fesetround (FE_DOWNWARD))
3147     {
3148       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
3149       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
3150       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
3151     }
3152
3153   fesetround (save_round_mode);
3154
3155   END (cosh_downward);
3156 }
3157
3158
3159 static void
3160 cosh_test_upward (void)
3161 {
3162   int save_round_mode;
3163   errno = 0;
3164   FUNC(cosh) (0);
3165   if (errno == ENOSYS)
3166     /* Function not implemented.  */
3167     return;
3168
3169   START (cosh_upward);
3170
3171   save_round_mode = fegetround ();
3172
3173   if (!fesetround (FE_UPWARD))
3174     {
3175       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
3176       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
3177       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
3178     }
3179
3180   fesetround (save_round_mode);
3181
3182   END (cosh_upward);
3183 }
3184
3185
3186 static void
3187 cpow_test (void)
3188 {
3189   errno = 0;
3190   FUNC(cpow) (BUILD_COMPLEX (1, 0), BUILD_COMPLEX (0, 0));
3191   if (errno == ENOSYS)
3192     /* Function not implemented.  */
3193     return;
3194
3195   START (cpow);
3196
3197   TEST_cc_c (cpow, 1, 0, 0, 0, 1.0, 0.0);
3198   TEST_cc_c (cpow, 2, 0, 10, 0, 1024.0, 0.0);
3199
3200   TEST_cc_c (cpow, M_El, 0, 0, 2 * M_PIl, 1.0, 0.0);
3201   TEST_cc_c (cpow, 2, 3, 4, 0, -119.0, -120.0);
3202
3203   TEST_cc_c (cpow, nan_value, nan_value, nan_value, nan_value, nan_value, nan_value);
3204
3205   TEST_cc_c (cpow, 0.75L, 1.25L, 0.75L, 1.25L, 0.117506293914473555420279832210420483L, 0.346552747708338676483025352060418001L);
3206   TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 1.0L, 0.0846958290317209430433805274189191353L, 0.513285749182902449043287190519090481L);
3207   TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 0.0L, 0.75L, 1.25L);
3208   TEST_cc_c (cpow, 0.75L, 1.25L, 0.0L, 1.0L, 0.331825439177608832276067945276730566L, 0.131338600281188544930936345230903032L);
3209
3210   END (cpow, complex);
3211 }
3212
3213
3214 static void
3215 cproj_test (void)
3216 {
3217   START (cproj);
3218   TEST_c_c (cproj, 0.0, 0.0, 0.0, 0.0);
3219   TEST_c_c (cproj, minus_zero, minus_zero, minus_zero, minus_zero);
3220   TEST_c_c (cproj, 0.0, minus_zero, 0.0, minus_zero);
3221   TEST_c_c (cproj, minus_zero, 0.0, minus_zero, 0.0);
3222
3223   TEST_c_c (cproj, nan_value, nan_value, nan_value, nan_value);
3224
3225   TEST_c_c (cproj, plus_infty, plus_infty, plus_infty, 0.0);
3226   TEST_c_c (cproj, plus_infty, minus_infty, plus_infty, minus_zero);
3227   TEST_c_c (cproj, minus_infty, plus_infty, plus_infty, 0.0);
3228   TEST_c_c (cproj, minus_infty, minus_infty, plus_infty, minus_zero);
3229
3230   TEST_c_c (cproj, 1.0, 0.0, 1.0, 0.0);
3231   TEST_c_c (cproj, 2.0, 3.0, 2.0, 3.0);
3232
3233   END (cproj, complex);
3234 }
3235
3236
3237 static void
3238 creal_test (void)
3239 {
3240   START (creal);
3241   TEST_c_f (creal, 0.0, 1.0, 0.0);
3242   TEST_c_f (creal, minus_zero, 1.0, minus_zero);
3243   TEST_c_f (creal, nan_value, 1.0, nan_value);
3244   TEST_c_f (creal, nan_value, nan_value, nan_value);
3245   TEST_c_f (creal, plus_infty, 1.0, plus_infty);
3246   TEST_c_f (creal, minus_infty, 1.0, minus_infty);
3247   TEST_c_f (creal, 2.0, 3.0, 2.0);
3248
3249   END (creal);
3250 }
3251
3252 static void
3253 csin_test (void)
3254 {
3255   errno = 0;
3256   FUNC(csin) (BUILD_COMPLEX (0.7L, 1.2L));
3257   if (errno == ENOSYS)
3258     /* Function not implemented.  */
3259     return;
3260
3261   START (csin);
3262
3263   TEST_c_c (csin, 0.0, 0.0, 0.0, 0.0);
3264   TEST_c_c (csin, minus_zero, 0.0, minus_zero, 0.0);
3265   TEST_c_c (csin, 0.0, minus_zero, 0, minus_zero);
3266   TEST_c_c (csin, minus_zero, minus_zero, minus_zero, minus_zero);
3267
3268   TEST_c_c (csin, 0.0, plus_infty, 0.0, plus_infty);
3269   TEST_c_c (csin, minus_zero, plus_infty, minus_zero, plus_infty);
3270   TEST_c_c (csin, 0.0, minus_infty, 0.0, minus_infty);
3271   TEST_c_c (csin, minus_zero, minus_infty, minus_zero, minus_infty);
3272
3273   TEST_c_c (csin, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3274   TEST_c_c (csin, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3275   TEST_c_c (csin, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3276   TEST_c_c (csin, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3277
3278   TEST_c_c (csin, plus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3279   TEST_c_c (csin, minus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3280   TEST_c_c (csin, plus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3281   TEST_c_c (csin, minus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3282
3283   TEST_c_c (csin, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
3284   TEST_c_c (csin, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
3285   TEST_c_c (csin, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
3286   TEST_c_c (csin, minus_infty, -6.75,  nan_value, nan_value, INVALID_EXCEPTION);
3287
3288   TEST_c_c (csin, 4.625, plus_infty, minus_infty, minus_infty);
3289   TEST_c_c (csin, 4.625, minus_infty, minus_infty, plus_infty);
3290   TEST_c_c (csin, -4.625, plus_infty, plus_infty, minus_infty);
3291   TEST_c_c (csin, -4.625, minus_infty, plus_infty, plus_infty);
3292
3293   TEST_c_c (csin, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
3294   TEST_c_c (csin, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
3295
3296   TEST_c_c (csin, nan_value, plus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
3297   TEST_c_c (csin, nan_value, minus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
3298
3299   TEST_c_c (csin, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3300   TEST_c_c (csin, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3301
3302   TEST_c_c (csin, 0.0, nan_value, 0.0, nan_value);
3303   TEST_c_c (csin, minus_zero, nan_value, minus_zero, nan_value);
3304
3305   TEST_c_c (csin, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3306   TEST_c_c (csin, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3307
3308   TEST_c_c (csin, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3309   TEST_c_c (csin, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3310
3311   TEST_c_c (csin, nan_value, nan_value, nan_value, nan_value);
3312
3313   TEST_c_c (csin, 0.75L, 1.25L, 1.28722291002649188575873510790565441L, 1.17210635989270256101081285116138863L);
3314   TEST_c_c (csin, -2, -3, -9.15449914691142957346729954460983256L, 4.16890695996656435075481305885375484L);
3315
3316   TEST_c_c (csin, 0.75, 89.5, 2.522786001038096774676288412995370563339e38L, 2.708024460708609732016532185663087200560e38L);
3317   TEST_c_c (csin, 0.75, -89.5, 2.522786001038096774676288412995370563339e38L, -2.708024460708609732016532185663087200560e38L);
3318   TEST_c_c (csin, -0.75, 89.5, -2.522786001038096774676288412995370563339e38L, 2.708024460708609732016532185663087200560e38L);
3319   TEST_c_c (csin, -0.75, -89.5, -2.522786001038096774676288412995370563339e38L, -2.708024460708609732016532185663087200560e38L);
3320
3321 #ifndef TEST_FLOAT
3322   TEST_c_c (csin, 0.75, 710.5, 1.255317763348154410745082950806112487736e308L, 1.347490911916428129246890157395342279438e308L);
3323   TEST_c_c (csin, 0.75, -710.5, 1.255317763348154410745082950806112487736e308L, -1.347490911916428129246890157395342279438e308L);
3324   TEST_c_c (csin, -0.75, 710.5, -1.255317763348154410745082950806112487736e308L, 1.347490911916428129246890157395342279438e308L);
3325   TEST_c_c (csin, -0.75, -710.5, -1.255317763348154410745082950806112487736e308L, -1.347490911916428129246890157395342279438e308L);
3326 #endif
3327
3328 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3329   TEST_c_c (csin, 0.75, 11357.25, 8.385498349388321535962327491346664141020e4931L, 9.001213196851067077465606717616495588201e4931L);
3330   TEST_c_c (csin, 0.75, -11357.25, 8.385498349388321535962327491346664141020e4931L, -9.001213196851067077465606717616495588201e4931L);
3331   TEST_c_c (csin, -0.75, 11357.25, -8.385498349388321535962327491346664141020e4931L, 9.001213196851067077465606717616495588201e4931L);
3332   TEST_c_c (csin, -0.75, -11357.25, -8.385498349388321535962327491346664141020e4931L, -9.001213196851067077465606717616495588201e4931L);
3333 #endif
3334
3335 #ifdef TEST_FLOAT
3336   TEST_c_c (csin, 0x1p-149, 180, 1.043535896672617552965983803453927655332e33L, plus_infty, OVERFLOW_EXCEPTION);
3337 #endif
3338
3339 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
3340   TEST_c_c (csin, 0x1p-1074, 1440, 5.981479269486130556466515778180916082415e301L, plus_infty, OVERFLOW_EXCEPTION);
3341 #endif
3342
3343 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3344   TEST_c_c (csin, 0x1p-16434L, 22730, 1.217853148905605987081057582351152052687e4924L, plus_infty, OVERFLOW_EXCEPTION);
3345 #endif
3346
3347   END (csin, complex);
3348 }
3349
3350
3351 static void
3352 csinh_test (void)
3353 {
3354   errno = 0;
3355   FUNC(csinh) (BUILD_COMPLEX (0.7L, 1.2L));
3356   if (errno == ENOSYS)
3357     /* Function not implemented.  */
3358     return;
3359
3360   START (csinh);
3361
3362   TEST_c_c (csinh, 0.0, 0.0, 0.0, 0.0);
3363   TEST_c_c (csinh, minus_zero, 0.0, minus_zero, 0.0);
3364   TEST_c_c (csinh, 0.0, minus_zero, 0.0, minus_zero);
3365   TEST_c_c (csinh, minus_zero, minus_zero, minus_zero, minus_zero);
3366
3367   TEST_c_c (csinh, 0.0, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3368   TEST_c_c (csinh, minus_zero, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3369   TEST_c_c (csinh, 0.0, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3370   TEST_c_c (csinh, minus_zero, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3371
3372   TEST_c_c (csinh, plus_infty, 0.0, plus_infty, 0.0);
3373   TEST_c_c (csinh, minus_infty, 0.0, minus_infty, 0.0);
3374   TEST_c_c (csinh, plus_infty, minus_zero, plus_infty, minus_zero);
3375   TEST_c_c (csinh, minus_infty, minus_zero, minus_infty, minus_zero);
3376
3377   TEST_c_c (csinh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3378   TEST_c_c (csinh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3379   TEST_c_c (csinh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3380   TEST_c_c (csinh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3381
3382   TEST_c_c (csinh, plus_infty, 4.625, minus_infty, minus_infty);
3383   TEST_c_c (csinh, minus_infty, 4.625, plus_infty, minus_infty);
3384   TEST_c_c (csinh, plus_infty, -4.625, minus_infty, plus_infty);
3385   TEST_c_c (csinh, minus_infty, -4.625, plus_infty, plus_infty);
3386
3387   TEST_c_c (csinh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3388   TEST_c_c (csinh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3389   TEST_c_c (csinh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3390   TEST_c_c (csinh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3391
3392   TEST_c_c (csinh, 0.0, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
3393   TEST_c_c (csinh, minus_zero, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
3394
3395   TEST_c_c (csinh, plus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
3396   TEST_c_c (csinh, minus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
3397
3398   TEST_c_c (csinh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3399   TEST_c_c (csinh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3400
3401   TEST_c_c (csinh, nan_value, 0.0, nan_value, 0.0);
3402   TEST_c_c (csinh, nan_value, minus_zero, nan_value, minus_zero);
3403
3404   TEST_c_c (csinh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3405   TEST_c_c (csinh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3406
3407   TEST_c_c (csinh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
3408   TEST_c_c (csinh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
3409
3410   TEST_c_c (csinh, nan_value, nan_value, nan_value, nan_value);
3411
3412   TEST_c_c (csinh, 0.75L, 1.25L, 0.259294854551162779153349830618433028L, 1.22863452409509552219214606515777594L);
3413   TEST_c_c (csinh, -2, -3, 3.59056458998577995201256544779481679L, -0.530921086248519805267040090660676560L);
3414
3415   TEST_c_c (csinh, 89.5, 0.75, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
3416   TEST_c_c (csinh, -89.5, 0.75, -2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
3417   TEST_c_c (csinh, 89.5, -0.75, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
3418   TEST_c_c (csinh, -89.5, -0.75, -2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
3419
3420 #ifndef TEST_FLOAT
3421   TEST_c_c (csinh, 710.5, 0.75, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
3422   TEST_c_c (csinh, -710.5, 0.75, -1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
3423   TEST_c_c (csinh, 710.5, -0.75, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
3424   TEST_c_c (csinh, -710.5, -0.75, -1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
3425 #endif
3426
3427 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3428   TEST_c_c (csinh, 11357.25, 0.75, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
3429   TEST_c_c (csinh, -11357.25, 0.75, -9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
3430   TEST_c_c (csinh, 11357.25, -0.75, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
3431   TEST_c_c (csinh, -11357.25, -0.75, -9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
3432 #endif
3433
3434 #ifdef TEST_FLOAT
3435   TEST_c_c (csinh, 180, 0x1p-149, plus_infty, 1.043535896672617552965983803453927655332e33L, OVERFLOW_EXCEPTION);
3436 #endif
3437
3438 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
3439   TEST_c_c (csinh, 1440, 0x1p-1074, plus_infty, 5.981479269486130556466515778180916082415e301L, OVERFLOW_EXCEPTION);
3440 #endif
3441
3442 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3443   TEST_c_c (csinh, 22730, 0x1p-16434L, plus_infty, 1.217853148905605987081057582351152052687e4924L, OVERFLOW_EXCEPTION);
3444 #endif
3445
3446   END (csinh, complex);
3447 }
3448
3449
3450 static void
3451 csqrt_test (void)
3452 {
3453   errno = 0;
3454   FUNC(csqrt) (BUILD_COMPLEX (-1, 0));
3455   if (errno == ENOSYS)
3456     /* Function not implemented.  */
3457     return;
3458
3459   START (csqrt);
3460
3461   TEST_c_c (csqrt, 0, 0, 0.0, 0.0);
3462   TEST_c_c (csqrt, 0, minus_zero, 0, minus_zero);
3463   TEST_c_c (csqrt, minus_zero, 0, 0.0, 0.0);
3464   TEST_c_c (csqrt, minus_zero, minus_zero, 0.0, minus_zero);
3465
3466   TEST_c_c (csqrt, minus_infty, 0, 0.0, plus_infty);
3467   TEST_c_c (csqrt, minus_infty, 6, 0.0, plus_infty);
3468   TEST_c_c (csqrt, minus_infty, minus_zero, 0.0, minus_infty);
3469   TEST_c_c (csqrt, minus_infty, -6, 0.0, minus_infty);
3470
3471   TEST_c_c (csqrt, plus_infty, 0, plus_infty, 0.0);
3472   TEST_c_c (csqrt, plus_infty, 6, plus_infty, 0.0);
3473   TEST_c_c (csqrt, plus_infty, minus_zero, plus_infty, minus_zero);
3474   TEST_c_c (csqrt, plus_infty, -6, plus_infty, minus_zero);
3475
3476   TEST_c_c (csqrt, 0, plus_infty, plus_infty, plus_infty);
3477   TEST_c_c (csqrt, 4, plus_infty, plus_infty, plus_infty);
3478   TEST_c_c (csqrt, plus_infty, plus_infty, plus_infty, plus_infty);
3479   TEST_c_c (csqrt, minus_zero, plus_infty, plus_infty, plus_infty);
3480   TEST_c_c (csqrt, -4, plus_infty, plus_infty, plus_infty);
3481   TEST_c_c (csqrt, minus_infty, plus_infty, plus_infty, plus_infty);
3482   TEST_c_c (csqrt, 0, minus_infty, plus_infty, minus_infty);
3483   TEST_c_c (csqrt, 4, minus_infty, plus_infty, minus_infty);
3484   TEST_c_c (csqrt, plus_infty, minus_infty, plus_infty, minus_infty);
3485   TEST_c_c (csqrt, minus_zero, minus_infty, plus_infty, minus_infty);
3486   TEST_c_c (csqrt, -4, minus_infty, plus_infty, minus_infty);
3487   TEST_c_c (csqrt, minus_infty, minus_infty, plus_infty, minus_infty);
3488
3489   TEST_c_c (csqrt, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
3490
3491   TEST_c_c (csqrt, plus_infty, nan_value, plus_infty, nan_value);
3492
3493   TEST_c_c (csqrt, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3494   TEST_c_c (csqrt, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3495   TEST_c_c (csqrt, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3496   TEST_c_c (csqrt, -1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3497
3498   TEST_c_c (csqrt, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3499   TEST_c_c (csqrt, nan_value, 8, nan_value, nan_value, INVALID_EXCEPTION_OK);
3500   TEST_c_c (csqrt, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
3501   TEST_c_c (csqrt, nan_value, -8, nan_value, nan_value, INVALID_EXCEPTION_OK);
3502
3503   TEST_c_c (csqrt, nan_value, nan_value, nan_value, nan_value);
3504
3505   TEST_c_c (csqrt, 16.0, -30.0, 5.0, -3.0);
3506   TEST_c_c (csqrt, -1, 0, 0.0, 1.0);
3507   TEST_c_c (csqrt, 0, 2, 1.0, 1.0);
3508   TEST_c_c (csqrt, 119, 120, 12.0, 5.0);
3509   TEST_c_c (csqrt, 0.75L, 1.25L, 1.05065169626078392338656675760808326L, 0.594868882070379067881984030639932657L);
3510   TEST_c_c (csqrt, -2, -3, 0.89597747612983812471573375529004348L, -1.6741492280355400404480393008490519L);
3511   TEST_c_c (csqrt, -2, 3, 0.89597747612983812471573375529004348L, 1.6741492280355400404480393008490519L);
3512   /* Principal square root should be returned (i.e., non-negative real
3513      part).  */
3514   TEST_c_c (csqrt, 0, -1, M_SQRT_2_2, -M_SQRT_2_2);
3515
3516   TEST_c_c (csqrt, 0x1.fffffep+127L, 0x1.fffffep+127L, 2.026714405498316804978751017492482558075e+19L, 8.394925938143272988211878516208015586281e+18L);
3517   TEST_c_c (csqrt, 0x1.fffffep+127L, 1.0L, 1.844674352395372953599975585936590505260e+19L, 2.710505511993121390769065968615872097053e-20L);
3518   TEST_c_c (csqrt, 0x1p-149L, 0x1p-149L, 4.112805464342778798097003462770175200803e-23L, 1.703579802732953750368659735601389709551e-23L);
3519   TEST_c_c (csqrt, 0x1p-147L, 0x1p-147L, 8.225610928685557596194006925540350401606e-23L, 3.407159605465907500737319471202779419102e-23L);
3520
3521   TEST_c_c (csqrt, plus_zero, 0x1p-149L, 2.646977960169688559588507814623881131411e-23L, 2.646977960169688559588507814623881131411e-23L);
3522   TEST_c_c (csqrt, 0x1p-50L, 0x1p-149L, 2.980232238769531250000000000000000000000e-8L, 2.350988701644575015937473074444491355637e-38L);
3523 #ifdef TEST_FLOAT
3524   TEST_c_c (csqrt, 0x1p+127L, 0x1p-149L, 1.304381782533278221234957180625250836888e19L, plus_zero, UNDERFLOW_EXCEPTION);
3525 #endif
3526   TEST_c_c (csqrt, 0x1p-149L, 0x1p+127L, 9.223372036854775808000000000000000000000e18L, 9.223372036854775808000000000000000000000e18L);
3527   TEST_c_c (csqrt, 0x1.000002p-126L, 0x1.000002p-126L, 1.191195773697904627170323731331667740087e-19L, 4.934094449071842328766868579214125217132e-20L);
3528   TEST_c_c (csqrt, -0x1.000002p-126L, -0x1.000002p-126L, 4.934094449071842328766868579214125217132e-20L, -1.191195773697904627170323731331667740087e-19L);
3529
3530 #ifndef TEST_FLOAT
3531   TEST_c_c (csqrt, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 1.473094556905565378990473658199034571917e+154L, 6.101757441282702188537080005372547713595e+153L);
3532   TEST_c_c (csqrt, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 1.379778091031440685006200821918878702861e+154L, 3.257214233483129514781233066898042490248e+153L);
3533   TEST_c_c (csqrt, 0x1p-1074L, 0x1p-1074L, 2.442109726130830256743814843868934877597e-162L, 1.011554969366634726113090867589031782487e-162L);
3534   TEST_c_c (csqrt, 0x1p-1073L, 0x1p-1073L, 3.453664695497464982856905711457966660085e-162L, 1.430554756764195530630723976279903095110e-162L);
3535
3536   TEST_c_c (csqrt, plus_zero, 0x1p-1074L, 1.571727784702628688909515672805082228285e-162L, 1.571727784702628688909515672805082228285e-162L);
3537   TEST_c_c (csqrt, 0x1p-500L, 0x1p-1074L, 5.527147875260444560247265192192255725514e-76L, 4.469444793151709302716387622440056066334e-249L);
3538 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
3539   TEST_c_c (csqrt, 0x1p+1023L, 0x1p-1074L, 9.480751908109176726832526455652159260085e153L, plus_zero, UNDERFLOW_EXCEPTION);
3540 #endif
3541   TEST_c_c (csqrt, 0x1p-1074L, 0x1p+1023L, 6.703903964971298549787012499102923063740e153L, 6.703903964971298549787012499102923063740e153L);
3542   TEST_c_c (csqrt, 0x1.0000000000001p-1022L, 0x1.0000000000001p-1022L, 1.638872094839911521020410942677082920935e-154L, 6.788430486774966350907249113759995429568e-155L);
3543   TEST_c_c (csqrt, -0x1.0000000000001p-1022L, -0x1.0000000000001p-1022L, 6.788430486774966350907249113759995429568e-155L, -1.638872094839911521020410942677082920935e-154L);
3544 #endif
3545
3546 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3547   TEST_c_c (csqrt, 0x1.fp+16383L, 0x1.fp+16383L, 1.179514222452201722651836720466795901016e+2466L, 4.885707879516577666702435054303191575148e+2465L);
3548   TEST_c_c (csqrt, 0x1.fp+16383L, 0x1p+16383L, 1.106698967236475180613254276996359485630e+2466L, 2.687568007603946993388538156299100955642e+2465L);
3549   TEST_c_c (csqrt, 0x1p-16440L, 0x1p-16441L, 3.514690655930285351254618340783294558136e-2475L,  8.297059146828716918029689466551384219370e-2476L);
3550
3551   TEST_c_c (csqrt, plus_zero, 0x1p-16445L, 4.269191686890197837775136325621239761720e-2476L, 4.269191686890197837775136325621239761720e-2476L);
3552   TEST_c_c (csqrt, 0x1p-5000L, 0x1p-16445L, 2.660791472672778409283210520357607795518e-753L, 6.849840675828785164910701384823702064234e-4199L);
3553   TEST_c_c (csqrt, 0x1p+16383L, 0x1p-16445L, 7.712754032630730034273323365543179095045e2465L, plus_zero, UNDERFLOW_EXCEPTION);
3554   TEST_c_c (csqrt, 0x1p-16445L, 0x1p+16383L, 5.453740678097079647314921223668914312241e2465L, 5.453740678097079647314921223668914312241e2465L);
3555   TEST_c_c (csqrt, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-16382L, 2.014551439675644900131815801350165472778e-2466L, 8.344545284118961664300307045791497724440e-2467L);
3556   TEST_c_c (csqrt, -0x1.0000000000000002p-16382L, -0x1.0000000000000002p-16382L, 8.344545284118961664300307045791497724440e-2467L, -2.014551439675644900131815801350165472778e-2466L);
3557
3558 # if LDBL_MANT_DIG >= 113
3559   TEST_c_c (csqrt, plus_zero, 0x1p-16494L, 1.799329752913293143453817328207572571442e-2483L, 1.799329752913293143453817328207572571442e-2483L);
3560   TEST_c_c (csqrt, 0x1p-5000L, 0x1p-16494L, 2.660791472672778409283210520357607795518e-753L, 1.216776133331049643422030716668249905907e-4213L);
3561   TEST_c_c (csqrt, 0x1p+16383L, 0x1p-16494L, 7.712754032630730034273323365543179095045e2465L, plus_zero, UNDERFLOW_EXCEPTION);
3562   TEST_c_c (csqrt, 0x1p-16494L, 0x1p+16383L, 5.453740678097079647314921223668914312241e2465L, 5.453740678097079647314921223668914312241e2465L);
3563   TEST_c_c (csqrt, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-16382L, 2.014551439675644900022606748976158925145e-2466L, 8.344545284118961663847948339519226074126e-2467L);
3564   TEST_c_c (csqrt, -0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-16382L, 8.344545284118961663847948339519226074126e-2467L, -2.014551439675644900022606748976158925145e-2466L);
3565 # endif
3566 #endif
3567
3568   END (csqrt, complex);
3569 }
3570
3571 static void
3572 ctan_test (void)
3573 {
3574   errno = 0;
3575   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3576   if (errno == ENOSYS)
3577     /* Function not implemented.  */
3578     return;
3579
3580   START (ctan);
3581
3582   TEST_c_c (ctan, 0, 0, 0.0, 0.0);
3583   TEST_c_c (ctan, 0, minus_zero, 0.0, minus_zero);
3584   TEST_c_c (ctan, minus_zero, 0, minus_zero, 0.0);
3585   TEST_c_c (ctan, minus_zero, minus_zero, minus_zero, minus_zero);
3586
3587   TEST_c_c (ctan, 0, plus_infty, 0.0, 1.0);
3588   TEST_c_c (ctan, 1, plus_infty, 0.0, 1.0);
3589   TEST_c_c (ctan, minus_zero, plus_infty, minus_zero, 1.0);
3590   TEST_c_c (ctan, -1, plus_infty, minus_zero, 1.0);
3591
3592   TEST_c_c (ctan, 0, minus_infty, 0.0, -1.0);
3593   TEST_c_c (ctan, 1, minus_infty, 0.0, -1.0);
3594   TEST_c_c (ctan, minus_zero, minus_infty, minus_zero, -1.0);
3595   TEST_c_c (ctan, -1, minus_infty, minus_zero, -1.0);
3596
3597   TEST_c_c (ctan, plus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
3598   TEST_c_c (ctan, plus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
3599   TEST_c_c (ctan, minus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
3600   TEST_c_c (ctan, minus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
3601   TEST_c_c (ctan, plus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
3602   TEST_c_c (ctan, plus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
3603   TEST_c_c (ctan, minus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
3604   TEST_c_c (ctan, minus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
3605
3606   TEST_c_c (ctan, nan_value, plus_infty, 0.0, 1.0, IGNORE_ZERO_INF_SIGN);
3607   TEST_c_c (ctan, nan_value, minus_infty, 0.0, -1.0, IGNORE_ZERO_INF_SIGN);
3608
3609   TEST_c_c (ctan, 0, nan_value, 0.0, nan_value);
3610   TEST_c_c (ctan, minus_zero, nan_value, minus_zero, nan_value);
3611
3612   TEST_c_c (ctan, 0.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3613   TEST_c_c (ctan, -4.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3614
3615   TEST_c_c (ctan, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3616   TEST_c_c (ctan, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
3617   TEST_c_c (ctan, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
3618   TEST_c_c (ctan, nan_value, -0.25, nan_value, nan_value, INVALID_EXCEPTION_OK);
3619
3620   TEST_c_c (ctan, nan_value, nan_value, nan_value, nan_value);
3621
3622   TEST_c_c (ctan, 0.75L, 1.25L, 0.160807785916206426725166058173438663L, 0.975363285031235646193581759755216379L);
3623   TEST_c_c (ctan, -2, -3, 0.376402564150424829275122113032269084e-2L, -1.00323862735360980144635859782192726L);
3624
3625   TEST_c_c (ctan, 1, 45, 1.490158918874345552942703234806348520895e-39L, 1.000000000000000000000000000000000000001L, UNDERFLOW_EXCEPTION_FLOAT);
3626   TEST_c_c (ctan, 1, 47, 2.729321264492904590777293425576722354636e-41L, 1.0, UNDERFLOW_EXCEPTION_FLOAT);
3627
3628 #ifndef TEST_FLOAT
3629   TEST_c_c (ctan, 1, 355, 8.140551093483276762350406321792653551513e-309L, 1.0, UNDERFLOW_EXCEPTION_DOUBLE);
3630   TEST_c_c (ctan, 1, 365, 1.677892637497921890115075995898773550884e-317L, 1.0, UNDERFLOW_EXCEPTION_DOUBLE);
3631 #endif
3632
3633 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3634   TEST_c_c (ctan, 1, 5680, 4.725214596136812019616700920476949798307e-4934L, 1.0, UNDERFLOW_EXCEPTION);
3635   TEST_c_c (ctan, 1, 5690, 9.739393181626937151720816611272607059057e-4943L, 1.0, UNDERFLOW_EXCEPTION);
3636 #endif
3637
3638   TEST_c_c (ctan, 0x3.243f6cp-1, 0, -2.287733242885645987394874673945769518150e7L, 0.0);
3639
3640   TEST_c_c (ctan, 0x1p127, 1, 0.2446359391192790896381501310437708987204L, 0.9101334047676183761532873794426475906201L);
3641
3642 #ifndef TEST_FLOAT
3643   TEST_c_c (ctan, 0x1p1023, 1, -0.2254627924997545057926782581695274244229L, 0.8786063118883068695462540226219865087189L);
3644 #endif
3645
3646 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3647   TEST_c_c (ctan, 0x1p16383L, 1, 0.1608598776370396607204448234354670036772L, 0.8133818522051542536316746743877629761488L);
3648 #endif
3649
3650   TEST_c_c (ctan, 50000, 50000, plus_zero, 1.0, UNDERFLOW_EXCEPTION);
3651   TEST_c_c (ctan, 50000, -50000, plus_zero, -1.0, UNDERFLOW_EXCEPTION);
3652   TEST_c_c (ctan, -50000, 50000, minus_zero, 1.0, UNDERFLOW_EXCEPTION);
3653   TEST_c_c (ctan, -50000, -50000, minus_zero, -1.0, UNDERFLOW_EXCEPTION);
3654
3655   END (ctan, complex);
3656 }
3657
3658
3659 static void
3660 ctan_test_tonearest (void)
3661 {
3662   int save_round_mode;
3663   errno = 0;
3664   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3665   if (errno == ENOSYS)
3666     /* Function not implemented.  */
3667     return;
3668
3669   START (ctan_tonearest);
3670
3671   save_round_mode = fegetround ();
3672
3673   if (!fesetround (FE_TONEAREST))
3674     {
3675       TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L);
3676
3677 #ifndef TEST_FLOAT
3678       TEST_c_c (ctan, 0x1.921fb54442d18p+0, 0x1p-1074, 1.633123935319536975596773704152891653086e16L, 1.317719414943508315995636961402669067843e-291L);
3679 #endif
3680
3681 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3682       TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L);
3683 #endif
3684     }
3685
3686   fesetround (save_round_mode);
3687
3688   END (ctan_tonearest, complex);
3689 }
3690
3691
3692 static void
3693 ctan_test_towardzero (void)
3694 {
3695   int save_round_mode;
3696   errno = 0;
3697   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3698   if (errno == ENOSYS)
3699     /* Function not implemented.  */
3700     return;
3701
3702   START (ctan_towardzero);
3703
3704   save_round_mode = fegetround ();
3705
3706   if (!fesetround (FE_TOWARDZERO))
3707     {
3708       TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L);
3709
3710 #ifndef TEST_FLOAT
3711       TEST_c_c (ctan, 0x1.921fb54442d18p+0, 0x1p-1074, 1.633123935319536975596773704152891653086e16L, 1.317719414943508315995636961402669067843e-291L);
3712 #endif
3713
3714 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3715       TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L);
3716 #endif
3717     }
3718
3719   fesetround (save_round_mode);
3720
3721   END (ctan_towardzero, complex);
3722 }
3723
3724
3725 static void
3726 ctan_test_downward (void)
3727 {
3728   int save_round_mode;
3729   errno = 0;
3730   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3731   if (errno == ENOSYS)
3732     /* Function not implemented.  */
3733     return;
3734
3735   START (ctan_downward);
3736
3737   save_round_mode = fegetround ();
3738
3739   if (!fesetround (FE_DOWNWARD))
3740     {
3741       TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L);
3742
3743 #ifndef TEST_FLOAT
3744       TEST_c_c (ctan, 0x1.921fb54442d18p+0, 0x1p-1074, 1.633123935319536975596773704152891653086e16L, 1.317719414943508315995636961402669067843e-291L);
3745 #endif
3746
3747 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3748       TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L);
3749 #endif
3750     }
3751
3752   fesetround (save_round_mode);
3753
3754   END (ctan_downward, complex);
3755 }
3756
3757
3758 static void
3759 ctan_test_upward (void)
3760 {
3761   int save_round_mode;
3762   errno = 0;
3763   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3764   if (errno == ENOSYS)
3765     /* Function not implemented.  */
3766     return;
3767
3768   START (ctan_upward);
3769
3770   save_round_mode = fegetround ();
3771
3772   if (!fesetround (FE_UPWARD))
3773     {
3774       TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L);
3775
3776 #ifndef TEST_FLOAT
3777       TEST_c_c (ctan, 0x1.921fb54442d18p+0, 0x1p-1074, 1.633123935319536975596773704152891653086e16L, 1.317719414943508315995636961402669067843e-291L);
3778 #endif
3779
3780 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3781       TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L);
3782 #endif
3783     }
3784
3785   fesetround (save_round_mode);
3786
3787   END (ctan_upward, complex);
3788 }
3789
3790
3791 static void
3792 ctanh_test (void)
3793 {
3794   errno = 0;
3795   FUNC(ctanh) (BUILD_COMPLEX (0, 0));
3796   if (errno == ENOSYS)
3797     /* Function not implemented.  */
3798     return;
3799
3800   START (ctanh);
3801
3802   TEST_c_c (ctanh, 0, 0, 0.0, 0.0);
3803   TEST_c_c (ctanh, 0, minus_zero, 0.0, minus_zero);
3804   TEST_c_c (ctanh, minus_zero, 0, minus_zero, 0.0);
3805   TEST_c_c (ctanh, minus_zero, minus_zero, minus_zero, minus_zero);
3806
3807   TEST_c_c (ctanh, plus_infty, 0, 1.0, 0.0);
3808   TEST_c_c (ctanh, plus_infty, 1, 1.0, 0.0);
3809   TEST_c_c (ctanh, plus_infty, minus_zero, 1.0, minus_zero);
3810   TEST_c_c (ctanh, plus_infty, -1, 1.0, minus_zero);
3811   TEST_c_c (ctanh, minus_infty, 0, -1.0, 0.0);
3812   TEST_c_c (ctanh, minus_infty, 1, -1.0, 0.0);
3813   TEST_c_c (ctanh, minus_infty, minus_zero, -1.0, minus_zero);
3814   TEST_c_c (ctanh, minus_infty, -1, -1.0, minus_zero);
3815
3816   TEST_c_c (ctanh, 0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3817   TEST_c_c (ctanh, 2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3818   TEST_c_c (ctanh, 0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3819   TEST_c_c (ctanh, 2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3820   TEST_c_c (ctanh, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3821   TEST_c_c (ctanh, -2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3822   TEST_c_c (ctanh, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3823   TEST_c_c (ctanh, -2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3824
3825   TEST_c_c (ctanh, plus_infty, nan_value, 1.0, 0.0, IGNORE_ZERO_INF_SIGN);
3826   TEST_c_c (ctanh, minus_infty, nan_value, -1.0, 0.0, IGNORE_ZERO_INF_SIGN);
3827
3828   TEST_c_c (ctanh, nan_value, 0, nan_value, 0.0);
3829   TEST_c_c (ctanh, nan_value, minus_zero, nan_value, minus_zero);
3830
3831   TEST_c_c (ctanh, nan_value, 0.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
3832   TEST_c_c (ctanh, nan_value, -4.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
3833
3834   TEST_c_c (ctanh, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3835   TEST_c_c (ctanh, 5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3836   TEST_c_c (ctanh, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3837   TEST_c_c (ctanh, -0.25, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3838
3839   TEST_c_c (ctanh, nan_value, nan_value, nan_value, nan_value);
3840
3841   TEST_c_c (ctanh, 0, M_PI_4l, 0.0, 1.0);
3842
3843   TEST_c_c (ctanh, 0.75L, 1.25L, 1.37260757053378320258048606571226857L, 0.385795952609750664177596760720790220L);
3844   TEST_c_c (ctanh, -2, -3, -0.965385879022133124278480269394560686L, 0.988437503832249372031403430350121098e-2L);
3845
3846   TEST_c_c (ctanh, 45, 1, 1.000000000000000000000000000000000000001L, 1.490158918874345552942703234806348520895e-39L, UNDERFLOW_EXCEPTION_FLOAT);
3847   TEST_c_c (ctanh, 47, 1, 1.0, 2.729321264492904590777293425576722354636e-41L, UNDERFLOW_EXCEPTION_FLOAT);
3848
3849 #ifndef TEST_FLOAT
3850   TEST_c_c (ctanh, 355, 1, 1.0, 8.140551093483276762350406321792653551513e-309L, UNDERFLOW_EXCEPTION_DOUBLE);
3851   TEST_c_c (ctanh, 365, 1, 1.0, 1.677892637497921890115075995898773550884e-317L, UNDERFLOW_EXCEPTION_DOUBLE);
3852 #endif
3853
3854 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3855   TEST_c_c (ctanh, 5680, 1, 1.0, 4.725214596136812019616700920476949798307e-4934L, UNDERFLOW_EXCEPTION);
3856   TEST_c_c (ctanh, 5690, 1, 1.0, 9.739393181626937151720816611272607059057e-4943L, UNDERFLOW_EXCEPTION);
3857 #endif
3858
3859   TEST_c_c (ctanh, 0, 0x3.243f6cp-1, 0.0, -2.287733242885645987394874673945769518150e7L);
3860
3861   TEST_c_c (ctanh, 1, 0x1p127, 0.9101334047676183761532873794426475906201L, 0.2446359391192790896381501310437708987204L);
3862
3863 #ifndef TEST_FLOAT
3864   TEST_c_c (ctanh, 1, 0x1p1023, 0.8786063118883068695462540226219865087189L, -0.2254627924997545057926782581695274244229L);
3865 #endif
3866
3867 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3868   TEST_c_c (ctanh, 1, 0x1p16383L, 0.8133818522051542536316746743877629761488L, 0.1608598776370396607204448234354670036772L);
3869 #endif
3870
3871   TEST_c_c (ctanh, 50000, 50000, 1.0, plus_zero, UNDERFLOW_EXCEPTION);
3872   TEST_c_c (ctanh, 50000, -50000, 1.0, minus_zero, UNDERFLOW_EXCEPTION);
3873   TEST_c_c (ctanh, -50000, 50000, -1.0, plus_zero, UNDERFLOW_EXCEPTION);
3874   TEST_c_c (ctanh, -50000, -50000, -1.0, minus_zero, UNDERFLOW_EXCEPTION);
3875
3876   END (ctanh, complex);
3877 }
3878
3879
3880 static void
3881 ctanh_test_tonearest (void)
3882 {
3883   int save_round_mode;
3884   errno = 0;
3885   FUNC(ctanh) (BUILD_COMPLEX (0.7L, 1.2L));
3886   if (errno == ENOSYS)
3887     /* Function not implemented.  */
3888     return;
3889
3890   START (ctanh_tonearest);
3891
3892   save_round_mode = fegetround ();
3893
3894   if (!fesetround (FE_TONEAREST))
3895     {
3896       TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L);
3897
3898 #ifndef TEST_FLOAT
3899       TEST_c_c (ctanh, 0x1p-1074, 0x1.921fb54442d18p+0, 1.317719414943508315995636961402669067843e-291L, 1.633123935319536975596773704152891653086e16L);
3900 #endif
3901
3902 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3903       TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L);
3904 #endif
3905     }
3906
3907   fesetround (save_round_mode);
3908
3909   END (ctanh_tonearest, complex);
3910 }
3911
3912
3913 static void
3914 ctanh_test_towardzero (void)
3915 {
3916   int save_round_mode;
3917   errno = 0;
3918   FUNC(ctanh) (BUILD_COMPLEX (0.7L, 1.2L));
3919   if (errno == ENOSYS)
3920     /* Function not implemented.  */
3921     return;
3922
3923   START (ctanh_towardzero);
3924
3925   save_round_mode = fegetround ();
3926
3927   if (!fesetround (FE_TOWARDZERO))
3928     {
3929       TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L);
3930
3931 #ifndef TEST_FLOAT
3932       TEST_c_c (ctanh, 0x1p-1074, 0x1.921fb54442d18p+0, 1.317719414943508315995636961402669067843e-291L, 1.633123935319536975596773704152891653086e16L);
3933 #endif
3934
3935 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3936       TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L);
3937 #endif
3938     }
3939
3940   fesetround (save_round_mode);
3941
3942   END (ctanh_towardzero, complex);
3943 }
3944
3945
3946 static void
3947 ctanh_test_downward (void)
3948 {
3949   int save_round_mode;
3950   errno = 0;
3951   FUNC(ctanh) (BUILD_COMPLEX (0.7L, 1.2L));
3952   if (errno == ENOSYS)
3953     /* Function not implemented.  */
3954     return;
3955
3956   START (ctanh_downward);
3957
3958   save_round_mode = fegetround ();
3959
3960   if (!fesetround (FE_DOWNWARD))
3961     {
3962       TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L);
3963
3964 #ifndef TEST_FLOAT
3965       TEST_c_c (ctanh, 0x1p-1074, 0x1.921fb54442d18p+0, 1.317719414943508315995636961402669067843e-291L, 1.633123935319536975596773704152891653086e16L);
3966 #endif
3967
3968 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3969       TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L);
3970 #endif
3971     }
3972
3973   fesetround (save_round_mode);
3974
3975   END (ctanh_downward, complex);
3976 }
3977
3978
3979 static void
3980 ctanh_test_upward (void)
3981 {
3982   int save_round_mode;
3983   errno = 0;
3984   FUNC(ctanh) (BUILD_COMPLEX (0.7L, 1.2L));
3985   if (errno == ENOSYS)
3986     /* Function not implemented.  */
3987     return;
3988
3989   START (ctanh_upward);
3990
3991   save_round_mode = fegetround ();
3992
3993   if (!fesetround (FE_UPWARD))
3994     {
3995       TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L);
3996
3997 #ifndef TEST_FLOAT
3998       TEST_c_c (ctanh, 0x1p-1074, 0x1.921fb54442d18p+0, 1.317719414943508315995636961402669067843e-291L, 1.633123935319536975596773704152891653086e16L);
3999 #endif
4000
4001 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
4002       TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L);
4003 #endif
4004     }
4005
4006   fesetround (save_round_mode);
4007
4008   END (ctanh_upward, complex);
4009 }
4010
4011
4012 static void
4013 erf_test (void)
4014 {
4015   errno = 0;
4016   FUNC(erf) (0);
4017   if (errno == ENOSYS)
4018     /* Function not implemented.  */
4019     return;
4020
4021   START (erf);
4022
4023   TEST_f_f (erf, 0, 0);
4024   TEST_f_f (erf, minus_zero, minus_zero);
4025   TEST_f_f (erf, plus_infty, 1);
4026   TEST_f_f (erf, minus_infty, -1);
4027   TEST_f_f (erf, nan_value, nan_value);
4028
4029   TEST_f_f (erf, 0.125L, 0.140316204801333817393029446521623398L);
4030   TEST_f_f (erf, 0.75L, 0.711155633653515131598937834591410777L);
4031   TEST_f_f (erf, 1.25L, 0.922900128256458230136523481197281140L);
4032   TEST_f_f (erf, 2.0L, 0.995322265018952734162069256367252929L);
4033   TEST_f_f (erf, 4.125L, 0.999999994576599200434933994687765914L);
4034   TEST_f_f (erf, 27.0L, 1.0L);
4035
4036   END (erf);
4037 }
4038
4039
4040 static void
4041 erfc_test (void)
4042 {
4043   errno = 0;
4044   FUNC(erfc) (0);
4045   if (errno == ENOSYS)
4046     /* Function not implemented.  */
4047     return;
4048
4049   START (erfc);
4050
4051   TEST_f_f (erfc, plus_infty, 0.0);
4052   TEST_f_f (erfc, minus_infty, 2.0);
4053   TEST_f_f (erfc, 0.0, 1.0);
4054   TEST_f_f (erfc, minus_zero, 1.0);
4055   TEST_f_f (erfc, nan_value, nan_value);
4056
4057   TEST_f_f (erfc, 0.125L, 0.859683795198666182606970553478376602L);
4058   TEST_f_f (erfc, 0.75L, 0.288844366346484868401062165408589223L);
4059   TEST_f_f (erfc, 1.25L, 0.0770998717435417698634765188027188596L);
4060   TEST_f_f (erfc, 2.0L, 0.00467773498104726583793074363274707139L);
4061   TEST_f_f (erfc, 0x1.f7303cp+1L, 2.705500297238986897105236321218861842255e-8L);
4062   TEST_f_f (erfc, 4.125L, 0.542340079956506600531223408575531062e-8L);
4063   TEST_f_f (erfc, 0x1.ffa002p+2L, 1.233585992097580296336099501489175967033e-29L);
4064   TEST_f_f (erfc, 0x1.ffffc8p+2L, 1.122671365033056305522366683719541099329e-29L);
4065 #ifdef TEST_LDOUBLE
4066   /* The result can only be represented in long double.  */
4067 # if LDBL_MIN_10_EXP < -319
4068   TEST_f_f (erfc, 27.0L, 0.523704892378925568501606768284954709e-318L);
4069 # endif
4070 # if LDBL_MANT_DIG >= 106
4071   TEST_f_f (erfc, 0x1.ffff56789abcdef0123456789a8p+2L, 1.123161416304655390092138725253789378459e-29L);
4072 # endif
4073 #endif
4074
4075   END (erfc);
4076 }
4077
4078
4079 static void
4080 exp_test (void)
4081 {
4082   errno = 0;
4083   FUNC(exp) (0);
4084   if (errno == ENOSYS)
4085     /* Function not implemented.  */
4086     return;
4087
4088   START (exp);
4089
4090   TEST_f_f (exp, 0, 1);
4091   TEST_f_f (exp, minus_zero, 1);
4092
4093 #ifndef TEST_INLINE
4094   TEST_f_f (exp, plus_infty, plus_infty);
4095   TEST_f_f (exp, minus_infty, 0);
4096 #endif
4097   TEST_f_f (exp, nan_value, nan_value);
4098   TEST_f_f (exp, 1, M_El);
4099
4100   TEST_f_f (exp, 2, M_E2l);
4101   TEST_f_f (exp, 3, M_E3l);
4102   TEST_f_f (exp, 0.75L, 2.11700001661267466854536981983709561L);
4103   TEST_f_f (exp, 50.0L, 5184705528587072464087.45332293348538L);
4104   TEST_f_f (exp, 88.72269439697265625L, 3.40233126623160774937554134772290447915e38L);
4105 #if defined TEST_LDOUBLE && __LDBL_MAX_EXP__ > 1024
4106   /* The result can only be represented in sane long double.  */
4107   TEST_f_f (exp, 1000.0L, 0.197007111401704699388887935224332313e435L);
4108 #endif
4109
4110 #if !(defined TEST_LDOUBLE && LDBL_MAX_EXP > 1024)
4111   TEST_f_f (exp, 710, plus_infty, OVERFLOW_EXCEPTION);
4112   TEST_f_f (exp, -1234, plus_zero, UNDERFLOW_EXCEPTION);
4113 #endif
4114   TEST_f_f (exp, 1e5, plus_infty, OVERFLOW_EXCEPTION);
4115   TEST_f_f (exp, max_value, plus_infty, OVERFLOW_EXCEPTION);
4116   TEST_f_f (exp, -max_value, 0, UNDERFLOW_EXCEPTION);
4117
4118   END (exp);
4119 }
4120
4121
4122 static void
4123 exp_test_tonearest (void)
4124 {
4125   int save_round_mode;
4126   errno = 0;
4127   FUNC(exp) (0);
4128   if (errno == ENOSYS)
4129     /* Function not implemented.  */
4130     return;
4131
4132   START (exp_tonearest);
4133
4134   save_round_mode = fegetround ();
4135
4136   if (!fesetround (FE_TONEAREST))
4137     {
4138       TEST_f_f (exp, 1, M_El);
4139       TEST_f_f (exp, 2, M_E2l);
4140       TEST_f_f (exp, 3, M_E3l);
4141     }
4142
4143   fesetround (save_round_mode);
4144
4145   END (exp_tonearest);
4146 }
4147
4148
4149 static void
4150 exp_test_towardzero (void)
4151 {
4152   int save_round_mode;
4153   errno = 0;
4154   FUNC(exp) (0);
4155   if (errno == ENOSYS)
4156     /* Function not implemented.  */
4157     return;
4158
4159   START (exp_towardzero);
4160
4161   save_round_mode = fegetround ();
4162
4163   if (!fesetround (FE_TOWARDZERO))
4164     {
4165       TEST_f_f (exp, 1, M_El);
4166       TEST_f_f (exp, 2, M_E2l);
4167       TEST_f_f (exp, 3, M_E3l);
4168     }
4169
4170   fesetround (save_round_mode);
4171
4172   END (exp_towardzero);
4173 }
4174
4175
4176 static void
4177 exp_test_downward (void)
4178 {
4179   int save_round_mode;
4180   errno = 0;
4181   FUNC(exp) (0);
4182   if (errno == ENOSYS)
4183     /* Function not implemented.  */
4184     return;
4185
4186   START (exp_downward);
4187
4188   save_round_mode = fegetround ();
4189
4190   if (!fesetround (FE_DOWNWARD))
4191     {
4192       TEST_f_f (exp, 1, M_El);
4193       TEST_f_f (exp, 2, M_E2l);
4194       TEST_f_f (exp, 3, M_E3l);
4195     }
4196
4197   fesetround (save_round_mode);
4198
4199   END (exp_downward);
4200 }
4201
4202
4203 static void
4204 exp_test_upward (void)
4205 {
4206   int save_round_mode;
4207   errno = 0;
4208   FUNC(exp) (0);
4209   if (errno == ENOSYS)
4210     /* Function not implemented.  */
4211     return;
4212
4213   START (exp_upward);
4214
4215   save_round_mode = fegetround ();
4216
4217   if (!fesetround (FE_UPWARD))
4218     {
4219       TEST_f_f (exp, 1, M_El);
4220       TEST_f_f (exp, 2, M_E2l);
4221       TEST_f_f (exp, 3, M_E3l);
4222     }
4223
4224   fesetround (save_round_mode);
4225
4226   END (exp_upward);
4227 }
4228
4229
4230 static void
4231 exp10_test (void)
4232 {
4233   errno = 0;
4234   FUNC(exp10) (0);
4235   if (errno == ENOSYS)
4236     /* Function not implemented.  */
4237     return;
4238
4239   START (exp10);
4240
4241   TEST_f_f (exp10, 0, 1);
4242   TEST_f_f (exp10, minus_zero, 1);
4243
4244   TEST_f_f (exp10, plus_infty, plus_infty);
4245   TEST_f_f (exp10, minus_infty, 0);
4246   TEST_f_f (exp10, nan_value, nan_value);
4247   TEST_f_f (exp10, 3, 1000);
4248   TEST_f_f (exp10, -1, 0.1L);
4249   TEST_f_f (exp10, 36, 1.0e36L);
4250   TEST_f_f (exp10, -36, 1.0e-36L);
4251 #ifndef TEST_FLOAT
4252   TEST_f_f (exp10, 305, 1.0e305L);
4253   TEST_f_f (exp10, -305, 1.0e-305L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
4254 #endif
4255 #if defined TEST_LDOUBLE && LDBL_MAX_10_EXP >= 4932
4256   TEST_f_f (exp10, 4932, 1.0e4932L);
4257   TEST_f_f (exp10, -4932, 1.0e-4932L, UNDERFLOW_EXCEPTION);
4258 #endif
4259   TEST_f_f (exp10, 1e6, plus_infty, OVERFLOW_EXCEPTION);
4260   TEST_f_f (exp10, -1e6, 0, UNDERFLOW_EXCEPTION);
4261   TEST_f_f (exp10, max_value, plus_infty, OVERFLOW_EXCEPTION);
4262   TEST_f_f (exp10, -max_value, 0, UNDERFLOW_EXCEPTION);
4263   TEST_f_f (exp10, 0.75L, 5.62341325190349080394951039776481231L);
4264
4265   END (exp10);
4266 }
4267
4268
4269 static void
4270 exp2_test (void)
4271 {
4272   errno = 0;
4273   FUNC(exp2) (0);
4274   if (errno == ENOSYS)
4275     /* Function not implemented.  */
4276     return;
4277
4278   START (exp2);
4279
4280   TEST_f_f (exp2, 0, 1);
4281   TEST_f_f (exp2, minus_zero, 1);
4282   TEST_f_f (exp2, plus_infty, plus_infty);
4283   TEST_f_f (exp2, minus_infty, 0);
4284   TEST_f_f (exp2, nan_value, nan_value);
4285
4286   TEST_f_f (exp2, 10, 1024);
4287   TEST_f_f (exp2, -1, 0.5);
4288   TEST_f_f (exp2, 1e6, plus_infty, OVERFLOW_EXCEPTION);
4289   TEST_f_f (exp2, -1e6, 0, UNDERFLOW_EXCEPTION);
4290   TEST_f_f (exp2, max_value, plus_infty, OVERFLOW_EXCEPTION);
4291   TEST_f_f (exp2, -max_value, 0, UNDERFLOW_EXCEPTION);
4292   TEST_f_f (exp2, 0.75L, 1.68179283050742908606225095246642979L);
4293
4294   TEST_f_f (exp2, 100.5, 1.792728671193156477399422023278661496394e+30L);
4295   TEST_f_f (exp2, 127, 0x1p127);
4296   TEST_f_f (exp2, -149, 0x1p-149);
4297
4298 #ifndef TEST_FLOAT
4299   TEST_f_f (exp2, 1000.25, 1.274245659452564874772384918171765416737e+301L);
4300   TEST_f_f (exp2, 1023, 0x1p1023);
4301   TEST_f_f (exp2, -1074, 0x1p-1074);
4302 #endif
4303
4304 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
4305   TEST_f_f (exp2, 16383, 0x1p16383L);
4306   TEST_f_f (exp2, -16400, 0x1p-16400L);
4307 #endif
4308
4309   END (exp2);
4310 }
4311
4312
4313 static void
4314 expm1_test (void)
4315 {
4316   errno = 0;
4317   FUNC(expm1) (0);
4318   if (errno == ENOSYS)
4319     /* Function not implemented.  */
4320     return;
4321
4322   START (expm1);
4323
4324   TEST_f_f (expm1, 0, 0);
4325   TEST_f_f (expm1, minus_zero, minus_zero);
4326
4327 #ifndef TEST_INLINE
4328   TEST_f_f (expm1, plus_infty, plus_infty);
4329   TEST_f_f (expm1, minus_infty, -1);
4330 #endif
4331   TEST_f_f (expm1, nan_value, nan_value);
4332
4333   TEST_f_f (expm1, 1, M_El - 1.0);
4334   TEST_f_f (expm1, 0.75L, 1.11700001661267466854536981983709561L);
4335
4336   TEST_f_f (expm1, 50.0L, 5.1847055285870724640864533229334853848275e+21L);
4337
4338 #ifndef TEST_FLOAT
4339   TEST_f_f (expm1, 127.0L, 1.4302079958348104463583671072905261080748e+55L);
4340   TEST_f_f (expm1, 500.0L, 1.4035922178528374107397703328409120821806e+217L);
4341 #endif
4342
4343 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
4344   TEST_f_f (expm1, 11356.25L, 9.05128237311923300051376115753226014206e+4931L);
4345 #endif
4346
4347   TEST_f_f (expm1, -10.0, -0.9999546000702375151484644084844394493898L);
4348   TEST_f_f (expm1, -16.0, -0.9999998874648252807408854862248209398728L);
4349   TEST_f_f (expm1, -17.0, -0.9999999586006228121483334034897228104472L);
4350   TEST_f_f (expm1, -18.0, -0.9999999847700202552873715638633707664826L);
4351   TEST_f_f (expm1, -36.0, -0.9999999999999997680477169756430611687736L);
4352   TEST_f_f (expm1, -37.0, -0.9999999999999999146695237425593420572195L);
4353   TEST_f_f (expm1, -38.0, -0.9999999999999999686086720795197037129104L);
4354   TEST_f_f (expm1, -44.0, -0.9999999999999999999221886775886620348429L);
4355   TEST_f_f (expm1, -45.0, -0.9999999999999999999713748141945060635553L);
4356   TEST_f_f (expm1, -46.0, -0.9999999999999999999894693826424461876212L);
4357   TEST_f_f (expm1, -73.0, -0.9999999999999999999999999999999802074012L);
4358   TEST_f_f (expm1, -74.0, -0.9999999999999999999999999999999927187098L);
4359   TEST_f_f (expm1, -75.0, -0.9999999999999999999999999999999973213630L);
4360   TEST_f_f (expm1, -78.0, -0.9999999999999999999999999999999998666385L);
4361   TEST_f_f (expm1, -79.0, -0.9999999999999999999999999999999999509391L);
4362   TEST_f_f (expm1, -80.0, -0.9999999999999999999999999999999999819515L);
4363   TEST_f_f (expm1, -100.0, -1.0);
4364   TEST_f_f (expm1, -1000.0, -1.0);
4365   TEST_f_f (expm1, -10000.0, -1.0);
4366   TEST_f_f (expm1, -100000.0, -1.0);
4367
4368   errno = 0;
4369   TEST_f_f (expm1, 100000.0, plus_infty, OVERFLOW_EXCEPTION);
4370   check_int ("errno for expm1(large) == ERANGE", errno, ERANGE, 0, 0, 0);
4371   TEST_f_f (expm1, max_value, plus_infty, OVERFLOW_EXCEPTION);
4372   TEST_f_f (expm1, -max_value, -1);
4373
4374   END (expm1);
4375 }
4376
4377
4378 static void
4379 fabs_test (void)
4380 {
4381   START (fabs);
4382
4383   TEST_f_f (fabs, 0, 0);
4384   TEST_f_f (fabs, minus_zero, 0);
4385
4386   TEST_f_f (fabs, plus_infty, plus_infty);
4387   TEST_f_f (fabs, minus_infty, plus_infty);
4388   TEST_f_f (fabs, nan_value, nan_value);
4389
4390   TEST_f_f (fabs, 38.0, 38.0);
4391   TEST_f_f (fabs, -M_El, M_El);
4392
4393   END (fabs);
4394 }
4395
4396
4397 static void
4398 fdim_test (void)
4399 {
4400   START (fdim);
4401
4402   TEST_ff_f (fdim, 0, 0, 0);
4403   TEST_ff_f (fdim, 9, 0, 9);
4404   TEST_ff_f (fdim, 0, 9, 0);
4405   TEST_ff_f (fdim, -9, 0, 0);
4406   TEST_ff_f (fdim, 0, -9, 9);
4407
4408   TEST_ff_f (fdim, plus_infty, 9, plus_infty);
4409   TEST_ff_f (fdim, plus_infty, -9, plus_infty);
4410   TEST_ff_f (fdim, minus_infty, 9, 0);
4411   TEST_ff_f (fdim, minus_infty, -9, 0);
4412   TEST_ff_f (fdim, 9, minus_infty, plus_infty);
4413   TEST_ff_f (fdim, -9, minus_infty, plus_infty);
4414   TEST_ff_f (fdim, 9, plus_infty, 0);
4415   TEST_ff_f (fdim, -9, plus_infty, 0);
4416
4417   TEST_ff_f (fdim, 0, nan_value, nan_value);
4418   TEST_ff_f (fdim, 9, nan_value, nan_value);
4419   TEST_ff_f (fdim, -9, nan_value, nan_value);
4420   TEST_ff_f (fdim, nan_value, 9, nan_value);
4421   TEST_ff_f (fdim, nan_value, -9, nan_value);
4422   TEST_ff_f (fdim, plus_infty, nan_value, nan_value);
4423   TEST_ff_f (fdim, minus_infty, nan_value, nan_value);
4424   TEST_ff_f (fdim, nan_value, plus_infty, nan_value);
4425   TEST_ff_f (fdim, nan_value, minus_infty, nan_value);
4426   TEST_ff_f (fdim, nan_value, nan_value, nan_value);
4427
4428   TEST_ff_f (fdim, plus_infty, plus_infty, 0);
4429
4430   END (fdim);
4431 }
4432
4433
4434 static void
4435 finite_test (void)
4436 {
4437   START (finite);
4438
4439   TEST_f_b (finite, 0, 1);
4440   TEST_f_b (finite, minus_zero, 1);
4441   TEST_f_b (finite, 10, 1);
4442   TEST_f_b (finite, min_subnorm_value, 1);
4443   TEST_f_b (finite, plus_infty, 0);
4444   TEST_f_b (finite, minus_infty, 0);
4445   TEST_f_b (finite, nan_value, 0);
4446
4447   END (finite);
4448 }
4449
4450
4451 static void
4452 floor_test (void)
4453 {
4454   START (floor);
4455
4456   TEST_f_f (floor, 0.0, 0.0);
4457   TEST_f_f (floor, minus_zero, minus_zero);
4458   TEST_f_f (floor, plus_infty, plus_infty);
4459   TEST_f_f (floor, minus_infty, minus_infty);
4460   TEST_f_f (floor, nan_value, nan_value);
4461
4462   TEST_f_f (floor, M_PIl, 3.0);
4463   TEST_f_f (floor, -M_PIl, -4.0);
4464
4465   TEST_f_f (floor, 0.1, 0.0);
4466   TEST_f_f (floor, 0.25, 0.0);
4467   TEST_f_f (floor, 0.625, 0.0);
4468   TEST_f_f (floor, -0.1, -1.0);
4469   TEST_f_f (floor, -0.25, -1.0);
4470   TEST_f_f (floor, -0.625, -1.0);
4471
4472 #ifdef TEST_LDOUBLE
4473   /* The result can only be represented in long double.  */
4474   TEST_f_f (floor, 4503599627370495.5L, 4503599627370495.0L);
4475   TEST_f_f (floor, 4503599627370496.25L, 4503599627370496.0L);
4476   TEST_f_f (floor, 4503599627370496.5L, 4503599627370496.0L);
4477   TEST_f_f (floor, 4503599627370496.75L, 4503599627370496.0L);
4478   TEST_f_f (floor, 4503599627370497.5L, 4503599627370497.0L);
4479 # if LDBL_MANT_DIG > 100
4480   TEST_f_f (floor, 4503599627370494.5000000000001L, 4503599627370494.0L);
4481   TEST_f_f (floor, 4503599627370495.5000000000001L, 4503599627370495.0L);
4482   TEST_f_f (floor, 4503599627370496.5000000000001L, 4503599627370496.0L);
4483 # endif
4484
4485   TEST_f_f (floor, -4503599627370495.5L, -4503599627370496.0L);
4486   TEST_f_f (floor, -4503599627370496.25L, -4503599627370497.0L);
4487   TEST_f_f (floor, -4503599627370496.5L, -4503599627370497.0L);
4488   TEST_f_f (floor, -4503599627370496.75L, -4503599627370497.0L);
4489   TEST_f_f (floor, -4503599627370497.5L, -4503599627370498.0L);
4490 # if LDBL_MANT_DIG > 100
4491   TEST_f_f (floor, -4503599627370494.5000000000001L, -4503599627370495.0L);
4492   TEST_f_f (floor, -4503599627370495.5000000000001L, -4503599627370496.0L);
4493   TEST_f_f (floor, -4503599627370496.5000000000001L, -4503599627370497.0L);
4494 # endif
4495
4496   TEST_f_f (floor, 9007199254740991.5L, 9007199254740991.0L);
4497   TEST_f_f (floor, 9007199254740992.25L, 9007199254740992.0L);
4498   TEST_f_f (floor, 9007199254740992.5L, 9007199254740992.0L);
4499   TEST_f_f (floor, 9007199254740992.75L, 9007199254740992.0L);
4500   TEST_f_f (floor, 9007199254740993.5L, 9007199254740993.0L);
4501
4502 # if LDBL_MANT_DIG > 100
4503   TEST_f_f (floor, 9007199254740991.0000000000001L, 9007199254740991.0L);
4504   TEST_f_f (floor, 9007199254740992.0000000000001L, 9007199254740992.0L);
4505   TEST_f_f (floor, 9007199254740993.0000000000001L, 9007199254740993.0L);
4506   TEST_f_f (floor, 9007199254740991.5000000000001L, 9007199254740991.0L);
4507   TEST_f_f (floor, 9007199254740992.5000000000001L, 9007199254740992.0L);
4508   TEST_f_f (floor, 9007199254740993.5000000000001L, 9007199254740993.0L);
4509 # endif
4510
4511   TEST_f_f (floor, -9007199254740991.5L, -9007199254740992.0L);
4512   TEST_f_f (floor, -9007199254740992.25L, -9007199254740993.0L);
4513   TEST_f_f (floor, -9007199254740992.5L, -9007199254740993.0L);
4514   TEST_f_f (floor, -9007199254740992.75L, -9007199254740993.0L);
4515   TEST_f_f (floor, -9007199254740993.5L, -9007199254740994.0L);
4516
4517 # if LDBL_MANT_DIG > 100
4518   TEST_f_f (floor, -9007199254740991.0000000000001L, -9007199254740992.0L);
4519   TEST_f_f (floor, -9007199254740992.0000000000001L, -9007199254740993.0L);
4520   TEST_f_f (floor, -9007199254740993.0000000000001L, -9007199254740994.0L);
4521   TEST_f_f (floor, -9007199254740991.5000000000001L, -9007199254740992.0L);
4522   TEST_f_f (floor, -9007199254740992.5000000000001L, -9007199254740993.0L);
4523   TEST_f_f (floor, -9007199254740993.5000000000001L, -9007199254740994.0L);
4524 # endif
4525
4526   TEST_f_f (floor, 72057594037927935.5L, 72057594037927935.0L);
4527   TEST_f_f (floor, 72057594037927936.25L, 72057594037927936.0L);
4528   TEST_f_f (floor, 72057594037927936.5L, 72057594037927936.0L);
4529   TEST_f_f (floor, 72057594037927936.75L, 72057594037927936.0L);
4530   TEST_f_f (floor, 72057594037927937.5L, 72057594037927937.0L);
4531
4532   TEST_f_f (floor, -72057594037927935.5L, -72057594037927936.0L);
4533   TEST_f_f (floor, -72057594037927936.25L, -72057594037927937.0L);
4534   TEST_f_f (floor, -72057594037927936.5L, -72057594037927937.0L);
4535   TEST_f_f (floor, -72057594037927936.75L, -72057594037927937.0L);
4536   TEST_f_f (floor, -72057594037927937.5L, -72057594037927938.0L);
4537
4538   TEST_f_f (floor, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
4539   TEST_f_f (floor, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
4540   TEST_f_f (floor, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
4541   TEST_f_f (floor, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
4542   TEST_f_f (floor, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
4543
4544   TEST_f_f (floor, 0xf.ffffffffffffff8p+47L, 0xf.fffffffffffep+47L);
4545   TEST_f_f (floor, -0x8.000000000000004p+48L, -0x8.000000000001p+48L);
4546 #endif
4547
4548   END (floor);
4549 }
4550
4551
4552 static void
4553 fma_test (void)
4554 {
4555   START (fma);
4556
4557   TEST_fff_f (fma, 1.0, 2.0, 3.0, 5.0);
4558   TEST_fff_f (fma, nan_value, 2.0, 3.0, nan_value);
4559   TEST_fff_f (fma, 1.0, nan_value, 3.0, nan_value);
4560   TEST_fff_f (fma, 1.0, 2.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
4561   TEST_fff_f (fma, plus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
4562   TEST_fff_f (fma, minus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
4563   TEST_fff_f (fma, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
4564   TEST_fff_f (fma, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
4565   TEST_fff_f (fma, plus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
4566   TEST_fff_f (fma, minus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
4567   TEST_fff_f (fma, 0.0, plus_infty, 1.0, nan_value, INVALID_EXCEPTION);
4568   TEST_fff_f (fma, 0.0, minus_infty, 1.0, nan_value, INVALID_EXCEPTION);
4569
4570   TEST_fff_f (fma, plus_infty, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
4571   TEST_fff_f (fma, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
4572   TEST_fff_f (fma, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
4573   TEST_fff_f (fma, minus_infty, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
4574   TEST_fff_f (fma, plus_infty, 3.5L, minus_infty, nan_value, INVALID_EXCEPTION);
4575   TEST_fff_f (fma, minus_infty, -7.5L, minus_infty, nan_value, INVALID_EXCEPTION);
4576   TEST_fff_f (fma, -13.5L, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
4577   TEST_fff_f (fma, minus_infty, 7.5L, plus_infty, nan_value, INVALID_EXCEPTION);
4578
4579   TEST_fff_f (fma, 1.25L, 0.75L, 0.0625L, 1.0L);
4580
4581   FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
4582                          LDBL_MAX, DBL_MAX, FLT_MAX);
4583   TEST_fff_f (fma, -fltmax, -fltmax, minus_infty, minus_infty);
4584   TEST_fff_f (fma, fltmax / 2, fltmax / 2, minus_infty, minus_infty);
4585   TEST_fff_f (fma, -fltmax, fltmax, plus_infty, plus_infty);
4586   TEST_fff_f (fma, fltmax / 2, -fltmax / 4, plus_infty, plus_infty);
4587   TEST_fff_f (fma, plus_infty, 4, plus_infty, plus_infty);
4588   TEST_fff_f (fma, 2, minus_infty, minus_infty, minus_infty);
4589   TEST_fff_f (fma, minus_infty, minus_infty, plus_infty, plus_infty);
4590   TEST_fff_f (fma, plus_infty, minus_infty, minus_infty, minus_infty);
4591
4592   TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero);
4593   TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, plus_zero);
4594   TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, plus_zero);
4595   TEST_fff_f (fma, plus_zero, minus_zero, minus_zero, minus_zero);
4596   TEST_fff_f (fma, minus_zero, plus_zero, plus_zero, plus_zero);
4597   TEST_fff_f (fma, minus_zero, plus_zero, minus_zero, minus_zero);
4598   TEST_fff_f (fma, minus_zero, minus_zero, plus_zero, plus_zero);
4599   TEST_fff_f (fma, minus_zero, minus_zero, minus_zero, plus_zero);
4600   TEST_fff_f (fma, 1.0, plus_zero, plus_zero, plus_zero);
4601   TEST_fff_f (fma, 1.0, plus_zero, minus_zero, plus_zero);
4602   TEST_fff_f (fma, 1.0, minus_zero, plus_zero, plus_zero);
4603   TEST_fff_f (fma, 1.0, minus_zero, minus_zero, minus_zero);
4604   TEST_fff_f (fma, -1.0, plus_zero, plus_zero, plus_zero);
4605   TEST_fff_f (fma, -1.0, plus_zero, minus_zero, minus_zero);
4606   TEST_fff_f (fma, -1.0, minus_zero, plus_zero, plus_zero);
4607   TEST_fff_f (fma, -1.0, minus_zero, minus_zero, plus_zero);
4608   TEST_fff_f (fma, plus_zero, 1.0, plus_zero, plus_zero);
4609   TEST_fff_f (fma, plus_zero, 1.0, minus_zero, plus_zero);
4610   TEST_fff_f (fma, plus_zero, -1.0, plus_zero, plus_zero);
4611   TEST_fff_f (fma, plus_zero, -1.0, minus_zero, minus_zero);
4612   TEST_fff_f (fma, minus_zero, 1.0, plus_zero, plus_zero);
4613   TEST_fff_f (fma, minus_zero, 1.0, minus_zero, minus_zero);
4614   TEST_fff_f (fma, minus_zero, -1.0, plus_zero, plus_zero);
4615   TEST_fff_f (fma, minus_zero, -1.0, minus_zero, plus_zero);
4616
4617   TEST_fff_f (fma, 1.0, 1.0, -1.0, plus_zero);
4618   TEST_fff_f (fma, 1.0, -1.0, 1.0, plus_zero);
4619   TEST_fff_f (fma, -1.0, 1.0, 1.0, plus_zero);
4620   TEST_fff_f (fma, -1.0, -1.0, -1.0, plus_zero);
4621
4622   TEST_fff_f (fma, min_value, min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4623   TEST_fff_f (fma, min_value, min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4624   TEST_fff_f (fma, min_value, -min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4625   TEST_fff_f (fma, min_value, -min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4626   TEST_fff_f (fma, -min_value, min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4627   TEST_fff_f (fma, -min_value, min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4628   TEST_fff_f (fma, -min_value, -min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4629   TEST_fff_f (fma, -min_value, -min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4630
4631   TEST_fff_f (fma, max_value, max_value, min_value, plus_infty, OVERFLOW_EXCEPTION);
4632   TEST_fff_f (fma, max_value, max_value, -min_value, plus_infty, OVERFLOW_EXCEPTION);
4633   TEST_fff_f (fma, max_value, -max_value, min_value, minus_infty, OVERFLOW_EXCEPTION);
4634   TEST_fff_f (fma, max_value, -max_value, -min_value, minus_infty, OVERFLOW_EXCEPTION);
4635   TEST_fff_f (fma, -max_value, max_value, min_value, minus_infty, OVERFLOW_EXCEPTION);
4636   TEST_fff_f (fma, -max_value, max_value, -min_value, minus_infty, OVERFLOW_EXCEPTION);
4637   TEST_fff_f (fma, -max_value, -max_value, min_value, plus_infty, OVERFLOW_EXCEPTION);
4638   TEST_fff_f (fma, -max_value, -max_value, -min_value, plus_infty, OVERFLOW_EXCEPTION);
4639
4640 #if defined (TEST_FLOAT) && FLT_MANT_DIG == 24
4641   TEST_fff_f (fma, 0x1.7ff8p+13, 0x1.000002p+0, 0x1.ffffp-24, 0x1.7ff802p+13);
4642   TEST_fff_f (fma, 0x1.fffp+0, 0x1.00001p+0, -0x1.fffp+0, 0x1.fffp-20);
4643   TEST_fff_f (fma, 0x1.9abcdep+127, 0x0.9abcdep-126, -0x1.f08948p+0, 0x1.bb421p-25);
4644   TEST_fff_f (fma, 0x1.9abcdep+100, 0x0.9abcdep-126, -0x1.f08948p-27, 0x1.bb421p-52);
4645   TEST_fff_f (fma, 0x1.fffffep+127, 0x1.001p+0, -0x1.fffffep+127, 0x1.fffffep+115);
4646   TEST_fff_f (fma, -0x1.fffffep+127, 0x1.fffffep+0, 0x1.fffffep+127, -0x1.fffffap+127);
4647   TEST_fff_f (fma, 0x1.fffffep+127, 2.0, -0x1.fffffep+127, 0x1.fffffep+127);
4648   TEST_fff_f (fma, 0x1.4p-126, 0x1.000004p-1, 0x1p-128, 0x1.c00004p-127, UNDERFLOW_EXCEPTION);
4649   TEST_fff_f (fma, -0x1.4p-126, 0x1.000004p-1, -0x1p-128, -0x1.c00004p-127, UNDERFLOW_EXCEPTION);
4650   TEST_fff_f (fma, 0x1.fffff8p-126, 0x1.000002p-1, 0x1p-149, 0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4651   TEST_fff_f (fma, -0x1.fffff8p-126, 0x1.000002p-1, -0x1p-149, -0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4652   TEST_fff_f (fma, 0x1p-149, 0x1p-1, 0x0.fffffep-126, 0x1p-126, UNDERFLOW_EXCEPTION);
4653   TEST_fff_f (fma, -0x1p-149, 0x1p-1, -0x0.fffffep-126, -0x1p-126, UNDERFLOW_EXCEPTION);
4654   TEST_fff_f (fma, 0x1p-149, 0x1.1p-1, 0x0.fffffep-126, 0x1p-126, UNDERFLOW_EXCEPTION);
4655   TEST_fff_f (fma, -0x1p-149, 0x1.1p-1, -0x0.fffffep-126, -0x1p-126, UNDERFLOW_EXCEPTION);
4656   TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p127, 0x1p127);
4657   TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p127, 0x1p127);
4658   TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p127, -0x1p127);
4659   TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p127, -0x1p127);
4660   TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-126, 0x1p-126);
4661   TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-126, 0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4662   TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-126, -0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4663   TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-126, -0x1p-126);
4664   TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4665   TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4666   TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4667   TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4668   TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-149, 0x1p-149, UNDERFLOW_EXCEPTION);
4669   TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-149, 0x1p-149, UNDERFLOW_EXCEPTION);
4670   TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-149, -0x1p-149, UNDERFLOW_EXCEPTION);
4671   TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-149, -0x1p-149, UNDERFLOW_EXCEPTION);
4672   TEST_fff_f (fma, 0x0.fffp0, 0x0.fffp0, -0x0.ffep0, 0x1p-24);
4673   TEST_fff_f (fma, 0x0.fffp0, -0x0.fffp0, 0x0.ffep0, -0x1p-24);
4674   TEST_fff_f (fma, -0x0.fffp0, 0x0.fffp0, 0x0.ffep0, -0x1p-24);
4675   TEST_fff_f (fma, -0x0.fffp0, -0x0.fffp0, -0x0.ffep0, 0x1p-24);
4676   TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p127, 0x1p127);
4677   TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p127, 0x1p127);
4678   TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p127, -0x1p127);
4679   TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p127, -0x1p127);
4680   TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p103, 0x1p103);
4681   TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p103, 0x1p103);
4682   TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p103, -0x1p103);
4683   TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p103, -0x1p103);
4684 #endif
4685 #if defined (TEST_DOUBLE) && DBL_MANT_DIG == 53
4686   TEST_fff_f (fma, 0x1.7fp+13, 0x1.0000000000001p+0, 0x1.ffep-48, 0x1.7f00000000001p+13);
4687   TEST_fff_f (fma, 0x1.fffp+0, 0x1.0000000000001p+0, -0x1.fffp+0, 0x1.fffp-52);
4688   TEST_fff_f (fma, 0x1.0000002p+0, 0x1.ffffffcp-1, 0x1p-300, 1.0);
4689   TEST_fff_f (fma, 0x1.0000002p+0, 0x1.ffffffcp-1, -0x1p-300, 0x1.fffffffffffffp-1);
4690   TEST_fff_f (fma, 0x1.deadbeef2feedp+1023, 0x0.deadbeef2feedp-1022, -0x1.a05f8c01a4bfbp+1, 0x1.0989687bc9da4p-53);
4691   TEST_fff_f (fma, 0x1.deadbeef2feedp+900, 0x0.deadbeef2feedp-1022, -0x1.a05f8c01a4bfbp-122, 0x1.0989687bc9da4p-176);
4692   TEST_fff_f (fma, 0x1.fffffffffffffp+1023, 0x1.001p+0, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+1011);
4693   TEST_fff_f (fma, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+0, 0x1.fffffffffffffp+1023, -0x1.ffffffffffffdp+1023);
4694   TEST_fff_f (fma, 0x1.fffffffffffffp+1023, 2.0, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+1023);
4695   TEST_fff_f (fma, 0x1.6a09e667f3bccp-538, 0x1.6a09e667f3bccp-538, 0.0, 0.0, UNDERFLOW_EXCEPTION);
4696   TEST_fff_f (fma, 0x1.deadbeef2feedp-495, 0x1.deadbeef2feedp-495, -0x1.bf86a5786a574p-989, 0x0.0000042625a1fp-1022, UNDERFLOW_EXCEPTION);
4697   TEST_fff_f (fma, 0x1.deadbeef2feedp-503, 0x1.deadbeef2feedp-503, -0x1.bf86a5786a574p-1005, 0x0.0000000004262p-1022, UNDERFLOW_EXCEPTION);
4698   TEST_fff_f (fma, 0x1p-537, 0x1p-538, 0x1p-1074, 0x0.0000000000002p-1022, UNDERFLOW_EXCEPTION);
4699   TEST_fff_f (fma, 0x1.7fffff8p-968, 0x1p-106, 0x0.000001p-1022, 0x0.0000010000001p-1022, UNDERFLOW_EXCEPTION);
4700   TEST_fff_f (fma, 0x1.4000004p-967, 0x1p-106, 0x0.000001p-1022, 0x0.0000010000003p-1022, UNDERFLOW_EXCEPTION);
4701   TEST_fff_f (fma, 0x1.4p-967, -0x1p-106, -0x0.000001p-1022, -0x0.0000010000002p-1022, UNDERFLOW_EXCEPTION);
4702   TEST_fff_f (fma, -0x1.19cab66d73e17p-959, 0x1.c7108a8c5ff51p-107, -0x0.80b0ad65d9b64p-1022, -0x0.80b0ad65d9d59p-1022, UNDERFLOW_EXCEPTION);
4703   TEST_fff_f (fma, -0x1.d2eaed6e8e9d3p-979, -0x1.4e066c62ac9ddp-63, -0x0.9245e6b003454p-1022, -0x0.9245c09c5fb5dp-1022, UNDERFLOW_EXCEPTION);
4704   TEST_fff_f (fma, 0x1.153d650bb9f06p-907, 0x1.2d01230d48407p-125, -0x0.b278d5acfc3cp-1022, -0x0.b22757123bbe9p-1022, UNDERFLOW_EXCEPTION);
4705   TEST_fff_f (fma, -0x1.fffffffffffffp-711, 0x1.fffffffffffffp-275, 0x1.fffffe00007ffp-983, 0x1.7ffffe00007ffp-983);
4706   TEST_fff_f (fma, 0x1.4p-1022, 0x1.0000000000002p-1, 0x1p-1024, 0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
4707   TEST_fff_f (fma, -0x1.4p-1022, 0x1.0000000000002p-1, -0x1p-1024, -0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
4708   TEST_fff_f (fma, 0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, 0x1p-1074, 0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4709   TEST_fff_f (fma, -0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, -0x1p-1074, -0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4710   TEST_fff_f (fma, 0x1p-1074, 0x1p-1, 0x0.fffffffffffffp-1022, 0x1p-1022, UNDERFLOW_EXCEPTION);
4711   TEST_fff_f (fma, -0x1p-1074, 0x1p-1, -0x0.fffffffffffffp-1022, -0x1p-1022, UNDERFLOW_EXCEPTION);
4712   TEST_fff_f (fma, 0x1p-1074, 0x1.1p-1, 0x0.fffffffffffffp-1022, 0x1p-1022, UNDERFLOW_EXCEPTION);
4713   TEST_fff_f (fma, -0x1p-1074, 0x1.1p-1, -0x0.fffffffffffffp-1022, -0x1p-1022, UNDERFLOW_EXCEPTION);
4714   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p1023, 0x1p1023);
4715   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p1023, 0x1p1023);
4716   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p1023, -0x1p1023);
4717   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p1023, -0x1p1023);
4718   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1022, 0x1p-1022);
4719   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1022, 0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4720   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1022, -0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4721   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1022, -0x1p-1022);
4722   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4723   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4724   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4725   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4726   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1074, 0x1p-1074, UNDERFLOW_EXCEPTION);
4727   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1074, 0x1p-1074, UNDERFLOW_EXCEPTION);
4728   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1074, -0x1p-1074, UNDERFLOW_EXCEPTION);
4729   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1074, -0x1p-1074, UNDERFLOW_EXCEPTION);
4730   TEST_fff_f (fma, 0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
4731   TEST_fff_f (fma, 0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
4732   TEST_fff_f (fma, -0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
4733   TEST_fff_f (fma, -0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
4734   TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p1023, 0x1p1023);
4735   TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p1023, 0x1p1023);
4736   TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p1023, -0x1p1023);
4737   TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p1023, -0x1p1023);
4738   TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p970, 0x1p970);
4739   TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p970, 0x1p970);
4740   TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p970, -0x1p970);
4741   TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p970, -0x1p970);
4742 #endif
4743 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 64
4744   TEST_fff_f (fma, -0x8.03fcp+3696L, 0xf.fffffffffffffffp-6140L, 0x8.3ffffffffffffffp-2450L, -0x8.01ecp-2440L);
4745   TEST_fff_f (fma, 0x9.fcp+2033L, -0x8.000e1f000ff800fp-3613L, -0xf.fffffffffffc0ffp-1579L, -0xd.fc119fb093ed092p-1577L);
4746   TEST_fff_f (fma, 0xc.7fc000003ffffffp-1194L, 0x8.1e0003fffffffffp+15327L, -0x8.fffep+14072L, 0xc.ae9f164020effffp+14136L);
4747   TEST_fff_f (fma, -0x8.0001fc000000003p+1798L, 0xcp-2230L, 0x8.f7e000000000007p-468L, -0xc.0002f9ffee10404p-429L);
4748   TEST_fff_f (fma, 0xc.0000000000007ffp+10130L, -0x8.000000000000001p+4430L, 0xc.07000000001ffffp+14513L, -0xb.fffffffffffd7e4p+14563L);
4749   TEST_fff_f (fma, 0xb.ffffp-4777L, 0x8.000000fffffffffp-11612L, -0x0.3800fff8p-16385L, 0x5.c7fe80c7ffeffffp-16385L, UNDERFLOW_EXCEPTION);
4750   TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000004p-1L, 0x1p-16384L, 0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
4751   TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000004p-1L, -0x1p-16384L, -0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
4752   TEST_fff_f (fma, 0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, 0x1p-16445L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4753   TEST_fff_f (fma, -0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, -0x1p-16445L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4754   TEST_fff_f (fma, 0x1p-16445L, 0x1p-1L, 0x0.fffffffffffffffep-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
4755   TEST_fff_f (fma, -0x1p-16445L, 0x1p-1L, -0x0.fffffffffffffffep-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
4756   TEST_fff_f (fma, 0x1p-16445L, 0x1.1p-1L, 0x0.fffffffffffffffep-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
4757   TEST_fff_f (fma, -0x1p-16445L, 0x1.1p-1L, -0x0.fffffffffffffffep-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
4758   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p16383L, 0x1p16383L);
4759   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p16383L, 0x1p16383L);
4760   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p16383L, -0x1p16383L);
4761   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p16383L, -0x1p16383L);
4762   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16382L, 0x1p-16382L);
4763   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4764   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4765   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16382L, -0x1p-16382L);
4766   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4767   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4768   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4769   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4770   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, UNDERFLOW_EXCEPTION);
4771   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16445L, 0x1p-16445L, UNDERFLOW_EXCEPTION);
4772   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, UNDERFLOW_EXCEPTION);
4773   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, -0x1p-16445L, UNDERFLOW_EXCEPTION);
4774   TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
4775   TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
4776   TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
4777   TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
4778   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16383L, 0x1p16383L);
4779   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16383L, 0x1p16383L);
4780   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16383L, -0x1p16383L);
4781   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16383L, -0x1p16383L);
4782   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16319L, 0x1p16319L);
4783   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16319L, 0x1p16319L);
4784   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16319L, -0x1p16319L);
4785   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16319L, -0x1p16319L);
4786 #endif
4787 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 113
4788   TEST_fff_f (fma, 0x1.bb2de33e02ccbbfa6e245a7c1f71p-2584L, -0x1.6b500daf0580d987f1bc0cadfcddp-13777L, 0x1.613cd91d9fed34b33820e5ab9d8dp-16378L, -0x1.3a79fb50eb9ce887cffa0f09bd9fp-16360L);
4789   TEST_fff_f (fma, -0x1.f949b880cacb0f0c61540105321dp-5954L, -0x1.3876cec84b4140f3bd6198731b7ep-10525L, -0x0.a5dc1c6cfbc498c54fb0b504bf19p-16382L, -0x0.a5dc1c6cfbc498c54fb0b5038abbp-16382L, UNDERFLOW_EXCEPTION);
4790   TEST_fff_f (fma, -0x1.0000fffffffffp-16221L, 0x1.0000001fffff8007fep-239L, 0x0.ff87ffffffffffffe000003fffffp-16382L, 0x0.ff87ffffffffffffdffc003bff7fp-16382L, UNDERFLOW_EXCEPTION);
4791   TEST_fff_f (fma, -0x1.ac79c9376ef447f3827c9e9de008p-2228L, -0x1.5ba830022b6139e21fbe7270cad8p-6314L, 0x1.e8282b6a26bb6a9daf5c8e73e9f9p-8616L, 0x1.22f14a0253878a730cd1aee373adp-8541L);
4792   TEST_fff_f (fma, -0x1.c69749ec574caaa2ab8e97ddb9f3p+2652L, 0x1.f34235ff9d095449c29b4831b62dp+3311L, 0x1.fbe4302df23354dbd0c4d3cfe606p+5879L, -0x1.bb473bfdfb7a6e18886ce6e57eafp+5964L);
4793   TEST_fff_f (fma, -0x1.ca8835fc6ecfb5398625fc891be5p-1686L, 0x1.621e1972bbe2180e5be9dd7d8df5p-7671L, -0x1.7d2d21b73b52cf20dec2a83902a4p-9395L, -0x1.3d2322191c9c88bc68a62ab8042cp-9356L);
4794   TEST_fff_f (fma, -0x1.55cff679ec49c2541fab41fc843ep-11819L, 0x1.e60e9f464f9e8df0509647c7c971p+12325L, 0x1.eaa2a7649d765c2f564f7a5beca7p+454L, -0x1.447e29fa7e406a285f4e350fcf86p+507L);
4795   TEST_fff_f (fma, 0x1.f0e7b1454908576f2537d863cf9bp+11432L, 0x1.cdce52f09d4ca76e68706f34b5d5p-1417L, -0x1.2e986187c70f146235ea2066e486p+9979L, 0x1.c030dad3cc5643f3dd0f5619f661p+10016L);
4796   TEST_fff_f (fma, 0x1.f102f7da4a57a3a4aab620e29452p-3098L, -0x1.cc06a4ff40248f9e2dcc4b6afd84p-11727L, 0x1.d512a11126b5ac8ed8973b8580c8p-14849L, -0x1.be8f1cf737ab4d1c31c54f5ec23bp-14824L);
4797   TEST_fff_f (fma, -0x1.fc47ac7434b993cd8dcb2b431f25p-3816L, 0x1.fbc9750da8468852d84558e1db6dp-5773L, -0x1.00a98abf783f75c40fe5b7a37d86p-9607L, -0x1.f81917b166f45e763cfcc057e2adp-9588L);
4798   TEST_fff_f (fma, 0x1.00000000000007ffffffffffffffp-9045L, -0x1.ffffffffffff80000001ffffffffp+4773L, -0x1.f8p-4316L, -0x1.00000000000f88000000fffffdffp-4271L);
4799   TEST_fff_f (fma, 0x1.4e922764c90701d4a2f21d01893dp-8683L, -0x1.955a12e2d7c9447c27fa022fc865p+212L, -0x1.e9634462eaef96528b90b6944578p-8521L, -0x1.08e1783184a371943d3598e10865p-8470L);
4800   TEST_fff_f (fma, 0x1.801181509c03bdbef10d6165588cp-15131L, 0x1.ad86f8e57d3d40bfa8007780af63p-368L, -0x1.6e9df0dab1c9f1d7a6043c390741p-15507L, 0x1.417c9b2b15e2ad57dc9e0e920844p-15498L);
4801   TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, 0x1p-16384L, 0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
4802   TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, -0x1p-16384L, -0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
4803   TEST_fff_f (fma, 0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, 0x1p-16494L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4804   TEST_fff_f (fma, -0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, -0x1p-16494L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4805   TEST_fff_f (fma, 0x1p-16494L, 0x1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
4806   TEST_fff_f (fma, -0x1p-16494L, 0x1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
4807   TEST_fff_f (fma, 0x1p-16494L, 0x1.1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
4808   TEST_fff_f (fma, -0x1p-16494L, 0x1.1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
4809   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p16383L, 0x1p16383L);
4810   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p16383L, 0x1p16383L);
4811   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p16383L, -0x1p16383L);
4812   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p16383L, -0x1p16383L);
4813   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16382L, 0x1p-16382L);
4814   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4815   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4816   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16382L, -0x1p-16382L);
4817   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
4818   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
4819   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
4820   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
4821   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, UNDERFLOW_EXCEPTION);
4822   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16494L, 0x1p-16494L, UNDERFLOW_EXCEPTION);
4823   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, UNDERFLOW_EXCEPTION);
4824   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, -0x1p-16494L, UNDERFLOW_EXCEPTION);
4825   TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
4826   TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
4827   TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
4828   TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
4829   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1p16383L);
4830   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1p16383L);
4831   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1p16383L);
4832   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1p16383L);
4833   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1p16319L);
4834   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1p16319L);
4835   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L);
4836   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L);
4837 #endif
4838
4839   END (fma);
4840 }
4841
4842
4843 static void
4844 fma_test_towardzero (void)
4845 {
4846   int save_round_mode;
4847   START (fma_towardzero);
4848
4849   save_round_mode = fegetround ();
4850
4851   if (!fesetround (FE_TOWARDZERO))
4852     {
4853       TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero);
4854       TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, plus_zero);
4855       TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, plus_zero);
4856       TEST_fff_f (fma, plus_zero, minus_zero, minus_zero, minus_zero);
4857       TEST_fff_f (fma, minus_zero, plus_zero, plus_zero, plus_zero);
4858       TEST_fff_f (fma, minus_zero, plus_zero, minus_zero, minus_zero);
4859       TEST_fff_f (fma, minus_zero, minus_zero, plus_zero, plus_zero);
4860       TEST_fff_f (fma, minus_zero, minus_zero, minus_zero, plus_zero);
4861       TEST_fff_f (fma, 1.0, plus_zero, plus_zero, plus_zero);
4862       TEST_fff_f (fma, 1.0, plus_zero, minus_zero, plus_zero);
4863       TEST_fff_f (fma, 1.0, minus_zero, plus_zero, plus_zero);
4864       TEST_fff_f (fma, 1.0, minus_zero, minus_zero, minus_zero);
4865       TEST_fff_f (fma, -1.0, plus_zero, plus_zero, plus_zero);
4866       TEST_fff_f (fma, -1.0, plus_zero, minus_zero, minus_zero);
4867       TEST_fff_f (fma, -1.0, minus_zero, plus_zero, plus_zero);
4868       TEST_fff_f (fma, -1.0, minus_zero, minus_zero, plus_zero);
4869       TEST_fff_f (fma, plus_zero, 1.0, plus_zero, plus_zero);
4870       TEST_fff_f (fma, plus_zero, 1.0, minus_zero, plus_zero);
4871       TEST_fff_f (fma, plus_zero, -1.0, plus_zero, plus_zero);
4872       TEST_fff_f (fma, plus_zero, -1.0, minus_zero, minus_zero);
4873       TEST_fff_f (fma, minus_zero, 1.0, plus_zero, plus_zero);
4874       TEST_fff_f (fma, minus_zero, 1.0, minus_zero, minus_zero);
4875       TEST_fff_f (fma, minus_zero, -1.0, plus_zero, plus_zero);
4876       TEST_fff_f (fma, minus_zero, -1.0, minus_zero, plus_zero);
4877
4878       TEST_fff_f (fma, 1.0, 1.0, -1.0, plus_zero);
4879       TEST_fff_f (fma, 1.0, -1.0, 1.0, plus_zero);
4880       TEST_fff_f (fma, -1.0, 1.0, 1.0, plus_zero);
4881       TEST_fff_f (fma, -1.0, -1.0, -1.0, plus_zero);
4882
4883       TEST_fff_f (fma, min_value, min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4884       TEST_fff_f (fma, min_value, min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4885       TEST_fff_f (fma, min_value, -min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4886       TEST_fff_f (fma, min_value, -min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4887       TEST_fff_f (fma, -min_value, min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4888       TEST_fff_f (fma, -min_value, min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4889       TEST_fff_f (fma, -min_value, -min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4890       TEST_fff_f (fma, -min_value, -min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4891
4892       TEST_fff_f (fma, max_value, max_value, min_value, max_value, OVERFLOW_EXCEPTION);
4893       TEST_fff_f (fma, max_value, max_value, -min_value, max_value, OVERFLOW_EXCEPTION);
4894       TEST_fff_f (fma, max_value, -max_value, min_value, -max_value, OVERFLOW_EXCEPTION);
4895       TEST_fff_f (fma, max_value, -max_value, -min_value, -max_value, OVERFLOW_EXCEPTION);
4896       TEST_fff_f (fma, -max_value, max_value, min_value, -max_value, OVERFLOW_EXCEPTION);
4897       TEST_fff_f (fma, -max_value, max_value, -min_value, -max_value, OVERFLOW_EXCEPTION);
4898       TEST_fff_f (fma, -max_value, -max_value, min_value, max_value, OVERFLOW_EXCEPTION);
4899       TEST_fff_f (fma, -max_value, -max_value, -min_value, max_value, OVERFLOW_EXCEPTION);
4900
4901 #if defined (TEST_FLOAT) && FLT_MANT_DIG == 24
4902       TEST_fff_f (fma, 0x1.4p-126, 0x1.000004p-1, 0x1p-128, 0x1.c00004p-127, UNDERFLOW_EXCEPTION);
4903       TEST_fff_f (fma, -0x1.4p-126, 0x1.000004p-1, -0x1p-128, -0x1.c00004p-127, UNDERFLOW_EXCEPTION);
4904       TEST_fff_f (fma, 0x1.fffff8p-126, 0x1.000002p-1, 0x1p-149, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4905       TEST_fff_f (fma, -0x1.fffff8p-126, 0x1.000002p-1, -0x1p-149, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4906       TEST_fff_f (fma, 0x1p-149, 0x1p-1, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4907       TEST_fff_f (fma, -0x1p-149, 0x1p-1, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4908       TEST_fff_f (fma, 0x1p-149, 0x1.1p-1, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4909       TEST_fff_f (fma, -0x1p-149, 0x1.1p-1, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4910       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p127, 0x1p127);
4911       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p127, 0x0.ffffffp127);
4912       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p127, -0x0.ffffffp127);
4913       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p127, -0x1p127);
4914       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-126, 0x1p-126);
4915       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4916       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4917       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-126, -0x1p-126);
4918       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4919       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x0.fffffep-126, 0x0.fffffcp-126, UNDERFLOW_EXCEPTION);
4920       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x0.fffffep-126, -0x0.fffffcp-126, UNDERFLOW_EXCEPTION);
4921       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4922       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-149, 0x1p-149, UNDERFLOW_EXCEPTION);
4923       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-149, plus_zero, UNDERFLOW_EXCEPTION);
4924       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-149, minus_zero, UNDERFLOW_EXCEPTION);
4925       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-149, -0x1p-149, UNDERFLOW_EXCEPTION);
4926       TEST_fff_f (fma, 0x0.fffp0, 0x0.fffp0, -0x0.ffep0, 0x1p-24);
4927       TEST_fff_f (fma, 0x0.fffp0, -0x0.fffp0, 0x0.ffep0, -0x1p-24);
4928       TEST_fff_f (fma, -0x0.fffp0, 0x0.fffp0, 0x0.ffep0, -0x1p-24);
4929       TEST_fff_f (fma, -0x0.fffp0, -0x0.fffp0, -0x0.ffep0, 0x1p-24);
4930       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p127, 0x1p127);
4931       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p127, 0x0.ffffffp127);
4932       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p127, -0x0.ffffffp127);
4933       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p127, -0x1p127);
4934       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p103, 0x1p103);
4935       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p103, 0x0.ffffffp103);
4936       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p103, -0x0.ffffffp103);
4937       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p103, -0x1p103);
4938 #endif
4939 #if defined (TEST_DOUBLE) && DBL_MANT_DIG == 53
4940       TEST_fff_f (fma, 0x1.4p-1022, 0x1.0000000000002p-1, 0x1p-1024, 0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
4941       TEST_fff_f (fma, -0x1.4p-1022, 0x1.0000000000002p-1, -0x1p-1024, -0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
4942       TEST_fff_f (fma, 0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, 0x1p-1074, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4943       TEST_fff_f (fma, -0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, -0x1p-1074, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4944       TEST_fff_f (fma, 0x1p-1074, 0x1p-1, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4945       TEST_fff_f (fma, -0x1p-1074, 0x1p-1, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4946       TEST_fff_f (fma, 0x1p-1074, 0x1.1p-1, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4947       TEST_fff_f (fma, -0x1p-1074, 0x1.1p-1, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4948       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p1023, 0x1p1023);
4949       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p1023, 0x0.fffffffffffff8p1023);
4950       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p1023, -0x0.fffffffffffff8p1023);
4951       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p1023, -0x1p1023);
4952       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1022, 0x1p-1022);
4953       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4954       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4955       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1022, -0x1p-1022);
4956       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4957       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.ffffffffffffep-1022, UNDERFLOW_EXCEPTION);
4958       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.ffffffffffffep-1022, UNDERFLOW_EXCEPTION);
4959       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4960       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1074, 0x1p-1074, UNDERFLOW_EXCEPTION);
4961       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1074, plus_zero, UNDERFLOW_EXCEPTION);
4962       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1074, minus_zero, UNDERFLOW_EXCEPTION);
4963       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1074, -0x1p-1074, UNDERFLOW_EXCEPTION);
4964       TEST_fff_f (fma, 0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
4965       TEST_fff_f (fma, 0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
4966       TEST_fff_f (fma, -0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
4967       TEST_fff_f (fma, -0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
4968       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p1023, 0x1p1023);
4969       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p1023, 0x0.fffffffffffff8p1023);
4970       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p1023, -0x0.fffffffffffff8p1023);
4971       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p1023, -0x1p1023);
4972       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p970, 0x1p970);
4973       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p970, 0x0.fffffffffffff8p970);
4974       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p970, -0x0.fffffffffffff8p970);
4975       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p970, -0x1p970);
4976 #endif
4977 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 64
4978       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000004p-1L, 0x1p-16384L, 0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
4979       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000004p-1L, -0x1p-16384L, -0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
4980       TEST_fff_f (fma, 0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4981       TEST_fff_f (fma, -0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4982       TEST_fff_f (fma, 0x1p-16445L, 0x1p-1L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4983       TEST_fff_f (fma, -0x1p-16445L, 0x1p-1L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4984       TEST_fff_f (fma, 0x1p-16445L, 0x1.1p-1L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4985       TEST_fff_f (fma, -0x1p-16445L, 0x1.1p-1L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4986       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p16383L, 0x1p16383L);
4987       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p16383L, 0x0.ffffffffffffffffp16383L);
4988       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p16383L, -0x0.ffffffffffffffffp16383L);
4989       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p16383L, -0x1p16383L);
4990       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16382L, 0x1p-16382L);
4991       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4992       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4993       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16382L, -0x1p-16382L);
4994       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4995       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffcp-16382L, UNDERFLOW_EXCEPTION);
4996       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffcp-16382L, UNDERFLOW_EXCEPTION);
4997       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4998       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, UNDERFLOW_EXCEPTION);
4999       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16445L, plus_zero, UNDERFLOW_EXCEPTION);
5000       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16445L, minus_zero, UNDERFLOW_EXCEPTION);
5001       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, -0x1p-16445L, UNDERFLOW_EXCEPTION);
5002       TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
5003       TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
5004       TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
5005       TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
5006       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16383L, 0x1p16383L);
5007       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16383L, 0x0.ffffffffffffffffp16383L);
5008       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16383L, -0x0.ffffffffffffffffp16383L);
5009       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16383L, -0x1p16383L);
5010       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16319L, 0x1p16319L);
5011       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16319L, 0x0.ffffffffffffffffp16319L);
5012       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16319L, -0x0.ffffffffffffffffp16319L);
5013       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16319L, -0x1p16319L);
5014 #endif
5015 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 113
5016       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, 0x1p-16384L, 0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
5017       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, -0x1p-16384L, -0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
5018       TEST_fff_f (fma, 0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5019       TEST_fff_f (fma, -0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5020       TEST_fff_f (fma, 0x1p-16494L, 0x1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5021       TEST_fff_f (fma, -0x1p-16494L, 0x1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5022       TEST_fff_f (fma, 0x1p-16494L, 0x1.1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5023       TEST_fff_f (fma, -0x1p-16494L, 0x1.1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5024       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p16383L, 0x1p16383L);
5025       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p16383L, 0x0.ffffffffffffffffffffffffffff8p16383L);
5026       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p16383L, -0x0.ffffffffffffffffffffffffffff8p16383L);
5027       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p16383L, -0x1p16383L);
5028       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16382L, 0x1p-16382L);
5029       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5030       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5031       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16382L, -0x1p-16382L);
5032       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5033       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.fffffffffffffffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5034       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.fffffffffffffffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5035       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5036       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, UNDERFLOW_EXCEPTION);
5037       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16494L, plus_zero, UNDERFLOW_EXCEPTION);
5038       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16494L, minus_zero, UNDERFLOW_EXCEPTION);
5039       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, -0x1p-16494L, UNDERFLOW_EXCEPTION);
5040       TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5041       TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5042       TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5043       TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5044       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1p16383L);
5045       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x0.ffffffffffffffffffffffffffff8p16383L);
5046       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x0.ffffffffffffffffffffffffffff8p16383L);
5047       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1p16383L);
5048       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1p16319L);
5049       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x0.ffffffffffffffffffffffffffff8p16319L);
5050       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x0.ffffffffffffffffffffffffffff8p16319L);
5051       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L);
5052 #endif
5053     }
5054
5055   fesetround (save_round_mode);
5056
5057   END (fma_towardzero);
5058 }
5059
5060
5061 static void
5062 fma_test_downward (void)
5063 {
5064   int save_round_mode;
5065   START (fma_downward);
5066
5067   save_round_mode = fegetround ();
5068
5069   if (!fesetround (FE_DOWNWARD))
5070     {
5071       TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero);
5072       TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, minus_zero);
5073       TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, minus_zero);
5074       TEST_fff_f (fma, plus_zero, minus_zero, minus_zero, minus_zero);
5075       TEST_fff_f (fma, minus_zero, plus_zero, plus_zero, minus_zero);
5076       TEST_fff_f (fma, minus_zero, plus_zero, minus_zero, minus_zero);
5077       TEST_fff_f (fma, minus_zero, minus_zero, plus_zero, plus_zero);
5078       TEST_fff_f (fma, minus_zero, minus_zero, minus_zero, minus_zero);
5079       TEST_fff_f (fma, 1.0, plus_zero, plus_zero, plus_zero);
5080       TEST_fff_f (fma, 1.0, plus_zero, minus_zero, minus_zero);
5081       TEST_fff_f (fma, 1.0, minus_zero, plus_zero, minus_zero);
5082       TEST_fff_f (fma, 1.0, minus_zero, minus_zero, minus_zero);
5083       TEST_fff_f (fma, -1.0, plus_zero, plus_zero, minus_zero);
5084       TEST_fff_f (fma, -1.0, plus_zero, minus_zero, minus_zero);
5085       TEST_fff_f (fma, -1.0, minus_zero, plus_zero, plus_zero);
5086       TEST_fff_f (fma, -1.0, minus_zero, minus_zero, minus_zero);
5087       TEST_fff_f (fma, plus_zero, 1.0, plus_zero, plus_zero);
5088       TEST_fff_f (fma, plus_zero, 1.0, minus_zero, minus_zero);
5089       TEST_fff_f (fma, plus_zero, -1.0, plus_zero, minus_zero);
5090       TEST_fff_f (fma, plus_zero, -1.0, minus_zero, minus_zero);
5091       TEST_fff_f (fma, minus_zero, 1.0, plus_zero, minus_zero);
5092       TEST_fff_f (fma, minus_zero, 1.0, minus_zero, minus_zero);
5093       TEST_fff_f (fma, minus_zero, -1.0, plus_zero, plus_zero);
5094       TEST_fff_f (fma, minus_zero, -1.0, minus_zero, minus_zero);
5095
5096       TEST_fff_f (fma, 1.0, 1.0, -1.0, minus_zero);
5097       TEST_fff_f (fma, 1.0, -1.0, 1.0, minus_zero);
5098       TEST_fff_f (fma, -1.0, 1.0, 1.0, minus_zero);
5099       TEST_fff_f (fma, -1.0, -1.0, -1.0, minus_zero);
5100
5101       TEST_fff_f (fma, min_value, min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
5102       TEST_fff_f (fma, min_value, min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
5103       TEST_fff_f (fma, min_value, -min_value, plus_zero, -min_subnorm_value, UNDERFLOW_EXCEPTION);
5104       TEST_fff_f (fma, min_value, -min_value, minus_zero, -min_subnorm_value, UNDERFLOW_EXCEPTION);
5105       TEST_fff_f (fma, -min_value, min_value, plus_zero, -min_subnorm_value, UNDERFLOW_EXCEPTION);
5106       TEST_fff_f (fma, -min_value, min_value, minus_zero, -min_subnorm_value, UNDERFLOW_EXCEPTION);
5107       TEST_fff_f (fma, -min_value, -min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
5108       TEST_fff_f (fma, -min_value, -min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
5109
5110       TEST_fff_f (fma, max_value, max_value, min_value, max_value, OVERFLOW_EXCEPTION);
5111       TEST_fff_f (fma, max_value, max_value, -min_value, max_value, OVERFLOW_EXCEPTION);
5112       TEST_fff_f (fma, max_value, -max_value, min_value, minus_infty, OVERFLOW_EXCEPTION);
5113       TEST_fff_f (fma, max_value, -max_value, -min_value, minus_infty, OVERFLOW_EXCEPTION);
5114       TEST_fff_f (fma, -max_value, max_value, min_value, minus_infty, OVERFLOW_EXCEPTION);
5115       TEST_fff_f (fma, -max_value, max_value, -min_value, minus_infty, OVERFLOW_EXCEPTION);
5116       TEST_fff_f (fma, -max_value, -max_value, min_value, max_value, OVERFLOW_EXCEPTION);
5117       TEST_fff_f (fma, -max_value, -max_value, -min_value, max_value, OVERFLOW_EXCEPTION);
5118
5119 #if defined (TEST_FLOAT) && FLT_MANT_DIG == 24
5120       TEST_fff_f (fma, 0x1.4p-126, 0x1.000004p-1, 0x1p-128, 0x1.c00004p-127, UNDERFLOW_EXCEPTION);
5121       TEST_fff_f (fma, -0x1.4p-126, 0x1.000004p-1, -0x1p-128, -0x1.c00008p-127, UNDERFLOW_EXCEPTION);
5122       TEST_fff_f (fma, 0x1.fffff8p-126, 0x1.000002p-1, 0x1p-149, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5123       TEST_fff_f (fma, -0x1.fffff8p-126, 0x1.000002p-1, -0x1p-149, -0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5124       TEST_fff_f (fma, 0x1p-149, 0x1p-1, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5125       TEST_fff_f (fma, -0x1p-149, 0x1p-1, -0x0.fffffep-126, -0x1p-126, UNDERFLOW_EXCEPTION);
5126       TEST_fff_f (fma, 0x1p-149, 0x1.1p-1, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5127       TEST_fff_f (fma, -0x1p-149, 0x1.1p-1, -0x0.fffffep-126, -0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5128       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p127, 0x1p127);
5129       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p127, 0x0.ffffffp127);
5130       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p127, -0x1p127);
5131       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p127, -0x1.000002p127);
5132       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-126, 0x1p-126);
5133       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5134       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-126, -0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5135       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-126, -0x1.000002p-126);
5136       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5137       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x0.fffffep-126, 0x0.fffffcp-126, UNDERFLOW_EXCEPTION);
5138       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5139       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x0.fffffep-126, -0x1p-126, UNDERFLOW_EXCEPTION);
5140       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-149, 0x1p-149, UNDERFLOW_EXCEPTION);
5141       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-149, plus_zero, UNDERFLOW_EXCEPTION);
5142       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-149, -0x1p-149, UNDERFLOW_EXCEPTION);
5143       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-149, -0x1p-148, UNDERFLOW_EXCEPTION);
5144       TEST_fff_f (fma, 0x0.fffp0, 0x0.fffp0, -0x0.ffep0, 0x1p-24);
5145       TEST_fff_f (fma, 0x0.fffp0, -0x0.fffp0, 0x0.ffep0, -0x1p-24);
5146       TEST_fff_f (fma, -0x0.fffp0, 0x0.fffp0, 0x0.ffep0, -0x1p-24);
5147       TEST_fff_f (fma, -0x0.fffp0, -0x0.fffp0, -0x0.ffep0, 0x1p-24);
5148       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p127, 0x1p127);
5149       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p127, 0x0.ffffffp127);
5150       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p127, -0x1p127);
5151       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p127, -0x1.000002p127);
5152       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p103, 0x1p103);
5153       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p103, 0x0.ffffffp103);
5154       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p103, -0x1p103);
5155       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p103, -0x1.000002p103);
5156 #endif
5157 #if defined (TEST_DOUBLE) && DBL_MANT_DIG == 53
5158       TEST_fff_f (fma, 0x1.4p-1022, 0x1.0000000000002p-1, 0x1p-1024, 0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
5159       TEST_fff_f (fma, -0x1.4p-1022, 0x1.0000000000002p-1, -0x1p-1024, -0x1.c000000000004p-1023, UNDERFLOW_EXCEPTION);
5160       TEST_fff_f (fma, 0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, 0x1p-1074, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5161       TEST_fff_f (fma, -0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, -0x1p-1074, -0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5162       TEST_fff_f (fma, 0x1p-1074, 0x1p-1, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5163       TEST_fff_f (fma, -0x1p-1074, 0x1p-1, -0x0.fffffffffffffp-1022, -0x1p-1022, UNDERFLOW_EXCEPTION);
5164       TEST_fff_f (fma, 0x1p-1074, 0x1.1p-1, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5165       TEST_fff_f (fma, -0x1p-1074, 0x1.1p-1, -0x0.fffffffffffffp-1022, -0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5166       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p1023, 0x1p1023);
5167       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p1023, 0x0.fffffffffffff8p1023);
5168       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p1023, -0x1p1023);
5169       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p1023, -0x1.0000000000001p1023);
5170       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1022, 0x1p-1022);
5171       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5172       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1022, -0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5173       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1022, -0x1.0000000000001p-1022);
5174       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5175       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.ffffffffffffep-1022, UNDERFLOW_EXCEPTION);
5176       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5177       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x0.fffffffffffffp-1022, -0x1p-1022, UNDERFLOW_EXCEPTION);
5178       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1074, 0x1p-1074, UNDERFLOW_EXCEPTION);
5179       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1074, plus_zero, UNDERFLOW_EXCEPTION);
5180       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1074, -0x1p-1074, UNDERFLOW_EXCEPTION);
5181       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1074, -0x1p-1073, UNDERFLOW_EXCEPTION);
5182       TEST_fff_f (fma, 0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
5183       TEST_fff_f (fma, 0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
5184       TEST_fff_f (fma, -0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
5185       TEST_fff_f (fma, -0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
5186       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p1023, 0x1p1023);
5187       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p1023, 0x0.fffffffffffff8p1023);
5188       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p1023, -0x1p1023);
5189       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p1023, -0x1.0000000000001p1023);
5190       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p970, 0x1p970);
5191       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p970, 0x0.fffffffffffff8p970);
5192       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p970, -0x1p970);
5193       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p970, -0x1.0000000000001p970);
5194 #endif
5195 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 64
5196       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000004p-1L, 0x1p-16384L, 0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
5197       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000004p-1L, -0x1p-16384L, -0x1.c000000000000008p-16383L, UNDERFLOW_EXCEPTION);
5198       TEST_fff_f (fma, 0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5199       TEST_fff_f (fma, -0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, -0x1p-16445L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5200       TEST_fff_f (fma, 0x1p-16445L, 0x1p-1L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5201       TEST_fff_f (fma, -0x1p-16445L, 0x1p-1L, -0x0.fffffffffffffffep-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
5202       TEST_fff_f (fma, 0x1p-16445L, 0x1.1p-1L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5203       TEST_fff_f (fma, -0x1p-16445L, 0x1.1p-1L, -0x0.fffffffffffffffep-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5204       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p16383L, 0x1p16383L);
5205       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p16383L, 0x0.ffffffffffffffffp16383L);
5206       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p16383L, -0x1p16383L);
5207       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p16383L, -0x1.0000000000000002p16383L);
5208       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16382L, 0x1p-16382L);
5209       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5210       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5211       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16382L, -0x1.0000000000000002p-16382L);
5212       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5213       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffcp-16382L, UNDERFLOW_EXCEPTION);
5214       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5215       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
5216       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, UNDERFLOW_EXCEPTION);
5217       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16445L, plus_zero, UNDERFLOW_EXCEPTION);
5218       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, UNDERFLOW_EXCEPTION);
5219       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, -0x1p-16444L, UNDERFLOW_EXCEPTION);
5220       TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
5221       TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
5222       TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
5223       TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
5224       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16383L, 0x1p16383L);
5225       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16383L, 0x0.ffffffffffffffffp16383L);
5226       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16383L, -0x1p16383L);
5227       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16383L, -0x1.0000000000000002p16383L);
5228       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16319L, 0x1p16319L);
5229       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16319L, 0x0.ffffffffffffffffp16319L);
5230       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16319L, -0x1p16319L);
5231       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16319L, -0x1.0000000000000002p16319L);
5232 #endif
5233 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 113
5234       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, 0x1p-16384L, 0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
5235       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, -0x1p-16384L, -0x1.c000000000000000000000000004p-16383L, UNDERFLOW_EXCEPTION);
5236       TEST_fff_f (fma, 0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5237       TEST_fff_f (fma, -0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, -0x1p-16494L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5238       TEST_fff_f (fma, 0x1p-16494L, 0x1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5239       TEST_fff_f (fma, -0x1p-16494L, 0x1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
5240       TEST_fff_f (fma, 0x1p-16494L, 0x1.1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5241       TEST_fff_f (fma, -0x1p-16494L, 0x1.1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5242       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p16383L, 0x1p16383L);
5243       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p16383L, 0x0.ffffffffffffffffffffffffffff8p16383L);
5244       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p16383L, -0x1p16383L);
5245       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p16383L, -0x1.0000000000000000000000000001p16383L);
5246       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16382L, 0x1p-16382L);
5247       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5248       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5249       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16382L, -0x1.0000000000000000000000000001p-16382L);
5250       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5251       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.fffffffffffffffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5252       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5253       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
5254       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, UNDERFLOW_EXCEPTION);
5255       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16494L, plus_zero, UNDERFLOW_EXCEPTION);
5256       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, UNDERFLOW_EXCEPTION);
5257       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, -0x1p-16493L, UNDERFLOW_EXCEPTION);
5258       TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5259       TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5260       TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5261       TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5262       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1p16383L);
5263       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x0.ffffffffffffffffffffffffffff8p16383L);
5264       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1p16383L);
5265       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1.0000000000000000000000000001p16383L);
5266       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1p16319L);
5267       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x0.ffffffffffffffffffffffffffff8p16319L);
5268       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L);
5269       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1.0000000000000000000000000001p16319L);
5270 #endif
5271     }
5272
5273   fesetround (save_round_mode);
5274
5275   END (fma_downward);
5276 }
5277
5278
5279 static void
5280 fma_test_upward (void)
5281 {
5282   int save_round_mode;
5283   START (fma_upward);
5284
5285   save_round_mode = fegetround ();
5286
5287   if (!fesetround (FE_UPWARD))
5288     {
5289       TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero);
5290       TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, plus_zero);
5291       TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, plus_zero);
5292       TEST_fff_f (fma, plus_zero, minus_zero, minus_zero, minus_zero);
5293       TEST_fff_f (fma, minus_zero, plus_zero, plus_zero, plus_zero);
5294       TEST_fff_f (fma, minus_zero, plus_zero, minus_zero, minus_zero);
5295       TEST_fff_f (fma, minus_zero, minus_zero, plus_zero, plus_zero);
5296       TEST_fff_f (fma, minus_zero, minus_zero, minus_zero, plus_zero);
5297       TEST_fff_f (fma, 1.0, plus_zero, plus_zero, plus_zero);
5298       TEST_fff_f (fma, 1.0, plus_zero, minus_zero, plus_zero);
5299       TEST_fff_f (fma, 1.0, minus_zero, plus_zero, plus_zero);
5300       TEST_fff_f (fma, 1.0, minus_zero, minus_zero, minus_zero);
5301       TEST_fff_f (fma, -1.0, plus_zero, plus_zero, plus_zero);
5302       TEST_fff_f (fma, -1.0, plus_zero, minus_zero, minus_zero);
5303       TEST_fff_f (fma, -1.0, minus_zero, plus_zero, plus_zero);
5304       TEST_fff_f (fma, -1.0, minus_zero, minus_zero, plus_zero);
5305       TEST_fff_f (fma, plus_zero, 1.0, plus_zero, plus_zero);
5306       TEST_fff_f (fma, plus_zero, 1.0, minus_zero, plus_zero);
5307       TEST_fff_f (fma, plus_zero, -1.0, plus_zero, plus_zero);
5308       TEST_fff_f (fma, plus_zero, -1.0, minus_zero, minus_zero);
5309       TEST_fff_f (fma, minus_zero, 1.0, plus_zero, plus_zero);
5310       TEST_fff_f (fma, minus_zero, 1.0, minus_zero, minus_zero);
5311       TEST_fff_f (fma, minus_zero, -1.0, plus_zero, plus_zero);
5312       TEST_fff_f (fma, minus_zero, -1.0, minus_zero, plus_zero);
5313
5314       TEST_fff_f (fma, 1.0, 1.0, -1.0, plus_zero);
5315       TEST_fff_f (fma, 1.0, -1.0, 1.0, plus_zero);
5316       TEST_fff_f (fma, -1.0, 1.0, 1.0, plus_zero);
5317       TEST_fff_f (fma, -1.0, -1.0, -1.0, plus_zero);
5318
5319       TEST_fff_f (fma, min_value, min_value, plus_zero, min_subnorm_value, UNDERFLOW_EXCEPTION);
5320       TEST_fff_f (fma, min_value, min_value, minus_zero, min_subnorm_value, UNDERFLOW_EXCEPTION);
5321       TEST_fff_f (fma, min_value, -min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
5322       TEST_fff_f (fma, min_value, -min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
5323       TEST_fff_f (fma, -min_value, min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
5324       TEST_fff_f (fma, -min_value, min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
5325       TEST_fff_f (fma, -min_value, -min_value, plus_zero, min_subnorm_value, UNDERFLOW_EXCEPTION);
5326       TEST_fff_f (fma, -min_value, -min_value, minus_zero, min_subnorm_value, UNDERFLOW_EXCEPTION);
5327
5328       TEST_fff_f (fma, max_value, max_value, min_value, plus_infty, OVERFLOW_EXCEPTION);
5329       TEST_fff_f (fma, max_value, max_value, -min_value, plus_infty, OVERFLOW_EXCEPTION);
5330       TEST_fff_f (fma, max_value, -max_value, min_value, -max_value, OVERFLOW_EXCEPTION);
5331       TEST_fff_f (fma, max_value, -max_value, -min_value, -max_value, OVERFLOW_EXCEPTION);
5332       TEST_fff_f (fma, -max_value, max_value, min_value, -max_value, OVERFLOW_EXCEPTION);
5333       TEST_fff_f (fma, -max_value, max_value, -min_value, -max_value, OVERFLOW_EXCEPTION);
5334       TEST_fff_f (fma, -max_value, -max_value, min_value, plus_infty, OVERFLOW_EXCEPTION);
5335       TEST_fff_f (fma, -max_value, -max_value, -min_value, plus_infty, OVERFLOW_EXCEPTION);
5336
5337 #if defined (TEST_FLOAT) && FLT_MANT_DIG == 24
5338       TEST_fff_f (fma, 0x1.4p-126, 0x1.000004p-1, 0x1p-128, 0x1.c00008p-127, UNDERFLOW_EXCEPTION);
5339       TEST_fff_f (fma, -0x1.4p-126, 0x1.000004p-1, -0x1p-128, -0x1.c00004p-127, UNDERFLOW_EXCEPTION);
5340       TEST_fff_f (fma, 0x1.fffff8p-126, 0x1.000002p-1, 0x1p-149, 0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5341       TEST_fff_f (fma, -0x1.fffff8p-126, 0x1.000002p-1, -0x1p-149, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5342       TEST_fff_f (fma, 0x1p-149, 0x1p-1, 0x0.fffffep-126, 0x1p-126, UNDERFLOW_EXCEPTION);
5343       TEST_fff_f (fma, -0x1p-149, 0x1p-1, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5344       TEST_fff_f (fma, 0x1p-149, 0x1.1p-1, 0x0.fffffep-126, 0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5345       TEST_fff_f (fma, -0x1p-149, 0x1.1p-1, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5346       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p127, 0x1.000002p127);
5347       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p127, 0x1p127);
5348       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p127, -0x0.ffffffp127);
5349       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p127, -0x1p127);
5350       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-126, 0x1.000002p-126);
5351       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-126, 0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5352       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5353       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-126, -0x1p-126);
5354       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x0.fffffep-126, 0x1p-126, UNDERFLOW_EXCEPTION);
5355       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5356       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x0.fffffep-126, -0x0.fffffcp-126, UNDERFLOW_EXCEPTION);
5357       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5358       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-149, 0x1p-148, UNDERFLOW_EXCEPTION);
5359       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-149, 0x1p-149, UNDERFLOW_EXCEPTION);
5360       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-149, minus_zero, UNDERFLOW_EXCEPTION);
5361       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-149, -0x1p-149, UNDERFLOW_EXCEPTION);
5362       TEST_fff_f (fma, 0x0.fffp0, 0x0.fffp0, -0x0.ffep0, 0x1p-24);
5363       TEST_fff_f (fma, 0x0.fffp0, -0x0.fffp0, 0x0.ffep0, -0x1p-24);
5364       TEST_fff_f (fma, -0x0.fffp0, 0x0.fffp0, 0x0.ffep0, -0x1p-24);
5365       TEST_fff_f (fma, -0x0.fffp0, -0x0.fffp0, -0x0.ffep0, 0x1p-24);
5366       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p127, 0x1.000002p127);
5367       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p127, 0x1p127);
5368       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p127, -0x0.ffffffp127);
5369       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p127, -0x1p127);
5370       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p103, 0x1.000002p103);
5371       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p103, 0x1p103);
5372       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p103, -0x0.ffffffp103);
5373       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p103, -0x1p103);
5374 #endif
5375 #if defined (TEST_DOUBLE) && DBL_MANT_DIG == 53
5376       TEST_fff_f (fma, 0x1.4p-1022, 0x1.0000000000002p-1, 0x1p-1024, 0x1.c000000000004p-1023, UNDERFLOW_EXCEPTION);
5377       TEST_fff_f (fma, -0x1.4p-1022, 0x1.0000000000002p-1, -0x1p-1024, -0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
5378       TEST_fff_f (fma, 0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, 0x1p-1074, 0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5379       TEST_fff_f (fma, -0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, -0x1p-1074, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5380       TEST_fff_f (fma, 0x1p-1074, 0x1p-1, 0x0.fffffffffffffp-1022, 0x1p-1022, UNDERFLOW_EXCEPTION);
5381       TEST_fff_f (fma, -0x1p-1074, 0x1p-1, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5382       TEST_fff_f (fma, 0x1p-1074, 0x1.1p-1, 0x0.fffffffffffffp-1022, 0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5383       TEST_fff_f (fma, -0x1p-1074, 0x1.1p-1, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5384       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p1023, 0x1.0000000000001p1023);
5385       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p1023, 0x1p1023);
5386       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p1023, -0x0.fffffffffffff8p1023);
5387       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p1023, -0x1p1023);
5388       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1022, 0x1.0000000000001p-1022);
5389       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1022, 0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5390       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5391       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1022, -0x1p-1022);
5392       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x0.fffffffffffffp-1022, 0x1p-1022, UNDERFLOW_EXCEPTION);
5393       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5394       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.ffffffffffffep-1022, UNDERFLOW_EXCEPTION);
5395       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5396       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1074, 0x1p-1073, UNDERFLOW_EXCEPTION);
5397       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1074, 0x1p-1074, UNDERFLOW_EXCEPTION);
5398       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1074, minus_zero, UNDERFLOW_EXCEPTION);
5399       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1074, -0x1p-1074, UNDERFLOW_EXCEPTION);
5400       TEST_fff_f (fma, 0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
5401       TEST_fff_f (fma, 0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
5402       TEST_fff_f (fma, -0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
5403       TEST_fff_f (fma, -0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
5404       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p1023, 0x1.0000000000001p1023);
5405       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p1023, 0x1p1023);
5406       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p1023, -0x0.fffffffffffff8p1023);
5407       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p1023, -0x1p1023);
5408       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p970, 0x1.0000000000001p970);
5409       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p970, 0x1p970);
5410       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p970, -0x0.fffffffffffff8p970);
5411       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p970, -0x1p970);
5412 #endif
5413 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 64
5414       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000004p-1L, 0x1p-16384L, 0x1.c000000000000008p-16383L, UNDERFLOW_EXCEPTION);
5415       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000004p-1L, -0x1p-16384L, -0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
5416       TEST_fff_f (fma, 0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, 0x1p-16445L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5417       TEST_fff_f (fma, -0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5418       TEST_fff_f (fma, 0x1p-16445L, 0x1p-1L, 0x0.fffffffffffffffep-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
5419       TEST_fff_f (fma, -0x1p-16445L, 0x1p-1L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5420       TEST_fff_f (fma, 0x1p-16445L, 0x1.1p-1L, 0x0.fffffffffffffffep-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5421       TEST_fff_f (fma, -0x1p-16445L, 0x1.1p-1L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5422       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p16383L, 0x1.0000000000000002p16383L);
5423       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p16383L, 0x1p16383L);
5424       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p16383L, -0x0.ffffffffffffffffp16383L);
5425       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p16383L, -0x1p16383L);
5426       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16382L, 0x1.0000000000000002p-16382L);
5427       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5428       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5429       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16382L, -0x1p-16382L);
5430       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
5431       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5432       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffcp-16382L, UNDERFLOW_EXCEPTION);
5433       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5434       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, 0x1p-16444L, UNDERFLOW_EXCEPTION);
5435       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16445L, 0x1p-16445L, UNDERFLOW_EXCEPTION);
5436       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16445L, minus_zero, UNDERFLOW_EXCEPTION);
5437       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, -0x1p-16445L, UNDERFLOW_EXCEPTION);
5438       TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
5439       TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
5440       TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
5441       TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
5442       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16383L, 0x1.0000000000000002p16383L);
5443       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16383L, 0x1p16383L);
5444       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16383L, -0x0.ffffffffffffffffp16383L);
5445       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16383L, -0x1p16383L);
5446       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16319L, 0x1.0000000000000002p16319L);
5447       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16319L, 0x1p16319L);
5448       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16319L, -0x0.ffffffffffffffffp16319L);
5449       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16319L, -0x1p16319L);
5450 #endif
5451 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 113
5452       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, 0x1p-16384L, 0x1.c000000000000000000000000004p-16383L, UNDERFLOW_EXCEPTION);
5453       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, -0x1p-16384L, -0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
5454       TEST_fff_f (fma, 0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, 0x1p-16494L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5455       TEST_fff_f (fma, -0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5456       TEST_fff_f (fma, 0x1p-16494L, 0x1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
5457       TEST_fff_f (fma, -0x1p-16494L, 0x1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5458       TEST_fff_f (fma, 0x1p-16494L, 0x1.1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5459       TEST_fff_f (fma, -0x1p-16494L, 0x1.1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5460       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p16383L, 0x1.0000000000000000000000000001p16383L);
5461       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p16383L, 0x1p16383L);
5462       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p16383L, -0x0.ffffffffffffffffffffffffffff8p16383L);
5463       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p16383L, -0x1p16383L);
5464       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16382L, 0x1.0000000000000000000000000001p-16382L);
5465       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5466       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5467       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16382L, -0x1p-16382L);
5468       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
5469       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5470       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.fffffffffffffffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5471       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5472       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, 0x1p-16493L, UNDERFLOW_EXCEPTION);
5473       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16494L, 0x1p-16494L, UNDERFLOW_EXCEPTION);
5474       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16494L, minus_zero, UNDERFLOW_EXCEPTION);
5475       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, -0x1p-16494L, UNDERFLOW_EXCEPTION);
5476       TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5477       TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5478       TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5479       TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5480       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1.0000000000000000000000000001p16383L);
5481       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1p16383L);
5482       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x0.ffffffffffffffffffffffffffff8p16383L);
5483       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1p16383L);
5484       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1.0000000000000000000000000001p16319L);
5485       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1p16319L);
5486       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x0.ffffffffffffffffffffffffffff8p16319L);
5487       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L);
5488 #endif
5489     }
5490
5491   fesetround (save_round_mode);
5492
5493   END (fma_upward);
5494 }
5495
5496
5497 static void
5498 fmax_test (void)
5499 {
5500   START (fmax);
5501
5502   TEST_ff_f (fmax, 0, 0, 0);
5503   TEST_ff_f (fmax, minus_zero, minus_zero, minus_zero);
5504   TEST_ff_f (fmax, 9, 0, 9);
5505   TEST_ff_f (fmax, 0, 9, 9);
5506   TEST_ff_f (fmax, -9, 0, 0);
5507   TEST_ff_f (fmax, 0, -9, 0);
5508
5509   TEST_ff_f (fmax, plus_infty, 9, plus_infty);
5510   TEST_ff_f (fmax, 0, plus_infty, plus_infty);
5511   TEST_ff_f (fmax, -9, plus_infty, plus_infty);
5512   TEST_ff_f (fmax, plus_infty, -9, plus_infty);
5513
5514   TEST_ff_f (fmax, minus_infty, 9, 9);
5515   TEST_ff_f (fmax, minus_infty, -9, -9);
5516   TEST_ff_f (fmax, 9, minus_infty, 9);
5517   TEST_ff_f (fmax, -9, minus_infty, -9);
5518
5519   TEST_ff_f (fmax, 0, nan_value, 0);
5520   TEST_ff_f (fmax, 9, nan_value, 9);
5521   TEST_ff_f (fmax, -9, nan_value, -9);
5522   TEST_ff_f (fmax, nan_value, 0, 0);
5523   TEST_ff_f (fmax, nan_value, 9, 9);
5524   TEST_ff_f (fmax, nan_value, -9, -9);
5525   TEST_ff_f (fmax, plus_infty, nan_value, plus_infty);
5526   TEST_ff_f (fmax, minus_infty, nan_value, minus_infty);
5527   TEST_ff_f (fmax, nan_value, plus_infty, plus_infty);
5528   TEST_ff_f (fmax, nan_value, minus_infty, minus_infty);
5529   TEST_ff_f (fmax, nan_value, nan_value, nan_value);
5530
5531   END (fmax);
5532 }
5533
5534
5535 static void
5536 fmin_test (void)
5537 {
5538   START (fmin);
5539
5540   TEST_ff_f (fmin, 0, 0, 0);
5541   TEST_ff_f (fmin, minus_zero, minus_zero, minus_zero);
5542   TEST_ff_f (fmin, 9, 0, 0);
5543   TEST_ff_f (fmin, 0, 9, 0);
5544   TEST_ff_f (fmin, -9, 0, -9);
5545   TEST_ff_f (fmin, 0, -9, -9);
5546
5547   TEST_ff_f (fmin, plus_infty, 9, 9);
5548   TEST_ff_f (fmin, 9, plus_infty, 9);
5549   TEST_ff_f (fmin, plus_infty, -9, -9);
5550   TEST_ff_f (fmin, -9, plus_infty, -9);
5551   TEST_ff_f (fmin, minus_infty, 9, minus_infty);
5552   TEST_ff_f (fmin, minus_infty, -9, minus_infty);
5553   TEST_ff_f (fmin, 9, minus_infty, minus_infty);
5554   TEST_ff_f (fmin, -9, minus_infty, minus_infty);
5555
5556   TEST_ff_f (fmin, 0, nan_value, 0);
5557   TEST_ff_f (fmin, 9, nan_value, 9);
5558   TEST_ff_f (fmin, -9, nan_value, -9);
5559   TEST_ff_f (fmin, nan_value, 0, 0);
5560   TEST_ff_f (fmin, nan_value, 9, 9);
5561   TEST_ff_f (fmin, nan_value, -9, -9);
5562   TEST_ff_f (fmin, plus_infty, nan_value, plus_infty);
5563   TEST_ff_f (fmin, minus_infty, nan_value, minus_infty);
5564   TEST_ff_f (fmin, nan_value, plus_infty, plus_infty);
5565   TEST_ff_f (fmin, nan_value, minus_infty, minus_infty);
5566   TEST_ff_f (fmin, nan_value, nan_value, nan_value);
5567
5568   END (fmin);
5569 }
5570
5571
5572 static void
5573 fmod_test (void)
5574 {
5575   errno = 0;
5576   FUNC(fmod) (6.5, 2.3L);
5577   if (errno == ENOSYS)
5578     /* Function not implemented.  */
5579     return;
5580
5581   START (fmod);
5582
5583   /* fmod (+0, y) == +0 for y != 0.  */
5584   TEST_ff_f (fmod, 0, 3, 0);
5585
5586   /* fmod (-0, y) == -0 for y != 0.  */
5587   TEST_ff_f (fmod, minus_zero, 3, minus_zero);
5588
5589   /* fmod (+inf, y) == NaN plus invalid exception.  */
5590   errno = 0;
5591   TEST_ff_f (fmod, plus_infty, 3, nan_value, INVALID_EXCEPTION);
5592   check_int ("errno for fmod(Inf,3) unchanged", errno, EDOM, 0, 0, 0);
5593   /* fmod (-inf, y) == NaN plus invalid exception.  */
5594   errno = 0;
5595   TEST_ff_f (fmod, minus_infty, 3, nan_value, INVALID_EXCEPTION);
5596   check_int ("errno for fmod(-Inf,3) unchanged", errno, EDOM, 0, 0, 0);
5597   /* fmod (x, +0) == NaN plus invalid exception.  */
5598   errno = 0;
5599   TEST_ff_f (fmod, 3, 0, nan_value, INVALID_EXCEPTION);
5600   check_int ("errno for fmod(3,0) unchanged", errno, EDOM, 0, 0, 0);
5601   /* fmod (x, -0) == NaN plus invalid exception.  */
5602   TEST_ff_f (fmod, 3, minus_zero, nan_value, INVALID_EXCEPTION);
5603
5604   /* fmod (x, +inf) == x for x not infinite.  */
5605   TEST_ff_f (fmod, 3.0, plus_infty, 3.0);
5606   /* fmod (x, -inf) == x for x not infinite.  */
5607   TEST_ff_f (fmod, 3.0, minus_infty, 3.0);
5608
5609   TEST_ff_f (fmod, nan_value, nan_value, nan_value);
5610
5611   TEST_ff_f (fmod, 6.5, 2.25L, 2.0L);
5612   TEST_ff_f (fmod, -6.5, 2.25L, -2.0L);
5613   TEST_ff_f (fmod, 6.5, -2.25L, 2.0L);
5614   TEST_ff_f (fmod, -6.5, -2.25L, -2.0L);
5615
5616   TEST_ff_f (fmod, 0x0.fffffep-126L, 0x1p-149L, plus_zero);
5617 #ifndef TEST_FLOAT
5618   TEST_ff_f (fmod, 0x0.fffffffffffffp-1022L, 0x1p-1074L, plus_zero);
5619 #endif
5620 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
5621   TEST_ff_f (fmod, 0x0.fffffffffffffffep-16382L, 0x1p-16445L, plus_zero);
5622 #endif
5623
5624   END (fmod);
5625 }
5626
5627
5628 static void
5629 fpclassify_test (void)
5630 {
5631   START (fpclassify);
5632
5633   TEST_f_i (fpclassify, nan_value, FP_NAN);
5634   TEST_f_i (fpclassify, plus_infty, FP_INFINITE);
5635   TEST_f_i (fpclassify, minus_infty, FP_INFINITE);
5636   TEST_f_i (fpclassify, plus_zero, FP_ZERO);
5637   TEST_f_i (fpclassify, minus_zero, FP_ZERO);
5638   TEST_f_i (fpclassify, 1000, FP_NORMAL);
5639   TEST_f_i (fpclassify, min_subnorm_value, FP_SUBNORMAL);
5640
5641   END (fpclassify);
5642 }
5643
5644
5645 static void
5646 frexp_test (void)
5647 {
5648   int x;
5649
5650   START (frexp);
5651
5652   TEST_fI_f1 (frexp, plus_infty, plus_infty, IGNORE);
5653   TEST_fI_f1 (frexp, minus_infty, minus_infty, IGNORE);
5654   TEST_fI_f1 (frexp, nan_value, nan_value, IGNORE);
5655
5656   TEST_fI_f1 (frexp, 0.0, 0.0, 0.0);
5657   TEST_fI_f1 (frexp, minus_zero, minus_zero, 0.0);
5658
5659   TEST_fI_f1 (frexp, 12.8L, 0.8L, 4);
5660   TEST_fI_f1 (frexp, -27.34L, -0.854375L, 5);
5661
5662   END (frexp);
5663 }
5664
5665
5666 static void
5667 gamma_test (void)
5668 {
5669   errno = 0;
5670   FUNC(gamma) (1);
5671
5672   if (errno == ENOSYS)
5673     /* Function not implemented.  */
5674     return;
5675
5676   START (gamma);
5677
5678   TEST_f_f (gamma, plus_infty, plus_infty);
5679   TEST_f_f (gamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5680   TEST_f_f (gamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5681   TEST_f_f (gamma, minus_infty, plus_infty);
5682   TEST_f_f (gamma, nan_value, nan_value);
5683
5684   TEST_f_f1 (gamma, 1, 0, 1);
5685   TEST_f_f1 (gamma, 3, M_LN2l, 1);
5686
5687   TEST_f_f1 (gamma, 0.5, M_LOG_SQRT_PIl, 1);
5688   TEST_f_f1 (gamma, -0.5, M_LOG_2_SQRT_PIl, -1);
5689
5690   END (gamma);
5691 }
5692
5693 static void
5694 hypot_test (void)
5695 {
5696   errno = 0;
5697   FUNC(hypot) (0.7L, 12.4L);
5698   if (errno == ENOSYS)
5699     /* Function not implemented.  */
5700     return;
5701
5702   START (hypot);
5703
5704   TEST_ff_f (hypot, plus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
5705   TEST_ff_f (hypot, minus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
5706
5707 #ifndef TEST_INLINE
5708   TEST_ff_f (hypot, plus_infty, nan_value, plus_infty);
5709   TEST_ff_f (hypot, minus_infty, nan_value, plus_infty);
5710   TEST_ff_f (hypot, nan_value, plus_infty, plus_infty);
5711   TEST_ff_f (hypot, nan_value, minus_infty, plus_infty);
5712 #endif
5713
5714   TEST_ff_f (hypot, nan_value, nan_value, nan_value);
5715
5716   /* hypot (x,y) == hypot (+-x, +-y)  */
5717   TEST_ff_f (hypot, 0.7L, 12.4L, 12.419742348374220601176836866763271L);
5718   TEST_ff_f (hypot, -0.7L, 12.4L, 12.419742348374220601176836866763271L);
5719   TEST_ff_f (hypot, 0.7L, -12.4L, 12.419742348374220601176836866763271L);
5720   TEST_ff_f (hypot, -0.7L, -12.4L, 12.419742348374220601176836866763271L);
5721   TEST_ff_f (hypot, 12.4L, 0.7L, 12.419742348374220601176836866763271L);
5722   TEST_ff_f (hypot, -12.4L, 0.7L, 12.419742348374220601176836866763271L);
5723   TEST_ff_f (hypot, 12.4L, -0.7L, 12.419742348374220601176836866763271L);
5724   TEST_ff_f (hypot, -12.4L, -0.7L, 12.419742348374220601176836866763271L);
5725
5726   /*  hypot (x,0) == fabs (x)  */
5727   TEST_ff_f (hypot, 0.75L, 0, 0.75L);
5728   TEST_ff_f (hypot, -0.75L, 0, 0.75L);
5729   TEST_ff_f (hypot, -5.7e7, 0, 5.7e7L);
5730
5731   TEST_ff_f (hypot, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
5732
5733 #if !(defined TEST_FLOAT && defined TEST_INLINE)
5734   TEST_ff_f (hypot, 0x3p125L, 0x4p125L, 0x5p125L);
5735   TEST_ff_f (hypot, 0x1.234566p-126L, 0x1.234566p-126L, 1.891441686191081936598531534017449451173e-38L);
5736 #endif
5737
5738 #if !defined TEST_FLOAT && !(defined TEST_DOUBLE && defined TEST_INLINE)
5739   TEST_ff_f (hypot, 0x3p1021L, 0x4p1021L, 0x5p1021L);
5740 #endif
5741
5742 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384 && !defined TEST_INLINE
5743   TEST_ff_f (hypot, 0x3p16381L, 0x4p16381L, 0x5p16381L);
5744 #endif
5745
5746   END (hypot);
5747 }
5748
5749
5750 static void
5751 ilogb_test (void)
5752 {
5753   START (ilogb);
5754
5755   TEST_f_i (ilogb, 1, 0);
5756   TEST_f_i (ilogb, M_El, 1);
5757   TEST_f_i (ilogb, 1024, 10);
5758   TEST_f_i (ilogb, -2000, 10);
5759
5760   /* ilogb (0.0) == FP_ILOGB0 plus invalid exception  */
5761   errno = 0;
5762   TEST_f_i (ilogb, 0.0, FP_ILOGB0, INVALID_EXCEPTION);
5763   check_int ("errno for ilogb(0.0) unchanged", errno, EDOM, 0, 0, 0);
5764   /* ilogb (NaN) == FP_ILOGBNAN plus invalid exception  */
5765   errno = 0;
5766   TEST_f_i (ilogb, nan_value, FP_ILOGBNAN, INVALID_EXCEPTION);
5767   check_int ("errno for ilogb(NaN) unchanged", errno, EDOM, 0, 0, 0);
5768   /* ilogb (inf) == INT_MAX plus invalid exception  */
5769   errno = 0;
5770   TEST_f_i (ilogb, plus_infty, INT_MAX, INVALID_EXCEPTION);
5771   check_int ("errno for ilogb(Inf) unchanged", errno, EDOM, 0, 0, 0);
5772   /* ilogb (-inf) == INT_MAX plus invalid exception  */
5773   errno = 0;
5774   TEST_f_i (ilogb, minus_infty, INT_MAX, INVALID_EXCEPTION);
5775   check_int ("errno for ilogb(-Inf) unchanged", errno, EDOM, 0, 0, 0);
5776
5777   END (ilogb);
5778 }
5779
5780 static void
5781 isfinite_test (void)
5782 {
5783   START (isfinite);
5784
5785   TEST_f_b (isfinite, 0, 1);
5786   TEST_f_b (isfinite, minus_zero, 1);
5787   TEST_f_b (isfinite, 10, 1);
5788   TEST_f_b (isfinite, min_subnorm_value, 1);
5789   TEST_f_b (isfinite, plus_infty, 0);
5790   TEST_f_b (isfinite, minus_infty, 0);
5791   TEST_f_b (isfinite, nan_value, 0);
5792
5793   END (isfinite);
5794 }
5795
5796 static void
5797 isgreater_test (void)
5798 {
5799   START (isgreater);
5800
5801   TEST_ff_i (isgreater, minus_zero, minus_zero, 0);
5802   TEST_ff_i (isgreater, minus_zero, plus_zero, 0);
5803   TEST_ff_i (isgreater, minus_zero, (FLOAT) 1, 0);
5804   TEST_ff_i (isgreater, minus_zero, nan_value, 0);
5805   TEST_ff_i (isgreater, plus_zero, minus_zero, 0);
5806   TEST_ff_i (isgreater, plus_zero, plus_zero, 0);
5807   TEST_ff_i (isgreater, plus_zero, (FLOAT) 1, 0);
5808   TEST_ff_i (isgreater, plus_zero, nan_value, 0);
5809   TEST_ff_i (isgreater, (FLOAT) 1, minus_zero, 1);
5810   TEST_ff_i (isgreater, (FLOAT) 1, plus_zero, 1);
5811   TEST_ff_i (isgreater, (FLOAT) 1, (FLOAT) 1, 0);
5812   TEST_ff_i (isgreater, (FLOAT) 1, nan_value, 0);
5813   TEST_ff_i (isgreater, nan_value, minus_zero, 0);
5814   TEST_ff_i (isgreater, nan_value, plus_zero, 0);
5815   TEST_ff_i (isgreater, nan_value, (FLOAT) 1, 0);
5816   TEST_ff_i (isgreater, nan_value, nan_value, 0);
5817
5818   END (isgreater);
5819 }
5820
5821 static void
5822 isgreaterequal_test (void)
5823 {
5824   START (isgreaterequal);
5825
5826   TEST_ff_i (isgreaterequal, minus_zero, minus_zero, 1);
5827   TEST_ff_i (isgreaterequal, minus_zero, plus_zero, 1);
5828   TEST_ff_i (isgreaterequal, minus_zero, (FLOAT) 1, 0);
5829   TEST_ff_i (isgreaterequal, minus_zero, nan_value, 0);
5830   TEST_ff_i (isgreaterequal, plus_zero, minus_zero, 1);
5831   TEST_ff_i (isgreaterequal, plus_zero, plus_zero, 1);
5832   TEST_ff_i (isgreaterequal, plus_zero, (FLOAT) 1, 0);
5833   TEST_ff_i (isgreaterequal, plus_zero, nan_value, 0);
5834   TEST_ff_i (isgreaterequal, (FLOAT) 1, minus_zero, 1);
5835   TEST_ff_i (isgreaterequal, (FLOAT) 1, plus_zero, 1);
5836   TEST_ff_i (isgreaterequal, (FLOAT) 1, (FLOAT) 1, 1);
5837   TEST_ff_i (isgreaterequal, (FLOAT) 1, nan_value, 0);
5838   TEST_ff_i (isgreaterequal, nan_value, minus_zero, 0);
5839   TEST_ff_i (isgreaterequal, nan_value, plus_zero, 0);
5840   TEST_ff_i (isgreaterequal, nan_value, (FLOAT) 1, 0);
5841   TEST_ff_i (isgreaterequal, nan_value, nan_value, 0);
5842
5843   END (isgreaterequal);
5844 }
5845
5846 static void
5847 isinf_test (void)
5848 {
5849   START (isinf);
5850
5851   TEST_f_b (isinf, 0, 0);
5852   TEST_f_b (isinf, minus_zero, 0);
5853   TEST_f_b (isinf, 10, 0);
5854   TEST_f_b (isinf, min_subnorm_value, 0);
5855   TEST_f_b (isinf, plus_infty, 1);
5856   TEST_f_b (isinf, minus_infty, 1);
5857   TEST_f_b (isinf, nan_value, 0);
5858
5859   END (isinf);
5860 }
5861
5862 static void
5863 isless_test (void)
5864 {
5865   START (isless);
5866
5867   TEST_ff_i (isless, minus_zero, minus_zero, 0);
5868   TEST_ff_i (isless, minus_zero, plus_zero, 0);
5869   TEST_ff_i (isless, minus_zero, (FLOAT) 1, 1);
5870   TEST_ff_i (isless, minus_zero, nan_value, 0);
5871   TEST_ff_i (isless, plus_zero, minus_zero, 0);
5872   TEST_ff_i (isless, plus_zero, plus_zero, 0);
5873   TEST_ff_i (isless, plus_zero, (FLOAT) 1, 1);
5874   TEST_ff_i (isless, plus_zero, nan_value, 0);
5875   TEST_ff_i (isless, (FLOAT) 1, minus_zero, 0);
5876   TEST_ff_i (isless, (FLOAT) 1, plus_zero, 0);
5877   TEST_ff_i (isless, (FLOAT) 1, (FLOAT) 1, 0);
5878   TEST_ff_i (isless, (FLOAT) 1, nan_value, 0);
5879   TEST_ff_i (isless, nan_value, minus_zero, 0);
5880   TEST_ff_i (isless, nan_value, plus_zero, 0);
5881   TEST_ff_i (isless, nan_value, (FLOAT) 1, 0);
5882   TEST_ff_i (isless, nan_value, nan_value, 0);
5883
5884   END (isless);
5885 }
5886
5887 static void
5888 islessequal_test (void)
5889 {
5890   START (islessequal);
5891
5892   TEST_ff_i (islessequal, minus_zero, minus_zero, 1);
5893   TEST_ff_i (islessequal, minus_zero, plus_zero, 1);
5894   TEST_ff_i (islessequal, minus_zero, (FLOAT) 1, 1);
5895   TEST_ff_i (islessequal, minus_zero, nan_value, 0);
5896   TEST_ff_i (islessequal, plus_zero, minus_zero, 1);
5897   TEST_ff_i (islessequal, plus_zero, plus_zero, 1);
5898   TEST_ff_i (islessequal, plus_zero, (FLOAT) 1, 1);
5899   TEST_ff_i (islessequal, plus_zero, nan_value, 0);
5900   TEST_ff_i (islessequal, (FLOAT) 1, minus_zero, 0);
5901   TEST_ff_i (islessequal, (FLOAT) 1, plus_zero, 0);
5902   TEST_ff_i (islessequal, (FLOAT) 1, (FLOAT) 1, 1);
5903   TEST_ff_i (islessequal, (FLOAT) 1, nan_value, 0);
5904   TEST_ff_i (islessequal, nan_value, minus_zero, 0);
5905   TEST_ff_i (islessequal, nan_value, plus_zero, 0);
5906   TEST_ff_i (islessequal, nan_value, (FLOAT) 1, 0);
5907   TEST_ff_i (islessequal, nan_value, nan_value, 0);
5908
5909   END (islessequal);
5910 }
5911
5912 static void
5913 islessgreater_test (void)
5914 {
5915   START (islessgreater);
5916
5917   TEST_ff_i (islessgreater, minus_zero, minus_zero, 0);
5918   TEST_ff_i (islessgreater, minus_zero, plus_zero, 0);
5919   TEST_ff_i (islessgreater, minus_zero, (FLOAT) 1, 1);
5920   TEST_ff_i (islessgreater, minus_zero, nan_value, 0);
5921   TEST_ff_i (islessgreater, plus_zero, minus_zero, 0);
5922   TEST_ff_i (islessgreater, plus_zero, plus_zero, 0);
5923   TEST_ff_i (islessgreater, plus_zero, (FLOAT) 1, 1);
5924   TEST_ff_i (islessgreater, plus_zero, nan_value, 0);
5925   TEST_ff_i (islessgreater, (FLOAT) 1, minus_zero, 1);
5926   TEST_ff_i (islessgreater, (FLOAT) 1, plus_zero, 1);
5927   TEST_ff_i (islessgreater, (FLOAT) 1, (FLOAT) 1, 0);
5928   TEST_ff_i (islessgreater, (FLOAT) 1, nan_value, 0);
5929   TEST_ff_i (islessgreater, nan_value, minus_zero, 0);
5930   TEST_ff_i (islessgreater, nan_value, plus_zero, 0);
5931   TEST_ff_i (islessgreater, nan_value, (FLOAT) 1, 0);
5932   TEST_ff_i (islessgreater, nan_value, nan_value, 0);
5933
5934   END (islessgreater);
5935 }
5936
5937 static void
5938 isnan_test (void)
5939 {
5940   START (isnan);
5941
5942   TEST_f_b (isnan, 0, 0);
5943   TEST_f_b (isnan, minus_zero, 0);
5944   TEST_f_b (isnan, 10, 0);
5945   TEST_f_b (isnan, min_subnorm_value, 0);
5946   TEST_f_b (isnan, plus_infty, 0);
5947   TEST_f_b (isnan, minus_infty, 0);
5948   TEST_f_b (isnan, nan_value, 1);
5949
5950   END (isnan);
5951 }
5952
5953 static void
5954 isnormal_test (void)
5955 {
5956   START (isnormal);
5957
5958   TEST_f_b (isnormal, 0, 0);
5959   TEST_f_b (isnormal, minus_zero, 0);
5960   TEST_f_b (isnormal, 10, 1);
5961   TEST_f_b (isnormal, min_subnorm_value, 0);
5962   TEST_f_b (isnormal, plus_infty, 0);
5963   TEST_f_b (isnormal, minus_infty, 0);
5964   TEST_f_b (isnormal, nan_value, 0);
5965
5966   END (isnormal);
5967 }
5968
5969 static void
5970 isunordered_test (void)
5971 {
5972   START (isunordered);
5973
5974   TEST_ff_i (isunordered, minus_zero, minus_zero, 0);
5975   TEST_ff_i (isunordered, minus_zero, plus_zero, 0);
5976   TEST_ff_i (isunordered, minus_zero, (FLOAT) 1, 0);
5977   TEST_ff_i (isunordered, minus_zero, nan_value, 1);
5978   TEST_ff_i (isunordered, plus_zero, minus_zero, 0);
5979   TEST_ff_i (isunordered, plus_zero, plus_zero, 0);
5980   TEST_ff_i (isunordered, plus_zero, (FLOAT) 1, 0);
5981   TEST_ff_i (isunordered, plus_zero, nan_value, 1);
5982   TEST_ff_i (isunordered, (FLOAT) 1, minus_zero, 0);
5983   TEST_ff_i (isunordered, (FLOAT) 1, plus_zero, 0);
5984   TEST_ff_i (isunordered, (FLOAT) 1, (FLOAT) 1, 0);
5985   TEST_ff_i (isunordered, (FLOAT) 1, nan_value, 1);
5986   TEST_ff_i (isunordered, nan_value, minus_zero, 1);
5987   TEST_ff_i (isunordered, nan_value, plus_zero, 1);
5988   TEST_ff_i (isunordered, nan_value, (FLOAT) 1, 1);
5989   TEST_ff_i (isunordered, nan_value, nan_value, 1);
5990
5991   END (isunordered);
5992 }
5993
5994 static void
5995 j0_test (void)
5996 {
5997   FLOAT s, c;
5998   errno = 0;
5999   FUNC (sincos) (0, &s, &c);
6000   if (errno == ENOSYS)
6001     /* Required function not implemented.  */
6002     return;
6003   FUNC(j0) (0);
6004   if (errno == ENOSYS)
6005     /* Function not implemented.  */
6006     return;
6007
6008   START (j0);
6009
6010   /* j0 is the Bessel function of the first kind of order 0 */
6011   TEST_f_f (j0, nan_value, nan_value);
6012   TEST_f_f (j0, plus_infty, 0);
6013   TEST_f_f (j0, -1.0, 0.765197686557966551449717526102663221L);
6014   TEST_f_f (j0, 0.0, 1.0);
6015   TEST_f_f (j0, 0.125L, 0.996097563041985204620768999453174712L);
6016   TEST_f_f (j0, 0.75L, 0.864242275166648623555731103820923211L);
6017   TEST_f_f (j0, 1.0, 0.765197686557966551449717526102663221L);
6018   TEST_f_f (j0, 1.5, 0.511827671735918128749051744283411720L);
6019   TEST_f_f (j0, 2.0, 0.223890779141235668051827454649948626L);
6020   TEST_f_f (j0, 8.0, 0.171650807137553906090869407851972001L);
6021   TEST_f_f (j0, 10.0, -0.245935764451348335197760862485328754L);
6022   TEST_f_f (j0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
6023   TEST_f_f (j0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
6024
6025   /* Bug 14155: spurious exception may occur.  */
6026   TEST_f_f (j0, 0x1.d7ce3ap+107L, 2.775523647291230802651040996274861694514e-17L, UNDERFLOW_EXCEPTION_OK);
6027
6028 #ifndef TEST_FLOAT
6029   /* Bug 14155: spurious exception may occur.  */
6030   TEST_f_f (j0, -0x1.001000001p+593L, -3.927269966354206207832593635798954916263e-90L, UNDERFLOW_EXCEPTION_OK);
6031 #endif
6032
6033   END (j0);
6034 }
6035
6036
6037 static void
6038 j1_test (void)
6039 {
6040   FLOAT s, c;
6041   errno = 0;
6042   FUNC (sincos) (0, &s, &c);
6043   if (errno == ENOSYS)
6044     /* Required function not implemented.  */
6045     return;
6046   FUNC(j1) (0);
6047   if (errno == ENOSYS)
6048     /* Function not implemented.  */
6049     return;
6050
6051   /* j1 is the Bessel function of the first kind of order 1 */
6052
6053   START (j1);
6054
6055   TEST_f_f (j1, nan_value, nan_value);
6056   TEST_f_f (j1, plus_infty, 0);
6057
6058   TEST_f_f (j1, -1.0, -0.440050585744933515959682203718914913L);
6059   TEST_f_f (j1, 0.0, 0.0);
6060   TEST_f_f (j1, 0.125L, 0.0623780091344946810942311355879361177L);
6061   TEST_f_f (j1, 0.75L, 0.349243602174862192523281016426251335L);
6062   TEST_f_f (j1, 1.0, 0.440050585744933515959682203718914913L);
6063   TEST_f_f (j1, 1.5, 0.557936507910099641990121213156089400L);
6064   TEST_f_f (j1, 2.0, 0.576724807756873387202448242269137087L);
6065   TEST_f_f (j1, 8.0, 0.234636346853914624381276651590454612L);
6066   TEST_f_f (j1, 10.0, 0.0434727461688614366697487680258592883L);
6067
6068   TEST_f_f (j1, 0x1.3ffp+74L, 1.818984347516051243459364437186082741567e-12L);
6069
6070 #ifndef TEST_FLOAT
6071   /* Bug 14155: spurious exception may occur.  */
6072   TEST_f_f (j1, 0x1.ff00000000002p+840L, 1.846591691699331493194965158699937660696e-127L, UNDERFLOW_EXCEPTION_OK);
6073 #endif
6074
6075   END (j1);
6076 }
6077
6078 static void
6079 jn_test (void)
6080 {
6081   FLOAT s, c;
6082   errno = 0;
6083   FUNC (sincos) (0, &s, &c);
6084   if (errno == ENOSYS)
6085     /* Required function not implemented.  */
6086     return;
6087   FUNC(jn) (1, 1);
6088   if (errno == ENOSYS)
6089     /* Function not implemented.  */
6090     return;
6091
6092   /* jn is the Bessel function of the first kind of order n.  */
6093   START (jn);
6094
6095   /* jn (0, x) == j0 (x)  */
6096   TEST_ff_f (jn, 0, nan_value, nan_value);
6097   TEST_ff_f (jn, 0, plus_infty, 0);
6098   TEST_ff_f (jn, 0, -1.0, 0.765197686557966551449717526102663221L);
6099   TEST_ff_f (jn, 0, 0.0, 1.0);
6100   TEST_ff_f (jn, 0, 0.125L, 0.996097563041985204620768999453174712L);
6101   TEST_ff_f (jn, 0, 0.75L, 0.864242275166648623555731103820923211L);
6102   TEST_ff_f (jn, 0, 1.0, 0.765197686557966551449717526102663221L);
6103   TEST_ff_f (jn, 0, 1.5, 0.511827671735918128749051744283411720L);
6104   TEST_ff_f (jn, 0, 2.0, 0.223890779141235668051827454649948626L);
6105   TEST_ff_f (jn, 0, 8.0, 0.171650807137553906090869407851972001L);
6106   TEST_ff_f (jn, 0, 10.0, -0.245935764451348335197760862485328754L);
6107   TEST_ff_f (jn, 0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
6108   TEST_ff_f (jn, 0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
6109
6110   /* jn (1, x) == j1 (x)  */
6111   TEST_ff_f (jn, 1, nan_value, nan_value);
6112   TEST_ff_f (jn, 1, plus_infty, 0);
6113   TEST_ff_f (jn, 1, -1.0, -0.440050585744933515959682203718914913L);
6114   TEST_ff_f (jn, 1, 0.0, 0.0);
6115   TEST_ff_f (jn, 1, 0.125L, 0.0623780091344946810942311355879361177L);
6116   TEST_ff_f (jn, 1, 0.75L, 0.349243602174862192523281016426251335L);
6117   TEST_ff_f (jn, 1, 1.0, 0.440050585744933515959682203718914913L);
6118   TEST_ff_f (jn, 1, 1.5, 0.557936507910099641990121213156089400L);
6119   TEST_ff_f (jn, 1, 2.0, 0.576724807756873387202448242269137087L);
6120   TEST_ff_f (jn, 1, 8.0, 0.234636346853914624381276651590454612L);
6121   TEST_ff_f (jn, 1, 10.0, 0.0434727461688614366697487680258592883L);
6122
6123   /* jn (3, x)  */
6124   TEST_ff_f (jn, 3, nan_value, nan_value);
6125   TEST_ff_f (jn, 3, plus_infty, 0);
6126
6127   TEST_ff_f (jn, 3, -1.0, -0.0195633539826684059189053216217515083L);
6128   TEST_ff_f (jn, 3, 0.0, 0.0);
6129   TEST_ff_f (jn, 3, 0.125L, 0.406503832554912875023029337653442868e-4L);
6130   TEST_ff_f (jn, 3, 0.75L, 0.848438342327410884392755236884386804e-2L);
6131   TEST_ff_f (jn, 3, 1.0, 0.0195633539826684059189053216217515083L);
6132   TEST_ff_f (jn, 3, 2.0, 0.128943249474402051098793332969239835L);
6133   TEST_ff_f (jn, 3, 10.0, 0.0583793793051868123429354784103409563L);
6134
6135   /*  jn (10, x)  */
6136   TEST_ff_f (jn, 10, nan_value, nan_value);
6137   TEST_ff_f (jn, 10, plus_infty, 0);
6138
6139   TEST_ff_f (jn, 10, -1.0, 0.263061512368745320699785368779050294e-9L);
6140   TEST_ff_f (jn, 10, 0.0, 0.0);
6141   TEST_ff_f (jn, 10, 0.125L, 0.250543369809369890173993791865771547e-18L);
6142   TEST_ff_f (jn, 10, 0.75L, 0.149621713117596814698712483621682835e-10L);
6143   TEST_ff_f (jn, 10, 1.0, 0.263061512368745320699785368779050294e-9L);
6144   TEST_ff_f (jn, 10, 2.0, 0.251538628271673670963516093751820639e-6L);
6145   TEST_ff_f (jn, 10, 10.0, 0.207486106633358857697278723518753428L);
6146
6147   /* BZ #11589 .*/
6148   TEST_ff_f (jn, 2, 2.4048255576957729L, 0.43175480701968038399746111312430703L);
6149   TEST_ff_f (jn, 3, 2.4048255576957729L, 0.19899990535769083404042146764530813L);
6150   TEST_ff_f (jn, 4, 2.4048255576957729L, 0.647466661641779720084932282551219891E-1L);
6151   TEST_ff_f (jn, 5, 2.4048255576957729L, 0.163892432048058525099230549946147698E-1L);
6152   TEST_ff_f (jn, 6, 2.4048255576957729L, 0.34048184720278336646673682895929161E-2L);
6153   TEST_ff_f (jn, 7, 2.4048255576957729L, 0.60068836573295394221291569249883076E-3L);
6154   TEST_ff_f (jn, 8, 2.4048255576957729L, 0.92165786705344923232879022467054148E-4L);
6155   TEST_ff_f (jn, 9, 2.4048255576957729L, 0.12517270977961513005428966643852564E-4L);
6156
6157   /* Bug 14155: spurious exception may occur.  */
6158   TEST_ff_f (jn, 2, 0x1.ffff62p+99L, -4.43860668048170034334926693188979974489e-16L, UNDERFLOW_EXCEPTION_OK);
6159
6160   END (jn);
6161 }
6162
6163
6164 static void
6165 ldexp_test (void)
6166 {
6167   TEST_ff_f (ldexp, 0, 0, 0);
6168   TEST_ff_f (ldexp, minus_zero, 0, minus_zero);
6169
6170   TEST_ff_f (ldexp, plus_infty, 1, plus_infty);
6171   TEST_ff_f (ldexp, minus_infty, 1, minus_infty);
6172   TEST_ff_f (ldexp, nan_value, 1, nan_value);
6173
6174   TEST_ff_f (ldexp, 0.8L, 4, 12.8L);
6175   TEST_ff_f (ldexp, -0.854375L, 5, -27.34L);
6176
6177   /* ldexp (x, 0) == x.  */
6178   TEST_ff_f (ldexp, 1.0L, 0L, 1.0L);
6179 }
6180
6181
6182 static void
6183 lgamma_test (void)
6184 {
6185   errno = 0;
6186   FUNC(lgamma) (0);
6187   if (errno == ENOSYS)
6188     /* Function not implemented.  */
6189     return;
6190
6191   START (lgamma);
6192
6193   TEST_f_f (lgamma, plus_infty, plus_infty);
6194   TEST_f_f (lgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6195   check_int ("signgam for lgamma(0) == 1", signgam, 1, 0, 0, 0);
6196   TEST_f_f (lgamma, minus_zero, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6197   check_int ("signgam for lgamma(-0) == -1", signgam, -1, 0, 0, 0);
6198   TEST_f_f (lgamma, nan_value, nan_value);
6199
6200   /* lgamma (x) == +inf plus divide by zero exception for integer x <= 0.  */
6201   errno = 0;
6202   TEST_f_f (lgamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6203   check_int ("errno for lgamma(-integer) == ERANGE", errno, ERANGE, 0, 0, 0);
6204   TEST_f_f (lgamma, minus_infty, plus_infty);
6205   TEST_f_f (lgamma, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6206   TEST_f_f (lgamma, max_value, plus_infty, OVERFLOW_EXCEPTION);
6207
6208   TEST_f_f1 (lgamma, 1, 0, 1);
6209
6210   TEST_f_f1 (lgamma, 3, M_LN2l, 1);
6211
6212   TEST_f_f1 (lgamma, 0.5, M_LOG_SQRT_PIl, 1);
6213   TEST_f_f1 (lgamma, -0.5, M_LOG_2_SQRT_PIl, -1);
6214   TEST_f_f1 (lgamma, 0.7L, 0.260867246531666514385732417016759578L, 1);
6215   TEST_f_f1 (lgamma, 1.2L, -0.853740900033158497197028392998854470e-1L, 1);
6216
6217   END (lgamma);
6218 }
6219
6220
6221 static void
6222 lrint_test (void)
6223 {
6224   /* XXX this test is incomplete.  We need to have a way to specifiy
6225      the rounding method and test the critical cases.  So far, only
6226      unproblematic numbers are tested.  */
6227
6228   START (lrint);
6229
6230   TEST_f_l (lrint, 0.0, 0);
6231   TEST_f_l (lrint, minus_zero, 0);
6232   TEST_f_l (lrint, 0.2L, 0);
6233   TEST_f_l (lrint, -0.2L, 0);
6234
6235   TEST_f_l (lrint, 1.4L, 1);
6236   TEST_f_l (lrint, -1.4L, -1);
6237
6238   TEST_f_l (lrint, 8388600.3L, 8388600);
6239   TEST_f_l (lrint, -8388600.3L, -8388600);
6240
6241   TEST_f_l (lrint, 1071930.0008, 1071930);
6242 #ifndef TEST_FLOAT
6243   TEST_f_l (lrint, 1073741824.01, 1073741824);
6244 # if LONG_MAX > 281474976710656
6245   TEST_f_l (lrint, 281474976710656.025, 281474976710656);
6246 # endif
6247 #endif
6248
6249   END (lrint);
6250 }
6251
6252
6253 static void
6254 lrint_test_tonearest (void)
6255 {
6256   int save_round_mode;
6257   START (lrint_tonearest);
6258
6259   save_round_mode = fegetround ();
6260
6261   if (!fesetround (FE_TONEAREST))
6262     {
6263       TEST_f_l (lrint, 0.0, 0);
6264       TEST_f_l (lrint, minus_zero, 0);
6265       TEST_f_l (lrint, 0.2L, 0);
6266       TEST_f_l (lrint, -0.2L, 0);
6267       TEST_f_l (lrint, 0.5L, 0);
6268       TEST_f_l (lrint, -0.5L, 0);
6269       TEST_f_l (lrint, 0.8L, 1);
6270       TEST_f_l (lrint, -0.8L, -1);
6271
6272       TEST_f_l (lrint, 1.4L, 1);
6273       TEST_f_l (lrint, -1.4L, -1);
6274
6275       TEST_f_l (lrint, 8388600.3L, 8388600);
6276       TEST_f_l (lrint, -8388600.3L, -8388600);
6277
6278       TEST_f_l (lrint, 1071930.0008, 1071930);
6279 #ifndef TEST_FLOAT
6280       TEST_f_l (lrint, 1073741824.01, 1073741824);
6281 # if LONG_MAX > 281474976710656
6282       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
6283 # endif
6284 #endif
6285     }
6286
6287   fesetround (save_round_mode);
6288
6289   END (lrint_tonearest);
6290 }
6291
6292
6293 static void
6294 lrint_test_towardzero (void)
6295 {
6296   int save_round_mode;
6297   START (lrint_towardzero);
6298
6299   save_round_mode = fegetround ();
6300
6301   if (!fesetround (FE_TOWARDZERO))
6302     {
6303       TEST_f_l (lrint, 0.0, 0);
6304       TEST_f_l (lrint, minus_zero, 0);
6305       TEST_f_l (lrint, 0.2L, 0);
6306       TEST_f_l (lrint, -0.2L, 0);
6307       TEST_f_l (lrint, 0.5L, 0);
6308       TEST_f_l (lrint, -0.5L, 0);
6309       TEST_f_l (lrint, 0.8L, 0);
6310       TEST_f_l (lrint, -0.8L, 0);
6311
6312       TEST_f_l (lrint, 1.4L, 1);
6313       TEST_f_l (lrint, -1.4L, -1);
6314
6315       TEST_f_l (lrint, 8388600.3L, 8388600);
6316       TEST_f_l (lrint, -8388600.3L, -8388600);
6317
6318       TEST_f_l (lrint, 1071930.0008, 1071930);
6319 #ifndef TEST_FLOAT
6320       TEST_f_l (lrint, 1073741824.01, 1073741824);
6321 # if LONG_MAX > 281474976710656
6322       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
6323 # endif
6324 #endif
6325     }
6326
6327   fesetround (save_round_mode);
6328
6329   END (lrint_towardzero);
6330 }
6331
6332
6333 static void
6334 lrint_test_downward (void)
6335 {
6336   int save_round_mode;
6337   START (lrint_downward);
6338
6339   save_round_mode = fegetround ();
6340
6341   if (!fesetround (FE_DOWNWARD))
6342     {
6343       TEST_f_l (lrint, 0.0, 0);
6344       TEST_f_l (lrint, minus_zero, 0);
6345       TEST_f_l (lrint, 0.2L, 0);
6346       TEST_f_l (lrint, -0.2L, -1);
6347       TEST_f_l (lrint, 0.5L, 0);
6348       TEST_f_l (lrint, -0.5L, -1);
6349       TEST_f_l (lrint, 0.8L, 0);
6350       TEST_f_l (lrint, -0.8L, -1);
6351
6352       TEST_f_l (lrint, 1.4L, 1);
6353       TEST_f_l (lrint, -1.4L, -2);
6354
6355       TEST_f_l (lrint, 8388600.3L, 8388600);
6356       TEST_f_l (lrint, -8388600.3L, -8388601);
6357
6358       TEST_f_l (lrint, 1071930.0008, 1071930);
6359 #ifndef TEST_FLOAT
6360       TEST_f_l (lrint, 1073741824.01, 1073741824);
6361 # if LONG_MAX > 281474976710656
6362       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
6363 # endif
6364 #endif
6365     }
6366
6367   fesetround (save_round_mode);
6368
6369   END (lrint_downward);
6370 }
6371
6372
6373 static void
6374 lrint_test_upward (void)
6375 {
6376   int save_round_mode;
6377   START (lrint_upward);
6378
6379   save_round_mode = fegetround ();
6380
6381   if (!fesetround (FE_UPWARD))
6382     {
6383       TEST_f_l (lrint, 0.0, 0);
6384       TEST_f_l (lrint, minus_zero, 0);
6385       TEST_f_l (lrint, 0.2L, 1);
6386       TEST_f_l (lrint, -0.2L, 0);
6387       TEST_f_l (lrint, 0.5L, 1);
6388       TEST_f_l (lrint, -0.5L, 0);
6389       TEST_f_l (lrint, 0.8L, 1);
6390       TEST_f_l (lrint, -0.8L, 0);
6391
6392       TEST_f_l (lrint, 1.4L, 2);
6393       TEST_f_l (lrint, -1.4L, -1);
6394
6395       TEST_f_l (lrint, 8388600.3L, 8388601);
6396       TEST_f_l (lrint, -8388600.3L, -8388600);
6397
6398 #ifndef TEST_FLOAT
6399       TEST_f_l (lrint, 1071930.0008, 1071931);
6400       TEST_f_l (lrint, 1073741824.01, 1073741825);
6401 # if LONG_MAX > 281474976710656 && defined (TEST_LDOUBLE)
6402       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
6403 # endif
6404 #endif
6405     }
6406
6407   fesetround (save_round_mode);
6408
6409   END (lrint_upward);
6410 }
6411
6412
6413 static void
6414 llrint_test (void)
6415 {
6416   /* XXX this test is incomplete.  We need to have a way to specifiy
6417      the rounding method and test the critical cases.  So far, only
6418      unproblematic numbers are tested.  */
6419
6420   START (llrint);
6421
6422   TEST_f_L (llrint, 0.0, 0);
6423   TEST_f_L (llrint, minus_zero, 0);
6424   TEST_f_L (llrint, 0.2L, 0);
6425   TEST_f_L (llrint, -0.2L, 0);
6426
6427   TEST_f_L (llrint, 1.4L, 1);
6428   TEST_f_L (llrint, -1.4L, -1);
6429
6430   TEST_f_L (llrint, 8388600.3L, 8388600);
6431   TEST_f_L (llrint, -8388600.3L, -8388600);
6432
6433   TEST_f_l (llrint, 1071930.0008, 1071930);
6434
6435   /* Test boundary conditions.  */
6436   /* 0x1FFFFF */
6437   TEST_f_L (llrint, 2097151.0,2097151LL);
6438   /* 0x800000 */
6439   TEST_f_L (llrint, 8388608.0, 8388608LL);
6440   /* 0x1000000 */
6441   TEST_f_L (llrint, 16777216.0, 16777216LL);
6442   /* 0x20000000000 */
6443   TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
6444   /* 0x40000000000 */
6445   TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
6446   /* 0x1000000000000 */
6447   TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
6448   /* 0x10000000000000 */
6449   TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
6450   /* 0x10000080000000 */
6451   TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
6452   /* 0x20000000000000 */
6453   TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
6454   /* 0x80000000000000 */
6455   TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
6456   /* 0x100000000000000 */
6457   TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
6458 #ifdef TEST_LDOUBLE
6459   /* The input can only be represented in long double.  */
6460   TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
6461   TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
6462   TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
6463   TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
6464   TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
6465
6466   TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
6467   TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
6468   TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
6469   TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
6470   TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
6471
6472 # if LDBL_MANT_DIG > 100
6473   TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
6474   TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
6475   TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
6476   TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
6477   TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
6478   TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
6479
6480   TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
6481   TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
6482   TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
6483   TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
6484   TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
6485   TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
6486 #endif
6487
6488   TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
6489   TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
6490   TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
6491   TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
6492   TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
6493
6494   TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
6495   TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
6496   TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
6497   TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
6498   TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
6499
6500 # if LDBL_MANT_DIG > 100
6501   TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
6502   TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
6503   TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
6504   TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
6505   TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
6506   TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
6507
6508   TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
6509   TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
6510   TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
6511   TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
6512   TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
6513   TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
6514 #endif
6515
6516   TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
6517   TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
6518   TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
6519   TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
6520   TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
6521
6522   TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
6523   TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
6524   TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
6525   TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
6526   TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
6527
6528 # if LDBL_MANT_DIG > 100
6529   TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
6530   TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
6531   TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
6532   TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
6533   TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
6534   TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
6535   TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
6536   TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
6537   TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
6538   TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
6539   TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
6540   TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
6541 # endif
6542 #endif
6543
6544   END (llrint);
6545 }
6546
6547 static void
6548 llrint_test_tonearest (void)
6549 {
6550   int save_round_mode;
6551   START (llrint_tonearest);
6552
6553   save_round_mode = fegetround ();
6554
6555   if (!fesetround (FE_TONEAREST))
6556     {
6557       TEST_f_L (llrint, 0.0, 0);
6558       TEST_f_L (llrint, minus_zero, 0);
6559       TEST_f_L (llrint, 0.2L, 0);
6560       TEST_f_L (llrint, -0.2L, 0);
6561
6562       TEST_f_L (llrint, 1.4L, 1);
6563       TEST_f_L (llrint, -1.4L, -1);
6564
6565       TEST_f_L (llrint, 8388600.3L, 8388600);
6566       TEST_f_L (llrint, -8388600.3L, -8388600);
6567
6568       TEST_f_l (llrint, 1071930.0008, 1071930);
6569
6570       /* Test boundary conditions.  */
6571       /* 0x1FFFFF */
6572       TEST_f_L (llrint, 2097151.0,2097151LL);
6573       /* 0x800000 */
6574       TEST_f_L (llrint, 8388608.0, 8388608LL);
6575       /* 0x1000000 */
6576       TEST_f_L (llrint, 16777216.0, 16777216LL);
6577       /* 0x20000000000 */
6578       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
6579       /* 0x40000000000 */
6580       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
6581       /* 0x1000000000000 */
6582       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
6583       /* 0x10000000000000 */
6584       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
6585       /* 0x10000080000000 */
6586       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
6587       /* 0x20000000000000 */
6588       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
6589       /* 0x80000000000000 */
6590       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
6591       /* 0x100000000000000 */
6592       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
6593 #ifdef TEST_LDOUBLE
6594       /* The input can only be represented in long double.  */
6595       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
6596       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
6597       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
6598       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
6599       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
6600
6601       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
6602       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
6603       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
6604       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
6605       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
6606
6607 # if LDBL_MANT_DIG > 100
6608       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
6609       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
6610       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
6611       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
6612       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
6613       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
6614
6615       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
6616       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
6617       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
6618       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
6619       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
6620       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
6621 #endif
6622
6623       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
6624       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
6625       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
6626       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
6627       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
6628
6629       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
6630       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
6631       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
6632       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
6633       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
6634
6635 # if LDBL_MANT_DIG > 100
6636       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
6637       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
6638       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
6639       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
6640       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
6641       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
6642
6643       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
6644       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
6645       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
6646       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
6647       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
6648       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
6649 #endif
6650
6651       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
6652       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
6653       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
6654       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
6655       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
6656
6657       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
6658       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
6659       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
6660       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
6661       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
6662
6663 # if LDBL_MANT_DIG > 100
6664       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
6665       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
6666       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
6667       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
6668       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
6669       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
6670       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
6671       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
6672       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
6673       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
6674       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
6675       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
6676 # endif
6677 #endif
6678     }
6679
6680   fesetround (save_round_mode);
6681
6682   END (llrint_tonearest);
6683 }
6684
6685 static void
6686 llrint_test_towardzero (void)
6687 {
6688   int save_round_mode;
6689   START (llrint_towardzero);
6690
6691   save_round_mode = fegetround ();
6692
6693   if (!fesetround (FE_TOWARDZERO))
6694     {
6695       TEST_f_L (llrint, 0.0, 0);
6696       TEST_f_L (llrint, minus_zero, 0);
6697       TEST_f_L (llrint, 0.2L, 0);
6698       TEST_f_L (llrint, -0.2L, 0);
6699
6700       TEST_f_L (llrint, 1.4L, 1);
6701       TEST_f_L (llrint, -1.4L, -1);
6702
6703       TEST_f_L (llrint, 8388600.3L, 8388600);
6704       TEST_f_L (llrint, -8388600.3L, -8388600);
6705
6706       TEST_f_l (llrint, 1071930.0008, 1071930);
6707
6708       /* Test boundary conditions.  */
6709       /* 0x1FFFFF */
6710       TEST_f_L (llrint, 2097151.0,2097151LL);
6711       /* 0x800000 */
6712       TEST_f_L (llrint, 8388608.0, 8388608LL);
6713       /* 0x1000000 */
6714       TEST_f_L (llrint, 16777216.0, 16777216LL);
6715       /* 0x20000000000 */
6716       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
6717       /* 0x40000000000 */
6718       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
6719       /* 0x1000000000000 */
6720       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
6721       /* 0x10000000000000 */
6722       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
6723       /* 0x10000080000000 */
6724       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
6725       /* 0x20000000000000 */
6726       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
6727       /* 0x80000000000000 */
6728       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
6729       /* 0x100000000000000 */
6730       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
6731 #ifdef TEST_LDOUBLE
6732       /* The input can only be represented in long double.  */
6733       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370495LL);
6734       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
6735       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
6736       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370496LL);
6737       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370497LL);
6738
6739       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370495LL);
6740       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
6741       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
6742       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370496LL);
6743       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370497LL);
6744
6745 # if LDBL_MANT_DIG > 100
6746       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
6747       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
6748       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
6749       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370494LL);
6750       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370495LL);
6751       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370496LL);
6752
6753       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
6754       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
6755       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
6756       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370494LL);
6757       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370495LL);
6758       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370496LL);
6759 #endif
6760
6761       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740991LL);
6762       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
6763       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
6764       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740992LL);
6765       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740993LL);
6766
6767       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740991LL);
6768       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
6769       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
6770       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740992LL);
6771       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740993LL);
6772
6773 # if LDBL_MANT_DIG > 100
6774       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
6775       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
6776       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
6777       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740991LL);
6778       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740992LL);
6779       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740993LL);
6780
6781       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
6782       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
6783       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
6784       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740991LL);
6785       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740992LL);
6786       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740993LL);
6787 #endif
6788
6789       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927935LL);
6790       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
6791       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
6792       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927936LL);
6793       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927937LL);
6794
6795       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927935LL);
6796       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
6797       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
6798       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927936LL);
6799       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927937LL);
6800
6801 # if LDBL_MANT_DIG > 100
6802       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775805LL);
6803       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775805LL);
6804       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
6805       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
6806       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
6807       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
6808       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
6809       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
6810       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775806LL);
6811       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775806LL);
6812       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
6813       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
6814 # endif
6815 #endif
6816     }
6817
6818   fesetround (save_round_mode);
6819
6820   END (llrint_towardzero);
6821 }
6822
6823 static void
6824 llrint_test_downward (void)
6825 {
6826   int save_round_mode;
6827   START (llrint_downward);
6828
6829   save_round_mode = fegetround ();
6830
6831   if (!fesetround (FE_DOWNWARD))
6832     {
6833       TEST_f_L (llrint, 0.0, 0);
6834       TEST_f_L (llrint, minus_zero, 0);
6835       TEST_f_L (llrint, 0.2L, 0);
6836       TEST_f_L (llrint, -0.2L, -1);
6837
6838       TEST_f_L (llrint, 1.4L, 1);
6839       TEST_f_L (llrint, -1.4L, -2);
6840
6841       TEST_f_L (llrint, 8388600.3L, 8388600);
6842       TEST_f_L (llrint, -8388600.3L, -8388601);
6843
6844       TEST_f_l (llrint, 1071930.0008, 1071930);
6845
6846       /* Test boundary conditions.  */
6847       /* 0x1FFFFF */
6848       TEST_f_L (llrint, 2097151.0,2097151LL);
6849       /* 0x800000 */
6850       TEST_f_L (llrint, 8388608.0, 8388608LL);
6851       /* 0x1000000 */
6852       TEST_f_L (llrint, 16777216.0, 16777216LL);
6853       /* 0x20000000000 */
6854       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
6855       /* 0x40000000000 */
6856       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
6857       /* 0x1000000000000 */
6858       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
6859       /* 0x10000000000000 */
6860       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
6861       /* 0x10000080000000 */
6862       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
6863       /* 0x20000000000000 */
6864       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
6865       /* 0x80000000000000 */
6866       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
6867       /* 0x100000000000000 */
6868       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
6869 #ifdef TEST_LDOUBLE
6870       /* The input can only be represented in long double.  */
6871       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370495LL);
6872       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
6873       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
6874       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370496LL);
6875       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370497LL);
6876
6877       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
6878       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
6879       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
6880       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370494LL);
6881       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370495LL);
6882       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370496LL);
6883
6884       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
6885       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370497LL);
6886       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370497LL);
6887       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
6888       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
6889
6890       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370496LL);
6891       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370497LL);
6892       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370498LL);
6893       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
6894       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
6895       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
6896
6897       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740991LL);
6898       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
6899       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
6900       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740992LL);
6901       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740993LL);
6902
6903       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
6904       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
6905       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
6906       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740991LL);
6907       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740992LL);
6908       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740993LL);
6909
6910       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
6911       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740993LL);
6912       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740993LL);
6913       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
6914       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
6915
6916       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740992LL);
6917       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740993LL);
6918       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740994LL);
6919       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
6920       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
6921       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
6922
6923       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927935LL);
6924       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
6925       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
6926       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927936LL);
6927       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927937LL);
6928
6929       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
6930       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927937LL);
6931       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927937LL);
6932       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
6933       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
6934
6935 # if LDBL_MANT_DIG > 100
6936       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775805LL);
6937       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
6938       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
6939       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
6940       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
6941       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775807LL);
6942       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
6943       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775807LL);
6944       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775806LL);
6945       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
6946       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
6947       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
6948 # endif
6949 #endif
6950     }
6951
6952   fesetround (save_round_mode);
6953
6954   END (llrint_downward);
6955 }
6956
6957 static void
6958 llrint_test_upward (void)
6959 {
6960   int save_round_mode;
6961   START (llrint_upward);
6962
6963   save_round_mode = fegetround ();
6964
6965   if (!fesetround (FE_UPWARD))
6966     {
6967       TEST_f_L (llrint, 0.0, 0);
6968       TEST_f_L (llrint, minus_zero, 0);
6969       TEST_f_L (llrint, 0.2L, 1);
6970       TEST_f_L (llrint, -0.2L, 0);
6971
6972       TEST_f_L (llrint, 1.4L, 2);
6973       TEST_f_L (llrint, -1.4L, -1);
6974
6975       TEST_f_L (llrint, 8388600.3L, 8388601);
6976       TEST_f_L (llrint, -8388600.3L, -8388600);
6977 #ifndef TEST_FLOAT
6978       TEST_f_l (llrint, 1071930.0008, 1071931);
6979 #endif
6980       /* Test boundary conditions.  */
6981       /* 0x1FFFFF */
6982       TEST_f_L (llrint, 2097151.0,2097151LL);
6983       /* 0x800000 */
6984       TEST_f_L (llrint, 8388608.0, 8388608LL);
6985       /* 0x1000000 */
6986       TEST_f_L (llrint, 16777216.0, 16777216LL);
6987       /* 0x20000000000 */
6988       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
6989       /* 0x40000000000 */
6990       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
6991       /* 0x1000000000000 */
6992       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
6993       /* 0x10000000000000 */
6994       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
6995       /* 0x10000080000000 */
6996       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
6997       /* 0x20000000000000 */
6998       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
6999       /* 0x80000000000000 */
7000       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
7001       /* 0x100000000000000 */
7002       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
7003 #ifdef TEST_LDOUBLE
7004       /* The input can only be represented in long double.  */
7005       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
7006       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370497LL);
7007       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370497LL);
7008       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
7009       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
7010
7011       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370496LL);
7012       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370497LL);
7013       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370498LL);
7014       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
7015       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
7016       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
7017
7018       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370495LL);
7019       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
7020       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
7021       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370496LL);
7022       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370497LL);
7023
7024       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
7025       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
7026       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
7027       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370494LL);
7028       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370495LL);
7029       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370496LL);
7030
7031       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
7032       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740993LL);
7033       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740993LL);
7034       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
7035       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
7036
7037       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740992LL);
7038       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740993LL);
7039       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740994LL);
7040       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
7041       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
7042       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
7043
7044       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740991LL);
7045       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
7046       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
7047       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740992LL);
7048       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740993LL);
7049
7050       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
7051       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
7052       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
7053       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740991LL);
7054       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740992LL);
7055       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740993LL);
7056
7057       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
7058       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927937LL);
7059       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927937LL);
7060       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
7061       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
7062
7063       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927935LL);
7064       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
7065       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
7066       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927936LL);
7067       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927937LL);
7068
7069 # if LDBL_MANT_DIG > 100
7070       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
7071       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775805LL);
7072       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
7073       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
7074       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775807LL);
7075       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
7076       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775807L);
7077       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
7078       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
7079       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775806LL);
7080       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
7081       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
7082 # endif
7083 #endif
7084     }
7085
7086   fesetround (save_round_mode);
7087
7088   END (llrint_upward);
7089 }
7090
7091
7092 static void
7093 log_test (void)
7094 {
7095   errno = 0;
7096   FUNC(log) (1);
7097   if (errno == ENOSYS)
7098     /* Function not implemented.  */
7099     return;
7100   START (log);
7101
7102   TEST_f_f (log, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7103   TEST_f_f (log, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7104
7105   TEST_f_f (log, 1, 0);
7106
7107   TEST_f_f (log, -1, nan_value, INVALID_EXCEPTION);
7108   TEST_f_f (log, -max_value, nan_value, INVALID_EXCEPTION);
7109   TEST_f_f (log, minus_infty, nan_value, INVALID_EXCEPTION);
7110   TEST_f_f (log, plus_infty, plus_infty);
7111   TEST_f_f (log, nan_value, nan_value);
7112
7113   TEST_f_f (log, M_El, 1);
7114   TEST_f_f (log, 1.0 / M_El, -1);
7115   TEST_f_f (log, 2, M_LN2l);
7116   TEST_f_f (log, 10, M_LN10l);
7117   TEST_f_f (log, 0.75L, -0.287682072451780927439219005993827432L);
7118
7119   END (log);
7120 }
7121
7122
7123 static void
7124 log10_test (void)
7125 {
7126   errno = 0;
7127   FUNC(log10) (1);
7128   if (errno == ENOSYS)
7129     /* Function not implemented.  */
7130     return;
7131
7132   START (log10);
7133
7134   TEST_f_f (log10, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7135   TEST_f_f (log10, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7136
7137   TEST_f_f (log10, 1, 0);
7138
7139   /* log10 (x) == NaN plus invalid exception if x < 0.  */
7140   TEST_f_f (log10, -1, nan_value, INVALID_EXCEPTION);
7141   TEST_f_f (log10, -max_value, nan_value, INVALID_EXCEPTION);
7142   TEST_f_f (log10, minus_infty, nan_value, INVALID_EXCEPTION);
7143
7144   TEST_f_f (log10, plus_infty, plus_infty);
7145   TEST_f_f (log10, nan_value, nan_value);
7146
7147   TEST_f_f (log10, 0.1L, -1);
7148   TEST_f_f (log10, 10.0, 1);
7149   TEST_f_f (log10, 100.0, 2);
7150   TEST_f_f (log10, 10000.0, 4);
7151   TEST_f_f (log10, M_El, M_LOG10El);
7152   TEST_f_f (log10, 0.75L, -0.124938736608299953132449886193870744L);
7153
7154   END (log10);
7155 }
7156
7157
7158 static void
7159 log1p_test (void)
7160 {
7161   errno = 0;
7162   FUNC(log1p) (0);
7163   if (errno == ENOSYS)
7164     /* Function not implemented.  */
7165     return;
7166
7167   START (log1p);
7168
7169   TEST_f_f (log1p, 0, 0);
7170   TEST_f_f (log1p, minus_zero, minus_zero);
7171
7172   TEST_f_f (log1p, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7173   TEST_f_f (log1p, -2, nan_value, INVALID_EXCEPTION);
7174   TEST_f_f (log1p, -max_value, nan_value, INVALID_EXCEPTION);
7175   TEST_f_f (log1p, minus_infty, nan_value, INVALID_EXCEPTION);
7176
7177   TEST_f_f (log1p, plus_infty, plus_infty);
7178   TEST_f_f (log1p, nan_value, nan_value);
7179
7180   TEST_f_f (log1p, M_El - 1.0, 1);
7181
7182   TEST_f_f (log1p, -0.25L, -0.287682072451780927439219005993827432L);
7183   TEST_f_f (log1p, -0.875, -2.07944154167983592825169636437452970L);
7184
7185   END (log1p);
7186 }
7187
7188
7189 static void
7190 log2_test (void)
7191 {
7192   errno = 0;
7193   FUNC(log2) (1);
7194   if (errno == ENOSYS)
7195     /* Function not implemented.  */
7196     return;
7197
7198   START (log2);
7199
7200   TEST_f_f (log2, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7201   TEST_f_f (log2, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7202
7203   TEST_f_f (log2, 1, 0);
7204
7205   TEST_f_f (log2, -1, nan_value, INVALID_EXCEPTION);
7206   TEST_f_f (log2, -max_value, nan_value, INVALID_EXCEPTION);
7207   TEST_f_f (log2, minus_infty, nan_value, INVALID_EXCEPTION);
7208
7209   TEST_f_f (log2, plus_infty, plus_infty);
7210   TEST_f_f (log2, nan_value, nan_value);
7211
7212   TEST_f_f (log2, M_El, M_LOG2El);
7213   TEST_f_f (log2, 2.0, 1);
7214   TEST_f_f (log2, 16.0, 4);
7215   TEST_f_f (log2, 256.0, 8);
7216   TEST_f_f (log2, 0.75L, -.415037499278843818546261056052183492L);
7217
7218   END (log2);
7219 }
7220
7221
7222 static void
7223 logb_test (void)
7224 {
7225   START (logb);
7226
7227   TEST_f_f (logb, plus_infty, plus_infty);
7228   TEST_f_f (logb, minus_infty, plus_infty);
7229
7230   TEST_f_f (logb, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7231
7232   TEST_f_f (logb, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7233   TEST_f_f (logb, nan_value, nan_value);
7234
7235   TEST_f_f (logb, 1, 0);
7236   TEST_f_f (logb, M_El, 1);
7237   TEST_f_f (logb, 1024, 10);
7238   TEST_f_f (logb, -2000, 10);
7239
7240   TEST_f_f (logb, 0x0.1p-127, -131);
7241   TEST_f_f (logb, 0x0.01p-127, -135);
7242   TEST_f_f (logb, 0x0.011p-127, -135);
7243 #ifndef TEST_FLOAT
7244   TEST_f_f (logb, 0x0.8p-1022, -1023);
7245   TEST_f_f (logb, 0x0.1p-1022, -1026);
7246   TEST_f_f (logb, 0x0.00111p-1022, -1034);
7247   TEST_f_f (logb, 0x0.00001p-1022, -1042);
7248   TEST_f_f (logb, 0x0.000011p-1022, -1042);
7249   TEST_f_f (logb, 0x0.0000000000001p-1022, -1074);
7250 #endif
7251 #if defined TEST_LDOUBLE && LDBL_MIN_EXP - LDBL_MANT_DIG <= -16400
7252   TEST_f_f (logb, 0x1p-16400L, -16400);
7253   TEST_f_f (logb, 0x.00000000001p-16382L, -16426);
7254 #endif
7255
7256   END (logb);
7257 }
7258
7259 static void
7260 logb_test_downward (void)
7261 {
7262   int save_round_mode;
7263   errno = 0;
7264
7265   FUNC(logb) (0);
7266   if (errno == ENOSYS)
7267     /* Function not implemented.  */
7268     return;
7269
7270   START (logb_downward);
7271
7272   save_round_mode = fegetround ();
7273
7274   if (!fesetround (FE_DOWNWARD))
7275     {
7276
7277       /* IEEE 754-2008 says (section 5.3.3) that "logB(1) is +0.".  Libm
7278          should not return -0 from logb in any rounding mode.  PowerPC32 has
7279          failed with this test for power4 logb (and logbl on all PowerPC
7280          platforms) in the past due to instruction selection.  GCC PR 52775
7281          provides the availability of the fcfid insn in 32-bit mode which
7282          eliminates the use of fsub in this instance and prevents the negative
7283          signed 0.0.  */
7284
7285       /* BZ #887  */
7286       TEST_f_f (logb, 1.000e+0, plus_zero);
7287     }
7288
7289   fesetround (save_round_mode);
7290
7291   END (logb_downward);
7292 }
7293
7294 static void
7295 lround_test (void)
7296 {
7297   START (lround);
7298
7299   TEST_f_l (lround, 0, 0);
7300   TEST_f_l (lround, minus_zero, 0);
7301   TEST_f_l (lround, 0.2L, 0.0);
7302   TEST_f_l (lround, -0.2L, 0);
7303   TEST_f_l (lround, 0.5, 1);
7304   TEST_f_l (lround, -0.5, -1);
7305   TEST_f_l (lround, 0.8L, 1);
7306   TEST_f_l (lround, -0.8L, -1);
7307   TEST_f_l (lround, 1.5, 2);
7308   TEST_f_l (lround, -1.5, -2);
7309   TEST_f_l (lround, 22514.5, 22515);
7310   TEST_f_l (lround, -22514.5, -22515);
7311   TEST_f_l (lround, 1071930.0008, 1071930);
7312 #ifndef TEST_FLOAT
7313   TEST_f_l (lround, 1073741824.01, 1073741824);
7314 # if LONG_MAX > 281474976710656
7315   TEST_f_l (lround, 281474976710656.025, 281474976710656);
7316   TEST_f_l (lround, 18014398509481974, 18014398509481974);
7317 # endif
7318   TEST_f_l (lround, 2097152.5, 2097153);
7319   TEST_f_l (lround, -2097152.5, -2097153);
7320   /* nextafter(0.5,-1)  */
7321   TEST_f_l (lround, 0x1.fffffffffffffp-2, 0);
7322   /* nextafter(-0.5,1)  */
7323   TEST_f_l (lround, -0x1.fffffffffffffp-2, 0);
7324 #else
7325   /* nextafter(0.5,-1)  */
7326   TEST_f_l (lround, 0x1.fffffp-2, 0);
7327   /* nextafter(-0.5,1)  */
7328   TEST_f_l (lround, -0x1.fffffp-2, 0);
7329   TEST_f_l (lround, 0x1.fffffep+23, 16777215);
7330   TEST_f_l (lround, -0x1.fffffep+23, -16777215);
7331 #endif
7332   END (lround);
7333 }
7334
7335
7336 static void
7337 llround_test (void)
7338 {
7339   START (llround);
7340
7341   TEST_f_L (llround, 0, 0);
7342   TEST_f_L (llround, minus_zero, 0);
7343   TEST_f_L (llround, 0.2L, 0.0);
7344   TEST_f_L (llround, -0.2L, 0);
7345   TEST_f_L (llround, 0.5, 1);
7346   TEST_f_L (llround, -0.5, -1);
7347   TEST_f_L (llround, 0.8L, 1);
7348   TEST_f_L (llround, -0.8L, -1);
7349   TEST_f_L (llround, 1.5, 2);
7350   TEST_f_L (llround, -1.5, -2);
7351   TEST_f_L (llround, 22514.5, 22515);
7352   TEST_f_L (llround, -22514.5, -22515);
7353   TEST_f_l (llround, 1071930.0008, 1071930);
7354 #ifndef TEST_FLOAT
7355   TEST_f_L (llround, 2097152.5, 2097153);
7356   TEST_f_L (llround, -2097152.5, -2097153);
7357   TEST_f_L (llround, 34359738368.5, 34359738369ll);
7358   TEST_f_L (llround, -34359738368.5, -34359738369ll);
7359   TEST_f_L (llround, -3.65309740835E17, -365309740835000000LL);
7360 #endif
7361
7362   /* Test boundary conditions.  */
7363   /* 0x1FFFFF */
7364   TEST_f_L (llround, 2097151.0, 2097151LL);
7365   /* 0x800000 */
7366   TEST_f_L (llround, 8388608.0, 8388608LL);
7367   /* 0x1000000 */
7368   TEST_f_L (llround, 16777216.0, 16777216LL);
7369   /* 0x20000000000 */
7370   TEST_f_L (llround, 2199023255552.0, 2199023255552LL);
7371   /* 0x40000000000 */
7372   TEST_f_L (llround, 4398046511104.0, 4398046511104LL);
7373   /* 0x1000000000000 */
7374   TEST_f_L (llround, 281474976710656.0, 281474976710656LL);
7375   /* 0x10000000000000 */
7376   TEST_f_L (llround, 4503599627370496.0, 4503599627370496LL);
7377   /* 0x10000080000000 */
7378   TEST_f_L (llround, 4503601774854144.0, 4503601774854144LL);
7379   /* 0x20000000000000 */
7380   TEST_f_L (llround, 9007199254740992.0, 9007199254740992LL);
7381   /* 0x80000000000000 */
7382   TEST_f_L (llround, 36028797018963968.0, 36028797018963968LL);
7383   /* 0x100000000000000 */
7384   TEST_f_L (llround, 72057594037927936.0, 72057594037927936LL);
7385
7386 #ifndef TEST_FLOAT
7387   /* 0x100000000 */
7388   TEST_f_L (llround, 4294967295.5, 4294967296LL);
7389   /* 0x200000000 */
7390   TEST_f_L (llround, 8589934591.5, 8589934592LL);
7391
7392   /* nextafter(0.5,-1)  */
7393   TEST_f_L (llround, 0x1.fffffffffffffp-2, 0);
7394   /* nextafter(-0.5,1)  */
7395   TEST_f_L (llround, -0x1.fffffffffffffp-2, 0);
7396   /* On PowerPC an exponent of '52' is the largest incrementally
7397    * representable sequence of whole-numbers in the 'double' range.  We test
7398    * lround to make sure that a guard bit set during the lround operation
7399    * hasn't forced an erroneous shift giving us an incorrect result.  The odd
7400    * numbers between +-(2^52+1 and 2^53-1) are affected since they have the
7401    * rightmost bit set.  */
7402   /* +-(2^52+1)  */
7403   TEST_f_L (llround, 0x1.0000000000001p+52,4503599627370497LL);
7404   TEST_f_L (llround, -0x1.0000000000001p+52,-4503599627370497LL);
7405   /* +-(2^53-1): Input is the last (positive and negative) incrementally
7406    * representable whole-number in the 'double' range that might round
7407    * erroneously.  */
7408   TEST_f_L (llround, 0x1.fffffffffffffp+52, 9007199254740991LL);
7409   TEST_f_L (llround, -0x1.fffffffffffffp+52, -9007199254740991LL);
7410 #else
7411   /* nextafter(0.5,-1)  */
7412   TEST_f_L (llround, 0x1.fffffep-2, 0);
7413   /* nextafter(-0.5,1)  */
7414   TEST_f_L (llround, -0x1.fffffep-2, 0);
7415   /* As above, on PowerPC an exponent of '23' is the largest incrementally
7416    * representable sequence of whole-numbers in the 'float' range.
7417    * Likewise, numbers between +-(2^23+1 and 2^24-1) are affected.  */
7418   TEST_f_L (llround, 0x1.000002p+23,8388609);
7419   TEST_f_L (llround, -0x1.000002p+23,-8388609);
7420   TEST_f_L (llround, 0x1.fffffep+23, 16777215);
7421   TEST_f_L (llround, -0x1.fffffep+23, -16777215);
7422 #endif
7423
7424
7425 #ifdef TEST_LDOUBLE
7426   /* The input can only be represented in long double.  */
7427   TEST_f_L (llround, 4503599627370495.5L, 4503599627370496LL);
7428   TEST_f_L (llround, 4503599627370496.25L, 4503599627370496LL);
7429   TEST_f_L (llround, 4503599627370496.5L, 4503599627370497LL);
7430   TEST_f_L (llround, 4503599627370496.75L, 4503599627370497LL);
7431   TEST_f_L (llround, 4503599627370497.5L, 4503599627370498LL);
7432
7433 # if LDBL_MANT_DIG > 100
7434   TEST_f_L (llround, 4503599627370495.4999999999999L, 4503599627370495LL);
7435   TEST_f_L (llround, 4503599627370496.4999999999999L, 4503599627370496LL);
7436   TEST_f_L (llround, 4503599627370497.4999999999999L, 4503599627370497LL);
7437   TEST_f_L (llround, 4503599627370494.5000000000001L, 4503599627370495LL);
7438   TEST_f_L (llround, 4503599627370495.5000000000001L, 4503599627370496LL);
7439   TEST_f_L (llround, 4503599627370496.5000000000001L, 4503599627370497LL);
7440
7441   TEST_f_L (llround, -4503599627370495.4999999999999L, -4503599627370495LL);
7442   TEST_f_L (llround, -4503599627370496.4999999999999L, -4503599627370496LL);
7443   TEST_f_L (llround, -4503599627370497.4999999999999L, -4503599627370497LL);
7444   TEST_f_L (llround, -4503599627370494.5000000000001L, -4503599627370495LL);
7445   TEST_f_L (llround, -4503599627370495.5000000000001L, -4503599627370496LL);
7446   TEST_f_L (llround, -4503599627370496.5000000000001L, -4503599627370497LL);
7447 # endif
7448
7449   TEST_f_L (llround, -4503599627370495.5L, -4503599627370496LL);
7450   TEST_f_L (llround, -4503599627370496.25L, -4503599627370496LL);
7451   TEST_f_L (llround, -4503599627370496.5L, -4503599627370497LL);
7452   TEST_f_L (llround, -4503599627370496.75L, -4503599627370497LL);
7453   TEST_f_L (llround, -4503599627370497.5L, -4503599627370498LL);
7454
7455   TEST_f_L (llround, 9007199254740991.5L, 9007199254740992LL);
7456   TEST_f_L (llround, 9007199254740992.25L, 9007199254740992LL);
7457   TEST_f_L (llround, 9007199254740992.5L, 9007199254740993LL);
7458   TEST_f_L (llround, 9007199254740992.75L, 9007199254740993LL);
7459   TEST_f_L (llround, 9007199254740993.5L, 9007199254740994LL);
7460
7461 # if LDBL_MANT_DIG > 100
7462   TEST_f_L (llround, 9007199254740991.4999999999999L, 9007199254740991LL);
7463   TEST_f_L (llround, 9007199254740992.4999999999999L, 9007199254740992LL);
7464   TEST_f_L (llround, 9007199254740993.4999999999999L, 9007199254740993LL);
7465   TEST_f_L (llround, 9007199254740991.5000000000001L, 9007199254740992LL);
7466   TEST_f_L (llround, 9007199254740992.5000000000001L, 9007199254740993LL);
7467   TEST_f_L (llround, 9007199254740993.5000000000001L, 9007199254740994LL);
7468
7469   TEST_f_L (llround, -9007199254740991.4999999999999L, -9007199254740991LL);
7470   TEST_f_L (llround, -9007199254740992.4999999999999L, -9007199254740992LL);
7471   TEST_f_L (llround, -9007199254740993.4999999999999L, -9007199254740993LL);
7472   TEST_f_L (llround, -9007199254740991.5000000000001L, -9007199254740992LL);
7473   TEST_f_L (llround, -9007199254740992.5000000000001L, -9007199254740993LL);
7474   TEST_f_L (llround, -9007199254740993.5000000000001L, -9007199254740994LL);
7475 # endif
7476
7477   TEST_f_L (llround, -9007199254740991.5L, -9007199254740992LL);
7478   TEST_f_L (llround, -9007199254740992.25L, -9007199254740992LL);
7479   TEST_f_L (llround, -9007199254740992.5L, -9007199254740993LL);
7480   TEST_f_L (llround, -9007199254740992.75L, -9007199254740993LL);
7481   TEST_f_L (llround, -9007199254740993.5L, -9007199254740994LL);
7482
7483   TEST_f_L (llround, 72057594037927935.5L, 72057594037927936LL);
7484   TEST_f_L (llround, 72057594037927936.25L, 72057594037927936LL);
7485   TEST_f_L (llround, 72057594037927936.5L, 72057594037927937LL);
7486   TEST_f_L (llround, 72057594037927936.75L, 72057594037927937LL);
7487   TEST_f_L (llround, 72057594037927937.5L, 72057594037927938LL);
7488
7489   TEST_f_L (llround, -72057594037927935.5L, -72057594037927936LL);
7490   TEST_f_L (llround, -72057594037927936.25L, -72057594037927936LL);
7491   TEST_f_L (llround, -72057594037927936.5L, -72057594037927937LL);
7492   TEST_f_L (llround, -72057594037927936.75L, -72057594037927937LL);
7493   TEST_f_L (llround, -72057594037927937.5L, -72057594037927938LL);
7494
7495   TEST_f_L (llround, 9223372036854775806.25L, 9223372036854775806LL);
7496   TEST_f_L (llround, -9223372036854775806.25L, -9223372036854775806LL);
7497   TEST_f_L (llround, 9223372036854775806.5L, 9223372036854775807LL);
7498   TEST_f_L (llround, -9223372036854775806.5L, -9223372036854775807LL);
7499   TEST_f_L (llround, 9223372036854775807.0L, 9223372036854775807LL);
7500   TEST_f_L (llround, -9223372036854775807.0L, -9223372036854775807LL);
7501 #endif
7502
7503   END (llround);
7504 }
7505
7506 static void
7507 modf_test (void)
7508 {
7509   FLOAT x;
7510
7511   START (modf);
7512
7513   TEST_fF_f1 (modf, plus_infty, 0, plus_infty);
7514   TEST_fF_f1 (modf, minus_infty, minus_zero, minus_infty);
7515   TEST_fF_f1 (modf, nan_value, nan_value, nan_value);
7516   TEST_fF_f1 (modf, 0, 0, 0);
7517   TEST_fF_f1 (modf, 1.5, 0.5, 1);
7518   TEST_fF_f1 (modf, 2.5, 0.5, 2);
7519   TEST_fF_f1 (modf, -2.5, -0.5, -2);
7520   TEST_fF_f1 (modf, 20, 0, 20);
7521   TEST_fF_f1 (modf, 21, 0, 21);
7522   TEST_fF_f1 (modf, 89.5, 0.5, 89);
7523
7524   END (modf);
7525 }
7526
7527
7528 static void
7529 nearbyint_test (void)
7530 {
7531   START (nearbyint);
7532
7533   TEST_f_f (nearbyint, 0.0, 0.0);
7534   TEST_f_f (nearbyint, minus_zero, minus_zero);
7535   TEST_f_f (nearbyint, plus_infty, plus_infty);
7536   TEST_f_f (nearbyint, minus_infty, minus_infty);
7537   TEST_f_f (nearbyint, nan_value, nan_value);
7538
7539   /* Subnormal values */
7540   TEST_f_f (nearbyint, -8.98847e+307, -8.98847e+307);
7541   TEST_f_f (nearbyint, -4.45015e-308, minus_zero);
7542
7543   /* Default rounding mode is round to nearest.  */
7544   TEST_f_f (nearbyint, 0.5, 0.0);
7545   TEST_f_f (nearbyint, 1.5, 2.0);
7546   TEST_f_f (nearbyint, -0.5, minus_zero);
7547   TEST_f_f (nearbyint, -1.5, -2.0);
7548
7549   TEST_f_f (nearbyint, 262144.75, 262145.0);
7550   TEST_f_f (nearbyint, 262142.75, 262143.0);
7551   TEST_f_f (nearbyint, 524286.75, 524287.0);
7552   TEST_f_f (nearbyint, 524288.75, 524289.0);
7553
7554   TEST_f_f (nearbyint, 1048576.75, 1048577.0);
7555   TEST_f_f (nearbyint, 2097152.75, 2097153.0);
7556   TEST_f_f (nearbyint, 2492472.75, 2492473.0);
7557   TEST_f_f (nearbyint, 2886220.75, 2886221.0);
7558   TEST_f_f (nearbyint, 3058792.75, 3058793.0);
7559   TEST_f_f (nearbyint, -1048576.75, -1048577.0);
7560   TEST_f_f (nearbyint, -2097152.75, -2097153.0);
7561   TEST_f_f (nearbyint, -2492472.75, -2492473.0);
7562   TEST_f_f (nearbyint, -2886220.75, -2886221.0);
7563   TEST_f_f (nearbyint, -3058792.75, -3058793.0);
7564 #ifndef TEST_FLOAT
7565   TEST_f_f (nearbyint, 70368744177664.75, 70368744177665.0);
7566   TEST_f_f (nearbyint, 140737488355328.75, 140737488355329.0);
7567   TEST_f_f (nearbyint, 281474976710656.75, 281474976710657.0);
7568   TEST_f_f (nearbyint, 562949953421312.75, 562949953421313.0);
7569   TEST_f_f (nearbyint, 1125899906842624.75, 1125899906842625.0);
7570   TEST_f_f (nearbyint, -70368744177664.75, -70368744177665.0);
7571   TEST_f_f (nearbyint, -140737488355328.75, -140737488355329.0);
7572   TEST_f_f (nearbyint, -281474976710656.75, -281474976710657.0);
7573   TEST_f_f (nearbyint, -562949953421312.75, -562949953421313.0);
7574   TEST_f_f (nearbyint, -1125899906842624.75, -1125899906842625.0);
7575 #endif
7576
7577   END (nearbyint);
7578 }
7579
7580 static void
7581 nextafter_test (void)
7582 {
7583
7584   START (nextafter);
7585
7586   TEST_ff_f (nextafter, 0, 0, 0);
7587   TEST_ff_f (nextafter, minus_zero, 0, 0);
7588   TEST_ff_f (nextafter, 0, minus_zero, minus_zero);
7589   TEST_ff_f (nextafter, minus_zero, minus_zero, minus_zero);
7590
7591   TEST_ff_f (nextafter, 9, 9, 9);
7592   TEST_ff_f (nextafter, -9, -9, -9);
7593   TEST_ff_f (nextafter, plus_infty, plus_infty, plus_infty);
7594   TEST_ff_f (nextafter, minus_infty, minus_infty, minus_infty);
7595
7596   TEST_ff_f (nextafter, nan_value, 1.1L, nan_value);
7597   TEST_ff_f (nextafter, 1.1L, nan_value, nan_value);
7598   TEST_ff_f (nextafter, nan_value, nan_value, nan_value);
7599
7600   FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
7601                          LDBL_MAX, DBL_MAX, FLT_MAX);
7602   TEST_ff_f (nextafter, fltmax, plus_infty, plus_infty, OVERFLOW_EXCEPTION);
7603   TEST_ff_f (nextafter, -fltmax, minus_infty, minus_infty, OVERFLOW_EXCEPTION);
7604
7605 #ifdef TEST_LDOUBLE
7606   // XXX Enable once gcc is fixed.
7607   //TEST_ff_f (nextafter, 0x0.00000040000000000000p-16385L, -0.1L, 0x0.0000003ffffffff00000p-16385L);
7608 #endif
7609
7610   /* XXX We need the hexadecimal FP number representation here for further
7611      tests.  */
7612
7613   END (nextafter);
7614 }
7615
7616
7617 static void
7618 nexttoward_test (void)
7619 {
7620   START (nexttoward);
7621   TEST_ff_f (nexttoward, 0, 0, 0);
7622   TEST_ff_f (nexttoward, minus_zero, 0, 0);
7623   TEST_ff_f (nexttoward, 0, minus_zero, minus_zero);
7624   TEST_ff_f (nexttoward, minus_zero, minus_zero, minus_zero);
7625
7626   TEST_ff_f (nexttoward, 9, 9, 9);
7627   TEST_ff_f (nexttoward, -9, -9, -9);
7628   TEST_ff_f (nexttoward, plus_infty, plus_infty, plus_infty);
7629   TEST_ff_f (nexttoward, minus_infty, minus_infty, minus_infty);
7630
7631   TEST_ff_f (nexttoward, nan_value, 1.1L, nan_value);
7632   TEST_ff_f (nexttoward, 1.1L, nan_value, nan_value);
7633   TEST_ff_f (nexttoward, nan_value, nan_value, nan_value);
7634
7635 #ifdef TEST_FLOAT
7636   TEST_ff_f (nexttoward, 1.0, 1.1L, 0x1.000002p0);
7637   TEST_ff_f (nexttoward, 1.0, LDBL_MAX, 0x1.000002p0);
7638   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000001p0, 0x1.000002p0);
7639   TEST_ff_f (nexttoward, 1.0, 0.9L, 0x0.ffffffp0);
7640   TEST_ff_f (nexttoward, 1.0, -LDBL_MAX, 0x0.ffffffp0);
7641   TEST_ff_f (nexttoward, 1.0, 0x0.fffffffffffff8p0, 0x0.ffffffp0);
7642   TEST_ff_f (nexttoward, -1.0, -1.1L, -0x1.000002p0);
7643   TEST_ff_f (nexttoward, -1.0, -LDBL_MAX, -0x1.000002p0);
7644   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000001p0, -0x1.000002p0);
7645   TEST_ff_f (nexttoward, -1.0, -0.9L, -0x0.ffffffp0);
7646   TEST_ff_f (nexttoward, -1.0, LDBL_MAX, -0x0.ffffffp0);
7647   TEST_ff_f (nexttoward, -1.0, -0x0.fffffffffffff8p0, -0x0.ffffffp0);
7648   TEST_ff_f (nexttoward, -0x1.3p-145, -0xap-148L, -0x1.4p-145, UNDERFLOW_EXCEPTION);
7649 # if LDBL_MANT_DIG >= 64
7650   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000002p0L, 0x1.000002p0);
7651   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffp0L, 0x0.ffffffp0);
7652   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000002p0L, -0x1.000002p0);
7653   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffp0L, -0x0.ffffffp0);
7654 # endif
7655 # if LDBL_MANT_DIG >= 106
7656   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000000000000000008p0L, 0x1.000002p0);
7657   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffcp0L, 0x0.ffffffp0);
7658   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000000000000000008p0L, -0x1.000002p0);
7659   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffcp0L, -0x0.ffffffp0);
7660 # endif
7661 # if LDBL_MANT_DIG >= 113
7662   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000000000000000000001p0L, 0x1.000002p0);
7663   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffp0);
7664   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000000000000000000001p0L, -0x1.000002p0);
7665   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffp0);
7666 # endif
7667 #endif
7668 #ifdef TEST_DOUBLE
7669   TEST_ff_f (nexttoward, 1.0, 1.1L, 0x1.0000000000001p0);
7670   TEST_ff_f (nexttoward, 1.0, LDBL_MAX, 0x1.0000000000001p0);
7671   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000001p0, 0x1.0000000000001p0);
7672   TEST_ff_f (nexttoward, 1.0, 0.9L, 0x0.fffffffffffff8p0);
7673   TEST_ff_f (nexttoward, 1.0, -LDBL_MAX, 0x0.fffffffffffff8p0);
7674   TEST_ff_f (nexttoward, 1.0, 0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0);
7675   TEST_ff_f (nexttoward, -1.0, -1.1L, -0x1.0000000000001p0);
7676   TEST_ff_f (nexttoward, -1.0, -LDBL_MAX, -0x1.0000000000001p0);
7677   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000001p0, -0x1.0000000000001p0);
7678   TEST_ff_f (nexttoward, -1.0, -0.9L, -0x0.fffffffffffff8p0);
7679   TEST_ff_f (nexttoward, -1.0, LDBL_MAX, -0x0.fffffffffffff8p0);
7680   TEST_ff_f (nexttoward, -1.0, -0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0);
7681   TEST_ff_f (nexttoward, -1.0, -0x8.00346dc5d6388p-3L, -0x1.0000000000001p0);
7682   TEST_ff_f (nexttoward, 0x1p-1074, 0x1p-1073L, 0x1p-1073, UNDERFLOW_EXCEPTION);
7683 # if LDBL_MANT_DIG >= 64
7684   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000002p0L, 0x1.0000000000001p0);
7685   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffp0L, 0x0.fffffffffffff8p0);
7686   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000002p0L, -0x1.0000000000001p0);
7687   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffp0L, -0x0.fffffffffffff8p0);
7688 # endif
7689 # if LDBL_MANT_DIG >= 106
7690   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000000000000000008p0L, 0x1.0000000000001p0);
7691   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffcp0L, 0x0.fffffffffffff8p0);
7692   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000000000000000008p0L, -0x1.0000000000001p0);
7693   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffcp0L, -0x0.fffffffffffff8p0);
7694 # endif
7695 # if LDBL_MANT_DIG >= 113
7696   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000000000000000000001p0L, 0x1.0000000000001p0);
7697   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.fffffffffffff8p0);
7698   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000000000000000000001p0L, -0x1.0000000000001p0);
7699   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.fffffffffffff8p0);
7700 # endif
7701 #endif
7702
7703   END (nexttoward);
7704 }
7705
7706
7707 static void
7708 pow_test (void)
7709 {
7710
7711   errno = 0;
7712   FUNC(pow) (0, 0);
7713   if (errno == ENOSYS)
7714     /* Function not implemented.  */
7715     return;
7716
7717   START (pow);
7718
7719   TEST_ff_f (pow, 0, 0, 1);
7720   TEST_ff_f (pow, 0, minus_zero, 1);
7721   TEST_ff_f (pow, minus_zero, 0, 1);
7722   TEST_ff_f (pow, minus_zero, minus_zero, 1);
7723
7724   TEST_ff_f (pow, 10, 0, 1);
7725   TEST_ff_f (pow, 10, minus_zero, 1);
7726   TEST_ff_f (pow, -10, 0, 1);
7727   TEST_ff_f (pow, -10, minus_zero, 1);
7728
7729   TEST_ff_f (pow, nan_value, 0, 1);
7730   TEST_ff_f (pow, nan_value, minus_zero, 1);
7731
7732
7733 #ifndef TEST_INLINE
7734   TEST_ff_f (pow, 1.1L, plus_infty, plus_infty);
7735   TEST_ff_f (pow, plus_infty, plus_infty, plus_infty);
7736   TEST_ff_f (pow, -1.1L, plus_infty, plus_infty);
7737   TEST_ff_f (pow, minus_infty, plus_infty, plus_infty);
7738
7739   TEST_ff_f (pow, 0.9L, plus_infty, 0);
7740   TEST_ff_f (pow, 1e-7L, plus_infty, 0);
7741   TEST_ff_f (pow, -0.9L, plus_infty, 0);
7742   TEST_ff_f (pow, -1e-7L, plus_infty, 0);
7743
7744   TEST_ff_f (pow, 1.1L, minus_infty, 0);
7745   TEST_ff_f (pow, plus_infty, minus_infty, 0);
7746   TEST_ff_f (pow, -1.1L, minus_infty, 0);
7747   TEST_ff_f (pow, minus_infty, minus_infty, 0);
7748
7749   TEST_ff_f (pow, 0.9L, minus_infty, plus_infty);
7750   TEST_ff_f (pow, 1e-7L, minus_infty, plus_infty);
7751   TEST_ff_f (pow, -0.9L, minus_infty, plus_infty);
7752   TEST_ff_f (pow, -1e-7L, minus_infty, plus_infty);
7753
7754   TEST_ff_f (pow, plus_infty, 1e-7L, plus_infty);
7755   TEST_ff_f (pow, plus_infty, 1, plus_infty);
7756   TEST_ff_f (pow, plus_infty, 1e7L, plus_infty);
7757   TEST_ff_f (pow, plus_infty, min_subnorm_value, plus_infty);
7758
7759   TEST_ff_f (pow, plus_infty, -1e-7L, 0);
7760   TEST_ff_f (pow, plus_infty, -1, 0);
7761   TEST_ff_f (pow, plus_infty, -1e7L, 0);
7762   TEST_ff_f (pow, plus_infty, -min_subnorm_value, 0);
7763
7764   TEST_ff_f (pow, minus_infty, 1, minus_infty);
7765   TEST_ff_f (pow, minus_infty, 11, minus_infty);
7766   TEST_ff_f (pow, minus_infty, 1001, minus_infty);
7767
7768   TEST_ff_f (pow, minus_infty, 2, plus_infty);
7769   TEST_ff_f (pow, minus_infty, 12, plus_infty);
7770   TEST_ff_f (pow, minus_infty, 1002, plus_infty);
7771   TEST_ff_f (pow, minus_infty, 0.1L, plus_infty);
7772   TEST_ff_f (pow, minus_infty, 1.1L, plus_infty);
7773   TEST_ff_f (pow, minus_infty, 11.1L, plus_infty);
7774   TEST_ff_f (pow, minus_infty, 1001.1L, plus_infty);
7775   TEST_ff_f (pow, minus_infty, min_subnorm_value, plus_infty);
7776
7777   TEST_ff_f (pow, minus_infty, -1, minus_zero);
7778   TEST_ff_f (pow, minus_infty, -11, minus_zero);
7779   TEST_ff_f (pow, minus_infty, -1001, minus_zero);
7780
7781   TEST_ff_f (pow, minus_infty, -2, 0);
7782   TEST_ff_f (pow, minus_infty, -12, 0);
7783   TEST_ff_f (pow, minus_infty, -1002, 0);
7784   TEST_ff_f (pow, minus_infty, -0.1L, 0);
7785   TEST_ff_f (pow, minus_infty, -1.1L, 0);
7786   TEST_ff_f (pow, minus_infty, -11.1L, 0);
7787   TEST_ff_f (pow, minus_infty, -1001.1L, 0);
7788   TEST_ff_f (pow, minus_infty, -min_subnorm_value, 0);
7789 #endif
7790
7791   TEST_ff_f (pow, nan_value, nan_value, nan_value);
7792   TEST_ff_f (pow, 0, nan_value, nan_value);
7793   TEST_ff_f (pow, 1, nan_value, 1);
7794   TEST_ff_f (pow, -1, nan_value, nan_value);
7795   TEST_ff_f (pow, nan_value, 1, nan_value);
7796   TEST_ff_f (pow, nan_value, -1, nan_value);
7797
7798   /* pow (x, NaN) == NaN.  */
7799   TEST_ff_f (pow, 3.0, nan_value, nan_value);
7800   TEST_ff_f (pow, minus_zero, nan_value, nan_value);
7801   TEST_ff_f (pow, plus_infty, nan_value, nan_value);
7802   TEST_ff_f (pow, -3.0, nan_value, nan_value);
7803   TEST_ff_f (pow, minus_infty, nan_value, nan_value);
7804
7805   TEST_ff_f (pow, nan_value, 3.0, nan_value);
7806   TEST_ff_f (pow, nan_value, -3.0, nan_value);
7807   TEST_ff_f (pow, nan_value, plus_infty, nan_value);
7808   TEST_ff_f (pow, nan_value, minus_infty, nan_value);
7809   TEST_ff_f (pow, nan_value, 2.5, nan_value);
7810   TEST_ff_f (pow, nan_value, -2.5, nan_value);
7811   TEST_ff_f (pow, nan_value, min_subnorm_value, nan_value);
7812   TEST_ff_f (pow, nan_value, -min_subnorm_value, nan_value);
7813
7814   TEST_ff_f (pow, 1, plus_infty, 1);
7815   TEST_ff_f (pow, -1, plus_infty, 1);
7816   TEST_ff_f (pow, 1, minus_infty, 1);
7817   TEST_ff_f (pow, -1, minus_infty, 1);
7818   TEST_ff_f (pow, 1, 1, 1);
7819   TEST_ff_f (pow, 1, -1, 1);
7820   TEST_ff_f (pow, 1, 1.25, 1);
7821   TEST_ff_f (pow, 1, -1.25, 1);
7822   TEST_ff_f (pow, 1, 0x1p62L, 1);
7823   TEST_ff_f (pow, 1, 0x1p63L, 1);
7824   TEST_ff_f (pow, 1, 0x1p64L, 1);
7825   TEST_ff_f (pow, 1, 0x1p72L, 1);
7826   TEST_ff_f (pow, 1, min_subnorm_value, 1);
7827   TEST_ff_f (pow, 1, -min_subnorm_value, 1);
7828
7829   /* pow (x, +-0) == 1.  */
7830   TEST_ff_f (pow, plus_infty, 0, 1);
7831   TEST_ff_f (pow, plus_infty, minus_zero, 1);
7832   TEST_ff_f (pow, minus_infty, 0, 1);
7833   TEST_ff_f (pow, minus_infty, minus_zero, 1);
7834   TEST_ff_f (pow, 32.75L, 0, 1);
7835   TEST_ff_f (pow, 32.75L, minus_zero, 1);
7836   TEST_ff_f (pow, -32.75L, 0, 1);
7837   TEST_ff_f (pow, -32.75L, minus_zero, 1);
7838   TEST_ff_f (pow, 0x1p72L, 0, 1);
7839   TEST_ff_f (pow, 0x1p72L, minus_zero, 1);
7840   TEST_ff_f (pow, 0x1p-72L, 0, 1);
7841   TEST_ff_f (pow, 0x1p-72L, minus_zero, 1);
7842
7843   TEST_ff_f (pow, -0.1L, 1.1L, nan_value, INVALID_EXCEPTION);
7844   TEST_ff_f (pow, -0.1L, -1.1L, nan_value, INVALID_EXCEPTION);
7845   TEST_ff_f (pow, -10.1L, 1.1L, nan_value, INVALID_EXCEPTION);
7846   TEST_ff_f (pow, -10.1L, -1.1L, nan_value, INVALID_EXCEPTION);
7847   TEST_ff_f (pow, -1.01L, min_subnorm_value, nan_value, INVALID_EXCEPTION);
7848   TEST_ff_f (pow, -1.01L, -min_subnorm_value, nan_value, INVALID_EXCEPTION);
7849   TEST_ff_f (pow, -1.0L, min_subnorm_value, nan_value, INVALID_EXCEPTION);
7850   TEST_ff_f (pow, -1.0L, -min_subnorm_value, nan_value, INVALID_EXCEPTION);
7851
7852   errno = 0;
7853   TEST_ff_f (pow, 0, -1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7854   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7855   errno = 0;
7856   TEST_ff_f (pow, 0, -11, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7857   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7858   errno = 0;
7859   TEST_ff_f (pow, 0, -0xffffff, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7860   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7861 #ifndef TEST_FLOAT
7862   errno = 0;
7863   TEST_ff_f (pow, 0, -0x1.fffffffffffffp+52L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7864   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7865 #endif
7866 #ifdef TEST_LDOUBLE
7867 # if LDBL_MANT_DIG >= 64
7868   errno = 0;
7869   TEST_ff_f (pow, 0, -0x1.fffffffffffffffep+63L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7870   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7871 # endif
7872 # if LDBL_MANT_DIG >= 106
7873   errno = 0;
7874   TEST_ff_f (pow, 0, -0x1.ffffffffffffffffffffffffff8p+105L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7875   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7876 # endif
7877 # if LDBL_MANT_DIG >= 113
7878   errno = 0;
7879   TEST_ff_f (pow, 0, -0x1.ffffffffffffffffffffffffffffp+112L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7880   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7881 # endif
7882 #endif
7883   TEST_ff_f (pow, minus_zero, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7884   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7885   errno = 0;
7886   TEST_ff_f (pow, minus_zero, -11L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7887   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7888   errno = 0;
7889   TEST_ff_f (pow, minus_zero, -0xffffff, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7890   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7891   errno = 0;
7892   TEST_ff_f (pow, minus_zero, -0x1fffffe, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7893   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7894 #ifndef TEST_FLOAT
7895   errno = 0;
7896   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffp+52L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7897   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7898   errno = 0;
7899   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffp+53L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7900   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7901 #endif
7902 #ifdef TEST_LDOUBLE
7903 # if LDBL_MANT_DIG >= 64
7904   errno = 0;
7905   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffffep+63L, 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, -0x1.fffffffffffffffep+64L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7909   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7910 # endif
7911 # if LDBL_MANT_DIG >= 106
7912   errno = 0;
7913   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7914   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7915   errno = 0;
7916   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7917   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7918 # endif
7919 # if LDBL_MANT_DIG >= 113
7920   errno = 0;
7921   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7922   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7923   errno = 0;
7924   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7925   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7926 # endif
7927 #endif
7928
7929   errno = 0;
7930   TEST_ff_f (pow, 0, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7931   check_int ("errno for pow(0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7932   errno = 0;
7933   TEST_ff_f (pow, 0, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7934   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7935   errno = 0;
7936   TEST_ff_f (pow, 0, -min_subnorm_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7937   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7938   errno = 0;
7939   TEST_ff_f (pow, 0, -0x1p24, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7940   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7941   errno = 0;
7942   TEST_ff_f (pow, 0, -0x1p127, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7943   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7944   errno = 0;
7945   TEST_ff_f (pow, 0, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7946   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7947   errno = 0;
7948   TEST_ff_f (pow, minus_zero, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7949   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7950   errno = 0;
7951   TEST_ff_f (pow, minus_zero, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7952   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7953   errno = 0;
7954   TEST_ff_f (pow, minus_zero, -min_subnorm_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7955   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7956   errno = 0;
7957   TEST_ff_f (pow, minus_zero, -0x1p24, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7958   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7959   errno = 0;
7960   TEST_ff_f (pow, minus_zero, -0x1p127, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7961   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7962   errno = 0;
7963   TEST_ff_f (pow, minus_zero, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7964   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7965
7966   TEST_ff_f (pow, 0x1p72L, 0x1p72L, plus_infty, OVERFLOW_EXCEPTION);
7967   TEST_ff_f (pow, 10, -0x1p72L, 0, UNDERFLOW_EXCEPTION);
7968   TEST_ff_f (pow, max_value, max_value, plus_infty, OVERFLOW_EXCEPTION);
7969   TEST_ff_f (pow, 10, -max_value, 0, UNDERFLOW_EXCEPTION);
7970
7971   TEST_ff_f (pow, 0, 1, 0);
7972   TEST_ff_f (pow, 0, 11, 0);
7973
7974   TEST_ff_f (pow, minus_zero, 1, minus_zero);
7975   TEST_ff_f (pow, minus_zero, 11, minus_zero);
7976
7977   TEST_ff_f (pow, 0, 2, 0);
7978   TEST_ff_f (pow, 0, 11.1L, 0);
7979
7980   TEST_ff_f (pow, minus_zero, 2, 0);
7981   TEST_ff_f (pow, minus_zero, 11.1L, 0);
7982   TEST_ff_f (pow, 0, plus_infty, 0);
7983   TEST_ff_f (pow, minus_zero, plus_infty, 0);
7984   TEST_ff_f (pow, 0, minus_infty, plus_infty, DIVIDE_BY_ZERO_EXCEPTION_OK);
7985   TEST_ff_f (pow, minus_zero, minus_infty, plus_infty, DIVIDE_BY_ZERO_EXCEPTION_OK);
7986
7987 #ifndef TEST_INLINE
7988   /* pow (x, +inf) == +inf for |x| > 1.  */
7989   TEST_ff_f (pow, 1.5, plus_infty, plus_infty);
7990
7991   /* pow (x, +inf) == +0 for |x| < 1.  */
7992   TEST_ff_f (pow, 0.5, plus_infty, 0.0);
7993
7994   /* pow (x, -inf) == +0 for |x| > 1.  */
7995   TEST_ff_f (pow, 1.5, minus_infty, 0.0);
7996
7997   /* pow (x, -inf) == +inf for |x| < 1.  */
7998   TEST_ff_f (pow, 0.5, minus_infty, plus_infty);
7999 #endif
8000
8001   /* pow (+inf, y) == +inf for y > 0.  */
8002   TEST_ff_f (pow, plus_infty, 2, plus_infty);
8003   TEST_ff_f (pow, plus_infty, 0xffffff, plus_infty);
8004 #ifndef TEST_FLOAT
8005   TEST_ff_f (pow, plus_infty, 0x1.fffffffffffffp+52L, plus_infty);
8006 #endif
8007 #ifdef TEST_LDOUBLE
8008 # if LDBL_MANT_DIG >= 64
8009   TEST_ff_f (pow, plus_infty, 0x1.fffffffffffffffep+63L, plus_infty);
8010 # endif
8011 # if LDBL_MANT_DIG >= 106
8012   TEST_ff_f (pow, plus_infty, 0x1.ffffffffffffffffffffffffff8p+105L, plus_infty);
8013 # endif
8014 # if LDBL_MANT_DIG >= 113
8015   TEST_ff_f (pow, plus_infty, 0x1.ffffffffffffffffffffffffffffp+112L, plus_infty);
8016 # endif
8017 #endif
8018   TEST_ff_f (pow, plus_infty, 0x1p24, plus_infty);
8019   TEST_ff_f (pow, plus_infty, 0x1p127, plus_infty);
8020   TEST_ff_f (pow, plus_infty, max_value, plus_infty);
8021
8022   /* pow (+inf, y) == +0 for y < 0.  */
8023   TEST_ff_f (pow, plus_infty, -1, 0.0);
8024   TEST_ff_f (pow, plus_infty, -0xffffff, 0.0);
8025 #ifndef TEST_FLOAT
8026   TEST_ff_f (pow, plus_infty, -0x1.fffffffffffffp+52L, 0.0);
8027 #endif
8028 #ifdef TEST_LDOUBLE
8029 # if LDBL_MANT_DIG >= 64
8030   TEST_ff_f (pow, plus_infty, -0x1.fffffffffffffffep+63L, 0.0);
8031 # endif
8032 # if LDBL_MANT_DIG >= 106
8033   TEST_ff_f (pow, plus_infty, -0x1.ffffffffffffffffffffffffff8p+105L, 0.0);
8034 # endif
8035 # if LDBL_MANT_DIG >= 113
8036   TEST_ff_f (pow, plus_infty, -0x1.ffffffffffffffffffffffffffffp+112L, 0.0);
8037 # endif
8038 #endif
8039   TEST_ff_f (pow, plus_infty, -0x1p24, 0.0);
8040   TEST_ff_f (pow, plus_infty, -0x1p127, 0.0);
8041   TEST_ff_f (pow, plus_infty, -max_value, 0.0);
8042
8043   /* pow (-inf, y) == -inf for y an odd integer > 0.  */
8044   TEST_ff_f (pow, minus_infty, 27, minus_infty);
8045   TEST_ff_f (pow, minus_infty, 0xffffff, minus_infty);
8046   TEST_ff_f (pow, minus_infty, 0x1fffffe, plus_infty);
8047 #ifndef TEST_FLOAT
8048   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffp+52L, minus_infty);
8049   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffp+53L, plus_infty);
8050 #endif
8051 #ifdef TEST_LDOUBLE
8052 # if LDBL_MANT_DIG >= 64
8053   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffffep+63L, minus_infty);
8054   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffffep+64L, plus_infty);
8055 # endif
8056 # if LDBL_MANT_DIG >= 106
8057   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty);
8058   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty);
8059 # endif
8060 # if LDBL_MANT_DIG >= 113
8061   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty);
8062   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty);
8063 # endif
8064 #endif
8065
8066   /* pow (-inf, y) == +inf for y > 0 and not an odd integer.  */
8067   TEST_ff_f (pow, minus_infty, 28, plus_infty);
8068   TEST_ff_f (pow, minus_infty, 0x1p24, plus_infty);
8069   TEST_ff_f (pow, minus_infty, 0x1p127, plus_infty);
8070   TEST_ff_f (pow, minus_infty, max_value, plus_infty);
8071
8072   /* pow (-inf, y) == -0 for y an odd integer < 0. */
8073   TEST_ff_f (pow, minus_infty, -3, minus_zero);
8074   TEST_ff_f (pow, minus_infty, -0xffffff, minus_zero);
8075   TEST_ff_f (pow, minus_infty, -0x1fffffe, plus_zero);
8076 #ifndef TEST_FLOAT
8077   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffp+52L, minus_zero);
8078   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffp+53L, plus_zero);
8079 #endif
8080 #ifdef TEST_LDOUBLE
8081 # if LDBL_MANT_DIG >= 64
8082   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffffep+63L, minus_zero);
8083   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffffep+64L, plus_zero);
8084 # endif
8085 # if LDBL_MANT_DIG >= 106
8086   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
8087   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
8088 # endif
8089 # if LDBL_MANT_DIG >= 113
8090   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
8091   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
8092 # endif
8093 #endif
8094   /* pow (-inf, y) == +0 for y < 0 and not an odd integer.  */
8095   TEST_ff_f (pow, minus_infty, -2.0, 0.0);
8096   TEST_ff_f (pow, minus_infty, -0x1p24, 0.0);
8097   TEST_ff_f (pow, minus_infty, -0x1p127, 0.0);
8098   TEST_ff_f (pow, minus_infty, -max_value, 0.0);
8099
8100   /* pow (+0, y) == +0 for y an odd integer > 0.  */
8101   TEST_ff_f (pow, 0.0, 27, 0.0);
8102   TEST_ff_f (pow, 0.0, 0xffffff, 0.0);
8103 #ifndef TEST_FLOAT
8104   TEST_ff_f (pow, 0.0, 0x1.fffffffffffffp+52L, 0.0);
8105 #endif
8106 #ifdef TEST_LDOUBLE
8107 # if LDBL_MANT_DIG >= 64
8108   TEST_ff_f (pow, 0.0, 0x1.fffffffffffffffep+63L, 0.0);
8109 # endif
8110 # if LDBL_MANT_DIG >= 106
8111   TEST_ff_f (pow, 0.0, 0x1.ffffffffffffffffffffffffff8p+105L, 0.0);
8112 # endif
8113 # if LDBL_MANT_DIG >= 113
8114   TEST_ff_f (pow, 0.0, 0x1.ffffffffffffffffffffffffffffp+112L, 0.0);
8115 # endif
8116 #endif
8117
8118   /* pow (-0, y) == -0 for y an odd integer > 0.  */
8119   TEST_ff_f (pow, minus_zero, 27, minus_zero);
8120   TEST_ff_f (pow, minus_zero, 0xffffff, minus_zero);
8121   TEST_ff_f (pow, minus_zero, 0x1fffffe, plus_zero);
8122 #ifndef TEST_FLOAT
8123   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffp+52L, minus_zero);
8124   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffp+53L, plus_zero);
8125 #endif
8126 #ifdef TEST_LDOUBLE
8127 # if LDBL_MANT_DIG >= 64
8128   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffffep+63L, minus_zero);
8129   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffffep+64L, plus_zero);
8130 # endif
8131 # if LDBL_MANT_DIG >= 106
8132   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
8133   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
8134 # endif
8135 # if LDBL_MANT_DIG >= 113
8136   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
8137   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
8138 # endif
8139 #endif
8140
8141   /* pow (+0, y) == +0 for y > 0 and not an odd integer.  */
8142   TEST_ff_f (pow, 0.0, 4, 0.0);
8143   TEST_ff_f (pow, 0.0, 0x1p24, 0.0);
8144   TEST_ff_f (pow, 0.0, 0x1p127, 0.0);
8145   TEST_ff_f (pow, 0.0, max_value, 0.0);
8146   TEST_ff_f (pow, 0.0, min_subnorm_value, 0.0);
8147
8148   /* pow (-0, y) == +0 for y > 0 and not an odd integer.  */
8149   TEST_ff_f (pow, minus_zero, 4, 0.0);
8150   TEST_ff_f (pow, minus_zero, 0x1p24, 0.0);
8151   TEST_ff_f (pow, minus_zero, 0x1p127, 0.0);
8152   TEST_ff_f (pow, minus_zero, max_value, 0.0);
8153   TEST_ff_f (pow, minus_zero, min_subnorm_value, 0.0);
8154
8155   TEST_ff_f (pow, 16, 0.25L, 2);
8156   TEST_ff_f (pow, 0x1p64L, 0.125L, 256);
8157   TEST_ff_f (pow, 2, 4, 16);
8158   TEST_ff_f (pow, 256, 8, 0x1p64L);
8159
8160   TEST_ff_f (pow, 0.75L, 1.25L, 0.697953644326574699205914060237425566L);
8161
8162 #if defined TEST_DOUBLE || defined TEST_LDOUBLE
8163   TEST_ff_f (pow, -7.49321e+133, -9.80818e+16, 0, UNDERFLOW_EXCEPTION);
8164 #endif
8165
8166   TEST_ff_f (pow, -1.0, -0xffffff, -1.0);
8167   TEST_ff_f (pow, -1.0, -0x1fffffe, 1.0);
8168 #ifndef TEST_FLOAT
8169   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffp+52L, -1.0);
8170   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffp+53L, 1.0);
8171 #endif
8172 #ifdef TEST_LDOUBLE
8173 # if LDBL_MANT_DIG >= 64
8174   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffffep+63L, -1.0);
8175   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffffep+64L, 1.0);
8176 # endif
8177 # if LDBL_MANT_DIG >= 106
8178   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffff8p+105L, -1.0);
8179   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffff8p+106L, 1.0);
8180 # endif
8181 # if LDBL_MANT_DIG >= 113
8182   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffffffp+112L, -1.0);
8183   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffffffp+113L, 1.0);
8184 # endif
8185 #endif
8186   TEST_ff_f (pow, -1.0, -max_value, 1.0);
8187
8188   TEST_ff_f (pow, -1.0, 0xffffff, -1.0);
8189   TEST_ff_f (pow, -1.0, 0x1fffffe, 1.0);
8190 #ifndef TEST_FLOAT
8191   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffp+52L, -1.0);
8192   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffp+53L, 1.0);
8193 #endif
8194 #ifdef TEST_LDOUBLE
8195 # if LDBL_MANT_DIG >= 64
8196   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffffep+63L, -1.0);
8197   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffffep+64L, 1.0);
8198 # endif
8199 # if LDBL_MANT_DIG >= 106
8200   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffff8p+105L, -1.0);
8201   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffff8p+106L, 1.0);
8202 # endif
8203 # if LDBL_MANT_DIG >= 113
8204   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffffffp+112L, -1.0);
8205   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffffffp+113L, 1.0);
8206 # endif
8207 #endif
8208   TEST_ff_f (pow, -1.0, max_value, 1.0);
8209
8210   TEST_ff_f (pow, -2.0, 126, 0x1p126);
8211   TEST_ff_f (pow, -2.0, 127, -0x1p127);
8212   /* Allow inexact results for float to be considered to underflow.  */
8213   TEST_ff_f (pow, -2.0, -126, 0x1p-126, UNDERFLOW_EXCEPTION_OK_FLOAT);
8214   TEST_ff_f (pow, -2.0, -127, -0x1p-127, UNDERFLOW_EXCEPTION_OK_FLOAT);
8215
8216   TEST_ff_f (pow, -2.0, -0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
8217   TEST_ff_f (pow, -2.0, -0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
8218 #ifndef TEST_FLOAT
8219   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
8220   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
8221 #endif
8222 #ifdef TEST_LDOUBLE
8223 # if LDBL_MANT_DIG >= 64
8224   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
8225   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
8226 # endif
8227 # if LDBL_MANT_DIG >= 106
8228   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
8229   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
8230 # endif
8231 # if LDBL_MANT_DIG >= 113
8232   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
8233   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
8234 # endif
8235 #endif
8236   TEST_ff_f (pow, -2.0, -max_value, plus_zero, UNDERFLOW_EXCEPTION);
8237
8238   TEST_ff_f (pow, -2.0, 0xffffff, minus_infty, OVERFLOW_EXCEPTION);
8239   TEST_ff_f (pow, -2.0, 0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
8240 #ifndef TEST_FLOAT
8241   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
8242   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
8243 #endif
8244 #ifdef TEST_LDOUBLE
8245 # if LDBL_MANT_DIG >= 64
8246   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
8247   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
8248 # endif
8249 # if LDBL_MANT_DIG >= 106
8250   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
8251   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
8252 # endif
8253 # if LDBL_MANT_DIG >= 113
8254   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
8255   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
8256 # endif
8257 #endif
8258   TEST_ff_f (pow, -2.0, max_value, plus_infty, OVERFLOW_EXCEPTION);
8259
8260   TEST_ff_f (pow, -max_value, 0.5, nan_value, INVALID_EXCEPTION);
8261   TEST_ff_f (pow, -max_value, 1.5, nan_value, INVALID_EXCEPTION);
8262   TEST_ff_f (pow, -max_value, 1000.5, nan_value, INVALID_EXCEPTION);
8263   TEST_ff_f (pow, -max_value, -2, plus_zero, UNDERFLOW_EXCEPTION);
8264   TEST_ff_f (pow, -max_value, -3, minus_zero, UNDERFLOW_EXCEPTION);
8265   TEST_ff_f (pow, -max_value, 2, plus_infty, OVERFLOW_EXCEPTION);
8266   TEST_ff_f (pow, -max_value, 3, minus_infty, OVERFLOW_EXCEPTION);
8267
8268   TEST_ff_f (pow, -max_value, -0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
8269   TEST_ff_f (pow, -max_value, -0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
8270 #ifndef TEST_FLOAT
8271   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
8272   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
8273 #endif
8274 #ifdef TEST_LDOUBLE
8275 # if LDBL_MANT_DIG >= 64
8276   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
8277   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
8278 # endif
8279 # if LDBL_MANT_DIG >= 106
8280   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
8281   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
8282 # endif
8283 # if LDBL_MANT_DIG >= 113
8284   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
8285   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
8286 # endif
8287 #endif
8288   TEST_ff_f (pow, -max_value, -max_value, plus_zero, UNDERFLOW_EXCEPTION);
8289
8290   TEST_ff_f (pow, -max_value, 0xffffff, minus_infty, OVERFLOW_EXCEPTION);
8291   TEST_ff_f (pow, -max_value, 0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
8292 #ifndef TEST_FLOAT
8293   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
8294   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
8295 #endif
8296 #ifdef TEST_LDOUBLE
8297 # if LDBL_MANT_DIG >= 64
8298   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
8299   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
8300 # endif
8301 # if LDBL_MANT_DIG >= 106
8302   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
8303   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
8304 # endif
8305 # if LDBL_MANT_DIG >= 113
8306   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
8307   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
8308 # endif
8309 #endif
8310   TEST_ff_f (pow, -max_value, max_value, plus_infty, OVERFLOW_EXCEPTION);
8311
8312   TEST_ff_f (pow, -0.5, 126, 0x1p-126);
8313   TEST_ff_f (pow, -0.5, 127, -0x1p-127);
8314   TEST_ff_f (pow, -0.5, -126, 0x1p126);
8315   TEST_ff_f (pow, -0.5, -127, -0x1p127);
8316
8317   TEST_ff_f (pow, -0.5, -0xffffff, minus_infty, OVERFLOW_EXCEPTION);
8318   TEST_ff_f (pow, -0.5, -0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
8319 #ifndef TEST_FLOAT
8320   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
8321   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
8322 #endif
8323 #ifdef TEST_LDOUBLE
8324 # if LDBL_MANT_DIG >= 64
8325   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
8326   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
8327 # endif
8328 # if LDBL_MANT_DIG >= 106
8329   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
8330   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
8331 # endif
8332 # if LDBL_MANT_DIG >= 113
8333   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
8334   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
8335 # endif
8336 #endif
8337   TEST_ff_f (pow, -0.5, -max_value, plus_infty, OVERFLOW_EXCEPTION);
8338
8339   TEST_ff_f (pow, -0.5, 0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
8340   TEST_ff_f (pow, -0.5, 0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
8341 #ifndef TEST_FLOAT
8342   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
8343   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
8344 #endif
8345 #ifdef TEST_LDOUBLE
8346 # if LDBL_MANT_DIG >= 64
8347   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
8348   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
8349 # endif
8350 # if LDBL_MANT_DIG >= 106
8351   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
8352   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
8353 # endif
8354 # if LDBL_MANT_DIG >= 113
8355   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
8356   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
8357 # endif
8358 #endif
8359   TEST_ff_f (pow, -0.5, max_value, plus_zero, UNDERFLOW_EXCEPTION);
8360
8361   TEST_ff_f (pow, -min_value, 0.5, nan_value, INVALID_EXCEPTION);
8362   TEST_ff_f (pow, -min_value, 1.5, nan_value, INVALID_EXCEPTION);
8363   TEST_ff_f (pow, -min_value, 1000.5, nan_value, INVALID_EXCEPTION);
8364   TEST_ff_f (pow, -min_value, -2, plus_infty, OVERFLOW_EXCEPTION);
8365   TEST_ff_f (pow, -min_value, -3, minus_infty, OVERFLOW_EXCEPTION);
8366   /* Allow inexact results to be considered to underflow.  */
8367   TEST_ff_f (pow, -min_value, 1, -min_value, UNDERFLOW_EXCEPTION_OK);
8368   TEST_ff_f (pow, -min_value, 2, plus_zero, UNDERFLOW_EXCEPTION);
8369   TEST_ff_f (pow, -min_value, 3, minus_zero, UNDERFLOW_EXCEPTION);
8370
8371   TEST_ff_f (pow, -min_value, -0xffffff, minus_infty, OVERFLOW_EXCEPTION);
8372   TEST_ff_f (pow, -min_value, -0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
8373 #ifndef TEST_FLOAT
8374   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
8375   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
8376 #endif
8377 #ifdef TEST_LDOUBLE
8378 # if LDBL_MANT_DIG >= 64
8379   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
8380   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
8381 # endif
8382 # if LDBL_MANT_DIG >= 106
8383   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
8384   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
8385 # endif
8386 # if LDBL_MANT_DIG >= 113
8387   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
8388   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
8389 # endif
8390 #endif
8391   TEST_ff_f (pow, -min_value, -max_value, plus_infty, OVERFLOW_EXCEPTION);
8392
8393   TEST_ff_f (pow, -min_value, 0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
8394   TEST_ff_f (pow, -min_value, 0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
8395 #ifndef TEST_FLOAT
8396   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
8397   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
8398 #endif
8399 #ifdef TEST_LDOUBLE
8400 # if LDBL_MANT_DIG >= 64
8401   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
8402   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
8403 # endif
8404 # if LDBL_MANT_DIG >= 106
8405   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
8406   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
8407 # endif
8408 # if LDBL_MANT_DIG >= 113
8409   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
8410   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
8411 # endif
8412 #endif
8413   TEST_ff_f (pow, -min_value, max_value, plus_zero, UNDERFLOW_EXCEPTION);
8414
8415 #ifndef TEST_LDOUBLE /* Bug 13881.  */
8416   TEST_ff_f (pow, 0x0.ffffffp0, 10, 0.999999403953712118183885036774764444747L);
8417   TEST_ff_f (pow, 0x0.ffffffp0, 100, 0.999994039553108359406305079606228341585L);
8418   TEST_ff_f (pow, 0x0.ffffffp0, 1000, 0.9999403971297699052276650144650733772182L);
8419   TEST_ff_f (pow, 0x0.ffffffp0, 0x1p24, 0.3678794302077803437135155590023422899744L);
8420   TEST_ff_f (pow, 0x0.ffffffp0, 0x1p30, 1.603807831524924233828134753069728224044e-28L);
8421   TEST_ff_f (pow, 0x0.ffffffp0, 0x1.234566p30, 2.374884712135295099971443365381007297732e-32L);
8422   TEST_ff_f (pow, 0x0.ffffffp0, -10, 1.000000596046643153205170848674671339688L);
8423   TEST_ff_f (pow, 0x0.ffffffp0, -100, 1.000005960482418779499387594989252621451L);
8424   TEST_ff_f (pow, 0x0.ffffffp0, -1000, 1.000059606422943986382898964231519867906L);
8425   TEST_ff_f (pow, 0x0.ffffffp0, -0x1p24, 2.7182819094701610539628664526874952929416L);
8426   TEST_ff_f (pow, 0x0.ffffffp0, -0x1p30, 6.2351609734265057988914412331288163636075e+27L);
8427   TEST_ff_f (pow, 0x0.ffffffp0, -0x1.234566p30, 4.2107307141696353498921307077142537353515e+31L);
8428   TEST_ff_f (pow, 0x1.000002p0, 0x1p24, 7.3890552180866447284268641248075832310141L);
8429   TEST_ff_f (pow, 0x1.000002p0, 0x1.234566p29, 4.2107033006507495188536371520637025716256e+31L);
8430   TEST_ff_f (pow, 0x1.000002p0, -0x1.234566p29, 2.3749001736727769098946062325205705312166e-32L);
8431 #endif
8432
8433   /* Bug 13881: powl inaccurate so these tests disabled for long double.  */
8434 #if !defined TEST_FLOAT && !defined TEST_LDOUBLE
8435   TEST_ff_f (pow, 0x0.fffffffffffff8p0L, 0x1.23456789abcdfp62L, 1.0118762747827252817436395051178295138220e-253L);
8436   TEST_ff_f (pow, 0x0.fffffffffffff8p0L, -0x1.23456789abcdfp62L, 9.8826311568054561811190162420900667121992e+252L);
8437   TEST_ff_f (pow, 0x1.0000000000001p0L, 0x1.23456789abcdfp61L, 9.8826311568044974397135026217687399395481e+252L);
8438   TEST_ff_f (pow, 0x1.0000000000001p0L, -0x1.23456789abcdfp61L, 1.0118762747828234466621210689458255908670e-253L);
8439 #endif
8440
8441   TEST_ff_f (pow, min_subnorm_value, min_subnorm_value, 1.0L);
8442   TEST_ff_f (pow, min_subnorm_value, -min_subnorm_value, 1.0L);
8443   TEST_ff_f (pow, max_value, min_subnorm_value, 1.0L);
8444   TEST_ff_f (pow, max_value, -min_subnorm_value, 1.0L);
8445   TEST_ff_f (pow, 0.99L, min_subnorm_value, 1.0L);
8446   TEST_ff_f (pow, 0.99L, -min_subnorm_value, 1.0L);
8447   TEST_ff_f (pow, 1.01L, min_subnorm_value, 1.0L);
8448   TEST_ff_f (pow, 1.01L, -min_subnorm_value, 1.0L);
8449
8450   TEST_ff_f (pow, 2.0L, -100000.0L, plus_zero, UNDERFLOW_EXCEPTION);
8451
8452   END (pow);
8453 }
8454
8455
8456 static void
8457 pow_test_tonearest (void)
8458 {
8459   int save_round_mode;
8460   errno = 0;
8461   FUNC(pow) (0, 0);
8462   if (errno == ENOSYS)
8463     /* Function not implemented.  */
8464     return;
8465
8466   START (pow_tonearest);
8467
8468   save_round_mode = fegetround ();
8469
8470   if (!fesetround (FE_TONEAREST))
8471     {
8472       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
8473       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
8474     }
8475
8476   fesetround (save_round_mode);
8477
8478   END (pow_tonearest);
8479 }
8480
8481
8482 static void
8483 pow_test_towardzero (void)
8484 {
8485   int save_round_mode;
8486   errno = 0;
8487   FUNC(pow) (0, 0);
8488   if (errno == ENOSYS)
8489     /* Function not implemented.  */
8490     return;
8491
8492   START (pow_towardzero);
8493
8494   save_round_mode = fegetround ();
8495
8496   if (!fesetround (FE_TOWARDZERO))
8497     {
8498       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
8499       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
8500     }
8501
8502   fesetround (save_round_mode);
8503
8504   END (pow_towardzero);
8505 }
8506
8507
8508 static void
8509 pow_test_downward (void)
8510 {
8511   int save_round_mode;
8512   errno = 0;
8513   FUNC(pow) (0, 0);
8514   if (errno == ENOSYS)
8515     /* Function not implemented.  */
8516     return;
8517
8518   START (pow_downward);
8519
8520   save_round_mode = fegetround ();
8521
8522   if (!fesetround (FE_DOWNWARD))
8523     {
8524       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
8525       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
8526     }
8527
8528   fesetround (save_round_mode);
8529
8530   END (pow_downward);
8531 }
8532
8533
8534 static void
8535 pow_test_upward (void)
8536 {
8537   int save_round_mode;
8538   errno = 0;
8539   FUNC(pow) (0, 0);
8540   if (errno == ENOSYS)
8541     /* Function not implemented.  */
8542     return;
8543
8544   START (pow_upward);
8545
8546   save_round_mode = fegetround ();
8547
8548   if (!fesetround (FE_UPWARD))
8549     {
8550       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
8551       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
8552     }
8553
8554   fesetround (save_round_mode);
8555
8556   END (pow_upward);
8557 }
8558
8559
8560 static void
8561 remainder_test (void)
8562 {
8563   errno = 0;
8564   FUNC(remainder) (1.625, 1.0);
8565   if (errno == ENOSYS)
8566     /* Function not implemented.  */
8567     return;
8568
8569   START (remainder);
8570
8571   errno = 0;
8572   TEST_ff_f (remainder, 1, 0, nan_value, INVALID_EXCEPTION);
8573   check_int ("errno for remainder(1, 0) = EDOM ", errno, EDOM, 0, 0, 0);
8574   errno = 0;
8575   TEST_ff_f (remainder, 1, minus_zero, nan_value, INVALID_EXCEPTION);
8576   check_int ("errno for remainder(1, -0) = EDOM ", errno, EDOM, 0, 0, 0);
8577   errno = 0;
8578   TEST_ff_f (remainder, plus_infty, 1, nan_value, INVALID_EXCEPTION);
8579   check_int ("errno for remainder(INF, 1) = EDOM ", errno, EDOM, 0, 0, 0);
8580   errno = 0;
8581   TEST_ff_f (remainder, minus_infty, 1, nan_value, INVALID_EXCEPTION);
8582   check_int ("errno for remainder(-INF, 1) = EDOM ", errno, EDOM, 0, 0, 0);
8583   errno = 0;
8584   TEST_ff_f (remainder, nan_value, nan_value, nan_value);
8585   check_int ("errno for remainder(NAN, NAN) unchanged", errno, 0, 0, 0, 0);
8586   errno = 0;
8587   TEST_ff_f (remainder, 0, nan_value, nan_value);
8588   check_int ("errno for remainder(0, NAN) unchanged", errno, 0, 0, 0, 0);
8589   errno = 0;
8590   TEST_ff_f (remainder, nan_value, 0, nan_value);
8591   check_int ("errno for remainder(NaN, 0) unchanged", errno, 0, 0, 0, 0);
8592
8593   TEST_ff_f (remainder, 1.625, 1.0, -0.375);
8594   TEST_ff_f (remainder, -1.625, 1.0, 0.375);
8595   TEST_ff_f (remainder, 1.625, -1.0, -0.375);
8596   TEST_ff_f (remainder, -1.625, -1.0, 0.375);
8597   TEST_ff_f (remainder, 5.0, 2.0, 1.0);
8598   TEST_ff_f (remainder, 3.0, 2.0, -1.0);
8599
8600   END (remainder);
8601 }
8602
8603 static void
8604 remquo_test (void)
8605 {
8606   /* x is needed.  */
8607   int x;
8608
8609   errno = 0;
8610   FUNC(remquo) (1.625, 1.0, &x);
8611   if (errno == ENOSYS)
8612     /* Function not implemented.  */
8613     return;
8614
8615   START (remquo);
8616
8617   TEST_ffI_f1 (remquo, 1, 0, nan_value, IGNORE, INVALID_EXCEPTION);
8618   TEST_ffI_f1 (remquo, 1, minus_zero, nan_value, IGNORE, INVALID_EXCEPTION);
8619   TEST_ffI_f1 (remquo, plus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
8620   TEST_ffI_f1 (remquo, minus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
8621   TEST_ffI_f1 (remquo, nan_value, nan_value, nan_value, IGNORE);
8622
8623   TEST_ffI_f1 (remquo, 1.625, 1.0, -0.375, 2);
8624   TEST_ffI_f1 (remquo, -1.625, 1.0, 0.375, -2);
8625   TEST_ffI_f1 (remquo, 1.625, -1.0, -0.375, -2);
8626   TEST_ffI_f1 (remquo, -1.625, -1.0, 0.375, 2);
8627
8628   TEST_ffI_f1 (remquo, 5, 2, 1, 2);
8629   TEST_ffI_f1 (remquo, 3, 2, -1, 2);
8630
8631   END (remquo);
8632 }
8633
8634 static void
8635 rint_test (void)
8636 {
8637   START (rint);
8638
8639   TEST_f_f (rint, 0.0, 0.0);
8640   TEST_f_f (rint, minus_zero, minus_zero);
8641   TEST_f_f (rint, plus_infty, plus_infty);
8642   TEST_f_f (rint, minus_infty, minus_infty);
8643
8644   /* Default rounding mode is round to even.  */
8645   TEST_f_f (rint, 0.5, 0.0);
8646   TEST_f_f (rint, 1.5, 2.0);
8647   TEST_f_f (rint, 2.5, 2.0);
8648   TEST_f_f (rint, 3.5, 4.0);
8649   TEST_f_f (rint, 4.5, 4.0);
8650   TEST_f_f (rint, -0.5, -0.0);
8651   TEST_f_f (rint, -1.5, -2.0);
8652   TEST_f_f (rint, -2.5, -2.0);
8653   TEST_f_f (rint, -3.5, -4.0);
8654   TEST_f_f (rint, -4.5, -4.0);
8655   TEST_f_f (rint, 0.1, 0.0);
8656   TEST_f_f (rint, 0.25, 0.0);
8657   TEST_f_f (rint, 0.625, 1.0);
8658   TEST_f_f (rint, -0.1, -0.0);
8659   TEST_f_f (rint, -0.25, -0.0);
8660   TEST_f_f (rint, -0.625, -1.0);
8661   TEST_f_f (rint, 262144.75, 262145.0);
8662   TEST_f_f (rint, 262142.75, 262143.0);
8663   TEST_f_f (rint, 524286.75, 524287.0);
8664   TEST_f_f (rint, 524288.75, 524289.0);
8665   TEST_f_f (rint, 1048576.75, 1048577.0);
8666   TEST_f_f (rint, 2097152.75, 2097153.0);
8667   TEST_f_f (rint, -1048576.75, -1048577.0);
8668   TEST_f_f (rint, -2097152.75, -2097153.0);
8669 #ifndef TEST_FLOAT
8670   TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
8671   TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
8672   TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
8673   TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
8674   TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
8675   TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
8676   TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
8677   TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
8678   TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
8679   TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
8680 #endif
8681 #ifdef TEST_LDOUBLE
8682   /* The result can only be represented in long double.  */
8683   TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
8684   TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
8685   TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
8686   TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
8687   TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
8688
8689 # if LDBL_MANT_DIG > 100
8690   TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
8691   TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
8692   TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
8693 # endif
8694
8695   TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
8696   TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
8697   TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
8698   TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
8699   TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
8700
8701 # if LDBL_MANT_DIG > 100
8702   TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
8703   TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
8704   TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
8705
8706   TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
8707   TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
8708   TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
8709   TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
8710   TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
8711   TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
8712
8713   TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
8714   TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
8715   TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
8716   TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
8717   TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
8718   TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
8719 # endif
8720
8721   TEST_f_f (rint, 9007199254740991.5L, 9007199254740992.0L);
8722   TEST_f_f (rint, 9007199254740992.25L, 9007199254740992.0L);
8723   TEST_f_f (rint, 9007199254740992.5L, 9007199254740992.0L);
8724   TEST_f_f (rint, 9007199254740992.75L, 9007199254740993.0L);
8725   TEST_f_f (rint, 9007199254740993.5L, 9007199254740994.0L);
8726
8727   TEST_f_f (rint, -9007199254740991.5L, -9007199254740992.0L);
8728   TEST_f_f (rint, -9007199254740992.25L, -9007199254740992.0L);
8729   TEST_f_f (rint, -9007199254740992.5L, -9007199254740992.0L);
8730   TEST_f_f (rint, -9007199254740992.75L, -9007199254740993.0L);
8731   TEST_f_f (rint, -9007199254740993.5L, -9007199254740994.0L);
8732
8733   TEST_f_f (rint, 72057594037927935.5L, 72057594037927936.0L);
8734   TEST_f_f (rint, 72057594037927936.25L, 72057594037927936.0L);
8735   TEST_f_f (rint, 72057594037927936.5L, 72057594037927936.0L);
8736   TEST_f_f (rint, 72057594037927936.75L, 72057594037927937.0L);
8737   TEST_f_f (rint, 72057594037927937.5L, 72057594037927938.0L);
8738
8739   TEST_f_f (rint, -72057594037927935.5L, -72057594037927936.0L);
8740   TEST_f_f (rint, -72057594037927936.25L, -72057594037927936.0L);
8741   TEST_f_f (rint, -72057594037927936.5L, -72057594037927936.0L);
8742   TEST_f_f (rint, -72057594037927936.75L, -72057594037927937.0L);
8743   TEST_f_f (rint, -72057594037927937.5L, -72057594037927938.0L);
8744
8745   TEST_f_f (rint, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
8746   TEST_f_f (rint, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
8747   TEST_f_f (rint, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
8748   TEST_f_f (rint, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
8749   TEST_f_f (rint, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
8750 #endif
8751
8752   END (rint);
8753 }
8754
8755 static void
8756 rint_test_tonearest (void)
8757 {
8758   int save_round_mode;
8759   START (rint_tonearest);
8760
8761   save_round_mode = fegetround ();
8762
8763   if (!fesetround (FE_TONEAREST))
8764     {
8765       TEST_f_f (rint, 2.0, 2.0);
8766       TEST_f_f (rint, 1.5, 2.0);
8767       TEST_f_f (rint, 1.0, 1.0);
8768       TEST_f_f (rint, 0.5, 0.0);
8769       TEST_f_f (rint, 0.0, 0.0);
8770       TEST_f_f (rint, minus_zero, minus_zero);
8771       TEST_f_f (rint, -0.5, -0.0);
8772       TEST_f_f (rint, -1.0, -1.0);
8773       TEST_f_f (rint, -1.5, -2.0);
8774       TEST_f_f (rint, -2.0, -2.0);
8775       TEST_f_f (rint, 0.1, 0.0);
8776       TEST_f_f (rint, 0.25, 0.0);
8777       TEST_f_f (rint, 0.625, 1.0);
8778       TEST_f_f (rint, -0.1, -0.0);
8779       TEST_f_f (rint, -0.25, -0.0);
8780       TEST_f_f (rint, -0.625, -1.0);
8781       TEST_f_f (rint, 1048576.75, 1048577.0);
8782       TEST_f_f (rint, 2097152.75, 2097153.0);
8783       TEST_f_f (rint, -1048576.75, -1048577.0);
8784       TEST_f_f (rint, -2097152.75, -2097153.0);
8785 #ifndef TEST_FLOAT
8786       TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
8787       TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
8788       TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
8789       TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
8790       TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
8791       TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
8792       TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
8793       TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
8794       TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
8795       TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
8796 #endif
8797 #ifdef TEST_LDOUBLE
8798       /* The result can only be represented in long double.  */
8799       TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
8800       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
8801       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
8802       TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
8803       TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
8804 # if LDBL_MANT_DIG > 100
8805       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
8806       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
8807       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
8808 # endif
8809       TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
8810       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
8811       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
8812       TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
8813       TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
8814 # if LDBL_MANT_DIG > 100
8815       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
8816       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
8817       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
8818
8819       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
8820       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
8821       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
8822       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
8823       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
8824       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
8825
8826       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
8827       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
8828       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
8829       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
8830       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
8831       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
8832 # endif
8833 #endif
8834     }
8835
8836   fesetround (save_round_mode);
8837
8838   END (rint_tonearest);
8839 }
8840
8841 static void
8842 rint_test_towardzero (void)
8843 {
8844   int save_round_mode;
8845   START (rint_towardzero);
8846
8847   save_round_mode = fegetround ();
8848
8849   if (!fesetround (FE_TOWARDZERO))
8850     {
8851       TEST_f_f (rint, 2.0, 2.0);
8852       TEST_f_f (rint, 1.5, 1.0);
8853       TEST_f_f (rint, 1.0, 1.0);
8854       TEST_f_f (rint, 0.5, 0.0);
8855       TEST_f_f (rint, 0.0, 0.0);
8856       TEST_f_f (rint, minus_zero, minus_zero);
8857       TEST_f_f (rint, -0.5, -0.0);
8858       TEST_f_f (rint, -1.0, -1.0);
8859       TEST_f_f (rint, -1.5, -1.0);
8860       TEST_f_f (rint, -2.0, -2.0);
8861       TEST_f_f (rint, 0.1, 0.0);
8862       TEST_f_f (rint, 0.25, 0.0);
8863       TEST_f_f (rint, 0.625, 0.0);
8864       TEST_f_f (rint, -0.1, -0.0);
8865       TEST_f_f (rint, -0.25, -0.0);
8866       TEST_f_f (rint, -0.625, -0.0);
8867       TEST_f_f (rint, 1048576.75, 1048576.0);
8868       TEST_f_f (rint, 2097152.75, 2097152.0);
8869       TEST_f_f (rint, -1048576.75, -1048576.0);
8870       TEST_f_f (rint, -2097152.75, -2097152.0);
8871 #ifndef TEST_FLOAT
8872       TEST_f_f (rint, 70368744177664.75, 70368744177664.0);
8873       TEST_f_f (rint, 140737488355328.75, 140737488355328.0);
8874       TEST_f_f (rint, 281474976710656.75, 281474976710656.0);
8875       TEST_f_f (rint, 562949953421312.75, 562949953421312.0);
8876       TEST_f_f (rint, 1125899906842624.75, 1125899906842624.0);
8877       TEST_f_f (rint, -70368744177664.75, -70368744177664.0);
8878       TEST_f_f (rint, -140737488355328.75, -140737488355328.0);
8879       TEST_f_f (rint, -281474976710656.75, -281474976710656.0);
8880       TEST_f_f (rint, -562949953421312.75, -562949953421312.0);
8881       TEST_f_f (rint, -1125899906842624.75, -1125899906842624.0);
8882 #endif
8883 #ifdef TEST_LDOUBLE
8884       /* The result can only be represented in long double.  */
8885       TEST_f_f (rint, 4503599627370495.5L, 4503599627370495.0L);
8886       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
8887       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
8888       TEST_f_f (rint, 4503599627370496.75L, 4503599627370496.0L);
8889       TEST_f_f (rint, 4503599627370497.5L, 4503599627370497.0L);
8890 # if LDBL_MANT_DIG > 100
8891       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370494.0L);
8892       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370495.0L);
8893       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370496.0L);
8894 # endif
8895       TEST_f_f (rint, -4503599627370495.5L, -4503599627370495.0L);
8896       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
8897       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
8898       TEST_f_f (rint, -4503599627370496.75L, -4503599627370496.0L);
8899       TEST_f_f (rint, -4503599627370497.5L, -4503599627370497.0L);
8900 # if LDBL_MANT_DIG > 100
8901       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370494.0L);
8902       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370495.0L);
8903       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370496.0L);
8904
8905       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
8906       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
8907       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
8908       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740991.0L);
8909       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740992.0L);
8910       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740993.0L);
8911
8912       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
8913       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
8914       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
8915       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740991.0L);
8916       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740992.0L);
8917       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L);
8918 # endif
8919 #endif
8920     }
8921
8922   fesetround (save_round_mode);
8923
8924   END (rint_towardzero);
8925 }
8926
8927 static void
8928 rint_test_downward (void)
8929 {
8930   int save_round_mode;
8931   START (rint_downward);
8932
8933   save_round_mode = fegetround ();
8934
8935   if (!fesetround (FE_DOWNWARD))
8936     {
8937       TEST_f_f (rint, 2.0, 2.0);
8938       TEST_f_f (rint, 1.5, 1.0);
8939       TEST_f_f (rint, 1.0, 1.0);
8940       TEST_f_f (rint, 0.5, 0.0);
8941       TEST_f_f (rint, 0.0, 0.0);
8942       TEST_f_f (rint, minus_zero, minus_zero);
8943       TEST_f_f (rint, -0.5, -1.0);
8944       TEST_f_f (rint, -1.0, -1.0);
8945       TEST_f_f (rint, -1.5, -2.0);
8946       TEST_f_f (rint, -2.0, -2.0);
8947       TEST_f_f (rint, 0.1, 0.0);
8948       TEST_f_f (rint, 0.25, 0.0);
8949       TEST_f_f (rint, 0.625, 0.0);
8950       TEST_f_f (rint, -0.1, -1.0);
8951       TEST_f_f (rint, -0.25, -1.0);
8952       TEST_f_f (rint, -0.625, -1.0);
8953       TEST_f_f (rint, 1048576.75, 1048576.0);
8954       TEST_f_f (rint, 2097152.75, 2097152.0);
8955       TEST_f_f (rint, -1048576.75, -1048577.0);
8956       TEST_f_f (rint, -2097152.75, -2097153.0);
8957 #ifndef TEST_FLOAT
8958       TEST_f_f (rint, 70368744177664.75, 70368744177664.0);
8959       TEST_f_f (rint, 140737488355328.75, 140737488355328.0);
8960       TEST_f_f (rint, 281474976710656.75, 281474976710656.0);
8961       TEST_f_f (rint, 562949953421312.75, 562949953421312.0);
8962       TEST_f_f (rint, 1125899906842624.75, 1125899906842624.0);
8963       TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
8964       TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
8965       TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
8966       TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
8967       TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
8968 #endif
8969 #ifdef TEST_LDOUBLE
8970       /* The result can only be represented in long double.  */
8971       TEST_f_f (rint, 4503599627370495.5L, 4503599627370495.0L);
8972       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
8973       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
8974       TEST_f_f (rint, 4503599627370496.75L, 4503599627370496.0L);
8975       TEST_f_f (rint, 4503599627370497.5L, 4503599627370497.0L);
8976 # if LDBL_MANT_DIG > 100
8977       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370494.0L);
8978       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370495.0L);
8979       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370496.0L);
8980 # endif
8981       TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
8982       TEST_f_f (rint, -4503599627370496.25L, -4503599627370497.0L);
8983       TEST_f_f (rint, -4503599627370496.5L, -4503599627370497.0L);
8984       TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
8985       TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
8986 # if LDBL_MANT_DIG > 100
8987       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
8988       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
8989       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
8990
8991       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
8992       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
8993       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
8994       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740991.0L);
8995       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740992.0L);
8996       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740993.0L);
8997
8998       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740992.0L);
8999       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740993.0L);
9000       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740994.0L);
9001       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
9002       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
9003       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
9004 # endif
9005 #endif
9006     }
9007
9008   fesetround (save_round_mode);
9009
9010   END (rint_downward);
9011 }
9012
9013 static void
9014 rint_test_upward (void)
9015 {
9016   int save_round_mode;
9017   START (rint_upward);
9018
9019   save_round_mode = fegetround ();
9020
9021   if (!fesetround (FE_UPWARD))
9022     {
9023       TEST_f_f (rint, 2.0, 2.0);
9024       TEST_f_f (rint, 1.5, 2.0);
9025       TEST_f_f (rint, 1.0, 1.0);
9026       TEST_f_f (rint, 0.5, 1.0);
9027       TEST_f_f (rint, 0.0, 0.0);
9028       TEST_f_f (rint, minus_zero, minus_zero);
9029       TEST_f_f (rint, -0.5, -0.0);
9030       TEST_f_f (rint, -1.0, -1.0);
9031       TEST_f_f (rint, -1.5, -1.0);
9032       TEST_f_f (rint, -2.0, -2.0);
9033       TEST_f_f (rint, 0.1, 1.0);
9034       TEST_f_f (rint, 0.25, 1.0);
9035       TEST_f_f (rint, 0.625, 1.0);
9036       TEST_f_f (rint, -0.1, -0.0);
9037       TEST_f_f (rint, -0.25, -0.0);
9038       TEST_f_f (rint, -0.625, -0.0);
9039       TEST_f_f (rint, 1048576.75, 1048577.0);
9040       TEST_f_f (rint, 2097152.75, 2097153.0);
9041       TEST_f_f (rint, -1048576.75, -1048576.0);
9042       TEST_f_f (rint, -2097152.75, -2097152.0);
9043 #ifndef TEST_FLOAT
9044       TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
9045       TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
9046       TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
9047       TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
9048       TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
9049       TEST_f_f (rint, -70368744177664.75, -70368744177664.0);
9050       TEST_f_f (rint, -140737488355328.75, -140737488355328.0);
9051       TEST_f_f (rint, -281474976710656.75, -281474976710656.0);
9052       TEST_f_f (rint, -562949953421312.75, -562949953421312.0);
9053       TEST_f_f (rint, -1125899906842624.75, -1125899906842624.0);
9054 #endif
9055 #ifdef TEST_LDOUBLE
9056       /* The result can only be represented in long double.  */
9057       TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
9058       TEST_f_f (rint, 4503599627370496.25L, 4503599627370497.0L);
9059       TEST_f_f (rint, 4503599627370496.5L, 4503599627370497.0L);
9060       TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
9061       TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
9062 # if LDBL_MANT_DIG > 100
9063       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
9064       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
9065       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
9066 # endif
9067       TEST_f_f (rint, -4503599627370495.5L, -4503599627370495.0L);
9068       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
9069       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
9070       TEST_f_f (rint, -4503599627370496.75L, -4503599627370496.0L);
9071       TEST_f_f (rint, -4503599627370497.5L, -4503599627370497.0L);
9072 # if LDBL_MANT_DIG > 100
9073       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370494.0L);
9074       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370495.0L);
9075       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370496.0L);
9076
9077       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740992.0L);
9078       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740993.0L);
9079       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740994.0L);
9080       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
9081       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
9082       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
9083
9084       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
9085       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
9086       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
9087       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740991.0L);
9088       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740992.0L);
9089       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L);
9090 # endif
9091 #endif
9092     }
9093
9094   fesetround (save_round_mode);
9095
9096   END (rint_upward);
9097 }
9098
9099 static void
9100 round_test (void)
9101 {
9102   START (round);
9103
9104   TEST_f_f (round, 0, 0);
9105   TEST_f_f (round, minus_zero, minus_zero);
9106   TEST_f_f (round, 0.2L, 0.0);
9107   TEST_f_f (round, -0.2L, minus_zero);
9108   TEST_f_f (round, 0.5, 1.0);
9109   TEST_f_f (round, -0.5, -1.0);
9110   TEST_f_f (round, 0.8L, 1.0);
9111   TEST_f_f (round, -0.8L, -1.0);
9112   TEST_f_f (round, 1.5, 2.0);
9113   TEST_f_f (round, -1.5, -2.0);
9114   TEST_f_f (round, 0.1, 0.0);
9115   TEST_f_f (round, 0.25, 0.0);
9116   TEST_f_f (round, 0.625, 1.0);
9117   TEST_f_f (round, -0.1, -0.0);
9118   TEST_f_f (round, -0.25, -0.0);
9119   TEST_f_f (round, -0.625, -1.0);
9120   TEST_f_f (round, 2097152.5, 2097153);
9121   TEST_f_f (round, -2097152.5, -2097153);
9122
9123 #ifdef TEST_LDOUBLE
9124   /* The result can only be represented in long double.  */
9125   TEST_f_f (round, 4503599627370495.5L, 4503599627370496.0L);
9126   TEST_f_f (round, 4503599627370496.25L, 4503599627370496.0L);
9127   TEST_f_f (round, 4503599627370496.5L, 4503599627370497.0L);
9128   TEST_f_f (round, 4503599627370496.75L, 4503599627370497.0L);
9129   TEST_f_f (round, 4503599627370497.5L, 4503599627370498.0L);
9130 # if LDBL_MANT_DIG > 100
9131   TEST_f_f (round, 4503599627370494.5000000000001L, 4503599627370495.0L);
9132   TEST_f_f (round, 4503599627370495.5000000000001L, 4503599627370496.0L);
9133   TEST_f_f (round, 4503599627370496.5000000000001L, 4503599627370497.0L);
9134 # endif
9135
9136   TEST_f_f (round, -4503599627370495.5L, -4503599627370496.0L);
9137   TEST_f_f (round, -4503599627370496.25L, -4503599627370496.0L);
9138   TEST_f_f (round, -4503599627370496.5L, -4503599627370497.0L);
9139   TEST_f_f (round, -4503599627370496.75L, -4503599627370497.0L);
9140   TEST_f_f (round, -4503599627370497.5L, -4503599627370498.0L);
9141 # if LDBL_MANT_DIG > 100
9142   TEST_f_f (round, -4503599627370494.5000000000001L, -4503599627370495.0L);
9143   TEST_f_f (round, -4503599627370495.5000000000001L, -4503599627370496.0L);
9144   TEST_f_f (round, -4503599627370496.5000000000001L, -4503599627370497.0L);
9145 # endif
9146
9147   TEST_f_f (round, 9007199254740991.5L, 9007199254740992.0L);
9148   TEST_f_f (round, 9007199254740992.25L, 9007199254740992.0L);
9149   TEST_f_f (round, 9007199254740992.5L, 9007199254740993.0L);
9150   TEST_f_f (round, 9007199254740992.75L, 9007199254740993.0L);
9151   TEST_f_f (round, 9007199254740993.5L, 9007199254740994.0L);
9152
9153   TEST_f_f (round, -9007199254740991.5L, -9007199254740992.0L);
9154   TEST_f_f (round, -9007199254740992.25L, -9007199254740992.0L);
9155   TEST_f_f (round, -9007199254740992.5L, -9007199254740993.0L);
9156   TEST_f_f (round, -9007199254740992.75L, -9007199254740993.0L);
9157   TEST_f_f (round, -9007199254740993.5L, -9007199254740994.0L);
9158
9159 # if LDBL_MANT_DIG > 100
9160   TEST_f_f (round, 9007199254740991.0000000000001L, 9007199254740991.0L);
9161   TEST_f_f (round, 9007199254740992.0000000000001L, 9007199254740992.0L);
9162   TEST_f_f (round, 9007199254740993.0000000000001L, 9007199254740993.0L);
9163   TEST_f_f (round, 9007199254740991.5000000000001L, 9007199254740992.0L);
9164   TEST_f_f (round, 9007199254740992.5000000000001L, 9007199254740993.0L);
9165   TEST_f_f (round, 9007199254740993.5000000000001L, 9007199254740994.0L);
9166
9167   TEST_f_f (round, -9007199254740991.0000000000001L, -9007199254740991.0L);
9168   TEST_f_f (round, -9007199254740992.0000000000001L, -9007199254740992.0L);
9169   TEST_f_f (round, -9007199254740993.0000000000001L, -9007199254740993.0L);
9170   TEST_f_f (round, -9007199254740991.5000000000001L, -9007199254740992.0L);
9171   TEST_f_f (round, -9007199254740992.5000000000001L, -9007199254740993.0L);
9172   TEST_f_f (round, -9007199254740993.5000000000001L, -9007199254740994.0L);
9173 # endif
9174
9175   TEST_f_f (round, 72057594037927935.5L, 72057594037927936.0L);
9176   TEST_f_f (round, 72057594037927936.25L, 72057594037927936.0L);
9177   TEST_f_f (round, 72057594037927936.5L, 72057594037927937.0L);
9178   TEST_f_f (round, 72057594037927936.75L, 72057594037927937.0L);
9179   TEST_f_f (round, 72057594037927937.5L, 72057594037927938.0L);
9180
9181   TEST_f_f (round, -72057594037927935.5L, -72057594037927936.0L);
9182   TEST_f_f (round, -72057594037927936.25L, -72057594037927936.0L);
9183   TEST_f_f (round, -72057594037927936.5L, -72057594037927937.0L);
9184   TEST_f_f (round, -72057594037927936.75L, -72057594037927937.0L);
9185   TEST_f_f (round, -72057594037927937.5L, -72057594037927938.0L);
9186
9187   TEST_f_f (round, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
9188   TEST_f_f (round, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
9189   TEST_f_f (round, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
9190   TEST_f_f (round, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
9191   TEST_f_f (round, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
9192 #endif
9193
9194   END (round);
9195 }
9196
9197
9198 static void
9199 scalb_test (void)
9200 {
9201
9202   START (scalb);
9203
9204   TEST_ff_f (scalb, 2.0, 0.5, nan_value, INVALID_EXCEPTION);
9205   TEST_ff_f (scalb, 3.0, -2.5, nan_value, INVALID_EXCEPTION);
9206
9207   TEST_ff_f (scalb, 0, nan_value, nan_value);
9208   TEST_ff_f (scalb, 1, nan_value, nan_value);
9209
9210   TEST_ff_f (scalb, 1, 0, 1);
9211   TEST_ff_f (scalb, -1, 0, -1);
9212
9213   TEST_ff_f (scalb, 0, plus_infty, nan_value, INVALID_EXCEPTION);
9214   TEST_ff_f (scalb, minus_zero, plus_infty, nan_value, INVALID_EXCEPTION);
9215
9216   TEST_ff_f (scalb, 0, 2, 0);
9217   TEST_ff_f (scalb, minus_zero, -4, minus_zero);
9218   TEST_ff_f (scalb, 0, 0, 0);
9219   TEST_ff_f (scalb, minus_zero, 0, minus_zero);
9220   TEST_ff_f (scalb, 0, -1, 0);
9221   TEST_ff_f (scalb, minus_zero, -10, minus_zero);
9222   TEST_ff_f (scalb, 0, minus_infty, 0);
9223   TEST_ff_f (scalb, minus_zero, minus_infty, minus_zero);
9224
9225   TEST_ff_f (scalb, plus_infty, -1, plus_infty);
9226   TEST_ff_f (scalb, minus_infty, -10, minus_infty);
9227   TEST_ff_f (scalb, plus_infty, 0, plus_infty);
9228   TEST_ff_f (scalb, minus_infty, 0, minus_infty);
9229   TEST_ff_f (scalb, plus_infty, 2, plus_infty);
9230   TEST_ff_f (scalb, minus_infty, 100, minus_infty);
9231
9232   TEST_ff_f (scalb, 0.1L, minus_infty, 0.0);
9233   TEST_ff_f (scalb, -0.1L, minus_infty, minus_zero);
9234
9235   TEST_ff_f (scalb, 1, plus_infty, plus_infty);
9236   TEST_ff_f (scalb, -1, plus_infty, minus_infty);
9237   TEST_ff_f (scalb, plus_infty, plus_infty, plus_infty);
9238   TEST_ff_f (scalb, minus_infty, plus_infty, minus_infty);
9239
9240   TEST_ff_f (scalb, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
9241   TEST_ff_f (scalb, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
9242
9243   TEST_ff_f (scalb, nan_value, 1, nan_value);
9244   TEST_ff_f (scalb, 1, nan_value, nan_value);
9245   TEST_ff_f (scalb, nan_value, 0, nan_value);
9246   TEST_ff_f (scalb, 0, nan_value, nan_value);
9247   TEST_ff_f (scalb, nan_value, plus_infty, nan_value);
9248   TEST_ff_f (scalb, plus_infty, nan_value, nan_value);
9249   TEST_ff_f (scalb, nan_value, nan_value, nan_value);
9250
9251   TEST_ff_f (scalb, 0.8L, 4, 12.8L);
9252   TEST_ff_f (scalb, -0.854375L, 5, -27.34L);
9253
9254   END (scalb);
9255 }
9256
9257
9258 static void
9259 scalbn_test (void)
9260 {
9261
9262   START (scalbn);
9263
9264   TEST_fi_f (scalbn, 0, 0, 0);
9265   TEST_fi_f (scalbn, minus_zero, 0, minus_zero);
9266
9267   TEST_fi_f (scalbn, plus_infty, 1, plus_infty);
9268   TEST_fi_f (scalbn, minus_infty, 1, minus_infty);
9269   TEST_fi_f (scalbn, nan_value, 1, nan_value);
9270
9271   TEST_fi_f (scalbn, 0.8L, 4, 12.8L);
9272   TEST_fi_f (scalbn, -0.854375L, 5, -27.34L);
9273
9274   TEST_fi_f (scalbn, 1, 0L, 1);
9275
9276   TEST_fi_f (scalbn, 1, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9277   TEST_fi_f (scalbn, 1, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9278   TEST_fi_f (scalbn, max_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9279   TEST_fi_f (scalbn, max_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9280   TEST_fi_f (scalbn, min_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9281   TEST_fi_f (scalbn, min_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9282   TEST_fi_f (scalbn, min_value / 4, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9283   TEST_fi_f (scalbn, min_value / 4, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9284
9285   END (scalbn);
9286 }
9287
9288
9289 static void
9290 scalbln_test (void)
9291 {
9292
9293   START (scalbln);
9294
9295   TEST_fl_f (scalbln, 0, 0, 0);
9296   TEST_fl_f (scalbln, minus_zero, 0, minus_zero);
9297
9298   TEST_fl_f (scalbln, plus_infty, 1, plus_infty);
9299   TEST_fl_f (scalbln, minus_infty, 1, minus_infty);
9300   TEST_fl_f (scalbln, nan_value, 1, nan_value);
9301
9302   TEST_fl_f (scalbln, 0.8L, 4, 12.8L);
9303   TEST_fl_f (scalbln, -0.854375L, 5, -27.34L);
9304
9305   TEST_fl_f (scalbln, 1, 0L, 1);
9306
9307   TEST_fi_f (scalbln, 1, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9308   TEST_fi_f (scalbln, 1, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9309   TEST_fi_f (scalbln, max_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9310   TEST_fi_f (scalbln, max_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9311   TEST_fi_f (scalbln, min_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9312   TEST_fi_f (scalbln, min_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9313   TEST_fi_f (scalbln, min_value / 4, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9314   TEST_fi_f (scalbln, min_value / 4, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9315
9316   TEST_fi_f (scalbln, 1, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
9317   TEST_fi_f (scalbln, 1, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9318   TEST_fi_f (scalbln, max_value, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
9319   TEST_fi_f (scalbln, max_value, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9320   TEST_fi_f (scalbln, min_value, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
9321   TEST_fi_f (scalbln, min_value, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9322   TEST_fi_f (scalbln, min_value / 4, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
9323   TEST_fi_f (scalbln, min_value / 4, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9324
9325 #if LONG_MAX >= 0x100000000
9326   TEST_fi_f (scalbln, 1, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
9327   TEST_fi_f (scalbln, 1, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
9328   TEST_fi_f (scalbln, max_value, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
9329   TEST_fi_f (scalbln, max_value, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
9330   TEST_fi_f (scalbln, min_value, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
9331   TEST_fi_f (scalbln, min_value, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
9332   TEST_fi_f (scalbln, min_value / 4, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
9333   TEST_fi_f (scalbln, min_value / 4, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
9334 #endif
9335
9336   END (scalbn);
9337 }
9338
9339
9340 static void
9341 signbit_test (void)
9342 {
9343
9344   START (signbit);
9345
9346   TEST_f_b (signbit, 0, 0);
9347   TEST_f_b (signbit, minus_zero, 1);
9348   TEST_f_b (signbit, plus_infty, 0);
9349   TEST_f_b (signbit, minus_infty, 1);
9350
9351   /* signbit (x) != 0 for x < 0.  */
9352   TEST_f_b (signbit, -1, 1);
9353   /* signbit (x) == 0 for x >= 0.  */
9354   TEST_f_b (signbit, 1, 0);
9355
9356   END (signbit);
9357 }
9358
9359
9360 static void
9361 sin_test (void)
9362 {
9363   errno = 0;
9364   FUNC(sin) (0);
9365   if (errno == ENOSYS)
9366     /* Function not implemented.  */
9367     return;
9368
9369   START (sin);
9370
9371   TEST_f_f (sin, 0, 0);
9372   TEST_f_f (sin, minus_zero, minus_zero);
9373   errno = 0;
9374   TEST_f_f (sin, plus_infty, nan_value, INVALID_EXCEPTION);
9375   check_int ("errno for sin(+inf) == EDOM", errno, EDOM, 0, 0, 0);
9376   errno = 0;
9377   TEST_f_f (sin, minus_infty, nan_value, INVALID_EXCEPTION);
9378   check_int ("errno for sin(-inf) == EDOM", errno, EDOM, 0, 0, 0);
9379   errno = 0;
9380   TEST_f_f (sin, nan_value, nan_value);
9381   check_int ("errno for sin(NaN) unchanged", errno, 0, 0, 0, 0);
9382
9383   TEST_f_f (sin, M_PI_6l, 0.5);
9384   TEST_f_f (sin, -M_PI_6l, -0.5);
9385   TEST_f_f (sin, M_PI_2l, 1);
9386   TEST_f_f (sin, -M_PI_2l, -1);
9387   TEST_f_f (sin, 0.75L, 0.681638760023334166733241952779893935L);
9388
9389   TEST_f_f (sin, 0x1p65, -0.047183876212354673805106149805700013943218L);
9390   TEST_f_f (sin, -0x1p65, 0.047183876212354673805106149805700013943218L);
9391
9392   TEST_f_f (sin, 0x1.7f4134p+103, -6.6703229329788657073304190650534846045235e-08L);
9393
9394 #ifdef TEST_DOUBLE
9395   TEST_f_f (sin, 0.80190127184058835, 0.71867942238767868);
9396   TEST_f_f (sin, 2.522464e-1, 2.4957989804940911e-1);
9397 #endif
9398
9399 #ifndef TEST_FLOAT
9400   TEST_f_f (sin, 1e22, -0.8522008497671888017727058937530293682618L);
9401   TEST_f_f (sin, 0x1p1023, 0.5631277798508840134529434079444683477104L);
9402 #endif
9403
9404 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
9405   TEST_f_f (sin, 0x1p16383L, 0.3893629985894208126948115852610595405563L);
9406 #endif
9407
9408   TEST_f_f (sin, 0x1p+120, 3.77820109360752022655548470056922991960587e-01L);
9409   TEST_f_f (sin, 0x1p+127, 6.23385512955870240370428801097126489001833e-01L);
9410   TEST_f_f (sin, 0x1.fffff8p+127, 4.85786063130487339701113680434728152037092e-02L);
9411   TEST_f_f (sin, 0x1.fffffep+127, -5.21876523333658540551505357019806722935726e-01L);
9412   TEST_f_f (sin, 0x1p+50, 4.96396515208940840876821859865411368093356e-01L);
9413   TEST_f_f (sin, 0x1p+28, -9.86198211836975655703110310527108292055548e-01L);
9414
9415   END (sin);
9416
9417 }
9418
9419
9420 static void
9421 sin_test_tonearest (void)
9422 {
9423   int save_round_mode;
9424   errno = 0;
9425   FUNC(sin) (0);
9426   if (errno == ENOSYS)
9427     /* Function not implemented.  */
9428     return;
9429
9430   START (sin_tonearest);
9431
9432   save_round_mode = fegetround ();
9433
9434   if (!fesetround (FE_TONEAREST))
9435     {
9436       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
9437       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
9438       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
9439       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
9440       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
9441       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
9442       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
9443       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
9444       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
9445       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
9446     }
9447
9448   fesetround (save_round_mode);
9449
9450   END (sin_tonearest);
9451 }
9452
9453
9454 static void
9455 sin_test_towardzero (void)
9456 {
9457   int save_round_mode;
9458   errno = 0;
9459   FUNC(sin) (0);
9460   if (errno == ENOSYS)
9461     /* Function not implemented.  */
9462     return;
9463
9464   START (sin_towardzero);
9465
9466   save_round_mode = fegetround ();
9467
9468   if (!fesetround (FE_TOWARDZERO))
9469     {
9470       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
9471       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
9472       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
9473       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
9474       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
9475       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
9476       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
9477       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
9478       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
9479       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
9480     }
9481
9482   fesetround (save_round_mode);
9483
9484   END (sin_towardzero);
9485 }
9486
9487
9488 static void
9489 sin_test_downward (void)
9490 {
9491   int save_round_mode;
9492   errno = 0;
9493   FUNC(sin) (0);
9494   if (errno == ENOSYS)
9495     /* Function not implemented.  */
9496     return;
9497
9498   START (sin_downward);
9499
9500   save_round_mode = fegetround ();
9501
9502   if (!fesetround (FE_DOWNWARD))
9503     {
9504       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
9505       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
9506       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
9507       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
9508       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
9509       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
9510       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
9511       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
9512       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
9513       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
9514     }
9515
9516   fesetround (save_round_mode);
9517
9518   END (sin_downward);
9519 }
9520
9521
9522 static void
9523 sin_test_upward (void)
9524 {
9525   int save_round_mode;
9526   errno = 0;
9527   FUNC(sin) (0);
9528   if (errno == ENOSYS)
9529     /* Function not implemented.  */
9530     return;
9531
9532   START (sin_upward);
9533
9534   save_round_mode = fegetround ();
9535
9536   if (!fesetround (FE_UPWARD))
9537     {
9538       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
9539       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
9540       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
9541       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
9542       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
9543       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
9544       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
9545       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
9546       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
9547       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
9548     }
9549
9550   fesetround (save_round_mode);
9551
9552   END (sin_upward);
9553 }
9554
9555
9556 static void
9557 sincos_test (void)
9558 {
9559   FLOAT sin_res, cos_res;
9560
9561   errno = 0;
9562   FUNC(sincos) (0, &sin_res, &cos_res);
9563   if (errno == ENOSYS)
9564     /* Function not implemented.  */
9565     return;
9566
9567   START (sincos);
9568
9569   /* sincos is treated differently because it returns void.  */
9570   TEST_extra (sincos, 0, 0, 1);
9571
9572   TEST_extra (sincos, minus_zero, minus_zero, 1);
9573   TEST_extra (sincos, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
9574   TEST_extra (sincos, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
9575   TEST_extra (sincos, nan_value, nan_value, nan_value);
9576
9577   TEST_extra (sincos, M_PI_2l, 1, 0);
9578   TEST_extra (sincos, M_PI_6l, 0.5, 0.86602540378443864676372317075293616L);
9579   TEST_extra (sincos, M_PI_6l*2.0, 0.86602540378443864676372317075293616L, 0.5);
9580   TEST_extra (sincos, 0.75L, 0.681638760023334166733241952779893935L, 0.731688868873820886311838753000084544L);
9581
9582   TEST_extra (sincos, 0x1p65, -0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L);
9583   TEST_extra (sincos, -0x1p65, 0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L);
9584
9585 #ifdef TEST_DOUBLE
9586   TEST_extra (sincos, 0.80190127184058835, 0.71867942238767868, 0.69534156199418473);
9587 #endif
9588
9589 #ifndef TEST_FLOAT
9590   TEST_extra (sincos, 1e22, -0.8522008497671888017727058937530293682618L, 0.5232147853951389454975944733847094921409L);
9591   TEST_extra (sincos, 0x1p1023, 0.5631277798508840134529434079444683477104L, -0.826369834614147994500785680811743734805L);
9592 #endif
9593
9594 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
9595   TEST_extra (sincos, 0x1p16383L, 0.3893629985894208126948115852610595405563L, 0.9210843909921906206874509522505756251609L);
9596 #endif
9597
9598   TEST_extra (sincos, 0x1p+120, 3.77820109360752022655548470056922991960587e-01L, -9.25879022854837867303861764107414946730833e-01L);
9599   TEST_extra (sincos, 0x1p+127, 6.23385512955870240370428801097126489001833e-01L, 7.81914638714960072263910298466369236613162e-01L);
9600   TEST_extra (sincos, 0x1.fffff8p+127, 4.85786063130487339701113680434728152037092e-02L, 9.98819362551949040703862043664101081064641e-01L);
9601   TEST_extra (sincos, 0x1.fffffep+127, -5.21876523333658540551505357019806722935726e-01L, 8.53021039830304158051791467692161107353094e-01L);
9602   TEST_extra (sincos, 0x1p+50, 4.96396515208940840876821859865411368093356e-01L, 8.68095904660550604334592502063501320395739e-01L);
9603   TEST_extra (sincos, 0x1p+28, -9.86198211836975655703110310527108292055548e-01L, -1.65568979490578758865468278195361551113358e-01L);
9604
9605   END (sincos);
9606 }
9607
9608 static void
9609 sinh_test (void)
9610 {
9611   errno = 0;
9612   FUNC(sinh) (0.7L);
9613   if (errno == ENOSYS)
9614     /* Function not implemented.  */
9615     return;
9616
9617   START (sinh);
9618   TEST_f_f (sinh, 0, 0);
9619   TEST_f_f (sinh, minus_zero, minus_zero);
9620
9621 #ifndef TEST_INLINE
9622   TEST_f_f (sinh, plus_infty, plus_infty);
9623   TEST_f_f (sinh, minus_infty, minus_infty);
9624 #endif
9625   TEST_f_f (sinh, nan_value, nan_value);
9626
9627   TEST_f_f (sinh, 0.75L, 0.822316731935829980703661634446913849L);
9628   TEST_f_f (sinh, 0x8p-32L, 1.86264514923095703232705808926175479e-9L);
9629
9630   END (sinh);
9631 }
9632
9633
9634 static void
9635 sinh_test_tonearest (void)
9636 {
9637   int save_round_mode;
9638   errno = 0;
9639   FUNC(sinh) (0);
9640   if (errno == ENOSYS)
9641     /* Function not implemented.  */
9642     return;
9643
9644   START (sinh_tonearest);
9645
9646   save_round_mode = fegetround ();
9647
9648   if (!fesetround (FE_TONEAREST))
9649     {
9650       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
9651       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
9652       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
9653     }
9654
9655   fesetround (save_round_mode);
9656
9657   END (sinh_tonearest);
9658 }
9659
9660
9661 static void
9662 sinh_test_towardzero (void)
9663 {
9664   int save_round_mode;
9665   errno = 0;
9666   FUNC(sinh) (0);
9667   if (errno == ENOSYS)
9668     /* Function not implemented.  */
9669     return;
9670
9671   START (sinh_towardzero);
9672
9673   save_round_mode = fegetround ();
9674
9675   if (!fesetround (FE_TOWARDZERO))
9676     {
9677       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
9678       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
9679       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
9680     }
9681
9682   fesetround (save_round_mode);
9683
9684   END (sinh_towardzero);
9685 }
9686
9687
9688 static void
9689 sinh_test_downward (void)
9690 {
9691   int save_round_mode;
9692   errno = 0;
9693   FUNC(sinh) (0);
9694   if (errno == ENOSYS)
9695     /* Function not implemented.  */
9696     return;
9697
9698   START (sinh_downward);
9699
9700   save_round_mode = fegetround ();
9701
9702   if (!fesetround (FE_DOWNWARD))
9703     {
9704       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
9705       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
9706       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
9707     }
9708
9709   fesetround (save_round_mode);
9710
9711   END (sinh_downward);
9712 }
9713
9714
9715 static void
9716 sinh_test_upward (void)
9717 {
9718   int save_round_mode;
9719   errno = 0;
9720   FUNC(sinh) (0);
9721   if (errno == ENOSYS)
9722     /* Function not implemented.  */
9723     return;
9724
9725   START (sinh_upward);
9726
9727   save_round_mode = fegetround ();
9728
9729   if (!fesetround (FE_UPWARD))
9730     {
9731       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
9732       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
9733       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
9734     }
9735
9736   fesetround (save_round_mode);
9737
9738   END (sinh_upward);
9739 }
9740
9741
9742 static void
9743 sqrt_test (void)
9744 {
9745   errno = 0;
9746   FUNC(sqrt) (1);
9747   if (errno == ENOSYS)
9748     /* Function not implemented.  */
9749     return;
9750
9751   START (sqrt);
9752
9753   TEST_f_f (sqrt, 0, 0);
9754   TEST_f_f (sqrt, nan_value, nan_value);
9755   TEST_f_f (sqrt, plus_infty, plus_infty);
9756
9757   TEST_f_f (sqrt, minus_zero, minus_zero);
9758
9759   /* sqrt (x) == NaN plus invalid exception for x < 0.  */
9760   TEST_f_f (sqrt, -1, nan_value, INVALID_EXCEPTION);
9761   TEST_f_f (sqrt, -max_value, nan_value, INVALID_EXCEPTION);
9762   TEST_f_f (sqrt, minus_infty, nan_value, INVALID_EXCEPTION);
9763   TEST_f_f (sqrt, nan_value, nan_value);
9764
9765   TEST_f_f (sqrt, 2209, 47);
9766   TEST_f_f (sqrt, 4, 2);
9767   TEST_f_f (sqrt, 2, M_SQRT2l);
9768   TEST_f_f (sqrt, 0.25, 0.5);
9769   TEST_f_f (sqrt, 6642.25, 81.5);
9770   TEST_f_f (sqrt, 15190.5625L, 123.25L);
9771   TEST_f_f (sqrt, 0.75L, 0.866025403784438646763723170752936183L);
9772
9773   END (sqrt);
9774 }
9775
9776
9777 static void
9778 tan_test (void)
9779 {
9780   errno = 0;
9781   FUNC(tan) (0);
9782   if (errno == ENOSYS)
9783     /* Function not implemented.  */
9784     return;
9785
9786   START (tan);
9787
9788   TEST_f_f (tan, 0, 0);
9789   TEST_f_f (tan, minus_zero, minus_zero);
9790   errno = 0;
9791   TEST_f_f (tan, plus_infty, nan_value, INVALID_EXCEPTION);
9792   check_int ("errno for tan(Inf) == EDOM", errno, EDOM, 0, 0, 0);
9793   errno = 0;
9794   TEST_f_f (tan, minus_infty, nan_value, INVALID_EXCEPTION);
9795   check_int ("errno for tan(-Inf) == EDOM", errno, EDOM, 0, 0, 0);
9796   errno = 0;
9797   TEST_f_f (tan, nan_value, nan_value);
9798   check_int ("errno for tan(NaN) == 0", errno, 0, 0, 0, 0);
9799
9800   TEST_f_f (tan, M_PI_4l, 1);
9801   TEST_f_f (tan, 0.75L, 0.931596459944072461165202756573936428L);
9802
9803   TEST_f_f (tan, 0x1p65, -0.0472364872359047946798414219288370688827L);
9804   TEST_f_f (tan, -0x1p65, 0.0472364872359047946798414219288370688827L);
9805
9806   TEST_f_f (tan, 0xc.9p-4, 0.9995162902115457818029468900654150261381L);
9807   TEST_f_f (tan, 0xc.908p-4, 0.9997603425502441410973077452249560802034L);
9808   TEST_f_f (tan, 0xc.90cp-4, 0.9998823910588060302788513970802357770031L);
9809   TEST_f_f (tan, 0xc.90ep-4, 0.9999434208994808753305784795924711152508L);
9810   TEST_f_f (tan, 0xc.90fp-4, 0.9999739372166156702433266059635165160515L);
9811   TEST_f_f (tan, 0xc.90f8p-4, 0.9999891957244072765118898375645469865764L);
9812   TEST_f_f (tan, 0xc.90fcp-4, 0.9999968250656122402859679132395522927393L);
9813   TEST_f_f (tan, 0xc.90fdp-4, 0.9999987324100083358016192309006353329444L);
9814   TEST_f_f (tan, 0xc.90fd8p-4, 0.9999996860835706212861509874451585282616L);
9815   TEST_f_f (tan, 0xc.90fdap-4, 0.9999999245021033010474530133665235922808L);
9816   TEST_f_f (tan, 0xc.ap-4, 1.0073556597407272165371804539701396631519L);
9817   TEST_f_f (tan, 0xc.98p-4, 1.0034282930863044654045449407466962736255L);
9818   TEST_f_f (tan, 0xc.94p-4, 1.0014703786820082237342656561856877993328L);
9819   TEST_f_f (tan, 0xc.92p-4, 1.0004928571392300571266638743539017593717L);
9820   TEST_f_f (tan, 0xc.91p-4, 1.0000044544650244953647966900221905361131L);
9821   TEST_f_f (tan, 0xc.90fep-4, 1.0000006397580424009014454926842136804016L);
9822   TEST_f_f (tan, 0xc.90fdcp-4, 1.0000001629206928242190327320047489394217L);
9823   TEST_f_f (tan, 0xc.90fdbp-4, 1.0000000437113909572052640953950483705005L);
9824
9825   TEST_f_f (tan, -0xc.9p-4, -0.9995162902115457818029468900654150261381L);
9826   TEST_f_f (tan, -0xc.908p-4, -0.9997603425502441410973077452249560802034L);
9827   TEST_f_f (tan, -0xc.90cp-4, -0.9998823910588060302788513970802357770031L);
9828   TEST_f_f (tan, -0xc.90ep-4, -0.9999434208994808753305784795924711152508L);
9829   TEST_f_f (tan, -0xc.90fp-4, -0.9999739372166156702433266059635165160515L);
9830   TEST_f_f (tan, -0xc.90f8p-4, -0.9999891957244072765118898375645469865764L);
9831   TEST_f_f (tan, -0xc.90fcp-4, -0.9999968250656122402859679132395522927393L);
9832   TEST_f_f (tan, -0xc.90fdp-4, -0.9999987324100083358016192309006353329444L);
9833   TEST_f_f (tan, -0xc.90fd8p-4, -0.9999996860835706212861509874451585282616L);
9834   TEST_f_f (tan, -0xc.90fdap-4, -0.9999999245021033010474530133665235922808L);
9835   TEST_f_f (tan, -0xc.ap-4, -1.0073556597407272165371804539701396631519L);
9836   TEST_f_f (tan, -0xc.98p-4, -1.0034282930863044654045449407466962736255L);
9837   TEST_f_f (tan, -0xc.94p-4, -1.0014703786820082237342656561856877993328L);
9838   TEST_f_f (tan, -0xc.92p-4, -1.0004928571392300571266638743539017593717L);
9839   TEST_f_f (tan, -0xc.91p-4, -1.0000044544650244953647966900221905361131L);
9840   TEST_f_f (tan, -0xc.90fep-4, -1.0000006397580424009014454926842136804016L);
9841   TEST_f_f (tan, -0xc.90fdcp-4, -1.0000001629206928242190327320047489394217L);
9842   TEST_f_f (tan, -0xc.90fdbp-4, -1.0000000437113909572052640953950483705005L);
9843
9844 #ifndef TEST_FLOAT
9845   TEST_f_f (tan, 1e22, -1.628778225606898878549375936939548513545L);
9846   TEST_f_f (tan, 0x1p1023, -0.6814476476066215012854144040167365190368L);
9847 #endif
9848
9849 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
9850   TEST_f_f (tan, 0x1p16383L, 0.422722393732022337800504160054440141575L);
9851 #endif
9852
9853   END (tan);
9854 }
9855
9856
9857 static void
9858 tan_test_tonearest (void)
9859 {
9860   int save_round_mode;
9861   errno = 0;
9862   FUNC(tan) (0);
9863   if (errno == ENOSYS)
9864     /* Function not implemented.  */
9865     return;
9866
9867   START (tan_tonearest);
9868
9869   save_round_mode = fegetround ();
9870
9871   if (!fesetround (FE_TONEAREST))
9872     {
9873       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
9874       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
9875       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
9876       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
9877       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
9878       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
9879       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
9880       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
9881       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
9882       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
9883     }
9884
9885   fesetround (save_round_mode);
9886
9887   END (tan_tonearest);
9888 }
9889
9890
9891 static void
9892 tan_test_towardzero (void)
9893 {
9894   int save_round_mode;
9895   errno = 0;
9896   FUNC(tan) (0);
9897   if (errno == ENOSYS)
9898     /* Function not implemented.  */
9899     return;
9900
9901   START (tan_towardzero);
9902
9903   save_round_mode = fegetround ();
9904
9905   if (!fesetround (FE_TOWARDZERO))
9906     {
9907       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
9908       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
9909       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
9910       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
9911       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
9912       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
9913       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
9914       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
9915       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
9916       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
9917     }
9918
9919   fesetround (save_round_mode);
9920
9921   END (tan_towardzero);
9922 }
9923
9924
9925 static void
9926 tan_test_downward (void)
9927 {
9928   int save_round_mode;
9929   errno = 0;
9930   FUNC(tan) (0);
9931   if (errno == ENOSYS)
9932     /* Function not implemented.  */
9933     return;
9934
9935   START (tan_downward);
9936
9937   save_round_mode = fegetround ();
9938
9939   if (!fesetround (FE_DOWNWARD))
9940     {
9941       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
9942       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
9943       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
9944       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
9945       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
9946       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
9947       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
9948       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
9949       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
9950       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
9951     }
9952
9953   fesetround (save_round_mode);
9954
9955   END (tan_downward);
9956 }
9957
9958
9959 static void
9960 tan_test_upward (void)
9961 {
9962   int save_round_mode;
9963   errno = 0;
9964   FUNC(tan) (0);
9965   if (errno == ENOSYS)
9966     /* Function not implemented.  */
9967     return;
9968
9969   START (tan_upward);
9970
9971   save_round_mode = fegetround ();
9972
9973   if (!fesetround (FE_UPWARD))
9974     {
9975       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
9976       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
9977       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
9978       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
9979       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
9980       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
9981       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
9982       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
9983       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
9984       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
9985     }
9986
9987   fesetround (save_round_mode);
9988
9989   END (tan_upward);
9990 }
9991
9992
9993 static void
9994 tanh_test (void)
9995 {
9996   errno = 0;
9997   FUNC(tanh) (0.7L);
9998   if (errno == ENOSYS)
9999     /* Function not implemented.  */
10000     return;
10001
10002   START (tanh);
10003
10004   TEST_f_f (tanh, 0, 0);
10005   TEST_f_f (tanh, minus_zero, minus_zero);
10006
10007 #ifndef TEST_INLINE
10008   TEST_f_f (tanh, plus_infty, 1);
10009   TEST_f_f (tanh, minus_infty, -1);
10010 #endif
10011   TEST_f_f (tanh, nan_value, nan_value);
10012
10013   TEST_f_f (tanh, 0.75L, 0.635148952387287319214434357312496495L);
10014   TEST_f_f (tanh, -0.75L, -0.635148952387287319214434357312496495L);
10015
10016   TEST_f_f (tanh, 1.0L, 0.7615941559557648881194582826047935904L);
10017   TEST_f_f (tanh, -1.0L, -0.7615941559557648881194582826047935904L);
10018
10019   /* 2^-57  */
10020   TEST_f_f (tanh, 0x1p-57L, 6.938893903907228377647697925567626953125e-18L);
10021
10022   END (tanh);
10023 }
10024
10025 static void
10026 tgamma_test (void)
10027 {
10028   errno = 0;
10029   FUNC(tgamma) (1);
10030   if (errno == ENOSYS)
10031     /* Function not implemented.  */
10032     return;
10033
10034   START (tgamma);
10035
10036   TEST_f_f (tgamma, plus_infty, plus_infty);
10037   TEST_f_f (tgamma, max_value, plus_infty, OVERFLOW_EXCEPTION);
10038   TEST_f_f (tgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
10039   TEST_f_f (tgamma, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
10040   /* tgamma (x) == NaN plus invalid exception for integer x <= 0.  */
10041   TEST_f_f (tgamma, -2, nan_value, INVALID_EXCEPTION);
10042   TEST_f_f (tgamma, -max_value, nan_value, INVALID_EXCEPTION);
10043   TEST_f_f (tgamma, minus_infty, nan_value, INVALID_EXCEPTION);
10044   TEST_f_f (tgamma, nan_value, nan_value);
10045
10046   TEST_f_f (tgamma, 0.5, M_SQRT_PIl);
10047   TEST_f_f (tgamma, -0.5, -M_2_SQRT_PIl);
10048
10049   TEST_f_f (tgamma, 1, 1);
10050   TEST_f_f (tgamma, 4, 6);
10051
10052   TEST_f_f (tgamma, 0.7L, 1.29805533264755778568117117915281162L);
10053   TEST_f_f (tgamma, 1.2L, 0.918168742399760610640951655185830401L);
10054
10055   END (tgamma);
10056 }
10057
10058
10059 static void
10060 trunc_test (void)
10061 {
10062   START (trunc);
10063
10064   TEST_f_f (trunc, plus_infty, plus_infty);
10065   TEST_f_f (trunc, minus_infty, minus_infty);
10066   TEST_f_f (trunc, nan_value, nan_value);
10067
10068   TEST_f_f (trunc, 0, 0);
10069   TEST_f_f (trunc, minus_zero, minus_zero);
10070   TEST_f_f (trunc, 0.1, 0);
10071   TEST_f_f (trunc, 0.25, 0);
10072   TEST_f_f (trunc, 0.625, 0);
10073   TEST_f_f (trunc, -0.1, minus_zero);
10074   TEST_f_f (trunc, -0.25, minus_zero);
10075   TEST_f_f (trunc, -0.625, minus_zero);
10076   TEST_f_f (trunc, 1, 1);
10077   TEST_f_f (trunc, -1, -1);
10078   TEST_f_f (trunc, 1.625, 1);
10079   TEST_f_f (trunc, -1.625, -1);
10080
10081   TEST_f_f (trunc, 1048580.625L, 1048580L);
10082   TEST_f_f (trunc, -1048580.625L, -1048580L);
10083
10084   TEST_f_f (trunc, 8388610.125L, 8388610.0L);
10085   TEST_f_f (trunc, -8388610.125L, -8388610.0L);
10086
10087   TEST_f_f (trunc, 4294967296.625L, 4294967296.0L);
10088   TEST_f_f (trunc, -4294967296.625L, -4294967296.0L);
10089
10090 #ifdef TEST_LDOUBLE
10091   /* The result can only be represented in long double.  */
10092   TEST_f_f (trunc, 4503599627370495.5L, 4503599627370495.0L);
10093   TEST_f_f (trunc, 4503599627370496.25L, 4503599627370496.0L);
10094   TEST_f_f (trunc, 4503599627370496.5L, 4503599627370496.0L);
10095   TEST_f_f (trunc, 4503599627370496.75L, 4503599627370496.0L);
10096   TEST_f_f (trunc, 4503599627370497.5L, 4503599627370497.0L);
10097
10098 # if LDBL_MANT_DIG > 100
10099   TEST_f_f (trunc, 4503599627370494.5000000000001L, 4503599627370494.0L);
10100   TEST_f_f (trunc, 4503599627370495.5000000000001L, 4503599627370495.0L);
10101   TEST_f_f (trunc, 4503599627370496.5000000000001L, 4503599627370496.0L);
10102 # endif
10103
10104   TEST_f_f (trunc, -4503599627370495.5L, -4503599627370495.0L);
10105   TEST_f_f (trunc, -4503599627370496.25L, -4503599627370496.0L);
10106   TEST_f_f (trunc, -4503599627370496.5L, -4503599627370496.0L);
10107   TEST_f_f (trunc, -4503599627370496.75L, -4503599627370496.0L);
10108   TEST_f_f (trunc, -4503599627370497.5L, -4503599627370497.0L);
10109
10110 # if LDBL_MANT_DIG > 100
10111   TEST_f_f (trunc, -4503599627370494.5000000000001L, -4503599627370494.0L);
10112   TEST_f_f (trunc, -4503599627370495.5000000000001L, -4503599627370495.0L);
10113   TEST_f_f (trunc, -4503599627370496.5000000000001L, -4503599627370496.0L);
10114 # endif
10115
10116   TEST_f_f (trunc, 9007199254740991.5L, 9007199254740991.0L);
10117   TEST_f_f (trunc, 9007199254740992.25L, 9007199254740992.0L);
10118   TEST_f_f (trunc, 9007199254740992.5L, 9007199254740992.0L);
10119   TEST_f_f (trunc, 9007199254740992.75L, 9007199254740992.0L);
10120   TEST_f_f (trunc, 9007199254740993.5L, 9007199254740993.0L);
10121
10122 # if LDBL_MANT_DIG > 100
10123   TEST_f_f (trunc, 9007199254740991.0000000000001L, 9007199254740991.0L);
10124   TEST_f_f (trunc, 9007199254740992.0000000000001L, 9007199254740992.0L);
10125   TEST_f_f (trunc, 9007199254740993.0000000000001L, 9007199254740993.0L);
10126   TEST_f_f (trunc, 9007199254740991.5000000000001L, 9007199254740991.0L);
10127   TEST_f_f (trunc, 9007199254740992.5000000000001L, 9007199254740992.0L);
10128   TEST_f_f (trunc, 9007199254740993.5000000000001L, 9007199254740993.0L);
10129 # endif
10130
10131   TEST_f_f (trunc, -9007199254740991.5L, -9007199254740991.0L);
10132   TEST_f_f (trunc, -9007199254740992.25L, -9007199254740992.0L);
10133   TEST_f_f (trunc, -9007199254740992.5L, -9007199254740992.0L);
10134   TEST_f_f (trunc, -9007199254740992.75L, -9007199254740992.0L);
10135   TEST_f_f (trunc, -9007199254740993.5L, -9007199254740993.0L);
10136
10137 # if LDBL_MANT_DIG > 100
10138   TEST_f_f (trunc, -9007199254740991.0000000000001L, -9007199254740991.0L);
10139   TEST_f_f (trunc, -9007199254740992.0000000000001L, -9007199254740992.0L);
10140   TEST_f_f (trunc, -9007199254740993.0000000000001L, -9007199254740993.0L);
10141   TEST_f_f (trunc, -9007199254740991.5000000000001L, -9007199254740991.0L);
10142   TEST_f_f (trunc, -9007199254740992.5000000000001L, -9007199254740992.0L);
10143   TEST_f_f (trunc, -9007199254740993.5000000000001L, -9007199254740993.0L);
10144 # endif
10145
10146   TEST_f_f (trunc, 72057594037927935.5L, 72057594037927935.0L);
10147   TEST_f_f (trunc, 72057594037927936.25L, 72057594037927936.0L);
10148   TEST_f_f (trunc, 72057594037927936.5L, 72057594037927936.0L);
10149   TEST_f_f (trunc, 72057594037927936.75L, 72057594037927936.0L);
10150   TEST_f_f (trunc, 72057594037927937.5L, 72057594037927937.0L);
10151
10152   TEST_f_f (trunc, -72057594037927935.5L, -72057594037927935.0L);
10153   TEST_f_f (trunc, -72057594037927936.25L, -72057594037927936.0L);
10154   TEST_f_f (trunc, -72057594037927936.5L, -72057594037927936.0L);
10155   TEST_f_f (trunc, -72057594037927936.75L, -72057594037927936.0L);
10156   TEST_f_f (trunc, -72057594037927937.5L, -72057594037927937.0L);
10157
10158   TEST_f_f (trunc, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
10159   TEST_f_f (trunc, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
10160   TEST_f_f (trunc, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
10161   TEST_f_f (trunc, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
10162   TEST_f_f (trunc, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
10163 #endif
10164
10165   END (trunc);
10166 }
10167
10168 static void
10169 y0_test (void)
10170 {
10171   FLOAT s, c;
10172   errno = 0;
10173   FUNC (sincos) (0, &s, &c);
10174   if (errno == ENOSYS)
10175     /* Required function not implemented.  */
10176     return;
10177   FUNC(y0) (1);
10178   if (errno == ENOSYS)
10179     /* Function not implemented.  */
10180     return;
10181
10182   /* y0 is the Bessel function of the second kind of order 0 */
10183   START (y0);
10184
10185   TEST_f_f (y0, -1.0, minus_infty, INVALID_EXCEPTION);
10186   TEST_f_f (y0, -max_value, minus_infty, INVALID_EXCEPTION);
10187   TEST_f_f (y0, 0.0, minus_infty);
10188   TEST_f_f (y0, nan_value, nan_value);
10189   TEST_f_f (y0, plus_infty, 0);
10190
10191   TEST_f_f (y0, 0.125L, -1.38968062514384052915582277745018693L);
10192   TEST_f_f (y0, 0.75L, -0.137172769385772397522814379396581855L);
10193   TEST_f_f (y0, 1.0, 0.0882569642156769579829267660235151628L);
10194   TEST_f_f (y0, 1.5, 0.382448923797758843955068554978089862L);
10195   TEST_f_f (y0, 2.0, 0.510375672649745119596606592727157873L);
10196   TEST_f_f (y0, 8.0, 0.223521489387566220527323400498620359L);
10197   TEST_f_f (y0, 10.0, 0.0556711672835993914244598774101900481L);
10198
10199   TEST_f_f (y0, 0x1.3ffp+74L, 1.818984347516051243459467456433028748678e-12L);
10200
10201 #ifndef TEST_FLOAT
10202   /* Bug 14155: spurious exception may occur.  */
10203   TEST_f_f (y0, 0x1.ff00000000002p+840L, 1.846591691699331493194965158699937660696e-127L, UNDERFLOW_EXCEPTION_OK);
10204 #endif
10205
10206   TEST_f_f (y0, 0x1p-10L, -4.4865150767109739412411806297168793661098L);
10207   TEST_f_f (y0, 0x1p-20L, -8.8992283012125827603076426611387876938160L);
10208   TEST_f_f (y0, 0x1p-30L, -1.3311940304267782826037118027401817264906e+1L);
10209   TEST_f_f (y0, 0x1p-40L, -1.7724652307320814696990854700366226762563e+1L);
10210   TEST_f_f (y0, 0x1p-50L, -2.2137364310373846564919987139743760738155e+1L);
10211   TEST_f_f (y0, 0x1p-60L, -2.6550076313426878432849115782108205929120e+1L);
10212   TEST_f_f (y0, 0x1p-70L, -3.0962788316479910300778244424468159753887e+1L);
10213   TEST_f_f (y0, 0x1p-80L, -3.5375500319532942168707373066828113573541e+1L);
10214   TEST_f_f (y0, 0x1p-90L, -3.9788212322585974036636501709188067393195e+1L);
10215   TEST_f_f (y0, 0x1p-100L, -4.420092432563900590456563035154802121284e+1L);
10216   TEST_f_f (y0, 0x1p-110L, -4.861363632869203777249475899390797503250e+1L);
10217
10218   END (y0);
10219 }
10220
10221
10222 static void
10223 y1_test (void)
10224 {
10225   FLOAT s, c;
10226   errno = 0;
10227   FUNC (sincos) (0, &s, &c);
10228   if (errno == ENOSYS)
10229     /* Required function not implemented.  */
10230     return;
10231   FUNC(y1) (1);
10232   if (errno == ENOSYS)
10233     /* Function not implemented.  */
10234     return;
10235
10236   /* y1 is the Bessel function of the second kind of order 1 */
10237   START (y1);
10238
10239   TEST_f_f (y1, -1.0, minus_infty, INVALID_EXCEPTION);
10240   TEST_f_f (y1, -max_value, minus_infty, INVALID_EXCEPTION);
10241   TEST_f_f (y1, 0.0, minus_infty);
10242   TEST_f_f (y1, plus_infty, 0);
10243   TEST_f_f (y1, nan_value, nan_value);
10244
10245   TEST_f_f (y1, 0.125L, -5.19993611253477499595928744876579921L);
10246   TEST_f_f (y1, 0.75L, -1.03759455076928541973767132140642198L);
10247   TEST_f_f (y1, 1.0, -0.781212821300288716547150000047964821L);
10248   TEST_f_f (y1, 1.5, -0.412308626973911295952829820633445323L);
10249   TEST_f_f (y1, 2.0, -0.107032431540937546888370772277476637L);
10250   TEST_f_f (y1, 8.0, -0.158060461731247494255555266187483550L);
10251   TEST_f_f (y1, 10.0, 0.249015424206953883923283474663222803L);
10252
10253   /* Bug 14155: spurious exception may occur.  */
10254   TEST_f_f (y1, 0x1.27e204p+99L, -8.881610148467797208469612080785210013461e-16L, UNDERFLOW_EXCEPTION_OK);
10255
10256 #ifndef TEST_FLOAT
10257   /* Bug 14155: spurious exception may occur.  */
10258   TEST_f_f (y1, 0x1.001000001p+593L, 3.927269966354206207832593635798954916263e-90L, UNDERFLOW_EXCEPTION_OK);
10259 #endif
10260
10261   TEST_f_f (y1, 0x1p-10L, -6.5190099301063115047395187618929589514382e+02L);
10262   TEST_f_f (y1, 0x1p-20L, -6.6754421443450423911167962313100637952285e+05L);
10263   TEST_f_f (y1, 0x1p-30L, -6.8356527557643159612937462812258975438856e+08L);
10264   TEST_f_f (y1, 0x1p-40L, -6.9997084219026594793707805777425993547887e+11L);
10265   TEST_f_f (y1, 0x1p-50L, -7.1677014240283233068755952926181262431559e+14L);
10266   TEST_f_f (y1, 0x1p-60L, -7.3397262582050030662406095795388448059822e+17L);
10267   TEST_f_f (y1, 0x1p-70L, -7.5158796884019231398303842094477769620063e+20L);
10268   TEST_f_f (y1, 0x1p-80L, -7.6962608009235692951863134304745236090943e+23L);
10269   TEST_f_f (y1, 0x1p-90L, -7.8809710601457349582707849528059121757126e+26L);
10270   TEST_f_f (y1, 0x1p-100L, -8.0701143655892325972692837916732540679297e+29L);
10271   TEST_f_f (y1, 0x1p-110L, -8.2637971103633741796037466026734121655600e+32L);
10272
10273   END (y1);
10274 }
10275
10276
10277 static void
10278 yn_test (void)
10279 {
10280   FLOAT s, c;
10281   errno = 0;
10282   FUNC (sincos) (0, &s, &c);
10283   if (errno == ENOSYS)
10284     /* Required function not implemented.  */
10285     return;
10286   FUNC(yn) (1, 1);
10287   if (errno == ENOSYS)
10288     /* Function not implemented.  */
10289     return;
10290
10291   /* yn is the Bessel function of the second kind of order n */
10292   START (yn);
10293
10294   /* yn (0, x) == y0 (x)  */
10295   TEST_ff_f (yn, 0, -1.0, minus_infty, INVALID_EXCEPTION);
10296   TEST_ff_f (yn, 0, -max_value, minus_infty, INVALID_EXCEPTION);
10297   TEST_ff_f (yn, 0, 0.0, minus_infty);
10298   TEST_ff_f (yn, 0, nan_value, nan_value);
10299   TEST_ff_f (yn, 0, plus_infty, 0);
10300
10301   TEST_ff_f (yn, 0, 0.125L, -1.38968062514384052915582277745018693L);
10302   TEST_ff_f (yn, 0, 0.75L, -0.137172769385772397522814379396581855L);
10303   TEST_ff_f (yn, 0, 1.0, 0.0882569642156769579829267660235151628L);
10304   TEST_ff_f (yn, 0, 1.5, 0.382448923797758843955068554978089862L);
10305   TEST_ff_f (yn, 0, 2.0, 0.510375672649745119596606592727157873L);
10306   TEST_ff_f (yn, 0, 8.0, 0.223521489387566220527323400498620359L);
10307   TEST_ff_f (yn, 0, 10.0, 0.0556711672835993914244598774101900481L);
10308
10309   /* yn (1, x) == y1 (x)  */
10310   TEST_ff_f (yn, 1, -1.0, minus_infty, INVALID_EXCEPTION);
10311   TEST_ff_f (yn, 1, 0.0, minus_infty);
10312   TEST_ff_f (yn, 1, plus_infty, 0);
10313   TEST_ff_f (yn, 1, nan_value, nan_value);
10314
10315   TEST_ff_f (yn, 1, 0.125L, -5.19993611253477499595928744876579921L);
10316   TEST_ff_f (yn, 1, 0.75L, -1.03759455076928541973767132140642198L);
10317   TEST_ff_f (yn, 1, 1.0, -0.781212821300288716547150000047964821L);
10318   TEST_ff_f (yn, 1, 1.5, -0.412308626973911295952829820633445323L);
10319   TEST_ff_f (yn, 1, 2.0, -0.107032431540937546888370772277476637L);
10320   TEST_ff_f (yn, 1, 8.0, -0.158060461731247494255555266187483550L);
10321   TEST_ff_f (yn, 1, 10.0, 0.249015424206953883923283474663222803L);
10322
10323   /* yn (3, x)  */
10324   TEST_ff_f (yn, 3, plus_infty, 0);
10325   TEST_ff_f (yn, 3, nan_value, nan_value);
10326
10327   TEST_ff_f (yn, 3, 0.125L, -2612.69757350066712600220955744091741L);
10328   TEST_ff_f (yn, 3, 0.75L, -12.9877176234475433186319774484809207L);
10329   TEST_ff_f (yn, 3, 1.0, -5.82151760596472884776175706442981440L);
10330   TEST_ff_f (yn, 3, 2.0, -1.12778377684042778608158395773179238L);
10331   TEST_ff_f (yn, 3, 10.0, -0.251362657183837329779204747654240998L);
10332
10333   /* yn (10, x)  */
10334   TEST_ff_f (yn, 10, plus_infty, 0);
10335   TEST_ff_f (yn, 10, nan_value, nan_value);
10336
10337   TEST_ff_f (yn, 10, 0.125L, -127057845771019398.252538486899753195L);
10338   TEST_ff_f (yn, 10, 0.75L, -2133501638.90573424452445412893839236L);
10339   TEST_ff_f (yn, 10, 1.0, -121618014.278689189288130426667971145L);
10340   TEST_ff_f (yn, 10, 2.0, -129184.542208039282635913145923304214L);
10341   TEST_ff_f (yn, 10, 10.0, -0.359814152183402722051986577343560609L);
10342
10343   /* Check whether yn returns correct value for LDBL_MIN, DBL_MIN,
10344      and FLT_MIN.  See Bug 14173.  */
10345   TEST_ff_f (yn, 10, min_value, minus_infty, OVERFLOW_EXCEPTION);
10346
10347   errno = 0;
10348   TEST_ff_f (yn, 10, min_value, minus_infty, OVERFLOW_EXCEPTION);
10349   check_int ("errno for yn(10,-min) == ERANGE", errno, ERANGE, 0, 0, 0);
10350
10351   END (yn);
10352 }
10353
10354
10355 static void
10356 significand_test (void)
10357 {
10358   /* significand returns the mantissa of the exponential representation.  */
10359   START (significand);
10360
10361   TEST_f_f (significand, 4.0, 1.0);
10362   TEST_f_f (significand, 6.0, 1.5);
10363   TEST_f_f (significand, 8.0, 1.0);
10364
10365   END (significand);
10366 }
10367
10368
10369 static void
10370 initialize (void)
10371 {
10372   fpstack_test ("start *init*");
10373   plus_zero = 0.0;
10374   nan_value = plus_zero / plus_zero;    /* Suppress GCC warning */
10375
10376   minus_zero = FUNC(copysign) (0.0, -1.0);
10377   plus_infty = CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF,
10378                        HUGE_VALL, HUGE_VAL, HUGE_VALF);
10379   minus_infty = CHOOSE (-HUGE_VALL, -HUGE_VAL, -HUGE_VALF,
10380                         -HUGE_VALL, -HUGE_VAL, -HUGE_VALF);
10381   max_value = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
10382                       LDBL_MAX, DBL_MAX, FLT_MAX);
10383   min_value = CHOOSE (LDBL_MIN, DBL_MIN, FLT_MIN,
10384                       LDBL_MIN, DBL_MIN, FLT_MIN);
10385   min_subnorm_value = CHOOSE (__LDBL_DENORM_MIN__,
10386                               __DBL_DENORM_MIN__,
10387                               __FLT_DENORM_MIN__,
10388                               __LDBL_DENORM_MIN__,
10389                               __DBL_DENORM_MIN__,
10390                               __FLT_DENORM_MIN__);
10391
10392   (void) &plus_zero;
10393   (void) &nan_value;
10394   (void) &minus_zero;
10395   (void) &plus_infty;
10396   (void) &minus_infty;
10397   (void) &max_value;
10398   (void) &min_value;
10399   (void) &min_subnorm_value;
10400
10401   /* Clear all exceptions.  From now on we must not get random exceptions.  */
10402   feclearexcept (FE_ALL_EXCEPT);
10403
10404   /* Test to make sure we start correctly.  */
10405   fpstack_test ("end *init*");
10406 }
10407
10408 /* Definitions of arguments for argp functions.  */
10409 static const struct argp_option options[] =
10410 {
10411   { "verbose", 'v', "NUMBER", 0, "Level of verbosity (0..3)"},
10412   { "ulps-file", 'u', NULL, 0, "Output ulps to file ULPs"},
10413   { "no-max-error", 'f', NULL, 0,
10414     "Don't output maximal errors of functions"},
10415   { "no-points", 'p', NULL, 0,
10416     "Don't output results of functions invocations"},
10417   { "ignore-max-ulp", 'i', "yes/no", 0,
10418     "Ignore given maximal errors"},
10419   { NULL, 0, NULL, 0, NULL }
10420 };
10421
10422 /* Short description of program.  */
10423 static const char doc[] = "Math test suite: " TEST_MSG ;
10424
10425 /* Prototype for option handler.  */
10426 static error_t parse_opt (int key, char *arg, struct argp_state *state);
10427
10428 /* Data structure to communicate with argp functions.  */
10429 static struct argp argp =
10430 {
10431   options, parse_opt, NULL, doc,
10432 };
10433
10434
10435 /* Handle program arguments.  */
10436 static error_t
10437 parse_opt (int key, char *arg, struct argp_state *state)
10438 {
10439   switch (key)
10440     {
10441     case 'f':
10442       output_max_error = 0;
10443       break;
10444     case 'i':
10445       if (strcmp (arg, "yes") == 0)
10446         ignore_max_ulp = 1;
10447       else if (strcmp (arg, "no") == 0)
10448         ignore_max_ulp = 0;
10449       break;
10450     case 'p':
10451       output_points = 0;
10452       break;
10453     case 'u':
10454       output_ulps = 1;
10455       break;
10456     case 'v':
10457       if (optarg)
10458         verbose = (unsigned int) strtoul (optarg, NULL, 0);
10459       else
10460         verbose = 3;
10461       break;
10462     default:
10463       return ARGP_ERR_UNKNOWN;
10464     }
10465   return 0;
10466 }
10467
10468 #if 0
10469 /* function to check our ulp calculation.  */
10470 void
10471 check_ulp (void)
10472 {
10473   int i;
10474
10475   FLOAT u, diff, ulp;
10476   /* This gives one ulp.  */
10477   u = FUNC(nextafter) (10, 20);
10478   check_equal (10.0, u, 1, &diff, &ulp);
10479   printf ("One ulp: % .4" PRINTF_NEXPR "\n", ulp);
10480
10481   /* This gives one more ulp.  */
10482   u = FUNC(nextafter) (u, 20);
10483   check_equal (10.0, u, 2, &diff, &ulp);
10484   printf ("two ulp: % .4" PRINTF_NEXPR "\n", ulp);
10485
10486   /* And now calculate 100 ulp.  */
10487   for (i = 2; i < 100; i++)
10488     u = FUNC(nextafter) (u, 20);
10489   check_equal (10.0, u, 100, &diff, &ulp);
10490   printf ("100 ulp: % .4" PRINTF_NEXPR "\n", ulp);
10491 }
10492 #endif
10493
10494 int
10495 main (int argc, char **argv)
10496 {
10497
10498   int remaining;
10499
10500   verbose = 1;
10501   output_ulps = 0;
10502   output_max_error = 1;
10503   output_points = 1;
10504   /* XXX set to 0 for releases.  */
10505   ignore_max_ulp = 0;
10506
10507   /* Parse and process arguments.  */
10508   argp_parse (&argp, argc, argv, 0, &remaining, NULL);
10509
10510   if (remaining != argc)
10511     {
10512       fprintf (stderr, "wrong number of arguments");
10513       argp_help (&argp, stdout, ARGP_HELP_SEE, program_invocation_short_name);
10514       exit (EXIT_FAILURE);
10515     }
10516
10517   if (output_ulps)
10518     {
10519       ulps_file = fopen ("ULPs", "a");
10520       if (ulps_file == NULL)
10521         {
10522           perror ("can't open file `ULPs' for writing: ");
10523           exit (1);
10524         }
10525     }
10526
10527
10528   initialize ();
10529   printf (TEST_MSG);
10530
10531 #if 0
10532   check_ulp ();
10533 #endif
10534
10535   /* Keep the tests a wee bit ordered (according to ISO C99).  */
10536   /* Classification macros:  */
10537   finite_test ();
10538   fpclassify_test ();
10539   isfinite_test ();
10540   isinf_test ();
10541   isnan_test ();
10542   isnormal_test ();
10543   signbit_test ();
10544
10545   /* Trigonometric functions:  */
10546   acos_test ();
10547   acos_test_tonearest ();
10548   acos_test_towardzero ();
10549   acos_test_downward ();
10550   acos_test_upward ();
10551   asin_test ();
10552   asin_test_tonearest ();
10553   asin_test_towardzero ();
10554   asin_test_downward ();
10555   asin_test_upward ();
10556   atan_test ();
10557   atan2_test ();
10558   cos_test ();
10559   cos_test_tonearest ();
10560   cos_test_towardzero ();
10561   cos_test_downward ();
10562   cos_test_upward ();
10563   sin_test ();
10564   sin_test_tonearest ();
10565   sin_test_towardzero ();
10566   sin_test_downward ();
10567   sin_test_upward ();
10568   sincos_test ();
10569   tan_test ();
10570   tan_test_tonearest ();
10571   tan_test_towardzero ();
10572   tan_test_downward ();
10573   tan_test_upward ();
10574
10575   /* Hyperbolic functions:  */
10576   acosh_test ();
10577   asinh_test ();
10578   atanh_test ();
10579   cosh_test ();
10580   cosh_test_tonearest ();
10581   cosh_test_towardzero ();
10582   cosh_test_downward ();
10583   cosh_test_upward ();
10584   sinh_test ();
10585   sinh_test_tonearest ();
10586   sinh_test_towardzero ();
10587   sinh_test_downward ();
10588   sinh_test_upward ();
10589   tanh_test ();
10590
10591   /* Exponential and logarithmic functions:  */
10592   exp_test ();
10593   exp_test_tonearest ();
10594   exp_test_towardzero ();
10595   exp_test_downward ();
10596   exp_test_upward ();
10597   exp10_test ();
10598   exp2_test ();
10599   expm1_test ();
10600   frexp_test ();
10601   ldexp_test ();
10602   log_test ();
10603   log10_test ();
10604   log1p_test ();
10605   log2_test ();
10606   logb_test ();
10607   logb_test_downward ();
10608   modf_test ();
10609   ilogb_test ();
10610   scalb_test ();
10611   scalbn_test ();
10612   scalbln_test ();
10613   significand_test ();
10614
10615   /* Power and absolute value functions:  */
10616   cbrt_test ();
10617   fabs_test ();
10618   hypot_test ();
10619   pow_test ();
10620   pow_test_tonearest ();
10621   pow_test_towardzero ();
10622   pow_test_downward ();
10623   pow_test_upward ();
10624   sqrt_test ();
10625
10626   /* Error and gamma functions:  */
10627   erf_test ();
10628   erfc_test ();
10629   gamma_test ();
10630   lgamma_test ();
10631   tgamma_test ();
10632
10633   /* Nearest integer functions:  */
10634   ceil_test ();
10635   floor_test ();
10636   nearbyint_test ();
10637   rint_test ();
10638   rint_test_tonearest ();
10639   rint_test_towardzero ();
10640   rint_test_downward ();
10641   rint_test_upward ();
10642   lrint_test ();
10643   lrint_test_tonearest ();
10644   lrint_test_towardzero ();
10645   lrint_test_downward ();
10646   lrint_test_upward ();
10647   llrint_test ();
10648   llrint_test_tonearest ();
10649   llrint_test_towardzero ();
10650   llrint_test_downward ();
10651   llrint_test_upward ();
10652   round_test ();
10653   lround_test ();
10654   llround_test ();
10655   trunc_test ();
10656
10657   /* Remainder functions:  */
10658   fmod_test ();
10659   remainder_test ();
10660   remquo_test ();
10661
10662   /* Manipulation functions:  */
10663   copysign_test ();
10664   nextafter_test ();
10665   nexttoward_test ();
10666
10667   /* maximum, minimum and positive difference functions */
10668   fdim_test ();
10669   fmax_test ();
10670   fmin_test ();
10671
10672   /* Multiply and add:  */
10673   fma_test ();
10674   fma_test_towardzero ();
10675   fma_test_downward ();
10676   fma_test_upward ();
10677
10678   /* Comparison macros:  */
10679   isgreater_test ();
10680   isgreaterequal_test ();
10681   isless_test ();
10682   islessequal_test ();
10683   islessgreater_test ();
10684   isunordered_test ();
10685
10686   /* Complex functions:  */
10687   cabs_test ();
10688   cacos_test ();
10689   cacosh_test ();
10690   carg_test ();
10691   casin_test ();
10692   casinh_test ();
10693   catan_test ();
10694   catanh_test ();
10695   ccos_test ();
10696   ccosh_test ();
10697   cexp_test ();
10698   cimag_test ();
10699   clog10_test ();
10700   clog_test ();
10701   conj_test ();
10702   cpow_test ();
10703   cproj_test ();
10704   creal_test ();
10705   csin_test ();
10706   csinh_test ();
10707   csqrt_test ();
10708   ctan_test ();
10709   ctan_test_tonearest ();
10710   ctan_test_towardzero ();
10711   ctan_test_downward ();
10712   ctan_test_upward ();
10713   ctanh_test ();
10714   ctanh_test_tonearest ();
10715   ctanh_test_towardzero ();
10716   ctanh_test_downward ();
10717   ctanh_test_upward ();
10718
10719   /* Bessel functions:  */
10720   j0_test ();
10721   j1_test ();
10722   jn_test ();
10723   y0_test ();
10724   y1_test ();
10725   yn_test ();
10726
10727   if (output_ulps)
10728     fclose (ulps_file);
10729
10730   printf ("\nTest suite completed:\n");
10731   printf ("  %d test cases plus %d tests for exception flags executed.\n",
10732           noTests, noExcTests);
10733   if (noXFails)
10734     printf ("  %d expected failures occurred.\n", noXFails);
10735   if (noXPasses)
10736     printf ("  %d unexpected passes occurred.\n", noXPasses);
10737   if (noErrors)
10738     {
10739       printf ("  %d errors occurred.\n", noErrors);
10740       return 1;
10741     }
10742   printf ("  All tests passed successfully.\n");
10743
10744   return 0;
10745 }
10746
10747 /*
10748  * Local Variables:
10749  * mode:c
10750  * End:
10751  */