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[200];
 631
 632   sprintf (str, "Real part of: %s", test_name);
 633   part_comp = __real__ computed;
 634   part_exp = __real__ expected;
 635   part_max_ulp = __real__ max_ulp;
 636   part_xfail = __real__ xfail;
 637
 638   check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
 639                         exception, &real_max_error);
 640
 641   sprintf (str, "Imaginary part of: %s", test_name);
 642   part_comp = __imag__ computed;
 643   part_exp = __imag__ expected;
 644   part_max_ulp = __imag__ max_ulp;
 645   part_xfail = __imag__ xfail;
 646
 647   /* Don't check again for exceptions, just pass through the
 648      zero/inf sign test.  */
 649   check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
 650                         exception & IGNORE_ZERO_INF_SIGN,
 651                         &imag_max_error);
 652 }
 653
 654
 655 /* Check that computed and expected values are equal (int values).  */
 656 static void
 657 check_int (const char *test_name, int computed, int expected, int max_ulp,
 658            int xfail, int exceptions)
 659 {
 660   int diff = computed - expected;
 661   int ok = 0;
 662
 663   test_exceptions (test_name, exceptions);
 664   noTests++;
 665   if (abs (diff) <= max_ulp)
 666     ok = 1;
 667
 668   if (!ok)
 669     print_ulps (test_name, diff);
 670
 671   if (print_screen (ok, xfail))
 672     {
 673       if (!ok)
 674         printf ("Failure: ");
 675       printf ("Test: %s\n", test_name);
 676       printf ("Result:\n");
 677       printf (" is:         %d\n", computed);
 678       printf (" should be:  %d\n", expected);
 679     }
 680
 681   update_stats (ok, xfail);
 682   fpstack_test (test_name);
 683 }
 684
 685
 686 /* Check that computed and expected values are equal (long int values).  */
 687 static void
 688 check_long (const char *test_name, long int computed, long int expected,
 689             long int max_ulp, int xfail, int exceptions)
 690 {
 691   long int diff = computed - expected;
 692   int ok = 0;
 693
 694   test_exceptions (test_name, exceptions);
 695   noTests++;
 696   if (labs (diff) <= max_ulp)
 697     ok = 1;
 698
 699   if (!ok)
 700     print_ulps (test_name, diff);
 701
 702   if (print_screen (ok, xfail))
 703     {
 704       if (!ok)
 705         printf ("Failure: ");
 706       printf ("Test: %s\n", test_name);
 707       printf ("Result:\n");
 708       printf (" is:         %ld\n", computed);
 709       printf (" should be:  %ld\n", expected);
 710     }
 711
 712   update_stats (ok, xfail);
 713   fpstack_test (test_name);
 714 }
 715
 716
 717 /* Check that computed value is true/false.  */
 718 static void
 719 check_bool (const char *test_name, int computed, int expected,
 720             long int max_ulp, int xfail, int exceptions)
 721 {
 722   int ok = 0;
 723
 724   test_exceptions (test_name, exceptions);
 725   noTests++;
 726   if ((computed == 0) == (expected == 0))
 727     ok = 1;
 728
 729   if (print_screen (ok, xfail))
 730     {
 731       if (!ok)
 732         printf ("Failure: ");
 733       printf ("Test: %s\n", test_name);
 734       printf ("Result:\n");
 735       printf (" is:         %d\n", computed);
 736       printf (" should be:  %d\n", expected);
 737     }
 738
 739   update_stats (ok, xfail);
 740   fpstack_test (test_name);
 741 }
 742
 743
 744 /* check that computed and expected values are equal (long int values) */
 745 static void
 746 check_longlong (const char *test_name, long long int computed,
 747                 long long int expected,
 748                 long long int max_ulp, int xfail,
 749                 int exceptions)
 750 {
 751   long long int diff = computed - expected;
 752   int ok = 0;
 753
 754   test_exceptions (test_name, exceptions);
 755   noTests++;
 756   if (llabs (diff) <= max_ulp)
 757     ok = 1;
 758
 759   if (!ok)
 760     print_ulps (test_name, diff);
 761
 762   if (print_screen (ok, xfail))
 763     {
 764       if (!ok)
 765         printf ("Failure:");
 766       printf ("Test: %s\n", test_name);
 767       printf ("Result:\n");
 768       printf (" is:         %lld\n", computed);
 769       printf (" should be:  %lld\n", expected);
 770     }
 771
 772   update_stats (ok, xfail);
 773   fpstack_test (test_name);
 774 }
 775
 776
 777
 778 /* This is to prevent messages from the SVID libm emulation.  */
 779 int
 780 matherr (struct exception *x __attribute__ ((unused)))
 781 {
 782   return 1;
 783 }
 784
 785
 786 /****************************************************************************
 787   Tests for single functions of libm.
 788   Please keep them alphabetically sorted!
 789 ****************************************************************************/
 790
 791 static void
 792 acos_test (void)
 793 {
 794   errno = 0;
 795   FUNC(acos) (0);
 796   if (errno == ENOSYS)
 797     /* Function not implemented.  */
 798     return;
 799
 800   START (acos);
 801
 802   TEST_f_f (acos, plus_infty, nan_value, INVALID_EXCEPTION);
 803   TEST_f_f (acos, minus_infty, nan_value, INVALID_EXCEPTION);
 804   TEST_f_f (acos, nan_value, nan_value);
 805
 806   /* |x| > 1: */
 807   TEST_f_f (acos, 1.125L, nan_value, INVALID_EXCEPTION);
 808   TEST_f_f (acos, -1.125L, nan_value, INVALID_EXCEPTION);
 809   TEST_f_f (acos, max_value, nan_value, INVALID_EXCEPTION);
 810   TEST_f_f (acos, -max_value, nan_value, INVALID_EXCEPTION);
 811
 812   TEST_f_f (acos, 0, M_PI_2l);
 813   TEST_f_f (acos, minus_zero, M_PI_2l);
 814   TEST_f_f (acos, 1, 0);
 815   TEST_f_f (acos, -1, M_PIl);
 816   TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 817   TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 818   TEST_f_f (acos, 0.75L, 0.722734247813415611178377352641333362L);
 819   TEST_f_f (acos, 2e-17L, 1.57079632679489659923132169163975144L);
 820   TEST_f_f (acos, 0.0625L, 1.50825556499840522843072005474337068L);
 821   TEST_f_f (acos, 0x0.ffffffp0L, 3.4526698471620358760324948263873649728491e-4L);
 822   TEST_f_f (acos, -0x0.ffffffp0L, 3.1412473866050770348750401337968641476999L);
 823 #ifndef TEST_FLOAT
 824   TEST_f_f (acos, 0x0.ffffffff8p0L, 1.5258789062648029736620564947844627548516e-5L);
 825   TEST_f_f (acos, -0x0.ffffffff8p0L, 3.1415773948007305904329067627145550395696L);
 826   TEST_f_f (acos, 0x0.ffffffffffffp0L, 8.4293697021788088529885473244391795127130e-8L);
 827   TEST_f_f (acos, -0x0.ffffffffffffp0L, 3.1415925692960962166745548533940296398054L);
 828 #endif
 829 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
 830   TEST_f_f (acos, 0x0.ffffffffffffffffp0L, 3.2927225399135962333718255320079907245059e-10L);
 831   TEST_f_f (acos, -0x0.ffffffffffffffffp0L, 3.1415926532605209844712837599423203309964L);
 832 #endif
 833   END (acos);
 834 }
 835
 836
 837 static void
 838 acos_test_tonearest (void)
 839 {
 840   int save_round_mode;
 841   errno = 0;
 842   FUNC(acos) (0);
 843   if (errno == ENOSYS)
 844     /* Function not implemented.  */
 845     return;
 846
 847   START (acos_tonearest);
 848
 849   save_round_mode = fegetround ();
 850
 851   if (!fesetround (FE_TONEAREST))
 852     {
 853       TEST_f_f (acos, 0, M_PI_2l);
 854       TEST_f_f (acos, minus_zero, M_PI_2l);
 855       TEST_f_f (acos, 1, 0);
 856       TEST_f_f (acos, -1, M_PIl);
 857       TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 858       TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 859     }
 860
 861   fesetround (save_round_mode);
 862
 863   END (acos_tonearest);
 864 }
 865
 866
 867 static void
 868 acos_test_towardzero (void)
 869 {
 870   int save_round_mode;
 871   errno = 0;
 872   FUNC(acos) (0);
 873   if (errno == ENOSYS)
 874     /* Function not implemented.  */
 875     return;
 876
 877   START (acos_towardzero);
 878
 879   save_round_mode = fegetround ();
 880
 881   if (!fesetround (FE_TOWARDZERO))
 882     {
 883       TEST_f_f (acos, 0, M_PI_2l);
 884       TEST_f_f (acos, minus_zero, M_PI_2l);
 885       TEST_f_f (acos, 1, 0);
 886       TEST_f_f (acos, -1, M_PIl);
 887       TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 888       TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 889     }
 890
 891   fesetround (save_round_mode);
 892
 893   END (acos_towardzero);
 894 }
 895
 896
 897 static void
 898 acos_test_downward (void)
 899 {
 900   int save_round_mode;
 901   errno = 0;
 902   FUNC(acos) (0);
 903   if (errno == ENOSYS)
 904     /* Function not implemented.  */
 905     return;
 906
 907   START (acos_downward);
 908
 909   save_round_mode = fegetround ();
 910
 911   if (!fesetround (FE_DOWNWARD))
 912     {
 913       TEST_f_f (acos, 0, M_PI_2l);
 914       TEST_f_f (acos, minus_zero, M_PI_2l);
 915       TEST_f_f (acos, 1, 0);
 916       TEST_f_f (acos, -1, M_PIl);
 917       TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 918       TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 919     }
 920
 921   fesetround (save_round_mode);
 922
 923   END (acos_downward);
 924 }
 925
 926
 927 static void
 928 acos_test_upward (void)
 929 {
 930   int save_round_mode;
 931   errno = 0;
 932   FUNC(acos) (0);
 933   if (errno == ENOSYS)
 934     /* Function not implemented.  */
 935     return;
 936
 937   START (acos_upward);
 938
 939   save_round_mode = fegetround ();
 940
 941   if (!fesetround (FE_UPWARD))
 942     {
 943       TEST_f_f (acos, 0, M_PI_2l);
 944       TEST_f_f (acos, minus_zero, M_PI_2l);
 945       TEST_f_f (acos, 1, 0);
 946       TEST_f_f (acos, -1, M_PIl);
 947       TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 948       TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 949     }
 950
 951   fesetround (save_round_mode);
 952
 953   END (acos_upward);
 954 }
 955
 956 static void
 957 acosh_test (void)
 958 {
 959   errno = 0;
 960   FUNC(acosh) (7);
 961   if (errno == ENOSYS)
 962     /* Function not implemented.  */
 963     return;
 964
 965   START (acosh);
 966
 967   TEST_f_f (acosh, plus_infty, plus_infty);
 968   TEST_f_f (acosh, minus_infty, nan_value, INVALID_EXCEPTION);
 969
 970   /* x < 1:  */
 971   TEST_f_f (acosh, -1.125L, nan_value, INVALID_EXCEPTION);
 972   TEST_f_f (acosh, -max_value, nan_value, INVALID_EXCEPTION);
 973
 974   TEST_f_f (acosh, 1, 0);
 975   TEST_f_f (acosh, 7, 2.63391579384963341725009269461593689L);
 976
 977   END (acosh);
 978 }
 979
 980 static void
 981 asin_test (void)
 982 {
 983   errno = 0;
 984   FUNC(asin) (0);
 985   if (errno == ENOSYS)
 986     /* Function not implemented.  */
 987     return;
 988
 989   START (asin);
 990
 991   TEST_f_f (asin, plus_infty, nan_value, INVALID_EXCEPTION);
 992   TEST_f_f (asin, minus_infty, nan_value, INVALID_EXCEPTION);
 993   TEST_f_f (asin, nan_value, nan_value);
 994
 995   /* asin x == NaN plus invalid exception for |x| > 1.  */
 996   TEST_f_f (asin, 1.125L, nan_value, INVALID_EXCEPTION);
 997   TEST_f_f (asin, -1.125L, nan_value, INVALID_EXCEPTION);
 998   TEST_f_f (asin, max_value, nan_value, INVALID_EXCEPTION);
 999   TEST_f_f (asin, -max_value, nan_value, INVALID_EXCEPTION);
1000
1001   TEST_f_f (asin, 0, 0);
1002   TEST_f_f (asin, minus_zero, minus_zero);
1003   TEST_f_f (asin, 0.5, M_PI_6l);
1004   TEST_f_f (asin, -0.5, -M_PI_6l);
1005   TEST_f_f (asin, 1.0, M_PI_2l);
1006   TEST_f_f (asin, -1.0, -M_PI_2l);
1007   TEST_f_f (asin, 0.75L, 0.848062078981481008052944338998418080L);
1008   TEST_f_f (asin, 0x0.ffffffp0L, 1.5704510598101804156437184421571127056013L);
1009   TEST_f_f (asin, -0x0.ffffffp0L, -1.5704510598101804156437184421571127056013L);
1010 #ifndef TEST_FLOAT
1011   TEST_f_f (asin, 0x0.ffffffff8p0L, 1.5707810680058339712015850710748035974710L);
1012   TEST_f_f (asin, -0x0.ffffffff8p0L, -1.5707810680058339712015850710748035974710L);
1013   TEST_f_f (asin, 0x0.ffffffffffffp0L, 1.5707962425011995974432331617542781977068L);
1014   TEST_f_f (asin, -0x0.ffffffffffffp0L, -1.5707962425011995974432331617542781977068L);
1015 #endif
1016 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
1017   TEST_f_f (asin, 0x0.ffffffffffffffffp0L, 1.5707963264656243652399620683025688888978L);
1018   TEST_f_f (asin, -0x0.ffffffffffffffffp0L, -1.5707963264656243652399620683025688888978L);
1019 #endif
1020
1021   END (asin);
1022 }
1023
1024
1025 static void
1026 asin_test_tonearest (void)
1027 {
1028   int save_round_mode;
1029   errno = 0;
1030   FUNC(asin) (0);
1031   if (errno == ENOSYS)
1032     /* Function not implemented.  */
1033     return;
1034
1035   START (asin_tonearest);
1036
1037   save_round_mode = fegetround ();
1038
1039   if (!fesetround (FE_TONEAREST))
1040     {
1041       TEST_f_f (asin, 0, 0);
1042       TEST_f_f (asin, minus_zero, minus_zero);
1043       TEST_f_f (asin, 0.5, M_PI_6l);
1044       TEST_f_f (asin, -0.5, -M_PI_6l);
1045       TEST_f_f (asin, 1.0, M_PI_2l);
1046       TEST_f_f (asin, -1.0, -M_PI_2l);
1047     }
1048
1049   fesetround (save_round_mode);
1050
1051   END (asin_tonearest);
1052 }
1053
1054
1055 static void
1056 asin_test_towardzero (void)
1057 {
1058   int save_round_mode;
1059   errno = 0;
1060   FUNC(asin) (0);
1061   if (errno == ENOSYS)
1062     /* Function not implemented.  */
1063     return;
1064
1065   START (asin_towardzero);
1066
1067   save_round_mode = fegetround ();
1068
1069   if (!fesetround (FE_TOWARDZERO))
1070     {
1071       TEST_f_f (asin, 0, 0);
1072       TEST_f_f (asin, minus_zero, minus_zero);
1073       TEST_f_f (asin, 0.5, M_PI_6l);
1074       TEST_f_f (asin, -0.5, -M_PI_6l);
1075       TEST_f_f (asin, 1.0, M_PI_2l);
1076       TEST_f_f (asin, -1.0, -M_PI_2l);
1077     }
1078
1079   fesetround (save_round_mode);
1080
1081   END (asin_towardzero);
1082 }
1083
1084
1085 static void
1086 asin_test_downward (void)
1087 {
1088   int save_round_mode;
1089   errno = 0;
1090   FUNC(asin) (0);
1091   if (errno == ENOSYS)
1092     /* Function not implemented.  */
1093     return;
1094
1095   START (asin_downward);
1096
1097   save_round_mode = fegetround ();
1098
1099   if (!fesetround (FE_DOWNWARD))
1100     {
1101       TEST_f_f (asin, 0, 0);
1102       TEST_f_f (asin, minus_zero, minus_zero);
1103       TEST_f_f (asin, 0.5, M_PI_6l);
1104       TEST_f_f (asin, -0.5, -M_PI_6l);
1105       TEST_f_f (asin, 1.0, M_PI_2l);
1106       TEST_f_f (asin, -1.0, -M_PI_2l);
1107     }
1108
1109   fesetround (save_round_mode);
1110
1111   END (asin_downward);
1112 }
1113
1114
1115 static void
1116 asin_test_upward (void)
1117 {
1118   int save_round_mode;
1119   errno = 0;
1120   FUNC(asin) (0);
1121   if (errno == ENOSYS)
1122     /* Function not implemented.  */
1123     return;
1124
1125   START (asin_upward);
1126
1127   save_round_mode = fegetround ();
1128
1129   if (!fesetround (FE_UPWARD))
1130     {
1131       TEST_f_f (asin, 0, 0);
1132       TEST_f_f (asin, minus_zero, minus_zero);
1133       TEST_f_f (asin, 0.5, M_PI_6l);
1134       TEST_f_f (asin, -0.5, -M_PI_6l);
1135       TEST_f_f (asin, 1.0, M_PI_2l);
1136       TEST_f_f (asin, -1.0, -M_PI_2l);
1137     }
1138
1139   fesetround (save_round_mode);
1140
1141   END (asin_upward);
1142 }
1143
1144 static void
1145 asinh_test (void)
1146 {
1147   errno = 0;
1148   FUNC(asinh) (0.7L);
1149   if (errno == ENOSYS)
1150     /* Function not implemented.  */
1151     return;
1152
1153   START (asinh);
1154
1155   TEST_f_f (asinh, 0, 0);
1156   TEST_f_f (asinh, minus_zero, minus_zero);
1157 #ifndef TEST_INLINE
1158   TEST_f_f (asinh, plus_infty, plus_infty);
1159   TEST_f_f (asinh, minus_infty, minus_infty);
1160 #endif
1161   TEST_f_f (asinh, nan_value, nan_value);
1162   TEST_f_f (asinh, 0.75L, 0.693147180559945309417232121458176568L);
1163
1164   END (asinh);
1165 }
1166
1167 static void
1168 atan_test (void)
1169 {
1170   errno = 0;
1171   FUNC(atan) (0);
1172   if (errno == ENOSYS)
1173     /* Function not implemented.  */
1174     return;
1175
1176   START (atan);
1177
1178   TEST_f_f (atan, 0, 0);
1179   TEST_f_f (atan, minus_zero, minus_zero);
1180
1181   TEST_f_f (atan, plus_infty, M_PI_2l);
1182   TEST_f_f (atan, minus_infty, -M_PI_2l);
1183   TEST_f_f (atan, nan_value, nan_value);
1184
1185   TEST_f_f (atan, 1, M_PI_4l);
1186   TEST_f_f (atan, -1, -M_PI_4l);
1187
1188   TEST_f_f (atan, 0.75L, 0.643501108793284386802809228717322638L);
1189
1190   END (atan);
1191 }
1192
1193
1194
1195 static void
1196 atanh_test (void)
1197 {
1198   errno = 0;
1199   FUNC(atanh) (0.7L);
1200   if (errno == ENOSYS)
1201     /* Function not implemented.  */
1202     return;
1203
1204   START (atanh);
1205
1206
1207   TEST_f_f (atanh, 0, 0);
1208   TEST_f_f (atanh, minus_zero, minus_zero);
1209
1210   TEST_f_f (atanh, 1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
1211   TEST_f_f (atanh, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
1212   TEST_f_f (atanh, nan_value, nan_value);
1213
1214   /* atanh (x) == NaN plus invalid exception if |x| > 1.  */
1215   TEST_f_f (atanh, 1.125L, nan_value, INVALID_EXCEPTION);
1216   TEST_f_f (atanh, -1.125L, nan_value, INVALID_EXCEPTION);
1217   TEST_f_f (atanh, max_value, nan_value, INVALID_EXCEPTION);
1218   TEST_f_f (atanh, -max_value, nan_value, INVALID_EXCEPTION);
1219
1220   TEST_f_f (atanh, 0.75L, 0.972955074527656652552676371721589865L);
1221
1222   END (atanh);
1223 }
1224
1225 static void
1226 atan2_test (void)
1227 {
1228   errno = 0;
1229   FUNC(atan2) (-0, 1);
1230   if (errno == ENOSYS)
1231     /* Function not implemented.  */
1232     return;
1233
1234   START (atan2);
1235
1236   /* atan2 (0,x) == 0 for x > 0.  */
1237   TEST_ff_f (atan2, 0, 1, 0);
1238
1239   /* atan2 (-0,x) == -0 for x > 0.  */
1240   TEST_ff_f (atan2, minus_zero, 1, minus_zero);
1241
1242   TEST_ff_f (atan2, 0, 0, 0);
1243   TEST_ff_f (atan2, minus_zero, 0, minus_zero);
1244
1245   /* atan2 (+0,x) == +pi for x < 0.  */
1246   TEST_ff_f (atan2, 0, -1, M_PIl);
1247
1248   /* atan2 (-0,x) == -pi for x < 0.  */
1249   TEST_ff_f (atan2, minus_zero, -1, -M_PIl);
1250
1251   TEST_ff_f (atan2, 0, minus_zero, M_PIl);
1252   TEST_ff_f (atan2, minus_zero, minus_zero, -M_PIl);
1253
1254   /* atan2 (y,+0) == pi/2 for y > 0.  */
1255   TEST_ff_f (atan2, 1, 0, M_PI_2l);
1256
1257   /* atan2 (y,-0) == pi/2 for y > 0.  */
1258   TEST_ff_f (atan2, 1, minus_zero, M_PI_2l);
1259
1260   /* atan2 (y,+0) == -pi/2 for y < 0.  */
1261   TEST_ff_f (atan2, -1, 0, -M_PI_2l);
1262
1263   /* atan2 (y,-0) == -pi/2 for y < 0.  */
1264   TEST_ff_f (atan2, -1, minus_zero, -M_PI_2l);
1265
1266   /* atan2 (y,inf) == +0 for finite y > 0.  */
1267   TEST_ff_f (atan2, 1, plus_infty, 0);
1268
1269   /* atan2 (y,inf) == -0 for finite y < 0.  */
1270   TEST_ff_f (atan2, -1, plus_infty, minus_zero);
1271
1272   /* atan2(+inf, x) == pi/2 for finite x.  */
1273   TEST_ff_f (atan2, plus_infty, -1, M_PI_2l);
1274
1275   /* atan2(-inf, x) == -pi/2 for finite x.  */
1276   TEST_ff_f (atan2, minus_infty, 1, -M_PI_2l);
1277
1278   /* atan2 (y,-inf) == +pi for finite y > 0.  */
1279   TEST_ff_f (atan2, 1, minus_infty, M_PIl);
1280
1281   /* atan2 (y,-inf) == -pi for finite y < 0.  */
1282   TEST_ff_f (atan2, -1, minus_infty, -M_PIl);
1283
1284   TEST_ff_f (atan2, plus_infty, plus_infty, M_PI_4l);
1285   TEST_ff_f (atan2, minus_infty, plus_infty, -M_PI_4l);
1286   TEST_ff_f (atan2, plus_infty, minus_infty, M_PI_34l);
1287   TEST_ff_f (atan2, minus_infty, minus_infty, -M_PI_34l);
1288   TEST_ff_f (atan2, nan_value, nan_value, nan_value);
1289
1290   TEST_ff_f (atan2, max_value, max_value, M_PI_4l);
1291
1292   TEST_ff_f (atan2, 0.75L, 1, 0.643501108793284386802809228717322638L);
1293   TEST_ff_f (atan2, -0.75L, 1.0L, -0.643501108793284386802809228717322638L);
1294   TEST_ff_f (atan2, 0.75L, -1.0L, 2.49809154479650885165983415456218025L);
1295   TEST_ff_f (atan2, -0.75L, -1.0L, -2.49809154479650885165983415456218025L);
1296   TEST_ff_f (atan2, 0.390625L, .00029L, 1.57005392693128974780151246612928941L);
1297   TEST_ff_f (atan2, 1.390625L, 0.9296875L, 0.981498387184244311516296577615519772L);
1298
1299   TEST_ff_f (atan2, -0.00756827042671106339L, -.001792735857538728036L, -1.80338464113663849327153994379639112L);
1300 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
1301   TEST_ff_f (atan2, 0x1.00000000000001p0L, 0x1.00000000000001p0L, M_PI_4l);
1302 #endif
1303
1304   END (atan2);
1305 }
1306
1307 static void
1308 cabs_test (void)
1309 {
1310   errno = 0;
1311   FUNC(cabs) (BUILD_COMPLEX (0.7L, 12.4L));
1312   if (errno == ENOSYS)
1313     /* Function not implemented.  */
1314     return;
1315
1316   START (cabs);
1317
1318   /* cabs (x + iy) is specified as hypot (x,y) */
1319
1320   /* cabs (+inf + i x) == +inf.  */
1321   TEST_c_f (cabs, plus_infty, 1.0, plus_infty);
1322   /* cabs (-inf + i x) == +inf.  */
1323   TEST_c_f (cabs, minus_infty, 1.0, plus_infty);
1324
1325   TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
1326   TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
1327
1328   TEST_c_f (cabs, nan_value, nan_value, nan_value);
1329
1330   /* cabs (x,y) == cabs (y,x).  */
1331   TEST_c_f (cabs, 0.75L, 12.390625L, 12.4133028598606664302388810868156657L);
1332   /* cabs (x,y) == cabs (-x,y).  */
1333   TEST_c_f (cabs, -12.390625L, 0.75L, 12.4133028598606664302388810868156657L);
1334   /* cabs (x,y) == cabs (-y,x).  */
1335   TEST_c_f (cabs, -0.75L, 12.390625L, 12.4133028598606664302388810868156657L);
1336   /* cabs (x,y) == cabs (-x,-y).  */
1337   TEST_c_f (cabs, -12.390625L, -0.75L, 12.4133028598606664302388810868156657L);
1338   /* cabs (x,y) == cabs (-y,-x).  */
1339   TEST_c_f (cabs, -0.75L, -12.390625L, 12.4133028598606664302388810868156657L);
1340   /* cabs (x,0) == fabs (x).  */
1341   TEST_c_f (cabs, -0.75L, 0, 0.75L);
1342   TEST_c_f (cabs, 0.75L, 0, 0.75L);
1343   TEST_c_f (cabs, -1.0L, 0, 1.0L);
1344   TEST_c_f (cabs, 1.0L, 0, 1.0L);
1345   TEST_c_f (cabs, -5.7e7L, 0, 5.7e7L);
1346   TEST_c_f (cabs, 5.7e7L, 0, 5.7e7L);
1347
1348   TEST_c_f (cabs, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
1349
1350   END (cabs);
1351 }
1352
1353
1354 static void
1355 cacos_test (void)
1356 {
1357   errno = 0;
1358   FUNC(cacos) (BUILD_COMPLEX (0.7L, 1.2L));
1359   if (errno == ENOSYS)
1360     /* Function not implemented.  */
1361     return;
1362
1363   START (cacos);
1364
1365
1366   TEST_c_c (cacos, 0, 0, M_PI_2l, minus_zero);
1367   TEST_c_c (cacos, minus_zero, 0, M_PI_2l, minus_zero);
1368   TEST_c_c (cacos, minus_zero, minus_zero, M_PI_2l, 0.0);
1369   TEST_c_c (cacos, 0, minus_zero, M_PI_2l, 0.0);
1370
1371   TEST_c_c (cacos, minus_infty, plus_infty, M_PI_34l, minus_infty);
1372   TEST_c_c (cacos, minus_infty, minus_infty, M_PI_34l, plus_infty);
1373
1374   TEST_c_c (cacos, plus_infty, plus_infty, M_PI_4l, minus_infty);
1375   TEST_c_c (cacos, plus_infty, minus_infty, M_PI_4l, plus_infty);
1376
1377   TEST_c_c (cacos, -10.0, plus_infty, M_PI_2l, minus_infty);
1378   TEST_c_c (cacos, -10.0, minus_infty, M_PI_2l, plus_infty);
1379   TEST_c_c (cacos, 0, plus_infty, M_PI_2l, minus_infty);
1380   TEST_c_c (cacos, 0, minus_infty, M_PI_2l, plus_infty);
1381   TEST_c_c (cacos, 0.1L, plus_infty, M_PI_2l, minus_infty);
1382   TEST_c_c (cacos, 0.1L, minus_infty, M_PI_2l, plus_infty);
1383
1384   TEST_c_c (cacos, minus_infty, 0, M_PIl, minus_infty);
1385   TEST_c_c (cacos, minus_infty, minus_zero, M_PIl, plus_infty);
1386   TEST_c_c (cacos, minus_infty, 100, M_PIl, minus_infty);
1387   TEST_c_c (cacos, minus_infty, -100, M_PIl, plus_infty);
1388
1389   TEST_c_c (cacos, plus_infty, 0, 0.0, minus_infty);
1390   TEST_c_c (cacos, plus_infty, minus_zero, 0.0, plus_infty);
1391   TEST_c_c (cacos, plus_infty, 0.5, 0.0, minus_infty);
1392   TEST_c_c (cacos, plus_infty, -0.5, 0.0, plus_infty);
1393
1394   TEST_c_c (cacos, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1395   TEST_c_c (cacos, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1396
1397   TEST_c_c (cacos, 0, nan_value, M_PI_2l, nan_value);
1398   TEST_c_c (cacos, minus_zero, nan_value, M_PI_2l, nan_value);
1399
1400   TEST_c_c (cacos, nan_value, plus_infty, nan_value, minus_infty);
1401   TEST_c_c (cacos, nan_value, minus_infty, nan_value, plus_infty);
1402
1403   TEST_c_c (cacos, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1404   TEST_c_c (cacos, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1405
1406   TEST_c_c (cacos, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1407   TEST_c_c (cacos, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1408
1409   TEST_c_c (cacos, nan_value, nan_value, nan_value, nan_value);
1410
1411   TEST_c_c (cacos, plus_zero, -1.5L, M_PI_2l, 1.194763217287109304111930828519090523536L);
1412   TEST_c_c (cacos, minus_zero, -1.5L, M_PI_2l, 1.194763217287109304111930828519090523536L);
1413   TEST_c_c (cacos, plus_zero, -1.0L, M_PI_2l, 0.8813735870195430252326093249797923090282L);
1414   TEST_c_c (cacos, minus_zero, -1.0L, M_PI_2l, 0.8813735870195430252326093249797923090282L);
1415   TEST_c_c (cacos, plus_zero, -0.5L, M_PI_2l, 0.4812118250596034474977589134243684231352L);
1416   TEST_c_c (cacos, minus_zero, -0.5L, M_PI_2l, 0.4812118250596034474977589134243684231352L);
1417   TEST_c_c (cacos, plus_zero, 0.5L, M_PI_2l, -0.4812118250596034474977589134243684231352L);
1418   TEST_c_c (cacos, minus_zero, 0.5L, M_PI_2l, -0.4812118250596034474977589134243684231352L);
1419   TEST_c_c (cacos, plus_zero, 1.0L, M_PI_2l, -0.8813735870195430252326093249797923090282L);
1420   TEST_c_c (cacos, minus_zero, 1.0L, M_PI_2l, -0.8813735870195430252326093249797923090282L);
1421   TEST_c_c (cacos, plus_zero, 1.5L, M_PI_2l, -1.194763217287109304111930828519090523536L);
1422   TEST_c_c (cacos, minus_zero, 1.5L, M_PI_2l, -1.194763217287109304111930828519090523536L);
1423
1424   TEST_c_c (cacos, -1.5L, plus_zero, M_PIl, -0.9624236501192068949955178268487368462704L);
1425   TEST_c_c (cacos, -1.5L, minus_zero, M_PIl, 0.9624236501192068949955178268487368462704L);
1426   TEST_c_c (cacos, -1.0L, plus_zero, M_PIl, minus_zero);
1427   TEST_c_c (cacos, -1.0L, minus_zero, M_PIl, plus_zero);
1428   TEST_c_c (cacos, -0.5L, plus_zero, 2.094395102393195492308428922186335256131L, minus_zero);
1429   TEST_c_c (cacos, -0.5L, minus_zero, 2.094395102393195492308428922186335256131L, plus_zero);
1430   TEST_c_c (cacos, 0.5L, plus_zero, 1.047197551196597746154214461093167628066L, minus_zero);
1431   TEST_c_c (cacos, 0.5L, minus_zero, 1.047197551196597746154214461093167628066L, plus_zero);
1432   TEST_c_c (cacos, 1.0L, plus_zero, plus_zero, minus_zero);
1433   TEST_c_c (cacos, 1.0L, minus_zero, plus_zero, plus_zero);
1434   TEST_c_c (cacos, 1.5L, plus_zero, plus_zero, -0.9624236501192068949955178268487368462704L);
1435   TEST_c_c (cacos, 1.5L, minus_zero, plus_zero, 0.9624236501192068949955178268487368462704L);
1436
1437   TEST_c_c (cacos, 0.75L, 1.25L, 1.11752014915610270578240049553777969L, -1.13239363160530819522266333696834467L);
1438   TEST_c_c (cacos, -2, -3, 2.1414491111159960199416055713254211L, 1.9833870299165354323470769028940395L);
1439
1440   END (cacos, complex);
1441 }
1442
1443 static void
1444 cacosh_test (void)
1445 {
1446   errno = 0;
1447   FUNC(cacosh) (BUILD_COMPLEX (0.7L, 1.2L));
1448   if (errno == ENOSYS)
1449     /* Function not implemented.  */
1450     return;
1451
1452   START (cacosh);
1453
1454
1455   TEST_c_c (cacosh, 0, 0, 0.0, M_PI_2l);
1456   TEST_c_c (cacosh, minus_zero, 0, 0.0, M_PI_2l);
1457   TEST_c_c (cacosh, 0, minus_zero, 0.0, -M_PI_2l);
1458   TEST_c_c (cacosh, minus_zero, minus_zero, 0.0, -M_PI_2l);
1459   TEST_c_c (cacosh, minus_infty, plus_infty, plus_infty, M_PI_34l);
1460   TEST_c_c (cacosh, minus_infty, minus_infty, plus_infty, -M_PI_34l);
1461
1462   TEST_c_c (cacosh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1463   TEST_c_c (cacosh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1464
1465   TEST_c_c (cacosh, -10.0, plus_infty, plus_infty, M_PI_2l);
1466   TEST_c_c (cacosh, -10.0, minus_infty, plus_infty, -M_PI_2l);
1467   TEST_c_c (cacosh, 0, plus_infty, plus_infty, M_PI_2l);
1468   TEST_c_c (cacosh, 0, minus_infty, plus_infty, -M_PI_2l);
1469   TEST_c_c (cacosh, 0.1L, plus_infty, plus_infty, M_PI_2l);
1470   TEST_c_c (cacosh, 0.1L, minus_infty, plus_infty, -M_PI_2l);
1471
1472   TEST_c_c (cacosh, minus_infty, 0, plus_infty, M_PIl);
1473   TEST_c_c (cacosh, minus_infty, minus_zero, plus_infty, -M_PIl);
1474   TEST_c_c (cacosh, minus_infty, 100, plus_infty, M_PIl);
1475   TEST_c_c (cacosh, minus_infty, -100, plus_infty, -M_PIl);
1476
1477   TEST_c_c (cacosh, plus_infty, 0, plus_infty, 0.0);
1478   TEST_c_c (cacosh, plus_infty, minus_zero, plus_infty, minus_zero);
1479   TEST_c_c (cacosh, plus_infty, 0.5, plus_infty, 0.0);
1480   TEST_c_c (cacosh, plus_infty, -0.5, plus_infty, minus_zero);
1481
1482   TEST_c_c (cacosh, plus_infty, nan_value, plus_infty, nan_value);
1483   TEST_c_c (cacosh, minus_infty, nan_value, plus_infty, nan_value);
1484
1485   TEST_c_c (cacosh, 0, nan_value, nan_value, nan_value);
1486   TEST_c_c (cacosh, minus_zero, nan_value, nan_value, nan_value);
1487
1488   TEST_c_c (cacosh, nan_value, plus_infty, plus_infty, nan_value);
1489   TEST_c_c (cacosh, nan_value, minus_infty, plus_infty, nan_value);
1490
1491   TEST_c_c (cacosh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1492   TEST_c_c (cacosh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1493
1494   TEST_c_c (cacosh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1495   TEST_c_c (cacosh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1496
1497   TEST_c_c (cacosh, nan_value, nan_value, nan_value, nan_value);
1498
1499   TEST_c_c (cacosh, plus_zero, -1.5L, 1.194763217287109304111930828519090523536L, -M_PI_2l);
1500   TEST_c_c (cacosh, minus_zero, -1.5L, 1.194763217287109304111930828519090523536L, -M_PI_2l);
1501   TEST_c_c (cacosh, plus_zero, -1.0L, 0.8813735870195430252326093249797923090282L, -M_PI_2l);
1502   TEST_c_c (cacosh, minus_zero, -1.0L, 0.8813735870195430252326093249797923090282L, -M_PI_2l);
1503   TEST_c_c (cacosh, plus_zero, -0.5L, 0.4812118250596034474977589134243684231352L, -M_PI_2l);
1504   TEST_c_c (cacosh, minus_zero, -0.5L, 0.4812118250596034474977589134243684231352L, -M_PI_2l);
1505   TEST_c_c (cacosh, plus_zero, 0.5L, 0.4812118250596034474977589134243684231352L, M_PI_2l);
1506   TEST_c_c (cacosh, minus_zero, 0.5L, 0.4812118250596034474977589134243684231352L, M_PI_2l);
1507   TEST_c_c (cacosh, plus_zero, 1.0L, 0.8813735870195430252326093249797923090282L, M_PI_2l);
1508   TEST_c_c (cacosh, minus_zero, 1.0L, 0.8813735870195430252326093249797923090282L, M_PI_2l);
1509   TEST_c_c (cacosh, plus_zero, 1.5L, 1.194763217287109304111930828519090523536L, M_PI_2l);
1510   TEST_c_c (cacosh, minus_zero, 1.5L, 1.194763217287109304111930828519090523536L, M_PI_2l);
1511
1512   TEST_c_c (cacosh, -1.5L, plus_zero, 0.9624236501192068949955178268487368462704L, M_PIl);
1513   TEST_c_c (cacosh, -1.5L, minus_zero, 0.9624236501192068949955178268487368462704L, -M_PIl);
1514   TEST_c_c (cacosh, -1.0L, plus_zero, plus_zero, M_PIl);
1515   TEST_c_c (cacosh, -1.0L, minus_zero, plus_zero, -M_PIl);
1516   TEST_c_c (cacosh, -0.5L, plus_zero, plus_zero, 2.094395102393195492308428922186335256131L);
1517   TEST_c_c (cacosh, -0.5L, minus_zero, plus_zero, -2.094395102393195492308428922186335256131L);
1518   TEST_c_c (cacosh, 0.5L, plus_zero, plus_zero, 1.047197551196597746154214461093167628066L);
1519   TEST_c_c (cacosh, 0.5L, minus_zero, plus_zero, -1.047197551196597746154214461093167628066L);
1520   TEST_c_c (cacosh, 1.0L, plus_zero, plus_zero, plus_zero);
1521   TEST_c_c (cacosh, 1.0L, minus_zero, plus_zero, minus_zero);
1522   TEST_c_c (cacosh, 1.5L, plus_zero, 0.9624236501192068949955178268487368462704L, plus_zero);
1523   TEST_c_c (cacosh, 1.5L, minus_zero, 0.9624236501192068949955178268487368462704L, minus_zero);
1524
1525   TEST_c_c (cacosh, 0.75L, 1.25L, 1.13239363160530819522266333696834467L, 1.11752014915610270578240049553777969L);
1526   TEST_c_c (cacosh, -2, -3, 1.9833870299165354323470769028940395L, -2.1414491111159960199416055713254211L);
1527
1528   END (cacosh, complex);
1529 }
1530
1531
1532 static void
1533 carg_test (void)
1534 {
1535   START (carg);
1536
1537   /* carg (x + iy) is specified as atan2 (y, x) */
1538
1539   /* carg (x + i 0) == 0 for x > 0.  */
1540   TEST_c_f (carg, 2.0, 0, 0);
1541   /* carg (x - i 0) == -0 for x > 0.  */
1542   TEST_c_f (carg, 2.0, minus_zero, minus_zero);
1543
1544   TEST_c_f (carg, 0, 0, 0);
1545   TEST_c_f (carg, 0, minus_zero, minus_zero);
1546
1547   /* carg (x + i 0) == +pi for x < 0.  */
1548   TEST_c_f (carg, -2.0, 0, M_PIl);
1549
1550   /* carg (x - i 0) == -pi for x < 0.  */
1551   TEST_c_f (carg, -2.0, minus_zero, -M_PIl);
1552
1553   TEST_c_f (carg, minus_zero, 0, M_PIl);
1554   TEST_c_f (carg, minus_zero, minus_zero, -M_PIl);
1555
1556   /* carg (+0 + i y) == pi/2 for y > 0.  */
1557   TEST_c_f (carg, 0, 2.0, M_PI_2l);
1558
1559   /* carg (-0 + i y) == pi/2 for y > 0.  */
1560   TEST_c_f (carg, minus_zero, 2.0, M_PI_2l);
1561
1562   /* carg (+0 + i y) == -pi/2 for y < 0.  */
1563   TEST_c_f (carg, 0, -2.0, -M_PI_2l);
1564
1565   /* carg (-0 + i y) == -pi/2 for y < 0.  */
1566   TEST_c_f (carg, minus_zero, -2.0, -M_PI_2l);
1567
1568   /* carg (inf + i y) == +0 for finite y > 0.  */
1569   TEST_c_f (carg, plus_infty, 2.0, 0);
1570
1571   /* carg (inf + i y) == -0 for finite y < 0.  */
1572   TEST_c_f (carg, plus_infty, -2.0, minus_zero);
1573
1574   /* carg(x + i inf) == pi/2 for finite x.  */
1575   TEST_c_f (carg, 10.0, plus_infty, M_PI_2l);
1576
1577   /* carg(x - i inf) == -pi/2 for finite x.  */
1578   TEST_c_f (carg, 10.0, minus_infty, -M_PI_2l);
1579
1580   /* carg (-inf + i y) == +pi for finite y > 0.  */
1581   TEST_c_f (carg, minus_infty, 10.0, M_PIl);
1582
1583   /* carg (-inf + i y) == -pi for finite y < 0.  */
1584   TEST_c_f (carg, minus_infty, -10.0, -M_PIl);
1585
1586   TEST_c_f (carg, plus_infty, plus_infty, M_PI_4l);
1587
1588   TEST_c_f (carg, plus_infty, minus_infty, -M_PI_4l);
1589
1590   TEST_c_f (carg, minus_infty, plus_infty, 3 * M_PI_4l);
1591
1592   TEST_c_f (carg, minus_infty, minus_infty, -3 * M_PI_4l);
1593
1594   TEST_c_f (carg, nan_value, nan_value, nan_value);
1595
1596   END (carg);
1597 }
1598
1599 static void
1600 casin_test (void)
1601 {
1602   errno = 0;
1603   FUNC(casin) (BUILD_COMPLEX (0.7L, 1.2L));
1604   if (errno == ENOSYS)
1605     /* Function not implemented.  */
1606     return;
1607
1608   START (casin);
1609
1610   TEST_c_c (casin, 0, 0, 0.0, 0.0);
1611   TEST_c_c (casin, minus_zero, 0, minus_zero, 0.0);
1612   TEST_c_c (casin, 0, minus_zero, 0.0, minus_zero);
1613   TEST_c_c (casin, minus_zero, minus_zero, minus_zero, minus_zero);
1614
1615   TEST_c_c (casin, plus_infty, plus_infty, M_PI_4l, plus_infty);
1616   TEST_c_c (casin, plus_infty, minus_infty, M_PI_4l, minus_infty);
1617   TEST_c_c (casin, minus_infty, plus_infty, -M_PI_4l, plus_infty);
1618   TEST_c_c (casin, minus_infty, minus_infty, -M_PI_4l, minus_infty);
1619
1620   TEST_c_c (casin, -10.0, plus_infty, minus_zero, plus_infty);
1621   TEST_c_c (casin, -10.0, minus_infty, minus_zero, minus_infty);
1622   TEST_c_c (casin, 0, plus_infty, 0.0, plus_infty);
1623   TEST_c_c (casin, 0, minus_infty, 0.0, minus_infty);
1624   TEST_c_c (casin, minus_zero, plus_infty, minus_zero, plus_infty);
1625   TEST_c_c (casin, minus_zero, minus_infty, minus_zero, minus_infty);
1626   TEST_c_c (casin, 0.1L, plus_infty, 0.0, plus_infty);
1627   TEST_c_c (casin, 0.1L, minus_infty, 0.0, minus_infty);
1628
1629   TEST_c_c (casin, minus_infty, 0, -M_PI_2l, plus_infty);
1630   TEST_c_c (casin, minus_infty, minus_zero, -M_PI_2l, minus_infty);
1631   TEST_c_c (casin, minus_infty, 100, -M_PI_2l, plus_infty);
1632   TEST_c_c (casin, minus_infty, -100, -M_PI_2l, minus_infty);
1633
1634   TEST_c_c (casin, plus_infty, 0, M_PI_2l, plus_infty);
1635   TEST_c_c (casin, plus_infty, minus_zero, M_PI_2l, minus_infty);
1636   TEST_c_c (casin, plus_infty, 0.5, M_PI_2l, plus_infty);
1637   TEST_c_c (casin, plus_infty, -0.5, M_PI_2l, minus_infty);
1638
1639   TEST_c_c (casin, nan_value, plus_infty, nan_value, plus_infty);
1640   TEST_c_c (casin, nan_value, minus_infty, nan_value, minus_infty);
1641
1642   TEST_c_c (casin, 0.0, nan_value, 0.0, nan_value);
1643   TEST_c_c (casin, minus_zero, nan_value, minus_zero, nan_value);
1644
1645   TEST_c_c (casin, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1646   TEST_c_c (casin, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1647
1648   TEST_c_c (casin, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1649   TEST_c_c (casin, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1650
1651   TEST_c_c (casin, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1652   TEST_c_c (casin, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1653
1654   TEST_c_c (casin, nan_value, nan_value, nan_value, nan_value);
1655
1656   TEST_c_c (casin, plus_zero, -1.5L, plus_zero, -1.194763217287109304111930828519090523536L);
1657   TEST_c_c (casin, minus_zero, -1.5L, minus_zero, -1.194763217287109304111930828519090523536L);
1658   TEST_c_c (casin, plus_zero, -1.0L, plus_zero, -0.8813735870195430252326093249797923090282L);
1659   TEST_c_c (casin, minus_zero, -1.0L, minus_zero, -0.8813735870195430252326093249797923090282L);
1660   TEST_c_c (casin, plus_zero, -0.5L, plus_zero, -0.4812118250596034474977589134243684231352L);
1661   TEST_c_c (casin, minus_zero, -0.5L, minus_zero, -0.4812118250596034474977589134243684231352L);
1662   TEST_c_c (casin, plus_zero, 0.5L, plus_zero, 0.4812118250596034474977589134243684231352L);
1663   TEST_c_c (casin, minus_zero, 0.5L, minus_zero, 0.4812118250596034474977589134243684231352L);
1664   TEST_c_c (casin, plus_zero, 1.0L, plus_zero, 0.8813735870195430252326093249797923090282L);
1665   TEST_c_c (casin, minus_zero, 1.0L, minus_zero, 0.8813735870195430252326093249797923090282L);
1666   TEST_c_c (casin, plus_zero, 1.5L, plus_zero, 1.194763217287109304111930828519090523536L);
1667   TEST_c_c (casin, minus_zero, 1.5L, minus_zero, 1.194763217287109304111930828519090523536L);
1668
1669   TEST_c_c (casin, -1.5L, plus_zero, -M_PI_2l, 0.9624236501192068949955178268487368462704L);
1670   TEST_c_c (casin, -1.5L, minus_zero, -M_PI_2l, -0.9624236501192068949955178268487368462704L);
1671   TEST_c_c (casin, -1.0L, plus_zero, -M_PI_2l, plus_zero);
1672   TEST_c_c (casin, -1.0L, minus_zero, -M_PI_2l, minus_zero);
1673   TEST_c_c (casin, -0.5L, plus_zero, -0.5235987755982988730771072305465838140329L, plus_zero);
1674   TEST_c_c (casin, -0.5L, minus_zero, -0.5235987755982988730771072305465838140329L, minus_zero);
1675   TEST_c_c (casin, 0.5L, plus_zero, 0.5235987755982988730771072305465838140329L, plus_zero);
1676   TEST_c_c (casin, 0.5L, minus_zero, 0.5235987755982988730771072305465838140329L, minus_zero);
1677   TEST_c_c (casin, 1.0L, plus_zero, M_PI_2l, plus_zero);
1678   TEST_c_c (casin, 1.0L, minus_zero, M_PI_2l, minus_zero);
1679   TEST_c_c (casin, 1.5L, plus_zero, M_PI_2l, 0.9624236501192068949955178268487368462704L);
1680   TEST_c_c (casin, 1.5L, minus_zero, M_PI_2l, -0.9624236501192068949955178268487368462704L);
1681
1682   TEST_c_c (casin, 0.75L, 1.25L, 0.453276177638793913448921196101971749L, 1.13239363160530819522266333696834467L);
1683   TEST_c_c (casin, -2, -3, -0.57065278432109940071028387968566963L, -1.9833870299165354323470769028940395L);
1684
1685   END (casin, complex);
1686 }
1687
1688
1689 static void
1690 casinh_test (void)
1691 {
1692   errno = 0;
1693   FUNC(casinh) (BUILD_COMPLEX (0.7L, 1.2L));
1694   if (errno == ENOSYS)
1695     /* Function not implemented.  */
1696     return;
1697
1698   START (casinh);
1699
1700   TEST_c_c (casinh, 0, 0, 0.0, 0.0);
1701   TEST_c_c (casinh, minus_zero, 0, minus_zero, 0);
1702   TEST_c_c (casinh, 0, minus_zero, 0.0, minus_zero);
1703   TEST_c_c (casinh, minus_zero, minus_zero, minus_zero, minus_zero);
1704
1705   TEST_c_c (casinh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1706   TEST_c_c (casinh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1707   TEST_c_c (casinh, minus_infty, plus_infty, minus_infty, M_PI_4l);
1708   TEST_c_c (casinh, minus_infty, minus_infty, minus_infty, -M_PI_4l);
1709
1710   TEST_c_c (casinh, -10.0, plus_infty, minus_infty, M_PI_2l);
1711   TEST_c_c (casinh, -10.0, minus_infty, minus_infty, -M_PI_2l);
1712   TEST_c_c (casinh, 0, plus_infty, plus_infty, M_PI_2l);
1713   TEST_c_c (casinh, 0, minus_infty, plus_infty, -M_PI_2l);
1714   TEST_c_c (casinh, minus_zero, plus_infty, minus_infty, M_PI_2l);
1715   TEST_c_c (casinh, minus_zero, minus_infty, minus_infty, -M_PI_2l);
1716   TEST_c_c (casinh, 0.1L, plus_infty, plus_infty, M_PI_2l);
1717   TEST_c_c (casinh, 0.1L, minus_infty, plus_infty, -M_PI_2l);
1718
1719   TEST_c_c (casinh, minus_infty, 0, minus_infty, 0.0);
1720   TEST_c_c (casinh, minus_infty, minus_zero, minus_infty, minus_zero);
1721   TEST_c_c (casinh, minus_infty, 100, minus_infty, 0.0);
1722   TEST_c_c (casinh, minus_infty, -100, minus_infty, minus_zero);
1723
1724   TEST_c_c (casinh, plus_infty, 0, plus_infty, 0.0);
1725   TEST_c_c (casinh, plus_infty, minus_zero, plus_infty, minus_zero);
1726   TEST_c_c (casinh, plus_infty, 0.5, plus_infty, 0.0);
1727   TEST_c_c (casinh, plus_infty, -0.5, plus_infty, minus_zero);
1728
1729   TEST_c_c (casinh, plus_infty, nan_value, plus_infty, nan_value);
1730   TEST_c_c (casinh, minus_infty, nan_value, minus_infty, nan_value);
1731
1732   TEST_c_c (casinh, nan_value, 0, nan_value, 0.0);
1733   TEST_c_c (casinh, nan_value, minus_zero, nan_value, minus_zero);
1734
1735   TEST_c_c (casinh, nan_value, plus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1736   TEST_c_c (casinh, nan_value, minus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1737
1738   TEST_c_c (casinh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1739   TEST_c_c (casinh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1740
1741   TEST_c_c (casinh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1742   TEST_c_c (casinh, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1743
1744   TEST_c_c (casinh, nan_value, nan_value, nan_value, nan_value);
1745
1746   TEST_c_c (casinh, plus_zero, -1.5L, 0.9624236501192068949955178268487368462704L, -M_PI_2l);
1747   TEST_c_c (casinh, minus_zero, -1.5L, -0.9624236501192068949955178268487368462704L, -M_PI_2l);
1748   TEST_c_c (casinh, plus_zero, -1.0L, plus_zero, -M_PI_2l);
1749   TEST_c_c (casinh, minus_zero, -1.0L, minus_zero, -M_PI_2l);
1750   TEST_c_c (casinh, plus_zero, -0.5L, plus_zero, -0.5235987755982988730771072305465838140329L);
1751   TEST_c_c (casinh, minus_zero, -0.5L, minus_zero, -0.5235987755982988730771072305465838140329L);
1752   TEST_c_c (casinh, plus_zero, 0.5L, plus_zero, 0.5235987755982988730771072305465838140329L);
1753   TEST_c_c (casinh, minus_zero, 0.5L, minus_zero, 0.5235987755982988730771072305465838140329L);
1754   TEST_c_c (casinh, plus_zero, 1.0L, plus_zero, M_PI_2l);
1755   TEST_c_c (casinh, minus_zero, 1.0L, minus_zero, M_PI_2l);
1756   TEST_c_c (casinh, plus_zero, 1.5L, 0.9624236501192068949955178268487368462704L, M_PI_2l);
1757   TEST_c_c (casinh, minus_zero, 1.5L, -0.9624236501192068949955178268487368462704L, M_PI_2l);
1758
1759   TEST_c_c (casinh, -1.5L, plus_zero, -1.194763217287109304111930828519090523536L, plus_zero);
1760   TEST_c_c (casinh, -1.5L, minus_zero, -1.194763217287109304111930828519090523536L, minus_zero);
1761   TEST_c_c (casinh, -1.0L, plus_zero, -0.8813735870195430252326093249797923090282L, plus_zero);
1762   TEST_c_c (casinh, -1.0L, minus_zero, -0.8813735870195430252326093249797923090282L, minus_zero);
1763   TEST_c_c (casinh, -0.5L, plus_zero, -0.4812118250596034474977589134243684231352L, plus_zero);
1764   TEST_c_c (casinh, -0.5L, minus_zero, -0.4812118250596034474977589134243684231352L, minus_zero);
1765   TEST_c_c (casinh, 0.5L, plus_zero, 0.4812118250596034474977589134243684231352L, plus_zero);
1766   TEST_c_c (casinh, 0.5L, minus_zero, 0.4812118250596034474977589134243684231352L, minus_zero);
1767   TEST_c_c (casinh, 1.0L, plus_zero, 0.8813735870195430252326093249797923090282L, plus_zero);
1768   TEST_c_c (casinh, 1.0L, minus_zero, 0.8813735870195430252326093249797923090282L, minus_zero);
1769   TEST_c_c (casinh, 1.5L, plus_zero, 1.194763217287109304111930828519090523536L, plus_zero);
1770   TEST_c_c (casinh, 1.5L, minus_zero, 1.194763217287109304111930828519090523536L, minus_zero);
1771
1772   TEST_c_c (casinh, 0.75L, 1.25L, 1.03171853444778027336364058631006594L, 0.911738290968487636358489564316731207L);
1773   TEST_c_c (casinh, -2, -3, -1.9686379257930962917886650952454982L, -0.96465850440760279204541105949953237L);
1774
1775   END (casinh, complex);
1776 }
1777
1778
1779 static void
1780 catan_test (void)
1781 {
1782   errno = 0;
1783   FUNC(catan) (BUILD_COMPLEX (0.7L, 1.2L));
1784   if (errno == ENOSYS)
1785     /* Function not implemented.  */
1786     return;
1787
1788   START (catan);
1789
1790   TEST_c_c (catan, 0, 0, 0, 0);
1791   TEST_c_c (catan, minus_zero, 0, minus_zero, 0);
1792   TEST_c_c (catan, 0, minus_zero, 0, minus_zero);
1793   TEST_c_c (catan, minus_zero, minus_zero, minus_zero, minus_zero);
1794
1795   TEST_c_c (catan, plus_infty, plus_infty, M_PI_2l, 0);
1796   TEST_c_c (catan, plus_infty, minus_infty, M_PI_2l, minus_zero);
1797   TEST_c_c (catan, minus_infty, plus_infty, -M_PI_2l, 0);
1798   TEST_c_c (catan, minus_infty, minus_infty, -M_PI_2l, minus_zero);
1799
1800
1801   TEST_c_c (catan, plus_infty, -10.0, M_PI_2l, minus_zero);
1802   TEST_c_c (catan, minus_infty, -10.0, -M_PI_2l, minus_zero);
1803   TEST_c_c (catan, plus_infty, minus_zero, M_PI_2l, minus_zero);
1804   TEST_c_c (catan, minus_infty, minus_zero, -M_PI_2l, minus_zero);
1805   TEST_c_c (catan, plus_infty, 0.0, M_PI_2l, 0);
1806   TEST_c_c (catan, minus_infty, 0.0, -M_PI_2l, 0);
1807   TEST_c_c (catan, plus_infty, 0.1L, M_PI_2l, 0);
1808   TEST_c_c (catan, minus_infty, 0.1L, -M_PI_2l, 0);
1809
1810   TEST_c_c (catan, 0.0, minus_infty, M_PI_2l, minus_zero);
1811   TEST_c_c (catan, minus_zero, minus_infty, -M_PI_2l, minus_zero);
1812   TEST_c_c (catan, 100.0, minus_infty, M_PI_2l, minus_zero);
1813   TEST_c_c (catan, -100.0, minus_infty, -M_PI_2l, minus_zero);
1814
1815   TEST_c_c (catan, 0.0, plus_infty, M_PI_2l, 0);
1816   TEST_c_c (catan, minus_zero, plus_infty, -M_PI_2l, 0);
1817   TEST_c_c (catan, 0.5, plus_infty, M_PI_2l, 0);
1818   TEST_c_c (catan, -0.5, plus_infty, -M_PI_2l, 0);
1819
1820   TEST_c_c (catan, nan_value, 0.0, nan_value, 0);
1821   TEST_c_c (catan, nan_value, minus_zero, nan_value, minus_zero);
1822
1823   TEST_c_c (catan, nan_value, plus_infty, nan_value, 0);
1824   TEST_c_c (catan, nan_value, minus_infty, nan_value, minus_zero);
1825
1826   TEST_c_c (catan, 0.0, nan_value, nan_value, nan_value);
1827   TEST_c_c (catan, minus_zero, nan_value, nan_value, nan_value);
1828
1829   TEST_c_c (catan, plus_infty, nan_value, M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1830   TEST_c_c (catan, minus_infty, nan_value, -M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1831
1832   TEST_c_c (catan, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1833   TEST_c_c (catan, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1834
1835   TEST_c_c (catan, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1836   TEST_c_c (catan, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1837
1838   TEST_c_c (catan, nan_value, nan_value, nan_value, nan_value);
1839
1840   TEST_c_c (catan, 0.75L, 1.25L, 1.10714871779409050301706546017853704L, 0.549306144334054845697622618461262852L);
1841   TEST_c_c (catan, -2, -3, -1.4099210495965755225306193844604208L, -0.22907268296853876629588180294200276L);
1842
1843   END (catan, complex);
1844 }
1845
1846 static void
1847 catanh_test (void)
1848 {
1849   errno = 0;
1850   FUNC(catanh) (BUILD_COMPLEX (0.7L, 1.2L));
1851   if (errno == ENOSYS)
1852     /* Function not implemented.  */
1853     return;
1854
1855   START (catanh);
1856
1857   TEST_c_c (catanh, 0, 0, 0.0, 0.0);
1858   TEST_c_c (catanh, minus_zero, 0, minus_zero, 0.0);
1859   TEST_c_c (catanh, 0, minus_zero, 0.0, minus_zero);
1860   TEST_c_c (catanh, minus_zero, minus_zero, minus_zero, minus_zero);
1861
1862   TEST_c_c (catanh, plus_infty, plus_infty, 0.0, M_PI_2l);
1863   TEST_c_c (catanh, plus_infty, minus_infty, 0.0, -M_PI_2l);
1864   TEST_c_c (catanh, minus_infty, plus_infty, minus_zero, M_PI_2l);
1865   TEST_c_c (catanh, minus_infty, minus_infty, minus_zero, -M_PI_2l);
1866
1867   TEST_c_c (catanh, -10.0, plus_infty, minus_zero, M_PI_2l);
1868   TEST_c_c (catanh, -10.0, minus_infty, minus_zero, -M_PI_2l);
1869   TEST_c_c (catanh, minus_zero, plus_infty, minus_zero, M_PI_2l);
1870   TEST_c_c (catanh, minus_zero, minus_infty, minus_zero, -M_PI_2l);
1871   TEST_c_c (catanh, 0, plus_infty, 0.0, M_PI_2l);
1872   TEST_c_c (catanh, 0, minus_infty, 0.0, -M_PI_2l);
1873   TEST_c_c (catanh, 0.1L, plus_infty, 0.0, M_PI_2l);
1874   TEST_c_c (catanh, 0.1L, minus_infty, 0.0, -M_PI_2l);
1875
1876   TEST_c_c (catanh, minus_infty, 0, minus_zero, M_PI_2l);
1877   TEST_c_c (catanh, minus_infty, minus_zero, minus_zero, -M_PI_2l);
1878   TEST_c_c (catanh, minus_infty, 100, minus_zero, M_PI_2l);
1879   TEST_c_c (catanh, minus_infty, -100, minus_zero, -M_PI_2l);
1880
1881   TEST_c_c (catanh, plus_infty, 0, 0.0, M_PI_2l);
1882   TEST_c_c (catanh, plus_infty, minus_zero, 0.0, -M_PI_2l);
1883   TEST_c_c (catanh, plus_infty, 0.5, 0.0, M_PI_2l);
1884   TEST_c_c (catanh, plus_infty, -0.5, 0.0, -M_PI_2l);
1885
1886   TEST_c_c (catanh, 0, nan_value, 0.0, nan_value);
1887   TEST_c_c (catanh, minus_zero, nan_value, minus_zero, nan_value);
1888
1889   TEST_c_c (catanh, plus_infty, nan_value, 0.0, nan_value);
1890   TEST_c_c (catanh, minus_infty, nan_value, minus_zero, nan_value);
1891
1892   TEST_c_c (catanh, nan_value, 0, nan_value, nan_value);
1893   TEST_c_c (catanh, nan_value, minus_zero, nan_value, nan_value);
1894
1895   TEST_c_c (catanh, nan_value, plus_infty, 0.0, M_PI_2l, IGNORE_ZERO_INF_SIGN);
1896   TEST_c_c (catanh, nan_value, minus_infty, 0.0, -M_PI_2l, IGNORE_ZERO_INF_SIGN);
1897
1898   TEST_c_c (catanh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1899   TEST_c_c (catanh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1900
1901   TEST_c_c (catanh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1902   TEST_c_c (catanh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1903
1904   TEST_c_c (catanh, nan_value, nan_value, nan_value, nan_value);
1905
1906   TEST_c_c (catanh, 0.75L, 1.25L, 0.261492138795671927078652057366532140L, 0.996825126463918666098902241310446708L);
1907   TEST_c_c (catanh, -2, -3, -0.14694666622552975204743278515471595L, -1.3389725222944935611241935759091443L);
1908
1909   END (catanh, complex);
1910 }
1911
1912 static void
1913 cbrt_test (void)
1914 {
1915   errno = 0;
1916   FUNC(cbrt) (8);
1917   if (errno == ENOSYS)
1918     /* Function not implemented.  */
1919     return;
1920
1921   START (cbrt);
1922
1923   TEST_f_f (cbrt, 0.0, 0.0);
1924   TEST_f_f (cbrt, minus_zero, minus_zero);
1925
1926   TEST_f_f (cbrt, plus_infty, plus_infty);
1927   TEST_f_f (cbrt, minus_infty, minus_infty);
1928   TEST_f_f (cbrt, nan_value, nan_value);
1929
1930   TEST_f_f (cbrt, -0.001L, -0.1L);
1931   TEST_f_f (cbrt, 8, 2);
1932   TEST_f_f (cbrt, -27.0, -3.0);
1933   TEST_f_f (cbrt, 0.9921875L, 0.997389022060725270579075195353955217L);
1934   TEST_f_f (cbrt, 0.75L, 0.908560296416069829445605878163630251L);
1935
1936   END (cbrt);
1937 }
1938
1939
1940 static void
1941 ccos_test (void)
1942 {
1943   errno = 0;
1944   FUNC(ccos) (BUILD_COMPLEX (0, 0));
1945   if (errno == ENOSYS)
1946     /* Function not implemented.  */
1947     return;
1948
1949   START (ccos);
1950
1951   TEST_c_c (ccos, 0.0, 0.0, 1.0, minus_zero);
1952   TEST_c_c (ccos, minus_zero, 0.0, 1.0, 0.0);
1953   TEST_c_c (ccos, 0.0, minus_zero, 1.0, 0.0);
1954   TEST_c_c (ccos, minus_zero, minus_zero, 1.0, minus_zero);
1955
1956   TEST_c_c (ccos, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1957   TEST_c_c (ccos, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1958   TEST_c_c (ccos, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1959   TEST_c_c (ccos, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1960
1961   TEST_c_c (ccos, 0.0, plus_infty, plus_infty, minus_zero);
1962   TEST_c_c (ccos, 0.0, minus_infty, plus_infty, 0.0);
1963   TEST_c_c (ccos, minus_zero, plus_infty, plus_infty, 0.0);
1964   TEST_c_c (ccos, minus_zero, minus_infty, plus_infty, minus_zero);
1965
1966   TEST_c_c (ccos, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1967   TEST_c_c (ccos, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1968   TEST_c_c (ccos, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1969   TEST_c_c (ccos, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1970
1971   TEST_c_c (ccos, 4.625, plus_infty, minus_infty, plus_infty);
1972   TEST_c_c (ccos, 4.625, minus_infty, minus_infty, minus_infty);
1973   TEST_c_c (ccos, -4.625, plus_infty, minus_infty, minus_infty);
1974   TEST_c_c (ccos, -4.625, minus_infty, minus_infty, plus_infty);
1975
1976   TEST_c_c (ccos, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1977   TEST_c_c (ccos, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1978   TEST_c_c (ccos, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1979   TEST_c_c (ccos, minus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1980
1981   TEST_c_c (ccos, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1982   TEST_c_c (ccos, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1983
1984   TEST_c_c (ccos, nan_value, plus_infty, plus_infty, nan_value);
1985   TEST_c_c (ccos, nan_value, minus_infty, plus_infty, nan_value);
1986
1987   TEST_c_c (ccos, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1988   TEST_c_c (ccos, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1989
1990   TEST_c_c (ccos, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1991   TEST_c_c (ccos, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1992
1993   TEST_c_c (ccos, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1994   TEST_c_c (ccos, -10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1995
1996   TEST_c_c (ccos, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1997   TEST_c_c (ccos, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1998
1999   TEST_c_c (ccos, nan_value, nan_value, nan_value, nan_value);
2000
2001   TEST_c_c (ccos, 0.75L, 1.25L, 1.38173873063425888530729933139078645L, -1.09193013555397466170919531722024128L);
2002   TEST_c_c (ccos, -2, -3, -4.18962569096880723013255501961597373L, -9.10922789375533659797919726277886212L);
2003
2004   TEST_c_c (ccos, 0.75, 89.5, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
2005   TEST_c_c (ccos, 0.75, -89.5, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
2006   TEST_c_c (ccos, -0.75, 89.5, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
2007   TEST_c_c (ccos, -0.75, -89.5, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
2008
2009 #ifndef TEST_FLOAT
2010   TEST_c_c (ccos, 0.75, 710.5, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
2011   TEST_c_c (ccos, 0.75, -710.5, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
2012   TEST_c_c (ccos, -0.75, 710.5, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
2013   TEST_c_c (ccos, -0.75, -710.5, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
2014 #endif
2015
2016 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2017   TEST_c_c (ccos, 0.75, 11357.25, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
2018   TEST_c_c (ccos, 0.75, -11357.25, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
2019   TEST_c_c (ccos, -0.75, 11357.25, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
2020   TEST_c_c (ccos, -0.75, -11357.25, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
2021 #endif
2022
2023 #ifdef TEST_FLOAT
2024   TEST_c_c (ccos, 0x1p-149, 180, plus_infty, -1.043535896672617552965983803453927655332e33L, OVERFLOW_EXCEPTION);
2025 #endif
2026
2027 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2028   TEST_c_c (ccos, 0x1p-1074, 1440, plus_infty, -5.981479269486130556466515778180916082415e301L, OVERFLOW_EXCEPTION);
2029 #endif
2030
2031 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2032   TEST_c_c (ccos, 0x1p-16434L, 22730, plus_infty, -1.217853148905605987081057582351152052687e4924L, OVERFLOW_EXCEPTION);
2033 #endif
2034
2035   END (ccos, complex);
2036 }
2037
2038
2039 static void
2040 ccosh_test (void)
2041 {
2042   errno = 0;
2043   FUNC(ccosh) (BUILD_COMPLEX (0.7L, 1.2L));
2044   if (errno == ENOSYS)
2045     /* Function not implemented.  */
2046     return;
2047
2048   START (ccosh);
2049
2050   TEST_c_c (ccosh, 0.0, 0.0, 1.0, 0.0);
2051   TEST_c_c (ccosh, minus_zero, 0.0, 1.0, minus_zero);
2052   TEST_c_c (ccosh, 0.0, minus_zero, 1.0, minus_zero);
2053   TEST_c_c (ccosh, minus_zero, minus_zero, 1.0, 0.0);
2054
2055   TEST_c_c (ccosh, 0.0, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2056   TEST_c_c (ccosh, minus_zero, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2057   TEST_c_c (ccosh, 0.0, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2058   TEST_c_c (ccosh, minus_zero, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2059
2060   TEST_c_c (ccosh, plus_infty, 0.0, plus_infty, 0.0);
2061   TEST_c_c (ccosh, minus_infty, 0.0, plus_infty, minus_zero);
2062   TEST_c_c (ccosh, plus_infty, minus_zero, plus_infty, minus_zero);
2063   TEST_c_c (ccosh, minus_infty, minus_zero, plus_infty, 0.0);
2064
2065   TEST_c_c (ccosh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2066   TEST_c_c (ccosh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2067   TEST_c_c (ccosh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2068   TEST_c_c (ccosh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2069
2070   TEST_c_c (ccosh, plus_infty, 4.625, minus_infty, minus_infty);
2071   TEST_c_c (ccosh, minus_infty, 4.625, minus_infty, plus_infty);
2072   TEST_c_c (ccosh, plus_infty, -4.625, minus_infty, plus_infty);
2073   TEST_c_c (ccosh, minus_infty, -4.625, minus_infty, minus_infty);
2074
2075   TEST_c_c (ccosh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2076   TEST_c_c (ccosh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2077   TEST_c_c (ccosh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2078   TEST_c_c (ccosh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2079
2080   TEST_c_c (ccosh, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2081   TEST_c_c (ccosh, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2082
2083   TEST_c_c (ccosh, plus_infty, nan_value, plus_infty, nan_value);
2084   TEST_c_c (ccosh, minus_infty, nan_value, plus_infty, nan_value);
2085
2086   TEST_c_c (ccosh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2087   TEST_c_c (ccosh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2088
2089   TEST_c_c (ccosh, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2090   TEST_c_c (ccosh, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2091
2092   TEST_c_c (ccosh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2093   TEST_c_c (ccosh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2094
2095   TEST_c_c (ccosh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2096   TEST_c_c (ccosh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2097
2098   TEST_c_c (ccosh, nan_value, nan_value, nan_value, nan_value);
2099
2100   TEST_c_c (ccosh, 0.75L, 1.25L, 0.408242591877968807788852146397499084L, 0.780365930845853240391326216300863152L);
2101
2102   TEST_c_c (ccosh, -2, -3, -3.72454550491532256547397070325597253L, 0.511822569987384608834463849801875634L);
2103
2104   TEST_c_c (ccosh, 89.5, 0.75, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
2105   TEST_c_c (ccosh, -89.5, 0.75, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
2106   TEST_c_c (ccosh, 89.5, -0.75, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
2107   TEST_c_c (ccosh, -89.5, -0.75, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
2108
2109 #ifndef TEST_FLOAT
2110   TEST_c_c (ccosh, 710.5, 0.75, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
2111   TEST_c_c (ccosh, -710.5, 0.75, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
2112   TEST_c_c (ccosh, 710.5, -0.75, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
2113   TEST_c_c (ccosh, -710.5, -0.75, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
2114 #endif
2115
2116 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2117   TEST_c_c (ccosh, 11357.25, 0.75, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
2118   TEST_c_c (ccosh, -11357.25, 0.75, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
2119   TEST_c_c (ccosh, 11357.25, -0.75, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
2120   TEST_c_c (ccosh, -11357.25, -0.75, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
2121 #endif
2122
2123 #ifdef TEST_FLOAT
2124   TEST_c_c (ccosh, 180, 0x1p-149, plus_infty, 1.043535896672617552965983803453927655332e33L, OVERFLOW_EXCEPTION);
2125 #endif
2126
2127 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2128   TEST_c_c (ccosh, 1440, 0x1p-1074, plus_infty, 5.981479269486130556466515778180916082415e301L, OVERFLOW_EXCEPTION);
2129 #endif
2130
2131 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2132   TEST_c_c (ccosh, 22730, 0x1p-16434L, plus_infty, 1.217853148905605987081057582351152052687e4924L, OVERFLOW_EXCEPTION);
2133 #endif
2134
2135   END (ccosh, complex);
2136 }
2137
2138
2139 static void
2140 ceil_test (void)
2141 {
2142   START (ceil);
2143
2144   TEST_f_f (ceil, 0.0, 0.0);
2145   TEST_f_f (ceil, minus_zero, minus_zero);
2146   TEST_f_f (ceil, plus_infty, plus_infty);
2147   TEST_f_f (ceil, minus_infty, minus_infty);
2148   TEST_f_f (ceil, nan_value, nan_value);
2149
2150   TEST_f_f (ceil, M_PIl, 4.0);
2151   TEST_f_f (ceil, -M_PIl, -3.0);
2152   TEST_f_f (ceil, 0.1, 1.0);
2153   TEST_f_f (ceil, 0.25, 1.0);
2154   TEST_f_f (ceil, 0.625, 1.0);
2155   TEST_f_f (ceil, -0.1, minus_zero);
2156   TEST_f_f (ceil, -0.25, minus_zero);
2157   TEST_f_f (ceil, -0.625, minus_zero);
2158
2159 #ifdef TEST_LDOUBLE
2160   /* The result can only be represented in long double.  */
2161   TEST_f_f (ceil, 4503599627370495.5L, 4503599627370496.0L);
2162   TEST_f_f (ceil, 4503599627370496.25L, 4503599627370497.0L);
2163   TEST_f_f (ceil, 4503599627370496.5L, 4503599627370497.0L);
2164   TEST_f_f (ceil, 4503599627370496.75L, 4503599627370497.0L);
2165   TEST_f_f (ceil, 4503599627370497.5L, 4503599627370498.0L);
2166
2167   TEST_f_f (ceil, -4503599627370495.5L, -4503599627370495.0L);
2168   TEST_f_f (ceil, -4503599627370496.25L, -4503599627370496.0L);
2169   TEST_f_f (ceil, -4503599627370496.5L, -4503599627370496.0L);
2170   TEST_f_f (ceil, -4503599627370496.75L, -4503599627370496.0L);
2171   TEST_f_f (ceil, -4503599627370497.5L, -4503599627370497.0L);
2172
2173 # if LDBL_MANT_DIG > 100
2174   TEST_f_f (ceil, 4503599627370494.5000000000001L, 4503599627370495.0L);
2175   TEST_f_f (ceil, 4503599627370495.5000000000001L, 4503599627370496.0L);
2176   TEST_f_f (ceil, 4503599627370496.5000000000001L, 4503599627370497.0L);
2177   TEST_f_f (ceil, -4503599627370494.5000000000001L, -4503599627370494.0L);
2178   TEST_f_f (ceil, -4503599627370495.5000000000001L, -4503599627370495.0L);
2179   TEST_f_f (ceil, -4503599627370496.5000000000001L, -4503599627370496.0L);
2180 # endif
2181
2182   TEST_f_f (ceil, 9007199254740991.5L, 9007199254740992.0L);
2183   TEST_f_f (ceil, 9007199254740992.25L, 9007199254740993.0L);
2184   TEST_f_f (ceil, 9007199254740992.5L, 9007199254740993.0L);
2185   TEST_f_f (ceil, 9007199254740992.75L, 9007199254740993.0L);
2186   TEST_f_f (ceil, 9007199254740993.5L, 9007199254740994.0L);
2187
2188   TEST_f_f (ceil, -9007199254740991.5L, -9007199254740991.0L);
2189   TEST_f_f (ceil, -9007199254740992.25L, -9007199254740992.0L);
2190   TEST_f_f (ceil, -9007199254740992.5L, -9007199254740992.0L);
2191   TEST_f_f (ceil, -9007199254740992.75L, -9007199254740992.0L);
2192   TEST_f_f (ceil, -9007199254740993.5L, -9007199254740993.0L);
2193
2194 # if LDBL_MANT_DIG > 100
2195   TEST_f_f (ceil, 9007199254740991.0000000000001L, 9007199254740992.0L);
2196   TEST_f_f (ceil, 9007199254740992.0000000000001L, 9007199254740993.0L);
2197   TEST_f_f (ceil, 9007199254740993.0000000000001L, 9007199254740994.0L);
2198   TEST_f_f (ceil, 9007199254740991.5000000000001L, 9007199254740992.0L);
2199   TEST_f_f (ceil, 9007199254740992.5000000000001L, 9007199254740993.0L);
2200   TEST_f_f (ceil, 9007199254740993.5000000000001L, 9007199254740994.0L);
2201
2202   TEST_f_f (ceil, -9007199254740991.0000000000001L, -9007199254740991.0L);
2203   TEST_f_f (ceil, -9007199254740992.0000000000001L, -9007199254740992.0L);
2204   TEST_f_f (ceil, -9007199254740993.0000000000001L, -9007199254740993.0L);
2205   TEST_f_f (ceil, -9007199254740991.5000000000001L, -9007199254740991.0L);
2206   TEST_f_f (ceil, -9007199254740992.5000000000001L, -9007199254740992.0L);
2207   TEST_f_f (ceil, -9007199254740993.5000000000001L, -9007199254740993.0L);
2208 # endif
2209
2210   TEST_f_f (ceil, 72057594037927935.5L, 72057594037927936.0L);
2211   TEST_f_f (ceil, 72057594037927936.25L, 72057594037927937.0L);
2212   TEST_f_f (ceil, 72057594037927936.5L, 72057594037927937.0L);
2213   TEST_f_f (ceil, 72057594037927936.75L, 72057594037927937.0L);
2214   TEST_f_f (ceil, 72057594037927937.5L, 72057594037927938.0L);
2215
2216   TEST_f_f (ceil, -72057594037927935.5L, -72057594037927935.0L);
2217   TEST_f_f (ceil, -72057594037927936.25L, -72057594037927936.0L);
2218   TEST_f_f (ceil, -72057594037927936.5L, -72057594037927936.0L);
2219   TEST_f_f (ceil, -72057594037927936.75L, -72057594037927936.0L);
2220   TEST_f_f (ceil, -72057594037927937.5L, -72057594037927937.0L);
2221
2222   TEST_f_f (ceil, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
2223   TEST_f_f (ceil, 10141204801825835211973625643008.25L, 10141204801825835211973625643009.0L);
2224   TEST_f_f (ceil, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
2225   TEST_f_f (ceil, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
2226   TEST_f_f (ceil, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
2227 #endif
2228
2229   END (ceil);
2230 }
2231
2232
2233 static void
2234 cexp_test (void)
2235 {
2236   errno = 0;
2237   FUNC(cexp) (BUILD_COMPLEX (0, 0));
2238   if (errno == ENOSYS)
2239     /* Function not implemented.  */
2240     return;
2241
2242   START (cexp);
2243
2244   TEST_c_c (cexp, plus_zero, plus_zero, 1, 0.0);
2245   TEST_c_c (cexp, minus_zero, plus_zero, 1, 0.0);
2246   TEST_c_c (cexp, plus_zero, minus_zero, 1, minus_zero);
2247   TEST_c_c (cexp, minus_zero, minus_zero, 1, minus_zero);
2248
2249   TEST_c_c (cexp, plus_infty, plus_zero, plus_infty, 0.0);
2250   TEST_c_c (cexp, plus_infty, minus_zero, plus_infty, minus_zero);
2251
2252   TEST_c_c (cexp, minus_infty, plus_zero, 0.0, 0.0);
2253   TEST_c_c (cexp, minus_infty, minus_zero, 0.0, minus_zero);
2254
2255   TEST_c_c (cexp, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2256   TEST_c_c (cexp, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2257
2258   TEST_c_c (cexp, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2259   TEST_c_c (cexp, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2260
2261   TEST_c_c (cexp, 100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2262   TEST_c_c (cexp, -100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2263
2264   TEST_c_c (cexp, 100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2265   TEST_c_c (cexp, -100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2266
2267   TEST_c_c (cexp, minus_infty, 2.0, minus_zero, 0.0);
2268   TEST_c_c (cexp, minus_infty, 4.0, minus_zero, minus_zero);
2269   TEST_c_c (cexp, plus_infty, 2.0, minus_infty, plus_infty);
2270   TEST_c_c (cexp, plus_infty, 4.0, minus_infty, minus_infty);
2271
2272   TEST_c_c (cexp, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2273   TEST_c_c (cexp, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2274
2275   TEST_c_c (cexp, minus_infty, plus_infty, 0.0, 0.0, IGNORE_ZERO_INF_SIGN);
2276   TEST_c_c (cexp, minus_infty, minus_infty, 0.0, minus_zero, IGNORE_ZERO_INF_SIGN);
2277
2278   TEST_c_c (cexp, minus_infty, nan_value, 0, 0, IGNORE_ZERO_INF_SIGN);
2279
2280   TEST_c_c (cexp, plus_infty, nan_value, plus_infty, nan_value);
2281
2282   TEST_c_c (cexp, nan_value, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2283   TEST_c_c (cexp, nan_value, 1.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2284
2285   TEST_c_c (cexp, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2286   TEST_c_c (cexp, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2287   TEST_c_c (cexp, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2288   TEST_c_c (cexp, nan_value, nan_value, nan_value, nan_value);
2289
2290   TEST_c_c (cexp, 0.75L, 1.25L, 0.667537446429131586942201977015932112L, 2.00900045494094876258347228145863909L);
2291   TEST_c_c (cexp, -2.0, -3.0, -0.13398091492954261346140525546115575L, -0.019098516261135196432576240858800925L);
2292
2293   TEST_c_c (cexp, 0, 0x1p65, 0.99888622066058013610642172179340364209972L, -0.047183876212354673805106149805700013943218L);
2294   TEST_c_c (cexp, 0, -0x1p65, 0.99888622066058013610642172179340364209972L, 0.047183876212354673805106149805700013943218L);
2295   TEST_c_c (cexp, 50, 0x1p127, 4.053997150228616856622417636046265337193e21L, 3.232070315463388524466674772633810238819e21L);
2296
2297 #ifndef TEST_FLOAT
2298   TEST_c_c (cexp, 0, 1e22, 0.5232147853951389454975944733847094921409L, -0.8522008497671888017727058937530293682618L);
2299   TEST_c_c (cexp, 0, 0x1p1023, -0.826369834614147994500785680811743734805L, 0.5631277798508840134529434079444683477104L);
2300   TEST_c_c (cexp, 500, 0x1p1023, -1.159886268932754433233243794561351783426e217L, 7.904017694554466595359379965081774849708e216L);
2301 #endif
2302
2303 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2304   TEST_c_c (cexp, 0, 0x1p16383L, 0.9210843909921906206874509522505756251609L, 0.3893629985894208126948115852610595405563L);
2305   TEST_c_c (cexp, -10000, 0x1p16383L, 1.045876464564882298442774542991176546722e-4343L, 4.421154026488516836023811173959413420548e-4344L);
2306 #endif
2307
2308   TEST_c_c (cexp, 88.75, 0.75, 2.558360358486542817001900410314204322891e38L, 2.383359453227311447654736314679677655100e38L);
2309   TEST_c_c (cexp, -95, 0.75, 4.039714446238306526889476684000081624047e-42L, 3.763383677300535390271646960780570275931e-42L, UNDERFLOW_EXCEPTION_FLOAT);
2310
2311 #ifndef TEST_FLOAT
2312   TEST_c_c (cexp, 709.8125, 0.75, 1.355121963080879535248452862759108365762e308L, 1.262426823598609432507811340856186873507e308L);
2313   TEST_c_c (cexp, -720, 0.75, 1.486960657116368433685753325516638551722e-313L, 1.385247284245720590980701226843815229385e-313L, UNDERFLOW_EXCEPTION_DOUBLE);
2314 #endif
2315
2316 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2317   TEST_c_c (cexp, 11356.5625, 0.75, 9.052188470850960144814815984311663764287e4931L, 8.432986734191301036267148978260970230200e4931L);
2318   TEST_c_c (cexp, -11370, 0.75, 8.631121063182211587489310508568170739592e-4939L, 8.040721827809267291427062346918413482824e-4939L, UNDERFLOW_EXCEPTION);
2319 #endif
2320
2321 #ifdef TEST_FLOAT
2322   TEST_c_c (cexp, 180, 0x1p-149, plus_infty, 2.087071793345235105931967606907855310664e33L, OVERFLOW_EXCEPTION);
2323 #endif
2324
2325 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2326   TEST_c_c (cexp, 1440, 0x1p-1074, plus_infty, 1.196295853897226111293303155636183216483e302L, OVERFLOW_EXCEPTION);
2327 #endif
2328
2329 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2330   TEST_c_c (cexp, 22730, 0x1p-16434L, plus_infty, 2.435706297811211974162115164702304105374e4924L, OVERFLOW_EXCEPTION);
2331 #endif
2332
2333   TEST_c_c (cexp, 1e6, 0, plus_infty, 0, OVERFLOW_EXCEPTION);
2334   TEST_c_c (cexp, 1e6, min_value, plus_infty, plus_infty, OVERFLOW_EXCEPTION);
2335   TEST_c_c (cexp, 1e6, -min_value, plus_infty, minus_infty, OVERFLOW_EXCEPTION);
2336
2337   END (cexp, complex);
2338 }
2339
2340
2341 static void
2342 cimag_test (void)
2343 {
2344   START (cimag);
2345   TEST_c_f (cimag, 1.0, 0.0, 0.0);
2346   TEST_c_f (cimag, 1.0, minus_zero, minus_zero);
2347   TEST_c_f (cimag, 1.0, nan_value, nan_value);
2348   TEST_c_f (cimag, nan_value, nan_value, nan_value);
2349   TEST_c_f (cimag, 1.0, plus_infty, plus_infty);
2350   TEST_c_f (cimag, 1.0, minus_infty, minus_infty);
2351   TEST_c_f (cimag, 2.0, 3.0, 3.0);
2352
2353   END (cimag);
2354 }
2355
2356 static void
2357 clog_test (void)
2358 {
2359   errno = 0;
2360   FUNC(clog) (BUILD_COMPLEX (-2, -3));
2361   if (errno == ENOSYS)
2362     /* Function not implemented.  */
2363     return;
2364
2365   START (clog);
2366
2367   TEST_c_c (clog, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2368   TEST_c_c (clog, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2369
2370   TEST_c_c (clog, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
2371   TEST_c_c (clog, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
2372
2373   TEST_c_c (clog, minus_infty, plus_infty, plus_infty, M_PI_34l);
2374   TEST_c_c (clog, minus_infty, minus_infty, plus_infty, -M_PI_34l);
2375
2376   TEST_c_c (clog, plus_infty, plus_infty, plus_infty, M_PI_4l);
2377   TEST_c_c (clog, plus_infty, minus_infty, plus_infty, -M_PI_4l);
2378
2379   TEST_c_c (clog, 0, plus_infty, plus_infty, M_PI_2l);
2380   TEST_c_c (clog, 3, plus_infty, plus_infty, M_PI_2l);
2381   TEST_c_c (clog, minus_zero, plus_infty, plus_infty, M_PI_2l);
2382   TEST_c_c (clog, -3, plus_infty, plus_infty, M_PI_2l);
2383   TEST_c_c (clog, 0, minus_infty, plus_infty, -M_PI_2l);
2384   TEST_c_c (clog, 3, minus_infty, plus_infty, -M_PI_2l);
2385   TEST_c_c (clog, minus_zero, minus_infty, plus_infty, -M_PI_2l);
2386   TEST_c_c (clog, -3, minus_infty, plus_infty, -M_PI_2l);
2387
2388   TEST_c_c (clog, minus_infty, 0, plus_infty, M_PIl);
2389   TEST_c_c (clog, minus_infty, 1, plus_infty, M_PIl);
2390   TEST_c_c (clog, minus_infty, minus_zero, plus_infty, -M_PIl);
2391   TEST_c_c (clog, minus_infty, -1, plus_infty, -M_PIl);
2392
2393   TEST_c_c (clog, plus_infty, 0, plus_infty, 0.0);
2394   TEST_c_c (clog, plus_infty, 1, plus_infty, 0.0);
2395   TEST_c_c (clog, plus_infty, minus_zero, plus_infty, minus_zero);
2396   TEST_c_c (clog, plus_infty, -1, plus_infty, minus_zero);
2397
2398   TEST_c_c (clog, plus_infty, nan_value, plus_infty, nan_value);
2399   TEST_c_c (clog, minus_infty, nan_value, plus_infty, nan_value);
2400
2401   TEST_c_c (clog, nan_value, plus_infty, plus_infty, nan_value);
2402   TEST_c_c (clog, nan_value, minus_infty, plus_infty, nan_value);
2403
2404   TEST_c_c (clog, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2405   TEST_c_c (clog, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2406   TEST_c_c (clog, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2407   TEST_c_c (clog, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2408
2409   TEST_c_c (clog, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2410   TEST_c_c (clog, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2411   TEST_c_c (clog, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2412   TEST_c_c (clog, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2413
2414   TEST_c_c (clog, nan_value, nan_value, nan_value, nan_value);
2415
2416   TEST_c_c (clog, 0.75L, 1.25L, 0.376885901188190075998919126749298416L, 1.03037682652431246378774332703115153L);
2417   TEST_c_c (clog, -2, -3, 1.2824746787307683680267437207826593L, -2.1587989303424641704769327722648368L);
2418
2419   TEST_c_c (clog, 0x1.fffffep+127L, 0x1.fffffep+127L, 89.06941264234832570836679262104313101776L, M_PI_4l);
2420   TEST_c_c (clog, 0x1.fffffep+127L, 1.0L, 88.72283905206835305365817656031404273372L, 2.938736052218037251011746307725933020145e-39L, UNDERFLOW_EXCEPTION_FLOAT);
2421   TEST_c_c (clog, 0x1p-149L, 0x1p-149L, -102.9323563131518784484589700365392203592L, M_PI_4l);
2422   TEST_c_c (clog, 0x1p-147L, 0x1p-147L, -101.5460619520319878296245057936228672231L, M_PI_4l);
2423
2424 #ifndef TEST_FLOAT
2425   TEST_c_c (clog, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 710.1292864836639693869320059713862337880L, M_PI_4l);
2426   TEST_c_c (clog, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 709.8942846690411016323109979483151967689L, 0.4636476090008061606231772164674799632783L);
2427   TEST_c_c (clog, 0x1p-1074L, 0x1p-1074L, -744.0934983311012896593986823853525458290L, M_PI_4l);
2428   TEST_c_c (clog, 0x1p-1073L, 0x1p-1073L, -743.4003511505413443499814502638943692610L, M_PI_4l);
2429 #endif
2430
2431 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2432   TEST_c_c (clog, 0x1.fp+16383L, 0x1.fp+16383L, 11356.83823118610934184548269774874545400L, M_PI_4l);
2433   TEST_c_c (clog, 0x1.fp+16383L, 0x1p+16383L, 11356.60974243783798653123798337822335902L, 0.4764674194737066993385333770295162295856L);
2434   TEST_c_c (clog, 0x1p-16440L, 0x1p-16441L, -11395.22807662984378194141292922726786191L, 0.4636476090008061162142562314612144020285L);
2435 #endif
2436
2437   TEST_c_c (clog, 0x1p-149L, 0x1.fp+127L, 88.69109041335841930424871526389807508374L, M_PI_2l);
2438   TEST_c_c (clog, -0x1p-149L, 0x1.fp+127L, 88.69109041335841930424871526389807508374L, M_PI_2l);
2439   TEST_c_c (clog, 0x1p-149L, -0x1.fp+127L, 88.69109041335841930424871526389807508374L, -M_PI_2l);
2440   TEST_c_c (clog, -0x1p-149L, -0x1.fp+127L, 88.69109041335841930424871526389807508374L, -M_PI_2l);
2441   TEST_c_c (clog, -0x1.fp+127L, 0x1p-149L, 88.69109041335841930424871526389807508374L, M_PIl);
2442   TEST_c_c (clog, -0x1.fp+127L, -0x1p-149L, 88.69109041335841930424871526389807508374L, -M_PIl);
2443 #ifdef TEST_FLOAT
2444   TEST_c_c (clog, 0x1.fp+127L, 0x1p-149L, 88.69109041335841930424871526389807508374L, plus_zero, UNDERFLOW_EXCEPTION);
2445   TEST_c_c (clog, 0x1.fp+127L, -0x1p-149L, 88.69109041335841930424871526389807508374L, minus_zero, UNDERFLOW_EXCEPTION);
2446 #endif
2447
2448 #ifndef TEST_FLOAT
2449   TEST_c_c (clog, 0x1p-1074L, 0x1.fp+1023L, 709.7509641950694165420886960904242800794L, M_PI_2l);
2450   TEST_c_c (clog, -0x1p-1074L, 0x1.fp+1023L, 709.7509641950694165420886960904242800794L, M_PI_2l);
2451   TEST_c_c (clog, 0x1p-1074L, -0x1.fp+1023L, 709.7509641950694165420886960904242800794L, -M_PI_2l);
2452   TEST_c_c (clog, -0x1p-1074L, -0x1.fp+1023L, 709.7509641950694165420886960904242800794L, -M_PI_2l);
2453   TEST_c_c (clog, -0x1.fp+1023L, 0x1p-1074L, 709.7509641950694165420886960904242800794L, M_PIl);
2454   TEST_c_c (clog, -0x1.fp+1023L, -0x1p-1074L, 709.7509641950694165420886960904242800794L, -M_PIl);
2455 #endif
2456 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2457   TEST_c_c (clog, 0x1.fp+1023L, 0x1p-1074L, 709.7509641950694165420886960904242800794L, plus_zero, UNDERFLOW_EXCEPTION);
2458   TEST_c_c (clog, 0x1.fp+1023L, -0x1p-1074L, 709.7509641950694165420886960904242800794L, minus_zero, UNDERFLOW_EXCEPTION);
2459 #endif
2460
2461 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2462   TEST_c_c (clog, 0x1p-16445L, 0x1.fp+16383L, 11356.49165759582936919077408168801636572L, M_PI_2l);
2463   TEST_c_c (clog, -0x1p-16445L, 0x1.fp+16383L, 11356.49165759582936919077408168801636572L, M_PI_2l);
2464   TEST_c_c (clog, 0x1p-16445L, -0x1.fp+16383L, 11356.49165759582936919077408168801636572L, -M_PI_2l);
2465   TEST_c_c (clog, -0x1p-16445L, -0x1.fp+16383L, 11356.49165759582936919077408168801636572L, -M_PI_2l);
2466   TEST_c_c (clog, -0x1.fp+16383L, 0x1p-16445L, 11356.49165759582936919077408168801636572L, M_PIl);
2467   TEST_c_c (clog, -0x1.fp+16383L, -0x1p-16445L, 11356.49165759582936919077408168801636572L, -M_PIl);
2468   TEST_c_c (clog, 0x1.fp+16383L, 0x1p-16445L, 11356.49165759582936919077408168801636572L, plus_zero, UNDERFLOW_EXCEPTION);
2469   TEST_c_c (clog, 0x1.fp+16383L, -0x1p-16445L, 11356.49165759582936919077408168801636572L, minus_zero, UNDERFLOW_EXCEPTION);
2470 # if LDBL_MANT_DIG >= 113
2471   TEST_c_c (clog, 0x1p-16494L, 0x1.fp+16383L, 11356.49165759582936919077408168801636572L, M_PI_2l);
2472   TEST_c_c (clog, -0x1p-16494L, 0x1.fp+16383L, 11356.49165759582936919077408168801636572L, M_PI_2l);
2473   TEST_c_c (clog, 0x1p-16494L, -0x1.fp+16383L, 11356.49165759582936919077408168801636572L, -M_PI_2l);
2474   TEST_c_c (clog, -0x1p-16494L, -0x1.fp+16383L, 11356.49165759582936919077408168801636572L, -M_PI_2l);
2475   TEST_c_c (clog, -0x1.fp+16383L, 0x1p-16494L, 11356.49165759582936919077408168801636572L, M_PIl);
2476   TEST_c_c (clog, -0x1.fp+16383L, -0x1p-16494L, 11356.49165759582936919077408168801636572L, -M_PIl);
2477   TEST_c_c (clog, 0x1.fp+16383L, 0x1p-16494L, 11356.49165759582936919077408168801636572L, plus_zero, UNDERFLOW_EXCEPTION);
2478   TEST_c_c (clog, 0x1.fp+16383L, -0x1p-16494L, 11356.49165759582936919077408168801636572L, minus_zero, UNDERFLOW_EXCEPTION);
2479 # endif
2480 #endif
2481
2482   TEST_c_c (clog, 1.0L, 0x1.234566p-10L, 6.172834701221959432440126967147726538097e-7L, 1.111110564353742042376451655136933182201e-3L);
2483   TEST_c_c (clog, -1.0L, 0x1.234566p-20L, 5.886877547844618300918562490463748605537e-13L, 3.141591568520436206990380699322226378452L);
2484   TEST_c_c (clog, 0x1.234566p-30L, 1.0L, 5.614163921211322622623353961365728040115e-19L, 1.570796325735258575254858696548386439740L);
2485   TEST_c_c (clog, -0x1.234566p-40L, -1.0L, 5.354083939753840089583620652120903838944e-25L, -1.570796326795931422008642456283782656359L);
2486   TEST_c_c (clog, 0x1.234566p-50L, 1.0L, 5.106052341226425256332038420428899201070e-31L, 1.570796326794895608681734464330528755366L);
2487   TEST_c_c (clog, 0x1.234566p-60L, 1.0L, 4.869510976053643471080816669875627875933e-37L, 1.570796326794896618244456860363082279319L);
2488   TEST_c_c (clog, 0x1p-62L, 1.0L, 2.350988701644575015937473074444491355582e-38L, 1.570796326794896619014481257142650555297L);
2489   TEST_c_c (clog, 0x1p-63L, 1.0L, 5.877471754111437539843682686111228389059e-39L, 1.570796326794896619122901474391200998698L, UNDERFLOW_EXCEPTION_FLOAT);
2490   TEST_c_c (clog, 0x1p-64L, 1.0L, 1.469367938527859384960920671527807097271e-39L, 1.570796326794896619177111583015476220398L, UNDERFLOW_EXCEPTION_FLOAT);
2491 #ifndef TEST_FLOAT
2492   TEST_c_c (clog, 0x1p-510L, 1.0L, 4.450147717014402766180465434664808128438e-308L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
2493   TEST_c_c (clog, 0x1p-511L, 1.0L, 1.112536929253600691545116358666202032110e-308L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION_DOUBLE);
2494   TEST_c_c (clog, 0x1p-512L, 1.0L, 2.781342323134001728862790896665505080274e-309L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION_DOUBLE);
2495 #endif
2496 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2497   TEST_c_c (clog, 0x1p-8190L, 1.0L, 6.724206286224187012525355634643505205196e-4932L, 1.570796326794896619231321691639751442099L);
2498   TEST_c_c (clog, 0x1p-8191L, 1.0L, 1.681051571556046753131338908660876301299e-4932L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION);
2499   TEST_c_c (clog, 0x1p-8192L, 1.0L, 4.202628928890116882828347271652190753248e-4933L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION);
2500 #endif
2501
2502   TEST_c_c (clog, 0x1.000566p0L, 0x1.234p-10L, 8.298731898331237038231468223024422855654e-5L, 1.110938609507128729312743251313024793990e-3L);
2503   TEST_c_c (clog, 0x1.000566p0L, 0x1.234p-100L, 8.237022655933121125560939513260027133767e-5L, 8.974094312218060110948251664314290484113e-31L);
2504 #ifndef TEST_FLOAT
2505   TEST_c_c (clog, -0x1.0000000123456p0L, 0x1.2345678p-30L, 2.649094282537168795982991778475646793277e-10L, 3.141592652530155111500161671113150737892L);
2506   TEST_c_c (clog, -0x1.0000000123456p0L, 0x1.2345678p-1000L, 2.649094276923003995420209214900915462737e-10L, 3.141592653589793238462643383279502884197L);
2507 #endif
2508 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
2509   TEST_c_c (clog, 0x1.00000000000000123456789abcp0L, 0x1.23456789p-60L, 9.868649107778739757272772275265050767867e-19L, 9.868649106423871142816660980898339912137e-19L);
2510   TEST_c_c (clog, 0x1.00000000000000123456789abcp0L, 0x1.23456789p-1000L, 9.868649107778739752403260515979017248596e-19L, 1.061846605795612822522063052130030717368e-301L);
2511 #endif
2512
2513   TEST_c_c (clog, 0x0.ffffffp0L, 0x0.ffffffp-100L, -5.960464655174753498633255797994360530379e-8L, 7.888609052210118054117285652827862296732e-31L);
2514 #ifndef TEST_FLOAT
2515   TEST_c_c (clog, 0x0.fffffffffffff8p0L, 0x0.fffffffffffff8p-1000L, -1.110223024625156602053389888482372171810e-16L, 9.332636185032188789900895447238171696171e-302L);
2516 #endif
2517 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
2518   TEST_c_c (clog, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp-15000L, -5.421010862427522170184200798202494495630e-20L, 3.548665303440282824232502561095699343814e-4516L);
2519 #endif
2520
2521   TEST_c_c (clog, 0x1a6p-10L, 0x3a5p-10L, -1.4305135209763571252847059962654228661815e-06L, 1.1460277178115757370775644871674016684074L);
2522   TEST_c_c (clog, 0xf2p-10L, 0x3e3p-10L, 6.1988446308070710970664736815277450078106e-06L, 1.3322126499153926210226335249558203898460L);
2523   TEST_c_c (clog, 0x4d4ep-15L, 0x6605p-15L, -1.6298145321400412054744424587143483169412e-08L, 0.9223574537155056772124552172295398141249L);
2524   TEST_c_c (clog, 0x2818p-15L, 0x798fp-15L, 1.5366822245016167178749091974664853785194e-08L, 1.2522014929038946066987318471922169174157L);
2525   TEST_c_c (clog, 0x9b57bp-20L, 0xcb7b4p-20L, -3.9563019528687610863490232935890272740908e-11L, 0.9187593477446338910857133065497364950682L);
2526   TEST_c_c (clog, 0x2731p-20L, 0xfffd0p-20L, 4.4110493034041283943115971658295280288115e-11L, 1.5612279663766352262688735061954290528838L);
2527   TEST_c_c (clog, 0x2ede88p-23L, 0x771c3fp-23L, -4.4764192352906350039050902870893173560494e-13L, 1.1959106857549200806818600493552847793381L);
2528   TEST_c_c (clog, 0x11682p-23L, 0x7ffed1p-23L, 1.1723955140027907954461000991619077811832e-12L, 1.5622968405332756349813737986164832897108L);
2529   TEST_c_c (clog, 0xa1f2c1p-24L, 0xc643aep-24L, -1.0480505352462576151523512837107080269981e-13L, 0.8858771987699967480545613322309315260313L);
2530   TEST_c_c (clog, 0x659feap-24L, 0xeaf6f9p-24L, 3.7303493627403868207597214252239749960738e-14L, 1.1625816408046866464773042283673653469061L);
2531 #ifndef TEST_FLOAT
2532   TEST_c_c (clog, 0x4447d7175p-35L, 0x6c445e00ap-35L, -1.4823076576950255933915367361099865652625e-20L, 1.0081311552703893116404606212158840190615L);
2533   TEST_c_c (clog, 0x2dd46725bp-35L, 0x7783a1284p-35L, 4.4469229730850767799109418892826021157328e-20L, 1.2046235979300843056806465045930070146351L);
2534   TEST_c_c (clog, 0x164c74eea876p-45L, 0x16f393482f77p-45L, -3.0292258760486853327810377824479932031744e-26L, 0.7998237934177411746093524982030330293980L);
2535   TEST_c_c (clog, 0xfe961079616p-45L, 0x1bc37e09e6d1p-45L, 5.3718272201930019901317065495843842735179e-26L, 1.0503831592447830576186444373011142397404L);
2536   TEST_c_c (clog, 0xa4722f19346cp-51L, 0x7f9631c5e7f07p-51L, -6.2122796286154679676173624516405339768606e-30L, 1.4904138780720095276446375492434049214172L);
2537   TEST_c_c (clog, 0x10673dd0f2481p-51L, 0x7ef1d17cefbd2p-51L, 3.2047474274603604594851472963586149973093e-29L, 1.4422922682185099608731642353544207976604L);
2538   TEST_c_c (clog, 0x8ecbf810c4ae6p-52L, 0xd479468b09a37p-52L, -9.7375017988218644730510244778042114638107e-30L, 0.9790637929494922564724108399524154766631L);
2539   TEST_c_c (clog, 0x5b06b680ea2ccp-52L, 0xef452b965da9fp-52L, 8.3076914081087805757422664530653247447136e-30L, 1.2072712126771536614482822173033535043206L);
2540   TEST_c_c (clog, 0x659b70ab7971bp-53L, 0x1f5d111e08abecp-53L, -2.5083311595699359750201056724289010648701e-30L, 1.3710185432462268491534742969536240564640L);
2541   TEST_c_c (clog, 0x15cfbd1990d1ffp-53L, 0x176a3973e09a9ap-53L, 1.0168910106364605304135563536838075568606e-30L, 0.8208373755522359859870890246475340086663L);
2542   TEST_c_c (clog, 0x1367a310575591p-54L, 0x3cfcc0a0541f60p-54L, 5.0844550531823026520677817684239496041087e-32L, 1.2627468605458094918919206628466016525397L);
2543   TEST_c_c (clog, 0x55cb6d0c83af5p-55L, 0x7fe33c0c7c4e90p-55L, -5.2000108498455368032511404449795741611813e-32L, 1.5288921536982513453421343495466824420259L);
2544 #endif
2545 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
2546   TEST_c_c (clog, 0x298c62cb546588a7p-63L, 0x7911b1dfcc4ecdaep-63L, -1.1931267660846218205882675852805793644095e-36L, 1.2402109774337032400594953899784058127412L);
2547   TEST_c_c (clog, 0x4d9c37e2b5cb4533p-63L, 0x65c98be2385a042ep-63L, 6.4064442119814669184296141278612389400075e-37L, 0.9193591364645830864185131402313014890145L);
2548   TEST_c_c (clog, 0x602fd5037c4792efp-64L, 0xed3e2086dcca80b8p-64L, -2.3362950222592964220878638677292132852104e-37L, 1.1856121127236268105413184264288408265852L);
2549   TEST_c_c (clog, 0x6b10b4f3520217b6p-64L, 0xe8893cbb449253a1p-64L, 2.4244570985709679851855191080208817099132e-37L, 1.1393074519572050614551047548718495655972L);
2550   TEST_c_c (clog, 0x81b7efa81fc35ad1p-65L, 0x1ef4b835f1c79d812p-65L, -9.9182335850630508484862145328126979066934e-39L, 1.3146479888794807046338799047003947008804L);
2551 #endif
2552 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
2553   TEST_c_c (clog, 0x3f96469050f650869c2p-75L, 0x6f16b2c9c8b05988335p-75L, -1.0509738482436128031927971874674370984602e-45L, 1.0509191467640012308402149909370784281448L);
2554   TEST_c_c (clog, 0x3157fc1d73233e580c8p-75L, 0x761b52ccd435d7c7f5fp-75L, 1.3487497719126364307640897239165442763573e-43L, 1.1750493008528425228929764149024375035382L);
2555   TEST_c_c (clog, 0x155f8afc4c48685bf63610p-85L, 0x17d0cf2652cdbeb1294e19p-85L, -4.7775669192897997174762089350332738583822e-50L, 0.8393953487996880419413728440067635213372L);
2556   TEST_c_c (clog, 0x13836d58a13448d750b4b9p-85L, 0x195ca7bc3ab4f9161edbe6p-85L, 2.8398125044729578740243199963484494962411e-50L, 0.9149964976334130461795060758257083099706L);
2557   TEST_c_c (clog, 0x1df515eb171a808b9e400266p-95L, 0x7c71eb0cd4688dfe98581c77p-95L, -3.5048022044913950094635368750889659723004e-57L, 1.3345633256521815205858155673950177421079L);
2558   TEST_c_c (clog, 0xe33f66c9542ca25cc43c867p-95L, 0x7f35a68ebd3704a43c465864p-95L, 4.1101771307217268747345114262406964584250e-56L, 1.4596065864518742494094402406719567059585L);
2559   TEST_c_c (clog, 0x6771f22c64ed551b857c128b4cp-105L, 0x1f570e7a13cc3cf2f44fd793ea1p-105L, -1.4281333889622737316199756373421183559948e-62L, 1.3673546561165378090903506783353927980633L);
2560   TEST_c_c (clog, 0x15d8ab6ed05ca514086ac3a1e84p-105L, 0x1761e480aa094c0b10b34b09ce9p-105L, 1.0027319539522347477331743836657426754857e-62L, 0.8193464073721167323313606647411269414759L);
2561   TEST_c_c (clog, 0x187190c1a334497bdbde5a95f48p-106L, 0x3b25f08062d0a095c4cfbbc338dp-106L, -1.7471844652198029695350765775994001163767e-63L, 1.1789110097072986038243729592318526094314L);
2562   TEST_c_c (clog, 0x6241ef0da53f539f02fad67dabp-106L, 0x3fb46641182f7efd9caa769dac0p-106L, 4.3299788920664682288477984749202524623248e-63L, 1.4746938237585656250866370987773473745867L);
2563 #endif
2564 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 113
2565   TEST_c_c (clog, 0x3e1d0a105ac4ebeacd9c6952d34cp-112L, 0xf859b3d1b06d005dcbb5516d5479p-112L, -1.1683999374665377365054966073875064467108e-66L, 1.3257197596350832748781065387304444940172L);
2566   TEST_c_c (clog, 0x47017a2e36807acb1e5214b209dep-112L, 0xf5f4a550c9d75e3bb1839d865f0dp-112L, 1.5077923002544367932999503838191154621839e-65L, 1.2897445708311412721399861948957141824914L);
2567   TEST_c_c (clog, 0x148f818cb7a9258fca942ade2a0cap-113L, 0x18854a34780b8333ec53310ad7001p-113L, -7.1865869169568789348552370692485515571497e-67L, 0.8730167479365994646287897223471819363668L);
2568   TEST_c_c (clog, 0xfd95243681c055c2632286921092p-113L, 0x1bccabcd29ca2152860ec29e34ef7p-113L, 6.6255694866654064502633121109394710807528e-66L, 1.0526409614996288387567810726095850312049L);
2569   TEST_c_c (clog, 0xdb85c467ee2aadd5f425fe0f4b8dp-114L, 0x3e83162a0f95f1dcbf97dddf410eap-114L, 4.6017338806965821566734340588575402712716e-67L, 1.3547418904611758959096647942223384691728L);
2570   TEST_c_c (clog, 0x1415bcaf2105940d49a636e98ae59p-115L, 0x7e6a150adfcd1b0921d44b31f40f4p-115L, 2.5993421227864195179698176012564317527271e-67L, 1.4132318089683022770487383611430906982461L);
2571 #endif
2572
2573   END (clog, complex);
2574 }
2575
2576
2577 static void
2578 clog10_test (void)
2579 {
2580   errno = 0;
2581   FUNC(clog10) (BUILD_COMPLEX (0.7L, 1.2L));
2582   if (errno == ENOSYS)
2583     /* Function not implemented.  */
2584     return;
2585
2586   START (clog10);
2587
2588   TEST_c_c (clog10, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2589   TEST_c_c (clog10, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2590
2591   TEST_c_c (clog10, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
2592   TEST_c_c (clog10, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
2593
2594   TEST_c_c (clog10, minus_infty, plus_infty, plus_infty, M_PI_34_LOG10El);
2595
2596   TEST_c_c (clog10, plus_infty, plus_infty, plus_infty, M_PI4_LOG10El);
2597   TEST_c_c (clog10, plus_infty, minus_infty, plus_infty, -M_PI4_LOG10El);
2598
2599   TEST_c_c (clog10, 0, plus_infty, plus_infty, M_PI2_LOG10El);
2600   TEST_c_c (clog10, 3, plus_infty, plus_infty, M_PI2_LOG10El);
2601   TEST_c_c (clog10, minus_zero, plus_infty, plus_infty, M_PI2_LOG10El);
2602   TEST_c_c (clog10, -3, plus_infty, plus_infty, M_PI2_LOG10El);
2603   TEST_c_c (clog10, 0, minus_infty, plus_infty, -M_PI2_LOG10El);
2604   TEST_c_c (clog10, 3, minus_infty, plus_infty, -M_PI2_LOG10El);
2605   TEST_c_c (clog10, minus_zero, minus_infty, plus_infty, -M_PI2_LOG10El);
2606   TEST_c_c (clog10, -3, minus_infty, plus_infty, -M_PI2_LOG10El);
2607
2608   TEST_c_c (clog10, minus_infty, 0, plus_infty, M_PI_LOG10El);
2609   TEST_c_c (clog10, minus_infty, 1, plus_infty, M_PI_LOG10El);
2610   TEST_c_c (clog10, minus_infty, minus_zero, plus_infty, -M_PI_LOG10El);
2611   TEST_c_c (clog10, minus_infty, -1, plus_infty, -M_PI_LOG10El);
2612
2613   TEST_c_c (clog10, plus_infty, 0, plus_infty, 0.0);
2614   TEST_c_c (clog10, plus_infty, 1, plus_infty, 0.0);
2615   TEST_c_c (clog10, plus_infty, minus_zero, plus_infty, minus_zero);
2616   TEST_c_c (clog10, plus_infty, -1, plus_infty, minus_zero);
2617
2618   TEST_c_c (clog10, plus_infty, nan_value, plus_infty, nan_value);
2619   TEST_c_c (clog10, minus_infty, nan_value, plus_infty, nan_value);
2620
2621   TEST_c_c (clog10, nan_value, plus_infty, plus_infty, nan_value);
2622   TEST_c_c (clog10, nan_value, minus_infty, plus_infty, nan_value);
2623
2624   TEST_c_c (clog10, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2625   TEST_c_c (clog10, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2626   TEST_c_c (clog10, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2627   TEST_c_c (clog10, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2628
2629   TEST_c_c (clog10, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2630   TEST_c_c (clog10, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2631   TEST_c_c (clog10, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2632   TEST_c_c (clog10, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2633
2634   TEST_c_c (clog10, nan_value, nan_value, nan_value, nan_value);
2635
2636   TEST_c_c (clog10, 0.75L, 1.25L, 0.163679467193165171449476605077428975L, 0.447486970040493067069984724340855636L);
2637   TEST_c_c (clog10, -2, -3, 0.556971676153418384603252578971164214L, -0.937554462986374708541507952140189646L);
2638
2639   TEST_c_c (clog10, 0x1.fffffep+127L, 0x1.fffffep+127L, 38.68235441693561449174780668781319348761L, M_PI4_LOG10El);
2640   TEST_c_c (clog10, 0x1.fffffep+127L, 1.0L, 38.53183941910362389414093724045094697423L, 1.276276851248440096917018665609900318458e-39L, UNDERFLOW_EXCEPTION_FLOAT);
2641   TEST_c_c (clog10, 0x1p-149L, 0x1p-149L, -44.70295435610120748924022586658721447508L, M_PI4_LOG10El);
2642   TEST_c_c (clog10, 0x1p-147L, 0x1p-147L, -44.10089436477324509881274807713822842154L, M_PI4_LOG10El);
2643
2644 #ifndef TEST_FLOAT
2645   TEST_c_c (clog10, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 308.4052305577487344482591243175787477115L, M_PI4_LOG10El);
2646   TEST_c_c (clog10, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 308.3031705664207720674749211936626341569L, 0.2013595981366865903254995612594728746470L);
2647   TEST_c_c (clog10, 0x1p-1074L, 0x1p-1074L, -323.1557003452838130619487034867432642357L, M_PI4_LOG10El);
2648   TEST_c_c (clog10, 0x1p-1073L, 0x1p-1073L, -322.8546703496198318667349645920187712089L, M_PI4_LOG10El);
2649 #endif
2650
2651 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2652   TEST_c_c (clog10, 0x1.fp+16383L, 0x1.fp+16383L, 4932.212175672014259683102930239951947672L, M_PI4_LOG10El);
2653   TEST_c_c (clog10, 0x1.fp+16383L, 0x1p+16383L, 4932.112944269463028900262609694408579449L, 0.2069271710841128115912940666587802677383L);
2654   TEST_c_c (clog10, 0x1p-16440L, 0x1p-16441L, -4948.884673709346821106688037612752099609L, 0.2013595981366865710389502301937289472543L);
2655 #endif
2656
2657   TEST_c_c (clog10, 0x1p-149L, 0x1.fp+127L, 38.51805116050395969095658815123105801479L, 0.6821881769209206737428918127156778851051L);
2658   TEST_c_c (clog10, -0x1p-149L, 0x1.fp+127L, 38.51805116050395969095658815123105801479L, 0.6821881769209206737428918127156778851051L);
2659   TEST_c_c (clog10, 0x1p-149L, -0x1.fp+127L, 38.51805116050395969095658815123105801479L, -0.6821881769209206737428918127156778851051L);
2660   TEST_c_c (clog10, -0x1p-149L, -0x1.fp+127L, 38.51805116050395969095658815123105801479L, -0.6821881769209206737428918127156778851051L);
2661   TEST_c_c (clog10, -0x1.fp+127L, 0x1p-149L, 38.51805116050395969095658815123105801479L, 1.364376353841841347485783625431355770210L);
2662   TEST_c_c (clog10, -0x1.fp+127L, -0x1p-149L, 38.51805116050395969095658815123105801479L, -1.364376353841841347485783625431355770210L);
2663 #ifdef TEST_FLOAT
2664   TEST_c_c (clog10, 0x1.fp+127L, 0x1p-149L, 38.51805116050395969095658815123105801479L, plus_zero, UNDERFLOW_EXCEPTION);
2665   TEST_c_c (clog10, 0x1.fp+127L, -0x1p-149L, 38.51805116050395969095658815123105801479L, minus_zero, UNDERFLOW_EXCEPTION);
2666 #endif
2667
2668 #ifndef TEST_FLOAT
2669   TEST_c_c (clog10, 0x1p-1074L, 0x1.fp+1023L, 308.2409272754311106024666378243768099991L, 0.6821881769209206737428918127156778851051L);
2670   TEST_c_c (clog10, -0x1p-1074L, 0x1.fp+1023L, 308.2409272754311106024666378243768099991L, 0.6821881769209206737428918127156778851051L);
2671   TEST_c_c (clog10, 0x1p-1074L, -0x1.fp+1023L, 308.2409272754311106024666378243768099991L, -0.6821881769209206737428918127156778851051L);
2672   TEST_c_c (clog10, -0x1p-1074L, -0x1.fp+1023L, 308.2409272754311106024666378243768099991L, -0.6821881769209206737428918127156778851051L);
2673   TEST_c_c (clog10, -0x1.fp+1023L, 0x1p-1074L, 308.2409272754311106024666378243768099991L, 1.364376353841841347485783625431355770210L);
2674   TEST_c_c (clog10, -0x1.fp+1023L, -0x1p-1074L, 308.2409272754311106024666378243768099991L, -1.364376353841841347485783625431355770210L);
2675 #endif
2676 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2677   TEST_c_c (clog10, 0x1.fp+1023L, 0x1p-1074L, 308.2409272754311106024666378243768099991L, plus_zero, UNDERFLOW_EXCEPTION);
2678   TEST_c_c (clog10, 0x1.fp+1023L, -0x1p-1074L, 308.2409272754311106024666378243768099991L, minus_zero, UNDERFLOW_EXCEPTION);
2679 #endif
2680
2681 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2682   TEST_c_c (clog10, 0x1p-16445L, 0x1.fp+16383L, 4932.061660674182269085496060792589701158L, 0.6821881769209206737428918127156778851051L);
2683   TEST_c_c (clog10, -0x1p-16445L, 0x1.fp+16383L, 4932.061660674182269085496060792589701158L, 0.6821881769209206737428918127156778851051L);
2684   TEST_c_c (clog10, 0x1p-16445L, -0x1.fp+16383L, 4932.061660674182269085496060792589701158L, -0.6821881769209206737428918127156778851051L);
2685   TEST_c_c (clog10, -0x1p-16445L, -0x1.fp+16383L, 4932.061660674182269085496060792589701158L, -0.6821881769209206737428918127156778851051L);
2686   TEST_c_c (clog10, -0x1.fp+16383L, 0x1p-16445L, 4932.061660674182269085496060792589701158L, 1.364376353841841347485783625431355770210L);
2687   TEST_c_c (clog10, -0x1.fp+16383L, -0x1p-16445L, 4932.061660674182269085496060792589701158L, -1.364376353841841347485783625431355770210L);
2688   TEST_c_c (clog10, 0x1.fp+16383L, 0x1p-16445L, 4932.061660674182269085496060792589701158L, plus_zero, UNDERFLOW_EXCEPTION);
2689   TEST_c_c (clog10, 0x1.fp+16383L, -0x1p-16445L, 4932.061660674182269085496060792589701158L, minus_zero, UNDERFLOW_EXCEPTION);
2690 # if LDBL_MANT_DIG >= 113
2691   TEST_c_c (clog10, 0x1p-16494L, 0x1.fp+16383L, 4932.061660674182269085496060792589701158L, 0.6821881769209206737428918127156778851051L);
2692   TEST_c_c (clog10, -0x1p-16494L, 0x1.fp+16383L, 4932.061660674182269085496060792589701158L, 0.6821881769209206737428918127156778851051L);
2693   TEST_c_c (clog10, 0x1p-16494L, -0x1.fp+16383L, 4932.061660674182269085496060792589701158L, -0.6821881769209206737428918127156778851051L);
2694   TEST_c_c (clog10, -0x1p-16494L, -0x1.fp+16383L, 4932.061660674182269085496060792589701158L, -0.6821881769209206737428918127156778851051L);
2695   TEST_c_c (clog10, -0x1.fp+16383L, 0x1p-16494L, 4932.061660674182269085496060792589701158L, 1.364376353841841347485783625431355770210L);
2696   TEST_c_c (clog10, -0x1.fp+16383L, -0x1p-16494L, 4932.061660674182269085496060792589701158L, -1.364376353841841347485783625431355770210L);
2697   TEST_c_c (clog10, 0x1.fp+16383L, 0x1p-16494L, 4932.061660674182269085496060792589701158L, plus_zero, UNDERFLOW_EXCEPTION);
2698   TEST_c_c (clog10, 0x1.fp+16383L, -0x1p-16494L, 4932.061660674182269085496060792589701158L, minus_zero, UNDERFLOW_EXCEPTION);
2699 # endif
2700 #endif
2701
2702   TEST_c_c (clog10, 1.0L, 0x1.234566p-10L, 2.680828048441605163181684680300513080769e-7L, 4.825491868832381486767558728169977751564e-4L);
2703   TEST_c_c (clog10, -1.0L, 0x1.234566p-20L, 2.556638434669064077889576526006849923281e-13L, 1.364375882602207106407956770293808181427L);
2704   TEST_c_c (clog10, 0x1.234566p-30L, 1.0L, 2.438200411482400072282924063740535840474e-19L, 6.821881764607257184291586401763604544928e-1L);
2705   TEST_c_c (clog10, -0x1.234566p-40L, -1.0L, 2.325249110681915353442924915876654139373e-25L, -6.821881769213700828789403802671540158935e-1L);
2706   TEST_c_c (clog10, 0x1.234566p-50L, 1.0L, 2.217530356103816369479108963807448194409e-31L, 6.821881769209202348667823902864283966959e-1L);
2707   TEST_c_c (clog10, 0x1.234566p-60L, 1.0L, 2.114801746467415208319767917450504756866e-37L, 6.821881769209206733143018621078368211515e-1L);
2708   TEST_c_c (clog10, 0x1p-61L, 1.0L, 4.084085680564517578238994467153626207224e-38L, 6.821881769209206735545466044044889962925e-1L);
2709   TEST_c_c (clog10, 0x1p-62L, 1.0L, 1.021021420141129394559748616788406551878e-38L, 6.821881769209206736487192085600834406988e-1L, UNDERFLOW_EXCEPTION_FLOAT);
2710   TEST_c_c (clog10, 0x1p-63L, 1.0L, 2.552553550352823486399371541971016379740e-39L, 6.821881769209206736958055106378806629019e-1L, UNDERFLOW_EXCEPTION_FLOAT);
2711 #ifndef TEST_FLOAT
2712   TEST_c_c (clog10, 0x1p-509L, 1.0L, 7.730698388614835910296270976605350994446e-308L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
2713   TEST_c_c (clog10, 0x1p-510L, 1.0L, 1.932674597153708977574067744151337748612e-308L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION_DOUBLE);
2714   TEST_c_c (clog10, 0x1p-511L, 1.0L, 4.831686492884272443935169360378344371529e-309L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION_DOUBLE);
2715 #endif
2716 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2717   TEST_c_c (clog10, 0x1p-8189L, 1.0L, 1.168114274114528946314738738025008370069e-4931L, 6.821881769209206737428918127156778851051e-1L);
2718   TEST_c_c (clog10, 0x1p-8190L, 1.0L, 2.920285685286322365786846845062520925172e-4932L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION);
2719   TEST_c_c (clog10, 0x1p-8191L, 1.0L, 7.300714213215805914467117112656302312931e-4933L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION);
2720 #endif
2721
2722   TEST_c_c (clog10, 0x1.000566p0L, 0x1.234p-10L, 3.604093470239754109961125085078190708674e-5L, 4.824745078422174667425851670822596859720e-4L);
2723   TEST_c_c (clog10, 0x1.000566p0L, 0x1.234p-100L, 3.577293486783822178310971763308187385546e-5L, 3.897399639875661463735636919790792140598e-31L);
2724 #ifndef TEST_FLOAT
2725   TEST_c_c (clog10, -0x1.0000000123456p0L, 0x1.2345678p-30L, 1.150487028947346337782682105935961875822e-10L, 1.364376353381646356131680448946397884147L);
2726   TEST_c_c (clog10, -0x1.0000000123456p0L, 0x1.2345678p-1000L, 1.150487026509145544402795327729455391948e-10L, 1.364376353841841347485783625431355770210L);
2727 #endif
2728 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
2729   TEST_c_c (clog10, 0x1.00000000000000123456789abcp0L, 0x1.23456789p-60L, 4.285899851347756188767674032946882584784e-19L, 4.285899850759344225805480528847018395861e-19L);
2730   TEST_c_c (clog10, 0x1.00000000000000123456789abcp0L, 0x1.23456789p-1000L, 4.285899851347756186652871946325962330640e-19L, 4.611541215247321502041995872887317363241e-302L);
2731 #endif
2732
2733   TEST_c_c (clog10, 0x0.ffffffp0L, 0x0.ffffffp-100L, -2.588596909321764128428416045209904492216e-8L, 3.425979381266895667295625489912064603415e-31L);
2734 #ifndef TEST_FLOAT
2735   TEST_c_c (clog10, 0x0.fffffffffffff8p0L, 0x0.fffffffffffff8p-1000L, -4.821637332766435821255375046554377090472e-17L, 4.053112396770095089737411317782466262176e-302L);
2736 #endif
2737 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
2738   TEST_c_c (clog10, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp-15000L, -2.354315103889861110220423157644627849164e-20L, 1.541165759405643564697852372112893034397e-4516L);
2739 #endif
2740
2741   TEST_c_c (clog10, 0x1a6p-10L, 0x3a5p-10L, -6.2126412844802358329771948751248003038444e-07L, 0.4977135139537443711784513409096950995985L);
2742   TEST_c_c (clog10, 0xf2p-10L, 0x3e3p-10L, 2.6921240173351112953324592659528481616879e-06L, 0.5785726025799636431142862788413361783862L);
2743   TEST_c_c (clog10, 0x4d4ep-15L, 0x6605p-15L, -7.0781945783414996953799915941870192015212e-09L, 0.4005747524909781155537088181659175147564L);
2744   TEST_c_c (clog10, 0x2818p-15L, 0x798fp-15L, 6.6737261053986614395049481326819059203910e-09L, 0.5438241985991753781478398141908629586460L);
2745   TEST_c_c (clog10, 0x9b57bp-20L, 0xcb7b4p-20L, -1.7182001068739620267773842120965071561416e-11L, 0.3990121149225253562859800593935899629087L);
2746   TEST_c_c (clog10, 0x2731p-20L, 0xfffd0p-20L, 1.9156943718715958194239364991329064049438e-11L, 0.6780326907904082601285090019969008967595L);
2747   TEST_c_c (clog10, 0x2ede88p-23L, 0x771c3fp-23L, -1.9440841725722970687903291200493082253766e-13L, 0.5193774116724956222518530053006822210323L);
2748   TEST_c_c (clog10, 0x11682p-23L, 0x7ffed1p-23L, 5.0916490233953865181284669870035717560498e-13L, 0.6784968969384861816694467029319146542069L);
2749   TEST_c_c (clog10, 0xa1f2c1p-24L, 0xc643aep-24L, -4.5516256421319921959681423447271490869664e-14L, 0.3847315790697197749315054516562206543710L);
2750   TEST_c_c (clog10, 0x659feap-24L, 0xeaf6f9p-24L, 1.6200701438094619117335617123525612051457e-14L, 0.5049027913635038013499728086604870749732L);
2751 #ifndef TEST_FLOAT
2752   TEST_c_c (clog10, 0x4447d7175p-35L, 0x6c445e00ap-35L, -6.4375803621988389731799033530075237868110e-21L, 0.4378257977686804492768642780897650927167L);
2753   TEST_c_c (clog10, 0x2dd46725bp-35L, 0x7783a1284p-35L, 1.9312741086596516918394613098872836703188e-20L, 0.5231613813514771042838490538484014771862L);
2754   TEST_c_c (clog10, 0x164c74eea876p-45L, 0x16f393482f77p-45L, -1.3155760824064879362415202279780039150764e-26L, 0.3473590599762514228227328130640352044313L);
2755   TEST_c_c (clog10, 0xfe961079616p-45L, 0x1bc37e09e6d1p-45L, 2.3329549194675052736016290082882121135546e-26L, 0.4561756099441139182878993697611751382976L);
2756   TEST_c_c (clog10, 0xa4722f19346cp-51L, 0x7f9631c5e7f07p-51L, -2.6979587627476803379953050733225113494503e-30L, 0.6472785229986997177606324374555347813105L);
2757   TEST_c_c (clog10, 0x10673dd0f2481p-51L, 0x7ef1d17cefbd2p-51L, 1.3918041236396763648388478552321724382899e-29L, 0.6263795733790237053262025311642907438291L);
2758   TEST_c_c (clog10, 0x8ecbf810c4ae6p-52L, 0xd479468b09a37p-52L, -4.2289432987513243393180377141513840878196e-30L, 0.4252020027092323591068799049905597805296L);
2759   TEST_c_c (clog10, 0x5b06b680ea2ccp-52L, 0xef452b965da9fp-52L, 3.6079845358966994996207055940336690133424e-30L, 0.5243112258263349992771652393178033846555L);
2760   TEST_c_c (clog10, 0x659b70ab7971bp-53L, 0x1f5d111e08abecp-53L, -1.0893543813872082317104059174982092534059e-30L, 0.5954257879188711495921161433751775633232L);
2761   TEST_c_c (clog10, 0x15cfbd1990d1ffp-53L, 0x176a3973e09a9ap-53L, 4.4163015461643576961232672330852798804976e-31L, 0.3564851427422832755956993418877523303529L);
2762   TEST_c_c (clog10, 0x1367a310575591p-54L, 0x3cfcc0a0541f60p-54L, 2.2081507730821788480616336165447731164865e-32L, 0.5484039935757001196548030312819898864760L);
2763   TEST_c_c (clog10, 0x55cb6d0c83af5p-55L, 0x7fe33c0c7c4e90p-55L, -2.2583360179249556400630343805573865814771e-32L, 0.6639894257763289307423302343317622430835L);
2764 #endif
2765 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
2766   TEST_c_c (clog10, 0x298c62cb546588a7p-63L, 0x7911b1dfcc4ecdaep-63L, -5.1816837072162316773907242302011632570857e-37L, 0.5386167838952956925896424154370364458140L);
2767   TEST_c_c (clog10, 0x4d9c37e2b5cb4533p-63L, 0x65c98be2385a042ep-63L, 2.7822833698845776001753149807484078521508e-37L, 0.3992725998539071066769046272515417679815L);
2768   TEST_c_c (clog10, 0x602fd5037c4792efp-64L, 0xed3e2086dcca80b8p-64L, -1.0146400362652473358437501879334790111898e-37L, 0.5149047982335273098246594109614460842099L);
2769   TEST_c_c (clog10, 0x6b10b4f3520217b6p-64L, 0xe8893cbb449253a1p-64L, 1.0529283395205396881397407610630442563938e-37L, 0.4947949395762683446121140513971996916447L);
2770   TEST_c_c (clog10, 0x81b7efa81fc35ad1p-65L, 0x1ef4b835f1c79d812p-65L, -4.3074341162203896332989394770760901408798e-39L, 0.5709443672155660428417571212549720987784L);
2771 #endif
2772 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
2773   TEST_c_c (clog10, 0x3f96469050f650869c2p-75L, 0x6f16b2c9c8b05988335p-75L, -4.5643214291682663316715446865040356750881e-46L, 0.4564083863660793840592614609053162690362L);
2774   TEST_c_c (clog10, 0x3157fc1d73233e580c8p-75L, 0x761b52ccd435d7c7f5fp-75L, 5.8575458340992751256451490143468457830297e-44L, 0.5103174273246635294300470585396890237265L);
2775   TEST_c_c (clog10, 0x155f8afc4c48685bf63610p-85L, 0x17d0cf2652cdbeb1294e19p-85L, -2.0748709499710785084693619097712106753591e-50L, 0.3645447681189598740620098186365764884771L);
2776   TEST_c_c (clog10, 0x13836d58a13448d750b4b9p-85L, 0x195ca7bc3ab4f9161edbe6p-85L, 1.2333149003324592532859843519619084433953e-50L, 0.3973779298829931059309198145608711073016L);
2777   TEST_c_c (clog10, 0x1df515eb171a808b9e400266p-95L, 0x7c71eb0cd4688dfe98581c77p-95L, -1.5221162575729652613635150540947625639689e-57L, 0.5795934880811949230121092882659698986043L);
2778   TEST_c_c (clog10, 0xe33f66c9542ca25cc43c867p-95L, 0x7f35a68ebd3704a43c465864p-95L, 1.7850272475173865337808494725293124613817e-56L, 0.6338990862456906754888183278564382516852L);
2779   TEST_c_c (clog10, 0x6771f22c64ed551b857c128b4cp-105L, 0x1f570e7a13cc3cf2f44fd793ea1p-105L, -6.2023045024810589256360494043570293518879e-63L, 0.5938345819561308555003145899438513900776L);
2780   TEST_c_c (clog10, 0x15d8ab6ed05ca514086ac3a1e84p-105L, 0x1761e480aa094c0b10b34b09ce9p-105L, 4.3548095442952115860848857519953610343042e-63L, 0.3558376234889641500775150477035448866763L);
2781   TEST_c_c (clog10, 0x187190c1a334497bdbde5a95f48p-106L, 0x3b25f08062d0a095c4cfbbc338dp-106L, -7.5879257211204444302994221436282805900756e-64L, 0.5119945461708707332160859198685423099187L);
2782   TEST_c_c (clog10, 0x6241ef0da53f539f02fad67dabp-106L, 0x3fb46641182f7efd9caa769dac0p-106L, 1.8804859395820231849002915747252695375405e-63L, 0.6404513901551516189871978418046651877394L);
2783 #endif
2784 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 113
2785   TEST_c_c (clog10, 0x3e1d0a105ac4ebeacd9c6952d34cp-112L, 0xf859b3d1b06d005dcbb5516d5479p-112L, -5.0742964549782184008668435276046798273476e-67L, 0.5757527761596220360985719127090110408283L);
2786   TEST_c_c (clog10, 0x47017a2e36807acb1e5214b209dep-112L, 0xf5f4a550c9d75e3bb1839d865f0dp-112L, 6.5482587585671294601662599808612773010057e-66L, 0.5601289501766423782280643144987875760229L);
2787   TEST_c_c (clog10, 0x148f818cb7a9258fca942ade2a0cap-113L, 0x18854a34780b8333ec53310ad7001p-113L, -3.1210950417524756037077807411854181477733e-67L, 0.3791463562379872585396164879981280044658L);
2788   TEST_c_c (clog10, 0xfd95243681c055c2632286921092p-113L, 0x1bccabcd29ca2152860ec29e34ef7p-113L, 2.8774482675253468630312378575186855052697e-66L, 0.4571561610046221605554903008571429975493L);
2789   TEST_c_c (clog10, 0xdb85c467ee2aadd5f425fe0f4b8dp-114L, 0x3e83162a0f95f1dcbf97dddf410eap-114L, 1.9985076315737626043096596036300177494613e-67L, 0.5883569274304683249184005177865521205198L);
2790   TEST_c_c (clog10, 0x1415bcaf2105940d49a636e98ae59p-115L, 0x7e6a150adfcd1b0921d44b31f40f4p-115L, 1.1288799405048268615023706955013387413519e-67L, 0.6137587762850841972073301550420510507903L);
2791 #endif
2792
2793   END (clog10, complex);
2794 }
2795
2796
2797 static void
2798 conj_test (void)
2799 {
2800   START (conj);
2801   TEST_c_c (conj, 0.0, 0.0, 0.0, minus_zero);
2802   TEST_c_c (conj, 0.0, minus_zero, 0.0, 0.0);
2803   TEST_c_c (conj, nan_value, nan_value, nan_value, nan_value);
2804   TEST_c_c (conj, plus_infty, minus_infty, plus_infty, plus_infty);
2805   TEST_c_c (conj, plus_infty, plus_infty, plus_infty, minus_infty);
2806   TEST_c_c (conj, 1.0, 2.0, 1.0, -2.0);
2807   TEST_c_c (conj, 3.0, -4.0, 3.0, 4.0);
2808
2809   END (conj, complex);
2810 }
2811
2812
2813 static void
2814 copysign_test (void)
2815 {
2816   START (copysign);
2817
2818   TEST_ff_f (copysign, 0, 4, 0);
2819   TEST_ff_f (copysign, 0, -4, minus_zero);
2820   TEST_ff_f (copysign, minus_zero, 4, 0);
2821   TEST_ff_f (copysign, minus_zero, -4, minus_zero);
2822
2823   TEST_ff_f (copysign, plus_infty, 0, plus_infty);
2824   TEST_ff_f (copysign, plus_infty, minus_zero, minus_infty);
2825   TEST_ff_f (copysign, minus_infty, 0, plus_infty);
2826   TEST_ff_f (copysign, minus_infty, minus_zero, minus_infty);
2827
2828   TEST_ff_f (copysign, 0, plus_infty, 0);
2829   TEST_ff_f (copysign, 0, minus_zero, minus_zero);
2830   TEST_ff_f (copysign, minus_zero, plus_infty, 0);
2831   TEST_ff_f (copysign, minus_zero, minus_zero, minus_zero);
2832
2833   /* XXX More correctly we would have to check the sign of the NaN.  */
2834   TEST_ff_f (copysign, nan_value, 0, nan_value);
2835   TEST_ff_f (copysign, nan_value, minus_zero, nan_value);
2836   TEST_ff_f (copysign, -nan_value, 0, nan_value);
2837   TEST_ff_f (copysign, -nan_value, minus_zero, nan_value);
2838
2839   END (copysign);
2840 }
2841
2842
2843 static void
2844 cos_test (void)
2845 {
2846   errno = 0;
2847   FUNC(cos) (0);
2848   if (errno == ENOSYS)
2849     /* Function not implemented.  */
2850     return;
2851
2852   START (cos);
2853
2854   TEST_f_f (cos, 0, 1);
2855   TEST_f_f (cos, minus_zero, 1);
2856   errno = 0;
2857   TEST_f_f (cos, plus_infty, nan_value, INVALID_EXCEPTION);
2858   check_int ("errno for cos(+inf) == EDOM", errno, EDOM, 0, 0, 0);
2859   errno = 0;
2860   TEST_f_f (cos, minus_infty, nan_value, INVALID_EXCEPTION);
2861   check_int ("errno for cos(-inf) == EDOM", errno, EDOM, 0, 0, 0);
2862   errno = 0;
2863   TEST_f_f (cos, nan_value, nan_value);
2864   check_int ("errno for cos(NaN) unchanged", errno, 0, 0, 0, 0);
2865
2866   TEST_f_f (cos, M_PI_6l * 2.0, 0.5);
2867   TEST_f_f (cos, M_PI_6l * 4.0, -0.5);
2868   TEST_f_f (cos, M_PI_2l, 0);
2869
2870   TEST_f_f (cos, 0.75L, 0.731688868873820886311838753000084544L);
2871
2872   TEST_f_f (cos, 0x1p65, 0.99888622066058013610642172179340364209972L);
2873   TEST_f_f (cos, -0x1p65, 0.99888622066058013610642172179340364209972L);
2874
2875 #ifdef TEST_DOUBLE
2876   TEST_f_f (cos, 0.80190127184058835, 0.69534156199418473);
2877 #endif
2878
2879   TEST_f_f (cos, 0x1.442f74p+15, 2.4407839902314016628485779006274989801517e-06L);
2880
2881 #ifndef TEST_FLOAT
2882   TEST_f_f (cos, 1e22, 0.5232147853951389454975944733847094921409L);
2883   TEST_f_f (cos, 0x1p1023, -0.826369834614147994500785680811743734805L);
2884 #endif
2885
2886 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2887   TEST_f_f (cos, 0x1p16383L, 0.9210843909921906206874509522505756251609L);
2888 #endif
2889
2890   TEST_f_f (cos, 0x1p+120, -9.25879022854837867303861764107414946730833e-01L);
2891   TEST_f_f (cos, 0x1p+127, 7.81914638714960072263910298466369236613162e-01L);
2892   TEST_f_f (cos, 0x1.fffff8p+127, 9.98819362551949040703862043664101081064641e-01L);
2893   TEST_f_f (cos, 0x1.fffffep+127, 8.53021039830304158051791467692161107353094e-01L);
2894   TEST_f_f (cos, 0x1p+50, 8.68095904660550604334592502063501320395739e-01L);
2895   TEST_f_f (cos, 0x1p+28, -1.65568979490578758865468278195361551113358e-01L);
2896
2897   END (cos);
2898 }
2899
2900
2901 static void
2902 cos_test_tonearest (void)
2903 {
2904   int save_round_mode;
2905   errno = 0;
2906   FUNC(cos) (0);
2907   if (errno == ENOSYS)
2908     /* Function not implemented.  */
2909     return;
2910
2911   START (cos_tonearest);
2912
2913   save_round_mode = fegetround ();
2914
2915   if (!fesetround (FE_TONEAREST))
2916     {
2917       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2918       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2919       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2920       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2921       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2922       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2923       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2924       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2925       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2926       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2927     }
2928
2929   fesetround (save_round_mode);
2930
2931   END (cos_tonearest);
2932 }
2933
2934
2935 static void
2936 cos_test_towardzero (void)
2937 {
2938   int save_round_mode;
2939   errno = 0;
2940   FUNC(cos) (0);
2941   if (errno == ENOSYS)
2942     /* Function not implemented.  */
2943     return;
2944
2945   START (cos_towardzero);
2946
2947   save_round_mode = fegetround ();
2948
2949   if (!fesetround (FE_TOWARDZERO))
2950     {
2951       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2952       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2953       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2954       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2955       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2956       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2957       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2958       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2959       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2960       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2961     }
2962
2963   fesetround (save_round_mode);
2964
2965   END (cos_towardzero);
2966 }
2967
2968
2969 static void
2970 cos_test_downward (void)
2971 {
2972   int save_round_mode;
2973   errno = 0;
2974   FUNC(cos) (0);
2975   if (errno == ENOSYS)
2976     /* Function not implemented.  */
2977     return;
2978
2979   START (cos_downward);
2980
2981   save_round_mode = fegetround ();
2982
2983   if (!fesetround (FE_DOWNWARD))
2984     {
2985       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2986       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2987       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2988       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2989       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2990       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2991       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2992       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2993       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2994       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2995     }
2996
2997   fesetround (save_round_mode);
2998
2999   END (cos_downward);
3000 }
3001
3002
3003 static void
3004 cos_test_upward (void)
3005 {
3006   int save_round_mode;
3007   errno = 0;
3008   FUNC(cos) (0);
3009   if (errno == ENOSYS)
3010     /* Function not implemented.  */
3011     return;
3012
3013   START (cos_upward);
3014
3015   save_round_mode = fegetround ();
3016
3017   if (!fesetround (FE_UPWARD))
3018     {
3019       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
3020       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
3021       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
3022       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
3023       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
3024       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
3025       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
3026       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
3027       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
3028       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
3029     }
3030
3031   fesetround (save_round_mode);
3032
3033   END (cos_upward);
3034 }
3035
3036
3037 static void
3038 cosh_test (void)
3039 {
3040   errno = 0;
3041   FUNC(cosh) (0.7L);
3042   if (errno == ENOSYS)
3043     /* Function not implemented.  */
3044     return;
3045
3046   START (cosh);
3047   TEST_f_f (cosh, 0, 1);
3048   TEST_f_f (cosh, minus_zero, 1);
3049
3050 #ifndef TEST_INLINE
3051   TEST_f_f (cosh, plus_infty, plus_infty);
3052   TEST_f_f (cosh, minus_infty, plus_infty);
3053 #endif
3054   TEST_f_f (cosh, nan_value, nan_value);
3055
3056   TEST_f_f (cosh, 0.75L, 1.29468328467684468784170818539018176L);
3057
3058 #ifndef TEST_FLOAT
3059   TEST_f_f (cosh, 709.8893558127259666434838436543941497802734375L, 9.9999998999995070652573675944761818416035e+307L);
3060   TEST_f_f (cosh, -709.8893558127259666434838436543941497802734375L, 9.9999998999995070652573675944761818416035e+307L);
3061 #endif
3062
3063   END (cosh);
3064 }
3065
3066
3067 static void
3068 cosh_test_tonearest (void)
3069 {
3070   int save_round_mode;
3071   errno = 0;
3072   FUNC(cosh) (0);
3073   if (errno == ENOSYS)
3074     /* Function not implemented.  */
3075     return;
3076
3077   START (cosh_tonearest);
3078
3079   save_round_mode = fegetround ();
3080
3081   if (!fesetround (FE_TONEAREST))
3082     {
3083       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
3084       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
3085       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
3086     }
3087
3088   fesetround (save_round_mode);
3089
3090   END (cosh_tonearest);
3091 }
3092
3093
3094 static void
3095 cosh_test_towardzero (void)
3096 {
3097   int save_round_mode;
3098   errno = 0;
3099   FUNC(cosh) (0);
3100   if (errno == ENOSYS)
3101     /* Function not implemented.  */
3102     return;
3103
3104   START (cosh_towardzero);
3105
3106   save_round_mode = fegetround ();
3107
3108   if (!fesetround (FE_TOWARDZERO))
3109     {
3110       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
3111       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
3112       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
3113     }
3114
3115   fesetround (save_round_mode);
3116
3117   END (cosh_towardzero);
3118 }
3119
3120
3121 static void
3122 cosh_test_downward (void)
3123 {
3124   int save_round_mode;
3125   errno = 0;
3126   FUNC(cosh) (0);
3127   if (errno == ENOSYS)
3128     /* Function not implemented.  */
3129     return;
3130
3131   START (cosh_downward);
3132
3133   save_round_mode = fegetround ();
3134
3135   if (!fesetround (FE_DOWNWARD))
3136     {
3137       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
3138       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
3139       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
3140     }
3141
3142   fesetround (save_round_mode);
3143
3144   END (cosh_downward);
3145 }
3146
3147
3148 static void
3149 cosh_test_upward (void)
3150 {
3151   int save_round_mode;
3152   errno = 0;
3153   FUNC(cosh) (0);
3154   if (errno == ENOSYS)
3155     /* Function not implemented.  */
3156     return;
3157
3158   START (cosh_upward);
3159
3160   save_round_mode = fegetround ();
3161
3162   if (!fesetround (FE_UPWARD))
3163     {
3164       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
3165       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
3166       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
3167     }
3168
3169   fesetround (save_round_mode);
3170
3171   END (cosh_upward);
3172 }
3173
3174
3175 static void
3176 cpow_test (void)
3177 {
3178   errno = 0;
3179   FUNC(cpow) (BUILD_COMPLEX (1, 0), BUILD_COMPLEX (0, 0));
3180   if (errno == ENOSYS)
3181     /* Function not implemented.  */
3182     return;
3183
3184   START (cpow);
3185
3186   TEST_cc_c (cpow, 1, 0, 0, 0, 1.0, 0.0);
3187   TEST_cc_c (cpow, 2, 0, 10, 0, 1024.0, 0.0);
3188
3189   TEST_cc_c (cpow, M_El, 0, 0, 2 * M_PIl, 1.0, 0.0);
3190   TEST_cc_c (cpow, 2, 3, 4, 0, -119.0, -120.0);
3191
3192   TEST_cc_c (cpow, nan_value, nan_value, nan_value, nan_value, nan_value, nan_value);
3193
3194   TEST_cc_c (cpow, 0.75L, 1.25L, 0.75L, 1.25L, 0.117506293914473555420279832210420483L, 0.346552747708338676483025352060418001L);
3195   TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 1.0L, 0.0846958290317209430433805274189191353L, 0.513285749182902449043287190519090481L);
3196   TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 0.0L, 0.75L, 1.25L);
3197   TEST_cc_c (cpow, 0.75L, 1.25L, 0.0L, 1.0L, 0.331825439177608832276067945276730566L, 0.131338600281188544930936345230903032L);
3198
3199   END (cpow, complex);
3200 }
3201
3202
3203 static void
3204 cproj_test (void)
3205 {
3206   START (cproj);
3207   TEST_c_c (cproj, 0.0, 0.0, 0.0, 0.0);
3208   TEST_c_c (cproj, minus_zero, minus_zero, minus_zero, minus_zero);
3209   TEST_c_c (cproj, 0.0, minus_zero, 0.0, minus_zero);
3210   TEST_c_c (cproj, minus_zero, 0.0, minus_zero, 0.0);
3211
3212   TEST_c_c (cproj, nan_value, nan_value, nan_value, nan_value);
3213
3214   TEST_c_c (cproj, plus_infty, plus_infty, plus_infty, 0.0);
3215   TEST_c_c (cproj, plus_infty, minus_infty, plus_infty, minus_zero);
3216   TEST_c_c (cproj, minus_infty, plus_infty, plus_infty, 0.0);
3217   TEST_c_c (cproj, minus_infty, minus_infty, plus_infty, minus_zero);
3218
3219   TEST_c_c (cproj, 1.0, 0.0, 1.0, 0.0);
3220   TEST_c_c (cproj, 2.0, 3.0, 2.0, 3.0);
3221
3222   END (cproj, complex);
3223 }
3224
3225
3226 static void
3227 creal_test (void)
3228 {
3229   START (creal);
3230   TEST_c_f (creal, 0.0, 1.0, 0.0);
3231   TEST_c_f (creal, minus_zero, 1.0, minus_zero);
3232   TEST_c_f (creal, nan_value, 1.0, nan_value);
3233   TEST_c_f (creal, nan_value, nan_value, nan_value);
3234   TEST_c_f (creal, plus_infty, 1.0, plus_infty);
3235   TEST_c_f (creal, minus_infty, 1.0, minus_infty);
3236   TEST_c_f (creal, 2.0, 3.0, 2.0);
3237
3238   END (creal);
3239 }
3240
3241 static void
3242 csin_test (void)
3243 {
3244   errno = 0;
3245   FUNC(csin) (BUILD_COMPLEX (0.7L, 1.2L));
3246   if (errno == ENOSYS)
3247     /* Function not implemented.  */
3248     return;
3249
3250   START (csin);
3251
3252   TEST_c_c (csin, 0.0, 0.0, 0.0, 0.0);
3253   TEST_c_c (csin, minus_zero, 0.0, minus_zero, 0.0);
3254   TEST_c_c (csin, 0.0, minus_zero, 0, minus_zero);
3255   TEST_c_c (csin, minus_zero, minus_zero, minus_zero, minus_zero);
3256
3257   TEST_c_c (csin, 0.0, plus_infty, 0.0, plus_infty);
3258   TEST_c_c (csin, minus_zero, plus_infty, minus_zero, plus_infty);
3259   TEST_c_c (csin, 0.0, minus_infty, 0.0, minus_infty);
3260   TEST_c_c (csin, minus_zero, minus_infty, minus_zero, minus_infty);
3261
3262   TEST_c_c (csin, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3263   TEST_c_c (csin, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3264   TEST_c_c (csin, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3265   TEST_c_c (csin, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3266
3267   TEST_c_c (csin, plus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3268   TEST_c_c (csin, minus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3269   TEST_c_c (csin, plus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3270   TEST_c_c (csin, minus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3271
3272   TEST_c_c (csin, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
3273   TEST_c_c (csin, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
3274   TEST_c_c (csin, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
3275   TEST_c_c (csin, minus_infty, -6.75,  nan_value, nan_value, INVALID_EXCEPTION);
3276
3277   TEST_c_c (csin, 4.625, plus_infty, minus_infty, minus_infty);
3278   TEST_c_c (csin, 4.625, minus_infty, minus_infty, plus_infty);
3279   TEST_c_c (csin, -4.625, plus_infty, plus_infty, minus_infty);
3280   TEST_c_c (csin, -4.625, minus_infty, plus_infty, plus_infty);
3281
3282   TEST_c_c (csin, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
3283   TEST_c_c (csin, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
3284
3285   TEST_c_c (csin, nan_value, plus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
3286   TEST_c_c (csin, nan_value, minus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
3287
3288   TEST_c_c (csin, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3289   TEST_c_c (csin, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3290
3291   TEST_c_c (csin, 0.0, nan_value, 0.0, nan_value);
3292   TEST_c_c (csin, minus_zero, nan_value, minus_zero, nan_value);
3293
3294   TEST_c_c (csin, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3295   TEST_c_c (csin, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3296
3297   TEST_c_c (csin, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3298   TEST_c_c (csin, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3299
3300   TEST_c_c (csin, nan_value, nan_value, nan_value, nan_value);
3301
3302   TEST_c_c (csin, 0.75L, 1.25L, 1.28722291002649188575873510790565441L, 1.17210635989270256101081285116138863L);
3303   TEST_c_c (csin, -2, -3, -9.15449914691142957346729954460983256L, 4.16890695996656435075481305885375484L);
3304
3305   TEST_c_c (csin, 0.75, 89.5, 2.522786001038096774676288412995370563339e38L, 2.708024460708609732016532185663087200560e38L);
3306   TEST_c_c (csin, 0.75, -89.5, 2.522786001038096774676288412995370563339e38L, -2.708024460708609732016532185663087200560e38L);
3307   TEST_c_c (csin, -0.75, 89.5, -2.522786001038096774676288412995370563339e38L, 2.708024460708609732016532185663087200560e38L);
3308   TEST_c_c (csin, -0.75, -89.5, -2.522786001038096774676288412995370563339e38L, -2.708024460708609732016532185663087200560e38L);
3309
3310 #ifndef TEST_FLOAT
3311   TEST_c_c (csin, 0.75, 710.5, 1.255317763348154410745082950806112487736e308L, 1.347490911916428129246890157395342279438e308L);
3312   TEST_c_c (csin, 0.75, -710.5, 1.255317763348154410745082950806112487736e308L, -1.347490911916428129246890157395342279438e308L);
3313   TEST_c_c (csin, -0.75, 710.5, -1.255317763348154410745082950806112487736e308L, 1.347490911916428129246890157395342279438e308L);
3314   TEST_c_c (csin, -0.75, -710.5, -1.255317763348154410745082950806112487736e308L, -1.347490911916428129246890157395342279438e308L);
3315 #endif
3316
3317 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3318   TEST_c_c (csin, 0.75, 11357.25, 8.385498349388321535962327491346664141020e4931L, 9.001213196851067077465606717616495588201e4931L);
3319   TEST_c_c (csin, 0.75, -11357.25, 8.385498349388321535962327491346664141020e4931L, -9.001213196851067077465606717616495588201e4931L);
3320   TEST_c_c (csin, -0.75, 11357.25, -8.385498349388321535962327491346664141020e4931L, 9.001213196851067077465606717616495588201e4931L);
3321   TEST_c_c (csin, -0.75, -11357.25, -8.385498349388321535962327491346664141020e4931L, -9.001213196851067077465606717616495588201e4931L);
3322 #endif
3323
3324 #ifdef TEST_FLOAT
3325   TEST_c_c (csin, 0x1p-149, 180, 1.043535896672617552965983803453927655332e33L, plus_infty, OVERFLOW_EXCEPTION);
3326 #endif
3327
3328 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
3329   TEST_c_c (csin, 0x1p-1074, 1440, 5.981479269486130556466515778180916082415e301L, plus_infty, OVERFLOW_EXCEPTION);
3330 #endif
3331
3332 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3333   TEST_c_c (csin, 0x1p-16434L, 22730, 1.217853148905605987081057582351152052687e4924L, plus_infty, OVERFLOW_EXCEPTION);
3334 #endif
3335
3336   END (csin, complex);
3337 }
3338
3339
3340 static void
3341 csinh_test (void)
3342 {
3343   errno = 0;
3344   FUNC(csinh) (BUILD_COMPLEX (0.7L, 1.2L));
3345   if (errno == ENOSYS)
3346     /* Function not implemented.  */
3347     return;
3348
3349   START (csinh);
3350
3351   TEST_c_c (csinh, 0.0, 0.0, 0.0, 0.0);
3352   TEST_c_c (csinh, minus_zero, 0.0, minus_zero, 0.0);
3353   TEST_c_c (csinh, 0.0, minus_zero, 0.0, minus_zero);
3354   TEST_c_c (csinh, minus_zero, minus_zero, minus_zero, minus_zero);
3355
3356   TEST_c_c (csinh, 0.0, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3357   TEST_c_c (csinh, minus_zero, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3358   TEST_c_c (csinh, 0.0, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3359   TEST_c_c (csinh, minus_zero, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3360
3361   TEST_c_c (csinh, plus_infty, 0.0, plus_infty, 0.0);
3362   TEST_c_c (csinh, minus_infty, 0.0, minus_infty, 0.0);
3363   TEST_c_c (csinh, plus_infty, minus_zero, plus_infty, minus_zero);
3364   TEST_c_c (csinh, minus_infty, minus_zero, minus_infty, minus_zero);
3365
3366   TEST_c_c (csinh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3367   TEST_c_c (csinh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3368   TEST_c_c (csinh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3369   TEST_c_c (csinh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3370
3371   TEST_c_c (csinh, plus_infty, 4.625, minus_infty, minus_infty);
3372   TEST_c_c (csinh, minus_infty, 4.625, plus_infty, minus_infty);
3373   TEST_c_c (csinh, plus_infty, -4.625, minus_infty, plus_infty);
3374   TEST_c_c (csinh, minus_infty, -4.625, plus_infty, plus_infty);
3375
3376   TEST_c_c (csinh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3377   TEST_c_c (csinh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3378   TEST_c_c (csinh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3379   TEST_c_c (csinh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3380
3381   TEST_c_c (csinh, 0.0, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
3382   TEST_c_c (csinh, minus_zero, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
3383
3384   TEST_c_c (csinh, plus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
3385   TEST_c_c (csinh, minus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
3386
3387   TEST_c_c (csinh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3388   TEST_c_c (csinh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3389
3390   TEST_c_c (csinh, nan_value, 0.0, nan_value, 0.0);
3391   TEST_c_c (csinh, nan_value, minus_zero, nan_value, minus_zero);
3392
3393   TEST_c_c (csinh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3394   TEST_c_c (csinh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3395
3396   TEST_c_c (csinh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
3397   TEST_c_c (csinh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
3398
3399   TEST_c_c (csinh, nan_value, nan_value, nan_value, nan_value);
3400
3401   TEST_c_c (csinh, 0.75L, 1.25L, 0.259294854551162779153349830618433028L, 1.22863452409509552219214606515777594L);
3402   TEST_c_c (csinh, -2, -3, 3.59056458998577995201256544779481679L, -0.530921086248519805267040090660676560L);
3403
3404   TEST_c_c (csinh, 89.5, 0.75, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
3405   TEST_c_c (csinh, -89.5, 0.75, -2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
3406   TEST_c_c (csinh, 89.5, -0.75, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
3407   TEST_c_c (csinh, -89.5, -0.75, -2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
3408
3409 #ifndef TEST_FLOAT
3410   TEST_c_c (csinh, 710.5, 0.75, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
3411   TEST_c_c (csinh, -710.5, 0.75, -1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
3412   TEST_c_c (csinh, 710.5, -0.75, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
3413   TEST_c_c (csinh, -710.5, -0.75, -1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
3414 #endif
3415
3416 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3417   TEST_c_c (csinh, 11357.25, 0.75, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
3418   TEST_c_c (csinh, -11357.25, 0.75, -9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
3419   TEST_c_c (csinh, 11357.25, -0.75, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
3420   TEST_c_c (csinh, -11357.25, -0.75, -9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
3421 #endif
3422
3423 #ifdef TEST_FLOAT
3424   TEST_c_c (csinh, 180, 0x1p-149, plus_infty, 1.043535896672617552965983803453927655332e33L, OVERFLOW_EXCEPTION);
3425 #endif
3426
3427 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
3428   TEST_c_c (csinh, 1440, 0x1p-1074, plus_infty, 5.981479269486130556466515778180916082415e301L, OVERFLOW_EXCEPTION);
3429 #endif
3430
3431 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3432   TEST_c_c (csinh, 22730, 0x1p-16434L, plus_infty, 1.217853148905605987081057582351152052687e4924L, OVERFLOW_EXCEPTION);
3433 #endif
3434
3435   END (csinh, complex);
3436 }
3437
3438
3439 static void
3440 csqrt_test (void)
3441 {
3442   errno = 0;
3443   FUNC(csqrt) (BUILD_COMPLEX (-1, 0));
3444   if (errno == ENOSYS)
3445     /* Function not implemented.  */
3446     return;
3447
3448   START (csqrt);
3449
3450   TEST_c_c (csqrt, 0, 0, 0.0, 0.0);
3451   TEST_c_c (csqrt, 0, minus_zero, 0, minus_zero);
3452   TEST_c_c (csqrt, minus_zero, 0, 0.0, 0.0);
3453   TEST_c_c (csqrt, minus_zero, minus_zero, 0.0, minus_zero);
3454
3455   TEST_c_c (csqrt, minus_infty, 0, 0.0, plus_infty);
3456   TEST_c_c (csqrt, minus_infty, 6, 0.0, plus_infty);
3457   TEST_c_c (csqrt, minus_infty, minus_zero, 0.0, minus_infty);
3458   TEST_c_c (csqrt, minus_infty, -6, 0.0, minus_infty);
3459
3460   TEST_c_c (csqrt, plus_infty, 0, plus_infty, 0.0);
3461   TEST_c_c (csqrt, plus_infty, 6, plus_infty, 0.0);
3462   TEST_c_c (csqrt, plus_infty, minus_zero, plus_infty, minus_zero);
3463   TEST_c_c (csqrt, plus_infty, -6, plus_infty, minus_zero);
3464
3465   TEST_c_c (csqrt, 0, plus_infty, plus_infty, plus_infty);
3466   TEST_c_c (csqrt, 4, plus_infty, plus_infty, plus_infty);
3467   TEST_c_c (csqrt, plus_infty, plus_infty, plus_infty, plus_infty);
3468   TEST_c_c (csqrt, minus_zero, plus_infty, plus_infty, plus_infty);
3469   TEST_c_c (csqrt, -4, plus_infty, plus_infty, plus_infty);
3470   TEST_c_c (csqrt, minus_infty, plus_infty, plus_infty, plus_infty);
3471   TEST_c_c (csqrt, 0, minus_infty, plus_infty, minus_infty);
3472   TEST_c_c (csqrt, 4, minus_infty, plus_infty, minus_infty);
3473   TEST_c_c (csqrt, plus_infty, minus_infty, plus_infty, minus_infty);
3474   TEST_c_c (csqrt, minus_zero, minus_infty, plus_infty, minus_infty);
3475   TEST_c_c (csqrt, -4, minus_infty, plus_infty, minus_infty);
3476   TEST_c_c (csqrt, minus_infty, minus_infty, plus_infty, minus_infty);
3477
3478   TEST_c_c (csqrt, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
3479
3480   TEST_c_c (csqrt, plus_infty, nan_value, plus_infty, nan_value);
3481
3482   TEST_c_c (csqrt, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3483   TEST_c_c (csqrt, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3484   TEST_c_c (csqrt, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3485   TEST_c_c (csqrt, -1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3486
3487   TEST_c_c (csqrt, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3488   TEST_c_c (csqrt, nan_value, 8, nan_value, nan_value, INVALID_EXCEPTION_OK);
3489   TEST_c_c (csqrt, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
3490   TEST_c_c (csqrt, nan_value, -8, nan_value, nan_value, INVALID_EXCEPTION_OK);
3491
3492   TEST_c_c (csqrt, nan_value, nan_value, nan_value, nan_value);
3493
3494   TEST_c_c (csqrt, 16.0, -30.0, 5.0, -3.0);
3495   TEST_c_c (csqrt, -1, 0, 0.0, 1.0);
3496   TEST_c_c (csqrt, 0, 2, 1.0, 1.0);
3497   TEST_c_c (csqrt, 119, 120, 12.0, 5.0);
3498   TEST_c_c (csqrt, 0.75L, 1.25L, 1.05065169626078392338656675760808326L, 0.594868882070379067881984030639932657L);
3499   TEST_c_c (csqrt, -2, -3, 0.89597747612983812471573375529004348L, -1.6741492280355400404480393008490519L);
3500   TEST_c_c (csqrt, -2, 3, 0.89597747612983812471573375529004348L, 1.6741492280355400404480393008490519L);
3501   /* Principal square root should be returned (i.e., non-negative real
3502      part).  */
3503   TEST_c_c (csqrt, 0, -1, M_SQRT_2_2, -M_SQRT_2_2);
3504
3505   TEST_c_c (csqrt, 0x1.fffffep+127L, 0x1.fffffep+127L, 2.026714405498316804978751017492482558075e+19L, 8.394925938143272988211878516208015586281e+18L);
3506   TEST_c_c (csqrt, 0x1.fffffep+127L, 1.0L, 1.844674352395372953599975585936590505260e+19L, 2.710505511993121390769065968615872097053e-20L);
3507   TEST_c_c (csqrt, 0x1p-149L, 0x1p-149L, 4.112805464342778798097003462770175200803e-23L, 1.703579802732953750368659735601389709551e-23L);
3508   TEST_c_c (csqrt, 0x1p-147L, 0x1p-147L, 8.225610928685557596194006925540350401606e-23L, 3.407159605465907500737319471202779419102e-23L);
3509
3510   TEST_c_c (csqrt, plus_zero, 0x1p-149L, 2.646977960169688559588507814623881131411e-23L, 2.646977960169688559588507814623881131411e-23L);
3511   TEST_c_c (csqrt, 0x1p-50L, 0x1p-149L, 2.980232238769531250000000000000000000000e-8L, 2.350988701644575015937473074444491355637e-38L);
3512 #ifdef TEST_FLOAT
3513   TEST_c_c (csqrt, 0x1p+127L, 0x1p-149L, 1.304381782533278221234957180625250836888e19L, plus_zero, UNDERFLOW_EXCEPTION);
3514 #endif
3515   TEST_c_c (csqrt, 0x1p-149L, 0x1p+127L, 9.223372036854775808000000000000000000000e18L, 9.223372036854775808000000000000000000000e18L);
3516   TEST_c_c (csqrt, 0x1.000002p-126L, 0x1.000002p-126L, 1.191195773697904627170323731331667740087e-19L, 4.934094449071842328766868579214125217132e-20L);
3517   TEST_c_c (csqrt, -0x1.000002p-126L, -0x1.000002p-126L, 4.934094449071842328766868579214125217132e-20L, -1.191195773697904627170323731331667740087e-19L);
3518
3519 #ifndef TEST_FLOAT
3520   TEST_c_c (csqrt, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 1.473094556905565378990473658199034571917e+154L, 6.101757441282702188537080005372547713595e+153L);
3521   TEST_c_c (csqrt, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 1.379778091031440685006200821918878702861e+154L, 3.257214233483129514781233066898042490248e+153L);
3522   TEST_c_c (csqrt, 0x1p-1074L, 0x1p-1074L, 2.442109726130830256743814843868934877597e-162L, 1.011554969366634726113090867589031782487e-162L);
3523   TEST_c_c (csqrt, 0x1p-1073L, 0x1p-1073L, 3.453664695497464982856905711457966660085e-162L, 1.430554756764195530630723976279903095110e-162L);
3524
3525   TEST_c_c (csqrt, plus_zero, 0x1p-1074L, 1.571727784702628688909515672805082228285e-162L, 1.571727784702628688909515672805082228285e-162L);
3526   TEST_c_c (csqrt, 0x1p-500L, 0x1p-1074L, 5.527147875260444560247265192192255725514e-76L, 4.469444793151709302716387622440056066334e-249L);
3527 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
3528   TEST_c_c (csqrt, 0x1p+1023L, 0x1p-1074L, 9.480751908109176726832526455652159260085e153L, plus_zero, UNDERFLOW_EXCEPTION);
3529 #endif
3530   TEST_c_c (csqrt, 0x1p-1074L, 0x1p+1023L, 6.703903964971298549787012499102923063740e153L, 6.703903964971298549787012499102923063740e153L);
3531   TEST_c_c (csqrt, 0x1.0000000000001p-1022L, 0x1.0000000000001p-1022L, 1.638872094839911521020410942677082920935e-154L, 6.788430486774966350907249113759995429568e-155L);
3532   TEST_c_c (csqrt, -0x1.0000000000001p-1022L, -0x1.0000000000001p-1022L, 6.788430486774966350907249113759995429568e-155L, -1.638872094839911521020410942677082920935e-154L);
3533 #endif
3534
3535 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3536   TEST_c_c (csqrt, 0x1.fp+16383L, 0x1.fp+16383L, 1.179514222452201722651836720466795901016e+2466L, 4.885707879516577666702435054303191575148e+2465L);
3537   TEST_c_c (csqrt, 0x1.fp+16383L, 0x1p+16383L, 1.106698967236475180613254276996359485630e+2466L, 2.687568007603946993388538156299100955642e+2465L);
3538   TEST_c_c (csqrt, 0x1p-16440L, 0x1p-16441L, 3.514690655930285351254618340783294558136e-2475L,  8.297059146828716918029689466551384219370e-2476L);
3539
3540   TEST_c_c (csqrt, plus_zero, 0x1p-16445L, 4.269191686890197837775136325621239761720e-2476L, 4.269191686890197837775136325621239761720e-2476L);
3541   TEST_c_c (csqrt, 0x1p-5000L, 0x1p-16445L, 2.660791472672778409283210520357607795518e-753L, 6.849840675828785164910701384823702064234e-4199L);
3542   TEST_c_c (csqrt, 0x1p+16383L, 0x1p-16445L, 7.712754032630730034273323365543179095045e2465L, plus_zero, UNDERFLOW_EXCEPTION);
3543   TEST_c_c (csqrt, 0x1p-16445L, 0x1p+16383L, 5.453740678097079647314921223668914312241e2465L, 5.453740678097079647314921223668914312241e2465L);
3544   TEST_c_c (csqrt, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-16382L, 2.014551439675644900131815801350165472778e-2466L, 8.344545284118961664300307045791497724440e-2467L);
3545   TEST_c_c (csqrt, -0x1.0000000000000002p-16382L, -0x1.0000000000000002p-16382L, 8.344545284118961664300307045791497724440e-2467L, -2.014551439675644900131815801350165472778e-2466L);
3546
3547 # if LDBL_MANT_DIG >= 113
3548   TEST_c_c (csqrt, plus_zero, 0x1p-16494L, 1.799329752913293143453817328207572571442e-2483L, 1.799329752913293143453817328207572571442e-2483L);
3549   TEST_c_c (csqrt, 0x1p-5000L, 0x1p-16494L, 2.660791472672778409283210520357607795518e-753L, 1.216776133331049643422030716668249905907e-4213L);
3550   TEST_c_c (csqrt, 0x1p+16383L, 0x1p-16494L, 7.712754032630730034273323365543179095045e2465L, plus_zero, UNDERFLOW_EXCEPTION);
3551   TEST_c_c (csqrt, 0x1p-16494L, 0x1p+16383L, 5.453740678097079647314921223668914312241e2465L, 5.453740678097079647314921223668914312241e2465L);
3552   TEST_c_c (csqrt, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-16382L, 2.014551439675644900022606748976158925145e-2466L, 8.344545284118961663847948339519226074126e-2467L);
3553   TEST_c_c (csqrt, -0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-16382L, 8.344545284118961663847948339519226074126e-2467L, -2.014551439675644900022606748976158925145e-2466L);
3554 # endif
3555 #endif
3556
3557   END (csqrt, complex);
3558 }
3559
3560 static void
3561 ctan_test (void)
3562 {
3563   errno = 0;
3564   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3565   if (errno == ENOSYS)
3566     /* Function not implemented.  */
3567     return;
3568
3569   START (ctan);
3570
3571   TEST_c_c (ctan, 0, 0, 0.0, 0.0);
3572   TEST_c_c (ctan, 0, minus_zero, 0.0, minus_zero);
3573   TEST_c_c (ctan, minus_zero, 0, minus_zero, 0.0);
3574   TEST_c_c (ctan, minus_zero, minus_zero, minus_zero, minus_zero);
3575
3576   TEST_c_c (ctan, 0, plus_infty, 0.0, 1.0);
3577   TEST_c_c (ctan, 1, plus_infty, 0.0, 1.0);
3578   TEST_c_c (ctan, minus_zero, plus_infty, minus_zero, 1.0);
3579   TEST_c_c (ctan, -1, plus_infty, minus_zero, 1.0);
3580
3581   TEST_c_c (ctan, 0, minus_infty, 0.0, -1.0);
3582   TEST_c_c (ctan, 1, minus_infty, 0.0, -1.0);
3583   TEST_c_c (ctan, minus_zero, minus_infty, minus_zero, -1.0);
3584   TEST_c_c (ctan, -1, minus_infty, minus_zero, -1.0);
3585
3586   TEST_c_c (ctan, plus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
3587   TEST_c_c (ctan, plus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
3588   TEST_c_c (ctan, minus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
3589   TEST_c_c (ctan, minus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
3590   TEST_c_c (ctan, plus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
3591   TEST_c_c (ctan, plus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
3592   TEST_c_c (ctan, minus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
3593   TEST_c_c (ctan, minus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
3594
3595   TEST_c_c (ctan, nan_value, plus_infty, 0.0, 1.0, IGNORE_ZERO_INF_SIGN);
3596   TEST_c_c (ctan, nan_value, minus_infty, 0.0, -1.0, IGNORE_ZERO_INF_SIGN);
3597
3598   TEST_c_c (ctan, 0, nan_value, 0.0, nan_value);
3599   TEST_c_c (ctan, minus_zero, nan_value, minus_zero, nan_value);
3600
3601   TEST_c_c (ctan, 0.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3602   TEST_c_c (ctan, -4.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3603
3604   TEST_c_c (ctan, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3605   TEST_c_c (ctan, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
3606   TEST_c_c (ctan, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
3607   TEST_c_c (ctan, nan_value, -0.25, nan_value, nan_value, INVALID_EXCEPTION_OK);
3608
3609   TEST_c_c (ctan, nan_value, nan_value, nan_value, nan_value);
3610
3611   TEST_c_c (ctan, 0.75L, 1.25L, 0.160807785916206426725166058173438663L, 0.975363285031235646193581759755216379L);
3612   TEST_c_c (ctan, -2, -3, 0.376402564150424829275122113032269084e-2L, -1.00323862735360980144635859782192726L);
3613
3614   TEST_c_c (ctan, 1, 45, 1.490158918874345552942703234806348520895e-39L, 1.000000000000000000000000000000000000001L, UNDERFLOW_EXCEPTION_FLOAT);
3615   TEST_c_c (ctan, 1, 47, 2.729321264492904590777293425576722354636e-41L, 1.0, UNDERFLOW_EXCEPTION_FLOAT);
3616
3617 #ifndef TEST_FLOAT
3618   TEST_c_c (ctan, 1, 355, 8.140551093483276762350406321792653551513e-309L, 1.0, UNDERFLOW_EXCEPTION_DOUBLE);
3619   TEST_c_c (ctan, 1, 365, 1.677892637497921890115075995898773550884e-317L, 1.0, UNDERFLOW_EXCEPTION_DOUBLE);
3620 #endif
3621
3622 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3623   TEST_c_c (ctan, 1, 5680, 4.725214596136812019616700920476949798307e-4934L, 1.0, UNDERFLOW_EXCEPTION);
3624   TEST_c_c (ctan, 1, 5690, 9.739393181626937151720816611272607059057e-4943L, 1.0, UNDERFLOW_EXCEPTION);
3625 #endif
3626
3627   TEST_c_c (ctan, 0x3.243f6cp-1, 0, -2.287733242885645987394874673945769518150e7L, 0.0);
3628
3629   TEST_c_c (ctan, 0x1p127, 1, 0.2446359391192790896381501310437708987204L, 0.9101334047676183761532873794426475906201L);
3630
3631 #ifndef TEST_FLOAT
3632   TEST_c_c (ctan, 0x1p1023, 1, -0.2254627924997545057926782581695274244229L, 0.8786063118883068695462540226219865087189L);
3633 #endif
3634
3635 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3636   TEST_c_c (ctan, 0x1p16383L, 1, 0.1608598776370396607204448234354670036772L, 0.8133818522051542536316746743877629761488L);
3637 #endif
3638
3639   TEST_c_c (ctan, 50000, 50000, plus_zero, 1.0, UNDERFLOW_EXCEPTION);
3640   TEST_c_c (ctan, 50000, -50000, plus_zero, -1.0, UNDERFLOW_EXCEPTION);
3641   TEST_c_c (ctan, -50000, 50000, minus_zero, 1.0, UNDERFLOW_EXCEPTION);
3642   TEST_c_c (ctan, -50000, -50000, minus_zero, -1.0, UNDERFLOW_EXCEPTION);
3643
3644   END (ctan, complex);
3645 }
3646
3647
3648 static void
3649 ctan_test_tonearest (void)
3650 {
3651   int save_round_mode;
3652   errno = 0;
3653   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3654   if (errno == ENOSYS)
3655     /* Function not implemented.  */
3656     return;
3657
3658   START (ctan_tonearest);
3659
3660   save_round_mode = fegetround ();
3661
3662   if (!fesetround (FE_TONEAREST))
3663     {
3664       TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L);
3665
3666 #ifndef TEST_FLOAT
3667       TEST_c_c (ctan, 0x1.921fb54442d18p+0, 0x1p-1074, 1.633123935319536975596773704152891653086e16L, 1.317719414943508315995636961402669067843e-291L);
3668 #endif
3669
3670 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3671       TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L);
3672 #endif
3673     }
3674
3675   fesetround (save_round_mode);
3676
3677   END (ctan_tonearest, complex);
3678 }
3679
3680
3681 static void
3682 ctan_test_towardzero (void)
3683 {
3684   int save_round_mode;
3685   errno = 0;
3686   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3687   if (errno == ENOSYS)
3688     /* Function not implemented.  */
3689     return;
3690
3691   START (ctan_towardzero);
3692
3693   save_round_mode = fegetround ();
3694
3695   if (!fesetround (FE_TOWARDZERO))
3696     {
3697       TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L);
3698
3699 #ifndef TEST_FLOAT
3700       TEST_c_c (ctan, 0x1.921fb54442d18p+0, 0x1p-1074, 1.633123935319536975596773704152891653086e16L, 1.317719414943508315995636961402669067843e-291L);
3701 #endif
3702
3703 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3704       TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L);
3705 #endif
3706     }
3707
3708   fesetround (save_round_mode);
3709
3710   END (ctan_towardzero, complex);
3711 }
3712
3713
3714 static void
3715 ctan_test_downward (void)
3716 {
3717   int save_round_mode;
3718   errno = 0;
3719   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3720   if (errno == ENOSYS)
3721     /* Function not implemented.  */
3722     return;
3723
3724   START (ctan_downward);
3725
3726   save_round_mode = fegetround ();
3727
3728   if (!fesetround (FE_DOWNWARD))
3729     {
3730       TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L);
3731
3732 #ifndef TEST_FLOAT
3733       TEST_c_c (ctan, 0x1.921fb54442d18p+0, 0x1p-1074, 1.633123935319536975596773704152891653086e16L, 1.317719414943508315995636961402669067843e-291L);
3734 #endif
3735
3736 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3737       TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L);
3738 #endif
3739     }
3740
3741   fesetround (save_round_mode);
3742
3743   END (ctan_downward, complex);
3744 }
3745
3746
3747 static void
3748 ctan_test_upward (void)
3749 {
3750   int save_round_mode;
3751   errno = 0;
3752   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3753   if (errno == ENOSYS)
3754     /* Function not implemented.  */
3755     return;
3756
3757   START (ctan_upward);
3758
3759   save_round_mode = fegetround ();
3760
3761   if (!fesetround (FE_UPWARD))
3762     {
3763       TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L);
3764
3765 #ifndef TEST_FLOAT
3766       TEST_c_c (ctan, 0x1.921fb54442d18p+0, 0x1p-1074, 1.633123935319536975596773704152891653086e16L, 1.317719414943508315995636961402669067843e-291L);
3767 #endif
3768
3769 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3770       TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L);
3771 #endif
3772     }
3773
3774   fesetround (save_round_mode);
3775
3776   END (ctan_upward, complex);
3777 }
3778
3779
3780 static void
3781 ctanh_test (void)
3782 {
3783   errno = 0;
3784   FUNC(ctanh) (BUILD_COMPLEX (0, 0));
3785   if (errno == ENOSYS)
3786     /* Function not implemented.  */
3787     return;
3788
3789   START (ctanh);
3790
3791   TEST_c_c (ctanh, 0, 0, 0.0, 0.0);
3792   TEST_c_c (ctanh, 0, minus_zero, 0.0, minus_zero);
3793   TEST_c_c (ctanh, minus_zero, 0, minus_zero, 0.0);
3794   TEST_c_c (ctanh, minus_zero, minus_zero, minus_zero, minus_zero);
3795
3796   TEST_c_c (ctanh, plus_infty, 0, 1.0, 0.0);
3797   TEST_c_c (ctanh, plus_infty, 1, 1.0, 0.0);
3798   TEST_c_c (ctanh, plus_infty, minus_zero, 1.0, minus_zero);
3799   TEST_c_c (ctanh, plus_infty, -1, 1.0, minus_zero);
3800   TEST_c_c (ctanh, minus_infty, 0, -1.0, 0.0);
3801   TEST_c_c (ctanh, minus_infty, 1, -1.0, 0.0);
3802   TEST_c_c (ctanh, minus_infty, minus_zero, -1.0, minus_zero);
3803   TEST_c_c (ctanh, minus_infty, -1, -1.0, minus_zero);
3804
3805   TEST_c_c (ctanh, 0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3806   TEST_c_c (ctanh, 2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3807   TEST_c_c (ctanh, 0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3808   TEST_c_c (ctanh, 2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3809   TEST_c_c (ctanh, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3810   TEST_c_c (ctanh, -2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3811   TEST_c_c (ctanh, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3812   TEST_c_c (ctanh, -2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3813
3814   TEST_c_c (ctanh, plus_infty, nan_value, 1.0, 0.0, IGNORE_ZERO_INF_SIGN);
3815   TEST_c_c (ctanh, minus_infty, nan_value, -1.0, 0.0, IGNORE_ZERO_INF_SIGN);
3816
3817   TEST_c_c (ctanh, nan_value, 0, nan_value, 0.0);
3818   TEST_c_c (ctanh, nan_value, minus_zero, nan_value, minus_zero);
3819
3820   TEST_c_c (ctanh, nan_value, 0.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
3821   TEST_c_c (ctanh, nan_value, -4.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
3822
3823   TEST_c_c (ctanh, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3824   TEST_c_c (ctanh, 5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3825   TEST_c_c (ctanh, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3826   TEST_c_c (ctanh, -0.25, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3827
3828   TEST_c_c (ctanh, nan_value, nan_value, nan_value, nan_value);
3829
3830   TEST_c_c (ctanh, 0, M_PI_4l, 0.0, 1.0);
3831
3832   TEST_c_c (ctanh, 0.75L, 1.25L, 1.37260757053378320258048606571226857L, 0.385795952609750664177596760720790220L);
3833   TEST_c_c (ctanh, -2, -3, -0.965385879022133124278480269394560686L, 0.988437503832249372031403430350121098e-2L);
3834
3835   TEST_c_c (ctanh, 45, 1, 1.000000000000000000000000000000000000001L, 1.490158918874345552942703234806348520895e-39L, UNDERFLOW_EXCEPTION_FLOAT);
3836   TEST_c_c (ctanh, 47, 1, 1.0, 2.729321264492904590777293425576722354636e-41L, UNDERFLOW_EXCEPTION_FLOAT);
3837
3838 #ifndef TEST_FLOAT
3839   TEST_c_c (ctanh, 355, 1, 1.0, 8.140551093483276762350406321792653551513e-309L, UNDERFLOW_EXCEPTION_DOUBLE);
3840   TEST_c_c (ctanh, 365, 1, 1.0, 1.677892637497921890115075995898773550884e-317L, UNDERFLOW_EXCEPTION_DOUBLE);
3841 #endif
3842
3843 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3844   TEST_c_c (ctanh, 5680, 1, 1.0, 4.725214596136812019616700920476949798307e-4934L, UNDERFLOW_EXCEPTION);
3845   TEST_c_c (ctanh, 5690, 1, 1.0, 9.739393181626937151720816611272607059057e-4943L, UNDERFLOW_EXCEPTION);
3846 #endif
3847
3848   TEST_c_c (ctanh, 0, 0x3.243f6cp-1, 0.0, -2.287733242885645987394874673945769518150e7L);
3849
3850   TEST_c_c (ctanh, 1, 0x1p127, 0.9101334047676183761532873794426475906201L, 0.2446359391192790896381501310437708987204L);
3851
3852 #ifndef TEST_FLOAT
3853   TEST_c_c (ctanh, 1, 0x1p1023, 0.8786063118883068695462540226219865087189L, -0.2254627924997545057926782581695274244229L);
3854 #endif
3855
3856 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3857   TEST_c_c (ctanh, 1, 0x1p16383L, 0.8133818522051542536316746743877629761488L, 0.1608598776370396607204448234354670036772L);
3858 #endif
3859
3860   TEST_c_c (ctanh, 50000, 50000, 1.0, plus_zero, UNDERFLOW_EXCEPTION);
3861   TEST_c_c (ctanh, 50000, -50000, 1.0, minus_zero, UNDERFLOW_EXCEPTION);
3862   TEST_c_c (ctanh, -50000, 50000, -1.0, plus_zero, UNDERFLOW_EXCEPTION);
3863   TEST_c_c (ctanh, -50000, -50000, -1.0, minus_zero, UNDERFLOW_EXCEPTION);
3864
3865   END (ctanh, complex);
3866 }
3867
3868
3869 static void
3870 ctanh_test_tonearest (void)
3871 {
3872   int save_round_mode;
3873   errno = 0;
3874   FUNC(ctanh) (BUILD_COMPLEX (0.7L, 1.2L));
3875   if (errno == ENOSYS)
3876     /* Function not implemented.  */
3877     return;
3878
3879   START (ctanh_tonearest);
3880
3881   save_round_mode = fegetround ();
3882
3883   if (!fesetround (FE_TONEAREST))
3884     {
3885       TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L);
3886
3887 #ifndef TEST_FLOAT
3888       TEST_c_c (ctanh, 0x1p-1074, 0x1.921fb54442d18p+0, 1.317719414943508315995636961402669067843e-291L, 1.633123935319536975596773704152891653086e16L);
3889 #endif
3890
3891 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3892       TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L);
3893 #endif
3894     }
3895
3896   fesetround (save_round_mode);
3897
3898   END (ctanh_tonearest, complex);
3899 }
3900
3901
3902 static void
3903 ctanh_test_towardzero (void)
3904 {
3905   int save_round_mode;
3906   errno = 0;
3907   FUNC(ctanh) (BUILD_COMPLEX (0.7L, 1.2L));
3908   if (errno == ENOSYS)
3909     /* Function not implemented.  */
3910     return;
3911
3912   START (ctanh_towardzero);
3913
3914   save_round_mode = fegetround ();
3915
3916   if (!fesetround (FE_TOWARDZERO))
3917     {
3918       TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L);
3919
3920 #ifndef TEST_FLOAT
3921       TEST_c_c (ctanh, 0x1p-1074, 0x1.921fb54442d18p+0, 1.317719414943508315995636961402669067843e-291L, 1.633123935319536975596773704152891653086e16L);
3922 #endif
3923
3924 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3925       TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L);
3926 #endif
3927     }
3928
3929   fesetround (save_round_mode);
3930
3931   END (ctanh_towardzero, complex);
3932 }
3933
3934
3935 static void
3936 ctanh_test_downward (void)
3937 {
3938   int save_round_mode;
3939   errno = 0;
3940   FUNC(ctanh) (BUILD_COMPLEX (0.7L, 1.2L));
3941   if (errno == ENOSYS)
3942     /* Function not implemented.  */
3943     return;
3944
3945   START (ctanh_downward);
3946
3947   save_round_mode = fegetround ();
3948
3949   if (!fesetround (FE_DOWNWARD))
3950     {
3951       TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L);
3952
3953 #ifndef TEST_FLOAT
3954       TEST_c_c (ctanh, 0x1p-1074, 0x1.921fb54442d18p+0, 1.317719414943508315995636961402669067843e-291L, 1.633123935319536975596773704152891653086e16L);
3955 #endif
3956
3957 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3958       TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L);
3959 #endif
3960     }
3961
3962   fesetround (save_round_mode);
3963
3964   END (ctanh_downward, complex);
3965 }
3966
3967
3968 static void
3969 ctanh_test_upward (void)
3970 {
3971   int save_round_mode;
3972   errno = 0;
3973   FUNC(ctanh) (BUILD_COMPLEX (0.7L, 1.2L));
3974   if (errno == ENOSYS)
3975     /* Function not implemented.  */
3976     return;
3977
3978   START (ctanh_upward);
3979
3980   save_round_mode = fegetround ();
3981
3982   if (!fesetround (FE_UPWARD))
3983     {
3984       TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L);
3985
3986 #ifndef TEST_FLOAT
3987       TEST_c_c (ctanh, 0x1p-1074, 0x1.921fb54442d18p+0, 1.317719414943508315995636961402669067843e-291L, 1.633123935319536975596773704152891653086e16L);
3988 #endif
3989
3990 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3991       TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L);
3992 #endif
3993     }
3994
3995   fesetround (save_round_mode);
3996
3997   END (ctanh_upward, complex);
3998 }
3999
4000
4001 static void
4002 erf_test (void)
4003 {
4004   errno = 0;
4005   FUNC(erf) (0);
4006   if (errno == ENOSYS)
4007     /* Function not implemented.  */
4008     return;
4009
4010   START (erf);
4011
4012   TEST_f_f (erf, 0, 0);
4013   TEST_f_f (erf, minus_zero, minus_zero);
4014   TEST_f_f (erf, plus_infty, 1);
4015   TEST_f_f (erf, minus_infty, -1);
4016   TEST_f_f (erf, nan_value, nan_value);
4017
4018   TEST_f_f (erf, 0.125L, 0.140316204801333817393029446521623398L);
4019   TEST_f_f (erf, 0.75L, 0.711155633653515131598937834591410777L);
4020   TEST_f_f (erf, 1.25L, 0.922900128256458230136523481197281140L);
4021   TEST_f_f (erf, 2.0L, 0.995322265018952734162069256367252929L);
4022   TEST_f_f (erf, 4.125L, 0.999999994576599200434933994687765914L);
4023   TEST_f_f (erf, 27.0L, 1.0L);
4024
4025   END (erf);
4026 }
4027
4028
4029 static void
4030 erfc_test (void)
4031 {
4032   errno = 0;
4033   FUNC(erfc) (0);
4034   if (errno == ENOSYS)
4035     /* Function not implemented.  */
4036     return;
4037
4038   START (erfc);
4039
4040   TEST_f_f (erfc, plus_infty, 0.0);
4041   TEST_f_f (erfc, minus_infty, 2.0);
4042   TEST_f_f (erfc, 0.0, 1.0);
4043   TEST_f_f (erfc, minus_zero, 1.0);
4044   TEST_f_f (erfc, nan_value, nan_value);
4045
4046   TEST_f_f (erfc, 0.125L, 0.859683795198666182606970553478376602L);
4047   TEST_f_f (erfc, 0.75L, 0.288844366346484868401062165408589223L);
4048   TEST_f_f (erfc, 1.25L, 0.0770998717435417698634765188027188596L);
4049   TEST_f_f (erfc, 2.0L, 0.00467773498104726583793074363274707139L);
4050   TEST_f_f (erfc, 0x1.f7303cp+1L, 2.705500297238986897105236321218861842255e-8L);
4051   TEST_f_f (erfc, 4.125L, 0.542340079956506600531223408575531062e-8L);
4052   TEST_f_f (erfc, 0x1.ffa002p+2L, 1.233585992097580296336099501489175967033e-29L);
4053   TEST_f_f (erfc, 0x1.ffffc8p+2L, 1.122671365033056305522366683719541099329e-29L);
4054 #ifdef TEST_LDOUBLE
4055   /* The result can only be represented in long double.  */
4056 # if LDBL_MIN_10_EXP < -319
4057   TEST_f_f (erfc, 27.0L, 0.523704892378925568501606768284954709e-318L);
4058 # endif
4059 # if LDBL_MANT_DIG >= 106
4060   TEST_f_f (erfc, 0x1.ffff56789abcdef0123456789a8p+2L, 1.123161416304655390092138725253789378459e-29L);
4061 # endif
4062 #endif
4063
4064   END (erfc);
4065 }
4066
4067
4068 static void
4069 exp_test (void)
4070 {
4071   errno = 0;
4072   FUNC(exp) (0);
4073   if (errno == ENOSYS)
4074     /* Function not implemented.  */
4075     return;
4076
4077   START (exp);
4078
4079   TEST_f_f (exp, 0, 1);
4080   TEST_f_f (exp, minus_zero, 1);
4081
4082 #ifndef TEST_INLINE
4083   TEST_f_f (exp, plus_infty, plus_infty);
4084   TEST_f_f (exp, minus_infty, 0);
4085 #endif
4086   TEST_f_f (exp, nan_value, nan_value);
4087   TEST_f_f (exp, 1, M_El);
4088
4089   TEST_f_f (exp, 2, M_E2l);
4090   TEST_f_f (exp, 3, M_E3l);
4091   TEST_f_f (exp, 0.75L, 2.11700001661267466854536981983709561L);
4092   TEST_f_f (exp, 50.0L, 5184705528587072464087.45332293348538L);
4093   TEST_f_f (exp, 88.72269439697265625L, 3.40233126623160774937554134772290447915e38L);
4094 #if defined TEST_LDOUBLE && __LDBL_MAX_EXP__ > 1024
4095   /* The result can only be represented in sane long double.  */
4096   TEST_f_f (exp, 1000.0L, 0.197007111401704699388887935224332313e435L);
4097 #endif
4098
4099 #if !(defined TEST_LDOUBLE && LDBL_MAX_EXP > 1024)
4100   TEST_f_f (exp, 710, plus_infty, OVERFLOW_EXCEPTION);
4101   TEST_f_f (exp, -1234, plus_zero, UNDERFLOW_EXCEPTION);
4102 #endif
4103   TEST_f_f (exp, 1e5, plus_infty, OVERFLOW_EXCEPTION);
4104   TEST_f_f (exp, max_value, plus_infty, OVERFLOW_EXCEPTION);
4105   TEST_f_f (exp, -max_value, 0, UNDERFLOW_EXCEPTION);
4106
4107   END (exp);
4108 }
4109
4110
4111 static void
4112 exp_test_tonearest (void)
4113 {
4114   int save_round_mode;
4115   errno = 0;
4116   FUNC(exp) (0);
4117   if (errno == ENOSYS)
4118     /* Function not implemented.  */
4119     return;
4120
4121   START (exp_tonearest);
4122
4123   save_round_mode = fegetround ();
4124
4125   if (!fesetround (FE_TONEAREST))
4126     {
4127       TEST_f_f (exp, 1, M_El);
4128       TEST_f_f (exp, 2, M_E2l);
4129       TEST_f_f (exp, 3, M_E3l);
4130     }
4131
4132   fesetround (save_round_mode);
4133
4134   END (exp_tonearest);
4135 }
4136
4137
4138 static void
4139 exp_test_towardzero (void)
4140 {
4141   int save_round_mode;
4142   errno = 0;
4143   FUNC(exp) (0);
4144   if (errno == ENOSYS)
4145     /* Function not implemented.  */
4146     return;
4147
4148   START (exp_towardzero);
4149
4150   save_round_mode = fegetround ();
4151
4152   if (!fesetround (FE_TOWARDZERO))
4153     {
4154       TEST_f_f (exp, 1, M_El);
4155       TEST_f_f (exp, 2, M_E2l);
4156       TEST_f_f (exp, 3, M_E3l);
4157     }
4158
4159   fesetround (save_round_mode);
4160
4161   END (exp_towardzero);
4162 }
4163
4164
4165 static void
4166 exp_test_downward (void)
4167 {
4168   int save_round_mode;
4169   errno = 0;
4170   FUNC(exp) (0);
4171   if (errno == ENOSYS)
4172     /* Function not implemented.  */
4173     return;
4174
4175   START (exp_downward);
4176
4177   save_round_mode = fegetround ();
4178
4179   if (!fesetround (FE_DOWNWARD))
4180     {
4181       TEST_f_f (exp, 1, M_El);
4182       TEST_f_f (exp, 2, M_E2l);
4183       TEST_f_f (exp, 3, M_E3l);
4184     }
4185
4186   fesetround (save_round_mode);
4187
4188   END (exp_downward);
4189 }
4190
4191
4192 static void
4193 exp_test_upward (void)
4194 {
4195   int save_round_mode;
4196   errno = 0;
4197   FUNC(exp) (0);
4198   if (errno == ENOSYS)
4199     /* Function not implemented.  */
4200     return;
4201
4202   START (exp_upward);
4203
4204   save_round_mode = fegetround ();
4205
4206   if (!fesetround (FE_UPWARD))
4207     {
4208       TEST_f_f (exp, 1, M_El);
4209       TEST_f_f (exp, 2, M_E2l);
4210       TEST_f_f (exp, 3, M_E3l);
4211     }
4212
4213   fesetround (save_round_mode);
4214
4215   END (exp_upward);
4216 }
4217
4218
4219 static void
4220 exp10_test (void)
4221 {
4222   errno = 0;
4223   FUNC(exp10) (0);
4224   if (errno == ENOSYS)
4225     /* Function not implemented.  */
4226     return;
4227
4228   START (exp10);
4229
4230   TEST_f_f (exp10, 0, 1);
4231   TEST_f_f (exp10, minus_zero, 1);
4232
4233   TEST_f_f (exp10, plus_infty, plus_infty);
4234   TEST_f_f (exp10, minus_infty, 0);
4235   TEST_f_f (exp10, nan_value, nan_value);
4236   TEST_f_f (exp10, 3, 1000);
4237   TEST_f_f (exp10, -1, 0.1L);
4238   TEST_f_f (exp10, 36, 1.0e36L);
4239   TEST_f_f (exp10, -36, 1.0e-36L);
4240 #ifndef TEST_FLOAT
4241   TEST_f_f (exp10, 305, 1.0e305L);
4242   TEST_f_f (exp10, -305, 1.0e-305L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
4243 #endif
4244 #if defined TEST_LDOUBLE && LDBL_MAX_10_EXP >= 4932
4245   TEST_f_f (exp10, 4932, 1.0e4932L);
4246   TEST_f_f (exp10, -4932, 1.0e-4932L, UNDERFLOW_EXCEPTION);
4247 #endif
4248   TEST_f_f (exp10, 1e6, plus_infty, OVERFLOW_EXCEPTION);
4249   TEST_f_f (exp10, -1e6, 0, UNDERFLOW_EXCEPTION);
4250   TEST_f_f (exp10, max_value, plus_infty, OVERFLOW_EXCEPTION);
4251   TEST_f_f (exp10, -max_value, 0, UNDERFLOW_EXCEPTION);
4252   TEST_f_f (exp10, 0.75L, 5.62341325190349080394951039776481231L);
4253
4254   END (exp10);
4255 }
4256
4257
4258 static void
4259 exp2_test (void)
4260 {
4261   errno = 0;
4262   FUNC(exp2) (0);
4263   if (errno == ENOSYS)
4264     /* Function not implemented.  */
4265     return;
4266
4267   START (exp2);
4268
4269   TEST_f_f (exp2, 0, 1);
4270   TEST_f_f (exp2, minus_zero, 1);
4271   TEST_f_f (exp2, plus_infty, plus_infty);
4272   TEST_f_f (exp2, minus_infty, 0);
4273   TEST_f_f (exp2, nan_value, nan_value);
4274
4275   TEST_f_f (exp2, 10, 1024);
4276   TEST_f_f (exp2, -1, 0.5);
4277   TEST_f_f (exp2, 1e6, plus_infty, OVERFLOW_EXCEPTION);
4278   TEST_f_f (exp2, -1e6, 0, UNDERFLOW_EXCEPTION);
4279   TEST_f_f (exp2, max_value, plus_infty, OVERFLOW_EXCEPTION);
4280   TEST_f_f (exp2, -max_value, 0, UNDERFLOW_EXCEPTION);
4281   TEST_f_f (exp2, 0.75L, 1.68179283050742908606225095246642979L);
4282
4283   TEST_f_f (exp2, 100.5, 1.792728671193156477399422023278661496394e+30L);
4284   TEST_f_f (exp2, 127, 0x1p127);
4285   TEST_f_f (exp2, -149, 0x1p-149);
4286
4287 #ifndef TEST_FLOAT
4288   TEST_f_f (exp2, 1000.25, 1.274245659452564874772384918171765416737e+301L);
4289   TEST_f_f (exp2, 1023, 0x1p1023);
4290   TEST_f_f (exp2, -1074, 0x1p-1074);
4291 #endif
4292
4293 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
4294   TEST_f_f (exp2, 16383, 0x1p16383L);
4295   TEST_f_f (exp2, -16400, 0x1p-16400L);
4296 #endif
4297
4298   END (exp2);
4299 }
4300
4301
4302 static void
4303 expm1_test (void)
4304 {
4305   errno = 0;
4306   FUNC(expm1) (0);
4307   if (errno == ENOSYS)
4308     /* Function not implemented.  */
4309     return;
4310
4311   START (expm1);
4312
4313   TEST_f_f (expm1, 0, 0);
4314   TEST_f_f (expm1, minus_zero, minus_zero);
4315
4316 #ifndef TEST_INLINE
4317   TEST_f_f (expm1, plus_infty, plus_infty);
4318   TEST_f_f (expm1, minus_infty, -1);
4319 #endif
4320   TEST_f_f (expm1, nan_value, nan_value);
4321
4322   TEST_f_f (expm1, 1, M_El - 1.0);
4323   TEST_f_f (expm1, 0.75L, 1.11700001661267466854536981983709561L);
4324
4325   TEST_f_f (expm1, 50.0L, 5.1847055285870724640864533229334853848275e+21L);
4326
4327 #ifndef TEST_FLOAT
4328   TEST_f_f (expm1, 127.0L, 1.4302079958348104463583671072905261080748e+55L);
4329   TEST_f_f (expm1, 500.0L, 1.4035922178528374107397703328409120821806e+217L);
4330 #endif
4331
4332 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
4333   TEST_f_f (expm1, 11356.25L, 9.05128237311923300051376115753226014206e+4931L);
4334 #endif
4335
4336   TEST_f_f (expm1, -10.0, -0.9999546000702375151484644084844394493898L);
4337   TEST_f_f (expm1, -16.0, -0.9999998874648252807408854862248209398728L);
4338   TEST_f_f (expm1, -17.0, -0.9999999586006228121483334034897228104472L);
4339   TEST_f_f (expm1, -18.0, -0.9999999847700202552873715638633707664826L);
4340   TEST_f_f (expm1, -36.0, -0.9999999999999997680477169756430611687736L);
4341   TEST_f_f (expm1, -37.0, -0.9999999999999999146695237425593420572195L);
4342   TEST_f_f (expm1, -38.0, -0.9999999999999999686086720795197037129104L);
4343   TEST_f_f (expm1, -44.0, -0.9999999999999999999221886775886620348429L);
4344   TEST_f_f (expm1, -45.0, -0.9999999999999999999713748141945060635553L);
4345   TEST_f_f (expm1, -46.0, -0.9999999999999999999894693826424461876212L);
4346   TEST_f_f (expm1, -73.0, -0.9999999999999999999999999999999802074012L);
4347   TEST_f_f (expm1, -74.0, -0.9999999999999999999999999999999927187098L);
4348   TEST_f_f (expm1, -75.0, -0.9999999999999999999999999999999973213630L);
4349   TEST_f_f (expm1, -78.0, -0.9999999999999999999999999999999998666385L);
4350   TEST_f_f (expm1, -79.0, -0.9999999999999999999999999999999999509391L);
4351   TEST_f_f (expm1, -80.0, -0.9999999999999999999999999999999999819515L);
4352   TEST_f_f (expm1, -100.0, -1.0);
4353   TEST_f_f (expm1, -1000.0, -1.0);
4354   TEST_f_f (expm1, -10000.0, -1.0);
4355   TEST_f_f (expm1, -100000.0, -1.0);
4356
4357   errno = 0;
4358   TEST_f_f (expm1, 100000.0, plus_infty, OVERFLOW_EXCEPTION);
4359   check_int ("errno for expm1(large) == ERANGE", errno, ERANGE, 0, 0, 0);
4360   TEST_f_f (expm1, max_value, plus_infty, OVERFLOW_EXCEPTION);
4361   TEST_f_f (expm1, -max_value, -1);
4362
4363   END (expm1);
4364 }
4365
4366
4367 static void
4368 fabs_test (void)
4369 {
4370   START (fabs);
4371
4372   TEST_f_f (fabs, 0, 0);
4373   TEST_f_f (fabs, minus_zero, 0);
4374
4375   TEST_f_f (fabs, plus_infty, plus_infty);
4376   TEST_f_f (fabs, minus_infty, plus_infty);
4377   TEST_f_f (fabs, nan_value, nan_value);
4378
4379   TEST_f_f (fabs, 38.0, 38.0);
4380   TEST_f_f (fabs, -M_El, M_El);
4381
4382   END (fabs);
4383 }
4384
4385
4386 static void
4387 fdim_test (void)
4388 {
4389   START (fdim);
4390
4391   TEST_ff_f (fdim, 0, 0, 0);
4392   TEST_ff_f (fdim, 9, 0, 9);
4393   TEST_ff_f (fdim, 0, 9, 0);
4394   TEST_ff_f (fdim, -9, 0, 0);
4395   TEST_ff_f (fdim, 0, -9, 9);
4396
4397   TEST_ff_f (fdim, plus_infty, 9, plus_infty);
4398   TEST_ff_f (fdim, plus_infty, -9, plus_infty);
4399   TEST_ff_f (fdim, minus_infty, 9, 0);
4400   TEST_ff_f (fdim, minus_infty, -9, 0);
4401   TEST_ff_f (fdim, 9, minus_infty, plus_infty);
4402   TEST_ff_f (fdim, -9, minus_infty, plus_infty);
4403   TEST_ff_f (fdim, 9, plus_infty, 0);
4404   TEST_ff_f (fdim, -9, plus_infty, 0);
4405
4406   TEST_ff_f (fdim, 0, nan_value, nan_value);
4407   TEST_ff_f (fdim, 9, nan_value, nan_value);
4408   TEST_ff_f (fdim, -9, nan_value, nan_value);
4409   TEST_ff_f (fdim, nan_value, 9, nan_value);
4410   TEST_ff_f (fdim, nan_value, -9, nan_value);
4411   TEST_ff_f (fdim, plus_infty, nan_value, nan_value);
4412   TEST_ff_f (fdim, minus_infty, nan_value, nan_value);
4413   TEST_ff_f (fdim, nan_value, plus_infty, nan_value);
4414   TEST_ff_f (fdim, nan_value, minus_infty, nan_value);
4415   TEST_ff_f (fdim, nan_value, nan_value, nan_value);
4416
4417   TEST_ff_f (fdim, plus_infty, plus_infty, 0);
4418
4419   END (fdim);
4420 }
4421
4422
4423 static void
4424 finite_test (void)
4425 {
4426   START (finite);
4427
4428   TEST_f_b (finite, 0, 1);
4429   TEST_f_b (finite, minus_zero, 1);
4430   TEST_f_b (finite, 10, 1);
4431   TEST_f_b (finite, min_subnorm_value, 1);
4432   TEST_f_b (finite, plus_infty, 0);
4433   TEST_f_b (finite, minus_infty, 0);
4434   TEST_f_b (finite, nan_value, 0);
4435
4436   END (finite);
4437 }
4438
4439
4440 static void
4441 floor_test (void)
4442 {
4443   START (floor);
4444
4445   TEST_f_f (floor, 0.0, 0.0);
4446   TEST_f_f (floor, minus_zero, minus_zero);
4447   TEST_f_f (floor, plus_infty, plus_infty);
4448   TEST_f_f (floor, minus_infty, minus_infty);
4449   TEST_f_f (floor, nan_value, nan_value);
4450
4451   TEST_f_f (floor, M_PIl, 3.0);
4452   TEST_f_f (floor, -M_PIl, -4.0);
4453
4454   TEST_f_f (floor, 0.1, 0.0);
4455   TEST_f_f (floor, 0.25, 0.0);
4456   TEST_f_f (floor, 0.625, 0.0);
4457   TEST_f_f (floor, -0.1, -1.0);
4458   TEST_f_f (floor, -0.25, -1.0);
4459   TEST_f_f (floor, -0.625, -1.0);
4460
4461 #ifdef TEST_LDOUBLE
4462   /* The result can only be represented in long double.  */
4463   TEST_f_f (floor, 4503599627370495.5L, 4503599627370495.0L);
4464   TEST_f_f (floor, 4503599627370496.25L, 4503599627370496.0L);
4465   TEST_f_f (floor, 4503599627370496.5L, 4503599627370496.0L);
4466   TEST_f_f (floor, 4503599627370496.75L, 4503599627370496.0L);
4467   TEST_f_f (floor, 4503599627370497.5L, 4503599627370497.0L);
4468 # if LDBL_MANT_DIG > 100
4469   TEST_f_f (floor, 4503599627370494.5000000000001L, 4503599627370494.0L);
4470   TEST_f_f (floor, 4503599627370495.5000000000001L, 4503599627370495.0L);
4471   TEST_f_f (floor, 4503599627370496.5000000000001L, 4503599627370496.0L);
4472 # endif
4473
4474   TEST_f_f (floor, -4503599627370495.5L, -4503599627370496.0L);
4475   TEST_f_f (floor, -4503599627370496.25L, -4503599627370497.0L);
4476   TEST_f_f (floor, -4503599627370496.5L, -4503599627370497.0L);
4477   TEST_f_f (floor, -4503599627370496.75L, -4503599627370497.0L);
4478   TEST_f_f (floor, -4503599627370497.5L, -4503599627370498.0L);
4479 # if LDBL_MANT_DIG > 100
4480   TEST_f_f (floor, -4503599627370494.5000000000001L, -4503599627370495.0L);
4481   TEST_f_f (floor, -4503599627370495.5000000000001L, -4503599627370496.0L);
4482   TEST_f_f (floor, -4503599627370496.5000000000001L, -4503599627370497.0L);
4483 # endif
4484
4485   TEST_f_f (floor, 9007199254740991.5L, 9007199254740991.0L);
4486   TEST_f_f (floor, 9007199254740992.25L, 9007199254740992.0L);
4487   TEST_f_f (floor, 9007199254740992.5L, 9007199254740992.0L);
4488   TEST_f_f (floor, 9007199254740992.75L, 9007199254740992.0L);
4489   TEST_f_f (floor, 9007199254740993.5L, 9007199254740993.0L);
4490
4491 # if LDBL_MANT_DIG > 100
4492   TEST_f_f (floor, 9007199254740991.0000000000001L, 9007199254740991.0L);
4493   TEST_f_f (floor, 9007199254740992.0000000000001L, 9007199254740992.0L);
4494   TEST_f_f (floor, 9007199254740993.0000000000001L, 9007199254740993.0L);
4495   TEST_f_f (floor, 9007199254740991.5000000000001L, 9007199254740991.0L);
4496   TEST_f_f (floor, 9007199254740992.5000000000001L, 9007199254740992.0L);
4497   TEST_f_f (floor, 9007199254740993.5000000000001L, 9007199254740993.0L);
4498 # endif
4499
4500   TEST_f_f (floor, -9007199254740991.5L, -9007199254740992.0L);
4501   TEST_f_f (floor, -9007199254740992.25L, -9007199254740993.0L);
4502   TEST_f_f (floor, -9007199254740992.5L, -9007199254740993.0L);
4503   TEST_f_f (floor, -9007199254740992.75L, -9007199254740993.0L);
4504   TEST_f_f (floor, -9007199254740993.5L, -9007199254740994.0L);
4505
4506 # if LDBL_MANT_DIG > 100
4507   TEST_f_f (floor, -9007199254740991.0000000000001L, -9007199254740992.0L);
4508   TEST_f_f (floor, -9007199254740992.0000000000001L, -9007199254740993.0L);
4509   TEST_f_f (floor, -9007199254740993.0000000000001L, -9007199254740994.0L);
4510   TEST_f_f (floor, -9007199254740991.5000000000001L, -9007199254740992.0L);
4511   TEST_f_f (floor, -9007199254740992.5000000000001L, -9007199254740993.0L);
4512   TEST_f_f (floor, -9007199254740993.5000000000001L, -9007199254740994.0L);
4513 # endif
4514
4515   TEST_f_f (floor, 72057594037927935.5L, 72057594037927935.0L);
4516   TEST_f_f (floor, 72057594037927936.25L, 72057594037927936.0L);
4517   TEST_f_f (floor, 72057594037927936.5L, 72057594037927936.0L);
4518   TEST_f_f (floor, 72057594037927936.75L, 72057594037927936.0L);
4519   TEST_f_f (floor, 72057594037927937.5L, 72057594037927937.0L);
4520
4521   TEST_f_f (floor, -72057594037927935.5L, -72057594037927936.0L);
4522   TEST_f_f (floor, -72057594037927936.25L, -72057594037927937.0L);
4523   TEST_f_f (floor, -72057594037927936.5L, -72057594037927937.0L);
4524   TEST_f_f (floor, -72057594037927936.75L, -72057594037927937.0L);
4525   TEST_f_f (floor, -72057594037927937.5L, -72057594037927938.0L);
4526
4527   TEST_f_f (floor, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
4528   TEST_f_f (floor, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
4529   TEST_f_f (floor, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
4530   TEST_f_f (floor, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
4531   TEST_f_f (floor, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
4532
4533   TEST_f_f (floor, 0xf.ffffffffffffff8p+47L, 0xf.fffffffffffep+47L);
4534   TEST_f_f (floor, -0x8.000000000000004p+48L, -0x8.000000000001p+48L);
4535 #endif
4536
4537   END (floor);
4538 }
4539
4540
4541 static void
4542 fma_test (void)
4543 {
4544   START (fma);
4545
4546   TEST_fff_f (fma, 1.0, 2.0, 3.0, 5.0);
4547   TEST_fff_f (fma, nan_value, 2.0, 3.0, nan_value);
4548   TEST_fff_f (fma, 1.0, nan_value, 3.0, nan_value);
4549   TEST_fff_f (fma, 1.0, 2.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
4550   TEST_fff_f (fma, plus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
4551   TEST_fff_f (fma, minus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
4552   TEST_fff_f (fma, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
4553   TEST_fff_f (fma, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
4554   TEST_fff_f (fma, plus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
4555   TEST_fff_f (fma, minus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
4556   TEST_fff_f (fma, 0.0, plus_infty, 1.0, nan_value, INVALID_EXCEPTION);
4557   TEST_fff_f (fma, 0.0, minus_infty, 1.0, nan_value, INVALID_EXCEPTION);
4558
4559   TEST_fff_f (fma, plus_infty, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
4560   TEST_fff_f (fma, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
4561   TEST_fff_f (fma, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
4562   TEST_fff_f (fma, minus_infty, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
4563   TEST_fff_f (fma, plus_infty, 3.5L, minus_infty, nan_value, INVALID_EXCEPTION);
4564   TEST_fff_f (fma, minus_infty, -7.5L, minus_infty, nan_value, INVALID_EXCEPTION);
4565   TEST_fff_f (fma, -13.5L, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
4566   TEST_fff_f (fma, minus_infty, 7.5L, plus_infty, nan_value, INVALID_EXCEPTION);
4567
4568   TEST_fff_f (fma, 1.25L, 0.75L, 0.0625L, 1.0L);
4569
4570   FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
4571                          LDBL_MAX, DBL_MAX, FLT_MAX);
4572   TEST_fff_f (fma, -fltmax, -fltmax, minus_infty, minus_infty);
4573   TEST_fff_f (fma, fltmax / 2, fltmax / 2, minus_infty, minus_infty);
4574   TEST_fff_f (fma, -fltmax, fltmax, plus_infty, plus_infty);
4575   TEST_fff_f (fma, fltmax / 2, -fltmax / 4, plus_infty, plus_infty);
4576   TEST_fff_f (fma, plus_infty, 4, plus_infty, plus_infty);
4577   TEST_fff_f (fma, 2, minus_infty, minus_infty, minus_infty);
4578   TEST_fff_f (fma, minus_infty, minus_infty, plus_infty, plus_infty);
4579   TEST_fff_f (fma, plus_infty, minus_infty, minus_infty, minus_infty);
4580
4581   TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero);
4582   TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, plus_zero);
4583   TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, plus_zero);
4584   TEST_fff_f (fma, plus_zero, minus_zero, minus_zero, minus_zero);
4585   TEST_fff_f (fma, minus_zero, plus_zero, plus_zero, plus_zero);
4586   TEST_fff_f (fma, minus_zero, plus_zero, minus_zero, minus_zero);
4587   TEST_fff_f (fma, minus_zero, minus_zero, plus_zero, plus_zero);
4588   TEST_fff_f (fma, minus_zero, minus_zero, minus_zero, plus_zero);
4589   TEST_fff_f (fma, 1.0, plus_zero, plus_zero, plus_zero);
4590   TEST_fff_f (fma, 1.0, plus_zero, minus_zero, plus_zero);
4591   TEST_fff_f (fma, 1.0, minus_zero, plus_zero, plus_zero);
4592   TEST_fff_f (fma, 1.0, minus_zero, minus_zero, minus_zero);
4593   TEST_fff_f (fma, -1.0, plus_zero, plus_zero, plus_zero);
4594   TEST_fff_f (fma, -1.0, plus_zero, minus_zero, minus_zero);
4595   TEST_fff_f (fma, -1.0, minus_zero, plus_zero, plus_zero);
4596   TEST_fff_f (fma, -1.0, minus_zero, minus_zero, plus_zero);
4597   TEST_fff_f (fma, plus_zero, 1.0, plus_zero, plus_zero);
4598   TEST_fff_f (fma, plus_zero, 1.0, minus_zero, plus_zero);
4599   TEST_fff_f (fma, plus_zero, -1.0, plus_zero, plus_zero);
4600   TEST_fff_f (fma, plus_zero, -1.0, minus_zero, minus_zero);
4601   TEST_fff_f (fma, minus_zero, 1.0, plus_zero, plus_zero);
4602   TEST_fff_f (fma, minus_zero, 1.0, minus_zero, minus_zero);
4603   TEST_fff_f (fma, minus_zero, -1.0, plus_zero, plus_zero);
4604   TEST_fff_f (fma, minus_zero, -1.0, minus_zero, plus_zero);
4605
4606   TEST_fff_f (fma, 1.0, 1.0, -1.0, plus_zero);
4607   TEST_fff_f (fma, 1.0, -1.0, 1.0, plus_zero);
4608   TEST_fff_f (fma, -1.0, 1.0, 1.0, plus_zero);
4609   TEST_fff_f (fma, -1.0, -1.0, -1.0, plus_zero);
4610
4611   TEST_fff_f (fma, min_value, min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4612   TEST_fff_f (fma, min_value, min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4613   TEST_fff_f (fma, min_value, -min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4614   TEST_fff_f (fma, min_value, -min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4615   TEST_fff_f (fma, -min_value, min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4616   TEST_fff_f (fma, -min_value, min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4617   TEST_fff_f (fma, -min_value, -min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4618   TEST_fff_f (fma, -min_value, -min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4619
4620   TEST_fff_f (fma, max_value, max_value, min_value, plus_infty, OVERFLOW_EXCEPTION);
4621   TEST_fff_f (fma, max_value, max_value, -min_value, plus_infty, OVERFLOW_EXCEPTION);
4622   TEST_fff_f (fma, max_value, -max_value, min_value, minus_infty, OVERFLOW_EXCEPTION);
4623   TEST_fff_f (fma, max_value, -max_value, -min_value, minus_infty, OVERFLOW_EXCEPTION);
4624   TEST_fff_f (fma, -max_value, max_value, min_value, minus_infty, OVERFLOW_EXCEPTION);
4625   TEST_fff_f (fma, -max_value, max_value, -min_value, minus_infty, OVERFLOW_EXCEPTION);
4626   TEST_fff_f (fma, -max_value, -max_value, min_value, plus_infty, OVERFLOW_EXCEPTION);
4627   TEST_fff_f (fma, -max_value, -max_value, -min_value, plus_infty, OVERFLOW_EXCEPTION);
4628
4629 #if defined (TEST_FLOAT) && FLT_MANT_DIG == 24
4630   TEST_fff_f (fma, 0x1.7ff8p+13, 0x1.000002p+0, 0x1.ffffp-24, 0x1.7ff802p+13);
4631   TEST_fff_f (fma, 0x1.fffp+0, 0x1.00001p+0, -0x1.fffp+0, 0x1.fffp-20);
4632   TEST_fff_f (fma, 0x1.9abcdep+127, 0x0.9abcdep-126, -0x1.f08948p+0, 0x1.bb421p-25);
4633   TEST_fff_f (fma, 0x1.9abcdep+100, 0x0.9abcdep-126, -0x1.f08948p-27, 0x1.bb421p-52);
4634   TEST_fff_f (fma, 0x1.fffffep+127, 0x1.001p+0, -0x1.fffffep+127, 0x1.fffffep+115);
4635   TEST_fff_f (fma, -0x1.fffffep+127, 0x1.fffffep+0, 0x1.fffffep+127, -0x1.fffffap+127);
4636   TEST_fff_f (fma, 0x1.fffffep+127, 2.0, -0x1.fffffep+127, 0x1.fffffep+127);
4637   TEST_fff_f (fma, 0x1.4p-126, 0x1.000004p-1, 0x1p-128, 0x1.c00004p-127, UNDERFLOW_EXCEPTION);
4638   TEST_fff_f (fma, -0x1.4p-126, 0x1.000004p-1, -0x1p-128, -0x1.c00004p-127, UNDERFLOW_EXCEPTION);
4639   TEST_fff_f (fma, 0x1.fffff8p-126, 0x1.000002p-1, 0x1p-149, 0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4640   TEST_fff_f (fma, -0x1.fffff8p-126, 0x1.000002p-1, -0x1p-149, -0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4641   TEST_fff_f (fma, 0x1p-149, 0x1p-1, 0x0.fffffep-126, 0x1p-126, UNDERFLOW_EXCEPTION);
4642   TEST_fff_f (fma, -0x1p-149, 0x1p-1, -0x0.fffffep-126, -0x1p-126, UNDERFLOW_EXCEPTION);
4643   TEST_fff_f (fma, 0x1p-149, 0x1.1p-1, 0x0.fffffep-126, 0x1p-126, UNDERFLOW_EXCEPTION);
4644   TEST_fff_f (fma, -0x1p-149, 0x1.1p-1, -0x0.fffffep-126, -0x1p-126, UNDERFLOW_EXCEPTION);
4645   TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p127, 0x1p127);
4646   TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p127, 0x1p127);
4647   TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p127, -0x1p127);
4648   TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p127, -0x1p127);
4649   TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-126, 0x1p-126);
4650   TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-126, 0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4651   TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-126, -0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4652   TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-126, -0x1p-126);
4653   TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4654   TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4655   TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4656   TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4657   TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-149, 0x1p-149, UNDERFLOW_EXCEPTION);
4658   TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-149, 0x1p-149, UNDERFLOW_EXCEPTION);
4659   TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-149, -0x1p-149, UNDERFLOW_EXCEPTION);
4660   TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-149, -0x1p-149, UNDERFLOW_EXCEPTION);
4661   TEST_fff_f (fma, 0x0.fffp0, 0x0.fffp0, -0x0.ffep0, 0x1p-24);
4662   TEST_fff_f (fma, 0x0.fffp0, -0x0.fffp0, 0x0.ffep0, -0x1p-24);
4663   TEST_fff_f (fma, -0x0.fffp0, 0x0.fffp0, 0x0.ffep0, -0x1p-24);
4664   TEST_fff_f (fma, -0x0.fffp0, -0x0.fffp0, -0x0.ffep0, 0x1p-24);
4665   TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p127, 0x1p127);
4666   TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p127, 0x1p127);
4667   TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p127, -0x1p127);
4668   TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p127, -0x1p127);
4669   TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p103, 0x1p103);
4670   TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p103, 0x1p103);
4671   TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p103, -0x1p103);
4672   TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p103, -0x1p103);
4673 #endif
4674 #if defined (TEST_DOUBLE) && DBL_MANT_DIG == 53
4675   TEST_fff_f (fma, 0x1.7fp+13, 0x1.0000000000001p+0, 0x1.ffep-48, 0x1.7f00000000001p+13);
4676   TEST_fff_f (fma, 0x1.fffp+0, 0x1.0000000000001p+0, -0x1.fffp+0, 0x1.fffp-52);
4677   TEST_fff_f (fma, 0x1.0000002p+0, 0x1.ffffffcp-1, 0x1p-300, 1.0);
4678   TEST_fff_f (fma, 0x1.0000002p+0, 0x1.ffffffcp-1, -0x1p-300, 0x1.fffffffffffffp-1);
4679   TEST_fff_f (fma, 0x1.deadbeef2feedp+1023, 0x0.deadbeef2feedp-1022, -0x1.a05f8c01a4bfbp+1, 0x1.0989687bc9da4p-53);
4680   TEST_fff_f (fma, 0x1.deadbeef2feedp+900, 0x0.deadbeef2feedp-1022, -0x1.a05f8c01a4bfbp-122, 0x1.0989687bc9da4p-176);
4681   TEST_fff_f (fma, 0x1.fffffffffffffp+1023, 0x1.001p+0, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+1011);
4682   TEST_fff_f (fma, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+0, 0x1.fffffffffffffp+1023, -0x1.ffffffffffffdp+1023);
4683   TEST_fff_f (fma, 0x1.fffffffffffffp+1023, 2.0, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+1023);
4684   TEST_fff_f (fma, 0x1.6a09e667f3bccp-538, 0x1.6a09e667f3bccp-538, 0.0, 0.0, UNDERFLOW_EXCEPTION);
4685   TEST_fff_f (fma, 0x1.deadbeef2feedp-495, 0x1.deadbeef2feedp-495, -0x1.bf86a5786a574p-989, 0x0.0000042625a1fp-1022, UNDERFLOW_EXCEPTION);
4686   TEST_fff_f (fma, 0x1.deadbeef2feedp-503, 0x1.deadbeef2feedp-503, -0x1.bf86a5786a574p-1005, 0x0.0000000004262p-1022, UNDERFLOW_EXCEPTION);
4687   TEST_fff_f (fma, 0x1p-537, 0x1p-538, 0x1p-1074, 0x0.0000000000002p-1022, UNDERFLOW_EXCEPTION);
4688   TEST_fff_f (fma, 0x1.7fffff8p-968, 0x1p-106, 0x0.000001p-1022, 0x0.0000010000001p-1022, UNDERFLOW_EXCEPTION);
4689   TEST_fff_f (fma, 0x1.4000004p-967, 0x1p-106, 0x0.000001p-1022, 0x0.0000010000003p-1022, UNDERFLOW_EXCEPTION);
4690   TEST_fff_f (fma, 0x1.4p-967, -0x1p-106, -0x0.000001p-1022, -0x0.0000010000002p-1022, UNDERFLOW_EXCEPTION);
4691   TEST_fff_f (fma, -0x1.19cab66d73e17p-959, 0x1.c7108a8c5ff51p-107, -0x0.80b0ad65d9b64p-1022, -0x0.80b0ad65d9d59p-1022, UNDERFLOW_EXCEPTION);
4692   TEST_fff_f (fma, -0x1.d2eaed6e8e9d3p-979, -0x1.4e066c62ac9ddp-63, -0x0.9245e6b003454p-1022, -0x0.9245c09c5fb5dp-1022, UNDERFLOW_EXCEPTION);
4693   TEST_fff_f (fma, 0x1.153d650bb9f06p-907, 0x1.2d01230d48407p-125, -0x0.b278d5acfc3cp-1022, -0x0.b22757123bbe9p-1022, UNDERFLOW_EXCEPTION);
4694   TEST_fff_f (fma, -0x1.fffffffffffffp-711, 0x1.fffffffffffffp-275, 0x1.fffffe00007ffp-983, 0x1.7ffffe00007ffp-983);
4695   TEST_fff_f (fma, 0x1.4p-1022, 0x1.0000000000002p-1, 0x1p-1024, 0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
4696   TEST_fff_f (fma, -0x1.4p-1022, 0x1.0000000000002p-1, -0x1p-1024, -0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
4697   TEST_fff_f (fma, 0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, 0x1p-1074, 0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4698   TEST_fff_f (fma, -0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, -0x1p-1074, -0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4699   TEST_fff_f (fma, 0x1p-1074, 0x1p-1, 0x0.fffffffffffffp-1022, 0x1p-1022, UNDERFLOW_EXCEPTION);
4700   TEST_fff_f (fma, -0x1p-1074, 0x1p-1, -0x0.fffffffffffffp-1022, -0x1p-1022, UNDERFLOW_EXCEPTION);
4701   TEST_fff_f (fma, 0x1p-1074, 0x1.1p-1, 0x0.fffffffffffffp-1022, 0x1p-1022, UNDERFLOW_EXCEPTION);
4702   TEST_fff_f (fma, -0x1p-1074, 0x1.1p-1, -0x0.fffffffffffffp-1022, -0x1p-1022, UNDERFLOW_EXCEPTION);
4703   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p1023, 0x1p1023);
4704   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p1023, 0x1p1023);
4705   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p1023, -0x1p1023);
4706   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p1023, -0x1p1023);
4707   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1022, 0x1p-1022);
4708   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1022, 0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4709   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1022, -0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4710   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1022, -0x1p-1022);
4711   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4712   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4713   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4714   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4715   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1074, 0x1p-1074, UNDERFLOW_EXCEPTION);
4716   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1074, 0x1p-1074, UNDERFLOW_EXCEPTION);
4717   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1074, -0x1p-1074, UNDERFLOW_EXCEPTION);
4718   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1074, -0x1p-1074, UNDERFLOW_EXCEPTION);
4719   TEST_fff_f (fma, 0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
4720   TEST_fff_f (fma, 0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
4721   TEST_fff_f (fma, -0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
4722   TEST_fff_f (fma, -0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
4723   TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p1023, 0x1p1023);
4724   TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p1023, 0x1p1023);
4725   TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p1023, -0x1p1023);
4726   TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p1023, -0x1p1023);
4727   TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p970, 0x1p970);
4728   TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p970, 0x1p970);
4729   TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p970, -0x1p970);
4730   TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p970, -0x1p970);
4731 #endif
4732 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 64
4733   TEST_fff_f (fma, -0x8.03fcp+3696L, 0xf.fffffffffffffffp-6140L, 0x8.3ffffffffffffffp-2450L, -0x8.01ecp-2440L);
4734   TEST_fff_f (fma, 0x9.fcp+2033L, -0x8.000e1f000ff800fp-3613L, -0xf.fffffffffffc0ffp-1579L, -0xd.fc119fb093ed092p-1577L);
4735   TEST_fff_f (fma, 0xc.7fc000003ffffffp-1194L, 0x8.1e0003fffffffffp+15327L, -0x8.fffep+14072L, 0xc.ae9f164020effffp+14136L);
4736   TEST_fff_f (fma, -0x8.0001fc000000003p+1798L, 0xcp-2230L, 0x8.f7e000000000007p-468L, -0xc.0002f9ffee10404p-429L);
4737   TEST_fff_f (fma, 0xc.0000000000007ffp+10130L, -0x8.000000000000001p+4430L, 0xc.07000000001ffffp+14513L, -0xb.fffffffffffd7e4p+14563L);
4738   TEST_fff_f (fma, 0xb.ffffp-4777L, 0x8.000000fffffffffp-11612L, -0x0.3800fff8p-16385L, 0x5.c7fe80c7ffeffffp-16385L, UNDERFLOW_EXCEPTION);
4739   TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000004p-1L, 0x1p-16384L, 0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
4740   TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000004p-1L, -0x1p-16384L, -0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
4741   TEST_fff_f (fma, 0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, 0x1p-16445L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4742   TEST_fff_f (fma, -0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, -0x1p-16445L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4743   TEST_fff_f (fma, 0x1p-16445L, 0x1p-1L, 0x0.fffffffffffffffep-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
4744   TEST_fff_f (fma, -0x1p-16445L, 0x1p-1L, -0x0.fffffffffffffffep-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
4745   TEST_fff_f (fma, 0x1p-16445L, 0x1.1p-1L, 0x0.fffffffffffffffep-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
4746   TEST_fff_f (fma, -0x1p-16445L, 0x1.1p-1L, -0x0.fffffffffffffffep-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
4747   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p16383L, 0x1p16383L);
4748   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p16383L, 0x1p16383L);
4749   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p16383L, -0x1p16383L);
4750   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p16383L, -0x1p16383L);
4751   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16382L, 0x1p-16382L);
4752   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4753   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4754   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16382L, -0x1p-16382L);
4755   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4756   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4757   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4758   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4759   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, UNDERFLOW_EXCEPTION);
4760   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16445L, 0x1p-16445L, UNDERFLOW_EXCEPTION);
4761   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, UNDERFLOW_EXCEPTION);
4762   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, -0x1p-16445L, UNDERFLOW_EXCEPTION);
4763   TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
4764   TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
4765   TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
4766   TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
4767   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16383L, 0x1p16383L);
4768   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16383L, 0x1p16383L);
4769   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16383L, -0x1p16383L);
4770   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16383L, -0x1p16383L);
4771   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16319L, 0x1p16319L);
4772   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16319L, 0x1p16319L);
4773   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16319L, -0x1p16319L);
4774   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16319L, -0x1p16319L);
4775 #endif
4776 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 113
4777   TEST_fff_f (fma, 0x1.bb2de33e02ccbbfa6e245a7c1f71p-2584L, -0x1.6b500daf0580d987f1bc0cadfcddp-13777L, 0x1.613cd91d9fed34b33820e5ab9d8dp-16378L, -0x1.3a79fb50eb9ce887cffa0f09bd9fp-16360L);
4778   TEST_fff_f (fma, -0x1.f949b880cacb0f0c61540105321dp-5954L, -0x1.3876cec84b4140f3bd6198731b7ep-10525L, -0x0.a5dc1c6cfbc498c54fb0b504bf19p-16382L, -0x0.a5dc1c6cfbc498c54fb0b5038abbp-16382L, UNDERFLOW_EXCEPTION);
4779   TEST_fff_f (fma, -0x1.0000fffffffffp-16221L, 0x1.0000001fffff8007fep-239L, 0x0.ff87ffffffffffffe000003fffffp-16382L, 0x0.ff87ffffffffffffdffc003bff7fp-16382L, UNDERFLOW_EXCEPTION);
4780   TEST_fff_f (fma, -0x1.ac79c9376ef447f3827c9e9de008p-2228L, -0x1.5ba830022b6139e21fbe7270cad8p-6314L, 0x1.e8282b6a26bb6a9daf5c8e73e9f9p-8616L, 0x1.22f14a0253878a730cd1aee373adp-8541L);
4781   TEST_fff_f (fma, -0x1.c69749ec574caaa2ab8e97ddb9f3p+2652L, 0x1.f34235ff9d095449c29b4831b62dp+3311L, 0x1.fbe4302df23354dbd0c4d3cfe606p+5879L, -0x1.bb473bfdfb7a6e18886ce6e57eafp+5964L);
4782   TEST_fff_f (fma, -0x1.ca8835fc6ecfb5398625fc891be5p-1686L, 0x1.621e1972bbe2180e5be9dd7d8df5p-7671L, -0x1.7d2d21b73b52cf20dec2a83902a4p-9395L, -0x1.3d2322191c9c88bc68a62ab8042cp-9356L);
4783   TEST_fff_f (fma, -0x1.55cff679ec49c2541fab41fc843ep-11819L, 0x1.e60e9f464f9e8df0509647c7c971p+12325L, 0x1.eaa2a7649d765c2f564f7a5beca7p+454L, -0x1.447e29fa7e406a285f4e350fcf86p+507L);
4784   TEST_fff_f (fma, 0x1.f0e7b1454908576f2537d863cf9bp+11432L, 0x1.cdce52f09d4ca76e68706f34b5d5p-1417L, -0x1.2e986187c70f146235ea2066e486p+9979L, 0x1.c030dad3cc5643f3dd0f5619f661p+10016L);
4785   TEST_fff_f (fma, 0x1.f102f7da4a57a3a4aab620e29452p-3098L, -0x1.cc06a4ff40248f9e2dcc4b6afd84p-11727L, 0x1.d512a11126b5ac8ed8973b8580c8p-14849L, -0x1.be8f1cf737ab4d1c31c54f5ec23bp-14824L);
4786   TEST_fff_f (fma, -0x1.fc47ac7434b993cd8dcb2b431f25p-3816L, 0x1.fbc9750da8468852d84558e1db6dp-5773L, -0x1.00a98abf783f75c40fe5b7a37d86p-9607L, -0x1.f81917b166f45e763cfcc057e2adp-9588L);
4787   TEST_fff_f (fma, 0x1.00000000000007ffffffffffffffp-9045L, -0x1.ffffffffffff80000001ffffffffp+4773L, -0x1.f8p-4316L, -0x1.00000000000f88000000fffffdffp-4271L);
4788   TEST_fff_f (fma, 0x1.4e922764c90701d4a2f21d01893dp-8683L, -0x1.955a12e2d7c9447c27fa022fc865p+212L, -0x1.e9634462eaef96528b90b6944578p-8521L, -0x1.08e1783184a371943d3598e10865p-8470L);
4789   TEST_fff_f (fma, 0x1.801181509c03bdbef10d6165588cp-15131L, 0x1.ad86f8e57d3d40bfa8007780af63p-368L, -0x1.6e9df0dab1c9f1d7a6043c390741p-15507L, 0x1.417c9b2b15e2ad57dc9e0e920844p-15498L);
4790   TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, 0x1p-16384L, 0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
4791   TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, -0x1p-16384L, -0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
4792   TEST_fff_f (fma, 0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, 0x1p-16494L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4793   TEST_fff_f (fma, -0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, -0x1p-16494L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4794   TEST_fff_f (fma, 0x1p-16494L, 0x1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
4795   TEST_fff_f (fma, -0x1p-16494L, 0x1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
4796   TEST_fff_f (fma, 0x1p-16494L, 0x1.1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
4797   TEST_fff_f (fma, -0x1p-16494L, 0x1.1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
4798   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p16383L, 0x1p16383L);
4799   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p16383L, 0x1p16383L);
4800   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p16383L, -0x1p16383L);
4801   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p16383L, -0x1p16383L);
4802   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16382L, 0x1p-16382L);
4803   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4804   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4805   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16382L, -0x1p-16382L);
4806   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
4807   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
4808   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
4809   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
4810   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, UNDERFLOW_EXCEPTION);
4811   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16494L, 0x1p-16494L, UNDERFLOW_EXCEPTION);
4812   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, UNDERFLOW_EXCEPTION);
4813   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, -0x1p-16494L, UNDERFLOW_EXCEPTION);
4814   TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
4815   TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
4816   TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
4817   TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
4818   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1p16383L);
4819   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1p16383L);
4820   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1p16383L);
4821   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1p16383L);
4822   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1p16319L);
4823   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1p16319L);
4824   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L);
4825   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L);
4826 #endif
4827
4828   END (fma);
4829 }
4830
4831
4832 static void
4833 fma_test_towardzero (void)
4834 {
4835   int save_round_mode;
4836   START (fma_towardzero);
4837
4838   save_round_mode = fegetround ();
4839
4840   if (!fesetround (FE_TOWARDZERO))
4841     {
4842       TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero);
4843       TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, plus_zero);
4844       TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, plus_zero);
4845       TEST_fff_f (fma, plus_zero, minus_zero, minus_zero, minus_zero);
4846       TEST_fff_f (fma, minus_zero, plus_zero, plus_zero, plus_zero);
4847       TEST_fff_f (fma, minus_zero, plus_zero, minus_zero, minus_zero);
4848       TEST_fff_f (fma, minus_zero, minus_zero, plus_zero, plus_zero);
4849       TEST_fff_f (fma, minus_zero, minus_zero, minus_zero, plus_zero);
4850       TEST_fff_f (fma, 1.0, plus_zero, plus_zero, plus_zero);
4851       TEST_fff_f (fma, 1.0, plus_zero, minus_zero, plus_zero);
4852       TEST_fff_f (fma, 1.0, minus_zero, plus_zero, plus_zero);
4853       TEST_fff_f (fma, 1.0, minus_zero, minus_zero, minus_zero);
4854       TEST_fff_f (fma, -1.0, plus_zero, plus_zero, plus_zero);
4855       TEST_fff_f (fma, -1.0, plus_zero, minus_zero, minus_zero);
4856       TEST_fff_f (fma, -1.0, minus_zero, plus_zero, plus_zero);
4857       TEST_fff_f (fma, -1.0, minus_zero, minus_zero, plus_zero);
4858       TEST_fff_f (fma, plus_zero, 1.0, plus_zero, plus_zero);
4859       TEST_fff_f (fma, plus_zero, 1.0, minus_zero, plus_zero);
4860       TEST_fff_f (fma, plus_zero, -1.0, plus_zero, plus_zero);
4861       TEST_fff_f (fma, plus_zero, -1.0, minus_zero, minus_zero);
4862       TEST_fff_f (fma, minus_zero, 1.0, plus_zero, plus_zero);
4863       TEST_fff_f (fma, minus_zero, 1.0, minus_zero, minus_zero);
4864       TEST_fff_f (fma, minus_zero, -1.0, plus_zero, plus_zero);
4865       TEST_fff_f (fma, minus_zero, -1.0, minus_zero, plus_zero);
4866
4867       TEST_fff_f (fma, 1.0, 1.0, -1.0, plus_zero);
4868       TEST_fff_f (fma, 1.0, -1.0, 1.0, plus_zero);
4869       TEST_fff_f (fma, -1.0, 1.0, 1.0, plus_zero);
4870       TEST_fff_f (fma, -1.0, -1.0, -1.0, plus_zero);
4871
4872       TEST_fff_f (fma, min_value, min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4873       TEST_fff_f (fma, min_value, min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4874       TEST_fff_f (fma, min_value, -min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4875       TEST_fff_f (fma, min_value, -min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4876       TEST_fff_f (fma, -min_value, min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4877       TEST_fff_f (fma, -min_value, min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4878       TEST_fff_f (fma, -min_value, -min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4879       TEST_fff_f (fma, -min_value, -min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4880
4881       TEST_fff_f (fma, max_value, max_value, min_value, max_value, OVERFLOW_EXCEPTION);
4882       TEST_fff_f (fma, max_value, max_value, -min_value, max_value, OVERFLOW_EXCEPTION);
4883       TEST_fff_f (fma, max_value, -max_value, min_value, -max_value, OVERFLOW_EXCEPTION);
4884       TEST_fff_f (fma, max_value, -max_value, -min_value, -max_value, OVERFLOW_EXCEPTION);
4885       TEST_fff_f (fma, -max_value, max_value, min_value, -max_value, OVERFLOW_EXCEPTION);
4886       TEST_fff_f (fma, -max_value, max_value, -min_value, -max_value, OVERFLOW_EXCEPTION);
4887       TEST_fff_f (fma, -max_value, -max_value, min_value, max_value, OVERFLOW_EXCEPTION);
4888       TEST_fff_f (fma, -max_value, -max_value, -min_value, max_value, OVERFLOW_EXCEPTION);
4889
4890 #if defined (TEST_FLOAT) && FLT_MANT_DIG == 24
4891       TEST_fff_f (fma, 0x1.4p-126, 0x1.000004p-1, 0x1p-128, 0x1.c00004p-127, UNDERFLOW_EXCEPTION);
4892       TEST_fff_f (fma, -0x1.4p-126, 0x1.000004p-1, -0x1p-128, -0x1.c00004p-127, UNDERFLOW_EXCEPTION);
4893       TEST_fff_f (fma, 0x1.fffff8p-126, 0x1.000002p-1, 0x1p-149, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4894       TEST_fff_f (fma, -0x1.fffff8p-126, 0x1.000002p-1, -0x1p-149, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4895       TEST_fff_f (fma, 0x1p-149, 0x1p-1, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4896       TEST_fff_f (fma, -0x1p-149, 0x1p-1, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4897       TEST_fff_f (fma, 0x1p-149, 0x1.1p-1, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4898       TEST_fff_f (fma, -0x1p-149, 0x1.1p-1, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4899       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p127, 0x1p127);
4900       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p127, 0x0.ffffffp127);
4901       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p127, -0x0.ffffffp127);
4902       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p127, -0x1p127);
4903       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-126, 0x1p-126);
4904       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4905       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4906       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-126, -0x1p-126);
4907       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4908       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x0.fffffep-126, 0x0.fffffcp-126, UNDERFLOW_EXCEPTION);
4909       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x0.fffffep-126, -0x0.fffffcp-126, UNDERFLOW_EXCEPTION);
4910       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4911       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-149, 0x1p-149, UNDERFLOW_EXCEPTION);
4912       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-149, plus_zero, UNDERFLOW_EXCEPTION);
4913       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-149, minus_zero, UNDERFLOW_EXCEPTION);
4914       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-149, -0x1p-149, UNDERFLOW_EXCEPTION);
4915       TEST_fff_f (fma, 0x0.fffp0, 0x0.fffp0, -0x0.ffep0, 0x1p-24);
4916       TEST_fff_f (fma, 0x0.fffp0, -0x0.fffp0, 0x0.ffep0, -0x1p-24);
4917       TEST_fff_f (fma, -0x0.fffp0, 0x0.fffp0, 0x0.ffep0, -0x1p-24);
4918       TEST_fff_f (fma, -0x0.fffp0, -0x0.fffp0, -0x0.ffep0, 0x1p-24);
4919       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p127, 0x1p127);
4920       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p127, 0x0.ffffffp127);
4921       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p127, -0x0.ffffffp127);
4922       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p127, -0x1p127);
4923       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p103, 0x1p103);
4924       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p103, 0x0.ffffffp103);
4925       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p103, -0x0.ffffffp103);
4926       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p103, -0x1p103);
4927 #endif
4928 #if defined (TEST_DOUBLE) && DBL_MANT_DIG == 53
4929       TEST_fff_f (fma, 0x1.4p-1022, 0x1.0000000000002p-1, 0x1p-1024, 0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
4930       TEST_fff_f (fma, -0x1.4p-1022, 0x1.0000000000002p-1, -0x1p-1024, -0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
4931       TEST_fff_f (fma, 0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, 0x1p-1074, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4932       TEST_fff_f (fma, -0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, -0x1p-1074, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4933       TEST_fff_f (fma, 0x1p-1074, 0x1p-1, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4934       TEST_fff_f (fma, -0x1p-1074, 0x1p-1, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4935       TEST_fff_f (fma, 0x1p-1074, 0x1.1p-1, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4936       TEST_fff_f (fma, -0x1p-1074, 0x1.1p-1, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4937       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p1023, 0x1p1023);
4938       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p1023, 0x0.fffffffffffff8p1023);
4939       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p1023, -0x0.fffffffffffff8p1023);
4940       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p1023, -0x1p1023);
4941       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1022, 0x1p-1022);
4942       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4943       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4944       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1022, -0x1p-1022);
4945       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4946       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.ffffffffffffep-1022, UNDERFLOW_EXCEPTION);
4947       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.ffffffffffffep-1022, UNDERFLOW_EXCEPTION);
4948       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4949       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1074, 0x1p-1074, UNDERFLOW_EXCEPTION);
4950       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1074, plus_zero, UNDERFLOW_EXCEPTION);
4951       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1074, minus_zero, UNDERFLOW_EXCEPTION);
4952       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1074, -0x1p-1074, UNDERFLOW_EXCEPTION);
4953       TEST_fff_f (fma, 0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
4954       TEST_fff_f (fma, 0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
4955       TEST_fff_f (fma, -0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
4956       TEST_fff_f (fma, -0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
4957       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p1023, 0x1p1023);
4958       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p1023, 0x0.fffffffffffff8p1023);
4959       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p1023, -0x0.fffffffffffff8p1023);
4960       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p1023, -0x1p1023);
4961       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p970, 0x1p970);
4962       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p970, 0x0.fffffffffffff8p970);
4963       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p970, -0x0.fffffffffffff8p970);
4964       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p970, -0x1p970);
4965 #endif
4966 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 64
4967       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000004p-1L, 0x1p-16384L, 0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
4968       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000004p-1L, -0x1p-16384L, -0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
4969       TEST_fff_f (fma, 0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4970       TEST_fff_f (fma, -0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4971       TEST_fff_f (fma, 0x1p-16445L, 0x1p-1L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4972       TEST_fff_f (fma, -0x1p-16445L, 0x1p-1L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4973       TEST_fff_f (fma, 0x1p-16445L, 0x1.1p-1L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4974       TEST_fff_f (fma, -0x1p-16445L, 0x1.1p-1L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4975       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p16383L, 0x1p16383L);
4976       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p16383L, 0x0.ffffffffffffffffp16383L);
4977       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p16383L, -0x0.ffffffffffffffffp16383L);
4978       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p16383L, -0x1p16383L);
4979       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16382L, 0x1p-16382L);
4980       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4981       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4982       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16382L, -0x1p-16382L);
4983       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4984       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffcp-16382L, UNDERFLOW_EXCEPTION);
4985       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffcp-16382L, UNDERFLOW_EXCEPTION);
4986       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4987       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, UNDERFLOW_EXCEPTION);
4988       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16445L, plus_zero, UNDERFLOW_EXCEPTION);
4989       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16445L, minus_zero, UNDERFLOW_EXCEPTION);
4990       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, -0x1p-16445L, UNDERFLOW_EXCEPTION);
4991       TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
4992       TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
4993       TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
4994       TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
4995       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16383L, 0x1p16383L);
4996       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16383L, 0x0.ffffffffffffffffp16383L);
4997       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16383L, -0x0.ffffffffffffffffp16383L);
4998       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16383L, -0x1p16383L);
4999       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16319L, 0x1p16319L);
5000       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16319L, 0x0.ffffffffffffffffp16319L);
5001       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16319L, -0x0.ffffffffffffffffp16319L);
5002       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16319L, -0x1p16319L);
5003 #endif
5004 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 113
5005       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, 0x1p-16384L, 0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
5006       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, -0x1p-16384L, -0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
5007       TEST_fff_f (fma, 0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5008       TEST_fff_f (fma, -0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5009       TEST_fff_f (fma, 0x1p-16494L, 0x1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5010       TEST_fff_f (fma, -0x1p-16494L, 0x1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5011       TEST_fff_f (fma, 0x1p-16494L, 0x1.1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5012       TEST_fff_f (fma, -0x1p-16494L, 0x1.1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5013       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p16383L, 0x1p16383L);
5014       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p16383L, 0x0.ffffffffffffffffffffffffffff8p16383L);
5015       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p16383L, -0x0.ffffffffffffffffffffffffffff8p16383L);
5016       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p16383L, -0x1p16383L);
5017       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16382L, 0x1p-16382L);
5018       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5019       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5020       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16382L, -0x1p-16382L);
5021       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5022       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.fffffffffffffffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5023       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.fffffffffffffffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5024       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5025       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, UNDERFLOW_EXCEPTION);
5026       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16494L, plus_zero, UNDERFLOW_EXCEPTION);
5027       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16494L, minus_zero, UNDERFLOW_EXCEPTION);
5028       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, -0x1p-16494L, UNDERFLOW_EXCEPTION);
5029       TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5030       TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5031       TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5032       TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5033       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1p16383L);
5034       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x0.ffffffffffffffffffffffffffff8p16383L);
5035       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x0.ffffffffffffffffffffffffffff8p16383L);
5036       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1p16383L);
5037       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1p16319L);
5038       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x0.ffffffffffffffffffffffffffff8p16319L);
5039       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x0.ffffffffffffffffffffffffffff8p16319L);
5040       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L);
5041 #endif
5042     }
5043
5044   fesetround (save_round_mode);
5045
5046   END (fma_towardzero);
5047 }
5048
5049
5050 static void
5051 fma_test_downward (void)
5052 {
5053   int save_round_mode;
5054   START (fma_downward);
5055
5056   save_round_mode = fegetround ();
5057
5058   if (!fesetround (FE_DOWNWARD))
5059     {
5060       TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero);
5061       TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, minus_zero);
5062       TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, minus_zero);
5063       TEST_fff_f (fma, plus_zero, minus_zero, minus_zero, minus_zero);
5064       TEST_fff_f (fma, minus_zero, plus_zero, plus_zero, minus_zero);
5065       TEST_fff_f (fma, minus_zero, plus_zero, minus_zero, minus_zero);
5066       TEST_fff_f (fma, minus_zero, minus_zero, plus_zero, plus_zero);
5067       TEST_fff_f (fma, minus_zero, minus_zero, minus_zero, minus_zero);
5068       TEST_fff_f (fma, 1.0, plus_zero, plus_zero, plus_zero);
5069       TEST_fff_f (fma, 1.0, plus_zero, minus_zero, minus_zero);
5070       TEST_fff_f (fma, 1.0, minus_zero, plus_zero, minus_zero);
5071       TEST_fff_f (fma, 1.0, minus_zero, minus_zero, minus_zero);
5072       TEST_fff_f (fma, -1.0, plus_zero, plus_zero, minus_zero);
5073       TEST_fff_f (fma, -1.0, plus_zero, minus_zero, minus_zero);
5074       TEST_fff_f (fma, -1.0, minus_zero, plus_zero, plus_zero);
5075       TEST_fff_f (fma, -1.0, minus_zero, minus_zero, minus_zero);
5076       TEST_fff_f (fma, plus_zero, 1.0, plus_zero, plus_zero);
5077       TEST_fff_f (fma, plus_zero, 1.0, minus_zero, minus_zero);
5078       TEST_fff_f (fma, plus_zero, -1.0, plus_zero, minus_zero);
5079       TEST_fff_f (fma, plus_zero, -1.0, minus_zero, minus_zero);
5080       TEST_fff_f (fma, minus_zero, 1.0, plus_zero, minus_zero);
5081       TEST_fff_f (fma, minus_zero, 1.0, minus_zero, minus_zero);
5082       TEST_fff_f (fma, minus_zero, -1.0, plus_zero, plus_zero);
5083       TEST_fff_f (fma, minus_zero, -1.0, minus_zero, minus_zero);
5084
5085       TEST_fff_f (fma, 1.0, 1.0, -1.0, minus_zero);
5086       TEST_fff_f (fma, 1.0, -1.0, 1.0, minus_zero);
5087       TEST_fff_f (fma, -1.0, 1.0, 1.0, minus_zero);
5088       TEST_fff_f (fma, -1.0, -1.0, -1.0, minus_zero);
5089
5090       TEST_fff_f (fma, min_value, min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
5091       TEST_fff_f (fma, min_value, min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
5092       TEST_fff_f (fma, min_value, -min_value, plus_zero, -min_subnorm_value, UNDERFLOW_EXCEPTION);
5093       TEST_fff_f (fma, min_value, -min_value, minus_zero, -min_subnorm_value, UNDERFLOW_EXCEPTION);
5094       TEST_fff_f (fma, -min_value, min_value, plus_zero, -min_subnorm_value, UNDERFLOW_EXCEPTION);
5095       TEST_fff_f (fma, -min_value, min_value, minus_zero, -min_subnorm_value, UNDERFLOW_EXCEPTION);
5096       TEST_fff_f (fma, -min_value, -min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
5097       TEST_fff_f (fma, -min_value, -min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
5098
5099       TEST_fff_f (fma, max_value, max_value, min_value, max_value, OVERFLOW_EXCEPTION);
5100       TEST_fff_f (fma, max_value, max_value, -min_value, max_value, OVERFLOW_EXCEPTION);
5101       TEST_fff_f (fma, max_value, -max_value, min_value, minus_infty, OVERFLOW_EXCEPTION);
5102       TEST_fff_f (fma, max_value, -max_value, -min_value, minus_infty, OVERFLOW_EXCEPTION);
5103       TEST_fff_f (fma, -max_value, max_value, min_value, minus_infty, OVERFLOW_EXCEPTION);
5104       TEST_fff_f (fma, -max_value, max_value, -min_value, minus_infty, OVERFLOW_EXCEPTION);
5105       TEST_fff_f (fma, -max_value, -max_value, min_value, max_value, OVERFLOW_EXCEPTION);
5106       TEST_fff_f (fma, -max_value, -max_value, -min_value, max_value, OVERFLOW_EXCEPTION);
5107
5108 #if defined (TEST_FLOAT) && FLT_MANT_DIG == 24
5109       TEST_fff_f (fma, 0x1.4p-126, 0x1.000004p-1, 0x1p-128, 0x1.c00004p-127, UNDERFLOW_EXCEPTION);
5110       TEST_fff_f (fma, -0x1.4p-126, 0x1.000004p-1, -0x1p-128, -0x1.c00008p-127, UNDERFLOW_EXCEPTION);
5111       TEST_fff_f (fma, 0x1.fffff8p-126, 0x1.000002p-1, 0x1p-149, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5112       TEST_fff_f (fma, -0x1.fffff8p-126, 0x1.000002p-1, -0x1p-149, -0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5113       TEST_fff_f (fma, 0x1p-149, 0x1p-1, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5114       TEST_fff_f (fma, -0x1p-149, 0x1p-1, -0x0.fffffep-126, -0x1p-126, UNDERFLOW_EXCEPTION);
5115       TEST_fff_f (fma, 0x1p-149, 0x1.1p-1, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5116       TEST_fff_f (fma, -0x1p-149, 0x1.1p-1, -0x0.fffffep-126, -0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5117       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p127, 0x1p127);
5118       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p127, 0x0.ffffffp127);
5119       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p127, -0x1p127);
5120       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p127, -0x1.000002p127);
5121       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-126, 0x1p-126);
5122       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5123       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-126, -0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5124       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-126, -0x1.000002p-126);
5125       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5126       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x0.fffffep-126, 0x0.fffffcp-126, UNDERFLOW_EXCEPTION);
5127       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5128       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x0.fffffep-126, -0x1p-126, UNDERFLOW_EXCEPTION);
5129       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-149, 0x1p-149, UNDERFLOW_EXCEPTION);
5130       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-149, plus_zero, UNDERFLOW_EXCEPTION);
5131       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-149, -0x1p-149, UNDERFLOW_EXCEPTION);
5132       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-149, -0x1p-148, UNDERFLOW_EXCEPTION);
5133       TEST_fff_f (fma, 0x0.fffp0, 0x0.fffp0, -0x0.ffep0, 0x1p-24);
5134       TEST_fff_f (fma, 0x0.fffp0, -0x0.fffp0, 0x0.ffep0, -0x1p-24);
5135       TEST_fff_f (fma, -0x0.fffp0, 0x0.fffp0, 0x0.ffep0, -0x1p-24);
5136       TEST_fff_f (fma, -0x0.fffp0, -0x0.fffp0, -0x0.ffep0, 0x1p-24);
5137       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p127, 0x1p127);
5138       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p127, 0x0.ffffffp127);
5139       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p127, -0x1p127);
5140       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p127, -0x1.000002p127);
5141       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p103, 0x1p103);
5142       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p103, 0x0.ffffffp103);
5143       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p103, -0x1p103);
5144       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p103, -0x1.000002p103);
5145 #endif
5146 #if defined (TEST_DOUBLE) && DBL_MANT_DIG == 53
5147       TEST_fff_f (fma, 0x1.4p-1022, 0x1.0000000000002p-1, 0x1p-1024, 0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
5148       TEST_fff_f (fma, -0x1.4p-1022, 0x1.0000000000002p-1, -0x1p-1024, -0x1.c000000000004p-1023, UNDERFLOW_EXCEPTION);
5149       TEST_fff_f (fma, 0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, 0x1p-1074, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5150       TEST_fff_f (fma, -0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, -0x1p-1074, -0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5151       TEST_fff_f (fma, 0x1p-1074, 0x1p-1, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5152       TEST_fff_f (fma, -0x1p-1074, 0x1p-1, -0x0.fffffffffffffp-1022, -0x1p-1022, UNDERFLOW_EXCEPTION);
5153       TEST_fff_f (fma, 0x1p-1074, 0x1.1p-1, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5154       TEST_fff_f (fma, -0x1p-1074, 0x1.1p-1, -0x0.fffffffffffffp-1022, -0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5155       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p1023, 0x1p1023);
5156       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p1023, 0x0.fffffffffffff8p1023);
5157       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p1023, -0x1p1023);
5158       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p1023, -0x1.0000000000001p1023);
5159       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1022, 0x1p-1022);
5160       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5161       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1022, -0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5162       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1022, -0x1.0000000000001p-1022);
5163       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5164       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.ffffffffffffep-1022, UNDERFLOW_EXCEPTION);
5165       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5166       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x0.fffffffffffffp-1022, -0x1p-1022, UNDERFLOW_EXCEPTION);
5167       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1074, 0x1p-1074, UNDERFLOW_EXCEPTION);
5168       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1074, plus_zero, UNDERFLOW_EXCEPTION);
5169       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1074, -0x1p-1074, UNDERFLOW_EXCEPTION);
5170       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1074, -0x1p-1073, UNDERFLOW_EXCEPTION);
5171       TEST_fff_f (fma, 0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
5172       TEST_fff_f (fma, 0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
5173       TEST_fff_f (fma, -0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
5174       TEST_fff_f (fma, -0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
5175       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p1023, 0x1p1023);
5176       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p1023, 0x0.fffffffffffff8p1023);
5177       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p1023, -0x1p1023);
5178       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p1023, -0x1.0000000000001p1023);
5179       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p970, 0x1p970);
5180       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p970, 0x0.fffffffffffff8p970);
5181       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p970, -0x1p970);
5182       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p970, -0x1.0000000000001p970);
5183 #endif
5184 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 64
5185       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000004p-1L, 0x1p-16384L, 0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
5186       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000004p-1L, -0x1p-16384L, -0x1.c000000000000008p-16383L, UNDERFLOW_EXCEPTION);
5187       TEST_fff_f (fma, 0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5188       TEST_fff_f (fma, -0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, -0x1p-16445L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5189       TEST_fff_f (fma, 0x1p-16445L, 0x1p-1L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5190       TEST_fff_f (fma, -0x1p-16445L, 0x1p-1L, -0x0.fffffffffffffffep-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
5191       TEST_fff_f (fma, 0x1p-16445L, 0x1.1p-1L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5192       TEST_fff_f (fma, -0x1p-16445L, 0x1.1p-1L, -0x0.fffffffffffffffep-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5193       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p16383L, 0x1p16383L);
5194       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p16383L, 0x0.ffffffffffffffffp16383L);
5195       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p16383L, -0x1p16383L);
5196       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p16383L, -0x1.0000000000000002p16383L);
5197       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16382L, 0x1p-16382L);
5198       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5199       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5200       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16382L, -0x1.0000000000000002p-16382L);
5201       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5202       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffcp-16382L, UNDERFLOW_EXCEPTION);
5203       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5204       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
5205       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, UNDERFLOW_EXCEPTION);
5206       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16445L, plus_zero, UNDERFLOW_EXCEPTION);
5207       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, UNDERFLOW_EXCEPTION);
5208       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, -0x1p-16444L, UNDERFLOW_EXCEPTION);
5209       TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
5210       TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
5211       TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
5212       TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
5213       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16383L, 0x1p16383L);
5214       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16383L, 0x0.ffffffffffffffffp16383L);
5215       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16383L, -0x1p16383L);
5216       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16383L, -0x1.0000000000000002p16383L);
5217       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16319L, 0x1p16319L);
5218       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16319L, 0x0.ffffffffffffffffp16319L);
5219       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16319L, -0x1p16319L);
5220       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16319L, -0x1.0000000000000002p16319L);
5221 #endif
5222 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 113
5223       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, 0x1p-16384L, 0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
5224       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, -0x1p-16384L, -0x1.c000000000000000000000000004p-16383L, UNDERFLOW_EXCEPTION);
5225       TEST_fff_f (fma, 0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5226       TEST_fff_f (fma, -0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, -0x1p-16494L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5227       TEST_fff_f (fma, 0x1p-16494L, 0x1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5228       TEST_fff_f (fma, -0x1p-16494L, 0x1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
5229       TEST_fff_f (fma, 0x1p-16494L, 0x1.1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5230       TEST_fff_f (fma, -0x1p-16494L, 0x1.1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5231       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p16383L, 0x1p16383L);
5232       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p16383L, 0x0.ffffffffffffffffffffffffffff8p16383L);
5233       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p16383L, -0x1p16383L);
5234       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p16383L, -0x1.0000000000000000000000000001p16383L);
5235       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16382L, 0x1p-16382L);
5236       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5237       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5238       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16382L, -0x1.0000000000000000000000000001p-16382L);
5239       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5240       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.fffffffffffffffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5241       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5242       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
5243       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, UNDERFLOW_EXCEPTION);
5244       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16494L, plus_zero, UNDERFLOW_EXCEPTION);
5245       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, UNDERFLOW_EXCEPTION);
5246       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, -0x1p-16493L, UNDERFLOW_EXCEPTION);
5247       TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5248       TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5249       TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5250       TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5251       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1p16383L);
5252       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x0.ffffffffffffffffffffffffffff8p16383L);
5253       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1p16383L);
5254       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1.0000000000000000000000000001p16383L);
5255       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1p16319L);
5256       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x0.ffffffffffffffffffffffffffff8p16319L);
5257       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L);
5258       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1.0000000000000000000000000001p16319L);
5259 #endif
5260     }
5261
5262   fesetround (save_round_mode);
5263
5264   END (fma_downward);
5265 }
5266
5267
5268 static void
5269 fma_test_upward (void)
5270 {
5271   int save_round_mode;
5272   START (fma_upward);
5273
5274   save_round_mode = fegetround ();
5275
5276   if (!fesetround (FE_UPWARD))
5277     {
5278       TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero);
5279       TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, plus_zero);
5280       TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, plus_zero);
5281       TEST_fff_f (fma, plus_zero, minus_zero, minus_zero, minus_zero);
5282       TEST_fff_f (fma, minus_zero, plus_zero, plus_zero, plus_zero);
5283       TEST_fff_f (fma, minus_zero, plus_zero, minus_zero, minus_zero);
5284       TEST_fff_f (fma, minus_zero, minus_zero, plus_zero, plus_zero);
5285       TEST_fff_f (fma, minus_zero, minus_zero, minus_zero, plus_zero);
5286       TEST_fff_f (fma, 1.0, plus_zero, plus_zero, plus_zero);
5287       TEST_fff_f (fma, 1.0, plus_zero, minus_zero, plus_zero);
5288       TEST_fff_f (fma, 1.0, minus_zero, plus_zero, plus_zero);
5289       TEST_fff_f (fma, 1.0, minus_zero, minus_zero, minus_zero);
5290       TEST_fff_f (fma, -1.0, plus_zero, plus_zero, plus_zero);
5291       TEST_fff_f (fma, -1.0, plus_zero, minus_zero, minus_zero);
5292       TEST_fff_f (fma, -1.0, minus_zero, plus_zero, plus_zero);
5293       TEST_fff_f (fma, -1.0, minus_zero, minus_zero, plus_zero);
5294       TEST_fff_f (fma, plus_zero, 1.0, plus_zero, plus_zero);
5295       TEST_fff_f (fma, plus_zero, 1.0, minus_zero, plus_zero);
5296       TEST_fff_f (fma, plus_zero, -1.0, plus_zero, plus_zero);
5297       TEST_fff_f (fma, plus_zero, -1.0, minus_zero, minus_zero);
5298       TEST_fff_f (fma, minus_zero, 1.0, plus_zero, plus_zero);
5299       TEST_fff_f (fma, minus_zero, 1.0, minus_zero, minus_zero);
5300       TEST_fff_f (fma, minus_zero, -1.0, plus_zero, plus_zero);
5301       TEST_fff_f (fma, minus_zero, -1.0, minus_zero, plus_zero);
5302
5303       TEST_fff_f (fma, 1.0, 1.0, -1.0, plus_zero);
5304       TEST_fff_f (fma, 1.0, -1.0, 1.0, plus_zero);
5305       TEST_fff_f (fma, -1.0, 1.0, 1.0, plus_zero);
5306       TEST_fff_f (fma, -1.0, -1.0, -1.0, plus_zero);
5307
5308       TEST_fff_f (fma, min_value, min_value, plus_zero, min_subnorm_value, UNDERFLOW_EXCEPTION);
5309       TEST_fff_f (fma, min_value, min_value, minus_zero, min_subnorm_value, UNDERFLOW_EXCEPTION);
5310       TEST_fff_f (fma, min_value, -min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
5311       TEST_fff_f (fma, min_value, -min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
5312       TEST_fff_f (fma, -min_value, min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
5313       TEST_fff_f (fma, -min_value, min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
5314       TEST_fff_f (fma, -min_value, -min_value, plus_zero, min_subnorm_value, UNDERFLOW_EXCEPTION);
5315       TEST_fff_f (fma, -min_value, -min_value, minus_zero, min_subnorm_value, UNDERFLOW_EXCEPTION);
5316
5317       TEST_fff_f (fma, max_value, max_value, min_value, plus_infty, OVERFLOW_EXCEPTION);
5318       TEST_fff_f (fma, max_value, max_value, -min_value, plus_infty, OVERFLOW_EXCEPTION);
5319       TEST_fff_f (fma, max_value, -max_value, min_value, -max_value, OVERFLOW_EXCEPTION);
5320       TEST_fff_f (fma, max_value, -max_value, -min_value, -max_value, OVERFLOW_EXCEPTION);
5321       TEST_fff_f (fma, -max_value, max_value, min_value, -max_value, OVERFLOW_EXCEPTION);
5322       TEST_fff_f (fma, -max_value, max_value, -min_value, -max_value, OVERFLOW_EXCEPTION);
5323       TEST_fff_f (fma, -max_value, -max_value, min_value, plus_infty, OVERFLOW_EXCEPTION);
5324       TEST_fff_f (fma, -max_value, -max_value, -min_value, plus_infty, OVERFLOW_EXCEPTION);
5325
5326 #if defined (TEST_FLOAT) && FLT_MANT_DIG == 24
5327       TEST_fff_f (fma, 0x1.4p-126, 0x1.000004p-1, 0x1p-128, 0x1.c00008p-127, UNDERFLOW_EXCEPTION);
5328       TEST_fff_f (fma, -0x1.4p-126, 0x1.000004p-1, -0x1p-128, -0x1.c00004p-127, UNDERFLOW_EXCEPTION);
5329       TEST_fff_f (fma, 0x1.fffff8p-126, 0x1.000002p-1, 0x1p-149, 0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5330       TEST_fff_f (fma, -0x1.fffff8p-126, 0x1.000002p-1, -0x1p-149, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5331       TEST_fff_f (fma, 0x1p-149, 0x1p-1, 0x0.fffffep-126, 0x1p-126, UNDERFLOW_EXCEPTION);
5332       TEST_fff_f (fma, -0x1p-149, 0x1p-1, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5333       TEST_fff_f (fma, 0x1p-149, 0x1.1p-1, 0x0.fffffep-126, 0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5334       TEST_fff_f (fma, -0x1p-149, 0x1.1p-1, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5335       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p127, 0x1.000002p127);
5336       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p127, 0x1p127);
5337       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p127, -0x0.ffffffp127);
5338       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p127, -0x1p127);
5339       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-126, 0x1.000002p-126);
5340       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-126, 0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5341       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5342       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-126, -0x1p-126);
5343       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x0.fffffep-126, 0x1p-126, UNDERFLOW_EXCEPTION);
5344       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5345       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x0.fffffep-126, -0x0.fffffcp-126, UNDERFLOW_EXCEPTION);
5346       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5347       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-149, 0x1p-148, UNDERFLOW_EXCEPTION);
5348       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-149, 0x1p-149, UNDERFLOW_EXCEPTION);
5349       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-149, minus_zero, UNDERFLOW_EXCEPTION);
5350       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-149, -0x1p-149, UNDERFLOW_EXCEPTION);
5351       TEST_fff_f (fma, 0x0.fffp0, 0x0.fffp0, -0x0.ffep0, 0x1p-24);
5352       TEST_fff_f (fma, 0x0.fffp0, -0x0.fffp0, 0x0.ffep0, -0x1p-24);
5353       TEST_fff_f (fma, -0x0.fffp0, 0x0.fffp0, 0x0.ffep0, -0x1p-24);
5354       TEST_fff_f (fma, -0x0.fffp0, -0x0.fffp0, -0x0.ffep0, 0x1p-24);
5355       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p127, 0x1.000002p127);
5356       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p127, 0x1p127);
5357       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p127, -0x0.ffffffp127);
5358       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p127, -0x1p127);
5359       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p103, 0x1.000002p103);
5360       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p103, 0x1p103);
5361       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p103, -0x0.ffffffp103);
5362       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p103, -0x1p103);
5363 #endif
5364 #if defined (TEST_DOUBLE) && DBL_MANT_DIG == 53
5365       TEST_fff_f (fma, 0x1.4p-1022, 0x1.0000000000002p-1, 0x1p-1024, 0x1.c000000000004p-1023, UNDERFLOW_EXCEPTION);
5366       TEST_fff_f (fma, -0x1.4p-1022, 0x1.0000000000002p-1, -0x1p-1024, -0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
5367       TEST_fff_f (fma, 0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, 0x1p-1074, 0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5368       TEST_fff_f (fma, -0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, -0x1p-1074, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5369       TEST_fff_f (fma, 0x1p-1074, 0x1p-1, 0x0.fffffffffffffp-1022, 0x1p-1022, UNDERFLOW_EXCEPTION);
5370       TEST_fff_f (fma, -0x1p-1074, 0x1p-1, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5371       TEST_fff_f (fma, 0x1p-1074, 0x1.1p-1, 0x0.fffffffffffffp-1022, 0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5372       TEST_fff_f (fma, -0x1p-1074, 0x1.1p-1, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5373       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p1023, 0x1.0000000000001p1023);
5374       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p1023, 0x1p1023);
5375       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p1023, -0x0.fffffffffffff8p1023);
5376       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p1023, -0x1p1023);
5377       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1022, 0x1.0000000000001p-1022);
5378       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1022, 0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5379       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5380       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1022, -0x1p-1022);
5381       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x0.fffffffffffffp-1022, 0x1p-1022, UNDERFLOW_EXCEPTION);
5382       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5383       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.ffffffffffffep-1022, UNDERFLOW_EXCEPTION);
5384       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5385       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1074, 0x1p-1073, UNDERFLOW_EXCEPTION);
5386       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1074, 0x1p-1074, UNDERFLOW_EXCEPTION);
5387       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1074, minus_zero, UNDERFLOW_EXCEPTION);
5388       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1074, -0x1p-1074, UNDERFLOW_EXCEPTION);
5389       TEST_fff_f (fma, 0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
5390       TEST_fff_f (fma, 0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
5391       TEST_fff_f (fma, -0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
5392       TEST_fff_f (fma, -0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
5393       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p1023, 0x1.0000000000001p1023);
5394       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p1023, 0x1p1023);
5395       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p1023, -0x0.fffffffffffff8p1023);
5396       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p1023, -0x1p1023);
5397       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p970, 0x1.0000000000001p970);
5398       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p970, 0x1p970);
5399       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p970, -0x0.fffffffffffff8p970);
5400       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p970, -0x1p970);
5401 #endif
5402 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 64
5403       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000004p-1L, 0x1p-16384L, 0x1.c000000000000008p-16383L, UNDERFLOW_EXCEPTION);
5404       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000004p-1L, -0x1p-16384L, -0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
5405       TEST_fff_f (fma, 0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, 0x1p-16445L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5406       TEST_fff_f (fma, -0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5407       TEST_fff_f (fma, 0x1p-16445L, 0x1p-1L, 0x0.fffffffffffffffep-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
5408       TEST_fff_f (fma, -0x1p-16445L, 0x1p-1L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5409       TEST_fff_f (fma, 0x1p-16445L, 0x1.1p-1L, 0x0.fffffffffffffffep-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5410       TEST_fff_f (fma, -0x1p-16445L, 0x1.1p-1L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5411       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p16383L, 0x1.0000000000000002p16383L);
5412       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p16383L, 0x1p16383L);
5413       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p16383L, -0x0.ffffffffffffffffp16383L);
5414       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p16383L, -0x1p16383L);
5415       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16382L, 0x1.0000000000000002p-16382L);
5416       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5417       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5418       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16382L, -0x1p-16382L);
5419       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
5420       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5421       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffcp-16382L, UNDERFLOW_EXCEPTION);
5422       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5423       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, 0x1p-16444L, UNDERFLOW_EXCEPTION);
5424       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16445L, 0x1p-16445L, UNDERFLOW_EXCEPTION);
5425       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16445L, minus_zero, UNDERFLOW_EXCEPTION);
5426       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, -0x1p-16445L, UNDERFLOW_EXCEPTION);
5427       TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
5428       TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
5429       TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
5430       TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
5431       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16383L, 0x1.0000000000000002p16383L);
5432       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16383L, 0x1p16383L);
5433       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16383L, -0x0.ffffffffffffffffp16383L);
5434       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16383L, -0x1p16383L);
5435       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16319L, 0x1.0000000000000002p16319L);
5436       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16319L, 0x1p16319L);
5437       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16319L, -0x0.ffffffffffffffffp16319L);
5438       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16319L, -0x1p16319L);
5439 #endif
5440 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 113
5441       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, 0x1p-16384L, 0x1.c000000000000000000000000004p-16383L, UNDERFLOW_EXCEPTION);
5442       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, -0x1p-16384L, -0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
5443       TEST_fff_f (fma, 0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, 0x1p-16494L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5444       TEST_fff_f (fma, -0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5445       TEST_fff_f (fma, 0x1p-16494L, 0x1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
5446       TEST_fff_f (fma, -0x1p-16494L, 0x1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5447       TEST_fff_f (fma, 0x1p-16494L, 0x1.1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5448       TEST_fff_f (fma, -0x1p-16494L, 0x1.1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5449       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p16383L, 0x1.0000000000000000000000000001p16383L);
5450       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p16383L, 0x1p16383L);
5451       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p16383L, -0x0.ffffffffffffffffffffffffffff8p16383L);
5452       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p16383L, -0x1p16383L);
5453       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16382L, 0x1.0000000000000000000000000001p-16382L);
5454       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5455       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5456       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16382L, -0x1p-16382L);
5457       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
5458       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5459       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.fffffffffffffffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5460       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5461       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, 0x1p-16493L, UNDERFLOW_EXCEPTION);
5462       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16494L, 0x1p-16494L, UNDERFLOW_EXCEPTION);
5463       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16494L, minus_zero, UNDERFLOW_EXCEPTION);
5464       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, -0x1p-16494L, UNDERFLOW_EXCEPTION);
5465       TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5466       TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5467       TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5468       TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5469       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1.0000000000000000000000000001p16383L);
5470       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1p16383L);
5471       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x0.ffffffffffffffffffffffffffff8p16383L);
5472       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1p16383L);
5473       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1.0000000000000000000000000001p16319L);
5474       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1p16319L);
5475       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x0.ffffffffffffffffffffffffffff8p16319L);
5476       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L);
5477 #endif
5478     }
5479
5480   fesetround (save_round_mode);
5481
5482   END (fma_upward);
5483 }
5484
5485
5486 static void
5487 fmax_test (void)
5488 {
5489   START (fmax);
5490
5491   TEST_ff_f (fmax, 0, 0, 0);
5492   TEST_ff_f (fmax, minus_zero, minus_zero, minus_zero);
5493   TEST_ff_f (fmax, 9, 0, 9);
5494   TEST_ff_f (fmax, 0, 9, 9);
5495   TEST_ff_f (fmax, -9, 0, 0);
5496   TEST_ff_f (fmax, 0, -9, 0);
5497
5498   TEST_ff_f (fmax, plus_infty, 9, plus_infty);
5499   TEST_ff_f (fmax, 0, plus_infty, plus_infty);
5500   TEST_ff_f (fmax, -9, plus_infty, plus_infty);
5501   TEST_ff_f (fmax, plus_infty, -9, plus_infty);
5502
5503   TEST_ff_f (fmax, minus_infty, 9, 9);
5504   TEST_ff_f (fmax, minus_infty, -9, -9);
5505   TEST_ff_f (fmax, 9, minus_infty, 9);
5506   TEST_ff_f (fmax, -9, minus_infty, -9);
5507
5508   TEST_ff_f (fmax, 0, nan_value, 0);
5509   TEST_ff_f (fmax, 9, nan_value, 9);
5510   TEST_ff_f (fmax, -9, nan_value, -9);
5511   TEST_ff_f (fmax, nan_value, 0, 0);
5512   TEST_ff_f (fmax, nan_value, 9, 9);
5513   TEST_ff_f (fmax, nan_value, -9, -9);
5514   TEST_ff_f (fmax, plus_infty, nan_value, plus_infty);
5515   TEST_ff_f (fmax, minus_infty, nan_value, minus_infty);
5516   TEST_ff_f (fmax, nan_value, plus_infty, plus_infty);
5517   TEST_ff_f (fmax, nan_value, minus_infty, minus_infty);
5518   TEST_ff_f (fmax, nan_value, nan_value, nan_value);
5519
5520   END (fmax);
5521 }
5522
5523
5524 static void
5525 fmin_test (void)
5526 {
5527   START (fmin);
5528
5529   TEST_ff_f (fmin, 0, 0, 0);
5530   TEST_ff_f (fmin, minus_zero, minus_zero, minus_zero);
5531   TEST_ff_f (fmin, 9, 0, 0);
5532   TEST_ff_f (fmin, 0, 9, 0);
5533   TEST_ff_f (fmin, -9, 0, -9);
5534   TEST_ff_f (fmin, 0, -9, -9);
5535
5536   TEST_ff_f (fmin, plus_infty, 9, 9);
5537   TEST_ff_f (fmin, 9, plus_infty, 9);
5538   TEST_ff_f (fmin, plus_infty, -9, -9);
5539   TEST_ff_f (fmin, -9, plus_infty, -9);
5540   TEST_ff_f (fmin, minus_infty, 9, minus_infty);
5541   TEST_ff_f (fmin, minus_infty, -9, minus_infty);
5542   TEST_ff_f (fmin, 9, minus_infty, minus_infty);
5543   TEST_ff_f (fmin, -9, minus_infty, minus_infty);
5544
5545   TEST_ff_f (fmin, 0, nan_value, 0);
5546   TEST_ff_f (fmin, 9, nan_value, 9);
5547   TEST_ff_f (fmin, -9, nan_value, -9);
5548   TEST_ff_f (fmin, nan_value, 0, 0);
5549   TEST_ff_f (fmin, nan_value, 9, 9);
5550   TEST_ff_f (fmin, nan_value, -9, -9);
5551   TEST_ff_f (fmin, plus_infty, nan_value, plus_infty);
5552   TEST_ff_f (fmin, minus_infty, nan_value, minus_infty);
5553   TEST_ff_f (fmin, nan_value, plus_infty, plus_infty);
5554   TEST_ff_f (fmin, nan_value, minus_infty, minus_infty);
5555   TEST_ff_f (fmin, nan_value, nan_value, nan_value);
5556
5557   END (fmin);
5558 }
5559
5560
5561 static void
5562 fmod_test (void)
5563 {
5564   errno = 0;
5565   FUNC(fmod) (6.5, 2.3L);
5566   if (errno == ENOSYS)
5567     /* Function not implemented.  */
5568     return;
5569
5570   START (fmod);
5571
5572   /* fmod (+0, y) == +0 for y != 0.  */
5573   TEST_ff_f (fmod, 0, 3, 0);
5574
5575   /* fmod (-0, y) == -0 for y != 0.  */
5576   TEST_ff_f (fmod, minus_zero, 3, minus_zero);
5577
5578   /* fmod (+inf, y) == NaN plus invalid exception.  */
5579   errno = 0;
5580   TEST_ff_f (fmod, plus_infty, 3, nan_value, INVALID_EXCEPTION);
5581   check_int ("errno for fmod(Inf,3) unchanged", errno, EDOM, 0, 0, 0);
5582   /* fmod (-inf, y) == NaN plus invalid exception.  */
5583   errno = 0;
5584   TEST_ff_f (fmod, minus_infty, 3, nan_value, INVALID_EXCEPTION);
5585   check_int ("errno for fmod(-Inf,3) unchanged", errno, EDOM, 0, 0, 0);
5586   /* fmod (x, +0) == NaN plus invalid exception.  */
5587   errno = 0;
5588   TEST_ff_f (fmod, 3, 0, nan_value, INVALID_EXCEPTION);
5589   check_int ("errno for fmod(3,0) unchanged", errno, EDOM, 0, 0, 0);
5590   /* fmod (x, -0) == NaN plus invalid exception.  */
5591   TEST_ff_f (fmod, 3, minus_zero, nan_value, INVALID_EXCEPTION);
5592
5593   /* fmod (x, +inf) == x for x not infinite.  */
5594   TEST_ff_f (fmod, 3.0, plus_infty, 3.0);
5595   /* fmod (x, -inf) == x for x not infinite.  */
5596   TEST_ff_f (fmod, 3.0, minus_infty, 3.0);
5597
5598   TEST_ff_f (fmod, nan_value, nan_value, nan_value);
5599
5600   TEST_ff_f (fmod, 6.5, 2.25L, 2.0L);
5601   TEST_ff_f (fmod, -6.5, 2.25L, -2.0L);
5602   TEST_ff_f (fmod, 6.5, -2.25L, 2.0L);
5603   TEST_ff_f (fmod, -6.5, -2.25L, -2.0L);
5604
5605   TEST_ff_f (fmod, 0x0.fffffep-126L, 0x1p-149L, plus_zero);
5606 #ifndef TEST_FLOAT
5607   TEST_ff_f (fmod, 0x0.fffffffffffffp-1022L, 0x1p-1074L, plus_zero);
5608 #endif
5609 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
5610   TEST_ff_f (fmod, 0x0.fffffffffffffffep-16382L, 0x1p-16445L, plus_zero);
5611 #endif
5612
5613   END (fmod);
5614 }
5615
5616
5617 static void
5618 fpclassify_test (void)
5619 {
5620   START (fpclassify);
5621
5622   TEST_f_i (fpclassify, nan_value, FP_NAN);
5623   TEST_f_i (fpclassify, plus_infty, FP_INFINITE);
5624   TEST_f_i (fpclassify, minus_infty, FP_INFINITE);
5625   TEST_f_i (fpclassify, plus_zero, FP_ZERO);
5626   TEST_f_i (fpclassify, minus_zero, FP_ZERO);
5627   TEST_f_i (fpclassify, 1000, FP_NORMAL);
5628   TEST_f_i (fpclassify, min_subnorm_value, FP_SUBNORMAL);
5629
5630   END (fpclassify);
5631 }
5632
5633
5634 static void
5635 frexp_test (void)
5636 {
5637   int x;
5638
5639   START (frexp);
5640
5641   TEST_fI_f1 (frexp, plus_infty, plus_infty, IGNORE);
5642   TEST_fI_f1 (frexp, minus_infty, minus_infty, IGNORE);
5643   TEST_fI_f1 (frexp, nan_value, nan_value, IGNORE);
5644
5645   TEST_fI_f1 (frexp, 0.0, 0.0, 0.0);
5646   TEST_fI_f1 (frexp, minus_zero, minus_zero, 0.0);
5647
5648   TEST_fI_f1 (frexp, 12.8L, 0.8L, 4);
5649   TEST_fI_f1 (frexp, -27.34L, -0.854375L, 5);
5650
5651   END (frexp);
5652 }
5653
5654
5655 static void
5656 gamma_test (void)
5657 {
5658   errno = 0;
5659   FUNC(gamma) (1);
5660
5661   if (errno == ENOSYS)
5662     /* Function not implemented.  */
5663     return;
5664
5665   START (gamma);
5666
5667   TEST_f_f (gamma, plus_infty, plus_infty);
5668   TEST_f_f (gamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5669   TEST_f_f (gamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5670   TEST_f_f (gamma, minus_infty, plus_infty);
5671   TEST_f_f (gamma, nan_value, nan_value);
5672
5673   TEST_f_f1 (gamma, 1, 0, 1);
5674   TEST_f_f1 (gamma, 3, M_LN2l, 1);
5675
5676   TEST_f_f1 (gamma, 0.5, M_LOG_SQRT_PIl, 1);
5677   TEST_f_f1 (gamma, -0.5, M_LOG_2_SQRT_PIl, -1);
5678
5679   END (gamma);
5680 }
5681
5682 static void
5683 hypot_test (void)
5684 {
5685   errno = 0;
5686   FUNC(hypot) (0.7L, 12.4L);
5687   if (errno == ENOSYS)
5688     /* Function not implemented.  */
5689     return;
5690
5691   START (hypot);
5692
5693   TEST_ff_f (hypot, plus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
5694   TEST_ff_f (hypot, minus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
5695
5696 #ifndef TEST_INLINE
5697   TEST_ff_f (hypot, plus_infty, nan_value, plus_infty);
5698   TEST_ff_f (hypot, minus_infty, nan_value, plus_infty);
5699   TEST_ff_f (hypot, nan_value, plus_infty, plus_infty);
5700   TEST_ff_f (hypot, nan_value, minus_infty, plus_infty);
5701 #endif
5702
5703   TEST_ff_f (hypot, nan_value, nan_value, nan_value);
5704
5705   /* hypot (x,y) == hypot (+-x, +-y)  */
5706   TEST_ff_f (hypot, 0.7L, 12.4L, 12.419742348374220601176836866763271L);
5707   TEST_ff_f (hypot, -0.7L, 12.4L, 12.419742348374220601176836866763271L);
5708   TEST_ff_f (hypot, 0.7L, -12.4L, 12.419742348374220601176836866763271L);
5709   TEST_ff_f (hypot, -0.7L, -12.4L, 12.419742348374220601176836866763271L);
5710   TEST_ff_f (hypot, 12.4L, 0.7L, 12.419742348374220601176836866763271L);
5711   TEST_ff_f (hypot, -12.4L, 0.7L, 12.419742348374220601176836866763271L);
5712   TEST_ff_f (hypot, 12.4L, -0.7L, 12.419742348374220601176836866763271L);
5713   TEST_ff_f (hypot, -12.4L, -0.7L, 12.419742348374220601176836866763271L);
5714
5715   /*  hypot (x,0) == fabs (x)  */
5716   TEST_ff_f (hypot, 0.75L, 0, 0.75L);
5717   TEST_ff_f (hypot, -0.75L, 0, 0.75L);
5718   TEST_ff_f (hypot, -5.7e7, 0, 5.7e7L);
5719
5720   TEST_ff_f (hypot, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
5721
5722 #if !(defined TEST_FLOAT && defined TEST_INLINE)
5723   TEST_ff_f (hypot, 0x3p125L, 0x4p125L, 0x5p125L);
5724   TEST_ff_f (hypot, 0x1.234566p-126L, 0x1.234566p-126L, 1.891441686191081936598531534017449451173e-38L);
5725 #endif
5726
5727 #if !defined TEST_FLOAT && !(defined TEST_DOUBLE && defined TEST_INLINE)
5728   TEST_ff_f (hypot, 0x3p1021L, 0x4p1021L, 0x5p1021L);
5729 #endif
5730
5731 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384 && !defined TEST_INLINE
5732   TEST_ff_f (hypot, 0x3p16381L, 0x4p16381L, 0x5p16381L);
5733 #endif
5734
5735   END (hypot);
5736 }
5737
5738
5739 static void
5740 ilogb_test (void)
5741 {
5742   START (ilogb);
5743
5744   TEST_f_i (ilogb, 1, 0);
5745   TEST_f_i (ilogb, M_El, 1);
5746   TEST_f_i (ilogb, 1024, 10);
5747   TEST_f_i (ilogb, -2000, 10);
5748
5749   /* ilogb (0.0) == FP_ILOGB0 plus invalid exception  */
5750   errno = 0;
5751   TEST_f_i (ilogb, 0.0, FP_ILOGB0, INVALID_EXCEPTION);
5752   check_int ("errno for ilogb(0.0) unchanged", errno, EDOM, 0, 0, 0);
5753   /* ilogb (NaN) == FP_ILOGBNAN plus invalid exception  */
5754   errno = 0;
5755   TEST_f_i (ilogb, nan_value, FP_ILOGBNAN, INVALID_EXCEPTION);
5756   check_int ("errno for ilogb(NaN) unchanged", errno, EDOM, 0, 0, 0);
5757   /* ilogb (inf) == INT_MAX plus invalid exception  */
5758   errno = 0;
5759   TEST_f_i (ilogb, plus_infty, INT_MAX, INVALID_EXCEPTION);
5760   check_int ("errno for ilogb(Inf) unchanged", errno, EDOM, 0, 0, 0);
5761   /* ilogb (-inf) == INT_MAX plus invalid exception  */
5762   errno = 0;
5763   TEST_f_i (ilogb, minus_infty, INT_MAX, INVALID_EXCEPTION);
5764   check_int ("errno for ilogb(-Inf) unchanged", errno, EDOM, 0, 0, 0);
5765
5766   END (ilogb);
5767 }
5768
5769 static void
5770 isfinite_test (void)
5771 {
5772   START (isfinite);
5773
5774   TEST_f_b (isfinite, 0, 1);
5775   TEST_f_b (isfinite, minus_zero, 1);
5776   TEST_f_b (isfinite, 10, 1);
5777   TEST_f_b (isfinite, min_subnorm_value, 1);
5778   TEST_f_b (isfinite, plus_infty, 0);
5779   TEST_f_b (isfinite, minus_infty, 0);
5780   TEST_f_b (isfinite, nan_value, 0);
5781
5782   END (isfinite);
5783 }
5784
5785 static void
5786 isgreater_test (void)
5787 {
5788   START (isgreater);
5789
5790   TEST_ff_i (isgreater, minus_zero, minus_zero, 0);
5791   TEST_ff_i (isgreater, minus_zero, plus_zero, 0);
5792   TEST_ff_i (isgreater, minus_zero, (FLOAT) 1, 0);
5793   TEST_ff_i (isgreater, minus_zero, nan_value, 0);
5794   TEST_ff_i (isgreater, plus_zero, minus_zero, 0);
5795   TEST_ff_i (isgreater, plus_zero, plus_zero, 0);
5796   TEST_ff_i (isgreater, plus_zero, (FLOAT) 1, 0);
5797   TEST_ff_i (isgreater, plus_zero, nan_value, 0);
5798   TEST_ff_i (isgreater, (FLOAT) 1, minus_zero, 1);
5799   TEST_ff_i (isgreater, (FLOAT) 1, plus_zero, 1);
5800   TEST_ff_i (isgreater, (FLOAT) 1, (FLOAT) 1, 0);
5801   TEST_ff_i (isgreater, (FLOAT) 1, nan_value, 0);
5802   TEST_ff_i (isgreater, nan_value, minus_zero, 0);
5803   TEST_ff_i (isgreater, nan_value, plus_zero, 0);
5804   TEST_ff_i (isgreater, nan_value, (FLOAT) 1, 0);
5805   TEST_ff_i (isgreater, nan_value, nan_value, 0);
5806
5807   END (isgreater);
5808 }
5809
5810 static void
5811 isgreaterequal_test (void)
5812 {
5813   START (isgreaterequal);
5814
5815   TEST_ff_i (isgreaterequal, minus_zero, minus_zero, 1);
5816   TEST_ff_i (isgreaterequal, minus_zero, plus_zero, 1);
5817   TEST_ff_i (isgreaterequal, minus_zero, (FLOAT) 1, 0);
5818   TEST_ff_i (isgreaterequal, minus_zero, nan_value, 0);
5819   TEST_ff_i (isgreaterequal, plus_zero, minus_zero, 1);
5820   TEST_ff_i (isgreaterequal, plus_zero, plus_zero, 1);
5821   TEST_ff_i (isgreaterequal, plus_zero, (FLOAT) 1, 0);
5822   TEST_ff_i (isgreaterequal, plus_zero, nan_value, 0);
5823   TEST_ff_i (isgreaterequal, (FLOAT) 1, minus_zero, 1);
5824   TEST_ff_i (isgreaterequal, (FLOAT) 1, plus_zero, 1);
5825   TEST_ff_i (isgreaterequal, (FLOAT) 1, (FLOAT) 1, 1);
5826   TEST_ff_i (isgreaterequal, (FLOAT) 1, nan_value, 0);
5827   TEST_ff_i (isgreaterequal, nan_value, minus_zero, 0);
5828   TEST_ff_i (isgreaterequal, nan_value, plus_zero, 0);
5829   TEST_ff_i (isgreaterequal, nan_value, (FLOAT) 1, 0);
5830   TEST_ff_i (isgreaterequal, nan_value, nan_value, 0);
5831
5832   END (isgreaterequal);
5833 }
5834
5835 static void
5836 isinf_test (void)
5837 {
5838   START (isinf);
5839
5840   TEST_f_b (isinf, 0, 0);
5841   TEST_f_b (isinf, minus_zero, 0);
5842   TEST_f_b (isinf, 10, 0);
5843   TEST_f_b (isinf, min_subnorm_value, 0);
5844   TEST_f_b (isinf, plus_infty, 1);
5845   TEST_f_b (isinf, minus_infty, 1);
5846   TEST_f_b (isinf, nan_value, 0);
5847
5848   END (isinf);
5849 }
5850
5851 static void
5852 isless_test (void)
5853 {
5854   START (isless);
5855
5856   TEST_ff_i (isless, minus_zero, minus_zero, 0);
5857   TEST_ff_i (isless, minus_zero, plus_zero, 0);
5858   TEST_ff_i (isless, minus_zero, (FLOAT) 1, 1);
5859   TEST_ff_i (isless, minus_zero, nan_value, 0);
5860   TEST_ff_i (isless, plus_zero, minus_zero, 0);
5861   TEST_ff_i (isless, plus_zero, plus_zero, 0);
5862   TEST_ff_i (isless, plus_zero, (FLOAT) 1, 1);
5863   TEST_ff_i (isless, plus_zero, nan_value, 0);
5864   TEST_ff_i (isless, (FLOAT) 1, minus_zero, 0);
5865   TEST_ff_i (isless, (FLOAT) 1, plus_zero, 0);
5866   TEST_ff_i (isless, (FLOAT) 1, (FLOAT) 1, 0);
5867   TEST_ff_i (isless, (FLOAT) 1, nan_value, 0);
5868   TEST_ff_i (isless, nan_value, minus_zero, 0);
5869   TEST_ff_i (isless, nan_value, plus_zero, 0);
5870   TEST_ff_i (isless, nan_value, (FLOAT) 1, 0);
5871   TEST_ff_i (isless, nan_value, nan_value, 0);
5872
5873   END (isless);
5874 }
5875
5876 static void
5877 islessequal_test (void)
5878 {
5879   START (islessequal);
5880
5881   TEST_ff_i (islessequal, minus_zero, minus_zero, 1);
5882   TEST_ff_i (islessequal, minus_zero, plus_zero, 1);
5883   TEST_ff_i (islessequal, minus_zero, (FLOAT) 1, 1);
5884   TEST_ff_i (islessequal, minus_zero, nan_value, 0);
5885   TEST_ff_i (islessequal, plus_zero, minus_zero, 1);
5886   TEST_ff_i (islessequal, plus_zero, plus_zero, 1);
5887   TEST_ff_i (islessequal, plus_zero, (FLOAT) 1, 1);
5888   TEST_ff_i (islessequal, plus_zero, nan_value, 0);
5889   TEST_ff_i (islessequal, (FLOAT) 1, minus_zero, 0);
5890   TEST_ff_i (islessequal, (FLOAT) 1, plus_zero, 0);
5891   TEST_ff_i (islessequal, (FLOAT) 1, (FLOAT) 1, 1);
5892   TEST_ff_i (islessequal, (FLOAT) 1, nan_value, 0);
5893   TEST_ff_i (islessequal, nan_value, minus_zero, 0);
5894   TEST_ff_i (islessequal, nan_value, plus_zero, 0);
5895   TEST_ff_i (islessequal, nan_value, (FLOAT) 1, 0);
5896   TEST_ff_i (islessequal, nan_value, nan_value, 0);
5897
5898   END (islessequal);
5899 }
5900
5901 static void
5902 islessgreater_test (void)
5903 {
5904   START (islessgreater);
5905
5906   TEST_ff_i (islessgreater, minus_zero, minus_zero, 0);
5907   TEST_ff_i (islessgreater, minus_zero, plus_zero, 0);
5908   TEST_ff_i (islessgreater, minus_zero, (FLOAT) 1, 1);
5909   TEST_ff_i (islessgreater, minus_zero, nan_value, 0);
5910   TEST_ff_i (islessgreater, plus_zero, minus_zero, 0);
5911   TEST_ff_i (islessgreater, plus_zero, plus_zero, 0);
5912   TEST_ff_i (islessgreater, plus_zero, (FLOAT) 1, 1);
5913   TEST_ff_i (islessgreater, plus_zero, nan_value, 0);
5914   TEST_ff_i (islessgreater, (FLOAT) 1, minus_zero, 1);
5915   TEST_ff_i (islessgreater, (FLOAT) 1, plus_zero, 1);
5916   TEST_ff_i (islessgreater, (FLOAT) 1, (FLOAT) 1, 0);
5917   TEST_ff_i (islessgreater, (FLOAT) 1, nan_value, 0);
5918   TEST_ff_i (islessgreater, nan_value, minus_zero, 0);
5919   TEST_ff_i (islessgreater, nan_value, plus_zero, 0);
5920   TEST_ff_i (islessgreater, nan_value, (FLOAT) 1, 0);
5921   TEST_ff_i (islessgreater, nan_value, nan_value, 0);
5922
5923   END (islessgreater);
5924 }
5925
5926 static void
5927 isnan_test (void)
5928 {
5929   START (isnan);
5930
5931   TEST_f_b (isnan, 0, 0);
5932   TEST_f_b (isnan, minus_zero, 0);
5933   TEST_f_b (isnan, 10, 0);
5934   TEST_f_b (isnan, min_subnorm_value, 0);
5935   TEST_f_b (isnan, plus_infty, 0);
5936   TEST_f_b (isnan, minus_infty, 0);
5937   TEST_f_b (isnan, nan_value, 1);
5938
5939   END (isnan);
5940 }
5941
5942 static void
5943 isnormal_test (void)
5944 {
5945   START (isnormal);
5946
5947   TEST_f_b (isnormal, 0, 0);
5948   TEST_f_b (isnormal, minus_zero, 0);
5949   TEST_f_b (isnormal, 10, 1);
5950   TEST_f_b (isnormal, min_subnorm_value, 0);
5951   TEST_f_b (isnormal, plus_infty, 0);
5952   TEST_f_b (isnormal, minus_infty, 0);
5953   TEST_f_b (isnormal, nan_value, 0);
5954
5955   END (isnormal);
5956 }
5957
5958 static void
5959 isunordered_test (void)
5960 {
5961   START (isunordered);
5962
5963   TEST_ff_i (isunordered, minus_zero, minus_zero, 0);
5964   TEST_ff_i (isunordered, minus_zero, plus_zero, 0);
5965   TEST_ff_i (isunordered, minus_zero, (FLOAT) 1, 0);
5966   TEST_ff_i (isunordered, minus_zero, nan_value, 1);
5967   TEST_ff_i (isunordered, plus_zero, minus_zero, 0);
5968   TEST_ff_i (isunordered, plus_zero, plus_zero, 0);
5969   TEST_ff_i (isunordered, plus_zero, (FLOAT) 1, 0);
5970   TEST_ff_i (isunordered, plus_zero, nan_value, 1);
5971   TEST_ff_i (isunordered, (FLOAT) 1, minus_zero, 0);
5972   TEST_ff_i (isunordered, (FLOAT) 1, plus_zero, 0);
5973   TEST_ff_i (isunordered, (FLOAT) 1, (FLOAT) 1, 0);
5974   TEST_ff_i (isunordered, (FLOAT) 1, nan_value, 1);
5975   TEST_ff_i (isunordered, nan_value, minus_zero, 1);
5976   TEST_ff_i (isunordered, nan_value, plus_zero, 1);
5977   TEST_ff_i (isunordered, nan_value, (FLOAT) 1, 1);
5978   TEST_ff_i (isunordered, nan_value, nan_value, 1);
5979
5980   END (isunordered);
5981 }
5982
5983 static void
5984 j0_test (void)
5985 {
5986   FLOAT s, c;
5987   errno = 0;
5988   FUNC (sincos) (0, &s, &c);
5989   if (errno == ENOSYS)
5990     /* Required function not implemented.  */
5991     return;
5992   FUNC(j0) (0);
5993   if (errno == ENOSYS)
5994     /* Function not implemented.  */
5995     return;
5996
5997   START (j0);
5998
5999   /* j0 is the Bessel function of the first kind of order 0 */
6000   TEST_f_f (j0, nan_value, nan_value);
6001   TEST_f_f (j0, plus_infty, 0);
6002   TEST_f_f (j0, -1.0, 0.765197686557966551449717526102663221L);
6003   TEST_f_f (j0, 0.0, 1.0);
6004   TEST_f_f (j0, 0.125L, 0.996097563041985204620768999453174712L);
6005   TEST_f_f (j0, 0.75L, 0.864242275166648623555731103820923211L);
6006   TEST_f_f (j0, 1.0, 0.765197686557966551449717526102663221L);
6007   TEST_f_f (j0, 1.5, 0.511827671735918128749051744283411720L);
6008   TEST_f_f (j0, 2.0, 0.223890779141235668051827454649948626L);
6009   TEST_f_f (j0, 8.0, 0.171650807137553906090869407851972001L);
6010   TEST_f_f (j0, 10.0, -0.245935764451348335197760862485328754L);
6011   TEST_f_f (j0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
6012   TEST_f_f (j0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
6013
6014   /* Bug 14155: spurious exception may occur.  */
6015   TEST_f_f (j0, 0x1.d7ce3ap+107L, 2.775523647291230802651040996274861694514e-17L, UNDERFLOW_EXCEPTION_OK);
6016
6017 #ifndef TEST_FLOAT
6018   /* Bug 14155: spurious exception may occur.  */
6019   TEST_f_f (j0, -0x1.001000001p+593L, -3.927269966354206207832593635798954916263e-90L, UNDERFLOW_EXCEPTION_OK);
6020 #endif
6021
6022   END (j0);
6023 }
6024
6025
6026 static void
6027 j1_test (void)
6028 {
6029   FLOAT s, c;
6030   errno = 0;
6031   FUNC (sincos) (0, &s, &c);
6032   if (errno == ENOSYS)
6033     /* Required function not implemented.  */
6034     return;
6035   FUNC(j1) (0);
6036   if (errno == ENOSYS)
6037     /* Function not implemented.  */
6038     return;
6039
6040   /* j1 is the Bessel function of the first kind of order 1 */
6041
6042   START (j1);
6043
6044   TEST_f_f (j1, nan_value, nan_value);
6045   TEST_f_f (j1, plus_infty, 0);
6046
6047   TEST_f_f (j1, -1.0, -0.440050585744933515959682203718914913L);
6048   TEST_f_f (j1, 0.0, 0.0);
6049   TEST_f_f (j1, 0.125L, 0.0623780091344946810942311355879361177L);
6050   TEST_f_f (j1, 0.75L, 0.349243602174862192523281016426251335L);
6051   TEST_f_f (j1, 1.0, 0.440050585744933515959682203718914913L);
6052   TEST_f_f (j1, 1.5, 0.557936507910099641990121213156089400L);
6053   TEST_f_f (j1, 2.0, 0.576724807756873387202448242269137087L);
6054   TEST_f_f (j1, 8.0, 0.234636346853914624381276651590454612L);
6055   TEST_f_f (j1, 10.0, 0.0434727461688614366697487680258592883L);
6056
6057   TEST_f_f (j1, 0x1.3ffp+74L, 1.818984347516051243459364437186082741567e-12L);
6058
6059 #ifndef TEST_FLOAT
6060   /* Bug 14155: spurious exception may occur.  */
6061   TEST_f_f (j1, 0x1.ff00000000002p+840L, 1.846591691699331493194965158699937660696e-127L, UNDERFLOW_EXCEPTION_OK);
6062 #endif
6063
6064   END (j1);
6065 }
6066
6067 static void
6068 jn_test (void)
6069 {
6070   FLOAT s, c;
6071   errno = 0;
6072   FUNC (sincos) (0, &s, &c);
6073   if (errno == ENOSYS)
6074     /* Required function not implemented.  */
6075     return;
6076   FUNC(jn) (1, 1);
6077   if (errno == ENOSYS)
6078     /* Function not implemented.  */
6079     return;
6080
6081   /* jn is the Bessel function of the first kind of order n.  */
6082   START (jn);
6083
6084   /* jn (0, x) == j0 (x)  */
6085   TEST_ff_f (jn, 0, nan_value, nan_value);
6086   TEST_ff_f (jn, 0, plus_infty, 0);
6087   TEST_ff_f (jn, 0, -1.0, 0.765197686557966551449717526102663221L);
6088   TEST_ff_f (jn, 0, 0.0, 1.0);
6089   TEST_ff_f (jn, 0, 0.125L, 0.996097563041985204620768999453174712L);
6090   TEST_ff_f (jn, 0, 0.75L, 0.864242275166648623555731103820923211L);
6091   TEST_ff_f (jn, 0, 1.0, 0.765197686557966551449717526102663221L);
6092   TEST_ff_f (jn, 0, 1.5, 0.511827671735918128749051744283411720L);
6093   TEST_ff_f (jn, 0, 2.0, 0.223890779141235668051827454649948626L);
6094   TEST_ff_f (jn, 0, 8.0, 0.171650807137553906090869407851972001L);
6095   TEST_ff_f (jn, 0, 10.0, -0.245935764451348335197760862485328754L);
6096   TEST_ff_f (jn, 0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
6097   TEST_ff_f (jn, 0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
6098
6099   /* jn (1, x) == j1 (x)  */
6100   TEST_ff_f (jn, 1, nan_value, nan_value);
6101   TEST_ff_f (jn, 1, plus_infty, 0);
6102   TEST_ff_f (jn, 1, -1.0, -0.440050585744933515959682203718914913L);
6103   TEST_ff_f (jn, 1, 0.0, 0.0);
6104   TEST_ff_f (jn, 1, 0.125L, 0.0623780091344946810942311355879361177L);
6105   TEST_ff_f (jn, 1, 0.75L, 0.349243602174862192523281016426251335L);
6106   TEST_ff_f (jn, 1, 1.0, 0.440050585744933515959682203718914913L);
6107   TEST_ff_f (jn, 1, 1.5, 0.557936507910099641990121213156089400L);
6108   TEST_ff_f (jn, 1, 2.0, 0.576724807756873387202448242269137087L);
6109   TEST_ff_f (jn, 1, 8.0, 0.234636346853914624381276651590454612L);
6110   TEST_ff_f (jn, 1, 10.0, 0.0434727461688614366697487680258592883L);
6111
6112   /* jn (3, x)  */
6113   TEST_ff_f (jn, 3, nan_value, nan_value);
6114   TEST_ff_f (jn, 3, plus_infty, 0);
6115
6116   TEST_ff_f (jn, 3, -1.0, -0.0195633539826684059189053216217515083L);
6117   TEST_ff_f (jn, 3, 0.0, 0.0);
6118   TEST_ff_f (jn, 3, 0.125L, 0.406503832554912875023029337653442868e-4L);
6119   TEST_ff_f (jn, 3, 0.75L, 0.848438342327410884392755236884386804e-2L);
6120   TEST_ff_f (jn, 3, 1.0, 0.0195633539826684059189053216217515083L);
6121   TEST_ff_f (jn, 3, 2.0, 0.128943249474402051098793332969239835L);
6122   TEST_ff_f (jn, 3, 10.0, 0.0583793793051868123429354784103409563L);
6123
6124   /*  jn (10, x)  */
6125   TEST_ff_f (jn, 10, nan_value, nan_value);
6126   TEST_ff_f (jn, 10, plus_infty, 0);
6127
6128   TEST_ff_f (jn, 10, -1.0, 0.263061512368745320699785368779050294e-9L);
6129   TEST_ff_f (jn, 10, 0.0, 0.0);
6130   TEST_ff_f (jn, 10, 0.125L, 0.250543369809369890173993791865771547e-18L);
6131   TEST_ff_f (jn, 10, 0.75L, 0.149621713117596814698712483621682835e-10L);
6132   TEST_ff_f (jn, 10, 1.0, 0.263061512368745320699785368779050294e-9L);
6133   TEST_ff_f (jn, 10, 2.0, 0.251538628271673670963516093751820639e-6L);
6134   TEST_ff_f (jn, 10, 10.0, 0.207486106633358857697278723518753428L);
6135
6136   /* BZ #11589 .*/
6137   TEST_ff_f (jn, 2, 2.4048255576957729L, 0.43175480701968038399746111312430703L);
6138   TEST_ff_f (jn, 3, 2.4048255576957729L, 0.19899990535769083404042146764530813L);
6139   TEST_ff_f (jn, 4, 2.4048255576957729L, 0.647466661641779720084932282551219891E-1L);
6140   TEST_ff_f (jn, 5, 2.4048255576957729L, 0.163892432048058525099230549946147698E-1L);
6141   TEST_ff_f (jn, 6, 2.4048255576957729L, 0.34048184720278336646673682895929161E-2L);
6142   TEST_ff_f (jn, 7, 2.4048255576957729L, 0.60068836573295394221291569249883076E-3L);
6143   TEST_ff_f (jn, 8, 2.4048255576957729L, 0.92165786705344923232879022467054148E-4L);
6144   TEST_ff_f (jn, 9, 2.4048255576957729L, 0.12517270977961513005428966643852564E-4L);
6145
6146   /* Bug 14155: spurious exception may occur.  */
6147   TEST_ff_f (jn, 2, 0x1.ffff62p+99L, -4.43860668048170034334926693188979974489e-16L, UNDERFLOW_EXCEPTION_OK);
6148
6149   END (jn);
6150 }
6151
6152
6153 static void
6154 ldexp_test (void)
6155 {
6156   TEST_ff_f (ldexp, 0, 0, 0);
6157   TEST_ff_f (ldexp, minus_zero, 0, minus_zero);
6158
6159   TEST_ff_f (ldexp, plus_infty, 1, plus_infty);
6160   TEST_ff_f (ldexp, minus_infty, 1, minus_infty);
6161   TEST_ff_f (ldexp, nan_value, 1, nan_value);
6162
6163   TEST_ff_f (ldexp, 0.8L, 4, 12.8L);
6164   TEST_ff_f (ldexp, -0.854375L, 5, -27.34L);
6165
6166   /* ldexp (x, 0) == x.  */
6167   TEST_ff_f (ldexp, 1.0L, 0L, 1.0L);
6168 }
6169
6170
6171 static void
6172 lgamma_test (void)
6173 {
6174   errno = 0;
6175   FUNC(lgamma) (0);
6176   if (errno == ENOSYS)
6177     /* Function not implemented.  */
6178     return;
6179
6180   START (lgamma);
6181
6182   TEST_f_f (lgamma, plus_infty, plus_infty);
6183   TEST_f_f (lgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6184   check_int ("signgam for lgamma(0) == 1", signgam, 1, 0, 0, 0);
6185   TEST_f_f (lgamma, minus_zero, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6186   check_int ("signgam for lgamma(-0) == -1", signgam, -1, 0, 0, 0);
6187   TEST_f_f (lgamma, nan_value, nan_value);
6188
6189   /* lgamma (x) == +inf plus divide by zero exception for integer x <= 0.  */
6190   errno = 0;
6191   TEST_f_f (lgamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6192   check_int ("errno for lgamma(-integer) == ERANGE", errno, ERANGE, 0, 0, 0);
6193   TEST_f_f (lgamma, minus_infty, plus_infty);
6194   TEST_f_f (lgamma, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6195   TEST_f_f (lgamma, max_value, plus_infty, OVERFLOW_EXCEPTION);
6196
6197   TEST_f_f1 (lgamma, 1, 0, 1);
6198
6199   TEST_f_f1 (lgamma, 3, M_LN2l, 1);
6200
6201   TEST_f_f1 (lgamma, 0.5, M_LOG_SQRT_PIl, 1);
6202   TEST_f_f1 (lgamma, -0.5, M_LOG_2_SQRT_PIl, -1);
6203   TEST_f_f1 (lgamma, 0.7L, 0.260867246531666514385732417016759578L, 1);
6204   TEST_f_f1 (lgamma, 1.2L, -0.853740900033158497197028392998854470e-1L, 1);
6205
6206   END (lgamma);
6207 }
6208
6209
6210 static void
6211 lrint_test (void)
6212 {
6213   /* XXX this test is incomplete.  We need to have a way to specifiy
6214      the rounding method and test the critical cases.  So far, only
6215      unproblematic numbers are tested.  */
6216
6217   START (lrint);
6218
6219   TEST_f_l (lrint, 0.0, 0);
6220   TEST_f_l (lrint, minus_zero, 0);
6221   TEST_f_l (lrint, 0.2L, 0);
6222   TEST_f_l (lrint, -0.2L, 0);
6223
6224   TEST_f_l (lrint, 1.4L, 1);
6225   TEST_f_l (lrint, -1.4L, -1);
6226
6227   TEST_f_l (lrint, 8388600.3L, 8388600);
6228   TEST_f_l (lrint, -8388600.3L, -8388600);
6229
6230   TEST_f_l (lrint, 1071930.0008, 1071930);
6231 #ifndef TEST_FLOAT
6232   TEST_f_l (lrint, 1073741824.01, 1073741824);
6233 # if LONG_MAX > 281474976710656
6234   TEST_f_l (lrint, 281474976710656.025, 281474976710656);
6235 # endif
6236 #endif
6237
6238   END (lrint);
6239 }
6240
6241
6242 static void
6243 lrint_test_tonearest (void)
6244 {
6245   int save_round_mode;
6246   START (lrint_tonearest);
6247
6248   save_round_mode = fegetround ();
6249
6250   if (!fesetround (FE_TONEAREST))
6251     {
6252       TEST_f_l (lrint, 0.0, 0);
6253       TEST_f_l (lrint, minus_zero, 0);
6254       TEST_f_l (lrint, 0.2L, 0);
6255       TEST_f_l (lrint, -0.2L, 0);
6256       TEST_f_l (lrint, 0.5L, 0);
6257       TEST_f_l (lrint, -0.5L, 0);
6258       TEST_f_l (lrint, 0.8L, 1);
6259       TEST_f_l (lrint, -0.8L, -1);
6260
6261       TEST_f_l (lrint, 1.4L, 1);
6262       TEST_f_l (lrint, -1.4L, -1);
6263
6264       TEST_f_l (lrint, 8388600.3L, 8388600);
6265       TEST_f_l (lrint, -8388600.3L, -8388600);
6266
6267       TEST_f_l (lrint, 1071930.0008, 1071930);
6268 #ifndef TEST_FLOAT
6269       TEST_f_l (lrint, 1073741824.01, 1073741824);
6270 # if LONG_MAX > 281474976710656
6271       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
6272 # endif
6273 #endif
6274     }
6275
6276   fesetround (save_round_mode);
6277
6278   END (lrint_tonearest);
6279 }
6280
6281
6282 static void
6283 lrint_test_towardzero (void)
6284 {
6285   int save_round_mode;
6286   START (lrint_towardzero);
6287
6288   save_round_mode = fegetround ();
6289
6290   if (!fesetround (FE_TOWARDZERO))
6291     {
6292       TEST_f_l (lrint, 0.0, 0);
6293       TEST_f_l (lrint, minus_zero, 0);
6294       TEST_f_l (lrint, 0.2L, 0);
6295       TEST_f_l (lrint, -0.2L, 0);
6296       TEST_f_l (lrint, 0.5L, 0);
6297       TEST_f_l (lrint, -0.5L, 0);
6298       TEST_f_l (lrint, 0.8L, 0);
6299       TEST_f_l (lrint, -0.8L, 0);
6300
6301       TEST_f_l (lrint, 1.4L, 1);
6302       TEST_f_l (lrint, -1.4L, -1);
6303
6304       TEST_f_l (lrint, 8388600.3L, 8388600);
6305       TEST_f_l (lrint, -8388600.3L, -8388600);
6306
6307       TEST_f_l (lrint, 1071930.0008, 1071930);
6308 #ifndef TEST_FLOAT
6309       TEST_f_l (lrint, 1073741824.01, 1073741824);
6310 # if LONG_MAX > 281474976710656
6311       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
6312 # endif
6313 #endif
6314     }
6315
6316   fesetround (save_round_mode);
6317
6318   END (lrint_towardzero);
6319 }
6320
6321
6322 static void
6323 lrint_test_downward (void)
6324 {
6325   int save_round_mode;
6326   START (lrint_downward);
6327
6328   save_round_mode = fegetround ();
6329
6330   if (!fesetround (FE_DOWNWARD))
6331     {
6332       TEST_f_l (lrint, 0.0, 0);
6333       TEST_f_l (lrint, minus_zero, 0);
6334       TEST_f_l (lrint, 0.2L, 0);
6335       TEST_f_l (lrint, -0.2L, -1);
6336       TEST_f_l (lrint, 0.5L, 0);
6337       TEST_f_l (lrint, -0.5L, -1);
6338       TEST_f_l (lrint, 0.8L, 0);
6339       TEST_f_l (lrint, -0.8L, -1);
6340
6341       TEST_f_l (lrint, 1.4L, 1);
6342       TEST_f_l (lrint, -1.4L, -2);
6343
6344       TEST_f_l (lrint, 8388600.3L, 8388600);
6345       TEST_f_l (lrint, -8388600.3L, -8388601);
6346
6347       TEST_f_l (lrint, 1071930.0008, 1071930);
6348 #ifndef TEST_FLOAT
6349       TEST_f_l (lrint, 1073741824.01, 1073741824);
6350 # if LONG_MAX > 281474976710656
6351       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
6352 # endif
6353 #endif
6354     }
6355
6356   fesetround (save_round_mode);
6357
6358   END (lrint_downward);
6359 }
6360
6361
6362 static void
6363 lrint_test_upward (void)
6364 {
6365   int save_round_mode;
6366   START (lrint_upward);
6367
6368   save_round_mode = fegetround ();
6369
6370   if (!fesetround (FE_UPWARD))
6371     {
6372       TEST_f_l (lrint, 0.0, 0);
6373       TEST_f_l (lrint, minus_zero, 0);
6374       TEST_f_l (lrint, 0.2L, 1);
6375       TEST_f_l (lrint, -0.2L, 0);
6376       TEST_f_l (lrint, 0.5L, 1);
6377       TEST_f_l (lrint, -0.5L, 0);
6378       TEST_f_l (lrint, 0.8L, 1);
6379       TEST_f_l (lrint, -0.8L, 0);
6380
6381       TEST_f_l (lrint, 1.4L, 2);
6382       TEST_f_l (lrint, -1.4L, -1);
6383
6384       TEST_f_l (lrint, 8388600.3L, 8388601);
6385       TEST_f_l (lrint, -8388600.3L, -8388600);
6386
6387 #ifndef TEST_FLOAT
6388       TEST_f_l (lrint, 1071930.0008, 1071931);
6389       TEST_f_l (lrint, 1073741824.01, 1073741825);
6390 # if LONG_MAX > 281474976710656 && defined (TEST_LDOUBLE)
6391       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
6392 # endif
6393 #endif
6394     }
6395
6396   fesetround (save_round_mode);
6397
6398   END (lrint_upward);
6399 }
6400
6401
6402 static void
6403 llrint_test (void)
6404 {
6405   /* XXX this test is incomplete.  We need to have a way to specifiy
6406      the rounding method and test the critical cases.  So far, only
6407      unproblematic numbers are tested.  */
6408
6409   START (llrint);
6410
6411   TEST_f_L (llrint, 0.0, 0);
6412   TEST_f_L (llrint, minus_zero, 0);
6413   TEST_f_L (llrint, 0.2L, 0);
6414   TEST_f_L (llrint, -0.2L, 0);
6415
6416   TEST_f_L (llrint, 1.4L, 1);
6417   TEST_f_L (llrint, -1.4L, -1);
6418
6419   TEST_f_L (llrint, 8388600.3L, 8388600);
6420   TEST_f_L (llrint, -8388600.3L, -8388600);
6421
6422   TEST_f_l (llrint, 1071930.0008, 1071930);
6423
6424   /* Test boundary conditions.  */
6425   /* 0x1FFFFF */
6426   TEST_f_L (llrint, 2097151.0,2097151LL);
6427   /* 0x800000 */
6428   TEST_f_L (llrint, 8388608.0, 8388608LL);
6429   /* 0x1000000 */
6430   TEST_f_L (llrint, 16777216.0, 16777216LL);
6431   /* 0x20000000000 */
6432   TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
6433   /* 0x40000000000 */
6434   TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
6435   /* 0x1000000000000 */
6436   TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
6437   /* 0x10000000000000 */
6438   TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
6439   /* 0x10000080000000 */
6440   TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
6441   /* 0x20000000000000 */
6442   TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
6443   /* 0x80000000000000 */
6444   TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
6445   /* 0x100000000000000 */
6446   TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
6447 #ifdef TEST_LDOUBLE
6448   /* The input can only be represented in long double.  */
6449   TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
6450   TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
6451   TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
6452   TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
6453   TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
6454
6455   TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
6456   TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
6457   TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
6458   TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
6459   TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
6460
6461 # if LDBL_MANT_DIG > 100
6462   TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
6463   TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
6464   TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
6465   TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
6466   TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
6467   TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
6468
6469   TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
6470   TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
6471   TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
6472   TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
6473   TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
6474   TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
6475 #endif
6476
6477   TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
6478   TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
6479   TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
6480   TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
6481   TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
6482
6483   TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
6484   TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
6485   TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
6486   TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
6487   TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
6488
6489 # if LDBL_MANT_DIG > 100
6490   TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
6491   TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
6492   TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
6493   TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
6494   TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
6495   TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
6496
6497   TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
6498   TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
6499   TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
6500   TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
6501   TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
6502   TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
6503 #endif
6504
6505   TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
6506   TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
6507   TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
6508   TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
6509   TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
6510
6511   TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
6512   TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
6513   TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
6514   TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
6515   TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
6516
6517 # if LDBL_MANT_DIG > 100
6518   TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
6519   TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
6520   TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
6521   TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
6522   TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
6523   TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
6524   TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
6525   TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
6526   TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
6527   TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
6528   TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
6529   TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
6530 # endif
6531 #endif
6532
6533   END (llrint);
6534 }
6535
6536 static void
6537 llrint_test_tonearest (void)
6538 {
6539   int save_round_mode;
6540   START (llrint_tonearest);
6541
6542   save_round_mode = fegetround ();
6543
6544   if (!fesetround (FE_TONEAREST))
6545     {
6546       TEST_f_L (llrint, 0.0, 0);
6547       TEST_f_L (llrint, minus_zero, 0);
6548       TEST_f_L (llrint, 0.2L, 0);
6549       TEST_f_L (llrint, -0.2L, 0);
6550
6551       TEST_f_L (llrint, 1.4L, 1);
6552       TEST_f_L (llrint, -1.4L, -1);
6553
6554       TEST_f_L (llrint, 8388600.3L, 8388600);
6555       TEST_f_L (llrint, -8388600.3L, -8388600);
6556
6557       TEST_f_l (llrint, 1071930.0008, 1071930);
6558
6559       /* Test boundary conditions.  */
6560       /* 0x1FFFFF */
6561       TEST_f_L (llrint, 2097151.0,2097151LL);
6562       /* 0x800000 */
6563       TEST_f_L (llrint, 8388608.0, 8388608LL);
6564       /* 0x1000000 */
6565       TEST_f_L (llrint, 16777216.0, 16777216LL);
6566       /* 0x20000000000 */
6567       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
6568       /* 0x40000000000 */
6569       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
6570       /* 0x1000000000000 */
6571       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
6572       /* 0x10000000000000 */
6573       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
6574       /* 0x10000080000000 */
6575       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
6576       /* 0x20000000000000 */
6577       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
6578       /* 0x80000000000000 */
6579       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
6580       /* 0x100000000000000 */
6581       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
6582 #ifdef TEST_LDOUBLE
6583       /* The input can only be represented in long double.  */
6584       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
6585       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
6586       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
6587       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
6588       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
6589
6590       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
6591       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
6592       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
6593       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
6594       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
6595
6596 # if LDBL_MANT_DIG > 100
6597       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
6598       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
6599       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
6600       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
6601       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
6602       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
6603
6604       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
6605       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
6606       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
6607       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
6608       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
6609       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
6610 #endif
6611
6612       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
6613       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
6614       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
6615       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
6616       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
6617
6618       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
6619       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
6620       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
6621       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
6622       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
6623
6624 # if LDBL_MANT_DIG > 100
6625       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
6626       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
6627       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
6628       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
6629       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
6630       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
6631
6632       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
6633       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
6634       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
6635       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
6636       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
6637       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
6638 #endif
6639
6640       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
6641       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
6642       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
6643       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
6644       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
6645
6646       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
6647       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
6648       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
6649       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
6650       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
6651
6652 # if LDBL_MANT_DIG > 100
6653       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
6654       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
6655       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
6656       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
6657       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
6658       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
6659       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
6660       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
6661       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
6662       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
6663       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
6664       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
6665 # endif
6666 #endif
6667     }
6668
6669   fesetround (save_round_mode);
6670
6671   END (llrint_tonearest);
6672 }
6673
6674 static void
6675 llrint_test_towardzero (void)
6676 {
6677   int save_round_mode;
6678   START (llrint_towardzero);
6679
6680   save_round_mode = fegetround ();
6681
6682   if (!fesetround (FE_TOWARDZERO))
6683     {
6684       TEST_f_L (llrint, 0.0, 0);
6685       TEST_f_L (llrint, minus_zero, 0);
6686       TEST_f_L (llrint, 0.2L, 0);
6687       TEST_f_L (llrint, -0.2L, 0);
6688
6689       TEST_f_L (llrint, 1.4L, 1);
6690       TEST_f_L (llrint, -1.4L, -1);
6691
6692       TEST_f_L (llrint, 8388600.3L, 8388600);
6693       TEST_f_L (llrint, -8388600.3L, -8388600);
6694
6695       TEST_f_l (llrint, 1071930.0008, 1071930);
6696
6697       /* Test boundary conditions.  */
6698       /* 0x1FFFFF */
6699       TEST_f_L (llrint, 2097151.0,2097151LL);
6700       /* 0x800000 */
6701       TEST_f_L (llrint, 8388608.0, 8388608LL);
6702       /* 0x1000000 */
6703       TEST_f_L (llrint, 16777216.0, 16777216LL);
6704       /* 0x20000000000 */
6705       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
6706       /* 0x40000000000 */
6707       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
6708       /* 0x1000000000000 */
6709       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
6710       /* 0x10000000000000 */
6711       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
6712       /* 0x10000080000000 */
6713       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
6714       /* 0x20000000000000 */
6715       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
6716       /* 0x80000000000000 */
6717       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
6718       /* 0x100000000000000 */
6719       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
6720 #ifdef TEST_LDOUBLE
6721       /* The input can only be represented in long double.  */
6722       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370495LL);
6723       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
6724       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
6725       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370496LL);
6726       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370497LL);
6727
6728       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370495LL);
6729       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
6730       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
6731       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370496LL);
6732       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370497LL);
6733
6734 # if LDBL_MANT_DIG > 100
6735       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
6736       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
6737       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
6738       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370494LL);
6739       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370495LL);
6740       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370496LL);
6741
6742       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
6743       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
6744       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
6745       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370494LL);
6746       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370495LL);
6747       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370496LL);
6748 #endif
6749
6750       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740991LL);
6751       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
6752       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
6753       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740992LL);
6754       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740993LL);
6755
6756       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740991LL);
6757       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
6758       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
6759       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740992LL);
6760       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740993LL);
6761
6762 # if LDBL_MANT_DIG > 100
6763       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
6764       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
6765       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
6766       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740991LL);
6767       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740992LL);
6768       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740993LL);
6769
6770       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
6771       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
6772       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
6773       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740991LL);
6774       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740992LL);
6775       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740993LL);
6776 #endif
6777
6778       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927935LL);
6779       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
6780       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
6781       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927936LL);
6782       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927937LL);
6783
6784       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927935LL);
6785       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
6786       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
6787       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927936LL);
6788       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927937LL);
6789
6790 # if LDBL_MANT_DIG > 100
6791       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775805LL);
6792       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775805LL);
6793       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
6794       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
6795       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
6796       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
6797       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
6798       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
6799       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775806LL);
6800       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775806LL);
6801       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
6802       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
6803 # endif
6804 #endif
6805     }
6806
6807   fesetround (save_round_mode);
6808
6809   END (llrint_towardzero);
6810 }
6811
6812 static void
6813 llrint_test_downward (void)
6814 {
6815   int save_round_mode;
6816   START (llrint_downward);
6817
6818   save_round_mode = fegetround ();
6819
6820   if (!fesetround (FE_DOWNWARD))
6821     {
6822       TEST_f_L (llrint, 0.0, 0);
6823       TEST_f_L (llrint, minus_zero, 0);
6824       TEST_f_L (llrint, 0.2L, 0);
6825       TEST_f_L (llrint, -0.2L, -1);
6826
6827       TEST_f_L (llrint, 1.4L, 1);
6828       TEST_f_L (llrint, -1.4L, -2);
6829
6830       TEST_f_L (llrint, 8388600.3L, 8388600);
6831       TEST_f_L (llrint, -8388600.3L, -8388601);
6832
6833       TEST_f_l (llrint, 1071930.0008, 1071930);
6834
6835       /* Test boundary conditions.  */
6836       /* 0x1FFFFF */
6837       TEST_f_L (llrint, 2097151.0,2097151LL);
6838       /* 0x800000 */
6839       TEST_f_L (llrint, 8388608.0, 8388608LL);
6840       /* 0x1000000 */
6841       TEST_f_L (llrint, 16777216.0, 16777216LL);
6842       /* 0x20000000000 */
6843       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
6844       /* 0x40000000000 */
6845       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
6846       /* 0x1000000000000 */
6847       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
6848       /* 0x10000000000000 */
6849       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
6850       /* 0x10000080000000 */
6851       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
6852       /* 0x20000000000000 */
6853       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
6854       /* 0x80000000000000 */
6855       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
6856       /* 0x100000000000000 */
6857       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
6858 #ifdef TEST_LDOUBLE
6859       /* The input can only be represented in long double.  */
6860       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370495LL);
6861       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
6862       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
6863       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370496LL);
6864       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370497LL);
6865
6866       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
6867       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
6868       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
6869       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370494LL);
6870       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370495LL);
6871       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370496LL);
6872
6873       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
6874       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370497LL);
6875       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370497LL);
6876       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
6877       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
6878
6879       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370496LL);
6880       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370497LL);
6881       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370498LL);
6882       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
6883       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
6884       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
6885
6886       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740991LL);
6887       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
6888       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
6889       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740992LL);
6890       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740993LL);
6891
6892       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
6893       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
6894       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
6895       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740991LL);
6896       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740992LL);
6897       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740993LL);
6898
6899       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
6900       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740993LL);
6901       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740993LL);
6902       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
6903       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
6904
6905       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740992LL);
6906       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740993LL);
6907       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740994LL);
6908       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
6909       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
6910       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
6911
6912       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927935LL);
6913       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
6914       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
6915       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927936LL);
6916       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927937LL);
6917
6918       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
6919       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927937LL);
6920       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927937LL);
6921       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
6922       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
6923
6924 # if LDBL_MANT_DIG > 100
6925       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775805LL);
6926       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
6927       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
6928       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
6929       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
6930       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775807LL);
6931       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
6932       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775807LL);
6933       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775806LL);
6934       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
6935       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
6936       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
6937 # endif
6938 #endif
6939     }
6940
6941   fesetround (save_round_mode);
6942
6943   END (llrint_downward);
6944 }
6945
6946 static void
6947 llrint_test_upward (void)
6948 {
6949   int save_round_mode;
6950   START (llrint_upward);
6951
6952   save_round_mode = fegetround ();
6953
6954   if (!fesetround (FE_UPWARD))
6955     {
6956       TEST_f_L (llrint, 0.0, 0);
6957       TEST_f_L (llrint, minus_zero, 0);
6958       TEST_f_L (llrint, 0.2L, 1);
6959       TEST_f_L (llrint, -0.2L, 0);
6960
6961       TEST_f_L (llrint, 1.4L, 2);
6962       TEST_f_L (llrint, -1.4L, -1);
6963
6964       TEST_f_L (llrint, 8388600.3L, 8388601);
6965       TEST_f_L (llrint, -8388600.3L, -8388600);
6966 #ifndef TEST_FLOAT
6967       TEST_f_l (llrint, 1071930.0008, 1071931);
6968 #endif
6969       /* Test boundary conditions.  */
6970       /* 0x1FFFFF */
6971       TEST_f_L (llrint, 2097151.0,2097151LL);
6972       /* 0x800000 */
6973       TEST_f_L (llrint, 8388608.0, 8388608LL);
6974       /* 0x1000000 */
6975       TEST_f_L (llrint, 16777216.0, 16777216LL);
6976       /* 0x20000000000 */
6977       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
6978       /* 0x40000000000 */
6979       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
6980       /* 0x1000000000000 */
6981       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
6982       /* 0x10000000000000 */
6983       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
6984       /* 0x10000080000000 */
6985       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
6986       /* 0x20000000000000 */
6987       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
6988       /* 0x80000000000000 */
6989       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
6990       /* 0x100000000000000 */
6991       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
6992 #ifdef TEST_LDOUBLE
6993       /* The input can only be represented in long double.  */
6994       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
6995       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370497LL);
6996       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370497LL);
6997       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
6998       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
6999
7000       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370496LL);
7001       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370497LL);
7002       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370498LL);
7003       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
7004       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
7005       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
7006
7007       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370495LL);
7008       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
7009       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
7010       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370496LL);
7011       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370497LL);
7012
7013       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
7014       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
7015       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
7016       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370494LL);
7017       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370495LL);
7018       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370496LL);
7019
7020       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
7021       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740993LL);
7022       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740993LL);
7023       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
7024       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
7025
7026       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740992LL);
7027       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740993LL);
7028       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740994LL);
7029       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
7030       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
7031       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
7032
7033       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740991LL);
7034       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
7035       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
7036       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740992LL);
7037       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740993LL);
7038
7039       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
7040       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
7041       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
7042       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740991LL);
7043       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740992LL);
7044       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740993LL);
7045
7046       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
7047       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927937LL);
7048       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927937LL);
7049       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
7050       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
7051
7052       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927935LL);
7053       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
7054       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
7055       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927936LL);
7056       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927937LL);
7057
7058 # if LDBL_MANT_DIG > 100
7059       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
7060       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775805LL);
7061       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
7062       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
7063       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775807LL);
7064       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
7065       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775807L);
7066       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
7067       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
7068       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775806LL);
7069       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
7070       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
7071 # endif
7072 #endif
7073     }
7074
7075   fesetround (save_round_mode);
7076
7077   END (llrint_upward);
7078 }
7079
7080
7081 static void
7082 log_test (void)
7083 {
7084   errno = 0;
7085   FUNC(log) (1);
7086   if (errno == ENOSYS)
7087     /* Function not implemented.  */
7088     return;
7089   START (log);
7090
7091   TEST_f_f (log, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7092   TEST_f_f (log, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7093
7094   TEST_f_f (log, 1, 0);
7095
7096   TEST_f_f (log, -1, nan_value, INVALID_EXCEPTION);
7097   TEST_f_f (log, -max_value, nan_value, INVALID_EXCEPTION);
7098   TEST_f_f (log, minus_infty, nan_value, INVALID_EXCEPTION);
7099   TEST_f_f (log, plus_infty, plus_infty);
7100   TEST_f_f (log, nan_value, nan_value);
7101
7102   TEST_f_f (log, M_El, 1);
7103   TEST_f_f (log, 1.0 / M_El, -1);
7104   TEST_f_f (log, 2, M_LN2l);
7105   TEST_f_f (log, 10, M_LN10l);
7106   TEST_f_f (log, 0.75L, -0.287682072451780927439219005993827432L);
7107
7108   END (log);
7109 }
7110
7111
7112 static void
7113 log10_test (void)
7114 {
7115   errno = 0;
7116   FUNC(log10) (1);
7117   if (errno == ENOSYS)
7118     /* Function not implemented.  */
7119     return;
7120
7121   START (log10);
7122
7123   TEST_f_f (log10, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7124   TEST_f_f (log10, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7125
7126   TEST_f_f (log10, 1, 0);
7127
7128   /* log10 (x) == NaN plus invalid exception if x < 0.  */
7129   TEST_f_f (log10, -1, nan_value, INVALID_EXCEPTION);
7130   TEST_f_f (log10, -max_value, nan_value, INVALID_EXCEPTION);
7131   TEST_f_f (log10, minus_infty, nan_value, INVALID_EXCEPTION);
7132
7133   TEST_f_f (log10, plus_infty, plus_infty);
7134   TEST_f_f (log10, nan_value, nan_value);
7135
7136   TEST_f_f (log10, 0.1L, -1);
7137   TEST_f_f (log10, 10.0, 1);
7138   TEST_f_f (log10, 100.0, 2);
7139   TEST_f_f (log10, 10000.0, 4);
7140   TEST_f_f (log10, M_El, M_LOG10El);
7141   TEST_f_f (log10, 0.75L, -0.124938736608299953132449886193870744L);
7142
7143   END (log10);
7144 }
7145
7146
7147 static void
7148 log1p_test (void)
7149 {
7150   errno = 0;
7151   FUNC(log1p) (0);
7152   if (errno == ENOSYS)
7153     /* Function not implemented.  */
7154     return;
7155
7156   START (log1p);
7157
7158   TEST_f_f (log1p, 0, 0);
7159   TEST_f_f (log1p, minus_zero, minus_zero);
7160
7161   TEST_f_f (log1p, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7162   TEST_f_f (log1p, -2, nan_value, INVALID_EXCEPTION);
7163   TEST_f_f (log1p, -max_value, nan_value, INVALID_EXCEPTION);
7164   TEST_f_f (log1p, minus_infty, nan_value, INVALID_EXCEPTION);
7165
7166   TEST_f_f (log1p, plus_infty, plus_infty);
7167   TEST_f_f (log1p, nan_value, nan_value);
7168
7169   TEST_f_f (log1p, M_El - 1.0, 1);
7170
7171   TEST_f_f (log1p, -0.25L, -0.287682072451780927439219005993827432L);
7172   TEST_f_f (log1p, -0.875, -2.07944154167983592825169636437452970L);
7173
7174   END (log1p);
7175 }
7176
7177
7178 static void
7179 log2_test (void)
7180 {
7181   errno = 0;
7182   FUNC(log2) (1);
7183   if (errno == ENOSYS)
7184     /* Function not implemented.  */
7185     return;
7186
7187   START (log2);
7188
7189   TEST_f_f (log2, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7190   TEST_f_f (log2, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7191
7192   TEST_f_f (log2, 1, 0);
7193
7194   TEST_f_f (log2, -1, nan_value, INVALID_EXCEPTION);
7195   TEST_f_f (log2, -max_value, nan_value, INVALID_EXCEPTION);
7196   TEST_f_f (log2, minus_infty, nan_value, INVALID_EXCEPTION);
7197
7198   TEST_f_f (log2, plus_infty, plus_infty);
7199   TEST_f_f (log2, nan_value, nan_value);
7200
7201   TEST_f_f (log2, M_El, M_LOG2El);
7202   TEST_f_f (log2, 2.0, 1);
7203   TEST_f_f (log2, 16.0, 4);
7204   TEST_f_f (log2, 256.0, 8);
7205   TEST_f_f (log2, 0.75L, -.415037499278843818546261056052183492L);
7206
7207   END (log2);
7208 }
7209
7210
7211 static void
7212 logb_test (void)
7213 {
7214   START (logb);
7215
7216   TEST_f_f (logb, plus_infty, plus_infty);
7217   TEST_f_f (logb, minus_infty, plus_infty);
7218
7219   TEST_f_f (logb, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7220
7221   TEST_f_f (logb, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7222   TEST_f_f (logb, nan_value, nan_value);
7223
7224   TEST_f_f (logb, 1, 0);
7225   TEST_f_f (logb, M_El, 1);
7226   TEST_f_f (logb, 1024, 10);
7227   TEST_f_f (logb, -2000, 10);
7228
7229   TEST_f_f (logb, 0x0.1p-127, -131);
7230   TEST_f_f (logb, 0x0.01p-127, -135);
7231   TEST_f_f (logb, 0x0.011p-127, -135);
7232 #ifndef TEST_FLOAT
7233   TEST_f_f (logb, 0x0.8p-1022, -1023);
7234   TEST_f_f (logb, 0x0.1p-1022, -1026);
7235   TEST_f_f (logb, 0x0.00111p-1022, -1034);
7236   TEST_f_f (logb, 0x0.00001p-1022, -1042);
7237   TEST_f_f (logb, 0x0.000011p-1022, -1042);
7238   TEST_f_f (logb, 0x0.0000000000001p-1022, -1074);
7239 #endif
7240 #if defined TEST_LDOUBLE && LDBL_MIN_EXP - LDBL_MANT_DIG <= -16400
7241   TEST_f_f (logb, 0x1p-16400L, -16400);
7242   TEST_f_f (logb, 0x.00000000001p-16382L, -16426);
7243 #endif
7244
7245   END (logb);
7246 }
7247
7248 static void
7249 logb_test_downward (void)
7250 {
7251   int save_round_mode;
7252   errno = 0;
7253
7254   FUNC(logb) (0);
7255   if (errno == ENOSYS)
7256     /* Function not implemented.  */
7257     return;
7258
7259   START (logb_downward);
7260
7261   save_round_mode = fegetround ();
7262
7263   if (!fesetround (FE_DOWNWARD))
7264     {
7265
7266       /* IEEE 754-2008 says (section 5.3.3) that "logB(1) is +0.".  Libm
7267          should not return -0 from logb in any rounding mode.  PowerPC32 has
7268          failed with this test for power4 logb (and logbl on all PowerPC
7269          platforms) in the past due to instruction selection.  GCC PR 52775
7270          provides the availability of the fcfid insn in 32-bit mode which
7271          eliminates the use of fsub in this instance and prevents the negative
7272          signed 0.0.  */
7273
7274       /* BZ #887  */
7275       TEST_f_f (logb, 1.000e+0, plus_zero);
7276     }
7277
7278   fesetround (save_round_mode);
7279
7280   END (logb_downward);
7281 }
7282
7283 static void
7284 lround_test (void)
7285 {
7286   START (lround);
7287
7288   TEST_f_l (lround, 0, 0);
7289   TEST_f_l (lround, minus_zero, 0);
7290   TEST_f_l (lround, 0.2L, 0.0);
7291   TEST_f_l (lround, -0.2L, 0);
7292   TEST_f_l (lround, 0.5, 1);
7293   TEST_f_l (lround, -0.5, -1);
7294   TEST_f_l (lround, 0.8L, 1);
7295   TEST_f_l (lround, -0.8L, -1);
7296   TEST_f_l (lround, 1.5, 2);
7297   TEST_f_l (lround, -1.5, -2);
7298   TEST_f_l (lround, 22514.5, 22515);
7299   TEST_f_l (lround, -22514.5, -22515);
7300   TEST_f_l (lround, 1071930.0008, 1071930);
7301 #ifndef TEST_FLOAT
7302   TEST_f_l (lround, 1073741824.01, 1073741824);
7303 # if LONG_MAX > 281474976710656
7304   TEST_f_l (lround, 281474976710656.025, 281474976710656);
7305   TEST_f_l (lround, 18014398509481974, 18014398509481974);
7306 # endif
7307   TEST_f_l (lround, 2097152.5, 2097153);
7308   TEST_f_l (lround, -2097152.5, -2097153);
7309   /* nextafter(0.5,-1)  */
7310   TEST_f_l (lround, 0x1.fffffffffffffp-2, 0);
7311   /* nextafter(-0.5,1)  */
7312   TEST_f_l (lround, -0x1.fffffffffffffp-2, 0);
7313 #else
7314   /* nextafter(0.5,-1)  */
7315   TEST_f_l (lround, 0x1.fffffp-2, 0);
7316   /* nextafter(-0.5,1)  */
7317   TEST_f_l (lround, -0x1.fffffp-2, 0);
7318   TEST_f_l (lround, 0x1.fffffep+23, 16777215);
7319   TEST_f_l (lround, -0x1.fffffep+23, -16777215);
7320 #endif
7321   END (lround);
7322 }
7323
7324
7325 static void
7326 llround_test (void)
7327 {
7328   START (llround);
7329
7330   TEST_f_L (llround, 0, 0);
7331   TEST_f_L (llround, minus_zero, 0);
7332   TEST_f_L (llround, 0.2L, 0.0);
7333   TEST_f_L (llround, -0.2L, 0);
7334   TEST_f_L (llround, 0.5, 1);
7335   TEST_f_L (llround, -0.5, -1);
7336   TEST_f_L (llround, 0.8L, 1);
7337   TEST_f_L (llround, -0.8L, -1);
7338   TEST_f_L (llround, 1.5, 2);
7339   TEST_f_L (llround, -1.5, -2);
7340   TEST_f_L (llround, 22514.5, 22515);
7341   TEST_f_L (llround, -22514.5, -22515);
7342   TEST_f_l (llround, 1071930.0008, 1071930);
7343 #ifndef TEST_FLOAT
7344   TEST_f_L (llround, 2097152.5, 2097153);
7345   TEST_f_L (llround, -2097152.5, -2097153);
7346   TEST_f_L (llround, 34359738368.5, 34359738369ll);
7347   TEST_f_L (llround, -34359738368.5, -34359738369ll);
7348   TEST_f_L (llround, -3.65309740835E17, -365309740835000000LL);
7349 #endif
7350
7351   /* Test boundary conditions.  */
7352   /* 0x1FFFFF */
7353   TEST_f_L (llround, 2097151.0, 2097151LL);
7354   /* 0x800000 */
7355   TEST_f_L (llround, 8388608.0, 8388608LL);
7356   /* 0x1000000 */
7357   TEST_f_L (llround, 16777216.0, 16777216LL);
7358   /* 0x20000000000 */
7359   TEST_f_L (llround, 2199023255552.0, 2199023255552LL);
7360   /* 0x40000000000 */
7361   TEST_f_L (llround, 4398046511104.0, 4398046511104LL);
7362   /* 0x1000000000000 */
7363   TEST_f_L (llround, 281474976710656.0, 281474976710656LL);
7364   /* 0x10000000000000 */
7365   TEST_f_L (llround, 4503599627370496.0, 4503599627370496LL);
7366   /* 0x10000080000000 */
7367   TEST_f_L (llround, 4503601774854144.0, 4503601774854144LL);
7368   /* 0x20000000000000 */
7369   TEST_f_L (llround, 9007199254740992.0, 9007199254740992LL);
7370   /* 0x80000000000000 */
7371   TEST_f_L (llround, 36028797018963968.0, 36028797018963968LL);
7372   /* 0x100000000000000 */
7373   TEST_f_L (llround, 72057594037927936.0, 72057594037927936LL);
7374
7375 #ifndef TEST_FLOAT
7376   /* 0x100000000 */
7377   TEST_f_L (llround, 4294967295.5, 4294967296LL);
7378   /* 0x200000000 */
7379   TEST_f_L (llround, 8589934591.5, 8589934592LL);
7380
7381   /* nextafter(0.5,-1)  */
7382   TEST_f_L (llround, 0x1.fffffffffffffp-2, 0);
7383   /* nextafter(-0.5,1)  */
7384   TEST_f_L (llround, -0x1.fffffffffffffp-2, 0);
7385   /* On PowerPC an exponent of '52' is the largest incrementally
7386    * representable sequence of whole-numbers in the 'double' range.  We test
7387    * lround to make sure that a guard bit set during the lround operation
7388    * hasn't forced an erroneous shift giving us an incorrect result.  The odd
7389    * numbers between +-(2^52+1 and 2^53-1) are affected since they have the
7390    * rightmost bit set.  */
7391   /* +-(2^52+1)  */
7392   TEST_f_L (llround, 0x1.0000000000001p+52,4503599627370497LL);
7393   TEST_f_L (llround, -0x1.0000000000001p+52,-4503599627370497LL);
7394   /* +-(2^53-1): Input is the last (positive and negative) incrementally
7395    * representable whole-number in the 'double' range that might round
7396    * erroneously.  */
7397   TEST_f_L (llround, 0x1.fffffffffffffp+52, 9007199254740991LL);
7398   TEST_f_L (llround, -0x1.fffffffffffffp+52, -9007199254740991LL);
7399 #else
7400   /* nextafter(0.5,-1)  */
7401   TEST_f_L (llround, 0x1.fffffep-2, 0);
7402   /* nextafter(-0.5,1)  */
7403   TEST_f_L (llround, -0x1.fffffep-2, 0);
7404   /* As above, on PowerPC an exponent of '23' is the largest incrementally
7405    * representable sequence of whole-numbers in the 'float' range.
7406    * Likewise, numbers between +-(2^23+1 and 2^24-1) are affected.  */
7407   TEST_f_L (llround, 0x1.000002p+23,8388609);
7408   TEST_f_L (llround, -0x1.000002p+23,-8388609);
7409   TEST_f_L (llround, 0x1.fffffep+23, 16777215);
7410   TEST_f_L (llround, -0x1.fffffep+23, -16777215);
7411 #endif
7412
7413
7414 #ifdef TEST_LDOUBLE
7415   /* The input can only be represented in long double.  */
7416   TEST_f_L (llround, 4503599627370495.5L, 4503599627370496LL);
7417   TEST_f_L (llround, 4503599627370496.25L, 4503599627370496LL);
7418   TEST_f_L (llround, 4503599627370496.5L, 4503599627370497LL);
7419   TEST_f_L (llround, 4503599627370496.75L, 4503599627370497LL);
7420   TEST_f_L (llround, 4503599627370497.5L, 4503599627370498LL);
7421
7422 # if LDBL_MANT_DIG > 100
7423   TEST_f_L (llround, 4503599627370495.4999999999999L, 4503599627370495LL);
7424   TEST_f_L (llround, 4503599627370496.4999999999999L, 4503599627370496LL);
7425   TEST_f_L (llround, 4503599627370497.4999999999999L, 4503599627370497LL);
7426   TEST_f_L (llround, 4503599627370494.5000000000001L, 4503599627370495LL);
7427   TEST_f_L (llround, 4503599627370495.5000000000001L, 4503599627370496LL);
7428   TEST_f_L (llround, 4503599627370496.5000000000001L, 4503599627370497LL);
7429
7430   TEST_f_L (llround, -4503599627370495.4999999999999L, -4503599627370495LL);
7431   TEST_f_L (llround, -4503599627370496.4999999999999L, -4503599627370496LL);
7432   TEST_f_L (llround, -4503599627370497.4999999999999L, -4503599627370497LL);
7433   TEST_f_L (llround, -4503599627370494.5000000000001L, -4503599627370495LL);
7434   TEST_f_L (llround, -4503599627370495.5000000000001L, -4503599627370496LL);
7435   TEST_f_L (llround, -4503599627370496.5000000000001L, -4503599627370497LL);
7436 # endif
7437
7438   TEST_f_L (llround, -4503599627370495.5L, -4503599627370496LL);
7439   TEST_f_L (llround, -4503599627370496.25L, -4503599627370496LL);
7440   TEST_f_L (llround, -4503599627370496.5L, -4503599627370497LL);
7441   TEST_f_L (llround, -4503599627370496.75L, -4503599627370497LL);
7442   TEST_f_L (llround, -4503599627370497.5L, -4503599627370498LL);
7443
7444   TEST_f_L (llround, 9007199254740991.5L, 9007199254740992LL);
7445   TEST_f_L (llround, 9007199254740992.25L, 9007199254740992LL);
7446   TEST_f_L (llround, 9007199254740992.5L, 9007199254740993LL);
7447   TEST_f_L (llround, 9007199254740992.75L, 9007199254740993LL);
7448   TEST_f_L (llround, 9007199254740993.5L, 9007199254740994LL);
7449
7450 # if LDBL_MANT_DIG > 100
7451   TEST_f_L (llround, 9007199254740991.4999999999999L, 9007199254740991LL);
7452   TEST_f_L (llround, 9007199254740992.4999999999999L, 9007199254740992LL);
7453   TEST_f_L (llround, 9007199254740993.4999999999999L, 9007199254740993LL);
7454   TEST_f_L (llround, 9007199254740991.5000000000001L, 9007199254740992LL);
7455   TEST_f_L (llround, 9007199254740992.5000000000001L, 9007199254740993LL);
7456   TEST_f_L (llround, 9007199254740993.5000000000001L, 9007199254740994LL);
7457
7458   TEST_f_L (llround, -9007199254740991.4999999999999L, -9007199254740991LL);
7459   TEST_f_L (llround, -9007199254740992.4999999999999L, -9007199254740992LL);
7460   TEST_f_L (llround, -9007199254740993.4999999999999L, -9007199254740993LL);
7461   TEST_f_L (llround, -9007199254740991.5000000000001L, -9007199254740992LL);
7462   TEST_f_L (llround, -9007199254740992.5000000000001L, -9007199254740993LL);
7463   TEST_f_L (llround, -9007199254740993.5000000000001L, -9007199254740994LL);
7464 # endif
7465
7466   TEST_f_L (llround, -9007199254740991.5L, -9007199254740992LL);
7467   TEST_f_L (llround, -9007199254740992.25L, -9007199254740992LL);
7468   TEST_f_L (llround, -9007199254740992.5L, -9007199254740993LL);
7469   TEST_f_L (llround, -9007199254740992.75L, -9007199254740993LL);
7470   TEST_f_L (llround, -9007199254740993.5L, -9007199254740994LL);
7471
7472   TEST_f_L (llround, 72057594037927935.5L, 72057594037927936LL);
7473   TEST_f_L (llround, 72057594037927936.25L, 72057594037927936LL);
7474   TEST_f_L (llround, 72057594037927936.5L, 72057594037927937LL);
7475   TEST_f_L (llround, 72057594037927936.75L, 72057594037927937LL);
7476   TEST_f_L (llround, 72057594037927937.5L, 72057594037927938LL);
7477
7478   TEST_f_L (llround, -72057594037927935.5L, -72057594037927936LL);
7479   TEST_f_L (llround, -72057594037927936.25L, -72057594037927936LL);
7480   TEST_f_L (llround, -72057594037927936.5L, -72057594037927937LL);
7481   TEST_f_L (llround, -72057594037927936.75L, -72057594037927937LL);
7482   TEST_f_L (llround, -72057594037927937.5L, -72057594037927938LL);
7483
7484   TEST_f_L (llround, 9223372036854775806.25L, 9223372036854775806LL);
7485   TEST_f_L (llround, -9223372036854775806.25L, -9223372036854775806LL);
7486   TEST_f_L (llround, 9223372036854775806.5L, 9223372036854775807LL);
7487   TEST_f_L (llround, -9223372036854775806.5L, -9223372036854775807LL);
7488   TEST_f_L (llround, 9223372036854775807.0L, 9223372036854775807LL);
7489   TEST_f_L (llround, -9223372036854775807.0L, -9223372036854775807LL);
7490 #endif
7491
7492   END (llround);
7493 }
7494
7495 static void
7496 modf_test (void)
7497 {
7498   FLOAT x;
7499
7500   START (modf);
7501
7502   TEST_fF_f1 (modf, plus_infty, 0, plus_infty);
7503   TEST_fF_f1 (modf, minus_infty, minus_zero, minus_infty);
7504   TEST_fF_f1 (modf, nan_value, nan_value, nan_value);
7505   TEST_fF_f1 (modf, 0, 0, 0);
7506   TEST_fF_f1 (modf, 1.5, 0.5, 1);
7507   TEST_fF_f1 (modf, 2.5, 0.5, 2);
7508   TEST_fF_f1 (modf, -2.5, -0.5, -2);
7509   TEST_fF_f1 (modf, 20, 0, 20);
7510   TEST_fF_f1 (modf, 21, 0, 21);
7511   TEST_fF_f1 (modf, 89.5, 0.5, 89);
7512
7513   END (modf);
7514 }
7515
7516
7517 static void
7518 nearbyint_test (void)
7519 {
7520   START (nearbyint);
7521
7522   TEST_f_f (nearbyint, 0.0, 0.0);
7523   TEST_f_f (nearbyint, minus_zero, minus_zero);
7524   TEST_f_f (nearbyint, plus_infty, plus_infty);
7525   TEST_f_f (nearbyint, minus_infty, minus_infty);
7526   TEST_f_f (nearbyint, nan_value, nan_value);
7527
7528   /* Subnormal values */
7529   TEST_f_f (nearbyint, -8.98847e+307, -8.98847e+307);
7530   TEST_f_f (nearbyint, -4.45015e-308, minus_zero);
7531
7532   /* Default rounding mode is round to nearest.  */
7533   TEST_f_f (nearbyint, 0.5, 0.0);
7534   TEST_f_f (nearbyint, 1.5, 2.0);
7535   TEST_f_f (nearbyint, -0.5, minus_zero);
7536   TEST_f_f (nearbyint, -1.5, -2.0);
7537
7538   TEST_f_f (nearbyint, 262144.75, 262145.0);
7539   TEST_f_f (nearbyint, 262142.75, 262143.0);
7540   TEST_f_f (nearbyint, 524286.75, 524287.0);
7541   TEST_f_f (nearbyint, 524288.75, 524289.0);
7542
7543   TEST_f_f (nearbyint, 1048576.75, 1048577.0);
7544   TEST_f_f (nearbyint, 2097152.75, 2097153.0);
7545   TEST_f_f (nearbyint, 2492472.75, 2492473.0);
7546   TEST_f_f (nearbyint, 2886220.75, 2886221.0);
7547   TEST_f_f (nearbyint, 3058792.75, 3058793.0);
7548   TEST_f_f (nearbyint, -1048576.75, -1048577.0);
7549   TEST_f_f (nearbyint, -2097152.75, -2097153.0);
7550   TEST_f_f (nearbyint, -2492472.75, -2492473.0);
7551   TEST_f_f (nearbyint, -2886220.75, -2886221.0);
7552   TEST_f_f (nearbyint, -3058792.75, -3058793.0);
7553 #ifndef TEST_FLOAT
7554   TEST_f_f (nearbyint, 70368744177664.75, 70368744177665.0);
7555   TEST_f_f (nearbyint, 140737488355328.75, 140737488355329.0);
7556   TEST_f_f (nearbyint, 281474976710656.75, 281474976710657.0);
7557   TEST_f_f (nearbyint, 562949953421312.75, 562949953421313.0);
7558   TEST_f_f (nearbyint, 1125899906842624.75, 1125899906842625.0);
7559   TEST_f_f (nearbyint, -70368744177664.75, -70368744177665.0);
7560   TEST_f_f (nearbyint, -140737488355328.75, -140737488355329.0);
7561   TEST_f_f (nearbyint, -281474976710656.75, -281474976710657.0);
7562   TEST_f_f (nearbyint, -562949953421312.75, -562949953421313.0);
7563   TEST_f_f (nearbyint, -1125899906842624.75, -1125899906842625.0);
7564 #endif
7565
7566   END (nearbyint);
7567 }
7568
7569 static void
7570 nextafter_test (void)
7571 {
7572
7573   START (nextafter);
7574
7575   TEST_ff_f (nextafter, 0, 0, 0);
7576   TEST_ff_f (nextafter, minus_zero, 0, 0);
7577   TEST_ff_f (nextafter, 0, minus_zero, minus_zero);
7578   TEST_ff_f (nextafter, minus_zero, minus_zero, minus_zero);
7579
7580   TEST_ff_f (nextafter, 9, 9, 9);
7581   TEST_ff_f (nextafter, -9, -9, -9);
7582   TEST_ff_f (nextafter, plus_infty, plus_infty, plus_infty);
7583   TEST_ff_f (nextafter, minus_infty, minus_infty, minus_infty);
7584
7585   TEST_ff_f (nextafter, nan_value, 1.1L, nan_value);
7586   TEST_ff_f (nextafter, 1.1L, nan_value, nan_value);
7587   TEST_ff_f (nextafter, nan_value, nan_value, nan_value);
7588
7589   FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
7590                          LDBL_MAX, DBL_MAX, FLT_MAX);
7591   TEST_ff_f (nextafter, fltmax, plus_infty, plus_infty, OVERFLOW_EXCEPTION);
7592   TEST_ff_f (nextafter, -fltmax, minus_infty, minus_infty, OVERFLOW_EXCEPTION);
7593
7594 #ifdef TEST_LDOUBLE
7595   // XXX Enable once gcc is fixed.
7596   //TEST_ff_f (nextafter, 0x0.00000040000000000000p-16385L, -0.1L, 0x0.0000003ffffffff00000p-16385L);
7597 #endif
7598
7599   /* XXX We need the hexadecimal FP number representation here for further
7600      tests.  */
7601
7602   END (nextafter);
7603 }
7604
7605
7606 static void
7607 nexttoward_test (void)
7608 {
7609   START (nexttoward);
7610   TEST_ff_f (nexttoward, 0, 0, 0);
7611   TEST_ff_f (nexttoward, minus_zero, 0, 0);
7612   TEST_ff_f (nexttoward, 0, minus_zero, minus_zero);
7613   TEST_ff_f (nexttoward, minus_zero, minus_zero, minus_zero);
7614
7615   TEST_ff_f (nexttoward, 9, 9, 9);
7616   TEST_ff_f (nexttoward, -9, -9, -9);
7617   TEST_ff_f (nexttoward, plus_infty, plus_infty, plus_infty);
7618   TEST_ff_f (nexttoward, minus_infty, minus_infty, minus_infty);
7619
7620   TEST_ff_f (nexttoward, nan_value, 1.1L, nan_value);
7621   TEST_ff_f (nexttoward, 1.1L, nan_value, nan_value);
7622   TEST_ff_f (nexttoward, nan_value, nan_value, nan_value);
7623
7624 #ifdef TEST_FLOAT
7625   TEST_ff_f (nexttoward, 1.0, 1.1L, 0x1.000002p0);
7626   TEST_ff_f (nexttoward, 1.0, LDBL_MAX, 0x1.000002p0);
7627   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000001p0, 0x1.000002p0);
7628   TEST_ff_f (nexttoward, 1.0, 0.9L, 0x0.ffffffp0);
7629   TEST_ff_f (nexttoward, 1.0, -LDBL_MAX, 0x0.ffffffp0);
7630   TEST_ff_f (nexttoward, 1.0, 0x0.fffffffffffff8p0, 0x0.ffffffp0);
7631   TEST_ff_f (nexttoward, -1.0, -1.1L, -0x1.000002p0);
7632   TEST_ff_f (nexttoward, -1.0, -LDBL_MAX, -0x1.000002p0);
7633   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000001p0, -0x1.000002p0);
7634   TEST_ff_f (nexttoward, -1.0, -0.9L, -0x0.ffffffp0);
7635   TEST_ff_f (nexttoward, -1.0, LDBL_MAX, -0x0.ffffffp0);
7636   TEST_ff_f (nexttoward, -1.0, -0x0.fffffffffffff8p0, -0x0.ffffffp0);
7637   TEST_ff_f (nexttoward, -0x1.3p-145, -0xap-148L, -0x1.4p-145, UNDERFLOW_EXCEPTION);
7638 # if LDBL_MANT_DIG >= 64
7639   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000002p0L, 0x1.000002p0);
7640   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffp0L, 0x0.ffffffp0);
7641   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000002p0L, -0x1.000002p0);
7642   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffp0L, -0x0.ffffffp0);
7643 # endif
7644 # if LDBL_MANT_DIG >= 106
7645   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000000000000000008p0L, 0x1.000002p0);
7646   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffcp0L, 0x0.ffffffp0);
7647   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000000000000000008p0L, -0x1.000002p0);
7648   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffcp0L, -0x0.ffffffp0);
7649 # endif
7650 # if LDBL_MANT_DIG >= 113
7651   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000000000000000000001p0L, 0x1.000002p0);
7652   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffp0);
7653   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000000000000000000001p0L, -0x1.000002p0);
7654   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffp0);
7655 # endif
7656 #endif
7657 #ifdef TEST_DOUBLE
7658   TEST_ff_f (nexttoward, 1.0, 1.1L, 0x1.0000000000001p0);
7659   TEST_ff_f (nexttoward, 1.0, LDBL_MAX, 0x1.0000000000001p0);
7660   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000001p0, 0x1.0000000000001p0);
7661   TEST_ff_f (nexttoward, 1.0, 0.9L, 0x0.fffffffffffff8p0);
7662   TEST_ff_f (nexttoward, 1.0, -LDBL_MAX, 0x0.fffffffffffff8p0);
7663   TEST_ff_f (nexttoward, 1.0, 0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0);
7664   TEST_ff_f (nexttoward, -1.0, -1.1L, -0x1.0000000000001p0);
7665   TEST_ff_f (nexttoward, -1.0, -LDBL_MAX, -0x1.0000000000001p0);
7666   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000001p0, -0x1.0000000000001p0);
7667   TEST_ff_f (nexttoward, -1.0, -0.9L, -0x0.fffffffffffff8p0);
7668   TEST_ff_f (nexttoward, -1.0, LDBL_MAX, -0x0.fffffffffffff8p0);
7669   TEST_ff_f (nexttoward, -1.0, -0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0);
7670   TEST_ff_f (nexttoward, -1.0, -0x8.00346dc5d6388p-3L, -0x1.0000000000001p0);
7671   TEST_ff_f (nexttoward, 0x1p-1074, 0x1p-1073L, 0x1p-1073, UNDERFLOW_EXCEPTION);
7672 # if LDBL_MANT_DIG >= 64
7673   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000002p0L, 0x1.0000000000001p0);
7674   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffp0L, 0x0.fffffffffffff8p0);
7675   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000002p0L, -0x1.0000000000001p0);
7676   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffp0L, -0x0.fffffffffffff8p0);
7677 # endif
7678 # if LDBL_MANT_DIG >= 106
7679   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000000000000000008p0L, 0x1.0000000000001p0);
7680   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffcp0L, 0x0.fffffffffffff8p0);
7681   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000000000000000008p0L, -0x1.0000000000001p0);
7682   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffcp0L, -0x0.fffffffffffff8p0);
7683 # endif
7684 # if LDBL_MANT_DIG >= 113
7685   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000000000000000000001p0L, 0x1.0000000000001p0);
7686   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.fffffffffffff8p0);
7687   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000000000000000000001p0L, -0x1.0000000000001p0);
7688   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.fffffffffffff8p0);
7689 # endif
7690 #endif
7691
7692   END (nexttoward);
7693 }
7694
7695
7696 static void
7697 pow_test (void)
7698 {
7699
7700   errno = 0;
7701   FUNC(pow) (0, 0);
7702   if (errno == ENOSYS)
7703     /* Function not implemented.  */
7704     return;
7705
7706   START (pow);
7707
7708   TEST_ff_f (pow, 0, 0, 1);
7709   TEST_ff_f (pow, 0, minus_zero, 1);
7710   TEST_ff_f (pow, minus_zero, 0, 1);
7711   TEST_ff_f (pow, minus_zero, minus_zero, 1);
7712
7713   TEST_ff_f (pow, 10, 0, 1);
7714   TEST_ff_f (pow, 10, minus_zero, 1);
7715   TEST_ff_f (pow, -10, 0, 1);
7716   TEST_ff_f (pow, -10, minus_zero, 1);
7717
7718   TEST_ff_f (pow, nan_value, 0, 1);
7719   TEST_ff_f (pow, nan_value, minus_zero, 1);
7720
7721
7722 #ifndef TEST_INLINE
7723   TEST_ff_f (pow, 1.1L, plus_infty, plus_infty);
7724   TEST_ff_f (pow, plus_infty, plus_infty, plus_infty);
7725   TEST_ff_f (pow, -1.1L, plus_infty, plus_infty);
7726   TEST_ff_f (pow, minus_infty, plus_infty, plus_infty);
7727
7728   TEST_ff_f (pow, 0.9L, plus_infty, 0);
7729   TEST_ff_f (pow, 1e-7L, plus_infty, 0);
7730   TEST_ff_f (pow, -0.9L, plus_infty, 0);
7731   TEST_ff_f (pow, -1e-7L, plus_infty, 0);
7732
7733   TEST_ff_f (pow, 1.1L, minus_infty, 0);
7734   TEST_ff_f (pow, plus_infty, minus_infty, 0);
7735   TEST_ff_f (pow, -1.1L, minus_infty, 0);
7736   TEST_ff_f (pow, minus_infty, minus_infty, 0);
7737
7738   TEST_ff_f (pow, 0.9L, minus_infty, plus_infty);
7739   TEST_ff_f (pow, 1e-7L, minus_infty, plus_infty);
7740   TEST_ff_f (pow, -0.9L, minus_infty, plus_infty);
7741   TEST_ff_f (pow, -1e-7L, minus_infty, plus_infty);
7742
7743   TEST_ff_f (pow, plus_infty, 1e-7L, plus_infty);
7744   TEST_ff_f (pow, plus_infty, 1, plus_infty);
7745   TEST_ff_f (pow, plus_infty, 1e7L, plus_infty);
7746   TEST_ff_f (pow, plus_infty, min_subnorm_value, plus_infty);
7747
7748   TEST_ff_f (pow, plus_infty, -1e-7L, 0);
7749   TEST_ff_f (pow, plus_infty, -1, 0);
7750   TEST_ff_f (pow, plus_infty, -1e7L, 0);
7751   TEST_ff_f (pow, plus_infty, -min_subnorm_value, 0);
7752
7753   TEST_ff_f (pow, minus_infty, 1, minus_infty);
7754   TEST_ff_f (pow, minus_infty, 11, minus_infty);
7755   TEST_ff_f (pow, minus_infty, 1001, minus_infty);
7756
7757   TEST_ff_f (pow, minus_infty, 2, plus_infty);
7758   TEST_ff_f (pow, minus_infty, 12, plus_infty);
7759   TEST_ff_f (pow, minus_infty, 1002, plus_infty);
7760   TEST_ff_f (pow, minus_infty, 0.1L, plus_infty);
7761   TEST_ff_f (pow, minus_infty, 1.1L, plus_infty);
7762   TEST_ff_f (pow, minus_infty, 11.1L, plus_infty);
7763   TEST_ff_f (pow, minus_infty, 1001.1L, plus_infty);
7764   TEST_ff_f (pow, minus_infty, min_subnorm_value, plus_infty);
7765
7766   TEST_ff_f (pow, minus_infty, -1, minus_zero);
7767   TEST_ff_f (pow, minus_infty, -11, minus_zero);
7768   TEST_ff_f (pow, minus_infty, -1001, minus_zero);
7769
7770   TEST_ff_f (pow, minus_infty, -2, 0);
7771   TEST_ff_f (pow, minus_infty, -12, 0);
7772   TEST_ff_f (pow, minus_infty, -1002, 0);
7773   TEST_ff_f (pow, minus_infty, -0.1L, 0);
7774   TEST_ff_f (pow, minus_infty, -1.1L, 0);
7775   TEST_ff_f (pow, minus_infty, -11.1L, 0);
7776   TEST_ff_f (pow, minus_infty, -1001.1L, 0);
7777   TEST_ff_f (pow, minus_infty, -min_subnorm_value, 0);
7778 #endif
7779
7780   TEST_ff_f (pow, nan_value, nan_value, nan_value);
7781   TEST_ff_f (pow, 0, nan_value, nan_value);
7782   TEST_ff_f (pow, 1, nan_value, 1);
7783   TEST_ff_f (pow, -1, nan_value, nan_value);
7784   TEST_ff_f (pow, nan_value, 1, nan_value);
7785   TEST_ff_f (pow, nan_value, -1, nan_value);
7786
7787   /* pow (x, NaN) == NaN.  */
7788   TEST_ff_f (pow, 3.0, nan_value, nan_value);
7789   TEST_ff_f (pow, minus_zero, nan_value, nan_value);
7790   TEST_ff_f (pow, plus_infty, nan_value, nan_value);
7791   TEST_ff_f (pow, -3.0, nan_value, nan_value);
7792   TEST_ff_f (pow, minus_infty, nan_value, nan_value);
7793
7794   TEST_ff_f (pow, nan_value, 3.0, nan_value);
7795   TEST_ff_f (pow, nan_value, -3.0, nan_value);
7796   TEST_ff_f (pow, nan_value, plus_infty, nan_value);
7797   TEST_ff_f (pow, nan_value, minus_infty, nan_value);
7798   TEST_ff_f (pow, nan_value, 2.5, nan_value);
7799   TEST_ff_f (pow, nan_value, -2.5, nan_value);
7800   TEST_ff_f (pow, nan_value, min_subnorm_value, nan_value);
7801   TEST_ff_f (pow, nan_value, -min_subnorm_value, nan_value);
7802
7803   TEST_ff_f (pow, 1, plus_infty, 1);
7804   TEST_ff_f (pow, -1, plus_infty, 1);
7805   TEST_ff_f (pow, 1, minus_infty, 1);
7806   TEST_ff_f (pow, -1, minus_infty, 1);
7807   TEST_ff_f (pow, 1, 1, 1);
7808   TEST_ff_f (pow, 1, -1, 1);
7809   TEST_ff_f (pow, 1, 1.25, 1);
7810   TEST_ff_f (pow, 1, -1.25, 1);
7811   TEST_ff_f (pow, 1, 0x1p62L, 1);
7812   TEST_ff_f (pow, 1, 0x1p63L, 1);
7813   TEST_ff_f (pow, 1, 0x1p64L, 1);
7814   TEST_ff_f (pow, 1, 0x1p72L, 1);
7815   TEST_ff_f (pow, 1, min_subnorm_value, 1);
7816   TEST_ff_f (pow, 1, -min_subnorm_value, 1);
7817
7818   /* pow (x, +-0) == 1.  */
7819   TEST_ff_f (pow, plus_infty, 0, 1);
7820   TEST_ff_f (pow, plus_infty, minus_zero, 1);
7821   TEST_ff_f (pow, minus_infty, 0, 1);
7822   TEST_ff_f (pow, minus_infty, minus_zero, 1);
7823   TEST_ff_f (pow, 32.75L, 0, 1);
7824   TEST_ff_f (pow, 32.75L, minus_zero, 1);
7825   TEST_ff_f (pow, -32.75L, 0, 1);
7826   TEST_ff_f (pow, -32.75L, minus_zero, 1);
7827   TEST_ff_f (pow, 0x1p72L, 0, 1);
7828   TEST_ff_f (pow, 0x1p72L, minus_zero, 1);
7829   TEST_ff_f (pow, 0x1p-72L, 0, 1);
7830   TEST_ff_f (pow, 0x1p-72L, minus_zero, 1);
7831
7832   TEST_ff_f (pow, -0.1L, 1.1L, nan_value, INVALID_EXCEPTION);
7833   TEST_ff_f (pow, -0.1L, -1.1L, nan_value, INVALID_EXCEPTION);
7834   TEST_ff_f (pow, -10.1L, 1.1L, nan_value, INVALID_EXCEPTION);
7835   TEST_ff_f (pow, -10.1L, -1.1L, nan_value, INVALID_EXCEPTION);
7836   TEST_ff_f (pow, -1.01L, min_subnorm_value, nan_value, INVALID_EXCEPTION);
7837   TEST_ff_f (pow, -1.01L, -min_subnorm_value, nan_value, INVALID_EXCEPTION);
7838   TEST_ff_f (pow, -1.0L, min_subnorm_value, nan_value, INVALID_EXCEPTION);
7839   TEST_ff_f (pow, -1.0L, -min_subnorm_value, nan_value, INVALID_EXCEPTION);
7840
7841   errno = 0;
7842   TEST_ff_f (pow, 0, -1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7843   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7844   errno = 0;
7845   TEST_ff_f (pow, 0, -11, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7846   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7847   errno = 0;
7848   TEST_ff_f (pow, 0, -0xffffff, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7849   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7850 #ifndef TEST_FLOAT
7851   errno = 0;
7852   TEST_ff_f (pow, 0, -0x1.fffffffffffffp+52L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7853   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7854 #endif
7855 #ifdef TEST_LDOUBLE
7856 # if LDBL_MANT_DIG >= 64
7857   errno = 0;
7858   TEST_ff_f (pow, 0, -0x1.fffffffffffffffep+63L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7859   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7860 # endif
7861 # if LDBL_MANT_DIG >= 106
7862   errno = 0;
7863   TEST_ff_f (pow, 0, -0x1.ffffffffffffffffffffffffff8p+105L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7864   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7865 # endif
7866 # if LDBL_MANT_DIG >= 113
7867   errno = 0;
7868   TEST_ff_f (pow, 0, -0x1.ffffffffffffffffffffffffffffp+112L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7869   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7870 # endif
7871 #endif
7872   TEST_ff_f (pow, minus_zero, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7873   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7874   errno = 0;
7875   TEST_ff_f (pow, minus_zero, -11L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7876   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7877   errno = 0;
7878   TEST_ff_f (pow, minus_zero, -0xffffff, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7879   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7880   errno = 0;
7881   TEST_ff_f (pow, minus_zero, -0x1fffffe, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7882   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7883 #ifndef TEST_FLOAT
7884   errno = 0;
7885   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffp+52L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7886   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7887   errno = 0;
7888   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffp+53L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7889   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7890 #endif
7891 #ifdef TEST_LDOUBLE
7892 # if LDBL_MANT_DIG >= 64
7893   errno = 0;
7894   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffffep+63L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7895   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7896   errno = 0;
7897   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffffep+64L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7898   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7899 # endif
7900 # if LDBL_MANT_DIG >= 106
7901   errno = 0;
7902   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7903   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7904   errno = 0;
7905   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7906   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7907 # endif
7908 # if LDBL_MANT_DIG >= 113
7909   errno = 0;
7910   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7911   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7912   errno = 0;
7913   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7914   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7915 # endif
7916 #endif
7917
7918   errno = 0;
7919   TEST_ff_f (pow, 0, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7920   check_int ("errno for pow(0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7921   errno = 0;
7922   TEST_ff_f (pow, 0, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7923   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7924   errno = 0;
7925   TEST_ff_f (pow, 0, -min_subnorm_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7926   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7927   errno = 0;
7928   TEST_ff_f (pow, 0, -0x1p24, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7929   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7930   errno = 0;
7931   TEST_ff_f (pow, 0, -0x1p127, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7932   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7933   errno = 0;
7934   TEST_ff_f (pow, 0, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7935   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7936   errno = 0;
7937   TEST_ff_f (pow, minus_zero, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7938   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7939   errno = 0;
7940   TEST_ff_f (pow, minus_zero, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7941   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7942   errno = 0;
7943   TEST_ff_f (pow, minus_zero, -min_subnorm_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7944   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7945   errno = 0;
7946   TEST_ff_f (pow, minus_zero, -0x1p24, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7947   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7948   errno = 0;
7949   TEST_ff_f (pow, minus_zero, -0x1p127, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7950   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7951   errno = 0;
7952   TEST_ff_f (pow, minus_zero, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7953   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7954
7955   TEST_ff_f (pow, 0x1p72L, 0x1p72L, plus_infty, OVERFLOW_EXCEPTION);
7956   TEST_ff_f (pow, 10, -0x1p72L, 0, UNDERFLOW_EXCEPTION);
7957   TEST_ff_f (pow, max_value, max_value, plus_infty, OVERFLOW_EXCEPTION);
7958   TEST_ff_f (pow, 10, -max_value, 0, UNDERFLOW_EXCEPTION);
7959
7960   TEST_ff_f (pow, 0, 1, 0);
7961   TEST_ff_f (pow, 0, 11, 0);
7962
7963   TEST_ff_f (pow, minus_zero, 1, minus_zero);
7964   TEST_ff_f (pow, minus_zero, 11, minus_zero);
7965
7966   TEST_ff_f (pow, 0, 2, 0);
7967   TEST_ff_f (pow, 0, 11.1L, 0);
7968
7969   TEST_ff_f (pow, minus_zero, 2, 0);
7970   TEST_ff_f (pow, minus_zero, 11.1L, 0);
7971   TEST_ff_f (pow, 0, plus_infty, 0);
7972   TEST_ff_f (pow, minus_zero, plus_infty, 0);
7973   TEST_ff_f (pow, 0, minus_infty, plus_infty, DIVIDE_BY_ZERO_EXCEPTION_OK);
7974   TEST_ff_f (pow, minus_zero, minus_infty, plus_infty, DIVIDE_BY_ZERO_EXCEPTION_OK);
7975
7976 #ifndef TEST_INLINE
7977   /* pow (x, +inf) == +inf for |x| > 1.  */
7978   TEST_ff_f (pow, 1.5, plus_infty, plus_infty);
7979
7980   /* pow (x, +inf) == +0 for |x| < 1.  */
7981   TEST_ff_f (pow, 0.5, plus_infty, 0.0);
7982
7983   /* pow (x, -inf) == +0 for |x| > 1.  */
7984   TEST_ff_f (pow, 1.5, minus_infty, 0.0);
7985
7986   /* pow (x, -inf) == +inf for |x| < 1.  */
7987   TEST_ff_f (pow, 0.5, minus_infty, plus_infty);
7988 #endif
7989
7990   /* pow (+inf, y) == +inf for y > 0.  */
7991   TEST_ff_f (pow, plus_infty, 2, plus_infty);
7992   TEST_ff_f (pow, plus_infty, 0xffffff, plus_infty);
7993 #ifndef TEST_FLOAT
7994   TEST_ff_f (pow, plus_infty, 0x1.fffffffffffffp+52L, plus_infty);
7995 #endif
7996 #ifdef TEST_LDOUBLE
7997 # if LDBL_MANT_DIG >= 64
7998   TEST_ff_f (pow, plus_infty, 0x1.fffffffffffffffep+63L, plus_infty);
7999 # endif
8000 # if LDBL_MANT_DIG >= 106
8001   TEST_ff_f (pow, plus_infty, 0x1.ffffffffffffffffffffffffff8p+105L, plus_infty);
8002 # endif
8003 # if LDBL_MANT_DIG >= 113
8004   TEST_ff_f (pow, plus_infty, 0x1.ffffffffffffffffffffffffffffp+112L, plus_infty);
8005 # endif
8006 #endif
8007   TEST_ff_f (pow, plus_infty, 0x1p24, plus_infty);
8008   TEST_ff_f (pow, plus_infty, 0x1p127, plus_infty);
8009   TEST_ff_f (pow, plus_infty, max_value, plus_infty);
8010
8011   /* pow (+inf, y) == +0 for y < 0.  */
8012   TEST_ff_f (pow, plus_infty, -1, 0.0);
8013   TEST_ff_f (pow, plus_infty, -0xffffff, 0.0);
8014 #ifndef TEST_FLOAT
8015   TEST_ff_f (pow, plus_infty, -0x1.fffffffffffffp+52L, 0.0);
8016 #endif
8017 #ifdef TEST_LDOUBLE
8018 # if LDBL_MANT_DIG >= 64
8019   TEST_ff_f (pow, plus_infty, -0x1.fffffffffffffffep+63L, 0.0);
8020 # endif
8021 # if LDBL_MANT_DIG >= 106
8022   TEST_ff_f (pow, plus_infty, -0x1.ffffffffffffffffffffffffff8p+105L, 0.0);
8023 # endif
8024 # if LDBL_MANT_DIG >= 113
8025   TEST_ff_f (pow, plus_infty, -0x1.ffffffffffffffffffffffffffffp+112L, 0.0);
8026 # endif
8027 #endif
8028   TEST_ff_f (pow, plus_infty, -0x1p24, 0.0);
8029   TEST_ff_f (pow, plus_infty, -0x1p127, 0.0);
8030   TEST_ff_f (pow, plus_infty, -max_value, 0.0);
8031
8032   /* pow (-inf, y) == -inf for y an odd integer > 0.  */
8033   TEST_ff_f (pow, minus_infty, 27, minus_infty);
8034   TEST_ff_f (pow, minus_infty, 0xffffff, minus_infty);
8035   TEST_ff_f (pow, minus_infty, 0x1fffffe, plus_infty);
8036 #ifndef TEST_FLOAT
8037   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffp+52L, minus_infty);
8038   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffp+53L, plus_infty);
8039 #endif
8040 #ifdef TEST_LDOUBLE
8041 # if LDBL_MANT_DIG >= 64
8042   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffffep+63L, minus_infty);
8043   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffffep+64L, plus_infty);
8044 # endif
8045 # if LDBL_MANT_DIG >= 106
8046   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty);
8047   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty);
8048 # endif
8049 # if LDBL_MANT_DIG >= 113
8050   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty);
8051   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty);
8052 # endif
8053 #endif
8054
8055   /* pow (-inf, y) == +inf for y > 0 and not an odd integer.  */
8056   TEST_ff_f (pow, minus_infty, 28, plus_infty);
8057   TEST_ff_f (pow, minus_infty, 0x1p24, plus_infty);
8058   TEST_ff_f (pow, minus_infty, 0x1p127, plus_infty);
8059   TEST_ff_f (pow, minus_infty, max_value, plus_infty);
8060
8061   /* pow (-inf, y) == -0 for y an odd integer < 0. */
8062   TEST_ff_f (pow, minus_infty, -3, minus_zero);
8063   TEST_ff_f (pow, minus_infty, -0xffffff, minus_zero);
8064   TEST_ff_f (pow, minus_infty, -0x1fffffe, plus_zero);
8065 #ifndef TEST_FLOAT
8066   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffp+52L, minus_zero);
8067   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffp+53L, plus_zero);
8068 #endif
8069 #ifdef TEST_LDOUBLE
8070 # if LDBL_MANT_DIG >= 64
8071   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffffep+63L, minus_zero);
8072   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffffep+64L, plus_zero);
8073 # endif
8074 # if LDBL_MANT_DIG >= 106
8075   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
8076   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
8077 # endif
8078 # if LDBL_MANT_DIG >= 113
8079   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
8080   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
8081 # endif
8082 #endif
8083   /* pow (-inf, y) == +0 for y < 0 and not an odd integer.  */
8084   TEST_ff_f (pow, minus_infty, -2.0, 0.0);
8085   TEST_ff_f (pow, minus_infty, -0x1p24, 0.0);
8086   TEST_ff_f (pow, minus_infty, -0x1p127, 0.0);
8087   TEST_ff_f (pow, minus_infty, -max_value, 0.0);
8088
8089   /* pow (+0, y) == +0 for y an odd integer > 0.  */
8090   TEST_ff_f (pow, 0.0, 27, 0.0);
8091   TEST_ff_f (pow, 0.0, 0xffffff, 0.0);
8092 #ifndef TEST_FLOAT
8093   TEST_ff_f (pow, 0.0, 0x1.fffffffffffffp+52L, 0.0);
8094 #endif
8095 #ifdef TEST_LDOUBLE
8096 # if LDBL_MANT_DIG >= 64
8097   TEST_ff_f (pow, 0.0, 0x1.fffffffffffffffep+63L, 0.0);
8098 # endif
8099 # if LDBL_MANT_DIG >= 106
8100   TEST_ff_f (pow, 0.0, 0x1.ffffffffffffffffffffffffff8p+105L, 0.0);
8101 # endif
8102 # if LDBL_MANT_DIG >= 113
8103   TEST_ff_f (pow, 0.0, 0x1.ffffffffffffffffffffffffffffp+112L, 0.0);
8104 # endif
8105 #endif
8106
8107   /* pow (-0, y) == -0 for y an odd integer > 0.  */
8108   TEST_ff_f (pow, minus_zero, 27, minus_zero);
8109   TEST_ff_f (pow, minus_zero, 0xffffff, minus_zero);
8110   TEST_ff_f (pow, minus_zero, 0x1fffffe, plus_zero);
8111 #ifndef TEST_FLOAT
8112   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffp+52L, minus_zero);
8113   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffp+53L, plus_zero);
8114 #endif
8115 #ifdef TEST_LDOUBLE
8116 # if LDBL_MANT_DIG >= 64
8117   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffffep+63L, minus_zero);
8118   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffffep+64L, plus_zero);
8119 # endif
8120 # if LDBL_MANT_DIG >= 106
8121   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
8122   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
8123 # endif
8124 # if LDBL_MANT_DIG >= 113
8125   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
8126   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
8127 # endif
8128 #endif
8129
8130   /* pow (+0, y) == +0 for y > 0 and not an odd integer.  */
8131   TEST_ff_f (pow, 0.0, 4, 0.0);
8132   TEST_ff_f (pow, 0.0, 0x1p24, 0.0);
8133   TEST_ff_f (pow, 0.0, 0x1p127, 0.0);
8134   TEST_ff_f (pow, 0.0, max_value, 0.0);
8135   TEST_ff_f (pow, 0.0, min_subnorm_value, 0.0);
8136
8137   /* pow (-0, y) == +0 for y > 0 and not an odd integer.  */
8138   TEST_ff_f (pow, minus_zero, 4, 0.0);
8139   TEST_ff_f (pow, minus_zero, 0x1p24, 0.0);
8140   TEST_ff_f (pow, minus_zero, 0x1p127, 0.0);
8141   TEST_ff_f (pow, minus_zero, max_value, 0.0);
8142   TEST_ff_f (pow, minus_zero, min_subnorm_value, 0.0);
8143
8144   TEST_ff_f (pow, 16, 0.25L, 2);
8145   TEST_ff_f (pow, 0x1p64L, 0.125L, 256);
8146   TEST_ff_f (pow, 2, 4, 16);
8147   TEST_ff_f (pow, 256, 8, 0x1p64L);
8148
8149   TEST_ff_f (pow, 0.75L, 1.25L, 0.697953644326574699205914060237425566L);
8150
8151 #if defined TEST_DOUBLE || defined TEST_LDOUBLE
8152   TEST_ff_f (pow, -7.49321e+133, -9.80818e+16, 0, UNDERFLOW_EXCEPTION);
8153 #endif
8154
8155   TEST_ff_f (pow, -1.0, -0xffffff, -1.0);
8156   TEST_ff_f (pow, -1.0, -0x1fffffe, 1.0);
8157 #ifndef TEST_FLOAT
8158   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffp+52L, -1.0);
8159   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffp+53L, 1.0);
8160 #endif
8161 #ifdef TEST_LDOUBLE
8162 # if LDBL_MANT_DIG >= 64
8163   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffffep+63L, -1.0);
8164   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffffep+64L, 1.0);
8165 # endif
8166 # if LDBL_MANT_DIG >= 106
8167   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffff8p+105L, -1.0);
8168   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffff8p+106L, 1.0);
8169 # endif
8170 # if LDBL_MANT_DIG >= 113
8171   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffffffp+112L, -1.0);
8172   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffffffp+113L, 1.0);
8173 # endif
8174 #endif
8175   TEST_ff_f (pow, -1.0, -max_value, 1.0);
8176
8177   TEST_ff_f (pow, -1.0, 0xffffff, -1.0);
8178   TEST_ff_f (pow, -1.0, 0x1fffffe, 1.0);
8179 #ifndef TEST_FLOAT
8180   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffp+52L, -1.0);
8181   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffp+53L, 1.0);
8182 #endif
8183 #ifdef TEST_LDOUBLE
8184 # if LDBL_MANT_DIG >= 64
8185   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffffep+63L, -1.0);
8186   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffffep+64L, 1.0);
8187 # endif
8188 # if LDBL_MANT_DIG >= 106
8189   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffff8p+105L, -1.0);
8190   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffff8p+106L, 1.0);
8191 # endif
8192 # if LDBL_MANT_DIG >= 113
8193   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffffffp+112L, -1.0);
8194   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffffffp+113L, 1.0);
8195 # endif
8196 #endif
8197   TEST_ff_f (pow, -1.0, max_value, 1.0);
8198
8199   TEST_ff_f (pow, -2.0, 126, 0x1p126);
8200   TEST_ff_f (pow, -2.0, 127, -0x1p127);
8201   /* Allow inexact results for float to be considered to underflow.  */
8202   TEST_ff_f (pow, -2.0, -126, 0x1p-126, UNDERFLOW_EXCEPTION_OK_FLOAT);
8203   TEST_ff_f (pow, -2.0, -127, -0x1p-127, UNDERFLOW_EXCEPTION_OK_FLOAT);
8204
8205   TEST_ff_f (pow, -2.0, -0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
8206   TEST_ff_f (pow, -2.0, -0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
8207 #ifndef TEST_FLOAT
8208   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
8209   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
8210 #endif
8211 #ifdef TEST_LDOUBLE
8212 # if LDBL_MANT_DIG >= 64
8213   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
8214   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
8215 # endif
8216 # if LDBL_MANT_DIG >= 106
8217   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
8218   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
8219 # endif
8220 # if LDBL_MANT_DIG >= 113
8221   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
8222   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
8223 # endif
8224 #endif
8225   TEST_ff_f (pow, -2.0, -max_value, plus_zero, UNDERFLOW_EXCEPTION);
8226
8227   TEST_ff_f (pow, -2.0, 0xffffff, minus_infty, OVERFLOW_EXCEPTION);
8228   TEST_ff_f (pow, -2.0, 0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
8229 #ifndef TEST_FLOAT
8230   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
8231   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
8232 #endif
8233 #ifdef TEST_LDOUBLE
8234 # if LDBL_MANT_DIG >= 64
8235   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
8236   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
8237 # endif
8238 # if LDBL_MANT_DIG >= 106
8239   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
8240   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
8241 # endif
8242 # if LDBL_MANT_DIG >= 113
8243   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
8244   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
8245 # endif
8246 #endif
8247   TEST_ff_f (pow, -2.0, max_value, plus_infty, OVERFLOW_EXCEPTION);
8248
8249   TEST_ff_f (pow, -max_value, 0.5, nan_value, INVALID_EXCEPTION);
8250   TEST_ff_f (pow, -max_value, 1.5, nan_value, INVALID_EXCEPTION);
8251   TEST_ff_f (pow, -max_value, 1000.5, nan_value, INVALID_EXCEPTION);
8252   TEST_ff_f (pow, -max_value, -2, plus_zero, UNDERFLOW_EXCEPTION);
8253   TEST_ff_f (pow, -max_value, -3, minus_zero, UNDERFLOW_EXCEPTION);
8254   TEST_ff_f (pow, -max_value, 2, plus_infty, OVERFLOW_EXCEPTION);
8255   TEST_ff_f (pow, -max_value, 3, minus_infty, OVERFLOW_EXCEPTION);
8256
8257   TEST_ff_f (pow, -max_value, -0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
8258   TEST_ff_f (pow, -max_value, -0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
8259 #ifndef TEST_FLOAT
8260   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
8261   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
8262 #endif
8263 #ifdef TEST_LDOUBLE
8264 # if LDBL_MANT_DIG >= 64
8265   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
8266   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
8267 # endif
8268 # if LDBL_MANT_DIG >= 106
8269   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
8270   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
8271 # endif
8272 # if LDBL_MANT_DIG >= 113
8273   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
8274   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
8275 # endif
8276 #endif
8277   TEST_ff_f (pow, -max_value, -max_value, plus_zero, UNDERFLOW_EXCEPTION);
8278
8279   TEST_ff_f (pow, -max_value, 0xffffff, minus_infty, OVERFLOW_EXCEPTION);
8280   TEST_ff_f (pow, -max_value, 0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
8281 #ifndef TEST_FLOAT
8282   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
8283   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
8284 #endif
8285 #ifdef TEST_LDOUBLE
8286 # if LDBL_MANT_DIG >= 64
8287   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
8288   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
8289 # endif
8290 # if LDBL_MANT_DIG >= 106
8291   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
8292   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
8293 # endif
8294 # if LDBL_MANT_DIG >= 113
8295   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
8296   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
8297 # endif
8298 #endif
8299   TEST_ff_f (pow, -max_value, max_value, plus_infty, OVERFLOW_EXCEPTION);
8300
8301   TEST_ff_f (pow, -0.5, 126, 0x1p-126);
8302   TEST_ff_f (pow, -0.5, 127, -0x1p-127);
8303   TEST_ff_f (pow, -0.5, -126, 0x1p126);
8304   TEST_ff_f (pow, -0.5, -127, -0x1p127);
8305
8306   TEST_ff_f (pow, -0.5, -0xffffff, minus_infty, OVERFLOW_EXCEPTION);
8307   TEST_ff_f (pow, -0.5, -0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
8308 #ifndef TEST_FLOAT
8309   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
8310   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
8311 #endif
8312 #ifdef TEST_LDOUBLE
8313 # if LDBL_MANT_DIG >= 64
8314   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
8315   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
8316 # endif
8317 # if LDBL_MANT_DIG >= 106
8318   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
8319   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
8320 # endif
8321 # if LDBL_MANT_DIG >= 113
8322   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
8323   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
8324 # endif
8325 #endif
8326   TEST_ff_f (pow, -0.5, -max_value, plus_infty, OVERFLOW_EXCEPTION);
8327
8328   TEST_ff_f (pow, -0.5, 0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
8329   TEST_ff_f (pow, -0.5, 0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
8330 #ifndef TEST_FLOAT
8331   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
8332   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
8333 #endif
8334 #ifdef TEST_LDOUBLE
8335 # if LDBL_MANT_DIG >= 64
8336   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
8337   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
8338 # endif
8339 # if LDBL_MANT_DIG >= 106
8340   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
8341   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
8342 # endif
8343 # if LDBL_MANT_DIG >= 113
8344   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
8345   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
8346 # endif
8347 #endif
8348   TEST_ff_f (pow, -0.5, max_value, plus_zero, UNDERFLOW_EXCEPTION);
8349
8350   TEST_ff_f (pow, -min_value, 0.5, nan_value, INVALID_EXCEPTION);
8351   TEST_ff_f (pow, -min_value, 1.5, nan_value, INVALID_EXCEPTION);
8352   TEST_ff_f (pow, -min_value, 1000.5, nan_value, INVALID_EXCEPTION);
8353   TEST_ff_f (pow, -min_value, -2, plus_infty, OVERFLOW_EXCEPTION);
8354   TEST_ff_f (pow, -min_value, -3, minus_infty, OVERFLOW_EXCEPTION);
8355   /* Allow inexact results to be considered to underflow.  */
8356   TEST_ff_f (pow, -min_value, 1, -min_value, UNDERFLOW_EXCEPTION_OK);
8357   TEST_ff_f (pow, -min_value, 2, plus_zero, UNDERFLOW_EXCEPTION);
8358   TEST_ff_f (pow, -min_value, 3, minus_zero, UNDERFLOW_EXCEPTION);
8359
8360   TEST_ff_f (pow, -min_value, -0xffffff, minus_infty, OVERFLOW_EXCEPTION);
8361   TEST_ff_f (pow, -min_value, -0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
8362 #ifndef TEST_FLOAT
8363   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
8364   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
8365 #endif
8366 #ifdef TEST_LDOUBLE
8367 # if LDBL_MANT_DIG >= 64
8368   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
8369   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
8370 # endif
8371 # if LDBL_MANT_DIG >= 106
8372   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
8373   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
8374 # endif
8375 # if LDBL_MANT_DIG >= 113
8376   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
8377   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
8378 # endif
8379 #endif
8380   TEST_ff_f (pow, -min_value, -max_value, plus_infty, OVERFLOW_EXCEPTION);
8381
8382   TEST_ff_f (pow, -min_value, 0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
8383   TEST_ff_f (pow, -min_value, 0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
8384 #ifndef TEST_FLOAT
8385   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
8386   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
8387 #endif
8388 #ifdef TEST_LDOUBLE
8389 # if LDBL_MANT_DIG >= 64
8390   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
8391   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
8392 # endif
8393 # if LDBL_MANT_DIG >= 106
8394   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
8395   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
8396 # endif
8397 # if LDBL_MANT_DIG >= 113
8398   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
8399   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
8400 # endif
8401 #endif
8402   TEST_ff_f (pow, -min_value, max_value, plus_zero, UNDERFLOW_EXCEPTION);
8403
8404 #ifndef TEST_LDOUBLE /* Bug 13881.  */
8405   TEST_ff_f (pow, 0x0.ffffffp0, 10, 0.999999403953712118183885036774764444747L);
8406   TEST_ff_f (pow, 0x0.ffffffp0, 100, 0.999994039553108359406305079606228341585L);
8407   TEST_ff_f (pow, 0x0.ffffffp0, 1000, 0.9999403971297699052276650144650733772182L);
8408   TEST_ff_f (pow, 0x0.ffffffp0, 0x1p24, 0.3678794302077803437135155590023422899744L);
8409   TEST_ff_f (pow, 0x0.ffffffp0, 0x1p30, 1.603807831524924233828134753069728224044e-28L);
8410   TEST_ff_f (pow, 0x0.ffffffp0, 0x1.234566p30, 2.374884712135295099971443365381007297732e-32L);
8411   TEST_ff_f (pow, 0x0.ffffffp0, -10, 1.000000596046643153205170848674671339688L);
8412   TEST_ff_f (pow, 0x0.ffffffp0, -100, 1.000005960482418779499387594989252621451L);
8413   TEST_ff_f (pow, 0x0.ffffffp0, -1000, 1.000059606422943986382898964231519867906L);
8414   TEST_ff_f (pow, 0x0.ffffffp0, -0x1p24, 2.7182819094701610539628664526874952929416L);
8415   TEST_ff_f (pow, 0x0.ffffffp0, -0x1p30, 6.2351609734265057988914412331288163636075e+27L);
8416   TEST_ff_f (pow, 0x0.ffffffp0, -0x1.234566p30, 4.2107307141696353498921307077142537353515e+31L);
8417   TEST_ff_f (pow, 0x1.000002p0, 0x1p24, 7.3890552180866447284268641248075832310141L);
8418   TEST_ff_f (pow, 0x1.000002p0, 0x1.234566p29, 4.2107033006507495188536371520637025716256e+31L);
8419   TEST_ff_f (pow, 0x1.000002p0, -0x1.234566p29, 2.3749001736727769098946062325205705312166e-32L);
8420 #endif
8421
8422   /* Bug 13881: powl inaccurate so these tests disabled for long double.  */
8423 #if !defined TEST_FLOAT && !defined TEST_LDOUBLE
8424   TEST_ff_f (pow, 0x0.fffffffffffff8p0L, 0x1.23456789abcdfp62L, 1.0118762747827252817436395051178295138220e-253L);
8425   TEST_ff_f (pow, 0x0.fffffffffffff8p0L, -0x1.23456789abcdfp62L, 9.8826311568054561811190162420900667121992e+252L);
8426   TEST_ff_f (pow, 0x1.0000000000001p0L, 0x1.23456789abcdfp61L, 9.8826311568044974397135026217687399395481e+252L);
8427   TEST_ff_f (pow, 0x1.0000000000001p0L, -0x1.23456789abcdfp61L, 1.0118762747828234466621210689458255908670e-253L);
8428 #endif
8429
8430   TEST_ff_f (pow, min_subnorm_value, min_subnorm_value, 1.0L);
8431   TEST_ff_f (pow, min_subnorm_value, -min_subnorm_value, 1.0L);
8432   TEST_ff_f (pow, max_value, min_subnorm_value, 1.0L);
8433   TEST_ff_f (pow, max_value, -min_subnorm_value, 1.0L);
8434   TEST_ff_f (pow, 0.99L, min_subnorm_value, 1.0L);
8435   TEST_ff_f (pow, 0.99L, -min_subnorm_value, 1.0L);
8436   TEST_ff_f (pow, 1.01L, min_subnorm_value, 1.0L);
8437   TEST_ff_f (pow, 1.01L, -min_subnorm_value, 1.0L);
8438
8439   TEST_ff_f (pow, 2.0L, -100000.0L, plus_zero, UNDERFLOW_EXCEPTION);
8440
8441   END (pow);
8442 }
8443
8444
8445 static void
8446 pow_test_tonearest (void)
8447 {
8448   int save_round_mode;
8449   errno = 0;
8450   FUNC(pow) (0, 0);
8451   if (errno == ENOSYS)
8452     /* Function not implemented.  */
8453     return;
8454
8455   START (pow_tonearest);
8456
8457   save_round_mode = fegetround ();
8458
8459   if (!fesetround (FE_TONEAREST))
8460     {
8461       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
8462       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
8463     }
8464
8465   fesetround (save_round_mode);
8466
8467   END (pow_tonearest);
8468 }
8469
8470
8471 static void
8472 pow_test_towardzero (void)
8473 {
8474   int save_round_mode;
8475   errno = 0;
8476   FUNC(pow) (0, 0);
8477   if (errno == ENOSYS)
8478     /* Function not implemented.  */
8479     return;
8480
8481   START (pow_towardzero);
8482
8483   save_round_mode = fegetround ();
8484
8485   if (!fesetround (FE_TOWARDZERO))
8486     {
8487       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
8488       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
8489     }
8490
8491   fesetround (save_round_mode);
8492
8493   END (pow_towardzero);
8494 }
8495
8496
8497 static void
8498 pow_test_downward (void)
8499 {
8500   int save_round_mode;
8501   errno = 0;
8502   FUNC(pow) (0, 0);
8503   if (errno == ENOSYS)
8504     /* Function not implemented.  */
8505     return;
8506
8507   START (pow_downward);
8508
8509   save_round_mode = fegetround ();
8510
8511   if (!fesetround (FE_DOWNWARD))
8512     {
8513       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
8514       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
8515     }
8516
8517   fesetround (save_round_mode);
8518
8519   END (pow_downward);
8520 }
8521
8522
8523 static void
8524 pow_test_upward (void)
8525 {
8526   int save_round_mode;
8527   errno = 0;
8528   FUNC(pow) (0, 0);
8529   if (errno == ENOSYS)
8530     /* Function not implemented.  */
8531     return;
8532
8533   START (pow_upward);
8534
8535   save_round_mode = fegetround ();
8536
8537   if (!fesetround (FE_UPWARD))
8538     {
8539       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
8540       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
8541     }
8542
8543   fesetround (save_round_mode);
8544
8545   END (pow_upward);
8546 }
8547
8548
8549 static void
8550 remainder_test (void)
8551 {
8552   errno = 0;
8553   FUNC(remainder) (1.625, 1.0);
8554   if (errno == ENOSYS)
8555     /* Function not implemented.  */
8556     return;
8557
8558   START (remainder);
8559
8560   errno = 0;
8561   TEST_ff_f (remainder, 1, 0, nan_value, INVALID_EXCEPTION);
8562   check_int ("errno for remainder(1, 0) = EDOM ", errno, EDOM, 0, 0, 0);
8563   errno = 0;
8564   TEST_ff_f (remainder, 1, minus_zero, nan_value, INVALID_EXCEPTION);
8565   check_int ("errno for remainder(1, -0) = EDOM ", errno, EDOM, 0, 0, 0);
8566   errno = 0;
8567   TEST_ff_f (remainder, plus_infty, 1, nan_value, INVALID_EXCEPTION);
8568   check_int ("errno for remainder(INF, 1) = EDOM ", errno, EDOM, 0, 0, 0);
8569   errno = 0;
8570   TEST_ff_f (remainder, minus_infty, 1, nan_value, INVALID_EXCEPTION);
8571   check_int ("errno for remainder(-INF, 1) = EDOM ", errno, EDOM, 0, 0, 0);
8572   errno = 0;
8573   TEST_ff_f (remainder, nan_value, nan_value, nan_value);
8574   check_int ("errno for remainder(NAN, NAN) unchanged", errno, 0, 0, 0, 0);
8575   errno = 0;
8576   TEST_ff_f (remainder, 0, nan_value, nan_value);
8577   check_int ("errno for remainder(0, NAN) unchanged", errno, 0, 0, 0, 0);
8578   errno = 0;
8579   TEST_ff_f (remainder, nan_value, 0, nan_value);
8580   check_int ("errno for remainder(NaN, 0) unchanged", errno, 0, 0, 0, 0);
8581
8582   TEST_ff_f (remainder, 1.625, 1.0, -0.375);
8583   TEST_ff_f (remainder, -1.625, 1.0, 0.375);
8584   TEST_ff_f (remainder, 1.625, -1.0, -0.375);
8585   TEST_ff_f (remainder, -1.625, -1.0, 0.375);
8586   TEST_ff_f (remainder, 5.0, 2.0, 1.0);
8587   TEST_ff_f (remainder, 3.0, 2.0, -1.0);
8588
8589   END (remainder);
8590 }
8591
8592 static void
8593 remquo_test (void)
8594 {
8595   /* x is needed.  */
8596   int x;
8597
8598   errno = 0;
8599   FUNC(remquo) (1.625, 1.0, &x);
8600   if (errno == ENOSYS)
8601     /* Function not implemented.  */
8602     return;
8603
8604   START (remquo);
8605
8606   TEST_ffI_f1 (remquo, 1, 0, nan_value, IGNORE, INVALID_EXCEPTION);
8607   TEST_ffI_f1 (remquo, 1, minus_zero, nan_value, IGNORE, INVALID_EXCEPTION);
8608   TEST_ffI_f1 (remquo, plus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
8609   TEST_ffI_f1 (remquo, minus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
8610   TEST_ffI_f1 (remquo, nan_value, nan_value, nan_value, IGNORE);
8611
8612   TEST_ffI_f1 (remquo, 1.625, 1.0, -0.375, 2);
8613   TEST_ffI_f1 (remquo, -1.625, 1.0, 0.375, -2);
8614   TEST_ffI_f1 (remquo, 1.625, -1.0, -0.375, -2);
8615   TEST_ffI_f1 (remquo, -1.625, -1.0, 0.375, 2);
8616
8617   TEST_ffI_f1 (remquo, 5, 2, 1, 2);
8618   TEST_ffI_f1 (remquo, 3, 2, -1, 2);
8619
8620   END (remquo);
8621 }
8622
8623 static void
8624 rint_test (void)
8625 {
8626   START (rint);
8627
8628   TEST_f_f (rint, 0.0, 0.0);
8629   TEST_f_f (rint, minus_zero, minus_zero);
8630   TEST_f_f (rint, plus_infty, plus_infty);
8631   TEST_f_f (rint, minus_infty, minus_infty);
8632
8633   /* Default rounding mode is round to even.  */
8634   TEST_f_f (rint, 0.5, 0.0);
8635   TEST_f_f (rint, 1.5, 2.0);
8636   TEST_f_f (rint, 2.5, 2.0);
8637   TEST_f_f (rint, 3.5, 4.0);
8638   TEST_f_f (rint, 4.5, 4.0);
8639   TEST_f_f (rint, -0.5, -0.0);
8640   TEST_f_f (rint, -1.5, -2.0);
8641   TEST_f_f (rint, -2.5, -2.0);
8642   TEST_f_f (rint, -3.5, -4.0);
8643   TEST_f_f (rint, -4.5, -4.0);
8644   TEST_f_f (rint, 0.1, 0.0);
8645   TEST_f_f (rint, 0.25, 0.0);
8646   TEST_f_f (rint, 0.625, 1.0);
8647   TEST_f_f (rint, -0.1, -0.0);
8648   TEST_f_f (rint, -0.25, -0.0);
8649   TEST_f_f (rint, -0.625, -1.0);
8650   TEST_f_f (rint, 262144.75, 262145.0);
8651   TEST_f_f (rint, 262142.75, 262143.0);
8652   TEST_f_f (rint, 524286.75, 524287.0);
8653   TEST_f_f (rint, 524288.75, 524289.0);
8654   TEST_f_f (rint, 1048576.75, 1048577.0);
8655   TEST_f_f (rint, 2097152.75, 2097153.0);
8656   TEST_f_f (rint, -1048576.75, -1048577.0);
8657   TEST_f_f (rint, -2097152.75, -2097153.0);
8658 #ifndef TEST_FLOAT
8659   TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
8660   TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
8661   TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
8662   TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
8663   TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
8664   TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
8665   TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
8666   TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
8667   TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
8668   TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
8669 #endif
8670 #ifdef TEST_LDOUBLE
8671   /* The result can only be represented in long double.  */
8672   TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
8673   TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
8674   TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
8675   TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
8676   TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
8677
8678 # if LDBL_MANT_DIG > 100
8679   TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
8680   TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
8681   TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
8682 # endif
8683
8684   TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
8685   TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
8686   TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
8687   TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
8688   TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
8689
8690 # if LDBL_MANT_DIG > 100
8691   TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
8692   TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
8693   TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
8694
8695   TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
8696   TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
8697   TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
8698   TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
8699   TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
8700   TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
8701
8702   TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
8703   TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
8704   TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
8705   TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
8706   TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
8707   TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
8708 # endif
8709
8710   TEST_f_f (rint, 9007199254740991.5L, 9007199254740992.0L);
8711   TEST_f_f (rint, 9007199254740992.25L, 9007199254740992.0L);
8712   TEST_f_f (rint, 9007199254740992.5L, 9007199254740992.0L);
8713   TEST_f_f (rint, 9007199254740992.75L, 9007199254740993.0L);
8714   TEST_f_f (rint, 9007199254740993.5L, 9007199254740994.0L);
8715
8716   TEST_f_f (rint, -9007199254740991.5L, -9007199254740992.0L);
8717   TEST_f_f (rint, -9007199254740992.25L, -9007199254740992.0L);
8718   TEST_f_f (rint, -9007199254740992.5L, -9007199254740992.0L);
8719   TEST_f_f (rint, -9007199254740992.75L, -9007199254740993.0L);
8720   TEST_f_f (rint, -9007199254740993.5L, -9007199254740994.0L);
8721
8722   TEST_f_f (rint, 72057594037927935.5L, 72057594037927936.0L);
8723   TEST_f_f (rint, 72057594037927936.25L, 72057594037927936.0L);
8724   TEST_f_f (rint, 72057594037927936.5L, 72057594037927936.0L);
8725   TEST_f_f (rint, 72057594037927936.75L, 72057594037927937.0L);
8726   TEST_f_f (rint, 72057594037927937.5L, 72057594037927938.0L);
8727
8728   TEST_f_f (rint, -72057594037927935.5L, -72057594037927936.0L);
8729   TEST_f_f (rint, -72057594037927936.25L, -72057594037927936.0L);
8730   TEST_f_f (rint, -72057594037927936.5L, -72057594037927936.0L);
8731   TEST_f_f (rint, -72057594037927936.75L, -72057594037927937.0L);
8732   TEST_f_f (rint, -72057594037927937.5L, -72057594037927938.0L);
8733
8734   TEST_f_f (rint, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
8735   TEST_f_f (rint, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
8736   TEST_f_f (rint, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
8737   TEST_f_f (rint, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
8738   TEST_f_f (rint, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
8739 #endif
8740
8741   END (rint);
8742 }
8743
8744 static void
8745 rint_test_tonearest (void)
8746 {
8747   int save_round_mode;
8748   START (rint_tonearest);
8749
8750   save_round_mode = fegetround ();
8751
8752   if (!fesetround (FE_TONEAREST))
8753     {
8754       TEST_f_f (rint, 2.0, 2.0);
8755       TEST_f_f (rint, 1.5, 2.0);
8756       TEST_f_f (rint, 1.0, 1.0);
8757       TEST_f_f (rint, 0.5, 0.0);
8758       TEST_f_f (rint, 0.0, 0.0);
8759       TEST_f_f (rint, minus_zero, minus_zero);
8760       TEST_f_f (rint, -0.5, -0.0);
8761       TEST_f_f (rint, -1.0, -1.0);
8762       TEST_f_f (rint, -1.5, -2.0);
8763       TEST_f_f (rint, -2.0, -2.0);
8764       TEST_f_f (rint, 0.1, 0.0);
8765       TEST_f_f (rint, 0.25, 0.0);
8766       TEST_f_f (rint, 0.625, 1.0);
8767       TEST_f_f (rint, -0.1, -0.0);
8768       TEST_f_f (rint, -0.25, -0.0);
8769       TEST_f_f (rint, -0.625, -1.0);
8770       TEST_f_f (rint, 1048576.75, 1048577.0);
8771       TEST_f_f (rint, 2097152.75, 2097153.0);
8772       TEST_f_f (rint, -1048576.75, -1048577.0);
8773       TEST_f_f (rint, -2097152.75, -2097153.0);
8774 #ifndef TEST_FLOAT
8775       TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
8776       TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
8777       TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
8778       TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
8779       TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
8780       TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
8781       TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
8782       TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
8783       TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
8784       TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
8785 #endif
8786 #ifdef TEST_LDOUBLE
8787       /* The result can only be represented in long double.  */
8788       TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
8789       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
8790       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
8791       TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
8792       TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
8793 # if LDBL_MANT_DIG > 100
8794       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
8795       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
8796       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
8797 # endif
8798       TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
8799       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
8800       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
8801       TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
8802       TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
8803 # if LDBL_MANT_DIG > 100
8804       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
8805       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
8806       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
8807
8808       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
8809       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
8810       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
8811       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
8812       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
8813       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
8814
8815       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
8816       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
8817       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
8818       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
8819       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
8820       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
8821 # endif
8822 #endif
8823     }
8824
8825   fesetround (save_round_mode);
8826
8827   END (rint_tonearest);
8828 }
8829
8830 static void
8831 rint_test_towardzero (void)
8832 {
8833   int save_round_mode;
8834   START (rint_towardzero);
8835
8836   save_round_mode = fegetround ();
8837
8838   if (!fesetround (FE_TOWARDZERO))
8839     {
8840       TEST_f_f (rint, 2.0, 2.0);
8841       TEST_f_f (rint, 1.5, 1.0);
8842       TEST_f_f (rint, 1.0, 1.0);
8843       TEST_f_f (rint, 0.5, 0.0);
8844       TEST_f_f (rint, 0.0, 0.0);
8845       TEST_f_f (rint, minus_zero, minus_zero);
8846       TEST_f_f (rint, -0.5, -0.0);
8847       TEST_f_f (rint, -1.0, -1.0);
8848       TEST_f_f (rint, -1.5, -1.0);
8849       TEST_f_f (rint, -2.0, -2.0);
8850       TEST_f_f (rint, 0.1, 0.0);
8851       TEST_f_f (rint, 0.25, 0.0);
8852       TEST_f_f (rint, 0.625, 0.0);
8853       TEST_f_f (rint, -0.1, -0.0);
8854       TEST_f_f (rint, -0.25, -0.0);
8855       TEST_f_f (rint, -0.625, -0.0);
8856       TEST_f_f (rint, 1048576.75, 1048576.0);
8857       TEST_f_f (rint, 2097152.75, 2097152.0);
8858       TEST_f_f (rint, -1048576.75, -1048576.0);
8859       TEST_f_f (rint, -2097152.75, -2097152.0);
8860 #ifndef TEST_FLOAT
8861       TEST_f_f (rint, 70368744177664.75, 70368744177664.0);
8862       TEST_f_f (rint, 140737488355328.75, 140737488355328.0);
8863       TEST_f_f (rint, 281474976710656.75, 281474976710656.0);
8864       TEST_f_f (rint, 562949953421312.75, 562949953421312.0);
8865       TEST_f_f (rint, 1125899906842624.75, 1125899906842624.0);
8866       TEST_f_f (rint, -70368744177664.75, -70368744177664.0);
8867       TEST_f_f (rint, -140737488355328.75, -140737488355328.0);
8868       TEST_f_f (rint, -281474976710656.75, -281474976710656.0);
8869       TEST_f_f (rint, -562949953421312.75, -562949953421312.0);
8870       TEST_f_f (rint, -1125899906842624.75, -1125899906842624.0);
8871 #endif
8872 #ifdef TEST_LDOUBLE
8873       /* The result can only be represented in long double.  */
8874       TEST_f_f (rint, 4503599627370495.5L, 4503599627370495.0L);
8875       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
8876       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
8877       TEST_f_f (rint, 4503599627370496.75L, 4503599627370496.0L);
8878       TEST_f_f (rint, 4503599627370497.5L, 4503599627370497.0L);
8879 # if LDBL_MANT_DIG > 100
8880       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370494.0L);
8881       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370495.0L);
8882       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370496.0L);
8883 # endif
8884       TEST_f_f (rint, -4503599627370495.5L, -4503599627370495.0L);
8885       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
8886       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
8887       TEST_f_f (rint, -4503599627370496.75L, -4503599627370496.0L);
8888       TEST_f_f (rint, -4503599627370497.5L, -4503599627370497.0L);
8889 # if LDBL_MANT_DIG > 100
8890       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370494.0L);
8891       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370495.0L);
8892       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370496.0L);
8893
8894       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
8895       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
8896       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
8897       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740991.0L);
8898       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740992.0L);
8899       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740993.0L);
8900
8901       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
8902       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
8903       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
8904       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740991.0L);
8905       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740992.0L);
8906       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L);
8907 # endif
8908 #endif
8909     }
8910
8911   fesetround (save_round_mode);
8912
8913   END (rint_towardzero);
8914 }
8915
8916 static void
8917 rint_test_downward (void)
8918 {
8919   int save_round_mode;
8920   START (rint_downward);
8921
8922   save_round_mode = fegetround ();
8923
8924   if (!fesetround (FE_DOWNWARD))
8925     {
8926       TEST_f_f (rint, 2.0, 2.0);
8927       TEST_f_f (rint, 1.5, 1.0);
8928       TEST_f_f (rint, 1.0, 1.0);
8929       TEST_f_f (rint, 0.5, 0.0);
8930       TEST_f_f (rint, 0.0, 0.0);
8931       TEST_f_f (rint, minus_zero, minus_zero);
8932       TEST_f_f (rint, -0.5, -1.0);
8933       TEST_f_f (rint, -1.0, -1.0);
8934       TEST_f_f (rint, -1.5, -2.0);
8935       TEST_f_f (rint, -2.0, -2.0);
8936       TEST_f_f (rint, 0.1, 0.0);
8937       TEST_f_f (rint, 0.25, 0.0);
8938       TEST_f_f (rint, 0.625, 0.0);
8939       TEST_f_f (rint, -0.1, -1.0);
8940       TEST_f_f (rint, -0.25, -1.0);
8941       TEST_f_f (rint, -0.625, -1.0);
8942       TEST_f_f (rint, 1048576.75, 1048576.0);
8943       TEST_f_f (rint, 2097152.75, 2097152.0);
8944       TEST_f_f (rint, -1048576.75, -1048577.0);
8945       TEST_f_f (rint, -2097152.75, -2097153.0);
8946 #ifndef TEST_FLOAT
8947       TEST_f_f (rint, 70368744177664.75, 70368744177664.0);
8948       TEST_f_f (rint, 140737488355328.75, 140737488355328.0);
8949       TEST_f_f (rint, 281474976710656.75, 281474976710656.0);
8950       TEST_f_f (rint, 562949953421312.75, 562949953421312.0);
8951       TEST_f_f (rint, 1125899906842624.75, 1125899906842624.0);
8952       TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
8953       TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
8954       TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
8955       TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
8956       TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
8957 #endif
8958 #ifdef TEST_LDOUBLE
8959       /* The result can only be represented in long double.  */
8960       TEST_f_f (rint, 4503599627370495.5L, 4503599627370495.0L);
8961       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
8962       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
8963       TEST_f_f (rint, 4503599627370496.75L, 4503599627370496.0L);
8964       TEST_f_f (rint, 4503599627370497.5L, 4503599627370497.0L);
8965 # if LDBL_MANT_DIG > 100
8966       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370494.0L);
8967       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370495.0L);
8968       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370496.0L);
8969 # endif
8970       TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
8971       TEST_f_f (rint, -4503599627370496.25L, -4503599627370497.0L);
8972       TEST_f_f (rint, -4503599627370496.5L, -4503599627370497.0L);
8973       TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
8974       TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
8975 # if LDBL_MANT_DIG > 100
8976       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
8977       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
8978       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
8979
8980       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
8981       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
8982       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
8983       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740991.0L);
8984       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740992.0L);
8985       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740993.0L);
8986
8987       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740992.0L);
8988       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740993.0L);
8989       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740994.0L);
8990       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
8991       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
8992       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
8993 # endif
8994 #endif
8995     }
8996
8997   fesetround (save_round_mode);
8998
8999   END (rint_downward);
9000 }
9001
9002 static void
9003 rint_test_upward (void)
9004 {
9005   int save_round_mode;
9006   START (rint_upward);
9007
9008   save_round_mode = fegetround ();
9009
9010   if (!fesetround (FE_UPWARD))
9011     {
9012       TEST_f_f (rint, 2.0, 2.0);
9013       TEST_f_f (rint, 1.5, 2.0);
9014       TEST_f_f (rint, 1.0, 1.0);
9015       TEST_f_f (rint, 0.5, 1.0);
9016       TEST_f_f (rint, 0.0, 0.0);
9017       TEST_f_f (rint, minus_zero, minus_zero);
9018       TEST_f_f (rint, -0.5, -0.0);
9019       TEST_f_f (rint, -1.0, -1.0);
9020       TEST_f_f (rint, -1.5, -1.0);
9021       TEST_f_f (rint, -2.0, -2.0);
9022       TEST_f_f (rint, 0.1, 1.0);
9023       TEST_f_f (rint, 0.25, 1.0);
9024       TEST_f_f (rint, 0.625, 1.0);
9025       TEST_f_f (rint, -0.1, -0.0);
9026       TEST_f_f (rint, -0.25, -0.0);
9027       TEST_f_f (rint, -0.625, -0.0);
9028       TEST_f_f (rint, 1048576.75, 1048577.0);
9029       TEST_f_f (rint, 2097152.75, 2097153.0);
9030       TEST_f_f (rint, -1048576.75, -1048576.0);
9031       TEST_f_f (rint, -2097152.75, -2097152.0);
9032 #ifndef TEST_FLOAT
9033       TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
9034       TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
9035       TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
9036       TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
9037       TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
9038       TEST_f_f (rint, -70368744177664.75, -70368744177664.0);
9039       TEST_f_f (rint, -140737488355328.75, -140737488355328.0);
9040       TEST_f_f (rint, -281474976710656.75, -281474976710656.0);
9041       TEST_f_f (rint, -562949953421312.75, -562949953421312.0);
9042       TEST_f_f (rint, -1125899906842624.75, -1125899906842624.0);
9043 #endif
9044 #ifdef TEST_LDOUBLE
9045       /* The result can only be represented in long double.  */
9046       TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
9047       TEST_f_f (rint, 4503599627370496.25L, 4503599627370497.0L);
9048       TEST_f_f (rint, 4503599627370496.5L, 4503599627370497.0L);
9049       TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
9050       TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
9051 # if LDBL_MANT_DIG > 100
9052       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
9053       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
9054       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
9055 # endif
9056       TEST_f_f (rint, -4503599627370495.5L, -4503599627370495.0L);
9057       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
9058       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
9059       TEST_f_f (rint, -4503599627370496.75L, -4503599627370496.0L);
9060       TEST_f_f (rint, -4503599627370497.5L, -4503599627370497.0L);
9061 # if LDBL_MANT_DIG > 100
9062       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370494.0L);
9063       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370495.0L);
9064       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370496.0L);
9065
9066       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740992.0L);
9067       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740993.0L);
9068       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740994.0L);
9069       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
9070       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
9071       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
9072
9073       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
9074       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
9075       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
9076       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740991.0L);
9077       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740992.0L);
9078       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L);
9079 # endif
9080 #endif
9081     }
9082
9083   fesetround (save_round_mode);
9084
9085   END (rint_upward);
9086 }
9087
9088 static void
9089 round_test (void)
9090 {
9091   START (round);
9092
9093   TEST_f_f (round, 0, 0);
9094   TEST_f_f (round, minus_zero, minus_zero);
9095   TEST_f_f (round, 0.2L, 0.0);
9096   TEST_f_f (round, -0.2L, minus_zero);
9097   TEST_f_f (round, 0.5, 1.0);
9098   TEST_f_f (round, -0.5, -1.0);
9099   TEST_f_f (round, 0.8L, 1.0);
9100   TEST_f_f (round, -0.8L, -1.0);
9101   TEST_f_f (round, 1.5, 2.0);
9102   TEST_f_f (round, -1.5, -2.0);
9103   TEST_f_f (round, 0.1, 0.0);
9104   TEST_f_f (round, 0.25, 0.0);
9105   TEST_f_f (round, 0.625, 1.0);
9106   TEST_f_f (round, -0.1, -0.0);
9107   TEST_f_f (round, -0.25, -0.0);
9108   TEST_f_f (round, -0.625, -1.0);
9109   TEST_f_f (round, 2097152.5, 2097153);
9110   TEST_f_f (round, -2097152.5, -2097153);
9111
9112 #ifdef TEST_LDOUBLE
9113   /* The result can only be represented in long double.  */
9114   TEST_f_f (round, 4503599627370495.5L, 4503599627370496.0L);
9115   TEST_f_f (round, 4503599627370496.25L, 4503599627370496.0L);
9116   TEST_f_f (round, 4503599627370496.5L, 4503599627370497.0L);
9117   TEST_f_f (round, 4503599627370496.75L, 4503599627370497.0L);
9118   TEST_f_f (round, 4503599627370497.5L, 4503599627370498.0L);
9119 # if LDBL_MANT_DIG > 100
9120   TEST_f_f (round, 4503599627370494.5000000000001L, 4503599627370495.0L);
9121   TEST_f_f (round, 4503599627370495.5000000000001L, 4503599627370496.0L);
9122   TEST_f_f (round, 4503599627370496.5000000000001L, 4503599627370497.0L);
9123 # endif
9124
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, 9007199254740991.5L, 9007199254740992.0L);
9137   TEST_f_f (round, 9007199254740992.25L, 9007199254740992.0L);
9138   TEST_f_f (round, 9007199254740992.5L, 9007199254740993.0L);
9139   TEST_f_f (round, 9007199254740992.75L, 9007199254740993.0L);
9140   TEST_f_f (round, 9007199254740993.5L, 9007199254740994.0L);
9141
9142   TEST_f_f (round, -9007199254740991.5L, -9007199254740992.0L);
9143   TEST_f_f (round, -9007199254740992.25L, -9007199254740992.0L);
9144   TEST_f_f (round, -9007199254740992.5L, -9007199254740993.0L);
9145   TEST_f_f (round, -9007199254740992.75L, -9007199254740993.0L);
9146   TEST_f_f (round, -9007199254740993.5L, -9007199254740994.0L);
9147
9148 # if LDBL_MANT_DIG > 100
9149   TEST_f_f (round, 9007199254740991.0000000000001L, 9007199254740991.0L);
9150   TEST_f_f (round, 9007199254740992.0000000000001L, 9007199254740992.0L);
9151   TEST_f_f (round, 9007199254740993.0000000000001L, 9007199254740993.0L);
9152   TEST_f_f (round, 9007199254740991.5000000000001L, 9007199254740992.0L);
9153   TEST_f_f (round, 9007199254740992.5000000000001L, 9007199254740993.0L);
9154   TEST_f_f (round, 9007199254740993.5000000000001L, 9007199254740994.0L);
9155
9156   TEST_f_f (round, -9007199254740991.0000000000001L, -9007199254740991.0L);
9157   TEST_f_f (round, -9007199254740992.0000000000001L, -9007199254740992.0L);
9158   TEST_f_f (round, -9007199254740993.0000000000001L, -9007199254740993.0L);
9159   TEST_f_f (round, -9007199254740991.5000000000001L, -9007199254740992.0L);
9160   TEST_f_f (round, -9007199254740992.5000000000001L, -9007199254740993.0L);
9161   TEST_f_f (round, -9007199254740993.5000000000001L, -9007199254740994.0L);
9162 # endif
9163
9164   TEST_f_f (round, 72057594037927935.5L, 72057594037927936.0L);
9165   TEST_f_f (round, 72057594037927936.25L, 72057594037927936.0L);
9166   TEST_f_f (round, 72057594037927936.5L, 72057594037927937.0L);
9167   TEST_f_f (round, 72057594037927936.75L, 72057594037927937.0L);
9168   TEST_f_f (round, 72057594037927937.5L, 72057594037927938.0L);
9169
9170   TEST_f_f (round, -72057594037927935.5L, -72057594037927936.0L);
9171   TEST_f_f (round, -72057594037927936.25L, -72057594037927936.0L);
9172   TEST_f_f (round, -72057594037927936.5L, -72057594037927937.0L);
9173   TEST_f_f (round, -72057594037927936.75L, -72057594037927937.0L);
9174   TEST_f_f (round, -72057594037927937.5L, -72057594037927938.0L);
9175
9176   TEST_f_f (round, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
9177   TEST_f_f (round, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
9178   TEST_f_f (round, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
9179   TEST_f_f (round, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
9180   TEST_f_f (round, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
9181 #endif
9182
9183   END (round);
9184 }
9185
9186
9187 static void
9188 scalb_test (void)
9189 {
9190
9191   START (scalb);
9192
9193   TEST_ff_f (scalb, 2.0, 0.5, nan_value, INVALID_EXCEPTION);
9194   TEST_ff_f (scalb, 3.0, -2.5, nan_value, INVALID_EXCEPTION);
9195
9196   TEST_ff_f (scalb, 0, nan_value, nan_value);
9197   TEST_ff_f (scalb, 1, nan_value, nan_value);
9198
9199   TEST_ff_f (scalb, 1, 0, 1);
9200   TEST_ff_f (scalb, -1, 0, -1);
9201
9202   TEST_ff_f (scalb, 0, plus_infty, nan_value, INVALID_EXCEPTION);
9203   TEST_ff_f (scalb, minus_zero, plus_infty, nan_value, INVALID_EXCEPTION);
9204
9205   TEST_ff_f (scalb, 0, 2, 0);
9206   TEST_ff_f (scalb, minus_zero, -4, minus_zero);
9207   TEST_ff_f (scalb, 0, 0, 0);
9208   TEST_ff_f (scalb, minus_zero, 0, minus_zero);
9209   TEST_ff_f (scalb, 0, -1, 0);
9210   TEST_ff_f (scalb, minus_zero, -10, minus_zero);
9211   TEST_ff_f (scalb, 0, minus_infty, 0);
9212   TEST_ff_f (scalb, minus_zero, minus_infty, minus_zero);
9213
9214   TEST_ff_f (scalb, plus_infty, -1, plus_infty);
9215   TEST_ff_f (scalb, minus_infty, -10, minus_infty);
9216   TEST_ff_f (scalb, plus_infty, 0, plus_infty);
9217   TEST_ff_f (scalb, minus_infty, 0, minus_infty);
9218   TEST_ff_f (scalb, plus_infty, 2, plus_infty);
9219   TEST_ff_f (scalb, minus_infty, 100, minus_infty);
9220
9221   TEST_ff_f (scalb, 0.1L, minus_infty, 0.0);
9222   TEST_ff_f (scalb, -0.1L, minus_infty, minus_zero);
9223
9224   TEST_ff_f (scalb, 1, plus_infty, plus_infty);
9225   TEST_ff_f (scalb, -1, plus_infty, minus_infty);
9226   TEST_ff_f (scalb, plus_infty, plus_infty, plus_infty);
9227   TEST_ff_f (scalb, minus_infty, plus_infty, minus_infty);
9228
9229   TEST_ff_f (scalb, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
9230   TEST_ff_f (scalb, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
9231
9232   TEST_ff_f (scalb, nan_value, 1, nan_value);
9233   TEST_ff_f (scalb, 1, nan_value, nan_value);
9234   TEST_ff_f (scalb, nan_value, 0, nan_value);
9235   TEST_ff_f (scalb, 0, nan_value, nan_value);
9236   TEST_ff_f (scalb, nan_value, plus_infty, nan_value);
9237   TEST_ff_f (scalb, plus_infty, nan_value, nan_value);
9238   TEST_ff_f (scalb, nan_value, nan_value, nan_value);
9239
9240   TEST_ff_f (scalb, 0.8L, 4, 12.8L);
9241   TEST_ff_f (scalb, -0.854375L, 5, -27.34L);
9242
9243   END (scalb);
9244 }
9245
9246
9247 static void
9248 scalbn_test (void)
9249 {
9250
9251   START (scalbn);
9252
9253   TEST_fi_f (scalbn, 0, 0, 0);
9254   TEST_fi_f (scalbn, minus_zero, 0, minus_zero);
9255
9256   TEST_fi_f (scalbn, plus_infty, 1, plus_infty);
9257   TEST_fi_f (scalbn, minus_infty, 1, minus_infty);
9258   TEST_fi_f (scalbn, nan_value, 1, nan_value);
9259
9260   TEST_fi_f (scalbn, 0.8L, 4, 12.8L);
9261   TEST_fi_f (scalbn, -0.854375L, 5, -27.34L);
9262
9263   TEST_fi_f (scalbn, 1, 0L, 1);
9264
9265   TEST_fi_f (scalbn, 1, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9266   TEST_fi_f (scalbn, 1, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9267   TEST_fi_f (scalbn, max_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9268   TEST_fi_f (scalbn, max_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9269   TEST_fi_f (scalbn, min_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9270   TEST_fi_f (scalbn, min_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9271   TEST_fi_f (scalbn, min_value / 4, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9272   TEST_fi_f (scalbn, min_value / 4, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9273
9274   END (scalbn);
9275 }
9276
9277
9278 static void
9279 scalbln_test (void)
9280 {
9281
9282   START (scalbln);
9283
9284   TEST_fl_f (scalbln, 0, 0, 0);
9285   TEST_fl_f (scalbln, minus_zero, 0, minus_zero);
9286
9287   TEST_fl_f (scalbln, plus_infty, 1, plus_infty);
9288   TEST_fl_f (scalbln, minus_infty, 1, minus_infty);
9289   TEST_fl_f (scalbln, nan_value, 1, nan_value);
9290
9291   TEST_fl_f (scalbln, 0.8L, 4, 12.8L);
9292   TEST_fl_f (scalbln, -0.854375L, 5, -27.34L);
9293
9294   TEST_fl_f (scalbln, 1, 0L, 1);
9295
9296   TEST_fi_f (scalbln, 1, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9297   TEST_fi_f (scalbln, 1, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9298   TEST_fi_f (scalbln, max_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9299   TEST_fi_f (scalbln, max_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9300   TEST_fi_f (scalbln, min_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9301   TEST_fi_f (scalbln, min_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9302   TEST_fi_f (scalbln, min_value / 4, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9303   TEST_fi_f (scalbln, min_value / 4, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9304
9305   TEST_fi_f (scalbln, 1, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
9306   TEST_fi_f (scalbln, 1, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9307   TEST_fi_f (scalbln, max_value, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
9308   TEST_fi_f (scalbln, max_value, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9309   TEST_fi_f (scalbln, min_value, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
9310   TEST_fi_f (scalbln, min_value, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9311   TEST_fi_f (scalbln, min_value / 4, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
9312   TEST_fi_f (scalbln, min_value / 4, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9313
9314 #if LONG_MAX >= 0x100000000
9315   TEST_fi_f (scalbln, 1, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
9316   TEST_fi_f (scalbln, 1, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
9317   TEST_fi_f (scalbln, max_value, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
9318   TEST_fi_f (scalbln, max_value, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
9319   TEST_fi_f (scalbln, min_value, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
9320   TEST_fi_f (scalbln, min_value, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
9321   TEST_fi_f (scalbln, min_value / 4, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
9322   TEST_fi_f (scalbln, min_value / 4, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
9323 #endif
9324
9325   END (scalbn);
9326 }
9327
9328
9329 static void
9330 signbit_test (void)
9331 {
9332
9333   START (signbit);
9334
9335   TEST_f_b (signbit, 0, 0);
9336   TEST_f_b (signbit, minus_zero, 1);
9337   TEST_f_b (signbit, plus_infty, 0);
9338   TEST_f_b (signbit, minus_infty, 1);
9339
9340   /* signbit (x) != 0 for x < 0.  */
9341   TEST_f_b (signbit, -1, 1);
9342   /* signbit (x) == 0 for x >= 0.  */
9343   TEST_f_b (signbit, 1, 0);
9344
9345   END (signbit);
9346 }
9347
9348
9349 static void
9350 sin_test (void)
9351 {
9352   errno = 0;
9353   FUNC(sin) (0);
9354   if (errno == ENOSYS)
9355     /* Function not implemented.  */
9356     return;
9357
9358   START (sin);
9359
9360   TEST_f_f (sin, 0, 0);
9361   TEST_f_f (sin, minus_zero, minus_zero);
9362   errno = 0;
9363   TEST_f_f (sin, plus_infty, nan_value, INVALID_EXCEPTION);
9364   check_int ("errno for sin(+inf) == EDOM", errno, EDOM, 0, 0, 0);
9365   errno = 0;
9366   TEST_f_f (sin, minus_infty, nan_value, INVALID_EXCEPTION);
9367   check_int ("errno for sin(-inf) == EDOM", errno, EDOM, 0, 0, 0);
9368   errno = 0;
9369   TEST_f_f (sin, nan_value, nan_value);
9370   check_int ("errno for sin(NaN) unchanged", errno, 0, 0, 0, 0);
9371
9372   TEST_f_f (sin, M_PI_6l, 0.5);
9373   TEST_f_f (sin, -M_PI_6l, -0.5);
9374   TEST_f_f (sin, M_PI_2l, 1);
9375   TEST_f_f (sin, -M_PI_2l, -1);
9376   TEST_f_f (sin, 0.75L, 0.681638760023334166733241952779893935L);
9377
9378   TEST_f_f (sin, 0x1p65, -0.047183876212354673805106149805700013943218L);
9379   TEST_f_f (sin, -0x1p65, 0.047183876212354673805106149805700013943218L);
9380
9381   TEST_f_f (sin, 0x1.7f4134p+103, -6.6703229329788657073304190650534846045235e-08L);
9382
9383 #ifdef TEST_DOUBLE
9384   TEST_f_f (sin, 0.80190127184058835, 0.71867942238767868);
9385   TEST_f_f (sin, 2.522464e-1, 2.4957989804940911e-1);
9386 #endif
9387
9388 #ifndef TEST_FLOAT
9389   TEST_f_f (sin, 1e22, -0.8522008497671888017727058937530293682618L);
9390   TEST_f_f (sin, 0x1p1023, 0.5631277798508840134529434079444683477104L);
9391 #endif
9392
9393 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
9394   TEST_f_f (sin, 0x1p16383L, 0.3893629985894208126948115852610595405563L);
9395 #endif
9396
9397   TEST_f_f (sin, 0x1p+120, 3.77820109360752022655548470056922991960587e-01L);
9398   TEST_f_f (sin, 0x1p+127, 6.23385512955870240370428801097126489001833e-01L);
9399   TEST_f_f (sin, 0x1.fffff8p+127, 4.85786063130487339701113680434728152037092e-02L);
9400   TEST_f_f (sin, 0x1.fffffep+127, -5.21876523333658540551505357019806722935726e-01L);
9401   TEST_f_f (sin, 0x1p+50, 4.96396515208940840876821859865411368093356e-01L);
9402   TEST_f_f (sin, 0x1p+28, -9.86198211836975655703110310527108292055548e-01L);
9403
9404   END (sin);
9405
9406 }
9407
9408
9409 static void
9410 sin_test_tonearest (void)
9411 {
9412   int save_round_mode;
9413   errno = 0;
9414   FUNC(sin) (0);
9415   if (errno == ENOSYS)
9416     /* Function not implemented.  */
9417     return;
9418
9419   START (sin_tonearest);
9420
9421   save_round_mode = fegetround ();
9422
9423   if (!fesetround (FE_TONEAREST))
9424     {
9425       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
9426       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
9427       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
9428       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
9429       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
9430       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
9431       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
9432       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
9433       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
9434       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
9435     }
9436
9437   fesetround (save_round_mode);
9438
9439   END (sin_tonearest);
9440 }
9441
9442
9443 static void
9444 sin_test_towardzero (void)
9445 {
9446   int save_round_mode;
9447   errno = 0;
9448   FUNC(sin) (0);
9449   if (errno == ENOSYS)
9450     /* Function not implemented.  */
9451     return;
9452
9453   START (sin_towardzero);
9454
9455   save_round_mode = fegetround ();
9456
9457   if (!fesetround (FE_TOWARDZERO))
9458     {
9459       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
9460       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
9461       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
9462       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
9463       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
9464       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
9465       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
9466       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
9467       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
9468       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
9469     }
9470
9471   fesetround (save_round_mode);
9472
9473   END (sin_towardzero);
9474 }
9475
9476
9477 static void
9478 sin_test_downward (void)
9479 {
9480   int save_round_mode;
9481   errno = 0;
9482   FUNC(sin) (0);
9483   if (errno == ENOSYS)
9484     /* Function not implemented.  */
9485     return;
9486
9487   START (sin_downward);
9488
9489   save_round_mode = fegetround ();
9490
9491   if (!fesetround (FE_DOWNWARD))
9492     {
9493       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
9494       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
9495       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
9496       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
9497       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
9498       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
9499       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
9500       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
9501       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
9502       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
9503     }
9504
9505   fesetround (save_round_mode);
9506
9507   END (sin_downward);
9508 }
9509
9510
9511 static void
9512 sin_test_upward (void)
9513 {
9514   int save_round_mode;
9515   errno = 0;
9516   FUNC(sin) (0);
9517   if (errno == ENOSYS)
9518     /* Function not implemented.  */
9519     return;
9520
9521   START (sin_upward);
9522
9523   save_round_mode = fegetround ();
9524
9525   if (!fesetround (FE_UPWARD))
9526     {
9527       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
9528       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
9529       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
9530       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
9531       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
9532       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
9533       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
9534       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
9535       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
9536       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
9537     }
9538
9539   fesetround (save_round_mode);
9540
9541   END (sin_upward);
9542 }
9543
9544
9545 static void
9546 sincos_test (void)
9547 {
9548   FLOAT sin_res, cos_res;
9549
9550   errno = 0;
9551   FUNC(sincos) (0, &sin_res, &cos_res);
9552   if (errno == ENOSYS)
9553     /* Function not implemented.  */
9554     return;
9555
9556   START (sincos);
9557
9558   /* sincos is treated differently because it returns void.  */
9559   TEST_extra (sincos, 0, 0, 1);
9560
9561   TEST_extra (sincos, minus_zero, minus_zero, 1);
9562   TEST_extra (sincos, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
9563   TEST_extra (sincos, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
9564   TEST_extra (sincos, nan_value, nan_value, nan_value);
9565
9566   TEST_extra (sincos, M_PI_2l, 1, 0);
9567   TEST_extra (sincos, M_PI_6l, 0.5, 0.86602540378443864676372317075293616L);
9568   TEST_extra (sincos, M_PI_6l*2.0, 0.86602540378443864676372317075293616L, 0.5);
9569   TEST_extra (sincos, 0.75L, 0.681638760023334166733241952779893935L, 0.731688868873820886311838753000084544L);
9570
9571   TEST_extra (sincos, 0x1p65, -0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L);
9572   TEST_extra (sincos, -0x1p65, 0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L);
9573
9574 #ifdef TEST_DOUBLE
9575   TEST_extra (sincos, 0.80190127184058835, 0.71867942238767868, 0.69534156199418473);
9576 #endif
9577
9578 #ifndef TEST_FLOAT
9579   TEST_extra (sincos, 1e22, -0.8522008497671888017727058937530293682618L, 0.5232147853951389454975944733847094921409L);
9580   TEST_extra (sincos, 0x1p1023, 0.5631277798508840134529434079444683477104L, -0.826369834614147994500785680811743734805L);
9581 #endif
9582
9583 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
9584   TEST_extra (sincos, 0x1p16383L, 0.3893629985894208126948115852610595405563L, 0.9210843909921906206874509522505756251609L);
9585 #endif
9586
9587   TEST_extra (sincos, 0x1p+120, 3.77820109360752022655548470056922991960587e-01L, -9.25879022854837867303861764107414946730833e-01L);
9588   TEST_extra (sincos, 0x1p+127, 6.23385512955870240370428801097126489001833e-01L, 7.81914638714960072263910298466369236613162e-01L);
9589   TEST_extra (sincos, 0x1.fffff8p+127, 4.85786063130487339701113680434728152037092e-02L, 9.98819362551949040703862043664101081064641e-01L);
9590   TEST_extra (sincos, 0x1.fffffep+127, -5.21876523333658540551505357019806722935726e-01L, 8.53021039830304158051791467692161107353094e-01L);
9591   TEST_extra (sincos, 0x1p+50, 4.96396515208940840876821859865411368093356e-01L, 8.68095904660550604334592502063501320395739e-01L);
9592   TEST_extra (sincos, 0x1p+28, -9.86198211836975655703110310527108292055548e-01L, -1.65568979490578758865468278195361551113358e-01L);
9593
9594   END (sincos);
9595 }
9596
9597 static void
9598 sinh_test (void)
9599 {
9600   errno = 0;
9601   FUNC(sinh) (0.7L);
9602   if (errno == ENOSYS)
9603     /* Function not implemented.  */
9604     return;
9605
9606   START (sinh);
9607   TEST_f_f (sinh, 0, 0);
9608   TEST_f_f (sinh, minus_zero, minus_zero);
9609
9610 #ifndef TEST_INLINE
9611   TEST_f_f (sinh, plus_infty, plus_infty);
9612   TEST_f_f (sinh, minus_infty, minus_infty);
9613 #endif
9614   TEST_f_f (sinh, nan_value, nan_value);
9615
9616   TEST_f_f (sinh, 0.75L, 0.822316731935829980703661634446913849L);
9617   TEST_f_f (sinh, 0x8p-32L, 1.86264514923095703232705808926175479e-9L);
9618
9619   END (sinh);
9620 }
9621
9622
9623 static void
9624 sinh_test_tonearest (void)
9625 {
9626   int save_round_mode;
9627   errno = 0;
9628   FUNC(sinh) (0);
9629   if (errno == ENOSYS)
9630     /* Function not implemented.  */
9631     return;
9632
9633   START (sinh_tonearest);
9634
9635   save_round_mode = fegetround ();
9636
9637   if (!fesetround (FE_TONEAREST))
9638     {
9639       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
9640       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
9641       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
9642     }
9643
9644   fesetround (save_round_mode);
9645
9646   END (sinh_tonearest);
9647 }
9648
9649
9650 static void
9651 sinh_test_towardzero (void)
9652 {
9653   int save_round_mode;
9654   errno = 0;
9655   FUNC(sinh) (0);
9656   if (errno == ENOSYS)
9657     /* Function not implemented.  */
9658     return;
9659
9660   START (sinh_towardzero);
9661
9662   save_round_mode = fegetround ();
9663
9664   if (!fesetround (FE_TOWARDZERO))
9665     {
9666       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
9667       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
9668       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
9669     }
9670
9671   fesetround (save_round_mode);
9672
9673   END (sinh_towardzero);
9674 }
9675
9676
9677 static void
9678 sinh_test_downward (void)
9679 {
9680   int save_round_mode;
9681   errno = 0;
9682   FUNC(sinh) (0);
9683   if (errno == ENOSYS)
9684     /* Function not implemented.  */
9685     return;
9686
9687   START (sinh_downward);
9688
9689   save_round_mode = fegetround ();
9690
9691   if (!fesetround (FE_DOWNWARD))
9692     {
9693       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
9694       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
9695       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
9696     }
9697
9698   fesetround (save_round_mode);
9699
9700   END (sinh_downward);
9701 }
9702
9703
9704 static void
9705 sinh_test_upward (void)
9706 {
9707   int save_round_mode;
9708   errno = 0;
9709   FUNC(sinh) (0);
9710   if (errno == ENOSYS)
9711     /* Function not implemented.  */
9712     return;
9713
9714   START (sinh_upward);
9715
9716   save_round_mode = fegetround ();
9717
9718   if (!fesetround (FE_UPWARD))
9719     {
9720       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
9721       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
9722       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
9723     }
9724
9725   fesetround (save_round_mode);
9726
9727   END (sinh_upward);
9728 }
9729
9730
9731 static void
9732 sqrt_test (void)
9733 {
9734   errno = 0;
9735   FUNC(sqrt) (1);
9736   if (errno == ENOSYS)
9737     /* Function not implemented.  */
9738     return;
9739
9740   START (sqrt);
9741
9742   TEST_f_f (sqrt, 0, 0);
9743   TEST_f_f (sqrt, nan_value, nan_value);
9744   TEST_f_f (sqrt, plus_infty, plus_infty);
9745
9746   TEST_f_f (sqrt, minus_zero, minus_zero);
9747
9748   /* sqrt (x) == NaN plus invalid exception for x < 0.  */
9749   TEST_f_f (sqrt, -1, nan_value, INVALID_EXCEPTION);
9750   TEST_f_f (sqrt, -max_value, nan_value, INVALID_EXCEPTION);
9751   TEST_f_f (sqrt, minus_infty, nan_value, INVALID_EXCEPTION);
9752   TEST_f_f (sqrt, nan_value, nan_value);
9753
9754   TEST_f_f (sqrt, 2209, 47);
9755   TEST_f_f (sqrt, 4, 2);
9756   TEST_f_f (sqrt, 2, M_SQRT2l);
9757   TEST_f_f (sqrt, 0.25, 0.5);
9758   TEST_f_f (sqrt, 6642.25, 81.5);
9759   TEST_f_f (sqrt, 15190.5625L, 123.25L);
9760   TEST_f_f (sqrt, 0.75L, 0.866025403784438646763723170752936183L);
9761
9762   END (sqrt);
9763 }
9764
9765
9766 static void
9767 tan_test (void)
9768 {
9769   errno = 0;
9770   FUNC(tan) (0);
9771   if (errno == ENOSYS)
9772     /* Function not implemented.  */
9773     return;
9774
9775   START (tan);
9776
9777   TEST_f_f (tan, 0, 0);
9778   TEST_f_f (tan, minus_zero, minus_zero);
9779   errno = 0;
9780   TEST_f_f (tan, plus_infty, nan_value, INVALID_EXCEPTION);
9781   check_int ("errno for tan(Inf) == EDOM", errno, EDOM, 0, 0, 0);
9782   errno = 0;
9783   TEST_f_f (tan, minus_infty, nan_value, INVALID_EXCEPTION);
9784   check_int ("errno for tan(-Inf) == EDOM", errno, EDOM, 0, 0, 0);
9785   errno = 0;
9786   TEST_f_f (tan, nan_value, nan_value);
9787   check_int ("errno for tan(NaN) == 0", errno, 0, 0, 0, 0);
9788
9789   TEST_f_f (tan, M_PI_4l, 1);
9790   TEST_f_f (tan, 0.75L, 0.931596459944072461165202756573936428L);
9791
9792   TEST_f_f (tan, 0x1p65, -0.0472364872359047946798414219288370688827L);
9793   TEST_f_f (tan, -0x1p65, 0.0472364872359047946798414219288370688827L);
9794
9795   TEST_f_f (tan, 0xc.9p-4, 0.9995162902115457818029468900654150261381L);
9796   TEST_f_f (tan, 0xc.908p-4, 0.9997603425502441410973077452249560802034L);
9797   TEST_f_f (tan, 0xc.90cp-4, 0.9998823910588060302788513970802357770031L);
9798   TEST_f_f (tan, 0xc.90ep-4, 0.9999434208994808753305784795924711152508L);
9799   TEST_f_f (tan, 0xc.90fp-4, 0.9999739372166156702433266059635165160515L);
9800   TEST_f_f (tan, 0xc.90f8p-4, 0.9999891957244072765118898375645469865764L);
9801   TEST_f_f (tan, 0xc.90fcp-4, 0.9999968250656122402859679132395522927393L);
9802   TEST_f_f (tan, 0xc.90fdp-4, 0.9999987324100083358016192309006353329444L);
9803   TEST_f_f (tan, 0xc.90fd8p-4, 0.9999996860835706212861509874451585282616L);
9804   TEST_f_f (tan, 0xc.90fdap-4, 0.9999999245021033010474530133665235922808L);
9805   TEST_f_f (tan, 0xc.ap-4, 1.0073556597407272165371804539701396631519L);
9806   TEST_f_f (tan, 0xc.98p-4, 1.0034282930863044654045449407466962736255L);
9807   TEST_f_f (tan, 0xc.94p-4, 1.0014703786820082237342656561856877993328L);
9808   TEST_f_f (tan, 0xc.92p-4, 1.0004928571392300571266638743539017593717L);
9809   TEST_f_f (tan, 0xc.91p-4, 1.0000044544650244953647966900221905361131L);
9810   TEST_f_f (tan, 0xc.90fep-4, 1.0000006397580424009014454926842136804016L);
9811   TEST_f_f (tan, 0xc.90fdcp-4, 1.0000001629206928242190327320047489394217L);
9812   TEST_f_f (tan, 0xc.90fdbp-4, 1.0000000437113909572052640953950483705005L);
9813
9814   TEST_f_f (tan, -0xc.9p-4, -0.9995162902115457818029468900654150261381L);
9815   TEST_f_f (tan, -0xc.908p-4, -0.9997603425502441410973077452249560802034L);
9816   TEST_f_f (tan, -0xc.90cp-4, -0.9998823910588060302788513970802357770031L);
9817   TEST_f_f (tan, -0xc.90ep-4, -0.9999434208994808753305784795924711152508L);
9818   TEST_f_f (tan, -0xc.90fp-4, -0.9999739372166156702433266059635165160515L);
9819   TEST_f_f (tan, -0xc.90f8p-4, -0.9999891957244072765118898375645469865764L);
9820   TEST_f_f (tan, -0xc.90fcp-4, -0.9999968250656122402859679132395522927393L);
9821   TEST_f_f (tan, -0xc.90fdp-4, -0.9999987324100083358016192309006353329444L);
9822   TEST_f_f (tan, -0xc.90fd8p-4, -0.9999996860835706212861509874451585282616L);
9823   TEST_f_f (tan, -0xc.90fdap-4, -0.9999999245021033010474530133665235922808L);
9824   TEST_f_f (tan, -0xc.ap-4, -1.0073556597407272165371804539701396631519L);
9825   TEST_f_f (tan, -0xc.98p-4, -1.0034282930863044654045449407466962736255L);
9826   TEST_f_f (tan, -0xc.94p-4, -1.0014703786820082237342656561856877993328L);
9827   TEST_f_f (tan, -0xc.92p-4, -1.0004928571392300571266638743539017593717L);
9828   TEST_f_f (tan, -0xc.91p-4, -1.0000044544650244953647966900221905361131L);
9829   TEST_f_f (tan, -0xc.90fep-4, -1.0000006397580424009014454926842136804016L);
9830   TEST_f_f (tan, -0xc.90fdcp-4, -1.0000001629206928242190327320047489394217L);
9831   TEST_f_f (tan, -0xc.90fdbp-4, -1.0000000437113909572052640953950483705005L);
9832
9833 #ifndef TEST_FLOAT
9834   TEST_f_f (tan, 1e22, -1.628778225606898878549375936939548513545L);
9835   TEST_f_f (tan, 0x1p1023, -0.6814476476066215012854144040167365190368L);
9836 #endif
9837
9838 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
9839   TEST_f_f (tan, 0x1p16383L, 0.422722393732022337800504160054440141575L);
9840 #endif
9841
9842   END (tan);
9843 }
9844
9845
9846 static void
9847 tan_test_tonearest (void)
9848 {
9849   int save_round_mode;
9850   errno = 0;
9851   FUNC(tan) (0);
9852   if (errno == ENOSYS)
9853     /* Function not implemented.  */
9854     return;
9855
9856   START (tan_tonearest);
9857
9858   save_round_mode = fegetround ();
9859
9860   if (!fesetround (FE_TONEAREST))
9861     {
9862       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
9863       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
9864       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
9865       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
9866       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
9867       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
9868       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
9869       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
9870       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
9871       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
9872     }
9873
9874   fesetround (save_round_mode);
9875
9876   END (tan_tonearest);
9877 }
9878
9879
9880 static void
9881 tan_test_towardzero (void)
9882 {
9883   int save_round_mode;
9884   errno = 0;
9885   FUNC(tan) (0);
9886   if (errno == ENOSYS)
9887     /* Function not implemented.  */
9888     return;
9889
9890   START (tan_towardzero);
9891
9892   save_round_mode = fegetround ();
9893
9894   if (!fesetround (FE_TOWARDZERO))
9895     {
9896       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
9897       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
9898       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
9899       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
9900       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
9901       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
9902       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
9903       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
9904       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
9905       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
9906     }
9907
9908   fesetround (save_round_mode);
9909
9910   END (tan_towardzero);
9911 }
9912
9913
9914 static void
9915 tan_test_downward (void)
9916 {
9917   int save_round_mode;
9918   errno = 0;
9919   FUNC(tan) (0);
9920   if (errno == ENOSYS)
9921     /* Function not implemented.  */
9922     return;
9923
9924   START (tan_downward);
9925
9926   save_round_mode = fegetround ();
9927
9928   if (!fesetround (FE_DOWNWARD))
9929     {
9930       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
9931       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
9932       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
9933       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
9934       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
9935       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
9936       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
9937       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
9938       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
9939       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
9940     }
9941
9942   fesetround (save_round_mode);
9943
9944   END (tan_downward);
9945 }
9946
9947
9948 static void
9949 tan_test_upward (void)
9950 {
9951   int save_round_mode;
9952   errno = 0;
9953   FUNC(tan) (0);
9954   if (errno == ENOSYS)
9955     /* Function not implemented.  */
9956     return;
9957
9958   START (tan_upward);
9959
9960   save_round_mode = fegetround ();
9961
9962   if (!fesetround (FE_UPWARD))
9963     {
9964       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
9965       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
9966       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
9967       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
9968       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
9969       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
9970       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
9971       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
9972       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
9973       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
9974     }
9975
9976   fesetround (save_round_mode);
9977
9978   END (tan_upward);
9979 }
9980
9981
9982 static void
9983 tanh_test (void)
9984 {
9985   errno = 0;
9986   FUNC(tanh) (0.7L);
9987   if (errno == ENOSYS)
9988     /* Function not implemented.  */
9989     return;
9990
9991   START (tanh);
9992
9993   TEST_f_f (tanh, 0, 0);
9994   TEST_f_f (tanh, minus_zero, minus_zero);
9995
9996 #ifndef TEST_INLINE
9997   TEST_f_f (tanh, plus_infty, 1);
9998   TEST_f_f (tanh, minus_infty, -1);
9999 #endif
10000   TEST_f_f (tanh, nan_value, nan_value);
10001
10002   TEST_f_f (tanh, 0.75L, 0.635148952387287319214434357312496495L);
10003   TEST_f_f (tanh, -0.75L, -0.635148952387287319214434357312496495L);
10004
10005   TEST_f_f (tanh, 1.0L, 0.7615941559557648881194582826047935904L);
10006   TEST_f_f (tanh, -1.0L, -0.7615941559557648881194582826047935904L);
10007
10008   /* 2^-57  */
10009   TEST_f_f (tanh, 0x1p-57L, 6.938893903907228377647697925567626953125e-18L);
10010
10011   END (tanh);
10012 }
10013
10014 static void
10015 tgamma_test (void)
10016 {
10017   errno = 0;
10018   FUNC(tgamma) (1);
10019   if (errno == ENOSYS)
10020     /* Function not implemented.  */
10021     return;
10022
10023   START (tgamma);
10024
10025   TEST_f_f (tgamma, plus_infty, plus_infty);
10026   TEST_f_f (tgamma, max_value, plus_infty, OVERFLOW_EXCEPTION);
10027   TEST_f_f (tgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
10028   TEST_f_f (tgamma, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
10029   /* tgamma (x) == NaN plus invalid exception for integer x <= 0.  */
10030   TEST_f_f (tgamma, -2, nan_value, INVALID_EXCEPTION);
10031   TEST_f_f (tgamma, -max_value, nan_value, INVALID_EXCEPTION);
10032   TEST_f_f (tgamma, minus_infty, nan_value, INVALID_EXCEPTION);
10033   TEST_f_f (tgamma, nan_value, nan_value);
10034
10035   TEST_f_f (tgamma, 0.5, M_SQRT_PIl);
10036   TEST_f_f (tgamma, -0.5, -M_2_SQRT_PIl);
10037
10038   TEST_f_f (tgamma, 1, 1);
10039   TEST_f_f (tgamma, 4, 6);
10040
10041   TEST_f_f (tgamma, 0.7L, 1.29805533264755778568117117915281162L);
10042   TEST_f_f (tgamma, 1.2L, 0.918168742399760610640951655185830401L);
10043
10044   END (tgamma);
10045 }
10046
10047
10048 static void
10049 trunc_test (void)
10050 {
10051   START (trunc);
10052
10053   TEST_f_f (trunc, plus_infty, plus_infty);
10054   TEST_f_f (trunc, minus_infty, minus_infty);
10055   TEST_f_f (trunc, nan_value, nan_value);
10056
10057   TEST_f_f (trunc, 0, 0);
10058   TEST_f_f (trunc, minus_zero, minus_zero);
10059   TEST_f_f (trunc, 0.1, 0);
10060   TEST_f_f (trunc, 0.25, 0);
10061   TEST_f_f (trunc, 0.625, 0);
10062   TEST_f_f (trunc, -0.1, minus_zero);
10063   TEST_f_f (trunc, -0.25, minus_zero);
10064   TEST_f_f (trunc, -0.625, minus_zero);
10065   TEST_f_f (trunc, 1, 1);
10066   TEST_f_f (trunc, -1, -1);
10067   TEST_f_f (trunc, 1.625, 1);
10068   TEST_f_f (trunc, -1.625, -1);
10069
10070   TEST_f_f (trunc, 1048580.625L, 1048580L);
10071   TEST_f_f (trunc, -1048580.625L, -1048580L);
10072
10073   TEST_f_f (trunc, 8388610.125L, 8388610.0L);
10074   TEST_f_f (trunc, -8388610.125L, -8388610.0L);
10075
10076   TEST_f_f (trunc, 4294967296.625L, 4294967296.0L);
10077   TEST_f_f (trunc, -4294967296.625L, -4294967296.0L);
10078
10079 #ifdef TEST_LDOUBLE
10080   /* The result can only be represented in long double.  */
10081   TEST_f_f (trunc, 4503599627370495.5L, 4503599627370495.0L);
10082   TEST_f_f (trunc, 4503599627370496.25L, 4503599627370496.0L);
10083   TEST_f_f (trunc, 4503599627370496.5L, 4503599627370496.0L);
10084   TEST_f_f (trunc, 4503599627370496.75L, 4503599627370496.0L);
10085   TEST_f_f (trunc, 4503599627370497.5L, 4503599627370497.0L);
10086
10087 # if LDBL_MANT_DIG > 100
10088   TEST_f_f (trunc, 4503599627370494.5000000000001L, 4503599627370494.0L);
10089   TEST_f_f (trunc, 4503599627370495.5000000000001L, 4503599627370495.0L);
10090   TEST_f_f (trunc, 4503599627370496.5000000000001L, 4503599627370496.0L);
10091 # endif
10092
10093   TEST_f_f (trunc, -4503599627370495.5L, -4503599627370495.0L);
10094   TEST_f_f (trunc, -4503599627370496.25L, -4503599627370496.0L);
10095   TEST_f_f (trunc, -4503599627370496.5L, -4503599627370496.0L);
10096   TEST_f_f (trunc, -4503599627370496.75L, -4503599627370496.0L);
10097   TEST_f_f (trunc, -4503599627370497.5L, -4503599627370497.0L);
10098
10099 # if LDBL_MANT_DIG > 100
10100   TEST_f_f (trunc, -4503599627370494.5000000000001L, -4503599627370494.0L);
10101   TEST_f_f (trunc, -4503599627370495.5000000000001L, -4503599627370495.0L);
10102   TEST_f_f (trunc, -4503599627370496.5000000000001L, -4503599627370496.0L);
10103 # endif
10104
10105   TEST_f_f (trunc, 9007199254740991.5L, 9007199254740991.0L);
10106   TEST_f_f (trunc, 9007199254740992.25L, 9007199254740992.0L);
10107   TEST_f_f (trunc, 9007199254740992.5L, 9007199254740992.0L);
10108   TEST_f_f (trunc, 9007199254740992.75L, 9007199254740992.0L);
10109   TEST_f_f (trunc, 9007199254740993.5L, 9007199254740993.0L);
10110
10111 # if LDBL_MANT_DIG > 100
10112   TEST_f_f (trunc, 9007199254740991.0000000000001L, 9007199254740991.0L);
10113   TEST_f_f (trunc, 9007199254740992.0000000000001L, 9007199254740992.0L);
10114   TEST_f_f (trunc, 9007199254740993.0000000000001L, 9007199254740993.0L);
10115   TEST_f_f (trunc, 9007199254740991.5000000000001L, 9007199254740991.0L);
10116   TEST_f_f (trunc, 9007199254740992.5000000000001L, 9007199254740992.0L);
10117   TEST_f_f (trunc, 9007199254740993.5000000000001L, 9007199254740993.0L);
10118 # endif
10119
10120   TEST_f_f (trunc, -9007199254740991.5L, -9007199254740991.0L);
10121   TEST_f_f (trunc, -9007199254740992.25L, -9007199254740992.0L);
10122   TEST_f_f (trunc, -9007199254740992.5L, -9007199254740992.0L);
10123   TEST_f_f (trunc, -9007199254740992.75L, -9007199254740992.0L);
10124   TEST_f_f (trunc, -9007199254740993.5L, -9007199254740993.0L);
10125
10126 # if LDBL_MANT_DIG > 100
10127   TEST_f_f (trunc, -9007199254740991.0000000000001L, -9007199254740991.0L);
10128   TEST_f_f (trunc, -9007199254740992.0000000000001L, -9007199254740992.0L);
10129   TEST_f_f (trunc, -9007199254740993.0000000000001L, -9007199254740993.0L);
10130   TEST_f_f (trunc, -9007199254740991.5000000000001L, -9007199254740991.0L);
10131   TEST_f_f (trunc, -9007199254740992.5000000000001L, -9007199254740992.0L);
10132   TEST_f_f (trunc, -9007199254740993.5000000000001L, -9007199254740993.0L);
10133 # endif
10134
10135   TEST_f_f (trunc, 72057594037927935.5L, 72057594037927935.0L);
10136   TEST_f_f (trunc, 72057594037927936.25L, 72057594037927936.0L);
10137   TEST_f_f (trunc, 72057594037927936.5L, 72057594037927936.0L);
10138   TEST_f_f (trunc, 72057594037927936.75L, 72057594037927936.0L);
10139   TEST_f_f (trunc, 72057594037927937.5L, 72057594037927937.0L);
10140
10141   TEST_f_f (trunc, -72057594037927935.5L, -72057594037927935.0L);
10142   TEST_f_f (trunc, -72057594037927936.25L, -72057594037927936.0L);
10143   TEST_f_f (trunc, -72057594037927936.5L, -72057594037927936.0L);
10144   TEST_f_f (trunc, -72057594037927936.75L, -72057594037927936.0L);
10145   TEST_f_f (trunc, -72057594037927937.5L, -72057594037927937.0L);
10146
10147   TEST_f_f (trunc, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
10148   TEST_f_f (trunc, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
10149   TEST_f_f (trunc, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
10150   TEST_f_f (trunc, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
10151   TEST_f_f (trunc, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
10152 #endif
10153
10154   END (trunc);
10155 }
10156
10157 static void
10158 y0_test (void)
10159 {
10160   FLOAT s, c;
10161   errno = 0;
10162   FUNC (sincos) (0, &s, &c);
10163   if (errno == ENOSYS)
10164     /* Required function not implemented.  */
10165     return;
10166   FUNC(y0) (1);
10167   if (errno == ENOSYS)
10168     /* Function not implemented.  */
10169     return;
10170
10171   /* y0 is the Bessel function of the second kind of order 0 */
10172   START (y0);
10173
10174   TEST_f_f (y0, -1.0, minus_infty, INVALID_EXCEPTION);
10175   TEST_f_f (y0, -max_value, minus_infty, INVALID_EXCEPTION);
10176   TEST_f_f (y0, 0.0, minus_infty);
10177   TEST_f_f (y0, nan_value, nan_value);
10178   TEST_f_f (y0, plus_infty, 0);
10179
10180   TEST_f_f (y0, 0.125L, -1.38968062514384052915582277745018693L);
10181   TEST_f_f (y0, 0.75L, -0.137172769385772397522814379396581855L);
10182   TEST_f_f (y0, 1.0, 0.0882569642156769579829267660235151628L);
10183   TEST_f_f (y0, 1.5, 0.382448923797758843955068554978089862L);
10184   TEST_f_f (y0, 2.0, 0.510375672649745119596606592727157873L);
10185   TEST_f_f (y0, 8.0, 0.223521489387566220527323400498620359L);
10186   TEST_f_f (y0, 10.0, 0.0556711672835993914244598774101900481L);
10187
10188   TEST_f_f (y0, 0x1.3ffp+74L, 1.818984347516051243459467456433028748678e-12L);
10189
10190 #ifndef TEST_FLOAT
10191   /* Bug 14155: spurious exception may occur.  */
10192   TEST_f_f (y0, 0x1.ff00000000002p+840L, 1.846591691699331493194965158699937660696e-127L, UNDERFLOW_EXCEPTION_OK);
10193 #endif
10194
10195   END (y0);
10196 }
10197
10198
10199 static void
10200 y1_test (void)
10201 {
10202   FLOAT s, c;
10203   errno = 0;
10204   FUNC (sincos) (0, &s, &c);
10205   if (errno == ENOSYS)
10206     /* Required function not implemented.  */
10207     return;
10208   FUNC(y1) (1);
10209   if (errno == ENOSYS)
10210     /* Function not implemented.  */
10211     return;
10212
10213   /* y1 is the Bessel function of the second kind of order 1 */
10214   START (y1);
10215
10216   TEST_f_f (y1, -1.0, minus_infty, INVALID_EXCEPTION);
10217   TEST_f_f (y1, -max_value, minus_infty, INVALID_EXCEPTION);
10218   TEST_f_f (y1, 0.0, minus_infty);
10219   TEST_f_f (y1, plus_infty, 0);
10220   TEST_f_f (y1, nan_value, nan_value);
10221
10222   TEST_f_f (y1, 0.125L, -5.19993611253477499595928744876579921L);
10223   TEST_f_f (y1, 0.75L, -1.03759455076928541973767132140642198L);
10224   TEST_f_f (y1, 1.0, -0.781212821300288716547150000047964821L);
10225   TEST_f_f (y1, 1.5, -0.412308626973911295952829820633445323L);
10226   TEST_f_f (y1, 2.0, -0.107032431540937546888370772277476637L);
10227   TEST_f_f (y1, 8.0, -0.158060461731247494255555266187483550L);
10228   TEST_f_f (y1, 10.0, 0.249015424206953883923283474663222803L);
10229
10230   /* Bug 14155: spurious exception may occur.  */
10231   TEST_f_f (y1, 0x1.27e204p+99L, -8.881610148467797208469612080785210013461e-16L, UNDERFLOW_EXCEPTION_OK);
10232
10233 #ifndef TEST_FLOAT
10234   /* Bug 14155: spurious exception may occur.  */
10235   TEST_f_f (y1, 0x1.001000001p+593L, 3.927269966354206207832593635798954916263e-90L, UNDERFLOW_EXCEPTION_OK);
10236 #endif
10237
10238   END (y1);
10239 }
10240
10241
10242 static void
10243 yn_test (void)
10244 {
10245   FLOAT s, c;
10246   errno = 0;
10247   FUNC (sincos) (0, &s, &c);
10248   if (errno == ENOSYS)
10249     /* Required function not implemented.  */
10250     return;
10251   FUNC(yn) (1, 1);
10252   if (errno == ENOSYS)
10253     /* Function not implemented.  */
10254     return;
10255
10256   /* yn is the Bessel function of the second kind of order n */
10257   START (yn);
10258
10259   /* yn (0, x) == y0 (x)  */
10260   TEST_ff_f (yn, 0, -1.0, minus_infty, INVALID_EXCEPTION);
10261   TEST_ff_f (yn, 0, -max_value, minus_infty, INVALID_EXCEPTION);
10262   TEST_ff_f (yn, 0, 0.0, minus_infty);
10263   TEST_ff_f (yn, 0, nan_value, nan_value);
10264   TEST_ff_f (yn, 0, plus_infty, 0);
10265
10266   TEST_ff_f (yn, 0, 0.125L, -1.38968062514384052915582277745018693L);
10267   TEST_ff_f (yn, 0, 0.75L, -0.137172769385772397522814379396581855L);
10268   TEST_ff_f (yn, 0, 1.0, 0.0882569642156769579829267660235151628L);
10269   TEST_ff_f (yn, 0, 1.5, 0.382448923797758843955068554978089862L);
10270   TEST_ff_f (yn, 0, 2.0, 0.510375672649745119596606592727157873L);
10271   TEST_ff_f (yn, 0, 8.0, 0.223521489387566220527323400498620359L);
10272   TEST_ff_f (yn, 0, 10.0, 0.0556711672835993914244598774101900481L);
10273
10274   /* yn (1, x) == y1 (x)  */
10275   TEST_ff_f (yn, 1, -1.0, minus_infty, INVALID_EXCEPTION);
10276   TEST_ff_f (yn, 1, 0.0, minus_infty);
10277   TEST_ff_f (yn, 1, plus_infty, 0);
10278   TEST_ff_f (yn, 1, nan_value, nan_value);
10279
10280   TEST_ff_f (yn, 1, 0.125L, -5.19993611253477499595928744876579921L);
10281   TEST_ff_f (yn, 1, 0.75L, -1.03759455076928541973767132140642198L);
10282   TEST_ff_f (yn, 1, 1.0, -0.781212821300288716547150000047964821L);
10283   TEST_ff_f (yn, 1, 1.5, -0.412308626973911295952829820633445323L);
10284   TEST_ff_f (yn, 1, 2.0, -0.107032431540937546888370772277476637L);
10285   TEST_ff_f (yn, 1, 8.0, -0.158060461731247494255555266187483550L);
10286   TEST_ff_f (yn, 1, 10.0, 0.249015424206953883923283474663222803L);
10287
10288   /* yn (3, x)  */
10289   TEST_ff_f (yn, 3, plus_infty, 0);
10290   TEST_ff_f (yn, 3, nan_value, nan_value);
10291
10292   TEST_ff_f (yn, 3, 0.125L, -2612.69757350066712600220955744091741L);
10293   TEST_ff_f (yn, 3, 0.75L, -12.9877176234475433186319774484809207L);
10294   TEST_ff_f (yn, 3, 1.0, -5.82151760596472884776175706442981440L);
10295   TEST_ff_f (yn, 3, 2.0, -1.12778377684042778608158395773179238L);
10296   TEST_ff_f (yn, 3, 10.0, -0.251362657183837329779204747654240998L);
10297
10298   /* yn (10, x)  */
10299   TEST_ff_f (yn, 10, plus_infty, 0);
10300   TEST_ff_f (yn, 10, nan_value, nan_value);
10301
10302   TEST_ff_f (yn, 10, 0.125L, -127057845771019398.252538486899753195L);
10303   TEST_ff_f (yn, 10, 0.75L, -2133501638.90573424452445412893839236L);
10304   TEST_ff_f (yn, 10, 1.0, -121618014.278689189288130426667971145L);
10305   TEST_ff_f (yn, 10, 2.0, -129184.542208039282635913145923304214L);
10306   TEST_ff_f (yn, 10, 10.0, -0.359814152183402722051986577343560609L);
10307
10308   /* Check whether yn returns correct value for LDBL_MIN, DBL_MIN,
10309      and FLT_MIN.  See Bug 14173.  */
10310   TEST_ff_f (yn, 10, min_value, minus_infty, OVERFLOW_EXCEPTION);
10311
10312   errno = 0;
10313   TEST_ff_f (yn, 10, min_value, minus_infty, OVERFLOW_EXCEPTION);
10314   check_int ("errno for yn(10,-min) == ERANGE", errno, ERANGE, 0, 0, 0);
10315
10316   END (yn);
10317 }
10318
10319
10320 static void
10321 significand_test (void)
10322 {
10323   /* significand returns the mantissa of the exponential representation.  */
10324   START (significand);
10325
10326   TEST_f_f (significand, 4.0, 1.0);
10327   TEST_f_f (significand, 6.0, 1.5);
10328   TEST_f_f (significand, 8.0, 1.0);
10329
10330   END (significand);
10331 }
10332
10333
10334 static void
10335 initialize (void)
10336 {
10337   fpstack_test ("start *init*");
10338   plus_zero = 0.0;
10339   nan_value = plus_zero / plus_zero;    /* Suppress GCC warning */
10340
10341   minus_zero = FUNC(copysign) (0.0, -1.0);
10342   plus_infty = CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF,
10343                        HUGE_VALL, HUGE_VAL, HUGE_VALF);
10344   minus_infty = CHOOSE (-HUGE_VALL, -HUGE_VAL, -HUGE_VALF,
10345                         -HUGE_VALL, -HUGE_VAL, -HUGE_VALF);
10346   max_value = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
10347                       LDBL_MAX, DBL_MAX, FLT_MAX);
10348   min_value = CHOOSE (LDBL_MIN, DBL_MIN, FLT_MIN,
10349                       LDBL_MIN, DBL_MIN, FLT_MIN);
10350   min_subnorm_value = CHOOSE (__LDBL_DENORM_MIN__,
10351                               __DBL_DENORM_MIN__,
10352                               __FLT_DENORM_MIN__,
10353                               __LDBL_DENORM_MIN__,
10354                               __DBL_DENORM_MIN__,
10355                               __FLT_DENORM_MIN__);
10356
10357   (void) &plus_zero;
10358   (void) &nan_value;
10359   (void) &minus_zero;
10360   (void) &plus_infty;
10361   (void) &minus_infty;
10362   (void) &max_value;
10363   (void) &min_value;
10364   (void) &min_subnorm_value;
10365
10366   /* Clear all exceptions.  From now on we must not get random exceptions.  */
10367   feclearexcept (FE_ALL_EXCEPT);
10368
10369   /* Test to make sure we start correctly.  */
10370   fpstack_test ("end *init*");
10371 }
10372
10373 /* Definitions of arguments for argp functions.  */
10374 static const struct argp_option options[] =
10375 {
10376   { "verbose", 'v', "NUMBER", 0, "Level of verbosity (0..3)"},
10377   { "ulps-file", 'u', NULL, 0, "Output ulps to file ULPs"},
10378   { "no-max-error", 'f', NULL, 0,
10379     "Don't output maximal errors of functions"},
10380   { "no-points", 'p', NULL, 0,
10381     "Don't output results of functions invocations"},
10382   { "ignore-max-ulp", 'i', "yes/no", 0,
10383     "Ignore given maximal errors"},
10384   { NULL, 0, NULL, 0, NULL }
10385 };
10386
10387 /* Short description of program.  */
10388 static const char doc[] = "Math test suite: " TEST_MSG ;
10389
10390 /* Prototype for option handler.  */
10391 static error_t parse_opt (int key, char *arg, struct argp_state *state);
10392
10393 /* Data structure to communicate with argp functions.  */
10394 static struct argp argp =
10395 {
10396   options, parse_opt, NULL, doc,
10397 };
10398
10399
10400 /* Handle program arguments.  */
10401 static error_t
10402 parse_opt (int key, char *arg, struct argp_state *state)
10403 {
10404   switch (key)
10405     {
10406     case 'f':
10407       output_max_error = 0;
10408       break;
10409     case 'i':
10410       if (strcmp (arg, "yes") == 0)
10411         ignore_max_ulp = 1;
10412       else if (strcmp (arg, "no") == 0)
10413         ignore_max_ulp = 0;
10414       break;
10415     case 'p':
10416       output_points = 0;
10417       break;
10418     case 'u':
10419       output_ulps = 1;
10420       break;
10421     case 'v':
10422       if (optarg)
10423         verbose = (unsigned int) strtoul (optarg, NULL, 0);
10424       else
10425         verbose = 3;
10426       break;
10427     default:
10428       return ARGP_ERR_UNKNOWN;
10429     }
10430   return 0;
10431 }
10432
10433 #if 0
10434 /* function to check our ulp calculation.  */
10435 void
10436 check_ulp (void)
10437 {
10438   int i;
10439
10440   FLOAT u, diff, ulp;
10441   /* This gives one ulp.  */
10442   u = FUNC(nextafter) (10, 20);
10443   check_equal (10.0, u, 1, &diff, &ulp);
10444   printf ("One ulp: % .4" PRINTF_NEXPR "\n", ulp);
10445
10446   /* This gives one more ulp.  */
10447   u = FUNC(nextafter) (u, 20);
10448   check_equal (10.0, u, 2, &diff, &ulp);
10449   printf ("two ulp: % .4" PRINTF_NEXPR "\n", ulp);
10450
10451   /* And now calculate 100 ulp.  */
10452   for (i = 2; i < 100; i++)
10453     u = FUNC(nextafter) (u, 20);
10454   check_equal (10.0, u, 100, &diff, &ulp);
10455   printf ("100 ulp: % .4" PRINTF_NEXPR "\n", ulp);
10456 }
10457 #endif
10458
10459 int
10460 main (int argc, char **argv)
10461 {
10462
10463   int remaining;
10464
10465   verbose = 1;
10466   output_ulps = 0;
10467   output_max_error = 1;
10468   output_points = 1;
10469   /* XXX set to 0 for releases.  */
10470   ignore_max_ulp = 0;
10471
10472   /* Parse and process arguments.  */
10473   argp_parse (&argp, argc, argv, 0, &remaining, NULL);
10474
10475   if (remaining != argc)
10476     {
10477       fprintf (stderr, "wrong number of arguments");
10478       argp_help (&argp, stdout, ARGP_HELP_SEE, program_invocation_short_name);
10479       exit (EXIT_FAILURE);
10480     }
10481
10482   if (output_ulps)
10483     {
10484       ulps_file = fopen ("ULPs", "a");
10485       if (ulps_file == NULL)
10486         {
10487           perror ("can't open file `ULPs' for writing: ");
10488           exit (1);
10489         }
10490     }
10491
10492
10493   initialize ();
10494   printf (TEST_MSG);
10495
10496 #if 0
10497   check_ulp ();
10498 #endif
10499
10500   /* Keep the tests a wee bit ordered (according to ISO C99).  */
10501   /* Classification macros:  */
10502   finite_test ();
10503   fpclassify_test ();
10504   isfinite_test ();
10505   isinf_test ();
10506   isnan_test ();
10507   isnormal_test ();
10508   signbit_test ();
10509
10510   /* Trigonometric functions:  */
10511   acos_test ();
10512   acos_test_tonearest ();
10513   acos_test_towardzero ();
10514   acos_test_downward ();
10515   acos_test_upward ();
10516   asin_test ();
10517   asin_test_tonearest ();
10518   asin_test_towardzero ();
10519   asin_test_downward ();
10520   asin_test_upward ();
10521   atan_test ();
10522   atan2_test ();
10523   cos_test ();
10524   cos_test_tonearest ();
10525   cos_test_towardzero ();
10526   cos_test_downward ();
10527   cos_test_upward ();
10528   sin_test ();
10529   sin_test_tonearest ();
10530   sin_test_towardzero ();
10531   sin_test_downward ();
10532   sin_test_upward ();
10533   sincos_test ();
10534   tan_test ();
10535   tan_test_tonearest ();
10536   tan_test_towardzero ();
10537   tan_test_downward ();
10538   tan_test_upward ();
10539
10540   /* Hyperbolic functions:  */
10541   acosh_test ();
10542   asinh_test ();
10543   atanh_test ();
10544   cosh_test ();
10545   cosh_test_tonearest ();
10546   cosh_test_towardzero ();
10547   cosh_test_downward ();
10548   cosh_test_upward ();
10549   sinh_test ();
10550   sinh_test_tonearest ();
10551   sinh_test_towardzero ();
10552   sinh_test_downward ();
10553   sinh_test_upward ();
10554   tanh_test ();
10555
10556   /* Exponential and logarithmic functions:  */
10557   exp_test ();
10558   exp_test_tonearest ();
10559   exp_test_towardzero ();
10560   exp_test_downward ();
10561   exp_test_upward ();
10562   exp10_test ();
10563   exp2_test ();
10564   expm1_test ();
10565   frexp_test ();
10566   ldexp_test ();
10567   log_test ();
10568   log10_test ();
10569   log1p_test ();
10570   log2_test ();
10571   logb_test ();
10572   logb_test_downward ();
10573   modf_test ();
10574   ilogb_test ();
10575   scalb_test ();
10576   scalbn_test ();
10577   scalbln_test ();
10578   significand_test ();
10579
10580   /* Power and absolute value functions:  */
10581   cbrt_test ();
10582   fabs_test ();
10583   hypot_test ();
10584   pow_test ();
10585   pow_test_tonearest ();
10586   pow_test_towardzero ();
10587   pow_test_downward ();
10588   pow_test_upward ();
10589   sqrt_test ();
10590
10591   /* Error and gamma functions:  */
10592   erf_test ();
10593   erfc_test ();
10594   gamma_test ();
10595   lgamma_test ();
10596   tgamma_test ();
10597
10598   /* Nearest integer functions:  */
10599   ceil_test ();
10600   floor_test ();
10601   nearbyint_test ();
10602   rint_test ();
10603   rint_test_tonearest ();
10604   rint_test_towardzero ();
10605   rint_test_downward ();
10606   rint_test_upward ();
10607   lrint_test ();
10608   lrint_test_tonearest ();
10609   lrint_test_towardzero ();
10610   lrint_test_downward ();
10611   lrint_test_upward ();
10612   llrint_test ();
10613   llrint_test_tonearest ();
10614   llrint_test_towardzero ();
10615   llrint_test_downward ();
10616   llrint_test_upward ();
10617   round_test ();
10618   lround_test ();
10619   llround_test ();
10620   trunc_test ();
10621
10622   /* Remainder functions:  */
10623   fmod_test ();
10624   remainder_test ();
10625   remquo_test ();
10626
10627   /* Manipulation functions:  */
10628   copysign_test ();
10629   nextafter_test ();
10630   nexttoward_test ();
10631
10632   /* maximum, minimum and positive difference functions */
10633   fdim_test ();
10634   fmax_test ();
10635   fmin_test ();
10636
10637   /* Multiply and add:  */
10638   fma_test ();
10639   fma_test_towardzero ();
10640   fma_test_downward ();
10641   fma_test_upward ();
10642
10643   /* Comparison macros:  */
10644   isgreater_test ();
10645   isgreaterequal_test ();
10646   isless_test ();
10647   islessequal_test ();
10648   islessgreater_test ();
10649   isunordered_test ();
10650
10651   /* Complex functions:  */
10652   cabs_test ();
10653   cacos_test ();
10654   cacosh_test ();
10655   carg_test ();
10656   casin_test ();
10657   casinh_test ();
10658   catan_test ();
10659   catanh_test ();
10660   ccos_test ();
10661   ccosh_test ();
10662   cexp_test ();
10663   cimag_test ();
10664   clog10_test ();
10665   clog_test ();
10666   conj_test ();
10667   cpow_test ();
10668   cproj_test ();
10669   creal_test ();
10670   csin_test ();
10671   csinh_test ();
10672   csqrt_test ();
10673   ctan_test ();
10674   ctan_test_tonearest ();
10675   ctan_test_towardzero ();
10676   ctan_test_downward ();
10677   ctan_test_upward ();
10678   ctanh_test ();
10679   ctanh_test_tonearest ();
10680   ctanh_test_towardzero ();
10681   ctanh_test_downward ();
10682   ctanh_test_upward ();
10683
10684   /* Bessel functions:  */
10685   j0_test ();
10686   j1_test ();
10687   jn_test ();
10688   y0_test ();
10689   y1_test ();
10690   yn_test ();
10691
10692   if (output_ulps)
10693     fclose (ulps_file);
10694
10695   printf ("\nTest suite completed:\n");
10696   printf ("  %d test cases plus %d tests for exception flags executed.\n",
10697           noTests, noExcTests);
10698   if (noXFails)
10699     printf ("  %d expected failures occurred.\n", noXFails);
10700   if (noXPasses)
10701     printf ("  %d unexpected passes occurred.\n", noXPasses);
10702   if (noErrors)
10703     {
10704       printf ("  %d errors occurred.\n", noErrors);
10705       return 1;
10706     }
10707   printf ("  All tests passed successfully.\n");
10708
10709   return 0;
10710 }
10711
10712 /*
10713  * Local Variables:
10714  * mode:c
10715  * End:
10716  */