lib/msun/tests/next_test.c

   1 /*-
   2  * Copyright (c) 2005 David Schultz <das@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 /*
  28  * Test the correctness of nextafter{,f,l} and nexttoward{,f,l}.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include <fenv.h>
  35 #include <float.h>
  36 #include <math.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39
  40 #ifdef  __i386__
  41 #include <ieeefp.h>
  42 #endif
  43
  44 #include "test-utils.h"
  45
  46 #define test(exp, ans, ex)      do {                    \
  47         double __ans = (ans);                           \
  48         feclearexcept(ALL_STD_EXCEPT);                  \
  49         _testl(#exp, __LINE__, (exp), __ans, (ex));     \
  50 } while (0)
  51 #define testf(exp, ans, ex)     do {                    \
  52         float __ans = (ans);                            \
  53         feclearexcept(ALL_STD_EXCEPT);                  \
  54         _testl(#exp, __LINE__, (exp), __ans, (ex));     \
  55 } while (0)
  56 #define testl(exp, ans, ex)     do {                    \
  57         long double __ans = (ans);                      \
  58         feclearexcept(ALL_STD_EXCEPT);                  \
  59         _testl(#exp, __LINE__, (exp), __ans, (ex));     \
  60 } while (0)
  61 #define testboth(arg1, arg2, ans, ex, prec)     do {                    \
  62         test##prec(nextafter##prec((arg1), (arg2)), (ans), (ex));       \
  63         test##prec(nexttoward##prec((arg1), (arg2)), (ans), (ex));      \
  64 } while (0)
  65 #define testall(arg1, arg2, ans, ex)    do {            \
  66         testboth((arg1), (arg2), (ans), (ex), );        \
  67         testboth((arg1), (arg2), (ans), (ex), f);       \
  68         testboth((arg1), (arg2), (ans), (ex), l);       \
  69 } while (0)
  70
  71 static void _testl(const char *, int, long double, long double, int);
  72 static double idd(double);
  73 static float idf(float);
  74
  75 static const int ex_under = FE_UNDERFLOW | FE_INEXACT;  /* shorthand */
  76 static const int ex_over = FE_OVERFLOW | FE_INEXACT;
  77 static const long double ldbl_eps = LDBL_EPSILON;
  78
  79
  80
  81 ATF_TC_WITHOUT_HEAD(zeros);
  82 ATF_TC_BODY(zeros, tc)
  83 {
  84         long double ldbl_small;
  85
  86 #ifdef  __i386__
  87         fpsetprec(FP_PE);
  88 #endif
  89         /*
  90          * We can't use a compile-time constant here because gcc on
  91          * FreeBSD/i386 assumes long doubles are truncated to the
  92          * double format.
  93          */
  94         ldbl_small = ldexpl(1.0, LDBL_MIN_EXP - LDBL_MANT_DIG);
  95
  96         /*
  97          * Special cases involving zeroes.
  98          */
  99 #define ztest(prec)                                                           \
 100         test##prec(copysign##prec(1.0, nextafter##prec(0.0, -0.0)), -1.0, 0); \
 101         test##prec(copysign##prec(1.0, nextafter##prec(-0.0, 0.0)), 1.0, 0);  \
 102         test##prec(copysign##prec(1.0, nexttoward##prec(0.0, -0.0)), -1.0, 0);\
 103         test##prec(copysign##prec(1.0, nexttoward##prec(-0.0, 0.0)), 1.0, 0)
 104
 105         ztest();
 106         ztest(f);
 107         ztest(l);
 108 #undef  ztest
 109
 110 #define stest(next, eps, prec)                                  \
 111         test##prec(next(-0.0, 42.0), eps, ex_under);            \
 112         test##prec(next(0.0, -42.0), -eps, ex_under);           \
 113         test##prec(next(0.0, INFINITY), eps, ex_under);         \
 114         test##prec(next(-0.0, -INFINITY), -eps, ex_under)
 115
 116         stest(nextafter, 0x1p-1074, );
 117         stest(nextafterf, 0x1p-149f, f);
 118         stest(nextafterl, ldbl_small, l);
 119         stest(nexttoward, 0x1p-1074, );
 120         stest(nexttowardf, 0x1p-149f, f);
 121         stest(nexttowardl, ldbl_small, l);
 122 #undef  stest
 123 }
 124
 125 ATF_TC_WITHOUT_HEAD(eq_and_nan);
 126 ATF_TC_BODY(eq_and_nan, tc)
 127 {
 128         /*
 129          * `x == y' and NaN tests
 130          */
 131         testall(42.0, 42.0, 42.0, 0);
 132         testall(-42.0, -42.0, -42.0, 0);
 133         testall(INFINITY, INFINITY, INFINITY, 0);
 134         testall(-INFINITY, -INFINITY, -INFINITY, 0);
 135         testall(NAN, 42.0, NAN, 0);
 136         testall(42.0, NAN, NAN, 0);
 137         testall(NAN, NAN, NAN, 0);
 138 }
 139
 140 ATF_TC_WITHOUT_HEAD(ordinary);
 141 ATF_TC_BODY(ordinary, tc)
 142 {
 143         /*
 144          * Tests where x is an ordinary normalized number
 145          */
 146         testboth(1.0, 2.0, 1.0 + DBL_EPSILON, 0, );
 147         testboth(1.0, -INFINITY, 1.0 - DBL_EPSILON / 2, 0, );
 148         testboth(1.0, 2.0, 1.0 + FLT_EPSILON, 0, f);
 149         testboth(1.0, -INFINITY, 1.0 - FLT_EPSILON / 2, 0, f);
 150         testboth(1.0, 2.0, 1.0 + ldbl_eps, 0, l);
 151         testboth(1.0, -INFINITY, 1.0 - ldbl_eps / 2, 0, l);
 152
 153         testboth(-1.0, 2.0, -1.0 + DBL_EPSILON / 2, 0, );
 154         testboth(-1.0, -INFINITY, -1.0 - DBL_EPSILON, 0, );
 155         testboth(-1.0, 2.0, -1.0 + FLT_EPSILON / 2, 0, f);
 156         testboth(-1.0, -INFINITY, -1.0 - FLT_EPSILON, 0, f);
 157         testboth(-1.0, 2.0, -1.0 + ldbl_eps / 2, 0, l);
 158         testboth(-1.0, -INFINITY, -1.0 - ldbl_eps, 0, l);
 159
 160         /* Cases where nextafter(...) != nexttoward(...) */
 161         test(nexttoward(1.0, 1.0 + ldbl_eps), 1.0 + DBL_EPSILON, 0);
 162         testf(nexttowardf(1.0, 1.0 + ldbl_eps), 1.0 + FLT_EPSILON, 0);
 163         testl(nexttowardl(1.0, 1.0 + ldbl_eps), 1.0 + ldbl_eps, 0);
 164 }
 165
 166 ATF_TC_WITHOUT_HEAD(boundaries);
 167 ATF_TC_BODY(boundaries, tc)
 168 {
 169         /*
 170          * Tests at word boundaries, normalization boundaries, etc.
 171          */
 172         testboth(0x1.87654ffffffffp+0, INFINITY, 0x1.87655p+0, 0, );
 173         testboth(0x1.87655p+0, -INFINITY, 0x1.87654ffffffffp+0, 0, );
 174         testboth(0x1.fffffffffffffp+0, INFINITY, 0x1p1, 0, );
 175         testboth(0x1p1, -INFINITY, 0x1.fffffffffffffp+0, 0, );
 176         testboth(0x0.fffffffffffffp-1022, INFINITY, 0x1p-1022, 0, );
 177         testboth(0x1p-1022, -INFINITY, 0x0.fffffffffffffp-1022, ex_under, );
 178
 179         testboth(0x1.fffffep0f, INFINITY, 0x1p1, 0, f);
 180         testboth(0x1p1, -INFINITY, 0x1.fffffep0f, 0, f);
 181         testboth(0x0.fffffep-126f, INFINITY, 0x1p-126f, 0, f);
 182         testboth(0x1p-126f, -INFINITY, 0x0.fffffep-126f, ex_under, f);
 183
 184 #if LDBL_MANT_DIG == 53
 185         testboth(0x1.87654ffffffffp+0L, INFINITY, 0x1.87655p+0L, 0, l);
 186         testboth(0x1.87655p+0L, -INFINITY, 0x1.87654ffffffffp+0L, 0, l);
 187         testboth(0x1.fffffffffffffp+0L, INFINITY, 0x1p1L, 0, l);
 188         testboth(0x1p1L, -INFINITY, 0x1.fffffffffffffp+0L, 0, l);
 189         testboth(0x0.fffffffffffffp-1022L, INFINITY, 0x1p-1022L, 0, l);
 190         testboth(0x1p-1022L, -INFINITY, 0x0.fffffffffffffp-1022L, ex_under, l);
 191 #elif LDBL_MANT_DIG == 64 && !defined(__i386)
 192         testboth(0x1.87654321fffffffep+0L, INFINITY, 0x1.87654322p+0L, 0, l);
 193         testboth(0x1.87654322p+0L, -INFINITY, 0x1.87654321fffffffep+0L, 0, l);
 194         testboth(0x1.fffffffffffffffep0L, INFINITY, 0x1p1L, 0, l);
 195         testboth(0x1p1L, -INFINITY, 0x1.fffffffffffffffep0L, 0, l);
 196         testboth(0x0.fffffffffffffffep-16382L, INFINITY, 0x1p-16382L, 0, l);
 197         testboth(0x1p-16382L, -INFINITY,
 198             0x0.fffffffffffffffep-16382L, ex_under, l);
 199 #elif LDBL_MANT_DIG == 113
 200         testboth(0x1.876543210987ffffffffffffffffp+0L, INFINITY,
 201             0x1.876543210988p+0, 0, l);
 202         testboth(0x1.876543210988p+0L, -INFINITY,
 203             0x1.876543210987ffffffffffffffffp+0L, 0, l);
 204         testboth(0x1.ffffffffffffffffffffffffffffp0L, INFINITY, 0x1p1L, 0, l);
 205         testboth(0x1p1L, -INFINITY, 0x1.ffffffffffffffffffffffffffffp0L, 0, l);
 206         testboth(0x0.ffffffffffffffffffffffffffffp-16382L, INFINITY,
 207             0x1p-16382L, 0, l);
 208         testboth(0x1p-16382L, -INFINITY,
 209             0x0.ffffffffffffffffffffffffffffp-16382L, ex_under, l);
 210 #endif
 211 }
 212
 213 ATF_TC_WITHOUT_HEAD(overflow);
 214 ATF_TC_BODY(overflow, tc)
 215 {
 216         long double ldbl_max;
 217         /*
 218          * We can't use a compile-time constant here because gcc on
 219          * FreeBSD/i386 assumes long doubles are truncated to the
 220          * double format.
 221          */
 222         ldbl_max = ldexpl(1.0 - ldbl_eps / 2, LDBL_MAX_EXP);
 223
 224         /*
 225          * Overflow tests
 226          */
 227         test(idd(nextafter(DBL_MAX, INFINITY)), INFINITY, ex_over);
 228         test(idd(nextafter(INFINITY, 0.0)), DBL_MAX, 0);
 229         test(idd(nexttoward(DBL_MAX, DBL_MAX * 2.0L)), INFINITY, ex_over);
 230 #if LDBL_MANT_DIG > 53
 231         test(idd(nexttoward(INFINITY, DBL_MAX * 2.0L)), DBL_MAX, 0);
 232 #endif
 233
 234         testf(idf(nextafterf(FLT_MAX, INFINITY)), INFINITY, ex_over);
 235         testf(idf(nextafterf(INFINITY, 0.0)), FLT_MAX, 0);
 236         testf(idf(nexttowardf(FLT_MAX, FLT_MAX * 2.0)), INFINITY, ex_over);
 237         testf(idf(nexttowardf(INFINITY, FLT_MAX * 2.0)), FLT_MAX, 0);
 238
 239         testboth(ldbl_max, INFINITY, INFINITY, ex_over, l);
 240         testboth(INFINITY, 0.0, ldbl_max, 0, l);
 241 }
 242
 243 static void
 244 _testl(const char *exp, int line, long double actual, long double expected,
 245     int except)
 246 {
 247         int actual_except;
 248
 249         actual_except = fetestexcept(ALL_STD_EXCEPT);
 250         if (!fpequal_cs(actual, expected, true)) {
 251                 atf_tc_fail_check(__FILE__, line,
 252                     "%s returned %La, expecting %La\n", exp, actual, expected);
 253         }
 254         if (actual_except != except) {
 255                 atf_tc_fail_check(__FILE__, line,
 256                     "%s raised 0x%x, expecting 0x%x\n", exp, actual_except,
 257                     except);
 258         }
 259 }
 260
 261 /*
 262  * The idd() and idf() routines ensure that doubles and floats are
 263  * converted to their respective types instead of stored in the FPU
 264  * with extra precision.
 265  */
 266 static double
 267 idd(double x)
 268 {
 269         return (x);
 270 }
 271
 272 static float
 273 idf(float x)
 274 {
 275         return (x);
 276 }
 277
 278 ATF_TP_ADD_TCS(tp)
 279 {
 280         ATF_TP_ADD_TC(tp, zeros);
 281         ATF_TP_ADD_TC(tp, ordinary);
 282         ATF_TP_ADD_TC(tp, eq_and_nan);
 283         ATF_TP_ADD_TC(tp, boundaries);
 284         ATF_TP_ADD_TC(tp, overflow);
 285
 286         return (atf_no_error());
 287 }