Updated to fedora-glibc-20080524T2218
[kopensolaris-gnu/glibc.git] / math / libm-test.inc
1 /* Copyright (C) 1997-2006, 2007 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, write to the Free
17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18    02111-1307 USA.  */
19
20 /* Part of testsuite for libm.
21
22    This file is processed by a perl script.  The resulting file has to
23    be included by a master file that defines:
24
25    Macros:
26    FUNC(function): converts general function name (like cos) to
27    name with correct suffix (e.g. cosl or cosf)
28    MATHCONST(x):   like FUNC but for constants (e.g convert 0.0 to 0.0L)
29    FLOAT:          floating point type to test
30    - TEST_MSG:     informal message to be displayed
31    CHOOSE(Clongdouble,Cdouble,Cfloat,Cinlinelongdouble,Cinlinedouble,Cinlinefloat):
32    chooses one of the parameters as delta for testing
33    equality
34    PRINTF_EXPR     Floating point conversion specification to print a variable
35    of type FLOAT with printf.  PRINTF_EXPR just contains
36    the specifier, not the percent and width arguments,
37    e.g. "f".
38    PRINTF_XEXPR    Like PRINTF_EXPR, but print in hexadecimal format.
39    PRINTF_NEXPR Like PRINTF_EXPR, but print nice.  */
40
41 /* This testsuite has currently tests for:
42    acos, acosh, asin, asinh, atan, atan2, atanh,
43    cbrt, ceil, copysign, cos, cosh, erf, erfc, exp, exp10, exp2, expm1,
44    fabs, fdim, floor, fma, fmax, fmin, fmod, fpclassify,
45    frexp, gamma, hypot,
46    ilogb, isfinite, isinf, isnan, isnormal,
47    isless, islessequal, isgreater, isgreaterequal, islessgreater, isunordered,
48    j0, j1, jn,
49    ldexp, lgamma, log, log10, log1p, log2, logb,
50    modf, nearbyint, nextafter,
51    pow, remainder, remquo, rint, lrint, llrint,
52    round, lround, llround,
53    scalb, scalbn, scalbln, signbit, sin, sincos, sinh, sqrt, tan, tanh, tgamma, trunc,
54    y0, y1, yn, significand
55
56    and for the following complex math functions:
57    cabs, cacos, cacosh, carg, casin, casinh, catan, catanh,
58    ccos, ccosh, cexp, clog, cpow, cproj, csin, csinh, csqrt, ctan, ctanh.
59
60    At the moment the following functions aren't tested:
61    drem, nan
62
63    Parameter handling is primitive in the moment:
64    --verbose=[0..3] for different levels of output:
65    0: only error count
66    1: basic report on failed tests (default)
67    2: full report on all tests
68    -v for full output (equals --verbose=3)
69    -u for generation of an ULPs file
70  */
71
72 /* "Philosophy":
73
74    This suite tests some aspects of the correct implementation of
75    mathematical functions in libm.  Some simple, specific parameters
76    are tested for correctness but there's no exhaustive
77    testing.  Handling of specific inputs (e.g. infinity, not-a-number)
78    is also tested.  Correct handling of exceptions is checked
79    against.  These implemented tests should check all cases that are
80    specified in ISO C99.
81
82    Exception testing: At the moment only divide-by-zero and invalid
83    exceptions are tested.  Overflow/underflow and inexact exceptions
84    aren't checked at the moment.
85
86    NaN values: There exist signalling and quiet NaNs.  This implementation
87    only uses quiet NaN as parameter but does not differenciate
88    between the two kinds of NaNs as result.
89
90    Inline functions: Inlining functions should give an improvement in
91    speed - but not in precission.  The inlined functions return
92    reasonable values for a reasonable range of input values.  The
93    result is not necessarily correct for all values and exceptions are
94    not correctly raised in all cases.  Problematic input and return
95    values are infinity, not-a-number and minus zero.  This suite
96    therefore does not check these specific inputs and the exception
97    handling for inlined mathematical functions - just the "reasonable"
98    values are checked.
99
100    Beware: The tests might fail for any of the following reasons:
101    - Tests are wrong
102    - Functions are wrong
103    - Floating Point Unit not working properly
104    - Compiler has errors
105
106    With e.g. gcc 2.7.2.2 the test for cexp fails because of a compiler error.
107
108
109    To Do: All parameter should be numbers that can be represented as
110    exact floating point values.  Currently some values cannot be
111    represented exactly and therefore the result is not the expected
112    result.  For this we will use 36 digits so that numbers can be
113    represented exactly.  */
114
115 #ifndef _GNU_SOURCE
116 # define _GNU_SOURCE
117 #endif
118
119 #include "libm-test-ulps.h"
120 #include <complex.h>
121 #include <math.h>
122 #include <float.h>
123 #include <fenv.h>
124 #include <limits.h>
125
126 #include <errno.h>
127 #include <stdlib.h>
128 #include <stdio.h>
129 #include <string.h>
130 #include <argp.h>
131
132 /* Possible exceptions */
133 #define NO_EXCEPTION                    0x0
134 #define INVALID_EXCEPTION               0x1
135 #define DIVIDE_BY_ZERO_EXCEPTION        0x2
136 /* The next flags signals that those exceptions are allowed but not required.   */
137 #define INVALID_EXCEPTION_OK            0x4
138 #define DIVIDE_BY_ZERO_EXCEPTION_OK     0x8
139 #define EXCEPTIONS_OK INVALID_EXCEPTION_OK+DIVIDE_BY_ZERO_EXCEPTION_OK
140 /* Some special test flags, passed togther with exceptions.  */
141 #define IGNORE_ZERO_INF_SIGN            0x10
142
143 /* Various constants (we must supply them precalculated for accuracy).  */
144 #define M_PI_6l                 .52359877559829887307710723054658383L
145 #define M_E2l                   7.389056098930650227230427460575008L
146 #define M_E3l                   20.085536923187667740928529654581719L
147 #define M_2_SQRT_PIl            3.5449077018110320545963349666822903L   /* 2 sqrt (M_PIl)  */
148 #define M_SQRT_PIl              1.7724538509055160272981674833411451L   /* sqrt (M_PIl)  */
149 #define M_LOG_SQRT_PIl          0.57236494292470008707171367567652933L  /* log(sqrt(M_PIl))  */
150 #define M_LOG_2_SQRT_PIl        1.265512123484645396488945797134706L    /* log(2*sqrt(M_PIl))  */
151 #define M_PI_34l                (M_PIl - M_PI_4l)               /* 3*pi/4 */
152 #define M_PI_34_LOG10El         (M_PIl - M_PI_4l) * M_LOG10El
153 #define M_PI2_LOG10El           M_PI_2l * M_LOG10El
154 #define M_PI4_LOG10El           M_PI_4l * M_LOG10El
155 #define M_PI_LOG10El            M_PIl * M_LOG10El
156 #define M_SQRT_2_2              0.70710678118654752440084436210484903L /* sqrt (2) / 2 */
157
158 static FILE *ulps_file; /* File to document difference.  */
159 static int output_ulps; /* Should ulps printed?  */
160
161 static int noErrors;    /* number of errors */
162 static int noTests;     /* number of tests (without testing exceptions) */
163 static int noExcTests;  /* number of tests for exception flags */
164 static int noXFails;    /* number of expected failures.  */
165 static int noXPasses;   /* number of unexpected passes.  */
166
167 static int verbose;
168 static int output_max_error;    /* Should the maximal errors printed?  */
169 static int output_points;       /* Should the single function results printed?  */
170 static int ignore_max_ulp;      /* Should we ignore max_ulp?  */
171
172 static FLOAT minus_zero, plus_zero;
173 static FLOAT plus_infty, minus_infty, nan_value, max_value, min_value;
174
175 static FLOAT max_error, real_max_error, imag_max_error;
176
177
178 #define BUILD_COMPLEX(real, imag) \
179   ({ __complex__ FLOAT __retval;                                              \
180      __real__ __retval = (real);                                              \
181      __imag__ __retval = (imag);                                              \
182      __retval; })
183
184 #define BUILD_COMPLEX_INT(real, imag) \
185   ({ __complex__ int __retval;                                                \
186      __real__ __retval = (real);                                              \
187      __imag__ __retval = (imag);                                              \
188      __retval; })
189
190
191 #define MANT_DIG CHOOSE ((LDBL_MANT_DIG-1), (DBL_MANT_DIG-1), (FLT_MANT_DIG-1),  \
192                          (LDBL_MANT_DIG-1), (DBL_MANT_DIG-1), (FLT_MANT_DIG-1))
193
194 static void
195 init_max_error (void)
196 {
197   max_error = 0;
198   real_max_error = 0;
199   imag_max_error = 0;
200   feclearexcept (FE_ALL_EXCEPT);
201 }
202
203 static void
204 set_max_error (FLOAT current, FLOAT *curr_max_error)
205 {
206   if (current > *curr_max_error)
207     *curr_max_error = current;
208 }
209
210
211 /* Should the message print to screen?  This depends on the verbose flag,
212    and the test status.  */
213 static int
214 print_screen (int ok, int xfail)
215 {
216   if (output_points
217       && (verbose > 1
218           || (verbose == 1 && ok == xfail)))
219     return 1;
220   return 0;
221 }
222
223
224 /* Should the message print to screen?  This depends on the verbose flag,
225    and the test status.  */
226 static int
227 print_screen_max_error (int ok, int xfail)
228 {
229   if (output_max_error
230       && (verbose > 1
231           || ((verbose == 1) && (ok == xfail))))
232     return 1;
233   return 0;
234 }
235
236 /* Update statistic counters.  */
237 static void
238 update_stats (int ok, int xfail)
239 {
240   ++noTests;
241   if (ok && xfail)
242     ++noXPasses;
243   else if (!ok && xfail)
244     ++noXFails;
245   else if (!ok && !xfail)
246     ++noErrors;
247 }
248
249 static void
250 print_ulps (const char *test_name, FLOAT ulp)
251 {
252   if (output_ulps)
253     {
254       fprintf (ulps_file, "Test \"%s\":\n", test_name);
255       fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
256                CHOOSE("ldouble", "double", "float",
257                       "ildouble", "idouble", "ifloat"),
258                FUNC(ceil) (ulp));
259     }
260 }
261
262 static void
263 print_function_ulps (const char *function_name, FLOAT ulp)
264 {
265   if (output_ulps)
266     {
267       fprintf (ulps_file, "Function: \"%s\":\n", function_name);
268       fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
269                CHOOSE("ldouble", "double", "float",
270                       "ildouble", "idouble", "ifloat"),
271                FUNC(ceil) (ulp));
272     }
273 }
274
275
276 static void
277 print_complex_function_ulps (const char *function_name, FLOAT real_ulp,
278                              FLOAT imag_ulp)
279 {
280   if (output_ulps)
281     {
282       if (real_ulp != 0.0)
283         {
284           fprintf (ulps_file, "Function: Real part of \"%s\":\n", function_name);
285           fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
286                    CHOOSE("ldouble", "double", "float",
287                           "ildouble", "idouble", "ifloat"),
288                    FUNC(ceil) (real_ulp));
289         }
290       if (imag_ulp != 0.0)
291         {
292           fprintf (ulps_file, "Function: Imaginary part of \"%s\":\n", function_name);
293           fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
294                    CHOOSE("ldouble", "double", "float",
295                           "ildouble", "idouble", "ifloat"),
296                    FUNC(ceil) (imag_ulp));
297         }
298
299
300     }
301 }
302
303
304
305 /* Test if Floating-Point stack hasn't changed */
306 static void
307 fpstack_test (const char *test_name)
308 {
309 #ifdef i386
310   static int old_stack;
311   int sw;
312
313   asm ("fnstsw" : "=a" (sw));
314   sw >>= 11;
315   sw &= 7;
316
317   if (sw != old_stack)
318     {
319       printf ("FP-Stack wrong after test %s (%d, should be %d)\n",
320               test_name, sw, old_stack);
321       ++noErrors;
322       old_stack = sw;
323     }
324 #endif
325 }
326
327
328 static void
329 print_max_error (const char *func_name, FLOAT allowed, int xfail)
330 {
331   int ok = 0;
332
333   if (max_error == 0.0 || (max_error <= allowed && !ignore_max_ulp))
334     {
335       ok = 1;
336     }
337
338   if (!ok)
339     print_function_ulps (func_name, max_error);
340
341
342   if (print_screen_max_error (ok, xfail))
343     {
344       printf ("Maximal error of `%s'\n", func_name);
345       printf (" is      : %.0" PRINTF_NEXPR " ulp\n", FUNC(ceil) (max_error));
346       printf (" accepted: %.0" PRINTF_NEXPR " ulp\n", FUNC(ceil) (allowed));
347     }
348
349   update_stats (ok, xfail);
350 }
351
352
353 static void
354 print_complex_max_error (const char *func_name, __complex__ FLOAT allowed,
355                          __complex__ int xfail)
356 {
357   int ok = 0;
358
359   if ((real_max_error == 0 && imag_max_error == 0)
360       || (real_max_error <= __real__ allowed
361           && imag_max_error <= __imag__ allowed
362           && !ignore_max_ulp))
363     {
364       ok = 1;
365     }
366
367   if (!ok)
368     print_complex_function_ulps (func_name, real_max_error, imag_max_error);
369
370
371   if (print_screen_max_error (ok, xfail))
372     {
373       printf ("Maximal error of real part of: %s\n", func_name);
374       printf (" is      : %.0" PRINTF_NEXPR " ulp\n",
375               FUNC(ceil) (real_max_error));
376       printf (" accepted: %.0" PRINTF_NEXPR " ulp\n",
377               FUNC(ceil) (__real__ allowed));
378       printf ("Maximal error of imaginary part of: %s\n", func_name);
379       printf (" is      : %.0" PRINTF_NEXPR " ulp\n",
380               FUNC(ceil) (imag_max_error));
381       printf (" accepted: %.0" PRINTF_NEXPR " ulp\n",
382               FUNC(ceil) (__imag__ allowed));
383     }
384
385   update_stats (ok, xfail);
386 }
387
388
389 /* Test whether a given exception was raised.  */
390 static void
391 test_single_exception (const char *test_name,
392                        int exception,
393                        int exc_flag,
394                        int fe_flag,
395                        const char *flag_name)
396 {
397 #ifndef TEST_INLINE
398   int ok = 1;
399   if (exception & exc_flag)
400     {
401       if (fetestexcept (fe_flag))
402         {
403           if (print_screen (1, 0))
404             printf ("Pass: %s: Exception \"%s\" set\n", test_name, flag_name);
405         }
406       else
407         {
408           ok = 0;
409           if (print_screen (0, 0))
410             printf ("Failure: %s: Exception \"%s\" not set\n",
411                     test_name, flag_name);
412         }
413     }
414   else
415     {
416       if (fetestexcept (fe_flag))
417         {
418           ok = 0;
419           if (print_screen (0, 0))
420             printf ("Failure: %s: Exception \"%s\" set\n",
421                     test_name, flag_name);
422         }
423       else
424         {
425           if (print_screen (1, 0))
426             printf ("%s: Exception \"%s\" not set\n", test_name,
427                     flag_name);
428         }
429     }
430   if (!ok)
431     ++noErrors;
432
433 #endif
434 }
435
436
437 /* Test whether exceptions given by EXCEPTION are raised.  Ignore thereby
438    allowed but not required exceptions.
439 */
440 static void
441 test_exceptions (const char *test_name, int exception)
442 {
443   ++noExcTests;
444 #ifdef FE_DIVBYZERO
445   if ((exception & DIVIDE_BY_ZERO_EXCEPTION_OK) == 0)
446     test_single_exception (test_name, exception,
447                            DIVIDE_BY_ZERO_EXCEPTION, FE_DIVBYZERO,
448                            "Divide by zero");
449 #endif
450 #ifdef FE_INVALID
451   if ((exception & INVALID_EXCEPTION_OK) == 0)
452     test_single_exception (test_name, exception, INVALID_EXCEPTION, FE_INVALID,
453                          "Invalid operation");
454 #endif
455   feclearexcept (FE_ALL_EXCEPT);
456 }
457
458
459 static void
460 check_float_internal (const char *test_name, FLOAT computed, FLOAT expected,
461                       FLOAT max_ulp, int xfail, int exceptions,
462                       FLOAT *curr_max_error)
463 {
464   int ok = 0;
465   int print_diff = 0;
466   FLOAT diff = 0;
467   FLOAT ulp = 0;
468
469   test_exceptions (test_name, exceptions);
470   if (isnan (computed) && isnan (expected))
471     ok = 1;
472   else if (isinf (computed) && isinf (expected))
473     {
474       /* Test for sign of infinities.  */
475       if ((exceptions & IGNORE_ZERO_INF_SIGN) == 0
476           && signbit (computed) != signbit (expected))
477         {
478           ok = 0;
479           printf ("infinity has wrong sign.\n");
480         }
481       else
482         ok = 1;
483     }
484   /* Don't calc ulp for NaNs or infinities.  */
485   else if (isinf (computed) || isnan (computed) || isinf (expected) || isnan (expected))
486     ok = 0;
487   else
488     {
489       diff = FUNC(fabs) (computed - expected);
490       switch (fpclassify (expected))
491         {
492         case FP_ZERO:
493           /* ilogb (0) isn't allowed. */
494           ulp = diff / FUNC(ldexp) (1.0, - MANT_DIG);
495           break;
496         case FP_NORMAL:
497           ulp = diff / FUNC(ldexp) (1.0, FUNC(ilogb) (expected) - MANT_DIG);
498           break;
499         case FP_SUBNORMAL:
500           ulp = (FUNC(ldexp) (diff, MANT_DIG)
501                  / FUNC(ldexp) (1.0, FUNC(ilogb) (expected)));
502           break;
503         default:
504           /* It should never happen. */
505           abort ();
506           break;
507         }
508       set_max_error (ulp, curr_max_error);
509       print_diff = 1;
510       if ((exceptions & IGNORE_ZERO_INF_SIGN) == 0
511           && computed == 0.0 && expected == 0.0
512           && signbit(computed) != signbit (expected))
513         ok = 0;
514       else if (ulp <= 0.5 || (ulp <= max_ulp && !ignore_max_ulp))
515         ok = 1;
516       else
517         {
518           ok = 0;
519           print_ulps (test_name, ulp);
520         }
521
522     }
523   if (print_screen (ok, xfail))
524     {
525       if (!ok)
526         printf ("Failure: ");
527       printf ("Test: %s\n", test_name);
528       printf ("Result:\n");
529       printf (" is:         % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
530               computed, computed);
531       printf (" should be:  % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
532               expected, expected);
533       if (print_diff)
534         {
535           printf (" difference: % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR
536                   "\n", diff, diff);
537           printf (" ulp       : % .4" PRINTF_NEXPR "\n", ulp);
538           printf (" max.ulp   : % .4" PRINTF_NEXPR "\n", max_ulp);
539         }
540     }
541   update_stats (ok, xfail);
542
543   fpstack_test (test_name);
544 }
545
546
547 static void
548 check_float (const char *test_name, FLOAT computed, FLOAT expected,
549              FLOAT max_ulp, int xfail, int exceptions)
550 {
551   check_float_internal (test_name, computed, expected, max_ulp, xfail,
552                         exceptions, &max_error);
553 }
554
555
556 static void
557 check_complex (const char *test_name, __complex__ FLOAT computed,
558                __complex__ FLOAT expected,
559                __complex__ FLOAT max_ulp, __complex__ int xfail,
560                int exception)
561 {
562   FLOAT part_comp, part_exp, part_max_ulp;
563   int part_xfail;
564   char str[200];
565
566   sprintf (str, "Real part of: %s", test_name);
567   part_comp = __real__ computed;
568   part_exp = __real__ expected;
569   part_max_ulp = __real__ max_ulp;
570   part_xfail = __real__ xfail;
571
572   check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
573                         exception, &real_max_error);
574
575   sprintf (str, "Imaginary part of: %s", test_name);
576   part_comp = __imag__ computed;
577   part_exp = __imag__ expected;
578   part_max_ulp = __imag__ max_ulp;
579   part_xfail = __imag__ xfail;
580
581   /* Don't check again for exceptions, just pass through the
582      zero/inf sign test.  */
583   check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
584                         exception & IGNORE_ZERO_INF_SIGN,
585                         &imag_max_error);
586 }
587
588
589 /* Check that computed and expected values are equal (int values).  */
590 static void
591 check_int (const char *test_name, int computed, int expected, int max_ulp,
592            int xfail, int exceptions)
593 {
594   int diff = computed - expected;
595   int ok = 0;
596
597   test_exceptions (test_name, exceptions);
598   noTests++;
599   if (abs (diff) <= max_ulp)
600     ok = 1;
601
602   if (!ok)
603     print_ulps (test_name, diff);
604
605   if (print_screen (ok, xfail))
606     {
607       if (!ok)
608         printf ("Failure: ");
609       printf ("Test: %s\n", test_name);
610       printf ("Result:\n");
611       printf (" is:         %d\n", computed);
612       printf (" should be:  %d\n", expected);
613     }
614
615   update_stats (ok, xfail);
616   fpstack_test (test_name);
617 }
618
619
620 /* Check that computed and expected values are equal (long int values).  */
621 static void
622 check_long (const char *test_name, long int computed, long int expected,
623             long int max_ulp, int xfail, int exceptions)
624 {
625   long int diff = computed - expected;
626   int ok = 0;
627
628   test_exceptions (test_name, exceptions);
629   noTests++;
630   if (labs (diff) <= max_ulp)
631     ok = 1;
632
633   if (!ok)
634     print_ulps (test_name, diff);
635
636   if (print_screen (ok, xfail))
637     {
638       if (!ok)
639         printf ("Failure: ");
640       printf ("Test: %s\n", test_name);
641       printf ("Result:\n");
642       printf (" is:         %ld\n", computed);
643       printf (" should be:  %ld\n", expected);
644     }
645
646   update_stats (ok, xfail);
647   fpstack_test (test_name);
648 }
649
650
651 /* Check that computed value is true/false.  */
652 static void
653 check_bool (const char *test_name, int computed, int expected,
654             long int max_ulp, int xfail, int exceptions)
655 {
656   int ok = 0;
657
658   test_exceptions (test_name, exceptions);
659   noTests++;
660   if ((computed == 0) == (expected == 0))
661     ok = 1;
662
663   if (print_screen (ok, xfail))
664     {
665       if (!ok)
666         printf ("Failure: ");
667       printf ("Test: %s\n", test_name);
668       printf ("Result:\n");
669       printf (" is:         %d\n", computed);
670       printf (" should be:  %d\n", expected);
671     }
672
673   update_stats (ok, xfail);
674   fpstack_test (test_name);
675 }
676
677
678 /* check that computed and expected values are equal (long int values) */
679 static void
680 check_longlong (const char *test_name, long long int computed,
681                 long long int expected,
682                 long long int max_ulp, int xfail,
683                 int exceptions)
684 {
685   long long int diff = computed - expected;
686   int ok = 0;
687
688   test_exceptions (test_name, exceptions);
689   noTests++;
690   if (llabs (diff) <= max_ulp)
691     ok = 1;
692
693   if (!ok)
694     print_ulps (test_name, diff);
695
696   if (print_screen (ok, xfail))
697     {
698       if (!ok)
699         printf ("Failure:");
700       printf ("Test: %s\n", test_name);
701       printf ("Result:\n");
702       printf (" is:         %lld\n", computed);
703       printf (" should be:  %lld\n", expected);
704     }
705
706   update_stats (ok, xfail);
707   fpstack_test (test_name);
708 }
709
710
711
712 /* This is to prevent messages from the SVID libm emulation.  */
713 int
714 matherr (struct exception *x __attribute__ ((unused)))
715 {
716   return 1;
717 }
718
719
720 /****************************************************************************
721   Tests for single functions of libm.
722   Please keep them alphabetically sorted!
723 ****************************************************************************/
724
725 static void
726 acos_test (void)
727 {
728   errno = 0;
729   FUNC(acos) (0);
730   if (errno == ENOSYS)
731     /* Function not implemented.  */
732     return;
733
734   START (acos);
735
736   TEST_f_f (acos, plus_infty, nan_value, INVALID_EXCEPTION);
737   TEST_f_f (acos, minus_infty, nan_value, INVALID_EXCEPTION);
738   TEST_f_f (acos, nan_value, nan_value);
739
740   /* |x| > 1: */
741   TEST_f_f (acos, 1.125L, nan_value, INVALID_EXCEPTION);
742   TEST_f_f (acos, -1.125L, nan_value, INVALID_EXCEPTION);
743
744   TEST_f_f (acos, 0, M_PI_2l);
745   TEST_f_f (acos, minus_zero, M_PI_2l);
746   TEST_f_f (acos, 1, 0);
747   TEST_f_f (acos, -1, M_PIl);
748   TEST_f_f (acos, 0.5, M_PI_6l*2.0);
749   TEST_f_f (acos, -0.5, M_PI_6l*4.0);
750   TEST_f_f (acos, 0.75L, 0.722734247813415611178377352641333362L);
751   TEST_f_f (acos, 2e-17L, 1.57079632679489659923132169163975144L);
752   TEST_f_f (acos, 0.0625L, 1.50825556499840522843072005474337068L);
753   END (acos);
754 }
755
756 static void
757 acosh_test (void)
758 {
759   errno = 0;
760   FUNC(acosh) (7);
761   if (errno == ENOSYS)
762     /* Function not implemented.  */
763     return;
764
765   START (acosh);
766
767   TEST_f_f (acosh, plus_infty, plus_infty);
768   TEST_f_f (acosh, minus_infty, nan_value, INVALID_EXCEPTION);
769
770   /* x < 1:  */
771   TEST_f_f (acosh, -1.125L, nan_value, INVALID_EXCEPTION);
772
773   TEST_f_f (acosh, 1, 0);
774   TEST_f_f (acosh, 7, 2.63391579384963341725009269461593689L);
775
776   END (acosh);
777 }
778
779 static void
780 asin_test (void)
781 {
782   errno = 0;
783   FUNC(asin) (0);
784   if (errno == ENOSYS)
785     /* Function not implemented.  */
786     return;
787
788   START (asin);
789
790   TEST_f_f (asin, plus_infty, nan_value, INVALID_EXCEPTION);
791   TEST_f_f (asin, minus_infty, nan_value, INVALID_EXCEPTION);
792   TEST_f_f (asin, nan_value, nan_value);
793
794   /* asin x == NaN plus invalid exception for |x| > 1.  */
795   TEST_f_f (asin, 1.125L, nan_value, INVALID_EXCEPTION);
796   TEST_f_f (asin, -1.125L, nan_value, INVALID_EXCEPTION);
797
798   TEST_f_f (asin, 0, 0);
799   TEST_f_f (asin, minus_zero, minus_zero);
800   TEST_f_f (asin, 0.5, M_PI_6l);
801   TEST_f_f (asin, -0.5, -M_PI_6l);
802   TEST_f_f (asin, 1.0, M_PI_2l);
803   TEST_f_f (asin, -1.0, -M_PI_2l);
804   TEST_f_f (asin, 0.75L, 0.848062078981481008052944338998418080L);
805
806   END (asin);
807 }
808
809 static void
810 asinh_test (void)
811 {
812   errno = 0;
813   FUNC(asinh) (0.7L);
814   if (errno == ENOSYS)
815     /* Function not implemented.  */
816     return;
817
818   START (asinh);
819
820   TEST_f_f (asinh, 0, 0);
821   TEST_f_f (asinh, minus_zero, minus_zero);
822 #ifndef TEST_INLINE
823   TEST_f_f (asinh, plus_infty, plus_infty);
824   TEST_f_f (asinh, minus_infty, minus_infty);
825 #endif
826   TEST_f_f (asinh, nan_value, nan_value);
827   TEST_f_f (asinh, 0.75L, 0.693147180559945309417232121458176568L);
828
829   END (asinh);
830 }
831
832 static void
833 atan_test (void)
834 {
835   errno = 0;
836   FUNC(atan) (0);
837   if (errno == ENOSYS)
838     /* Function not implemented.  */
839     return;
840
841   START (atan);
842
843   TEST_f_f (atan, 0, 0);
844   TEST_f_f (atan, minus_zero, minus_zero);
845
846   TEST_f_f (atan, plus_infty, M_PI_2l);
847   TEST_f_f (atan, minus_infty, -M_PI_2l);
848   TEST_f_f (atan, nan_value, nan_value);
849
850   TEST_f_f (atan, 1, M_PI_4l);
851   TEST_f_f (atan, -1, -M_PI_4l);
852
853   TEST_f_f (atan, 0.75L, 0.643501108793284386802809228717322638L);
854
855   END (atan);
856 }
857
858
859
860 static void
861 atanh_test (void)
862 {
863   errno = 0;
864   FUNC(atanh) (0.7L);
865   if (errno == ENOSYS)
866     /* Function not implemented.  */
867     return;
868
869   START (atanh);
870
871
872   TEST_f_f (atanh, 0, 0);
873   TEST_f_f (atanh, minus_zero, minus_zero);
874
875   TEST_f_f (atanh, 1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
876   TEST_f_f (atanh, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
877   TEST_f_f (atanh, nan_value, nan_value);
878
879   /* atanh (x) == NaN plus invalid exception if |x| > 1.  */
880   TEST_f_f (atanh, 1.125L, nan_value, INVALID_EXCEPTION);
881   TEST_f_f (atanh, -1.125L, nan_value, INVALID_EXCEPTION);
882
883   TEST_f_f (atanh, 0.75L, 0.972955074527656652552676371721589865L);
884
885   END (atanh);
886 }
887
888 static void
889 atan2_test (void)
890 {
891   errno = 0;
892   FUNC(atan2) (-0, 1);
893   if (errno == ENOSYS)
894     /* Function not implemented.  */
895     return;
896
897   START (atan2);
898
899   /* atan2 (0,x) == 0 for x > 0.  */
900   TEST_ff_f (atan2, 0, 1, 0);
901
902   /* atan2 (-0,x) == -0 for x > 0.  */
903   TEST_ff_f (atan2, minus_zero, 1, minus_zero);
904
905   TEST_ff_f (atan2, 0, 0, 0);
906   TEST_ff_f (atan2, minus_zero, 0, minus_zero);
907
908   /* atan2 (+0,x) == +pi for x < 0.  */
909   TEST_ff_f (atan2, 0, -1, M_PIl);
910
911   /* atan2 (-0,x) == -pi for x < 0.  */
912   TEST_ff_f (atan2, minus_zero, -1, -M_PIl);
913
914   TEST_ff_f (atan2, 0, minus_zero, M_PIl);
915   TEST_ff_f (atan2, minus_zero, minus_zero, -M_PIl);
916
917   /* atan2 (y,+0) == pi/2 for y > 0.  */
918   TEST_ff_f (atan2, 1, 0, M_PI_2l);
919
920   /* atan2 (y,-0) == pi/2 for y > 0.  */
921   TEST_ff_f (atan2, 1, minus_zero, M_PI_2l);
922
923   /* atan2 (y,+0) == -pi/2 for y < 0.  */
924   TEST_ff_f (atan2, -1, 0, -M_PI_2l);
925
926   /* atan2 (y,-0) == -pi/2 for y < 0.  */
927   TEST_ff_f (atan2, -1, minus_zero, -M_PI_2l);
928
929   /* atan2 (y,inf) == +0 for finite y > 0.  */
930   TEST_ff_f (atan2, 1, plus_infty, 0);
931
932   /* atan2 (y,inf) == -0 for finite y < 0.  */
933   TEST_ff_f (atan2, -1, plus_infty, minus_zero);
934
935   /* atan2(+inf, x) == pi/2 for finite x.  */
936   TEST_ff_f (atan2, plus_infty, -1, M_PI_2l);
937
938   /* atan2(-inf, x) == -pi/2 for finite x.  */
939   TEST_ff_f (atan2, minus_infty, 1, -M_PI_2l);
940
941   /* atan2 (y,-inf) == +pi for finite y > 0.  */
942   TEST_ff_f (atan2, 1, minus_infty, M_PIl);
943
944   /* atan2 (y,-inf) == -pi for finite y < 0.  */
945   TEST_ff_f (atan2, -1, minus_infty, -M_PIl);
946
947   TEST_ff_f (atan2, plus_infty, plus_infty, M_PI_4l);
948   TEST_ff_f (atan2, minus_infty, plus_infty, -M_PI_4l);
949   TEST_ff_f (atan2, plus_infty, minus_infty, M_PI_34l);
950   TEST_ff_f (atan2, minus_infty, minus_infty, -M_PI_34l);
951   TEST_ff_f (atan2, nan_value, nan_value, nan_value);
952
953   TEST_ff_f (atan2, 0.75L, 1, 0.643501108793284386802809228717322638L);
954   TEST_ff_f (atan2, -0.75L, 1.0L, -0.643501108793284386802809228717322638L);
955   TEST_ff_f (atan2, 0.75L, -1.0L, 2.49809154479650885165983415456218025L);
956   TEST_ff_f (atan2, -0.75L, -1.0L, -2.49809154479650885165983415456218025L);
957   TEST_ff_f (atan2, 0.390625L, .00029L, 1.57005392693128974780151246612928941L);
958   TEST_ff_f (atan2, 1.390625L, 0.9296875L, 0.981498387184244311516296577615519772L);
959
960   TEST_ff_f (atan2, -0.00756827042671106339L, -.001792735857538728036L, -1.80338464113663849327153994379639112L);
961
962   END (atan2);
963 }
964
965 static void
966 cabs_test (void)
967 {
968   errno = 0;
969   FUNC(cabs) (BUILD_COMPLEX (0.7L, 12.4L));
970   if (errno == ENOSYS)
971     /* Function not implemented.  */
972     return;
973
974   START (cabs);
975
976   /* cabs (x + iy) is specified as hypot (x,y) */
977
978   /* cabs (+inf + i x) == +inf.  */
979   TEST_c_f (cabs, plus_infty, 1.0, plus_infty);
980   /* cabs (-inf + i x) == +inf.  */
981   TEST_c_f (cabs, minus_infty, 1.0, plus_infty);
982
983   TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
984   TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
985
986   TEST_c_f (cabs, nan_value, nan_value, nan_value);
987
988   /* cabs (x,y) == cabs (y,x).  */
989   TEST_c_f (cabs, 0.75L, 12.390625L, 12.4133028598606664302388810868156657L);
990   /* cabs (x,y) == cabs (-x,y).  */
991   TEST_c_f (cabs, -12.390625L, 0.75L, 12.4133028598606664302388810868156657L);
992   /* cabs (x,y) == cabs (-y,x).  */
993   TEST_c_f (cabs, -0.75L, 12.390625L, 12.4133028598606664302388810868156657L);
994   /* cabs (x,y) == cabs (-x,-y).  */
995   TEST_c_f (cabs, -12.390625L, -0.75L, 12.4133028598606664302388810868156657L);
996   /* cabs (x,y) == cabs (-y,-x).  */
997   TEST_c_f (cabs, -0.75L, -12.390625L, 12.4133028598606664302388810868156657L);
998   /* cabs (x,0) == fabs (x).  */
999   TEST_c_f (cabs, -0.75L, 0, 0.75L);
1000   TEST_c_f (cabs, 0.75L, 0, 0.75L);
1001   TEST_c_f (cabs, -1.0L, 0, 1.0L);
1002   TEST_c_f (cabs, 1.0L, 0, 1.0L);
1003   TEST_c_f (cabs, -5.7e7L, 0, 5.7e7L);
1004   TEST_c_f (cabs, 5.7e7L, 0, 5.7e7L);
1005
1006   TEST_c_f (cabs, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
1007
1008   END (cabs);
1009 }
1010
1011
1012 static void
1013 cacos_test (void)
1014 {
1015   errno = 0;
1016   FUNC(cacos) (BUILD_COMPLEX (0.7L, 1.2L));
1017   if (errno == ENOSYS)
1018     /* Function not implemented.  */
1019     return;
1020
1021   START (cacos);
1022
1023
1024   TEST_c_c (cacos, 0, 0, M_PI_2l, minus_zero);
1025   TEST_c_c (cacos, minus_zero, 0, M_PI_2l, minus_zero);
1026   TEST_c_c (cacos, minus_zero, minus_zero, M_PI_2l, 0.0);
1027   TEST_c_c (cacos, 0, minus_zero, M_PI_2l, 0.0);
1028
1029   TEST_c_c (cacos, minus_infty, plus_infty, M_PI_34l, minus_infty);
1030   TEST_c_c (cacos, minus_infty, minus_infty, M_PI_34l, plus_infty);
1031
1032   TEST_c_c (cacos, plus_infty, plus_infty, M_PI_4l, minus_infty);
1033   TEST_c_c (cacos, plus_infty, minus_infty, M_PI_4l, plus_infty);
1034
1035   TEST_c_c (cacos, -10.0, plus_infty, M_PI_2l, minus_infty);
1036   TEST_c_c (cacos, -10.0, minus_infty, M_PI_2l, plus_infty);
1037   TEST_c_c (cacos, 0, plus_infty, M_PI_2l, minus_infty);
1038   TEST_c_c (cacos, 0, minus_infty, M_PI_2l, plus_infty);
1039   TEST_c_c (cacos, 0.1L, plus_infty, M_PI_2l, minus_infty);
1040   TEST_c_c (cacos, 0.1L, minus_infty, M_PI_2l, plus_infty);
1041
1042   TEST_c_c (cacos, minus_infty, 0, M_PIl, minus_infty);
1043   TEST_c_c (cacos, minus_infty, minus_zero, M_PIl, plus_infty);
1044   TEST_c_c (cacos, minus_infty, 100, M_PIl, minus_infty);
1045   TEST_c_c (cacos, minus_infty, -100, M_PIl, plus_infty);
1046
1047   TEST_c_c (cacos, plus_infty, 0, 0.0, minus_infty);
1048   TEST_c_c (cacos, plus_infty, minus_zero, 0.0, plus_infty);
1049   TEST_c_c (cacos, plus_infty, 0.5, 0.0, minus_infty);
1050   TEST_c_c (cacos, plus_infty, -0.5, 0.0, plus_infty);
1051
1052   TEST_c_c (cacos, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1053   TEST_c_c (cacos, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1054
1055   TEST_c_c (cacos, 0, nan_value, M_PI_2l, nan_value);
1056   TEST_c_c (cacos, minus_zero, nan_value, M_PI_2l, nan_value);
1057
1058   TEST_c_c (cacos, nan_value, plus_infty, nan_value, minus_infty);
1059   TEST_c_c (cacos, nan_value, minus_infty, nan_value, plus_infty);
1060
1061   TEST_c_c (cacos, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1062   TEST_c_c (cacos, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1063
1064   TEST_c_c (cacos, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1065   TEST_c_c (cacos, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1066
1067   TEST_c_c (cacos, nan_value, nan_value, nan_value, nan_value);
1068
1069   TEST_c_c (cacos, 0.75L, 1.25L, 1.11752014915610270578240049553777969L, -1.13239363160530819522266333696834467L);
1070   TEST_c_c (cacos, -2, -3, 2.1414491111159960199416055713254211L, 1.9833870299165354323470769028940395L);
1071
1072   END (cacos, complex);
1073 }
1074
1075 static void
1076 cacosh_test (void)
1077 {
1078   errno = 0;
1079   FUNC(cacosh) (BUILD_COMPLEX (0.7L, 1.2L));
1080   if (errno == ENOSYS)
1081     /* Function not implemented.  */
1082     return;
1083
1084   START (cacosh);
1085
1086
1087   TEST_c_c (cacosh, 0, 0, 0.0, M_PI_2l);
1088   TEST_c_c (cacosh, minus_zero, 0, 0.0, M_PI_2l);
1089   TEST_c_c (cacosh, 0, minus_zero, 0.0, -M_PI_2l);
1090   TEST_c_c (cacosh, minus_zero, minus_zero, 0.0, -M_PI_2l);
1091   TEST_c_c (cacosh, minus_infty, plus_infty, plus_infty, M_PI_34l);
1092   TEST_c_c (cacosh, minus_infty, minus_infty, plus_infty, -M_PI_34l);
1093
1094   TEST_c_c (cacosh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1095   TEST_c_c (cacosh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1096
1097   TEST_c_c (cacosh, -10.0, plus_infty, plus_infty, M_PI_2l);
1098   TEST_c_c (cacosh, -10.0, minus_infty, plus_infty, -M_PI_2l);
1099   TEST_c_c (cacosh, 0, plus_infty, plus_infty, M_PI_2l);
1100   TEST_c_c (cacosh, 0, minus_infty, plus_infty, -M_PI_2l);
1101   TEST_c_c (cacosh, 0.1L, plus_infty, plus_infty, M_PI_2l);
1102   TEST_c_c (cacosh, 0.1L, minus_infty, plus_infty, -M_PI_2l);
1103
1104   TEST_c_c (cacosh, minus_infty, 0, plus_infty, M_PIl);
1105   TEST_c_c (cacosh, minus_infty, minus_zero, plus_infty, -M_PIl);
1106   TEST_c_c (cacosh, minus_infty, 100, plus_infty, M_PIl);
1107   TEST_c_c (cacosh, minus_infty, -100, plus_infty, -M_PIl);
1108
1109   TEST_c_c (cacosh, plus_infty, 0, plus_infty, 0.0);
1110   TEST_c_c (cacosh, plus_infty, minus_zero, plus_infty, minus_zero);
1111   TEST_c_c (cacosh, plus_infty, 0.5, plus_infty, 0.0);
1112   TEST_c_c (cacosh, plus_infty, -0.5, plus_infty, minus_zero);
1113
1114   TEST_c_c (cacosh, plus_infty, nan_value, plus_infty, nan_value);
1115   TEST_c_c (cacosh, minus_infty, nan_value, plus_infty, nan_value);
1116
1117   TEST_c_c (cacosh, 0, nan_value, nan_value, nan_value);
1118   TEST_c_c (cacosh, minus_zero, nan_value, nan_value, nan_value);
1119
1120   TEST_c_c (cacosh, nan_value, plus_infty, plus_infty, nan_value);
1121   TEST_c_c (cacosh, nan_value, minus_infty, plus_infty, nan_value);
1122
1123   TEST_c_c (cacosh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1124   TEST_c_c (cacosh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1125
1126   TEST_c_c (cacosh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1127   TEST_c_c (cacosh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1128
1129   TEST_c_c (cacosh, nan_value, nan_value, nan_value, nan_value);
1130
1131   TEST_c_c (cacosh, 0.75L, 1.25L, 1.13239363160530819522266333696834467L, 1.11752014915610270578240049553777969L);
1132   TEST_c_c (cacosh, -2, -3, 1.9833870299165354323470769028940395L, -2.1414491111159960199416055713254211L);
1133
1134   END (cacosh, complex);
1135 }
1136
1137
1138 static void
1139 carg_test (void)
1140 {
1141   START (carg);
1142
1143   /* carg (x + iy) is specified as atan2 (y, x) */
1144
1145   /* carg (x + i 0) == 0 for x > 0.  */
1146   TEST_c_f (carg, 2.0, 0, 0);
1147   /* carg (x - i 0) == -0 for x > 0.  */
1148   TEST_c_f (carg, 2.0, minus_zero, minus_zero);
1149
1150   TEST_c_f (carg, 0, 0, 0);
1151   TEST_c_f (carg, 0, minus_zero, minus_zero);
1152
1153   /* carg (x + i 0) == +pi for x < 0.  */
1154   TEST_c_f (carg, -2.0, 0, M_PIl);
1155
1156   /* carg (x - i 0) == -pi for x < 0.  */
1157   TEST_c_f (carg, -2.0, minus_zero, -M_PIl);
1158
1159   TEST_c_f (carg, minus_zero, 0, M_PIl);
1160   TEST_c_f (carg, minus_zero, minus_zero, -M_PIl);
1161
1162   /* carg (+0 + i y) == pi/2 for y > 0.  */
1163   TEST_c_f (carg, 0, 2.0, M_PI_2l);
1164
1165   /* carg (-0 + i y) == pi/2 for y > 0.  */
1166   TEST_c_f (carg, minus_zero, 2.0, M_PI_2l);
1167
1168   /* carg (+0 + i y) == -pi/2 for y < 0.  */
1169   TEST_c_f (carg, 0, -2.0, -M_PI_2l);
1170
1171   /* carg (-0 + i y) == -pi/2 for y < 0.  */
1172   TEST_c_f (carg, minus_zero, -2.0, -M_PI_2l);
1173
1174   /* carg (inf + i y) == +0 for finite y > 0.  */
1175   TEST_c_f (carg, plus_infty, 2.0, 0);
1176
1177   /* carg (inf + i y) == -0 for finite y < 0.  */
1178   TEST_c_f (carg, plus_infty, -2.0, minus_zero);
1179
1180   /* carg(x + i inf) == pi/2 for finite x.  */
1181   TEST_c_f (carg, 10.0, plus_infty, M_PI_2l);
1182
1183   /* carg(x - i inf) == -pi/2 for finite x.  */
1184   TEST_c_f (carg, 10.0, minus_infty, -M_PI_2l);
1185
1186   /* carg (-inf + i y) == +pi for finite y > 0.  */
1187   TEST_c_f (carg, minus_infty, 10.0, M_PIl);
1188
1189   /* carg (-inf + i y) == -pi for finite y < 0.  */
1190   TEST_c_f (carg, minus_infty, -10.0, -M_PIl);
1191
1192   TEST_c_f (carg, plus_infty, plus_infty, M_PI_4l);
1193
1194   TEST_c_f (carg, plus_infty, minus_infty, -M_PI_4l);
1195
1196   TEST_c_f (carg, minus_infty, plus_infty, 3 * M_PI_4l);
1197
1198   TEST_c_f (carg, minus_infty, minus_infty, -3 * M_PI_4l);
1199
1200   TEST_c_f (carg, nan_value, nan_value, nan_value);
1201
1202   END (carg);
1203 }
1204
1205 static void
1206 casin_test (void)
1207 {
1208   errno = 0;
1209   FUNC(casin) (BUILD_COMPLEX (0.7L, 1.2L));
1210   if (errno == ENOSYS)
1211     /* Function not implemented.  */
1212     return;
1213
1214   START (casin);
1215
1216   TEST_c_c (casin, 0, 0, 0.0, 0.0);
1217   TEST_c_c (casin, minus_zero, 0, minus_zero, 0.0);
1218   TEST_c_c (casin, 0, minus_zero, 0.0, minus_zero);
1219   TEST_c_c (casin, minus_zero, minus_zero, minus_zero, minus_zero);
1220
1221   TEST_c_c (casin, plus_infty, plus_infty, M_PI_4l, plus_infty);
1222   TEST_c_c (casin, plus_infty, minus_infty, M_PI_4l, minus_infty);
1223   TEST_c_c (casin, minus_infty, plus_infty, -M_PI_4l, plus_infty);
1224   TEST_c_c (casin, minus_infty, minus_infty, -M_PI_4l, minus_infty);
1225
1226   TEST_c_c (casin, -10.0, plus_infty, minus_zero, plus_infty);
1227   TEST_c_c (casin, -10.0, minus_infty, minus_zero, minus_infty);
1228   TEST_c_c (casin, 0, plus_infty, 0.0, plus_infty);
1229   TEST_c_c (casin, 0, minus_infty, 0.0, minus_infty);
1230   TEST_c_c (casin, minus_zero, plus_infty, minus_zero, plus_infty);
1231   TEST_c_c (casin, minus_zero, minus_infty, minus_zero, minus_infty);
1232   TEST_c_c (casin, 0.1L, plus_infty, 0.0, plus_infty);
1233   TEST_c_c (casin, 0.1L, minus_infty, 0.0, minus_infty);
1234
1235   TEST_c_c (casin, minus_infty, 0, -M_PI_2l, plus_infty);
1236   TEST_c_c (casin, minus_infty, minus_zero, -M_PI_2l, minus_infty);
1237   TEST_c_c (casin, minus_infty, 100, -M_PI_2l, plus_infty);
1238   TEST_c_c (casin, minus_infty, -100, -M_PI_2l, minus_infty);
1239
1240   TEST_c_c (casin, plus_infty, 0, M_PI_2l, plus_infty);
1241   TEST_c_c (casin, plus_infty, minus_zero, M_PI_2l, minus_infty);
1242   TEST_c_c (casin, plus_infty, 0.5, M_PI_2l, plus_infty);
1243   TEST_c_c (casin, plus_infty, -0.5, M_PI_2l, minus_infty);
1244
1245   TEST_c_c (casin, nan_value, plus_infty, nan_value, plus_infty);
1246   TEST_c_c (casin, nan_value, minus_infty, nan_value, minus_infty);
1247
1248   TEST_c_c (casin, 0.0, nan_value, 0.0, nan_value);
1249   TEST_c_c (casin, minus_zero, nan_value, minus_zero, nan_value);
1250
1251   TEST_c_c (casin, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1252   TEST_c_c (casin, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1253
1254   TEST_c_c (casin, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1255   TEST_c_c (casin, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1256
1257   TEST_c_c (casin, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1258   TEST_c_c (casin, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1259
1260   TEST_c_c (casin, nan_value, nan_value, nan_value, nan_value);
1261
1262   TEST_c_c (casin, 0.75L, 1.25L, 0.453276177638793913448921196101971749L, 1.13239363160530819522266333696834467L);
1263   TEST_c_c (casin, -2, -3, -0.57065278432109940071028387968566963L, -1.9833870299165354323470769028940395L);
1264
1265   END (casin, complex);
1266 }
1267
1268
1269 static void
1270 casinh_test (void)
1271 {
1272   errno = 0;
1273   FUNC(casinh) (BUILD_COMPLEX (0.7L, 1.2L));
1274   if (errno == ENOSYS)
1275     /* Function not implemented.  */
1276     return;
1277
1278   START (casinh);
1279
1280   TEST_c_c (casinh, 0, 0, 0.0, 0.0);
1281   TEST_c_c (casinh, minus_zero, 0, minus_zero, 0);
1282   TEST_c_c (casinh, 0, minus_zero, 0.0, minus_zero);
1283   TEST_c_c (casinh, minus_zero, minus_zero, minus_zero, minus_zero);
1284
1285   TEST_c_c (casinh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1286   TEST_c_c (casinh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1287   TEST_c_c (casinh, minus_infty, plus_infty, minus_infty, M_PI_4l);
1288   TEST_c_c (casinh, minus_infty, minus_infty, minus_infty, -M_PI_4l);
1289
1290   TEST_c_c (casinh, -10.0, plus_infty, minus_infty, M_PI_2l);
1291   TEST_c_c (casinh, -10.0, minus_infty, minus_infty, -M_PI_2l);
1292   TEST_c_c (casinh, 0, plus_infty, plus_infty, M_PI_2l);
1293   TEST_c_c (casinh, 0, minus_infty, plus_infty, -M_PI_2l);
1294   TEST_c_c (casinh, minus_zero, plus_infty, minus_infty, M_PI_2l);
1295   TEST_c_c (casinh, minus_zero, minus_infty, minus_infty, -M_PI_2l);
1296   TEST_c_c (casinh, 0.1L, plus_infty, plus_infty, M_PI_2l);
1297   TEST_c_c (casinh, 0.1L, minus_infty, plus_infty, -M_PI_2l);
1298
1299   TEST_c_c (casinh, minus_infty, 0, minus_infty, 0.0);
1300   TEST_c_c (casinh, minus_infty, minus_zero, minus_infty, minus_zero);
1301   TEST_c_c (casinh, minus_infty, 100, minus_infty, 0.0);
1302   TEST_c_c (casinh, minus_infty, -100, minus_infty, minus_zero);
1303
1304   TEST_c_c (casinh, plus_infty, 0, plus_infty, 0.0);
1305   TEST_c_c (casinh, plus_infty, minus_zero, plus_infty, minus_zero);
1306   TEST_c_c (casinh, plus_infty, 0.5, plus_infty, 0.0);
1307   TEST_c_c (casinh, plus_infty, -0.5, plus_infty, minus_zero);
1308
1309   TEST_c_c (casinh, plus_infty, nan_value, plus_infty, nan_value);
1310   TEST_c_c (casinh, minus_infty, nan_value, minus_infty, nan_value);
1311
1312   TEST_c_c (casinh, nan_value, 0, nan_value, 0.0);
1313   TEST_c_c (casinh, nan_value, minus_zero, nan_value, minus_zero);
1314
1315   TEST_c_c (casinh, nan_value, plus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1316   TEST_c_c (casinh, nan_value, minus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1317
1318   TEST_c_c (casinh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1319   TEST_c_c (casinh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1320
1321   TEST_c_c (casinh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1322   TEST_c_c (casinh, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1323
1324   TEST_c_c (casinh, nan_value, nan_value, nan_value, nan_value);
1325
1326   TEST_c_c (casinh, 0.75L, 1.25L, 1.03171853444778027336364058631006594L, 0.911738290968487636358489564316731207L);
1327   TEST_c_c (casinh, -2, -3, -1.9686379257930962917886650952454982L, -0.96465850440760279204541105949953237L);
1328
1329   END (casinh, complex);
1330 }
1331
1332
1333 static void
1334 catan_test (void)
1335 {
1336   errno = 0;
1337   FUNC(catan) (BUILD_COMPLEX (0.7L, 1.2L));
1338   if (errno == ENOSYS)
1339     /* Function not implemented.  */
1340     return;
1341
1342   START (catan);
1343
1344   TEST_c_c (catan, 0, 0, 0, 0);
1345   TEST_c_c (catan, minus_zero, 0, minus_zero, 0);
1346   TEST_c_c (catan, 0, minus_zero, 0, minus_zero);
1347   TEST_c_c (catan, minus_zero, minus_zero, minus_zero, minus_zero);
1348
1349   TEST_c_c (catan, plus_infty, plus_infty, M_PI_2l, 0);
1350   TEST_c_c (catan, plus_infty, minus_infty, M_PI_2l, minus_zero);
1351   TEST_c_c (catan, minus_infty, plus_infty, -M_PI_2l, 0);
1352   TEST_c_c (catan, minus_infty, minus_infty, -M_PI_2l, minus_zero);
1353
1354
1355   TEST_c_c (catan, plus_infty, -10.0, M_PI_2l, minus_zero);
1356   TEST_c_c (catan, minus_infty, -10.0, -M_PI_2l, minus_zero);
1357   TEST_c_c (catan, plus_infty, minus_zero, M_PI_2l, minus_zero);
1358   TEST_c_c (catan, minus_infty, minus_zero, -M_PI_2l, minus_zero);
1359   TEST_c_c (catan, plus_infty, 0.0, M_PI_2l, 0);
1360   TEST_c_c (catan, minus_infty, 0.0, -M_PI_2l, 0);
1361   TEST_c_c (catan, plus_infty, 0.1L, M_PI_2l, 0);
1362   TEST_c_c (catan, minus_infty, 0.1L, -M_PI_2l, 0);
1363
1364   TEST_c_c (catan, 0.0, minus_infty, M_PI_2l, minus_zero);
1365   TEST_c_c (catan, minus_zero, minus_infty, -M_PI_2l, minus_zero);
1366   TEST_c_c (catan, 100.0, minus_infty, M_PI_2l, minus_zero);
1367   TEST_c_c (catan, -100.0, minus_infty, -M_PI_2l, minus_zero);
1368
1369   TEST_c_c (catan, 0.0, plus_infty, M_PI_2l, 0);
1370   TEST_c_c (catan, minus_zero, plus_infty, -M_PI_2l, 0);
1371   TEST_c_c (catan, 0.5, plus_infty, M_PI_2l, 0);
1372   TEST_c_c (catan, -0.5, plus_infty, -M_PI_2l, 0);
1373
1374   TEST_c_c (catan, nan_value, 0.0, nan_value, 0);
1375   TEST_c_c (catan, nan_value, minus_zero, nan_value, minus_zero);
1376
1377   TEST_c_c (catan, nan_value, plus_infty, nan_value, 0);
1378   TEST_c_c (catan, nan_value, minus_infty, nan_value, minus_zero);
1379
1380   TEST_c_c (catan, 0.0, nan_value, nan_value, nan_value);
1381   TEST_c_c (catan, minus_zero, nan_value, nan_value, nan_value);
1382
1383   TEST_c_c (catan, plus_infty, nan_value, M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1384   TEST_c_c (catan, minus_infty, nan_value, -M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1385
1386   TEST_c_c (catan, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1387   TEST_c_c (catan, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1388
1389   TEST_c_c (catan, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1390   TEST_c_c (catan, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1391
1392   TEST_c_c (catan, nan_value, nan_value, nan_value, nan_value);
1393
1394   TEST_c_c (catan, 0.75L, 1.25L, 1.10714871779409050301706546017853704L, 0.549306144334054845697622618461262852L);
1395   TEST_c_c (catan, -2, -3, -1.4099210495965755225306193844604208L, -0.22907268296853876629588180294200276L);
1396
1397   END (catan, complex);
1398 }
1399
1400 static void
1401 catanh_test (void)
1402 {
1403   errno = 0;
1404   FUNC(catanh) (BUILD_COMPLEX (0.7L, 1.2L));
1405   if (errno == ENOSYS)
1406     /* Function not implemented.  */
1407     return;
1408
1409   START (catanh);
1410
1411   TEST_c_c (catanh, 0, 0, 0.0, 0.0);
1412   TEST_c_c (catanh, minus_zero, 0, minus_zero, 0.0);
1413   TEST_c_c (catanh, 0, minus_zero, 0.0, minus_zero);
1414   TEST_c_c (catanh, minus_zero, minus_zero, minus_zero, minus_zero);
1415
1416   TEST_c_c (catanh, plus_infty, plus_infty, 0.0, M_PI_2l);
1417   TEST_c_c (catanh, plus_infty, minus_infty, 0.0, -M_PI_2l);
1418   TEST_c_c (catanh, minus_infty, plus_infty, minus_zero, M_PI_2l);
1419   TEST_c_c (catanh, minus_infty, minus_infty, minus_zero, -M_PI_2l);
1420
1421   TEST_c_c (catanh, -10.0, plus_infty, minus_zero, M_PI_2l);
1422   TEST_c_c (catanh, -10.0, minus_infty, minus_zero, -M_PI_2l);
1423   TEST_c_c (catanh, minus_zero, plus_infty, minus_zero, M_PI_2l);
1424   TEST_c_c (catanh, minus_zero, minus_infty, minus_zero, -M_PI_2l);
1425   TEST_c_c (catanh, 0, plus_infty, 0.0, M_PI_2l);
1426   TEST_c_c (catanh, 0, minus_infty, 0.0, -M_PI_2l);
1427   TEST_c_c (catanh, 0.1L, plus_infty, 0.0, M_PI_2l);
1428   TEST_c_c (catanh, 0.1L, minus_infty, 0.0, -M_PI_2l);
1429
1430   TEST_c_c (catanh, minus_infty, 0, minus_zero, M_PI_2l);
1431   TEST_c_c (catanh, minus_infty, minus_zero, minus_zero, -M_PI_2l);
1432   TEST_c_c (catanh, minus_infty, 100, minus_zero, M_PI_2l);
1433   TEST_c_c (catanh, minus_infty, -100, minus_zero, -M_PI_2l);
1434
1435   TEST_c_c (catanh, plus_infty, 0, 0.0, M_PI_2l);
1436   TEST_c_c (catanh, plus_infty, minus_zero, 0.0, -M_PI_2l);
1437   TEST_c_c (catanh, plus_infty, 0.5, 0.0, M_PI_2l);
1438   TEST_c_c (catanh, plus_infty, -0.5, 0.0, -M_PI_2l);
1439
1440   TEST_c_c (catanh, 0, nan_value, 0.0, nan_value);
1441   TEST_c_c (catanh, minus_zero, nan_value, minus_zero, nan_value);
1442
1443   TEST_c_c (catanh, plus_infty, nan_value, 0.0, nan_value);
1444   TEST_c_c (catanh, minus_infty, nan_value, minus_zero, nan_value);
1445
1446   TEST_c_c (catanh, nan_value, 0, nan_value, nan_value);
1447   TEST_c_c (catanh, nan_value, minus_zero, nan_value, nan_value);
1448
1449   TEST_c_c (catanh, nan_value, plus_infty, 0.0, M_PI_2l, IGNORE_ZERO_INF_SIGN);
1450   TEST_c_c (catanh, nan_value, minus_infty, 0.0, -M_PI_2l, IGNORE_ZERO_INF_SIGN);
1451
1452   TEST_c_c (catanh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1453   TEST_c_c (catanh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1454
1455   TEST_c_c (catanh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1456   TEST_c_c (catanh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1457
1458   TEST_c_c (catanh, nan_value, nan_value, nan_value, nan_value);
1459
1460   TEST_c_c (catanh, 0.75L, 1.25L, 0.261492138795671927078652057366532140L, 0.996825126463918666098902241310446708L);
1461   TEST_c_c (catanh, -2, -3, -0.14694666622552975204743278515471595L, -1.3389725222944935611241935759091443L);
1462
1463   END (catanh, complex);
1464 }
1465
1466 static void
1467 cbrt_test (void)
1468 {
1469   errno = 0;
1470   FUNC(cbrt) (8);
1471   if (errno == ENOSYS)
1472     /* Function not implemented.  */
1473     return;
1474
1475   START (cbrt);
1476
1477   TEST_f_f (cbrt, 0.0, 0.0);
1478   TEST_f_f (cbrt, minus_zero, minus_zero);
1479
1480   TEST_f_f (cbrt, plus_infty, plus_infty);
1481   TEST_f_f (cbrt, minus_infty, minus_infty);
1482   TEST_f_f (cbrt, nan_value, nan_value);
1483
1484   TEST_f_f (cbrt, -0.001L, -0.1L);
1485   TEST_f_f (cbrt, 8, 2);
1486   TEST_f_f (cbrt, -27.0, -3.0);
1487   TEST_f_f (cbrt, 0.9921875L, 0.997389022060725270579075195353955217L);
1488   TEST_f_f (cbrt, 0.75L, 0.908560296416069829445605878163630251L);
1489
1490   END (cbrt);
1491 }
1492
1493
1494 static void
1495 ccos_test (void)
1496 {
1497   errno = 0;
1498   FUNC(ccos) (BUILD_COMPLEX (0, 0));
1499   if (errno == ENOSYS)
1500     /* Function not implemented.  */
1501     return;
1502
1503   START (ccos);
1504
1505   TEST_c_c (ccos, 0.0, 0.0, 1.0, minus_zero);
1506   TEST_c_c (ccos, minus_zero, 0.0, 1.0, 0.0);
1507   TEST_c_c (ccos, 0.0, minus_zero, 1.0, 0.0);
1508   TEST_c_c (ccos, minus_zero, minus_zero, 1.0, minus_zero);
1509
1510   TEST_c_c (ccos, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1511   TEST_c_c (ccos, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1512   TEST_c_c (ccos, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1513   TEST_c_c (ccos, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1514
1515   TEST_c_c (ccos, 0.0, plus_infty, plus_infty, minus_zero);
1516   TEST_c_c (ccos, 0.0, minus_infty, plus_infty, 0.0);
1517   TEST_c_c (ccos, minus_zero, plus_infty, plus_infty, 0.0);
1518   TEST_c_c (ccos, minus_zero, minus_infty, plus_infty, minus_zero);
1519
1520   TEST_c_c (ccos, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1521   TEST_c_c (ccos, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1522   TEST_c_c (ccos, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1523   TEST_c_c (ccos, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1524
1525   TEST_c_c (ccos, 4.625, plus_infty, minus_infty, plus_infty);
1526   TEST_c_c (ccos, 4.625, minus_infty, minus_infty, minus_infty);
1527   TEST_c_c (ccos, -4.625, plus_infty, minus_infty, minus_infty);
1528   TEST_c_c (ccos, -4.625, minus_infty, minus_infty, plus_infty);
1529
1530   TEST_c_c (ccos, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1531   TEST_c_c (ccos, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1532   TEST_c_c (ccos, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1533   TEST_c_c (ccos, minus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1534
1535   TEST_c_c (ccos, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1536   TEST_c_c (ccos, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1537
1538   TEST_c_c (ccos, nan_value, plus_infty, plus_infty, nan_value);
1539   TEST_c_c (ccos, nan_value, minus_infty, plus_infty, nan_value);
1540
1541   TEST_c_c (ccos, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1542   TEST_c_c (ccos, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1543
1544   TEST_c_c (ccos, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1545   TEST_c_c (ccos, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1546
1547   TEST_c_c (ccos, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1548   TEST_c_c (ccos, -10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1549
1550   TEST_c_c (ccos, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1551   TEST_c_c (ccos, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1552
1553   TEST_c_c (ccos, nan_value, nan_value, nan_value, nan_value);
1554
1555   TEST_c_c (ccos, 0.75L, 1.25L, 1.38173873063425888530729933139078645L, -1.09193013555397466170919531722024128L);
1556   TEST_c_c (ccos, -2, -3, -4.18962569096880723013255501961597373L, -9.10922789375533659797919726277886212L);
1557
1558   END (ccos, complex);
1559 }
1560
1561
1562 static void
1563 ccosh_test (void)
1564 {
1565   errno = 0;
1566   FUNC(ccosh) (BUILD_COMPLEX (0.7L, 1.2L));
1567   if (errno == ENOSYS)
1568     /* Function not implemented.  */
1569     return;
1570
1571   START (ccosh);
1572
1573   TEST_c_c (ccosh, 0.0, 0.0, 1.0, 0.0);
1574   TEST_c_c (ccosh, minus_zero, 0.0, 1.0, minus_zero);
1575   TEST_c_c (ccosh, 0.0, minus_zero, 1.0, minus_zero);
1576   TEST_c_c (ccosh, minus_zero, minus_zero, 1.0, 0.0);
1577
1578   TEST_c_c (ccosh, 0.0, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1579   TEST_c_c (ccosh, minus_zero, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1580   TEST_c_c (ccosh, 0.0, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1581   TEST_c_c (ccosh, minus_zero, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1582
1583   TEST_c_c (ccosh, plus_infty, 0.0, plus_infty, 0.0);
1584   TEST_c_c (ccosh, minus_infty, 0.0, plus_infty, minus_zero);
1585   TEST_c_c (ccosh, plus_infty, minus_zero, plus_infty, minus_zero);
1586   TEST_c_c (ccosh, minus_infty, minus_zero, plus_infty, 0.0);
1587
1588   TEST_c_c (ccosh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1589   TEST_c_c (ccosh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1590   TEST_c_c (ccosh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1591   TEST_c_c (ccosh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1592
1593   TEST_c_c (ccosh, plus_infty, 4.625, minus_infty, minus_infty);
1594   TEST_c_c (ccosh, minus_infty, 4.625, minus_infty, plus_infty);
1595   TEST_c_c (ccosh, plus_infty, -4.625, minus_infty, plus_infty);
1596   TEST_c_c (ccosh, minus_infty, -4.625, minus_infty, minus_infty);
1597
1598   TEST_c_c (ccosh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1599   TEST_c_c (ccosh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1600   TEST_c_c (ccosh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1601   TEST_c_c (ccosh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1602
1603   TEST_c_c (ccosh, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1604   TEST_c_c (ccosh, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1605
1606   TEST_c_c (ccosh, plus_infty, nan_value, plus_infty, nan_value);
1607   TEST_c_c (ccosh, minus_infty, nan_value, plus_infty, nan_value);
1608
1609   TEST_c_c (ccosh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1610   TEST_c_c (ccosh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1611
1612   TEST_c_c (ccosh, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1613   TEST_c_c (ccosh, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1614
1615   TEST_c_c (ccosh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1616   TEST_c_c (ccosh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1617
1618   TEST_c_c (ccosh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1619   TEST_c_c (ccosh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1620
1621   TEST_c_c (ccosh, nan_value, nan_value, nan_value, nan_value);
1622
1623   TEST_c_c (ccosh, 0.75L, 1.25L, 0.408242591877968807788852146397499084L, 0.780365930845853240391326216300863152L);
1624
1625   TEST_c_c (ccosh, -2, -3, -3.72454550491532256547397070325597253L, 0.511822569987384608834463849801875634L);
1626
1627   END (ccosh, complex);
1628 }
1629
1630
1631 static void
1632 ceil_test (void)
1633 {
1634   START (ceil);
1635
1636   TEST_f_f (ceil, 0.0, 0.0);
1637   TEST_f_f (ceil, minus_zero, minus_zero);
1638   TEST_f_f (ceil, plus_infty, plus_infty);
1639   TEST_f_f (ceil, minus_infty, minus_infty);
1640   TEST_f_f (ceil, nan_value, nan_value);
1641
1642   TEST_f_f (ceil, M_PIl, 4.0);
1643   TEST_f_f (ceil, -M_PIl, -3.0);
1644   TEST_f_f (ceil, 0.1, 1.0);
1645   TEST_f_f (ceil, 0.25, 1.0);
1646   TEST_f_f (ceil, 0.625, 1.0);
1647   TEST_f_f (ceil, -0.1, minus_zero);
1648   TEST_f_f (ceil, -0.25, minus_zero);
1649   TEST_f_f (ceil, -0.625, minus_zero);
1650
1651 #ifdef TEST_LDOUBLE
1652   /* The result can only be represented in long double.  */
1653   TEST_f_f (ceil, 4503599627370495.5L, 4503599627370496.0L);
1654   TEST_f_f (ceil, 4503599627370496.25L, 4503599627370497.0L);
1655   TEST_f_f (ceil, 4503599627370496.5L, 4503599627370497.0L);
1656   TEST_f_f (ceil, 4503599627370496.75L, 4503599627370497.0L);
1657   TEST_f_f (ceil, 4503599627370497.5L, 4503599627370498.0L);
1658
1659   TEST_f_f (ceil, -4503599627370495.5L, -4503599627370495.0L);
1660   TEST_f_f (ceil, -4503599627370496.25L, -4503599627370496.0L);
1661   TEST_f_f (ceil, -4503599627370496.5L, -4503599627370496.0L);
1662   TEST_f_f (ceil, -4503599627370496.75L, -4503599627370496.0L);
1663   TEST_f_f (ceil, -4503599627370497.5L, -4503599627370497.0L);
1664
1665 # if LDBL_MANT_DIG > 100
1666   TEST_f_f (ceil, 4503599627370494.5000000000001L, 4503599627370495.0L);
1667   TEST_f_f (ceil, 4503599627370495.5000000000001L, 4503599627370496.0L);
1668   TEST_f_f (ceil, 4503599627370496.5000000000001L, 4503599627370497.0L);
1669   TEST_f_f (ceil, -4503599627370494.5000000000001L, -4503599627370494.0L);
1670   TEST_f_f (ceil, -4503599627370495.5000000000001L, -4503599627370495.0L);
1671   TEST_f_f (ceil, -4503599627370496.5000000000001L, -4503599627370496.0L);
1672 # endif
1673
1674   TEST_f_f (ceil, 9007199254740991.5L, 9007199254740992.0L);
1675   TEST_f_f (ceil, 9007199254740992.25L, 9007199254740993.0L);
1676   TEST_f_f (ceil, 9007199254740992.5L, 9007199254740993.0L);
1677   TEST_f_f (ceil, 9007199254740992.75L, 9007199254740993.0L);
1678   TEST_f_f (ceil, 9007199254740993.5L, 9007199254740994.0L);
1679
1680   TEST_f_f (ceil, -9007199254740991.5L, -9007199254740991.0L);
1681   TEST_f_f (ceil, -9007199254740992.25L, -9007199254740992.0L);
1682   TEST_f_f (ceil, -9007199254740992.5L, -9007199254740992.0L);
1683   TEST_f_f (ceil, -9007199254740992.75L, -9007199254740992.0L);
1684   TEST_f_f (ceil, -9007199254740993.5L, -9007199254740993.0L);
1685
1686 # if LDBL_MANT_DIG > 100
1687   TEST_f_f (ceil, 9007199254740991.0000000000001L, 9007199254740992.0L);
1688   TEST_f_f (ceil, 9007199254740992.0000000000001L, 9007199254740993.0L);
1689   TEST_f_f (ceil, 9007199254740993.0000000000001L, 9007199254740994.0L);
1690   TEST_f_f (ceil, 9007199254740991.5000000000001L, 9007199254740992.0L);
1691   TEST_f_f (ceil, 9007199254740992.5000000000001L, 9007199254740993.0L);
1692   TEST_f_f (ceil, 9007199254740993.5000000000001L, 9007199254740994.0L);
1693
1694   TEST_f_f (ceil, -9007199254740991.0000000000001L, -9007199254740991.0L);
1695   TEST_f_f (ceil, -9007199254740992.0000000000001L, -9007199254740992.0L);
1696   TEST_f_f (ceil, -9007199254740993.0000000000001L, -9007199254740993.0L);
1697   TEST_f_f (ceil, -9007199254740991.5000000000001L, -9007199254740991.0L);
1698   TEST_f_f (ceil, -9007199254740992.5000000000001L, -9007199254740992.0L);
1699   TEST_f_f (ceil, -9007199254740993.5000000000001L, -9007199254740993.0L);
1700 # endif
1701
1702   TEST_f_f (ceil, 72057594037927935.5L, 72057594037927936.0L);
1703   TEST_f_f (ceil, 72057594037927936.25L, 72057594037927937.0L);
1704   TEST_f_f (ceil, 72057594037927936.5L, 72057594037927937.0L);
1705   TEST_f_f (ceil, 72057594037927936.75L, 72057594037927937.0L);
1706   TEST_f_f (ceil, 72057594037927937.5L, 72057594037927938.0L);
1707
1708   TEST_f_f (ceil, -72057594037927935.5L, -72057594037927935.0L);
1709   TEST_f_f (ceil, -72057594037927936.25L, -72057594037927936.0L);
1710   TEST_f_f (ceil, -72057594037927936.5L, -72057594037927936.0L);
1711   TEST_f_f (ceil, -72057594037927936.75L, -72057594037927936.0L);
1712   TEST_f_f (ceil, -72057594037927937.5L, -72057594037927937.0L);
1713
1714   TEST_f_f (ceil, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
1715   TEST_f_f (ceil, 10141204801825835211973625643008.25L, 10141204801825835211973625643009.0L);
1716   TEST_f_f (ceil, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
1717   TEST_f_f (ceil, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
1718   TEST_f_f (ceil, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
1719 #endif
1720
1721   END (ceil);
1722 }
1723
1724
1725 static void
1726 cexp_test (void)
1727 {
1728   errno = 0;
1729   FUNC(cexp) (BUILD_COMPLEX (0, 0));
1730   if (errno == ENOSYS)
1731     /* Function not implemented.  */
1732     return;
1733
1734   START (cexp);
1735
1736   TEST_c_c (cexp, plus_zero, plus_zero, 1, 0.0);
1737   TEST_c_c (cexp, minus_zero, plus_zero, 1, 0.0);
1738   TEST_c_c (cexp, plus_zero, minus_zero, 1, minus_zero);
1739   TEST_c_c (cexp, minus_zero, minus_zero, 1, minus_zero);
1740
1741   TEST_c_c (cexp, plus_infty, plus_zero, plus_infty, 0.0);
1742   TEST_c_c (cexp, plus_infty, minus_zero, plus_infty, minus_zero);
1743
1744   TEST_c_c (cexp, minus_infty, plus_zero, 0.0, 0.0);
1745   TEST_c_c (cexp, minus_infty, minus_zero, 0.0, minus_zero);
1746
1747   TEST_c_c (cexp, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1748   TEST_c_c (cexp, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1749
1750   TEST_c_c (cexp, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1751   TEST_c_c (cexp, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1752
1753   TEST_c_c (cexp, 100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1754   TEST_c_c (cexp, -100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1755
1756   TEST_c_c (cexp, 100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1757   TEST_c_c (cexp, -100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1758
1759   TEST_c_c (cexp, minus_infty, 2.0, minus_zero, 0.0);
1760   TEST_c_c (cexp, minus_infty, 4.0, minus_zero, minus_zero);
1761   TEST_c_c (cexp, plus_infty, 2.0, minus_infty, plus_infty);
1762   TEST_c_c (cexp, plus_infty, 4.0, minus_infty, minus_infty);
1763
1764   TEST_c_c (cexp, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1765   TEST_c_c (cexp, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1766
1767   TEST_c_c (cexp, minus_infty, plus_infty, 0.0, 0.0, IGNORE_ZERO_INF_SIGN);
1768   TEST_c_c (cexp, minus_infty, minus_infty, 0.0, minus_zero, IGNORE_ZERO_INF_SIGN);
1769
1770   TEST_c_c (cexp, minus_infty, nan_value, 0, 0, IGNORE_ZERO_INF_SIGN);
1771
1772   TEST_c_c (cexp, plus_infty, nan_value, plus_infty, nan_value);
1773
1774   TEST_c_c (cexp, nan_value, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1775   TEST_c_c (cexp, nan_value, 1.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1776
1777   TEST_c_c (cexp, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1778   TEST_c_c (cexp, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1779   TEST_c_c (cexp, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1780   TEST_c_c (cexp, nan_value, nan_value, nan_value, nan_value);
1781
1782   TEST_c_c (cexp, 0.75L, 1.25L, 0.667537446429131586942201977015932112L, 2.00900045494094876258347228145863909L);
1783   TEST_c_c (cexp, -2.0, -3.0, -0.13398091492954261346140525546115575L, -0.019098516261135196432576240858800925L);
1784
1785   END (cexp, complex);
1786 }
1787
1788
1789 static void
1790 cimag_test (void)
1791 {
1792   START (cimag);
1793   TEST_c_f (cimag, 1.0, 0.0, 0.0);
1794   TEST_c_f (cimag, 1.0, minus_zero, minus_zero);
1795   TEST_c_f (cimag, 1.0, nan_value, nan_value);
1796   TEST_c_f (cimag, nan_value, nan_value, nan_value);
1797   TEST_c_f (cimag, 1.0, plus_infty, plus_infty);
1798   TEST_c_f (cimag, 1.0, minus_infty, minus_infty);
1799   TEST_c_f (cimag, 2.0, 3.0, 3.0);
1800
1801   END (cimag);
1802 }
1803
1804 static void
1805 clog_test (void)
1806 {
1807   errno = 0;
1808   FUNC(clog) (BUILD_COMPLEX (-2, -3));
1809   if (errno == ENOSYS)
1810     /* Function not implemented.  */
1811     return;
1812
1813   START (clog);
1814
1815   TEST_c_c (clog, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1816   TEST_c_c (clog, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1817
1818   TEST_c_c (clog, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
1819   TEST_c_c (clog, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
1820
1821   TEST_c_c (clog, minus_infty, plus_infty, plus_infty, M_PI_34l);
1822   TEST_c_c (clog, minus_infty, minus_infty, plus_infty, -M_PI_34l);
1823
1824   TEST_c_c (clog, plus_infty, plus_infty, plus_infty, M_PI_4l);
1825   TEST_c_c (clog, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1826
1827   TEST_c_c (clog, 0, plus_infty, plus_infty, M_PI_2l);
1828   TEST_c_c (clog, 3, plus_infty, plus_infty, M_PI_2l);
1829   TEST_c_c (clog, minus_zero, plus_infty, plus_infty, M_PI_2l);
1830   TEST_c_c (clog, -3, plus_infty, plus_infty, M_PI_2l);
1831   TEST_c_c (clog, 0, minus_infty, plus_infty, -M_PI_2l);
1832   TEST_c_c (clog, 3, minus_infty, plus_infty, -M_PI_2l);
1833   TEST_c_c (clog, minus_zero, minus_infty, plus_infty, -M_PI_2l);
1834   TEST_c_c (clog, -3, minus_infty, plus_infty, -M_PI_2l);
1835
1836   TEST_c_c (clog, minus_infty, 0, plus_infty, M_PIl);
1837   TEST_c_c (clog, minus_infty, 1, plus_infty, M_PIl);
1838   TEST_c_c (clog, minus_infty, minus_zero, plus_infty, -M_PIl);
1839   TEST_c_c (clog, minus_infty, -1, plus_infty, -M_PIl);
1840
1841   TEST_c_c (clog, plus_infty, 0, plus_infty, 0.0);
1842   TEST_c_c (clog, plus_infty, 1, plus_infty, 0.0);
1843   TEST_c_c (clog, plus_infty, minus_zero, plus_infty, minus_zero);
1844   TEST_c_c (clog, plus_infty, -1, plus_infty, minus_zero);
1845
1846   TEST_c_c (clog, plus_infty, nan_value, plus_infty, nan_value);
1847   TEST_c_c (clog, minus_infty, nan_value, plus_infty, nan_value);
1848
1849   TEST_c_c (clog, nan_value, plus_infty, plus_infty, nan_value);
1850   TEST_c_c (clog, nan_value, minus_infty, plus_infty, nan_value);
1851
1852   TEST_c_c (clog, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1853   TEST_c_c (clog, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1854   TEST_c_c (clog, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1855   TEST_c_c (clog, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1856
1857   TEST_c_c (clog, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1858   TEST_c_c (clog, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1859   TEST_c_c (clog, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
1860   TEST_c_c (clog, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1861
1862   TEST_c_c (clog, nan_value, nan_value, nan_value, nan_value);
1863
1864   TEST_c_c (clog, 0.75L, 1.25L, 0.376885901188190075998919126749298416L, 1.03037682652431246378774332703115153L);
1865   TEST_c_c (clog, -2, -3, 1.2824746787307683680267437207826593L, -2.1587989303424641704769327722648368L);
1866
1867   END (clog, complex);
1868 }
1869
1870
1871 static void
1872 clog10_test (void)
1873 {
1874   errno = 0;
1875   FUNC(clog10) (BUILD_COMPLEX (0.7L, 1.2L));
1876   if (errno == ENOSYS)
1877     /* Function not implemented.  */
1878     return;
1879
1880   START (clog10);
1881
1882   TEST_c_c (clog10, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1883   TEST_c_c (clog10, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1884
1885   TEST_c_c (clog10, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
1886   TEST_c_c (clog10, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
1887
1888   TEST_c_c (clog10, minus_infty, plus_infty, plus_infty, M_PI_34_LOG10El);
1889
1890   TEST_c_c (clog10, plus_infty, plus_infty, plus_infty, M_PI4_LOG10El);
1891   TEST_c_c (clog10, plus_infty, minus_infty, plus_infty, -M_PI4_LOG10El);
1892
1893   TEST_c_c (clog10, 0, plus_infty, plus_infty, M_PI2_LOG10El);
1894   TEST_c_c (clog10, 3, plus_infty, plus_infty, M_PI2_LOG10El);
1895   TEST_c_c (clog10, minus_zero, plus_infty, plus_infty, M_PI2_LOG10El);
1896   TEST_c_c (clog10, -3, plus_infty, plus_infty, M_PI2_LOG10El);
1897   TEST_c_c (clog10, 0, minus_infty, plus_infty, -M_PI2_LOG10El);
1898   TEST_c_c (clog10, 3, minus_infty, plus_infty, -M_PI2_LOG10El);
1899   TEST_c_c (clog10, minus_zero, minus_infty, plus_infty, -M_PI2_LOG10El);
1900   TEST_c_c (clog10, -3, minus_infty, plus_infty, -M_PI2_LOG10El);
1901
1902   TEST_c_c (clog10, minus_infty, 0, plus_infty, M_PI_LOG10El);
1903   TEST_c_c (clog10, minus_infty, 1, plus_infty, M_PI_LOG10El);
1904   TEST_c_c (clog10, minus_infty, minus_zero, plus_infty, -M_PI_LOG10El);
1905   TEST_c_c (clog10, minus_infty, -1, plus_infty, -M_PI_LOG10El);
1906
1907   TEST_c_c (clog10, plus_infty, 0, plus_infty, 0.0);
1908   TEST_c_c (clog10, plus_infty, 1, plus_infty, 0.0);
1909   TEST_c_c (clog10, plus_infty, minus_zero, plus_infty, minus_zero);
1910   TEST_c_c (clog10, plus_infty, -1, plus_infty, minus_zero);
1911
1912   TEST_c_c (clog10, plus_infty, nan_value, plus_infty, nan_value);
1913   TEST_c_c (clog10, minus_infty, nan_value, plus_infty, nan_value);
1914
1915   TEST_c_c (clog10, nan_value, plus_infty, plus_infty, nan_value);
1916   TEST_c_c (clog10, nan_value, minus_infty, plus_infty, nan_value);
1917
1918   TEST_c_c (clog10, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1919   TEST_c_c (clog10, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1920   TEST_c_c (clog10, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1921   TEST_c_c (clog10, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1922
1923   TEST_c_c (clog10, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1924   TEST_c_c (clog10, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1925   TEST_c_c (clog10, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
1926   TEST_c_c (clog10, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1927
1928   TEST_c_c (clog10, nan_value, nan_value, nan_value, nan_value);
1929
1930   TEST_c_c (clog10, 0.75L, 1.25L, 0.163679467193165171449476605077428975L, 0.447486970040493067069984724340855636L);
1931   TEST_c_c (clog10, -2, -3, 0.556971676153418384603252578971164214L, -0.937554462986374708541507952140189646L);
1932
1933   END (clog10, complex);
1934 }
1935
1936
1937 static void
1938 conj_test (void)
1939 {
1940   START (conj);
1941   TEST_c_c (conj, 0.0, 0.0, 0.0, minus_zero);
1942   TEST_c_c (conj, 0.0, minus_zero, 0.0, 0.0);
1943   TEST_c_c (conj, nan_value, nan_value, nan_value, nan_value);
1944   TEST_c_c (conj, plus_infty, minus_infty, plus_infty, plus_infty);
1945   TEST_c_c (conj, plus_infty, plus_infty, plus_infty, minus_infty);
1946   TEST_c_c (conj, 1.0, 2.0, 1.0, -2.0);
1947   TEST_c_c (conj, 3.0, -4.0, 3.0, 4.0);
1948
1949   END (conj, complex);
1950 }
1951
1952
1953 static void
1954 copysign_test (void)
1955 {
1956   START (copysign);
1957
1958   TEST_ff_f (copysign, 0, 4, 0);
1959   TEST_ff_f (copysign, 0, -4, minus_zero);
1960   TEST_ff_f (copysign, minus_zero, 4, 0);
1961   TEST_ff_f (copysign, minus_zero, -4, minus_zero);
1962
1963   TEST_ff_f (copysign, plus_infty, 0, plus_infty);
1964   TEST_ff_f (copysign, plus_infty, minus_zero, minus_infty);
1965   TEST_ff_f (copysign, minus_infty, 0, plus_infty);
1966   TEST_ff_f (copysign, minus_infty, minus_zero, minus_infty);
1967
1968   TEST_ff_f (copysign, 0, plus_infty, 0);
1969   TEST_ff_f (copysign, 0, minus_zero, minus_zero);
1970   TEST_ff_f (copysign, minus_zero, plus_infty, 0);
1971   TEST_ff_f (copysign, minus_zero, minus_zero, minus_zero);
1972
1973   /* XXX More correctly we would have to check the sign of the NaN.  */
1974   TEST_ff_f (copysign, nan_value, 0, nan_value);
1975   TEST_ff_f (copysign, nan_value, minus_zero, nan_value);
1976   TEST_ff_f (copysign, -nan_value, 0, nan_value);
1977   TEST_ff_f (copysign, -nan_value, minus_zero, nan_value);
1978
1979   END (copysign);
1980 }
1981
1982
1983 static void
1984 cos_test (void)
1985 {
1986   errno = 0;
1987   FUNC(cos) (0);
1988   if (errno == ENOSYS)
1989     /* Function not implemented.  */
1990     return;
1991
1992   START (cos);
1993
1994   TEST_f_f (cos, 0, 1);
1995   TEST_f_f (cos, minus_zero, 1);
1996   TEST_f_f (cos, plus_infty, nan_value, INVALID_EXCEPTION);
1997   TEST_f_f (cos, minus_infty, nan_value, INVALID_EXCEPTION);
1998   TEST_f_f (cos, nan_value, nan_value);
1999
2000   TEST_f_f (cos, M_PI_6l * 2.0, 0.5);
2001   TEST_f_f (cos, M_PI_6l * 4.0, -0.5);
2002   TEST_f_f (cos, M_PI_2l, 0);
2003
2004   TEST_f_f (cos, 0.75L, 0.731688868873820886311838753000084544L);
2005
2006 #ifdef TEST_DOUBLE
2007   TEST_f_f (cos, 0.80190127184058835, 0.69534156199418473);
2008 #endif
2009
2010   END (cos);
2011 }
2012
2013
2014 static void
2015 cosh_test (void)
2016 {
2017   errno = 0;
2018   FUNC(cosh) (0.7L);
2019   if (errno == ENOSYS)
2020     /* Function not implemented.  */
2021     return;
2022
2023   START (cosh);
2024   TEST_f_f (cosh, 0, 1);
2025   TEST_f_f (cosh, minus_zero, 1);
2026
2027 #ifndef TEST_INLINE
2028   TEST_f_f (cosh, plus_infty, plus_infty);
2029   TEST_f_f (cosh, minus_infty, plus_infty);
2030 #endif
2031   TEST_f_f (cosh, nan_value, nan_value);
2032
2033   TEST_f_f (cosh, 0.75L, 1.29468328467684468784170818539018176L);
2034
2035   END (cosh);
2036 }
2037
2038
2039 static void
2040 cpow_test (void)
2041 {
2042   errno = 0;
2043   FUNC(cpow) (BUILD_COMPLEX (1, 0), BUILD_COMPLEX (0, 0));
2044   if (errno == ENOSYS)
2045     /* Function not implemented.  */
2046     return;
2047
2048   START (cpow);
2049
2050   TEST_cc_c (cpow, 1, 0, 0, 0, 1.0, 0.0);
2051   TEST_cc_c (cpow, 2, 0, 10, 0, 1024.0, 0.0);
2052
2053   TEST_cc_c (cpow, M_El, 0, 0, 2 * M_PIl, 1.0, 0.0);
2054   TEST_cc_c (cpow, 2, 3, 4, 0, -119.0, -120.0);
2055
2056   TEST_cc_c (cpow, nan_value, nan_value, nan_value, nan_value, nan_value, nan_value);
2057
2058   TEST_cc_c (cpow, 0.75L, 1.25L, 0.75L, 1.25L, 0.117506293914473555420279832210420483L, 0.346552747708338676483025352060418001L);
2059   TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 1.0L, 0.0846958290317209430433805274189191353L, 0.513285749182902449043287190519090481L);
2060   TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 0.0L, 0.75L, 1.25L);
2061   TEST_cc_c (cpow, 0.75L, 1.25L, 0.0L, 1.0L, 0.331825439177608832276067945276730566L, 0.131338600281188544930936345230903032L);
2062
2063   END (cpow, complex);
2064 }
2065
2066
2067 static void
2068 cproj_test (void)
2069 {
2070   START (cproj);
2071   TEST_c_c (cproj, 0.0, 0.0, 0.0, 0.0);
2072   TEST_c_c (cproj, minus_zero, minus_zero, minus_zero, minus_zero);
2073   TEST_c_c (cproj, 0.0, minus_zero, 0.0, minus_zero);
2074   TEST_c_c (cproj, minus_zero, 0.0, minus_zero, 0.0);
2075
2076   TEST_c_c (cproj, nan_value, nan_value, nan_value, nan_value);
2077
2078   TEST_c_c (cproj, plus_infty, plus_infty, plus_infty, 0.0);
2079   TEST_c_c (cproj, plus_infty, minus_infty, plus_infty, minus_zero);
2080   TEST_c_c (cproj, minus_infty, plus_infty, plus_infty, 0.0);
2081   TEST_c_c (cproj, minus_infty, minus_infty, plus_infty, minus_zero);
2082
2083   TEST_c_c (cproj, 1.0, 0.0, 1.0, 0.0);
2084   TEST_c_c (cproj, 2.0, 3.0, 0.2857142857142857142857142857142857L, 0.42857142857142857142857142857142855L);
2085
2086   END (cproj, complex);
2087 }
2088
2089
2090 static void
2091 creal_test (void)
2092 {
2093   START (creal);
2094   TEST_c_f (creal, 0.0, 1.0, 0.0);
2095   TEST_c_f (creal, minus_zero, 1.0, minus_zero);
2096   TEST_c_f (creal, nan_value, 1.0, nan_value);
2097   TEST_c_f (creal, nan_value, nan_value, nan_value);
2098   TEST_c_f (creal, plus_infty, 1.0, plus_infty);
2099   TEST_c_f (creal, minus_infty, 1.0, minus_infty);
2100   TEST_c_f (creal, 2.0, 3.0, 2.0);
2101
2102   END (creal);
2103 }
2104
2105 static void
2106 csin_test (void)
2107 {
2108   errno = 0;
2109   FUNC(csin) (BUILD_COMPLEX (0.7L, 1.2L));
2110   if (errno == ENOSYS)
2111     /* Function not implemented.  */
2112     return;
2113
2114   START (csin);
2115
2116   TEST_c_c (csin, 0.0, 0.0, 0.0, 0.0);
2117   TEST_c_c (csin, minus_zero, 0.0, minus_zero, 0.0);
2118   TEST_c_c (csin, 0.0, minus_zero, 0, minus_zero);
2119   TEST_c_c (csin, minus_zero, minus_zero, minus_zero, minus_zero);
2120
2121   TEST_c_c (csin, 0.0, plus_infty, 0.0, plus_infty);
2122   TEST_c_c (csin, minus_zero, plus_infty, minus_zero, plus_infty);
2123   TEST_c_c (csin, 0.0, minus_infty, 0.0, minus_infty);
2124   TEST_c_c (csin, minus_zero, minus_infty, minus_zero, minus_infty);
2125
2126   TEST_c_c (csin, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2127   TEST_c_c (csin, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2128   TEST_c_c (csin, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2129   TEST_c_c (csin, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2130
2131   TEST_c_c (csin, plus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2132   TEST_c_c (csin, minus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2133   TEST_c_c (csin, plus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2134   TEST_c_c (csin, minus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2135
2136   TEST_c_c (csin, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
2137   TEST_c_c (csin, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
2138   TEST_c_c (csin, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
2139   TEST_c_c (csin, minus_infty, -6.75,  nan_value, nan_value, INVALID_EXCEPTION);
2140
2141   TEST_c_c (csin, 4.625, plus_infty, minus_infty, minus_infty);
2142   TEST_c_c (csin, 4.625, minus_infty, minus_infty, plus_infty);
2143   TEST_c_c (csin, -4.625, plus_infty, plus_infty, minus_infty);
2144   TEST_c_c (csin, -4.625, minus_infty, plus_infty, plus_infty);
2145
2146   TEST_c_c (csin, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2147   TEST_c_c (csin, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2148
2149   TEST_c_c (csin, nan_value, plus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2150   TEST_c_c (csin, nan_value, minus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2151
2152   TEST_c_c (csin, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2153   TEST_c_c (csin, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2154
2155   TEST_c_c (csin, 0.0, nan_value, 0.0, nan_value);
2156   TEST_c_c (csin, minus_zero, nan_value, minus_zero, nan_value);
2157
2158   TEST_c_c (csin, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2159   TEST_c_c (csin, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2160
2161   TEST_c_c (csin, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2162   TEST_c_c (csin, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2163
2164   TEST_c_c (csin, nan_value, nan_value, nan_value, nan_value);
2165
2166   TEST_c_c (csin, 0.75L, 1.25L, 1.28722291002649188575873510790565441L, 1.17210635989270256101081285116138863L);
2167   TEST_c_c (csin, -2, -3, -9.15449914691142957346729954460983256L, 4.16890695996656435075481305885375484L);
2168
2169   END (csin, complex);
2170 }
2171
2172
2173 static void
2174 csinh_test (void)
2175 {
2176   errno = 0;
2177   FUNC(csinh) (BUILD_COMPLEX (0.7L, 1.2L));
2178   if (errno == ENOSYS)
2179     /* Function not implemented.  */
2180     return;
2181
2182   START (csinh);
2183
2184   TEST_c_c (csinh, 0.0, 0.0, 0.0, 0.0);
2185   TEST_c_c (csinh, minus_zero, 0.0, minus_zero, 0.0);
2186   TEST_c_c (csinh, 0.0, minus_zero, 0.0, minus_zero);
2187   TEST_c_c (csinh, minus_zero, minus_zero, minus_zero, minus_zero);
2188
2189   TEST_c_c (csinh, 0.0, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2190   TEST_c_c (csinh, minus_zero, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2191   TEST_c_c (csinh, 0.0, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2192   TEST_c_c (csinh, minus_zero, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2193
2194   TEST_c_c (csinh, plus_infty, 0.0, plus_infty, 0.0);
2195   TEST_c_c (csinh, minus_infty, 0.0, minus_infty, 0.0);
2196   TEST_c_c (csinh, plus_infty, minus_zero, plus_infty, minus_zero);
2197   TEST_c_c (csinh, minus_infty, minus_zero, minus_infty, minus_zero);
2198
2199   TEST_c_c (csinh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2200   TEST_c_c (csinh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2201   TEST_c_c (csinh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2202   TEST_c_c (csinh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2203
2204   TEST_c_c (csinh, plus_infty, 4.625, minus_infty, minus_infty);
2205   TEST_c_c (csinh, minus_infty, 4.625, plus_infty, minus_infty);
2206   TEST_c_c (csinh, plus_infty, -4.625, minus_infty, plus_infty);
2207   TEST_c_c (csinh, minus_infty, -4.625, plus_infty, plus_infty);
2208
2209   TEST_c_c (csinh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2210   TEST_c_c (csinh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2211   TEST_c_c (csinh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2212   TEST_c_c (csinh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2213
2214   TEST_c_c (csinh, 0.0, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
2215   TEST_c_c (csinh, minus_zero, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
2216
2217   TEST_c_c (csinh, plus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
2218   TEST_c_c (csinh, minus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
2219
2220   TEST_c_c (csinh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2221   TEST_c_c (csinh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2222
2223   TEST_c_c (csinh, nan_value, 0.0, nan_value, 0.0);
2224   TEST_c_c (csinh, nan_value, minus_zero, nan_value, minus_zero);
2225
2226   TEST_c_c (csinh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2227   TEST_c_c (csinh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2228
2229   TEST_c_c (csinh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2230   TEST_c_c (csinh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2231
2232   TEST_c_c (csinh, nan_value, nan_value, nan_value, nan_value);
2233
2234   TEST_c_c (csinh, 0.75L, 1.25L, 0.259294854551162779153349830618433028L, 1.22863452409509552219214606515777594L);
2235   TEST_c_c (csinh, -2, -3, 3.59056458998577995201256544779481679L, -0.530921086248519805267040090660676560L);
2236
2237   END (csinh, complex);
2238 }
2239
2240
2241 static void
2242 csqrt_test (void)
2243 {
2244   errno = 0;
2245   FUNC(csqrt) (BUILD_COMPLEX (-1, 0));
2246   if (errno == ENOSYS)
2247     /* Function not implemented.  */
2248     return;
2249
2250   START (csqrt);
2251
2252   TEST_c_c (csqrt, 0, 0, 0.0, 0.0);
2253   TEST_c_c (csqrt, 0, minus_zero, 0, minus_zero);
2254   TEST_c_c (csqrt, minus_zero, 0, 0.0, 0.0);
2255   TEST_c_c (csqrt, minus_zero, minus_zero, 0.0, minus_zero);
2256
2257   TEST_c_c (csqrt, minus_infty, 0, 0.0, plus_infty);
2258   TEST_c_c (csqrt, minus_infty, 6, 0.0, plus_infty);
2259   TEST_c_c (csqrt, minus_infty, minus_zero, 0.0, minus_infty);
2260   TEST_c_c (csqrt, minus_infty, -6, 0.0, minus_infty);
2261
2262   TEST_c_c (csqrt, plus_infty, 0, plus_infty, 0.0);
2263   TEST_c_c (csqrt, plus_infty, 6, plus_infty, 0.0);
2264   TEST_c_c (csqrt, plus_infty, minus_zero, plus_infty, minus_zero);
2265   TEST_c_c (csqrt, plus_infty, -6, plus_infty, minus_zero);
2266
2267   TEST_c_c (csqrt, 0, plus_infty, plus_infty, plus_infty);
2268   TEST_c_c (csqrt, 4, plus_infty, plus_infty, plus_infty);
2269   TEST_c_c (csqrt, plus_infty, plus_infty, plus_infty, plus_infty);
2270   TEST_c_c (csqrt, minus_zero, plus_infty, plus_infty, plus_infty);
2271   TEST_c_c (csqrt, -4, plus_infty, plus_infty, plus_infty);
2272   TEST_c_c (csqrt, minus_infty, plus_infty, plus_infty, plus_infty);
2273   TEST_c_c (csqrt, 0, minus_infty, plus_infty, minus_infty);
2274   TEST_c_c (csqrt, 4, minus_infty, plus_infty, minus_infty);
2275   TEST_c_c (csqrt, plus_infty, minus_infty, plus_infty, minus_infty);
2276   TEST_c_c (csqrt, minus_zero, minus_infty, plus_infty, minus_infty);
2277   TEST_c_c (csqrt, -4, minus_infty, plus_infty, minus_infty);
2278   TEST_c_c (csqrt, minus_infty, minus_infty, plus_infty, minus_infty);
2279
2280   TEST_c_c (csqrt, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2281
2282   TEST_c_c (csqrt, plus_infty, nan_value, plus_infty, nan_value);
2283
2284   TEST_c_c (csqrt, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2285   TEST_c_c (csqrt, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2286   TEST_c_c (csqrt, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2287   TEST_c_c (csqrt, -1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2288
2289   TEST_c_c (csqrt, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2290   TEST_c_c (csqrt, nan_value, 8, nan_value, nan_value, INVALID_EXCEPTION_OK);
2291   TEST_c_c (csqrt, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2292   TEST_c_c (csqrt, nan_value, -8, nan_value, nan_value, INVALID_EXCEPTION_OK);
2293
2294   TEST_c_c (csqrt, nan_value, nan_value, nan_value, nan_value);
2295
2296   TEST_c_c (csqrt, 16.0, -30.0, 5.0, -3.0);
2297   TEST_c_c (csqrt, -1, 0, 0.0, 1.0);
2298   TEST_c_c (csqrt, 0, 2, 1.0, 1.0);
2299   TEST_c_c (csqrt, 119, 120, 12.0, 5.0);
2300   TEST_c_c (csqrt, 0.75L, 1.25L, 1.05065169626078392338656675760808326L, 0.594868882070379067881984030639932657L);
2301   TEST_c_c (csqrt, -2, -3, 0.89597747612983812471573375529004348L, -1.6741492280355400404480393008490519L);
2302   TEST_c_c (csqrt, -2, 3, 0.89597747612983812471573375529004348L, 1.6741492280355400404480393008490519L);
2303   /* Principal square root should be returned (i.e., non-negative real
2304      part).  */
2305   TEST_c_c (csqrt, 0, -1, M_SQRT_2_2, -M_SQRT_2_2);
2306
2307   END (csqrt, complex);
2308 }
2309
2310 static void
2311 ctan_test (void)
2312 {
2313   errno = 0;
2314   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
2315   if (errno == ENOSYS)
2316     /* Function not implemented.  */
2317     return;
2318
2319   START (ctan);
2320
2321   TEST_c_c (ctan, 0, 0, 0.0, 0.0);
2322   TEST_c_c (ctan, 0, minus_zero, 0.0, minus_zero);
2323   TEST_c_c (ctan, minus_zero, 0, minus_zero, 0.0);
2324   TEST_c_c (ctan, minus_zero, minus_zero, minus_zero, minus_zero);
2325
2326   TEST_c_c (ctan, 0, plus_infty, 0.0, 1.0);
2327   TEST_c_c (ctan, 1, plus_infty, 0.0, 1.0);
2328   TEST_c_c (ctan, minus_zero, plus_infty, minus_zero, 1.0);
2329   TEST_c_c (ctan, -1, plus_infty, minus_zero, 1.0);
2330
2331   TEST_c_c (ctan, 0, minus_infty, 0.0, -1.0);
2332   TEST_c_c (ctan, 1, minus_infty, 0.0, -1.0);
2333   TEST_c_c (ctan, minus_zero, minus_infty, minus_zero, -1.0);
2334   TEST_c_c (ctan, -1, minus_infty, minus_zero, -1.0);
2335
2336   TEST_c_c (ctan, plus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
2337   TEST_c_c (ctan, plus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
2338   TEST_c_c (ctan, minus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
2339   TEST_c_c (ctan, minus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
2340   TEST_c_c (ctan, plus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
2341   TEST_c_c (ctan, plus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
2342   TEST_c_c (ctan, minus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
2343   TEST_c_c (ctan, minus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
2344
2345   TEST_c_c (ctan, nan_value, plus_infty, 0.0, 1.0, IGNORE_ZERO_INF_SIGN);
2346   TEST_c_c (ctan, nan_value, minus_infty, 0.0, -1.0, IGNORE_ZERO_INF_SIGN);
2347
2348   TEST_c_c (ctan, 0, nan_value, 0.0, nan_value);
2349   TEST_c_c (ctan, minus_zero, nan_value, minus_zero, nan_value);
2350
2351   TEST_c_c (ctan, 0.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2352   TEST_c_c (ctan, -4.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2353
2354   TEST_c_c (ctan, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2355   TEST_c_c (ctan, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2356   TEST_c_c (ctan, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2357   TEST_c_c (ctan, nan_value, -0.25, nan_value, nan_value, INVALID_EXCEPTION_OK);
2358
2359   TEST_c_c (ctan, nan_value, nan_value, nan_value, nan_value);
2360
2361   TEST_c_c (ctan, 0.75L, 1.25L, 0.160807785916206426725166058173438663L, 0.975363285031235646193581759755216379L);
2362   TEST_c_c (ctan, -2, -3, 0.376402564150424829275122113032269084e-2L, -1.00323862735360980144635859782192726L);
2363
2364   END (ctan, complex);
2365 }
2366
2367
2368 static void
2369 ctanh_test (void)
2370 {
2371   errno = 0;
2372   FUNC(ctanh) (BUILD_COMPLEX (0, 0));
2373   if (errno == ENOSYS)
2374     /* Function not implemented.  */
2375     return;
2376
2377   START (ctanh);
2378
2379   TEST_c_c (ctanh, 0, 0, 0.0, 0.0);
2380   TEST_c_c (ctanh, 0, minus_zero, 0.0, minus_zero);
2381   TEST_c_c (ctanh, minus_zero, 0, minus_zero, 0.0);
2382   TEST_c_c (ctanh, minus_zero, minus_zero, minus_zero, minus_zero);
2383
2384   TEST_c_c (ctanh, plus_infty, 0, 1.0, 0.0);
2385   TEST_c_c (ctanh, plus_infty, 1, 1.0, 0.0);
2386   TEST_c_c (ctanh, plus_infty, minus_zero, 1.0, minus_zero);
2387   TEST_c_c (ctanh, plus_infty, -1, 1.0, minus_zero);
2388   TEST_c_c (ctanh, minus_infty, 0, -1.0, 0.0);
2389   TEST_c_c (ctanh, minus_infty, 1, -1.0, 0.0);
2390   TEST_c_c (ctanh, minus_infty, minus_zero, -1.0, minus_zero);
2391   TEST_c_c (ctanh, minus_infty, -1, -1.0, minus_zero);
2392
2393   TEST_c_c (ctanh, 0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2394   TEST_c_c (ctanh, 2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2395   TEST_c_c (ctanh, 0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2396   TEST_c_c (ctanh, 2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2397   TEST_c_c (ctanh, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2398   TEST_c_c (ctanh, -2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2399   TEST_c_c (ctanh, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2400   TEST_c_c (ctanh, -2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2401
2402   TEST_c_c (ctanh, plus_infty, nan_value, 1.0, 0.0, IGNORE_ZERO_INF_SIGN);
2403   TEST_c_c (ctanh, minus_infty, nan_value, -1.0, 0.0, IGNORE_ZERO_INF_SIGN);
2404
2405   TEST_c_c (ctanh, nan_value, 0, nan_value, 0.0);
2406   TEST_c_c (ctanh, nan_value, minus_zero, nan_value, minus_zero);
2407
2408   TEST_c_c (ctanh, nan_value, 0.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2409   TEST_c_c (ctanh, nan_value, -4.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2410
2411   TEST_c_c (ctanh, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2412   TEST_c_c (ctanh, 5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2413   TEST_c_c (ctanh, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2414   TEST_c_c (ctanh, -0.25, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2415
2416   TEST_c_c (ctanh, nan_value, nan_value, nan_value, nan_value);
2417
2418   TEST_c_c (ctanh, 0, M_PI_4l, 0.0, 1.0);
2419
2420   TEST_c_c (ctanh, 0.75L, 1.25L, 1.37260757053378320258048606571226857L, 0.385795952609750664177596760720790220L);
2421   TEST_c_c (ctanh, -2, -3, -0.965385879022133124278480269394560686L, 0.988437503832249372031403430350121098e-2L);
2422
2423   END (ctanh, complex);
2424 }
2425
2426
2427 static void
2428 erf_test (void)
2429 {
2430   errno = 0;
2431   FUNC(erf) (0);
2432   if (errno == ENOSYS)
2433     /* Function not implemented.  */
2434     return;
2435
2436   START (erf);
2437
2438   TEST_f_f (erf, 0, 0);
2439   TEST_f_f (erf, minus_zero, minus_zero);
2440   TEST_f_f (erf, plus_infty, 1);
2441   TEST_f_f (erf, minus_infty, -1);
2442   TEST_f_f (erf, nan_value, nan_value);
2443
2444   TEST_f_f (erf, 0.125L, 0.140316204801333817393029446521623398L);
2445   TEST_f_f (erf, 0.75L, 0.711155633653515131598937834591410777L);
2446   TEST_f_f (erf, 1.25L, 0.922900128256458230136523481197281140L);
2447   TEST_f_f (erf, 2.0L, 0.995322265018952734162069256367252929L);
2448   TEST_f_f (erf, 4.125L, 0.999999994576599200434933994687765914L);
2449   TEST_f_f (erf, 27.0L, 1.0L);
2450
2451   END (erf);
2452 }
2453
2454
2455 static void
2456 erfc_test (void)
2457 {
2458   errno = 0;
2459   FUNC(erfc) (0);
2460   if (errno == ENOSYS)
2461     /* Function not implemented.  */
2462     return;
2463
2464   START (erfc);
2465
2466   TEST_f_f (erfc, plus_infty, 0.0);
2467   TEST_f_f (erfc, minus_infty, 2.0);
2468   TEST_f_f (erfc, 0.0, 1.0);
2469   TEST_f_f (erfc, minus_zero, 1.0);
2470   TEST_f_f (erfc, nan_value, nan_value);
2471
2472   TEST_f_f (erfc, 0.125L, 0.859683795198666182606970553478376602L);
2473   TEST_f_f (erfc, 0.75L, 0.288844366346484868401062165408589223L);
2474   TEST_f_f (erfc, 1.25L, 0.0770998717435417698634765188027188596L);
2475   TEST_f_f (erfc, 2.0L, 0.00467773498104726583793074363274707139L);
2476   TEST_f_f (erfc, 4.125L, 0.542340079956506600531223408575531062e-8L);
2477 #ifdef TEST_LDOUBLE
2478   /* The result can only be represented in long double.  */
2479 # if LDBL_MIN_10_EXP < -319
2480   TEST_f_f (erfc, 27.0L, 0.523704892378925568501606768284954709e-318L);
2481 # endif
2482 #endif
2483
2484   END (erfc);
2485 }
2486
2487
2488 static void
2489 exp_test (void)
2490 {
2491   errno = 0;
2492   FUNC(exp) (0);
2493   if (errno == ENOSYS)
2494     /* Function not implemented.  */
2495     return;
2496
2497   START (exp);
2498
2499   TEST_f_f (exp, 0, 1);
2500   TEST_f_f (exp, minus_zero, 1);
2501
2502 #ifndef TEST_INLINE
2503   TEST_f_f (exp, plus_infty, plus_infty);
2504   TEST_f_f (exp, minus_infty, 0);
2505 #endif
2506   TEST_f_f (exp, nan_value, nan_value);
2507   TEST_f_f (exp, 1, M_El);
2508
2509   TEST_f_f (exp, 2, M_E2l);
2510   TEST_f_f (exp, 3, M_E3l);
2511   TEST_f_f (exp, 0.75L, 2.11700001661267466854536981983709561L);
2512   TEST_f_f (exp, 50.0L, 5184705528587072464087.45332293348538L);
2513   TEST_f_f (exp, 88.72269439697265625L, 3.40233126623160774937554134772290447915e38L);
2514 #if defined TEST_LDOUBLE && __LDBL_MAX_EXP__ > 1024
2515   /* The result can only be represented in sane long double.  */
2516   TEST_f_f (exp, 1000.0L, 0.197007111401704699388887935224332313e435L);
2517 #endif
2518
2519   END (exp);
2520 }
2521
2522
2523 static void
2524 exp10_test (void)
2525 {
2526   errno = 0;
2527   FUNC(exp10) (0);
2528   if (errno == ENOSYS)
2529     /* Function not implemented.  */
2530     return;
2531
2532   START (exp10);
2533
2534   TEST_f_f (exp10, 0, 1);
2535   TEST_f_f (exp10, minus_zero, 1);
2536
2537   TEST_f_f (exp10, plus_infty, plus_infty);
2538   TEST_f_f (exp10, minus_infty, 0);
2539   TEST_f_f (exp10, nan_value, nan_value);
2540   TEST_f_f (exp10, 3, 1000);
2541   TEST_f_f (exp10, -1, 0.1L);
2542   TEST_f_f (exp10, 1e6, plus_infty);
2543   TEST_f_f (exp10, -1e6, 0);
2544   TEST_f_f (exp10, 0.75L, 5.62341325190349080394951039776481231L);
2545
2546   END (exp10);
2547 }
2548
2549
2550 static void
2551 exp2_test (void)
2552 {
2553   errno = 0;
2554   FUNC(exp2) (0);
2555   if (errno == ENOSYS)
2556     /* Function not implemented.  */
2557     return;
2558
2559   START (exp2);
2560
2561   TEST_f_f (exp2, 0, 1);
2562   TEST_f_f (exp2, minus_zero, 1);
2563   TEST_f_f (exp2, plus_infty, plus_infty);
2564   TEST_f_f (exp2, minus_infty, 0);
2565   TEST_f_f (exp2, nan_value, nan_value);
2566
2567   TEST_f_f (exp2, 10, 1024);
2568   TEST_f_f (exp2, -1, 0.5);
2569   TEST_f_f (exp2, 1e6, plus_infty);
2570   TEST_f_f (exp2, -1e6, 0);
2571   TEST_f_f (exp2, 0.75L, 1.68179283050742908606225095246642979L);
2572
2573   END (exp2);
2574 }
2575
2576
2577 static void
2578 expm1_test (void)
2579 {
2580   errno = 0;
2581   FUNC(expm1) (0);
2582   if (errno == ENOSYS)
2583     /* Function not implemented.  */
2584     return;
2585
2586   START (expm1);
2587
2588   TEST_f_f (expm1, 0, 0);
2589   TEST_f_f (expm1, minus_zero, minus_zero);
2590
2591 #ifndef TEST_INLINE
2592   TEST_f_f (expm1, plus_infty, plus_infty);
2593   TEST_f_f (expm1, minus_infty, -1);
2594 #endif
2595   TEST_f_f (expm1, nan_value, nan_value);
2596
2597   TEST_f_f (expm1, 1, M_El - 1.0);
2598   TEST_f_f (expm1, 0.75L, 1.11700001661267466854536981983709561L);
2599
2600   END (expm1);
2601 }
2602
2603
2604 static void
2605 fabs_test (void)
2606 {
2607   START (fabs);
2608
2609   TEST_f_f (fabs, 0, 0);
2610   TEST_f_f (fabs, minus_zero, 0);
2611
2612   TEST_f_f (fabs, plus_infty, plus_infty);
2613   TEST_f_f (fabs, minus_infty, plus_infty);
2614   TEST_f_f (fabs, nan_value, nan_value);
2615
2616   TEST_f_f (fabs, 38.0, 38.0);
2617   TEST_f_f (fabs, -M_El, M_El);
2618
2619   END (fabs);
2620 }
2621
2622
2623 static void
2624 fdim_test (void)
2625 {
2626   START (fdim);
2627
2628   TEST_ff_f (fdim, 0, 0, 0);
2629   TEST_ff_f (fdim, 9, 0, 9);
2630   TEST_ff_f (fdim, 0, 9, 0);
2631   TEST_ff_f (fdim, -9, 0, 0);
2632   TEST_ff_f (fdim, 0, -9, 9);
2633
2634   TEST_ff_f (fdim, plus_infty, 9, plus_infty);
2635   TEST_ff_f (fdim, plus_infty, -9, plus_infty);
2636   TEST_ff_f (fdim, minus_infty, 9, 0);
2637   TEST_ff_f (fdim, minus_infty, -9, 0);
2638   TEST_ff_f (fdim, 9, minus_infty, plus_infty);
2639   TEST_ff_f (fdim, -9, minus_infty, plus_infty);
2640   TEST_ff_f (fdim, 9, plus_infty, 0);
2641   TEST_ff_f (fdim, -9, plus_infty, 0);
2642
2643   TEST_ff_f (fdim, 0, nan_value, nan_value);
2644   TEST_ff_f (fdim, 9, nan_value, nan_value);
2645   TEST_ff_f (fdim, -9, nan_value, nan_value);
2646   TEST_ff_f (fdim, nan_value, 9, nan_value);
2647   TEST_ff_f (fdim, nan_value, -9, nan_value);
2648   TEST_ff_f (fdim, plus_infty, nan_value, nan_value);
2649   TEST_ff_f (fdim, minus_infty, nan_value, nan_value);
2650   TEST_ff_f (fdim, nan_value, plus_infty, nan_value);
2651   TEST_ff_f (fdim, nan_value, minus_infty, nan_value);
2652   TEST_ff_f (fdim, nan_value, nan_value, nan_value);
2653
2654   TEST_ff_f (fdim, plus_infty, plus_infty, 0);
2655
2656   END (fdim);
2657 }
2658
2659
2660 static void
2661 floor_test (void)
2662 {
2663   START (floor);
2664
2665   TEST_f_f (floor, 0.0, 0.0);
2666   TEST_f_f (floor, minus_zero, minus_zero);
2667   TEST_f_f (floor, plus_infty, plus_infty);
2668   TEST_f_f (floor, minus_infty, minus_infty);
2669   TEST_f_f (floor, nan_value, nan_value);
2670
2671   TEST_f_f (floor, M_PIl, 3.0);
2672   TEST_f_f (floor, -M_PIl, -4.0);
2673
2674   TEST_f_f (floor, 0.1, 0.0);
2675   TEST_f_f (floor, 0.25, 0.0);
2676   TEST_f_f (floor, 0.625, 0.0);
2677   TEST_f_f (floor, -0.1, -1.0);
2678   TEST_f_f (floor, -0.25, -1.0);
2679   TEST_f_f (floor, -0.625, -1.0);
2680
2681 #ifdef TEST_LDOUBLE
2682   /* The result can only be represented in long double.  */
2683   TEST_f_f (floor, 4503599627370495.5L, 4503599627370495.0L);
2684   TEST_f_f (floor, 4503599627370496.25L, 4503599627370496.0L);
2685   TEST_f_f (floor, 4503599627370496.5L, 4503599627370496.0L);
2686   TEST_f_f (floor, 4503599627370496.75L, 4503599627370496.0L);
2687   TEST_f_f (floor, 4503599627370497.5L, 4503599627370497.0L);
2688 # if LDBL_MANT_DIG > 100
2689   TEST_f_f (floor, 4503599627370494.5000000000001L, 4503599627370494.0L);
2690   TEST_f_f (floor, 4503599627370495.5000000000001L, 4503599627370495.0L);
2691   TEST_f_f (floor, 4503599627370496.5000000000001L, 4503599627370496.0L);
2692 # endif
2693
2694   TEST_f_f (floor, -4503599627370495.5L, -4503599627370496.0L);
2695   TEST_f_f (floor, -4503599627370496.25L, -4503599627370497.0L);
2696   TEST_f_f (floor, -4503599627370496.5L, -4503599627370497.0L);
2697   TEST_f_f (floor, -4503599627370496.75L, -4503599627370497.0L);
2698   TEST_f_f (floor, -4503599627370497.5L, -4503599627370498.0L);
2699 # if LDBL_MANT_DIG > 100
2700   TEST_f_f (floor, -4503599627370494.5000000000001L, -4503599627370495.0L);
2701   TEST_f_f (floor, -4503599627370495.5000000000001L, -4503599627370496.0L);
2702   TEST_f_f (floor, -4503599627370496.5000000000001L, -4503599627370497.0L);
2703 # endif
2704
2705   TEST_f_f (floor, 9007199254740991.5L, 9007199254740991.0L);
2706   TEST_f_f (floor, 9007199254740992.25L, 9007199254740992.0L);
2707   TEST_f_f (floor, 9007199254740992.5L, 9007199254740992.0L);
2708   TEST_f_f (floor, 9007199254740992.75L, 9007199254740992.0L);
2709   TEST_f_f (floor, 9007199254740993.5L, 9007199254740993.0L);
2710
2711 # if LDBL_MANT_DIG > 100
2712   TEST_f_f (floor, 9007199254740991.0000000000001L, 9007199254740991.0L);
2713   TEST_f_f (floor, 9007199254740992.0000000000001L, 9007199254740992.0L);
2714   TEST_f_f (floor, 9007199254740993.0000000000001L, 9007199254740993.0L);
2715   TEST_f_f (floor, 9007199254740991.5000000000001L, 9007199254740991.0L);
2716   TEST_f_f (floor, 9007199254740992.5000000000001L, 9007199254740992.0L);
2717   TEST_f_f (floor, 9007199254740993.5000000000001L, 9007199254740993.0L);
2718 # endif
2719
2720   TEST_f_f (floor, -9007199254740991.5L, -9007199254740992.0L);
2721   TEST_f_f (floor, -9007199254740992.25L, -9007199254740993.0L);
2722   TEST_f_f (floor, -9007199254740992.5L, -9007199254740993.0L);
2723   TEST_f_f (floor, -9007199254740992.75L, -9007199254740993.0L);
2724   TEST_f_f (floor, -9007199254740993.5L, -9007199254740994.0L);
2725
2726 # if LDBL_MANT_DIG > 100
2727   TEST_f_f (floor, -9007199254740991.0000000000001L, -9007199254740992.0L);
2728   TEST_f_f (floor, -9007199254740992.0000000000001L, -9007199254740993.0L);
2729   TEST_f_f (floor, -9007199254740993.0000000000001L, -9007199254740994.0L);
2730   TEST_f_f (floor, -9007199254740991.5000000000001L, -9007199254740992.0L);
2731   TEST_f_f (floor, -9007199254740992.5000000000001L, -9007199254740993.0L);
2732   TEST_f_f (floor, -9007199254740993.5000000000001L, -9007199254740994.0L);
2733 # endif
2734
2735   TEST_f_f (floor, 72057594037927935.5L, 72057594037927935.0L);
2736   TEST_f_f (floor, 72057594037927936.25L, 72057594037927936.0L);
2737   TEST_f_f (floor, 72057594037927936.5L, 72057594037927936.0L);
2738   TEST_f_f (floor, 72057594037927936.75L, 72057594037927936.0L);
2739   TEST_f_f (floor, 72057594037927937.5L, 72057594037927937.0L);
2740
2741   TEST_f_f (floor, -72057594037927935.5L, -72057594037927936.0L);
2742   TEST_f_f (floor, -72057594037927936.25L, -72057594037927937.0L);
2743   TEST_f_f (floor, -72057594037927936.5L, -72057594037927937.0L);
2744   TEST_f_f (floor, -72057594037927936.75L, -72057594037927937.0L);
2745   TEST_f_f (floor, -72057594037927937.5L, -72057594037927938.0L);
2746
2747   TEST_f_f (floor, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
2748   TEST_f_f (floor, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
2749   TEST_f_f (floor, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
2750   TEST_f_f (floor, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
2751   TEST_f_f (floor, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
2752 #endif
2753
2754   END (floor);
2755 }
2756
2757
2758 static void
2759 fma_test (void)
2760 {
2761   START (fma);
2762
2763   TEST_fff_f (fma, 1.0, 2.0, 3.0, 5.0);
2764   TEST_fff_f (fma, nan_value, 2.0, 3.0, nan_value);
2765   TEST_fff_f (fma, 1.0, nan_value, 3.0, nan_value);
2766   TEST_fff_f (fma, 1.0, 2.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2767   TEST_fff_f (fma, plus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2768   TEST_fff_f (fma, minus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2769   TEST_fff_f (fma, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2770   TEST_fff_f (fma, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2771   TEST_fff_f (fma, plus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
2772   TEST_fff_f (fma, minus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
2773   TEST_fff_f (fma, 0.0, plus_infty, 1.0, nan_value, INVALID_EXCEPTION);
2774   TEST_fff_f (fma, 0.0, minus_infty, 1.0, nan_value, INVALID_EXCEPTION);
2775
2776   TEST_fff_f (fma, plus_infty, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
2777   TEST_fff_f (fma, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2778   TEST_fff_f (fma, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2779   TEST_fff_f (fma, minus_infty, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
2780
2781   TEST_fff_f (fma, 1.25L, 0.75L, 0.0625L, 1.0L);
2782
2783   END (fma);
2784 }
2785
2786
2787 static void
2788 fmax_test (void)
2789 {
2790   START (fmax);
2791
2792   TEST_ff_f (fmax, 0, 0, 0);
2793   TEST_ff_f (fmax, minus_zero, minus_zero, minus_zero);
2794   TEST_ff_f (fmax, 9, 0, 9);
2795   TEST_ff_f (fmax, 0, 9, 9);
2796   TEST_ff_f (fmax, -9, 0, 0);
2797   TEST_ff_f (fmax, 0, -9, 0);
2798
2799   TEST_ff_f (fmax, plus_infty, 9, plus_infty);
2800   TEST_ff_f (fmax, 0, plus_infty, plus_infty);
2801   TEST_ff_f (fmax, -9, plus_infty, plus_infty);
2802   TEST_ff_f (fmax, plus_infty, -9, plus_infty);
2803
2804   TEST_ff_f (fmax, minus_infty, 9, 9);
2805   TEST_ff_f (fmax, minus_infty, -9, -9);
2806   TEST_ff_f (fmax, 9, minus_infty, 9);
2807   TEST_ff_f (fmax, -9, minus_infty, -9);
2808
2809   TEST_ff_f (fmax, 0, nan_value, 0);
2810   TEST_ff_f (fmax, 9, nan_value, 9);
2811   TEST_ff_f (fmax, -9, nan_value, -9);
2812   TEST_ff_f (fmax, nan_value, 0, 0);
2813   TEST_ff_f (fmax, nan_value, 9, 9);
2814   TEST_ff_f (fmax, nan_value, -9, -9);
2815   TEST_ff_f (fmax, plus_infty, nan_value, plus_infty);
2816   TEST_ff_f (fmax, minus_infty, nan_value, minus_infty);
2817   TEST_ff_f (fmax, nan_value, plus_infty, plus_infty);
2818   TEST_ff_f (fmax, nan_value, minus_infty, minus_infty);
2819   TEST_ff_f (fmax, nan_value, nan_value, nan_value);
2820
2821   END (fmax);
2822 }
2823
2824
2825 static void
2826 fmin_test (void)
2827 {
2828   START (fmin);
2829
2830   TEST_ff_f (fmin, 0, 0, 0);
2831   TEST_ff_f (fmin, minus_zero, minus_zero, minus_zero);
2832   TEST_ff_f (fmin, 9, 0, 0);
2833   TEST_ff_f (fmin, 0, 9, 0);
2834   TEST_ff_f (fmin, -9, 0, -9);
2835   TEST_ff_f (fmin, 0, -9, -9);
2836
2837   TEST_ff_f (fmin, plus_infty, 9, 9);
2838   TEST_ff_f (fmin, 9, plus_infty, 9);
2839   TEST_ff_f (fmin, plus_infty, -9, -9);
2840   TEST_ff_f (fmin, -9, plus_infty, -9);
2841   TEST_ff_f (fmin, minus_infty, 9, minus_infty);
2842   TEST_ff_f (fmin, minus_infty, -9, minus_infty);
2843   TEST_ff_f (fmin, 9, minus_infty, minus_infty);
2844   TEST_ff_f (fmin, -9, minus_infty, minus_infty);
2845
2846   TEST_ff_f (fmin, 0, nan_value, 0);
2847   TEST_ff_f (fmin, 9, nan_value, 9);
2848   TEST_ff_f (fmin, -9, nan_value, -9);
2849   TEST_ff_f (fmin, nan_value, 0, 0);
2850   TEST_ff_f (fmin, nan_value, 9, 9);
2851   TEST_ff_f (fmin, nan_value, -9, -9);
2852   TEST_ff_f (fmin, plus_infty, nan_value, plus_infty);
2853   TEST_ff_f (fmin, minus_infty, nan_value, minus_infty);
2854   TEST_ff_f (fmin, nan_value, plus_infty, plus_infty);
2855   TEST_ff_f (fmin, nan_value, minus_infty, minus_infty);
2856   TEST_ff_f (fmin, nan_value, nan_value, nan_value);
2857
2858   END (fmin);
2859 }
2860
2861
2862 static void
2863 fmod_test (void)
2864 {
2865   errno = 0;
2866   FUNC(fmod) (6.5, 2.3L);
2867   if (errno == ENOSYS)
2868     /* Function not implemented.  */
2869     return;
2870
2871   START (fmod);
2872
2873   /* fmod (+0, y) == +0 for y != 0.  */
2874   TEST_ff_f (fmod, 0, 3, 0);
2875
2876   /* fmod (-0, y) == -0 for y != 0.  */
2877   TEST_ff_f (fmod, minus_zero, 3, minus_zero);
2878
2879   /* fmod (+inf, y) == NaN plus invalid exception.  */
2880   TEST_ff_f (fmod, plus_infty, 3, nan_value, INVALID_EXCEPTION);
2881   /* fmod (-inf, y) == NaN plus invalid exception.  */
2882   TEST_ff_f (fmod, minus_infty, 3, nan_value, INVALID_EXCEPTION);
2883   /* fmod (x, +0) == NaN plus invalid exception.  */
2884   TEST_ff_f (fmod, 3, 0, nan_value, INVALID_EXCEPTION);
2885   /* fmod (x, -0) == NaN plus invalid exception.  */
2886   TEST_ff_f (fmod, 3, minus_zero, nan_value, INVALID_EXCEPTION);
2887
2888   /* fmod (x, +inf) == x for x not infinite.  */
2889   TEST_ff_f (fmod, 3.0, plus_infty, 3.0);
2890   /* fmod (x, -inf) == x for x not infinite.  */
2891   TEST_ff_f (fmod, 3.0, minus_infty, 3.0);
2892
2893   TEST_ff_f (fmod, nan_value, nan_value, nan_value);
2894
2895   TEST_ff_f (fmod, 6.5, 2.25L, 2.0L);
2896   TEST_ff_f (fmod, -6.5, 2.25L, -2.0L);
2897   TEST_ff_f (fmod, 6.5, -2.25L, 2.0L);
2898   TEST_ff_f (fmod, -6.5, -2.25L, -2.0L);
2899
2900   END (fmod);
2901 }
2902
2903
2904 static void
2905 fpclassify_test (void)
2906 {
2907   START (fpclassify);
2908
2909   TEST_f_i (fpclassify, nan_value, FP_NAN);
2910   TEST_f_i (fpclassify, plus_infty, FP_INFINITE);
2911   TEST_f_i (fpclassify, minus_infty, FP_INFINITE);
2912   TEST_f_i (fpclassify, plus_zero, FP_ZERO);
2913   TEST_f_i (fpclassify, minus_zero, FP_ZERO);
2914   TEST_f_i (fpclassify, 1000, FP_NORMAL);
2915
2916   END (fpclassify);
2917 }
2918
2919
2920 static void
2921 frexp_test (void)
2922 {
2923   int x;
2924
2925   START (frexp);
2926
2927   TEST_fI_f1 (frexp, plus_infty, plus_infty, IGNORE);
2928   TEST_fI_f1 (frexp, minus_infty, minus_infty, IGNORE);
2929   TEST_fI_f1 (frexp, nan_value, nan_value, IGNORE);
2930
2931   TEST_fI_f1 (frexp, 0.0, 0.0, 0.0);
2932   TEST_fI_f1 (frexp, minus_zero, minus_zero, 0.0);
2933
2934   TEST_fI_f1 (frexp, 12.8L, 0.8L, 4);
2935   TEST_fI_f1 (frexp, -27.34L, -0.854375L, 5);
2936
2937   END (frexp);
2938 }
2939
2940
2941 static void
2942 gamma_test (void)
2943 {
2944   errno = 0;
2945   FUNC(gamma) (1);
2946
2947   if (errno == ENOSYS)
2948     /* Function not implemented.  */
2949     return;
2950   feclearexcept (FE_ALL_EXCEPT);
2951
2952   START (gamma);
2953
2954   TEST_f_f (gamma, plus_infty, plus_infty);
2955   TEST_f_f (gamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2956   TEST_f_f (gamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2957   TEST_f_f (gamma, minus_infty, plus_infty);
2958   TEST_f_f (gamma, nan_value, nan_value);
2959
2960   TEST_f_f1 (gamma, 1, 0, 1);
2961   TEST_f_f1 (gamma, 3, M_LN2l, 1);
2962
2963   TEST_f_f1 (gamma, 0.5, M_LOG_SQRT_PIl, 1);
2964   TEST_f_f1 (gamma, -0.5, M_LOG_2_SQRT_PIl, -1);
2965
2966   END (gamma);
2967 }
2968
2969 static void
2970 hypot_test (void)
2971 {
2972   errno = 0;
2973   FUNC(hypot) (0.7L, 12.4L);
2974   if (errno == ENOSYS)
2975     /* Function not implemented.  */
2976     return;
2977
2978   START (hypot);
2979
2980   TEST_ff_f (hypot, plus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
2981   TEST_ff_f (hypot, minus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
2982
2983 #ifndef TEST_INLINE
2984   TEST_ff_f (hypot, plus_infty, nan_value, plus_infty);
2985   TEST_ff_f (hypot, minus_infty, nan_value, plus_infty);
2986   TEST_ff_f (hypot, nan_value, plus_infty, plus_infty);
2987   TEST_ff_f (hypot, nan_value, minus_infty, plus_infty);
2988 #endif
2989
2990   TEST_ff_f (hypot, nan_value, nan_value, nan_value);
2991
2992   /* hypot (x,y) == hypot (+-x, +-y)  */
2993   TEST_ff_f (hypot, 0.7L, 12.4L, 12.419742348374220601176836866763271L);
2994   TEST_ff_f (hypot, -0.7L, 12.4L, 12.419742348374220601176836866763271L);
2995   TEST_ff_f (hypot, 0.7L, -12.4L, 12.419742348374220601176836866763271L);
2996   TEST_ff_f (hypot, -0.7L, -12.4L, 12.419742348374220601176836866763271L);
2997   TEST_ff_f (hypot, 12.4L, 0.7L, 12.419742348374220601176836866763271L);
2998   TEST_ff_f (hypot, -12.4L, 0.7L, 12.419742348374220601176836866763271L);
2999   TEST_ff_f (hypot, 12.4L, -0.7L, 12.419742348374220601176836866763271L);
3000   TEST_ff_f (hypot, -12.4L, -0.7L, 12.419742348374220601176836866763271L);
3001
3002   /*  hypot (x,0) == fabs (x)  */
3003   TEST_ff_f (hypot, 0.75L, 0, 0.75L);
3004   TEST_ff_f (hypot, -0.75L, 0, 0.75L);
3005   TEST_ff_f (hypot, -5.7e7, 0, 5.7e7L);
3006
3007   TEST_ff_f (hypot, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
3008
3009   END (hypot);
3010 }
3011
3012
3013 static void
3014 ilogb_test (void)
3015 {
3016   START (ilogb);
3017
3018   TEST_f_i (ilogb, 1, 0);
3019   TEST_f_i (ilogb, M_El, 1);
3020   TEST_f_i (ilogb, 1024, 10);
3021   TEST_f_i (ilogb, -2000, 10);
3022
3023   /* XXX We have a problem here: the standard does not tell us whether
3024      exceptions are allowed/required.  ignore them for now.  */
3025
3026   TEST_f_i (ilogb, 0.0, FP_ILOGB0, EXCEPTIONS_OK);
3027   TEST_f_i (ilogb, nan_value, FP_ILOGBNAN, EXCEPTIONS_OK);
3028   TEST_f_i (ilogb, plus_infty, INT_MAX, EXCEPTIONS_OK);
3029   TEST_f_i (ilogb, minus_infty, INT_MAX, EXCEPTIONS_OK);
3030
3031   END (ilogb);
3032 }
3033
3034 static void
3035 isfinite_test (void)
3036 {
3037   START (isfinite);
3038
3039   TEST_f_b (isfinite, 0, 1);
3040   TEST_f_b (isfinite, minus_zero, 1);
3041   TEST_f_b (isfinite, 10, 1);
3042   TEST_f_b (isfinite, plus_infty, 0);
3043   TEST_f_b (isfinite, minus_infty, 0);
3044   TEST_f_b (isfinite, nan_value, 0);
3045
3046   END (isfinite);
3047 }
3048
3049 static void
3050 isnormal_test (void)
3051 {
3052   START (isnormal);
3053
3054   TEST_f_b (isnormal, 0, 0);
3055   TEST_f_b (isnormal, minus_zero, 0);
3056   TEST_f_b (isnormal, 10, 1);
3057   TEST_f_b (isnormal, plus_infty, 0);
3058   TEST_f_b (isnormal, minus_infty, 0);
3059   TEST_f_b (isnormal, nan_value, 0);
3060
3061   END (isnormal);
3062 }
3063
3064 static void
3065 j0_test (void)
3066 {
3067   FLOAT s, c;
3068   errno = 0;
3069   FUNC (sincos) (0, &s, &c);
3070   if (errno == ENOSYS)
3071     /* Required function not implemented.  */
3072     return;
3073   FUNC(j0) (0);
3074   if (errno == ENOSYS)
3075     /* Function not implemented.  */
3076     return;
3077
3078   START (j0);
3079
3080   /* j0 is the Bessel function of the first kind of order 0 */
3081   TEST_f_f (j0, nan_value, nan_value);
3082   TEST_f_f (j0, plus_infty, 0);
3083   TEST_f_f (j0, -1.0, 0.765197686557966551449717526102663221L);
3084   TEST_f_f (j0, 0.0, 1.0);
3085   TEST_f_f (j0, 0.125L, 0.996097563041985204620768999453174712L);
3086   TEST_f_f (j0, 0.75L, 0.864242275166648623555731103820923211L);
3087   TEST_f_f (j0, 1.0, 0.765197686557966551449717526102663221L);
3088   TEST_f_f (j0, 1.5, 0.511827671735918128749051744283411720L);
3089   TEST_f_f (j0, 2.0, 0.223890779141235668051827454649948626L);
3090   TEST_f_f (j0, 8.0, 0.171650807137553906090869407851972001L);
3091   TEST_f_f (j0, 10.0, -0.245935764451348335197760862485328754L);
3092   TEST_f_f (j0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
3093   TEST_f_f (j0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
3094
3095   END (j0);
3096 }
3097
3098
3099 static void
3100 j1_test (void)
3101 {
3102   FLOAT s, c;
3103   errno = 0;
3104   FUNC (sincos) (0, &s, &c);
3105   if (errno == ENOSYS)
3106     /* Required function not implemented.  */
3107     return;
3108   FUNC(j1) (0);
3109   if (errno == ENOSYS)
3110     /* Function not implemented.  */
3111     return;
3112
3113   /* j1 is the Bessel function of the first kind of order 1 */
3114
3115   START (j1);
3116
3117   TEST_f_f (j1, nan_value, nan_value);
3118   TEST_f_f (j1, plus_infty, 0);
3119
3120   TEST_f_f (j1, -1.0, -0.440050585744933515959682203718914913L);
3121   TEST_f_f (j1, 0.0, 0.0);
3122   TEST_f_f (j1, 0.125L, 0.0623780091344946810942311355879361177L);
3123   TEST_f_f (j1, 0.75L, 0.349243602174862192523281016426251335L);
3124   TEST_f_f (j1, 1.0, 0.440050585744933515959682203718914913L);
3125   TEST_f_f (j1, 1.5, 0.557936507910099641990121213156089400L);
3126   TEST_f_f (j1, 2.0, 0.576724807756873387202448242269137087L);
3127   TEST_f_f (j1, 8.0, 0.234636346853914624381276651590454612L);
3128   TEST_f_f (j1, 10.0, 0.0434727461688614366697487680258592883L);
3129
3130   END (j1);
3131 }
3132
3133 static void
3134 jn_test (void)
3135 {
3136   FLOAT s, c;
3137   errno = 0;
3138   FUNC (sincos) (0, &s, &c);
3139   if (errno == ENOSYS)
3140     /* Required function not implemented.  */
3141     return;
3142   FUNC(jn) (1, 1);
3143   if (errno == ENOSYS)
3144     /* Function not implemented.  */
3145     return;
3146
3147   /* jn is the Bessel function of the first kind of order n.  */
3148   START (jn);
3149
3150   /* jn (0, x) == j0 (x)  */
3151   TEST_ff_f (jn, 0, nan_value, nan_value);
3152   TEST_ff_f (jn, 0, plus_infty, 0);
3153   TEST_ff_f (jn, 0, -1.0, 0.765197686557966551449717526102663221L);
3154   TEST_ff_f (jn, 0, 0.0, 1.0);
3155   TEST_ff_f (jn, 0, 0.125L, 0.996097563041985204620768999453174712L);
3156   TEST_ff_f (jn, 0, 0.75L, 0.864242275166648623555731103820923211L);
3157   TEST_ff_f (jn, 0, 1.0, 0.765197686557966551449717526102663221L);
3158   TEST_ff_f (jn, 0, 1.5, 0.511827671735918128749051744283411720L);
3159   TEST_ff_f (jn, 0, 2.0, 0.223890779141235668051827454649948626L);
3160   TEST_ff_f (jn, 0, 8.0, 0.171650807137553906090869407851972001L);
3161   TEST_ff_f (jn, 0, 10.0, -0.245935764451348335197760862485328754L);
3162   TEST_ff_f (jn, 0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
3163   TEST_ff_f (jn, 0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
3164
3165   /* jn (1, x) == j1 (x)  */
3166   TEST_ff_f (jn, 1, nan_value, nan_value);
3167   TEST_ff_f (jn, 1, plus_infty, 0);
3168   TEST_ff_f (jn, 1, -1.0, -0.440050585744933515959682203718914913L);
3169   TEST_ff_f (jn, 1, 0.0, 0.0);
3170   TEST_ff_f (jn, 1, 0.125L, 0.0623780091344946810942311355879361177L);
3171   TEST_ff_f (jn, 1, 0.75L, 0.349243602174862192523281016426251335L);
3172   TEST_ff_f (jn, 1, 1.0, 0.440050585744933515959682203718914913L);
3173   TEST_ff_f (jn, 1, 1.5, 0.557936507910099641990121213156089400L);
3174   TEST_ff_f (jn, 1, 2.0, 0.576724807756873387202448242269137087L);
3175   TEST_ff_f (jn, 1, 8.0, 0.234636346853914624381276651590454612L);
3176   TEST_ff_f (jn, 1, 10.0, 0.0434727461688614366697487680258592883L);
3177
3178   /* jn (3, x)  */
3179   TEST_ff_f (jn, 3, nan_value, nan_value);
3180   TEST_ff_f (jn, 3, plus_infty, 0);
3181
3182   TEST_ff_f (jn, 3, -1.0, -0.0195633539826684059189053216217515083L);
3183   TEST_ff_f (jn, 3, 0.0, 0.0);
3184   TEST_ff_f (jn, 3, 0.125L, 0.406503832554912875023029337653442868e-4L);
3185   TEST_ff_f (jn, 3, 0.75L, 0.848438342327410884392755236884386804e-2L);
3186   TEST_ff_f (jn, 3, 1.0, 0.0195633539826684059189053216217515083L);
3187   TEST_ff_f (jn, 3, 2.0, 0.128943249474402051098793332969239835L);
3188   TEST_ff_f (jn, 3, 10.0, 0.0583793793051868123429354784103409563L);
3189
3190   /*  jn (10, x)  */
3191   TEST_ff_f (jn, 10, nan_value, nan_value);
3192   TEST_ff_f (jn, 10, plus_infty, 0);
3193
3194   TEST_ff_f (jn, 10, -1.0, 0.263061512368745320699785368779050294e-9L);
3195   TEST_ff_f (jn, 10, 0.0, 0.0);
3196   TEST_ff_f (jn, 10, 0.125L, 0.250543369809369890173993791865771547e-18L);
3197   TEST_ff_f (jn, 10, 0.75L, 0.149621713117596814698712483621682835e-10L);
3198   TEST_ff_f (jn, 10, 1.0, 0.263061512368745320699785368779050294e-9L);
3199   TEST_ff_f (jn, 10, 2.0, 0.251538628271673670963516093751820639e-6L);
3200   TEST_ff_f (jn, 10, 10.0, 0.207486106633358857697278723518753428L);
3201
3202   END (jn);
3203 }
3204
3205
3206 static void
3207 ldexp_test (void)
3208 {
3209   TEST_ff_f (ldexp, 0, 0, 0);
3210   TEST_ff_f (ldexp, minus_zero, 0, minus_zero);
3211
3212   TEST_ff_f (ldexp, plus_infty, 1, plus_infty);
3213   TEST_ff_f (ldexp, minus_infty, 1, minus_infty);
3214   TEST_ff_f (ldexp, nan_value, 1, nan_value);
3215
3216   TEST_ff_f (ldexp, 0.8L, 4, 12.8L);
3217   TEST_ff_f (ldexp, -0.854375L, 5, -27.34L);
3218
3219   /* ldexp (x, 0) == x.  */
3220   TEST_ff_f (ldexp, 1.0L, 0L, 1.0L);
3221 }
3222
3223
3224 static void
3225 lgamma_test (void)
3226 {
3227   errno = 0;
3228   FUNC(lgamma) (0);
3229   if (errno == ENOSYS)
3230     /* Function not implemented.  */
3231     return;
3232   feclearexcept (FE_ALL_EXCEPT);
3233
3234   START (lgamma);
3235
3236   TEST_f_f (lgamma, plus_infty, plus_infty);
3237   TEST_f_f (lgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3238   check_int ("signgam for lgamma(0) == 1", signgam, 1, 0, 0, 0);
3239   TEST_f_f (lgamma, minus_zero, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3240   check_int ("signgam for lgamma(-0) == -1", signgam, -1, 0, 0, 0);
3241   TEST_f_f (lgamma, nan_value, nan_value);
3242
3243   /* lgamma (x) == +inf plus divide by zero exception for integer x <= 0.  */
3244   TEST_f_f (lgamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3245   TEST_f_f (lgamma, minus_infty, plus_infty);
3246
3247   TEST_f_f1 (lgamma, 1, 0, 1);
3248
3249   TEST_f_f1 (lgamma, 3, M_LN2l, 1);
3250
3251   TEST_f_f1 (lgamma, 0.5, M_LOG_SQRT_PIl, 1);
3252   TEST_f_f1 (lgamma, -0.5, M_LOG_2_SQRT_PIl, -1);
3253   TEST_f_f1 (lgamma, 0.7L, 0.260867246531666514385732417016759578L, 1);
3254   TEST_f_f1 (lgamma, 1.2L, -0.853740900033158497197028392998854470e-1L, 1);
3255
3256   END (lgamma);
3257 }
3258
3259
3260 static void
3261 lrint_test (void)
3262 {
3263   /* XXX this test is incomplete.  We need to have a way to specifiy
3264      the rounding method and test the critical cases.  So far, only
3265      unproblematic numbers are tested.  */
3266
3267   START (lrint);
3268
3269   TEST_f_l (lrint, 0.0, 0);
3270   TEST_f_l (lrint, minus_zero, 0);
3271   TEST_f_l (lrint, 0.2L, 0);
3272   TEST_f_l (lrint, -0.2L, 0);
3273
3274   TEST_f_l (lrint, 1.4L, 1);
3275   TEST_f_l (lrint, -1.4L, -1);
3276
3277   TEST_f_l (lrint, 8388600.3L, 8388600);
3278   TEST_f_l (lrint, -8388600.3L, -8388600);
3279
3280   TEST_f_l (lrint, 1071930.0008, 1071930);
3281 #ifndef TEST_FLOAT
3282   TEST_f_l (lrint, 1073741824.01, 1073741824);
3283 # if LONG_MAX > 281474976710656
3284   TEST_f_l (lrint, 281474976710656.025, 281474976710656);
3285 # endif
3286 #endif
3287
3288   END (lrint);
3289 }
3290
3291
3292 static void
3293 lrint_test_tonearest (void)
3294 {
3295   int save_round_mode;
3296   START (lrint_tonearest);
3297
3298   save_round_mode = fegetround ();
3299
3300   if (!fesetround (FE_TONEAREST))
3301     {
3302       TEST_f_l (lrint, 0.0, 0);
3303       TEST_f_l (lrint, minus_zero, 0);
3304       TEST_f_l (lrint, 0.2L, 0);
3305       TEST_f_l (lrint, -0.2L, 0);
3306       TEST_f_l (lrint, 0.5L, 0);
3307       TEST_f_l (lrint, -0.5L, 0);
3308       TEST_f_l (lrint, 0.8L, 1);
3309       TEST_f_l (lrint, -0.8L, -1);
3310
3311       TEST_f_l (lrint, 1.4L, 1);
3312       TEST_f_l (lrint, -1.4L, -1);
3313
3314       TEST_f_l (lrint, 8388600.3L, 8388600);
3315       TEST_f_l (lrint, -8388600.3L, -8388600);
3316
3317       TEST_f_l (lrint, 1071930.0008, 1071930);
3318 #ifndef TEST_FLOAT
3319       TEST_f_l (lrint, 1073741824.01, 1073741824);
3320 # if LONG_MAX > 281474976710656
3321       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
3322 # endif
3323 #endif
3324     }
3325
3326   fesetround (save_round_mode);
3327
3328   END (lrint_tonearest);
3329 }
3330
3331
3332 static void
3333 lrint_test_towardzero (void)
3334 {
3335   int save_round_mode;
3336   START (lrint_towardzero);
3337
3338   save_round_mode = fegetround ();
3339
3340   if (!fesetround (FE_TOWARDZERO))
3341     {
3342       TEST_f_l (lrint, 0.0, 0);
3343       TEST_f_l (lrint, minus_zero, 0);
3344       TEST_f_l (lrint, 0.2L, 0);
3345       TEST_f_l (lrint, -0.2L, 0);
3346       TEST_f_l (lrint, 0.5L, 0);
3347       TEST_f_l (lrint, -0.5L, 0);
3348       TEST_f_l (lrint, 0.8L, 0);
3349       TEST_f_l (lrint, -0.8L, 0);
3350
3351       TEST_f_l (lrint, 1.4L, 1);
3352       TEST_f_l (lrint, -1.4L, -1);
3353
3354       TEST_f_l (lrint, 8388600.3L, 8388600);
3355       TEST_f_l (lrint, -8388600.3L, -8388600);
3356
3357       TEST_f_l (lrint, 1071930.0008, 1071930);
3358 #ifndef TEST_FLOAT
3359       TEST_f_l (lrint, 1073741824.01, 1073741824);
3360 # if LONG_MAX > 281474976710656
3361       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
3362 # endif
3363 #endif
3364     }
3365
3366   fesetround (save_round_mode);
3367
3368   END (lrint_towardzero);
3369 }
3370
3371
3372 static void
3373 lrint_test_downward (void)
3374 {
3375   int save_round_mode;
3376   START (lrint_downward);
3377
3378   save_round_mode = fegetround ();
3379
3380   if (!fesetround (FE_DOWNWARD))
3381     {
3382       TEST_f_l (lrint, 0.0, 0);
3383       TEST_f_l (lrint, minus_zero, 0);
3384       TEST_f_l (lrint, 0.2L, 0);
3385       TEST_f_l (lrint, -0.2L, -1);
3386       TEST_f_l (lrint, 0.5L, 0);
3387       TEST_f_l (lrint, -0.5L, -1);
3388       TEST_f_l (lrint, 0.8L, 0);
3389       TEST_f_l (lrint, -0.8L, -1);
3390
3391       TEST_f_l (lrint, 1.4L, 1);
3392       TEST_f_l (lrint, -1.4L, -2);
3393
3394       TEST_f_l (lrint, 8388600.3L, 8388600);
3395       TEST_f_l (lrint, -8388600.3L, -8388601);
3396
3397       TEST_f_l (lrint, 1071930.0008, 1071930);
3398 #ifndef TEST_FLOAT
3399       TEST_f_l (lrint, 1073741824.01, 1073741824);
3400 # if LONG_MAX > 281474976710656
3401       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
3402 # endif
3403 #endif
3404     }
3405
3406   fesetround (save_round_mode);
3407
3408   END (lrint_downward);
3409 }
3410
3411
3412 static void
3413 lrint_test_upward (void)
3414 {
3415   int save_round_mode;
3416   START (lrint_upward);
3417
3418   save_round_mode = fegetround ();
3419
3420   if (!fesetround (FE_UPWARD))
3421     {
3422       TEST_f_l (lrint, 0.0, 0);
3423       TEST_f_l (lrint, minus_zero, 0);
3424       TEST_f_l (lrint, 0.2L, 1);
3425       TEST_f_l (lrint, -0.2L, 0);
3426       TEST_f_l (lrint, 0.5L, 1);
3427       TEST_f_l (lrint, -0.5L, 0);
3428       TEST_f_l (lrint, 0.8L, 1);
3429       TEST_f_l (lrint, -0.8L, 0);
3430
3431       TEST_f_l (lrint, 1.4L, 2);
3432       TEST_f_l (lrint, -1.4L, -1);
3433
3434       TEST_f_l (lrint, 8388600.3L, 8388601);
3435       TEST_f_l (lrint, -8388600.3L, -8388600);
3436
3437 #ifndef TEST_FLOAT
3438       TEST_f_l (lrint, 1071930.0008, 1071931);
3439       TEST_f_l (lrint, 1073741824.01, 1073741825);
3440 # if LONG_MAX > 281474976710656 && defined (TEST_LDOUBLE)
3441       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
3442 # endif
3443 #endif
3444     }
3445
3446   fesetround (save_round_mode);
3447
3448   END (lrint_upward);
3449 }
3450
3451
3452 static void
3453 llrint_test (void)
3454 {
3455   /* XXX this test is incomplete.  We need to have a way to specifiy
3456      the rounding method and test the critical cases.  So far, only
3457      unproblematic numbers are tested.  */
3458
3459   START (llrint);
3460
3461   TEST_f_L (llrint, 0.0, 0);
3462   TEST_f_L (llrint, minus_zero, 0);
3463   TEST_f_L (llrint, 0.2L, 0);
3464   TEST_f_L (llrint, -0.2L, 0);
3465
3466   TEST_f_L (llrint, 1.4L, 1);
3467   TEST_f_L (llrint, -1.4L, -1);
3468
3469   TEST_f_L (llrint, 8388600.3L, 8388600);
3470   TEST_f_L (llrint, -8388600.3L, -8388600);
3471
3472   TEST_f_l (llrint, 1071930.0008, 1071930);
3473
3474   /* Test boundary conditions.  */
3475   /* 0x1FFFFF */
3476   TEST_f_L (llrint, 2097151.0,2097151LL);
3477   /* 0x800000 */
3478   TEST_f_L (llrint, 8388608.0, 8388608LL);
3479   /* 0x1000000 */
3480   TEST_f_L (llrint, 16777216.0, 16777216LL);
3481   /* 0x20000000000 */
3482   TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
3483   /* 0x40000000000 */
3484   TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
3485   /* 0x1000000000000 */
3486   TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
3487   /* 0x10000000000000 */
3488   TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
3489   /* 0x10000080000000 */
3490   TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
3491   /* 0x20000000000000 */
3492   TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
3493   /* 0x80000000000000 */
3494   TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
3495   /* 0x100000000000000 */
3496   TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
3497 #ifdef TEST_LDOUBLE
3498   /* The input can only be represented in long double.  */
3499   TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
3500   TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
3501   TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
3502   TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
3503   TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
3504
3505   TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
3506   TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
3507   TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
3508   TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
3509   TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
3510
3511 # if LDBL_MANT_DIG > 100
3512   TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
3513   TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
3514   TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
3515   TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
3516   TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
3517   TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
3518
3519   TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
3520   TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
3521   TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
3522   TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
3523   TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
3524   TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
3525 #endif
3526
3527   TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
3528   TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
3529   TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
3530   TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
3531   TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
3532
3533   TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
3534   TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
3535   TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
3536   TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
3537   TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
3538
3539 # if LDBL_MANT_DIG > 100
3540   TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
3541   TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
3542   TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
3543   TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
3544   TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
3545   TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
3546
3547   TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
3548   TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
3549   TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
3550   TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
3551   TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
3552   TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
3553 #endif
3554
3555   TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
3556   TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
3557   TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
3558   TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
3559   TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
3560
3561   TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
3562   TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
3563   TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
3564   TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
3565   TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
3566
3567 # if LDBL_MANT_DIG > 100
3568   TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
3569   TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
3570   TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
3571   TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
3572   TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
3573   TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
3574   TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
3575   TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
3576   TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
3577   TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
3578   TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
3579   TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
3580 # endif
3581 #endif
3582
3583   END (llrint);
3584 }
3585
3586 static void
3587 llrint_test_tonearest (void)
3588 {
3589   int save_round_mode;
3590   START (llrint_tonearest);
3591
3592   save_round_mode = fegetround ();
3593
3594   if (!fesetround (FE_TONEAREST))
3595     {
3596       TEST_f_L (llrint, 0.0, 0);
3597       TEST_f_L (llrint, minus_zero, 0);
3598       TEST_f_L (llrint, 0.2L, 0);
3599       TEST_f_L (llrint, -0.2L, 0);
3600
3601       TEST_f_L (llrint, 1.4L, 1);
3602       TEST_f_L (llrint, -1.4L, -1);
3603
3604       TEST_f_L (llrint, 8388600.3L, 8388600);
3605       TEST_f_L (llrint, -8388600.3L, -8388600);
3606
3607       TEST_f_l (llrint, 1071930.0008, 1071930);
3608
3609       /* Test boundary conditions.  */
3610       /* 0x1FFFFF */
3611       TEST_f_L (llrint, 2097151.0,2097151LL);
3612       /* 0x800000 */
3613       TEST_f_L (llrint, 8388608.0, 8388608LL);
3614       /* 0x1000000 */
3615       TEST_f_L (llrint, 16777216.0, 16777216LL);
3616       /* 0x20000000000 */
3617       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
3618       /* 0x40000000000 */
3619       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
3620       /* 0x1000000000000 */
3621       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
3622       /* 0x10000000000000 */
3623       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
3624       /* 0x10000080000000 */
3625       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
3626       /* 0x20000000000000 */
3627       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
3628       /* 0x80000000000000 */
3629       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
3630       /* 0x100000000000000 */
3631       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
3632 #ifdef TEST_LDOUBLE
3633       /* The input can only be represented in long double.  */
3634       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
3635       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
3636       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
3637       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
3638       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
3639
3640       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
3641       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
3642       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
3643       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
3644       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
3645
3646 # if LDBL_MANT_DIG > 100
3647       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
3648       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
3649       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
3650       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
3651       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
3652       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
3653
3654       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
3655       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
3656       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
3657       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
3658       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
3659       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
3660 #endif
3661
3662       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
3663       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
3664       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
3665       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
3666       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
3667
3668       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
3669       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
3670       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
3671       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
3672       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
3673
3674 # if LDBL_MANT_DIG > 100
3675       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
3676       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
3677       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
3678       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
3679       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
3680       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
3681
3682       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
3683       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
3684       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
3685       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
3686       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
3687       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
3688 #endif
3689
3690       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
3691       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
3692       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
3693       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
3694       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
3695
3696       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
3697       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
3698       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
3699       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
3700       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
3701
3702 # if LDBL_MANT_DIG > 100
3703       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
3704       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
3705       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
3706       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
3707       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
3708       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
3709       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
3710       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
3711       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
3712       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
3713       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
3714       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
3715 # endif
3716 #endif
3717     }
3718
3719   fesetround (save_round_mode);
3720
3721   END (llrint_tonearest);
3722 }
3723
3724 static void
3725 llrint_test_towardzero (void)
3726 {
3727   int save_round_mode;
3728   START (llrint_towardzero);
3729
3730   save_round_mode = fegetround ();
3731
3732   if (!fesetround (FE_TOWARDZERO))
3733     {
3734       TEST_f_L (llrint, 0.0, 0);
3735       TEST_f_L (llrint, minus_zero, 0);
3736       TEST_f_L (llrint, 0.2L, 0);
3737       TEST_f_L (llrint, -0.2L, 0);