math/libm-test.inc

   1 /* Copyright (C) 1997-2013 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Andreas Jaeger <aj@suse.de>, 1997.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 /* Part of testsuite for libm.
  20
  21    This file is processed by a perl script.  The resulting file has to
  22    be included by a master file that defines:
  23
  24    Macros:
  25    FUNC(function): converts general function name (like cos) to
  26    name with correct suffix (e.g. cosl or cosf)
  27    MATHCONST(x):   like FUNC but for constants (e.g convert 0.0 to 0.0L)
  28    FLOAT:          floating point type to test
  29    - TEST_MSG:     informal message to be displayed
  30    CHOOSE(Clongdouble,Cdouble,Cfloat,Cinlinelongdouble,Cinlinedouble,Cinlinefloat):
  31    chooses one of the parameters as delta for testing
  32    equality
  33    PRINTF_EXPR     Floating point conversion specification to print a variable
  34    of type FLOAT with printf.  PRINTF_EXPR just contains
  35    the specifier, not the percent and width arguments,
  36    e.g. "f".
  37    PRINTF_XEXPR    Like PRINTF_EXPR, but print in hexadecimal format.
  38    PRINTF_NEXPR Like PRINTF_EXPR, but print nice.  */
  39
  40 /* This testsuite has currently tests for:
  41    acos, acosh, asin, asinh, atan, atan2, atanh,
  42    cbrt, ceil, copysign, cos, cosh, erf, erfc, exp, exp10, exp2, expm1,
  43    fabs, fdim, finite, floor, fma, fmax, fmin, fmod, fpclassify,
  44    frexp, gamma, hypot,
  45    ilogb, isfinite, isinf, isnan, isnormal,
  46    isless, islessequal, isgreater, isgreaterequal, islessgreater, isunordered,
  47    j0, j1, jn,
  48    ldexp, lgamma, log, log10, log1p, log2, logb,
  49    modf, nearbyint, nextafter, nexttoward,
  50    pow, remainder, remquo, rint, lrint, llrint,
  51    round, lround, llround,
  52    scalb, scalbn, scalbln, signbit, sin, sincos, sinh, sqrt, tan, tanh, tgamma, trunc,
  53    y0, y1, yn, significand
  54
  55    and for the following complex math functions:
  56    cabs, cacos, cacosh, carg, casin, casinh, catan, catanh,
  57    ccos, ccosh, cexp, cimag, clog, clog10, conj, cpow, cproj, creal,
  58    csin, csinh, csqrt, ctan, ctanh.
  59
  60    At the moment the following functions and macros aren't tested:
  61    drem (alias for remainder),
  62    lgamma_r,
  63    nan,
  64    pow10 (alias for exp10).
  65
  66    Parameter handling is primitive in the moment:
  67    --verbose=[0..3] for different levels of output:
  68    0: only error count
  69    1: basic report on failed tests (default)
  70    2: full report on all tests
  71    -v for full output (equals --verbose=3)
  72    -u for generation of an ULPs file
  73  */
  74
  75 /* "Philosophy":
  76
  77    This suite tests some aspects of the correct implementation of
  78    mathematical functions in libm.  Some simple, specific parameters
  79    are tested for correctness but there's no exhaustive
  80    testing.  Handling of specific inputs (e.g. infinity, not-a-number)
  81    is also tested.  Correct handling of exceptions is checked
  82    against.  These implemented tests should check all cases that are
  83    specified in ISO C99.
  84
  85    Exception testing: At the moment only divide-by-zero, invalid,
  86    overflow and underflow exceptions are tested.  Inexact exceptions
  87    aren't checked at the moment.
  88
  89    NaN values: There exist signalling and quiet NaNs.  This implementation
  90    only uses quiet NaN as parameter but does not differentiate
  91    between the two kinds of NaNs as result.  Where the sign of a NaN is
  92    significant, this is not tested.
  93
  94    Inline functions: Inlining functions should give an improvement in
  95    speed - but not in precission.  The inlined functions return
  96    reasonable values for a reasonable range of input values.  The
  97    result is not necessarily correct for all values and exceptions are
  98    not correctly raised in all cases.  Problematic input and return
  99    values are infinity, not-a-number and minus zero.  This suite
 100    therefore does not check these specific inputs and the exception
 101    handling for inlined mathematical functions - just the "reasonable"
 102    values are checked.
 103
 104    Beware: The tests might fail for any of the following reasons:
 105    - Tests are wrong
 106    - Functions are wrong
 107    - Floating Point Unit not working properly
 108    - Compiler has errors
 109
 110    With e.g. gcc 2.7.2.2 the test for cexp fails because of a compiler error.
 111
 112
 113    To Do: All parameter should be numbers that can be represented as
 114    exact floating point values.  Currently some values cannot be
 115    represented exactly and therefore the result is not the expected
 116    result.  For this we will use 36 digits so that numbers can be
 117    represented exactly.  */
 118
 119 #ifndef _GNU_SOURCE
 120 # define _GNU_SOURCE
 121 #endif
 122
 123 #include "libm-test-ulps.h"
 124 #include <complex.h>
 125 #include <math.h>
 126 #include <float.h>
 127 #include <fenv.h>
 128 #include <limits.h>
 129
 130 #include <errno.h>
 131 #include <stdlib.h>
 132 #include <stdio.h>
 133 #include <string.h>
 134 #include <argp.h>
 135 #include <tininess.h>
 136
 137 /* Allow platforms without all rounding modes to test properly,
 138    assuming they provide an __FE_UNDEFINED in <bits/fenv.h> which
 139    causes fesetround() to return failure.  */
 140 #ifndef FE_TONEAREST
 141 # define FE_TONEAREST   __FE_UNDEFINED
 142 #endif
 143 #ifndef FE_TOWARDZERO
 144 # define FE_TOWARDZERO  __FE_UNDEFINED
 145 #endif
 146 #ifndef FE_UPWARD
 147 # define FE_UPWARD      __FE_UNDEFINED
 148 #endif
 149 #ifndef FE_DOWNWARD
 150 # define FE_DOWNWARD    __FE_UNDEFINED
 151 #endif
 152
 153 /* Possible exceptions */
 154 #define NO_EXCEPTION                    0x0
 155 #define INVALID_EXCEPTION               0x1
 156 #define DIVIDE_BY_ZERO_EXCEPTION        0x2
 157 #define OVERFLOW_EXCEPTION              0x4
 158 #define UNDERFLOW_EXCEPTION             0x8
 159 /* The next flags signals that those exceptions are allowed but not required.   */
 160 #define INVALID_EXCEPTION_OK            0x10
 161 #define DIVIDE_BY_ZERO_EXCEPTION_OK     0x20
 162 #define OVERFLOW_EXCEPTION_OK           0x40
 163 #define UNDERFLOW_EXCEPTION_OK          0x80
 164 #define EXCEPTIONS_OK INVALID_EXCEPTION_OK+DIVIDE_BY_ZERO_EXCEPTION_OK
 165 /* Some special test flags, passed together with exceptions.  */
 166 #define IGNORE_ZERO_INF_SIGN            0x100
 167
 168 /* Values underflowing only for float.  */
 169 #ifdef TEST_FLOAT
 170 # define UNDERFLOW_EXCEPTION_FLOAT      UNDERFLOW_EXCEPTION
 171 # define UNDERFLOW_EXCEPTION_OK_FLOAT   UNDERFLOW_EXCEPTION_OK
 172 #else
 173 # define UNDERFLOW_EXCEPTION_FLOAT      0
 174 # define UNDERFLOW_EXCEPTION_OK_FLOAT   0
 175 #endif
 176 /* Values underflowing only for double or types with a larger least
 177    positive normal value.  */
 178 #if defined TEST_FLOAT || defined TEST_DOUBLE \
 179   || (defined TEST_LDOUBLE && LDBL_MIN_EXP >= DBL_MIN_EXP)
 180 # define UNDERFLOW_EXCEPTION_DOUBLE     UNDERFLOW_EXCEPTION
 181 #else
 182 # define UNDERFLOW_EXCEPTION_DOUBLE     0
 183 #endif
 184 /* Values underflowing only for IBM long double or types with a larger least
 185    positive normal value.  */
 186 #if defined TEST_FLOAT || (defined TEST_LDOUBLE && LDBL_MIN_EXP > DBL_MIN_EXP)
 187 # define UNDERFLOW_EXCEPTION_LDOUBLE_IBM        UNDERFLOW_EXCEPTION
 188 #else
 189 # define UNDERFLOW_EXCEPTION_LDOUBLE_IBM        0
 190 #endif
 191 /* Values underflowing on architectures detecting tininess before
 192    rounding, but not on those detecting tininess after rounding.  */
 193 #define UNDERFLOW_EXCEPTION_BEFORE_ROUNDING     (TININESS_AFTER_ROUNDING \
 194                                                  ? 0                    \
 195                                                  : UNDERFLOW_EXCEPTION)
 196
 197 /* Various constants (we must supply them precalculated for accuracy).  */
 198 #define M_PI_6l                 .52359877559829887307710723054658383L
 199 #define M_E2l                   7.389056098930650227230427460575008L
 200 #define M_E3l                   20.085536923187667740928529654581719L
 201 #define M_2_SQRT_PIl            3.5449077018110320545963349666822903L   /* 2 sqrt (M_PIl)  */
 202 #define M_SQRT_PIl              1.7724538509055160272981674833411451L   /* sqrt (M_PIl)  */
 203 #define M_LOG_SQRT_PIl          0.57236494292470008707171367567652933L  /* log(sqrt(M_PIl))  */
 204 #define M_LOG_2_SQRT_PIl        1.265512123484645396488945797134706L    /* log(2*sqrt(M_PIl))  */
 205 #define M_PI_34l                (M_PIl - M_PI_4l)               /* 3*pi/4 */
 206 #define M_PI_34_LOG10El         (M_PIl - M_PI_4l) * M_LOG10El
 207 #define M_PI2_LOG10El           M_PI_2l * M_LOG10El
 208 #define M_PI4_LOG10El           M_PI_4l * M_LOG10El
 209 #define M_PI_LOG10El            M_PIl * M_LOG10El
 210 #define M_SQRT_2_2              0.70710678118654752440084436210484903L /* sqrt (2) / 2 */
 211
 212 static FILE *ulps_file; /* File to document difference.  */
 213 static int output_ulps; /* Should ulps printed?  */
 214
 215 static int noErrors;    /* number of errors */
 216 static int noTests;     /* number of tests (without testing exceptions) */
 217 static int noExcTests;  /* number of tests for exception flags */
 218 static int noXFails;    /* number of expected failures.  */
 219 static int noXPasses;   /* number of unexpected passes.  */
 220
 221 static int verbose;
 222 static int output_max_error;    /* Should the maximal errors printed?  */
 223 static int output_points;       /* Should the single function results printed?  */
 224 static int ignore_max_ulp;      /* Should we ignore max_ulp?  */
 225
 226 static FLOAT minus_zero, plus_zero;
 227 static FLOAT plus_infty, minus_infty, nan_value, max_value, min_value;
 228 static FLOAT min_subnorm_value;
 229
 230 static FLOAT max_error, real_max_error, imag_max_error;
 231
 232
 233 #define BUILD_COMPLEX(real, imag) \
 234   ({ __complex__ FLOAT __retval;                                              \
 235      __real__ __retval = (real);                                              \
 236      __imag__ __retval = (imag);                                              \
 237      __retval; })
 238
 239 #define BUILD_COMPLEX_INT(real, imag) \
 240   ({ __complex__ int __retval;                                                \
 241      __real__ __retval = (real);                                              \
 242      __imag__ __retval = (imag);                                              \
 243      __retval; })
 244
 245
 246 #define MANT_DIG CHOOSE ((LDBL_MANT_DIG-1), (DBL_MANT_DIG-1), (FLT_MANT_DIG-1),  \
 247                          (LDBL_MANT_DIG-1), (DBL_MANT_DIG-1), (FLT_MANT_DIG-1))
 248
 249 static void
 250 init_max_error (void)
 251 {
 252   max_error = 0;
 253   real_max_error = 0;
 254   imag_max_error = 0;
 255   feclearexcept (FE_ALL_EXCEPT);
 256 }
 257
 258 static void
 259 set_max_error (FLOAT current, FLOAT *curr_max_error)
 260 {
 261   if (current > *curr_max_error)
 262     *curr_max_error = current;
 263 }
 264
 265
 266 /* Should the message print to screen?  This depends on the verbose flag,
 267    and the test status.  */
 268 static int
 269 print_screen (int ok, int xfail)
 270 {
 271   if (output_points
 272       && (verbose > 1
 273           || (verbose == 1 && ok == xfail)))
 274     return 1;
 275   return 0;
 276 }
 277
 278
 279 /* Should the message print to screen?  This depends on the verbose flag,
 280    and the test status.  */
 281 static int
 282 print_screen_max_error (int ok, int xfail)
 283 {
 284   if (output_max_error
 285       && (verbose > 1
 286           || ((verbose == 1) && (ok == xfail))))
 287     return 1;
 288   return 0;
 289 }
 290
 291 /* Update statistic counters.  */
 292 static void
 293 update_stats (int ok, int xfail)
 294 {
 295   ++noTests;
 296   if (ok && xfail)
 297     ++noXPasses;
 298   else if (!ok && xfail)
 299     ++noXFails;
 300   else if (!ok && !xfail)
 301     ++noErrors;
 302 }
 303
 304 static void
 305 print_ulps (const char *test_name, FLOAT ulp)
 306 {
 307   if (output_ulps)
 308     {
 309       fprintf (ulps_file, "Test \"%s\":\n", test_name);
 310       fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
 311                CHOOSE("ldouble", "double", "float",
 312                       "ildouble", "idouble", "ifloat"),
 313                FUNC(ceil) (ulp));
 314     }
 315 }
 316
 317 static void
 318 print_function_ulps (const char *function_name, FLOAT ulp)
 319 {
 320   if (output_ulps)
 321     {
 322       fprintf (ulps_file, "Function: \"%s\":\n", function_name);
 323       fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
 324                CHOOSE("ldouble", "double", "float",
 325                       "ildouble", "idouble", "ifloat"),
 326                FUNC(ceil) (ulp));
 327     }
 328 }
 329
 330
 331 static void
 332 print_complex_function_ulps (const char *function_name, FLOAT real_ulp,
 333                              FLOAT imag_ulp)
 334 {
 335   if (output_ulps)
 336     {
 337       if (real_ulp != 0.0)
 338         {
 339           fprintf (ulps_file, "Function: Real part of \"%s\":\n", function_name);
 340           fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
 341                    CHOOSE("ldouble", "double", "float",
 342                           "ildouble", "idouble", "ifloat"),
 343                    FUNC(ceil) (real_ulp));
 344         }
 345       if (imag_ulp != 0.0)
 346         {
 347           fprintf (ulps_file, "Function: Imaginary part of \"%s\":\n", function_name);
 348           fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
 349                    CHOOSE("ldouble", "double", "float",
 350                           "ildouble", "idouble", "ifloat"),
 351                    FUNC(ceil) (imag_ulp));
 352         }
 353
 354
 355     }
 356 }
 357
 358
 359
 360 /* Test if Floating-Point stack hasn't changed */
 361 static void
 362 fpstack_test (const char *test_name)
 363 {
 364 #ifdef i386
 365   static int old_stack;
 366   int sw;
 367
 368   asm ("fnstsw" : "=a" (sw));
 369   sw >>= 11;
 370   sw &= 7;
 371
 372   if (sw != old_stack)
 373     {
 374       printf ("FP-Stack wrong after test %s (%d, should be %d)\n",
 375               test_name, sw, old_stack);
 376       ++noErrors;
 377       old_stack = sw;
 378     }
 379 #endif
 380 }
 381
 382
 383 static void
 384 print_max_error (const char *func_name, FLOAT allowed, int xfail)
 385 {
 386   int ok = 0;
 387
 388   if (max_error == 0.0 || (max_error <= allowed && !ignore_max_ulp))
 389     {
 390       ok = 1;
 391     }
 392
 393   if (!ok)
 394     print_function_ulps (func_name, max_error);
 395
 396
 397   if (print_screen_max_error (ok, xfail))
 398     {
 399       printf ("Maximal error of `%s'\n", func_name);
 400       printf (" is      : %.0" PRINTF_NEXPR " ulp\n", FUNC(ceil) (max_error));
 401       printf (" accepted: %.0" PRINTF_NEXPR " ulp\n", FUNC(ceil) (allowed));
 402     }
 403
 404   update_stats (ok, xfail);
 405 }
 406
 407
 408 static void
 409 print_complex_max_error (const char *func_name, __complex__ FLOAT allowed,
 410                          __complex__ int xfail)
 411 {
 412   int ok = 0;
 413
 414   if ((real_max_error == 0 && imag_max_error == 0)
 415       || (real_max_error <= __real__ allowed
 416           && imag_max_error <= __imag__ allowed
 417           && !ignore_max_ulp))
 418     {
 419       ok = 1;
 420     }
 421
 422   if (!ok)
 423     print_complex_function_ulps (func_name, real_max_error, imag_max_error);
 424
 425
 426   if (print_screen_max_error (ok, xfail))
 427     {
 428       printf ("Maximal error of real part of: %s\n", func_name);
 429       printf (" is      : %.0" PRINTF_NEXPR " ulp\n",
 430               FUNC(ceil) (real_max_error));
 431       printf (" accepted: %.0" PRINTF_NEXPR " ulp\n",
 432               FUNC(ceil) (__real__ allowed));
 433       printf ("Maximal error of imaginary part of: %s\n", func_name);
 434       printf (" is      : %.0" PRINTF_NEXPR " ulp\n",
 435               FUNC(ceil) (imag_max_error));
 436       printf (" accepted: %.0" PRINTF_NEXPR " ulp\n",
 437               FUNC(ceil) (__imag__ allowed));
 438     }
 439
 440   update_stats (ok, xfail);
 441 }
 442
 443
 444 /* Test whether a given exception was raised.  */
 445 static void
 446 test_single_exception (const char *test_name,
 447                        int exception,
 448                        int exc_flag,
 449                        int fe_flag,
 450                        const char *flag_name)
 451 {
 452 #ifndef TEST_INLINE
 453   int ok = 1;
 454   if (exception & exc_flag)
 455     {
 456       if (fetestexcept (fe_flag))
 457         {
 458           if (print_screen (1, 0))
 459             printf ("Pass: %s: Exception \"%s\" set\n", test_name, flag_name);
 460         }
 461       else
 462         {
 463           ok = 0;
 464           if (print_screen (0, 0))
 465             printf ("Failure: %s: Exception \"%s\" not set\n",
 466                     test_name, flag_name);
 467         }
 468     }
 469   else
 470     {
 471       if (fetestexcept (fe_flag))
 472         {
 473           ok = 0;
 474           if (print_screen (0, 0))
 475             printf ("Failure: %s: Exception \"%s\" set\n",
 476                     test_name, flag_name);
 477         }
 478       else
 479         {
 480           if (print_screen (1, 0))
 481             printf ("%s: Exception \"%s\" not set\n", test_name,
 482                     flag_name);
 483         }
 484     }
 485   if (!ok)
 486     ++noErrors;
 487
 488 #endif
 489 }
 490
 491
 492 /* Test whether exceptions given by EXCEPTION are raised.  Ignore thereby
 493    allowed but not required exceptions.
 494 */
 495 static void
 496 test_exceptions (const char *test_name, int exception)
 497 {
 498   ++noExcTests;
 499 #ifdef FE_DIVBYZERO
 500   if ((exception & DIVIDE_BY_ZERO_EXCEPTION_OK) == 0)
 501     test_single_exception (test_name, exception,
 502                            DIVIDE_BY_ZERO_EXCEPTION, FE_DIVBYZERO,
 503                            "Divide by zero");
 504 #endif
 505 #ifdef FE_INVALID
 506   if ((exception & INVALID_EXCEPTION_OK) == 0)
 507     test_single_exception (test_name, exception, INVALID_EXCEPTION, FE_INVALID,
 508                          "Invalid operation");
 509 #endif
 510 #ifdef FE_OVERFLOW
 511   if ((exception & OVERFLOW_EXCEPTION_OK) == 0)
 512     test_single_exception (test_name, exception, OVERFLOW_EXCEPTION,
 513                            FE_OVERFLOW, "Overflow");
 514 #endif
 515 #ifdef FE_UNDERFLOW
 516   if ((exception & UNDERFLOW_EXCEPTION_OK) == 0)
 517     test_single_exception (test_name, exception, UNDERFLOW_EXCEPTION,
 518                            FE_UNDERFLOW, "Underflow");
 519 #endif
 520   feclearexcept (FE_ALL_EXCEPT);
 521 }
 522
 523
 524 static void
 525 check_float_internal (const char *test_name, FLOAT computed, FLOAT expected,
 526                       FLOAT max_ulp, int xfail, int exceptions,
 527                       FLOAT *curr_max_error)
 528 {
 529   int ok = 0;
 530   int print_diff = 0;
 531   FLOAT diff = 0;
 532   FLOAT ulp = 0;
 533
 534   test_exceptions (test_name, exceptions);
 535   if (isnan (computed) && isnan (expected))
 536     ok = 1;
 537   else if (isinf (computed) && isinf (expected))
 538     {
 539       /* Test for sign of infinities.  */
 540       if ((exceptions & IGNORE_ZERO_INF_SIGN) == 0
 541           && signbit (computed) != signbit (expected))
 542         {
 543           ok = 0;
 544           printf ("infinity has wrong sign.\n");
 545         }
 546       else
 547         ok = 1;
 548     }
 549   /* Don't calc ulp for NaNs or infinities.  */
 550   else if (isinf (computed) || isnan (computed) || isinf (expected) || isnan (expected))
 551     ok = 0;
 552   else
 553     {
 554       diff = FUNC(fabs) (computed - expected);
 555       switch (fpclassify (expected))
 556         {
 557         case FP_ZERO:
 558           /* ilogb (0) isn't allowed. */
 559           ulp = diff / FUNC(ldexp) (1.0, - MANT_DIG);
 560           break;
 561         case FP_NORMAL:
 562           ulp = diff / FUNC(ldexp) (1.0, FUNC(ilogb) (expected) - MANT_DIG);
 563           break;
 564         case FP_SUBNORMAL:
 565           /* 1ulp for a subnormal value, shifted by MANT_DIG, is the
 566              least normal value.  */
 567           ulp = (FUNC(ldexp) (diff, MANT_DIG) / min_value);
 568           break;
 569         default:
 570           /* It should never happen. */
 571           abort ();
 572           break;
 573         }
 574       set_max_error (ulp, curr_max_error);
 575       print_diff = 1;
 576       if ((exceptions & IGNORE_ZERO_INF_SIGN) == 0
 577           && computed == 0.0 && expected == 0.0
 578           && signbit(computed) != signbit (expected))
 579         ok = 0;
 580       else if (ulp <= 0.5 || (ulp <= max_ulp && !ignore_max_ulp))
 581         ok = 1;
 582       else
 583         {
 584           ok = 0;
 585           print_ulps (test_name, ulp);
 586         }
 587
 588     }
 589   if (print_screen (ok, xfail))
 590     {
 591       if (!ok)
 592         printf ("Failure: ");
 593       printf ("Test: %s\n", test_name);
 594       printf ("Result:\n");
 595       printf (" is:         % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
 596               computed, computed);
 597       printf (" should be:  % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
 598               expected, expected);
 599       if (print_diff)
 600         {
 601           printf (" difference: % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR
 602                   "\n", diff, diff);
 603           printf (" ulp       : % .4" PRINTF_NEXPR "\n", ulp);
 604           printf (" max.ulp   : % .4" PRINTF_NEXPR "\n", max_ulp);
 605         }
 606     }
 607   update_stats (ok, xfail);
 608
 609   fpstack_test (test_name);
 610 }
 611
 612
 613 static void
 614 check_float (const char *test_name, FLOAT computed, FLOAT expected,
 615              FLOAT max_ulp, int xfail, int exceptions)
 616 {
 617   check_float_internal (test_name, computed, expected, max_ulp, xfail,
 618                         exceptions, &max_error);
 619 }
 620
 621
 622 static void
 623 check_complex (const char *test_name, __complex__ FLOAT computed,
 624                __complex__ FLOAT expected,
 625                __complex__ FLOAT max_ulp, __complex__ int xfail,
 626                int exception)
 627 {
 628   FLOAT part_comp, part_exp, part_max_ulp;
 629   int part_xfail;
 630   char *str;
 631
 632   if (asprintf (&str, "Real part of: %s", test_name) == -1)
 633     abort ();
 634
 635   part_comp = __real__ computed;
 636   part_exp = __real__ expected;
 637   part_max_ulp = __real__ max_ulp;
 638   part_xfail = __real__ xfail;
 639
 640   check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
 641                         exception, &real_max_error);
 642   free (str);
 643
 644   if (asprintf (&str, "Imaginary part of: %s", test_name) == -1)
 645     abort ();
 646
 647   part_comp = __imag__ computed;
 648   part_exp = __imag__ expected;
 649   part_max_ulp = __imag__ max_ulp;
 650   part_xfail = __imag__ xfail;
 651
 652   /* Don't check again for exceptions, just pass through the
 653      zero/inf sign test.  */
 654   check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
 655                         exception & IGNORE_ZERO_INF_SIGN,
 656                         &imag_max_error);
 657   free (str);
 658 }
 659
 660
 661 /* Check that computed and expected values are equal (int values).  */
 662 static void
 663 check_int (const char *test_name, int computed, int expected, int max_ulp,
 664            int xfail, int exceptions)
 665 {
 666   int diff = computed - expected;
 667   int ok = 0;
 668
 669   test_exceptions (test_name, exceptions);
 670   noTests++;
 671   if (abs (diff) <= max_ulp)
 672     ok = 1;
 673
 674   if (!ok)
 675     print_ulps (test_name, diff);
 676
 677   if (print_screen (ok, xfail))
 678     {
 679       if (!ok)
 680         printf ("Failure: ");
 681       printf ("Test: %s\n", test_name);
 682       printf ("Result:\n");
 683       printf (" is:         %d\n", computed);
 684       printf (" should be:  %d\n", expected);
 685     }
 686
 687   update_stats (ok, xfail);
 688   fpstack_test (test_name);
 689 }
 690
 691
 692 /* Check that computed and expected values are equal (long int values).  */
 693 static void
 694 check_long (const char *test_name, long int computed, long int expected,
 695             long int max_ulp, int xfail, int exceptions)
 696 {
 697   long int diff = computed - expected;
 698   int ok = 0;
 699
 700   test_exceptions (test_name, exceptions);
 701   noTests++;
 702   if (labs (diff) <= max_ulp)
 703     ok = 1;
 704
 705   if (!ok)
 706     print_ulps (test_name, diff);
 707
 708   if (print_screen (ok, xfail))
 709     {
 710       if (!ok)
 711         printf ("Failure: ");
 712       printf ("Test: %s\n", test_name);
 713       printf ("Result:\n");
 714       printf (" is:         %ld\n", computed);
 715       printf (" should be:  %ld\n", expected);
 716     }
 717
 718   update_stats (ok, xfail);
 719   fpstack_test (test_name);
 720 }
 721
 722
 723 /* Check that computed value is true/false.  */
 724 static void
 725 check_bool (const char *test_name, int computed, int expected,
 726             long int max_ulp, int xfail, int exceptions)
 727 {
 728   int ok = 0;
 729
 730   test_exceptions (test_name, exceptions);
 731   noTests++;
 732   if ((computed == 0) == (expected == 0))
 733     ok = 1;
 734
 735   if (print_screen (ok, xfail))
 736     {
 737       if (!ok)
 738         printf ("Failure: ");
 739       printf ("Test: %s\n", test_name);
 740       printf ("Result:\n");
 741       printf (" is:         %d\n", computed);
 742       printf (" should be:  %d\n", expected);
 743     }
 744
 745   update_stats (ok, xfail);
 746   fpstack_test (test_name);
 747 }
 748
 749
 750 /* check that computed and expected values are equal (long int values) */
 751 static void
 752 check_longlong (const char *test_name, long long int computed,
 753                 long long int expected,
 754                 long long int max_ulp, int xfail,
 755                 int exceptions)
 756 {
 757   long long int diff = computed - expected;
 758   int ok = 0;
 759
 760   test_exceptions (test_name, exceptions);
 761   noTests++;
 762   if (llabs (diff) <= max_ulp)
 763     ok = 1;
 764
 765   if (!ok)
 766     print_ulps (test_name, diff);
 767
 768   if (print_screen (ok, xfail))
 769     {
 770       if (!ok)
 771         printf ("Failure:");
 772       printf ("Test: %s\n", test_name);
 773       printf ("Result:\n");
 774       printf (" is:         %lld\n", computed);
 775       printf (" should be:  %lld\n", expected);
 776     }
 777
 778   update_stats (ok, xfail);
 779   fpstack_test (test_name);
 780 }
 781
 782
 783
 784 /* This is to prevent messages from the SVID libm emulation.  */
 785 int
 786 matherr (struct exception *x __attribute__ ((unused)))
 787 {
 788   return 1;
 789 }
 790
 791
 792 /****************************************************************************
 793   Tests for single functions of libm.
 794   Please keep them alphabetically sorted!
 795 ****************************************************************************/
 796
 797 static void
 798 acos_test (void)
 799 {
 800   errno = 0;
 801   FUNC(acos) (0);
 802   if (errno == ENOSYS)
 803     /* Function not implemented.  */
 804     return;
 805
 806   START (acos);
 807
 808   TEST_f_f (acos, plus_infty, nan_value, INVALID_EXCEPTION);
 809   TEST_f_f (acos, minus_infty, nan_value, INVALID_EXCEPTION);
 810   TEST_f_f (acos, nan_value, nan_value);
 811
 812   /* |x| > 1: */
 813   TEST_f_f (acos, 1.125L, nan_value, INVALID_EXCEPTION);
 814   TEST_f_f (acos, -1.125L, nan_value, INVALID_EXCEPTION);
 815   TEST_f_f (acos, max_value, nan_value, INVALID_EXCEPTION);
 816   TEST_f_f (acos, -max_value, nan_value, INVALID_EXCEPTION);
 817
 818   TEST_f_f (acos, 0, M_PI_2l);
 819   TEST_f_f (acos, minus_zero, M_PI_2l);
 820   TEST_f_f (acos, 1, 0);
 821   TEST_f_f (acos, -1, M_PIl);
 822   TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 823   TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 824   TEST_f_f (acos, 0.75L, 0.722734247813415611178377352641333362L);
 825   TEST_f_f (acos, 2e-17L, 1.57079632679489659923132169163975144L);
 826   TEST_f_f (acos, 0.0625L, 1.50825556499840522843072005474337068L);
 827   TEST_f_f (acos, 0x0.ffffffp0L, 3.4526698471620358760324948263873649728491e-4L);
 828   TEST_f_f (acos, -0x0.ffffffp0L, 3.1412473866050770348750401337968641476999L);
 829 #ifndef TEST_FLOAT
 830   TEST_f_f (acos, 0x0.ffffffff8p0L, 1.5258789062648029736620564947844627548516e-5L);
 831   TEST_f_f (acos, -0x0.ffffffff8p0L, 3.1415773948007305904329067627145550395696L);
 832   TEST_f_f (acos, 0x0.ffffffffffffp0L, 8.4293697021788088529885473244391795127130e-8L);
 833   TEST_f_f (acos, -0x0.ffffffffffffp0L, 3.1415925692960962166745548533940296398054L);
 834 #endif
 835 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
 836   TEST_f_f (acos, 0x0.ffffffffffffffffp0L, 3.2927225399135962333718255320079907245059e-10L);
 837   TEST_f_f (acos, -0x0.ffffffffffffffffp0L, 3.1415926532605209844712837599423203309964L);
 838 #endif
 839   END (acos);
 840 }
 841
 842
 843 static void
 844 acos_test_tonearest (void)
 845 {
 846   int save_round_mode;
 847   errno = 0;
 848   FUNC(acos) (0);
 849   if (errno == ENOSYS)
 850     /* Function not implemented.  */
 851     return;
 852
 853   START (acos_tonearest);
 854
 855   save_round_mode = fegetround ();
 856
 857   if (!fesetround (FE_TONEAREST))
 858     {
 859       TEST_f_f (acos, 0, M_PI_2l);
 860       TEST_f_f (acos, minus_zero, M_PI_2l);
 861       TEST_f_f (acos, 1, 0);
 862       TEST_f_f (acos, -1, M_PIl);
 863       TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 864       TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 865     }
 866
 867   fesetround (save_round_mode);
 868
 869   END (acos_tonearest);
 870 }
 871
 872
 873 static void
 874 acos_test_towardzero (void)
 875 {
 876   int save_round_mode;
 877   errno = 0;
 878   FUNC(acos) (0);
 879   if (errno == ENOSYS)
 880     /* Function not implemented.  */
 881     return;
 882
 883   START (acos_towardzero);
 884
 885   save_round_mode = fegetround ();
 886
 887   if (!fesetround (FE_TOWARDZERO))
 888     {
 889       TEST_f_f (acos, 0, M_PI_2l);
 890       TEST_f_f (acos, minus_zero, M_PI_2l);
 891       TEST_f_f (acos, 1, 0);
 892       TEST_f_f (acos, -1, M_PIl);
 893       TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 894       TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 895     }
 896
 897   fesetround (save_round_mode);
 898
 899   END (acos_towardzero);
 900 }
 901
 902
 903 static void
 904 acos_test_downward (void)
 905 {
 906   int save_round_mode;
 907   errno = 0;
 908   FUNC(acos) (0);
 909   if (errno == ENOSYS)
 910     /* Function not implemented.  */
 911     return;
 912
 913   START (acos_downward);
 914
 915   save_round_mode = fegetround ();
 916
 917   if (!fesetround (FE_DOWNWARD))
 918     {
 919       TEST_f_f (acos, 0, M_PI_2l);
 920       TEST_f_f (acos, minus_zero, M_PI_2l);
 921       TEST_f_f (acos, 1, 0);
 922       TEST_f_f (acos, -1, M_PIl);
 923       TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 924       TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 925     }
 926
 927   fesetround (save_round_mode);
 928
 929   END (acos_downward);
 930 }
 931
 932
 933 static void
 934 acos_test_upward (void)
 935 {
 936   int save_round_mode;
 937   errno = 0;
 938   FUNC(acos) (0);
 939   if (errno == ENOSYS)
 940     /* Function not implemented.  */
 941     return;
 942
 943   START (acos_upward);
 944
 945   save_round_mode = fegetround ();
 946
 947   if (!fesetround (FE_UPWARD))
 948     {
 949       TEST_f_f (acos, 0, M_PI_2l);
 950       TEST_f_f (acos, minus_zero, M_PI_2l);
 951       TEST_f_f (acos, 1, 0);
 952       TEST_f_f (acos, -1, M_PIl);
 953       TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 954       TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 955     }
 956
 957   fesetround (save_round_mode);
 958
 959   END (acos_upward);
 960 }
 961
 962 static void
 963 acosh_test (void)
 964 {
 965   errno = 0;
 966   FUNC(acosh) (7);
 967   if (errno == ENOSYS)
 968     /* Function not implemented.  */
 969     return;
 970
 971   START (acosh);
 972
 973   TEST_f_f (acosh, plus_infty, plus_infty);
 974   TEST_f_f (acosh, minus_infty, nan_value, INVALID_EXCEPTION);
 975
 976   /* x < 1:  */
 977   TEST_f_f (acosh, -1.125L, nan_value, INVALID_EXCEPTION);
 978   TEST_f_f (acosh, -max_value, nan_value, INVALID_EXCEPTION);
 979
 980   TEST_f_f (acosh, 1, 0);
 981   TEST_f_f (acosh, 7, 2.63391579384963341725009269461593689L);
 982
 983   END (acosh);
 984 }
 985
 986 static void
 987 asin_test (void)
 988 {
 989   errno = 0;
 990   FUNC(asin) (0);
 991   if (errno == ENOSYS)
 992     /* Function not implemented.  */
 993     return;
 994
 995   START (asin);
 996
 997   TEST_f_f (asin, plus_infty, nan_value, INVALID_EXCEPTION);
 998   TEST_f_f (asin, minus_infty, nan_value, INVALID_EXCEPTION);
 999   TEST_f_f (asin, nan_value, nan_value);
1000
1001   /* asin x == NaN plus invalid exception for |x| > 1.  */
1002   TEST_f_f (asin, 1.125L, nan_value, INVALID_EXCEPTION);
1003   TEST_f_f (asin, -1.125L, nan_value, INVALID_EXCEPTION);
1004   TEST_f_f (asin, max_value, nan_value, INVALID_EXCEPTION);
1005   TEST_f_f (asin, -max_value, nan_value, INVALID_EXCEPTION);
1006
1007   TEST_f_f (asin, 0, 0);
1008   TEST_f_f (asin, minus_zero, minus_zero);
1009   TEST_f_f (asin, 0.5, M_PI_6l);
1010   TEST_f_f (asin, -0.5, -M_PI_6l);
1011   TEST_f_f (asin, 1.0, M_PI_2l);
1012   TEST_f_f (asin, -1.0, -M_PI_2l);
1013   TEST_f_f (asin, 0.75L, 0.848062078981481008052944338998418080L);
1014   TEST_f_f (asin, 0x0.ffffffp0L, 1.5704510598101804156437184421571127056013L);
1015   TEST_f_f (asin, -0x0.ffffffp0L, -1.5704510598101804156437184421571127056013L);
1016 #ifndef TEST_FLOAT
1017   TEST_f_f (asin, 0x0.ffffffff8p0L, 1.5707810680058339712015850710748035974710L);
1018   TEST_f_f (asin, -0x0.ffffffff8p0L, -1.5707810680058339712015850710748035974710L);
1019   TEST_f_f (asin, 0x0.ffffffffffffp0L, 1.5707962425011995974432331617542781977068L);
1020   TEST_f_f (asin, -0x0.ffffffffffffp0L, -1.5707962425011995974432331617542781977068L);
1021 #endif
1022 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
1023   TEST_f_f (asin, 0x0.ffffffffffffffffp0L, 1.5707963264656243652399620683025688888978L);
1024   TEST_f_f (asin, -0x0.ffffffffffffffffp0L, -1.5707963264656243652399620683025688888978L);
1025 #endif
1026
1027   END (asin);
1028 }
1029
1030
1031 static void
1032 asin_test_tonearest (void)
1033 {
1034   int save_round_mode;
1035   errno = 0;
1036   FUNC(asin) (0);
1037   if (errno == ENOSYS)
1038     /* Function not implemented.  */
1039     return;
1040
1041   START (asin_tonearest);
1042
1043   save_round_mode = fegetround ();
1044
1045   if (!fesetround (FE_TONEAREST))
1046     {
1047       TEST_f_f (asin, 0, 0);
1048       TEST_f_f (asin, minus_zero, minus_zero);
1049       TEST_f_f (asin, 0.5, M_PI_6l);
1050       TEST_f_f (asin, -0.5, -M_PI_6l);
1051       TEST_f_f (asin, 1.0, M_PI_2l);
1052       TEST_f_f (asin, -1.0, -M_PI_2l);
1053     }
1054
1055   fesetround (save_round_mode);
1056
1057   END (asin_tonearest);
1058 }
1059
1060
1061 static void
1062 asin_test_towardzero (void)
1063 {
1064   int save_round_mode;
1065   errno = 0;
1066   FUNC(asin) (0);
1067   if (errno == ENOSYS)
1068     /* Function not implemented.  */
1069     return;
1070
1071   START (asin_towardzero);
1072
1073   save_round_mode = fegetround ();
1074
1075   if (!fesetround (FE_TOWARDZERO))
1076     {
1077       TEST_f_f (asin, 0, 0);
1078       TEST_f_f (asin, minus_zero, minus_zero);
1079       TEST_f_f (asin, 0.5, M_PI_6l);
1080       TEST_f_f (asin, -0.5, -M_PI_6l);
1081       TEST_f_f (asin, 1.0, M_PI_2l);
1082       TEST_f_f (asin, -1.0, -M_PI_2l);
1083     }
1084
1085   fesetround (save_round_mode);
1086
1087   END (asin_towardzero);
1088 }
1089
1090
1091 static void
1092 asin_test_downward (void)
1093 {
1094   int save_round_mode;
1095   errno = 0;
1096   FUNC(asin) (0);
1097   if (errno == ENOSYS)
1098     /* Function not implemented.  */
1099     return;
1100
1101   START (asin_downward);
1102
1103   save_round_mode = fegetround ();
1104
1105   if (!fesetround (FE_DOWNWARD))
1106     {
1107       TEST_f_f (asin, 0, 0);
1108       TEST_f_f (asin, minus_zero, minus_zero);
1109       TEST_f_f (asin, 0.5, M_PI_6l);
1110       TEST_f_f (asin, -0.5, -M_PI_6l);
1111       TEST_f_f (asin, 1.0, M_PI_2l);
1112       TEST_f_f (asin, -1.0, -M_PI_2l);
1113     }
1114
1115   fesetround (save_round_mode);
1116
1117   END (asin_downward);
1118 }
1119
1120
1121 static void
1122 asin_test_upward (void)
1123 {
1124   int save_round_mode;
1125   errno = 0;
1126   FUNC(asin) (0);
1127   if (errno == ENOSYS)
1128     /* Function not implemented.  */
1129     return;
1130
1131   START (asin_upward);
1132
1133   save_round_mode = fegetround ();
1134
1135   if (!fesetround (FE_UPWARD))
1136     {
1137       TEST_f_f (asin, 0, 0);
1138       TEST_f_f (asin, minus_zero, minus_zero);
1139       TEST_f_f (asin, 0.5, M_PI_6l);
1140       TEST_f_f (asin, -0.5, -M_PI_6l);
1141       TEST_f_f (asin, 1.0, M_PI_2l);
1142       TEST_f_f (asin, -1.0, -M_PI_2l);
1143     }
1144
1145   fesetround (save_round_mode);
1146
1147   END (asin_upward);
1148 }
1149
1150 static void
1151 asinh_test (void)
1152 {
1153   errno = 0;
1154   FUNC(asinh) (0.7L);
1155   if (errno == ENOSYS)
1156     /* Function not implemented.  */
1157     return;
1158
1159   START (asinh);
1160
1161   TEST_f_f (asinh, 0, 0);
1162   TEST_f_f (asinh, minus_zero, minus_zero);
1163 #ifndef TEST_INLINE
1164   TEST_f_f (asinh, plus_infty, plus_infty);
1165   TEST_f_f (asinh, minus_infty, minus_infty);
1166 #endif
1167   TEST_f_f (asinh, nan_value, nan_value);
1168   TEST_f_f (asinh, 0.75L, 0.693147180559945309417232121458176568L);
1169
1170   END (asinh);
1171 }
1172
1173 static void
1174 atan_test (void)
1175 {
1176   errno = 0;
1177   FUNC(atan) (0);
1178   if (errno == ENOSYS)
1179     /* Function not implemented.  */
1180     return;
1181
1182   START (atan);
1183
1184   TEST_f_f (atan, 0, 0);
1185   TEST_f_f (atan, minus_zero, minus_zero);
1186
1187   TEST_f_f (atan, plus_infty, M_PI_2l);
1188   TEST_f_f (atan, minus_infty, -M_PI_2l);
1189   TEST_f_f (atan, nan_value, nan_value);
1190   TEST_f_f (atan, max_value, M_PI_2l);
1191   TEST_f_f (atan, -max_value, -M_PI_2l);
1192
1193   TEST_f_f (atan, 1, M_PI_4l);
1194   TEST_f_f (atan, -1, -M_PI_4l);
1195
1196   TEST_f_f (atan, 0.75L, 0.643501108793284386802809228717322638L);
1197
1198   TEST_f_f (atan, 0x1p-100L, 0x1p-100L);
1199 #ifndef TEST_FLOAT
1200   TEST_f_f (atan, 0x1p-600L, 0x1p-600L);
1201 #endif
1202 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
1203   TEST_f_f (atan, 0x1p-10000L, 0x1p-10000L);
1204 #endif
1205
1206   END (atan);
1207 }
1208
1209
1210
1211 static void
1212 atanh_test (void)
1213 {
1214   errno = 0;
1215   FUNC(atanh) (0.7L);
1216   if (errno == ENOSYS)
1217     /* Function not implemented.  */
1218     return;
1219
1220   START (atanh);
1221
1222
1223   TEST_f_f (atanh, 0, 0);
1224   TEST_f_f (atanh, minus_zero, minus_zero);
1225
1226   TEST_f_f (atanh, 1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
1227   TEST_f_f (atanh, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
1228   TEST_f_f (atanh, nan_value, nan_value);
1229
1230   /* atanh (x) == NaN plus invalid exception if |x| > 1.  */
1231   TEST_f_f (atanh, 1.125L, nan_value, INVALID_EXCEPTION);
1232   TEST_f_f (atanh, -1.125L, nan_value, INVALID_EXCEPTION);
1233   TEST_f_f (atanh, max_value, nan_value, INVALID_EXCEPTION);
1234   TEST_f_f (atanh, -max_value, nan_value, INVALID_EXCEPTION);
1235
1236   TEST_f_f (atanh, 0.75L, 0.972955074527656652552676371721589865L);
1237
1238   END (atanh);
1239 }
1240
1241 static void
1242 atan2_test (void)
1243 {
1244   errno = 0;
1245   FUNC(atan2) (-0, 1);
1246   if (errno == ENOSYS)
1247     /* Function not implemented.  */
1248     return;
1249
1250   START (atan2);
1251
1252   /* atan2 (0,x) == 0 for x > 0.  */
1253   TEST_ff_f (atan2, 0, 1, 0);
1254
1255   /* atan2 (-0,x) == -0 for x > 0.  */
1256   TEST_ff_f (atan2, minus_zero, 1, minus_zero);
1257
1258   TEST_ff_f (atan2, 0, 0, 0);
1259   TEST_ff_f (atan2, minus_zero, 0, minus_zero);
1260
1261   /* atan2 (+0,x) == +pi for x < 0.  */
1262   TEST_ff_f (atan2, 0, -1, M_PIl);
1263
1264   /* atan2 (-0,x) == -pi for x < 0.  */
1265   TEST_ff_f (atan2, minus_zero, -1, -M_PIl);
1266
1267   TEST_ff_f (atan2, 0, minus_zero, M_PIl);
1268   TEST_ff_f (atan2, minus_zero, minus_zero, -M_PIl);
1269
1270   /* atan2 (y,+0) == pi/2 for y > 0.  */
1271   TEST_ff_f (atan2, 1, 0, M_PI_2l);
1272
1273   /* atan2 (y,-0) == pi/2 for y > 0.  */
1274   TEST_ff_f (atan2, 1, minus_zero, M_PI_2l);
1275
1276   /* atan2 (y,+0) == -pi/2 for y < 0.  */
1277   TEST_ff_f (atan2, -1, 0, -M_PI_2l);
1278
1279   /* atan2 (y,-0) == -pi/2 for y < 0.  */
1280   TEST_ff_f (atan2, -1, minus_zero, -M_PI_2l);
1281
1282   /* atan2 (y,inf) == +0 for finite y > 0.  */
1283   TEST_ff_f (atan2, 1, plus_infty, 0);
1284
1285   /* atan2 (y,inf) == -0 for finite y < 0.  */
1286   TEST_ff_f (atan2, -1, plus_infty, minus_zero);
1287
1288   /* atan2(+inf, x) == pi/2 for finite x.  */
1289   TEST_ff_f (atan2, plus_infty, -1, M_PI_2l);
1290
1291   /* atan2(-inf, x) == -pi/2 for finite x.  */
1292   TEST_ff_f (atan2, minus_infty, 1, -M_PI_2l);
1293
1294   /* atan2 (y,-inf) == +pi for finite y > 0.  */
1295   TEST_ff_f (atan2, 1, minus_infty, M_PIl);
1296
1297   /* atan2 (y,-inf) == -pi for finite y < 0.  */
1298   TEST_ff_f (atan2, -1, minus_infty, -M_PIl);
1299
1300   TEST_ff_f (atan2, plus_infty, plus_infty, M_PI_4l);
1301   TEST_ff_f (atan2, minus_infty, plus_infty, -M_PI_4l);
1302   TEST_ff_f (atan2, plus_infty, minus_infty, M_PI_34l);
1303   TEST_ff_f (atan2, minus_infty, minus_infty, -M_PI_34l);
1304   TEST_ff_f (atan2, nan_value, nan_value, nan_value);
1305
1306   TEST_ff_f (atan2, max_value, max_value, M_PI_4l);
1307
1308   TEST_ff_f (atan2, max_value, min_value, M_PI_2l);
1309   TEST_ff_f (atan2, -max_value, -min_value, -M_PI_2l);
1310
1311   TEST_ff_f (atan2, 0.75L, 1, 0.643501108793284386802809228717322638L);
1312   TEST_ff_f (atan2, -0.75L, 1.0L, -0.643501108793284386802809228717322638L);
1313   TEST_ff_f (atan2, 0.75L, -1.0L, 2.49809154479650885165983415456218025L);
1314   TEST_ff_f (atan2, -0.75L, -1.0L, -2.49809154479650885165983415456218025L);
1315   TEST_ff_f (atan2, 0.390625L, .00029L, 1.57005392693128974780151246612928941L);
1316   TEST_ff_f (atan2, 1.390625L, 0.9296875L, 0.981498387184244311516296577615519772L);
1317
1318   TEST_ff_f (atan2, -0.00756827042671106339L, -.001792735857538728036L, -1.80338464113663849327153994379639112L);
1319 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
1320   TEST_ff_f (atan2, 0x1.00000000000001p0L, 0x1.00000000000001p0L, M_PI_4l);
1321 #endif
1322
1323   END (atan2);
1324 }
1325
1326 static void
1327 cabs_test (void)
1328 {
1329   errno = 0;
1330   FUNC(cabs) (BUILD_COMPLEX (0.7L, 12.4L));
1331   if (errno == ENOSYS)
1332     /* Function not implemented.  */
1333     return;
1334
1335   START (cabs);
1336
1337   /* cabs (x + iy) is specified as hypot (x,y) */
1338
1339   /* cabs (+inf + i x) == +inf.  */
1340   TEST_c_f (cabs, plus_infty, 1.0, plus_infty);
1341   /* cabs (-inf + i x) == +inf.  */
1342   TEST_c_f (cabs, minus_infty, 1.0, plus_infty);
1343
1344   TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
1345   TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
1346
1347   TEST_c_f (cabs, nan_value, nan_value, nan_value);
1348
1349   /* cabs (x,y) == cabs (y,x).  */
1350   TEST_c_f (cabs, 0.75L, 12.390625L, 12.4133028598606664302388810868156657L);
1351   /* cabs (x,y) == cabs (-x,y).  */
1352   TEST_c_f (cabs, -12.390625L, 0.75L, 12.4133028598606664302388810868156657L);
1353   /* cabs (x,y) == cabs (-y,x).  */
1354   TEST_c_f (cabs, -0.75L, 12.390625L, 12.4133028598606664302388810868156657L);
1355   /* cabs (x,y) == cabs (-x,-y).  */
1356   TEST_c_f (cabs, -12.390625L, -0.75L, 12.4133028598606664302388810868156657L);
1357   /* cabs (x,y) == cabs (-y,-x).  */
1358   TEST_c_f (cabs, -0.75L, -12.390625L, 12.4133028598606664302388810868156657L);
1359   /* cabs (x,0) == fabs (x).  */
1360   TEST_c_f (cabs, -0.75L, 0, 0.75L);
1361   TEST_c_f (cabs, 0.75L, 0, 0.75L);
1362   TEST_c_f (cabs, -1.0L, 0, 1.0L);
1363   TEST_c_f (cabs, 1.0L, 0, 1.0L);
1364   TEST_c_f (cabs, -5.7e7L, 0, 5.7e7L);
1365   TEST_c_f (cabs, 5.7e7L, 0, 5.7e7L);
1366
1367   TEST_c_f (cabs, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
1368
1369   END (cabs);
1370 }
1371
1372
1373 static void
1374 cacos_test (void)
1375 {
1376   errno = 0;
1377   FUNC(cacos) (BUILD_COMPLEX (0.7L, 1.2L));
1378   if (errno == ENOSYS)
1379     /* Function not implemented.  */
1380     return;
1381
1382   START (cacos);
1383
1384
1385   TEST_c_c (cacos, 0, 0, M_PI_2l, minus_zero);
1386   TEST_c_c (cacos, minus_zero, 0, M_PI_2l, minus_zero);
1387   TEST_c_c (cacos, minus_zero, minus_zero, M_PI_2l, 0.0);
1388   TEST_c_c (cacos, 0, minus_zero, M_PI_2l, 0.0);
1389
1390   TEST_c_c (cacos, minus_infty, plus_infty, M_PI_34l, minus_infty);
1391   TEST_c_c (cacos, minus_infty, minus_infty, M_PI_34l, plus_infty);
1392
1393   TEST_c_c (cacos, plus_infty, plus_infty, M_PI_4l, minus_infty);
1394   TEST_c_c (cacos, plus_infty, minus_infty, M_PI_4l, plus_infty);
1395
1396   TEST_c_c (cacos, -10.0, plus_infty, M_PI_2l, minus_infty);
1397   TEST_c_c (cacos, -10.0, minus_infty, M_PI_2l, plus_infty);
1398   TEST_c_c (cacos, 0, plus_infty, M_PI_2l, minus_infty);
1399   TEST_c_c (cacos, 0, minus_infty, M_PI_2l, plus_infty);
1400   TEST_c_c (cacos, 0.1L, plus_infty, M_PI_2l, minus_infty);
1401   TEST_c_c (cacos, 0.1L, minus_infty, M_PI_2l, plus_infty);
1402
1403   TEST_c_c (cacos, minus_infty, 0, M_PIl, minus_infty);
1404   TEST_c_c (cacos, minus_infty, minus_zero, M_PIl, plus_infty);
1405   TEST_c_c (cacos, minus_infty, 100, M_PIl, minus_infty);
1406   TEST_c_c (cacos, minus_infty, -100, M_PIl, plus_infty);
1407
1408   TEST_c_c (cacos, plus_infty, 0, 0.0, minus_infty);
1409   TEST_c_c (cacos, plus_infty, minus_zero, 0.0, plus_infty);
1410   TEST_c_c (cacos, plus_infty, 0.5, 0.0, minus_infty);
1411   TEST_c_c (cacos, plus_infty, -0.5, 0.0, plus_infty);
1412
1413   TEST_c_c (cacos, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1414   TEST_c_c (cacos, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1415
1416   TEST_c_c (cacos, 0, nan_value, M_PI_2l, nan_value);
1417   TEST_c_c (cacos, minus_zero, nan_value, M_PI_2l, nan_value);
1418
1419   TEST_c_c (cacos, nan_value, plus_infty, nan_value, minus_infty);
1420   TEST_c_c (cacos, nan_value, minus_infty, nan_value, plus_infty);
1421
1422   TEST_c_c (cacos, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1423   TEST_c_c (cacos, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1424
1425   TEST_c_c (cacos, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1426   TEST_c_c (cacos, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1427
1428   TEST_c_c (cacos, nan_value, nan_value, nan_value, nan_value);
1429
1430   TEST_c_c (cacos, plus_zero, -1.5L, M_PI_2l, 1.194763217287109304111930828519090523536L);
1431   TEST_c_c (cacos, minus_zero, -1.5L, M_PI_2l, 1.194763217287109304111930828519090523536L);
1432   TEST_c_c (cacos, plus_zero, -1.0L, M_PI_2l, 0.8813735870195430252326093249797923090282L);
1433   TEST_c_c (cacos, minus_zero, -1.0L, M_PI_2l, 0.8813735870195430252326093249797923090282L);
1434   TEST_c_c (cacos, plus_zero, -0.5L, M_PI_2l, 0.4812118250596034474977589134243684231352L);
1435   TEST_c_c (cacos, minus_zero, -0.5L, M_PI_2l, 0.4812118250596034474977589134243684231352L);
1436   TEST_c_c (cacos, plus_zero, 0.5L, M_PI_2l, -0.4812118250596034474977589134243684231352L);
1437   TEST_c_c (cacos, minus_zero, 0.5L, M_PI_2l, -0.4812118250596034474977589134243684231352L);
1438   TEST_c_c (cacos, plus_zero, 1.0L, M_PI_2l, -0.8813735870195430252326093249797923090282L);
1439   TEST_c_c (cacos, minus_zero, 1.0L, M_PI_2l, -0.8813735870195430252326093249797923090282L);
1440   TEST_c_c (cacos, plus_zero, 1.5L, M_PI_2l, -1.194763217287109304111930828519090523536L);
1441   TEST_c_c (cacos, minus_zero, 1.5L, M_PI_2l, -1.194763217287109304111930828519090523536L);
1442
1443   TEST_c_c (cacos, -1.5L, plus_zero, M_PIl, -0.9624236501192068949955178268487368462704L);
1444   TEST_c_c (cacos, -1.5L, minus_zero, M_PIl, 0.9624236501192068949955178268487368462704L);
1445   TEST_c_c (cacos, -1.0L, plus_zero, M_PIl, minus_zero);
1446   TEST_c_c (cacos, -1.0L, minus_zero, M_PIl, plus_zero);
1447   TEST_c_c (cacos, -0.5L, plus_zero, 2.094395102393195492308428922186335256131L, minus_zero);
1448   TEST_c_c (cacos, -0.5L, minus_zero, 2.094395102393195492308428922186335256131L, plus_zero);
1449   TEST_c_c (cacos, 0.5L, plus_zero, 1.047197551196597746154214461093167628066L, minus_zero);
1450   TEST_c_c (cacos, 0.5L, minus_zero, 1.047197551196597746154214461093167628066L, plus_zero);
1451   TEST_c_c (cacos, 1.0L, plus_zero, plus_zero, minus_zero);
1452   TEST_c_c (cacos, 1.0L, minus_zero, plus_zero, plus_zero);
1453   TEST_c_c (cacos, 1.5L, plus_zero, plus_zero, -0.9624236501192068949955178268487368462704L);
1454   TEST_c_c (cacos, 1.5L, minus_zero, plus_zero, 0.9624236501192068949955178268487368462704L);
1455
1456   TEST_c_c (cacos, 0x1p50L, 1.0L, 8.881784197001252323389053344727730248720e-16L, -3.535050620855721078027883819436720218708e1L);
1457   TEST_c_c (cacos, 0x1p50L, -1.0L, 8.881784197001252323389053344727730248720e-16L, 3.535050620855721078027883819436720218708e1L);
1458   TEST_c_c (cacos, -0x1p50L, 1.0L, 3.141592653589792350284223683154270545292L, -3.535050620855721078027883819436720218708e1L);
1459   TEST_c_c (cacos, -0x1p50L, -1.0L, 3.141592653589792350284223683154270545292L, 3.535050620855721078027883819436720218708e1L);
1460   TEST_c_c (cacos, 1.0L, 0x1p50L, 1.570796326794895731052901991514519103193L, -3.535050620855721078027883819436759661753e1L);
1461   TEST_c_c (cacos, -1.0L, 0x1p50L, 1.570796326794897507409741391764983781004L, -3.535050620855721078027883819436759661753e1L);
1462   TEST_c_c (cacos, 1.0L, -0x1p50L, 1.570796326794895731052901991514519103193L, 3.535050620855721078027883819436759661753e1L);
1463   TEST_c_c (cacos, -1.0L, -0x1p50L, 1.570796326794897507409741391764983781004L, 3.535050620855721078027883819436759661753e1L);
1464 #ifndef TEST_FLOAT
1465   TEST_c_c (cacos, 0x1p500L, 1.0L, 3.054936363499604682051979393213617699789e-151L, -3.472667374605326000180332928505464606058e2L);
1466   TEST_c_c (cacos, 0x1p500L, -1.0L, 3.054936363499604682051979393213617699789e-151L, 3.472667374605326000180332928505464606058e2L);
1467   TEST_c_c (cacos, -0x1p500L, 1.0L, 3.141592653589793238462643383279502884197L, -3.472667374605326000180332928505464606058e2L);
1468   TEST_c_c (cacos, -0x1p500L, -1.0L, 3.141592653589793238462643383279502884197L, 3.472667374605326000180332928505464606058e2L);
1469   TEST_c_c (cacos, 1.0L, 0x1p500L, 1.570796326794896619231321691639751442099L, -3.472667374605326000180332928505464606058e2L);
1470   TEST_c_c (cacos, -1.0L, 0x1p500L, 1.570796326794896619231321691639751442099L, -3.472667374605326000180332928505464606058e2L);
1471   TEST_c_c (cacos, 1.0L, -0x1p500L, 1.570796326794896619231321691639751442099L, 3.472667374605326000180332928505464606058e2L);
1472   TEST_c_c (cacos, -1.0L, -0x1p500L, 1.570796326794896619231321691639751442099L, 3.472667374605326000180332928505464606058e2L);
1473 #endif
1474 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
1475   TEST_c_c (cacos, 0x1p5000L, 1.0L, 7.079811261048172892385615158694057552948e-1506L, -3.466429049980286492395577839412341016946e3L);
1476   TEST_c_c (cacos, 0x1p5000L, -1.0L, 7.079811261048172892385615158694057552948e-1506L, 3.466429049980286492395577839412341016946e3L);
1477   TEST_c_c (cacos, -0x1p5000L, 1.0L, 3.141592653589793238462643383279502884197L, -3.466429049980286492395577839412341016946e3L);
1478   TEST_c_c (cacos, -0x1p5000L, -1.0L, 3.141592653589793238462643383279502884197L, 3.466429049980286492395577839412341016946e3L);
1479   TEST_c_c (cacos, 1.0L, 0x1p5000L, 1.570796326794896619231321691639751442099L, -3.466429049980286492395577839412341016946e3L);
1480   TEST_c_c (cacos, -1.0L, 0x1p5000L, 1.570796326794896619231321691639751442099L, -3.466429049980286492395577839412341016946e3L);
1481   TEST_c_c (cacos, 1.0L, -0x1p5000L, 1.570796326794896619231321691639751442099L, 3.466429049980286492395577839412341016946e3L);
1482   TEST_c_c (cacos, -1.0L, -0x1p5000L, 1.570796326794896619231321691639751442099L, 3.466429049980286492395577839412341016946e3L);
1483 #endif
1484
1485   TEST_c_c (cacos, 0x1.fp127L, 0x1.fp127L, 7.853981633974483096156608458198757210493e-1L, -8.973081118419833726837456344608533993585e1L);
1486 #ifndef TEST_FLOAT
1487   TEST_c_c (cacos, 0x1.fp1023L, 0x1.fp1023L, 7.853981633974483096156608458198757210493e-1L, -7.107906849659093345062145442726115449315e2L);
1488 #endif
1489 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
1490   TEST_c_c (cacos, 0x1.fp16383L, 0x1.fp16383L, 7.853981633974483096156608458198757210493e-1L, -1.135753137836666928715489992987020363057e4L);
1491 #endif
1492
1493   TEST_c_c (cacos, 0x1.fp-129L, 1.5L, 1.570796326794896619231321691639751442097L, -1.194763217287109304111930828519090523536L);
1494   TEST_c_c (cacos, 0x1.fp-129L, -1.5L, 1.570796326794896619231321691639751442097L, 1.194763217287109304111930828519090523536L);
1495   TEST_c_c (cacos, -0x1.fp-129L, 1.5L, 1.570796326794896619231321691639751442100L, -1.194763217287109304111930828519090523536L);
1496   TEST_c_c (cacos, -0x1.fp-129L, -1.5L, 1.570796326794896619231321691639751442100L, 1.194763217287109304111930828519090523536L);
1497   TEST_c_c (cacos, 1.5L, 0x1.fp-129L, 2.546345110742945032959687790021055102355e-39L, -9.624236501192068949955178268487368462704e-1L, UNDERFLOW_EXCEPTION_FLOAT);
1498   TEST_c_c (cacos, -1.5L, 0x1.fp-129L, 3.141592653589793238462643383279502884195L, -9.624236501192068949955178268487368462704e-1L);
1499   TEST_c_c (cacos, 1.5L, -0x1.fp-129L, 2.546345110742945032959687790021055102355e-39L, 9.624236501192068949955178268487368462704e-1L, UNDERFLOW_EXCEPTION_FLOAT);
1500   TEST_c_c (cacos, -1.5L, -0x1.fp-129L, 3.141592653589793238462643383279502884195L, 9.624236501192068949955178268487368462704e-1L);
1501 #ifndef TEST_FLOAT
1502   TEST_c_c (cacos, 0x1.fp-1025L, 1.5L, 1.570796326794896619231321691639751442099L, -1.194763217287109304111930828519090523536L);
1503   TEST_c_c (cacos, 0x1.fp-1025L, -1.5L, 1.570796326794896619231321691639751442099L, 1.194763217287109304111930828519090523536L);
1504   TEST_c_c (cacos, -0x1.fp-1025L, 1.5L, 1.570796326794896619231321691639751442099L, -1.194763217287109304111930828519090523536L);
1505   TEST_c_c (cacos, -0x1.fp-1025L, -1.5L, 1.570796326794896619231321691639751442099L, 1.194763217287109304111930828519090523536L);
1506   TEST_c_c (cacos, 1.5L, 0x1.fp-1025L, 4.819934639999230680322935210539402497827e-309L, -9.624236501192068949955178268487368462704e-1L, UNDERFLOW_EXCEPTION_DOUBLE);
1507   TEST_c_c (cacos, -1.5L, 0x1.fp-1025L, 3.141592653589793238462643383279502884197L, -9.624236501192068949955178268487368462704e-1L);
1508   TEST_c_c (cacos, 1.5L, -0x1.fp-1025L, 4.819934639999230680322935210539402497827e-309L, 9.624236501192068949955178268487368462704e-1L, UNDERFLOW_EXCEPTION_DOUBLE);
1509   TEST_c_c (cacos, -1.5L, -0x1.fp-1025L, 3.141592653589793238462643383279502884197L, 9.624236501192068949955178268487368462704e-1L);
1510 #endif
1511 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
1512   TEST_c_c (cacos, 0x1.fp-16385L, 1.5L, 1.570796326794896619231321691639751442099L, -1.194763217287109304111930828519090523536L);
1513   TEST_c_c (cacos, 0x1.fp-16385L, -1.5L, 1.570796326794896619231321691639751442099L, 1.194763217287109304111930828519090523536L);
1514   TEST_c_c (cacos, -0x1.fp-16385L, 1.5L, 1.570796326794896619231321691639751442099L, -1.194763217287109304111930828519090523536L);
1515   TEST_c_c (cacos, -0x1.fp-16385L, -1.5L, 1.570796326794896619231321691639751442099L, 1.194763217287109304111930828519090523536L);
1516   TEST_c_c (cacos, 1.5L, 0x1.fp-16385L, 7.282957076134209141226696333885150260319e-4933L, -9.624236501192068949955178268487368462704e-1L, UNDERFLOW_EXCEPTION);
1517   TEST_c_c (cacos, -1.5L, 0x1.fp-16385L, 3.141592653589793238462643383279502884197L, -9.624236501192068949955178268487368462704e-1L);
1518   TEST_c_c (cacos, 1.5L, -0x1.fp-16385L, 7.282957076134209141226696333885150260319e-4933L, 9.624236501192068949955178268487368462704e-1L, UNDERFLOW_EXCEPTION);
1519   TEST_c_c (cacos, -1.5L, -0x1.fp-16385L, 3.141592653589793238462643383279502884197L, 9.624236501192068949955178268487368462704e-1L);
1520 #endif
1521
1522   TEST_c_c (cacos, 0.75L, 1.25L, 1.11752014915610270578240049553777969L, -1.13239363160530819522266333696834467L);
1523   TEST_c_c (cacos, -2, -3, 2.1414491111159960199416055713254211L, 1.9833870299165354323470769028940395L);
1524
1525   END (cacos, complex);
1526 }
1527
1528 static void
1529 cacosh_test (void)
1530 {
1531   errno = 0;
1532   FUNC(cacosh) (BUILD_COMPLEX (0.7L, 1.2L));
1533   if (errno == ENOSYS)
1534     /* Function not implemented.  */
1535     return;
1536
1537   START (cacosh);
1538
1539
1540   TEST_c_c (cacosh, 0, 0, 0.0, M_PI_2l);
1541   TEST_c_c (cacosh, minus_zero, 0, 0.0, M_PI_2l);
1542   TEST_c_c (cacosh, 0, minus_zero, 0.0, -M_PI_2l);
1543   TEST_c_c (cacosh, minus_zero, minus_zero, 0.0, -M_PI_2l);
1544   TEST_c_c (cacosh, minus_infty, plus_infty, plus_infty, M_PI_34l);
1545   TEST_c_c (cacosh, minus_infty, minus_infty, plus_infty, -M_PI_34l);
1546
1547   TEST_c_c (cacosh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1548   TEST_c_c (cacosh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1549
1550   TEST_c_c (cacosh, -10.0, plus_infty, plus_infty, M_PI_2l);
1551   TEST_c_c (cacosh, -10.0, minus_infty, plus_infty, -M_PI_2l);
1552   TEST_c_c (cacosh, 0, plus_infty, plus_infty, M_PI_2l);
1553   TEST_c_c (cacosh, 0, minus_infty, plus_infty, -M_PI_2l);
1554   TEST_c_c (cacosh, 0.1L, plus_infty, plus_infty, M_PI_2l);
1555   TEST_c_c (cacosh, 0.1L, minus_infty, plus_infty, -M_PI_2l);
1556
1557   TEST_c_c (cacosh, minus_infty, 0, plus_infty, M_PIl);
1558   TEST_c_c (cacosh, minus_infty, minus_zero, plus_infty, -M_PIl);
1559   TEST_c_c (cacosh, minus_infty, 100, plus_infty, M_PIl);
1560   TEST_c_c (cacosh, minus_infty, -100, plus_infty, -M_PIl);
1561
1562   TEST_c_c (cacosh, plus_infty, 0, plus_infty, 0.0);
1563   TEST_c_c (cacosh, plus_infty, minus_zero, plus_infty, minus_zero);
1564   TEST_c_c (cacosh, plus_infty, 0.5, plus_infty, 0.0);
1565   TEST_c_c (cacosh, plus_infty, -0.5, plus_infty, minus_zero);
1566
1567   TEST_c_c (cacosh, plus_infty, nan_value, plus_infty, nan_value);
1568   TEST_c_c (cacosh, minus_infty, nan_value, plus_infty, nan_value);
1569
1570   TEST_c_c (cacosh, 0, nan_value, nan_value, nan_value);
1571   TEST_c_c (cacosh, minus_zero, nan_value, nan_value, nan_value);
1572
1573   TEST_c_c (cacosh, nan_value, plus_infty, plus_infty, nan_value);
1574   TEST_c_c (cacosh, nan_value, minus_infty, plus_infty, nan_value);
1575
1576   TEST_c_c (cacosh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1577   TEST_c_c (cacosh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1578
1579   TEST_c_c (cacosh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1580   TEST_c_c (cacosh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1581
1582   TEST_c_c (cacosh, nan_value, nan_value, nan_value, nan_value);
1583
1584   TEST_c_c (cacosh, plus_zero, -1.5L, 1.194763217287109304111930828519090523536L, -M_PI_2l);
1585   TEST_c_c (cacosh, minus_zero, -1.5L, 1.194763217287109304111930828519090523536L, -M_PI_2l);
1586   TEST_c_c (cacosh, plus_zero, -1.0L, 0.8813735870195430252326093249797923090282L, -M_PI_2l);
1587   TEST_c_c (cacosh, minus_zero, -1.0L, 0.8813735870195430252326093249797923090282L, -M_PI_2l);
1588   TEST_c_c (cacosh, plus_zero, -0.5L, 0.4812118250596034474977589134243684231352L, -M_PI_2l);
1589   TEST_c_c (cacosh, minus_zero, -0.5L, 0.4812118250596034474977589134243684231352L, -M_PI_2l);
1590   TEST_c_c (cacosh, plus_zero, 0.5L, 0.4812118250596034474977589134243684231352L, M_PI_2l);
1591   TEST_c_c (cacosh, minus_zero, 0.5L, 0.4812118250596034474977589134243684231352L, M_PI_2l);
1592   TEST_c_c (cacosh, plus_zero, 1.0L, 0.8813735870195430252326093249797923090282L, M_PI_2l);
1593   TEST_c_c (cacosh, minus_zero, 1.0L, 0.8813735870195430252326093249797923090282L, M_PI_2l);
1594   TEST_c_c (cacosh, plus_zero, 1.5L, 1.194763217287109304111930828519090523536L, M_PI_2l);
1595   TEST_c_c (cacosh, minus_zero, 1.5L, 1.194763217287109304111930828519090523536L, M_PI_2l);
1596
1597   TEST_c_c (cacosh, -1.5L, plus_zero, 0.9624236501192068949955178268487368462704L, M_PIl);
1598   TEST_c_c (cacosh, -1.5L, minus_zero, 0.9624236501192068949955178268487368462704L, -M_PIl);
1599   TEST_c_c (cacosh, -1.0L, plus_zero, plus_zero, M_PIl);
1600   TEST_c_c (cacosh, -1.0L, minus_zero, plus_zero, -M_PIl);
1601   TEST_c_c (cacosh, -0.5L, plus_zero, plus_zero, 2.094395102393195492308428922186335256131L);
1602   TEST_c_c (cacosh, -0.5L, minus_zero, plus_zero, -2.094395102393195492308428922186335256131L);
1603   TEST_c_c (cacosh, 0.5L, plus_zero, plus_zero, 1.047197551196597746154214461093167628066L);
1604   TEST_c_c (cacosh, 0.5L, minus_zero, plus_zero, -1.047197551196597746154214461093167628066L);
1605   TEST_c_c (cacosh, 1.0L, plus_zero, plus_zero, plus_zero);
1606   TEST_c_c (cacosh, 1.0L, minus_zero, plus_zero, minus_zero);
1607   TEST_c_c (cacosh, 1.5L, plus_zero, 0.9624236501192068949955178268487368462704L, plus_zero);
1608   TEST_c_c (cacosh, 1.5L, minus_zero, 0.9624236501192068949955178268487368462704L, minus_zero);
1609
1610   TEST_c_c (cacosh, 0.75L, 1.25L, 1.13239363160530819522266333696834467L, 1.11752014915610270578240049553777969L);
1611   TEST_c_c (cacosh, -2, -3, 1.9833870299165354323470769028940395L, -2.1414491111159960199416055713254211L);
1612
1613   END (cacosh, complex);
1614 }
1615
1616
1617 static void
1618 carg_test (void)
1619 {
1620   START (carg);
1621
1622   /* carg (x + iy) is specified as atan2 (y, x) */
1623
1624   /* carg (x + i 0) == 0 for x > 0.  */
1625   TEST_c_f (carg, 2.0, 0, 0);
1626   /* carg (x - i 0) == -0 for x > 0.  */
1627   TEST_c_f (carg, 2.0, minus_zero, minus_zero);
1628
1629   TEST_c_f (carg, 0, 0, 0);
1630   TEST_c_f (carg, 0, minus_zero, minus_zero);
1631
1632   /* carg (x + i 0) == +pi for x < 0.  */
1633   TEST_c_f (carg, -2.0, 0, M_PIl);
1634
1635   /* carg (x - i 0) == -pi for x < 0.  */
1636   TEST_c_f (carg, -2.0, minus_zero, -M_PIl);
1637
1638   TEST_c_f (carg, minus_zero, 0, M_PIl);
1639   TEST_c_f (carg, minus_zero, minus_zero, -M_PIl);
1640
1641   /* carg (+0 + i y) == pi/2 for y > 0.  */
1642   TEST_c_f (carg, 0, 2.0, M_PI_2l);
1643
1644   /* carg (-0 + i y) == pi/2 for y > 0.  */
1645   TEST_c_f (carg, minus_zero, 2.0, M_PI_2l);
1646
1647   /* carg (+0 + i y) == -pi/2 for y < 0.  */
1648   TEST_c_f (carg, 0, -2.0, -M_PI_2l);
1649
1650   /* carg (-0 + i y) == -pi/2 for y < 0.  */
1651   TEST_c_f (carg, minus_zero, -2.0, -M_PI_2l);
1652
1653   /* carg (inf + i y) == +0 for finite y > 0.  */
1654   TEST_c_f (carg, plus_infty, 2.0, 0);
1655
1656   /* carg (inf + i y) == -0 for finite y < 0.  */
1657   TEST_c_f (carg, plus_infty, -2.0, minus_zero);
1658
1659   /* carg(x + i inf) == pi/2 for finite x.  */
1660   TEST_c_f (carg, 10.0, plus_infty, M_PI_2l);
1661
1662   /* carg(x - i inf) == -pi/2 for finite x.  */
1663   TEST_c_f (carg, 10.0, minus_infty, -M_PI_2l);
1664
1665   /* carg (-inf + i y) == +pi for finite y > 0.  */
1666   TEST_c_f (carg, minus_infty, 10.0, M_PIl);
1667
1668   /* carg (-inf + i y) == -pi for finite y < 0.  */
1669   TEST_c_f (carg, minus_infty, -10.0, -M_PIl);
1670
1671   TEST_c_f (carg, plus_infty, plus_infty, M_PI_4l);
1672
1673   TEST_c_f (carg, plus_infty, minus_infty, -M_PI_4l);
1674
1675   TEST_c_f (carg, minus_infty, plus_infty, 3 * M_PI_4l);
1676
1677   TEST_c_f (carg, minus_infty, minus_infty, -3 * M_PI_4l);
1678
1679   TEST_c_f (carg, nan_value, nan_value, nan_value);
1680
1681   END (carg);
1682 }
1683
1684 static void
1685 casin_test (void)
1686 {
1687   errno = 0;
1688   FUNC(casin) (BUILD_COMPLEX (0.7L, 1.2L));
1689   if (errno == ENOSYS)
1690     /* Function not implemented.  */
1691     return;
1692
1693   START (casin);
1694
1695   TEST_c_c (casin, 0, 0, 0.0, 0.0);
1696   TEST_c_c (casin, minus_zero, 0, minus_zero, 0.0);
1697   TEST_c_c (casin, 0, minus_zero, 0.0, minus_zero);
1698   TEST_c_c (casin, minus_zero, minus_zero, minus_zero, minus_zero);
1699
1700   TEST_c_c (casin, plus_infty, plus_infty, M_PI_4l, plus_infty);
1701   TEST_c_c (casin, plus_infty, minus_infty, M_PI_4l, minus_infty);
1702   TEST_c_c (casin, minus_infty, plus_infty, -M_PI_4l, plus_infty);
1703   TEST_c_c (casin, minus_infty, minus_infty, -M_PI_4l, minus_infty);
1704
1705   TEST_c_c (casin, -10.0, plus_infty, minus_zero, plus_infty);
1706   TEST_c_c (casin, -10.0, minus_infty, minus_zero, minus_infty);
1707   TEST_c_c (casin, 0, plus_infty, 0.0, plus_infty);
1708   TEST_c_c (casin, 0, minus_infty, 0.0, minus_infty);
1709   TEST_c_c (casin, minus_zero, plus_infty, minus_zero, plus_infty);
1710   TEST_c_c (casin, minus_zero, minus_infty, minus_zero, minus_infty);
1711   TEST_c_c (casin, 0.1L, plus_infty, 0.0, plus_infty);
1712   TEST_c_c (casin, 0.1L, minus_infty, 0.0, minus_infty);
1713
1714   TEST_c_c (casin, minus_infty, 0, -M_PI_2l, plus_infty);
1715   TEST_c_c (casin, minus_infty, minus_zero, -M_PI_2l, minus_infty);
1716   TEST_c_c (casin, minus_infty, 100, -M_PI_2l, plus_infty);
1717   TEST_c_c (casin, minus_infty, -100, -M_PI_2l, minus_infty);
1718
1719   TEST_c_c (casin, plus_infty, 0, M_PI_2l, plus_infty);
1720   TEST_c_c (casin, plus_infty, minus_zero, M_PI_2l, minus_infty);
1721   TEST_c_c (casin, plus_infty, 0.5, M_PI_2l, plus_infty);
1722   TEST_c_c (casin, plus_infty, -0.5, M_PI_2l, minus_infty);
1723
1724   TEST_c_c (casin, nan_value, plus_infty, nan_value, plus_infty);
1725   TEST_c_c (casin, nan_value, minus_infty, nan_value, minus_infty);
1726
1727   TEST_c_c (casin, 0.0, nan_value, 0.0, nan_value);
1728   TEST_c_c (casin, minus_zero, nan_value, minus_zero, nan_value);
1729
1730   TEST_c_c (casin, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1731   TEST_c_c (casin, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1732
1733   TEST_c_c (casin, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1734   TEST_c_c (casin, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1735
1736   TEST_c_c (casin, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1737   TEST_c_c (casin, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1738
1739   TEST_c_c (casin, nan_value, nan_value, nan_value, nan_value);
1740
1741   TEST_c_c (casin, plus_zero, -1.5L, plus_zero, -1.194763217287109304111930828519090523536L);
1742   TEST_c_c (casin, minus_zero, -1.5L, minus_zero, -1.194763217287109304111930828519090523536L);
1743   TEST_c_c (casin, plus_zero, -1.0L, plus_zero, -0.8813735870195430252326093249797923090282L);
1744   TEST_c_c (casin, minus_zero, -1.0L, minus_zero, -0.8813735870195430252326093249797923090282L);
1745   TEST_c_c (casin, plus_zero, -0.5L, plus_zero, -0.4812118250596034474977589134243684231352L);
1746   TEST_c_c (casin, minus_zero, -0.5L, minus_zero, -0.4812118250596034474977589134243684231352L);
1747   TEST_c_c (casin, plus_zero, 0.5L, plus_zero, 0.4812118250596034474977589134243684231352L);
1748   TEST_c_c (casin, minus_zero, 0.5L, minus_zero, 0.4812118250596034474977589134243684231352L);
1749   TEST_c_c (casin, plus_zero, 1.0L, plus_zero, 0.8813735870195430252326093249797923090282L);
1750   TEST_c_c (casin, minus_zero, 1.0L, minus_zero, 0.8813735870195430252326093249797923090282L);
1751   TEST_c_c (casin, plus_zero, 1.5L, plus_zero, 1.194763217287109304111930828519090523536L);
1752   TEST_c_c (casin, minus_zero, 1.5L, minus_zero, 1.194763217287109304111930828519090523536L);
1753
1754   TEST_c_c (casin, -1.5L, plus_zero, -M_PI_2l, 0.9624236501192068949955178268487368462704L);
1755   TEST_c_c (casin, -1.5L, minus_zero, -M_PI_2l, -0.9624236501192068949955178268487368462704L);
1756   TEST_c_c (casin, -1.0L, plus_zero, -M_PI_2l, plus_zero);
1757   TEST_c_c (casin, -1.0L, minus_zero, -M_PI_2l, minus_zero);
1758   TEST_c_c (casin, -0.5L, plus_zero, -0.5235987755982988730771072305465838140329L, plus_zero);
1759   TEST_c_c (casin, -0.5L, minus_zero, -0.5235987755982988730771072305465838140329L, minus_zero);
1760   TEST_c_c (casin, 0.5L, plus_zero, 0.5235987755982988730771072305465838140329L, plus_zero);
1761   TEST_c_c (casin, 0.5L, minus_zero, 0.5235987755982988730771072305465838140329L, minus_zero);
1762   TEST_c_c (casin, 1.0L, plus_zero, M_PI_2l, plus_zero);
1763   TEST_c_c (casin, 1.0L, minus_zero, M_PI_2l, minus_zero);
1764   TEST_c_c (casin, 1.5L, plus_zero, M_PI_2l, 0.9624236501192068949955178268487368462704L);
1765   TEST_c_c (casin, 1.5L, minus_zero, M_PI_2l, -0.9624236501192068949955178268487368462704L);
1766
1767   TEST_c_c (casin, 0x1p50L, 1.0L, 1.570796326794895731052901991514519103193L, 3.535050620855721078027883819436720218708e1L);
1768   TEST_c_c (casin, 0x1p50L, -1.0L, 1.570796326794895731052901991514519103193L, -3.535050620855721078027883819436720218708e1L);
1769   TEST_c_c (casin, -0x1p50L, 1.0L, -1.570796326794895731052901991514519103193L, 3.535050620855721078027883819436720218708e1L);
1770   TEST_c_c (casin, -0x1p50L, -1.0L, -1.570796326794895731052901991514519103193L, -3.535050620855721078027883819436720218708e1L);
1771   TEST_c_c (casin, 1.0L, 0x1p50L, 8.881784197001252323389053344720723756399e-16L, 3.535050620855721078027883819436759661753e1L);
1772   TEST_c_c (casin, -1.0L, 0x1p50L, -8.881784197001252323389053344720723756399e-16L, 3.535050620855721078027883819436759661753e1L);
1773   TEST_c_c (casin, 1.0L, -0x1p50L, 8.881784197001252323389053344720723756399e-16L, -3.535050620855721078027883819436759661753e1L);
1774   TEST_c_c (casin, -1.0L, -0x1p50L, -8.881784197001252323389053344720723756399e-16L, -3.535050620855721078027883819436759661753e1L);
1775 #ifndef TEST_FLOAT
1776   TEST_c_c (casin, 0x1p500L, 1.0L, 1.570796326794896619231321691639751442099L, 3.472667374605326000180332928505464606058e2L);
1777   TEST_c_c (casin, 0x1p500L, -1.0L, 1.570796326794896619231321691639751442099L, -3.472667374605326000180332928505464606058e2L);
1778   TEST_c_c (casin, -0x1p500L, 1.0L, -1.570796326794896619231321691639751442099L, 3.472667374605326000180332928505464606058e2L);
1779   TEST_c_c (casin, -0x1p500L, -1.0L, -1.570796326794896619231321691639751442099L, -3.472667374605326000180332928505464606058e2L);
1780   TEST_c_c (casin, 1.0L, 0x1p500L, 3.054936363499604682051979393213617699789e-151L, 3.472667374605326000180332928505464606058e2L);
1781   TEST_c_c (casin, -1.0L, 0x1p500L, -3.054936363499604682051979393213617699789e-151L, 3.472667374605326000180332928505464606058e2L);
1782   TEST_c_c (casin, 1.0L, -0x1p500L, 3.054936363499604682051979393213617699789e-151L, -3.472667374605326000180332928505464606058e2L);
1783   TEST_c_c (casin, -1.0L, -0x1p500L, -3.054936363499604682051979393213617699789e-151L, -3.472667374605326000180332928505464606058e2L);
1784 #endif
1785 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
1786   TEST_c_c (casin, 0x1p5000L, 1.0L, 1.570796326794896619231321691639751442099L, 3.466429049980286492395577839412341016946e3L);
1787   TEST_c_c (casin, 0x1p5000L, -1.0L, 1.570796326794896619231321691639751442099L, -3.466429049980286492395577839412341016946e3L);
1788   TEST_c_c (casin, -0x1p5000L, 1.0L, -1.570796326794896619231321691639751442099L, 3.466429049980286492395577839412341016946e3L);
1789   TEST_c_c (casin, -0x1p5000L, -1.0L, -1.570796326794896619231321691639751442099L, -3.466429049980286492395577839412341016946e3L);
1790   TEST_c_c (casin, 1.0L, 0x1p5000L, 7.079811261048172892385615158694057552948e-1506L, 3.466429049980286492395577839412341016946e3L);
1791   TEST_c_c (casin, -1.0L, 0x1p5000L, -7.079811261048172892385615158694057552948e-1506L, 3.466429049980286492395577839412341016946e3L);
1792   TEST_c_c (casin, 1.0L, -0x1p5000L, 7.079811261048172892385615158694057552948e-1506L, -3.466429049980286492395577839412341016946e3L);
1793   TEST_c_c (casin, -1.0L, -0x1p5000L, -7.079811261048172892385615158694057552948e-1506L, -3.466429049980286492395577839412341016946e3L);
1794 #endif
1795
1796   TEST_c_c (casin, 0x1.fp127L, 0x1.fp127L, 7.853981633974483096156608458198757210493e-1L, 8.973081118419833726837456344608533993585e1L);
1797 #ifndef TEST_FLOAT
1798   TEST_c_c (casin, 0x1.fp1023L, 0x1.fp1023L, 7.853981633974483096156608458198757210493e-1L, 7.107906849659093345062145442726115449315e2L);
1799 #endif
1800 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
1801   TEST_c_c (casin, 0x1.fp16383L, 0x1.fp16383L, 7.853981633974483096156608458198757210493e-1L, 1.135753137836666928715489992987020363057e4L);
1802 #endif
1803
1804   TEST_c_c (casin, 0x1.fp-129L, 1.5L, 1.579176199917649005841160751101628985741e-39L, 1.194763217287109304111930828519090523536L, UNDERFLOW_EXCEPTION_FLOAT);
1805   TEST_c_c (casin, 0x1.fp-129L, -1.5L, 1.579176199917649005841160751101628985741e-39L, -1.194763217287109304111930828519090523536L, UNDERFLOW_EXCEPTION_FLOAT);
1806   TEST_c_c (casin, -0x1.fp-129L, 1.5L, -1.579176199917649005841160751101628985741e-39L, 1.194763217287109304111930828519090523536L, UNDERFLOW_EXCEPTION_FLOAT);
1807   TEST_c_c (casin, -0x1.fp-129L, -1.5L, -1.579176199917649005841160751101628985741e-39L, -1.194763217287109304111930828519090523536L, UNDERFLOW_EXCEPTION_FLOAT);
1808   TEST_c_c (casin, 1.5L, 0x1.fp-129L, 1.570796326794896619231321691639751442096L, 9.624236501192068949955178268487368462704e-1L);
1809   TEST_c_c (casin, -1.5L, 0x1.fp-129L, -1.570796326794896619231321691639751442096L, 9.624236501192068949955178268487368462704e-1L);
1810   TEST_c_c (casin, 1.5L, -0x1.fp-129L, 1.570796326794896619231321691639751442096L, -9.624236501192068949955178268487368462704e-1L);
1811   TEST_c_c (casin, -1.5L, -0x1.fp-129L, -1.570796326794896619231321691639751442096L, -9.624236501192068949955178268487368462704e-1L);
1812 #ifndef TEST_FLOAT
1813   TEST_c_c (casin, 0x1.fp-1025L, 1.5L, 2.989196569048182929051881765490354365918e-309L, 1.194763217287109304111930828519090523536L, UNDERFLOW_EXCEPTION_DOUBLE);
1814   TEST_c_c (casin, 0x1.fp-1025L, -1.5L, 2.989196569048182929051881765490354365918e-309L, -1.194763217287109304111930828519090523536L, UNDERFLOW_EXCEPTION_DOUBLE);
1815   TEST_c_c (casin, -0x1.fp-1025L, 1.5L, -2.989196569048182929051881765490354365918e-309L, 1.194763217287109304111930828519090523536L, UNDERFLOW_EXCEPTION_DOUBLE);
1816   TEST_c_c (casin, -0x1.fp-1025L, -1.5L, -2.989196569048182929051881765490354365918e-309L, -1.194763217287109304111930828519090523536L, UNDERFLOW_EXCEPTION_DOUBLE);
1817   TEST_c_c (casin, 1.5L, 0x1.fp-1025L, 1.570796326794896619231321691639751442099L, 9.624236501192068949955178268487368462704e-1L);
1818   TEST_c_c (casin, -1.5L, 0x1.fp-1025L, -1.570796326794896619231321691639751442099L, 9.624236501192068949955178268487368462704e-1L);
1819   TEST_c_c (casin, 1.5L, -0x1.fp-1025L, 1.570796326794896619231321691639751442099L, -9.624236501192068949955178268487368462704e-1L);
1820   TEST_c_c (casin, -1.5L, -0x1.fp-1025L, -1.570796326794896619231321691639751442099L, -9.624236501192068949955178268487368462704e-1L);
1821 #endif
1822 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
1823   TEST_c_c (casin, 0x1.fp-16385L, 1.5L, 4.516698239814521372306784062043266700598e-4933L, 1.194763217287109304111930828519090523536L, UNDERFLOW_EXCEPTION);
1824   TEST_c_c (casin, 0x1.fp-16385L, -1.5L, 4.516698239814521372306784062043266700598e-4933L, -1.194763217287109304111930828519090523536L, UNDERFLOW_EXCEPTION);
1825   TEST_c_c (casin, -0x1.fp-16385L, 1.5L, -4.516698239814521372306784062043266700598e-4933L, 1.194763217287109304111930828519090523536L, UNDERFLOW_EXCEPTION);
1826   TEST_c_c (casin, -0x1.fp-16385L, -1.5L, -4.516698239814521372306784062043266700598e-4933L, -1.194763217287109304111930828519090523536L, UNDERFLOW_EXCEPTION);
1827   TEST_c_c (casin, 1.5L, 0x1.fp-16385L, 1.570796326794896619231321691639751442099L, 9.624236501192068949955178268487368462704e-1L);
1828   TEST_c_c (casin, -1.5L, 0x1.fp-16385L, -1.570796326794896619231321691639751442099L, 9.624236501192068949955178268487368462704e-1L);
1829   TEST_c_c (casin, 1.5L, -0x1.fp-16385L, 1.570796326794896619231321691639751442099L, -9.624236501192068949955178268487368462704e-1L);
1830   TEST_c_c (casin, -1.5L, -0x1.fp-16385L, -1.570796326794896619231321691639751442099L, -9.624236501192068949955178268487368462704e-1L);
1831 #endif
1832
1833   TEST_c_c (casin, 0.75L, 1.25L, 0.453276177638793913448921196101971749L, 1.13239363160530819522266333696834467L);
1834   TEST_c_c (casin, -2, -3, -0.57065278432109940071028387968566963L, -1.9833870299165354323470769028940395L);
1835
1836   END (casin, complex);
1837 }
1838
1839
1840 static void
1841 casinh_test (void)
1842 {
1843   errno = 0;
1844   FUNC(casinh) (BUILD_COMPLEX (0.7L, 1.2L));
1845   if (errno == ENOSYS)
1846     /* Function not implemented.  */
1847     return;
1848
1849   START (casinh);
1850
1851   TEST_c_c (casinh, 0, 0, 0.0, 0.0);
1852   TEST_c_c (casinh, minus_zero, 0, minus_zero, 0);
1853   TEST_c_c (casinh, 0, minus_zero, 0.0, minus_zero);
1854   TEST_c_c (casinh, minus_zero, minus_zero, minus_zero, minus_zero);
1855
1856   TEST_c_c (casinh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1857   TEST_c_c (casinh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1858   TEST_c_c (casinh, minus_infty, plus_infty, minus_infty, M_PI_4l);
1859   TEST_c_c (casinh, minus_infty, minus_infty, minus_infty, -M_PI_4l);
1860
1861   TEST_c_c (casinh, -10.0, plus_infty, minus_infty, M_PI_2l);
1862   TEST_c_c (casinh, -10.0, minus_infty, minus_infty, -M_PI_2l);
1863   TEST_c_c (casinh, 0, plus_infty, plus_infty, M_PI_2l);
1864   TEST_c_c (casinh, 0, minus_infty, plus_infty, -M_PI_2l);
1865   TEST_c_c (casinh, minus_zero, plus_infty, minus_infty, M_PI_2l);
1866   TEST_c_c (casinh, minus_zero, minus_infty, minus_infty, -M_PI_2l);
1867   TEST_c_c (casinh, 0.1L, plus_infty, plus_infty, M_PI_2l);
1868   TEST_c_c (casinh, 0.1L, minus_infty, plus_infty, -M_PI_2l);
1869
1870   TEST_c_c (casinh, minus_infty, 0, minus_infty, 0.0);
1871   TEST_c_c (casinh, minus_infty, minus_zero, minus_infty, minus_zero);
1872   TEST_c_c (casinh, minus_infty, 100, minus_infty, 0.0);
1873   TEST_c_c (casinh, minus_infty, -100, minus_infty, minus_zero);
1874
1875   TEST_c_c (casinh, plus_infty, 0, plus_infty, 0.0);
1876   TEST_c_c (casinh, plus_infty, minus_zero, plus_infty, minus_zero);
1877   TEST_c_c (casinh, plus_infty, 0.5, plus_infty, 0.0);
1878   TEST_c_c (casinh, plus_infty, -0.5, plus_infty, minus_zero);
1879
1880   TEST_c_c (casinh, plus_infty, nan_value, plus_infty, nan_value);
1881   TEST_c_c (casinh, minus_infty, nan_value, minus_infty, nan_value);
1882
1883   TEST_c_c (casinh, nan_value, 0, nan_value, 0.0);
1884   TEST_c_c (casinh, nan_value, minus_zero, nan_value, minus_zero);
1885
1886   TEST_c_c (casinh, nan_value, plus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1887   TEST_c_c (casinh, nan_value, minus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1888
1889   TEST_c_c (casinh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1890   TEST_c_c (casinh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1891
1892   TEST_c_c (casinh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1893   TEST_c_c (casinh, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1894
1895   TEST_c_c (casinh, nan_value, nan_value, nan_value, nan_value);
1896
1897   TEST_c_c (casinh, plus_zero, -1.5L, 0.9624236501192068949955178268487368462704L, -M_PI_2l);
1898   TEST_c_c (casinh, minus_zero, -1.5L, -0.9624236501192068949955178268487368462704L, -M_PI_2l);
1899   TEST_c_c (casinh, plus_zero, -1.0L, plus_zero, -M_PI_2l);
1900   TEST_c_c (casinh, minus_zero, -1.0L, minus_zero, -M_PI_2l);
1901   TEST_c_c (casinh, plus_zero, -0.5L, plus_zero, -0.5235987755982988730771072305465838140329L);
1902   TEST_c_c (casinh, minus_zero, -0.5L, minus_zero, -0.5235987755982988730771072305465838140329L);
1903   TEST_c_c (casinh, plus_zero, 0.5L, plus_zero, 0.5235987755982988730771072305465838140329L);
1904   TEST_c_c (casinh, minus_zero, 0.5L, minus_zero, 0.5235987755982988730771072305465838140329L);
1905   TEST_c_c (casinh, plus_zero, 1.0L, plus_zero, M_PI_2l);
1906   TEST_c_c (casinh, minus_zero, 1.0L, minus_zero, M_PI_2l);
1907   TEST_c_c (casinh, plus_zero, 1.5L, 0.9624236501192068949955178268487368462704L, M_PI_2l);
1908   TEST_c_c (casinh, minus_zero, 1.5L, -0.9624236501192068949955178268487368462704L, M_PI_2l);
1909
1910   TEST_c_c (casinh, -1.5L, plus_zero, -1.194763217287109304111930828519090523536L, plus_zero);
1911   TEST_c_c (casinh, -1.5L, minus_zero, -1.194763217287109304111930828519090523536L, minus_zero);
1912   TEST_c_c (casinh, -1.0L, plus_zero, -0.8813735870195430252326093249797923090282L, plus_zero);
1913   TEST_c_c (casinh, -1.0L, minus_zero, -0.8813735870195430252326093249797923090282L, minus_zero);
1914   TEST_c_c (casinh, -0.5L, plus_zero, -0.4812118250596034474977589134243684231352L, plus_zero);
1915   TEST_c_c (casinh, -0.5L, minus_zero, -0.4812118250596034474977589134243684231352L, minus_zero);
1916   TEST_c_c (casinh, 0.5L, plus_zero, 0.4812118250596034474977589134243684231352L, plus_zero);
1917   TEST_c_c (casinh, 0.5L, minus_zero, 0.4812118250596034474977589134243684231352L, minus_zero);
1918   TEST_c_c (casinh, 1.0L, plus_zero, 0.8813735870195430252326093249797923090282L, plus_zero);
1919   TEST_c_c (casinh, 1.0L, minus_zero, 0.8813735870195430252326093249797923090282L, minus_zero);
1920   TEST_c_c (casinh, 1.5L, plus_zero, 1.194763217287109304111930828519090523536L, plus_zero);
1921   TEST_c_c (casinh, 1.5L, minus_zero, 1.194763217287109304111930828519090523536L, minus_zero);
1922
1923   TEST_c_c (casinh, 0x1p50L, 1.0L, 3.535050620855721078027883819436759661753e1L, 8.881784197001252323389053344720723756399e-16L);
1924   TEST_c_c (casinh, 0x1p50L, -1.0L, 3.535050620855721078027883819436759661753e1L, -8.881784197001252323389053344720723756399e-16L);
1925   TEST_c_c (casinh, -0x1p50L, 1.0L, -3.535050620855721078027883819436759661753e1L, 8.881784197001252323389053344720723756399e-16L);
1926   TEST_c_c (casinh, -0x1p50L, -1.0L, -3.535050620855721078027883819436759661753e1L, -8.881784197001252323389053344720723756399e-16L);
1927   TEST_c_c (casinh, 1.0L, 0x1p50L, 3.535050620855721078027883819436720218708e1L, 1.570796326794895731052901991514519103193L);
1928   TEST_c_c (casinh, -1.0L, 0x1p50L, -3.535050620855721078027883819436720218708e1L, 1.570796326794895731052901991514519103193L);
1929   TEST_c_c (casinh, 1.0L, -0x1p50L, 3.535050620855721078027883819436720218708e1L, -1.570796326794895731052901991514519103193L);
1930   TEST_c_c (casinh, -1.0L, -0x1p50L, -3.535050620855721078027883819436720218708e1L, -1.570796326794895731052901991514519103193L);
1931 #ifndef TEST_FLOAT
1932   TEST_c_c (casinh, 0x1p500L, 1.0L, 3.472667374605326000180332928505464606058e2L, 3.054936363499604682051979393213617699789e-151L);
1933   TEST_c_c (casinh, 0x1p500L, -1.0L, 3.472667374605326000180332928505464606058e2L, -3.054936363499604682051979393213617699789e-151L);
1934   TEST_c_c (casinh, -0x1p500L, 1.0L, -3.472667374605326000180332928505464606058e2L, 3.054936363499604682051979393213617699789e-151L);
1935   TEST_c_c (casinh, -0x1p500L, -1.0L, -3.472667374605326000180332928505464606058e2L, -3.054936363499604682051979393213617699789e-151L);
1936   TEST_c_c (casinh, 1.0L, 0x1p500L, 3.472667374605326000180332928505464606058e2L, 1.570796326794896619231321691639751442099L);
1937   TEST_c_c (casinh, -1.0L, 0x1p500L, -3.472667374605326000180332928505464606058e2L, 1.570796326794896619231321691639751442099L);
1938   TEST_c_c (casinh, 1.0L, -0x1p500L, 3.472667374605326000180332928505464606058e2L, -1.570796326794896619231321691639751442099L);
1939   TEST_c_c (casinh, -1.0L, -0x1p500L, -3.472667374605326000180332928505464606058e2L, -1.570796326794896619231321691639751442099L);
1940 #endif
1941 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
1942   TEST_c_c (casinh, 0x1p5000L, 1.0L, 3.466429049980286492395577839412341016946e3L, 7.079811261048172892385615158694057552948e-1506L);
1943   TEST_c_c (casinh, 0x1p5000L, -1.0L, 3.466429049980286492395577839412341016946e3L, -7.079811261048172892385615158694057552948e-1506L);
1944   TEST_c_c (casinh, -0x1p5000L, 1.0L, -3.466429049980286492395577839412341016946e3L, 7.079811261048172892385615158694057552948e-1506L);
1945   TEST_c_c (casinh, -0x1p5000L, -1.0L, -3.466429049980286492395577839412341016946e3L, -7.079811261048172892385615158694057552948e-1506L);
1946   TEST_c_c (casinh, 1.0L, 0x1p5000L, 3.466429049980286492395577839412341016946e3L, 1.570796326794896619231321691639751442099L);
1947   TEST_c_c (casinh, -1.0L, 0x1p5000L, -3.466429049980286492395577839412341016946e3L, 1.570796326794896619231321691639751442099L);
1948   TEST_c_c (casinh, 1.0L, -0x1p5000L, 3.466429049980286492395577839412341016946e3L, -1.570796326794896619231321691639751442099L);
1949   TEST_c_c (casinh, -1.0L, -0x1p5000L, -3.466429049980286492395577839412341016946e3L, -1.570796326794896619231321691639751442099L);
1950 #endif
1951
1952   TEST_c_c (casinh, 0x1.fp127L, 0x1.fp127L, 8.973081118419833726837456344608533993585e1L, 7.853981633974483096156608458198757210493e-1L);
1953 #ifndef TEST_FLOAT
1954   TEST_c_c (casinh, 0x1.fp1023L, 0x1.fp1023L, 7.107906849659093345062145442726115449315e2L, 7.853981633974483096156608458198757210493e-1L);
1955 #endif
1956 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
1957   TEST_c_c (casinh, 0x1.fp16383L, 0x1.fp16383L, 1.135753137836666928715489992987020363057e4L, 7.853981633974483096156608458198757210493e-1L);
1958 #endif
1959
1960   TEST_c_c (casinh, 0x1.fp-129L, 1.5L, 9.624236501192068949955178268487368462704e-1L, 1.570796326794896619231321691639751442096L);
1961   TEST_c_c (casinh, 0x1.fp-129L, -1.5L, 9.624236501192068949955178268487368462704e-1L, -1.570796326794896619231321691639751442096L);
1962   TEST_c_c (casinh, -0x1.fp-129L, 1.5L, -9.624236501192068949955178268487368462704e-1L, 1.570796326794896619231321691639751442096L);
1963   TEST_c_c (casinh, -0x1.fp-129L, -1.5L, -9.624236501192068949955178268487368462704e-1L, -1.570796326794896619231321691639751442096L);
1964   TEST_c_c (casinh, 1.5L, 0x1.fp-129L, 1.194763217287109304111930828519090523536L, 1.579176199917649005841160751101628985741e-39L, UNDERFLOW_EXCEPTION_FLOAT);
1965   TEST_c_c (casinh, -1.5L, 0x1.fp-129L, -1.194763217287109304111930828519090523536L, 1.579176199917649005841160751101628985741e-39L, UNDERFLOW_EXCEPTION_FLOAT);
1966   TEST_c_c (casinh, 1.5L, -0x1.fp-129L, 1.194763217287109304111930828519090523536L, -1.579176199917649005841160751101628985741e-39L, UNDERFLOW_EXCEPTION_FLOAT);
1967   TEST_c_c (casinh, -1.5L, -0x1.fp-129L, -1.194763217287109304111930828519090523536L, -1.579176199917649005841160751101628985741e-39L, UNDERFLOW_EXCEPTION_FLOAT);
1968 #ifndef TEST_FLOAT
1969   TEST_c_c (casinh, 0x1.fp-1025L, 1.5L, 9.624236501192068949955178268487368462704e-1L, 1.570796326794896619231321691639751442099L);
1970   TEST_c_c (casinh, 0x1.fp-1025L, -1.5L, 9.624236501192068949955178268487368462704e-1L, -1.570796326794896619231321691639751442099L);
1971   TEST_c_c (casinh, -0x1.fp-1025L, 1.5L, -9.624236501192068949955178268487368462704e-1L, 1.570796326794896619231321691639751442099L);
1972   TEST_c_c (casinh, -0x1.fp-1025L, -1.5L, -9.624236501192068949955178268487368462704e-1L, -1.570796326794896619231321691639751442099L);
1973   TEST_c_c (casinh, 1.5L, 0x1.fp-1025L, 1.194763217287109304111930828519090523536L, 2.989196569048182929051881765490354365918e-309L, UNDERFLOW_EXCEPTION_DOUBLE);
1974   TEST_c_c (casinh, -1.5L, 0x1.fp-1025L, -1.194763217287109304111930828519090523536L, 2.989196569048182929051881765490354365918e-309L, UNDERFLOW_EXCEPTION_DOUBLE);
1975   TEST_c_c (casinh, 1.5L, -0x1.fp-1025L, 1.194763217287109304111930828519090523536L, -2.989196569048182929051881765490354365918e-309L, UNDERFLOW_EXCEPTION_DOUBLE);
1976   TEST_c_c (casinh, -1.5L, -0x1.fp-1025L, -1.194763217287109304111930828519090523536L, -2.989196569048182929051881765490354365918e-309L, UNDERFLOW_EXCEPTION_DOUBLE);
1977 #endif
1978 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
1979   TEST_c_c (casinh, 0x1.fp-16385L, 1.5L, 9.624236501192068949955178268487368462704e-1L, 1.570796326794896619231321691639751442099L);
1980   TEST_c_c (casinh, 0x1.fp-16385L, -1.5L, 9.624236501192068949955178268487368462704e-1L, -1.570796326794896619231321691639751442099L);
1981   TEST_c_c (casinh, -0x1.fp-16385L, 1.5L, -9.624236501192068949955178268487368462704e-1L, 1.570796326794896619231321691639751442099L);
1982   TEST_c_c (casinh, -0x1.fp-16385L, -1.5L, -9.624236501192068949955178268487368462704e-1L, -1.570796326794896619231321691639751442099L);
1983   TEST_c_c (casinh, 1.5L, 0x1.fp-16385L, 1.194763217287109304111930828519090523536L, 4.516698239814521372306784062043266700598e-4933L, UNDERFLOW_EXCEPTION);
1984   TEST_c_c (casinh, -1.5L, 0x1.fp-16385L, -1.194763217287109304111930828519090523536L, 4.516698239814521372306784062043266700598e-4933L, UNDERFLOW_EXCEPTION);
1985   TEST_c_c (casinh, 1.5L, -0x1.fp-16385L, 1.194763217287109304111930828519090523536L, -4.516698239814521372306784062043266700598e-4933L, UNDERFLOW_EXCEPTION);
1986   TEST_c_c (casinh, -1.5L, -0x1.fp-16385L, -1.194763217287109304111930828519090523536L, -4.516698239814521372306784062043266700598e-4933L, UNDERFLOW_EXCEPTION);
1987 #endif
1988
1989   TEST_c_c (casinh, 0.75L, 1.25L, 1.03171853444778027336364058631006594L, 0.911738290968487636358489564316731207L);
1990   TEST_c_c (casinh, -2, -3, -1.9686379257930962917886650952454982L, -0.96465850440760279204541105949953237L);
1991
1992   END (casinh, complex);
1993 }
1994
1995
1996 static void
1997 catan_test (void)
1998 {
1999   errno = 0;
2000   FUNC(catan) (BUILD_COMPLEX (0.7L, 1.2L));
2001   if (errno == ENOSYS)
2002     /* Function not implemented.  */
2003     return;
2004
2005   START (catan);
2006
2007   TEST_c_c (catan, 0, 0, 0, 0);
2008   TEST_c_c (catan, minus_zero, 0, minus_zero, 0);
2009   TEST_c_c (catan, 0, minus_zero, 0, minus_zero);
2010   TEST_c_c (catan, minus_zero, minus_zero, minus_zero, minus_zero);
2011
2012   TEST_c_c (catan, plus_infty, plus_infty, M_PI_2l, 0);
2013   TEST_c_c (catan, plus_infty, minus_infty, M_PI_2l, minus_zero);
2014   TEST_c_c (catan, minus_infty, plus_infty, -M_PI_2l, 0);
2015   TEST_c_c (catan, minus_infty, minus_infty, -M_PI_2l, minus_zero);
2016
2017
2018   TEST_c_c (catan, plus_infty, -10.0, M_PI_2l, minus_zero);
2019   TEST_c_c (catan, minus_infty, -10.0, -M_PI_2l, minus_zero);
2020   TEST_c_c (catan, plus_infty, minus_zero, M_PI_2l, minus_zero);
2021   TEST_c_c (catan, minus_infty, minus_zero, -M_PI_2l, minus_zero);
2022   TEST_c_c (catan, plus_infty, 0.0, M_PI_2l, 0);
2023   TEST_c_c (catan, minus_infty, 0.0, -M_PI_2l, 0);
2024   TEST_c_c (catan, plus_infty, 0.1L, M_PI_2l, 0);
2025   TEST_c_c (catan, minus_infty, 0.1L, -M_PI_2l, 0);
2026
2027   TEST_c_c (catan, 0.0, minus_infty, M_PI_2l, minus_zero);
2028   TEST_c_c (catan, minus_zero, minus_infty, -M_PI_2l, minus_zero);
2029   TEST_c_c (catan, 100.0, minus_infty, M_PI_2l, minus_zero);
2030   TEST_c_c (catan, -100.0, minus_infty, -M_PI_2l, minus_zero);
2031
2032   TEST_c_c (catan, 0.0, plus_infty, M_PI_2l, 0);
2033   TEST_c_c (catan, minus_zero, plus_infty, -M_PI_2l, 0);
2034   TEST_c_c (catan, 0.5, plus_infty, M_PI_2l, 0);
2035   TEST_c_c (catan, -0.5, plus_infty, -M_PI_2l, 0);
2036
2037   TEST_c_c (catan, nan_value, 0.0, nan_value, 0);
2038   TEST_c_c (catan, nan_value, minus_zero, nan_value, minus_zero);
2039
2040   TEST_c_c (catan, nan_value, plus_infty, nan_value, 0);
2041   TEST_c_c (catan, nan_value, minus_infty, nan_value, minus_zero);
2042
2043   TEST_c_c (catan, 0.0, nan_value, nan_value, nan_value);
2044   TEST_c_c (catan, minus_zero, nan_value, nan_value, nan_value);
2045
2046   TEST_c_c (catan, plus_infty, nan_value, M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
2047   TEST_c_c (catan, minus_infty, nan_value, -M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
2048
2049   TEST_c_c (catan, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2050   TEST_c_c (catan, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2051
2052   TEST_c_c (catan, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2053   TEST_c_c (catan, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2054
2055   TEST_c_c (catan, nan_value, nan_value, nan_value, nan_value);
2056
2057   TEST_c_c (catan, 0.75L, 1.25L, 1.10714871779409050301706546017853704L, 0.549306144334054845697622618461262852L);
2058   TEST_c_c (catan, -2, -3, -1.4099210495965755225306193844604208L, -0.22907268296853876629588180294200276L);
2059
2060   END (catan, complex);
2061 }
2062
2063 static void
2064 catanh_test (void)
2065 {
2066   errno = 0;
2067   FUNC(catanh) (BUILD_COMPLEX (0.7L, 1.2L));
2068   if (errno == ENOSYS)
2069     /* Function not implemented.  */
2070     return;
2071
2072   START (catanh);
2073
2074   TEST_c_c (catanh, 0, 0, 0.0, 0.0);
2075   TEST_c_c (catanh, minus_zero, 0, minus_zero, 0.0);
2076   TEST_c_c (catanh, 0, minus_zero, 0.0, minus_zero);
2077   TEST_c_c (catanh, minus_zero, minus_zero, minus_zero, minus_zero);
2078
2079   TEST_c_c (catanh, plus_infty, plus_infty, 0.0, M_PI_2l);
2080   TEST_c_c (catanh, plus_infty, minus_infty, 0.0, -M_PI_2l);
2081   TEST_c_c (catanh, minus_infty, plus_infty, minus_zero, M_PI_2l);
2082   TEST_c_c (catanh, minus_infty, minus_infty, minus_zero, -M_PI_2l);
2083
2084   TEST_c_c (catanh, -10.0, plus_infty, minus_zero, M_PI_2l);
2085   TEST_c_c (catanh, -10.0, minus_infty, minus_zero, -M_PI_2l);
2086   TEST_c_c (catanh, minus_zero, plus_infty, minus_zero, M_PI_2l);
2087   TEST_c_c (catanh, minus_zero, minus_infty, minus_zero, -M_PI_2l);
2088   TEST_c_c (catanh, 0, plus_infty, 0.0, M_PI_2l);
2089   TEST_c_c (catanh, 0, minus_infty, 0.0, -M_PI_2l);
2090   TEST_c_c (catanh, 0.1L, plus_infty, 0.0, M_PI_2l);
2091   TEST_c_c (catanh, 0.1L, minus_infty, 0.0, -M_PI_2l);
2092
2093   TEST_c_c (catanh, minus_infty, 0, minus_zero, M_PI_2l);
2094   TEST_c_c (catanh, minus_infty, minus_zero, minus_zero, -M_PI_2l);
2095   TEST_c_c (catanh, minus_infty, 100, minus_zero, M_PI_2l);
2096   TEST_c_c (catanh, minus_infty, -100, minus_zero, -M_PI_2l);
2097
2098   TEST_c_c (catanh, plus_infty, 0, 0.0, M_PI_2l);
2099   TEST_c_c (catanh, plus_infty, minus_zero, 0.0, -M_PI_2l);
2100   TEST_c_c (catanh, plus_infty, 0.5, 0.0, M_PI_2l);
2101   TEST_c_c (catanh, plus_infty, -0.5, 0.0, -M_PI_2l);
2102
2103   TEST_c_c (catanh, 0, nan_value, 0.0, nan_value);
2104   TEST_c_c (catanh, minus_zero, nan_value, minus_zero, nan_value);
2105
2106   TEST_c_c (catanh, plus_infty, nan_value, 0.0, nan_value);
2107   TEST_c_c (catanh, minus_infty, nan_value, minus_zero, nan_value);
2108
2109   TEST_c_c (catanh, nan_value, 0, nan_value, nan_value);
2110   TEST_c_c (catanh, nan_value, minus_zero, nan_value, nan_value);
2111
2112   TEST_c_c (catanh, nan_value, plus_infty, 0.0, M_PI_2l, IGNORE_ZERO_INF_SIGN);
2113   TEST_c_c (catanh, nan_value, minus_infty, 0.0, -M_PI_2l, IGNORE_ZERO_INF_SIGN);
2114
2115   TEST_c_c (catanh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2116   TEST_c_c (catanh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2117
2118   TEST_c_c (catanh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
2119   TEST_c_c (catanh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
2120
2121   TEST_c_c (catanh, nan_value, nan_value, nan_value, nan_value);
2122
2123   TEST_c_c (catanh, 0.75L, 1.25L, 0.261492138795671927078652057366532140L, 0.996825126463918666098902241310446708L);
2124   TEST_c_c (catanh, -2, -3, -0.14694666622552975204743278515471595L, -1.3389725222944935611241935759091443L);
2125
2126   END (catanh, complex);
2127 }
2128
2129 static void
2130 cbrt_test (void)
2131 {
2132   errno = 0;
2133   FUNC(cbrt) (8);
2134   if (errno == ENOSYS)
2135     /* Function not implemented.  */
2136     return;
2137
2138   START (cbrt);
2139
2140   TEST_f_f (cbrt, 0.0, 0.0);
2141   TEST_f_f (cbrt, minus_zero, minus_zero);
2142
2143   TEST_f_f (cbrt, plus_infty, plus_infty);
2144   TEST_f_f (cbrt, minus_infty, minus_infty);
2145   TEST_f_f (cbrt, nan_value, nan_value);
2146
2147   TEST_f_f (cbrt, -0.001L, -0.1L);
2148   TEST_f_f (cbrt, 8, 2);
2149   TEST_f_f (cbrt, -27.0, -3.0);
2150   TEST_f_f (cbrt, 0.9921875L, 0.997389022060725270579075195353955217L);
2151   TEST_f_f (cbrt, 0.75L, 0.908560296416069829445605878163630251L);
2152
2153   END (cbrt);
2154 }
2155
2156
2157 static void
2158 ccos_test (void)
2159 {
2160   errno = 0;
2161   FUNC(ccos) (BUILD_COMPLEX (0, 0));
2162   if (errno == ENOSYS)
2163     /* Function not implemented.  */
2164     return;
2165
2166   START (ccos);
2167
2168   TEST_c_c (ccos, 0.0, 0.0, 1.0, minus_zero);
2169   TEST_c_c (ccos, minus_zero, 0.0, 1.0, 0.0);
2170   TEST_c_c (ccos, 0.0, minus_zero, 1.0, 0.0);
2171   TEST_c_c (ccos, minus_zero, minus_zero, 1.0, minus_zero);
2172
2173   TEST_c_c (ccos, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2174   TEST_c_c (ccos, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2175   TEST_c_c (ccos, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2176   TEST_c_c (ccos, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2177
2178   TEST_c_c (ccos, 0.0, plus_infty, plus_infty, minus_zero);
2179   TEST_c_c (ccos, 0.0, minus_infty, plus_infty, 0.0);
2180   TEST_c_c (ccos, minus_zero, plus_infty, plus_infty, 0.0);
2181   TEST_c_c (ccos, minus_zero, minus_infty, plus_infty, minus_zero);
2182
2183   TEST_c_c (ccos, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2184   TEST_c_c (ccos, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2185   TEST_c_c (ccos, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2186   TEST_c_c (ccos, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2187
2188   TEST_c_c (ccos, 4.625, plus_infty, minus_infty, plus_infty);
2189   TEST_c_c (ccos, 4.625, minus_infty, minus_infty, minus_infty);
2190   TEST_c_c (ccos, -4.625, plus_infty, minus_infty, minus_infty);
2191   TEST_c_c (ccos, -4.625, minus_infty, minus_infty, plus_infty);
2192
2193   TEST_c_c (ccos, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
2194   TEST_c_c (ccos, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
2195   TEST_c_c (ccos, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
2196   TEST_c_c (ccos, minus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
2197
2198   TEST_c_c (ccos, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2199   TEST_c_c (ccos, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2200
2201   TEST_c_c (ccos, nan_value, plus_infty, plus_infty, nan_value);
2202   TEST_c_c (ccos, nan_value, minus_infty, plus_infty, nan_value);
2203
2204   TEST_c_c (ccos, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2205   TEST_c_c (ccos, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2206
2207   TEST_c_c (ccos, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2208   TEST_c_c (ccos, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2209
2210   TEST_c_c (ccos, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2211   TEST_c_c (ccos, -10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2212
2213   TEST_c_c (ccos, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2214   TEST_c_c (ccos, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2215
2216   TEST_c_c (ccos, nan_value, nan_value, nan_value, nan_value);
2217
2218   TEST_c_c (ccos, 0.75L, 1.25L, 1.38173873063425888530729933139078645L, -1.09193013555397466170919531722024128L);
2219   TEST_c_c (ccos, -2, -3, -4.18962569096880723013255501961597373L, -9.10922789375533659797919726277886212L);
2220
2221   TEST_c_c (ccos, 0.75, 89.5, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
2222   TEST_c_c (ccos, 0.75, -89.5, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
2223   TEST_c_c (ccos, -0.75, 89.5, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
2224   TEST_c_c (ccos, -0.75, -89.5, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
2225
2226 #ifndef TEST_FLOAT
2227   TEST_c_c (ccos, 0.75, 710.5, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
2228   TEST_c_c (ccos, 0.75, -710.5, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
2229   TEST_c_c (ccos, -0.75, 710.5, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
2230   TEST_c_c (ccos, -0.75, -710.5, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
2231 #endif
2232
2233 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2234   TEST_c_c (ccos, 0.75, 11357.25, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
2235   TEST_c_c (ccos, 0.75, -11357.25, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
2236   TEST_c_c (ccos, -0.75, 11357.25, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
2237   TEST_c_c (ccos, -0.75, -11357.25, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
2238 #endif
2239
2240 #ifdef TEST_FLOAT
2241   TEST_c_c (ccos, 0x1p-149, 180, plus_infty, -1.043535896672617552965983803453927655332e33L, OVERFLOW_EXCEPTION);
2242 #endif
2243
2244 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2245   TEST_c_c (ccos, 0x1p-1074, 1440, plus_infty, -5.981479269486130556466515778180916082415e301L, OVERFLOW_EXCEPTION);
2246 #endif
2247
2248 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2249   TEST_c_c (ccos, 0x1p-16434L, 22730, plus_infty, -1.217853148905605987081057582351152052687e4924L, OVERFLOW_EXCEPTION);
2250 #endif
2251
2252   END (ccos, complex);
2253 }
2254
2255
2256 static void
2257 ccosh_test (void)
2258 {
2259   errno = 0;
2260   FUNC(ccosh) (BUILD_COMPLEX (0.7L, 1.2L));
2261   if (errno == ENOSYS)
2262     /* Function not implemented.  */
2263     return;
2264
2265   START (ccosh);
2266
2267   TEST_c_c (ccosh, 0.0, 0.0, 1.0, 0.0);
2268   TEST_c_c (ccosh, minus_zero, 0.0, 1.0, minus_zero);
2269   TEST_c_c (ccosh, 0.0, minus_zero, 1.0, minus_zero);
2270   TEST_c_c (ccosh, minus_zero, minus_zero, 1.0, 0.0);
2271
2272   TEST_c_c (ccosh, 0.0, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2273   TEST_c_c (ccosh, minus_zero, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2274   TEST_c_c (ccosh, 0.0, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2275   TEST_c_c (ccosh, minus_zero, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2276
2277   TEST_c_c (ccosh, plus_infty, 0.0, plus_infty, 0.0);
2278   TEST_c_c (ccosh, minus_infty, 0.0, plus_infty, minus_zero);
2279   TEST_c_c (ccosh, plus_infty, minus_zero, plus_infty, minus_zero);
2280   TEST_c_c (ccosh, minus_infty, minus_zero, plus_infty, 0.0);
2281
2282   TEST_c_c (ccosh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2283   TEST_c_c (ccosh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2284   TEST_c_c (ccosh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2285   TEST_c_c (ccosh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2286
2287   TEST_c_c (ccosh, plus_infty, 4.625, minus_infty, minus_infty);
2288   TEST_c_c (ccosh, minus_infty, 4.625, minus_infty, plus_infty);
2289   TEST_c_c (ccosh, plus_infty, -4.625, minus_infty, plus_infty);
2290   TEST_c_c (ccosh, minus_infty, -4.625, minus_infty, minus_infty);
2291
2292   TEST_c_c (ccosh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2293   TEST_c_c (ccosh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2294   TEST_c_c (ccosh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2295   TEST_c_c (ccosh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2296
2297   TEST_c_c (ccosh, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2298   TEST_c_c (ccosh, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2299
2300   TEST_c_c (ccosh, plus_infty, nan_value, plus_infty, nan_value);
2301   TEST_c_c (ccosh, minus_infty, nan_value, plus_infty, nan_value);
2302
2303   TEST_c_c (ccosh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2304   TEST_c_c (ccosh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2305
2306   TEST_c_c (ccosh, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2307   TEST_c_c (ccosh, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2308
2309   TEST_c_c (ccosh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2310   TEST_c_c (ccosh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2311
2312   TEST_c_c (ccosh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2313   TEST_c_c (ccosh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2314
2315   TEST_c_c (ccosh, nan_value, nan_value, nan_value, nan_value);
2316
2317   TEST_c_c (ccosh, 0.75L, 1.25L, 0.408242591877968807788852146397499084L, 0.780365930845853240391326216300863152L);
2318
2319   TEST_c_c (ccosh, -2, -3, -3.72454550491532256547397070325597253L, 0.511822569987384608834463849801875634L);
2320
2321   TEST_c_c (ccosh, 89.5, 0.75, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
2322   TEST_c_c (ccosh, -89.5, 0.75, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
2323   TEST_c_c (ccosh, 89.5, -0.75, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
2324   TEST_c_c (ccosh, -89.5, -0.75, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
2325
2326 #ifndef TEST_FLOAT
2327   TEST_c_c (ccosh, 710.5, 0.75, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
2328   TEST_c_c (ccosh, -710.5, 0.75, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
2329   TEST_c_c (ccosh, 710.5, -0.75, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
2330   TEST_c_c (ccosh, -710.5, -0.75, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
2331 #endif
2332
2333 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2334   TEST_c_c (ccosh, 11357.25, 0.75, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
2335   TEST_c_c (ccosh, -11357.25, 0.75, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
2336   TEST_c_c (ccosh, 11357.25, -0.75, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
2337   TEST_c_c (ccosh, -11357.25, -0.75, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
2338 #endif
2339
2340 #ifdef TEST_FLOAT
2341   TEST_c_c (ccosh, 180, 0x1p-149, plus_infty, 1.043535896672617552965983803453927655332e33L, OVERFLOW_EXCEPTION);
2342 #endif
2343
2344 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2345   TEST_c_c (ccosh, 1440, 0x1p-1074, plus_infty, 5.981479269486130556466515778180916082415e301L, OVERFLOW_EXCEPTION);
2346 #endif
2347
2348 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2349   TEST_c_c (ccosh, 22730, 0x1p-16434L, plus_infty, 1.217853148905605987081057582351152052687e4924L, OVERFLOW_EXCEPTION);
2350 #endif
2351
2352   END (ccosh, complex);
2353 }
2354
2355
2356 static void
2357 ceil_test (void)
2358 {
2359   START (ceil);
2360
2361   TEST_f_f (ceil, 0.0, 0.0);
2362   TEST_f_f (ceil, minus_zero, minus_zero);
2363   TEST_f_f (ceil, plus_infty, plus_infty);
2364   TEST_f_f (ceil, minus_infty, minus_infty);
2365   TEST_f_f (ceil, nan_value, nan_value);
2366
2367   TEST_f_f (ceil, M_PIl, 4.0);
2368   TEST_f_f (ceil, -M_PIl, -3.0);
2369   TEST_f_f (ceil, 0.1, 1.0);
2370   TEST_f_f (ceil, 0.25, 1.0);
2371   TEST_f_f (ceil, 0.625, 1.0);
2372   TEST_f_f (ceil, -0.1, minus_zero);
2373   TEST_f_f (ceil, -0.25, minus_zero);
2374   TEST_f_f (ceil, -0.625, minus_zero);
2375
2376 #ifdef TEST_LDOUBLE
2377   /* The result can only be represented in long double.  */
2378   TEST_f_f (ceil, 4503599627370495.5L, 4503599627370496.0L);
2379   TEST_f_f (ceil, 4503599627370496.25L, 4503599627370497.0L);
2380   TEST_f_f (ceil, 4503599627370496.5L, 4503599627370497.0L);
2381   TEST_f_f (ceil, 4503599627370496.75L, 4503599627370497.0L);
2382   TEST_f_f (ceil, 4503599627370497.5L, 4503599627370498.0L);
2383
2384   TEST_f_f (ceil, -4503599627370495.5L, -4503599627370495.0L);
2385   TEST_f_f (ceil, -4503599627370496.25L, -4503599627370496.0L);
2386   TEST_f_f (ceil, -4503599627370496.5L, -4503599627370496.0L);
2387   TEST_f_f (ceil, -4503599627370496.75L, -4503599627370496.0L);
2388   TEST_f_f (ceil, -4503599627370497.5L, -4503599627370497.0L);
2389
2390 # if LDBL_MANT_DIG > 100
2391   TEST_f_f (ceil, 4503599627370494.5000000000001L, 4503599627370495.0L);
2392   TEST_f_f (ceil, 4503599627370495.5000000000001L, 4503599627370496.0L);
2393   TEST_f_f (ceil, 4503599627370496.5000000000001L, 4503599627370497.0L);
2394   TEST_f_f (ceil, -4503599627370494.5000000000001L, -4503599627370494.0L);
2395   TEST_f_f (ceil, -4503599627370495.5000000000001L, -4503599627370495.0L);
2396   TEST_f_f (ceil, -4503599627370496.5000000000001L, -4503599627370496.0L);
2397 # endif
2398
2399   TEST_f_f (ceil, 9007199254740991.5L, 9007199254740992.0L);
2400   TEST_f_f (ceil, 9007199254740992.25L, 9007199254740993.0L);
2401   TEST_f_f (ceil, 9007199254740992.5L, 9007199254740993.0L);
2402   TEST_f_f (ceil, 9007199254740992.75L, 9007199254740993.0L);
2403   TEST_f_f (ceil, 9007199254740993.5L, 9007199254740994.0L);
2404
2405   TEST_f_f (ceil, -9007199254740991.5L, -9007199254740991.0L);
2406   TEST_f_f (ceil, -9007199254740992.25L, -9007199254740992.0L);
2407   TEST_f_f (ceil, -9007199254740992.5L, -9007199254740992.0L);
2408   TEST_f_f (ceil, -9007199254740992.75L, -9007199254740992.0L);
2409   TEST_f_f (ceil, -9007199254740993.5L, -9007199254740993.0L);
2410
2411 # if LDBL_MANT_DIG > 100
2412   TEST_f_f (ceil, 9007199254740991.0000000000001L, 9007199254740992.0L);
2413   TEST_f_f (ceil, 9007199254740992.0000000000001L, 9007199254740993.0L);
2414   TEST_f_f (ceil, 9007199254740993.0000000000001L, 9007199254740994.0L);
2415   TEST_f_f (ceil, 9007199254740991.5000000000001L, 9007199254740992.0L);
2416   TEST_f_f (ceil, 9007199254740992.5000000000001L, 9007199254740993.0L);
2417   TEST_f_f (ceil, 9007199254740993.5000000000001L, 9007199254740994.0L);
2418
2419   TEST_f_f (ceil, -9007199254740991.0000000000001L, -9007199254740991.0L);
2420   TEST_f_f (ceil, -9007199254740992.0000000000001L, -9007199254740992.0L);
2421   TEST_f_f (ceil, -9007199254740993.0000000000001L, -9007199254740993.0L);
2422   TEST_f_f (ceil, -9007199254740991.5000000000001L, -9007199254740991.0L);
2423   TEST_f_f (ceil, -9007199254740992.5000000000001L, -9007199254740992.0L);
2424   TEST_f_f (ceil, -9007199254740993.5000000000001L, -9007199254740993.0L);
2425 # endif
2426
2427   TEST_f_f (ceil, 72057594037927935.5L, 72057594037927936.0L);
2428   TEST_f_f (ceil, 72057594037927936.25L, 72057594037927937.0L);
2429   TEST_f_f (ceil, 72057594037927936.5L, 72057594037927937.0L);
2430   TEST_f_f (ceil, 72057594037927936.75L, 72057594037927937.0L);
2431   TEST_f_f (ceil, 72057594037927937.5L, 72057594037927938.0L);
2432
2433   TEST_f_f (ceil, -72057594037927935.5L, -72057594037927935.0L);
2434   TEST_f_f (ceil, -72057594037927936.25L, -72057594037927936.0L);
2435   TEST_f_f (ceil, -72057594037927936.5L, -72057594037927936.0L);
2436   TEST_f_f (ceil, -72057594037927936.75L, -72057594037927936.0L);
2437   TEST_f_f (ceil, -72057594037927937.5L, -72057594037927937.0L);
2438
2439   TEST_f_f (ceil, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
2440   TEST_f_f (ceil, 10141204801825835211973625643008.25L, 10141204801825835211973625643009.0L);
2441   TEST_f_f (ceil, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
2442   TEST_f_f (ceil, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
2443   TEST_f_f (ceil, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
2444 #endif
2445
2446   END (ceil);
2447 }
2448
2449
2450 static void
2451 cexp_test (void)
2452 {
2453   errno = 0;
2454   FUNC(cexp) (BUILD_COMPLEX (0, 0));
2455   if (errno == ENOSYS)
2456     /* Function not implemented.  */
2457     return;
2458
2459   START (cexp);
2460
2461   TEST_c_c (cexp, plus_zero, plus_zero, 1, 0.0);
2462   TEST_c_c (cexp, minus_zero, plus_zero, 1, 0.0);
2463   TEST_c_c (cexp, plus_zero, minus_zero, 1, minus_zero);
2464   TEST_c_c (cexp, minus_zero, minus_zero, 1, minus_zero);
2465
2466   TEST_c_c (cexp, plus_infty, plus_zero, plus_infty, 0.0);
2467   TEST_c_c (cexp, plus_infty, minus_zero, plus_infty, minus_zero);
2468
2469   TEST_c_c (cexp, minus_infty, plus_zero, 0.0, 0.0);
2470   TEST_c_c (cexp, minus_infty, minus_zero, 0.0, minus_zero);
2471
2472   TEST_c_c (cexp, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2473   TEST_c_c (cexp, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2474
2475   TEST_c_c (cexp, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2476   TEST_c_c (cexp, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2477
2478   TEST_c_c (cexp, 100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2479   TEST_c_c (cexp, -100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2480
2481   TEST_c_c (cexp, 100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2482   TEST_c_c (cexp, -100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2483
2484   TEST_c_c (cexp, minus_infty, 2.0, minus_zero, 0.0);
2485   TEST_c_c (cexp, minus_infty, 4.0, minus_zero, minus_zero);
2486   TEST_c_c (cexp, plus_infty, 2.0, minus_infty, plus_infty);
2487   TEST_c_c (cexp, plus_infty, 4.0, minus_infty, minus_infty);
2488
2489   TEST_c_c (cexp, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2490   TEST_c_c (cexp, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2491
2492   TEST_c_c (cexp, minus_infty, plus_infty, 0.0, 0.0, IGNORE_ZERO_INF_SIGN);
2493   TEST_c_c (cexp, minus_infty, minus_infty, 0.0, minus_zero, IGNORE_ZERO_INF_SIGN);
2494
2495   TEST_c_c (cexp, minus_infty, nan_value, 0, 0, IGNORE_ZERO_INF_SIGN);
2496
2497   TEST_c_c (cexp, plus_infty, nan_value, plus_infty, nan_value);
2498
2499   TEST_c_c (cexp, nan_value, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2500   TEST_c_c (cexp, nan_value, 1.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2501
2502   TEST_c_c (cexp, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2503   TEST_c_c (cexp, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2504   TEST_c_c (cexp, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2505   TEST_c_c (cexp, nan_value, nan_value, nan_value, nan_value);
2506
2507   TEST_c_c (cexp, 0.75L, 1.25L, 0.667537446429131586942201977015932112L, 2.00900045494094876258347228145863909L);
2508   TEST_c_c (cexp, -2.0, -3.0, -0.13398091492954261346140525546115575L, -0.019098516261135196432576240858800925L);
2509
2510   TEST_c_c (cexp, 0, 0x1p65, 0.99888622066058013610642172179340364209972L, -0.047183876212354673805106149805700013943218L);
2511   TEST_c_c (cexp, 0, -0x1p65, 0.99888622066058013610642172179340364209972L, 0.047183876212354673805106149805700013943218L);
2512   TEST_c_c (cexp, 50, 0x1p127, 4.053997150228616856622417636046265337193e21L, 3.232070315463388524466674772633810238819e21L);
2513
2514 #ifndef TEST_FLOAT
2515   TEST_c_c (cexp, 0, 1e22, 0.5232147853951389454975944733847094921409L, -0.8522008497671888017727058937530293682618L);
2516   TEST_c_c (cexp, 0, 0x1p1023, -0.826369834614147994500785680811743734805L, 0.5631277798508840134529434079444683477104L);
2517   TEST_c_c (cexp, 500, 0x1p1023, -1.159886268932754433233243794561351783426e217L, 7.904017694554466595359379965081774849708e216L);
2518 #endif
2519
2520 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2521   TEST_c_c (cexp, 0, 0x1p16383L, 0.9210843909921906206874509522505756251609L, 0.3893629985894208126948115852610595405563L);
2522   TEST_c_c (cexp, -10000, 0x1p16383L, 1.045876464564882298442774542991176546722e-4343L, 4.421154026488516836023811173959413420548e-4344L);
2523 #endif
2524
2525   TEST_c_c (cexp, 88.75, 0.75, 2.558360358486542817001900410314204322891e38L, 2.383359453227311447654736314679677655100e38L);
2526   TEST_c_c (cexp, -95, 0.75, 4.039714446238306526889476684000081624047e-42L, 3.763383677300535390271646960780570275931e-42L, UNDERFLOW_EXCEPTION_FLOAT);
2527
2528 #ifndef TEST_FLOAT
2529   TEST_c_c (cexp, 709.8125, 0.75, 1.355121963080879535248452862759108365762e308L, 1.262426823598609432507811340856186873507e308L);
2530   TEST_c_c (cexp, -720, 0.75, 1.486960657116368433685753325516638551722e-313L, 1.385247284245720590980701226843815229385e-313L, UNDERFLOW_EXCEPTION_DOUBLE);
2531 #endif
2532
2533 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2534   TEST_c_c (cexp, 11356.5625, 0.75, 9.052188470850960144814815984311663764287e4931L, 8.432986734191301036267148978260970230200e4931L);
2535   TEST_c_c (cexp, -11370, 0.75, 8.631121063182211587489310508568170739592e-4939L, 8.040721827809267291427062346918413482824e-4939L, UNDERFLOW_EXCEPTION);
2536 #endif
2537
2538 #ifdef TEST_FLOAT
2539   TEST_c_c (cexp, 180, 0x1p-149, plus_infty, 2.087071793345235105931967606907855310664e33L, OVERFLOW_EXCEPTION);
2540 #endif
2541
2542 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2543   TEST_c_c (cexp, 1440, 0x1p-1074, plus_infty, 1.196295853897226111293303155636183216483e302L, OVERFLOW_EXCEPTION);
2544 #endif
2545
2546 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2547   TEST_c_c (cexp, 22730, 0x1p-16434L, plus_infty, 2.435706297811211974162115164702304105374e4924L, OVERFLOW_EXCEPTION);
2548 #endif
2549
2550   TEST_c_c (cexp, 1e6, 0, plus_infty, 0, OVERFLOW_EXCEPTION);
2551   TEST_c_c (cexp, 1e6, min_value, plus_infty, plus_infty, OVERFLOW_EXCEPTION);
2552   TEST_c_c (cexp, 1e6, -min_value, plus_infty, minus_infty, OVERFLOW_EXCEPTION);
2553
2554   END (cexp, complex);
2555 }
2556
2557
2558 static void
2559 cimag_test (void)
2560 {
2561   START (cimag);
2562   TEST_c_f (cimag, 1.0, 0.0, 0.0);
2563   TEST_c_f (cimag, 1.0, minus_zero, minus_zero);
2564   TEST_c_f (cimag, 1.0, nan_value, nan_value);
2565   TEST_c_f (cimag, nan_value, nan_value, nan_value);
2566   TEST_c_f (cimag, 1.0, plus_infty, plus_infty);
2567   TEST_c_f (cimag, 1.0, minus_infty, minus_infty);
2568   TEST_c_f (cimag, 2.0, 3.0, 3.0);
2569
2570   END (cimag);
2571 }
2572
2573 static void
2574 clog_test (void)
2575 {
2576   errno = 0;
2577   FUNC(clog) (BUILD_COMPLEX (-2, -3));
2578   if (errno == ENOSYS)
2579     /* Function not implemented.  */
2580     return;
2581
2582   START (clog);
2583
2584   TEST_c_c (clog, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2585   TEST_c_c (clog, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2586
2587   TEST_c_c (clog, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
2588   TEST_c_c (clog, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
2589
2590   TEST_c_c (clog, minus_infty, plus_infty, plus_infty, M_PI_34l);
2591   TEST_c_c (clog, minus_infty, minus_infty, plus_infty, -M_PI_34l);
2592
2593   TEST_c_c (clog, plus_infty, plus_infty, plus_infty, M_PI_4l);
2594   TEST_c_c (clog, plus_infty, minus_infty, plus_infty, -M_PI_4l);
2595
2596   TEST_c_c (clog, 0, plus_infty, plus_infty, M_PI_2l);
2597   TEST_c_c (clog, 3, plus_infty, plus_infty, M_PI_2l);
2598   TEST_c_c (clog, minus_zero, plus_infty, plus_infty, M_PI_2l);
2599   TEST_c_c (clog, -3, plus_infty, plus_infty, M_PI_2l);
2600   TEST_c_c (clog, 0, minus_infty, plus_infty, -M_PI_2l);
2601   TEST_c_c (clog, 3, minus_infty, plus_infty, -M_PI_2l);
2602   TEST_c_c (clog, minus_zero, minus_infty, plus_infty, -M_PI_2l);
2603   TEST_c_c (clog, -3, minus_infty, plus_infty, -M_PI_2l);
2604
2605   TEST_c_c (clog, minus_infty, 0, plus_infty, M_PIl);
2606   TEST_c_c (clog, minus_infty, 1, plus_infty, M_PIl);
2607   TEST_c_c (clog, minus_infty, minus_zero, plus_infty, -M_PIl);
2608   TEST_c_c (clog, minus_infty, -1, plus_infty, -M_PIl);
2609
2610   TEST_c_c (clog, plus_infty, 0, plus_infty, 0.0);
2611   TEST_c_c (clog, plus_infty, 1, plus_infty, 0.0);
2612   TEST_c_c (clog, plus_infty, minus_zero, plus_infty, minus_zero);
2613   TEST_c_c (clog, plus_infty, -1, plus_infty, minus_zero);
2614
2615   TEST_c_c (clog, plus_infty, nan_value, plus_infty, nan_value);
2616   TEST_c_c (clog, minus_infty, nan_value, plus_infty, nan_value);
2617
2618   TEST_c_c (clog, nan_value, plus_infty, plus_infty, nan_value);
2619   TEST_c_c (clog, nan_value, minus_infty, plus_infty, nan_value);
2620
2621   TEST_c_c (clog, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2622   TEST_c_c (clog, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2623   TEST_c_c (clog, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2624   TEST_c_c (clog, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2625
2626   TEST_c_c (clog, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2627   TEST_c_c (clog, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2628   TEST_c_c (clog, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2629   TEST_c_c (clog, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2630
2631   TEST_c_c (clog, nan_value, nan_value, nan_value, nan_value);
2632
2633   TEST_c_c (clog, 0.75L, 1.25L, 0.376885901188190075998919126749298416L, 1.03037682652431246378774332703115153L);
2634   TEST_c_c (clog, -2, -3, 1.2824746787307683680267437207826593L, -2.1587989303424641704769327722648368L);
2635
2636   TEST_c_c (clog, 0x1.fffffep+127L, 0x1.fffffep+127L, 89.06941264234832570836679262104313101776L, M_PI_4l);
2637   TEST_c_c (clog, 0x1.fffffep+127L, 1.0L, 88.72283905206835305365817656031404273372L, 2.938736052218037251011746307725933020145e-39L, UNDERFLOW_EXCEPTION_FLOAT);
2638   TEST_c_c (clog, 0x1p-149L, 0x1p-149L, -102.9323563131518784484589700365392203592L, M_PI_4l);
2639   TEST_c_c (clog, 0x1p-147L, 0x1p-147L, -101.5460619520319878296245057936228672231L, M_PI_4l);
2640
2641 #ifndef TEST_FLOAT
2642   TEST_c_c (clog, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 710.1292864836639693869320059713862337880L, M_PI_4l);
2643   TEST_c_c (clog, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 709.8942846690411016323109979483151967689L, 0.4636476090008061606231772164674799632783L);
2644   TEST_c_c (clog, 0x1p-1074L, 0x1p-1074L, -744.0934983311012896593986823853525458290L, M_PI_4l);
2645   TEST_c_c (clog, 0x1p-1073L, 0x1p-1073L, -743.4003511505413443499814502638943692610L, M_PI_4l);
2646 #endif
2647
2648 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2649   TEST_c_c (clog, 0x1.fp+16383L, 0x1.fp+16383L, 11356.83823118610934184548269774874545400L, M_PI_4l);
2650   TEST_c_c (clog, 0x1.fp+16383L, 0x1p+16383L, 11356.60974243783798653123798337822335902L, 0.4764674194737066993385333770295162295856L);
2651   TEST_c_c (clog, 0x1p-16440L, 0x1p-16441L, -11395.22807662984378194141292922726786191L, 0.4636476090008061162142562314612144020285L);
2652 #endif
2653
2654   TEST_c_c (clog, 0x1p-149L, 0x1.fp+127L, 88.69109041335841930424871526389807508374L, M_PI_2l);
2655   TEST_c_c (clog, -0x1p-149L, 0x1.fp+127L, 88.69109041335841930424871526389807508374L, M_PI_2l);
2656   TEST_c_c (clog, 0x1p-149L, -0x1.fp+127L, 88.69109041335841930424871526389807508374L, -M_PI_2l);
2657   TEST_c_c (clog, -0x1p-149L, -0x1.fp+127L, 88.69109041335841930424871526389807508374L, -M_PI_2l);
2658   TEST_c_c (clog, -0x1.fp+127L, 0x1p-149L, 88.69109041335841930424871526389807508374L, M_PIl);
2659   TEST_c_c (clog, -0x1.fp+127L, -0x1p-149L, 88.69109041335841930424871526389807508374L, -M_PIl);
2660 #ifdef TEST_FLOAT
2661   TEST_c_c (clog, 0x1.fp+127L, 0x1p-149L, 88.69109041335841930424871526389807508374L, plus_zero, UNDERFLOW_EXCEPTION);
2662   TEST_c_c (clog, 0x1.fp+127L, -0x1p-149L, 88.69109041335841930424871526389807508374L, minus_zero, UNDERFLOW_EXCEPTION);
2663 #endif
2664
2665 #ifndef TEST_FLOAT
2666   TEST_c_c (clog, 0x1p-1074L, 0x1.fp+1023L, 709.7509641950694165420886960904242800794L, M_PI_2l);
2667   TEST_c_c (clog, -0x1p-1074L, 0x1.fp+1023L, 709.7509641950694165420886960904242800794L, M_PI_2l);
2668   TEST_c_c (clog, 0x1p-1074L, -0x1.fp+1023L, 709.7509641950694165420886960904242800794L, -M_PI_2l);
2669   TEST_c_c (clog, -0x1p-1074L, -0x1.fp+1023L, 709.7509641950694165420886960904242800794L, -M_PI_2l);
2670   TEST_c_c (clog, -0x1.fp+1023L, 0x1p-1074L, 709.7509641950694165420886960904242800794L, M_PIl);
2671   TEST_c_c (clog, -0x1.fp+1023L, -0x1p-1074L, 709.7509641950694165420886960904242800794L, -M_PIl);
2672 #endif
2673 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2674   TEST_c_c (clog, 0x1.fp+1023L, 0x1p-1074L, 709.7509641950694165420886960904242800794L, plus_zero, UNDERFLOW_EXCEPTION);
2675   TEST_c_c (clog, 0x1.fp+1023L, -0x1p-1074L, 709.7509641950694165420886960904242800794L, minus_zero, UNDERFLOW_EXCEPTION);
2676 #endif
2677
2678 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2679   TEST_c_c (clog, 0x1p-16445L, 0x1.fp+16383L, 11356.49165759582936919077408168801636572L, M_PI_2l);
2680   TEST_c_c (clog, -0x1p-16445L, 0x1.fp+16383L, 11356.49165759582936919077408168801636572L, M_PI_2l);
2681   TEST_c_c (clog, 0x1p-16445L, -0x1.fp+16383L, 11356.49165759582936919077408168801636572L, -M_PI_2l);
2682   TEST_c_c (clog, -0x1p-16445L, -0x1.fp+16383L, 11356.49165759582936919077408168801636572L, -M_PI_2l);
2683   TEST_c_c (clog, -0x1.fp+16383L, 0x1p-16445L, 11356.49165759582936919077408168801636572L, M_PIl);
2684   TEST_c_c (clog, -0x1.fp+16383L, -0x1p-16445L, 11356.49165759582936919077408168801636572L, -M_PIl);
2685   TEST_c_c (clog, 0x1.fp+16383L, 0x1p-16445L, 11356.49165759582936919077408168801636572L, plus_zero, UNDERFLOW_EXCEPTION);
2686   TEST_c_c (clog, 0x1.fp+16383L, -0x1p-16445L, 11356.49165759582936919077408168801636572L, minus_zero, UNDERFLOW_EXCEPTION);
2687 # if LDBL_MANT_DIG >= 113
2688   TEST_c_c (clog, 0x1p-16494L, 0x1.fp+16383L, 11356.49165759582936919077408168801636572L, M_PI_2l);
2689   TEST_c_c (clog, -0x1p-16494L, 0x1.fp+16383L, 11356.49165759582936919077408168801636572L, M_PI_2l);
2690   TEST_c_c (clog, 0x1p-16494L, -0x1.fp+16383L, 11356.49165759582936919077408168801636572L, -M_PI_2l);
2691   TEST_c_c (clog, -0x1p-16494L, -0x1.fp+16383L, 11356.49165759582936919077408168801636572L, -M_PI_2l);
2692   TEST_c_c (clog, -0x1.fp+16383L, 0x1p-16494L, 11356.49165759582936919077408168801636572L, M_PIl);
2693   TEST_c_c (clog, -0x1.fp+16383L, -0x1p-16494L, 11356.49165759582936919077408168801636572L, -M_PIl);
2694   TEST_c_c (clog, 0x1.fp+16383L, 0x1p-16494L, 11356.49165759582936919077408168801636572L, plus_zero, UNDERFLOW_EXCEPTION);
2695   TEST_c_c (clog, 0x1.fp+16383L, -0x1p-16494L, 11356.49165759582936919077408168801636572L, minus_zero, UNDERFLOW_EXCEPTION);
2696 # endif
2697 #endif
2698
2699   TEST_c_c (clog, 1.0L, 0x1.234566p-10L, 6.172834701221959432440126967147726538097e-7L, 1.111110564353742042376451655136933182201e-3L);
2700   TEST_c_c (clog, -1.0L, 0x1.234566p-20L, 5.886877547844618300918562490463748605537e-13L, 3.141591568520436206990380699322226378452L);
2701   TEST_c_c (clog, 0x1.234566p-30L, 1.0L, 5.614163921211322622623353961365728040115e-19L, 1.570796325735258575254858696548386439740L);
2702   TEST_c_c (clog, -0x1.234566p-40L, -1.0L, 5.354083939753840089583620652120903838944e-25L, -1.570796326795931422008642456283782656359L);
2703   TEST_c_c (clog, 0x1.234566p-50L, 1.0L, 5.106052341226425256332038420428899201070e-31L, 1.570796326794895608681734464330528755366L);
2704   TEST_c_c (clog, 0x1.234566p-60L, 1.0L, 4.869510976053643471080816669875627875933e-37L, 1.570796326794896618244456860363082279319L);
2705   TEST_c_c (clog, 0x1p-62L, 1.0L, 2.350988701644575015937473074444491355582e-38L, 1.570796326794896619014481257142650555297L);
2706   TEST_c_c (clog, 0x1p-63L, 1.0L, 5.877471754111437539843682686111228389059e-39L, 1.570796326794896619122901474391200998698L, UNDERFLOW_EXCEPTION_FLOAT);
2707   TEST_c_c (clog, 0x1p-64L, 1.0L, 1.469367938527859384960920671527807097271e-39L, 1.570796326794896619177111583015476220398L, UNDERFLOW_EXCEPTION_FLOAT);
2708 #ifndef TEST_FLOAT
2709   TEST_c_c (clog, 0x1p-510L, 1.0L, 4.450147717014402766180465434664808128438e-308L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
2710   TEST_c_c (clog, 0x1p-511L, 1.0L, 1.112536929253600691545116358666202032110e-308L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION_DOUBLE);
2711   TEST_c_c (clog, 0x1p-512L, 1.0L, 2.781342323134001728862790896665505080274e-309L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION_DOUBLE);
2712 #endif
2713 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2714   TEST_c_c (clog, 0x1p-8190L, 1.0L, 6.724206286224187012525355634643505205196e-4932L, 1.570796326794896619231321691639751442099L);
2715   TEST_c_c (clog, 0x1p-8191L, 1.0L, 1.681051571556046753131338908660876301299e-4932L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION);
2716   TEST_c_c (clog, 0x1p-8192L, 1.0L, 4.202628928890116882828347271652190753248e-4933L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION);
2717 #endif
2718
2719   TEST_c_c (clog, 0x1.000566p0L, 0x1.234p-10L, 8.298731898331237038231468223024422855654e-5L, 1.110938609507128729312743251313024793990e-3L);
2720   TEST_c_c (clog, 0x1.000566p0L, 0x1.234p-100L, 8.237022655933121125560939513260027133767e-5L, 8.974094312218060110948251664314290484113e-31L);
2721 #ifndef TEST_FLOAT
2722   TEST_c_c (clog, -0x1.0000000123456p0L, 0x1.2345678p-30L, 2.649094282537168795982991778475646793277e-10L, 3.141592652530155111500161671113150737892L);
2723   TEST_c_c (clog, -0x1.0000000123456p0L, 0x1.2345678p-1000L, 2.649094276923003995420209214900915462737e-10L, 3.141592653589793238462643383279502884197L);
2724 #endif
2725 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
2726   TEST_c_c (clog, 0x1.00000000000000123456789abcp0L, 0x1.23456789p-60L, 9.868649107778739757272772275265050767867e-19L, 9.868649106423871142816660980898339912137e-19L);
2727   TEST_c_c (clog, 0x1.00000000000000123456789abcp0L, 0x1.23456789p-1000L, 9.868649107778739752403260515979017248596e-19L, 1.061846605795612822522063052130030717368e-301L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
2728 #endif
2729
2730   TEST_c_c (clog, 0x0.ffffffp0L, 0x0.ffffffp-100L, -5.960464655174753498633255797994360530379e-8L, 7.888609052210118054117285652827862296732e-31L);
2731 #ifndef TEST_FLOAT
2732   TEST_c_c (clog, 0x0.fffffffffffff8p0L, 0x0.fffffffffffff8p-1000L, -1.110223024625156602053389888482372171810e-16L, 9.332636185032188789900895447238171696171e-302L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
2733 #endif
2734 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
2735   TEST_c_c (clog, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp-15000L, -5.421010862427522170184200798202494495630e-20L, 3.548665303440282824232502561095699343814e-4516L);
2736 #endif
2737
2738   TEST_c_c (clog, 0x1a6p-10L, 0x3a5p-10L, -1.4305135209763571252847059962654228661815e-06L, 1.1460277178115757370775644871674016684074L);
2739   TEST_c_c (clog, 0xf2p-10L, 0x3e3p-10L, 6.1988446308070710970664736815277450078106e-06L, 1.3322126499153926210226335249558203898460L);
2740   TEST_c_c (clog, 0x4d4ep-15L, 0x6605p-15L, -1.6298145321400412054744424587143483169412e-08L, 0.9223574537155056772124552172295398141249L);
2741   TEST_c_c (clog, 0x2818p-15L, 0x798fp-15L, 1.5366822245016167178749091974664853785194e-08L, 1.2522014929038946066987318471922169174157L);
2742   TEST_c_c (clog, 0x9b57bp-20L, 0xcb7b4p-20L, -3.9563019528687610863490232935890272740908e-11L, 0.9187593477446338910857133065497364950682L);
2743   TEST_c_c (clog, 0x2731p-20L, 0xfffd0p-20L, 4.4110493034041283943115971658295280288115e-11L, 1.5612279663766352262688735061954290528838L);
2744   TEST_c_c (clog, 0x2ede88p-23L, 0x771c3fp-23L, -4.4764192352906350039050902870893173560494e-13L, 1.1959106857549200806818600493552847793381L);
2745   TEST_c_c (clog, 0x11682p-23L, 0x7ffed1p-23L, 1.1723955140027907954461000991619077811832e-12L, 1.5622968405332756349813737986164832897108L);
2746   TEST_c_c (clog, 0xa1f2c1p-24L, 0xc643aep-24L, -1.0480505352462576151523512837107080269981e-13L, 0.8858771987699967480545613322309315260313L);
2747   TEST_c_c (clog, 0x659feap-24L, 0xeaf6f9p-24L, 3.7303493627403868207597214252239749960738e-14L, 1.1625816408046866464773042283673653469061L);
2748 #ifndef TEST_FLOAT
2749   TEST_c_c (clog, 0x4447d7175p-35L, 0x6c445e00ap-35L, -1.4823076576950255933915367361099865652625e-20L, 1.0081311552703893116404606212158840190615L);
2750   TEST_c_c (clog, 0x2dd46725bp-35L, 0x7783a1284p-35L, 4.4469229730850767799109418892826021157328e-20L, 1.2046235979300843056806465045930070146351L);
2751   TEST_c_c (clog, 0x164c74eea876p-45L, 0x16f393482f77p-45L, -3.0292258760486853327810377824479932031744e-26L, 0.7998237934177411746093524982030330293980L);
2752   TEST_c_c (clog, 0xfe961079616p-45L, 0x1bc37e09e6d1p-45L, 5.3718272201930019901317065495843842735179e-26L, 1.0503831592447830576186444373011142397404L);
2753   TEST_c_c (clog, 0xa4722f19346cp-51L, 0x7f9631c5e7f07p-51L, -6.2122796286154679676173624516405339768606e-30L, 1.4904138780720095276446375492434049214172L);
2754   TEST_c_c (clog, 0x10673dd0f2481p-51L, 0x7ef1d17cefbd2p-51L, 3.2047474274603604594851472963586149973093e-29L, 1.4422922682185099608731642353544207976604L);
2755   TEST_c_c (clog, 0x8ecbf810c4ae6p-52L, 0xd479468b09a37p-52L, -9.7375017988218644730510244778042114638107e-30L, 0.9790637929494922564724108399524154766631L);
2756   TEST_c_c (clog, 0x5b06b680ea2ccp-52L, 0xef452b965da9fp-52L, 8.3076914081087805757422664530653247447136e-30L, 1.2072712126771536614482822173033535043206L);
2757   TEST_c_c (clog, 0x659b70ab7971bp-53L, 0x1f5d111e08abecp-53L, -2.5083311595699359750201056724289010648701e-30L, 1.3710185432462268491534742969536240564640L);
2758   TEST_c_c (clog, 0x15cfbd1990d1ffp-53L, 0x176a3973e09a9ap-53L, 1.0168910106364605304135563536838075568606e-30L, 0.8208373755522359859870890246475340086663L);
2759   TEST_c_c (clog, 0x1367a310575591p-54L, 0x3cfcc0a0541f60p-54L, 5.0844550531823026520677817684239496041087e-32L, 1.2627468605458094918919206628466016525397L);
2760   TEST_c_c (clog, 0x55cb6d0c83af5p-55L, 0x7fe33c0c7c4e90p-55L, -5.2000108498455368032511404449795741611813e-32L, 1.5288921536982513453421343495466824420259L);
2761 #endif
2762 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
2763   TEST_c_c (clog, 0x298c62cb546588a7p-63L, 0x7911b1dfcc4ecdaep-63L, -1.1931267660846218205882675852805793644095e-36L, 1.2402109774337032400594953899784058127412L);
2764   TEST_c_c (clog, 0x4d9c37e2b5cb4533p-63L, 0x65c98be2385a042ep-63L, 6.4064442119814669184296141278612389400075e-37L, 0.9193591364645830864185131402313014890145L);
2765   TEST_c_c (clog, 0x602fd5037c4792efp-64L, 0xed3e2086dcca80b8p-64L, -2.3362950222592964220878638677292132852104e-37L, 1.1856121127236268105413184264288408265852L);
2766   TEST_c_c (clog, 0x6b10b4f3520217b6p-64L, 0xe8893cbb449253a1p-64L, 2.4244570985709679851855191080208817099132e-37L, 1.1393074519572050614551047548718495655972L);
2767   TEST_c_c (clog, 0x81b7efa81fc35ad1p-65L, 0x1ef4b835f1c79d812p-65L, -9.9182335850630508484862145328126979066934e-39L, 1.3146479888794807046338799047003947008804L);
2768 #endif
2769 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
2770   TEST_c_c (clog, 0x3f96469050f650869c2p-75L, 0x6f16b2c9c8b05988335p-75L, -1.0509738482436128031927971874674370984602e-45L, 1.0509191467640012308402149909370784281448L);
2771   TEST_c_c (clog, 0x3157fc1d73233e580c8p-75L, 0x761b52ccd435d7c7f5fp-75L, 1.3487497719126364307640897239165442763573e-43L, 1.1750493008528425228929764149024375035382L);
2772   TEST_c_c (clog, 0x155f8afc4c48685bf63610p-85L, 0x17d0cf2652cdbeb1294e19p-85L, -4.7775669192897997174762089350332738583822e-50L, 0.8393953487996880419413728440067635213372L);
2773   TEST_c_c (clog, 0x13836d58a13448d750b4b9p-85L, 0x195ca7bc3ab4f9161edbe6p-85L, 2.8398125044729578740243199963484494962411e-50L, 0.9149964976334130461795060758257083099706L);
2774   TEST_c_c (clog, 0x1df515eb171a808b9e400266p-95L, 0x7c71eb0cd4688dfe98581c77p-95L, -3.5048022044913950094635368750889659723004e-57L, 1.3345633256521815205858155673950177421079L);
2775   TEST_c_c (clog, 0xe33f66c9542ca25cc43c867p-95L, 0x7f35a68ebd3704a43c465864p-95L, 4.1101771307217268747345114262406964584250e-56L, 1.4596065864518742494094402406719567059585L);
2776   TEST_c_c (clog, 0x6771f22c64ed551b857c128b4cp-105L, 0x1f570e7a13cc3cf2f44fd793ea1p-105L, -1.4281333889622737316199756373421183559948e-62L, 1.3673546561165378090903506783353927980633L);
2777   TEST_c_c (clog, 0x15d8ab6ed05ca514086ac3a1e84p-105L, 0x1761e480aa094c0b10b34b09ce9p-105L, 1.0027319539522347477331743836657426754857e-62L, 0.8193464073721167323313606647411269414759L);
2778   TEST_c_c (clog, 0x187190c1a334497bdbde5a95f48p-106L, 0x3b25f08062d0a095c4cfbbc338dp-106L, -1.7471844652198029695350765775994001163767e-63L, 1.1789110097072986038243729592318526094314L);
2779   TEST_c_c (clog, 0x6241ef0da53f539f02fad67dabp-106L, 0x3fb46641182f7efd9caa769dac0p-106L, 4.3299788920664682288477984749202524623248e-63L, 1.4746938237585656250866370987773473745867L);
2780 #endif
2781 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 113
2782   TEST_c_c (clog, 0x3e1d0a105ac4ebeacd9c6952d34cp-112L, 0xf859b3d1b06d005dcbb5516d5479p-112L, -1.1683999374665377365054966073875064467108e-66L, 1.3257197596350832748781065387304444940172L);
2783   TEST_c_c (clog, 0x47017a2e36807acb1e5214b209dep-112L, 0xf5f4a550c9d75e3bb1839d865f0dp-112L, 1.5077923002544367932999503838191154621839e-65L, 1.2897445708311412721399861948957141824914L);
2784   TEST_c_c (clog, 0x148f818cb7a9258fca942ade2a0cap-113L, 0x18854a34780b8333ec53310ad7001p-113L, -7.1865869169568789348552370692485515571497e-67L, 0.8730167479365994646287897223471819363668L);
2785   TEST_c_c (clog, 0xfd95243681c055c2632286921092p-113L, 0x1bccabcd29ca2152860ec29e34ef7p-113L, 6.6255694866654064502633121109394710807528e-66L, 1.0526409614996288387567810726095850312049L);
2786   TEST_c_c (clog, 0xdb85c467ee2aadd5f425fe0f4b8dp-114L, 0x3e83162a0f95f1dcbf97dddf410eap-114L, 4.6017338806965821566734340588575402712716e-67L, 1.3547418904611758959096647942223384691728L);
2787   TEST_c_c (clog, 0x1415bcaf2105940d49a636e98ae59p-115L, 0x7e6a150adfcd1b0921d44b31f40f4p-115L, 2.5993421227864195179698176012564317527271e-67L, 1.4132318089683022770487383611430906982461L);
2788 #endif
2789
2790   END (clog, complex);
2791 }
2792
2793
2794 static void
2795 clog10_test (void)
2796 {
2797   errno = 0;
2798   FUNC(clog10) (BUILD_COMPLEX (0.7L, 1.2L));
2799   if (errno == ENOSYS)
2800     /* Function not implemented.  */
2801     return;
2802
2803   START (clog10);
2804
2805   TEST_c_c (clog10, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2806   TEST_c_c (clog10, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2807
2808   TEST_c_c (clog10, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
2809   TEST_c_c (clog10, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
2810
2811   TEST_c_c (clog10, minus_infty, plus_infty, plus_infty, M_PI_34_LOG10El);
2812
2813   TEST_c_c (clog10, plus_infty, plus_infty, plus_infty, M_PI4_LOG10El);
2814   TEST_c_c (clog10, plus_infty, minus_infty, plus_infty, -M_PI4_LOG10El);
2815
2816   TEST_c_c (clog10, 0, plus_infty, plus_infty, M_PI2_LOG10El);
2817   TEST_c_c (clog10, 3, plus_infty, plus_infty, M_PI2_LOG10El);
2818   TEST_c_c (clog10, minus_zero, plus_infty, plus_infty, M_PI2_LOG10El);
2819   TEST_c_c (clog10, -3, plus_infty, plus_infty, M_PI2_LOG10El);
2820   TEST_c_c (clog10, 0, minus_infty, plus_infty, -M_PI2_LOG10El);
2821   TEST_c_c (clog10, 3, minus_infty, plus_infty, -M_PI2_LOG10El);
2822   TEST_c_c (clog10, minus_zero, minus_infty, plus_infty, -M_PI2_LOG10El);
2823   TEST_c_c (clog10, -3, minus_infty, plus_infty, -M_PI2_LOG10El);
2824
2825   TEST_c_c (clog10, minus_infty, 0, plus_infty, M_PI_LOG10El);
2826   TEST_c_c (clog10, minus_infty, 1, plus_infty, M_PI_LOG10El);
2827   TEST_c_c (clog10, minus_infty, minus_zero, plus_infty, -M_PI_LOG10El);
2828   TEST_c_c (clog10, minus_infty, -1, plus_infty, -M_PI_LOG10El);
2829
2830   TEST_c_c (clog10, plus_infty, 0, plus_infty, 0.0);
2831   TEST_c_c (clog10, plus_infty, 1, plus_infty, 0.0);
2832   TEST_c_c (clog10, plus_infty, minus_zero, plus_infty, minus_zero);
2833   TEST_c_c (clog10, plus_infty, -1, plus_infty, minus_zero);
2834
2835   TEST_c_c (clog10, plus_infty, nan_value, plus_infty, nan_value);
2836   TEST_c_c (clog10, minus_infty, nan_value, plus_infty, nan_value);
2837
2838   TEST_c_c (clog10, nan_value, plus_infty, plus_infty, nan_value);
2839   TEST_c_c (clog10, nan_value, minus_infty, plus_infty, nan_value);
2840
2841   TEST_c_c (clog10, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2842   TEST_c_c (clog10, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2843   TEST_c_c (clog10, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2844   TEST_c_c (clog10, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2845
2846   TEST_c_c (clog10, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2847   TEST_c_c (clog10, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2848   TEST_c_c (clog10, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2849   TEST_c_c (clog10, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2850
2851   TEST_c_c (clog10, nan_value, nan_value, nan_value, nan_value);
2852
2853   TEST_c_c (clog10, 0.75L, 1.25L, 0.163679467193165171449476605077428975L, 0.447486970040493067069984724340855636L);
2854   TEST_c_c (clog10, -2, -3, 0.556971676153418384603252578971164214L, -0.937554462986374708541507952140189646L);
2855
2856   TEST_c_c (clog10, 0x1.fffffep+127L, 0x1.fffffep+127L, 38.68235441693561449174780668781319348761L, M_PI4_LOG10El);
2857   TEST_c_c (clog10, 0x1.fffffep+127L, 1.0L, 38.53183941910362389414093724045094697423L, 1.276276851248440096917018665609900318458e-39L, UNDERFLOW_EXCEPTION_FLOAT);
2858   TEST_c_c (clog10, 0x1p-149L, 0x1p-149L, -44.70295435610120748924022586658721447508L, M_PI4_LOG10El);
2859   TEST_c_c (clog10, 0x1p-147L, 0x1p-147L, -44.10089436477324509881274807713822842154L, M_PI4_LOG10El);
2860
2861 #ifndef TEST_FLOAT
2862   TEST_c_c (clog10, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 308.4052305577487344482591243175787477115L, M_PI4_LOG10El);
2863   TEST_c_c (clog10, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 308.3031705664207720674749211936626341569L, 0.2013595981366865903254995612594728746470L);
2864   TEST_c_c (clog10, 0x1p-1074L, 0x1p-1074L, -323.1557003452838130619487034867432642357L, M_PI4_LOG10El);
2865   TEST_c_c (clog10, 0x1p-1073L, 0x1p-1073L, -322.8546703496198318667349645920187712089L, M_PI4_LOG10El);
2866 #endif
2867
2868 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2869   TEST_c_c (clog10, 0x1.fp+16383L, 0x1.fp+16383L, 4932.212175672014259683102930239951947672L, M_PI4_LOG10El);
2870   TEST_c_c (clog10, 0x1.fp+16383L, 0x1p+16383L, 4932.112944269463028900262609694408579449L, 0.2069271710841128115912940666587802677383L);
2871   TEST_c_c (clog10, 0x1p-16440L, 0x1p-16441L, -4948.884673709346821106688037612752099609L, 0.2013595981366865710389502301937289472543L);
2872 #endif
2873
2874   TEST_c_c (clog10, 0x1p-149L, 0x1.fp+127L, 38.51805116050395969095658815123105801479L, 0.6821881769209206737428918127156778851051L);
2875   TEST_c_c (clog10, -0x1p-149L, 0x1.fp+127L, 38.51805116050395969095658815123105801479L, 0.6821881769209206737428918127156778851051L);
2876   TEST_c_c (clog10, 0x1p-149L, -0x1.fp+127L, 38.51805116050395969095658815123105801479L, -0.6821881769209206737428918127156778851051L);
2877   TEST_c_c (clog10, -0x1p-149L, -0x1.fp+127L, 38.51805116050395969095658815123105801479L, -0.6821881769209206737428918127156778851051L);
2878   TEST_c_c (clog10, -0x1.fp+127L, 0x1p-149L, 38.51805116050395969095658815123105801479L, 1.364376353841841347485783625431355770210L);
2879   TEST_c_c (clog10, -0x1.fp+127L, -0x1p-149L, 38.51805116050395969095658815123105801479L, -1.364376353841841347485783625431355770210L);
2880 #ifdef TEST_FLOAT
2881   TEST_c_c (clog10, 0x1.fp+127L, 0x1p-149L, 38.51805116050395969095658815123105801479L, plus_zero, UNDERFLOW_EXCEPTION);
2882   TEST_c_c (clog10, 0x1.fp+127L, -0x1p-149L, 38.51805116050395969095658815123105801479L, minus_zero, UNDERFLOW_EXCEPTION);
2883 #endif
2884
2885 #ifndef TEST_FLOAT
2886   TEST_c_c (clog10, 0x1p-1074L, 0x1.fp+1023L, 308.2409272754311106024666378243768099991L, 0.6821881769209206737428918127156778851051L);
2887   TEST_c_c (clog10, -0x1p-1074L, 0x1.fp+1023L, 308.2409272754311106024666378243768099991L, 0.6821881769209206737428918127156778851051L);
2888   TEST_c_c (clog10, 0x1p-1074L, -0x1.fp+1023L, 308.2409272754311106024666378243768099991L, -0.6821881769209206737428918127156778851051L);
2889   TEST_c_c (clog10, -0x1p-1074L, -0x1.fp+1023L, 308.2409272754311106024666378243768099991L, -0.6821881769209206737428918127156778851051L);
2890   TEST_c_c (clog10, -0x1.fp+1023L, 0x1p-1074L, 308.2409272754311106024666378243768099991L, 1.364376353841841347485783625431355770210L);
2891   TEST_c_c (clog10, -0x1.fp+1023L, -0x1p-1074L, 308.2409272754311106024666378243768099991L, -1.364376353841841347485783625431355770210L);
2892 #endif
2893 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2894   TEST_c_c (clog10, 0x1.fp+1023L, 0x1p-1074L, 308.2409272754311106024666378243768099991L, plus_zero, UNDERFLOW_EXCEPTION);
2895   TEST_c_c (clog10, 0x1.fp+1023L, -0x1p-1074L, 308.2409272754311106024666378243768099991L, minus_zero, UNDERFLOW_EXCEPTION);
2896 #endif
2897
2898 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2899   TEST_c_c (clog10, 0x1p-16445L, 0x1.fp+16383L, 4932.061660674182269085496060792589701158L, 0.6821881769209206737428918127156778851051L);
2900   TEST_c_c (clog10, -0x1p-16445L, 0x1.fp+16383L, 4932.061660674182269085496060792589701158L, 0.6821881769209206737428918127156778851051L);
2901   TEST_c_c (clog10, 0x1p-16445L, -0x1.fp+16383L, 4932.061660674182269085496060792589701158L, -0.6821881769209206737428918127156778851051L);
2902   TEST_c_c (clog10, -0x1p-16445L, -0x1.fp+16383L, 4932.061660674182269085496060792589701158L, -0.6821881769209206737428918127156778851051L);
2903   TEST_c_c (clog10, -0x1.fp+16383L, 0x1p-16445L, 4932.061660674182269085496060792589701158L, 1.364376353841841347485783625431355770210L);
2904   TEST_c_c (clog10, -0x1.fp+16383L, -0x1p-16445L, 4932.061660674182269085496060792589701158L, -1.364376353841841347485783625431355770210L);
2905   TEST_c_c (clog10, 0x1.fp+16383L, 0x1p-16445L, 4932.061660674182269085496060792589701158L, plus_zero, UNDERFLOW_EXCEPTION);
2906   TEST_c_c (clog10, 0x1.fp+16383L, -0x1p-16445L, 4932.061660674182269085496060792589701158L, minus_zero, UNDERFLOW_EXCEPTION);
2907 # if LDBL_MANT_DIG >= 113
2908   TEST_c_c (clog10, 0x1p-16494L, 0x1.fp+16383L, 4932.061660674182269085496060792589701158L, 0.6821881769209206737428918127156778851051L);
2909   TEST_c_c (clog10, -0x1p-16494L, 0x1.fp+16383L, 4932.061660674182269085496060792589701158L, 0.6821881769209206737428918127156778851051L);
2910   TEST_c_c (clog10, 0x1p-16494L, -0x1.fp+16383L, 4932.061660674182269085496060792589701158L, -0.6821881769209206737428918127156778851051L);
2911   TEST_c_c (clog10, -0x1p-16494L, -0x1.fp+16383L, 4932.061660674182269085496060792589701158L, -0.6821881769209206737428918127156778851051L);
2912   TEST_c_c (clog10, -0x1.fp+16383L, 0x1p-16494L, 4932.061660674182269085496060792589701158L, 1.364376353841841347485783625431355770210L);
2913   TEST_c_c (clog10, -0x1.fp+16383L, -0x1p-16494L, 4932.061660674182269085496060792589701158L, -1.364376353841841347485783625431355770210L);
2914   TEST_c_c (clog10, 0x1.fp+16383L, 0x1p-16494L, 4932.061660674182269085496060792589701158L, plus_zero, UNDERFLOW_EXCEPTION);
2915   TEST_c_c (clog10, 0x1.fp+16383L, -0x1p-16494L, 4932.061660674182269085496060792589701158L, minus_zero, UNDERFLOW_EXCEPTION);
2916 # endif
2917 #endif
2918
2919   TEST_c_c (clog10, 1.0L, 0x1.234566p-10L, 2.680828048441605163181684680300513080769e-7L, 4.825491868832381486767558728169977751564e-4L);
2920   TEST_c_c (clog10, -1.0L, 0x1.234566p-20L, 2.556638434669064077889576526006849923281e-13L, 1.364375882602207106407956770293808181427L);
2921   TEST_c_c (clog10, 0x1.234566p-30L, 1.0L, 2.438200411482400072282924063740535840474e-19L, 6.821881764607257184291586401763604544928e-1L);
2922   TEST_c_c (clog10, -0x1.234566p-40L, -1.0L, 2.325249110681915353442924915876654139373e-25L, -6.821881769213700828789403802671540158935e-1L);
2923   TEST_c_c (clog10, 0x1.234566p-50L, 1.0L, 2.217530356103816369479108963807448194409e-31L, 6.821881769209202348667823902864283966959e-1L);
2924   TEST_c_c (clog10, 0x1.234566p-60L, 1.0L, 2.114801746467415208319767917450504756866e-37L, 6.821881769209206733143018621078368211515e-1L);
2925   TEST_c_c (clog10, 0x1p-61L, 1.0L, 4.084085680564517578238994467153626207224e-38L, 6.821881769209206735545466044044889962925e-1L);
2926   TEST_c_c (clog10, 0x1p-62L, 1.0L, 1.021021420141129394559748616788406551878e-38L, 6.821881769209206736487192085600834406988e-1L, UNDERFLOW_EXCEPTION_FLOAT);
2927   TEST_c_c (clog10, 0x1p-63L, 1.0L, 2.552553550352823486399371541971016379740e-39L, 6.821881769209206736958055106378806629019e-1L, UNDERFLOW_EXCEPTION_FLOAT);
2928 #ifndef TEST_FLOAT
2929   TEST_c_c (clog10, 0x1p-509L, 1.0L, 7.730698388614835910296270976605350994446e-308L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
2930   TEST_c_c (clog10, 0x1p-510L, 1.0L, 1.932674597153708977574067744151337748612e-308L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION_DOUBLE);
2931   TEST_c_c (clog10, 0x1p-511L, 1.0L, 4.831686492884272443935169360378344371529e-309L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION_DOUBLE);
2932 #endif
2933 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2934   TEST_c_c (clog10, 0x1p-8189L, 1.0L, 1.168114274114528946314738738025008370069e-4931L, 6.821881769209206737428918127156778851051e-1L);
2935   TEST_c_c (clog10, 0x1p-8190L, 1.0L, 2.920285685286322365786846845062520925172e-4932L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION);
2936   TEST_c_c (clog10, 0x1p-8191L, 1.0L, 7.300714213215805914467117112656302312931e-4933L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION);
2937 #endif
2938
2939   TEST_c_c (clog10, 0x1.000566p0L, 0x1.234p-10L, 3.604093470239754109961125085078190708674e-5L, 4.824745078422174667425851670822596859720e-4L);
2940   TEST_c_c (clog10, 0x1.000566p0L, 0x1.234p-100L, 3.577293486783822178310971763308187385546e-5L, 3.897399639875661463735636919790792140598e-31L);
2941 #ifndef TEST_FLOAT
2942   TEST_c_c (clog10, -0x1.0000000123456p0L, 0x1.2345678p-30L, 1.150487028947346337782682105935961875822e-10L, 1.364376353381646356131680448946397884147L);
2943   TEST_c_c (clog10, -0x1.0000000123456p0L, 0x1.2345678p-1000L, 1.150487026509145544402795327729455391948e-10L, 1.364376353841841347485783625431355770210L);
2944 #endif
2945 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
2946   TEST_c_c (clog10, 0x1.00000000000000123456789abcp0L, 0x1.23456789p-60L, 4.285899851347756188767674032946882584784e-19L, 4.285899850759344225805480528847018395861e-19L);
2947   TEST_c_c (clog10, 0x1.00000000000000123456789abcp0L, 0x1.23456789p-1000L, 4.285899851347756186652871946325962330640e-19L, 4.611541215247321502041995872887317363241e-302L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
2948 #endif
2949
2950   TEST_c_c (clog10, 0x0.ffffffp0L, 0x0.ffffffp-100L, -2.588596909321764128428416045209904492216e-8L, 3.425979381266895667295625489912064603415e-31L);
2951 #ifndef TEST_FLOAT
2952   TEST_c_c (clog10, 0x0.fffffffffffff8p0L, 0x0.fffffffffffff8p-1000L, -4.821637332766435821255375046554377090472e-17L, 4.053112396770095089737411317782466262176e-302L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
2953 #endif
2954 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
2955   TEST_c_c (clog10, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp-15000L, -2.354315103889861110220423157644627849164e-20L, 1.541165759405643564697852372112893034397e-4516L);
2956 #endif
2957
2958   TEST_c_c (clog10, 0x1a6p-10L, 0x3a5p-10L, -6.2126412844802358329771948751248003038444e-07L, 0.4977135139537443711784513409096950995985L);
2959   TEST_c_c (clog10, 0xf2p-10L, 0x3e3p-10L, 2.6921240173351112953324592659528481616879e-06L, 0.5785726025799636431142862788413361783862L);
2960   TEST_c_c (clog10, 0x4d4ep-15L, 0x6605p-15L, -7.0781945783414996953799915941870192015212e-09L, 0.4005747524909781155537088181659175147564L);
2961   TEST_c_c (clog10, 0x2818p-15L, 0x798fp-15L, 6.6737261053986614395049481326819059203910e-09L, 0.5438241985991753781478398141908629586460L);
2962   TEST_c_c (clog10, 0x9b57bp-20L, 0xcb7b4p-20L, -1.7182001068739620267773842120965071561416e-11L, 0.3990121149225253562859800593935899629087L);
2963   TEST_c_c (clog10, 0x2731p-20L, 0xfffd0p-20L, 1.9156943718715958194239364991329064049438e-11L, 0.6780326907904082601285090019969008967595L);
2964   TEST_c_c (clog10, 0x2ede88p-23L, 0x771c3fp-23L, -1.9440841725722970687903291200493082253766e-13L, 0.5193774116724956222518530053006822210323L);
2965   TEST_c_c (clog10, 0x11682p-23L, 0x7ffed1p-23L, 5.0916490233953865181284669870035717560498e-13L, 0.6784968969384861816694467029319146542069L);
2966   TEST_c_c (clog10, 0xa1f2c1p-24L, 0xc643aep-24L, -4.5516256421319921959681423447271490869664e-14L, 0.3847315790697197749315054516562206543710L);
2967   TEST_c_c (clog10, 0x659feap-24L, 0xeaf6f9p-24L, 1.6200701438094619117335617123525612051457e-14L, 0.5049027913635038013499728086604870749732L);
2968 #ifndef TEST_FLOAT
2969   TEST_c_c (clog10, 0x4447d7175p-35L, 0x6c445e00ap-35L, -6.4375803621988389731799033530075237868110e-21L, 0.4378257977686804492768642780897650927167L);
2970   TEST_c_c (clog10, 0x2dd46725bp-35L, 0x7783a1284p-35L, 1.9312741086596516918394613098872836703188e-20L, 0.5231613813514771042838490538484014771862L);
2971   TEST_c_c (clog10, 0x164c74eea876p-45L, 0x16f393482f77p-45L, -1.3155760824064879362415202279780039150764e-26L, 0.3473590599762514228227328130640352044313L);
2972   TEST_c_c (clog10, 0xfe961079616p-45L, 0x1bc37e09e6d1p-45L, 2.3329549194675052736016290082882121135546e-26L, 0.4561756099441139182878993697611751382976L);
2973   TEST_c_c (clog10, 0xa4722f19346cp-51L, 0x7f9631c5e7f07p-51L, -2.6979587627476803379953050733225113494503e-30L, 0.6472785229986997177606324374555347813105L);
2974   TEST_c_c (clog10, 0x10673dd0f2481p-51L, 0x7ef1d17cefbd2p-51L, 1.3918041236396763648388478552321724382899e-29L, 0.6263795733790237053262025311642907438291L);
2975   TEST_c_c (clog10, 0x8ecbf810c4ae6p-52L, 0xd479468b09a37p-52L, -4.2289432987513243393180377141513840878196e-30L, 0.4252020027092323591068799049905597805296L);
2976   TEST_c_c (clog10, 0x5b06b680ea2ccp-52L, 0xef452b965da9fp-52L, 3.6079845358966994996207055940336690133424e-30L, 0.5243112258263349992771652393178033846555L);
2977   TEST_c_c (clog10, 0x659b70ab7971bp-53L, 0x1f5d111e08abecp-53L, -1.0893543813872082317104059174982092534059e-30L, 0.5954257879188711495921161433751775633232L);
2978   TEST_c_c (clog10, 0x15cfbd1990d1ffp-53L, 0x176a3973e09a9ap-53L, 4.4163015461643576961232672330852798804976e-31L, 0.3564851427422832755956993418877523303529L);
2979   TEST_c_c (clog10, 0x1367a310575591p-54L, 0x3cfcc0a0541f60p-54L, 2.2081507730821788480616336165447731164865e-32L, 0.5484039935757001196548030312819898864760L);
2980   TEST_c_c (clog10, 0x55cb6d0c83af5p-55L, 0x7fe33c0c7c4e90p-55L, -2.2583360179249556400630343805573865814771e-32L, 0.6639894257763289307423302343317622430835L);
2981 #endif
2982 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
2983   TEST_c_c (clog10, 0x298c62cb546588a7p-63L, 0x7911b1dfcc4ecdaep-63L, -5.1816837072162316773907242302011632570857e-37L, 0.5386167838952956925896424154370364458140L);
2984   TEST_c_c (clog10, 0x4d9c37e2b5cb4533p-63L, 0x65c98be2385a042ep-63L, 2.7822833698845776001753149807484078521508e-37L, 0.3992725998539071066769046272515417679815L);
2985   TEST_c_c (clog10, 0x602fd5037c4792efp-64L, 0xed3e2086dcca80b8p-64L, -1.0146400362652473358437501879334790111898e-37L, 0.5149047982335273098246594109614460842099L);
2986   TEST_c_c (clog10, 0x6b10b4f3520217b6p-64L, 0xe8893cbb449253a1p-64L, 1.0529283395205396881397407610630442563938e-37L, 0.4947949395762683446121140513971996916447L);
2987   TEST_c_c (clog10, 0x81b7efa81fc35ad1p-65L, 0x1ef4b835f1c79d812p-65L, -4.3074341162203896332989394770760901408798e-39L, 0.5709443672155660428417571212549720987784L);
2988 #endif
2989 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
2990   TEST_c_c (clog10, 0x3f96469050f650869c2p-75L, 0x6f16b2c9c8b05988335p-75L, -4.5643214291682663316715446865040356750881e-46L, 0.4564083863660793840592614609053162690362L);
2991   TEST_c_c (clog10, 0x3157fc1d73233e580c8p-75L, 0x761b52ccd435d7c7f5fp-75L, 5.8575458340992751256451490143468457830297e-44L, 0.5103174273246635294300470585396890237265L);
2992   TEST_c_c (clog10, 0x155f8afc4c48685bf63610p-85L, 0x17d0cf2652cdbeb1294e19p-85L, -2.0748709499710785084693619097712106753591e-50L, 0.3645447681189598740620098186365764884771L);
2993   TEST_c_c (clog10, 0x13836d58a13448d750b4b9p-85L, 0x195ca7bc3ab4f9161edbe6p-85L, 1.2333149003324592532859843519619084433953e-50L, 0.3973779298829931059309198145608711073016L);
2994   TEST_c_c (clog10, 0x1df515eb171a808b9e400266p-95L, 0x7c71eb0cd4688dfe98581c77p-95L, -1.5221162575729652613635150540947625639689e-57L, 0.5795934880811949230121092882659698986043L);
2995   TEST_c_c (clog10, 0xe33f66c9542ca25cc43c867p-95L, 0x7f35a68ebd3704a43c465864p-95L, 1.7850272475173865337808494725293124613817e-56L, 0.6338990862456906754888183278564382516852L);
2996   TEST_c_c (clog10, 0x6771f22c64ed551b857c128b4cp-105L, 0x1f570e7a13cc3cf2f44fd793ea1p-105L, -6.2023045024810589256360494043570293518879e-63L, 0.5938345819561308555003145899438513900776L);
2997   TEST_c_c (clog10, 0x15d8ab6ed05ca514086ac3a1e84p-105L, 0x1761e480aa094c0b10b34b09ce9p-105L, 4.3548095442952115860848857519953610343042e-63L, 0.3558376234889641500775150477035448866763L);
2998   TEST_c_c (clog10, 0x187190c1a334497bdbde5a95f48p-106L, 0x3b25f08062d0a095c4cfbbc338dp-106L, -7.5879257211204444302994221436282805900756e-64L, 0.5119945461708707332160859198685423099187L);
2999   TEST_c_c (clog10, 0x6241ef0da53f539f02fad67dabp-106L, 0x3fb46641182f7efd9caa769dac0p-106L, 1.8804859395820231849002915747252695375405e-63L, 0.6404513901551516189871978418046651877394L);
3000 #endif
3001 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 113
3002   TEST_c_c (clog10, 0x3e1d0a105ac4ebeacd9c6952d34cp-112L, 0xf859b3d1b06d005dcbb5516d5479p-112L, -5.0742964549782184008668435276046798273476e-67L, 0.5757527761596220360985719127090110408283L);
3003   TEST_c_c (clog10, 0x47017a2e36807acb1e5214b209dep-112L, 0xf5f4a550c9d75e3bb1839d865f0dp-112L, 6.5482587585671294601662599808612773010057e-66L, 0.5601289501766423782280643144987875760229L);
3004   TEST_c_c (clog10, 0x148f818cb7a9258fca942ade2a0cap-113L, 0x18854a34780b8333ec53310ad7001p-113L, -3.1210950417524756037077807411854181477733e-67L, 0.3791463562379872585396164879981280044658L);
3005   TEST_c_c (clog10, 0xfd95243681c055c2632286921092p-113L, 0x1bccabcd29ca2152860ec29e34ef7p-113L, 2.8774482675253468630312378575186855052697e-66L, 0.4571561610046221605554903008571429975493L);
3006   TEST_c_c (clog10, 0xdb85c467ee2aadd5f425fe0f4b8dp-114L, 0x3e83162a0f95f1dcbf97dddf410eap-114L, 1.9985076315737626043096596036300177494613e-67L, 0.5883569274304683249184005177865521205198L);
3007   TEST_c_c (clog10, 0x1415bcaf2105940d49a636e98ae59p-115L, 0x7e6a150adfcd1b0921d44b31f40f4p-115L, 1.1288799405048268615023706955013387413519e-67L, 0.6137587762850841972073301550420510507903L);
3008 #endif
3009
3010   END (clog10, complex);
3011 }
3012
3013
3014 static void
3015 conj_test (void)
3016 {
3017   START (conj);
3018   TEST_c_c (conj, 0.0, 0.0, 0.0, minus_zero);
3019   TEST_c_c (conj, 0.0, minus_zero, 0.0, 0.0);
3020   TEST_c_c (conj, nan_value, nan_value, nan_value, nan_value);
3021   TEST_c_c (conj, plus_infty, minus_infty, plus_infty, plus_infty);
3022   TEST_c_c (conj, plus_infty, plus_infty, plus_infty, minus_infty);
3023   TEST_c_c (conj, 1.0, 2.0, 1.0, -2.0);
3024   TEST_c_c (conj, 3.0, -4.0, 3.0, 4.0);
3025
3026   END (conj, complex);
3027 }
3028
3029
3030 static void
3031 copysign_test (void)
3032 {
3033   START (copysign);
3034
3035   TEST_ff_f (copysign, 0, 4, 0);
3036   TEST_ff_f (copysign, 0, -4, minus_zero);
3037   TEST_ff_f (copysign, minus_zero, 4, 0);
3038   TEST_ff_f (copysign, minus_zero, -4, minus_zero);
3039
3040   TEST_ff_f (copysign, plus_infty, 0, plus_infty);
3041   TEST_ff_f (copysign, plus_infty, minus_zero, minus_infty);
3042   TEST_ff_f (copysign, minus_infty, 0, plus_infty);
3043   TEST_ff_f (copysign, minus_infty, minus_zero, minus_infty);
3044
3045   TEST_ff_f (copysign, 0, plus_infty, 0);
3046   TEST_ff_f (copysign, 0, minus_zero, minus_zero);
3047   TEST_ff_f (copysign, minus_zero, plus_infty, 0);
3048   TEST_ff_f (copysign, minus_zero, minus_zero, minus_zero);
3049
3050   /* XXX More correctly we would have to check the sign of the NaN.  */
3051   TEST_ff_f (copysign, nan_value, 0, nan_value);
3052   TEST_ff_f (copysign, nan_value, minus_zero, nan_value);
3053   TEST_ff_f (copysign, -nan_value, 0, nan_value);
3054   TEST_ff_f (copysign, -nan_value, minus_zero, nan_value);
3055
3056   END (copysign);
3057 }
3058
3059
3060 static void
3061 cos_test (void)
3062 {
3063   errno = 0;
3064   FUNC(cos) (0);
3065   if (errno == ENOSYS)
3066     /* Function not implemented.  */
3067     return;
3068
3069   START (cos);
3070
3071   TEST_f_f (cos, 0, 1);
3072   TEST_f_f (cos, minus_zero, 1);
3073   errno = 0;
3074   TEST_f_f (cos, plus_infty, nan_value, INVALID_EXCEPTION);
3075   check_int ("errno for cos(+inf) == EDOM", errno, EDOM, 0, 0, 0);
3076   errno = 0;
3077   TEST_f_f (cos, minus_infty, nan_value, INVALID_EXCEPTION);
3078   check_int ("errno for cos(-inf) == EDOM", errno, EDOM, 0, 0, 0);
3079   errno = 0;
3080   TEST_f_f (cos, nan_value, nan_value);
3081   check_int ("errno for cos(NaN) unchanged", errno, 0, 0, 0, 0);
3082
3083   TEST_f_f (cos, M_PI_6l * 2.0, 0.5);
3084   TEST_f_f (cos, M_PI_6l * 4.0, -0.5);
3085   TEST_f_f (cos, M_PI_2l, 0);
3086
3087   TEST_f_f (cos, 0.75L, 0.731688868873820886311838753000084544L);
3088
3089   TEST_f_f (cos, 0x1p65, 0.99888622066058013610642172179340364209972L);
3090   TEST_f_f (cos, -0x1p65, 0.99888622066058013610642172179340364209972L);
3091
3092 #ifdef TEST_DOUBLE
3093   TEST_f_f (cos, 0.80190127184058835, 0.69534156199418473);
3094 #endif
3095
3096   TEST_f_f (cos, 0x1.442f74p+15, 2.4407839902314016628485779006274989801517e-06L);
3097
3098 #ifndef TEST_FLOAT
3099   TEST_f_f (cos, 1e22, 0.5232147853951389454975944733847094921409L);
3100   TEST_f_f (cos, 0x1p1023, -0.826369834614147994500785680811743734805L);
3101 #endif
3102
3103 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3104   TEST_f_f (cos, 0x1p16383L, 0.9210843909921906206874509522505756251609L);
3105 #endif
3106
3107   TEST_f_f (cos, 0x1p+120, -9.25879022854837867303861764107414946730833e-01L);
3108   TEST_f_f (cos, 0x1p+127, 7.81914638714960072263910298466369236613162e-01L);
3109   TEST_f_f (cos, 0x1.fffff8p+127, 9.98819362551949040703862043664101081064641e-01L);
3110   TEST_f_f (cos, 0x1.fffffep+127, 8.53021039830304158051791467692161107353094e-01L);
3111   TEST_f_f (cos, 0x1p+50, 8.68095904660550604334592502063501320395739e-01L);
3112   TEST_f_f (cos, 0x1p+28, -1.65568979490578758865468278195361551113358e-01L);
3113
3114   END (cos);
3115 }
3116
3117
3118 static void
3119 cos_test_tonearest (void)
3120 {
3121   int save_round_mode;
3122   errno = 0;
3123   FUNC(cos) (0);
3124   if (errno == ENOSYS)
3125     /* Function not implemented.  */
3126     return;
3127
3128   START (cos_tonearest);
3129
3130   save_round_mode = fegetround ();
3131
3132   if (!fesetround (FE_TONEAREST))
3133     {
3134       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
3135       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
3136       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
3137       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
3138       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
3139       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
3140       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
3141       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
3142       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
3143       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
3144     }
3145
3146   fesetround (save_round_mode);
3147
3148   END (cos_tonearest);
3149 }
3150
3151
3152 static void
3153 cos_test_towardzero (void)
3154 {
3155   int save_round_mode;
3156   errno = 0;
3157   FUNC(cos) (0);
3158   if (errno == ENOSYS)
3159     /* Function not implemented.  */
3160     return;
3161
3162   START (cos_towardzero);
3163
3164   save_round_mode = fegetround ();
3165
3166   if (!fesetround (FE_TOWARDZERO))
3167     {
3168       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
3169       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
3170       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
3171       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
3172       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
3173       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
3174       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
3175       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
3176       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
3177       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
3178     }
3179
3180   fesetround (save_round_mode);
3181
3182   END (cos_towardzero);
3183 }
3184
3185
3186 static void
3187 cos_test_downward (void)
3188 {
3189   int save_round_mode;
3190   errno = 0;
3191   FUNC(cos) (0);
3192   if (errno == ENOSYS)
3193     /* Function not implemented.  */
3194     return;
3195
3196   START (cos_downward);
3197
3198   save_round_mode = fegetround ();
3199
3200   if (!fesetround (FE_DOWNWARD))
3201     {
3202       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
3203       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
3204       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
3205       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
3206       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
3207       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
3208       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
3209       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
3210       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
3211       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
3212     }
3213
3214   fesetround (save_round_mode);
3215
3216   END (cos_downward);
3217 }
3218
3219
3220 static void
3221 cos_test_upward (void)
3222 {
3223   int save_round_mode;
3224   errno = 0;
3225   FUNC(cos) (0);
3226   if (errno == ENOSYS)
3227     /* Function not implemented.  */
3228     return;
3229
3230   START (cos_upward);
3231
3232   save_round_mode = fegetround ();
3233
3234   if (!fesetround (FE_UPWARD))
3235     {
3236       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
3237       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
3238       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
3239       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
3240       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
3241       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
3242       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
3243       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
3244       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
3245       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
3246     }
3247
3248   fesetround (save_round_mode);
3249
3250   END (cos_upward);
3251 }
3252
3253
3254 static void
3255 cosh_test (void)
3256 {
3257   errno = 0;
3258   FUNC(cosh) (0.7L);
3259   if (errno == ENOSYS)
3260     /* Function not implemented.  */
3261     return;
3262
3263   START (cosh);
3264   TEST_f_f (cosh, 0, 1);
3265   TEST_f_f (cosh, minus_zero, 1);
3266
3267 #ifndef TEST_INLINE
3268   TEST_f_f (cosh, plus_infty, plus_infty);
3269   TEST_f_f (cosh, minus_infty, plus_infty);
3270 #endif
3271   TEST_f_f (cosh, nan_value, nan_value);
3272
3273   TEST_f_f (cosh, 0.75L, 1.29468328467684468784170818539018176L);
3274
3275 #ifndef TEST_FLOAT
3276   TEST_f_f (cosh, 709.8893558127259666434838436543941497802734375L, 9.9999998999995070652573675944761818416035e+307L);
3277   TEST_f_f (cosh, -709.8893558127259666434838436543941497802734375L, 9.9999998999995070652573675944761818416035e+307L);
3278 #endif
3279
3280   END (cosh);
3281 }
3282
3283
3284 static void
3285 cosh_test_tonearest (void)
3286 {
3287   int save_round_mode;
3288   errno = 0;
3289   FUNC(cosh) (0);
3290   if (errno == ENOSYS)
3291     /* Function not implemented.  */
3292     return;
3293
3294   START (cosh_tonearest);
3295
3296   save_round_mode = fegetround ();
3297
3298   if (!fesetround (FE_TONEAREST))
3299     {
3300       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
3301       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
3302       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
3303     }
3304
3305   fesetround (save_round_mode);
3306
3307   END (cosh_tonearest);
3308 }
3309
3310
3311 static void
3312 cosh_test_towardzero (void)
3313 {
3314   int save_round_mode;
3315   errno = 0;
3316   FUNC(cosh) (0);
3317   if (errno == ENOSYS)
3318     /* Function not implemented.  */
3319     return;
3320
3321   START (cosh_towardzero);
3322
3323   save_round_mode = fegetround ();
3324
3325   if (!fesetround (FE_TOWARDZERO))
3326     {
3327       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
3328       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
3329       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
3330     }
3331
3332   fesetround (save_round_mode);
3333
3334   END (cosh_towardzero);
3335 }
3336
3337
3338 static void
3339 cosh_test_downward (void)
3340 {
3341   int save_round_mode;
3342   errno = 0;
3343   FUNC(cosh) (0);
3344   if (errno == ENOSYS)
3345     /* Function not implemented.  */
3346     return;
3347
3348   START (cosh_downward);
3349
3350   save_round_mode = fegetround ();
3351
3352   if (!fesetround (FE_DOWNWARD))
3353     {
3354       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
3355       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
3356       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
3357     }
3358
3359   fesetround (save_round_mode);
3360
3361   END (cosh_downward);
3362 }
3363
3364
3365 static void
3366 cosh_test_upward (void)
3367 {
3368   int save_round_mode;
3369   errno = 0;
3370   FUNC(cosh) (0);
3371   if (errno == ENOSYS)
3372     /* Function not implemented.  */
3373     return;
3374
3375   START (cosh_upward);
3376
3377   save_round_mode = fegetround ();
3378
3379   if (!fesetround (FE_UPWARD))
3380     {
3381       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
3382       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
3383       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
3384     }
3385
3386   fesetround (save_round_mode);
3387
3388   END (cosh_upward);
3389 }
3390
3391
3392 static void
3393 cpow_test (void)
3394 {
3395   errno = 0;
3396   FUNC(cpow) (BUILD_COMPLEX (1, 0), BUILD_COMPLEX (0, 0));
3397   if (errno == ENOSYS)
3398     /* Function not implemented.  */
3399     return;
3400
3401   START (cpow);
3402
3403   TEST_cc_c (cpow, 1, 0, 0, 0, 1.0, 0.0);
3404   TEST_cc_c (cpow, 2, 0, 10, 0, 1024.0, 0.0);
3405
3406   TEST_cc_c (cpow, M_El, 0, 0, 2 * M_PIl, 1.0, 0.0);
3407   TEST_cc_c (cpow, 2, 3, 4, 0, -119.0, -120.0);
3408
3409   TEST_cc_c (cpow, nan_value, nan_value, nan_value, nan_value, nan_value, nan_value);
3410
3411   TEST_cc_c (cpow, 0.75L, 1.25L, 0.75L, 1.25L, 0.117506293914473555420279832210420483L, 0.346552747708338676483025352060418001L);
3412   TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 1.0L, 0.0846958290317209430433805274189191353L, 0.513285749182902449043287190519090481L);
3413   TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 0.0L, 0.75L, 1.25L);
3414   TEST_cc_c (cpow, 0.75L, 1.25L, 0.0L, 1.0L, 0.331825439177608832276067945276730566L, 0.131338600281188544930936345230903032L);
3415
3416   END (cpow, complex);
3417 }
3418
3419
3420 static void
3421 cproj_test (void)
3422 {
3423   START (cproj);
3424   TEST_c_c (cproj, 0.0, 0.0, 0.0, 0.0);
3425   TEST_c_c (cproj, minus_zero, minus_zero, minus_zero, minus_zero);
3426   TEST_c_c (cproj, 0.0, minus_zero, 0.0, minus_zero);
3427   TEST_c_c (cproj, minus_zero, 0.0, minus_zero, 0.0);
3428
3429   TEST_c_c (cproj, nan_value, nan_value, nan_value, nan_value);
3430
3431   TEST_c_c (cproj, plus_infty, plus_infty, plus_infty, 0.0);
3432   TEST_c_c (cproj, plus_infty, minus_infty, plus_infty, minus_zero);
3433   TEST_c_c (cproj, minus_infty, plus_infty, plus_infty, 0.0);
3434   TEST_c_c (cproj, minus_infty, minus_infty, plus_infty, minus_zero);
3435
3436   TEST_c_c (cproj, 1.0, 0.0, 1.0, 0.0);
3437   TEST_c_c (cproj, 2.0, 3.0, 2.0, 3.0);
3438
3439   END (cproj, complex);
3440 }
3441
3442
3443 static void
3444 creal_test (void)
3445 {
3446   START (creal);
3447   TEST_c_f (creal, 0.0, 1.0, 0.0);
3448   TEST_c_f (creal, minus_zero, 1.0, minus_zero);
3449   TEST_c_f (creal, nan_value, 1.0, nan_value);
3450   TEST_c_f (creal, nan_value, nan_value, nan_value);
3451   TEST_c_f (creal, plus_infty, 1.0, plus_infty);
3452   TEST_c_f (creal, minus_infty, 1.0, minus_infty);
3453   TEST_c_f (creal, 2.0, 3.0, 2.0);
3454
3455   END (creal);
3456 }
3457
3458 static void
3459 csin_test (void)
3460 {
3461   errno = 0;
3462   FUNC(csin) (BUILD_COMPLEX (0.7L, 1.2L));
3463   if (errno == ENOSYS)
3464     /* Function not implemented.  */
3465     return;
3466
3467   START (csin);
3468
3469   TEST_c_c (csin, 0.0, 0.0, 0.0, 0.0);
3470   TEST_c_c (csin, minus_zero, 0.0, minus_zero, 0.0);
3471   TEST_c_c (csin, 0.0, minus_zero, 0, minus_zero);
3472   TEST_c_c (csin, minus_zero, minus_zero, minus_zero, minus_zero);
3473
3474   TEST_c_c (csin, 0.0, plus_infty, 0.0, plus_infty);
3475   TEST_c_c (csin, minus_zero, plus_infty, minus_zero, plus_infty);
3476   TEST_c_c (csin, 0.0, minus_infty, 0.0, minus_infty);
3477   TEST_c_c (csin, minus_zero, minus_infty, minus_zero, minus_infty);
3478
3479   TEST_c_c (csin, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3480   TEST_c_c (csin, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3481   TEST_c_c (csin, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3482   TEST_c_c (csin, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3483
3484   TEST_c_c (csin, plus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3485   TEST_c_c (csin, minus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3486   TEST_c_c (csin, plus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3487   TEST_c_c (csin, minus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3488
3489   TEST_c_c (csin, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
3490   TEST_c_c (csin, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
3491   TEST_c_c (csin, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
3492   TEST_c_c (csin, minus_infty, -6.75,  nan_value, nan_value, INVALID_EXCEPTION);
3493
3494   TEST_c_c (csin, 4.625, plus_infty, minus_infty, minus_infty);
3495   TEST_c_c (csin, 4.625, minus_infty, minus_infty, plus_infty);
3496   TEST_c_c (csin, -4.625, plus_infty, plus_infty, minus_infty);
3497   TEST_c_c (csin, -4.625, minus_infty, plus_infty, plus_infty);
3498
3499   TEST_c_c (csin, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
3500   TEST_c_c (csin, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
3501
3502   TEST_c_c (csin, nan_value, plus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
3503   TEST_c_c (csin, nan_value, minus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
3504
3505   TEST_c_c (csin, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3506   TEST_c_c (csin, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3507
3508   TEST_c_c (csin, 0.0, nan_value, 0.0, nan_value);
3509   TEST_c_c (csin, minus_zero, nan_value, minus_zero, nan_value);
3510
3511   TEST_c_c (csin, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3512   TEST_c_c (csin, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3513
3514   TEST_c_c (csin, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3515   TEST_c_c (csin, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3516
3517   TEST_c_c (csin, nan_value, nan_value, nan_value, nan_value);
3518
3519   TEST_c_c (csin, 0.75L, 1.25L, 1.28722291002649188575873510790565441L, 1.17210635989270256101081285116138863L);
3520   TEST_c_c (csin, -2, -3, -9.15449914691142957346729954460983256L, 4.16890695996656435075481305885375484L);
3521
3522   TEST_c_c (csin, 0.75, 89.5, 2.522786001038096774676288412995370563339e38L, 2.708024460708609732016532185663087200560e38L);
3523   TEST_c_c (csin, 0.75, -89.5, 2.522786001038096774676288412995370563339e38L, -2.708024460708609732016532185663087200560e38L);
3524   TEST_c_c (csin, -0.75, 89.5, -2.522786001038096774676288412995370563339e38L, 2.708024460708609732016532185663087200560e38L);
3525   TEST_c_c (csin, -0.75, -89.5, -2.522786001038096774676288412995370563339e38L, -2.708024460708609732016532185663087200560e38L);
3526
3527 #ifndef TEST_FLOAT
3528   TEST_c_c (csin, 0.75, 710.5, 1.255317763348154410745082950806112487736e308L, 1.347490911916428129246890157395342279438e308L);
3529   TEST_c_c (csin, 0.75, -710.5, 1.255317763348154410745082950806112487736e308L, -1.347490911916428129246890157395342279438e308L);
3530   TEST_c_c (csin, -0.75, 710.5, -1.255317763348154410745082950806112487736e308L, 1.347490911916428129246890157395342279438e308L);
3531   TEST_c_c (csin, -0.75, -710.5, -1.255317763348154410745082950806112487736e308L, -1.347490911916428129246890157395342279438e308L);
3532 #endif
3533
3534 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3535   TEST_c_c (csin, 0.75, 11357.25, 8.385498349388321535962327491346664141020e4931L, 9.001213196851067077465606717616495588201e4931L);
3536   TEST_c_c (csin, 0.75, -11357.25, 8.385498349388321535962327491346664141020e4931L, -9.001213196851067077465606717616495588201e4931L);
3537   TEST_c_c (csin, -0.75, 11357.25, -8.385498349388321535962327491346664141020e4931L, 9.001213196851067077465606717616495588201e4931L);
3538   TEST_c_c (csin, -0.75, -11357.25, -8.385498349388321535962327491346664141020e4931L, -9.001213196851067077465606717616495588201e4931L);
3539 #endif
3540
3541 #ifdef TEST_FLOAT
3542   TEST_c_c (csin, 0x1p-149, 180, 1.043535896672617552965983803453927655332e33L, plus_infty, OVERFLOW_EXCEPTION);
3543 #endif
3544
3545 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
3546   TEST_c_c (csin, 0x1p-1074, 1440, 5.981479269486130556466515778180916082415e301L, plus_infty, OVERFLOW_EXCEPTION);
3547 #endif
3548
3549 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3550   TEST_c_c (csin, 0x1p-16434L, 22730, 1.217853148905605987081057582351152052687e4924L, plus_infty, OVERFLOW_EXCEPTION);
3551 #endif
3552
3553   END (csin, complex);
3554 }
3555
3556
3557 static void
3558 csinh_test (void)
3559 {
3560   errno = 0;
3561   FUNC(csinh) (BUILD_COMPLEX (0.7L, 1.2L));
3562   if (errno == ENOSYS)
3563     /* Function not implemented.  */
3564     return;
3565
3566   START (csinh);
3567
3568   TEST_c_c (csinh, 0.0, 0.0, 0.0, 0.0);
3569   TEST_c_c (csinh, minus_zero, 0.0, minus_zero, 0.0);
3570   TEST_c_c (csinh, 0.0, minus_zero, 0.0, minus_zero);
3571   TEST_c_c (csinh, minus_zero, minus_zero, minus_zero, minus_zero);
3572
3573   TEST_c_c (csinh, 0.0, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3574   TEST_c_c (csinh, minus_zero, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3575   TEST_c_c (csinh, 0.0, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3576   TEST_c_c (csinh, minus_zero, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3577
3578   TEST_c_c (csinh, plus_infty, 0.0, plus_infty, 0.0);
3579   TEST_c_c (csinh, minus_infty, 0.0, minus_infty, 0.0);
3580   TEST_c_c (csinh, plus_infty, minus_zero, plus_infty, minus_zero);
3581   TEST_c_c (csinh, minus_infty, minus_zero, minus_infty, minus_zero);
3582
3583   TEST_c_c (csinh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3584   TEST_c_c (csinh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3585   TEST_c_c (csinh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3586   TEST_c_c (csinh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3587
3588   TEST_c_c (csinh, plus_infty, 4.625, minus_infty, minus_infty);
3589   TEST_c_c (csinh, minus_infty, 4.625, plus_infty, minus_infty);
3590   TEST_c_c (csinh, plus_infty, -4.625, minus_infty, plus_infty);
3591   TEST_c_c (csinh, minus_infty, -4.625, plus_infty, plus_infty);
3592
3593   TEST_c_c (csinh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3594   TEST_c_c (csinh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3595   TEST_c_c (csinh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3596   TEST_c_c (csinh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3597
3598   TEST_c_c (csinh, 0.0, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
3599   TEST_c_c (csinh, minus_zero, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
3600
3601   TEST_c_c (csinh, plus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
3602   TEST_c_c (csinh, minus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
3603
3604   TEST_c_c (csinh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3605   TEST_c_c (csinh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3606
3607   TEST_c_c (csinh, nan_value, 0.0, nan_value, 0.0);
3608   TEST_c_c (csinh, nan_value, minus_zero, nan_value, minus_zero);
3609
3610   TEST_c_c (csinh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3611   TEST_c_c (csinh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3612
3613   TEST_c_c (csinh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
3614   TEST_c_c (csinh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
3615
3616   TEST_c_c (csinh, nan_value, nan_value, nan_value, nan_value);
3617
3618   TEST_c_c (csinh, 0.75L, 1.25L, 0.259294854551162779153349830618433028L, 1.22863452409509552219214606515777594L);
3619   TEST_c_c (csinh, -2, -3, 3.59056458998577995201256544779481679L, -0.530921086248519805267040090660676560L);
3620
3621   TEST_c_c (csinh, 89.5, 0.75, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
3622   TEST_c_c (csinh, -89.5, 0.75, -2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
3623   TEST_c_c (csinh, 89.5, -0.75, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
3624   TEST_c_c (csinh, -89.5, -0.75, -2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
3625
3626 #ifndef TEST_FLOAT
3627   TEST_c_c (csinh, 710.5, 0.75, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
3628   TEST_c_c (csinh, -710.5, 0.75, -1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
3629   TEST_c_c (csinh, 710.5, -0.75, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
3630   TEST_c_c (csinh, -710.5, -0.75, -1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
3631 #endif
3632
3633 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3634   TEST_c_c (csinh, 11357.25, 0.75, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
3635   TEST_c_c (csinh, -11357.25, 0.75, -9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
3636   TEST_c_c (csinh, 11357.25, -0.75, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
3637   TEST_c_c (csinh, -11357.25, -0.75, -9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
3638 #endif
3639
3640 #ifdef TEST_FLOAT
3641   TEST_c_c (csinh, 180, 0x1p-149, plus_infty, 1.043535896672617552965983803453927655332e33L, OVERFLOW_EXCEPTION);
3642 #endif
3643
3644 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
3645   TEST_c_c (csinh, 1440, 0x1p-1074, plus_infty, 5.981479269486130556466515778180916082415e301L, OVERFLOW_EXCEPTION);
3646 #endif
3647
3648 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3649   TEST_c_c (csinh, 22730, 0x1p-16434L, plus_infty, 1.217853148905605987081057582351152052687e4924L, OVERFLOW_EXCEPTION);
3650 #endif
3651
3652   END (csinh, complex);
3653 }
3654
3655
3656 static void
3657 csqrt_test (void)
3658 {
3659   errno = 0;
3660   FUNC(csqrt) (BUILD_COMPLEX (-1, 0));
3661   if (errno == ENOSYS)
3662     /* Function not implemented.  */
3663     return;
3664
3665   START (csqrt);
3666
3667   TEST_c_c (csqrt, 0, 0, 0.0, 0.0);
3668   TEST_c_c (csqrt, 0, minus_zero, 0, minus_zero);
3669   TEST_c_c (csqrt, minus_zero, 0, 0.0, 0.0);
3670   TEST_c_c (csqrt, minus_zero, minus_zero, 0.0, minus_zero);
3671
3672   TEST_c_c (csqrt, minus_infty, 0, 0.0, plus_infty);
3673   TEST_c_c (csqrt, minus_infty, 6, 0.0, plus_infty);
3674   TEST_c_c (csqrt, minus_infty, minus_zero, 0.0, minus_infty);
3675   TEST_c_c (csqrt, minus_infty, -6, 0.0, minus_infty);
3676
3677   TEST_c_c (csqrt, plus_infty, 0, plus_infty, 0.0);
3678   TEST_c_c (csqrt, plus_infty, 6, plus_infty, 0.0);
3679   TEST_c_c (csqrt, plus_infty, minus_zero, plus_infty, minus_zero);
3680   TEST_c_c (csqrt, plus_infty, -6, plus_infty, minus_zero);
3681
3682   TEST_c_c (csqrt, 0, plus_infty, plus_infty, plus_infty);
3683   TEST_c_c (csqrt, 4, plus_infty, plus_infty, plus_infty);
3684   TEST_c_c (csqrt, plus_infty, plus_infty, plus_infty, plus_infty);
3685   TEST_c_c (csqrt, minus_zero, plus_infty, plus_infty, plus_infty);
3686   TEST_c_c (csqrt, -4, plus_infty, plus_infty, plus_infty);
3687   TEST_c_c (csqrt, minus_infty, plus_infty, plus_infty, plus_infty);
3688   TEST_c_c (csqrt, 0, minus_infty, plus_infty, minus_infty);
3689   TEST_c_c (csqrt, 4, minus_infty, plus_infty, minus_infty);
3690   TEST_c_c (csqrt, plus_infty, minus_infty, plus_infty, minus_infty);
3691   TEST_c_c (csqrt, minus_zero, minus_infty, plus_infty, minus_infty);
3692   TEST_c_c (csqrt, -4, minus_infty, plus_infty, minus_infty);
3693   TEST_c_c (csqrt, minus_infty, minus_infty, plus_infty, minus_infty);
3694
3695   TEST_c_c (csqrt, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
3696
3697   TEST_c_c (csqrt, plus_infty, nan_value, plus_infty, nan_value);
3698
3699   TEST_c_c (csqrt, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3700   TEST_c_c (csqrt, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3701   TEST_c_c (csqrt, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3702   TEST_c_c (csqrt, -1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3703
3704   TEST_c_c (csqrt, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3705   TEST_c_c (csqrt, nan_value, 8, nan_value, nan_value, INVALID_EXCEPTION_OK);
3706   TEST_c_c (csqrt, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
3707   TEST_c_c (csqrt, nan_value, -8, nan_value, nan_value, INVALID_EXCEPTION_OK);
3708
3709   TEST_c_c (csqrt, nan_value, nan_value, nan_value, nan_value);
3710
3711   TEST_c_c (csqrt, 16.0, -30.0, 5.0, -3.0);
3712   TEST_c_c (csqrt, -1, 0, 0.0, 1.0);
3713   TEST_c_c (csqrt, 0, 2, 1.0, 1.0);
3714   TEST_c_c (csqrt, 119, 120, 12.0, 5.0);
3715   TEST_c_c (csqrt, 0.75L, 1.25L, 1.05065169626078392338656675760808326L, 0.594868882070379067881984030639932657L);
3716   TEST_c_c (csqrt, -2, -3, 0.89597747612983812471573375529004348L, -1.6741492280355400404480393008490519L);
3717   TEST_c_c (csqrt, -2, 3, 0.89597747612983812471573375529004348L, 1.6741492280355400404480393008490519L);
3718   /* Principal square root should be returned (i.e., non-negative real
3719      part).  */
3720   TEST_c_c (csqrt, 0, -1, M_SQRT_2_2, -M_SQRT_2_2);
3721
3722   TEST_c_c (csqrt, 0x1.fffffep+127L, 0x1.fffffep+127L, 2.026714405498316804978751017492482558075e+19L, 8.394925938143272988211878516208015586281e+18L);
3723   TEST_c_c (csqrt, 0x1.fffffep+127L, 1.0L, 1.844674352395372953599975585936590505260e+19L, 2.710505511993121390769065968615872097053e-20L);
3724   TEST_c_c (csqrt, 0x1p-149L, 0x1p-149L, 4.112805464342778798097003462770175200803e-23L, 1.703579802732953750368659735601389709551e-23L);
3725   TEST_c_c (csqrt, 0x1p-147L, 0x1p-147L, 8.225610928685557596194006925540350401606e-23L, 3.407159605465907500737319471202779419102e-23L);
3726
3727   TEST_c_c (csqrt, plus_zero, 0x1p-149L, 2.646977960169688559588507814623881131411e-23L, 2.646977960169688559588507814623881131411e-23L);
3728   TEST_c_c (csqrt, 0x1p-50L, 0x1p-149L, 2.980232238769531250000000000000000000000e-8L, 2.350988701644575015937473074444491355637e-38L);
3729 #ifdef TEST_FLOAT
3730   TEST_c_c (csqrt, 0x1p+127L, 0x1p-149L, 1.304381782533278221234957180625250836888e19L, plus_zero, UNDERFLOW_EXCEPTION);
3731 #endif
3732   TEST_c_c (csqrt, 0x1p-149L, 0x1p+127L, 9.223372036854775808000000000000000000000e18L, 9.223372036854775808000000000000000000000e18L);
3733   TEST_c_c (csqrt, 0x1.000002p-126L, 0x1.000002p-126L, 1.191195773697904627170323731331667740087e-19L, 4.934094449071842328766868579214125217132e-20L);
3734   TEST_c_c (csqrt, -0x1.000002p-126L, -0x1.000002p-126L, 4.934094449071842328766868579214125217132e-20L, -1.191195773697904627170323731331667740087e-19L);
3735
3736 #ifndef TEST_FLOAT
3737   TEST_c_c (csqrt, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 1.473094556905565378990473658199034571917e+154L, 6.101757441282702188537080005372547713595e+153L);
3738   TEST_c_c (csqrt, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 1.379778091031440685006200821918878702861e+154L, 3.257214233483129514781233066898042490248e+153L);
3739   TEST_c_c (csqrt, 0x1p-1074L, 0x1p-1074L, 2.442109726130830256743814843868934877597e-162L, 1.011554969366634726113090867589031782487e-162L);
3740   TEST_c_c (csqrt, 0x1p-1073L, 0x1p-1073L, 3.453664695497464982856905711457966660085e-162L, 1.430554756764195530630723976279903095110e-162L);
3741
3742   TEST_c_c (csqrt, plus_zero, 0x1p-1074L, 1.571727784702628688909515672805082228285e-162L, 1.571727784702628688909515672805082228285e-162L);
3743   TEST_c_c (csqrt, 0x1p-500L, 0x1p-1074L, 5.527147875260444560247265192192255725514e-76L, 4.469444793151709302716387622440056066334e-249L);
3744 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
3745   TEST_c_c (csqrt, 0x1p+1023L, 0x1p-1074L, 9.480751908109176726832526455652159260085e153L, plus_zero, UNDERFLOW_EXCEPTION);
3746 #endif
3747   TEST_c_c (csqrt, 0x1p-1074L, 0x1p+1023L, 6.703903964971298549787012499102923063740e153L, 6.703903964971298549787012499102923063740e153L);
3748   TEST_c_c (csqrt, 0x1.0000000000001p-1022L, 0x1.0000000000001p-1022L, 1.638872094839911521020410942677082920935e-154L, 6.788430486774966350907249113759995429568e-155L);
3749   TEST_c_c (csqrt, -0x1.0000000000001p-1022L, -0x1.0000000000001p-1022L, 6.788430486774966350907249113759995429568e-155L, -1.638872094839911521020410942677082920935e-154L);
3750 #endif
3751
3752 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3753   TEST_c_c (csqrt, 0x1.fp+16383L, 0x1.fp+16383L, 1.179514222452201722651836720466795901016e+2466L, 4.885707879516577666702435054303191575148e+2465L);
3754   TEST_c_c (csqrt, 0x1.fp+16383L, 0x1p+16383L, 1.106698967236475180613254276996359485630e+2466L, 2.687568007603946993388538156299100955642e+2465L);
3755   TEST_c_c (csqrt, 0x1p-16440L, 0x1p-16441L, 3.514690655930285351254618340783294558136e-2475L,  8.297059146828716918029689466551384219370e-2476L);
3756
3757   TEST_c_c (csqrt, plus_zero, 0x1p-16445L, 4.269191686890197837775136325621239761720e-2476L, 4.269191686890197837775136325621239761720e-2476L);
3758   TEST_c_c (csqrt, 0x1p-5000L, 0x1p-16445L, 2.660791472672778409283210520357607795518e-753L, 6.849840675828785164910701384823702064234e-4199L);
3759   TEST_c_c (csqrt, 0x1p+16383L, 0x1p-16445L, 7.712754032630730034273323365543179095045e2465L, plus_zero, UNDERFLOW_EXCEPTION);
3760   TEST_c_c (csqrt, 0x1p-16445L, 0x1p+16383L, 5.453740678097079647314921223668914312241e2465L, 5.453740678097079647314921223668914312241e2465L);
3761   TEST_c_c (csqrt, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-16382L, 2.014551439675644900131815801350165472778e-2466L, 8.344545284118961664300307045791497724440e-2467L);
3762   TEST_c_c (csqrt, -0x1.0000000000000002p-16382L, -0x1.0000000000000002p-16382L, 8.344545284118961664300307045791497724440e-2467L, -2.014551439675644900131815801350165472778e-2466L);
3763
3764 # if LDBL_MANT_DIG >= 113
3765   TEST_c_c (csqrt, plus_zero, 0x1p-16494L, 1.799329752913293143453817328207572571442e-2483L, 1.799329752913293143453817328207572571442e-2483L);
3766   TEST_c_c (csqrt, 0x1p-5000L, 0x1p-16494L, 2.660791472672778409283210520357607795518e-753L, 1.216776133331049643422030716668249905907e-4213L);
3767   TEST_c_c (csqrt, 0x1p+16383L, 0x1p-16494L, 7.712754032630730034273323365543179095045e2465L, plus_zero, UNDERFLOW_EXCEPTION);
3768   TEST_c_c (csqrt, 0x1p-16494L, 0x1p+16383L, 5.453740678097079647314921223668914312241e2465L, 5.453740678097079647314921223668914312241e2465L);
3769   TEST_c_c (csqrt, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-16382L, 2.014551439675644900022606748976158925145e-2466L, 8.344545284118961663847948339519226074126e-2467L);
3770   TEST_c_c (csqrt, -0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-16382L, 8.344545284118961663847948339519226074126e-2467L, -2.014551439675644900022606748976158925145e-2466L);
3771 # endif
3772 #endif
3773
3774   END (csqrt, complex);
3775 }
3776
3777 static void
3778 ctan_test (void)
3779 {
3780   errno = 0;
3781   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3782   if (errno == ENOSYS)
3783     /* Function not implemented.  */
3784     return;
3785
3786   START (ctan);
3787
3788   TEST_c_c (ctan, 0, 0, 0.0, 0.0);
3789   TEST_c_c (ctan, 0, minus_zero, 0.0, minus_zero);
3790   TEST_c_c (ctan, minus_zero, 0, minus_zero, 0.0);
3791   TEST_c_c (ctan, minus_zero, minus_zero, minus_zero, minus_zero);
3792
3793   TEST_c_c (ctan, 0, plus_infty, 0.0, 1.0);
3794   TEST_c_c (ctan, 1, plus_infty, 0.0, 1.0);
3795   TEST_c_c (ctan, minus_zero, plus_infty, minus_zero, 1.0);
3796   TEST_c_c (ctan, -1, plus_infty, minus_zero, 1.0);
3797
3798   TEST_c_c (ctan, 0, minus_infty, 0.0, -1.0);
3799   TEST_c_c (ctan, 1, minus_infty, 0.0, -1.0);
3800   TEST_c_c (ctan, minus_zero, minus_infty, minus_zero, -1.0);
3801   TEST_c_c (ctan, -1, minus_infty, minus_zero, -1.0);
3802
3803   TEST_c_c (ctan, plus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
3804   TEST_c_c (ctan, plus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
3805   TEST_c_c (ctan, minus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
3806   TEST_c_c (ctan, minus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
3807   TEST_c_c (ctan, plus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
3808   TEST_c_c (ctan, plus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
3809   TEST_c_c (ctan, minus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
3810   TEST_c_c (ctan, minus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
3811
3812   TEST_c_c (ctan, nan_value, plus_infty, 0.0, 1.0, IGNORE_ZERO_INF_SIGN);
3813   TEST_c_c (ctan, nan_value, minus_infty, 0.0, -1.0, IGNORE_ZERO_INF_SIGN);
3814
3815   TEST_c_c (ctan, 0, nan_value, 0.0, nan_value);
3816   TEST_c_c (ctan, minus_zero, nan_value, minus_zero, nan_value);
3817
3818   TEST_c_c (ctan, 0.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3819   TEST_c_c (ctan, -4.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3820
3821   TEST_c_c (ctan, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3822   TEST_c_c (ctan, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
3823   TEST_c_c (ctan, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
3824   TEST_c_c (ctan, nan_value, -0.25, nan_value, nan_value, INVALID_EXCEPTION_OK);
3825
3826   TEST_c_c (ctan, nan_value, nan_value, nan_value, nan_value);
3827
3828   TEST_c_c (ctan, 0.75L, 1.25L, 0.160807785916206426725166058173438663L, 0.975363285031235646193581759755216379L);
3829   TEST_c_c (ctan, -2, -3, 0.376402564150424829275122113032269084e-2L, -1.00323862735360980144635859782192726L);
3830
3831   TEST_c_c (ctan, 1, 45, 1.490158918874345552942703234806348520895e-39L, 1.000000000000000000000000000000000000001L, UNDERFLOW_EXCEPTION_FLOAT);
3832   TEST_c_c (ctan, 1, 47, 2.729321264492904590777293425576722354636e-41L, 1.0, UNDERFLOW_EXCEPTION_FLOAT);
3833
3834 #ifndef TEST_FLOAT
3835   TEST_c_c (ctan, 1, 355, 8.140551093483276762350406321792653551513e-309L, 1.0, UNDERFLOW_EXCEPTION_DOUBLE);
3836   TEST_c_c (ctan, 1, 365, 1.677892637497921890115075995898773550884e-317L, 1.0, UNDERFLOW_EXCEPTION_DOUBLE);
3837 #endif
3838
3839 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3840   TEST_c_c (ctan, 1, 5680, 4.725214596136812019616700920476949798307e-4934L, 1.0, UNDERFLOW_EXCEPTION);
3841   TEST_c_c (ctan, 1, 5690, 9.739393181626937151720816611272607059057e-4943L, 1.0, UNDERFLOW_EXCEPTION);
3842 #endif
3843
3844   TEST_c_c (ctan, 0x3.243f6cp-1, 0, -2.287733242885645987394874673945769518150e7L, 0.0);
3845
3846   TEST_c_c (ctan, 0x1p127, 1, 0.2446359391192790896381501310437708987204L, 0.9101334047676183761532873794426475906201L);
3847
3848 #ifndef TEST_FLOAT
3849   TEST_c_c (ctan, 0x1p1023, 1, -0.2254627924997545057926782581695274244229L, 0.8786063118883068695462540226219865087189L);
3850 #endif
3851
3852 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3853   TEST_c_c (ctan, 0x1p16383L, 1, 0.1608598776370396607204448234354670036772L, 0.8133818522051542536316746743877629761488L);
3854 #endif
3855
3856   TEST_c_c (ctan, 50000, 50000, plus_zero, 1.0, UNDERFLOW_EXCEPTION);
3857   TEST_c_c (ctan, 50000, -50000, plus_zero, -1.0, UNDERFLOW_EXCEPTION);
3858   TEST_c_c (ctan, -50000, 50000, minus_zero, 1.0, UNDERFLOW_EXCEPTION);
3859   TEST_c_c (ctan, -50000, -50000, minus_zero, -1.0, UNDERFLOW_EXCEPTION);
3860
3861   END (ctan, complex);
3862 }
3863
3864
3865 static void
3866 ctan_test_tonearest (void)
3867 {
3868   int save_round_mode;
3869   errno = 0;
3870   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3871   if (errno == ENOSYS)
3872     /* Function not implemented.  */
3873     return;
3874
3875   START (ctan_tonearest);
3876
3877   save_round_mode = fegetround ();
3878
3879   if (!fesetround (FE_TONEAREST))
3880     {
3881       TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L);
3882
3883 #ifndef TEST_FLOAT
3884       TEST_c_c (ctan, 0x1.921fb54442d18p+0, 0x1p-1074, 1.633123935319536975596773704152891653086e16L, 1.317719414943508315995636961402669067843e-291L);
3885 #endif
3886
3887 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3888       TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L);
3889 #endif
3890     }
3891
3892   fesetround (save_round_mode);
3893
3894   END (ctan_tonearest, complex);
3895 }
3896
3897
3898 static void
3899 ctan_test_towardzero (void)
3900 {
3901   int save_round_mode;
3902   errno = 0;
3903   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3904   if (errno == ENOSYS)
3905     /* Function not implemented.  */
3906     return;
3907
3908   START (ctan_towardzero);
3909
3910   save_round_mode = fegetround ();
3911
3912   if (!fesetround (FE_TOWARDZERO))
3913     {
3914       TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L);
3915
3916 #ifndef TEST_FLOAT
3917       TEST_c_c (ctan, 0x1.921fb54442d18p+0, 0x1p-1074, 1.633123935319536975596773704152891653086e16L, 1.317719414943508315995636961402669067843e-291L);
3918 #endif
3919
3920 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3921       TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L);
3922 #endif
3923     }
3924
3925   fesetround (save_round_mode);
3926
3927   END (ctan_towardzero, complex);
3928 }
3929
3930
3931 static void
3932 ctan_test_downward (void)
3933 {
3934   int save_round_mode;
3935   errno = 0;
3936   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3937   if (errno == ENOSYS)
3938     /* Function not implemented.  */
3939     return;
3940
3941   START (ctan_downward);
3942
3943   save_round_mode = fegetround ();
3944
3945   if (!fesetround (FE_DOWNWARD))
3946     {
3947       TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L);
3948
3949 #ifndef TEST_FLOAT
3950       TEST_c_c (ctan, 0x1.921fb54442d18p+0, 0x1p-1074, 1.633123935319536975596773704152891653086e16L, 1.317719414943508315995636961402669067843e-291L);
3951 #endif
3952
3953 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3954       TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L);
3955 #endif
3956     }
3957
3958   fesetround (save_round_mode);
3959
3960   END (ctan_downward, complex);
3961 }
3962
3963
3964 static void
3965 ctan_test_upward (void)
3966 {
3967   int save_round_mode;
3968   errno = 0;
3969   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3970   if (errno == ENOSYS)
3971     /* Function not implemented.  */
3972     return;
3973
3974   START (ctan_upward);
3975
3976   save_round_mode = fegetround ();
3977
3978   if (!fesetround (FE_UPWARD))
3979     {
3980       TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L);
3981
3982 #ifndef TEST_FLOAT
3983       TEST_c_c (ctan, 0x1.921fb54442d18p+0, 0x1p-1074, 1.633123935319536975596773704152891653086e16L, 1.317719414943508315995636961402669067843e-291L);
3984 #endif
3985
3986 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3987       TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L);
3988 #endif
3989     }
3990
3991   fesetround (save_round_mode);
3992
3993   END (ctan_upward, complex);
3994 }
3995
3996
3997 static void
3998 ctanh_test (void)
3999 {
4000   errno = 0;
4001   FUNC(ctanh) (BUILD_COMPLEX (0, 0));
4002   if (errno == ENOSYS)
4003     /* Function not implemented.  */
4004     return;
4005
4006   START (ctanh);
4007
4008   TEST_c_c (ctanh, 0, 0, 0.0, 0.0);
4009   TEST_c_c (ctanh, 0, minus_zero, 0.0, minus_zero);
4010   TEST_c_c (ctanh, minus_zero, 0, minus_zero, 0.0);
4011   TEST_c_c (ctanh, minus_zero, minus_zero, minus_zero, minus_zero);
4012
4013   TEST_c_c (ctanh, plus_infty, 0, 1.0, 0.0);
4014   TEST_c_c (ctanh, plus_infty, 1, 1.0, 0.0);
4015   TEST_c_c (ctanh, plus_infty, minus_zero, 1.0, minus_zero);
4016   TEST_c_c (ctanh, plus_infty, -1, 1.0, minus_zero);
4017   TEST_c_c (ctanh, minus_infty, 0, -1.0, 0.0);
4018   TEST_c_c (ctanh, minus_infty, 1, -1.0, 0.0);
4019   TEST_c_c (ctanh, minus_infty, minus_zero, -1.0, minus_zero);
4020   TEST_c_c (ctanh, minus_infty, -1, -1.0, minus_zero);
4021
4022   TEST_c_c (ctanh, 0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
4023   TEST_c_c (ctanh, 2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
4024   TEST_c_c (ctanh, 0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
4025   TEST_c_c (ctanh, 2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
4026   TEST_c_c (ctanh, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
4027   TEST_c_c (ctanh, -2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
4028   TEST_c_c (ctanh, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
4029   TEST_c_c (ctanh, -2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
4030
4031   TEST_c_c (ctanh, plus_infty, nan_value, 1.0, 0.0, IGNORE_ZERO_INF_SIGN);
4032   TEST_c_c (ctanh, minus_infty, nan_value, -1.0, 0.0, IGNORE_ZERO_INF_SIGN);
4033
4034   TEST_c_c (ctanh, nan_value, 0, nan_value, 0.0);
4035   TEST_c_c (ctanh, nan_value, minus_zero, nan_value, minus_zero);
4036
4037   TEST_c_c (ctanh, nan_value, 0.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
4038   TEST_c_c (ctanh, nan_value, -4.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
4039
4040   TEST_c_c (ctanh, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
4041   TEST_c_c (ctanh, 5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
4042   TEST_c_c (ctanh, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
4043   TEST_c_c (ctanh, -0.25, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
4044
4045   TEST_c_c (ctanh, nan_value, nan_value, nan_value, nan_value);
4046
4047   TEST_c_c (ctanh, 0, M_PI_4l, 0.0, 1.0);
4048
4049   TEST_c_c (ctanh, 0.75L, 1.25L, 1.37260757053378320258048606571226857L, 0.385795952609750664177596760720790220L);
4050   TEST_c_c (ctanh, -2, -3, -0.965385879022133124278480269394560686L, 0.988437503832249372031403430350121098e-2L);
4051
4052   TEST_c_c (ctanh, 45, 1, 1.000000000000000000000000000000000000001L, 1.490158918874345552942703234806348520895e-39L, UNDERFLOW_EXCEPTION_FLOAT);
4053   TEST_c_c (ctanh, 47, 1, 1.0, 2.729321264492904590777293425576722354636e-41L, UNDERFLOW_EXCEPTION_FLOAT);
4054
4055 #ifndef TEST_FLOAT
4056   TEST_c_c (ctanh, 355, 1, 1.0, 8.140551093483276762350406321792653551513e-309L, UNDERFLOW_EXCEPTION_DOUBLE);
4057   TEST_c_c (ctanh, 365, 1, 1.0, 1.677892637497921890115075995898773550884e-317L, UNDERFLOW_EXCEPTION_DOUBLE);
4058 #endif
4059
4060 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
4061   TEST_c_c (ctanh, 5680, 1, 1.0, 4.725214596136812019616700920476949798307e-4934L, UNDERFLOW_EXCEPTION);
4062   TEST_c_c (ctanh, 5690, 1, 1.0, 9.739393181626937151720816611272607059057e-4943L, UNDERFLOW_EXCEPTION);
4063 #endif
4064
4065   TEST_c_c (ctanh, 0, 0x3.243f6cp-1, 0.0, -2.287733242885645987394874673945769518150e7L);
4066
4067   TEST_c_c (ctanh, 1, 0x1p127, 0.9101334047676183761532873794426475906201L, 0.2446359391192790896381501310437708987204L);
4068
4069 #ifndef TEST_FLOAT
4070   TEST_c_c (ctanh, 1, 0x1p1023, 0.8786063118883068695462540226219865087189L, -0.2254627924997545057926782581695274244229L);
4071 #endif
4072
4073 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
4074   TEST_c_c (ctanh, 1, 0x1p16383L, 0.8133818522051542536316746743877629761488L, 0.1608598776370396607204448234354670036772L);
4075 #endif
4076
4077   TEST_c_c (ctanh, 50000, 50000, 1.0, plus_zero, UNDERFLOW_EXCEPTION);
4078   TEST_c_c (ctanh, 50000, -50000, 1.0, minus_zero, UNDERFLOW_EXCEPTION);
4079   TEST_c_c (ctanh, -50000, 50000, -1.0, plus_zero, UNDERFLOW_EXCEPTION);
4080   TEST_c_c (ctanh, -50000, -50000, -1.0, minus_zero, UNDERFLOW_EXCEPTION);
4081
4082   END (ctanh, complex);
4083 }
4084
4085
4086 static void
4087 ctanh_test_tonearest (void)
4088 {
4089   int save_round_mode;
4090   errno = 0;
4091   FUNC(ctanh) (BUILD_COMPLEX (0.7L, 1.2L));
4092   if (errno == ENOSYS)
4093     /* Function not implemented.  */
4094     return;
4095
4096   START (ctanh_tonearest);
4097
4098   save_round_mode = fegetround ();
4099
4100   if (!fesetround (FE_TONEAREST))
4101     {
4102       TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L);
4103
4104 #ifndef TEST_FLOAT
4105       TEST_c_c (ctanh, 0x1p-1074, 0x1.921fb54442d18p+0, 1.317719414943508315995636961402669067843e-291L, 1.633123935319536975596773704152891653086e16L);
4106 #endif
4107
4108 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
4109       TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L);
4110 #endif
4111     }
4112
4113   fesetround (save_round_mode);
4114
4115   END (ctanh_tonearest, complex);
4116 }
4117
4118
4119 static void
4120 ctanh_test_towardzero (void)
4121 {
4122   int save_round_mode;
4123   errno = 0;
4124   FUNC(ctanh) (BUILD_COMPLEX (0.7L, 1.2L));
4125   if (errno == ENOSYS)
4126     /* Function not implemented.  */
4127     return;
4128
4129   START (ctanh_towardzero);
4130
4131   save_round_mode = fegetround ();
4132
4133   if (!fesetround (FE_TOWARDZERO))
4134     {
4135       TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L);
4136
4137 #ifndef TEST_FLOAT
4138       TEST_c_c (ctanh, 0x1p-1074, 0x1.921fb54442d18p+0, 1.317719414943508315995636961402669067843e-291L, 1.633123935319536975596773704152891653086e16L);
4139 #endif
4140
4141 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
4142       TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L);
4143 #endif
4144     }
4145
4146   fesetround (save_round_mode);
4147
4148   END (ctanh_towardzero, complex);
4149 }
4150
4151
4152 static void
4153 ctanh_test_downward (void)
4154 {
4155   int save_round_mode;
4156   errno = 0;
4157   FUNC(ctanh) (BUILD_COMPLEX (0.7L, 1.2L));
4158   if (errno == ENOSYS)
4159     /* Function not implemented.  */
4160     return;
4161
4162   START (ctanh_downward);
4163
4164   save_round_mode = fegetround ();
4165
4166   if (!fesetround (FE_DOWNWARD))
4167     {
4168       TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L);
4169
4170 #ifndef TEST_FLOAT
4171       TEST_c_c (ctanh, 0x1p-1074, 0x1.921fb54442d18p+0, 1.317719414943508315995636961402669067843e-291L, 1.633123935319536975596773704152891653086e16L);
4172 #endif
4173
4174 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
4175       TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L);
4176 #endif
4177     }
4178
4179   fesetround (save_round_mode);
4180
4181   END (ctanh_downward, complex);
4182 }
4183
4184
4185 static void
4186 ctanh_test_upward (void)
4187 {
4188   int save_round_mode;
4189   errno = 0;
4190   FUNC(ctanh) (BUILD_COMPLEX (0.7L, 1.2L));
4191   if (errno == ENOSYS)
4192     /* Function not implemented.  */
4193     return;
4194
4195   START (ctanh_upward);
4196
4197   save_round_mode = fegetround ();
4198
4199   if (!fesetround (FE_UPWARD))
4200     {
4201       TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L);
4202
4203 #ifndef TEST_FLOAT
4204       TEST_c_c (ctanh, 0x1p-1074, 0x1.921fb54442d18p+0, 1.317719414943508315995636961402669067843e-291L, 1.633123935319536975596773704152891653086e16L);
4205 #endif
4206
4207 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
4208       TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L);
4209 #endif
4210     }
4211
4212   fesetround (save_round_mode);
4213
4214   END (ctanh_upward, complex);
4215 }
4216
4217
4218 static void
4219 erf_test (void)
4220 {
4221   errno = 0;
4222   FUNC(erf) (0);
4223   if (errno == ENOSYS)
4224     /* Function not implemented.  */
4225     return;
4226
4227   START (erf);
4228
4229   TEST_f_f (erf, 0, 0);
4230   TEST_f_f (erf, minus_zero, minus_zero);
4231   TEST_f_f (erf, plus_infty, 1);
4232   TEST_f_f (erf, minus_infty, -1);
4233   TEST_f_f (erf, nan_value, nan_value);
4234
4235   TEST_f_f (erf, 0.125L, 0.140316204801333817393029446521623398L);
4236   TEST_f_f (erf, 0.75L, 0.711155633653515131598937834591410777L);
4237   TEST_f_f (erf, 1.25L, 0.922900128256458230136523481197281140L);
4238   TEST_f_f (erf, 2.0L, 0.995322265018952734162069256367252929L);
4239   TEST_f_f (erf, 4.125L, 0.999999994576599200434933994687765914L);
4240   TEST_f_f (erf, 27.0L, 1.0L);
4241
4242   END (erf);
4243 }
4244
4245
4246 static void
4247 erfc_test (void)
4248 {
4249   errno = 0;
4250   FUNC(erfc) (0);
4251   if (errno == ENOSYS)
4252     /* Function not implemented.  */
4253     return;
4254
4255   START (erfc);
4256
4257   TEST_f_f (erfc, plus_infty, 0.0);
4258   TEST_f_f (erfc, minus_infty, 2.0);
4259   TEST_f_f (erfc, 0.0, 1.0);
4260   TEST_f_f (erfc, minus_zero, 1.0);
4261   TEST_f_f (erfc, nan_value, nan_value);
4262
4263   TEST_f_f (erfc, 0.125L, 0.859683795198666182606970553478376602L);
4264   TEST_f_f (erfc, 0.75L, 0.288844366346484868401062165408589223L);
4265   TEST_f_f (erfc, 1.25L, 0.0770998717435417698634765188027188596L);
4266   TEST_f_f (erfc, 2.0L, 0.00467773498104726583793074363274707139L);
4267   TEST_f_f (erfc, 0x1.f7303cp+1L, 2.705500297238986897105236321218861842255e-8L);
4268   TEST_f_f (erfc, 4.125L, 0.542340079956506600531223408575531062e-8L);
4269   TEST_f_f (erfc, 0x1.ffa002p+2L, 1.233585992097580296336099501489175967033e-29L);
4270   TEST_f_f (erfc, 0x1.ffffc8p+2L, 1.122671365033056305522366683719541099329e-29L);
4271 #ifdef TEST_LDOUBLE
4272   /* The result can only be represented in long double.  */
4273 # if LDBL_MIN_10_EXP < -319
4274   TEST_f_f (erfc, 27.0L, 0.523704892378925568501606768284954709e-318L);
4275 # endif
4276 # if LDBL_MANT_DIG >= 106
4277   TEST_f_f (erfc, 0x1.ffff56789abcdef0123456789a8p+2L, 1.123161416304655390092138725253789378459e-29L);
4278 # endif
4279 #endif
4280
4281   END (erfc);
4282 }
4283
4284
4285 static void
4286 exp_test (void)
4287 {
4288   errno = 0;
4289   FUNC(exp) (0);
4290   if (errno == ENOSYS)
4291     /* Function not implemented.  */
4292     return;
4293
4294   START (exp);
4295
4296   TEST_f_f (exp, 0, 1);
4297   TEST_f_f (exp, minus_zero, 1);
4298
4299 #ifndef TEST_INLINE
4300   TEST_f_f (exp, plus_infty, plus_infty);
4301   TEST_f_f (exp, minus_infty, 0);
4302 #endif
4303   TEST_f_f (exp, nan_value, nan_value);
4304   TEST_f_f (exp, 1, M_El);
4305
4306   TEST_f_f (exp, 2, M_E2l);
4307   TEST_f_f (exp, 3, M_E3l);
4308   TEST_f_f (exp, 0.75L, 2.11700001661267466854536981983709561L);
4309   TEST_f_f (exp, 50.0L, 5184705528587072464087.45332293348538L);
4310   TEST_f_f (exp, 88.72269439697265625L, 3.40233126623160774937554134772290447915e38L);
4311 #if defined TEST_LDOUBLE && __LDBL_MAX_EXP__ > 1024
4312   /* The result can only be represented in sane long double.  */
4313   TEST_f_f (exp, 1000.0L, 0.197007111401704699388887935224332313e435L);
4314 #endif
4315
4316 #if !(defined TEST_LDOUBLE && LDBL_MAX_EXP > 1024)
4317   TEST_f_f (exp, 710, plus_infty, OVERFLOW_EXCEPTION);
4318   TEST_f_f (exp, -1234, plus_zero, UNDERFLOW_EXCEPTION);
4319 #endif
4320   TEST_f_f (exp, 1e5, plus_infty, OVERFLOW_EXCEPTION);
4321   TEST_f_f (exp, max_value, plus_infty, OVERFLOW_EXCEPTION);
4322   TEST_f_f (exp, -max_value, 0, UNDERFLOW_EXCEPTION);
4323
4324   END (exp);
4325 }
4326
4327
4328 static void
4329 exp_test_tonearest (void)
4330 {
4331   int save_round_mode;
4332   errno = 0;
4333   FUNC(exp) (0);
4334   if (errno == ENOSYS)
4335     /* Function not implemented.  */
4336     return;
4337
4338   START (exp_tonearest);
4339
4340   save_round_mode = fegetround ();
4341
4342   if (!fesetround (FE_TONEAREST))
4343     {
4344       TEST_f_f (exp, 1, M_El);
4345       TEST_f_f (exp, 2, M_E2l);
4346       TEST_f_f (exp, 3, M_E3l);
4347     }
4348
4349   fesetround (save_round_mode);
4350
4351   END (exp_tonearest);
4352 }
4353
4354
4355 static void
4356 exp_test_towardzero (void)
4357 {
4358   int save_round_mode;
4359   errno = 0;
4360   FUNC(exp) (0);
4361   if (errno == ENOSYS)
4362     /* Function not implemented.  */
4363     return;
4364
4365   START (exp_towardzero);
4366
4367   save_round_mode = fegetround ();
4368
4369   if (!fesetround (FE_TOWARDZERO))
4370     {
4371       TEST_f_f (exp, 1, M_El);
4372       TEST_f_f (exp, 2, M_E2l);
4373       TEST_f_f (exp, 3, M_E3l);
4374     }
4375
4376   fesetround (save_round_mode);
4377
4378   END (exp_towardzero);
4379 }
4380
4381
4382 static void
4383 exp_test_downward (void)
4384 {
4385   int save_round_mode;
4386   errno = 0;
4387   FUNC(exp) (0);
4388   if (errno == ENOSYS)
4389     /* Function not implemented.  */
4390     return;
4391
4392   START (exp_downward);
4393
4394   save_round_mode = fegetround ();
4395
4396   if (!fesetround (FE_DOWNWARD))
4397     {
4398       TEST_f_f (exp, 1, M_El);
4399       TEST_f_f (exp, 2, M_E2l);
4400       TEST_f_f (exp, 3, M_E3l);
4401     }
4402
4403   fesetround (save_round_mode);
4404
4405   END (exp_downward);
4406 }
4407
4408
4409 static void
4410 exp_test_upward (void)
4411 {
4412   int save_round_mode;
4413   errno = 0;
4414   FUNC(exp) (0);
4415   if (errno == ENOSYS)
4416     /* Function not implemented.  */
4417     return;
4418
4419   START (exp_upward);
4420
4421   save_round_mode = fegetround ();
4422
4423   if (!fesetround (FE_UPWARD))
4424     {
4425       TEST_f_f (exp, 1, M_El);
4426       TEST_f_f (exp, 2, M_E2l);
4427       TEST_f_f (exp, 3, M_E3l);
4428     }
4429
4430   fesetround (save_round_mode);
4431
4432   END (exp_upward);
4433 }
4434
4435
4436 static void
4437 exp10_test (void)
4438 {
4439   errno = 0;
4440   FUNC(exp10) (0);
4441   if (errno == ENOSYS)
4442     /* Function not implemented.  */
4443     return;
4444
4445   START (exp10);
4446
4447   TEST_f_f (exp10, 0, 1);
4448   TEST_f_f (exp10, minus_zero, 1);
4449
4450   TEST_f_f (exp10, plus_infty, plus_infty);
4451   TEST_f_f (exp10, minus_infty, 0);
4452   TEST_f_f (exp10, nan_value, nan_value);
4453   TEST_f_f (exp10, 3, 1000);
4454   TEST_f_f (exp10, -1, 0.1L);
4455   TEST_f_f (exp10, 36, 1.0e36L);
4456   TEST_f_f (exp10, -36, 1.0e-36L);
4457 #ifndef TEST_FLOAT
4458   TEST_f_f (exp10, 305, 1.0e305L);
4459   TEST_f_f (exp10, -305, 1.0e-305L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
4460 #endif
4461 #if defined TEST_LDOUBLE && LDBL_MAX_10_EXP >= 4932
4462   TEST_f_f (exp10, 4932, 1.0e4932L);
4463   TEST_f_f (exp10, -4932, 1.0e-4932L, UNDERFLOW_EXCEPTION);
4464 #endif
4465   TEST_f_f (exp10, 1e6, plus_infty, OVERFLOW_EXCEPTION);
4466   TEST_f_f (exp10, -1e6, 0, UNDERFLOW_EXCEPTION);
4467   TEST_f_f (exp10, max_value, plus_infty, OVERFLOW_EXCEPTION);
4468   TEST_f_f (exp10, -max_value, 0, UNDERFLOW_EXCEPTION);
4469   TEST_f_f (exp10, 0.75L, 5.62341325190349080394951039776481231L);
4470
4471   END (exp10);
4472 }
4473
4474
4475 static void
4476 exp2_test (void)
4477 {
4478   errno = 0;
4479   FUNC(exp2) (0);
4480   if (errno == ENOSYS)
4481     /* Function not implemented.  */
4482     return;
4483
4484   START (exp2);
4485
4486   TEST_f_f (exp2, 0, 1);
4487   TEST_f_f (exp2, minus_zero, 1);
4488   TEST_f_f (exp2, plus_infty, plus_infty);
4489   TEST_f_f (exp2, minus_infty, 0);
4490   TEST_f_f (exp2, nan_value, nan_value);
4491
4492   TEST_f_f (exp2, 10, 1024);
4493   TEST_f_f (exp2, -1, 0.5);
4494   TEST_f_f (exp2, 1e6, plus_infty, OVERFLOW_EXCEPTION);
4495   TEST_f_f (exp2, -1e6, 0, UNDERFLOW_EXCEPTION);
4496   TEST_f_f (exp2, max_value, plus_infty, OVERFLOW_EXCEPTION);
4497   TEST_f_f (exp2, -max_value, 0, UNDERFLOW_EXCEPTION);
4498   TEST_f_f (exp2, 0.75L, 1.68179283050742908606225095246642979L);
4499
4500   TEST_f_f (exp2, 100.5, 1.792728671193156477399422023278661496394e+30L);
4501   TEST_f_f (exp2, 127, 0x1p127);
4502   TEST_f_f (exp2, -149, 0x1p-149);
4503
4504 #ifndef TEST_FLOAT
4505   TEST_f_f (exp2, 1000.25, 1.274245659452564874772384918171765416737e+301L);
4506   TEST_f_f (exp2, 1023, 0x1p1023);
4507   TEST_f_f (exp2, -1074, 0x1p-1074);
4508 #endif
4509
4510 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
4511   TEST_f_f (exp2, 16383, 0x1p16383L);
4512   TEST_f_f (exp2, -16400, 0x1p-16400L);
4513 #endif
4514
4515   END (exp2);
4516 }
4517
4518
4519 static void
4520 expm1_test (void)
4521 {
4522   errno = 0;
4523   FUNC(expm1) (0);
4524   if (errno == ENOSYS)
4525     /* Function not implemented.  */
4526     return;
4527
4528   START (expm1);
4529
4530   TEST_f_f (expm1, 0, 0);
4531   TEST_f_f (expm1, minus_zero, minus_zero);
4532
4533 #ifndef TEST_INLINE
4534   TEST_f_f (expm1, plus_infty, plus_infty);
4535   TEST_f_f (expm1, minus_infty, -1);
4536 #endif
4537   TEST_f_f (expm1, nan_value, nan_value);
4538
4539   TEST_f_f (expm1, 1, M_El - 1.0);
4540   TEST_f_f (expm1, 0.75L, 1.11700001661267466854536981983709561L);
4541
4542   TEST_f_f (expm1, 50.0L, 5.1847055285870724640864533229334853848275e+21L);
4543
4544 #ifndef TEST_FLOAT
4545   TEST_f_f (expm1, 127.0L, 1.4302079958348104463583671072905261080748e+55L);
4546   TEST_f_f (expm1, 500.0L, 1.4035922178528374107397703328409120821806e+217L);
4547 #endif
4548
4549 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
4550   TEST_f_f (expm1, 11356.25L, 9.05128237311923300051376115753226014206e+4931L);
4551 #endif
4552
4553   TEST_f_f (expm1, -10.0, -0.9999546000702375151484644084844394493898L);
4554   TEST_f_f (expm1, -16.0, -0.9999998874648252807408854862248209398728L);
4555   TEST_f_f (expm1, -17.0, -0.9999999586006228121483334034897228104472L);
4556   TEST_f_f (expm1, -18.0, -0.9999999847700202552873715638633707664826L);
4557   TEST_f_f (expm1, -36.0, -0.9999999999999997680477169756430611687736L);
4558   TEST_f_f (expm1, -37.0, -0.9999999999999999146695237425593420572195L);
4559   TEST_f_f (expm1, -38.0, -0.9999999999999999686086720795197037129104L);
4560   TEST_f_f (expm1, -44.0, -0.9999999999999999999221886775886620348429L);
4561   TEST_f_f (expm1, -45.0, -0.9999999999999999999713748141945060635553L);
4562   TEST_f_f (expm1, -46.0, -0.9999999999999999999894693826424461876212L);
4563   TEST_f_f (expm1, -73.0, -0.9999999999999999999999999999999802074012L);
4564   TEST_f_f (expm1, -74.0, -0.9999999999999999999999999999999927187098L);
4565   TEST_f_f (expm1, -75.0, -0.9999999999999999999999999999999973213630L);
4566   TEST_f_f (expm1, -78.0, -0.9999999999999999999999999999999998666385L);
4567   TEST_f_f (expm1, -79.0, -0.9999999999999999999999999999999999509391L);
4568   TEST_f_f (expm1, -80.0, -0.9999999999999999999999999999999999819515L);
4569   TEST_f_f (expm1, -100.0, -1.0);
4570   TEST_f_f (expm1, -1000.0, -1.0);
4571   TEST_f_f (expm1, -10000.0, -1.0);
4572   TEST_f_f (expm1, -100000.0, -1.0);
4573
4574   errno = 0;
4575   TEST_f_f (expm1, 100000.0, plus_infty, OVERFLOW_EXCEPTION);
4576   check_int ("errno for expm1(large) == ERANGE", errno, ERANGE, 0, 0, 0);
4577   TEST_f_f (expm1, max_value, plus_infty, OVERFLOW_EXCEPTION);
4578   TEST_f_f (expm1, -max_value, -1);
4579
4580   END (expm1);
4581 }
4582
4583
4584 static void
4585 fabs_test (void)
4586 {
4587   START (fabs);
4588
4589   TEST_f_f (fabs, 0, 0);
4590   TEST_f_f (fabs, minus_zero, 0);
4591
4592   TEST_f_f (fabs, plus_infty, plus_infty);
4593   TEST_f_f (fabs, minus_infty, plus_infty);
4594   TEST_f_f (fabs, nan_value, nan_value);
4595
4596   TEST_f_f (fabs, 38.0, 38.0);
4597   TEST_f_f (fabs, -M_El, M_El);
4598
4599   END (fabs);
4600 }
4601
4602
4603 static void
4604 fdim_test (void)
4605 {
4606   START (fdim);
4607
4608   TEST_ff_f (fdim, 0, 0, 0);
4609   TEST_ff_f (fdim, 9, 0, 9);
4610   TEST_ff_f (fdim, 0, 9, 0);
4611   TEST_ff_f (fdim, -9, 0, 0);
4612   TEST_ff_f (fdim, 0, -9, 9);
4613
4614   TEST_ff_f (fdim, plus_infty, 9, plus_infty);
4615   TEST_ff_f (fdim, plus_infty, -9, plus_infty);
4616   TEST_ff_f (fdim, minus_infty, 9, 0);
4617   TEST_ff_f (fdim, minus_infty, -9, 0);
4618   TEST_ff_f (fdim, 9, minus_infty, plus_infty);
4619   TEST_ff_f (fdim, -9, minus_infty, plus_infty);
4620   TEST_ff_f (fdim, 9, plus_infty, 0);
4621   TEST_ff_f (fdim, -9, plus_infty, 0);
4622
4623   TEST_ff_f (fdim, 0, nan_value, nan_value);
4624   TEST_ff_f (fdim, 9, nan_value, nan_value);
4625   TEST_ff_f (fdim, -9, nan_value, nan_value);
4626   TEST_ff_f (fdim, nan_value, 9, nan_value);
4627   TEST_ff_f (fdim, nan_value, -9, nan_value);
4628   TEST_ff_f (fdim, plus_infty, nan_value, nan_value);
4629   TEST_ff_f (fdim, minus_infty, nan_value, nan_value);
4630   TEST_ff_f (fdim, nan_value, plus_infty, nan_value);
4631   TEST_ff_f (fdim, nan_value, minus_infty, nan_value);
4632   TEST_ff_f (fdim, nan_value, nan_value, nan_value);
4633
4634   TEST_ff_f (fdim, plus_infty, plus_infty, 0);
4635
4636   END (fdim);
4637 }
4638
4639
4640 static void
4641 finite_test (void)
4642 {
4643   START (finite);
4644
4645   TEST_f_b (finite, 0, 1);
4646   TEST_f_b (finite, minus_zero, 1);
4647   TEST_f_b (finite, 10, 1);
4648   TEST_f_b (finite, min_subnorm_value, 1);
4649   TEST_f_b (finite, plus_infty, 0);
4650   TEST_f_b (finite, minus_infty, 0);
4651   TEST_f_b (finite, nan_value, 0);
4652
4653   END (finite);
4654 }
4655
4656
4657 static void
4658 floor_test (void)
4659 {
4660   START (floor);
4661
4662   TEST_f_f (floor, 0.0, 0.0);
4663   TEST_f_f (floor, minus_zero, minus_zero);
4664   TEST_f_f (floor, plus_infty, plus_infty);
4665   TEST_f_f (floor, minus_infty, minus_infty);
4666   TEST_f_f (floor, nan_value, nan_value);
4667
4668   TEST_f_f (floor, M_PIl, 3.0);
4669   TEST_f_f (floor, -M_PIl, -4.0);
4670
4671   TEST_f_f (floor, 0.1, 0.0);
4672   TEST_f_f (floor, 0.25, 0.0);
4673   TEST_f_f (floor, 0.625, 0.0);
4674   TEST_f_f (floor, -0.1, -1.0);
4675   TEST_f_f (floor, -0.25, -1.0);
4676   TEST_f_f (floor, -0.625, -1.0);
4677
4678 #ifdef TEST_LDOUBLE
4679   /* The result can only be represented in long double.  */
4680   TEST_f_f (floor, 4503599627370495.5L, 4503599627370495.0L);
4681   TEST_f_f (floor, 4503599627370496.25L, 4503599627370496.0L);
4682   TEST_f_f (floor, 4503599627370496.5L, 4503599627370496.0L);
4683   TEST_f_f (floor, 4503599627370496.75L, 4503599627370496.0L);
4684   TEST_f_f (floor, 4503599627370497.5L, 4503599627370497.0L);
4685 # if LDBL_MANT_DIG > 100
4686   TEST_f_f (floor, 4503599627370494.5000000000001L, 4503599627370494.0L);
4687   TEST_f_f (floor, 4503599627370495.5000000000001L, 4503599627370495.0L);
4688   TEST_f_f (floor, 4503599627370496.5000000000001L, 4503599627370496.0L);
4689 # endif
4690
4691   TEST_f_f (floor, -4503599627370495.5L, -4503599627370496.0L);
4692   TEST_f_f (floor, -4503599627370496.25L, -4503599627370497.0L);
4693   TEST_f_f (floor, -4503599627370496.5L, -4503599627370497.0L);
4694   TEST_f_f (floor, -4503599627370496.75L, -4503599627370497.0L);
4695   TEST_f_f (floor, -4503599627370497.5L, -4503599627370498.0L);
4696 # if LDBL_MANT_DIG > 100
4697   TEST_f_f (floor, -4503599627370494.5000000000001L, -4503599627370495.0L);
4698   TEST_f_f (floor, -4503599627370495.5000000000001L, -4503599627370496.0L);
4699   TEST_f_f (floor, -4503599627370496.5000000000001L, -4503599627370497.0L);
4700 # endif
4701
4702   TEST_f_f (floor, 9007199254740991.5L, 9007199254740991.0L);
4703   TEST_f_f (floor, 9007199254740992.25L, 9007199254740992.0L);
4704   TEST_f_f (floor, 9007199254740992.5L, 9007199254740992.0L);
4705   TEST_f_f (floor, 9007199254740992.75L, 9007199254740992.0L);
4706   TEST_f_f (floor, 9007199254740993.5L, 9007199254740993.0L);
4707
4708 # if LDBL_MANT_DIG > 100
4709   TEST_f_f (floor, 9007199254740991.0000000000001L, 9007199254740991.0L);
4710   TEST_f_f (floor, 9007199254740992.0000000000001L, 9007199254740992.0L);
4711   TEST_f_f (floor, 9007199254740993.0000000000001L, 9007199254740993.0L);
4712   TEST_f_f (floor, 9007199254740991.5000000000001L, 9007199254740991.0L);
4713   TEST_f_f (floor, 9007199254740992.5000000000001L, 9007199254740992.0L);
4714   TEST_f_f (floor, 9007199254740993.5000000000001L, 9007199254740993.0L);
4715 # endif
4716
4717   TEST_f_f (floor, -9007199254740991.5L, -9007199254740992.0L);
4718   TEST_f_f (floor, -9007199254740992.25L, -9007199254740993.0L);
4719   TEST_f_f (floor, -9007199254740992.5L, -9007199254740993.0L);
4720   TEST_f_f (floor, -9007199254740992.75L, -9007199254740993.0L);
4721   TEST_f_f (floor, -9007199254740993.5L, -9007199254740994.0L);
4722
4723 # if LDBL_MANT_DIG > 100
4724   TEST_f_f (floor, -9007199254740991.0000000000001L, -9007199254740992.0L);
4725   TEST_f_f (floor, -9007199254740992.0000000000001L, -9007199254740993.0L);
4726   TEST_f_f (floor, -9007199254740993.0000000000001L, -9007199254740994.0L);
4727   TEST_f_f (floor, -9007199254740991.5000000000001L, -9007199254740992.0L);
4728   TEST_f_f (floor, -9007199254740992.5000000000001L, -9007199254740993.0L);
4729   TEST_f_f (floor, -9007199254740993.5000000000001L, -9007199254740994.0L);
4730 # endif
4731
4732   TEST_f_f (floor, 72057594037927935.5L, 72057594037927935.0L);
4733   TEST_f_f (floor, 72057594037927936.25L, 72057594037927936.0L);
4734   TEST_f_f (floor, 72057594037927936.5L, 72057594037927936.0L);
4735   TEST_f_f (floor, 72057594037927936.75L, 72057594037927936.0L);
4736   TEST_f_f (floor, 72057594037927937.5L, 72057594037927937.0L);
4737
4738   TEST_f_f (floor, -72057594037927935.5L, -72057594037927936.0L);
4739   TEST_f_f (floor, -72057594037927936.25L, -72057594037927937.0L);
4740   TEST_f_f (floor, -72057594037927936.5L, -72057594037927937.0L);
4741   TEST_f_f (floor, -72057594037927936.75L, -72057594037927937.0L);
4742   TEST_f_f (floor, -72057594037927937.5L, -72057594037927938.0L);
4743
4744   TEST_f_f (floor, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
4745   TEST_f_f (floor, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
4746   TEST_f_f (floor, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
4747   TEST_f_f (floor, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
4748   TEST_f_f (floor, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
4749
4750   TEST_f_f (floor, 0xf.ffffffffffffff8p+47L, 0xf.fffffffffffep+47L);
4751   TEST_f_f (floor, -0x8.000000000000004p+48L, -0x8.000000000001p+48L);
4752 #endif
4753
4754   END (floor);
4755 }
4756
4757
4758 static void
4759 fma_test (void)
4760 {
4761   START (fma);
4762
4763   TEST_fff_f (fma, 1.0, 2.0, 3.0, 5.0);
4764   TEST_fff_f (fma, nan_value, 2.0, 3.0, nan_value);
4765   TEST_fff_f (fma, 1.0, nan_value, 3.0, nan_value);
4766   TEST_fff_f (fma, 1.0, 2.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
4767   TEST_fff_f (fma, plus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
4768   TEST_fff_f (fma, minus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
4769   TEST_fff_f (fma, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
4770   TEST_fff_f (fma, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
4771   TEST_fff_f (fma, plus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
4772   TEST_fff_f (fma, minus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
4773   TEST_fff_f (fma, 0.0, plus_infty, 1.0, nan_value, INVALID_EXCEPTION);
4774   TEST_fff_f (fma, 0.0, minus_infty, 1.0, nan_value, INVALID_EXCEPTION);
4775
4776   TEST_fff_f (fma, plus_infty, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
4777   TEST_fff_f (fma, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
4778   TEST_fff_f (fma, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
4779   TEST_fff_f (fma, minus_infty, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
4780   TEST_fff_f (fma, plus_infty, 3.5L, minus_infty, nan_value, INVALID_EXCEPTION);
4781   TEST_fff_f (fma, minus_infty, -7.5L, minus_infty, nan_value, INVALID_EXCEPTION);
4782   TEST_fff_f (fma, -13.5L, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
4783   TEST_fff_f (fma, minus_infty, 7.5L, plus_infty, nan_value, INVALID_EXCEPTION);
4784
4785   TEST_fff_f (fma, 1.25L, 0.75L, 0.0625L, 1.0L);
4786
4787   FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
4788                          LDBL_MAX, DBL_MAX, FLT_MAX);
4789   TEST_fff_f (fma, -fltmax, -fltmax, minus_infty, minus_infty);
4790   TEST_fff_f (fma, fltmax / 2, fltmax / 2, minus_infty, minus_infty);
4791   TEST_fff_f (fma, -fltmax, fltmax, plus_infty, plus_infty);
4792   TEST_fff_f (fma, fltmax / 2, -fltmax / 4, plus_infty, plus_infty);
4793   TEST_fff_f (fma, plus_infty, 4, plus_infty, plus_infty);
4794   TEST_fff_f (fma, 2, minus_infty, minus_infty, minus_infty);
4795   TEST_fff_f (fma, minus_infty, minus_infty, plus_infty, plus_infty);
4796   TEST_fff_f (fma, plus_infty, minus_infty, minus_infty, minus_infty);
4797
4798   TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero);
4799   TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, plus_zero);
4800   TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, plus_zero);
4801   TEST_fff_f (fma, plus_zero, minus_zero, minus_zero, minus_zero);
4802   TEST_fff_f (fma, minus_zero, plus_zero, plus_zero, plus_zero);
4803   TEST_fff_f (fma, minus_zero, plus_zero, minus_zero, minus_zero);
4804   TEST_fff_f (fma, minus_zero, minus_zero, plus_zero, plus_zero);
4805   TEST_fff_f (fma, minus_zero, minus_zero, minus_zero, plus_zero);
4806   TEST_fff_f (fma, 1.0, plus_zero, plus_zero, plus_zero);
4807   TEST_fff_f (fma, 1.0, plus_zero, minus_zero, plus_zero);
4808   TEST_fff_f (fma, 1.0, minus_zero, plus_zero, plus_zero);
4809   TEST_fff_f (fma, 1.0, minus_zero, minus_zero, minus_zero);
4810   TEST_fff_f (fma, -1.0, plus_zero, plus_zero, plus_zero);
4811   TEST_fff_f (fma, -1.0, plus_zero, minus_zero, minus_zero);
4812   TEST_fff_f (fma, -1.0, minus_zero, plus_zero, plus_zero);
4813   TEST_fff_f (fma, -1.0, minus_zero, minus_zero, plus_zero);
4814   TEST_fff_f (fma, plus_zero, 1.0, plus_zero, plus_zero);
4815   TEST_fff_f (fma, plus_zero, 1.0, minus_zero, plus_zero);
4816   TEST_fff_f (fma, plus_zero, -1.0, plus_zero, plus_zero);
4817   TEST_fff_f (fma, plus_zero, -1.0, minus_zero, minus_zero);
4818   TEST_fff_f (fma, minus_zero, 1.0, plus_zero, plus_zero);
4819   TEST_fff_f (fma, minus_zero, 1.0, minus_zero, minus_zero);
4820   TEST_fff_f (fma, minus_zero, -1.0, plus_zero, plus_zero);
4821   TEST_fff_f (fma, minus_zero, -1.0, minus_zero, plus_zero);
4822
4823   TEST_fff_f (fma, 1.0, 1.0, -1.0, plus_zero);
4824   TEST_fff_f (fma, 1.0, -1.0, 1.0, plus_zero);
4825   TEST_fff_f (fma, -1.0, 1.0, 1.0, plus_zero);
4826   TEST_fff_f (fma, -1.0, -1.0, -1.0, plus_zero);
4827
4828   TEST_fff_f (fma, min_value, min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4829   TEST_fff_f (fma, min_value, min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4830   TEST_fff_f (fma, min_value, -min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4831   TEST_fff_f (fma, min_value, -min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4832   TEST_fff_f (fma, -min_value, min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4833   TEST_fff_f (fma, -min_value, min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4834   TEST_fff_f (fma, -min_value, -min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4835   TEST_fff_f (fma, -min_value, -min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4836
4837   TEST_fff_f (fma, max_value, max_value, min_value, plus_infty, OVERFLOW_EXCEPTION);
4838   TEST_fff_f (fma, max_value, max_value, -min_value, plus_infty, OVERFLOW_EXCEPTION);
4839   TEST_fff_f (fma, max_value, -max_value, min_value, minus_infty, OVERFLOW_EXCEPTION);
4840   TEST_fff_f (fma, max_value, -max_value, -min_value, minus_infty, OVERFLOW_EXCEPTION);
4841   TEST_fff_f (fma, -max_value, max_value, min_value, minus_infty, OVERFLOW_EXCEPTION);
4842   TEST_fff_f (fma, -max_value, max_value, -min_value, minus_infty, OVERFLOW_EXCEPTION);
4843   TEST_fff_f (fma, -max_value, -max_value, min_value, plus_infty, OVERFLOW_EXCEPTION);
4844   TEST_fff_f (fma, -max_value, -max_value, -min_value, plus_infty, OVERFLOW_EXCEPTION);
4845
4846 #if defined (TEST_FLOAT) && FLT_MANT_DIG == 24
4847   TEST_fff_f (fma, 0x1.7ff8p+13, 0x1.000002p+0, 0x1.ffffp-24, 0x1.7ff802p+13);
4848   TEST_fff_f (fma, 0x1.fffp+0, 0x1.00001p+0, -0x1.fffp+0, 0x1.fffp-20);
4849   TEST_fff_f (fma, 0x1.9abcdep+127, 0x0.9abcdep-126, -0x1.f08948p+0, 0x1.bb421p-25);
4850   TEST_fff_f (fma, 0x1.9abcdep+100, 0x0.9abcdep-126, -0x1.f08948p-27, 0x1.bb421p-52);
4851   TEST_fff_f (fma, 0x1.fffffep+127, 0x1.001p+0, -0x1.fffffep+127, 0x1.fffffep+115);
4852   TEST_fff_f (fma, -0x1.fffffep+127, 0x1.fffffep+0, 0x1.fffffep+127, -0x1.fffffap+127);
4853   TEST_fff_f (fma, 0x1.fffffep+127, 2.0, -0x1.fffffep+127, 0x1.fffffep+127);
4854   TEST_fff_f (fma, 0x1.4p-126, 0x1.000004p-1, 0x1p-128, 0x1.c00004p-127, UNDERFLOW_EXCEPTION);
4855   TEST_fff_f (fma, -0x1.4p-126, 0x1.000004p-1, -0x1p-128, -0x1.c00004p-127, UNDERFLOW_EXCEPTION);
4856   TEST_fff_f (fma, 0x1.fffff8p-126, 0x1.000002p-1, 0x1p-149, 0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4857   TEST_fff_f (fma, -0x1.fffff8p-126, 0x1.000002p-1, -0x1p-149, -0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4858   TEST_fff_f (fma, 0x1p-149, 0x1p-1, 0x0.fffffep-126, 0x1p-126, UNDERFLOW_EXCEPTION);
4859   TEST_fff_f (fma, -0x1p-149, 0x1p-1, -0x0.fffffep-126, -0x1p-126, UNDERFLOW_EXCEPTION);
4860   TEST_fff_f (fma, 0x1p-149, 0x1.1p-1, 0x0.fffffep-126, 0x1p-126, UNDERFLOW_EXCEPTION);
4861   TEST_fff_f (fma, -0x1p-149, 0x1.1p-1, -0x0.fffffep-126, -0x1p-126, UNDERFLOW_EXCEPTION);
4862   TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p127, 0x1p127);
4863   TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p127, 0x1p127);
4864   TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p127, -0x1p127);
4865   TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p127, -0x1p127);
4866   TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-126, 0x1p-126);
4867   TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-126, 0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4868   TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-126, -0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4869   TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-126, -0x1p-126);
4870   TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4871   TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4872   TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4873   TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
4874   TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-149, 0x1p-149, UNDERFLOW_EXCEPTION);
4875   TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-149, 0x1p-149, UNDERFLOW_EXCEPTION);
4876   TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-149, -0x1p-149, UNDERFLOW_EXCEPTION);
4877   TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-149, -0x1p-149, UNDERFLOW_EXCEPTION);
4878   TEST_fff_f (fma, 0x0.fffp0, 0x0.fffp0, -0x0.ffep0, 0x1p-24);
4879   TEST_fff_f (fma, 0x0.fffp0, -0x0.fffp0, 0x0.ffep0, -0x1p-24);
4880   TEST_fff_f (fma, -0x0.fffp0, 0x0.fffp0, 0x0.ffep0, -0x1p-24);
4881   TEST_fff_f (fma, -0x0.fffp0, -0x0.fffp0, -0x0.ffep0, 0x1p-24);
4882   TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p127, 0x1p127);
4883   TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p127, 0x1p127);
4884   TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p127, -0x1p127);
4885   TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p127, -0x1p127);
4886   TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p103, 0x1p103);
4887   TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p103, 0x1p103);
4888   TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p103, -0x1p103);
4889   TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p103, -0x1p103);
4890 #endif
4891 #if defined (TEST_DOUBLE) && DBL_MANT_DIG == 53
4892   TEST_fff_f (fma, 0x1.7fp+13, 0x1.0000000000001p+0, 0x1.ffep-48, 0x1.7f00000000001p+13);
4893   TEST_fff_f (fma, 0x1.fffp+0, 0x1.0000000000001p+0, -0x1.fffp+0, 0x1.fffp-52);
4894   TEST_fff_f (fma, 0x1.0000002p+0, 0x1.ffffffcp-1, 0x1p-300, 1.0);
4895   TEST_fff_f (fma, 0x1.0000002p+0, 0x1.ffffffcp-1, -0x1p-300, 0x1.fffffffffffffp-1);
4896   TEST_fff_f (fma, 0x1.deadbeef2feedp+1023, 0x0.deadbeef2feedp-1022, -0x1.a05f8c01a4bfbp+1, 0x1.0989687bc9da4p-53);
4897   TEST_fff_f (fma, 0x1.deadbeef2feedp+900, 0x0.deadbeef2feedp-1022, -0x1.a05f8c01a4bfbp-122, 0x1.0989687bc9da4p-176);
4898   TEST_fff_f (fma, 0x1.fffffffffffffp+1023, 0x1.001p+0, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+1011);
4899   TEST_fff_f (fma, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+0, 0x1.fffffffffffffp+1023, -0x1.ffffffffffffdp+1023);
4900   TEST_fff_f (fma, 0x1.fffffffffffffp+1023, 2.0, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+1023);
4901   TEST_fff_f (fma, 0x1.6a09e667f3bccp-538, 0x1.6a09e667f3bccp-538, 0.0, 0.0, UNDERFLOW_EXCEPTION);
4902   TEST_fff_f (fma, 0x1.deadbeef2feedp-495, 0x1.deadbeef2feedp-495, -0x1.bf86a5786a574p-989, 0x0.0000042625a1fp-1022, UNDERFLOW_EXCEPTION);
4903   TEST_fff_f (fma, 0x1.deadbeef2feedp-503, 0x1.deadbeef2feedp-503, -0x1.bf86a5786a574p-1005, 0x0.0000000004262p-1022, UNDERFLOW_EXCEPTION);
4904   TEST_fff_f (fma, 0x1p-537, 0x1p-538, 0x1p-1074, 0x0.0000000000002p-1022, UNDERFLOW_EXCEPTION);
4905   TEST_fff_f (fma, 0x1.7fffff8p-968, 0x1p-106, 0x0.000001p-1022, 0x0.0000010000001p-1022, UNDERFLOW_EXCEPTION);
4906   TEST_fff_f (fma, 0x1.4000004p-967, 0x1p-106, 0x0.000001p-1022, 0x0.0000010000003p-1022, UNDERFLOW_EXCEPTION);
4907   TEST_fff_f (fma, 0x1.4p-967, -0x1p-106, -0x0.000001p-1022, -0x0.0000010000002p-1022, UNDERFLOW_EXCEPTION);
4908   TEST_fff_f (fma, -0x1.19cab66d73e17p-959, 0x1.c7108a8c5ff51p-107, -0x0.80b0ad65d9b64p-1022, -0x0.80b0ad65d9d59p-1022, UNDERFLOW_EXCEPTION);
4909   TEST_fff_f (fma, -0x1.d2eaed6e8e9d3p-979, -0x1.4e066c62ac9ddp-63, -0x0.9245e6b003454p-1022, -0x0.9245c09c5fb5dp-1022, UNDERFLOW_EXCEPTION);
4910   TEST_fff_f (fma, 0x1.153d650bb9f06p-907, 0x1.2d01230d48407p-125, -0x0.b278d5acfc3cp-1022, -0x0.b22757123bbe9p-1022, UNDERFLOW_EXCEPTION);
4911   TEST_fff_f (fma, -0x1.fffffffffffffp-711, 0x1.fffffffffffffp-275, 0x1.fffffe00007ffp-983, 0x1.7ffffe00007ffp-983);
4912   TEST_fff_f (fma, 0x1.4p-1022, 0x1.0000000000002p-1, 0x1p-1024, 0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
4913   TEST_fff_f (fma, -0x1.4p-1022, 0x1.0000000000002p-1, -0x1p-1024, -0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
4914   TEST_fff_f (fma, 0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, 0x1p-1074, 0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4915   TEST_fff_f (fma, -0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, -0x1p-1074, -0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4916   TEST_fff_f (fma, 0x1p-1074, 0x1p-1, 0x0.fffffffffffffp-1022, 0x1p-1022, UNDERFLOW_EXCEPTION);
4917   TEST_fff_f (fma, -0x1p-1074, 0x1p-1, -0x0.fffffffffffffp-1022, -0x1p-1022, UNDERFLOW_EXCEPTION);
4918   TEST_fff_f (fma, 0x1p-1074, 0x1.1p-1, 0x0.fffffffffffffp-1022, 0x1p-1022, UNDERFLOW_EXCEPTION);
4919   TEST_fff_f (fma, -0x1p-1074, 0x1.1p-1, -0x0.fffffffffffffp-1022, -0x1p-1022, UNDERFLOW_EXCEPTION);
4920   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p1023, 0x1p1023);
4921   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p1023, 0x1p1023);
4922   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p1023, -0x1p1023);
4923   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p1023, -0x1p1023);
4924   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1022, 0x1p-1022);
4925   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1022, 0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4926   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1022, -0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4927   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1022, -0x1p-1022);
4928   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4929   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4930   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4931   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
4932   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1074, 0x1p-1074, UNDERFLOW_EXCEPTION);
4933   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1074, 0x1p-1074, UNDERFLOW_EXCEPTION);
4934   TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1074, -0x1p-1074, UNDERFLOW_EXCEPTION);
4935   TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1074, -0x1p-1074, UNDERFLOW_EXCEPTION);
4936   TEST_fff_f (fma, 0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
4937   TEST_fff_f (fma, 0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
4938   TEST_fff_f (fma, -0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
4939   TEST_fff_f (fma, -0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
4940   TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p1023, 0x1p1023);
4941   TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p1023, 0x1p1023);
4942   TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p1023, -0x1p1023);
4943   TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p1023, -0x1p1023);
4944   TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p970, 0x1p970);
4945   TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p970, 0x1p970);
4946   TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p970, -0x1p970);
4947   TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p970, -0x1p970);
4948 #endif
4949 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 64
4950   TEST_fff_f (fma, -0x8.03fcp+3696L, 0xf.fffffffffffffffp-6140L, 0x8.3ffffffffffffffp-2450L, -0x8.01ecp-2440L);
4951   TEST_fff_f (fma, 0x9.fcp+2033L, -0x8.000e1f000ff800fp-3613L, -0xf.fffffffffffc0ffp-1579L, -0xd.fc119fb093ed092p-1577L);
4952   TEST_fff_f (fma, 0xc.7fc000003ffffffp-1194L, 0x8.1e0003fffffffffp+15327L, -0x8.fffep+14072L, 0xc.ae9f164020effffp+14136L);
4953   TEST_fff_f (fma, -0x8.0001fc000000003p+1798L, 0xcp-2230L, 0x8.f7e000000000007p-468L, -0xc.0002f9ffee10404p-429L);
4954   TEST_fff_f (fma, 0xc.0000000000007ffp+10130L, -0x8.000000000000001p+4430L, 0xc.07000000001ffffp+14513L, -0xb.fffffffffffd7e4p+14563L);
4955   TEST_fff_f (fma, 0xb.ffffp-4777L, 0x8.000000fffffffffp-11612L, -0x0.3800fff8p-16385L, 0x5.c7fe80c7ffeffffp-16385L, UNDERFLOW_EXCEPTION);
4956   TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000004p-1L, 0x1p-16384L, 0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
4957   TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000004p-1L, -0x1p-16384L, -0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
4958   TEST_fff_f (fma, 0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, 0x1p-16445L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4959   TEST_fff_f (fma, -0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, -0x1p-16445L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4960   TEST_fff_f (fma, 0x1p-16445L, 0x1p-1L, 0x0.fffffffffffffffep-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
4961   TEST_fff_f (fma, -0x1p-16445L, 0x1p-1L, -0x0.fffffffffffffffep-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
4962   TEST_fff_f (fma, 0x1p-16445L, 0x1.1p-1L, 0x0.fffffffffffffffep-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
4963   TEST_fff_f (fma, -0x1p-16445L, 0x1.1p-1L, -0x0.fffffffffffffffep-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
4964   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p16383L, 0x1p16383L);
4965   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p16383L, 0x1p16383L);
4966   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p16383L, -0x1p16383L);
4967   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p16383L, -0x1p16383L);
4968   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16382L, 0x1p-16382L);
4969   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4970   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
4971   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16382L, -0x1p-16382L);
4972   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4973   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4974   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4975   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
4976   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, UNDERFLOW_EXCEPTION);
4977   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16445L, 0x1p-16445L, UNDERFLOW_EXCEPTION);
4978   TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, UNDERFLOW_EXCEPTION);
4979   TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, -0x1p-16445L, UNDERFLOW_EXCEPTION);
4980   TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
4981   TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
4982   TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
4983   TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
4984   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16383L, 0x1p16383L);
4985   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16383L, 0x1p16383L);
4986   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16383L, -0x1p16383L);
4987   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16383L, -0x1p16383L);
4988   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16319L, 0x1p16319L);
4989   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16319L, 0x1p16319L);
4990   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16319L, -0x1p16319L);
4991   TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16319L, -0x1p16319L);
4992 #endif
4993 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 113
4994   TEST_fff_f (fma, 0x1.bb2de33e02ccbbfa6e245a7c1f71p-2584L, -0x1.6b500daf0580d987f1bc0cadfcddp-13777L, 0x1.613cd91d9fed34b33820e5ab9d8dp-16378L, -0x1.3a79fb50eb9ce887cffa0f09bd9fp-16360L);
4995   TEST_fff_f (fma, -0x1.f949b880cacb0f0c61540105321dp-5954L, -0x1.3876cec84b4140f3bd6198731b7ep-10525L, -0x0.a5dc1c6cfbc498c54fb0b504bf19p-16382L, -0x0.a5dc1c6cfbc498c54fb0b5038abbp-16382L, UNDERFLOW_EXCEPTION);
4996   TEST_fff_f (fma, -0x1.0000fffffffffp-16221L, 0x1.0000001fffff8007fep-239L, 0x0.ff87ffffffffffffe000003fffffp-16382L, 0x0.ff87ffffffffffffdffc003bff7fp-16382L, UNDERFLOW_EXCEPTION);
4997   TEST_fff_f (fma, -0x1.ac79c9376ef447f3827c9e9de008p-2228L, -0x1.5ba830022b6139e21fbe7270cad8p-6314L, 0x1.e8282b6a26bb6a9daf5c8e73e9f9p-8616L, 0x1.22f14a0253878a730cd1aee373adp-8541L);
4998   TEST_fff_f (fma, -0x1.c69749ec574caaa2ab8e97ddb9f3p+2652L, 0x1.f34235ff9d095449c29b4831b62dp+3311L, 0x1.fbe4302df23354dbd0c4d3cfe606p+5879L, -0x1.bb473bfdfb7a6e18886ce6e57eafp+5964L);
4999   TEST_fff_f (fma, -0x1.ca8835fc6ecfb5398625fc891be5p-1686L, 0x1.621e1972bbe2180e5be9dd7d8df5p-7671L, -0x1.7d2d21b73b52cf20dec2a83902a4p-9395L, -0x1.3d2322191c9c88bc68a62ab8042cp-9356L);
5000   TEST_fff_f (fma, -0x1.55cff679ec49c2541fab41fc843ep-11819L, 0x1.e60e9f464f9e8df0509647c7c971p+12325L, 0x1.eaa2a7649d765c2f564f7a5beca7p+454L, -0x1.447e29fa7e406a285f4e350fcf86p+507L);
5001   TEST_fff_f (fma, 0x1.f0e7b1454908576f2537d863cf9bp+11432L, 0x1.cdce52f09d4ca76e68706f34b5d5p-1417L, -0x1.2e986187c70f146235ea2066e486p+9979L, 0x1.c030dad3cc5643f3dd0f5619f661p+10016L);
5002   TEST_fff_f (fma, 0x1.f102f7da4a57a3a4aab620e29452p-3098L, -0x1.cc06a4ff40248f9e2dcc4b6afd84p-11727L, 0x1.d512a11126b5ac8ed8973b8580c8p-14849L, -0x1.be8f1cf737ab4d1c31c54f5ec23bp-14824L);
5003   TEST_fff_f (fma, -0x1.fc47ac7434b993cd8dcb2b431f25p-3816L, 0x1.fbc9750da8468852d84558e1db6dp-5773L, -0x1.00a98abf783f75c40fe5b7a37d86p-9607L, -0x1.f81917b166f45e763cfcc057e2adp-9588L);
5004   TEST_fff_f (fma, 0x1.00000000000007ffffffffffffffp-9045L, -0x1.ffffffffffff80000001ffffffffp+4773L, -0x1.f8p-4316L, -0x1.00000000000f88000000fffffdffp-4271L);
5005   TEST_fff_f (fma, 0x1.4e922764c90701d4a2f21d01893dp-8683L, -0x1.955a12e2d7c9447c27fa022fc865p+212L, -0x1.e9634462eaef96528b90b6944578p-8521L, -0x1.08e1783184a371943d3598e10865p-8470L);
5006   TEST_fff_f (fma, 0x1.801181509c03bdbef10d6165588cp-15131L, 0x1.ad86f8e57d3d40bfa8007780af63p-368L, -0x1.6e9df0dab1c9f1d7a6043c390741p-15507L, 0x1.417c9b2b15e2ad57dc9e0e920844p-15498L);
5007   TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, 0x1p-16384L, 0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
5008   TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, -0x1p-16384L, -0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
5009   TEST_fff_f (fma, 0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, 0x1p-16494L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5010   TEST_fff_f (fma, -0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, -0x1p-16494L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5011   TEST_fff_f (fma, 0x1p-16494L, 0x1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
5012   TEST_fff_f (fma, -0x1p-16494L, 0x1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
5013   TEST_fff_f (fma, 0x1p-16494L, 0x1.1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
5014   TEST_fff_f (fma, -0x1p-16494L, 0x1.1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
5015   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p16383L, 0x1p16383L);
5016   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p16383L, 0x1p16383L);
5017   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p16383L, -0x1p16383L);
5018   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p16383L, -0x1p16383L);
5019   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16382L, 0x1p-16382L);
5020   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5021   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5022   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16382L, -0x1p-16382L);
5023   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-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, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5026   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5027   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, UNDERFLOW_EXCEPTION);
5028   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16494L, 0x1p-16494L, UNDERFLOW_EXCEPTION);
5029   TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, UNDERFLOW_EXCEPTION);
5030   TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, -0x1p-16494L, UNDERFLOW_EXCEPTION);
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, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5034   TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5035   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1p16383L);
5036   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1p16383L);
5037   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1p16383L);
5038   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1p16383L);
5039   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1p16319L);
5040   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1p16319L);
5041   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L);
5042   TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L);
5043 #endif
5044
5045   END (fma);
5046 }
5047
5048
5049 static void
5050 fma_test_towardzero (void)
5051 {
5052   int save_round_mode;
5053   START (fma_towardzero);
5054
5055   save_round_mode = fegetround ();
5056
5057   if (!fesetround (FE_TOWARDZERO))
5058     {
5059       TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero);
5060       TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, plus_zero);
5061       TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, plus_zero);
5062       TEST_fff_f (fma, plus_zero, minus_zero, minus_zero, minus_zero);
5063       TEST_fff_f (fma, minus_zero, plus_zero, plus_zero, plus_zero);
5064       TEST_fff_f (fma, minus_zero, plus_zero, minus_zero, minus_zero);
5065       TEST_fff_f (fma, minus_zero, minus_zero, plus_zero, plus_zero);
5066       TEST_fff_f (fma, minus_zero, minus_zero, minus_zero, plus_zero);
5067       TEST_fff_f (fma, 1.0, plus_zero, plus_zero, plus_zero);
5068       TEST_fff_f (fma, 1.0, plus_zero, minus_zero, plus_zero);
5069       TEST_fff_f (fma, 1.0, minus_zero, plus_zero, plus_zero);
5070       TEST_fff_f (fma, 1.0, minus_zero, minus_zero, minus_zero);
5071       TEST_fff_f (fma, -1.0, plus_zero, plus_zero, plus_zero);
5072       TEST_fff_f (fma, -1.0, plus_zero, minus_zero, minus_zero);
5073       TEST_fff_f (fma, -1.0, minus_zero, plus_zero, plus_zero);
5074       TEST_fff_f (fma, -1.0, minus_zero, minus_zero, plus_zero);
5075       TEST_fff_f (fma, plus_zero, 1.0, plus_zero, plus_zero);
5076       TEST_fff_f (fma, plus_zero, 1.0, minus_zero, plus_zero);
5077       TEST_fff_f (fma, plus_zero, -1.0, plus_zero, plus_zero);
5078       TEST_fff_f (fma, plus_zero, -1.0, minus_zero, minus_zero);
5079       TEST_fff_f (fma, minus_zero, 1.0, plus_zero, plus_zero);
5080       TEST_fff_f (fma, minus_zero, 1.0, minus_zero, minus_zero);
5081       TEST_fff_f (fma, minus_zero, -1.0, plus_zero, plus_zero);
5082       TEST_fff_f (fma, minus_zero, -1.0, minus_zero, plus_zero);
5083
5084       TEST_fff_f (fma, 1.0, 1.0, -1.0, plus_zero);
5085       TEST_fff_f (fma, 1.0, -1.0, 1.0, plus_zero);
5086       TEST_fff_f (fma, -1.0, 1.0, 1.0, plus_zero);
5087       TEST_fff_f (fma, -1.0, -1.0, -1.0, plus_zero);
5088
5089       TEST_fff_f (fma, min_value, min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
5090       TEST_fff_f (fma, min_value, min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
5091       TEST_fff_f (fma, min_value, -min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
5092       TEST_fff_f (fma, min_value, -min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
5093       TEST_fff_f (fma, -min_value, min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
5094       TEST_fff_f (fma, -min_value, min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
5095       TEST_fff_f (fma, -min_value, -min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
5096       TEST_fff_f (fma, -min_value, -min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
5097
5098 #if !(defined TEST_LDOUBLE && LDBL_MANT_DIG == 106) /* Bug 13304.  */
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, -max_value, OVERFLOW_EXCEPTION);
5102       TEST_fff_f (fma, max_value, -max_value, -min_value, -max_value, OVERFLOW_EXCEPTION);
5103       TEST_fff_f (fma, -max_value, max_value, min_value, -max_value, OVERFLOW_EXCEPTION);
5104       TEST_fff_f (fma, -max_value, max_value, -min_value, -max_value, 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 #endif
5108
5109 #if defined (TEST_FLOAT) && FLT_MANT_DIG == 24
5110       TEST_fff_f (fma, 0x1.4p-126, 0x1.000004p-1, 0x1p-128, 0x1.c00004p-127, UNDERFLOW_EXCEPTION);
5111       TEST_fff_f (fma, -0x1.4p-126, 0x1.000004p-1, -0x1p-128, -0x1.c00004p-127, UNDERFLOW_EXCEPTION);
5112       TEST_fff_f (fma, 0x1.fffff8p-126, 0x1.000002p-1, 0x1p-149, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5113       TEST_fff_f (fma, -0x1.fffff8p-126, 0x1.000002p-1, -0x1p-149, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5114       TEST_fff_f (fma, 0x1p-149, 0x1p-1, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5115       TEST_fff_f (fma, -0x1p-149, 0x1p-1, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5116       TEST_fff_f (fma, 0x1p-149, 0x1.1p-1, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5117       TEST_fff_f (fma, -0x1p-149, 0x1.1p-1, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5118       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p127, 0x1p127);
5119       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p127, 0x0.ffffffp127);
5120       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p127, -0x0.ffffffp127);
5121       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p127, -0x1p127);
5122       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-126, 0x1p-126);
5123       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5124       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5125       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-126, -0x1p-126);
5126       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5127       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x0.fffffep-126, 0x0.fffffcp-126, UNDERFLOW_EXCEPTION);
5128       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x0.fffffep-126, -0x0.fffffcp-126, UNDERFLOW_EXCEPTION);
5129       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5130       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-149, 0x1p-149, UNDERFLOW_EXCEPTION);
5131       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-149, plus_zero, UNDERFLOW_EXCEPTION);
5132       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-149, minus_zero, UNDERFLOW_EXCEPTION);
5133       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-149, -0x1p-149, UNDERFLOW_EXCEPTION);
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, -0x0.fffp0, -0x0.fffp0, -0x0.ffep0, 0x1p-24);
5138       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p127, 0x1p127);
5139       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p127, 0x0.ffffffp127);
5140       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p127, -0x0.ffffffp127);
5141       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p127, -0x1p127);
5142       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p103, 0x1p103);
5143       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p103, 0x0.ffffffp103);
5144       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p103, -0x0.ffffffp103);
5145       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p103, -0x1p103);
5146 #endif
5147 #if defined (TEST_DOUBLE) && DBL_MANT_DIG == 53
5148       TEST_fff_f (fma, 0x1.4p-1022, 0x1.0000000000002p-1, 0x1p-1024, 0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
5149       TEST_fff_f (fma, -0x1.4p-1022, 0x1.0000000000002p-1, -0x1p-1024, -0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
5150       TEST_fff_f (fma, 0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, 0x1p-1074, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5151       TEST_fff_f (fma, -0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, -0x1p-1074, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5152       TEST_fff_f (fma, 0x1p-1074, 0x1p-1, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5153       TEST_fff_f (fma, -0x1p-1074, 0x1p-1, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5154       TEST_fff_f (fma, 0x1p-1074, 0x1.1p-1, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5155       TEST_fff_f (fma, -0x1p-1074, 0x1.1p-1, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5156       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p1023, 0x1p1023);
5157       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p1023, 0x0.fffffffffffff8p1023);
5158       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p1023, -0x0.fffffffffffff8p1023);
5159       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p1023, -0x1p1023);
5160       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1022, 0x1p-1022);
5161       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5162       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5163       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1022, -0x1p-1022);
5164       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5165       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.ffffffffffffep-1022, UNDERFLOW_EXCEPTION);
5166       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.ffffffffffffep-1022, UNDERFLOW_EXCEPTION);
5167       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5168       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1074, 0x1p-1074, UNDERFLOW_EXCEPTION);
5169       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1074, plus_zero, UNDERFLOW_EXCEPTION);
5170       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1074, minus_zero, UNDERFLOW_EXCEPTION);
5171       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1074, -0x1p-1074, UNDERFLOW_EXCEPTION);
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, -0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
5176       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p1023, 0x1p1023);
5177       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p1023, 0x0.fffffffffffff8p1023);
5178       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p1023, -0x0.fffffffffffff8p1023);
5179       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p1023, -0x1p1023);
5180       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p970, 0x1p970);
5181       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p970, 0x0.fffffffffffff8p970);
5182       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p970, -0x0.fffffffffffff8p970);
5183       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p970, -0x1p970);
5184 #endif
5185 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 64
5186       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000004p-1L, 0x1p-16384L, 0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
5187       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000004p-1L, -0x1p-16384L, -0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
5188       TEST_fff_f (fma, 0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5189       TEST_fff_f (fma, -0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5190       TEST_fff_f (fma, 0x1p-16445L, 0x1p-1L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5191       TEST_fff_f (fma, -0x1p-16445L, 0x1p-1L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5192       TEST_fff_f (fma, 0x1p-16445L, 0x1.1p-1L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5193       TEST_fff_f (fma, -0x1p-16445L, 0x1.1p-1L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5194       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p16383L, 0x1p16383L);
5195       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p16383L, 0x0.ffffffffffffffffp16383L);
5196       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p16383L, -0x0.ffffffffffffffffp16383L);
5197       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p16383L, -0x1p16383L);
5198       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16382L, 0x1p-16382L);
5199       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5200       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5201       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16382L, -0x1p-16382L);
5202       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5203       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffcp-16382L, UNDERFLOW_EXCEPTION);
5204       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffcp-16382L, UNDERFLOW_EXCEPTION);
5205       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5206       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, UNDERFLOW_EXCEPTION);
5207       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16445L, plus_zero, UNDERFLOW_EXCEPTION);
5208       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16445L, minus_zero, UNDERFLOW_EXCEPTION);
5209       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, -0x1p-16445L, UNDERFLOW_EXCEPTION);
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, -0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
5214       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16383L, 0x1p16383L);
5215       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16383L, 0x0.ffffffffffffffffp16383L);
5216       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16383L, -0x0.ffffffffffffffffp16383L);
5217       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16383L, -0x1p16383L);
5218       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16319L, 0x1p16319L);
5219       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16319L, 0x0.ffffffffffffffffp16319L);
5220       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16319L, -0x0.ffffffffffffffffp16319L);
5221       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16319L, -0x1p16319L);
5222 #endif
5223 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 113
5224       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, 0x1p-16384L, 0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
5225       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, -0x1p-16384L, -0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
5226       TEST_fff_f (fma, 0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5227       TEST_fff_f (fma, -0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5228       TEST_fff_f (fma, 0x1p-16494L, 0x1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5229       TEST_fff_f (fma, -0x1p-16494L, 0x1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5230       TEST_fff_f (fma, 0x1p-16494L, 0x1.1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5231       TEST_fff_f (fma, -0x1p-16494L, 0x1.1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5232       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p16383L, 0x1p16383L);
5233       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p16383L, 0x0.ffffffffffffffffffffffffffff8p16383L);
5234       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p16383L, -0x0.ffffffffffffffffffffffffffff8p16383L);
5235       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p16383L, -0x1p16383L);
5236       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16382L, 0x1p-16382L);
5237       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5238       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5239       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16382L, -0x1p-16382L);
5240       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5241       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.fffffffffffffffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5242       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.fffffffffffffffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5243       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5244       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, UNDERFLOW_EXCEPTION);
5245       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16494L, plus_zero, UNDERFLOW_EXCEPTION);
5246       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16494L, minus_zero, UNDERFLOW_EXCEPTION);
5247       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, -0x1p-16494L, UNDERFLOW_EXCEPTION);
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, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5252       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1p16383L);
5253       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x0.ffffffffffffffffffffffffffff8p16383L);
5254       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x0.ffffffffffffffffffffffffffff8p16383L);
5255       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1p16383L);
5256       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1p16319L);
5257       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x0.ffffffffffffffffffffffffffff8p16319L);
5258       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x0.ffffffffffffffffffffffffffff8p16319L);
5259       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L);
5260 #endif
5261     }
5262
5263   fesetround (save_round_mode);
5264
5265   END (fma_towardzero);
5266 }
5267
5268
5269 static void
5270 fma_test_downward (void)
5271 {
5272   int save_round_mode;
5273   START (fma_downward);
5274
5275   save_round_mode = fegetround ();
5276
5277   if (!fesetround (FE_DOWNWARD))
5278     {
5279       TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero);
5280       TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, minus_zero);
5281       TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, minus_zero);
5282       TEST_fff_f (fma, plus_zero, minus_zero, minus_zero, minus_zero);
5283       TEST_fff_f (fma, minus_zero, plus_zero, plus_zero, minus_zero);
5284       TEST_fff_f (fma, minus_zero, plus_zero, minus_zero, minus_zero);
5285       TEST_fff_f (fma, minus_zero, minus_zero, plus_zero, plus_zero);
5286       TEST_fff_f (fma, minus_zero, minus_zero, minus_zero, minus_zero);
5287       TEST_fff_f (fma, 1.0, plus_zero, plus_zero, plus_zero);
5288       TEST_fff_f (fma, 1.0, plus_zero, minus_zero, minus_zero);
5289       TEST_fff_f (fma, 1.0, minus_zero, plus_zero, minus_zero);
5290       TEST_fff_f (fma, 1.0, minus_zero, minus_zero, minus_zero);
5291       TEST_fff_f (fma, -1.0, plus_zero, plus_zero, minus_zero);
5292       TEST_fff_f (fma, -1.0, plus_zero, minus_zero, minus_zero);
5293       TEST_fff_f (fma, -1.0, minus_zero, plus_zero, plus_zero);
5294       TEST_fff_f (fma, -1.0, minus_zero, minus_zero, minus_zero);
5295       TEST_fff_f (fma, plus_zero, 1.0, plus_zero, plus_zero);
5296       TEST_fff_f (fma, plus_zero, 1.0, minus_zero, minus_zero);
5297       TEST_fff_f (fma, plus_zero, -1.0, plus_zero, minus_zero);
5298       TEST_fff_f (fma, plus_zero, -1.0, minus_zero, minus_zero);
5299       TEST_fff_f (fma, minus_zero, 1.0, plus_zero, minus_zero);
5300       TEST_fff_f (fma, minus_zero, 1.0, minus_zero, minus_zero);
5301       TEST_fff_f (fma, minus_zero, -1.0, plus_zero, plus_zero);
5302       TEST_fff_f (fma, minus_zero, -1.0, minus_zero, minus_zero);
5303
5304       TEST_fff_f (fma, 1.0, 1.0, -1.0, minus_zero);
5305       TEST_fff_f (fma, 1.0, -1.0, 1.0, minus_zero);
5306       TEST_fff_f (fma, -1.0, 1.0, 1.0, minus_zero);
5307       TEST_fff_f (fma, -1.0, -1.0, -1.0, minus_zero);
5308
5309       TEST_fff_f (fma, min_value, min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
5310       TEST_fff_f (fma, min_value, min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
5311       TEST_fff_f (fma, min_value, -min_value, plus_zero, -min_subnorm_value, UNDERFLOW_EXCEPTION);
5312       TEST_fff_f (fma, min_value, -min_value, minus_zero, -min_subnorm_value, UNDERFLOW_EXCEPTION);
5313       TEST_fff_f (fma, -min_value, min_value, plus_zero, -min_subnorm_value, UNDERFLOW_EXCEPTION);
5314       TEST_fff_f (fma, -min_value, min_value, minus_zero, -min_subnorm_value, UNDERFLOW_EXCEPTION);
5315       TEST_fff_f (fma, -min_value, -min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
5316       TEST_fff_f (fma, -min_value, -min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
5317
5318 #if !(defined TEST_LDOUBLE && LDBL_MANT_DIG == 106) /* Bug 13304.  */
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, minus_infty, OVERFLOW_EXCEPTION);
5322       TEST_fff_f (fma, max_value, -max_value, -min_value, minus_infty, OVERFLOW_EXCEPTION);
5323       TEST_fff_f (fma, -max_value, max_value, min_value, minus_infty, OVERFLOW_EXCEPTION);
5324       TEST_fff_f (fma, -max_value, max_value, -min_value, minus_infty, OVERFLOW_EXCEPTION);
5325       TEST_fff_f (fma, -max_value, -max_value, min_value, max_value, OVERFLOW_EXCEPTION);
5326       TEST_fff_f (fma, -max_value, -max_value, -min_value, max_value, OVERFLOW_EXCEPTION);
5327 #endif
5328
5329 #if defined (TEST_FLOAT) && FLT_MANT_DIG == 24
5330       TEST_fff_f (fma, 0x1.4p-126, 0x1.000004p-1, 0x1p-128, 0x1.c00004p-127, UNDERFLOW_EXCEPTION);
5331       TEST_fff_f (fma, -0x1.4p-126, 0x1.000004p-1, -0x1p-128, -0x1.c00008p-127, UNDERFLOW_EXCEPTION);
5332       TEST_fff_f (fma, 0x1.fffff8p-126, 0x1.000002p-1, 0x1p-149, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5333       TEST_fff_f (fma, -0x1.fffff8p-126, 0x1.000002p-1, -0x1p-149, -0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5334       TEST_fff_f (fma, 0x1p-149, 0x1p-1, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5335       TEST_fff_f (fma, -0x1p-149, 0x1p-1, -0x0.fffffep-126, -0x1p-126, UNDERFLOW_EXCEPTION);
5336       TEST_fff_f (fma, 0x1p-149, 0x1.1p-1, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5337       TEST_fff_f (fma, -0x1p-149, 0x1.1p-1, -0x0.fffffep-126, -0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5338       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p127, 0x1p127);
5339       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p127, 0x0.ffffffp127);
5340       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p127, -0x1p127);
5341       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p127, -0x1.000002p127);
5342       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-126, 0x1p-126);
5343       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5344       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-126, -0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5345       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-126, -0x1.000002p-126);
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, 0x0.fffffep-126, 0x0.fffffcp-126, UNDERFLOW_EXCEPTION);
5348       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5349       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x0.fffffep-126, -0x1p-126, UNDERFLOW_EXCEPTION);
5350       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-149, 0x1p-149, UNDERFLOW_EXCEPTION);
5351       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-149, plus_zero, UNDERFLOW_EXCEPTION);
5352       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-149, -0x1p-149, UNDERFLOW_EXCEPTION);
5353       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-149, -0x1p-148, UNDERFLOW_EXCEPTION);
5354       TEST_fff_f (fma, 0x0.fffp0, 0x0.fffp0, -0x0.ffep0, 0x1p-24);
5355       TEST_fff_f (fma, 0x0.fffp0, -0x0.fffp0, 0x0.ffep0, -0x1p-24);
5356       TEST_fff_f (fma, -0x0.fffp0, 0x0.fffp0, 0x0.ffep0, -0x1p-24);
5357       TEST_fff_f (fma, -0x0.fffp0, -0x0.fffp0, -0x0.ffep0, 0x1p-24);
5358       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p127, 0x1p127);
5359       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p127, 0x0.ffffffp127);
5360       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p127, -0x1p127);
5361       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p127, -0x1.000002p127);
5362       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p103, 0x1p103);
5363       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p103, 0x0.ffffffp103);
5364       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p103, -0x1p103);
5365       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p103, -0x1.000002p103);
5366 #endif
5367 #if defined (TEST_DOUBLE) && DBL_MANT_DIG == 53
5368       TEST_fff_f (fma, 0x1.4p-1022, 0x1.0000000000002p-1, 0x1p-1024, 0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
5369       TEST_fff_f (fma, -0x1.4p-1022, 0x1.0000000000002p-1, -0x1p-1024, -0x1.c000000000004p-1023, UNDERFLOW_EXCEPTION);
5370       TEST_fff_f (fma, 0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, 0x1p-1074, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5371       TEST_fff_f (fma, -0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, -0x1p-1074, -0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5372       TEST_fff_f (fma, 0x1p-1074, 0x1p-1, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5373       TEST_fff_f (fma, -0x1p-1074, 0x1p-1, -0x0.fffffffffffffp-1022, -0x1p-1022, UNDERFLOW_EXCEPTION);
5374       TEST_fff_f (fma, 0x1p-1074, 0x1.1p-1, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5375       TEST_fff_f (fma, -0x1p-1074, 0x1.1p-1, -0x0.fffffffffffffp-1022, -0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5376       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p1023, 0x1p1023);
5377       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p1023, 0x0.fffffffffffff8p1023);
5378       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p1023, -0x1p1023);
5379       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p1023, -0x1.0000000000001p1023);
5380       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1022, 0x1p-1022);
5381       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5382       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1022, -0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5383       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1022, -0x1.0000000000001p-1022);
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, 0x0.fffffffffffffp-1022, 0x0.ffffffffffffep-1022, UNDERFLOW_EXCEPTION);
5386       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5387       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x0.fffffffffffffp-1022, -0x1p-1022, UNDERFLOW_EXCEPTION);
5388       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1074, 0x1p-1074, UNDERFLOW_EXCEPTION);
5389       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1074, plus_zero, UNDERFLOW_EXCEPTION);
5390       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1074, -0x1p-1074, UNDERFLOW_EXCEPTION);
5391       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1074, -0x1p-1073, UNDERFLOW_EXCEPTION);
5392       TEST_fff_f (fma, 0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
5393       TEST_fff_f (fma, 0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
5394       TEST_fff_f (fma, -0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
5395       TEST_fff_f (fma, -0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
5396       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p1023, 0x1p1023);
5397       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p1023, 0x0.fffffffffffff8p1023);
5398       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p1023, -0x1p1023);
5399       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p1023, -0x1.0000000000001p1023);
5400       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p970, 0x1p970);
5401       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p970, 0x0.fffffffffffff8p970);
5402       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p970, -0x1p970);
5403       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p970, -0x1.0000000000001p970);
5404 #endif
5405 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 64
5406       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000004p-1L, 0x1p-16384L, 0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
5407       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000004p-1L, -0x1p-16384L, -0x1.c000000000000008p-16383L, UNDERFLOW_EXCEPTION);
5408       TEST_fff_f (fma, 0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5409       TEST_fff_f (fma, -0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, -0x1p-16445L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5410       TEST_fff_f (fma, 0x1p-16445L, 0x1p-1L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5411       TEST_fff_f (fma, -0x1p-16445L, 0x1p-1L, -0x0.fffffffffffffffep-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
5412       TEST_fff_f (fma, 0x1p-16445L, 0x1.1p-1L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5413       TEST_fff_f (fma, -0x1p-16445L, 0x1.1p-1L, -0x0.fffffffffffffffep-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5414       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p16383L, 0x1p16383L);
5415       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p16383L, 0x0.ffffffffffffffffp16383L);
5416       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p16383L, -0x1p16383L);
5417       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p16383L, -0x1.0000000000000002p16383L);
5418       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16382L, 0x1p-16382L);
5419       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5420       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5421       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16382L, -0x1.0000000000000002p-16382L);
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, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffcp-16382L, UNDERFLOW_EXCEPTION);
5424       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5425       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
5426       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, UNDERFLOW_EXCEPTION);
5427       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16445L, plus_zero, UNDERFLOW_EXCEPTION);
5428       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, UNDERFLOW_EXCEPTION);
5429       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, -0x1p-16444L, UNDERFLOW_EXCEPTION);
5430       TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
5431       TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
5432       TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
5433       TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
5434       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16383L, 0x1p16383L);
5435       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16383L, 0x0.ffffffffffffffffp16383L);
5436       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16383L, -0x1p16383L);
5437       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16383L, -0x1.0000000000000002p16383L);
5438       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16319L, 0x1p16319L);
5439       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16319L, 0x0.ffffffffffffffffp16319L);
5440       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16319L, -0x1p16319L);
5441       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16319L, -0x1.0000000000000002p16319L);
5442 #endif
5443 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 113
5444       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, 0x1p-16384L, 0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
5445       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, -0x1p-16384L, -0x1.c000000000000000000000000004p-16383L, UNDERFLOW_EXCEPTION);
5446       TEST_fff_f (fma, 0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5447       TEST_fff_f (fma, -0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, -0x1p-16494L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5448       TEST_fff_f (fma, 0x1p-16494L, 0x1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5449       TEST_fff_f (fma, -0x1p-16494L, 0x1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
5450       TEST_fff_f (fma, 0x1p-16494L, 0x1.1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5451       TEST_fff_f (fma, -0x1p-16494L, 0x1.1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5452       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p16383L, 0x1p16383L);
5453       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p16383L, 0x0.ffffffffffffffffffffffffffff8p16383L);
5454       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p16383L, -0x1p16383L);
5455       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p16383L, -0x1.0000000000000000000000000001p16383L);
5456       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16382L, 0x1p-16382L);
5457       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5458       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5459       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16382L, -0x1.0000000000000000000000000001p-16382L);
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, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.fffffffffffffffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5462       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5463       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x1p-16382L, UNDERFLOW_EXCEPTION);
5464       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, UNDERFLOW_EXCEPTION);
5465       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16494L, plus_zero, UNDERFLOW_EXCEPTION);
5466       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, UNDERFLOW_EXCEPTION);
5467       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, -0x1p-16493L, UNDERFLOW_EXCEPTION);
5468       TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5469       TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5470       TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5471       TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5472       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1p16383L);
5473       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x0.ffffffffffffffffffffffffffff8p16383L);
5474       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1p16383L);
5475       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1.0000000000000000000000000001p16383L);
5476       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1p16319L);
5477       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x0.ffffffffffffffffffffffffffff8p16319L);
5478       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L);
5479       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1.0000000000000000000000000001p16319L);
5480 #endif
5481     }
5482
5483   fesetround (save_round_mode);
5484
5485   END (fma_downward);
5486 }
5487
5488
5489 static void
5490 fma_test_upward (void)
5491 {
5492   int save_round_mode;
5493   START (fma_upward);
5494
5495   save_round_mode = fegetround ();
5496
5497   if (!fesetround (FE_UPWARD))
5498     {
5499       TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero);
5500       TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, plus_zero);
5501       TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, plus_zero);
5502       TEST_fff_f (fma, plus_zero, minus_zero, minus_zero, minus_zero);
5503       TEST_fff_f (fma, minus_zero, plus_zero, plus_zero, plus_zero);
5504       TEST_fff_f (fma, minus_zero, plus_zero, minus_zero, minus_zero);
5505       TEST_fff_f (fma, minus_zero, minus_zero, plus_zero, plus_zero);
5506       TEST_fff_f (fma, minus_zero, minus_zero, minus_zero, plus_zero);
5507       TEST_fff_f (fma, 1.0, plus_zero, plus_zero, plus_zero);
5508       TEST_fff_f (fma, 1.0, plus_zero, minus_zero, plus_zero);
5509       TEST_fff_f (fma, 1.0, minus_zero, plus_zero, plus_zero);
5510       TEST_fff_f (fma, 1.0, minus_zero, minus_zero, minus_zero);
5511       TEST_fff_f (fma, -1.0, plus_zero, plus_zero, plus_zero);
5512       TEST_fff_f (fma, -1.0, plus_zero, minus_zero, minus_zero);
5513       TEST_fff_f (fma, -1.0, minus_zero, plus_zero, plus_zero);
5514       TEST_fff_f (fma, -1.0, minus_zero, minus_zero, plus_zero);
5515       TEST_fff_f (fma, plus_zero, 1.0, plus_zero, plus_zero);
5516       TEST_fff_f (fma, plus_zero, 1.0, minus_zero, plus_zero);
5517       TEST_fff_f (fma, plus_zero, -1.0, plus_zero, plus_zero);
5518       TEST_fff_f (fma, plus_zero, -1.0, minus_zero, minus_zero);
5519       TEST_fff_f (fma, minus_zero, 1.0, plus_zero, plus_zero);
5520       TEST_fff_f (fma, minus_zero, 1.0, minus_zero, minus_zero);
5521       TEST_fff_f (fma, minus_zero, -1.0, plus_zero, plus_zero);
5522       TEST_fff_f (fma, minus_zero, -1.0, minus_zero, plus_zero);
5523
5524       TEST_fff_f (fma, 1.0, 1.0, -1.0, plus_zero);
5525       TEST_fff_f (fma, 1.0, -1.0, 1.0, plus_zero);
5526       TEST_fff_f (fma, -1.0, 1.0, 1.0, plus_zero);
5527       TEST_fff_f (fma, -1.0, -1.0, -1.0, plus_zero);
5528
5529       TEST_fff_f (fma, min_value, min_value, plus_zero, min_subnorm_value, UNDERFLOW_EXCEPTION);
5530       TEST_fff_f (fma, min_value, min_value, minus_zero, min_subnorm_value, UNDERFLOW_EXCEPTION);
5531       TEST_fff_f (fma, min_value, -min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
5532       TEST_fff_f (fma, min_value, -min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
5533       TEST_fff_f (fma, -min_value, min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
5534       TEST_fff_f (fma, -min_value, min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
5535       TEST_fff_f (fma, -min_value, -min_value, plus_zero, min_subnorm_value, UNDERFLOW_EXCEPTION);
5536       TEST_fff_f (fma, -min_value, -min_value, minus_zero, min_subnorm_value, UNDERFLOW_EXCEPTION);
5537
5538 #if !(defined TEST_LDOUBLE && LDBL_MANT_DIG == 106) /* Bug 13304.  */
5539       TEST_fff_f (fma, max_value, max_value, min_value, plus_infty, OVERFLOW_EXCEPTION);
5540       TEST_fff_f (fma, max_value, max_value, -min_value, plus_infty, OVERFLOW_EXCEPTION);
5541       TEST_fff_f (fma, max_value, -max_value, min_value, -max_value, OVERFLOW_EXCEPTION);
5542       TEST_fff_f (fma, max_value, -max_value, -min_value, -max_value, OVERFLOW_EXCEPTION);
5543       TEST_fff_f (fma, -max_value, max_value, min_value, -max_value, OVERFLOW_EXCEPTION);
5544       TEST_fff_f (fma, -max_value, max_value, -min_value, -max_value, OVERFLOW_EXCEPTION);
5545       TEST_fff_f (fma, -max_value, -max_value, min_value, plus_infty, OVERFLOW_EXCEPTION);
5546       TEST_fff_f (fma, -max_value, -max_value, -min_value, plus_infty, OVERFLOW_EXCEPTION);
5547 #endif
5548
5549 #if defined (TEST_FLOAT) && FLT_MANT_DIG == 24
5550       TEST_fff_f (fma, 0x1.4p-126, 0x1.000004p-1, 0x1p-128, 0x1.c00008p-127, UNDERFLOW_EXCEPTION);
5551       TEST_fff_f (fma, -0x1.4p-126, 0x1.000004p-1, -0x1p-128, -0x1.c00004p-127, UNDERFLOW_EXCEPTION);
5552       TEST_fff_f (fma, 0x1.fffff8p-126, 0x1.000002p-1, 0x1p-149, 0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5553       TEST_fff_f (fma, -0x1.fffff8p-126, 0x1.000002p-1, -0x1p-149, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5554       TEST_fff_f (fma, 0x1p-149, 0x1p-1, 0x0.fffffep-126, 0x1p-126, UNDERFLOW_EXCEPTION);
5555       TEST_fff_f (fma, -0x1p-149, 0x1p-1, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5556       TEST_fff_f (fma, 0x1p-149, 0x1.1p-1, 0x0.fffffep-126, 0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5557       TEST_fff_f (fma, -0x1p-149, 0x1.1p-1, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5558       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p127, 0x1.000002p127);
5559       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p127, 0x1p127);
5560       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p127, -0x0.ffffffp127);
5561       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p127, -0x1p127);
5562       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-126, 0x1.000002p-126);
5563       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-126, 0x1p-126, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5564       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5565       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-126, -0x1p-126);
5566       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x0.fffffep-126, 0x1p-126, UNDERFLOW_EXCEPTION);
5567       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x0.fffffep-126, 0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5568       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x0.fffffep-126, -0x0.fffffcp-126, UNDERFLOW_EXCEPTION);
5569       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x0.fffffep-126, -0x0.fffffep-126, UNDERFLOW_EXCEPTION);
5570       TEST_fff_f (fma, 0x1p-149, 0x1p-149, 0x1p-149, 0x1p-148, UNDERFLOW_EXCEPTION);
5571       TEST_fff_f (fma, 0x1p-149, -0x1p-149, 0x1p-149, 0x1p-149, UNDERFLOW_EXCEPTION);
5572       TEST_fff_f (fma, 0x1p-149, 0x1p-149, -0x1p-149, minus_zero, UNDERFLOW_EXCEPTION);
5573       TEST_fff_f (fma, 0x1p-149, -0x1p-149, -0x1p-149, -0x1p-149, UNDERFLOW_EXCEPTION);
5574       TEST_fff_f (fma, 0x0.fffp0, 0x0.fffp0, -0x0.ffep0, 0x1p-24);
5575       TEST_fff_f (fma, 0x0.fffp0, -0x0.fffp0, 0x0.ffep0, -0x1p-24);
5576       TEST_fff_f (fma, -0x0.fffp0, 0x0.fffp0, 0x0.ffep0, -0x1p-24);
5577       TEST_fff_f (fma, -0x0.fffp0, -0x0.fffp0, -0x0.ffep0, 0x1p-24);
5578       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p127, 0x1.000002p127);
5579       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p127, 0x1p127);
5580       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p127, -0x0.ffffffp127);
5581       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p127, -0x1p127);
5582       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, 0x1p103, 0x1.000002p103);
5583       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, 0x1p103, 0x1p103);
5584       TEST_fff_f (fma, 0x1.000002p-126, 0x1.000002p-26, -0x1p103, -0x0.ffffffp103);
5585       TEST_fff_f (fma, 0x1.000002p-126, -0x1.000002p-26, -0x1p103, -0x1p103);
5586 #endif
5587 #if defined (TEST_DOUBLE) && DBL_MANT_DIG == 53
5588       TEST_fff_f (fma, 0x1.4p-1022, 0x1.0000000000002p-1, 0x1p-1024, 0x1.c000000000004p-1023, UNDERFLOW_EXCEPTION);
5589       TEST_fff_f (fma, -0x1.4p-1022, 0x1.0000000000002p-1, -0x1p-1024, -0x1.c000000000002p-1023, UNDERFLOW_EXCEPTION);
5590       TEST_fff_f (fma, 0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, 0x1p-1074, 0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5591       TEST_fff_f (fma, -0x1.ffffffffffffcp-1022, 0x1.0000000000001p-1, -0x1p-1074, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5592       TEST_fff_f (fma, 0x1p-1074, 0x1p-1, 0x0.fffffffffffffp-1022, 0x1p-1022, UNDERFLOW_EXCEPTION);
5593       TEST_fff_f (fma, -0x1p-1074, 0x1p-1, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5594       TEST_fff_f (fma, 0x1p-1074, 0x1.1p-1, 0x0.fffffffffffffp-1022, 0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5595       TEST_fff_f (fma, -0x1p-1074, 0x1.1p-1, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5596       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p1023, 0x1.0000000000001p1023);
5597       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p1023, 0x1p1023);
5598       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p1023, -0x0.fffffffffffff8p1023);
5599       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p1023, -0x1p1023);
5600       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1022, 0x1.0000000000001p-1022);
5601       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1022, 0x1p-1022, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5602       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5603       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1022, -0x1p-1022);
5604       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x0.fffffffffffffp-1022, 0x1p-1022, UNDERFLOW_EXCEPTION);
5605       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x0.fffffffffffffp-1022, 0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5606       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.ffffffffffffep-1022, UNDERFLOW_EXCEPTION);
5607       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x0.fffffffffffffp-1022, -0x0.fffffffffffffp-1022, UNDERFLOW_EXCEPTION);
5608       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, 0x1p-1074, 0x1p-1073, UNDERFLOW_EXCEPTION);
5609       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, 0x1p-1074, 0x1p-1074, UNDERFLOW_EXCEPTION);
5610       TEST_fff_f (fma, 0x1p-1074, 0x1p-1074, -0x1p-1074, minus_zero, UNDERFLOW_EXCEPTION);
5611       TEST_fff_f (fma, 0x1p-1074, -0x1p-1074, -0x1p-1074, -0x1p-1074, UNDERFLOW_EXCEPTION);
5612       TEST_fff_f (fma, 0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
5613       TEST_fff_f (fma, 0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
5614       TEST_fff_f (fma, -0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0, 0x0.fffffffffffffp0, -0x1p-106);
5615       TEST_fff_f (fma, -0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0, -0x0.fffffffffffffp0, 0x1p-106);
5616       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p1023, 0x1.0000000000001p1023);
5617       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p1023, 0x1p1023);
5618       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p1023, -0x0.fffffffffffff8p1023);
5619       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p1023, -0x1p1023);
5620       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, 0x1p970, 0x1.0000000000001p970);
5621       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, 0x1p970, 0x1p970);
5622       TEST_fff_f (fma, 0x1.0000000000001p-1022, 0x1.0000000000001p-55, -0x1p970, -0x0.fffffffffffff8p970);
5623       TEST_fff_f (fma, 0x1.0000000000001p-1022, -0x1.0000000000001p-55, -0x1p970, -0x1p970);
5624 #endif
5625 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 64
5626       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000004p-1L, 0x1p-16384L, 0x1.c000000000000008p-16383L, UNDERFLOW_EXCEPTION);
5627       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000004p-1L, -0x1p-16384L, -0x1.c000000000000004p-16383L, UNDERFLOW_EXCEPTION);
5628       TEST_fff_f (fma, 0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, 0x1p-16445L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5629       TEST_fff_f (fma, -0x1.fffffffffffffff8p-16382L, 0x1.0000000000000002p-1L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5630       TEST_fff_f (fma, 0x1p-16445L, 0x1p-1L, 0x0.fffffffffffffffep-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
5631       TEST_fff_f (fma, -0x1p-16445L, 0x1p-1L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5632       TEST_fff_f (fma, 0x1p-16445L, 0x1.1p-1L, 0x0.fffffffffffffffep-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5633       TEST_fff_f (fma, -0x1p-16445L, 0x1.1p-1L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5634       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p16383L, 0x1.0000000000000002p16383L);
5635       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p16383L, 0x1p16383L);
5636       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p16383L, -0x0.ffffffffffffffffp16383L);
5637       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p16383L, -0x1p16383L);
5638       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16382L, 0x1.0000000000000002p-16382L);
5639       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5640       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5641       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16382L, -0x1p-16382L);
5642       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
5643       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x0.fffffffffffffffep-16382L, 0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5644       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffcp-16382L, UNDERFLOW_EXCEPTION);
5645       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x0.fffffffffffffffep-16382L, -0x0.fffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5646       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, 0x1p-16445L, 0x1p-16444L, UNDERFLOW_EXCEPTION);
5647       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, 0x1p-16445L, 0x1p-16445L, UNDERFLOW_EXCEPTION);
5648       TEST_fff_f (fma, 0x1p-16445L, 0x1p-16445L, -0x1p-16445L, minus_zero, UNDERFLOW_EXCEPTION);
5649       TEST_fff_f (fma, 0x1p-16445L, -0x1p-16445L, -0x1p-16445L, -0x1p-16445L, UNDERFLOW_EXCEPTION);
5650       TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
5651       TEST_fff_f (fma, 0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
5652       TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp0L, 0x0.fffffffffffffffep0L, -0x1p-128L);
5653       TEST_fff_f (fma, -0x0.ffffffffffffffffp0L, -0x0.ffffffffffffffffp0L, -0x0.fffffffffffffffep0L, 0x1p-128L);
5654       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16383L, 0x1.0000000000000002p16383L);
5655       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16383L, 0x1p16383L);
5656       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16383L, -0x0.ffffffffffffffffp16383L);
5657       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16383L, -0x1p16383L);
5658       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, 0x1p16319L, 0x1.0000000000000002p16319L);
5659       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, 0x1p16319L, 0x1p16319L);
5660       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-66L, -0x1p16319L, -0x0.ffffffffffffffffp16319L);
5661       TEST_fff_f (fma, 0x1.0000000000000002p-16382L, -0x1.0000000000000002p-66L, -0x1p16319L, -0x1p16319L);
5662 #endif
5663 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 113
5664       TEST_fff_f (fma, 0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, 0x1p-16384L, 0x1.c000000000000000000000000004p-16383L, UNDERFLOW_EXCEPTION);
5665       TEST_fff_f (fma, -0x1.4p-16382L, 0x1.0000000000000000000000000002p-1L, -0x1p-16384L, -0x1.c000000000000000000000000002p-16383L, UNDERFLOW_EXCEPTION);
5666       TEST_fff_f (fma, 0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, 0x1p-16494L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5667       TEST_fff_f (fma, -0x1.fffffffffffffffffffffffffffcp-16382L, 0x1.0000000000000000000000000001p-1L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5668       TEST_fff_f (fma, 0x1p-16494L, 0x1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
5669       TEST_fff_f (fma, -0x1p-16494L, 0x1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5670       TEST_fff_f (fma, 0x1p-16494L, 0x1.1p-1L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5671       TEST_fff_f (fma, -0x1p-16494L, 0x1.1p-1L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5672       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p16383L, 0x1.0000000000000000000000000001p16383L);
5673       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p16383L, 0x1p16383L);
5674       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p16383L, -0x0.ffffffffffffffffffffffffffff8p16383L);
5675       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p16383L, -0x1p16383L);
5676       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16382L, 0x1.0000000000000000000000000001p-16382L);
5677       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION_BEFORE_ROUNDING);
5678       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5679       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16382L, -0x1p-16382L);
5680       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x1p-16382L, UNDERFLOW_EXCEPTION);
5681       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x0.ffffffffffffffffffffffffffffp-16382L, 0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5682       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.fffffffffffffffffffffffffffep-16382L, UNDERFLOW_EXCEPTION);
5683       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x0.ffffffffffffffffffffffffffffp-16382L, -0x0.ffffffffffffffffffffffffffffp-16382L, UNDERFLOW_EXCEPTION);
5684       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, 0x1p-16494L, 0x1p-16493L, UNDERFLOW_EXCEPTION);
5685       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, 0x1p-16494L, 0x1p-16494L, UNDERFLOW_EXCEPTION);
5686       TEST_fff_f (fma, 0x1p-16494L, 0x1p-16494L, -0x1p-16494L, minus_zero, UNDERFLOW_EXCEPTION);
5687       TEST_fff_f (fma, 0x1p-16494L, -0x1p-16494L, -0x1p-16494L, -0x1p-16494L, UNDERFLOW_EXCEPTION);
5688       TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5689       TEST_fff_f (fma, 0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5690       TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffffffffffffffffffffffffp0L, -0x1p-226L);
5691       TEST_fff_f (fma, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffffffffffffffffffffffffp0L, 0x1p-226L);
5692       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1.0000000000000000000000000001p16383L);
5693       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16383L, 0x1p16383L);
5694       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x0.ffffffffffffffffffffffffffff8p16383L);
5695       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16383L, -0x1p16383L);
5696       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1.0000000000000000000000000001p16319L);
5697       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, 0x1p16319L, 0x1p16319L);
5698       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x0.ffffffffffffffffffffffffffff8p16319L);
5699       TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L);
5700 #endif
5701     }
5702
5703   fesetround (save_round_mode);
5704
5705   END (fma_upward);
5706 }
5707
5708
5709 static void
5710 fmax_test (void)
5711 {
5712   START (fmax);
5713
5714   TEST_ff_f (fmax, 0, 0, 0);
5715   TEST_ff_f (fmax, minus_zero, minus_zero, minus_zero);
5716   TEST_ff_f (fmax, 9, 0, 9);
5717   TEST_ff_f (fmax, 0, 9, 9);
5718   TEST_ff_f (fmax, -9, 0, 0);
5719   TEST_ff_f (fmax, 0, -9, 0);
5720
5721   TEST_ff_f (fmax, plus_infty, 9, plus_infty);
5722   TEST_ff_f (fmax, 0, plus_infty, plus_infty);
5723   TEST_ff_f (fmax, -9, plus_infty, plus_infty);
5724   TEST_ff_f (fmax, plus_infty, -9, plus_infty);
5725
5726   TEST_ff_f (fmax, minus_infty, 9, 9);
5727   TEST_ff_f (fmax, minus_infty, -9, -9);
5728   TEST_ff_f (fmax, 9, minus_infty, 9);
5729   TEST_ff_f (fmax, -9, minus_infty, -9);
5730
5731   TEST_ff_f (fmax, 0, nan_value, 0);
5732   TEST_ff_f (fmax, 9, nan_value, 9);
5733   TEST_ff_f (fmax, -9, nan_value, -9);
5734   TEST_ff_f (fmax, nan_value, 0, 0);
5735   TEST_ff_f (fmax, nan_value, 9, 9);
5736   TEST_ff_f (fmax, nan_value, -9, -9);
5737   TEST_ff_f (fmax, plus_infty, nan_value, plus_infty);
5738   TEST_ff_f (fmax, minus_infty, nan_value, minus_infty);
5739   TEST_ff_f (fmax, nan_value, plus_infty, plus_infty);
5740   TEST_ff_f (fmax, nan_value, minus_infty, minus_infty);
5741   TEST_ff_f (fmax, nan_value, nan_value, nan_value);
5742
5743   END (fmax);
5744 }
5745
5746
5747 static void
5748 fmin_test (void)
5749 {
5750   START (fmin);
5751
5752   TEST_ff_f (fmin, 0, 0, 0);
5753   TEST_ff_f (fmin, minus_zero, minus_zero, minus_zero);
5754   TEST_ff_f (fmin, 9, 0, 0);
5755   TEST_ff_f (fmin, 0, 9, 0);
5756   TEST_ff_f (fmin, -9, 0, -9);
5757   TEST_ff_f (fmin, 0, -9, -9);
5758
5759   TEST_ff_f (fmin, plus_infty, 9, 9);
5760   TEST_ff_f (fmin, 9, plus_infty, 9);
5761   TEST_ff_f (fmin, plus_infty, -9, -9);
5762   TEST_ff_f (fmin, -9, plus_infty, -9);
5763   TEST_ff_f (fmin, minus_infty, 9, minus_infty);
5764   TEST_ff_f (fmin, minus_infty, -9, minus_infty);
5765   TEST_ff_f (fmin, 9, minus_infty, minus_infty);
5766   TEST_ff_f (fmin, -9, minus_infty, minus_infty);
5767
5768   TEST_ff_f (fmin, 0, nan_value, 0);
5769   TEST_ff_f (fmin, 9, nan_value, 9);
5770   TEST_ff_f (fmin, -9, nan_value, -9);
5771   TEST_ff_f (fmin, nan_value, 0, 0);
5772   TEST_ff_f (fmin, nan_value, 9, 9);
5773   TEST_ff_f (fmin, nan_value, -9, -9);
5774   TEST_ff_f (fmin, plus_infty, nan_value, plus_infty);
5775   TEST_ff_f (fmin, minus_infty, nan_value, minus_infty);
5776   TEST_ff_f (fmin, nan_value, plus_infty, plus_infty);
5777   TEST_ff_f (fmin, nan_value, minus_infty, minus_infty);
5778   TEST_ff_f (fmin, nan_value, nan_value, nan_value);
5779
5780   END (fmin);
5781 }
5782
5783
5784 static void
5785 fmod_test (void)
5786 {
5787   errno = 0;
5788   FUNC(fmod) (6.5, 2.3L);
5789   if (errno == ENOSYS)
5790     /* Function not implemented.  */
5791     return;
5792
5793   START (fmod);
5794
5795   /* fmod (+0, y) == +0 for y != 0.  */
5796   TEST_ff_f (fmod, 0, 3, 0);
5797
5798   /* fmod (-0, y) == -0 for y != 0.  */
5799   TEST_ff_f (fmod, minus_zero, 3, minus_zero);
5800
5801   /* fmod (+inf, y) == NaN plus invalid exception.  */
5802   errno = 0;
5803   TEST_ff_f (fmod, plus_infty, 3, nan_value, INVALID_EXCEPTION);
5804   check_int ("errno for fmod(Inf,3) unchanged", errno, EDOM, 0, 0, 0);
5805   /* fmod (-inf, y) == NaN plus invalid exception.  */
5806   errno = 0;
5807   TEST_ff_f (fmod, minus_infty, 3, nan_value, INVALID_EXCEPTION);
5808   check_int ("errno for fmod(-Inf,3) unchanged", errno, EDOM, 0, 0, 0);
5809   /* fmod (x, +0) == NaN plus invalid exception.  */
5810   errno = 0;
5811   TEST_ff_f (fmod, 3, 0, nan_value, INVALID_EXCEPTION);
5812   check_int ("errno for fmod(3,0) unchanged", errno, EDOM, 0, 0, 0);
5813   /* fmod (x, -0) == NaN plus invalid exception.  */
5814   TEST_ff_f (fmod, 3, minus_zero, nan_value, INVALID_EXCEPTION);
5815
5816   /* fmod (x, +inf) == x for x not infinite.  */
5817   TEST_ff_f (fmod, 3.0, plus_infty, 3.0);
5818   /* fmod (x, -inf) == x for x not infinite.  */
5819   TEST_ff_f (fmod, 3.0, minus_infty, 3.0);
5820
5821   TEST_ff_f (fmod, nan_value, nan_value, nan_value);
5822
5823   TEST_ff_f (fmod, 6.5, 2.25L, 2.0L);
5824   TEST_ff_f (fmod, -6.5, 2.25L, -2.0L);
5825   TEST_ff_f (fmod, 6.5, -2.25L, 2.0L);
5826   TEST_ff_f (fmod, -6.5, -2.25L, -2.0L);
5827
5828   TEST_ff_f (fmod, 0x0.fffffep-126L, 0x1p-149L, plus_zero);
5829 #ifndef TEST_FLOAT
5830   TEST_ff_f (fmod, 0x0.fffffffffffffp-1022L, 0x1p-1074L, plus_zero);
5831 #endif
5832 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
5833   TEST_ff_f (fmod, 0x0.fffffffffffffffep-16382L, 0x1p-16445L, plus_zero);
5834 #endif
5835
5836   END (fmod);
5837 }
5838
5839
5840 static void
5841 fpclassify_test (void)
5842 {
5843   START (fpclassify);
5844
5845   TEST_f_i (fpclassify, nan_value, FP_NAN);
5846   TEST_f_i (fpclassify, plus_infty, FP_INFINITE);
5847   TEST_f_i (fpclassify, minus_infty, FP_INFINITE);
5848   TEST_f_i (fpclassify, plus_zero, FP_ZERO);
5849   TEST_f_i (fpclassify, minus_zero, FP_ZERO);
5850   TEST_f_i (fpclassify, 1000, FP_NORMAL);
5851   TEST_f_i (fpclassify, min_subnorm_value, FP_SUBNORMAL);
5852
5853   END (fpclassify);
5854 }
5855
5856
5857 static void
5858 frexp_test (void)
5859 {
5860   int x;
5861
5862   START (frexp);
5863
5864   TEST_fI_f1 (frexp, plus_infty, plus_infty, IGNORE);
5865   TEST_fI_f1 (frexp, minus_infty, minus_infty, IGNORE);
5866   TEST_fI_f1 (frexp, nan_value, nan_value, IGNORE);
5867
5868   TEST_fI_f1 (frexp, 0.0, 0.0, 0.0);
5869   TEST_fI_f1 (frexp, minus_zero, minus_zero, 0.0);
5870
5871   TEST_fI_f1 (frexp, 12.8L, 0.8L, 4);
5872   TEST_fI_f1 (frexp, -27.34L, -0.854375L, 5);
5873
5874   END (frexp);
5875 }
5876
5877
5878 static void
5879 gamma_test (void)
5880 {
5881   errno = 0;
5882   FUNC(gamma) (1);
5883
5884   if (errno == ENOSYS)
5885     /* Function not implemented.  */
5886     return;
5887
5888   START (gamma);
5889
5890   TEST_f_f (gamma, plus_infty, plus_infty);
5891   TEST_f_f (gamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5892   TEST_f_f (gamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5893   TEST_f_f (gamma, minus_infty, plus_infty);
5894   TEST_f_f (gamma, nan_value, nan_value);
5895
5896   TEST_f_f1 (gamma, 1, 0, 1);
5897   TEST_f_f1 (gamma, 3, M_LN2l, 1);
5898
5899   TEST_f_f1 (gamma, 0.5, M_LOG_SQRT_PIl, 1);
5900   TEST_f_f1 (gamma, -0.5, M_LOG_2_SQRT_PIl, -1);
5901
5902   END (gamma);
5903 }
5904
5905 static void
5906 hypot_test (void)
5907 {
5908   errno = 0;
5909   FUNC(hypot) (0.7L, 12.4L);
5910   if (errno == ENOSYS)
5911     /* Function not implemented.  */
5912     return;
5913
5914   START (hypot);
5915
5916   TEST_ff_f (hypot, plus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
5917   TEST_ff_f (hypot, minus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
5918
5919 #ifndef TEST_INLINE
5920   TEST_ff_f (hypot, plus_infty, nan_value, plus_infty);
5921   TEST_ff_f (hypot, minus_infty, nan_value, plus_infty);
5922   TEST_ff_f (hypot, nan_value, plus_infty, plus_infty);
5923   TEST_ff_f (hypot, nan_value, minus_infty, plus_infty);
5924 #endif
5925
5926   TEST_ff_f (hypot, nan_value, nan_value, nan_value);
5927
5928   /* hypot (x,y) == hypot (+-x, +-y)  */
5929   TEST_ff_f (hypot, 0.7L, 12.4L, 12.419742348374220601176836866763271L);
5930   TEST_ff_f (hypot, -0.7L, 12.4L, 12.419742348374220601176836866763271L);
5931   TEST_ff_f (hypot, 0.7L, -12.4L, 12.419742348374220601176836866763271L);
5932   TEST_ff_f (hypot, -0.7L, -12.4L, 12.419742348374220601176836866763271L);
5933   TEST_ff_f (hypot, 12.4L, 0.7L, 12.419742348374220601176836866763271L);
5934   TEST_ff_f (hypot, -12.4L, 0.7L, 12.419742348374220601176836866763271L);
5935   TEST_ff_f (hypot, 12.4L, -0.7L, 12.419742348374220601176836866763271L);
5936   TEST_ff_f (hypot, -12.4L, -0.7L, 12.419742348374220601176836866763271L);
5937
5938   /*  hypot (x,0) == fabs (x)  */
5939   TEST_ff_f (hypot, 0.75L, 0, 0.75L);
5940   TEST_ff_f (hypot, -0.75L, 0, 0.75L);
5941   TEST_ff_f (hypot, -5.7e7, 0, 5.7e7L);
5942
5943   TEST_ff_f (hypot, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
5944
5945   TEST_ff_f (hypot, 1.0L, 0x1p-61L, 1.0L);
5946 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
5947   TEST_ff_f (hypot, 0x1.23456789abcdef0123456789ab8p-500L, 0x1.23456789abcdef0123456789ab8p-500L, 4.9155782399407039128612180934736799735113e-151L);
5948 #endif
5949
5950 #if !(defined TEST_FLOAT && defined TEST_INLINE)
5951   TEST_ff_f (hypot, 0x3p125L, 0x4p125L, 0x5p125L);
5952   TEST_ff_f (hypot, 0x1.234566p-126L, 0x1.234566p-126L, 1.891441686191081936598531534017449451173e-38L);
5953 #endif
5954
5955 #if !defined TEST_FLOAT && !(defined TEST_DOUBLE && defined TEST_INLINE)
5956   TEST_ff_f (hypot, 0x3p1021L, 0x4p1021L, 0x5p1021L);
5957 #endif
5958
5959 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384 && !defined TEST_INLINE
5960   TEST_ff_f (hypot, 0x3p16381L, 0x4p16381L, 0x5p16381L);
5961 #endif
5962
5963   END (hypot);
5964 }
5965
5966
5967 static void
5968 ilogb_test (void)
5969 {
5970   START (ilogb);
5971
5972   TEST_f_i (ilogb, 1, 0);
5973   TEST_f_i (ilogb, M_El, 1);
5974   TEST_f_i (ilogb, 1024, 10);
5975   TEST_f_i (ilogb, -2000, 10);
5976
5977   /* ilogb (0.0) == FP_ILOGB0 plus invalid exception  */
5978   errno = 0;
5979   TEST_f_i (ilogb, 0.0, FP_ILOGB0, INVALID_EXCEPTION);
5980   check_int ("errno for ilogb(0.0) unchanged", errno, EDOM, 0, 0, 0);
5981   /* ilogb (NaN) == FP_ILOGBNAN plus invalid exception  */
5982   errno = 0;
5983   TEST_f_i (ilogb, nan_value, FP_ILOGBNAN, INVALID_EXCEPTION);
5984   check_int ("errno for ilogb(NaN) unchanged", errno, EDOM, 0, 0, 0);
5985   /* ilogb (inf) == INT_MAX plus invalid exception  */
5986   errno = 0;
5987   TEST_f_i (ilogb, plus_infty, INT_MAX, INVALID_EXCEPTION);
5988   check_int ("errno for ilogb(Inf) unchanged", errno, EDOM, 0, 0, 0);
5989   /* ilogb (-inf) == INT_MAX plus invalid exception  */
5990   errno = 0;
5991   TEST_f_i (ilogb, minus_infty, INT_MAX, INVALID_EXCEPTION);
5992   check_int ("errno for ilogb(-Inf) unchanged", errno, EDOM, 0, 0, 0);
5993
5994   END (ilogb);
5995 }
5996
5997 static void
5998 isfinite_test (void)
5999 {
6000   START (isfinite);
6001
6002   TEST_f_b (isfinite, 0, 1);
6003   TEST_f_b (isfinite, minus_zero, 1);
6004   TEST_f_b (isfinite, 10, 1);
6005   TEST_f_b (isfinite, min_subnorm_value, 1);
6006   TEST_f_b (isfinite, plus_infty, 0);
6007   TEST_f_b (isfinite, minus_infty, 0);
6008   TEST_f_b (isfinite, nan_value, 0);
6009
6010   END (isfinite);
6011 }
6012
6013 static void
6014 isgreater_test (void)
6015 {
6016   START (isgreater);
6017
6018   TEST_ff_i (isgreater, minus_zero, minus_zero, 0);
6019   TEST_ff_i (isgreater, minus_zero, plus_zero, 0);
6020   TEST_ff_i (isgreater, minus_zero, (FLOAT) 1, 0);
6021   TEST_ff_i (isgreater, minus_zero, nan_value, 0);
6022   TEST_ff_i (isgreater, plus_zero, minus_zero, 0);
6023   TEST_ff_i (isgreater, plus_zero, plus_zero, 0);
6024   TEST_ff_i (isgreater, plus_zero, (FLOAT) 1, 0);
6025   TEST_ff_i (isgreater, plus_zero, nan_value, 0);
6026   TEST_ff_i (isgreater, (FLOAT) 1, minus_zero, 1);
6027   TEST_ff_i (isgreater, (FLOAT) 1, plus_zero, 1);
6028   TEST_ff_i (isgreater, (FLOAT) 1, (FLOAT) 1, 0);
6029   TEST_ff_i (isgreater, (FLOAT) 1, nan_value, 0);
6030   TEST_ff_i (isgreater, nan_value, minus_zero, 0);
6031   TEST_ff_i (isgreater, nan_value, plus_zero, 0);
6032   TEST_ff_i (isgreater, nan_value, (FLOAT) 1, 0);
6033   TEST_ff_i (isgreater, nan_value, nan_value, 0);
6034
6035   END (isgreater);
6036 }
6037
6038 static void
6039 isgreaterequal_test (void)
6040 {
6041   START (isgreaterequal);
6042
6043   TEST_ff_i (isgreaterequal, minus_zero, minus_zero, 1);
6044   TEST_ff_i (isgreaterequal, minus_zero, plus_zero, 1);
6045   TEST_ff_i (isgreaterequal, minus_zero, (FLOAT) 1, 0);
6046   TEST_ff_i (isgreaterequal, minus_zero, nan_value, 0);
6047   TEST_ff_i (isgreaterequal, plus_zero, minus_zero, 1);
6048   TEST_ff_i (isgreaterequal, plus_zero, plus_zero, 1);
6049   TEST_ff_i (isgreaterequal, plus_zero, (FLOAT) 1, 0);
6050   TEST_ff_i (isgreaterequal, plus_zero, nan_value, 0);
6051   TEST_ff_i (isgreaterequal, (FLOAT) 1, minus_zero, 1);
6052   TEST_ff_i (isgreaterequal, (FLOAT) 1, plus_zero, 1);
6053   TEST_ff_i (isgreaterequal, (FLOAT) 1, (FLOAT) 1, 1);
6054   TEST_ff_i (isgreaterequal, (FLOAT) 1, nan_value, 0);
6055   TEST_ff_i (isgreaterequal, nan_value, minus_zero, 0);
6056   TEST_ff_i (isgreaterequal, nan_value, plus_zero, 0);
6057   TEST_ff_i (isgreaterequal, nan_value, (FLOAT) 1, 0);
6058   TEST_ff_i (isgreaterequal, nan_value, nan_value, 0);
6059
6060   END (isgreaterequal);
6061 }
6062
6063 static void
6064 isinf_test (void)
6065 {
6066   START (isinf);
6067
6068   TEST_f_b (isinf, 0, 0);
6069   TEST_f_b (isinf, minus_zero, 0);
6070   TEST_f_b (isinf, 10, 0);
6071   TEST_f_b (isinf, min_subnorm_value, 0);
6072   TEST_f_b (isinf, plus_infty, 1);
6073   TEST_f_b (isinf, minus_infty, 1);
6074   TEST_f_b (isinf, nan_value, 0);
6075
6076   END (isinf);
6077 }
6078
6079 static void
6080 isless_test (void)
6081 {
6082   START (isless);
6083
6084   TEST_ff_i (isless, minus_zero, minus_zero, 0);
6085   TEST_ff_i (isless, minus_zero, plus_zero, 0);
6086   TEST_ff_i (isless, minus_zero, (FLOAT) 1, 1);
6087   TEST_ff_i (isless, minus_zero, nan_value, 0);
6088   TEST_ff_i (isless, plus_zero, minus_zero, 0);
6089   TEST_ff_i (isless, plus_zero, plus_zero, 0);
6090   TEST_ff_i (isless, plus_zero, (FLOAT) 1, 1);
6091   TEST_ff_i (isless, plus_zero, nan_value, 0);
6092   TEST_ff_i (isless, (FLOAT) 1, minus_zero, 0);
6093   TEST_ff_i (isless, (FLOAT) 1, plus_zero, 0);
6094   TEST_ff_i (isless, (FLOAT) 1, (FLOAT) 1, 0);
6095   TEST_ff_i (isless, (FLOAT) 1, nan_value, 0);
6096   TEST_ff_i (isless, nan_value, minus_zero, 0);
6097   TEST_ff_i (isless, nan_value, plus_zero, 0);
6098   TEST_ff_i (isless, nan_value, (FLOAT) 1, 0);
6099   TEST_ff_i (isless, nan_value, nan_value, 0);
6100
6101   END (isless);
6102 }
6103
6104 static void
6105 islessequal_test (void)
6106 {
6107   START (islessequal);
6108
6109   TEST_ff_i (islessequal, minus_zero, minus_zero, 1);
6110   TEST_ff_i (islessequal, minus_zero, plus_zero, 1);
6111   TEST_ff_i (islessequal, minus_zero, (FLOAT) 1, 1);
6112   TEST_ff_i (islessequal, minus_zero, nan_value, 0);
6113   TEST_ff_i (islessequal, plus_zero, minus_zero, 1);
6114   TEST_ff_i (islessequal, plus_zero, plus_zero, 1);
6115   TEST_ff_i (islessequal, plus_zero, (FLOAT) 1, 1);
6116   TEST_ff_i (islessequal, plus_zero, nan_value, 0);
6117   TEST_ff_i (islessequal, (FLOAT) 1, minus_zero, 0);
6118   TEST_ff_i (islessequal, (FLOAT) 1, plus_zero, 0);
6119   TEST_ff_i (islessequal, (FLOAT) 1, (FLOAT) 1, 1);
6120   TEST_ff_i (islessequal, (FLOAT) 1, nan_value, 0);
6121   TEST_ff_i (islessequal, nan_value, minus_zero, 0);
6122   TEST_ff_i (islessequal, nan_value, plus_zero, 0);
6123   TEST_ff_i (islessequal, nan_value, (FLOAT) 1, 0);
6124   TEST_ff_i (islessequal, nan_value, nan_value, 0);
6125
6126   END (islessequal);
6127 }
6128
6129 static void
6130 islessgreater_test (void)
6131 {
6132   START (islessgreater);
6133
6134   TEST_ff_i (islessgreater, minus_zero, minus_zero, 0);
6135   TEST_ff_i (islessgreater, minus_zero, plus_zero, 0);
6136   TEST_ff_i (islessgreater, minus_zero, (FLOAT) 1, 1);
6137   TEST_ff_i (islessgreater, minus_zero, nan_value, 0);
6138   TEST_ff_i (islessgreater, plus_zero, minus_zero, 0);
6139   TEST_ff_i (islessgreater, plus_zero, plus_zero, 0);
6140   TEST_ff_i (islessgreater, plus_zero, (FLOAT) 1, 1);
6141   TEST_ff_i (islessgreater, plus_zero, nan_value, 0);
6142   TEST_ff_i (islessgreater, (FLOAT) 1, minus_zero, 1);
6143   TEST_ff_i (islessgreater, (FLOAT) 1, plus_zero, 1);
6144   TEST_ff_i (islessgreater, (FLOAT) 1, (FLOAT) 1, 0);
6145   TEST_ff_i (islessgreater, (FLOAT) 1, nan_value, 0);
6146   TEST_ff_i (islessgreater, nan_value, minus_zero, 0);
6147   TEST_ff_i (islessgreater, nan_value, plus_zero, 0);
6148   TEST_ff_i (islessgreater, nan_value, (FLOAT) 1, 0);
6149   TEST_ff_i (islessgreater, nan_value, nan_value, 0);
6150
6151   END (islessgreater);
6152 }
6153
6154 static void
6155 isnan_test (void)
6156 {
6157   START (isnan);
6158
6159   TEST_f_b (isnan, 0, 0);
6160   TEST_f_b (isnan, minus_zero, 0);
6161   TEST_f_b (isnan, 10, 0);
6162   TEST_f_b (isnan, min_subnorm_value, 0);
6163   TEST_f_b (isnan, plus_infty, 0);
6164   TEST_f_b (isnan, minus_infty, 0);
6165   TEST_f_b (isnan, nan_value, 1);
6166
6167   END (isnan);
6168 }
6169
6170 static void
6171 isnormal_test (void)
6172 {
6173   START (isnormal);
6174
6175   TEST_f_b (isnormal, 0, 0);
6176   TEST_f_b (isnormal, minus_zero, 0);
6177   TEST_f_b (isnormal, 10, 1);
6178   TEST_f_b (isnormal, min_subnorm_value, 0);
6179   TEST_f_b (isnormal, plus_infty, 0);
6180   TEST_f_b (isnormal, minus_infty, 0);
6181   TEST_f_b (isnormal, nan_value, 0);
6182
6183   END (isnormal);
6184 }
6185
6186 static void
6187 isunordered_test (void)
6188 {
6189   START (isunordered);
6190
6191   TEST_ff_i (isunordered, minus_zero, minus_zero, 0);
6192   TEST_ff_i (isunordered, minus_zero, plus_zero, 0);
6193   TEST_ff_i (isunordered, minus_zero, (FLOAT) 1, 0);
6194   TEST_ff_i (isunordered, minus_zero, nan_value, 1);
6195   TEST_ff_i (isunordered, plus_zero, minus_zero, 0);
6196   TEST_ff_i (isunordered, plus_zero, plus_zero, 0);
6197   TEST_ff_i (isunordered, plus_zero, (FLOAT) 1, 0);
6198   TEST_ff_i (isunordered, plus_zero, nan_value, 1);
6199   TEST_ff_i (isunordered, (FLOAT) 1, minus_zero, 0);
6200   TEST_ff_i (isunordered, (FLOAT) 1, plus_zero, 0);
6201   TEST_ff_i (isunordered, (FLOAT) 1, (FLOAT) 1, 0);
6202   TEST_ff_i (isunordered, (FLOAT) 1, nan_value, 1);
6203   TEST_ff_i (isunordered, nan_value, minus_zero, 1);
6204   TEST_ff_i (isunordered, nan_value, plus_zero, 1);
6205   TEST_ff_i (isunordered, nan_value, (FLOAT) 1, 1);
6206   TEST_ff_i (isunordered, nan_value, nan_value, 1);
6207
6208   END (isunordered);
6209 }
6210
6211 static void
6212 j0_test (void)
6213 {
6214   FLOAT s, c;
6215   errno = 0;
6216   FUNC (sincos) (0, &s, &c);
6217   if (errno == ENOSYS)
6218     /* Required function not implemented.  */
6219     return;
6220   FUNC(j0) (0);
6221   if (errno == ENOSYS)
6222     /* Function not implemented.  */
6223     return;
6224
6225   START (j0);
6226
6227   /* j0 is the Bessel function of the first kind of order 0 */
6228   TEST_f_f (j0, nan_value, nan_value);
6229   TEST_f_f (j0, plus_infty, 0);
6230   TEST_f_f (j0, -1.0, 0.765197686557966551449717526102663221L);
6231   TEST_f_f (j0, 0.0, 1.0);
6232   TEST_f_f (j0, 0.125L, 0.996097563041985204620768999453174712L);
6233   TEST_f_f (j0, 0.75L, 0.864242275166648623555731103820923211L);
6234   TEST_f_f (j0, 1.0, 0.765197686557966551449717526102663221L);
6235   TEST_f_f (j0, 1.5, 0.511827671735918128749051744283411720L);
6236   TEST_f_f (j0, 2.0, 0.223890779141235668051827454649948626L);
6237   TEST_f_f (j0, 8.0, 0.171650807137553906090869407851972001L);
6238   TEST_f_f (j0, 10.0, -0.245935764451348335197760862485328754L);
6239   TEST_f_f (j0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
6240   TEST_f_f (j0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
6241
6242   /* Bug 14155: spurious exception may occur.  */
6243   TEST_f_f (j0, 0x1.d7ce3ap+107L, 2.775523647291230802651040996274861694514e-17L, UNDERFLOW_EXCEPTION_OK);
6244
6245 #ifndef TEST_FLOAT
6246   /* Bug 14155: spurious exception may occur.  */
6247   TEST_f_f (j0, -0x1.001000001p+593L, -3.927269966354206207832593635798954916263e-90L, UNDERFLOW_EXCEPTION_OK);
6248 #endif
6249
6250   END (j0);
6251 }
6252
6253
6254 static void
6255 j1_test (void)
6256 {
6257   FLOAT s, c;
6258   errno = 0;
6259   FUNC (sincos) (0, &s, &c);
6260   if (errno == ENOSYS)
6261     /* Required function not implemented.  */
6262     return;
6263   FUNC(j1) (0);
6264   if (errno == ENOSYS)
6265     /* Function not implemented.  */
6266     return;
6267
6268   /* j1 is the Bessel function of the first kind of order 1 */
6269
6270   START (j1);
6271
6272   TEST_f_f (j1, nan_value, nan_value);
6273   TEST_f_f (j1, plus_infty, 0);
6274
6275   TEST_f_f (j1, -1.0, -0.440050585744933515959682203718914913L);
6276   TEST_f_f (j1, 0.0, 0.0);
6277   TEST_f_f (j1, 0.125L, 0.0623780091344946810942311355879361177L);
6278   TEST_f_f (j1, 0.75L, 0.349243602174862192523281016426251335L);
6279   TEST_f_f (j1, 1.0, 0.440050585744933515959682203718914913L);
6280   TEST_f_f (j1, 1.5, 0.557936507910099641990121213156089400L);
6281   TEST_f_f (j1, 2.0, 0.576724807756873387202448242269137087L);
6282   TEST_f_f (j1, 8.0, 0.234636346853914624381276651590454612L);
6283   TEST_f_f (j1, 10.0, 0.0434727461688614366697487680258592883L);
6284
6285   TEST_f_f (j1, 0x1.3ffp+74L, 1.818984347516051243459364437186082741567e-12L);
6286
6287 #ifndef TEST_FLOAT
6288   /* Bug 14155: spurious exception may occur.  */
6289   TEST_f_f (j1, 0x1.ff00000000002p+840L, 1.846591691699331493194965158699937660696e-127L, UNDERFLOW_EXCEPTION_OK);
6290 #endif
6291
6292   END (j1);
6293 }
6294
6295 static void
6296 jn_test (void)
6297 {
6298   FLOAT s, c;
6299   errno = 0;
6300   FUNC (sincos) (0, &s, &c);
6301   if (errno == ENOSYS)
6302     /* Required function not implemented.  */
6303     return;
6304   FUNC(jn) (1, 1);
6305   if (errno == ENOSYS)
6306     /* Function not implemented.  */
6307     return;
6308
6309   /* jn is the Bessel function of the first kind of order n.  */
6310   START (jn);
6311
6312   /* jn (0, x) == j0 (x)  */
6313   TEST_ff_f (jn, 0, nan_value, nan_value);
6314   TEST_ff_f (jn, 0, plus_infty, 0);
6315   TEST_ff_f (jn, 0, -1.0, 0.765197686557966551449717526102663221L);
6316   TEST_ff_f (jn, 0, 0.0, 1.0);
6317   TEST_ff_f (jn, 0, 0.125L, 0.996097563041985204620768999453174712L);
6318   TEST_ff_f (jn, 0, 0.75L, 0.864242275166648623555731103820923211L);
6319   TEST_ff_f (jn, 0, 1.0, 0.765197686557966551449717526102663221L);
6320   TEST_ff_f (jn, 0, 1.5, 0.511827671735918128749051744283411720L);
6321   TEST_ff_f (jn, 0, 2.0, 0.223890779141235668051827454649948626L);
6322   TEST_ff_f (jn, 0, 8.0, 0.171650807137553906090869407851972001L);
6323   TEST_ff_f (jn, 0, 10.0, -0.245935764451348335197760862485328754L);
6324   TEST_ff_f (jn, 0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
6325   TEST_ff_f (jn, 0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
6326
6327   /* jn (1, x) == j1 (x)  */
6328   TEST_ff_f (jn, 1, nan_value, nan_value);
6329   TEST_ff_f (jn, 1, plus_infty, 0);
6330   TEST_ff_f (jn, 1, -1.0, -0.440050585744933515959682203718914913L);
6331   TEST_ff_f (jn, 1, 0.0, 0.0);
6332   TEST_ff_f (jn, 1, 0.125L, 0.0623780091344946810942311355879361177L);
6333   TEST_ff_f (jn, 1, 0.75L, 0.349243602174862192523281016426251335L);
6334   TEST_ff_f (jn, 1, 1.0, 0.440050585744933515959682203718914913L);
6335   TEST_ff_f (jn, 1, 1.5, 0.557936507910099641990121213156089400L);
6336   TEST_ff_f (jn, 1, 2.0, 0.576724807756873387202448242269137087L);
6337   TEST_ff_f (jn, 1, 8.0, 0.234636346853914624381276651590454612L);
6338   TEST_ff_f (jn, 1, 10.0, 0.0434727461688614366697487680258592883L);
6339
6340   /* jn (3, x)  */
6341   TEST_ff_f (jn, 3, nan_value, nan_value);
6342   TEST_ff_f (jn, 3, plus_infty, 0);
6343
6344   TEST_ff_f (jn, 3, -1.0, -0.0195633539826684059189053216217515083L);
6345   TEST_ff_f (jn, 3, 0.0, 0.0);
6346   TEST_ff_f (jn, 3, 0.125L, 0.406503832554912875023029337653442868e-4L);
6347   TEST_ff_f (jn, 3, 0.75L, 0.848438342327410884392755236884386804e-2L);
6348   TEST_ff_f (jn, 3, 1.0, 0.0195633539826684059189053216217515083L);
6349   TEST_ff_f (jn, 3, 2.0, 0.128943249474402051098793332969239835L);
6350   TEST_ff_f (jn, 3, 10.0, 0.0583793793051868123429354784103409563L);
6351
6352   /*  jn (10, x)  */
6353   TEST_ff_f (jn, 10, nan_value, nan_value);
6354   TEST_ff_f (jn, 10, plus_infty, 0);
6355
6356   TEST_ff_f (jn, 10, -1.0, 0.263061512368745320699785368779050294e-9L);
6357   TEST_ff_f (jn, 10, 0.0, 0.0);
6358   TEST_ff_f (jn, 10, 0.125L, 0.250543369809369890173993791865771547e-18L);
6359   TEST_ff_f (jn, 10, 0.75L, 0.149621713117596814698712483621682835e-10L);
6360   TEST_ff_f (jn, 10, 1.0, 0.263061512368745320699785368779050294e-9L);
6361   TEST_ff_f (jn, 10, 2.0, 0.251538628271673670963516093751820639e-6L);
6362   TEST_ff_f (jn, 10, 10.0, 0.207486106633358857697278723518753428L);
6363
6364   /* BZ #11589 .*/
6365   TEST_ff_f (jn, 2, 2.4048255576957729L, 0.43175480701968038399746111312430703L);
6366   TEST_ff_f (jn, 3, 2.4048255576957729L, 0.19899990535769083404042146764530813L);
6367   TEST_ff_f (jn, 4, 2.4048255576957729L, 0.647466661641779720084932282551219891E-1L);
6368   TEST_ff_f (jn, 5, 2.4048255576957729L, 0.163892432048058525099230549946147698E-1L);
6369   TEST_ff_f (jn, 6, 2.4048255576957729L, 0.34048184720278336646673682895929161E-2L);
6370   TEST_ff_f (jn, 7, 2.4048255576957729L, 0.60068836573295394221291569249883076E-3L);
6371   TEST_ff_f (jn, 8, 2.4048255576957729L, 0.92165786705344923232879022467054148E-4L);
6372   TEST_ff_f (jn, 9, 2.4048255576957729L, 0.12517270977961513005428966643852564E-4L);
6373
6374   /* Bug 14155: spurious exception may occur.  */
6375   TEST_ff_f (jn, 2, 0x1.ffff62p+99L, -4.43860668048170034334926693188979974489e-16L, UNDERFLOW_EXCEPTION_OK);
6376
6377   END (jn);
6378 }
6379
6380
6381 static void
6382 ldexp_test (void)
6383 {
6384   TEST_ff_f (ldexp, 0, 0, 0);
6385   TEST_ff_f (ldexp, minus_zero, 0, minus_zero);
6386
6387   TEST_ff_f (ldexp, plus_infty, 1, plus_infty);
6388   TEST_ff_f (ldexp, minus_infty, 1, minus_infty);
6389   TEST_ff_f (ldexp, nan_value, 1, nan_value);
6390
6391   TEST_ff_f (ldexp, 0.8L, 4, 12.8L);
6392   TEST_ff_f (ldexp, -0.854375L, 5, -27.34L);
6393
6394   /* ldexp (x, 0) == x.  */
6395   TEST_ff_f (ldexp, 1.0L, 0L, 1.0L);
6396 }
6397
6398
6399 static void
6400 lgamma_test (void)
6401 {
6402   errno = 0;
6403   FUNC(lgamma) (0);
6404   if (errno == ENOSYS)
6405     /* Function not implemented.  */
6406     return;
6407
6408   START (lgamma);
6409
6410   TEST_f_f (lgamma, plus_infty, plus_infty);
6411   TEST_f_f (lgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6412   check_int ("signgam for lgamma(0) == 1", signgam, 1, 0, 0, 0);
6413   TEST_f_f (lgamma, minus_zero, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6414   check_int ("signgam for lgamma(-0) == -1", signgam, -1, 0, 0, 0);
6415   TEST_f_f (lgamma, nan_value, nan_value);
6416
6417   /* lgamma (x) == +inf plus divide by zero exception for integer x <= 0.  */
6418   errno = 0;
6419   TEST_f_f (lgamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6420   check_int ("errno for lgamma(-integer) == ERANGE", errno, ERANGE, 0, 0, 0);
6421   TEST_f_f (lgamma, minus_infty, plus_infty);
6422   TEST_f_f (lgamma, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6423   TEST_f_f (lgamma, max_value, plus_infty, OVERFLOW_EXCEPTION);
6424
6425   TEST_f_f1 (lgamma, 1, 0, 1);
6426
6427   TEST_f_f1 (lgamma, 3, M_LN2l, 1);
6428
6429   TEST_f_f1 (lgamma, 0.5, M_LOG_SQRT_PIl, 1);
6430   TEST_f_f1 (lgamma, -0.5, M_LOG_2_SQRT_PIl, -1);
6431   TEST_f_f1 (lgamma, 0.7L, 0.260867246531666514385732417016759578L, 1);
6432   TEST_f_f1 (lgamma, 1.2L, -0.853740900033158497197028392998854470e-1L, 1);
6433
6434   END (lgamma);
6435 }
6436
6437
6438 static void
6439 lrint_test (void)
6440 {
6441   /* XXX this test is incomplete.  We need to have a way to specifiy
6442      the rounding method and test the critical cases.  So far, only
6443      unproblematic numbers are tested.  */
6444
6445   START (lrint);
6446
6447   TEST_f_l (lrint, 0.0, 0);
6448   TEST_f_l (lrint, minus_zero, 0);
6449   TEST_f_l (lrint, 0.2L, 0);
6450   TEST_f_l (lrint, -0.2L, 0);
6451
6452   TEST_f_l (lrint, 1.4L, 1);
6453   TEST_f_l (lrint, -1.4L, -1);
6454
6455   TEST_f_l (lrint, 8388600.3L, 8388600);
6456   TEST_f_l (lrint, -8388600.3L, -8388600);
6457
6458   TEST_f_l (lrint, 1071930.0008, 1071930);
6459 #ifndef TEST_FLOAT
6460   TEST_f_l (lrint, 1073741824.01, 1073741824);
6461 # if LONG_MAX > 281474976710656
6462   TEST_f_l (lrint, 281474976710656.025, 281474976710656);
6463 # endif
6464 #endif
6465
6466   END (lrint);
6467 }
6468
6469
6470 static void
6471 lrint_test_tonearest (void)
6472 {
6473   int save_round_mode;
6474   START (lrint_tonearest);
6475
6476   save_round_mode = fegetround ();
6477
6478   if (!fesetround (FE_TONEAREST))
6479     {
6480       TEST_f_l (lrint, 0.0, 0);
6481       TEST_f_l (lrint, minus_zero, 0);
6482       TEST_f_l (lrint, 0.2L, 0);
6483       TEST_f_l (lrint, -0.2L, 0);
6484       TEST_f_l (lrint, 0.5L, 0);
6485       TEST_f_l (lrint, -0.5L, 0);
6486       TEST_f_l (lrint, 0.8L, 1);
6487       TEST_f_l (lrint, -0.8L, -1);
6488
6489       TEST_f_l (lrint, 1.4L, 1);
6490       TEST_f_l (lrint, -1.4L, -1);
6491
6492       TEST_f_l (lrint, 8388600.3L, 8388600);
6493       TEST_f_l (lrint, -8388600.3L, -8388600);
6494
6495       TEST_f_l (lrint, 1071930.0008, 1071930);
6496 #ifndef TEST_FLOAT
6497       TEST_f_l (lrint, 1073741824.01, 1073741824);
6498 # if LONG_MAX > 281474976710656
6499       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
6500 # endif
6501 #endif
6502     }
6503
6504   fesetround (save_round_mode);
6505
6506   END (lrint_tonearest);
6507 }
6508
6509
6510 static void
6511 lrint_test_towardzero (void)
6512 {
6513   int save_round_mode;
6514   START (lrint_towardzero);
6515
6516   save_round_mode = fegetround ();
6517
6518   if (!fesetround (FE_TOWARDZERO))
6519     {
6520       TEST_f_l (lrint, 0.0, 0);
6521       TEST_f_l (lrint, minus_zero, 0);
6522       TEST_f_l (lrint, 0.2L, 0);
6523       TEST_f_l (lrint, -0.2L, 0);
6524       TEST_f_l (lrint, 0.5L, 0);
6525       TEST_f_l (lrint, -0.5L, 0);
6526       TEST_f_l (lrint, 0.8L, 0);
6527       TEST_f_l (lrint, -0.8L, 0);
6528
6529       TEST_f_l (lrint, 1.4L, 1);
6530       TEST_f_l (lrint, -1.4L, -1);
6531
6532       TEST_f_l (lrint, 8388600.3L, 8388600);
6533       TEST_f_l (lrint, -8388600.3L, -8388600);
6534
6535       TEST_f_l (lrint, 1071930.0008, 1071930);
6536 #ifndef TEST_FLOAT
6537       TEST_f_l (lrint, 1073741824.01, 1073741824);
6538 # if LONG_MAX > 281474976710656
6539       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
6540 # endif
6541 #endif
6542     }
6543
6544   fesetround (save_round_mode);
6545
6546   END (lrint_towardzero);
6547 }
6548
6549
6550 static void
6551 lrint_test_downward (void)
6552 {
6553   int save_round_mode;
6554   START (lrint_downward);
6555
6556   save_round_mode = fegetround ();
6557
6558   if (!fesetround (FE_DOWNWARD))
6559     {
6560       TEST_f_l (lrint, 0.0, 0);
6561       TEST_f_l (lrint, minus_zero, 0);
6562       TEST_f_l (lrint, 0.2L, 0);
6563       TEST_f_l (lrint, -0.2L, -1);
6564       TEST_f_l (lrint, 0.5L, 0);
6565       TEST_f_l (lrint, -0.5L, -1);
6566       TEST_f_l (lrint, 0.8L, 0);
6567       TEST_f_l (lrint, -0.8L, -1);
6568
6569       TEST_f_l (lrint, 1.4L, 1);
6570       TEST_f_l (lrint, -1.4L, -2);
6571
6572       TEST_f_l (lrint, 8388600.3L, 8388600);
6573       TEST_f_l (lrint, -8388600.3L, -8388601);
6574
6575       TEST_f_l (lrint, 1071930.0008, 1071930);
6576 #ifndef TEST_FLOAT
6577       TEST_f_l (lrint, 1073741824.01, 1073741824);
6578 # if LONG_MAX > 281474976710656
6579       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
6580 # endif
6581 #endif
6582     }
6583
6584   fesetround (save_round_mode);
6585
6586   END (lrint_downward);
6587 }
6588
6589
6590 static void
6591 lrint_test_upward (void)
6592 {
6593   int save_round_mode;
6594   START (lrint_upward);
6595
6596   save_round_mode = fegetround ();
6597
6598   if (!fesetround (FE_UPWARD))
6599     {
6600       TEST_f_l (lrint, 0.0, 0);
6601       TEST_f_l (lrint, minus_zero, 0);
6602       TEST_f_l (lrint, 0.2L, 1);
6603       TEST_f_l (lrint, -0.2L, 0);
6604       TEST_f_l (lrint, 0.5L, 1);
6605       TEST_f_l (lrint, -0.5L, 0);
6606       TEST_f_l (lrint, 0.8L, 1);
6607       TEST_f_l (lrint, -0.8L, 0);
6608
6609       TEST_f_l (lrint, 1.4L, 2);
6610       TEST_f_l (lrint, -1.4L, -1);
6611
6612       TEST_f_l (lrint, 8388600.3L, 8388601);
6613       TEST_f_l (lrint, -8388600.3L, -8388600);
6614
6615 #ifndef TEST_FLOAT
6616       TEST_f_l (lrint, 1071930.0008, 1071931);
6617       TEST_f_l (lrint, 1073741824.01, 1073741825);
6618 # if LONG_MAX > 281474976710656 && defined (TEST_LDOUBLE)
6619       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
6620 # endif
6621 #endif
6622     }
6623
6624   fesetround (save_round_mode);
6625
6626   END (lrint_upward);
6627 }
6628
6629
6630 static void
6631 llrint_test (void)
6632 {
6633   /* XXX this test is incomplete.  We need to have a way to specifiy
6634      the rounding method and test the critical cases.  So far, only
6635      unproblematic numbers are tested.  */
6636
6637   START (llrint);
6638
6639   TEST_f_L (llrint, 0.0, 0);
6640   TEST_f_L (llrint, minus_zero, 0);
6641   TEST_f_L (llrint, 0.2L, 0);
6642   TEST_f_L (llrint, -0.2L, 0);
6643
6644   TEST_f_L (llrint, 1.4L, 1);
6645   TEST_f_L (llrint, -1.4L, -1);
6646
6647   TEST_f_L (llrint, 8388600.3L, 8388600);
6648   TEST_f_L (llrint, -8388600.3L, -8388600);
6649
6650   TEST_f_l (llrint, 1071930.0008, 1071930);
6651
6652   /* Test boundary conditions.  */
6653   /* 0x1FFFFF */
6654   TEST_f_L (llrint, 2097151.0,2097151LL);
6655   /* 0x800000 */
6656   TEST_f_L (llrint, 8388608.0, 8388608LL);
6657   /* 0x1000000 */
6658   TEST_f_L (llrint, 16777216.0, 16777216LL);
6659   /* 0x20000000000 */
6660   TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
6661   /* 0x40000000000 */
6662   TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
6663   /* 0x1000000000000 */
6664   TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
6665   /* 0x10000000000000 */
6666   TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
6667   /* 0x10000080000000 */
6668   TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
6669   /* 0x20000000000000 */
6670   TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
6671   /* 0x80000000000000 */
6672   TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
6673   /* 0x100000000000000 */
6674   TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
6675 #ifdef TEST_LDOUBLE
6676   /* The input can only be represented in long double.  */
6677   TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
6678   TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
6679   TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
6680   TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
6681   TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
6682
6683   TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
6684   TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
6685   TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
6686   TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
6687   TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
6688
6689 # if LDBL_MANT_DIG > 100
6690   TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
6691   TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
6692   TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
6693   TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
6694   TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
6695   TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
6696
6697   TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
6698   TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
6699   TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
6700   TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
6701   TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
6702   TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
6703 #endif
6704
6705   TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
6706   TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
6707   TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
6708   TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
6709   TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
6710
6711   TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
6712   TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
6713   TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
6714   TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
6715   TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
6716
6717 # if LDBL_MANT_DIG > 100
6718   TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
6719   TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
6720   TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
6721   TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
6722   TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
6723   TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
6724
6725   TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
6726   TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
6727   TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
6728   TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
6729   TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
6730   TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
6731 #endif
6732
6733   TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
6734   TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
6735   TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
6736   TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
6737   TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
6738
6739   TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
6740   TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
6741   TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
6742   TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
6743   TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
6744
6745 # if LDBL_MANT_DIG > 100
6746   TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
6747   TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
6748   TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
6749   TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
6750   TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
6751   TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
6752   TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
6753   TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
6754   TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
6755   TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
6756   TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
6757   TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
6758 # endif
6759 #endif
6760
6761   END (llrint);
6762 }
6763
6764 static void
6765 llrint_test_tonearest (void)
6766 {
6767   int save_round_mode;
6768   START (llrint_tonearest);
6769
6770   save_round_mode = fegetround ();
6771
6772   if (!fesetround (FE_TONEAREST))
6773     {
6774       TEST_f_L (llrint, 0.0, 0);
6775       TEST_f_L (llrint, minus_zero, 0);
6776       TEST_f_L (llrint, 0.2L, 0);
6777       TEST_f_L (llrint, -0.2L, 0);
6778
6779       TEST_f_L (llrint, 1.4L, 1);
6780       TEST_f_L (llrint, -1.4L, -1);
6781
6782       TEST_f_L (llrint, 8388600.3L, 8388600);
6783       TEST_f_L (llrint, -8388600.3L, -8388600);
6784
6785       TEST_f_l (llrint, 1071930.0008, 1071930);
6786
6787       /* Test boundary conditions.  */
6788       /* 0x1FFFFF */
6789       TEST_f_L (llrint, 2097151.0,2097151LL);
6790       /* 0x800000 */
6791       TEST_f_L (llrint, 8388608.0, 8388608LL);
6792       /* 0x1000000 */
6793       TEST_f_L (llrint, 16777216.0, 16777216LL);
6794       /* 0x20000000000 */
6795       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
6796       /* 0x40000000000 */
6797       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
6798       /* 0x1000000000000 */
6799       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
6800       /* 0x10000000000000 */
6801       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
6802       /* 0x10000080000000 */
6803       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
6804       /* 0x20000000000000 */
6805       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
6806       /* 0x80000000000000 */
6807       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
6808       /* 0x100000000000000 */
6809       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
6810 #ifdef TEST_LDOUBLE
6811       /* The input can only be represented in long double.  */
6812       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
6813       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
6814       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
6815       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
6816       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
6817
6818       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
6819       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
6820       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
6821       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
6822       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
6823
6824 # if LDBL_MANT_DIG > 100
6825       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
6826       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
6827       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
6828       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
6829       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
6830       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
6831
6832       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
6833       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
6834       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
6835       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
6836       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
6837       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
6838 #endif
6839
6840       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
6841       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
6842       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
6843       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
6844       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
6845
6846       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
6847       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
6848       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
6849       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
6850       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
6851
6852 # if LDBL_MANT_DIG > 100
6853       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
6854       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
6855       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
6856       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
6857       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
6858       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
6859
6860       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
6861       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
6862       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
6863       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
6864       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
6865       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
6866 #endif
6867
6868       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
6869       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
6870       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
6871       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
6872       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
6873
6874       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
6875       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
6876       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
6877       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
6878       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
6879
6880 # if LDBL_MANT_DIG > 100
6881       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
6882       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
6883       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
6884       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
6885       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
6886       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
6887       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
6888       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
6889       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
6890       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
6891       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
6892       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
6893 # endif
6894 #endif
6895     }
6896
6897   fesetround (save_round_mode);
6898
6899   END (llrint_tonearest);
6900 }
6901
6902 static void
6903 llrint_test_towardzero (void)
6904 {
6905   int save_round_mode;
6906   START (llrint_towardzero);
6907
6908   save_round_mode = fegetround ();
6909
6910   if (!fesetround (FE_TOWARDZERO))
6911     {
6912       TEST_f_L (llrint, 0.0, 0);
6913       TEST_f_L (llrint, minus_zero, 0);
6914       TEST_f_L (llrint, 0.2L, 0);
6915       TEST_f_L (llrint, -0.2L, 0);
6916
6917       TEST_f_L (llrint, 1.4L, 1);
6918       TEST_f_L (llrint, -1.4L, -1);
6919
6920       TEST_f_L (llrint, 8388600.3L, 8388600);
6921       TEST_f_L (llrint, -8388600.3L, -8388600);
6922
6923       TEST_f_l (llrint, 1071930.0008, 1071930);
6924
6925       /* Test boundary conditions.  */
6926       /* 0x1FFFFF */
6927       TEST_f_L (llrint, 2097151.0,2097151LL);
6928       /* 0x800000 */
6929       TEST_f_L (llrint, 8388608.0, 8388608LL);
6930       /* 0x1000000 */
6931       TEST_f_L (llrint, 16777216.0, 16777216LL);
6932       /* 0x20000000000 */
6933       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
6934       /* 0x40000000000 */
6935       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
6936       /* 0x1000000000000 */
6937       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
6938       /* 0x10000000000000 */
6939       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
6940       /* 0x10000080000000 */
6941       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
6942       /* 0x20000000000000 */
6943       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
6944       /* 0x80000000000000 */
6945       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
6946       /* 0x100000000000000 */
6947       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
6948 #ifdef TEST_LDOUBLE
6949       /* The input can only be represented in long double.  */
6950       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370495LL);
6951       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
6952       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
6953       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370496LL);
6954       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370497LL);
6955
6956       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370495LL);
6957       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
6958       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
6959       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370496LL);
6960       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370497LL);
6961
6962 # if LDBL_MANT_DIG > 100
6963       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
6964       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
6965       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
6966       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370494LL);
6967       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370495LL);
6968       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370496LL);
6969
6970       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
6971       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
6972       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
6973       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370494LL);
6974       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370495LL);
6975       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370496LL);
6976 #endif
6977
6978       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740991LL);
6979       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
6980       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
6981       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740992LL);
6982       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740993LL);
6983
6984       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740991LL);
6985       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
6986       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
6987       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740992LL);
6988       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740993LL);
6989
6990 # if LDBL_MANT_DIG > 100
6991       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
6992       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
6993       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
6994       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740991LL);
6995       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740992LL);
6996       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740993LL);
6997
6998       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
6999       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
7000       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
7001       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740991LL);
7002       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740992LL);
7003       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740993LL);
7004 #endif
7005
7006       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927935LL);
7007       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
7008       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
7009       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927936LL);
7010       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927937LL);
7011
7012       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927935LL);
7013       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
7014       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
7015       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927936LL);
7016       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927937LL);
7017
7018 # if LDBL_MANT_DIG > 100
7019       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775805LL);
7020       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775805LL);
7021       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
7022       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
7023       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
7024       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
7025       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
7026       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
7027       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775806LL);
7028       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775806LL);
7029       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
7030       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
7031 # endif
7032 #endif
7033     }
7034
7035   fesetround (save_round_mode);
7036
7037   END (llrint_towardzero);
7038 }
7039
7040 static void
7041 llrint_test_downward (void)
7042 {
7043   int save_round_mode;
7044   START (llrint_downward);
7045
7046   save_round_mode = fegetround ();
7047
7048   if (!fesetround (FE_DOWNWARD))
7049     {
7050       TEST_f_L (llrint, 0.0, 0);
7051       TEST_f_L (llrint, minus_zero, 0);
7052       TEST_f_L (llrint, 0.2L, 0);
7053       TEST_f_L (llrint, -0.2L, -1);
7054
7055       TEST_f_L (llrint, 1.4L, 1);
7056       TEST_f_L (llrint, -1.4L, -2);
7057
7058       TEST_f_L (llrint, 8388600.3L, 8388600);
7059       TEST_f_L (llrint, -8388600.3L, -8388601);
7060
7061       TEST_f_l (llrint, 1071930.0008, 1071930);
7062
7063       /* Test boundary conditions.  */
7064       /* 0x1FFFFF */
7065       TEST_f_L (llrint, 2097151.0,2097151LL);
7066       /* 0x800000 */
7067       TEST_f_L (llrint, 8388608.0, 8388608LL);
7068       /* 0x1000000 */
7069       TEST_f_L (llrint, 16777216.0, 16777216LL);
7070       /* 0x20000000000 */
7071       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
7072       /* 0x40000000000 */
7073       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
7074       /* 0x1000000000000 */
7075       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
7076       /* 0x10000000000000 */
7077       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
7078       /* 0x10000080000000 */
7079       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
7080       /* 0x20000000000000 */
7081       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
7082       /* 0x80000000000000 */
7083       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
7084       /* 0x100000000000000 */
7085       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
7086 #ifdef TEST_LDOUBLE
7087       /* The input can only be represented in long double.  */
7088       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370495LL);
7089       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
7090       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
7091       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370496LL);
7092       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370497LL);
7093
7094       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
7095       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
7096       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
7097       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370494LL);
7098       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370495LL);
7099       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370496LL);
7100
7101       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
7102       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370497LL);
7103       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370497LL);
7104       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
7105       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
7106
7107       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370496LL);
7108       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370497LL);
7109       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370498LL);
7110       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
7111       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
7112       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
7113
7114       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740991LL);
7115       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
7116       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
7117       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740992LL);
7118       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740993LL);
7119
7120       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
7121       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
7122       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
7123       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740991LL);
7124       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740992LL);
7125       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740993LL);
7126
7127       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
7128       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740993LL);
7129       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740993LL);
7130       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
7131       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
7132
7133       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740992LL);
7134       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740993LL);
7135       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740994LL);
7136       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
7137       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
7138       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
7139
7140       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927935LL);
7141       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
7142       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
7143       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927936LL);
7144       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927937LL);
7145
7146       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
7147       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927937LL);
7148       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927937LL);
7149       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
7150       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
7151
7152 # if LDBL_MANT_DIG > 100
7153       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775805LL);
7154       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
7155       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
7156       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
7157       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
7158       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775807LL);
7159       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
7160       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775807LL);
7161       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775806LL);
7162       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
7163       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
7164       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
7165 # endif
7166 #endif
7167     }
7168
7169   fesetround (save_round_mode);
7170
7171   END (llrint_downward);
7172 }
7173
7174 static void
7175 llrint_test_upward (void)
7176 {
7177   int save_round_mode;
7178   START (llrint_upward);
7179
7180   save_round_mode = fegetround ();
7181
7182   if (!fesetround (FE_UPWARD))
7183     {
7184       TEST_f_L (llrint, 0.0, 0);
7185       TEST_f_L (llrint, minus_zero, 0);
7186       TEST_f_L (llrint, 0.2L, 1);
7187       TEST_f_L (llrint, -0.2L, 0);
7188
7189       TEST_f_L (llrint, 1.4L, 2);
7190       TEST_f_L (llrint, -1.4L, -1);
7191
7192       TEST_f_L (llrint, 8388600.3L, 8388601);
7193       TEST_f_L (llrint, -8388600.3L, -8388600);
7194 #ifndef TEST_FLOAT
7195       TEST_f_l (llrint, 1071930.0008, 1071931);
7196 #endif
7197       /* Test boundary conditions.  */
7198       /* 0x1FFFFF */
7199       TEST_f_L (llrint, 2097151.0,2097151LL);
7200       /* 0x800000 */
7201       TEST_f_L (llrint, 8388608.0, 8388608LL);
7202       /* 0x1000000 */
7203       TEST_f_L (llrint, 16777216.0, 16777216LL);
7204       /* 0x20000000000 */
7205       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
7206       /* 0x40000000000 */
7207       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
7208       /* 0x1000000000000 */
7209       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
7210       /* 0x10000000000000 */
7211       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
7212       /* 0x10000080000000 */
7213       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
7214       /* 0x20000000000000 */
7215       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
7216       /* 0x80000000000000 */
7217       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
7218       /* 0x100000000000000 */
7219       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
7220 #ifdef TEST_LDOUBLE
7221       /* The input can only be represented in long double.  */
7222       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
7223       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370497LL);
7224       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370497LL);
7225       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
7226       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
7227
7228       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370496LL);
7229       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370497LL);
7230       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370498LL);
7231       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
7232       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
7233       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
7234
7235       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370495LL);
7236       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
7237       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
7238       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370496LL);
7239       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370497LL);
7240
7241       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
7242       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
7243       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
7244       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370494LL);
7245       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370495LL);
7246       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370496LL);
7247
7248       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
7249       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740993LL);
7250       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740993LL);
7251       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
7252       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
7253
7254       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740992LL);
7255       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740993LL);
7256       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740994LL);
7257       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
7258       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
7259       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
7260
7261       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740991LL);
7262       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
7263       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
7264       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740992LL);
7265       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740993LL);
7266
7267       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
7268       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
7269       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
7270       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740991LL);
7271       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740992LL);
7272       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740993LL);
7273
7274       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
7275       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927937LL);
7276       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927937LL);
7277       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
7278       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
7279
7280       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927935LL);
7281       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
7282       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
7283       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927936LL);
7284       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927937LL);
7285
7286 # if LDBL_MANT_DIG > 100
7287       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
7288       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775805LL);
7289       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
7290       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
7291       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775807LL);
7292       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
7293       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775807L);
7294       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
7295       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
7296       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775806LL);
7297       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
7298       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
7299 # endif
7300 #endif
7301     }
7302
7303   fesetround (save_round_mode);
7304
7305   END (llrint_upward);
7306 }
7307
7308
7309 static void
7310 log_test (void)
7311 {
7312   errno = 0;
7313   FUNC(log) (1);
7314   if (errno == ENOSYS)
7315     /* Function not implemented.  */
7316     return;
7317   START (log);
7318
7319   TEST_f_f (log, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7320   TEST_f_f (log, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7321
7322   TEST_f_f (log, 1, 0);
7323
7324   TEST_f_f (log, -1, nan_value, INVALID_EXCEPTION);
7325   TEST_f_f (log, -max_value, nan_value, INVALID_EXCEPTION);
7326   TEST_f_f (log, minus_infty, nan_value, INVALID_EXCEPTION);
7327   TEST_f_f (log, plus_infty, plus_infty);
7328   TEST_f_f (log, nan_value, nan_value);
7329
7330   TEST_f_f (log, M_El, 1);
7331   TEST_f_f (log, 1.0 / M_El, -1);
7332   TEST_f_f (log, 2, M_LN2l);
7333   TEST_f_f (log, 10, M_LN10l);
7334   TEST_f_f (log, 0.75L, -0.287682072451780927439219005993827432L);
7335
7336   END (log);
7337 }
7338
7339
7340 static void
7341 log10_test (void)
7342 {
7343   errno = 0;
7344   FUNC(log10) (1);
7345   if (errno == ENOSYS)
7346     /* Function not implemented.  */
7347     return;
7348
7349   START (log10);
7350
7351   TEST_f_f (log10, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7352   TEST_f_f (log10, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7353
7354   TEST_f_f (log10, 1, 0);
7355
7356   /* log10 (x) == NaN plus invalid exception if x < 0.  */
7357   TEST_f_f (log10, -1, nan_value, INVALID_EXCEPTION);
7358   TEST_f_f (log10, -max_value, nan_value, INVALID_EXCEPTION);
7359   TEST_f_f (log10, minus_infty, nan_value, INVALID_EXCEPTION);
7360
7361   TEST_f_f (log10, plus_infty, plus_infty);
7362   TEST_f_f (log10, nan_value, nan_value);
7363
7364   TEST_f_f (log10, 0.1L, -1);
7365   TEST_f_f (log10, 10.0, 1);
7366   TEST_f_f (log10, 100.0, 2);
7367   TEST_f_f (log10, 10000.0, 4);
7368   TEST_f_f (log10, M_El, M_LOG10El);
7369   TEST_f_f (log10, 0.75L, -0.124938736608299953132449886193870744L);
7370
7371   END (log10);
7372 }
7373
7374
7375 static void
7376 log1p_test (void)
7377 {
7378   errno = 0;
7379   FUNC(log1p) (0);
7380   if (errno == ENOSYS)
7381     /* Function not implemented.  */
7382     return;
7383
7384   START (log1p);
7385
7386   TEST_f_f (log1p, 0, 0);
7387   TEST_f_f (log1p, minus_zero, minus_zero);
7388
7389   TEST_f_f (log1p, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7390   TEST_f_f (log1p, -2, nan_value, INVALID_EXCEPTION);
7391   TEST_f_f (log1p, -max_value, nan_value, INVALID_EXCEPTION);
7392   TEST_f_f (log1p, minus_infty, nan_value, INVALID_EXCEPTION);
7393
7394   TEST_f_f (log1p, plus_infty, plus_infty);
7395   TEST_f_f (log1p, nan_value, nan_value);
7396
7397   TEST_f_f (log1p, M_El - 1.0, 1);
7398
7399   TEST_f_f (log1p, -0.25L, -0.287682072451780927439219005993827432L);
7400   TEST_f_f (log1p, -0.875, -2.07944154167983592825169636437452970L);
7401
7402   END (log1p);
7403 }
7404
7405
7406 static void
7407 log2_test (void)
7408 {
7409   errno = 0;
7410   FUNC(log2) (1);
7411   if (errno == ENOSYS)
7412     /* Function not implemented.  */
7413     return;
7414
7415   START (log2);
7416
7417   TEST_f_f (log2, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7418   TEST_f_f (log2, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7419
7420   TEST_f_f (log2, 1, 0);
7421
7422   TEST_f_f (log2, -1, nan_value, INVALID_EXCEPTION);
7423   TEST_f_f (log2, -max_value, nan_value, INVALID_EXCEPTION);
7424   TEST_f_f (log2, minus_infty, nan_value, INVALID_EXCEPTION);
7425
7426   TEST_f_f (log2, plus_infty, plus_infty);
7427   TEST_f_f (log2, nan_value, nan_value);
7428
7429   TEST_f_f (log2, M_El, M_LOG2El);
7430   TEST_f_f (log2, 2.0, 1);
7431   TEST_f_f (log2, 16.0, 4);
7432   TEST_f_f (log2, 256.0, 8);
7433   TEST_f_f (log2, 0.75L, -.415037499278843818546261056052183492L);
7434
7435   END (log2);
7436 }
7437
7438
7439 static void
7440 logb_test (void)
7441 {
7442   START (logb);
7443
7444   TEST_f_f (logb, plus_infty, plus_infty);
7445   TEST_f_f (logb, minus_infty, plus_infty);
7446
7447   TEST_f_f (logb, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7448
7449   TEST_f_f (logb, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7450   TEST_f_f (logb, nan_value, nan_value);
7451
7452   TEST_f_f (logb, 1, 0);
7453   TEST_f_f (logb, M_El, 1);
7454   TEST_f_f (logb, 1024, 10);
7455   TEST_f_f (logb, -2000, 10);
7456
7457   TEST_f_f (logb, 0x0.1p-127, -131);
7458   TEST_f_f (logb, 0x0.01p-127, -135);
7459   TEST_f_f (logb, 0x0.011p-127, -135);
7460 #ifndef TEST_FLOAT
7461   TEST_f_f (logb, 0x0.8p-1022, -1023);
7462   TEST_f_f (logb, 0x0.1p-1022, -1026);
7463   TEST_f_f (logb, 0x0.00111p-1022, -1034);
7464   TEST_f_f (logb, 0x0.00001p-1022, -1042);
7465   TEST_f_f (logb, 0x0.000011p-1022, -1042);
7466   TEST_f_f (logb, 0x0.0000000000001p-1022, -1074);
7467 #endif
7468 #if defined TEST_LDOUBLE && LDBL_MIN_EXP - LDBL_MANT_DIG <= -16400
7469   TEST_f_f (logb, 0x1p-16400L, -16400);
7470   TEST_f_f (logb, 0x.00000000001p-16382L, -16426);
7471 #endif
7472
7473   END (logb);
7474 }
7475
7476 static void
7477 logb_test_downward (void)
7478 {
7479   int save_round_mode;
7480   errno = 0;
7481
7482   FUNC(logb) (0);
7483   if (errno == ENOSYS)
7484     /* Function not implemented.  */
7485     return;
7486
7487   START (logb_downward);
7488
7489   save_round_mode = fegetround ();
7490
7491   if (!fesetround (FE_DOWNWARD))
7492     {
7493
7494       /* IEEE 754-2008 says (section 5.3.3) that "logB(1) is +0.".  Libm
7495          should not return -0 from logb in any rounding mode.  PowerPC32 has
7496          failed with this test for power4 logb (and logbl on all PowerPC
7497          platforms) in the past due to instruction selection.  GCC PR 52775
7498          provides the availability of the fcfid insn in 32-bit mode which
7499          eliminates the use of fsub in this instance and prevents the negative
7500          signed 0.0.  */
7501
7502       /* BZ #887  */
7503       TEST_f_f (logb, 1.000e+0, plus_zero);
7504     }
7505
7506   fesetround (save_round_mode);
7507
7508   END (logb_downward);
7509 }
7510
7511 static void
7512 lround_test (void)
7513 {
7514   START (lround);
7515
7516   TEST_f_l (lround, 0, 0);
7517   TEST_f_l (lround, minus_zero, 0);
7518   TEST_f_l (lround, 0.2L, 0.0);
7519   TEST_f_l (lround, -0.2L, 0);
7520   TEST_f_l (lround, 0.5, 1);
7521   TEST_f_l (lround, -0.5, -1);
7522   TEST_f_l (lround, 0.8L, 1);
7523   TEST_f_l (lround, -0.8L, -1);
7524   TEST_f_l (lround, 1.5, 2);
7525   TEST_f_l (lround, -1.5, -2);
7526   TEST_f_l (lround, 22514.5, 22515);
7527   TEST_f_l (lround, -22514.5, -22515);
7528   TEST_f_l (lround, 1071930.0008, 1071930);
7529 #ifndef TEST_FLOAT
7530   TEST_f_l (lround, 1073741824.01, 1073741824);
7531 # if LONG_MAX > 281474976710656
7532   TEST_f_l (lround, 281474976710656.025, 281474976710656);
7533   TEST_f_l (lround, 18014398509481974, 18014398509481974);
7534 # endif
7535   TEST_f_l (lround, 2097152.5, 2097153);
7536   TEST_f_l (lround, -2097152.5, -2097153);
7537   /* nextafter(0.5,-1)  */
7538   TEST_f_l (lround, 0x1.fffffffffffffp-2, 0);
7539   /* nextafter(-0.5,1)  */
7540   TEST_f_l (lround, -0x1.fffffffffffffp-2, 0);
7541 #else
7542   /* nextafter(0.5,-1)  */
7543   TEST_f_l (lround, 0x1.fffffp-2, 0);
7544   /* nextafter(-0.5,1)  */
7545   TEST_f_l (lround, -0x1.fffffp-2, 0);
7546   TEST_f_l (lround, 0x1.fffffep+23, 16777215);
7547   TEST_f_l (lround, -0x1.fffffep+23, -16777215);
7548 #endif
7549   END (lround);
7550 }
7551
7552
7553 static void
7554 llround_test (void)
7555 {
7556   START (llround);
7557
7558   TEST_f_L (llround, 0, 0);
7559   TEST_f_L (llround, minus_zero, 0);
7560   TEST_f_L (llround, 0.2L, 0.0);
7561   TEST_f_L (llround, -0.2L, 0);
7562   TEST_f_L (llround, 0.5, 1);
7563   TEST_f_L (llround, -0.5, -1);
7564   TEST_f_L (llround, 0.8L, 1);
7565   TEST_f_L (llround, -0.8L, -1);
7566   TEST_f_L (llround, 1.5, 2);
7567   TEST_f_L (llround, -1.5, -2);
7568   TEST_f_L (llround, 22514.5, 22515);
7569   TEST_f_L (llround, -22514.5, -22515);
7570   TEST_f_l (llround, 1071930.0008, 1071930);
7571 #ifndef TEST_FLOAT
7572   TEST_f_L (llround, 2097152.5, 2097153);
7573   TEST_f_L (llround, -2097152.5, -2097153);
7574   TEST_f_L (llround, 34359738368.5, 34359738369ll);
7575   TEST_f_L (llround, -34359738368.5, -34359738369ll);
7576   TEST_f_L (llround, -3.65309740835E17, -365309740835000000LL);
7577 #endif
7578
7579   /* Test boundary conditions.  */
7580   /* 0x1FFFFF */
7581   TEST_f_L (llround, 2097151.0, 2097151LL);
7582   /* 0x800000 */
7583   TEST_f_L (llround, 8388608.0, 8388608LL);
7584   /* 0x1000000 */
7585   TEST_f_L (llround, 16777216.0, 16777216LL);
7586   /* 0x20000000000 */
7587   TEST_f_L (llround, 2199023255552.0, 2199023255552LL);
7588   /* 0x40000000000 */
7589   TEST_f_L (llround, 4398046511104.0, 4398046511104LL);
7590   /* 0x1000000000000 */
7591   TEST_f_L (llround, 281474976710656.0, 281474976710656LL);
7592   /* 0x10000000000000 */
7593   TEST_f_L (llround, 4503599627370496.0, 4503599627370496LL);
7594   /* 0x10000080000000 */
7595   TEST_f_L (llround, 4503601774854144.0, 4503601774854144LL);
7596   /* 0x20000000000000 */
7597   TEST_f_L (llround, 9007199254740992.0, 9007199254740992LL);
7598   /* 0x80000000000000 */
7599   TEST_f_L (llround, 36028797018963968.0, 36028797018963968LL);
7600   /* 0x100000000000000 */
7601   TEST_f_L (llround, 72057594037927936.0, 72057594037927936LL);
7602
7603 #ifndef TEST_FLOAT
7604   /* 0x100000000 */
7605   TEST_f_L (llround, 4294967295.5, 4294967296LL);
7606   /* 0x200000000 */
7607   TEST_f_L (llround, 8589934591.5, 8589934592LL);
7608
7609   /* nextafter(0.5,-1)  */
7610   TEST_f_L (llround, 0x1.fffffffffffffp-2, 0);
7611   /* nextafter(-0.5,1)  */
7612   TEST_f_L (llround, -0x1.fffffffffffffp-2, 0);
7613   /* On PowerPC an exponent of '52' is the largest incrementally
7614    * representable sequence of whole-numbers in the 'double' range.  We test
7615    * lround to make sure that a guard bit set during the lround operation
7616    * hasn't forced an erroneous shift giving us an incorrect result.  The odd
7617    * numbers between +-(2^52+1 and 2^53-1) are affected since they have the
7618    * rightmost bit set.  */
7619   /* +-(2^52+1)  */
7620   TEST_f_L (llround, 0x1.0000000000001p+52,4503599627370497LL);
7621   TEST_f_L (llround, -0x1.0000000000001p+52,-4503599627370497LL);
7622   /* +-(2^53-1): Input is the last (positive and negative) incrementally
7623    * representable whole-number in the 'double' range that might round
7624    * erroneously.  */
7625   TEST_f_L (llround, 0x1.fffffffffffffp+52, 9007199254740991LL);
7626   TEST_f_L (llround, -0x1.fffffffffffffp+52, -9007199254740991LL);
7627 #else
7628   /* nextafter(0.5,-1)  */
7629   TEST_f_L (llround, 0x1.fffffep-2, 0);
7630   /* nextafter(-0.5,1)  */
7631   TEST_f_L (llround, -0x1.fffffep-2, 0);
7632   /* As above, on PowerPC an exponent of '23' is the largest incrementally
7633    * representable sequence of whole-numbers in the 'float' range.
7634    * Likewise, numbers between +-(2^23+1 and 2^24-1) are affected.  */
7635   TEST_f_L (llround, 0x1.000002p+23,8388609);
7636   TEST_f_L (llround, -0x1.000002p+23,-8388609);
7637   TEST_f_L (llround, 0x1.fffffep+23, 16777215);
7638   TEST_f_L (llround, -0x1.fffffep+23, -16777215);
7639 #endif
7640
7641
7642 #ifdef TEST_LDOUBLE
7643   /* The input can only be represented in long double.  */
7644   TEST_f_L (llround, 4503599627370495.5L, 4503599627370496LL);
7645   TEST_f_L (llround, 4503599627370496.25L, 4503599627370496LL);
7646   TEST_f_L (llround, 4503599627370496.5L, 4503599627370497LL);
7647   TEST_f_L (llround, 4503599627370496.75L, 4503599627370497LL);
7648   TEST_f_L (llround, 4503599627370497.5L, 4503599627370498LL);
7649
7650 # if LDBL_MANT_DIG > 100
7651   TEST_f_L (llround, 4503599627370495.4999999999999L, 4503599627370495LL);
7652   TEST_f_L (llround, 4503599627370496.4999999999999L, 4503599627370496LL);
7653   TEST_f_L (llround, 4503599627370497.4999999999999L, 4503599627370497LL);
7654   TEST_f_L (llround, 4503599627370494.5000000000001L, 4503599627370495LL);
7655   TEST_f_L (llround, 4503599627370495.5000000000001L, 4503599627370496LL);
7656   TEST_f_L (llround, 4503599627370496.5000000000001L, 4503599627370497LL);
7657
7658   TEST_f_L (llround, -4503599627370495.4999999999999L, -4503599627370495LL);
7659   TEST_f_L (llround, -4503599627370496.4999999999999L, -4503599627370496LL);
7660   TEST_f_L (llround, -4503599627370497.4999999999999L, -4503599627370497LL);
7661   TEST_f_L (llround, -4503599627370494.5000000000001L, -4503599627370495LL);
7662   TEST_f_L (llround, -4503599627370495.5000000000001L, -4503599627370496LL);
7663   TEST_f_L (llround, -4503599627370496.5000000000001L, -4503599627370497LL);
7664 # endif
7665
7666   TEST_f_L (llround, -4503599627370495.5L, -4503599627370496LL);
7667   TEST_f_L (llround, -4503599627370496.25L, -4503599627370496LL);
7668   TEST_f_L (llround, -4503599627370496.5L, -4503599627370497LL);
7669   TEST_f_L (llround, -4503599627370496.75L, -4503599627370497LL);
7670   TEST_f_L (llround, -4503599627370497.5L, -4503599627370498LL);
7671
7672   TEST_f_L (llround, 9007199254740991.5L, 9007199254740992LL);
7673   TEST_f_L (llround, 9007199254740992.25L, 9007199254740992LL);
7674   TEST_f_L (llround, 9007199254740992.5L, 9007199254740993LL);
7675   TEST_f_L (llround, 9007199254740992.75L, 9007199254740993LL);
7676   TEST_f_L (llround, 9007199254740993.5L, 9007199254740994LL);
7677
7678 # if LDBL_MANT_DIG > 100
7679   TEST_f_L (llround, 9007199254740991.4999999999999L, 9007199254740991LL);
7680   TEST_f_L (llround, 9007199254740992.4999999999999L, 9007199254740992LL);
7681   TEST_f_L (llround, 9007199254740993.4999999999999L, 9007199254740993LL);
7682   TEST_f_L (llround, 9007199254740991.5000000000001L, 9007199254740992LL);
7683   TEST_f_L (llround, 9007199254740992.5000000000001L, 9007199254740993LL);
7684   TEST_f_L (llround, 9007199254740993.5000000000001L, 9007199254740994LL);
7685
7686   TEST_f_L (llround, -9007199254740991.4999999999999L, -9007199254740991LL);
7687   TEST_f_L (llround, -9007199254740992.4999999999999L, -9007199254740992LL);
7688   TEST_f_L (llround, -9007199254740993.4999999999999L, -9007199254740993LL);
7689   TEST_f_L (llround, -9007199254740991.5000000000001L, -9007199254740992LL);
7690   TEST_f_L (llround, -9007199254740992.5000000000001L, -9007199254740993LL);
7691   TEST_f_L (llround, -9007199254740993.5000000000001L, -9007199254740994LL);
7692 # endif
7693
7694   TEST_f_L (llround, -9007199254740991.5L, -9007199254740992LL);
7695   TEST_f_L (llround, -9007199254740992.25L, -9007199254740992LL);
7696   TEST_f_L (llround, -9007199254740992.5L, -9007199254740993LL);
7697   TEST_f_L (llround, -9007199254740992.75L, -9007199254740993LL);
7698   TEST_f_L (llround, -9007199254740993.5L, -9007199254740994LL);
7699
7700   TEST_f_L (llround, 72057594037927935.5L, 72057594037927936LL);
7701   TEST_f_L (llround, 72057594037927936.25L, 72057594037927936LL);
7702   TEST_f_L (llround, 72057594037927936.5L, 72057594037927937LL);
7703   TEST_f_L (llround, 72057594037927936.75L, 72057594037927937LL);
7704   TEST_f_L (llround, 72057594037927937.5L, 72057594037927938LL);
7705
7706   TEST_f_L (llround, -72057594037927935.5L, -72057594037927936LL);
7707   TEST_f_L (llround, -72057594037927936.25L, -72057594037927936LL);
7708   TEST_f_L (llround, -72057594037927936.5L, -72057594037927937LL);
7709   TEST_f_L (llround, -72057594037927936.75L, -72057594037927937LL);
7710   TEST_f_L (llround, -72057594037927937.5L, -72057594037927938LL);
7711
7712   TEST_f_L (llround, 9223372036854775806.25L, 9223372036854775806LL);
7713   TEST_f_L (llround, -9223372036854775806.25L, -9223372036854775806LL);
7714   TEST_f_L (llround, 9223372036854775806.5L, 9223372036854775807LL);
7715   TEST_f_L (llround, -9223372036854775806.5L, -9223372036854775807LL);
7716   TEST_f_L (llround, 9223372036854775807.0L, 9223372036854775807LL);
7717   TEST_f_L (llround, -9223372036854775807.0L, -9223372036854775807LL);
7718 #endif
7719
7720   END (llround);
7721 }
7722
7723 static void
7724 modf_test (void)
7725 {
7726   FLOAT x;
7727
7728   START (modf);
7729
7730   TEST_fF_f1 (modf, plus_infty, 0, plus_infty);
7731   TEST_fF_f1 (modf, minus_infty, minus_zero, minus_infty);
7732   TEST_fF_f1 (modf, nan_value, nan_value, nan_value);
7733   TEST_fF_f1 (modf, 0, 0, 0);
7734   TEST_fF_f1 (modf, 1.5, 0.5, 1);
7735   TEST_fF_f1 (modf, 2.5, 0.5, 2);
7736   TEST_fF_f1 (modf, -2.5, -0.5, -2);
7737   TEST_fF_f1 (modf, 20, 0, 20);
7738   TEST_fF_f1 (modf, 21, 0, 21);
7739   TEST_fF_f1 (modf, 89.5, 0.5, 89);
7740
7741   END (modf);
7742 }
7743
7744
7745 static void
7746 nearbyint_test (void)
7747 {
7748   START (nearbyint);
7749
7750   TEST_f_f (nearbyint, 0.0, 0.0);
7751   TEST_f_f (nearbyint, minus_zero, minus_zero);
7752   TEST_f_f (nearbyint, plus_infty, plus_infty);
7753   TEST_f_f (nearbyint, minus_infty, minus_infty);
7754   TEST_f_f (nearbyint, nan_value, nan_value);
7755
7756   /* Subnormal values */
7757   TEST_f_f (nearbyint, -8.98847e+307, -8.98847e+307);
7758   TEST_f_f (nearbyint, -4.45015e-308, minus_zero);
7759
7760   /* Default rounding mode is round to nearest.  */
7761   TEST_f_f (nearbyint, 0.5, 0.0);
7762   TEST_f_f (nearbyint, 1.5, 2.0);
7763   TEST_f_f (nearbyint, -0.5, minus_zero);
7764   TEST_f_f (nearbyint, -1.5, -2.0);
7765
7766   TEST_f_f (nearbyint, 262144.75, 262145.0);
7767   TEST_f_f (nearbyint, 262142.75, 262143.0);
7768   TEST_f_f (nearbyint, 524286.75, 524287.0);
7769   TEST_f_f (nearbyint, 524288.75, 524289.0);
7770
7771   TEST_f_f (nearbyint, 1048576.75, 1048577.0);
7772   TEST_f_f (nearbyint, 2097152.75, 2097153.0);
7773   TEST_f_f (nearbyint, 2492472.75, 2492473.0);
7774   TEST_f_f (nearbyint, 2886220.75, 2886221.0);
7775   TEST_f_f (nearbyint, 3058792.75, 3058793.0);
7776   TEST_f_f (nearbyint, -1048576.75, -1048577.0);
7777   TEST_f_f (nearbyint, -2097152.75, -2097153.0);
7778   TEST_f_f (nearbyint, -2492472.75, -2492473.0);
7779   TEST_f_f (nearbyint, -2886220.75, -2886221.0);
7780   TEST_f_f (nearbyint, -3058792.75, -3058793.0);
7781 #ifndef TEST_FLOAT
7782   TEST_f_f (nearbyint, 70368744177664.75, 70368744177665.0);
7783   TEST_f_f (nearbyint, 140737488355328.75, 140737488355329.0);
7784   TEST_f_f (nearbyint, 281474976710656.75, 281474976710657.0);
7785   TEST_f_f (nearbyint, 562949953421312.75, 562949953421313.0);
7786   TEST_f_f (nearbyint, 1125899906842624.75, 1125899906842625.0);
7787   TEST_f_f (nearbyint, -70368744177664.75, -70368744177665.0);
7788   TEST_f_f (nearbyint, -140737488355328.75, -140737488355329.0);
7789   TEST_f_f (nearbyint, -281474976710656.75, -281474976710657.0);
7790   TEST_f_f (nearbyint, -562949953421312.75, -562949953421313.0);
7791   TEST_f_f (nearbyint, -1125899906842624.75, -1125899906842625.0);
7792 #endif
7793
7794   END (nearbyint);
7795 }
7796
7797 static void
7798 nextafter_test (void)
7799 {
7800
7801   START (nextafter);
7802
7803   TEST_ff_f (nextafter, 0, 0, 0);
7804   TEST_ff_f (nextafter, minus_zero, 0, 0);
7805   TEST_ff_f (nextafter, 0, minus_zero, minus_zero);
7806   TEST_ff_f (nextafter, minus_zero, minus_zero, minus_zero);
7807
7808   TEST_ff_f (nextafter, 9, 9, 9);
7809   TEST_ff_f (nextafter, -9, -9, -9);
7810   TEST_ff_f (nextafter, plus_infty, plus_infty, plus_infty);
7811   TEST_ff_f (nextafter, minus_infty, minus_infty, minus_infty);
7812
7813   TEST_ff_f (nextafter, nan_value, 1.1L, nan_value);
7814   TEST_ff_f (nextafter, 1.1L, nan_value, nan_value);
7815   TEST_ff_f (nextafter, nan_value, nan_value, nan_value);
7816
7817   FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
7818                          LDBL_MAX, DBL_MAX, FLT_MAX);
7819   TEST_ff_f (nextafter, fltmax, plus_infty, plus_infty, OVERFLOW_EXCEPTION);
7820   TEST_ff_f (nextafter, -fltmax, minus_infty, minus_infty, OVERFLOW_EXCEPTION);
7821
7822 #ifdef TEST_LDOUBLE
7823   // XXX Enable once gcc is fixed.
7824   //TEST_ff_f (nextafter, 0x0.00000040000000000000p-16385L, -0.1L, 0x0.0000003ffffffff00000p-16385L);
7825 #endif
7826
7827   /* XXX We need the hexadecimal FP number representation here for further
7828      tests.  */
7829
7830   END (nextafter);
7831 }
7832
7833
7834 static void
7835 nexttoward_test (void)
7836 {
7837   START (nexttoward);
7838   TEST_ff_f (nexttoward, 0, 0, 0);
7839   TEST_ff_f (nexttoward, minus_zero, 0, 0);
7840   TEST_ff_f (nexttoward, 0, minus_zero, minus_zero);
7841   TEST_ff_f (nexttoward, minus_zero, minus_zero, minus_zero);
7842
7843   TEST_ff_f (nexttoward, 9, 9, 9);
7844   TEST_ff_f (nexttoward, -9, -9, -9);
7845   TEST_ff_f (nexttoward, plus_infty, plus_infty, plus_infty);
7846   TEST_ff_f (nexttoward, minus_infty, minus_infty, minus_infty);
7847
7848   TEST_ff_f (nexttoward, nan_value, 1.1L, nan_value);
7849   TEST_ff_f (nexttoward, 1.1L, nan_value, nan_value);
7850   TEST_ff_f (nexttoward, nan_value, nan_value, nan_value);
7851
7852 #ifdef TEST_FLOAT
7853   TEST_ff_f (nexttoward, 1.0, 1.1L, 0x1.000002p0);
7854   TEST_ff_f (nexttoward, 1.0, LDBL_MAX, 0x1.000002p0);
7855   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000001p0, 0x1.000002p0);
7856   TEST_ff_f (nexttoward, 1.0, 0.9L, 0x0.ffffffp0);
7857   TEST_ff_f (nexttoward, 1.0, -LDBL_MAX, 0x0.ffffffp0);
7858   TEST_ff_f (nexttoward, 1.0, 0x0.fffffffffffff8p0, 0x0.ffffffp0);
7859   TEST_ff_f (nexttoward, -1.0, -1.1L, -0x1.000002p0);
7860   TEST_ff_f (nexttoward, -1.0, -LDBL_MAX, -0x1.000002p0);
7861   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000001p0, -0x1.000002p0);
7862   TEST_ff_f (nexttoward, -1.0, -0.9L, -0x0.ffffffp0);
7863   TEST_ff_f (nexttoward, -1.0, LDBL_MAX, -0x0.ffffffp0);
7864   TEST_ff_f (nexttoward, -1.0, -0x0.fffffffffffff8p0, -0x0.ffffffp0);
7865   TEST_ff_f (nexttoward, -0x1.3p-145, -0xap-148L, -0x1.4p-145, UNDERFLOW_EXCEPTION);
7866 # if LDBL_MANT_DIG >= 64
7867   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000002p0L, 0x1.000002p0);
7868   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffp0L, 0x0.ffffffp0);
7869   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000002p0L, -0x1.000002p0);
7870   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffp0L, -0x0.ffffffp0);
7871 # endif
7872 # if LDBL_MANT_DIG >= 106
7873   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000000000000000008p0L, 0x1.000002p0);
7874   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffcp0L, 0x0.ffffffp0);
7875   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000000000000000008p0L, -0x1.000002p0);
7876   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffcp0L, -0x0.ffffffp0);
7877 # endif
7878 # if LDBL_MANT_DIG >= 113
7879   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000000000000000000001p0L, 0x1.000002p0);
7880   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffp0);
7881   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000000000000000000001p0L, -0x1.000002p0);
7882   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffp0);
7883 # endif
7884 #endif
7885 #ifdef TEST_DOUBLE
7886   TEST_ff_f (nexttoward, 1.0, 1.1L, 0x1.0000000000001p0);
7887   TEST_ff_f (nexttoward, 1.0, LDBL_MAX, 0x1.0000000000001p0);
7888   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000001p0, 0x1.0000000000001p0);
7889   TEST_ff_f (nexttoward, 1.0, 0.9L, 0x0.fffffffffffff8p0);
7890   TEST_ff_f (nexttoward, 1.0, -LDBL_MAX, 0x0.fffffffffffff8p0);
7891   TEST_ff_f (nexttoward, 1.0, 0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0);
7892   TEST_ff_f (nexttoward, -1.0, -1.1L, -0x1.0000000000001p0);
7893   TEST_ff_f (nexttoward, -1.0, -LDBL_MAX, -0x1.0000000000001p0);
7894   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000001p0, -0x1.0000000000001p0);
7895   TEST_ff_f (nexttoward, -1.0, -0.9L, -0x0.fffffffffffff8p0);
7896   TEST_ff_f (nexttoward, -1.0, LDBL_MAX, -0x0.fffffffffffff8p0);
7897   TEST_ff_f (nexttoward, -1.0, -0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0);
7898   TEST_ff_f (nexttoward, -1.0, -0x8.00346dc5d6388p-3L, -0x1.0000000000001p0);
7899   TEST_ff_f (nexttoward, 0x1p-1074, 0x1p-1073L, 0x1p-1073, UNDERFLOW_EXCEPTION);
7900 # if LDBL_MANT_DIG >= 64
7901   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000002p0L, 0x1.0000000000001p0);
7902   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffp0L, 0x0.fffffffffffff8p0);
7903   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000002p0L, -0x1.0000000000001p0);
7904   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffp0L, -0x0.fffffffffffff8p0);
7905 # endif
7906 # if LDBL_MANT_DIG >= 106
7907   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000000000000000008p0L, 0x1.0000000000001p0);
7908   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffcp0L, 0x0.fffffffffffff8p0);
7909   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000000000000000008p0L, -0x1.0000000000001p0);
7910   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffcp0L, -0x0.fffffffffffff8p0);
7911 # endif
7912 # if LDBL_MANT_DIG >= 113
7913   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000000000000000000001p0L, 0x1.0000000000001p0);
7914   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.fffffffffffff8p0);
7915   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000000000000000000001p0L, -0x1.0000000000001p0);
7916   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.fffffffffffff8p0);
7917 # endif
7918 #endif
7919
7920   END (nexttoward);
7921 }
7922
7923
7924 static void
7925 pow_test (void)
7926 {
7927
7928   errno = 0;
7929   FUNC(pow) (0, 0);
7930   if (errno == ENOSYS)
7931     /* Function not implemented.  */
7932     return;
7933
7934   START (pow);
7935
7936   TEST_ff_f (pow, 0, 0, 1);
7937   TEST_ff_f (pow, 0, minus_zero, 1);
7938   TEST_ff_f (pow, minus_zero, 0, 1);
7939   TEST_ff_f (pow, minus_zero, minus_zero, 1);
7940
7941   TEST_ff_f (pow, 10, 0, 1);
7942   TEST_ff_f (pow, 10, minus_zero, 1);
7943   TEST_ff_f (pow, -10, 0, 1);
7944   TEST_ff_f (pow, -10, minus_zero, 1);
7945
7946   TEST_ff_f (pow, nan_value, 0, 1);
7947   TEST_ff_f (pow, nan_value, minus_zero, 1);
7948
7949
7950 #ifndef TEST_INLINE
7951   TEST_ff_f (pow, 1.1L, plus_infty, plus_infty);
7952   TEST_ff_f (pow, plus_infty, plus_infty, plus_infty);
7953   TEST_ff_f (pow, -1.1L, plus_infty, plus_infty);
7954   TEST_ff_f (pow, minus_infty, plus_infty, plus_infty);
7955
7956   TEST_ff_f (pow, 0.9L, plus_infty, 0);
7957   TEST_ff_f (pow, 1e-7L, plus_infty, 0);
7958   TEST_ff_f (pow, -0.9L, plus_infty, 0);
7959   TEST_ff_f (pow, -1e-7L, plus_infty, 0);
7960
7961   TEST_ff_f (pow, 1.1L, minus_infty, 0);
7962   TEST_ff_f (pow, plus_infty, minus_infty, 0);
7963   TEST_ff_f (pow, -1.1L, minus_infty, 0);
7964   TEST_ff_f (pow, minus_infty, minus_infty, 0);
7965
7966   TEST_ff_f (pow, 0.9L, minus_infty, plus_infty);
7967   TEST_ff_f (pow, 1e-7L, minus_infty, plus_infty);
7968   TEST_ff_f (pow, -0.9L, minus_infty, plus_infty);
7969   TEST_ff_f (pow, -1e-7L, minus_infty, plus_infty);
7970
7971   TEST_ff_f (pow, plus_infty, 1e-7L, plus_infty);
7972   TEST_ff_f (pow, plus_infty, 1, plus_infty);
7973   TEST_ff_f (pow, plus_infty, 1e7L, plus_infty);
7974   TEST_ff_f (pow, plus_infty, min_subnorm_value, plus_infty);
7975
7976   TEST_ff_f (pow, plus_infty, -1e-7L, 0);
7977   TEST_ff_f (pow, plus_infty, -1, 0);
7978   TEST_ff_f (pow, plus_infty, -1e7L, 0);
7979   TEST_ff_f (pow, plus_infty, -min_subnorm_value, 0);
7980
7981   TEST_ff_f (pow, minus_infty, 1, minus_infty);
7982   TEST_ff_f (pow, minus_infty, 11, minus_infty);
7983   TEST_ff_f (pow, minus_infty, 1001, minus_infty);
7984
7985   TEST_ff_f (pow, minus_infty, 2, plus_infty);
7986   TEST_ff_f (pow, minus_infty, 12, plus_infty);
7987   TEST_ff_f (pow, minus_infty, 1002, plus_infty);
7988   TEST_ff_f (pow, minus_infty, 0.1L, plus_infty);
7989   TEST_ff_f (pow, minus_infty, 1.1L, plus_infty);
7990   TEST_ff_f (pow, minus_infty, 11.1L, plus_infty);
7991   TEST_ff_f (pow, minus_infty, 1001.1L, plus_infty);
7992   TEST_ff_f (pow, minus_infty, min_subnorm_value, plus_infty);
7993
7994   TEST_ff_f (pow, minus_infty, -1, minus_zero);
7995   TEST_ff_f (pow, minus_infty, -11, minus_zero);
7996   TEST_ff_f (pow, minus_infty, -1001, minus_zero);
7997
7998   TEST_ff_f (pow, minus_infty, -2, 0);
7999   TEST_ff_f (pow, minus_infty, -12, 0);
8000   TEST_ff_f (pow, minus_infty, -1002, 0);
8001   TEST_ff_f (pow, minus_infty, -0.1L, 0);
8002   TEST_ff_f (pow, minus_infty, -1.1L, 0);
8003   TEST_ff_f (pow, minus_infty, -11.1L, 0);
8004   TEST_ff_f (pow, minus_infty, -1001.1L, 0);
8005   TEST_ff_f (pow, minus_infty, -min_subnorm_value, 0);
8006 #endif
8007
8008   TEST_ff_f (pow, nan_value, nan_value, nan_value);
8009   TEST_ff_f (pow, 0, nan_value, nan_value);
8010   TEST_ff_f (pow, 1, nan_value, 1);
8011   TEST_ff_f (pow, -1, nan_value, nan_value);
8012   TEST_ff_f (pow, nan_value, 1, nan_value);
8013   TEST_ff_f (pow, nan_value, -1, nan_value);
8014
8015   /* pow (x, NaN) == NaN.  */
8016   TEST_ff_f (pow, 3.0, nan_value, nan_value);
8017   TEST_ff_f (pow, minus_zero, nan_value, nan_value);
8018   TEST_ff_f (pow, plus_infty, nan_value, nan_value);
8019   TEST_ff_f (pow, -3.0, nan_value, nan_value);
8020   TEST_ff_f (pow, minus_infty, nan_value, nan_value);
8021
8022   TEST_ff_f (pow, nan_value, 3.0, nan_value);
8023   TEST_ff_f (pow, nan_value, -3.0, nan_value);
8024   TEST_ff_f (pow, nan_value, plus_infty, nan_value);
8025   TEST_ff_f (pow, nan_value, minus_infty, nan_value);
8026   TEST_ff_f (pow, nan_value, 2.5, nan_value);
8027   TEST_ff_f (pow, nan_value, -2.5, nan_value);
8028   TEST_ff_f (pow, nan_value, min_subnorm_value, nan_value);
8029   TEST_ff_f (pow, nan_value, -min_subnorm_value, nan_value);
8030
8031   TEST_ff_f (pow, 1, plus_infty, 1);
8032   TEST_ff_f (pow, -1, plus_infty, 1);
8033   TEST_ff_f (pow, 1, minus_infty, 1);
8034   TEST_ff_f (pow, -1, minus_infty, 1);
8035   TEST_ff_f (pow, 1, 1, 1);
8036   TEST_ff_f (pow, 1, -1, 1);
8037   TEST_ff_f (pow, 1, 1.25, 1);
8038   TEST_ff_f (pow, 1, -1.25, 1);
8039   TEST_ff_f (pow, 1, 0x1p62L, 1);
8040   TEST_ff_f (pow, 1, 0x1p63L, 1);
8041   TEST_ff_f (pow, 1, 0x1p64L, 1);
8042   TEST_ff_f (pow, 1, 0x1p72L, 1);
8043   TEST_ff_f (pow, 1, min_subnorm_value, 1);
8044   TEST_ff_f (pow, 1, -min_subnorm_value, 1);
8045
8046   /* pow (x, +-0) == 1.  */
8047   TEST_ff_f (pow, plus_infty, 0, 1);
8048   TEST_ff_f (pow, plus_infty, minus_zero, 1);
8049   TEST_ff_f (pow, minus_infty, 0, 1);
8050   TEST_ff_f (pow, minus_infty, minus_zero, 1);
8051   TEST_ff_f (pow, 32.75L, 0, 1);
8052   TEST_ff_f (pow, 32.75L, minus_zero, 1);
8053   TEST_ff_f (pow, -32.75L, 0, 1);
8054   TEST_ff_f (pow, -32.75L, minus_zero, 1);
8055   TEST_ff_f (pow, 0x1p72L, 0, 1);
8056   TEST_ff_f (pow, 0x1p72L, minus_zero, 1);
8057   TEST_ff_f (pow, 0x1p-72L, 0, 1);
8058   TEST_ff_f (pow, 0x1p-72L, minus_zero, 1);
8059
8060   TEST_ff_f (pow, -0.1L, 1.1L, nan_value, INVALID_EXCEPTION);
8061   TEST_ff_f (pow, -0.1L, -1.1L, nan_value, INVALID_EXCEPTION);
8062   TEST_ff_f (pow, -10.1L, 1.1L, nan_value, INVALID_EXCEPTION);
8063   TEST_ff_f (pow, -10.1L, -1.1L, nan_value, INVALID_EXCEPTION);
8064   TEST_ff_f (pow, -1.01L, min_subnorm_value, nan_value, INVALID_EXCEPTION);
8065   TEST_ff_f (pow, -1.01L, -min_subnorm_value, nan_value, INVALID_EXCEPTION);
8066   TEST_ff_f (pow, -1.0L, min_subnorm_value, nan_value, INVALID_EXCEPTION);
8067   TEST_ff_f (pow, -1.0L, -min_subnorm_value, nan_value, INVALID_EXCEPTION);
8068
8069   errno = 0;
8070   TEST_ff_f (pow, 0, -1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8071   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
8072   errno = 0;
8073   TEST_ff_f (pow, 0, -11, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8074   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
8075   errno = 0;
8076   TEST_ff_f (pow, 0, -0xffffff, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8077   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
8078 #ifndef TEST_FLOAT
8079   errno = 0;
8080   TEST_ff_f (pow, 0, -0x1.fffffffffffffp+52L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8081   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
8082 #endif
8083 #ifdef TEST_LDOUBLE
8084 # if LDBL_MANT_DIG >= 64
8085   errno = 0;
8086   TEST_ff_f (pow, 0, -0x1.fffffffffffffffep+63L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8087   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
8088 # endif
8089 # if LDBL_MANT_DIG >= 106
8090   errno = 0;
8091   TEST_ff_f (pow, 0, -0x1.ffffffffffffffffffffffffff8p+105L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8092   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
8093 # endif
8094 # if LDBL_MANT_DIG >= 113
8095   errno = 0;
8096   TEST_ff_f (pow, 0, -0x1.ffffffffffffffffffffffffffffp+112L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8097   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
8098 # endif
8099 #endif
8100   TEST_ff_f (pow, minus_zero, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8101   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
8102   errno = 0;
8103   TEST_ff_f (pow, minus_zero, -11L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8104   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
8105   errno = 0;
8106   TEST_ff_f (pow, minus_zero, -0xffffff, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8107   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
8108   errno = 0;
8109   TEST_ff_f (pow, minus_zero, -0x1fffffe, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8110   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
8111 #ifndef TEST_FLOAT
8112   errno = 0;
8113   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffp+52L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8114   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
8115   errno = 0;
8116   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffp+53L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8117   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
8118 #endif
8119 #ifdef TEST_LDOUBLE
8120 # if LDBL_MANT_DIG >= 64
8121   errno = 0;
8122   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffffep+63L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8123   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
8124   errno = 0;
8125   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffffep+64L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8126   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
8127 # endif
8128 # if LDBL_MANT_DIG >= 106
8129   errno = 0;
8130   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8131   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
8132   errno = 0;
8133   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8134   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
8135 # endif
8136 # if LDBL_MANT_DIG >= 113
8137   errno = 0;
8138   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8139   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
8140   errno = 0;
8141   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8142   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
8143 # endif
8144 #endif
8145
8146   errno = 0;
8147   TEST_ff_f (pow, 0, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8148   check_int ("errno for pow(0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
8149   errno = 0;
8150   TEST_ff_f (pow, 0, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8151   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
8152   errno = 0;
8153   TEST_ff_f (pow, 0, -min_subnorm_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8154   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
8155   errno = 0;
8156   TEST_ff_f (pow, 0, -0x1p24, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8157   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
8158   errno = 0;
8159   TEST_ff_f (pow, 0, -0x1p127, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8160   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
8161   errno = 0;
8162   TEST_ff_f (pow, 0, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8163   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
8164   errno = 0;
8165   TEST_ff_f (pow, minus_zero, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8166   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
8167   errno = 0;
8168   TEST_ff_f (pow, minus_zero, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8169   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
8170   errno = 0;
8171   TEST_ff_f (pow, minus_zero, -min_subnorm_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8172   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
8173   errno = 0;
8174   TEST_ff_f (pow, minus_zero, -0x1p24, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8175   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
8176   errno = 0;
8177   TEST_ff_f (pow, minus_zero, -0x1p127, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8178   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
8179   errno = 0;
8180   TEST_ff_f (pow, minus_zero, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8181   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
8182
8183   TEST_ff_f (pow, 0x1p72L, 0x1p72L, plus_infty, OVERFLOW_EXCEPTION);
8184   TEST_ff_f (pow, 10, -0x1p72L, 0, UNDERFLOW_EXCEPTION);
8185   TEST_ff_f (pow, max_value, max_value, plus_infty, OVERFLOW_EXCEPTION);
8186   TEST_ff_f (pow, 10, -max_value, 0, UNDERFLOW_EXCEPTION);
8187
8188   TEST_ff_f (pow, 0, 1, 0);
8189   TEST_ff_f (pow, 0, 11, 0);
8190
8191   TEST_ff_f (pow, minus_zero, 1, minus_zero);
8192   TEST_ff_f (pow, minus_zero, 11, minus_zero);
8193
8194   TEST_ff_f (pow, 0, 2, 0);
8195   TEST_ff_f (pow, 0, 11.1L, 0);
8196
8197   TEST_ff_f (pow, minus_zero, 2, 0);
8198   TEST_ff_f (pow, minus_zero, 11.1L, 0);
8199   TEST_ff_f (pow, 0, plus_infty, 0);
8200   TEST_ff_f (pow, minus_zero, plus_infty, 0);
8201   TEST_ff_f (pow, 0, minus_infty, plus_infty, DIVIDE_BY_ZERO_EXCEPTION_OK);
8202   TEST_ff_f (pow, minus_zero, minus_infty, plus_infty, DIVIDE_BY_ZERO_EXCEPTION_OK);
8203
8204 #ifndef TEST_INLINE
8205   /* pow (x, +inf) == +inf for |x| > 1.  */
8206   TEST_ff_f (pow, 1.5, plus_infty, plus_infty);
8207
8208   /* pow (x, +inf) == +0 for |x| < 1.  */
8209   TEST_ff_f (pow, 0.5, plus_infty, 0.0);
8210
8211   /* pow (x, -inf) == +0 for |x| > 1.  */
8212   TEST_ff_f (pow, 1.5, minus_infty, 0.0);
8213
8214   /* pow (x, -inf) == +inf for |x| < 1.  */
8215   TEST_ff_f (pow, 0.5, minus_infty, plus_infty);
8216 #endif
8217
8218   /* pow (+inf, y) == +inf for y > 0.  */
8219   TEST_ff_f (pow, plus_infty, 2, plus_infty);
8220   TEST_ff_f (pow, plus_infty, 0xffffff, plus_infty);
8221 #ifndef TEST_FLOAT
8222   TEST_ff_f (pow, plus_infty, 0x1.fffffffffffffp+52L, plus_infty);
8223 #endif
8224 #ifdef TEST_LDOUBLE
8225 # if LDBL_MANT_DIG >= 64
8226   TEST_ff_f (pow, plus_infty, 0x1.fffffffffffffffep+63L, plus_infty);
8227 # endif
8228 # if LDBL_MANT_DIG >= 106
8229   TEST_ff_f (pow, plus_infty, 0x1.ffffffffffffffffffffffffff8p+105L, plus_infty);
8230 # endif
8231 # if LDBL_MANT_DIG >= 113
8232   TEST_ff_f (pow, plus_infty, 0x1.ffffffffffffffffffffffffffffp+112L, plus_infty);
8233 # endif
8234 #endif
8235   TEST_ff_f (pow, plus_infty, 0x1p24, plus_infty);
8236   TEST_ff_f (pow, plus_infty, 0x1p127, plus_infty);
8237   TEST_ff_f (pow, plus_infty, max_value, plus_infty);
8238
8239   /* pow (+inf, y) == +0 for y < 0.  */
8240   TEST_ff_f (pow, plus_infty, -1, 0.0);
8241   TEST_ff_f (pow, plus_infty, -0xffffff, 0.0);
8242 #ifndef TEST_FLOAT
8243   TEST_ff_f (pow, plus_infty, -0x1.fffffffffffffp+52L, 0.0);
8244 #endif
8245 #ifdef TEST_LDOUBLE
8246 # if LDBL_MANT_DIG >= 64
8247   TEST_ff_f (pow, plus_infty, -0x1.fffffffffffffffep+63L, 0.0);
8248 # endif
8249 # if LDBL_MANT_DIG >= 106
8250   TEST_ff_f (pow, plus_infty, -0x1.ffffffffffffffffffffffffff8p+105L, 0.0);
8251 # endif
8252 # if LDBL_MANT_DIG >= 113
8253   TEST_ff_f (pow, plus_infty, -0x1.ffffffffffffffffffffffffffffp+112L, 0.0);
8254 # endif
8255 #endif
8256   TEST_ff_f (pow, plus_infty, -0x1p24, 0.0);
8257   TEST_ff_f (pow, plus_infty, -0x1p127, 0.0);
8258   TEST_ff_f (pow, plus_infty, -max_value, 0.0);
8259
8260   /* pow (-inf, y) == -inf for y an odd integer > 0.  */
8261   TEST_ff_f (pow, minus_infty, 27, minus_infty);
8262   TEST_ff_f (pow, minus_infty, 0xffffff, minus_infty);
8263   TEST_ff_f (pow, minus_infty, 0x1fffffe, plus_infty);
8264 #ifndef TEST_FLOAT
8265   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffp+52L, minus_infty);
8266   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffp+53L, plus_infty);
8267 #endif
8268 #ifdef TEST_LDOUBLE
8269 # if LDBL_MANT_DIG >= 64
8270   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffffep+63L, minus_infty);
8271   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffffep+64L, plus_infty);
8272 # endif
8273 # if LDBL_MANT_DIG >= 106
8274   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty);
8275   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty);
8276 # endif
8277 # if LDBL_MANT_DIG >= 113
8278   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty);
8279   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty);
8280 # endif
8281 #endif
8282
8283   /* pow (-inf, y) == +inf for y > 0 and not an odd integer.  */
8284   TEST_ff_f (pow, minus_infty, 28, plus_infty);
8285   TEST_ff_f (pow, minus_infty, 0x1p24, plus_infty);
8286   TEST_ff_f (pow, minus_infty, 0x1p127, plus_infty);
8287   TEST_ff_f (pow, minus_infty, max_value, plus_infty);
8288
8289   /* pow (-inf, y) == -0 for y an odd integer < 0. */
8290   TEST_ff_f (pow, minus_infty, -3, minus_zero);
8291   TEST_ff_f (pow, minus_infty, -0xffffff, minus_zero);
8292   TEST_ff_f (pow, minus_infty, -0x1fffffe, plus_zero);
8293 #ifndef TEST_FLOAT
8294   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffp+52L, minus_zero);
8295   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffp+53L, plus_zero);
8296 #endif
8297 #ifdef TEST_LDOUBLE
8298 # if LDBL_MANT_DIG >= 64
8299   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffffep+63L, minus_zero);
8300   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffffep+64L, plus_zero);
8301 # endif
8302 # if LDBL_MANT_DIG >= 106
8303   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
8304   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
8305 # endif
8306 # if LDBL_MANT_DIG >= 113
8307   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
8308   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
8309 # endif
8310 #endif
8311   /* pow (-inf, y) == +0 for y < 0 and not an odd integer.  */
8312   TEST_ff_f (pow, minus_infty, -2.0, 0.0);
8313   TEST_ff_f (pow, minus_infty, -0x1p24, 0.0);
8314   TEST_ff_f (pow, minus_infty, -0x1p127, 0.0);
8315   TEST_ff_f (pow, minus_infty, -max_value, 0.0);
8316
8317   /* pow (+0, y) == +0 for y an odd integer > 0.  */
8318   TEST_ff_f (pow, 0.0, 27, 0.0);
8319   TEST_ff_f (pow, 0.0, 0xffffff, 0.0);
8320 #ifndef TEST_FLOAT
8321   TEST_ff_f (pow, 0.0, 0x1.fffffffffffffp+52L, 0.0);
8322 #endif
8323 #ifdef TEST_LDOUBLE
8324 # if LDBL_MANT_DIG >= 64
8325   TEST_ff_f (pow, 0.0, 0x1.fffffffffffffffep+63L, 0.0);
8326 # endif
8327 # if LDBL_MANT_DIG >= 106
8328   TEST_ff_f (pow, 0.0, 0x1.ffffffffffffffffffffffffff8p+105L, 0.0);
8329 # endif
8330 # if LDBL_MANT_DIG >= 113
8331   TEST_ff_f (pow, 0.0, 0x1.ffffffffffffffffffffffffffffp+112L, 0.0);
8332 # endif
8333 #endif
8334
8335   /* pow (-0, y) == -0 for y an odd integer > 0.  */
8336   TEST_ff_f (pow, minus_zero, 27, minus_zero);
8337   TEST_ff_f (pow, minus_zero, 0xffffff, minus_zero);
8338   TEST_ff_f (pow, minus_zero, 0x1fffffe, plus_zero);
8339 #ifndef TEST_FLOAT
8340   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffp+52L, minus_zero);
8341   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffp+53L, plus_zero);
8342 #endif
8343 #ifdef TEST_LDOUBLE
8344 # if LDBL_MANT_DIG >= 64
8345   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffffep+63L, minus_zero);
8346   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffffep+64L, plus_zero);
8347 # endif
8348 # if LDBL_MANT_DIG >= 106
8349   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
8350   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
8351 # endif
8352 # if LDBL_MANT_DIG >= 113
8353   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
8354   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
8355 # endif
8356 #endif
8357
8358   /* pow (+0, y) == +0 for y > 0 and not an odd integer.  */
8359   TEST_ff_f (pow, 0.0, 4, 0.0);
8360   TEST_ff_f (pow, 0.0, 0x1p24, 0.0);
8361   TEST_ff_f (pow, 0.0, 0x1p127, 0.0);
8362   TEST_ff_f (pow, 0.0, max_value, 0.0);
8363   TEST_ff_f (pow, 0.0, min_subnorm_value, 0.0);
8364
8365   /* pow (-0, y) == +0 for y > 0 and not an odd integer.  */
8366   TEST_ff_f (pow, minus_zero, 4, 0.0);
8367   TEST_ff_f (pow, minus_zero, 0x1p24, 0.0);
8368   TEST_ff_f (pow, minus_zero, 0x1p127, 0.0);
8369   TEST_ff_f (pow, minus_zero, max_value, 0.0);
8370   TEST_ff_f (pow, minus_zero, min_subnorm_value, 0.0);
8371
8372   TEST_ff_f (pow, 16, 0.25L, 2);
8373   TEST_ff_f (pow, 0x1p64L, 0.125L, 256);
8374   TEST_ff_f (pow, 2, 4, 16);
8375   TEST_ff_f (pow, 256, 8, 0x1p64L);
8376
8377   TEST_ff_f (pow, 0.75L, 1.25L, 0.697953644326574699205914060237425566L);
8378
8379 #if defined TEST_DOUBLE || defined TEST_LDOUBLE
8380   TEST_ff_f (pow, -7.49321e+133, -9.80818e+16, 0, UNDERFLOW_EXCEPTION);
8381 #endif
8382
8383   TEST_ff_f (pow, -1.0, -0xffffff, -1.0);
8384   TEST_ff_f (pow, -1.0, -0x1fffffe, 1.0);
8385 #ifndef TEST_FLOAT
8386   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffp+52L, -1.0);
8387   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffp+53L, 1.0);
8388 #endif
8389 #ifdef TEST_LDOUBLE
8390 # if LDBL_MANT_DIG >= 64
8391   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffffep+63L, -1.0);
8392   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffffep+64L, 1.0);
8393 # endif
8394 # if LDBL_MANT_DIG >= 106
8395   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffff8p+105L, -1.0);
8396   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffff8p+106L, 1.0);
8397 # endif
8398 # if LDBL_MANT_DIG >= 113
8399   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffffffp+112L, -1.0);
8400   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffffffp+113L, 1.0);
8401 # endif
8402 #endif
8403   TEST_ff_f (pow, -1.0, -max_value, 1.0);
8404
8405   TEST_ff_f (pow, -1.0, 0xffffff, -1.0);
8406   TEST_ff_f (pow, -1.0, 0x1fffffe, 1.0);
8407 #ifndef TEST_FLOAT
8408   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffp+52L, -1.0);
8409   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffp+53L, 1.0);
8410 #endif
8411 #ifdef TEST_LDOUBLE
8412 # if LDBL_MANT_DIG >= 64
8413   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffffep+63L, -1.0);
8414   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffffep+64L, 1.0);
8415 # endif
8416 # if LDBL_MANT_DIG >= 106
8417   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffff8p+105L, -1.0);
8418   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffff8p+106L, 1.0);
8419 # endif
8420 # if LDBL_MANT_DIG >= 113
8421   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffffffp+112L, -1.0);
8422   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffffffp+113L, 1.0);
8423 # endif
8424 #endif
8425   TEST_ff_f (pow, -1.0, max_value, 1.0);
8426
8427   TEST_ff_f (pow, -2.0, 126, 0x1p126);
8428   TEST_ff_f (pow, -2.0, 127, -0x1p127);
8429   /* Allow inexact results for float to be considered to underflow.  */
8430   TEST_ff_f (pow, -2.0, -126, 0x1p-126, UNDERFLOW_EXCEPTION_OK_FLOAT);
8431   TEST_ff_f (pow, -2.0, -127, -0x1p-127, UNDERFLOW_EXCEPTION_OK_FLOAT);
8432
8433   TEST_ff_f (pow, -2.0, -0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
8434   TEST_ff_f (pow, -2.0, -0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
8435 #ifndef TEST_FLOAT
8436   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
8437   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
8438 #endif
8439 #ifdef TEST_LDOUBLE
8440 # if LDBL_MANT_DIG >= 64
8441   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
8442   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
8443 # endif
8444 # if LDBL_MANT_DIG >= 106
8445   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
8446   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
8447 # endif
8448 # if LDBL_MANT_DIG >= 113
8449   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
8450   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
8451 # endif
8452 #endif
8453   TEST_ff_f (pow, -2.0, -max_value, plus_zero, UNDERFLOW_EXCEPTION);
8454
8455   TEST_ff_f (pow, -2.0, 0xffffff, minus_infty, OVERFLOW_EXCEPTION);
8456   TEST_ff_f (pow, -2.0, 0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
8457 #ifndef TEST_FLOAT
8458   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
8459   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
8460 #endif
8461 #ifdef TEST_LDOUBLE
8462 # if LDBL_MANT_DIG >= 64
8463   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
8464   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
8465 # endif
8466 # if LDBL_MANT_DIG >= 106
8467   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
8468   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
8469 # endif
8470 # if LDBL_MANT_DIG >= 113
8471   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
8472   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
8473 # endif
8474 #endif
8475   TEST_ff_f (pow, -2.0, max_value, plus_infty, OVERFLOW_EXCEPTION);
8476
8477   TEST_ff_f (pow, -max_value, 0.5, nan_value, INVALID_EXCEPTION);
8478   TEST_ff_f (pow, -max_value, 1.5, nan_value, INVALID_EXCEPTION);
8479   TEST_ff_f (pow, -max_value, 1000.5, nan_value, INVALID_EXCEPTION);
8480   TEST_ff_f (pow, -max_value, -2, plus_zero, UNDERFLOW_EXCEPTION);
8481   TEST_ff_f (pow, -max_value, -3, minus_zero, UNDERFLOW_EXCEPTION);
8482   TEST_ff_f (pow, -max_value, 2, plus_infty, OVERFLOW_EXCEPTION);
8483   TEST_ff_f (pow, -max_value, 3, minus_infty, OVERFLOW_EXCEPTION);
8484
8485   TEST_ff_f (pow, -max_value, -0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
8486   TEST_ff_f (pow, -max_value, -0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
8487 #ifndef TEST_FLOAT
8488   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
8489   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
8490 #endif
8491 #ifdef TEST_LDOUBLE
8492 # if LDBL_MANT_DIG >= 64
8493   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
8494   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
8495 # endif
8496 # if LDBL_MANT_DIG >= 106
8497   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
8498   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
8499 # endif
8500 # if LDBL_MANT_DIG >= 113
8501   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
8502   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
8503 # endif
8504 #endif
8505   TEST_ff_f (pow, -max_value, -max_value, plus_zero, UNDERFLOW_EXCEPTION);
8506
8507   TEST_ff_f (pow, -max_value, 0xffffff, minus_infty, OVERFLOW_EXCEPTION);
8508   TEST_ff_f (pow, -max_value, 0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
8509 #ifndef TEST_FLOAT
8510   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
8511   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
8512 #endif
8513 #ifdef TEST_LDOUBLE
8514 # if LDBL_MANT_DIG >= 64
8515   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
8516   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
8517 # endif
8518 # if LDBL_MANT_DIG >= 106
8519   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
8520   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
8521 # endif
8522 # if LDBL_MANT_DIG >= 113
8523   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
8524   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
8525 # endif
8526 #endif
8527   TEST_ff_f (pow, -max_value, max_value, plus_infty, OVERFLOW_EXCEPTION);
8528
8529   TEST_ff_f (pow, -0.5, 126, 0x1p-126);
8530   TEST_ff_f (pow, -0.5, 127, -0x1p-127);
8531   TEST_ff_f (pow, -0.5, -126, 0x1p126);
8532   TEST_ff_f (pow, -0.5, -127, -0x1p127);
8533
8534   TEST_ff_f (pow, -0.5, -0xffffff, minus_infty, OVERFLOW_EXCEPTION);
8535   TEST_ff_f (pow, -0.5, -0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
8536 #ifndef TEST_FLOAT
8537   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
8538   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
8539 #endif
8540 #ifdef TEST_LDOUBLE
8541 # if LDBL_MANT_DIG >= 64
8542   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
8543   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
8544 # endif
8545 # if LDBL_MANT_DIG >= 106
8546   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
8547   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
8548 # endif
8549 # if LDBL_MANT_DIG >= 113
8550   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
8551   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
8552 # endif
8553 #endif
8554   TEST_ff_f (pow, -0.5, -max_value, plus_infty, OVERFLOW_EXCEPTION);
8555
8556   TEST_ff_f (pow, -0.5, 0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
8557   TEST_ff_f (pow, -0.5, 0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
8558 #ifndef TEST_FLOAT
8559   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
8560   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
8561 #endif
8562 #ifdef TEST_LDOUBLE
8563 # if LDBL_MANT_DIG >= 64
8564   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
8565   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
8566 # endif
8567 # if LDBL_MANT_DIG >= 106
8568   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
8569   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
8570 # endif
8571 # if LDBL_MANT_DIG >= 113
8572   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
8573   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
8574 # endif
8575 #endif
8576   TEST_ff_f (pow, -0.5, max_value, plus_zero, UNDERFLOW_EXCEPTION);
8577
8578   TEST_ff_f (pow, -min_value, 0.5, nan_value, INVALID_EXCEPTION);
8579   TEST_ff_f (pow, -min_value, 1.5, nan_value, INVALID_EXCEPTION);
8580   TEST_ff_f (pow, -min_value, 1000.5, nan_value, INVALID_EXCEPTION);
8581   TEST_ff_f (pow, -min_value, -2, plus_infty, OVERFLOW_EXCEPTION);
8582   TEST_ff_f (pow, -min_value, -3, minus_infty, OVERFLOW_EXCEPTION);
8583   /* Allow inexact results to be considered to underflow.  */
8584   TEST_ff_f (pow, -min_value, 1, -min_value, UNDERFLOW_EXCEPTION_OK);
8585   TEST_ff_f (pow, -min_value, 2, plus_zero, UNDERFLOW_EXCEPTION);
8586   TEST_ff_f (pow, -min_value, 3, minus_zero, UNDERFLOW_EXCEPTION);
8587
8588   TEST_ff_f (pow, -min_value, -0xffffff, minus_infty, OVERFLOW_EXCEPTION);
8589   TEST_ff_f (pow, -min_value, -0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
8590 #ifndef TEST_FLOAT
8591   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
8592   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
8593 #endif
8594 #ifdef TEST_LDOUBLE
8595 # if LDBL_MANT_DIG >= 64
8596   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
8597   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
8598 # endif
8599 # if LDBL_MANT_DIG >= 106
8600   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
8601   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
8602 # endif
8603 # if LDBL_MANT_DIG >= 113
8604   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
8605   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
8606 # endif
8607 #endif
8608   TEST_ff_f (pow, -min_value, -max_value, plus_infty, OVERFLOW_EXCEPTION);
8609
8610   TEST_ff_f (pow, -min_value, 0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
8611   TEST_ff_f (pow, -min_value, 0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
8612 #ifndef TEST_FLOAT
8613   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
8614   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
8615 #endif
8616 #ifdef TEST_LDOUBLE
8617 # if LDBL_MANT_DIG >= 64
8618   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
8619   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
8620 # endif
8621 # if LDBL_MANT_DIG >= 106
8622   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
8623   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
8624 # endif
8625 # if LDBL_MANT_DIG >= 113
8626   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
8627   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
8628 # endif
8629 #endif
8630   TEST_ff_f (pow, -min_value, max_value, plus_zero, UNDERFLOW_EXCEPTION);
8631
8632   TEST_ff_f (pow, 0x0.ffffffp0, 10, 0.999999403953712118183885036774764444747L);
8633   TEST_ff_f (pow, 0x0.ffffffp0, 100, 0.999994039553108359406305079606228341585L);
8634   TEST_ff_f (pow, 0x0.ffffffp0, 1000, 0.9999403971297699052276650144650733772182L);
8635   TEST_ff_f (pow, 0x0.ffffffp0, 0x1p24, 0.3678794302077803437135155590023422899744L);
8636   TEST_ff_f (pow, 0x0.ffffffp0, 0x1p30, 1.603807831524924233828134753069728224044e-28L);
8637   TEST_ff_f (pow, 0x0.ffffffp0, 0x1.234566p30, 2.374884712135295099971443365381007297732e-32L);
8638   TEST_ff_f (pow, 0x0.ffffffp0, -10, 1.000000596046643153205170848674671339688L);
8639   TEST_ff_f (pow, 0x0.ffffffp0, -100, 1.000005960482418779499387594989252621451L);
8640   TEST_ff_f (pow, 0x0.ffffffp0, -1000, 1.000059606422943986382898964231519867906L);
8641   TEST_ff_f (pow, 0x0.ffffffp0, -0x1p24, 2.7182819094701610539628664526874952929416L);
8642   TEST_ff_f (pow, 0x0.ffffffp0, -0x1p30, 6.2351609734265057988914412331288163636075e+27L);
8643   TEST_ff_f (pow, 0x0.ffffffp0, -0x1.234566p30, 4.2107307141696353498921307077142537353515e+31L);
8644   TEST_ff_f (pow, 0x1.000002p0, 0x1p24, 7.3890552180866447284268641248075832310141L);
8645   TEST_ff_f (pow, 0x1.000002p0, 0x1.234566p29, 4.2107033006507495188536371520637025716256e+31L);
8646   TEST_ff_f (pow, 0x1.000002p0, -0x1.234566p29, 2.3749001736727769098946062325205705312166e-32L);
8647
8648 #if !defined TEST_FLOAT
8649   TEST_ff_f (pow, 0x0.fffffffffffff8p0L, 0x1.23456789abcdfp62L, 1.0118762747827252817436395051178295138220e-253L);
8650   TEST_ff_f (pow, 0x0.fffffffffffff8p0L, -0x1.23456789abcdfp62L, 9.8826311568054561811190162420900667121992e+252L);
8651   TEST_ff_f (pow, 0x1.0000000000001p0L, 0x1.23456789abcdfp61L, 9.8826311568044974397135026217687399395481e+252L);
8652   TEST_ff_f (pow, 0x1.0000000000001p0L, -0x1.23456789abcdfp61L, 1.0118762747828234466621210689458255908670e-253L);
8653 #endif
8654
8655 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64 && LDBL_MAX_EXP >= 16384
8656   TEST_ff_f (pow, 0x0.ffffffffffffffffp0L, 0x1.23456789abcdef0ep77L, 1.2079212226420368189981778807634890018840e-4048L);
8657   TEST_ff_f (pow, 0x0.ffffffffffffffffp0L, -0x1.23456789abcdef0ep77L, 8.2786855736563746280496724205839522148001e+4047L);
8658   TEST_ff_f (pow, 0x1.0000000000000002p0L, 0x1.23456789abcdef0ep76L, 8.2786855736563683535324500168799315131570e+4047L);
8659   TEST_ff_f (pow, 0x1.0000000000000002p0L, -0x1.23456789abcdef0ep76L, 1.2079212226420377344964713407722652880280e-4048L);
8660 #endif
8661
8662 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 113
8663   TEST_ff_f (pow, 0x0.ffffffffffffffffffffffffffff8p0L, 0x1.23456789abcdef0123456789abcdp126L, 1.2079212226420440237790185999151440179953e-4048L);
8664   TEST_ff_f (pow, 0x0.ffffffffffffffffffffffffffff8p0L, -0x1.23456789abcdef0123456789abcdp126L, 8.2786855736563252489063231915535105363602e+4047L);
8665   TEST_ff_f (pow, 0x1.0000000000000000000000000001p0L, 0x1.23456789abcdef0123456789abcdp125L, 8.2786855736563252489063231915423647547782e+4047L);
8666   TEST_ff_f (pow, 0x1.0000000000000000000000000001p0L, -0x1.23456789abcdef0123456789abcdp125L, 1.2079212226420440237790185999167702696503e-4048L);
8667 #endif
8668
8669 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
8670   TEST_ff_f (pow, 1e4932L, 0.75L, 1e3699L);
8671   TEST_ff_f (pow, 1e4928L, 0.75L, 1e3696L);
8672   TEST_ff_f (pow, 1e4924L, 0.75L, 1e3693L);
8673   TEST_ff_f (pow, 1e4920L, 0.75L, 1e3690L);
8674   TEST_ff_f (pow, 10.0L, 4932.0L, 1e4932L);
8675   TEST_ff_f (pow, 10.0L, 4931.0L, 1e4931L);
8676   TEST_ff_f (pow, 10.0L, 4930.0L, 1e4930L);
8677   TEST_ff_f (pow, 10.0L, 4929.0L, 1e4929L);
8678   TEST_ff_f (pow, 10.0L, -4931.0L, 1e-4931L);
8679   TEST_ff_f (pow, 10.0L, -4930.0L, 1e-4930L);
8680   TEST_ff_f (pow, 10.0L, -4929.0L, 1e-4929L);
8681   TEST_ff_f (pow, 1e27L, 182.0L, 1e4914L);
8682   TEST_ff_f (pow, 1e27L, -182.0L, 1e-4914L);
8683 #endif
8684
8685   TEST_ff_f (pow, min_subnorm_value, min_subnorm_value, 1.0L);
8686   TEST_ff_f (pow, min_subnorm_value, -min_subnorm_value, 1.0L);
8687   TEST_ff_f (pow, max_value, min_subnorm_value, 1.0L);
8688   TEST_ff_f (pow, max_value, -min_subnorm_value, 1.0L);
8689   TEST_ff_f (pow, 0.99L, min_subnorm_value, 1.0L);
8690   TEST_ff_f (pow, 0.99L, -min_subnorm_value, 1.0L);
8691   TEST_ff_f (pow, 1.01L, min_subnorm_value, 1.0L);
8692   TEST_ff_f (pow, 1.01L, -min_subnorm_value, 1.0L);
8693
8694   TEST_ff_f (pow, 2.0L, -100000.0L, plus_zero, UNDERFLOW_EXCEPTION);
8695
8696   END (pow);
8697 }
8698
8699
8700 static void
8701 pow_test_tonearest (void)
8702 {
8703   int save_round_mode;
8704   errno = 0;
8705   FUNC(pow) (0, 0);
8706   if (errno == ENOSYS)
8707     /* Function not implemented.  */
8708     return;
8709
8710   START (pow_tonearest);
8711
8712   save_round_mode = fegetround ();
8713
8714   if (!fesetround (FE_TONEAREST))
8715     {
8716       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
8717       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
8718     }
8719
8720   fesetround (save_round_mode);
8721
8722   END (pow_tonearest);
8723 }
8724
8725
8726 static void
8727 pow_test_towardzero (void)
8728 {
8729   int save_round_mode;
8730   errno = 0;
8731   FUNC(pow) (0, 0);
8732   if (errno == ENOSYS)
8733     /* Function not implemented.  */
8734     return;
8735
8736   START (pow_towardzero);
8737
8738   save_round_mode = fegetround ();
8739
8740   if (!fesetround (FE_TOWARDZERO))
8741     {
8742       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
8743       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
8744     }
8745
8746   fesetround (save_round_mode);
8747
8748   END (pow_towardzero);
8749 }
8750
8751
8752 static void
8753 pow_test_downward (void)
8754 {
8755   int save_round_mode;
8756   errno = 0;
8757   FUNC(pow) (0, 0);
8758   if (errno == ENOSYS)
8759     /* Function not implemented.  */
8760     return;
8761
8762   START (pow_downward);
8763
8764   save_round_mode = fegetround ();
8765
8766   if (!fesetround (FE_DOWNWARD))
8767     {
8768       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
8769       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
8770     }
8771
8772   fesetround (save_round_mode);
8773
8774   END (pow_downward);
8775 }
8776
8777
8778 static void
8779 pow_test_upward (void)
8780 {
8781   int save_round_mode;
8782   errno = 0;
8783   FUNC(pow) (0, 0);
8784   if (errno == ENOSYS)
8785     /* Function not implemented.  */
8786     return;
8787
8788   START (pow_upward);
8789
8790   save_round_mode = fegetround ();
8791
8792   if (!fesetround (FE_UPWARD))
8793     {
8794       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
8795       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
8796     }
8797
8798   fesetround (save_round_mode);
8799
8800   END (pow_upward);
8801 }
8802
8803
8804 static void
8805 remainder_test (void)
8806 {
8807   errno = 0;
8808   FUNC(remainder) (1.625, 1.0);
8809   if (errno == ENOSYS)
8810     /* Function not implemented.  */
8811     return;
8812
8813   START (remainder);
8814
8815   errno = 0;
8816   TEST_ff_f (remainder, 1, 0, nan_value, INVALID_EXCEPTION);
8817   check_int ("errno for remainder(1, 0) = EDOM ", errno, EDOM, 0, 0, 0);
8818   errno = 0;
8819   TEST_ff_f (remainder, 1, minus_zero, nan_value, INVALID_EXCEPTION);
8820   check_int ("errno for remainder(1, -0) = EDOM ", errno, EDOM, 0, 0, 0);
8821   errno = 0;
8822   TEST_ff_f (remainder, plus_infty, 1, nan_value, INVALID_EXCEPTION);
8823   check_int ("errno for remainder(INF, 1) = EDOM ", errno, EDOM, 0, 0, 0);
8824   errno = 0;
8825   TEST_ff_f (remainder, minus_infty, 1, nan_value, INVALID_EXCEPTION);
8826   check_int ("errno for remainder(-INF, 1) = EDOM ", errno, EDOM, 0, 0, 0);
8827   errno = 0;
8828   TEST_ff_f (remainder, nan_value, nan_value, nan_value);
8829   check_int ("errno for remainder(NAN, NAN) unchanged", errno, 0, 0, 0, 0);
8830   errno = 0;
8831   TEST_ff_f (remainder, 0, nan_value, nan_value);
8832   check_int ("errno for remainder(0, NAN) unchanged", errno, 0, 0, 0, 0);
8833   errno = 0;
8834   TEST_ff_f (remainder, nan_value, 0, nan_value);
8835   check_int ("errno for remainder(NaN, 0) unchanged", errno, 0, 0, 0, 0);
8836
8837   TEST_ff_f (remainder, 1.625, 1.0, -0.375);
8838   TEST_ff_f (remainder, -1.625, 1.0, 0.375);
8839   TEST_ff_f (remainder, 1.625, -1.0, -0.375);
8840   TEST_ff_f (remainder, -1.625, -1.0, 0.375);
8841   TEST_ff_f (remainder, 5.0, 2.0, 1.0);
8842   TEST_ff_f (remainder, 3.0, 2.0, -1.0);
8843
8844   END (remainder);
8845 }
8846
8847 static void
8848 remquo_test (void)
8849 {
8850   /* x is needed.  */
8851   int x;
8852
8853   errno = 0;
8854   FUNC(remquo) (1.625, 1.0, &x);
8855   if (errno == ENOSYS)
8856     /* Function not implemented.  */
8857     return;
8858
8859   START (remquo);
8860
8861   TEST_ffI_f1 (remquo, 1, 0, nan_value, IGNORE, INVALID_EXCEPTION);
8862   TEST_ffI_f1 (remquo, 1, minus_zero, nan_value, IGNORE, INVALID_EXCEPTION);
8863   TEST_ffI_f1 (remquo, plus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
8864   TEST_ffI_f1 (remquo, minus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
8865   TEST_ffI_f1 (remquo, nan_value, nan_value, nan_value, IGNORE);
8866
8867   TEST_ffI_f1 (remquo, 1.625, 1.0, -0.375, 2);
8868   TEST_ffI_f1 (remquo, -1.625, 1.0, 0.375, -2);
8869   TEST_ffI_f1 (remquo, 1.625, -1.0, -0.375, -2);
8870   TEST_ffI_f1 (remquo, -1.625, -1.0, 0.375, 2);
8871
8872   TEST_ffI_f1 (remquo, 5, 2, 1, 2);
8873   TEST_ffI_f1 (remquo, 3, 2, -1, 2);
8874
8875   END (remquo);
8876 }
8877
8878 static void
8879 rint_test (void)
8880 {
8881   START (rint);
8882
8883   TEST_f_f (rint, 0.0, 0.0);
8884   TEST_f_f (rint, minus_zero, minus_zero);
8885   TEST_f_f (rint, plus_infty, plus_infty);
8886   TEST_f_f (rint, minus_infty, minus_infty);
8887
8888   /* Default rounding mode is round to even.  */
8889   TEST_f_f (rint, 0.5, 0.0);
8890   TEST_f_f (rint, 1.5, 2.0);
8891   TEST_f_f (rint, 2.5, 2.0);
8892   TEST_f_f (rint, 3.5, 4.0);
8893   TEST_f_f (rint, 4.5, 4.0);
8894   TEST_f_f (rint, -0.5, -0.0);
8895   TEST_f_f (rint, -1.5, -2.0);
8896   TEST_f_f (rint, -2.5, -2.0);
8897   TEST_f_f (rint, -3.5, -4.0);
8898   TEST_f_f (rint, -4.5, -4.0);
8899   TEST_f_f (rint, 0.1, 0.0);
8900   TEST_f_f (rint, 0.25, 0.0);
8901   TEST_f_f (rint, 0.625, 1.0);
8902   TEST_f_f (rint, -0.1, -0.0);
8903   TEST_f_f (rint, -0.25, -0.0);
8904   TEST_f_f (rint, -0.625, -1.0);
8905   TEST_f_f (rint, 262144.75, 262145.0);
8906   TEST_f_f (rint, 262142.75, 262143.0);
8907   TEST_f_f (rint, 524286.75, 524287.0);
8908   TEST_f_f (rint, 524288.75, 524289.0);
8909   TEST_f_f (rint, 1048576.75, 1048577.0);
8910   TEST_f_f (rint, 2097152.75, 2097153.0);
8911   TEST_f_f (rint, -1048576.75, -1048577.0);
8912   TEST_f_f (rint, -2097152.75, -2097153.0);
8913 #ifndef TEST_FLOAT
8914   TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
8915   TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
8916   TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
8917   TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
8918   TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
8919   TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
8920   TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
8921   TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
8922   TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
8923   TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
8924 #endif
8925 #ifdef TEST_LDOUBLE
8926   /* The result can only be represented in long double.  */
8927   TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
8928   TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
8929   TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
8930   TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
8931   TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
8932
8933 # if LDBL_MANT_DIG > 100
8934   TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
8935   TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
8936   TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
8937 # endif
8938
8939   TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
8940   TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
8941   TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
8942   TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
8943   TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
8944
8945 # if LDBL_MANT_DIG > 100
8946   TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
8947   TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
8948   TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
8949
8950   TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
8951   TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
8952   TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
8953   TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
8954   TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
8955   TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
8956
8957   TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
8958   TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
8959   TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
8960   TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
8961   TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
8962   TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
8963 # endif
8964
8965   TEST_f_f (rint, 9007199254740991.5L, 9007199254740992.0L);
8966   TEST_f_f (rint, 9007199254740992.25L, 9007199254740992.0L);
8967   TEST_f_f (rint, 9007199254740992.5L, 9007199254740992.0L);
8968   TEST_f_f (rint, 9007199254740992.75L, 9007199254740993.0L);
8969   TEST_f_f (rint, 9007199254740993.5L, 9007199254740994.0L);
8970
8971   TEST_f_f (rint, -9007199254740991.5L, -9007199254740992.0L);
8972   TEST_f_f (rint, -9007199254740992.25L, -9007199254740992.0L);
8973   TEST_f_f (rint, -9007199254740992.5L, -9007199254740992.0L);
8974   TEST_f_f (rint, -9007199254740992.75L, -9007199254740993.0L);
8975   TEST_f_f (rint, -9007199254740993.5L, -9007199254740994.0L);
8976
8977   TEST_f_f (rint, 72057594037927935.5L, 72057594037927936.0L);
8978   TEST_f_f (rint, 72057594037927936.25L, 72057594037927936.0L);
8979   TEST_f_f (rint, 72057594037927936.5L, 72057594037927936.0L);
8980   TEST_f_f (rint, 72057594037927936.75L, 72057594037927937.0L);
8981   TEST_f_f (rint, 72057594037927937.5L, 72057594037927938.0L);
8982
8983   TEST_f_f (rint, -72057594037927935.5L, -72057594037927936.0L);
8984   TEST_f_f (rint, -72057594037927936.25L, -72057594037927936.0L);
8985   TEST_f_f (rint, -72057594037927936.5L, -72057594037927936.0L);
8986   TEST_f_f (rint, -72057594037927936.75L, -72057594037927937.0L);
8987   TEST_f_f (rint, -72057594037927937.5L, -72057594037927938.0L);
8988
8989   TEST_f_f (rint, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
8990   TEST_f_f (rint, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
8991   TEST_f_f (rint, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
8992   TEST_f_f (rint, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
8993   TEST_f_f (rint, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
8994 #endif
8995
8996   END (rint);
8997 }
8998
8999 static void
9000 rint_test_tonearest (void)
9001 {
9002   int save_round_mode;
9003   START (rint_tonearest);
9004
9005   save_round_mode = fegetround ();
9006
9007   if (!fesetround (FE_TONEAREST))
9008     {
9009       TEST_f_f (rint, 2.0, 2.0);
9010       TEST_f_f (rint, 1.5, 2.0);
9011       TEST_f_f (rint, 1.0, 1.0);
9012       TEST_f_f (rint, 0.5, 0.0);
9013       TEST_f_f (rint, 0.0, 0.0);
9014       TEST_f_f (rint, minus_zero, minus_zero);
9015       TEST_f_f (rint, -0.5, -0.0);
9016       TEST_f_f (rint, -1.0, -1.0);
9017       TEST_f_f (rint, -1.5, -2.0);
9018       TEST_f_f (rint, -2.0, -2.0);
9019       TEST_f_f (rint, 0.1, 0.0);
9020       TEST_f_f (rint, 0.25, 0.0);
9021       TEST_f_f (rint, 0.625, 1.0);
9022       TEST_f_f (rint, -0.1, -0.0);
9023       TEST_f_f (rint, -0.25, -0.0);
9024       TEST_f_f (rint, -0.625, -1.0);
9025       TEST_f_f (rint, 1048576.75, 1048577.0);
9026       TEST_f_f (rint, 2097152.75, 2097153.0);
9027       TEST_f_f (rint, -1048576.75, -1048577.0);
9028       TEST_f_f (rint, -2097152.75, -2097153.0);
9029 #ifndef TEST_FLOAT
9030       TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
9031       TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
9032       TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
9033       TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
9034       TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
9035       TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
9036       TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
9037       TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
9038       TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
9039       TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
9040 #endif
9041 #ifdef TEST_LDOUBLE
9042       /* The result can only be represented in long double.  */
9043       TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
9044       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
9045       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
9046       TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
9047       TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
9048 # if LDBL_MANT_DIG > 100
9049       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
9050       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
9051       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
9052 # endif
9053       TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
9054       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
9055       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
9056       TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
9057       TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
9058 # if LDBL_MANT_DIG > 100
9059       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
9060       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
9061       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
9062
9063       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
9064       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
9065       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
9066       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
9067       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
9068       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
9069
9070       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
9071       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
9072       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
9073       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
9074       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
9075       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
9076 # endif
9077 #endif
9078     }
9079
9080   fesetround (save_round_mode);
9081
9082   END (rint_tonearest);
9083 }
9084
9085 static void
9086 rint_test_towardzero (void)
9087 {
9088   int save_round_mode;
9089   START (rint_towardzero);
9090
9091   save_round_mode = fegetround ();
9092
9093   if (!fesetround (FE_TOWARDZERO))
9094     {
9095       TEST_f_f (rint, 2.0, 2.0);
9096       TEST_f_f (rint, 1.5, 1.0);
9097       TEST_f_f (rint, 1.0, 1.0);
9098       TEST_f_f (rint, 0.5, 0.0);
9099       TEST_f_f (rint, 0.0, 0.0);
9100       TEST_f_f (rint, minus_zero, minus_zero);
9101       TEST_f_f (rint, -0.5, -0.0);
9102       TEST_f_f (rint, -1.0, -1.0);
9103       TEST_f_f (rint, -1.5, -1.0);
9104       TEST_f_f (rint, -2.0, -2.0);
9105       TEST_f_f (rint, 0.1, 0.0);
9106       TEST_f_f (rint, 0.25, 0.0);
9107       TEST_f_f (rint, 0.625, 0.0);
9108       TEST_f_f (rint, -0.1, -0.0);
9109       TEST_f_f (rint, -0.25, -0.0);
9110       TEST_f_f (rint, -0.625, -0.0);
9111       TEST_f_f (rint, 1048576.75, 1048576.0);
9112       TEST_f_f (rint, 2097152.75, 2097152.0);
9113       TEST_f_f (rint, -1048576.75, -1048576.0);
9114       TEST_f_f (rint, -2097152.75, -2097152.0);
9115 #ifndef TEST_FLOAT
9116       TEST_f_f (rint, 70368744177664.75, 70368744177664.0);
9117       TEST_f_f (rint, 140737488355328.75, 140737488355328.0);
9118       TEST_f_f (rint, 281474976710656.75, 281474976710656.0);
9119       TEST_f_f (rint, 562949953421312.75, 562949953421312.0);
9120       TEST_f_f (rint, 1125899906842624.75, 1125899906842624.0);
9121       TEST_f_f (rint, -70368744177664.75, -70368744177664.0);
9122       TEST_f_f (rint, -140737488355328.75, -140737488355328.0);
9123       TEST_f_f (rint, -281474976710656.75, -281474976710656.0);
9124       TEST_f_f (rint, -562949953421312.75, -562949953421312.0);
9125       TEST_f_f (rint, -1125899906842624.75, -1125899906842624.0);
9126 #endif
9127 #ifdef TEST_LDOUBLE
9128       /* The result can only be represented in long double.  */
9129       TEST_f_f (rint, 4503599627370495.5L, 4503599627370495.0L);
9130       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
9131       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
9132       TEST_f_f (rint, 4503599627370496.75L, 4503599627370496.0L);
9133       TEST_f_f (rint, 4503599627370497.5L, 4503599627370497.0L);
9134 # if LDBL_MANT_DIG > 100
9135       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370494.0L);
9136       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370495.0L);
9137       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370496.0L);
9138 # endif
9139       TEST_f_f (rint, -4503599627370495.5L, -4503599627370495.0L);
9140       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
9141       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
9142       TEST_f_f (rint, -4503599627370496.75L, -4503599627370496.0L);
9143       TEST_f_f (rint, -4503599627370497.5L, -4503599627370497.0L);
9144 # if LDBL_MANT_DIG > 100
9145       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370494.0L);
9146       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370495.0L);
9147       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370496.0L);
9148
9149       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
9150       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
9151       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
9152       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740991.0L);
9153       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740992.0L);
9154       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740993.0L);
9155
9156       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
9157       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
9158       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
9159       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740991.0L);
9160       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740992.0L);
9161       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L);
9162 # endif
9163 #endif
9164     }
9165
9166   fesetround (save_round_mode);
9167
9168   END (rint_towardzero);
9169 }
9170
9171 static void
9172 rint_test_downward (void)
9173 {
9174   int save_round_mode;
9175   START (rint_downward);
9176
9177   save_round_mode = fegetround ();
9178
9179   if (!fesetround (FE_DOWNWARD))
9180     {
9181       TEST_f_f (rint, 2.0, 2.0);
9182       TEST_f_f (rint, 1.5, 1.0);
9183       TEST_f_f (rint, 1.0, 1.0);
9184       TEST_f_f (rint, 0.5, 0.0);
9185       TEST_f_f (rint, 0.0, 0.0);
9186       TEST_f_f (rint, minus_zero, minus_zero);
9187       TEST_f_f (rint, -0.5, -1.0);
9188       TEST_f_f (rint, -1.0, -1.0);
9189       TEST_f_f (rint, -1.5, -2.0);
9190       TEST_f_f (rint, -2.0, -2.0);
9191       TEST_f_f (rint, 0.1, 0.0);
9192       TEST_f_f (rint, 0.25, 0.0);
9193       TEST_f_f (rint, 0.625, 0.0);
9194       TEST_f_f (rint, -0.1, -1.0);
9195       TEST_f_f (rint, -0.25, -1.0);
9196       TEST_f_f (rint, -0.625, -1.0);
9197       TEST_f_f (rint, 1048576.75, 1048576.0);
9198       TEST_f_f (rint, 2097152.75, 2097152.0);
9199       TEST_f_f (rint, -1048576.75, -1048577.0);
9200       TEST_f_f (rint, -2097152.75, -2097153.0);
9201 #ifndef TEST_FLOAT
9202       TEST_f_f (rint, 70368744177664.75, 70368744177664.0);
9203       TEST_f_f (rint, 140737488355328.75, 140737488355328.0);
9204       TEST_f_f (rint, 281474976710656.75, 281474976710656.0);
9205       TEST_f_f (rint, 562949953421312.75, 562949953421312.0);
9206       TEST_f_f (rint, 1125899906842624.75, 1125899906842624.0);
9207       TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
9208       TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
9209       TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
9210       TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
9211       TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
9212 #endif
9213 #ifdef TEST_LDOUBLE
9214       /* The result can only be represented in long double.  */
9215       TEST_f_f (rint, 4503599627370495.5L, 4503599627370495.0L);
9216       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
9217       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
9218       TEST_f_f (rint, 4503599627370496.75L, 4503599627370496.0L);
9219       TEST_f_f (rint, 4503599627370497.5L, 4503599627370497.0L);
9220 # if LDBL_MANT_DIG > 100
9221       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370494.0L);
9222       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370495.0L);
9223       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370496.0L);
9224 # endif
9225       TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
9226       TEST_f_f (rint, -4503599627370496.25L, -4503599627370497.0L);
9227       TEST_f_f (rint, -4503599627370496.5L, -4503599627370497.0L);
9228       TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
9229       TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
9230 # if LDBL_MANT_DIG > 100
9231       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
9232       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
9233       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
9234
9235       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
9236       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
9237       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
9238       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740991.0L);
9239       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740992.0L);
9240       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740993.0L);
9241
9242       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740992.0L);
9243       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740993.0L);
9244       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740994.0L);
9245       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
9246       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
9247       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
9248 # endif
9249 #endif
9250     }
9251
9252   fesetround (save_round_mode);
9253
9254   END (rint_downward);
9255 }
9256
9257 static void
9258 rint_test_upward (void)
9259 {
9260   int save_round_mode;
9261   START (rint_upward);
9262
9263   save_round_mode = fegetround ();
9264
9265   if (!fesetround (FE_UPWARD))
9266     {
9267       TEST_f_f (rint, 2.0, 2.0);
9268       TEST_f_f (rint, 1.5, 2.0);
9269       TEST_f_f (rint, 1.0, 1.0);
9270       TEST_f_f (rint, 0.5, 1.0);
9271       TEST_f_f (rint, 0.0, 0.0);
9272       TEST_f_f (rint, minus_zero, minus_zero);
9273       TEST_f_f (rint, -0.5, -0.0);
9274       TEST_f_f (rint, -1.0, -1.0);
9275       TEST_f_f (rint, -1.5, -1.0);
9276       TEST_f_f (rint, -2.0, -2.0);
9277       TEST_f_f (rint, 0.1, 1.0);
9278       TEST_f_f (rint, 0.25, 1.0);
9279       TEST_f_f (rint, 0.625, 1.0);
9280       TEST_f_f (rint, -0.1, -0.0);
9281       TEST_f_f (rint, -0.25, -0.0);
9282       TEST_f_f (rint, -0.625, -0.0);
9283       TEST_f_f (rint, 1048576.75, 1048577.0);
9284       TEST_f_f (rint, 2097152.75, 2097153.0);
9285       TEST_f_f (rint, -1048576.75, -1048576.0);
9286       TEST_f_f (rint, -2097152.75, -2097152.0);
9287 #ifndef TEST_FLOAT
9288       TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
9289       TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
9290       TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
9291       TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
9292       TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
9293       TEST_f_f (rint, -70368744177664.75, -70368744177664.0);
9294       TEST_f_f (rint, -140737488355328.75, -140737488355328.0);
9295       TEST_f_f (rint, -281474976710656.75, -281474976710656.0);
9296       TEST_f_f (rint, -562949953421312.75, -562949953421312.0);
9297       TEST_f_f (rint, -1125899906842624.75, -1125899906842624.0);
9298 #endif
9299 #ifdef TEST_LDOUBLE
9300       /* The result can only be represented in long double.  */
9301       TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
9302       TEST_f_f (rint, 4503599627370496.25L, 4503599627370497.0L);
9303       TEST_f_f (rint, 4503599627370496.5L, 4503599627370497.0L);
9304       TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
9305       TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
9306 # if LDBL_MANT_DIG > 100
9307       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
9308       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
9309       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
9310 # endif
9311       TEST_f_f (rint, -4503599627370495.5L, -4503599627370495.0L);
9312       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
9313       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
9314       TEST_f_f (rint, -4503599627370496.75L, -4503599627370496.0L);
9315       TEST_f_f (rint, -4503599627370497.5L, -4503599627370497.0L);
9316 # if LDBL_MANT_DIG > 100
9317       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370494.0L);
9318       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370495.0L);
9319       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370496.0L);
9320
9321       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740992.0L);
9322       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740993.0L);
9323       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740994.0L);
9324       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
9325       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
9326       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
9327
9328       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
9329       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
9330       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
9331       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740991.0L);
9332       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740992.0L);
9333       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L);
9334 # endif
9335 #endif
9336     }
9337
9338   fesetround (save_round_mode);
9339
9340   END (rint_upward);
9341 }
9342
9343 static void
9344 round_test (void)
9345 {
9346   START (round);
9347
9348   TEST_f_f (round, 0, 0);
9349   TEST_f_f (round, minus_zero, minus_zero);
9350   TEST_f_f (round, 0.2L, 0.0);
9351   TEST_f_f (round, -0.2L, minus_zero);
9352   TEST_f_f (round, 0.5, 1.0);
9353   TEST_f_f (round, -0.5, -1.0);
9354   TEST_f_f (round, 0.8L, 1.0);
9355   TEST_f_f (round, -0.8L, -1.0);
9356   TEST_f_f (round, 1.5, 2.0);
9357   TEST_f_f (round, -1.5, -2.0);
9358   TEST_f_f (round, 0.1, 0.0);
9359   TEST_f_f (round, 0.25, 0.0);
9360   TEST_f_f (round, 0.625, 1.0);
9361   TEST_f_f (round, -0.1, -0.0);
9362   TEST_f_f (round, -0.25, -0.0);
9363   TEST_f_f (round, -0.625, -1.0);
9364   TEST_f_f (round, 2097152.5, 2097153);
9365   TEST_f_f (round, -2097152.5, -2097153);
9366
9367 #ifdef TEST_LDOUBLE
9368   /* The result can only be represented in long double.  */
9369   TEST_f_f (round, 4503599627370495.5L, 4503599627370496.0L);
9370   TEST_f_f (round, 4503599627370496.25L, 4503599627370496.0L);
9371   TEST_f_f (round, 4503599627370496.5L, 4503599627370497.0L);
9372   TEST_f_f (round, 4503599627370496.75L, 4503599627370497.0L);
9373   TEST_f_f (round, 4503599627370497.5L, 4503599627370498.0L);
9374 # if LDBL_MANT_DIG > 100
9375   TEST_f_f (round, 4503599627370494.5000000000001L, 4503599627370495.0L);
9376   TEST_f_f (round, 4503599627370495.5000000000001L, 4503599627370496.0L);
9377   TEST_f_f (round, 4503599627370496.5000000000001L, 4503599627370497.0L);
9378 # endif
9379
9380   TEST_f_f (round, -4503599627370495.5L, -4503599627370496.0L);
9381   TEST_f_f (round, -4503599627370496.25L, -4503599627370496.0L);
9382   TEST_f_f (round, -4503599627370496.5L, -4503599627370497.0L);
9383   TEST_f_f (round, -4503599627370496.75L, -4503599627370497.0L);
9384   TEST_f_f (round, -4503599627370497.5L, -4503599627370498.0L);
9385 # if LDBL_MANT_DIG > 100
9386   TEST_f_f (round, -4503599627370494.5000000000001L, -4503599627370495.0L);
9387   TEST_f_f (round, -4503599627370495.5000000000001L, -4503599627370496.0L);
9388   TEST_f_f (round, -4503599627370496.5000000000001L, -4503599627370497.0L);
9389 # endif
9390
9391   TEST_f_f (round, 9007199254740991.5L, 9007199254740992.0L);
9392   TEST_f_f (round, 9007199254740992.25L, 9007199254740992.0L);
9393   TEST_f_f (round, 9007199254740992.5L, 9007199254740993.0L);
9394   TEST_f_f (round, 9007199254740992.75L, 9007199254740993.0L);
9395   TEST_f_f (round, 9007199254740993.5L, 9007199254740994.0L);
9396
9397   TEST_f_f (round, -9007199254740991.5L, -9007199254740992.0L);
9398   TEST_f_f (round, -9007199254740992.25L, -9007199254740992.0L);
9399   TEST_f_f (round, -9007199254740992.5L, -9007199254740993.0L);
9400   TEST_f_f (round, -9007199254740992.75L, -9007199254740993.0L);
9401   TEST_f_f (round, -9007199254740993.5L, -9007199254740994.0L);
9402
9403 # if LDBL_MANT_DIG > 100
9404   TEST_f_f (round, 9007199254740991.0000000000001L, 9007199254740991.0L);
9405   TEST_f_f (round, 9007199254740992.0000000000001L, 9007199254740992.0L);
9406   TEST_f_f (round, 9007199254740993.0000000000001L, 9007199254740993.0L);
9407   TEST_f_f (round, 9007199254740991.5000000000001L, 9007199254740992.0L);
9408   TEST_f_f (round, 9007199254740992.5000000000001L, 9007199254740993.0L);
9409   TEST_f_f (round, 9007199254740993.5000000000001L, 9007199254740994.0L);
9410
9411   TEST_f_f (round, -9007199254740991.0000000000001L, -9007199254740991.0L);
9412   TEST_f_f (round, -9007199254740992.0000000000001L, -9007199254740992.0L);
9413   TEST_f_f (round, -9007199254740993.0000000000001L, -9007199254740993.0L);
9414   TEST_f_f (round, -9007199254740991.5000000000001L, -9007199254740992.0L);
9415   TEST_f_f (round, -9007199254740992.5000000000001L, -9007199254740993.0L);
9416   TEST_f_f (round, -9007199254740993.5000000000001L, -9007199254740994.0L);
9417 # endif
9418
9419   TEST_f_f (round, 72057594037927935.5L, 72057594037927936.0L);
9420   TEST_f_f (round, 72057594037927936.25L, 72057594037927936.0L);
9421   TEST_f_f (round, 72057594037927936.5L, 72057594037927937.0L);
9422   TEST_f_f (round, 72057594037927936.75L, 72057594037927937.0L);
9423   TEST_f_f (round, 72057594037927937.5L, 72057594037927938.0L);
9424
9425   TEST_f_f (round, -72057594037927935.5L, -72057594037927936.0L);
9426   TEST_f_f (round, -72057594037927936.25L, -72057594037927936.0L);
9427   TEST_f_f (round, -72057594037927936.5L, -72057594037927937.0L);
9428   TEST_f_f (round, -72057594037927936.75L, -72057594037927937.0L);
9429   TEST_f_f (round, -72057594037927937.5L, -72057594037927938.0L);
9430
9431   TEST_f_f (round, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
9432   TEST_f_f (round, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
9433   TEST_f_f (round, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
9434   TEST_f_f (round, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
9435   TEST_f_f (round, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
9436 #endif
9437
9438   END (round);
9439 }
9440
9441
9442 static void
9443 scalb_test (void)
9444 {
9445
9446   START (scalb);
9447
9448   TEST_ff_f (scalb, 2.0, 0.5, nan_value, INVALID_EXCEPTION);
9449   TEST_ff_f (scalb, 3.0, -2.5, nan_value, INVALID_EXCEPTION);
9450
9451   TEST_ff_f (scalb, 0, nan_value, nan_value);
9452   TEST_ff_f (scalb, 1, nan_value, nan_value);
9453
9454   TEST_ff_f (scalb, 1, 0, 1);
9455   TEST_ff_f (scalb, -1, 0, -1);
9456
9457   TEST_ff_f (scalb, 0, plus_infty, nan_value, INVALID_EXCEPTION);
9458   TEST_ff_f (scalb, minus_zero, plus_infty, nan_value, INVALID_EXCEPTION);
9459
9460   TEST_ff_f (scalb, 0, 2, 0);
9461   TEST_ff_f (scalb, minus_zero, -4, minus_zero);
9462   TEST_ff_f (scalb, 0, 0, 0);
9463   TEST_ff_f (scalb, minus_zero, 0, minus_zero);
9464   TEST_ff_f (scalb, 0, -1, 0);
9465   TEST_ff_f (scalb, minus_zero, -10, minus_zero);
9466   TEST_ff_f (scalb, 0, minus_infty, 0);
9467   TEST_ff_f (scalb, minus_zero, minus_infty, minus_zero);
9468
9469   TEST_ff_f (scalb, plus_infty, -1, plus_infty);
9470   TEST_ff_f (scalb, minus_infty, -10, minus_infty);
9471   TEST_ff_f (scalb, plus_infty, 0, plus_infty);
9472   TEST_ff_f (scalb, minus_infty, 0, minus_infty);
9473   TEST_ff_f (scalb, plus_infty, 2, plus_infty);
9474   TEST_ff_f (scalb, minus_infty, 100, minus_infty);
9475
9476   TEST_ff_f (scalb, 0.1L, minus_infty, 0.0);
9477   TEST_ff_f (scalb, -0.1L, minus_infty, minus_zero);
9478
9479   TEST_ff_f (scalb, 1, plus_infty, plus_infty);
9480   TEST_ff_f (scalb, -1, plus_infty, minus_infty);
9481   TEST_ff_f (scalb, plus_infty, plus_infty, plus_infty);
9482   TEST_ff_f (scalb, minus_infty, plus_infty, minus_infty);
9483
9484   TEST_ff_f (scalb, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
9485   TEST_ff_f (scalb, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
9486
9487   TEST_ff_f (scalb, nan_value, 1, nan_value);
9488   TEST_ff_f (scalb, 1, nan_value, nan_value);
9489   TEST_ff_f (scalb, nan_value, 0, nan_value);
9490   TEST_ff_f (scalb, 0, nan_value, nan_value);
9491   TEST_ff_f (scalb, nan_value, plus_infty, nan_value);
9492   TEST_ff_f (scalb, plus_infty, nan_value, nan_value);
9493   TEST_ff_f (scalb, nan_value, nan_value, nan_value);
9494
9495   TEST_ff_f (scalb, 0.8L, 4, 12.8L);
9496   TEST_ff_f (scalb, -0.854375L, 5, -27.34L);
9497
9498   END (scalb);
9499 }
9500
9501
9502 static void
9503 scalbn_test (void)
9504 {
9505
9506   START (scalbn);
9507
9508   TEST_fi_f (scalbn, 0, 0, 0);
9509   TEST_fi_f (scalbn, minus_zero, 0, minus_zero);
9510
9511   TEST_fi_f (scalbn, plus_infty, 1, plus_infty);
9512   TEST_fi_f (scalbn, minus_infty, 1, minus_infty);
9513   TEST_fi_f (scalbn, nan_value, 1, nan_value);
9514
9515   TEST_fi_f (scalbn, 0.8L, 4, 12.8L);
9516   TEST_fi_f (scalbn, -0.854375L, 5, -27.34L);
9517
9518   TEST_fi_f (scalbn, 1, 0L, 1);
9519
9520   TEST_fi_f (scalbn, 1, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9521   TEST_fi_f (scalbn, 1, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9522   TEST_fi_f (scalbn, max_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9523   TEST_fi_f (scalbn, max_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9524   TEST_fi_f (scalbn, min_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9525   TEST_fi_f (scalbn, min_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9526   TEST_fi_f (scalbn, min_value / 4, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9527   TEST_fi_f (scalbn, min_value / 4, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9528
9529   END (scalbn);
9530 }
9531
9532
9533 static void
9534 scalbln_test (void)
9535 {
9536
9537   START (scalbln);
9538
9539   TEST_fl_f (scalbln, 0, 0, 0);
9540   TEST_fl_f (scalbln, minus_zero, 0, minus_zero);
9541
9542   TEST_fl_f (scalbln, plus_infty, 1, plus_infty);
9543   TEST_fl_f (scalbln, minus_infty, 1, minus_infty);
9544   TEST_fl_f (scalbln, nan_value, 1, nan_value);
9545
9546   TEST_fl_f (scalbln, 0.8L, 4, 12.8L);
9547   TEST_fl_f (scalbln, -0.854375L, 5, -27.34L);
9548
9549   TEST_fl_f (scalbln, 1, 0L, 1);
9550
9551   TEST_fi_f (scalbln, 1, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9552   TEST_fi_f (scalbln, 1, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9553   TEST_fi_f (scalbln, max_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9554   TEST_fi_f (scalbln, max_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9555   TEST_fi_f (scalbln, min_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9556   TEST_fi_f (scalbln, min_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9557   TEST_fi_f (scalbln, min_value / 4, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
9558   TEST_fi_f (scalbln, min_value / 4, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9559
9560   TEST_fi_f (scalbln, 1, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
9561   TEST_fi_f (scalbln, 1, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9562   TEST_fi_f (scalbln, max_value, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
9563   TEST_fi_f (scalbln, max_value, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9564   TEST_fi_f (scalbln, min_value, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
9565   TEST_fi_f (scalbln, min_value, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9566   TEST_fi_f (scalbln, min_value / 4, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
9567   TEST_fi_f (scalbln, min_value / 4, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
9568
9569 #if LONG_MAX >= 0x100000000
9570   TEST_fi_f (scalbln, 1, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
9571   TEST_fi_f (scalbln, 1, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
9572   TEST_fi_f (scalbln, max_value, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
9573   TEST_fi_f (scalbln, max_value, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
9574   TEST_fi_f (scalbln, min_value, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
9575   TEST_fi_f (scalbln, min_value, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
9576   TEST_fi_f (scalbln, min_value / 4, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
9577   TEST_fi_f (scalbln, min_value / 4, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
9578 #endif
9579
9580   END (scalbn);
9581 }
9582
9583
9584 static void
9585 signbit_test (void)
9586 {
9587
9588   START (signbit);
9589
9590   TEST_f_b (signbit, 0, 0);
9591   TEST_f_b (signbit, minus_zero, 1);
9592   TEST_f_b (signbit, plus_infty, 0);
9593   TEST_f_b (signbit, minus_infty, 1);
9594
9595   /* signbit (x) != 0 for x < 0.  */
9596   TEST_f_b (signbit, -1, 1);
9597   /* signbit (x) == 0 for x >= 0.  */
9598   TEST_f_b (signbit, 1, 0);
9599
9600   END (signbit);
9601 }
9602
9603
9604 static void
9605 sin_test (void)
9606 {
9607   errno = 0;
9608   FUNC(sin) (0);
9609   if (errno == ENOSYS)
9610     /* Function not implemented.  */
9611     return;
9612
9613   START (sin);
9614
9615   TEST_f_f (sin, 0, 0);
9616   TEST_f_f (sin, minus_zero, minus_zero);
9617   errno = 0;
9618   TEST_f_f (sin, plus_infty, nan_value, INVALID_EXCEPTION);
9619   check_int ("errno for sin(+inf) == EDOM", errno, EDOM, 0, 0, 0);
9620   errno = 0;
9621   TEST_f_f (sin, minus_infty, nan_value, INVALID_EXCEPTION);
9622   check_int ("errno for sin(-inf) == EDOM", errno, EDOM, 0, 0, 0);
9623   errno = 0;
9624   TEST_f_f (sin, nan_value, nan_value);
9625   check_int ("errno for sin(NaN) unchanged", errno, 0, 0, 0, 0);
9626
9627   TEST_f_f (sin, M_PI_6l, 0.5);
9628   TEST_f_f (sin, -M_PI_6l, -0.5);
9629   TEST_f_f (sin, M_PI_2l, 1);
9630   TEST_f_f (sin, -M_PI_2l, -1);
9631   TEST_f_f (sin, 0.75L, 0.681638760023334166733241952779893935L);
9632
9633   TEST_f_f (sin, 0x1p65, -0.047183876212354673805106149805700013943218L);
9634   TEST_f_f (sin, -0x1p65, 0.047183876212354673805106149805700013943218L);
9635
9636   TEST_f_f (sin, 0x1.7f4134p+103, -6.6703229329788657073304190650534846045235e-08L);
9637
9638 #ifdef TEST_DOUBLE
9639   TEST_f_f (sin, 0.80190127184058835, 0.71867942238767868);
9640   TEST_f_f (sin, 2.522464e-1, 2.4957989804940911e-1);
9641 #endif
9642
9643 #ifndef TEST_FLOAT
9644   TEST_f_f (sin, 1e22, -0.8522008497671888017727058937530293682618L);
9645   TEST_f_f (sin, 0x1p1023, 0.5631277798508840134529434079444683477104L);
9646 #endif
9647
9648 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
9649   TEST_f_f (sin, 0x1p16383L, 0.3893629985894208126948115852610595405563L);
9650 #endif
9651
9652   TEST_f_f (sin, 0x1p+120, 3.77820109360752022655548470056922991960587e-01L);
9653   TEST_f_f (sin, 0x1p+127, 6.23385512955870240370428801097126489001833e-01L);
9654   TEST_f_f (sin, 0x1.fffff8p+127, 4.85786063130487339701113680434728152037092e-02L);
9655   TEST_f_f (sin, 0x1.fffffep+127, -5.21876523333658540551505357019806722935726e-01L);
9656   TEST_f_f (sin, 0x1p+50, 4.96396515208940840876821859865411368093356e-01L);
9657   TEST_f_f (sin, 0x1p+28, -9.86198211836975655703110310527108292055548e-01L);
9658
9659   END (sin);
9660
9661 }
9662
9663
9664 static void
9665 sin_test_tonearest (void)
9666 {
9667   int save_round_mode;
9668   errno = 0;
9669   FUNC(sin) (0);
9670   if (errno == ENOSYS)
9671     /* Function not implemented.  */
9672     return;
9673
9674   START (sin_tonearest);
9675
9676   save_round_mode = fegetround ();
9677
9678   if (!fesetround (FE_TONEAREST))
9679     {
9680       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
9681       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
9682       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
9683       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
9684       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
9685       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
9686       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
9687       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
9688       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
9689       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
9690     }
9691
9692   fesetround (save_round_mode);
9693
9694   END (sin_tonearest);
9695 }
9696
9697
9698 static void
9699 sin_test_towardzero (void)
9700 {
9701   int save_round_mode;
9702   errno = 0;
9703   FUNC(sin) (0);
9704   if (errno == ENOSYS)
9705     /* Function not implemented.  */
9706     return;
9707
9708   START (sin_towardzero);
9709
9710   save_round_mode = fegetround ();
9711
9712   if (!fesetround (FE_TOWARDZERO))
9713     {
9714       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
9715       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
9716       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
9717       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
9718       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
9719       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
9720       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
9721       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
9722       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
9723       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
9724     }
9725
9726   fesetround (save_round_mode);
9727
9728   END (sin_towardzero);
9729 }
9730
9731
9732 static void
9733 sin_test_downward (void)
9734 {
9735   int save_round_mode;
9736   errno = 0;
9737   FUNC(sin) (0);
9738   if (errno == ENOSYS)
9739     /* Function not implemented.  */
9740     return;
9741
9742   START (sin_downward);
9743
9744   save_round_mode = fegetround ();
9745
9746   if (!fesetround (FE_DOWNWARD))
9747     {
9748       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
9749       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
9750       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
9751       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
9752       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
9753       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
9754       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
9755       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
9756       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
9757       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
9758     }
9759
9760   fesetround (save_round_mode);
9761
9762   END (sin_downward);
9763 }
9764
9765
9766 static void
9767 sin_test_upward (void)
9768 {
9769   int save_round_mode;
9770   errno = 0;
9771   FUNC(sin) (0);
9772   if (errno == ENOSYS)
9773     /* Function not implemented.  */
9774     return;
9775
9776   START (sin_upward);
9777
9778   save_round_mode = fegetround ();
9779
9780   if (!fesetround (FE_UPWARD))
9781     {
9782       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
9783       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
9784       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
9785       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
9786       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
9787       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
9788       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
9789       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
9790       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
9791       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
9792     }
9793
9794   fesetround (save_round_mode);
9795
9796   END (sin_upward);
9797 }
9798
9799
9800 static void
9801 sincos_test (void)
9802 {
9803   FLOAT sin_res, cos_res;
9804
9805   errno = 0;
9806   FUNC(sincos) (0, &sin_res, &cos_res);
9807   if (errno == ENOSYS)
9808     /* Function not implemented.  */
9809     return;
9810
9811   START (sincos);
9812
9813   /* sincos is treated differently because it returns void.  */
9814   TEST_extra (sincos, 0, 0, 1);
9815
9816   TEST_extra (sincos, minus_zero, minus_zero, 1);
9817   TEST_extra (sincos, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
9818   TEST_extra (sincos, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
9819   TEST_extra (sincos, nan_value, nan_value, nan_value);
9820
9821   TEST_extra (sincos, M_PI_2l, 1, 0);
9822   TEST_extra (sincos, M_PI_6l, 0.5, 0.86602540378443864676372317075293616L);
9823   TEST_extra (sincos, M_PI_6l*2.0, 0.86602540378443864676372317075293616L, 0.5);
9824   TEST_extra (sincos, 0.75L, 0.681638760023334166733241952779893935L, 0.731688868873820886311838753000084544L);
9825
9826   TEST_extra (sincos, 0x1p65, -0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L);
9827   TEST_extra (sincos, -0x1p65, 0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L);
9828
9829 #ifdef TEST_DOUBLE
9830   TEST_extra (sincos, 0.80190127184058835, 0.71867942238767868, 0.69534156199418473);
9831 #endif
9832
9833 #ifndef TEST_FLOAT
9834   TEST_extra (sincos, 1e22, -0.8522008497671888017727058937530293682618L, 0.5232147853951389454975944733847094921409L);
9835   TEST_extra (sincos, 0x1p1023, 0.5631277798508840134529434079444683477104L, -0.826369834614147994500785680811743734805L);
9836 #endif
9837
9838 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
9839   TEST_extra (sincos, 0x1p16383L, 0.3893629985894208126948115852610595405563L, 0.9210843909921906206874509522505756251609L);
9840 #endif
9841
9842   TEST_extra (sincos, 0x1p+120, 3.77820109360752022655548470056922991960587e-01L, -9.25879022854837867303861764107414946730833e-01L);
9843   TEST_extra (sincos, 0x1p+127, 6.23385512955870240370428801097126489001833e-01L, 7.81914638714960072263910298466369236613162e-01L);
9844   TEST_extra (sincos, 0x1.fffff8p+127, 4.85786063130487339701113680434728152037092e-02L, 9.98819362551949040703862043664101081064641e-01L);
9845   TEST_extra (sincos, 0x1.fffffep+127, -5.21876523333658540551505357019806722935726e-01L, 8.53021039830304158051791467692161107353094e-01L);
9846   TEST_extra (sincos, 0x1p+50, 4.96396515208940840876821859865411368093356e-01L, 8.68095904660550604334592502063501320395739e-01L);
9847   TEST_extra (sincos, 0x1p+28, -9.86198211836975655703110310527108292055548e-01L, -1.65568979490578758865468278195361551113358e-01L);
9848
9849   END (sincos);
9850 }
9851
9852 static void
9853 sinh_test (void)
9854 {
9855   errno = 0;
9856   FUNC(sinh) (0.7L);
9857   if (errno == ENOSYS)
9858     /* Function not implemented.  */
9859     return;
9860
9861   START (sinh);
9862   TEST_f_f (sinh, 0, 0);
9863   TEST_f_f (sinh, minus_zero, minus_zero);
9864
9865 #ifndef TEST_INLINE
9866   TEST_f_f (sinh, plus_infty, plus_infty);
9867   TEST_f_f (sinh, minus_infty, minus_infty);
9868 #endif
9869   TEST_f_f (sinh, nan_value, nan_value);
9870
9871   TEST_f_f (sinh, 0.75L, 0.822316731935829980703661634446913849L);
9872   TEST_f_f (sinh, 0x8p-32L, 1.86264514923095703232705808926175479e-9L);
9873
9874   END (sinh);
9875 }
9876
9877
9878 static void
9879 sinh_test_tonearest (void)
9880 {
9881   int save_round_mode;
9882   errno = 0;
9883   FUNC(sinh) (0);
9884   if (errno == ENOSYS)
9885     /* Function not implemented.  */
9886     return;
9887
9888   START (sinh_tonearest);
9889
9890   save_round_mode = fegetround ();
9891
9892   if (!fesetround (FE_TONEAREST))
9893     {
9894       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
9895       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
9896       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
9897     }
9898
9899   fesetround (save_round_mode);
9900
9901   END (sinh_tonearest);
9902 }
9903
9904
9905 static void
9906 sinh_test_towardzero (void)
9907 {
9908   int save_round_mode;
9909   errno = 0;
9910   FUNC(sinh) (0);
9911   if (errno == ENOSYS)
9912     /* Function not implemented.  */
9913     return;
9914
9915   START (sinh_towardzero);
9916
9917   save_round_mode = fegetround ();
9918
9919   if (!fesetround (FE_TOWARDZERO))
9920     {
9921       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
9922       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
9923       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
9924     }
9925
9926   fesetround (save_round_mode);
9927
9928   END (sinh_towardzero);
9929 }
9930
9931
9932 static void
9933 sinh_test_downward (void)
9934 {
9935   int save_round_mode;
9936   errno = 0;
9937   FUNC(sinh) (0);
9938   if (errno == ENOSYS)
9939     /* Function not implemented.  */
9940     return;
9941
9942   START (sinh_downward);
9943
9944   save_round_mode = fegetround ();
9945
9946   if (!fesetround (FE_DOWNWARD))
9947     {
9948       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
9949       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
9950       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
9951     }
9952
9953   fesetround (save_round_mode);
9954
9955   END (sinh_downward);
9956 }
9957
9958
9959 static void
9960 sinh_test_upward (void)
9961 {
9962   int save_round_mode;
9963   errno = 0;
9964   FUNC(sinh) (0);
9965   if (errno == ENOSYS)
9966     /* Function not implemented.  */
9967     return;
9968
9969   START (sinh_upward);
9970
9971   save_round_mode = fegetround ();
9972
9973   if (!fesetround (FE_UPWARD))
9974     {
9975       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
9976       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
9977       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
9978     }
9979
9980   fesetround (save_round_mode);
9981
9982   END (sinh_upward);
9983 }
9984
9985
9986 static void
9987 sqrt_test (void)
9988 {
9989   errno = 0;
9990   FUNC(sqrt) (1);
9991   if (errno == ENOSYS)
9992     /* Function not implemented.  */
9993     return;
9994
9995   START (sqrt);
9996
9997   TEST_f_f (sqrt, 0, 0);
9998   TEST_f_f (sqrt, nan_value, nan_value);
9999   TEST_f_f (sqrt, plus_infty, plus_infty);
10000
10001   TEST_f_f (sqrt, minus_zero, minus_zero);
10002
10003   /* sqrt (x) == NaN plus invalid exception for x < 0.  */
10004   TEST_f_f (sqrt, -1, nan_value, INVALID_EXCEPTION);
10005   TEST_f_f (sqrt, -max_value, nan_value, INVALID_EXCEPTION);
10006   TEST_f_f (sqrt, minus_infty, nan_value, INVALID_EXCEPTION);
10007   TEST_f_f (sqrt, nan_value, nan_value);
10008
10009   TEST_f_f (sqrt, 2209, 47);
10010   TEST_f_f (sqrt, 4, 2);
10011   TEST_f_f (sqrt, 2, M_SQRT2l);
10012   TEST_f_f (sqrt, 0.25, 0.5);
10013   TEST_f_f (sqrt, 6642.25, 81.5);
10014   TEST_f_f (sqrt, 15190.5625L, 123.25L);
10015   TEST_f_f (sqrt, 0.75L, 0.866025403784438646763723170752936183L);
10016
10017   END (sqrt);
10018 }
10019
10020
10021 static void
10022 tan_test (void)
10023 {
10024   errno = 0;
10025   FUNC(tan) (0);
10026   if (errno == ENOSYS)
10027     /* Function not implemented.  */
10028     return;
10029
10030   START (tan);
10031
10032   TEST_f_f (tan, 0, 0);
10033   TEST_f_f (tan, minus_zero, minus_zero);
10034   errno = 0;
10035   TEST_f_f (tan, plus_infty, nan_value, INVALID_EXCEPTION);
10036   check_int ("errno for tan(Inf) == EDOM", errno, EDOM, 0, 0, 0);
10037   errno = 0;
10038   TEST_f_f (tan, minus_infty, nan_value, INVALID_EXCEPTION);
10039   check_int ("errno for tan(-Inf) == EDOM", errno, EDOM, 0, 0, 0);
10040   errno = 0;
10041   TEST_f_f (tan, nan_value, nan_value);
10042   check_int ("errno for tan(NaN) == 0", errno, 0, 0, 0, 0);
10043
10044   TEST_f_f (tan, M_PI_4l, 1);
10045   TEST_f_f (tan, 0.75L, 0.931596459944072461165202756573936428L);
10046
10047   TEST_f_f (tan, 0x1p65, -0.0472364872359047946798414219288370688827L);
10048   TEST_f_f (tan, -0x1p65, 0.0472364872359047946798414219288370688827L);
10049
10050   TEST_f_f (tan, 0xc.9p-4, 0.9995162902115457818029468900654150261381L);
10051   TEST_f_f (tan, 0xc.908p-4, 0.9997603425502441410973077452249560802034L);
10052   TEST_f_f (tan, 0xc.90cp-4, 0.9998823910588060302788513970802357770031L);
10053   TEST_f_f (tan, 0xc.90ep-4, 0.9999434208994808753305784795924711152508L);
10054   TEST_f_f (tan, 0xc.90fp-4, 0.9999739372166156702433266059635165160515L);
10055   TEST_f_f (tan, 0xc.90f8p-4, 0.9999891957244072765118898375645469865764L);
10056   TEST_f_f (tan, 0xc.90fcp-4, 0.9999968250656122402859679132395522927393L);
10057   TEST_f_f (tan, 0xc.90fdp-4, 0.9999987324100083358016192309006353329444L);
10058   TEST_f_f (tan, 0xc.90fd8p-4, 0.9999996860835706212861509874451585282616L);
10059   TEST_f_f (tan, 0xc.90fdap-4, 0.9999999245021033010474530133665235922808L);
10060   TEST_f_f (tan, 0xc.ap-4, 1.0073556597407272165371804539701396631519L);
10061   TEST_f_f (tan, 0xc.98p-4, 1.0034282930863044654045449407466962736255L);
10062   TEST_f_f (tan, 0xc.94p-4, 1.0014703786820082237342656561856877993328L);
10063   TEST_f_f (tan, 0xc.92p-4, 1.0004928571392300571266638743539017593717L);
10064   TEST_f_f (tan, 0xc.91p-4, 1.0000044544650244953647966900221905361131L);
10065   TEST_f_f (tan, 0xc.90fep-4, 1.0000006397580424009014454926842136804016L);
10066   TEST_f_f (tan, 0xc.90fdcp-4, 1.0000001629206928242190327320047489394217L);
10067   TEST_f_f (tan, 0xc.90fdbp-4, 1.0000000437113909572052640953950483705005L);
10068
10069   TEST_f_f (tan, -0xc.9p-4, -0.9995162902115457818029468900654150261381L);
10070   TEST_f_f (tan, -0xc.908p-4, -0.9997603425502441410973077452249560802034L);
10071   TEST_f_f (tan, -0xc.90cp-4, -0.9998823910588060302788513970802357770031L);
10072   TEST_f_f (tan, -0xc.90ep-4, -0.9999434208994808753305784795924711152508L);
10073   TEST_f_f (tan, -0xc.90fp-4, -0.9999739372166156702433266059635165160515L);
10074   TEST_f_f (tan, -0xc.90f8p-4, -0.9999891957244072765118898375645469865764L);
10075   TEST_f_f (tan, -0xc.90fcp-4, -0.9999968250656122402859679132395522927393L);
10076   TEST_f_f (tan, -0xc.90fdp-4, -0.9999987324100083358016192309006353329444L);
10077   TEST_f_f (tan, -0xc.90fd8p-4, -0.9999996860835706212861509874451585282616L);
10078   TEST_f_f (tan, -0xc.90fdap-4, -0.9999999245021033010474530133665235922808L);
10079   TEST_f_f (tan, -0xc.ap-4, -1.0073556597407272165371804539701396631519L);
10080   TEST_f_f (tan, -0xc.98p-4, -1.0034282930863044654045449407466962736255L);
10081   TEST_f_f (tan, -0xc.94p-4, -1.0014703786820082237342656561856877993328L);
10082   TEST_f_f (tan, -0xc.92p-4, -1.0004928571392300571266638743539017593717L);
10083   TEST_f_f (tan, -0xc.91p-4, -1.0000044544650244953647966900221905361131L);
10084   TEST_f_f (tan, -0xc.90fep-4, -1.0000006397580424009014454926842136804016L);
10085   TEST_f_f (tan, -0xc.90fdcp-4, -1.0000001629206928242190327320047489394217L);
10086   TEST_f_f (tan, -0xc.90fdbp-4, -1.0000000437113909572052640953950483705005L);
10087
10088 #ifndef TEST_FLOAT
10089   TEST_f_f (tan, 1e22, -1.628778225606898878549375936939548513545L);
10090   TEST_f_f (tan, 0x1p1023, -0.6814476476066215012854144040167365190368L);
10091 #endif
10092
10093 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
10094   TEST_f_f (tan, 0x1p16383L, 0.422722393732022337800504160054440141575L);
10095 #endif
10096
10097   END (tan);
10098 }
10099
10100
10101 static void
10102 tan_test_tonearest (void)
10103 {
10104   int save_round_mode;
10105   errno = 0;
10106   FUNC(tan) (0);
10107   if (errno == ENOSYS)
10108     /* Function not implemented.  */
10109     return;
10110
10111   START (tan_tonearest);
10112
10113   save_round_mode = fegetround ();
10114
10115   if (!fesetround (FE_TONEAREST))
10116     {
10117       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
10118       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
10119       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
10120       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
10121       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
10122       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
10123       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
10124       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
10125       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
10126       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
10127     }
10128
10129   fesetround (save_round_mode);
10130
10131   END (tan_tonearest);
10132 }
10133
10134
10135 static void
10136 tan_test_towardzero (void)
10137 {
10138   int save_round_mode;
10139   errno = 0;
10140   FUNC(tan) (0);
10141   if (errno == ENOSYS)
10142     /* Function not implemented.  */
10143     return;
10144
10145   START (tan_towardzero);
10146
10147   save_round_mode = fegetround ();
10148
10149   if (!fesetround (FE_TOWARDZERO))
10150     {
10151       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
10152       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
10153       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
10154       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
10155       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
10156       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
10157       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
10158       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
10159       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
10160       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
10161     }
10162
10163   fesetround (save_round_mode);
10164
10165   END (tan_towardzero);
10166 }
10167
10168
10169 static void
10170 tan_test_downward (void)
10171 {
10172   int save_round_mode;
10173   errno = 0;
10174   FUNC(tan) (0);
10175   if (errno == ENOSYS)
10176     /* Function not implemented.  */
10177     return;
10178
10179   START (tan_downward);
10180
10181   save_round_mode = fegetround ();
10182
10183   if (!fesetround (FE_DOWNWARD))
10184     {
10185       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
10186       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
10187       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
10188       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
10189       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
10190       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
10191       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
10192       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
10193       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
10194       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
10195     }
10196
10197   fesetround (save_round_mode);
10198
10199   END (tan_downward);
10200 }
10201
10202
10203 static void
10204 tan_test_upward (void)
10205 {
10206   int save_round_mode;
10207   errno = 0;
10208   FUNC(tan) (0);
10209   if (errno == ENOSYS)
10210     /* Function not implemented.  */
10211     return;
10212
10213   START (tan_upward);
10214
10215   save_round_mode = fegetround ();
10216
10217   if (!fesetround (FE_UPWARD))
10218     {
10219       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
10220       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
10221       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
10222       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
10223       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
10224       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
10225       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
10226       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
10227       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
10228       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
10229     }
10230
10231   fesetround (save_round_mode);
10232
10233   END (tan_upward);
10234 }
10235
10236
10237 static void
10238 tanh_test (void)
10239 {
10240   errno = 0;
10241   FUNC(tanh) (0.7L);
10242   if (errno == ENOSYS)
10243     /* Function not implemented.  */
10244     return;
10245
10246   START (tanh);
10247
10248   TEST_f_f (tanh, 0, 0);
10249   TEST_f_f (tanh, minus_zero, minus_zero);
10250
10251 #ifndef TEST_INLINE
10252   TEST_f_f (tanh, plus_infty, 1);
10253   TEST_f_f (tanh, minus_infty, -1);
10254 #endif
10255   TEST_f_f (tanh, nan_value, nan_value);
10256
10257   TEST_f_f (tanh, 0.75L, 0.635148952387287319214434357312496495L);
10258   TEST_f_f (tanh, -0.75L, -0.635148952387287319214434357312496495L);
10259
10260   TEST_f_f (tanh, 1.0L, 0.7615941559557648881194582826047935904L);
10261   TEST_f_f (tanh, -1.0L, -0.7615941559557648881194582826047935904L);
10262
10263   /* 2^-57  */
10264   TEST_f_f (tanh, 0x1p-57L, 6.938893903907228377647697925567626953125e-18L);
10265
10266   END (tanh);
10267 }
10268
10269 static void
10270 tgamma_test (void)
10271 {
10272   errno = 0;
10273   FUNC(tgamma) (1);
10274   if (errno == ENOSYS)
10275     /* Function not implemented.  */
10276     return;
10277
10278   START (tgamma);
10279
10280   TEST_f_f (tgamma, plus_infty, plus_infty);
10281   TEST_f_f (tgamma, max_value, plus_infty, OVERFLOW_EXCEPTION);
10282   TEST_f_f (tgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
10283   TEST_f_f (tgamma, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
10284   /* tgamma (x) == NaN plus invalid exception for integer x <= 0.  */
10285   TEST_f_f (tgamma, -2, nan_value, INVALID_EXCEPTION);
10286   TEST_f_f (tgamma, -max_value, nan_value, INVALID_EXCEPTION);
10287   TEST_f_f (tgamma, minus_infty, nan_value, INVALID_EXCEPTION);
10288   TEST_f_f (tgamma, nan_value, nan_value);
10289
10290   TEST_f_f (tgamma, 0.5, M_SQRT_PIl);
10291   TEST_f_f (tgamma, -0.5, -M_2_SQRT_PIl);
10292
10293   TEST_f_f (tgamma, 1, 1);
10294   TEST_f_f (tgamma, 4, 6);
10295
10296   TEST_f_f (tgamma, 0.7L, 1.29805533264755778568117117915281162L);
10297   TEST_f_f (tgamma, 1.2L, 0.918168742399760610640951655185830401L);
10298
10299   END (tgamma);
10300 }
10301
10302
10303 static void
10304 trunc_test (void)
10305 {
10306   START (trunc);
10307
10308   TEST_f_f (trunc, plus_infty, plus_infty);
10309   TEST_f_f (trunc, minus_infty, minus_infty);
10310   TEST_f_f (trunc, nan_value, nan_value);
10311
10312   TEST_f_f (trunc, 0, 0);
10313   TEST_f_f (trunc, minus_zero, minus_zero);
10314   TEST_f_f (trunc, 0.1, 0);
10315   TEST_f_f (trunc, 0.25, 0);
10316   TEST_f_f (trunc, 0.625, 0);
10317   TEST_f_f (trunc, -0.1, minus_zero);
10318   TEST_f_f (trunc, -0.25, minus_zero);
10319   TEST_f_f (trunc, -0.625, minus_zero);
10320   TEST_f_f (trunc, 1, 1);
10321   TEST_f_f (trunc, -1, -1);
10322   TEST_f_f (trunc, 1.625, 1);
10323   TEST_f_f (trunc, -1.625, -1);
10324
10325   TEST_f_f (trunc, 1048580.625L, 1048580L);
10326   TEST_f_f (trunc, -1048580.625L, -1048580L);
10327
10328   TEST_f_f (trunc, 8388610.125L, 8388610.0L);
10329   TEST_f_f (trunc, -8388610.125L, -8388610.0L);
10330
10331   TEST_f_f (trunc, 4294967296.625L, 4294967296.0L);
10332   TEST_f_f (trunc, -4294967296.625L, -4294967296.0L);
10333
10334 #ifdef TEST_LDOUBLE
10335   /* The result can only be represented in long double.  */
10336   TEST_f_f (trunc, 4503599627370495.5L, 4503599627370495.0L);
10337   TEST_f_f (trunc, 4503599627370496.25L, 4503599627370496.0L);
10338   TEST_f_f (trunc, 4503599627370496.5L, 4503599627370496.0L);
10339   TEST_f_f (trunc, 4503599627370496.75L, 4503599627370496.0L);
10340   TEST_f_f (trunc, 4503599627370497.5L, 4503599627370497.0L);
10341
10342 # if LDBL_MANT_DIG > 100
10343   TEST_f_f (trunc, 4503599627370494.5000000000001L, 4503599627370494.0L);
10344   TEST_f_f (trunc, 4503599627370495.5000000000001L, 4503599627370495.0L);
10345   TEST_f_f (trunc, 4503599627370496.5000000000001L, 4503599627370496.0L);
10346 # endif
10347
10348   TEST_f_f (trunc, -4503599627370495.5L, -4503599627370495.0L);
10349   TEST_f_f (trunc, -4503599627370496.25L, -4503599627370496.0L);
10350   TEST_f_f (trunc, -4503599627370496.5L, -4503599627370496.0L);
10351   TEST_f_f (trunc, -4503599627370496.75L, -4503599627370496.0L);
10352   TEST_f_f (trunc, -4503599627370497.5L, -4503599627370497.0L);
10353
10354 # if LDBL_MANT_DIG > 100
10355   TEST_f_f (trunc, -4503599627370494.5000000000001L, -4503599627370494.0L);
10356   TEST_f_f (trunc, -4503599627370495.5000000000001L, -4503599627370495.0L);
10357   TEST_f_f (trunc, -4503599627370496.5000000000001L, -4503599627370496.0L);
10358 # endif
10359
10360   TEST_f_f (trunc, 9007199254740991.5L, 9007199254740991.0L);
10361   TEST_f_f (trunc, 9007199254740992.25L, 9007199254740992.0L);
10362   TEST_f_f (trunc, 9007199254740992.5L, 9007199254740992.0L);
10363   TEST_f_f (trunc, 9007199254740992.75L, 9007199254740992.0L);
10364   TEST_f_f (trunc, 9007199254740993.5L, 9007199254740993.0L);
10365
10366 # if LDBL_MANT_DIG > 100
10367   TEST_f_f (trunc, 9007199254740991.0000000000001L, 9007199254740991.0L);
10368   TEST_f_f (trunc, 9007199254740992.0000000000001L, 9007199254740992.0L);
10369   TEST_f_f (trunc, 9007199254740993.0000000000001L, 9007199254740993.0L);
10370   TEST_f_f (trunc, 9007199254740991.5000000000001L, 9007199254740991.0L);
10371   TEST_f_f (trunc, 9007199254740992.5000000000001L, 9007199254740992.0L);
10372   TEST_f_f (trunc, 9007199254740993.5000000000001L, 9007199254740993.0L);
10373 # endif
10374
10375   TEST_f_f (trunc, -9007199254740991.5L, -9007199254740991.0L);
10376   TEST_f_f (trunc, -9007199254740992.25L, -9007199254740992.0L);
10377   TEST_f_f (trunc, -9007199254740992.5L, -9007199254740992.0L);
10378   TEST_f_f (trunc, -9007199254740992.75L, -9007199254740992.0L);
10379   TEST_f_f (trunc, -9007199254740993.5L, -9007199254740993.0L);
10380
10381 # if LDBL_MANT_DIG > 100
10382   TEST_f_f (trunc, -9007199254740991.0000000000001L, -9007199254740991.0L);
10383   TEST_f_f (trunc, -9007199254740992.0000000000001L, -9007199254740992.0L);
10384   TEST_f_f (trunc, -9007199254740993.0000000000001L, -9007199254740993.0L);
10385   TEST_f_f (trunc, -9007199254740991.5000000000001L, -9007199254740991.0L);
10386   TEST_f_f (trunc, -9007199254740992.5000000000001L, -9007199254740992.0L);
10387   TEST_f_f (trunc, -9007199254740993.5000000000001L, -9007199254740993.0L);
10388 # endif
10389
10390   TEST_f_f (trunc, 72057594037927935.5L, 72057594037927935.0L);
10391   TEST_f_f (trunc, 72057594037927936.25L, 72057594037927936.0L);
10392   TEST_f_f (trunc, 72057594037927936.5L, 72057594037927936.0L);
10393   TEST_f_f (trunc, 72057594037927936.75L, 72057594037927936.0L);
10394   TEST_f_f (trunc, 72057594037927937.5L, 72057594037927937.0L);
10395
10396   TEST_f_f (trunc, -72057594037927935.5L, -72057594037927935.0L);
10397   TEST_f_f (trunc, -72057594037927936.25L, -72057594037927936.0L);
10398   TEST_f_f (trunc, -72057594037927936.5L, -72057594037927936.0L);
10399   TEST_f_f (trunc, -72057594037927936.75L, -72057594037927936.0L);
10400   TEST_f_f (trunc, -72057594037927937.5L, -72057594037927937.0L);
10401
10402   TEST_f_f (trunc, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
10403   TEST_f_f (trunc, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
10404   TEST_f_f (trunc, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
10405   TEST_f_f (trunc, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
10406   TEST_f_f (trunc, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
10407 #endif
10408
10409   END (trunc);
10410 }
10411
10412 static void
10413 y0_test (void)
10414 {
10415   FLOAT s, c;
10416   errno = 0;
10417   FUNC (sincos) (0, &s, &c);
10418   if (errno == ENOSYS)
10419     /* Required function not implemented.  */
10420     return;
10421   FUNC(y0) (1);
10422   if (errno == ENOSYS)
10423     /* Function not implemented.  */
10424     return;
10425
10426   /* y0 is the Bessel function of the second kind of order 0 */
10427   START (y0);
10428
10429   TEST_f_f (y0, -1.0, minus_infty, INVALID_EXCEPTION);
10430   TEST_f_f (y0, -max_value, minus_infty, INVALID_EXCEPTION);
10431   TEST_f_f (y0, 0.0, minus_infty);
10432   TEST_f_f (y0, nan_value, nan_value);
10433   TEST_f_f (y0, plus_infty, 0);
10434
10435   TEST_f_f (y0, 0.125L, -1.38968062514384052915582277745018693L);
10436   TEST_f_f (y0, 0.75L, -0.137172769385772397522814379396581855L);
10437   TEST_f_f (y0, 1.0, 0.0882569642156769579829267660235151628L);
10438   TEST_f_f (y0, 1.5, 0.382448923797758843955068554978089862L);
10439   TEST_f_f (y0, 2.0, 0.510375672649745119596606592727157873L);
10440   TEST_f_f (y0, 8.0, 0.223521489387566220527323400498620359L);
10441   TEST_f_f (y0, 10.0, 0.0556711672835993914244598774101900481L);
10442
10443   TEST_f_f (y0, 0x1.3ffp+74L, 1.818984347516051243459467456433028748678e-12L);
10444
10445 #ifndef TEST_FLOAT
10446   /* Bug 14155: spurious exception may occur.  */
10447   TEST_f_f (y0, 0x1.ff00000000002p+840L, 1.846591691699331493194965158699937660696e-127L, UNDERFLOW_EXCEPTION_OK);
10448 #endif
10449
10450   TEST_f_f (y0, 0x1p-10L, -4.4865150767109739412411806297168793661098L);
10451   TEST_f_f (y0, 0x1p-20L, -8.8992283012125827603076426611387876938160L);
10452   TEST_f_f (y0, 0x1p-30L, -1.3311940304267782826037118027401817264906e+1L);
10453   TEST_f_f (y0, 0x1p-40L, -1.7724652307320814696990854700366226762563e+1L);
10454   TEST_f_f (y0, 0x1p-50L, -2.2137364310373846564919987139743760738155e+1L);
10455   TEST_f_f (y0, 0x1p-60L, -2.6550076313426878432849115782108205929120e+1L);
10456   TEST_f_f (y0, 0x1p-70L, -3.0962788316479910300778244424468159753887e+1L);
10457   TEST_f_f (y0, 0x1p-80L, -3.5375500319532942168707373066828113573541e+1L);
10458   TEST_f_f (y0, 0x1p-90L, -3.9788212322585974036636501709188067393195e+1L);
10459   TEST_f_f (y0, 0x1p-100L, -4.420092432563900590456563035154802121284e+1L);
10460   TEST_f_f (y0, 0x1p-110L, -4.861363632869203777249475899390797503250e+1L);
10461
10462   END (y0);
10463 }
10464
10465
10466 static void
10467 y1_test (void)
10468 {
10469   FLOAT s, c;
10470   errno = 0;
10471   FUNC (sincos) (0, &s, &c);
10472   if (errno == ENOSYS)
10473     /* Required function not implemented.  */
10474     return;
10475   FUNC(y1) (1);
10476   if (errno == ENOSYS)
10477     /* Function not implemented.  */
10478     return;
10479
10480   /* y1 is the Bessel function of the second kind of order 1 */
10481   START (y1);
10482
10483   TEST_f_f (y1, -1.0, minus_infty, INVALID_EXCEPTION);
10484   TEST_f_f (y1, -max_value, minus_infty, INVALID_EXCEPTION);
10485   TEST_f_f (y1, 0.0, minus_infty);
10486   TEST_f_f (y1, plus_infty, 0);
10487   TEST_f_f (y1, nan_value, nan_value);
10488
10489   TEST_f_f (y1, 0.125L, -5.19993611253477499595928744876579921L);
10490   TEST_f_f (y1, 0.75L, -1.03759455076928541973767132140642198L);
10491   TEST_f_f (y1, 1.0, -0.781212821300288716547150000047964821L);
10492   TEST_f_f (y1, 1.5, -0.412308626973911295952829820633445323L);
10493   TEST_f_f (y1, 2.0, -0.107032431540937546888370772277476637L);
10494   TEST_f_f (y1, 8.0, -0.158060461731247494255555266187483550L);
10495   TEST_f_f (y1, 10.0, 0.249015424206953883923283474663222803L);
10496
10497   /* Bug 14155: spurious exception may occur.  */
10498   TEST_f_f (y1, 0x1.27e204p+99L, -8.881610148467797208469612080785210013461e-16L, UNDERFLOW_EXCEPTION_OK);
10499
10500 #ifndef TEST_FLOAT
10501   /* Bug 14155: spurious exception may occur.  */
10502   TEST_f_f (y1, 0x1.001000001p+593L, 3.927269966354206207832593635798954916263e-90L, UNDERFLOW_EXCEPTION_OK);
10503 #endif
10504
10505   TEST_f_f (y1, 0x1p-10L, -6.5190099301063115047395187618929589514382e+02L);
10506   TEST_f_f (y1, 0x1p-20L, -6.6754421443450423911167962313100637952285e+05L);
10507   TEST_f_f (y1, 0x1p-30L, -6.8356527557643159612937462812258975438856e+08L);
10508   TEST_f_f (y1, 0x1p-40L, -6.9997084219026594793707805777425993547887e+11L);
10509   TEST_f_f (y1, 0x1p-50L, -7.1677014240283233068755952926181262431559e+14L);
10510   TEST_f_f (y1, 0x1p-60L, -7.3397262582050030662406095795388448059822e+17L);
10511   TEST_f_f (y1, 0x1p-70L, -7.5158796884019231398303842094477769620063e+20L);
10512   TEST_f_f (y1, 0x1p-80L, -7.6962608009235692951863134304745236090943e+23L);
10513   TEST_f_f (y1, 0x1p-90L, -7.8809710601457349582707849528059121757126e+26L);
10514   TEST_f_f (y1, 0x1p-100L, -8.0701143655892325972692837916732540679297e+29L);
10515   TEST_f_f (y1, 0x1p-110L, -8.2637971103633741796037466026734121655600e+32L);
10516
10517   END (y1);
10518 }
10519
10520
10521 static void
10522 yn_test (void)
10523 {
10524   FLOAT s, c;
10525   errno = 0;
10526   FUNC (sincos) (0, &s, &c);
10527   if (errno == ENOSYS)
10528     /* Required function not implemented.  */
10529     return;
10530   FUNC(yn) (1, 1);
10531   if (errno == ENOSYS)
10532     /* Function not implemented.  */
10533     return;
10534
10535   /* yn is the Bessel function of the second kind of order n */
10536   START (yn);
10537
10538   /* yn (0, x) == y0 (x)  */
10539   TEST_ff_f (yn, 0, -1.0, minus_infty, INVALID_EXCEPTION);
10540   TEST_ff_f (yn, 0, -max_value, minus_infty, INVALID_EXCEPTION);
10541   TEST_ff_f (yn, 0, 0.0, minus_infty);
10542   TEST_ff_f (yn, 0, nan_value, nan_value);
10543   TEST_ff_f (yn, 0, plus_infty, 0);
10544
10545   TEST_ff_f (yn, 0, 0.125L, -1.38968062514384052915582277745018693L);
10546   TEST_ff_f (yn, 0, 0.75L, -0.137172769385772397522814379396581855L);
10547   TEST_ff_f (yn, 0, 1.0, 0.0882569642156769579829267660235151628L);
10548   TEST_ff_f (yn, 0, 1.5, 0.382448923797758843955068554978089862L);
10549   TEST_ff_f (yn, 0, 2.0, 0.510375672649745119596606592727157873L);
10550   TEST_ff_f (yn, 0, 8.0, 0.223521489387566220527323400498620359L);
10551   TEST_ff_f (yn, 0, 10.0, 0.0556711672835993914244598774101900481L);
10552
10553   /* yn (1, x) == y1 (x)  */
10554   TEST_ff_f (yn, 1, -1.0, minus_infty, INVALID_EXCEPTION);
10555   TEST_ff_f (yn, 1, 0.0, minus_infty);
10556   TEST_ff_f (yn, 1, plus_infty, 0);
10557   TEST_ff_f (yn, 1, nan_value, nan_value);
10558
10559   TEST_ff_f (yn, 1, 0.125L, -5.19993611253477499595928744876579921L);
10560   TEST_ff_f (yn, 1, 0.75L, -1.03759455076928541973767132140642198L);
10561   TEST_ff_f (yn, 1, 1.0, -0.781212821300288716547150000047964821L);
10562   TEST_ff_f (yn, 1, 1.5, -0.412308626973911295952829820633445323L);
10563   TEST_ff_f (yn, 1, 2.0, -0.107032431540937546888370772277476637L);
10564   TEST_ff_f (yn, 1, 8.0, -0.158060461731247494255555266187483550L);
10565   TEST_ff_f (yn, 1, 10.0, 0.249015424206953883923283474663222803L);
10566
10567   /* yn (3, x)  */
10568   TEST_ff_f (yn, 3, plus_infty, 0);
10569   TEST_ff_f (yn, 3, nan_value, nan_value);
10570
10571   TEST_ff_f (yn, 3, 0.125L, -2612.69757350066712600220955744091741L);
10572   TEST_ff_f (yn, 3, 0.75L, -12.9877176234475433186319774484809207L);
10573   TEST_ff_f (yn, 3, 1.0, -5.82151760596472884776175706442981440L);
10574   TEST_ff_f (yn, 3, 2.0, -1.12778377684042778608158395773179238L);
10575   TEST_ff_f (yn, 3, 10.0, -0.251362657183837329779204747654240998L);
10576
10577   /* yn (10, x)  */
10578   TEST_ff_f (yn, 10, plus_infty, 0);
10579   TEST_ff_f (yn, 10, nan_value, nan_value);
10580
10581   TEST_ff_f (yn, 10, 0.125L, -127057845771019398.252538486899753195L);
10582   TEST_ff_f (yn, 10, 0.75L, -2133501638.90573424452445412893839236L);
10583   TEST_ff_f (yn, 10, 1.0, -121618014.278689189288130426667971145L);
10584   TEST_ff_f (yn, 10, 2.0, -129184.542208039282635913145923304214L);
10585   TEST_ff_f (yn, 10, 10.0, -0.359814152183402722051986577343560609L);
10586
10587   /* Check whether yn returns correct value for LDBL_MIN, DBL_MIN,
10588      and FLT_MIN.  See Bug 14173.  */
10589   TEST_ff_f (yn, 10, min_value, minus_infty, OVERFLOW_EXCEPTION);
10590
10591   errno = 0;
10592   TEST_ff_f (yn, 10, min_value, minus_infty, OVERFLOW_EXCEPTION);
10593   check_int ("errno for yn(10,-min) == ERANGE", errno, ERANGE, 0, 0, 0);
10594
10595   END (yn);
10596 }
10597
10598
10599 static void
10600 significand_test (void)
10601 {
10602   /* significand returns the mantissa of the exponential representation.  */
10603   START (significand);
10604
10605   TEST_f_f (significand, 4.0, 1.0);
10606   TEST_f_f (significand, 6.0, 1.5);
10607   TEST_f_f (significand, 8.0, 1.0);
10608
10609   END (significand);
10610 }
10611
10612
10613 static void
10614 initialize (void)
10615 {
10616   fpstack_test ("start *init*");
10617   plus_zero = 0.0;
10618   nan_value = plus_zero / plus_zero;    /* Suppress GCC warning */
10619
10620   minus_zero = FUNC(copysign) (0.0, -1.0);
10621   plus_infty = CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF,
10622                        HUGE_VALL, HUGE_VAL, HUGE_VALF);
10623   minus_infty = CHOOSE (-HUGE_VALL, -HUGE_VAL, -HUGE_VALF,
10624                         -HUGE_VALL, -HUGE_VAL, -HUGE_VALF);
10625   max_value = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
10626                       LDBL_MAX, DBL_MAX, FLT_MAX);
10627   min_value = CHOOSE (LDBL_MIN, DBL_MIN, FLT_MIN,
10628                       LDBL_MIN, DBL_MIN, FLT_MIN);
10629   min_subnorm_value = CHOOSE (__LDBL_DENORM_MIN__,
10630                               __DBL_DENORM_MIN__,
10631                               __FLT_DENORM_MIN__,
10632                               __LDBL_DENORM_MIN__,
10633                               __DBL_DENORM_MIN__,
10634                               __FLT_DENORM_MIN__);
10635
10636   (void) &plus_zero;
10637   (void) &nan_value;
10638   (void) &minus_zero;
10639   (void) &plus_infty;
10640   (void) &minus_infty;
10641   (void) &max_value;
10642   (void) &min_value;
10643   (void) &min_subnorm_value;
10644
10645   /* Clear all exceptions.  From now on we must not get random exceptions.  */
10646   feclearexcept (FE_ALL_EXCEPT);
10647
10648   /* Test to make sure we start correctly.  */
10649   fpstack_test ("end *init*");
10650 }
10651
10652 /* Definitions of arguments for argp functions.  */
10653 static const struct argp_option options[] =
10654 {
10655   { "verbose", 'v', "NUMBER", 0, "Level of verbosity (0..3)"},
10656   { "ulps-file", 'u', NULL, 0, "Output ulps to file ULPs"},
10657   { "no-max-error", 'f', NULL, 0,
10658     "Don't output maximal errors of functions"},
10659   { "no-points", 'p', NULL, 0,
10660     "Don't output results of functions invocations"},
10661   { "ignore-max-ulp", 'i', "yes/no", 0,
10662     "Ignore given maximal errors"},
10663   { NULL, 0, NULL, 0, NULL }
10664 };
10665
10666 /* Short description of program.  */
10667 static const char doc[] = "Math test suite: " TEST_MSG ;
10668
10669 /* Prototype for option handler.  */
10670 static error_t parse_opt (int key, char *arg, struct argp_state *state);
10671
10672 /* Data structure to communicate with argp functions.  */
10673 static struct argp argp =
10674 {
10675   options, parse_opt, NULL, doc,
10676 };
10677
10678
10679 /* Handle program arguments.  */
10680 static error_t
10681 parse_opt (int key, char *arg, struct argp_state *state)
10682 {
10683   switch (key)
10684     {
10685     case 'f':
10686       output_max_error = 0;
10687       break;
10688     case 'i':
10689       if (strcmp (arg, "yes") == 0)
10690         ignore_max_ulp = 1;
10691       else if (strcmp (arg, "no") == 0)
10692         ignore_max_ulp = 0;
10693       break;
10694     case 'p':
10695       output_points = 0;
10696       break;
10697     case 'u':
10698       output_ulps = 1;
10699       break;
10700     case 'v':
10701       if (optarg)
10702         verbose = (unsigned int) strtoul (optarg, NULL, 0);
10703       else
10704         verbose = 3;
10705       break;
10706     default:
10707       return ARGP_ERR_UNKNOWN;
10708     }
10709   return 0;
10710 }
10711
10712 #if 0
10713 /* function to check our ulp calculation.  */
10714 void
10715 check_ulp (void)
10716 {
10717   int i;
10718
10719   FLOAT u, diff, ulp;
10720   /* This gives one ulp.  */
10721   u = FUNC(nextafter) (10, 20);
10722   check_equal (10.0, u, 1, &diff, &ulp);
10723   printf ("One ulp: % .4" PRINTF_NEXPR "\n", ulp);
10724
10725   /* This gives one more ulp.  */
10726   u = FUNC(nextafter) (u, 20);
10727   check_equal (10.0, u, 2, &diff, &ulp);
10728   printf ("two ulp: % .4" PRINTF_NEXPR "\n", ulp);
10729
10730   /* And now calculate 100 ulp.  */
10731   for (i = 2; i < 100; i++)
10732     u = FUNC(nextafter) (u, 20);
10733   check_equal (10.0, u, 100, &diff, &ulp);
10734   printf ("100 ulp: % .4" PRINTF_NEXPR "\n", ulp);
10735 }
10736 #endif
10737
10738 int
10739 main (int argc, char **argv)
10740 {
10741
10742   int remaining;
10743
10744   verbose = 1;
10745   output_ulps = 0;
10746   output_max_error = 1;
10747   output_points = 1;
10748   /* XXX set to 0 for releases.  */
10749   ignore_max_ulp = 0;
10750
10751   /* Parse and process arguments.  */
10752   argp_parse (&argp, argc, argv, 0, &remaining, NULL);
10753
10754   if (remaining != argc)
10755     {
10756       fprintf (stderr, "wrong number of arguments");
10757       argp_help (&argp, stdout, ARGP_HELP_SEE, program_invocation_short_name);
10758       exit (EXIT_FAILURE);
10759     }
10760
10761   if (output_ulps)
10762     {
10763       ulps_file = fopen ("ULPs", "a");
10764       if (ulps_file == NULL)
10765         {
10766           perror ("can't open file `ULPs' for writing: ");
10767           exit (1);
10768         }
10769     }
10770
10771
10772   initialize ();
10773   printf (TEST_MSG);
10774
10775 #if 0
10776   check_ulp ();
10777 #endif
10778
10779   /* Keep the tests a wee bit ordered (according to ISO C99).  */
10780   /* Classification macros:  */
10781   finite_test ();
10782   fpclassify_test ();
10783   isfinite_test ();
10784   isinf_test ();
10785   isnan_test ();
10786   isnormal_test ();
10787   signbit_test ();
10788
10789   /* Trigonometric functions:  */
10790   acos_test ();
10791   acos_test_tonearest ();
10792   acos_test_towardzero ();
10793   acos_test_downward ();
10794   acos_test_upward ();
10795   asin_test ();
10796   asin_test_tonearest ();
10797   asin_test_towardzero ();
10798   asin_test_downward ();
10799   asin_test_upward ();
10800   atan_test ();
10801   atan2_test ();
10802   cos_test ();
10803   cos_test_tonearest ();
10804   cos_test_towardzero ();
10805   cos_test_downward ();
10806   cos_test_upward ();
10807   sin_test ();
10808   sin_test_tonearest ();
10809   sin_test_towardzero ();
10810   sin_test_downward ();
10811   sin_test_upward ();
10812   sincos_test ();
10813   tan_test ();
10814   tan_test_tonearest ();
10815   tan_test_towardzero ();
10816   tan_test_downward ();
10817   tan_test_upward ();
10818
10819   /* Hyperbolic functions:  */
10820   acosh_test ();
10821   asinh_test ();
10822   atanh_test ();
10823   cosh_test ();
10824   cosh_test_tonearest ();
10825   cosh_test_towardzero ();
10826   cosh_test_downward ();
10827   cosh_test_upward ();
10828   sinh_test ();
10829   sinh_test_tonearest ();
10830   sinh_test_towardzero ();
10831   sinh_test_downward ();
10832   sinh_test_upward ();
10833   tanh_test ();
10834
10835   /* Exponential and logarithmic functions:  */
10836   exp_test ();
10837   exp_test_tonearest ();
10838   exp_test_towardzero ();
10839   exp_test_downward ();
10840   exp_test_upward ();
10841   exp10_test ();
10842   exp2_test ();
10843   expm1_test ();
10844   frexp_test ();
10845   ldexp_test ();
10846   log_test ();
10847   log10_test ();
10848   log1p_test ();
10849   log2_test ();
10850   logb_test ();
10851   logb_test_downward ();
10852   modf_test ();
10853   ilogb_test ();
10854   scalb_test ();
10855   scalbn_test ();
10856   scalbln_test ();
10857   significand_test ();
10858
10859   /* Power and absolute value functions:  */
10860   cbrt_test ();
10861   fabs_test ();
10862   hypot_test ();
10863   pow_test ();
10864   pow_test_tonearest ();
10865   pow_test_towardzero ();
10866   pow_test_downward ();
10867   pow_test_upward ();
10868   sqrt_test ();
10869
10870   /* Error and gamma functions:  */
10871   erf_test ();
10872   erfc_test ();
10873   gamma_test ();
10874   lgamma_test ();
10875   tgamma_test ();
10876
10877   /* Nearest integer functions:  */
10878   ceil_test ();
10879   floor_test ();
10880   nearbyint_test ();
10881   rint_test ();
10882   rint_test_tonearest ();
10883   rint_test_towardzero ();
10884   rint_test_downward ();
10885   rint_test_upward ();
10886   lrint_test ();
10887   lrint_test_tonearest ();
10888   lrint_test_towardzero ();
10889   lrint_test_downward ();
10890   lrint_test_upward ();
10891   llrint_test ();
10892   llrint_test_tonearest ();
10893   llrint_test_towardzero ();
10894   llrint_test_downward ();
10895   llrint_test_upward ();
10896   round_test ();
10897   lround_test ();
10898   llround_test ();
10899   trunc_test ();
10900
10901   /* Remainder functions:  */
10902   fmod_test ();
10903   remainder_test ();
10904   remquo_test ();
10905
10906   /* Manipulation functions:  */
10907   copysign_test ();
10908   nextafter_test ();
10909   nexttoward_test ();
10910
10911   /* maximum, minimum and positive difference functions */
10912   fdim_test ();
10913   fmax_test ();
10914   fmin_test ();
10915
10916   /* Multiply and add:  */
10917   fma_test ();
10918   fma_test_towardzero ();
10919   fma_test_downward ();
10920   fma_test_upward ();
10921
10922   /* Comparison macros:  */
10923   isgreater_test ();
10924   isgreaterequal_test ();
10925   isless_test ();
10926   islessequal_test ();
10927   islessgreater_test ();
10928   isunordered_test ();
10929
10930   /* Complex functions:  */
10931   cabs_test ();
10932   cacos_test ();
10933   cacosh_test ();
10934   carg_test ();
10935   casin_test ();
10936   casinh_test ();
10937   catan_test ();
10938   catanh_test ();
10939   ccos_test ();
10940   ccosh_test ();
10941   cexp_test ();
10942   cimag_test ();
10943   clog10_test ();
10944   clog_test ();
10945   conj_test ();
10946   cpow_test ();
10947   cproj_test ();
10948   creal_test ();
10949   csin_test ();
10950   csinh_test ();
10951   csqrt_test ();
10952   ctan_test ();
10953   ctan_test_tonearest ();
10954   ctan_test_towardzero ();
10955   ctan_test_downward ();
10956   ctan_test_upward ();
10957   ctanh_test ();
10958   ctanh_test_tonearest ();
10959   ctanh_test_towardzero ();
10960   ctanh_test_downward ();
10961   ctanh_test_upward ();
10962
10963   /* Bessel functions:  */
10964   j0_test ();
10965   j1_test ();
10966   jn_test ();
10967   y0_test ();
10968   y1_test ();
10969   yn_test ();
10970
10971   if (output_ulps)
10972     fclose (ulps_file);
10973
10974   printf ("\nTest suite completed:\n");
10975   printf ("  %d test cases plus %d tests for exception flags executed.\n",
10976           noTests, noExcTests);
10977   if (noXFails)
10978     printf ("  %d expected failures occurred.\n", noXFails);
10979   if (noXPasses)
10980     printf ("  %d unexpected passes occurred.\n", noXPasses);
10981   if (noErrors)
10982     {
10983       printf ("  %d errors occurred.\n", noErrors);
10984       return 1;
10985     }
10986   printf ("  All tests passed successfully.\n");
10987
10988   return 0;
10989 }
10990
10991 /*
10992  * Local Variables:
10993  * mode:c
10994  * End:
10995  */