diff options
| -rw-r--r-- | libc/bionic/strtold.cpp | 2 | ||||
| -rw-r--r-- | libc/bionic/wcstod.cpp | 2 | ||||
| -rw-r--r-- | libc/include/complex.h | 44 | ||||
| -rw-r--r-- | libc/include/math.h | 489 | ||||
| -rw-r--r-- | libc/include/stdlib.h | 2 | ||||
| -rw-r--r-- | libc/include/sys/cdefs.h | 24 | ||||
| -rw-r--r-- | libc/include/wchar.h | 2 | ||||
| -rw-r--r-- | libm/Android.bp | 1 | ||||
| -rw-r--r-- | tests/Android.bp | 2 | ||||
| -rw-r--r-- | tests/complex_force_long_double_test.cpp | 2 | ||||
| -rw-r--r-- | tests/complex_test.cpp | 141 | ||||
| -rw-r--r-- | tests/math_force_long_double_test.cpp | 2 | ||||
| -rw-r--r-- | tests/math_test.cpp | 650 |
13 files changed, 728 insertions, 635 deletions
diff --git a/libc/bionic/strtold.cpp b/libc/bionic/strtold.cpp index c55dd61c0..6b673e6e0 100644 --- a/libc/bionic/strtold.cpp +++ b/libc/bionic/strtold.cpp @@ -26,6 +26,8 @@ * SUCH DAMAGE. */ +#define __BIONIC_LP32_USE_LONG_DOUBLE + #include <float.h> #include <stdlib.h> diff --git a/libc/bionic/wcstod.cpp b/libc/bionic/wcstod.cpp index f7bd4337f..41df85455 100644 --- a/libc/bionic/wcstod.cpp +++ b/libc/bionic/wcstod.cpp @@ -26,6 +26,8 @@ * SUCH DAMAGE. */ +#define __BIONIC_LP32_USE_LONG_DOUBLE + #include <wchar.h> #include <stdlib.h> diff --git a/libc/include/complex.h b/libc/include/complex.h index 79fe07c39..3fe8f359e 100644 --- a/libc/include/complex.h +++ b/libc/include/complex.h @@ -61,99 +61,99 @@ __BEGIN_DECLS /* 7.3.5.1 The cacos functions */ double complex cacos(double complex __z) __INTRODUCED_IN(23); float complex cacosf(float complex __z) __INTRODUCED_IN(23); -long double complex cacosl(long double complex __z) __INTRODUCED_IN(26); +long double complex cacosl(long double complex __z) __RENAME_LDBL(cacos, 23, 26); /* 7.3.5.2 The casin functions */ double complex casin(double complex __z) __INTRODUCED_IN(23); float complex casinf(float complex __z) __INTRODUCED_IN(23); -long double complex casinl(long double complex __z) __INTRODUCED_IN(26); +long double complex casinl(long double complex __z) __RENAME_LDBL(casin, 23, 26); /* 7.3.5.1 The catan functions */ double complex catan(double complex __z) __INTRODUCED_IN(23); float complex catanf(float complex __z) __INTRODUCED_IN(23); -long double complex catanl(long double complex __z) __INTRODUCED_IN(26); +long double complex catanl(long double complex __z) __RENAME_LDBL(catan, 23, 26); /* 7.3.5.1 The ccos functions */ double complex ccos(double complex __z) __INTRODUCED_IN(23); float complex ccosf(float complex __z) __INTRODUCED_IN(23); -long double complex ccosl(long double complex __z) __INTRODUCED_IN(26); +long double complex ccosl(long double complex __z) __RENAME_LDBL(ccos, 23, 26); /* 7.3.5.1 The csin functions */ double complex csin(double complex __z) __INTRODUCED_IN(23); float complex csinf(float complex __z) __INTRODUCED_IN(23); -long double complex csinl(long double complex __z) __INTRODUCED_IN(26); +long double complex csinl(long double complex __z) __RENAME_LDBL(csin, 23, 26); /* 7.3.5.1 The ctan functions */ double complex ctan(double complex __z) __INTRODUCED_IN(23); float complex ctanf(float complex __z) __INTRODUCED_IN(23); -long double complex ctanl(long double complex __z) __INTRODUCED_IN(26); +long double complex ctanl(long double complex __z) __RENAME_LDBL(ctan, 23, 26); /* 7.3.6 Hyperbolic functions */ /* 7.3.6.1 The cacosh functions */ double complex cacosh(double complex __z) __INTRODUCED_IN(23); float complex cacoshf(float complex __z) __INTRODUCED_IN(23); -long double complex cacoshl(long double complex __z) __INTRODUCED_IN(26); +long double complex cacoshl(long double complex __z) __RENAME_LDBL(cacosh, 23, 26); /* 7.3.6.2 The casinh functions */ double complex casinh(double complex __z) __INTRODUCED_IN(23); float complex casinhf(float complex __z) __INTRODUCED_IN(23); -long double complex casinhl(long double complex __z) __INTRODUCED_IN(26); +long double complex casinhl(long double complex __z) __RENAME_LDBL(casinh, 23, 26); /* 7.3.6.3 The catanh functions */ double complex catanh(double complex __z) __INTRODUCED_IN(23); float complex catanhf(float complex __z) __INTRODUCED_IN(23); -long double complex catanhl(long double complex __z) __INTRODUCED_IN(26); +long double complex catanhl(long double complex __z) __RENAME_LDBL(catanh, 23, 26); /* 7.3.6.4 The ccosh functions */ double complex ccosh(double complex __z) __INTRODUCED_IN(23); float complex ccoshf(float complex __z) __INTRODUCED_IN(23); -long double complex ccoshl(long double complex __z) __INTRODUCED_IN(26); +long double complex ccoshl(long double complex __z) __RENAME_LDBL(ccosh, 23, 26); /* 7.3.6.5 The csinh functions */ double complex csinh(double complex __z) __INTRODUCED_IN(23); float complex csinhf(float complex __z) __INTRODUCED_IN(23); -long double complex csinhl(long double complex __z) __INTRODUCED_IN(26); +long double complex csinhl(long double complex __z) __RENAME_LDBL(csinh, 23, 26); /* 7.3.6.6 The ctanh functions */ double complex ctanh(double complex __z) __INTRODUCED_IN(23); float complex ctanhf(float complex __z) __INTRODUCED_IN(23); -long double complex ctanhl(long double complex __z) __INTRODUCED_IN(26); +long double complex ctanhl(long double complex __z) __RENAME_LDBL(ctanh, 23, 26); /* 7.3.7 Exponential and logarithmic functions */ /* 7.3.7.1 The cexp functions */ double complex cexp(double complex __z) __INTRODUCED_IN(23); float complex cexpf(float complex __z) __INTRODUCED_IN(23); -long double complex cexpl(long double complex __z) __INTRODUCED_IN(26); +long double complex cexpl(long double complex __z) __RENAME_LDBL(cexp, 23, 26); /* 7.3.7.2 The clog functions */ double complex clog(double complex __z) __INTRODUCED_IN(26); float complex clogf(float complex __z) __INTRODUCED_IN(26); -long double complex clogl(long double complex __z) __INTRODUCED_IN(26); +long double complex clogl(long double complex __z) __RENAME_LDBL(clog, 26, 26); /* 7.3.8 Power and absolute-value functions */ /* 7.3.8.1 The cabs functions */ double cabs(double complex __z) __INTRODUCED_IN(23); float cabsf(float complex __z) __INTRODUCED_IN(23); -long double cabsl(long double complex __z) __INTRODUCED_IN_32(21) __INTRODUCED_IN_64(23); +long double cabsl(long double complex __z) __INTRODUCED_IN_32(21) __INTRODUCED_IN_64(23) /*__RENAME_LDBL(cabs)*/; /* 7.3.8.2 The cpow functions */ double complex cpow(double complex __x, double complex __z) __INTRODUCED_IN(26); float complex cpowf(float complex __x, float complex __z) __INTRODUCED_IN(26); -long double complex cpowl(long double complex __x, long double complex __z) __INTRODUCED_IN(26); +long double complex cpowl(long double complex __x, long double complex __z) __RENAME_LDBL(cpow, 26, 26); /* 7.3.8.3 The csqrt functions */ double complex csqrt(double complex __z) __INTRODUCED_IN(23); float complex csqrtf(float complex __z) __INTRODUCED_IN(23); -long double complex csqrtl(long double complex __z) __INTRODUCED_IN_32(21) __INTRODUCED_IN_64(23); +long double complex csqrtl(long double complex __z) __INTRODUCED_IN_32(21) __INTRODUCED_IN_64(23) /*__RENAME_LDBL(csqrt)*/; /* 7.3.9 Manipulation functions */ /* 7.3.9.1 The carg functions */ double carg(double complex __z) __INTRODUCED_IN(23); float cargf(float complex __z) __INTRODUCED_IN(23); -long double cargl(long double complex __z) __INTRODUCED_IN(23); +long double cargl(long double complex __z) __RENAME_LDBL(carg, 23, 23); /* 7.3.9.2 The cimag functions */ double cimag(double complex __z) __INTRODUCED_IN(23); float cimagf(float complex __z) __INTRODUCED_IN(23); -long double cimagl(long double complex __z) __INTRODUCED_IN(23); +long double cimagl(long double complex __z) __RENAME_LDBL(cimag, 23, 23); /* 7.3.9.3 The conj functions */ double complex conj(double complex __z) __INTRODUCED_IN(23); float complex conjf(float complex __z) __INTRODUCED_IN(23); -long double complex conjl(long double complex __z) __INTRODUCED_IN(23); +long double complex conjl(long double complex __z) __RENAME_LDBL(conj, 23, 23); /* 7.3.9.4 The cproj functions */ double complex cproj(double complex __z) __INTRODUCED_IN(23); float complex cprojf(float complex __z) __INTRODUCED_IN(23); -long double complex cprojl(long double complex __z) __INTRODUCED_IN_32(21) __INTRODUCED_IN_64(23); +long double complex cprojl(long double complex __z) __INTRODUCED_IN_32(21) __INTRODUCED_IN_64(23) /*__RENAME_LDBL(cproj)*/; /* 7.3.9.5 The creal functions */ double creal(double complex __z) __INTRODUCED_IN(23); float crealf(float complex __z) __INTRODUCED_IN(23); -long double creall(long double complex __z) __INTRODUCED_IN(23); +long double creall(long double complex __z) __RENAME_LDBL(creal, 23, 23); __END_DECLS diff --git a/libc/include/math.h b/libc/include/math.h index 248ed3c1e..3d0ec496b 100644 --- a/libc/include/math.h +++ b/libc/include/math.h @@ -22,19 +22,26 @@ __BEGIN_DECLS -#define HUGE_VAL __builtin_huge_val() +/* C11. */ -#define FP_ILOGB0 (-INT_MAX) -#define FP_ILOGBNAN INT_MAX +typedef double __double_t; +typedef __double_t double_t; +typedef float __float_t; +typedef __float_t float_t; + +#define HUGE_VAL __builtin_huge_val() +#define HUGE_VALF __builtin_huge_valf() +#define HUGE_VALL __builtin_huge_vall() -#define HUGE_VALF __builtin_huge_valf() -#define HUGE_VALL __builtin_huge_vall() -#define INFINITY __builtin_inff() -#define NAN __builtin_nanf("") +#define INFINITY __builtin_inff() -#define MATH_ERRNO 1 -#define MATH_ERREXCEPT 2 -#define math_errhandling MATH_ERREXCEPT +#define NAN __builtin_nanf("") + +#define FP_INFINITE 0x01 +#define FP_NAN 0x02 +#define FP_NORMAL 0x04 +#define FP_SUBNORMAL 0x08 +#define FP_ZERO 0x10 #if defined(__FP_FAST_FMA) #define FP_FAST_FMA 1 @@ -46,271 +53,281 @@ __BEGIN_DECLS #define FP_FAST_FMAL 1 #endif -/* Symbolic constants to classify floating point numbers. */ -#define FP_INFINITE 0x01 -#define FP_NAN 0x02 -#define FP_NORMAL 0x04 -#define FP_SUBNORMAL 0x08 -#define FP_ZERO 0x10 -#define fpclassify(x) \ - __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, x) +#define FP_ILOGB0 (-INT_MAX) +#define FP_ILOGBNAN INT_MAX + +#define MATH_ERRNO 1 +#define MATH_ERREXCEPT 2 +#define math_errhandling MATH_ERREXCEPT + +#define fpclassify(x) __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, x) #define isfinite(x) __builtin_isfinite(x) + #define isinf(x) __builtin_isinf(x) + #define isnan(x) __builtin_isnan(x) -#define isnormal(x) __builtin_isnormal(x) -#define isgreater(x, y) __builtin_isgreater((x), (y)) -#define isgreaterequal(x, y) __builtin_isgreaterequal((x), (y)) -#define isless(x, y) __builtin_isless((x), (y)) -#define islessequal(x, y) __builtin_islessequal((x), (y)) -#define islessgreater(x, y) __builtin_islessgreater((x), (y)) -#define isunordered(x, y) __builtin_isunordered((x), (y)) +#define isnormal(x) __builtin_isnormal(x) #define signbit(x) \ ((sizeof(x) == sizeof(float)) ? __builtin_signbitf(x) \ : (sizeof(x) == sizeof(double)) ? __builtin_signbit(x) \ : __builtin_signbitl(x)) -typedef double __double_t; -typedef __double_t double_t; -typedef float __float_t; -typedef __float_t float_t; - -#if defined(__USE_BSD) -#define HUGE MAXFLOAT -#endif - -extern int signgam; - -/* - * Most of these functions depend on the rounding mode and have the side - * effect of raising floating-point exceptions, so they are not declared - * as __attribute_const__. In C99, FENV_ACCESS affects the purity of these functions. - */ - -int __fpclassifyd(double __x) __attribute_const__; -int __fpclassifyf(float __x) __attribute_const__; -int __fpclassifyl(long double __x) __attribute_const__; -int __isfinitef(float __x) __attribute_const__; -int __isfinite(double __x) __attribute_const__; -int __isfinitel(long double __x) __attribute_const__; -int __isinff(float __x) __attribute_const__; -int __isinfl(long double __x) __attribute_const__; -int __isnanf(float __x) __attribute_const__ __INTRODUCED_IN(21); -int __isnanl(long double __x) __attribute_const__; -int __isnormalf(float __x) __attribute_const__; -int __isnormal(double __x) __attribute_const__; -int __isnormall(long double __x) __attribute_const__; -int __signbit(double __x) __attribute_const__; -int __signbitf(float __x) __attribute_const__; -int __signbitl(long double __x) __attribute_const__; - double acos(double __x); +float acosf(float __x); +long double acosl(long double __x) __RENAME_LDBL(acos, 3, 21); + double asin(double __x); +float asinf(float __x); +long double asinl(long double __x) __RENAME_LDBL(asin, 3, 21); + double atan(double __x); +float atanf(float __x); +long double atanl(long double __x) __RENAME_LDBL(atan, 3, 21); + double atan2(double __y, double __x); +float atan2f(float __y, float __x); +long double atan2l(long double __y, long double __x) __RENAME_LDBL(atan2, 3, 21); + double cos(double __x); +float cosf(float __x); +long double cosl(long double __x) __RENAME_LDBL(cos, 3, 21); + double sin(double __x); +float sinf(float __x); +long double sinl(long double __x) __RENAME_LDBL(sin, 3, 21); + double tan(double __x); +float tanf(float __x); +long double tanl(long double __x) __RENAME_LDBL(tan, 3, 21); + +double acosh(double __x); +float acoshf(float __x); +long double acoshl(long double __x) __RENAME_LDBL(acosh, 3, 21); + +double asinh(double __x); +float asinhf(float __x); +long double asinhl(long double __x) __RENAME_LDBL(asinh, 3, 21); + +double atanh(double __x); +float atanhf(float __x); +long double atanhl(long double __x) __RENAME_LDBL(atanh, 3, 21); double cosh(double __x); +float coshf(float __x); +long double coshl(long double __x) __RENAME_LDBL(cosh, 3, 21); + double sinh(double __x); +float sinhf(float __x); +long double sinhl(long double __x) __RENAME_LDBL(sinh, 3, 21); + double tanh(double __x); +float tanhf(float __x); +long double tanhl(long double __x) __RENAME_LDBL(tanh, 3, 21); double exp(double __x); -double frexp(double __x, int* __exponent); /* fundamentally !__attribute_const__ */ -double ldexp(double __x, int __exponent); -double log(double __x); -double log10(double __x); -double modf(double __x, double* __integral_part); /* fundamentally !__attribute_const__ */ - -double pow(double __x, double __y); -double sqrt(double __x); - -double ceil(double __x); -double fabs(double __x) __attribute_const__; -double floor(double __x); -double fmod(double __x, double __y); +float expf(float __x); +long double expl(long double __x) __RENAME_LDBL(exp, 3, 21); -double acosh(double __x); -double asinh(double __x); -double atanh(double __x); -double cbrt(double __x); -double erf(double __x); -double erfc(double __x); double exp2(double __x); +float exp2f(float __x); +long double exp2l(long double __x) __RENAME_LDBL(exp2, 3, 21); + double expm1(double __x); -double fma(double __x, double __y, double __z); -double hypot(double __x, double __y); +float expm1f(float __x); +long double expm1l(long double __x) __RENAME_LDBL(expm1, 3, 21); + +double frexp(double __x, int* __exponent); +float frexpf(float __x, int* __exponent); +long double frexpl(long double __x, int* __exponent) __RENAME_LDBL(frexp, 3, 21); + int ilogb(double __x) __attribute_const__; -double lgamma(double __x); -long long llrint(double __x); -long long llround(double __x); +int ilogbf(float __x) __attribute_const__; +int ilogbl(long double __x) __attribute_const__ __RENAME_LDBL(ilogb, 3, 3); + +double ldexp(double __x, int __exponent); +float ldexpf(float __x, int __exponent); +long double ldexpl(long double __x, int __exponent) __RENAME_LDBL(ldexp, 3, 3); + +double log(double __x); +float logf(float __x); +long double logl(long double __x) __RENAME_LDBL(log, 3, 21); + +double log10(double __x); +float log10f(float __x); +long double log10l(long double __x) __RENAME_LDBL(log10, 3, 21); + double log1p(double __x); +float log1pf(float __x); +long double log1pl(long double __x) __RENAME_LDBL(log1p, 3, 21); + double log2(double __x) __INTRODUCED_IN(18); -double logb(double __x); -long lrint(double __x); -long lround(double __x); +float log2f(float __x) __INTRODUCED_IN(18); +long double log2l(long double __x) __RENAME_LDBL(log2, 18, 18); -/* - * https://code.google.com/p/android/issues/detail?id=271629 - * To be fully compliant with C++, we need to not define these (C doesn't - * specify them either). Exposing these means that isinf and isnan will have a - * return type of int in C++ rather than bool like they're supposed to be. - * - * GNU libstdc++ 4.9 isn't able to handle a standard compliant C library. Its - * <cmath> will `#undef isnan` from math.h and only adds the function overloads - * to the std namespace, making it impossible to use both <cmath> (which gets - * included by a lot of other standard headers) and ::isnan. - */ -int (isinf)(double __x) __attribute_const__ __INTRODUCED_IN(21); -int (isnan)(double __x) __attribute_const__; +double logb(double __x); +float logbf(float __x); +long double logbl(long double __x) __RENAME_LDBL(logb, 3, 18); -double nan(const char* __kind) __attribute_const__ __INTRODUCED_IN_ARM(13) __INTRODUCED_IN_MIPS(13) - __INTRODUCED_IN_X86(9); +double modf(double __x, double* __integral_part); +float modff(float __x, float* __integral_part); +long double modfl(long double __x, long double* __integral_part) __RENAME_LDBL(modf, 3, 21); -double nextafter(double __x, double __y); -double remainder(double __x, double __y); -double remquo(double __x, double __y, int* __quotient_bits); -double rint(double __x); +double scalbn(double __x, int __exponent); +float scalbnf(float __x, int __exponent); +long double scalbnl(long double __x, int __exponent) __RENAME_LDBL(scalbn, 3, 3); -double copysign(double __value, double __sign) __attribute_const__; -double fdim(double __x, double __y); -double fmax(double __x, double __y) __attribute_const__; -double fmin(double __x, double __y) __attribute_const__; -double nearbyint(double __x); -double round(double __x); +/* TODO: once the NDK only supports >= 18, use __RENAME_LDBL here too. */ double scalbln(double __x, long __exponent) __INTRODUCED_IN_X86(18) __VERSIONER_NO_GUARD; -double scalbn(double __x, int __exponent); -double tgamma(double __x); -double trunc(double __x); +float scalblnf(float __x, long __exponent) __INTRODUCED_IN_X86(18) __VERSIONER_NO_GUARD; +long double scalblnl(long double __x, long __exponent) __INTRODUCED_IN_X86(18) __VERSIONER_NO_GUARD; -float acosf(float __x); -float asinf(float __x); -float atanf(float __x); -float atan2f(float __y, float __x); -float cosf(float __x); -float sinf(float __x); -float tanf(float __x); +double cbrt(double __x); +float cbrtf(float __x); +long double cbrtl(long double __x) __RENAME_LDBL(cbrt, 3, 21); -float coshf(float __x); -float sinhf(float __x); -float tanhf(float __x); +double fabs(double __x) __attribute_const__; +float fabsf(float __x) __attribute_const__; +long double fabsl(long double __x) __attribute_const__ __RENAME_LDBL(fabs, 3, 3); -float exp2f(float __x); -float expf(float __x); -float expm1f(float __x); -float frexpf(float __x, int* __exponent); /* fundamentally !__attribute_const__ */ -int ilogbf(float __x) __attribute_const__; -float ldexpf(float __x, int __exponent); -float log10f(float __x); -float log1pf(float __x); -float log2f(float __x) __INTRODUCED_IN(18); -float logf(float __x); -float modff(float __x, float* __integral_part); /* fundamentally !__attribute_const__ */ +double hypot(double __x, double __y); +float hypotf(float __x, float __y); +long double hypotl(long double __x, long double __y) __RENAME_LDBL(hypot, 3, 21); +double pow(double __x, double __y); float powf(float __x, float __y); -float sqrtf(float __x); +long double powl(long double __x, long double __y) __RENAME_LDBL(pow, 3, 21); -float ceilf(float __x); -float fabsf(float __x) __attribute_const__; -float floorf(float __x); -float fmodf(float __x, float __y); -float roundf(float __x); +double sqrt(double __x); +float sqrtf(float __x); +long double sqrtl(long double __x) __RENAME_LDBL(sqrt, 3, 21); +double erf(double __x); float erff(float __x); +long double erfl(long double __x) __RENAME_LDBL(erf, 3, 21); + +double erfc(double __x); float erfcf(float __x); -float hypotf(float __x, float __y); +long double erfcl(long double __x) __RENAME_LDBL(erfc, 3, 21); + +double lgamma(double __x); float lgammaf(float __x); +long double lgammal(long double __x) __RENAME_LDBL(lgamma, 3, 21); + +double tgamma(double __x); float tgammaf(float __x) __INTRODUCED_IN_ARM(13) __INTRODUCED_IN_MIPS(13) __INTRODUCED_IN_X86(9); +long double tgammal(long double __x) __RENAME_LDBL(tgamma, 3, 21); -float acoshf(float __x); -float asinhf(float __x); -float atanhf(float __x); -float cbrtf(float __x); -float logbf(float __x); -float copysignf(float __value, float __sign) __attribute_const__; -long long llrintf(float __x); -long long llroundf(float __x); +double ceil(double __x); +float ceilf(float __x); +long double ceill(long double __x) __RENAME_LDBL(ceil, 3, 3); + +double floor(double __x); +float floorf(float __x); +long double floorl(long double __x) __RENAME_LDBL(floor, 3, 3); + +double nearbyint(double __x); +float nearbyintf(float __x); +long double nearbyintl(long double __x) __RENAME_LDBL(nearbyint, 3, 21); + +double rint(double __x); +float rintf(float __x); +long double rintl(long double __x) __RENAME_LDBL(rint, 3, 21); + +long lrint(double __x); long lrintf(float __x); +long lrintl(long double __x) __RENAME_LDBL(lrint, 3, 21); + +long long llrint(double __x); +long long llrintf(float __x); +long long llrintl(long double __x) __RENAME_LDBL(llrint, 3, 21); + +double round(double __x); +float roundf(float __x); +long double roundl(long double __x) __RENAME_LDBL(roundl, 3, 3); + +long lround(double __x); long lroundf(float __x); -float nanf(const char* __kind) __attribute_const__ __INTRODUCED_IN_ARM(13) __INTRODUCED_IN_MIPS(13) - __INTRODUCED_IN_X86(9); -float nearbyintf(float __x); -float nextafterf(float __x, float __y); +long lroundl(long double __x) __RENAME_LDBL(lround, 3, 3); + +long long llround(double __x); +long long llroundf(float __x); +long long llroundl(long double __x) __RENAME_LDBL(llround, 3, 3); + +double trunc(double __x); +float truncf(float __x); +long double truncl(long double __x) __RENAME_LDBL(trunc, 3, 3); + +double fmod(double __x, double __y); +float fmodf(float __x, float __y); +long double fmodl(long double __x, long double __y) __RENAME_LDBL(fmod, 3, 21); + +double remainder(double __x, double __y); float remainderf(float __x, float __y); +long double remainderl(long double __x, long double __y) __RENAME_LDBL(remainder, 3, 21); + +double remquo(double __x, double __y, int* __quotient_bits); float remquof(float __x, float __y, int* __quotient_bits); -float rintf(float __x); -float scalblnf(float __x, long __exponent) __INTRODUCED_IN_X86(18) __VERSIONER_NO_GUARD; -float scalbnf(float __x, int __exponent); -float truncf(float __x); +long double remquol(long double __x, long double __y, int* __quotient_bits) __RENAME_LDBL(remquo, 3, 21); + +double copysign(double __value, double __sign) __attribute_const__; +float copysignf(float __value, float __sign) __attribute_const__; +long double copysignl(long double __value, long double __sign) __attribute_const__ __RENAME_LDBL(copysign, 3, 3); + +double nan(const char* __kind) __attribute_const__ __INTRODUCED_IN_ARM(13) __INTRODUCED_IN_MIPS(13) __INTRODUCED_IN_X86(9); +float nanf(const char* __kind) __attribute_const__ __INTRODUCED_IN_ARM(13) __INTRODUCED_IN_MIPS(13) __INTRODUCED_IN_X86(9); +long double nanl(const char* __kind) __attribute_const__ __RENAME_LDBL(nan, 13, 13); + +double nextafter(double __x, double __y); +float nextafterf(float __x, float __y); +long double nextafterl(long double __x, long double __y) __RENAME_LDBL(nextafter, 3, 21) __VERSIONER_NO_GUARD; +double nexttoward(double __x, long double __y) __INTRODUCED_IN(18) __VERSIONER_NO_GUARD; +float nexttowardf(float __x, long double __y); +long double nexttowardl(long double __x, long double __y) __RENAME_LDBL(nexttoward, 18, 18) __VERSIONER_NO_GUARD; + +double fdim(double __x, double __y); float fdimf(float __x, float __y); -float fmaf(float __x, float __y, float __z); +long double fdiml(long double __x, long double __y) __RENAME_LDBL(fdim, 3, 3); + +double fmax(double __x, double __y) __attribute_const__; float fmaxf(float __x, float __y) __attribute_const__; +long double fmaxl(long double __x, long double __y) __attribute_const__ __RENAME_LDBL(fmax, 3, 3); + +double fmin(double __x, double __y) __attribute_const__; float fminf(float __x, float __y) __attribute_const__; +long double fminl(long double __x, long double __y) __attribute_const__ __RENAME_LDBL(fmin, 3, 3); -long double acoshl(long double __x) __INTRODUCED_IN(21); -long double acosl(long double __x) __INTRODUCED_IN(21); -long double asinhl(long double __x) __INTRODUCED_IN(21); -long double asinl(long double __x) __INTRODUCED_IN(21); -long double atan2l(long double __y, long double __x) __INTRODUCED_IN(21); -long double atanhl(long double __x) __INTRODUCED_IN(21); -long double atanl(long double __x) __INTRODUCED_IN(21); -long double cbrtl(long double __x) __INTRODUCED_IN(21); -long double ceill(long double __x); -long double copysignl(long double __value, long double __sign) __attribute_const__; -long double coshl(long double __x) __INTRODUCED_IN(21); -long double cosl(long double __x) __INTRODUCED_IN(21); -long double erfcl(long double __x) __INTRODUCED_IN(21); -long double erfl(long double __x) __INTRODUCED_IN(21); -long double exp2l(long double __x) __INTRODUCED_IN(21); -long double expl(long double __x) __INTRODUCED_IN(21); -long double expm1l(long double __x) __INTRODUCED_IN(21); -long double fabsl(long double __x) __attribute_const__; -long double fdiml(long double __x, long double __y); -long double floorl(long double __x); -long double fmal(long double __x, long double __y, long double __z) __INTRODUCED_IN(21) __VERSIONER_NO_GUARD; -long double fmaxl(long double __x, long double __y) __attribute_const__; -long double fminl(long double __x, long double __y) __attribute_const__; -long double fmodl(long double __x, long double __y) __INTRODUCED_IN(21); -long double frexpl(long double __x, int* __exponent) - __INTRODUCED_IN(21) __VERSIONER_NO_GUARD; /* fundamentally !__attribute_const__ */ -long double hypotl(long double __x, long double __y) __INTRODUCED_IN(21); -int ilogbl(long double __x) __attribute_const__; -long double ldexpl(long double __x, int __exponent); -long double lgammal(long double __x) __INTRODUCED_IN(21); -long long llrintl(long double __x) __INTRODUCED_IN(21); -long long llroundl(long double __x); -long double log10l(long double __x) __INTRODUCED_IN(21); -long double log1pl(long double __x) __INTRODUCED_IN(21); -long double log2l(long double __x) __INTRODUCED_IN(18); -long double logbl(long double __x) __INTRODUCED_IN(18); -long double logl(long double __x) __INTRODUCED_IN(21); -long lrintl(long double __x) __INTRODUCED_IN(21); -long lroundl(long double __x); -long double modfl(long double __x, long double* __integral_part) __INTRODUCED_IN(21); /* fundamentally !__attribute_const__ */ -long double nanl(const char* __kind) __attribute_const__ __INTRODUCED_IN(13); -long double nearbyintl(long double __x) __INTRODUCED_IN(21); -long double nextafterl(long double __x, long double __y) __INTRODUCED_IN(21) __VERSIONER_NO_GUARD; -double nexttoward(double __x, long double __y) __INTRODUCED_IN(18) __VERSIONER_NO_GUARD; -float nexttowardf(float __x, long double __y); -long double nexttowardl(long double __x, long double __y) __INTRODUCED_IN(18) __VERSIONER_NO_GUARD; -long double powl(long double __x, long double __y) __INTRODUCED_IN(21); -long double remainderl(long double __x, long double __y) __INTRODUCED_IN(21); -long double remquol(long double __x, long double __y, int* __quotient_bits) __INTRODUCED_IN(21); -long double rintl(long double __x) __INTRODUCED_IN(21); -long double roundl(long double __x); -long double scalblnl(long double __x, long __exponent) __INTRODUCED_IN_X86(18) __VERSIONER_NO_GUARD; -long double scalbnl(long double __x, int __exponent); -long double sinhl(long double __x) __INTRODUCED_IN(21); -long double sinl(long double __x) __INTRODUCED_IN(21); -long double sqrtl(long double __x) __INTRODUCED_IN(21); -long double tanhl(long double __x) __INTRODUCED_IN(21); -long double tanl(long double __x) __INTRODUCED_IN(21); -long double tgammal(long double __x) __INTRODUCED_IN(21); -long double truncl(long double __x); +double fma(double __x, double __y, double __z); +float fmaf(float __x, float __y, float __z); +long double fmal(long double __x, long double __y, long double __z) __RENAME_LDBL(fma, 3, 21) __VERSIONER_NO_GUARD; + +#define isgreater(x, y) __builtin_isgreater((x), (y)) +#define isgreaterequal(x, y) __builtin_isgreaterequal((x), (y)) +#define isless(x, y) __builtin_isless((x), (y)) +#define islessequal(x, y) __builtin_islessequal((x), (y)) +#define islessgreater(x, y) __builtin_islessgreater((x), (y)) +#define isunordered(x, y) __builtin_isunordered((x), (y)) + +/* + * https://code.google.com/p/android/issues/detail?id=271629 + * To be fully compliant with C++, we need to not define these (C doesn't + * specify them either). Exposing these means that isinf and isnan will have a + * return type of int in C++ rather than bool like they're supposed to be. + * + * GNU libstdc++ 4.9 isn't able to handle a standard compliant C library. Its + * <cmath> will `#undef isnan` from math.h and only adds the function overloads + * to the std namespace, making it impossible to use both <cmath> (which gets + * included by a lot of other standard headers) and ::isnan. + */ +int (isinf)(double __x) __attribute_const__ __INTRODUCED_IN(21); +int (isnan)(double __x) __attribute_const__; + +/* POSIX extensions. */ + +extern int signgam; double j0(double __x); double j1(double __x); @@ -335,6 +352,38 @@ double yn(int __n, double __x); #define MAXFLOAT ((float)3.40282346638528860e+38) +/* Legacy cruft from before we had builtin implementations of the standard macros. */ + +int __fpclassifyd(double __x) __attribute_const__; +int __fpclassifyf(float __x) __attribute_const__; +int __fpclassifyl(long double __x) __attribute_const__; + +int __isfinitef(float __x) __attribute_const__; +int __isfinite(double __x) __attribute_const__; +int __isfinitel(long double __x) __attribute_const__; + +int __isinff(float __x) __attribute_const__; +int __isinfl(long double __x) __attribute_const__; + +int __isnanf(float __x) __attribute_const__ __INTRODUCED_IN(21); +int __isnanl(long double __x) __attribute_const__; + +int __isnormal(double __x) __attribute_const__; +int __isnormalf(float __x) __attribute_const__; +int __isnormall(long double __x) __attribute_const__; + +int __signbit(double __x) __attribute_const__; +int __signbitf(float __x) __attribute_const__; +int __signbitl(long double __x) __attribute_const__; + +/* BSD extensions. */ + +#if defined(__USE_BSD) +#define HUGE MAXFLOAT +#endif + +/* Extensions in both BSD and GNU. */ + #if defined(__USE_BSD) || defined(__USE_GNU) double gamma(double __x); double scalb(double __x, double __exponent); @@ -361,6 +410,8 @@ float lgammaf_r(float __x, int* __sign); float significandf(float __x); #endif +/* GNU extensions. */ + #if defined(__USE_GNU) #define M_El 2.718281828459045235360287471352662498L /* e */ #define M_LOG2El 1.442695040888963407359924681001892137L /* log 2e */ diff --git a/libc/include/stdlib.h b/libc/include/stdlib.h index 4182f2dff..86336a057 100644 --- a/libc/include/stdlib.h +++ b/libc/include/stdlib.h @@ -75,7 +75,7 @@ unsigned long long strtoull(const char* __s, char** __end_ptr, int __base); int posix_memalign(void** __memptr, size_t __alignment, size_t __size) __INTRODUCED_IN(16); double strtod(const char* __s, char** __end_ptr); -long double strtold(const char* __s, char** __end_ptr) __INTRODUCED_IN(21); +long double strtold(const char* __s, char** __end_ptr) __RENAME_LDBL(strtod, 3, 21); unsigned long strtoul_l(const char* __s, char** __end_ptr, int __base, locale_t __l) __INTRODUCED_IN(26); diff --git a/libc/include/sys/cdefs.h b/libc/include/sys/cdefs.h index 58eebc575..063b51d3c 100644 --- a/libc/include/sys/cdefs.h +++ b/libc/include/sys/cdefs.h @@ -37,6 +37,11 @@ #ifndef _SYS_CDEFS_H_ #define _SYS_CDEFS_H_ +#include <android/api-level.h> +#include <android/versioning.h> + +#define __BIONIC__ 1 + /* * Testing against Clang-specific extensions. */ @@ -219,8 +224,21 @@ #define __RENAME_IF_FILE_OFFSET64(func) #endif -#define __BIONIC__ 1 -#include <android/api-level.h> +/* + * For LP32, `long double` == `double`. Historically many `long double` functions were incorrect + * on x86, missing on most architectures, and even if they are present and correct, linking to + * them just bloats your ELF file by adding extra relocations. The __BIONIC_LP32_USE_LONG_DOUBLE + * macro lets us test the headers both ways (and adds an escape valve). + * + * Note that some functions have their __RENAME_LDBL commented out as a sign that although we could + * use __RENAME_LDBL it would actually cause the function to be introduced later because the + * `long double` variant appeared before the `double` variant. + */ +#if defined(__LP64__) || defined(__BIONIC_LP32_USE_LONG_DOUBLE) +#define __RENAME_LDBL(rewrite,rewrite_api_level,regular_api_level) __INTRODUCED_IN(regular_api_level) +#else +#define __RENAME_LDBL(rewrite,rewrite_api_level,regular_api_level) __RENAME(rewrite) __INTRODUCED_IN(rewrite_api_level) +#endif /* glibc compatibility. */ #if defined(__LP64__) @@ -334,8 +352,6 @@ /* Used to rename functions so that the compiler emits a call to 'x' rather than the function this was applied to. */ #define __RENAME(x) __asm__(#x) -#include <android/versioning.h> - #if __has_builtin(__builtin_umul_overflow) || __GNUC__ >= 5 #if defined(__LP64__) #define __size_mul_overflow(a, b, result) __builtin_umull_overflow(a, b, result) diff --git a/libc/include/wchar.h b/libc/include/wchar.h index 1dda4bd9c..1cf498c83 100644 --- a/libc/include/wchar.h +++ b/libc/include/wchar.h @@ -98,7 +98,7 @@ float wcstof(const wchar_t* __s, wchar_t** __end_ptr) __INTRODUCED_IN(21); wchar_t* wcstok(wchar_t* __s, const wchar_t* __delimiter, wchar_t** __ptr); long wcstol(const wchar_t* __s, wchar_t** __end_ptr, int __base); long long wcstoll(const wchar_t* __s, wchar_t** __end_ptr, int __base) __INTRODUCED_IN(21); -long double wcstold(const wchar_t* __s, wchar_t** __end_ptr) __INTRODUCED_IN(21); +long double wcstold(const wchar_t* __s, wchar_t** __end_ptr) __RENAME_LDBL(wcstod, 3, 21); unsigned long wcstoul(const wchar_t* __s, wchar_t** __end_ptr, int __base); unsigned long long wcstoull(const wchar_t* __s, wchar_t** __end_ptr, int __base) __INTRODUCED_IN(21); int wcswidth(const wchar_t* __s, size_t __n); diff --git a/libm/Android.bp b/libm/Android.bp index e5cb02931..bf8626450 100644 --- a/libm/Android.bp +++ b/libm/Android.bp @@ -506,6 +506,7 @@ cc_library { ], cflags: [ + "-D__BIONIC_LP32_USE_LONG_DOUBLE", "-D__BIONIC_NO_MATH_INLINES", "-D_BSD_SOURCE", "-DFLT_EVAL_METHOD=0", diff --git a/tests/Android.bp b/tests/Android.bp index 075822a41..37311563a 100644 --- a/tests/Android.bp +++ b/tests/Android.bp @@ -57,6 +57,7 @@ cc_test_library { "buffer_tests.cpp", "bug_26110743_test.cpp", "complex_test.cpp", + "complex_force_long_double_test.cpp", "ctype_test.cpp", "dirent_test.cpp", "elf_test.cpp", @@ -84,6 +85,7 @@ cc_test_library { "locale_test.cpp", "malloc_test.cpp", "math_test.cpp", + "math_force_long_double_test.cpp", "mntent_test.cpp", "netdb_test.cpp", "net_if_test.cpp", diff --git a/tests/complex_force_long_double_test.cpp b/tests/complex_force_long_double_test.cpp new file mode 100644 index 000000000..2ea7bd449 --- /dev/null +++ b/tests/complex_force_long_double_test.cpp @@ -0,0 +1,2 @@ +#define __BIONIC_LP32_USE_LONG_DOUBLE +#include "complex_test.cpp" diff --git a/tests/complex_test.cpp b/tests/complex_test.cpp index 3a5ef7430..85b20de40 100644 --- a/tests/complex_test.cpp +++ b/tests/complex_test.cpp @@ -16,6 +16,12 @@ #include <gtest/gtest.h> +#if defined(__BIONIC_LP32_USE_LONG_DOUBLE) +#define COMPLEX_TEST complex_h_force_long_double +#else +#define COMPLEX_TEST complex_h +#endif + // This file is compiled against both glibc and bionic, and our complex.h // depends on bionic-specific macros, so hack around that. #include <sys/cdefs.h> @@ -24,6 +30,7 @@ #define __INTRODUCED_IN_32(x) #define __INTRODUCED_IN_64(x) #define __INTRODUCED_IN_FUTURE +#define __RENAME_LDBL(a,b,c) #endif // libc++ actively gets in the way of including <complex.h> from C++, so we @@ -36,6 +43,7 @@ #include <math.h> // For M_PI_2/M_PI_2l. +#if 0 // Note that gtest doesn't support complex numbers, so the output from // assertion failures is misleading/useless (at best you'll only see the real // part). @@ -54,267 +62,268 @@ std::ostream& operator<<(std::ostream& os, const long double _Complex c) { os << "(" << creall(c) << "," << cimagl(c) << "i)"; return os; } +#endif -TEST(complex, cabs) { +TEST(COMPLEX_TEST, cabs) { ASSERT_EQ(0.0, cabs(0)); } -TEST(complex, cabsf) { +TEST(COMPLEX_TEST, cabsf) { ASSERT_EQ(0.0, cabsf(0)); } -TEST(complex, cabsl) { +TEST(COMPLEX_TEST, cabsl) { ASSERT_EQ(0.0, cabsl(0)); } -TEST(complex, cacos) { +TEST(COMPLEX_TEST, cacos) { ASSERT_EQ(M_PI_2, cacos(0.0)); } -TEST(complex, cacosf) { +TEST(COMPLEX_TEST, cacosf) { ASSERT_EQ(static_cast<float>(M_PI_2), cacosf(0.0)); } -TEST(complex, cacosl) { +TEST(COMPLEX_TEST, cacosl) { ASSERT_EQ(M_PI_2l, cacosl(0.0)); } -TEST(complex, cacosh) { +TEST(COMPLEX_TEST, cacosh) { ASSERT_EQ(0.0, cacosh(1.0)); } -TEST(complex, cacoshl) { +TEST(COMPLEX_TEST, cacoshl) { ASSERT_EQ(0.0, cacoshl(1.0)); } -TEST(complex, cacoshf) { +TEST(COMPLEX_TEST, cacoshf) { ASSERT_EQ(0.0, cacoshf(1.0)); } -TEST(complex, carg) { +TEST(COMPLEX_TEST, carg) { ASSERT_EQ(0.0, carg(0)); } -TEST(complex, cargf) { +TEST(COMPLEX_TEST, cargf) { ASSERT_EQ(0.0, cargf(0)); } -TEST(complex, cargl) { +TEST(COMPLEX_TEST, cargl) { ASSERT_EQ(0.0, cargl(0)); } -TEST(complex, casin) { +TEST(COMPLEX_TEST, casin) { ASSERT_EQ(0.0, casin(0)); } -TEST(complex, casinf) { +TEST(COMPLEX_TEST, casinf) { ASSERT_EQ(0.0, casinf(0)); } -TEST(complex, casinl) { +TEST(COMPLEX_TEST, casinl) { ASSERT_EQ(0.0, casinl(0)); } -TEST(complex, casinh) { +TEST(COMPLEX_TEST, casinh) { ASSERT_EQ(0.0, casinh(0)); } -TEST(complex, casinhf) { +TEST(COMPLEX_TEST, casinhf) { ASSERT_EQ(0.0, casinhf(0)); } -TEST(complex, casinhl) { +TEST(COMPLEX_TEST, casinhl) { ASSERT_EQ(0.0, casinhl(0)); } -TEST(complex, catan) { +TEST(COMPLEX_TEST, catan) { ASSERT_EQ(0.0, catan(0)); } -TEST(complex, catanf) { +TEST(COMPLEX_TEST, catanf) { ASSERT_EQ(0.0, catanf(0)); } -TEST(complex, catanl) { +TEST(COMPLEX_TEST, catanl) { ASSERT_EQ(0.0, catanl(0)); } -TEST(complex, catanh) { +TEST(COMPLEX_TEST, catanh) { ASSERT_EQ(0.0, catanh(0)); } -TEST(complex, catanhf) { +TEST(COMPLEX_TEST, catanhf) { ASSERT_EQ(0.0, catanhf(0)); } -TEST(complex, catanhl) { +TEST(COMPLEX_TEST, catanhl) { ASSERT_EQ(0.0, catanhl(0)); } -TEST(complex, ccos) { +TEST(COMPLEX_TEST, ccos) { ASSERT_EQ(1.0, ccos(0)); } -TEST(complex, ccosf) { +TEST(COMPLEX_TEST, ccosf) { ASSERT_EQ(1.0, ccosf(0)); } -TEST(complex, ccosl) { +TEST(COMPLEX_TEST, ccosl) { ASSERT_EQ(1.0, ccosl(0)); } -TEST(complex, ccosh) { +TEST(COMPLEX_TEST, ccosh) { ASSERT_EQ(1.0, ccosh(0)); } -TEST(complex, ccoshf) { +TEST(COMPLEX_TEST, ccoshf) { ASSERT_EQ(1.0, ccoshf(0)); } -TEST(complex, ccoshl) { +TEST(COMPLEX_TEST, ccoshl) { ASSERT_EQ(1.0, ccoshl(0)); } -TEST(complex, cexp) { +TEST(COMPLEX_TEST, cexp) { ASSERT_EQ(1.0, cexp(0)); } -TEST(complex, cexpf) { +TEST(COMPLEX_TEST, cexpf) { ASSERT_EQ(1.0, cexpf(0)); } -TEST(complex, cexpl) { +TEST(COMPLEX_TEST, cexpl) { ASSERT_EQ(1.0, cexpl(0)); } -TEST(complex, cimag) { +TEST(COMPLEX_TEST, cimag) { ASSERT_EQ(0.0, cimag(0)); } -TEST(complex, cimagf) { +TEST(COMPLEX_TEST, cimagf) { ASSERT_EQ(0.0f, cimagf(0)); } -TEST(complex, cimagl) { +TEST(COMPLEX_TEST, cimagl) { ASSERT_EQ(0.0, cimagl(0)); } -TEST(complex, clog) { +TEST(COMPLEX_TEST, clog) { ASSERT_EQ(0.0, clog(1.0)); } -TEST(complex, clogf) { +TEST(COMPLEX_TEST, clogf) { ASSERT_EQ(0.0f, clogf(1.0f)); } -TEST(complex, clogl) { +TEST(COMPLEX_TEST, clogl) { ASSERT_EQ(0.0L, clogl(1.0L)); } -TEST(complex, conj) { +TEST(COMPLEX_TEST, conj) { ASSERT_EQ(0.0, conj(0)); } -TEST(complex, conjf) { +TEST(COMPLEX_TEST, conjf) { ASSERT_EQ(0.0f, conjf(0)); } -TEST(complex, conjl) { +TEST(COMPLEX_TEST, conjl) { ASSERT_EQ(0.0, conjl(0)); } -TEST(complex, cpow) { +TEST(COMPLEX_TEST, cpow) { ASSERT_EQ(8.0, cpow(2.0, 3.0)); } -TEST(complex, cpowf) { +TEST(COMPLEX_TEST, cpowf) { ASSERT_EQ(8.0f, cpowf(2.0f, 3.0f)); } -TEST(complex, cpowl) { +TEST(COMPLEX_TEST, cpowl) { ASSERT_EQ(8.0L, cpowl(2.0L, 3.0L)); } -TEST(complex, cproj) { +TEST(COMPLEX_TEST, cproj) { ASSERT_EQ(0.0, cproj(0)); } -TEST(complex, cprojf) { +TEST(COMPLEX_TEST, cprojf) { ASSERT_EQ(0.0f, cprojf(0)); } -TEST(complex, cprojl) { +TEST(COMPLEX_TEST, cprojl) { ASSERT_EQ(0.0, cprojl(0)); } -TEST(complex, creal) { +TEST(COMPLEX_TEST, creal) { ASSERT_EQ(2.0, creal(2.0 + 3.0I)); } -TEST(complex, crealf) { +TEST(COMPLEX_TEST, crealf) { ASSERT_EQ(2.0f, crealf(2.0f + 3.0fI)); } -TEST(complex, creall) { +TEST(COMPLEX_TEST, creall) { ASSERT_EQ(2.0, creall(2.0L + 3.0LI)); } -TEST(complex, csin) { +TEST(COMPLEX_TEST, csin) { ASSERT_EQ(0.0, csin(0)); } -TEST(complex, csinf) { +TEST(COMPLEX_TEST, csinf) { ASSERT_EQ(0.0, csinf(0)); } -TEST(complex, csinl) { +TEST(COMPLEX_TEST, csinl) { ASSERT_EQ(0.0, csinl(0)); } -TEST(complex, csinh) { +TEST(COMPLEX_TEST, csinh) { ASSERT_EQ(0.0, csinh(0)); } -TEST(complex, csinhf) { +TEST(COMPLEX_TEST, csinhf) { ASSERT_EQ(0.0, csinhf(0)); } -TEST(complex, csinhl) { +TEST(COMPLEX_TEST, csinhl) { ASSERT_EQ(0.0, csinhl(0)); } -TEST(complex, csqrt) { +TEST(COMPLEX_TEST, csqrt) { ASSERT_EQ(0.0, csqrt(0)); } -TEST(complex, csqrtf) { +TEST(COMPLEX_TEST, csqrtf) { ASSERT_EQ(0.0f, csqrtf(0)); } -TEST(complex, csqrtl) { +TEST(COMPLEX_TEST, csqrtl) { ASSERT_EQ(0.0, csqrtl(0)); } -TEST(complex, ctan) { +TEST(COMPLEX_TEST, ctan) { ASSERT_EQ(0.0, ctan(0)); } -TEST(complex, ctanf) { +TEST(COMPLEX_TEST, ctanf) { ASSERT_EQ(0.0, ctanf(0)); } -TEST(complex, ctanl) { +TEST(COMPLEX_TEST, ctanl) { ASSERT_EQ(0.0, ctanl(0)); } -TEST(complex, ctanh) { +TEST(COMPLEX_TEST, ctanh) { ASSERT_EQ(0.0, ctanh(0)); } -TEST(complex, ctanhf) { +TEST(COMPLEX_TEST, ctanhf) { ASSERT_EQ(0.0, ctanhf(0)); } -TEST(complex, ctanhl) { +TEST(COMPLEX_TEST, ctanhl) { ASSERT_EQ(0.0, ctanhl(0)); } diff --git a/tests/math_force_long_double_test.cpp b/tests/math_force_long_double_test.cpp new file mode 100644 index 000000000..432182b72 --- /dev/null +++ b/tests/math_force_long_double_test.cpp @@ -0,0 +1,2 @@ +#define __BIONIC_LP32_USE_LONG_DOUBLE +#include "math_test.cpp" diff --git a/tests/math_test.cpp b/tests/math_test.cpp index b960944bc..0fc4e505a 100644 --- a/tests/math_test.cpp +++ b/tests/math_test.cpp @@ -48,6 +48,12 @@ template<typename T> inline int test_capture_isinf(const T in) { } } +#if defined(__BIONIC_LP32_USE_LONG_DOUBLE) +#define MATH_TEST math_h_force_long_double +#else +#define MATH_TEST math_h +#endif + #include "math_data_test.h" #include <gtest/gtest.h> @@ -59,7 +65,7 @@ template<typename T> inline int test_capture_isinf(const T in) { #include <android-base/scopeguard.h> -float float_subnormal() { +static float float_subnormal() { union { float f; uint32_t i; @@ -68,7 +74,7 @@ float float_subnormal() { return u.f; } -double double_subnormal() { +static double double_subnormal() { union { double d; uint64_t i; @@ -77,7 +83,7 @@ double double_subnormal() { return u.d; } -long double ldouble_subnormal() { +static long double ldouble_subnormal() { union { long double e; unsigned char c[sizeof(long double)]; @@ -96,7 +102,7 @@ long double ldouble_subnormal() { return u.e; } -TEST(math, fpclassify) { +TEST(MATH_TEST, fpclassify) { ASSERT_EQ(FP_INFINITE, fpclassify(INFINITY)); ASSERT_EQ(FP_INFINITE, fpclassify(HUGE_VALF)); ASSERT_EQ(FP_INFINITE, fpclassify(HUGE_VAL)); @@ -119,7 +125,7 @@ TEST(math, fpclassify) { ASSERT_EQ(FP_ZERO, fpclassify(0.0L)); } -TEST(math, isfinite) { +TEST(MATH_TEST, isfinite) { ASSERT_TRUE(test_capture_isfinite(123.0f)); ASSERT_TRUE(test_capture_isfinite(123.0)); ASSERT_TRUE(test_capture_isfinite(123.0L)); @@ -128,7 +134,7 @@ TEST(math, isfinite) { ASSERT_FALSE(test_capture_isfinite(HUGE_VALL)); } -TEST(math, isinf) { +TEST(MATH_TEST, isinf) { ASSERT_FALSE(test_capture_isinf(123.0f)); ASSERT_FALSE(test_capture_isinf(123.0)); ASSERT_FALSE(test_capture_isinf(123.0L)); @@ -137,7 +143,7 @@ TEST(math, isinf) { ASSERT_TRUE(test_capture_isinf(HUGE_VALL)); } -TEST(math, isnan) { +TEST(MATH_TEST, isnan) { ASSERT_FALSE(test_capture_isnan(123.0f)); ASSERT_FALSE(test_capture_isnan(123.0)); ASSERT_FALSE(test_capture_isnan(123.0L)); @@ -146,7 +152,7 @@ TEST(math, isnan) { ASSERT_TRUE(test_capture_isnan(nanl(""))); } -TEST(math, isnormal) { +TEST(MATH_TEST, isnormal) { ASSERT_TRUE(isnormal(123.0f)); ASSERT_TRUE(isnormal(123.0)); ASSERT_TRUE(isnormal(123.0L)); @@ -156,7 +162,7 @@ TEST(math, isnormal) { } // TODO: isgreater, isgreaterequals, isless, islessequal, islessgreater, isunordered -TEST(math, signbit) { +TEST(MATH_TEST, signbit) { ASSERT_EQ(0, test_capture_signbit(0.0f)); ASSERT_EQ(0, test_capture_signbit(0.0)); ASSERT_EQ(0, test_capture_signbit(0.0L)); @@ -170,7 +176,7 @@ TEST(math, signbit) { ASSERT_NE(0, test_capture_signbit(-1.0L)); } -TEST(math, __fpclassifyd) { +TEST(MATH_TEST, __fpclassifyd) { #if defined(__GLIBC__) #define __fpclassifyd __fpclassify #endif @@ -181,7 +187,7 @@ TEST(math, __fpclassifyd) { ASSERT_EQ(FP_ZERO, __fpclassifyd(0.0)); } -TEST(math, __fpclassifyf) { +TEST(MATH_TEST, __fpclassifyf) { ASSERT_EQ(FP_INFINITE, __fpclassifyf(HUGE_VALF)); ASSERT_EQ(FP_NAN, __fpclassifyf(nanf(""))); ASSERT_EQ(FP_NORMAL, __fpclassifyf(1.0f)); @@ -189,7 +195,7 @@ TEST(math, __fpclassifyf) { ASSERT_EQ(FP_ZERO, __fpclassifyf(0.0f)); } -TEST(math, __fpclassifyl) { +TEST(MATH_TEST, __fpclassifyl) { EXPECT_EQ(FP_INFINITE, __fpclassifyl(HUGE_VALL)); EXPECT_EQ(FP_NAN, __fpclassifyl(nanl(""))); EXPECT_EQ(FP_NORMAL, __fpclassifyl(1.0L)); @@ -197,12 +203,12 @@ TEST(math, __fpclassifyl) { EXPECT_EQ(FP_ZERO, __fpclassifyl(0.0L)); } -TEST(math, finitef) { +TEST(MATH_TEST, finitef) { ASSERT_TRUE(finitef(123.0f)); ASSERT_FALSE(finitef(HUGE_VALF)); } -TEST(math, __isfinite) { +TEST(MATH_TEST, __isfinite) { #if defined(__GLIBC__) #define __isfinite __finite #endif @@ -210,7 +216,7 @@ TEST(math, __isfinite) { ASSERT_FALSE(__isfinite(HUGE_VAL)); } -TEST(math, __isfinitef) { +TEST(MATH_TEST, __isfinitef) { #if defined(__GLIBC__) #define __isfinitef __finitef #endif @@ -218,7 +224,7 @@ TEST(math, __isfinitef) { ASSERT_FALSE(__isfinitef(HUGE_VALF)); } -TEST(math, __isfinitel) { +TEST(MATH_TEST, __isfinitel) { #if defined(__GLIBC__) #define __isfinitel __finitel #endif @@ -226,49 +232,49 @@ TEST(math, __isfinitel) { ASSERT_FALSE(__isfinitel(HUGE_VALL)); } -TEST(math, finite) { +TEST(MATH_TEST, finite) { ASSERT_TRUE(finite(123.0)); ASSERT_FALSE(finite(HUGE_VAL)); } -TEST(math, isinf_function) { +TEST(MATH_TEST, isinf_function) { // The isinf macro deals with all three types; the isinf function is for doubles. ASSERT_FALSE((isinf)(123.0)); ASSERT_TRUE((isinf)(HUGE_VAL)); } -TEST(math, __isinff) { +TEST(MATH_TEST, __isinff) { ASSERT_FALSE(__isinff(123.0f)); ASSERT_TRUE(__isinff(HUGE_VALF)); } -TEST(math, __isinfl) { +TEST(MATH_TEST, __isinfl) { ASSERT_FALSE(__isinfl(123.0L)); ASSERT_TRUE(__isinfl(HUGE_VALL)); } -TEST(math, isnan_function) { +TEST(MATH_TEST, isnan_function) { // The isnan macro deals with all three types; the isnan function is for doubles. ASSERT_FALSE((isnan)(123.0)); ASSERT_TRUE((isnan)(nan(""))); } -TEST(math, __isnanf) { +TEST(MATH_TEST, __isnanf) { ASSERT_FALSE(__isnanf(123.0f)); ASSERT_TRUE(__isnanf(nanf(""))); } -TEST(math, __isnanl) { +TEST(MATH_TEST, __isnanl) { ASSERT_FALSE(__isnanl(123.0L)); ASSERT_TRUE(__isnanl(nanl(""))); } -TEST(math, isnanf) { +TEST(MATH_TEST, isnanf) { ASSERT_FALSE(isnanf(123.0f)); ASSERT_TRUE(isnanf(nanf(""))); } -TEST(math, __isnormal) { +TEST(MATH_TEST, __isnormal) { #if defined(__BIONIC__) ASSERT_TRUE(__isnormal(123.0)); ASSERT_FALSE(__isnormal(double_subnormal())); @@ -277,7 +283,7 @@ TEST(math, __isnormal) { #endif // __BIONIC__ } -TEST(math, __isnormalf) { +TEST(MATH_TEST, __isnormalf) { #if defined(__BIONIC__) ASSERT_TRUE(__isnormalf(123.0f)); ASSERT_FALSE(__isnormalf(float_subnormal())); @@ -286,7 +292,7 @@ TEST(math, __isnormalf) { #endif // __BIONIC__ } -TEST(math, __isnormall) { +TEST(MATH_TEST, __isnormall) { #if defined(__BIONIC__) ASSERT_TRUE(__isnormall(123.0L)); ASSERT_FALSE(__isnormall(ldouble_subnormal())); @@ -295,486 +301,486 @@ TEST(math, __isnormall) { #endif // __BIONIC__ } -TEST(math, __signbit) { +TEST(MATH_TEST, __signbit) { ASSERT_EQ(0, __signbit(0.0)); ASSERT_EQ(0, __signbit(1.0)); ASSERT_NE(0, __signbit(-1.0)); } -TEST(math, __signbitf) { +TEST(MATH_TEST, __signbitf) { ASSERT_EQ(0, __signbitf(0.0f)); ASSERT_EQ(0, __signbitf(1.0f)); ASSERT_NE(0, __signbitf(-1.0f)); } -TEST(math, __signbitl) { +TEST(MATH_TEST, __signbitl) { ASSERT_EQ(0L, __signbitl(0.0L)); ASSERT_EQ(0L, __signbitl(1.0L)); ASSERT_NE(0L, __signbitl(-1.0L)); } -TEST(math, acos) { +TEST(MATH_TEST, acos) { ASSERT_DOUBLE_EQ(M_PI/2.0, acos(0.0)); } -TEST(math, acosf) { +TEST(MATH_TEST, acosf) { ASSERT_FLOAT_EQ(static_cast<float>(M_PI)/2.0f, acosf(0.0f)); } -TEST(math, acosl) { +TEST(MATH_TEST, acosl) { ASSERT_DOUBLE_EQ(M_PI/2.0L, acosl(0.0L)); } -TEST(math, asin) { +TEST(MATH_TEST, asin) { ASSERT_DOUBLE_EQ(0.0, asin(0.0)); } -TEST(math, asinf) { +TEST(MATH_TEST, asinf) { ASSERT_FLOAT_EQ(0.0f, asinf(0.0f)); } -TEST(math, asinl) { +TEST(MATH_TEST, asinl) { ASSERT_DOUBLE_EQ(0.0L, asinl(0.0L)); } -TEST(math, atan) { +TEST(MATH_TEST, atan) { ASSERT_DOUBLE_EQ(0.0, atan(0.0)); } -TEST(math, atanf) { +TEST(MATH_TEST, atanf) { ASSERT_FLOAT_EQ(0.0f, atanf(0.0f)); } -TEST(math, atanl) { +TEST(MATH_TEST, atanl) { ASSERT_DOUBLE_EQ(0.0L, atanl(0.0L)); } -TEST(math, atan2) { +TEST(MATH_TEST, atan2) { ASSERT_DOUBLE_EQ(0.0, atan2(0.0, 0.0)); } -TEST(math, atan2f) { +TEST(MATH_TEST, atan2f) { ASSERT_FLOAT_EQ(0.0f, atan2f(0.0f, 0.0f)); } -TEST(math, atan2l) { +TEST(MATH_TEST, atan2l) { ASSERT_DOUBLE_EQ(0.0L, atan2l(0.0L, 0.0L)); } -TEST(math, cos) { +TEST(MATH_TEST, cos) { ASSERT_DOUBLE_EQ(1.0, cos(0.0)); } -TEST(math, cosf) { +TEST(MATH_TEST, cosf) { ASSERT_FLOAT_EQ(1.0f, cosf(0.0f)); } -TEST(math, cosl) { +TEST(MATH_TEST, cosl) { ASSERT_DOUBLE_EQ(1.0L, cosl(0.0L)); } -TEST(math, sin) { +TEST(MATH_TEST, sin) { ASSERT_DOUBLE_EQ(0.0, sin(0.0)); } -TEST(math, sinf) { +TEST(MATH_TEST, sinf) { ASSERT_FLOAT_EQ(0.0f, sinf(0.0f)); } -TEST(math, sinl) { +TEST(MATH_TEST, sinl) { ASSERT_DOUBLE_EQ(0.0L, sinl(0.0L)); } -TEST(math, sincos) { +TEST(MATH_TEST, sincos) { double s, c; sincos(0.0, &s, &c); ASSERT_DOUBLE_EQ(0.0, s); ASSERT_DOUBLE_EQ(1.0, c); } -TEST(math, sincosf) { +TEST(MATH_TEST, sincosf) { float s, c; sincosf(0.0f, &s, &c); ASSERT_FLOAT_EQ(0.0f, s); ASSERT_FLOAT_EQ(1.0f, c); } -TEST(math, sincosl) { +TEST(MATH_TEST, sincosl) { long double s, c; sincosl(0.0L, &s, &c); ASSERT_DOUBLE_EQ(0.0L, s); ASSERT_DOUBLE_EQ(1.0L, c); } -TEST(math, tan) { +TEST(MATH_TEST, tan) { ASSERT_DOUBLE_EQ(0.0, tan(0.0)); } -TEST(math, tanf) { +TEST(MATH_TEST, tanf) { ASSERT_FLOAT_EQ(0.0f, tanf(0.0f)); } -TEST(math, tanl) { +TEST(MATH_TEST, tanl) { ASSERT_DOUBLE_EQ(0.0L, tanl(0.0L)); } -TEST(math, acosh) { +TEST(MATH_TEST, acosh) { ASSERT_DOUBLE_EQ(0.0, acosh(1.0)); } -TEST(math, acoshf) { +TEST(MATH_TEST, acoshf) { ASSERT_FLOAT_EQ(0.0f, acoshf(1.0f)); } -TEST(math, acoshl) { +TEST(MATH_TEST, acoshl) { ASSERT_DOUBLE_EQ(0.0L, acoshl(1.0L)); } -TEST(math, asinh) { +TEST(MATH_TEST, asinh) { ASSERT_DOUBLE_EQ(0.0, asinh(0.0)); } -TEST(math, asinhf) { +TEST(MATH_TEST, asinhf) { ASSERT_FLOAT_EQ(0.0f, asinhf(0.0f)); } -TEST(math, asinhl) { +TEST(MATH_TEST, asinhl) { ASSERT_DOUBLE_EQ(0.0L, asinhl(0.0L)); } -TEST(math, atanh) { +TEST(MATH_TEST, atanh) { ASSERT_DOUBLE_EQ(0.0, atanh(0.0)); } -TEST(math, atanhf) { +TEST(MATH_TEST, atanhf) { ASSERT_FLOAT_EQ(0.0f, atanhf(0.0f)); } -TEST(math, atanhl) { +TEST(MATH_TEST, atanhl) { ASSERT_DOUBLE_EQ(0.0L, atanhl(0.0L)); } -TEST(math, cosh) { +TEST(MATH_TEST, cosh) { ASSERT_DOUBLE_EQ(1.0, cosh(0.0)); } -TEST(math, coshf) { +TEST(MATH_TEST, coshf) { ASSERT_FLOAT_EQ(1.0f, coshf(0.0f)); } -TEST(math, coshl) { +TEST(MATH_TEST, coshl) { ASSERT_DOUBLE_EQ(1.0L, coshl(0.0L)); } -TEST(math, sinh) { +TEST(MATH_TEST, sinh) { ASSERT_DOUBLE_EQ(0.0, sinh(0.0)); } -TEST(math, sinhf) { +TEST(MATH_TEST, sinhf) { ASSERT_FLOAT_EQ(0.0f, sinhf(0.0f)); } -TEST(math, sinhl) { +TEST(MATH_TEST, sinhl) { ASSERT_DOUBLE_EQ(0.0L, sinhl(0.0L)); } -TEST(math, tanh) { +TEST(MATH_TEST, tanh) { ASSERT_DOUBLE_EQ(0.0, tanh(0.0)); } -TEST(math, tanhf) { +TEST(MATH_TEST, tanhf) { ASSERT_FLOAT_EQ(0.0f, tanhf(0.0f)); } -TEST(math, tanhl) { +TEST(MATH_TEST, tanhl) { ASSERT_DOUBLE_EQ(0.0L, tanhl(0.0L)); } -TEST(math, log) { +TEST(MATH_TEST, log) { ASSERT_DOUBLE_EQ(1.0, log(M_E)); } -TEST(math, logf) { +TEST(MATH_TEST, logf) { ASSERT_FLOAT_EQ(1.0f, logf(static_cast<float>(M_E))); } -TEST(math, logl) { +TEST(MATH_TEST, logl) { ASSERT_DOUBLE_EQ(1.0L, logl(M_E)); } -TEST(math, log2) { +TEST(MATH_TEST, log2) { ASSERT_DOUBLE_EQ(12.0, log2(4096.0)); } -TEST(math, log2f) { +TEST(MATH_TEST, log2f) { ASSERT_FLOAT_EQ(12.0f, log2f(4096.0f)); } -TEST(math, log2l) { +TEST(MATH_TEST, log2l) { ASSERT_DOUBLE_EQ(12.0L, log2l(4096.0L)); } -TEST(math, log10) { +TEST(MATH_TEST, log10) { ASSERT_DOUBLE_EQ(3.0, log10(1000.0)); } -TEST(math, log10f) { +TEST(MATH_TEST, log10f) { ASSERT_FLOAT_EQ(3.0f, log10f(1000.0f)); } -TEST(math, log10l) { +TEST(MATH_TEST, log10l) { ASSERT_DOUBLE_EQ(3.0L, log10l(1000.0L)); } -TEST(math, cbrt) { +TEST(MATH_TEST, cbrt) { ASSERT_DOUBLE_EQ(3.0, cbrt(27.0)); } -TEST(math, cbrtf) { +TEST(MATH_TEST, cbrtf) { ASSERT_FLOAT_EQ(3.0f, cbrtf(27.0f)); } -TEST(math, cbrtl) { +TEST(MATH_TEST, cbrtl) { ASSERT_DOUBLE_EQ(3.0L, cbrtl(27.0L)); } -TEST(math, sqrt) { +TEST(MATH_TEST, sqrt) { ASSERT_DOUBLE_EQ(2.0, sqrt(4.0)); } -TEST(math, sqrtf) { +TEST(MATH_TEST, sqrtf) { ASSERT_FLOAT_EQ(2.0f, sqrtf(4.0f)); } -TEST(math, sqrtl) { +TEST(MATH_TEST, sqrtl) { ASSERT_DOUBLE_EQ(2.0L, sqrtl(4.0L)); } -TEST(math, exp) { +TEST(MATH_TEST, exp) { ASSERT_DOUBLE_EQ(1.0, exp(0.0)); ASSERT_DOUBLE_EQ(M_E, exp(1.0)); } -TEST(math, expf) { +TEST(MATH_TEST, expf) { ASSERT_FLOAT_EQ(1.0f, expf(0.0f)); ASSERT_FLOAT_EQ(static_cast<float>(M_E), expf(1.0f)); } -TEST(math, expl) { +TEST(MATH_TEST, expl) { ASSERT_DOUBLE_EQ(1.0L, expl(0.0L)); ASSERT_DOUBLE_EQ(M_E, expl(1.0L)); } -TEST(math, exp2) { +TEST(MATH_TEST, exp2) { ASSERT_DOUBLE_EQ(8.0, exp2(3.0)); } -TEST(math, exp2f) { +TEST(MATH_TEST, exp2f) { ASSERT_FLOAT_EQ(8.0f, exp2f(3.0f)); } -TEST(math, exp2l) { +TEST(MATH_TEST, exp2l) { ASSERT_DOUBLE_EQ(8.0L, exp2l(3.0L)); } -TEST(math, expm1) { +TEST(MATH_TEST, expm1) { ASSERT_DOUBLE_EQ(M_E - 1.0, expm1(1.0)); } -TEST(math, expm1f) { +TEST(MATH_TEST, expm1f) { ASSERT_FLOAT_EQ(static_cast<float>(M_E) - 1.0f, expm1f(1.0f)); } -TEST(math, expm1l) { +TEST(MATH_TEST, expm1l) { ASSERT_DOUBLE_EQ(M_E - 1.0L, expm1l(1.0L)); } -TEST(math, pow) { +TEST(MATH_TEST, pow) { ASSERT_TRUE(isnan(pow(nan(""), 3.0))); ASSERT_DOUBLE_EQ(1.0, (pow(1.0, nan("")))); ASSERT_TRUE(isnan(pow(2.0, nan("")))); ASSERT_DOUBLE_EQ(8.0, pow(2.0, 3.0)); } -TEST(math, powf) { +TEST(MATH_TEST, powf) { ASSERT_TRUE(isnanf(powf(nanf(""), 3.0f))); ASSERT_FLOAT_EQ(1.0f, (powf(1.0f, nanf("")))); ASSERT_TRUE(isnanf(powf(2.0f, nanf("")))); ASSERT_FLOAT_EQ(8.0f, powf(2.0f, 3.0f)); } -TEST(math, powl) { +TEST(MATH_TEST, powl) { ASSERT_TRUE(__isnanl(powl(nanl(""), 3.0L))); ASSERT_DOUBLE_EQ(1.0L, (powl(1.0L, nanl("")))); ASSERT_TRUE(__isnanl(powl(2.0L, nanl("")))); ASSERT_DOUBLE_EQ(8.0L, powl(2.0L, 3.0L)); } -TEST(math, ceil) { +TEST(MATH_TEST, ceil) { ASSERT_DOUBLE_EQ(1.0, ceil(0.9)); } -TEST(math, ceilf) { +TEST(MATH_TEST, ceilf) { ASSERT_FLOAT_EQ(1.0f, ceilf(0.9f)); } -TEST(math, ceill) { +TEST(MATH_TEST, ceill) { ASSERT_DOUBLE_EQ(1.0L, ceill(0.9L)); } -TEST(math, floor) { +TEST(MATH_TEST, floor) { ASSERT_DOUBLE_EQ(1.0, floor(1.1)); } -TEST(math, floorf) { +TEST(MATH_TEST, floorf) { ASSERT_FLOAT_EQ(1.0f, floorf(1.1f)); } -TEST(math, floorl) { +TEST(MATH_TEST, floorl) { ASSERT_DOUBLE_EQ(1.0L, floorl(1.1L)); } -TEST(math, fabs) { +TEST(MATH_TEST, fabs) { ASSERT_DOUBLE_EQ(1.0, fabs(-1.0)); } -TEST(math, fabsf) { +TEST(MATH_TEST, fabsf) { ASSERT_FLOAT_EQ(1.0f, fabsf(-1.0f)); } -TEST(math, fabsl) { +TEST(MATH_TEST, fabsl) { ASSERT_DOUBLE_EQ(1.0L, fabsl(-1.0L)); } -TEST(math, ldexp) { +TEST(MATH_TEST, ldexp) { ASSERT_DOUBLE_EQ(16.0, ldexp(2.0, 3.0)); } -TEST(math, ldexpf) { +TEST(MATH_TEST, ldexpf) { ASSERT_FLOAT_EQ(16.0f, ldexpf(2.0f, 3.0f)); } -TEST(math, ldexpl) { +TEST(MATH_TEST, ldexpl) { ASSERT_DOUBLE_EQ(16.0L, ldexpl(2.0L, 3.0)); } -TEST(math, fmod) { +TEST(MATH_TEST, fmod) { ASSERT_DOUBLE_EQ(2.0, fmod(12.0, 10.0)); } -TEST(math, fmodf) { +TEST(MATH_TEST, fmodf) { ASSERT_FLOAT_EQ(2.0f, fmodf(12.0f, 10.0f)); } -TEST(math, fmodl) { +TEST(MATH_TEST, fmodl) { ASSERT_DOUBLE_EQ(2.0L, fmodl(12.0L, 10.0L)); } -TEST(math, remainder) { +TEST(MATH_TEST, remainder) { ASSERT_DOUBLE_EQ(2.0, remainder(12.0, 10.0)); } -TEST(math, remainderf) { +TEST(MATH_TEST, remainderf) { ASSERT_FLOAT_EQ(2.0f, remainderf(12.0f, 10.0f)); } -TEST(math, remainderl) { +TEST(MATH_TEST, remainderl) { ASSERT_DOUBLE_EQ(2.0L, remainderl(12.0L, 10.0L)); } -TEST(math, drem) { +TEST(MATH_TEST, drem) { ASSERT_DOUBLE_EQ(2.0, drem(12.0, 10.0)); } -TEST(math, dremf) { +TEST(MATH_TEST, dremf) { ASSERT_FLOAT_EQ(2.0f, dremf(12.0f, 10.0f)); } -TEST(math, fmax) { +TEST(MATH_TEST, fmax) { ASSERT_DOUBLE_EQ(12.0, fmax(12.0, 10.0)); ASSERT_DOUBLE_EQ(12.0, fmax(12.0, nan(""))); ASSERT_DOUBLE_EQ(12.0, fmax(nan(""), 12.0)); } -TEST(math, fmaxf) { +TEST(MATH_TEST, fmaxf) { ASSERT_FLOAT_EQ(12.0f, fmaxf(12.0f, 10.0f)); ASSERT_FLOAT_EQ(12.0f, fmaxf(12.0f, nanf(""))); ASSERT_FLOAT_EQ(12.0f, fmaxf(nanf(""), 12.0f)); } -TEST(math, fmaxl) { +TEST(MATH_TEST, fmaxl) { ASSERT_DOUBLE_EQ(12.0L, fmaxl(12.0L, 10.0L)); ASSERT_DOUBLE_EQ(12.0L, fmaxl(12.0L, nanl(""))); ASSERT_DOUBLE_EQ(12.0L, fmaxl(nanl(""), 12.0L)); } -TEST(math, fmin) { +TEST(MATH_TEST, fmin) { ASSERT_DOUBLE_EQ(10.0, fmin(12.0, 10.0)); ASSERT_DOUBLE_EQ(12.0, fmin(12.0, nan(""))); ASSERT_DOUBLE_EQ(12.0, fmin(nan(""), 12.0)); } -TEST(math, fminf) { +TEST(MATH_TEST, fminf) { ASSERT_FLOAT_EQ(10.0f, fminf(12.0f, 10.0f)); ASSERT_FLOAT_EQ(12.0f, fminf(12.0f, nanf(""))); ASSERT_FLOAT_EQ(12.0f, fminf(nanf(""), 12.0f)); } -TEST(math, fminl) { +TEST(MATH_TEST, fminl) { ASSERT_DOUBLE_EQ(10.0L, fminl(12.0L, 10.0L)); ASSERT_DOUBLE_EQ(12.0L, fminl(12.0L, nanl(""))); ASSERT_DOUBLE_EQ(12.0L, fminl(nanl(""), 12.0L)); } -TEST(math, fma) { +TEST(MATH_TEST, fma) { ASSERT_DOUBLE_EQ(10.0, fma(2.0, 3.0, 4.0)); } -TEST(math, fmaf) { +TEST(MATH_TEST, fmaf) { ASSERT_FLOAT_EQ(10.0f, fmaf(2.0f, 3.0f, 4.0f)); } -TEST(math, fmal) { +TEST(MATH_TEST, fmal) { ASSERT_DOUBLE_EQ(10.0L, fmal(2.0L, 3.0L, 4.0L)); } -TEST(math, hypot) { +TEST(MATH_TEST, hypot) { ASSERT_DOUBLE_EQ(5.0, hypot(3.0, 4.0)); } -TEST(math, hypotf) { +TEST(MATH_TEST, hypotf) { ASSERT_FLOAT_EQ(5.0f, hypotf(3.0f, 4.0f)); } -TEST(math, hypotl) { +TEST(MATH_TEST, hypotl) { ASSERT_DOUBLE_EQ(5.0L, hypotl(3.0L, 4.0L)); } -TEST(math, erf) { +TEST(MATH_TEST, erf) { ASSERT_DOUBLE_EQ(0.84270079294971489, erf(1.0)); } -TEST(math, erff) { +TEST(MATH_TEST, erff) { ASSERT_FLOAT_EQ(0.84270078f, erff(1.0f)); } -TEST(math, erfl) { +TEST(MATH_TEST, erfl) { ASSERT_DOUBLE_EQ(0.84270079294971489L, erfl(1.0L)); } -TEST(math, erfc) { +TEST(MATH_TEST, erfc) { ASSERT_DOUBLE_EQ(0.15729920705028513, erfc(1.0)); } -TEST(math, erfcf) { +TEST(MATH_TEST, erfcf) { ASSERT_FLOAT_EQ(0.15729921f, erfcf(1.0f)); } -TEST(math, erfcl) { +TEST(MATH_TEST, erfcl) { ASSERT_DOUBLE_EQ(0.15729920705028513l, erfcl(1.0L)); } -TEST(math, lrint) { +TEST(MATH_TEST, lrint) { auto guard = android::base::make_scope_guard([]() { fesetenv(FE_DFL_ENV); }); fesetround(FE_UPWARD); // lrint/lrintf/lrintl obey the rounding mode. @@ -796,7 +802,7 @@ TEST(math, lrint) { ASSERT_EQ(1234L, llrintl(1234.01L)); } -TEST(math, rint) { +TEST(MATH_TEST, rint) { auto guard = android::base::make_scope_guard([]() { fesetenv(FE_DFL_ENV); }); fesetround(FE_UPWARD); // rint/rintf/rintl obey the rounding mode. @@ -824,7 +830,7 @@ TEST(math, rint) { ASSERT_EQ(1234.0, rintl(1234.01L)); } -TEST(math, nearbyint) { +TEST(MATH_TEST, nearbyint) { auto guard = android::base::make_scope_guard([]() { fesetenv(FE_DFL_ENV); }); fesetround(FE_UPWARD); // nearbyint/nearbyintf/nearbyintl obey the rounding mode. feclearexcept(FE_ALL_EXCEPT); // nearbyint/nearbyintf/nearbyintl don't set the FE_INEXACT flag. @@ -851,7 +857,7 @@ TEST(math, nearbyint) { ASSERT_EQ(1234.0, nearbyintl(1234.01L)); } -TEST(math, lround) { +TEST(MATH_TEST, lround) { auto guard = android::base::make_scope_guard([]() { fesetenv(FE_DFL_ENV); }); fesetround(FE_UPWARD); // lround ignores the rounding mode. ASSERT_EQ(1234, lround(1234.01)); @@ -859,7 +865,7 @@ TEST(math, lround) { ASSERT_EQ(1234, lroundl(1234.01L)); } -TEST(math, llround) { +TEST(MATH_TEST, llround) { auto guard = android::base::make_scope_guard([]() { fesetenv(FE_DFL_ENV); }); fesetround(FE_UPWARD); // llround ignores the rounding mode. ASSERT_EQ(1234L, llround(1234.01)); @@ -867,7 +873,7 @@ TEST(math, llround) { ASSERT_EQ(1234L, llroundl(1234.01L)); } -TEST(math, ilogb) { +TEST(MATH_TEST, ilogb) { ASSERT_EQ(FP_ILOGB0, ilogb(0.0)); ASSERT_EQ(FP_ILOGBNAN, ilogb(nan(""))); ASSERT_EQ(INT_MAX, ilogb(HUGE_VAL)); @@ -875,7 +881,7 @@ TEST(math, ilogb) { ASSERT_EQ(3, ilogb(10.0)); } -TEST(math, ilogbf) { +TEST(MATH_TEST, ilogbf) { ASSERT_EQ(FP_ILOGB0, ilogbf(0.0f)); ASSERT_EQ(FP_ILOGBNAN, ilogbf(nanf(""))); ASSERT_EQ(INT_MAX, ilogbf(HUGE_VALF)); @@ -883,7 +889,7 @@ TEST(math, ilogbf) { ASSERT_EQ(3, ilogbf(10.0f)); } -TEST(math, ilogbl) { +TEST(MATH_TEST, ilogbl) { ASSERT_EQ(FP_ILOGB0, ilogbl(0.0L)); ASSERT_EQ(FP_ILOGBNAN, ilogbl(nanl(""))); ASSERT_EQ(INT_MAX, ilogbl(HUGE_VALL)); @@ -891,7 +897,7 @@ TEST(math, ilogbl) { ASSERT_EQ(3L, ilogbl(10.0L)); } -TEST(math, logb) { +TEST(MATH_TEST, logb) { ASSERT_EQ(-HUGE_VAL, logb(0.0)); ASSERT_TRUE(isnan(logb(nan("")))); ASSERT_TRUE(isinf(logb(HUGE_VAL))); @@ -899,7 +905,7 @@ TEST(math, logb) { ASSERT_EQ(3.0, logb(10.0)); } -TEST(math, logbf) { +TEST(MATH_TEST, logbf) { ASSERT_EQ(-HUGE_VALF, logbf(0.0f)); ASSERT_TRUE(isnanf(logbf(nanf("")))); ASSERT_TRUE(__isinff(logbf(HUGE_VALF))); @@ -907,7 +913,7 @@ TEST(math, logbf) { ASSERT_EQ(3.0f, logbf(10.0f)); } -TEST(math, logbl) { +TEST(MATH_TEST, logbl) { ASSERT_EQ(-HUGE_VAL, logbl(0.0L)); ASSERT_TRUE(isnan(logbl(nanl("")))); ASSERT_TRUE(isinf(logbl(HUGE_VALL))); @@ -915,46 +921,46 @@ TEST(math, logbl) { ASSERT_EQ(3.0L, logbl(10.0L)); } -TEST(math, log1p) { +TEST(MATH_TEST, log1p) { ASSERT_EQ(-HUGE_VAL, log1p(-1.0)); ASSERT_TRUE(isnan(log1p(nan("")))); ASSERT_TRUE(isinf(log1p(HUGE_VAL))); ASSERT_DOUBLE_EQ(1.0, log1p(M_E - 1.0)); } -TEST(math, log1pf) { +TEST(MATH_TEST, log1pf) { ASSERT_EQ(-HUGE_VALF, log1pf(-1.0f)); ASSERT_TRUE(isnanf(log1pf(nanf("")))); ASSERT_TRUE(__isinff(log1pf(HUGE_VALF))); ASSERT_FLOAT_EQ(1.0f, log1pf(static_cast<float>(M_E) - 1.0f)); } -TEST(math, log1pl) { +TEST(MATH_TEST, log1pl) { ASSERT_EQ(-HUGE_VALL, log1pl(-1.0L)); ASSERT_TRUE(isnan(log1pl(nanl("")))); ASSERT_TRUE(isinf(log1pl(HUGE_VALL))); ASSERT_DOUBLE_EQ(1.0L, log1pl(M_E - 1.0L)); } -TEST(math, fdim) { +TEST(MATH_TEST, fdim) { ASSERT_DOUBLE_EQ(0.0, fdim(1.0, 1.0)); ASSERT_DOUBLE_EQ(1.0, fdim(2.0, 1.0)); ASSERT_DOUBLE_EQ(0.0, fdim(1.0, 2.0)); } -TEST(math, fdimf) { +TEST(MATH_TEST, fdimf) { ASSERT_FLOAT_EQ(0.0f, fdimf(1.0f, 1.0f)); ASSERT_FLOAT_EQ(1.0f, fdimf(2.0f, 1.0f)); ASSERT_FLOAT_EQ(0.0f, fdimf(1.0f, 2.0f)); } -TEST(math, fdiml) { +TEST(MATH_TEST, fdiml) { ASSERT_DOUBLE_EQ(0.0L, fdiml(1.0L, 1.0L)); ASSERT_DOUBLE_EQ(1.0L, fdiml(2.0L, 1.0L)); ASSERT_DOUBLE_EQ(0.0L, fdiml(1.0L, 2.0L)); } -TEST(math, round) { +TEST(MATH_TEST, round) { auto guard = android::base::make_scope_guard([]() { fesetenv(FE_DFL_ENV); }); fesetround(FE_TOWARDZERO); // round ignores the rounding mode and always rounds away from zero. ASSERT_DOUBLE_EQ(1.0, round(0.5)); @@ -965,7 +971,7 @@ TEST(math, round) { ASSERT_DOUBLE_EQ(HUGE_VAL, round(HUGE_VAL)); } -TEST(math, roundf) { +TEST(MATH_TEST, roundf) { auto guard = android::base::make_scope_guard([]() { fesetenv(FE_DFL_ENV); }); fesetround(FE_TOWARDZERO); // roundf ignores the rounding mode and always rounds away from zero. ASSERT_FLOAT_EQ(1.0f, roundf(0.5f)); @@ -976,7 +982,7 @@ TEST(math, roundf) { ASSERT_FLOAT_EQ(HUGE_VALF, roundf(HUGE_VALF)); } -TEST(math, roundl) { +TEST(MATH_TEST, roundl) { auto guard = android::base::make_scope_guard([]() { fesetenv(FE_DFL_ENV); }); fesetround(FE_TOWARDZERO); // roundl ignores the rounding mode and always rounds away from zero. ASSERT_DOUBLE_EQ(1.0L, roundl(0.5L)); @@ -987,7 +993,7 @@ TEST(math, roundl) { ASSERT_DOUBLE_EQ(HUGE_VALL, roundl(HUGE_VALL)); } -TEST(math, trunc) { +TEST(MATH_TEST, trunc) { auto guard = android::base::make_scope_guard([]() { fesetenv(FE_DFL_ENV); }); fesetround(FE_UPWARD); // trunc ignores the rounding mode and always rounds toward zero. ASSERT_DOUBLE_EQ(1.0, trunc(1.5)); @@ -998,7 +1004,7 @@ TEST(math, trunc) { ASSERT_DOUBLE_EQ(HUGE_VAL, trunc(HUGE_VAL)); } -TEST(math, truncf) { +TEST(MATH_TEST, truncf) { auto guard = android::base::make_scope_guard([]() { fesetenv(FE_DFL_ENV); }); fesetround(FE_UPWARD); // truncf ignores the rounding mode and always rounds toward zero. ASSERT_FLOAT_EQ(1.0f, truncf(1.5f)); @@ -1009,7 +1015,7 @@ TEST(math, truncf) { ASSERT_FLOAT_EQ(HUGE_VALF, truncf(HUGE_VALF)); } -TEST(math, truncl) { +TEST(MATH_TEST, truncl) { auto guard = android::base::make_scope_guard([]() { fesetenv(FE_DFL_ENV); }); fesetround(FE_UPWARD); // truncl ignores the rounding mode and always rounds toward zero. ASSERT_DOUBLE_EQ(1.0L, truncl(1.5L)); @@ -1020,19 +1026,19 @@ TEST(math, truncl) { ASSERT_DOUBLE_EQ(HUGE_VALL, truncl(HUGE_VALL)); } -TEST(math, nextafter) { +TEST(MATH_TEST, nextafter) { ASSERT_DOUBLE_EQ(0.0, nextafter(0.0, 0.0)); ASSERT_DOUBLE_EQ(4.9406564584124654e-324, nextafter(0.0, 1.0)); ASSERT_DOUBLE_EQ(-4.9406564584124654e-324, nextafter(0.0, -1.0)); } -TEST(math, nextafterf) { +TEST(MATH_TEST, nextafterf) { ASSERT_FLOAT_EQ(0.0f, nextafterf(0.0f, 0.0f)); ASSERT_FLOAT_EQ(1.4012985e-45f, nextafterf(0.0f, 1.0f)); ASSERT_FLOAT_EQ(-1.4012985e-45f, nextafterf(0.0f, -1.0f)); } -TEST(math, nextafterl) { +TEST(MATH_TEST, nextafterl) { ASSERT_DOUBLE_EQ(0.0L, nextafterl(0.0L, 0.0L)); // Use a runtime value to accomodate the case when // sizeof(double) == sizeof(long double) @@ -1041,19 +1047,19 @@ TEST(math, nextafterl) { ASSERT_DOUBLE_EQ(-smallest_positive, nextafterl(0.0L, -1.0L)); } -TEST(math, nexttoward) { +TEST(MATH_TEST, nexttoward) { ASSERT_DOUBLE_EQ(0.0, nexttoward(0.0, 0.0L)); ASSERT_DOUBLE_EQ(4.9406564584124654e-324, nexttoward(0.0, 1.0L)); ASSERT_DOUBLE_EQ(-4.9406564584124654e-324, nexttoward(0.0, -1.0L)); } -TEST(math, nexttowardf) { +TEST(MATH_TEST, nexttowardf) { ASSERT_FLOAT_EQ(0.0f, nexttowardf(0.0f, 0.0L)); ASSERT_FLOAT_EQ(1.4012985e-45f, nexttowardf(0.0f, 1.0L)); ASSERT_FLOAT_EQ(-1.4012985e-45f, nexttowardf(0.0f, -1.0L)); } -TEST(math, nexttowardl) { +TEST(MATH_TEST, nexttowardl) { ASSERT_DOUBLE_EQ(0.0L, nexttowardl(0.0L, 0.0L)); // Use a runtime value to accomodate the case when // sizeof(double) == sizeof(long double) @@ -1062,86 +1068,86 @@ TEST(math, nexttowardl) { ASSERT_DOUBLE_EQ(-smallest_positive, nexttowardl(0.0L, -1.0L)); } -TEST(math, copysign) { +TEST(MATH_TEST, copysign) { ASSERT_DOUBLE_EQ(0.0, copysign(0.0, 1.0)); ASSERT_DOUBLE_EQ(-0.0, copysign(0.0, -1.0)); ASSERT_DOUBLE_EQ(2.0, copysign(2.0, 1.0)); ASSERT_DOUBLE_EQ(-2.0, copysign(2.0, -1.0)); } -TEST(math, copysignf) { +TEST(MATH_TEST, copysignf) { ASSERT_FLOAT_EQ(0.0f, copysignf(0.0f, 1.0f)); ASSERT_FLOAT_EQ(-0.0f, copysignf(0.0f, -1.0f)); ASSERT_FLOAT_EQ(2.0f, copysignf(2.0f, 1.0f)); ASSERT_FLOAT_EQ(-2.0f, copysignf(2.0f, -1.0f)); } -TEST(math, copysignl) { +TEST(MATH_TEST, copysignl) { ASSERT_DOUBLE_EQ(0.0L, copysignl(0.0L, 1.0L)); ASSERT_DOUBLE_EQ(-0.0L, copysignl(0.0L, -1.0L)); ASSERT_DOUBLE_EQ(2.0L, copysignl(2.0L, 1.0L)); ASSERT_DOUBLE_EQ(-2.0L, copysignl(2.0L, -1.0L)); } -TEST(math, significand) { +TEST(MATH_TEST, significand) { ASSERT_DOUBLE_EQ(0.0, significand(0.0)); ASSERT_DOUBLE_EQ(1.2, significand(1.2)); ASSERT_DOUBLE_EQ(1.53125, significand(12.25)); } -TEST(math, significandf) { +TEST(MATH_TEST, significandf) { ASSERT_FLOAT_EQ(0.0f, significandf(0.0f)); ASSERT_FLOAT_EQ(1.2f, significandf(1.2f)); ASSERT_FLOAT_EQ(1.53125f, significandf(12.25f)); } -TEST(math, significandl) { +TEST(MATH_TEST, significandl) { ASSERT_DOUBLE_EQ(0.0L, significandl(0.0L)); ASSERT_DOUBLE_EQ(1.2L, significandl(1.2L)); ASSERT_DOUBLE_EQ(1.53125L, significandl(12.25L)); } -TEST(math, scalb) { +TEST(MATH_TEST, scalb) { ASSERT_DOUBLE_EQ(12.0, scalb(3.0, 2.0)); } -TEST(math, scalbf) { +TEST(MATH_TEST, scalbf) { ASSERT_FLOAT_EQ(12.0f, scalbf(3.0f, 2.0f)); } -TEST(math, scalbln) { +TEST(MATH_TEST, scalbln) { ASSERT_DOUBLE_EQ(12.0, scalbln(3.0, 2L)); } -TEST(math, scalblnf) { +TEST(MATH_TEST, scalblnf) { ASSERT_FLOAT_EQ(12.0f, scalblnf(3.0f, 2L)); } -TEST(math, scalblnl) { +TEST(MATH_TEST, scalblnl) { ASSERT_DOUBLE_EQ(12.0L, scalblnl(3.0L, 2L)); } -TEST(math, scalbn) { +TEST(MATH_TEST, scalbn) { ASSERT_DOUBLE_EQ(12.0, scalbn(3.0, 2)); } -TEST(math, scalbnf) { +TEST(MATH_TEST, scalbnf) { ASSERT_FLOAT_EQ(12.0f, scalbnf(3.0f, 2)); } -TEST(math, scalbnl) { +TEST(MATH_TEST, scalbnl) { ASSERT_DOUBLE_EQ(12.0L, scalbnl(3.0L, 2)); } -TEST(math, gamma) { +TEST(MATH_TEST, gamma) { ASSERT_DOUBLE_EQ(log(24.0), gamma(5.0)); } -TEST(math, gammaf) { +TEST(MATH_TEST, gammaf) { ASSERT_FLOAT_EQ(logf(24.0f), gammaf(5.0f)); } -TEST(math, gamma_r) { +TEST(MATH_TEST, gamma_r) { #if defined(__BIONIC__) int sign; ASSERT_DOUBLE_EQ(log(24.0), gamma_r(5.0, &sign)); @@ -1151,7 +1157,7 @@ TEST(math, gamma_r) { #endif // __BIONIC__ } -TEST(math, gammaf_r) { +TEST(MATH_TEST, gammaf_r) { #if defined(__BIONIC__) int sign; ASSERT_FLOAT_EQ(logf(24.0f), gammaf_r(5.0f, &sign)); @@ -1161,25 +1167,25 @@ TEST(math, gammaf_r) { #endif // __BIONIC__ } -TEST(math, lgamma) { +TEST(MATH_TEST, lgamma) { ASSERT_DOUBLE_EQ(log(24.0), lgamma(5.0)); } -TEST(math, lgammaf) { +TEST(MATH_TEST, lgammaf) { ASSERT_FLOAT_EQ(logf(24.0f), lgammaf(5.0f)); } -TEST(math, lgammal) { +TEST(MATH_TEST, lgammal) { ASSERT_DOUBLE_EQ(logl(24.0L), lgammal(5.0L)); } -TEST(math, lgamma_r) { +TEST(MATH_TEST, lgamma_r) { int sign; ASSERT_DOUBLE_EQ(log(24.0), lgamma_r(5.0, &sign)); ASSERT_EQ(1, sign); } -TEST(math, lgamma_r_17471883) { +TEST(MATH_TEST, lgamma_r_17471883) { int sign; sign = 0; @@ -1190,13 +1196,13 @@ TEST(math, lgamma_r_17471883) { ASSERT_EQ(-1, sign); } -TEST(math, lgammaf_r) { +TEST(MATH_TEST, lgammaf_r) { int sign; ASSERT_FLOAT_EQ(logf(24.0f), lgammaf_r(5.0f, &sign)); ASSERT_EQ(1, sign); } -TEST(math, lgammaf_r_17471883) { +TEST(MATH_TEST, lgammaf_r_17471883) { int sign; sign = 0; @@ -1207,13 +1213,13 @@ TEST(math, lgammaf_r_17471883) { ASSERT_EQ(-1, sign); } -TEST(math, lgammal_r) { +TEST(MATH_TEST, lgammal_r) { int sign; ASSERT_DOUBLE_EQ(log(24.0L), lgamma_r(5.0L, &sign)); ASSERT_EQ(1, sign); } -TEST(math, lgammal_r_17471883) { +TEST(MATH_TEST, lgammal_r_17471883) { int sign; sign = 0; @@ -1224,132 +1230,132 @@ TEST(math, lgammal_r_17471883) { ASSERT_EQ(-1, sign); } -TEST(math, tgamma) { +TEST(MATH_TEST, tgamma) { ASSERT_DOUBLE_EQ(24.0, tgamma(5.0)); } -TEST(math, tgammaf) { +TEST(MATH_TEST, tgammaf) { ASSERT_FLOAT_EQ(24.0f, tgammaf(5.0f)); } -TEST(math, tgammal) { +TEST(MATH_TEST, tgammal) { ASSERT_DOUBLE_EQ(24.0L, tgammal(5.0L)); } -TEST(math, j0) { +TEST(MATH_TEST, j0) { ASSERT_DOUBLE_EQ(1.0, j0(0.0)); ASSERT_DOUBLE_EQ(0.76519768655796661, j0(1.0)); } -TEST(math, j0f) { +TEST(MATH_TEST, j0f) { ASSERT_FLOAT_EQ(1.0f, j0f(0.0f)); ASSERT_FLOAT_EQ(0.76519769f, j0f(1.0f)); } -TEST(math, j1) { +TEST(MATH_TEST, j1) { ASSERT_DOUBLE_EQ(0.0, j1(0.0)); ASSERT_DOUBLE_EQ(0.44005058574493355, j1(1.0)); } -TEST(math, j1f) { +TEST(MATH_TEST, j1f) { ASSERT_FLOAT_EQ(0.0f, j1f(0.0f)); ASSERT_FLOAT_EQ(0.44005057f, j1f(1.0f)); } -TEST(math, jn) { +TEST(MATH_TEST, jn) { ASSERT_DOUBLE_EQ(0.0, jn(4, 0.0)); ASSERT_DOUBLE_EQ(0.0024766389641099553, jn(4, 1.0)); } -TEST(math, jnf) { +TEST(MATH_TEST, jnf) { ASSERT_FLOAT_EQ(0.0f, jnf(4, 0.0f)); ASSERT_FLOAT_EQ(0.0024766389f, jnf(4, 1.0f)); } -TEST(math, y0) { +TEST(MATH_TEST, y0) { ASSERT_DOUBLE_EQ(-HUGE_VAL, y0(0.0)); ASSERT_DOUBLE_EQ(0.08825696421567697, y0(1.0)); } -TEST(math, y0f) { +TEST(MATH_TEST, y0f) { ASSERT_FLOAT_EQ(-HUGE_VALF, y0f(0.0f)); ASSERT_FLOAT_EQ(0.088256963f, y0f(1.0f)); } -TEST(math, y1) { +TEST(MATH_TEST, y1) { ASSERT_DOUBLE_EQ(-HUGE_VAL, y1(0.0)); ASSERT_DOUBLE_EQ(-0.78121282130028868, y1(1.0)); } -TEST(math, y1f) { +TEST(MATH_TEST, y1f) { ASSERT_FLOAT_EQ(-HUGE_VALF, y1f(0.0f)); ASSERT_FLOAT_EQ(-0.78121281f, y1f(1.0f)); } -TEST(math, yn) { +TEST(MATH_TEST, yn) { ASSERT_DOUBLE_EQ(-HUGE_VAL, yn(4, 0.0)); ASSERT_DOUBLE_EQ(-33.278423028972114, yn(4, 1.0)); } -TEST(math, ynf) { +TEST(MATH_TEST, ynf) { ASSERT_FLOAT_EQ(-HUGE_VALF, ynf(4, 0.0f)); ASSERT_FLOAT_EQ(-33.278423f, ynf(4, 1.0f)); } -TEST(math, frexp) { +TEST(MATH_TEST, frexp) { int exp; double dr = frexp(1024.0, &exp); ASSERT_DOUBLE_EQ(1024.0, scalbn(dr, exp)); } -TEST(math, frexpf) { +TEST(MATH_TEST, frexpf) { int exp; float fr = frexpf(1024.0f, &exp); ASSERT_FLOAT_EQ(1024.0f, scalbnf(fr, exp)); } -TEST(math, frexpl) { +TEST(MATH_TEST, frexpl) { int exp; long double ldr = frexpl(1024.0L, &exp); ASSERT_DOUBLE_EQ(1024.0L, scalbnl(ldr, exp)); } -TEST(math, modf) { +TEST(MATH_TEST, modf) { double di; double df = modf(123.75, &di); ASSERT_DOUBLE_EQ(123.0, di); ASSERT_DOUBLE_EQ(0.75, df); } -TEST(math, modff) { +TEST(MATH_TEST, modff) { float fi; float ff = modff(123.75f, &fi); ASSERT_FLOAT_EQ(123.0f, fi); ASSERT_FLOAT_EQ(0.75f, ff); } -TEST(math, modfl) { +TEST(MATH_TEST, modfl) { long double ldi; long double ldf = modfl(123.75L, &ldi); ASSERT_DOUBLE_EQ(123.0L, ldi); ASSERT_DOUBLE_EQ(0.75L, ldf); } -TEST(math, remquo) { +TEST(MATH_TEST, remquo) { int q; double d = remquo(13.0, 4.0, &q); ASSERT_EQ(3, q); ASSERT_DOUBLE_EQ(1.0, d); } -TEST(math, remquof) { +TEST(MATH_TEST, remquof) { int q; float f = remquof(13.0f, 4.0f, &q); ASSERT_EQ(3, q); ASSERT_FLOAT_EQ(1.0, f); } -TEST(math, remquol) { +TEST(MATH_TEST, remquol) { int q; long double ld = remquol(13.0L, 4.0L, &q); ASSERT_DOUBLE_EQ(3L, q); @@ -1357,13 +1363,13 @@ TEST(math, remquol) { } // https://code.google.com/p/android/issues/detail?id=6697 -TEST(math, frexpf_public_bug_6697) { +TEST(MATH_TEST, frexpf_public_bug_6697) { int exp; float fr = frexpf(14.1f, &exp); ASSERT_FLOAT_EQ(14.1f, scalbnf(fr, exp)); } -TEST(math, exp2_STRICT_ALIGN_OpenBSD_bug) { +TEST(MATH_TEST, exp2_STRICT_ALIGN_OpenBSD_bug) { // OpenBSD/x86's libm had a bug here, but it was already fixed in FreeBSD: // http://svnweb.FreeBSD.org/base/head/lib/msun/src/math_private.h?revision=240827&view=markup ASSERT_DOUBLE_EQ(5.0, exp2(log2(5))); @@ -1371,7 +1377,7 @@ TEST(math, exp2_STRICT_ALIGN_OpenBSD_bug) { ASSERT_DOUBLE_EQ(5.0L, exp2l(log2l(5))); } -TEST(math, nextafterl_OpenBSD_bug) { +TEST(MATH_TEST, nextafterl_OpenBSD_bug) { // OpenBSD/x86's libm had a bug here. ASSERT_TRUE(nextafter(1.0, 0.0) - 1.0 < 0.0); ASSERT_TRUE(nextafterf(1.0f, 0.0f) - 1.0f < 0.0f); @@ -1379,511 +1385,511 @@ TEST(math, nextafterl_OpenBSD_bug) { } #include "math_data/acos_intel_data.h" -TEST(math, acos_intel) { +TEST(MATH_TEST, acos_intel) { DoMathDataTest<1>(g_acos_intel_data, acos); } #include "math_data/acosf_intel_data.h" -TEST(math, acosf_intel) { +TEST(MATH_TEST, acosf_intel) { DoMathDataTest<1>(g_acosf_intel_data, acosf); } #include "math_data/acosh_intel_data.h" -TEST(math, acosh_intel) { +TEST(MATH_TEST, acosh_intel) { DoMathDataTest<2>(g_acosh_intel_data, acosh); } #include "math_data/acoshf_intel_data.h" -TEST(math, acoshf_intel) { +TEST(MATH_TEST, acoshf_intel) { DoMathDataTest<2>(g_acoshf_intel_data, acoshf); } #include "math_data/asin_intel_data.h" -TEST(math, asin_intel) { +TEST(MATH_TEST, asin_intel) { DoMathDataTest<1>(g_asin_intel_data, asin); } #include "math_data/asinf_intel_data.h" -TEST(math, asinf_intel) { +TEST(MATH_TEST, asinf_intel) { DoMathDataTest<1>(g_asinf_intel_data, asinf); } #include "math_data/asinh_intel_data.h" -TEST(math, asinh_intel) { +TEST(MATH_TEST, asinh_intel) { DoMathDataTest<2>(g_asinh_intel_data, asinh); } #include "math_data/asinhf_intel_data.h" -TEST(math, asinhf_intel) { +TEST(MATH_TEST, asinhf_intel) { DoMathDataTest<2>(g_asinhf_intel_data, asinhf); } #include "math_data/atan2_intel_data.h" -TEST(math, atan2_intel) { +TEST(MATH_TEST, atan2_intel) { DoMathDataTest<2>(g_atan2_intel_data, atan2); } #include "math_data/atan2f_intel_data.h" -TEST(math, atan2f_intel) { +TEST(MATH_TEST, atan2f_intel) { DoMathDataTest<2>(g_atan2f_intel_data, atan2f); } #include "math_data/atan_intel_data.h" -TEST(math, atan_intel) { +TEST(MATH_TEST, atan_intel) { DoMathDataTest<1>(g_atan_intel_data, atan); } #include "math_data/atanf_intel_data.h" -TEST(math, atanf_intel) { +TEST(MATH_TEST, atanf_intel) { DoMathDataTest<1>(g_atanf_intel_data, atanf); } #include "math_data/atanh_intel_data.h" -TEST(math, atanh_intel) { +TEST(MATH_TEST, atanh_intel) { DoMathDataTest<2>(g_atanh_intel_data, atanh); } #include "math_data/atanhf_intel_data.h" -TEST(math, atanhf_intel) { +TEST(MATH_TEST, atanhf_intel) { DoMathDataTest<2>(g_atanhf_intel_data, atanhf); } #include "math_data/cbrt_intel_data.h" -TEST(math, cbrt_intel) { +TEST(MATH_TEST, cbrt_intel) { DoMathDataTest<1>(g_cbrt_intel_data, cbrt); } #include "math_data/cbrtf_intel_data.h" -TEST(math, cbrtf_intel) { +TEST(MATH_TEST, cbrtf_intel) { DoMathDataTest<1>(g_cbrtf_intel_data, cbrtf); } #include "math_data/ceil_intel_data.h" -TEST(math, ceil_intel) { +TEST(MATH_TEST, ceil_intel) { DoMathDataTest<1>(g_ceil_intel_data, ceil); } #include "math_data/ceilf_intel_data.h" -TEST(math, ceilf_intel) { +TEST(MATH_TEST, ceilf_intel) { DoMathDataTest<1>(g_ceilf_intel_data, ceilf); } #include "math_data/copysign_intel_data.h" -TEST(math, copysign_intel) { +TEST(MATH_TEST, copysign_intel) { DoMathDataTest<1>(g_copysign_intel_data, copysign); } #include "math_data/copysignf_intel_data.h" -TEST(math, copysignf_intel) { +TEST(MATH_TEST, copysignf_intel) { DoMathDataTest<1>(g_copysignf_intel_data, copysignf); } #include "math_data/cos_intel_data.h" -TEST(math, cos_intel) { +TEST(MATH_TEST, cos_intel) { DoMathDataTest<1>(g_cos_intel_data, cos); } #include "math_data/cosf_intel_data.h" -TEST(math, cosf_intel) { +TEST(MATH_TEST, cosf_intel) { DoMathDataTest<1>(g_cosf_intel_data, cosf); } #include "math_data/cosh_intel_data.h" -TEST(math, cosh_intel) { +TEST(MATH_TEST, cosh_intel) { DoMathDataTest<2>(g_cosh_intel_data, cosh); } #include "math_data/coshf_intel_data.h" -TEST(math, coshf_intel) { +TEST(MATH_TEST, coshf_intel) { DoMathDataTest<2>(g_coshf_intel_data, coshf); } #include "math_data/exp_intel_data.h" -TEST(math, exp_intel) { +TEST(MATH_TEST, exp_intel) { DoMathDataTest<1>(g_exp_intel_data, exp); } #include "math_data/expf_intel_data.h" -TEST(math, expf_intel) { +TEST(MATH_TEST, expf_intel) { DoMathDataTest<1>(g_expf_intel_data, expf); } #include "math_data/exp2_intel_data.h" -TEST(math, exp2_intel) { +TEST(MATH_TEST, exp2_intel) { DoMathDataTest<1>(g_exp2_intel_data, exp2); } #include "math_data/exp2f_intel_data.h" -TEST(math, exp2f_intel) { +TEST(MATH_TEST, exp2f_intel) { DoMathDataTest<1>(g_exp2f_intel_data, exp2f); } #include "math_data/expm1_intel_data.h" -TEST(math, expm1_intel) { +TEST(MATH_TEST, expm1_intel) { DoMathDataTest<1>(g_expm1_intel_data, expm1); } #include "math_data/expm1f_intel_data.h" -TEST(math, expm1f_intel) { +TEST(MATH_TEST, expm1f_intel) { DoMathDataTest<1>(g_expm1f_intel_data, expm1f); } #include "math_data/fabs_intel_data.h" -TEST(math, fabs_intel) { +TEST(MATH_TEST, fabs_intel) { DoMathDataTest<1>(g_fabs_intel_data, fabs); } #include "math_data/fabsf_intel_data.h" -TEST(math, fabsf_intel) { +TEST(MATH_TEST, fabsf_intel) { DoMathDataTest<1>(g_fabsf_intel_data, fabsf); } #include "math_data/fdim_intel_data.h" -TEST(math, fdim_intel) { +TEST(MATH_TEST, fdim_intel) { DoMathDataTest<1>(g_fdim_intel_data, fdim); } #include "math_data/fdimf_intel_data.h" -TEST(math, fdimf_intel) { +TEST(MATH_TEST, fdimf_intel) { DoMathDataTest<1>(g_fdimf_intel_data, fdimf); } #include "math_data/floor_intel_data.h" -TEST(math, floor_intel) { +TEST(MATH_TEST, floor_intel) { DoMathDataTest<1>(g_floor_intel_data, floor); } #include "math_data/floorf_intel_data.h" -TEST(math, floorf_intel) { +TEST(MATH_TEST, floorf_intel) { DoMathDataTest<1>(g_floorf_intel_data, floorf); } #include "math_data/fma_intel_data.h" -TEST(math, fma_intel) { +TEST(MATH_TEST, fma_intel) { DoMathDataTest<1>(g_fma_intel_data, fma); } #include "math_data/fmaf_intel_data.h" -TEST(math, fmaf_intel) { +TEST(MATH_TEST, fmaf_intel) { DoMathDataTest<1>(g_fmaf_intel_data, fmaf); } #include "math_data/fmax_intel_data.h" -TEST(math, fmax_intel) { +TEST(MATH_TEST, fmax_intel) { DoMathDataTest<1>(g_fmax_intel_data, fmax); } #include "math_data/fmaxf_intel_data.h" -TEST(math, fmaxf_intel) { +TEST(MATH_TEST, fmaxf_intel) { DoMathDataTest<1>(g_fmaxf_intel_data, fmaxf); } #include "math_data/fmin_intel_data.h" -TEST(math, fmin_intel) { +TEST(MATH_TEST, fmin_intel) { DoMathDataTest<1>(g_fmin_intel_data, fmin); } #include "math_data/fminf_intel_data.h" -TEST(math, fminf_intel) { +TEST(MATH_TEST, fminf_intel) { DoMathDataTest<1>(g_fminf_intel_data, fminf); } #include "math_data/fmod_intel_data.h" -TEST(math, fmod_intel) { +TEST(MATH_TEST, fmod_intel) { DoMathDataTest<1>(g_fmod_intel_data, fmod); } #include "math_data/fmodf_intel_data.h" -TEST(math, fmodf_intel) { +TEST(MATH_TEST, fmodf_intel) { DoMathDataTest<1>(g_fmodf_intel_data, fmodf); } #include "math_data/frexp_intel_data.h" -TEST(math, frexp_intel) { +TEST(MATH_TEST, frexp_intel) { DoMathDataTest<1>(g_frexp_intel_data, frexp); } #include "math_data/frexpf_intel_data.h" -TEST(math, frexpf_intel) { +TEST(MATH_TEST, frexpf_intel) { DoMathDataTest<1>(g_frexpf_intel_data, frexpf); } #include "math_data/hypot_intel_data.h" -TEST(math, hypot_intel) { +TEST(MATH_TEST, hypot_intel) { DoMathDataTest<1>(g_hypot_intel_data, hypot); } #include "math_data/hypotf_intel_data.h" -TEST(math, hypotf_intel) { +TEST(MATH_TEST, hypotf_intel) { DoMathDataTest<1>(g_hypotf_intel_data, hypotf); } #include "math_data/ilogb_intel_data.h" -TEST(math, ilogb_intel) { +TEST(MATH_TEST, ilogb_intel) { DoMathDataTest<1>(g_ilogb_intel_data, ilogb); } #include "math_data/ilogbf_intel_data.h" -TEST(math, ilogbf_intel) { +TEST(MATH_TEST, ilogbf_intel) { DoMathDataTest<1>(g_ilogbf_intel_data, ilogbf); } #include "math_data/ldexp_intel_data.h" -TEST(math, ldexp_intel) { +TEST(MATH_TEST, ldexp_intel) { DoMathDataTest<1>(g_ldexp_intel_data, ldexp); } #include "math_data/ldexpf_intel_data.h" -TEST(math, ldexpf_intel) { +TEST(MATH_TEST, ldexpf_intel) { DoMathDataTest<1>(g_ldexpf_intel_data, ldexpf); } #include "math_data/llrint_intel_data.h" -TEST(math, llrint_intel) { +TEST(MATH_TEST, llrint_intel) { DoMathDataTest<1>(g_llrint_intel_data, llrint); } #include "math_data/llrintf_intel_data.h" -TEST(math, llrintf_intel) { +TEST(MATH_TEST, llrintf_intel) { DoMathDataTest<1>(g_llrintf_intel_data, llrintf); } #include "math_data/log_intel_data.h" -TEST(math, log_intel) { +TEST(MATH_TEST, log_intel) { DoMathDataTest<1>(g_log_intel_data, log); } #include "math_data/logf_intel_data.h" -TEST(math, logf_intel) { +TEST(MATH_TEST, logf_intel) { DoMathDataTest<1>(g_logf_intel_data, logf); } #include "math_data/log10_intel_data.h" -TEST(math, log10_intel) { +TEST(MATH_TEST, log10_intel) { DoMathDataTest<1>(g_log10_intel_data, log10); } #include "math_data/log10f_intel_data.h" -TEST(math, log10f_intel) { +TEST(MATH_TEST, log10f_intel) { DoMathDataTest<1>(g_log10f_intel_data, log10f); } #include "math_data/log1p_intel_data.h" -TEST(math, log1p_intel) { +TEST(MATH_TEST, log1p_intel) { DoMathDataTest<1>(g_log1p_intel_data, log1p); } #include "math_data/log1pf_intel_data.h" -TEST(math, log1pf_intel) { +TEST(MATH_TEST, log1pf_intel) { DoMathDataTest<1>(g_log1pf_intel_data, log1pf); } #include "math_data/log2_intel_data.h" -TEST(math, log2_intel) { +TEST(MATH_TEST, log2_intel) { DoMathDataTest<1>(g_log2_intel_data, log2); } #include "math_data/log2f_intel_data.h" -TEST(math, log2f_intel) { +TEST(MATH_TEST, log2f_intel) { DoMathDataTest<1>(g_log2f_intel_data, log2f); } #include "math_data/logb_intel_data.h" -TEST(math, logb_intel) { +TEST(MATH_TEST, logb_intel) { DoMathDataTest<1>(g_logb_intel_data, logb); } #include "math_data/logbf_intel_data.h" -TEST(math, logbf_intel) { +TEST(MATH_TEST, logbf_intel) { DoMathDataTest<1>(g_logbf_intel_data, logbf); } #include "math_data/lrint_intel_data.h" -TEST(math, lrint_intel) { +TEST(MATH_TEST, lrint_intel) { DoMathDataTest<1>(g_lrint_intel_data, lrint); } #include "math_data/lrintf_intel_data.h" -TEST(math, lrintf_intel) { +TEST(MATH_TEST, lrintf_intel) { DoMathDataTest<1>(g_lrintf_intel_data, lrintf); } #include "math_data/modf_intel_data.h" -TEST(math, modf_intel) { +TEST(MATH_TEST, modf_intel) { DoMathDataTest<1>(g_modf_intel_data, modf); } #include "math_data/modff_intel_data.h" -TEST(math, modff_intel) { +TEST(MATH_TEST, modff_intel) { DoMathDataTest<1>(g_modff_intel_data, modff); } #include "math_data/nearbyint_intel_data.h" -TEST(math, nearbyint_intel) { +TEST(MATH_TEST, nearbyint_intel) { DoMathDataTest<1>(g_nearbyint_intel_data, nearbyint); } #include "math_data/nearbyintf_intel_data.h" -TEST(math, nearbyintf_intel) { +TEST(MATH_TEST, nearbyintf_intel) { DoMathDataTest<1>(g_nearbyintf_intel_data, nearbyintf); } #include "math_data/nextafter_intel_data.h" -TEST(math, nextafter_intel) { +TEST(MATH_TEST, nextafter_intel) { DoMathDataTest<1>(g_nextafter_intel_data, nextafter); } #include "math_data/nextafterf_intel_data.h" -TEST(math, nextafterf_intel) { +TEST(MATH_TEST, nextafterf_intel) { DoMathDataTest<1>(g_nextafterf_intel_data, nextafterf); } #include "math_data/pow_intel_data.h" -TEST(math, pow_intel) { +TEST(MATH_TEST, pow_intel) { DoMathDataTest<1>(g_pow_intel_data, pow); } #include "math_data/powf_intel_data.h" -TEST(math, powf_intel) { +TEST(MATH_TEST, powf_intel) { DoMathDataTest<1>(g_powf_intel_data, powf); } #include "math_data/remainder_intel_data.h" -TEST(math, remainder_intel) { +TEST(MATH_TEST, remainder_intel) { DoMathDataTest<1>(g_remainder_intel_data, remainder); } #include "math_data/remainderf_intel_data.h" -TEST(math, remainderf_intel) { +TEST(MATH_TEST, remainderf_intel) { DoMathDataTest<1>(g_remainderf_intel_data, remainderf); } #include "math_data/remquo_intel_data.h" -TEST(math, remquo_intel) { +TEST(MATH_TEST, remquo_intel) { DoMathDataTest<1>(g_remquo_intel_data, remquo); } #include "math_data/remquof_intel_data.h" -TEST(math, remquof_intel) { +TEST(MATH_TEST, remquof_intel) { DoMathDataTest<1>(g_remquof_intel_data, remquof); } #include "math_data/rint_intel_data.h" -TEST(math, rint_intel) { +TEST(MATH_TEST, rint_intel) { DoMathDataTest<1>(g_rint_intel_data, rint); } #include "math_data/rintf_intel_data.h" -TEST(math, rintf_intel) { +TEST(MATH_TEST, rintf_intel) { DoMathDataTest<1>(g_rintf_intel_data, rintf); } #include "math_data/round_intel_data.h" -TEST(math, round_intel) { +TEST(MATH_TEST, round_intel) { DoMathDataTest<1>(g_round_intel_data, round); } #include "math_data/roundf_intel_data.h" -TEST(math, roundf_intel) { +TEST(MATH_TEST, roundf_intel) { DoMathDataTest<1>(g_roundf_intel_data, roundf); } #include "math_data/scalb_intel_data.h" -TEST(math, scalb_intel) { +TEST(MATH_TEST, scalb_intel) { DoMathDataTest<1>(g_scalb_intel_data, scalb); } #include "math_data/scalbf_intel_data.h" -TEST(math, scalbf_intel) { +TEST(MATH_TEST, scalbf_intel) { DoMathDataTest<1>(g_scalbf_intel_data, scalbf); } #include "math_data/scalbn_intel_data.h" -TEST(math, scalbn_intel) { +TEST(MATH_TEST, scalbn_intel) { DoMathDataTest<1>(g_scalbn_intel_data, scalbn); } #include "math_data/scalbnf_intel_data.h" -TEST(math, scalbnf_intel) { +TEST(MATH_TEST, scalbnf_intel) { DoMathDataTest<1>(g_scalbnf_intel_data, scalbnf); } #include "math_data/significand_intel_data.h" -TEST(math, significand_intel) { +TEST(MATH_TEST, significand_intel) { DoMathDataTest<1>(g_significand_intel_data, significand); } #include "math_data/significandf_intel_data.h" -TEST(math, significandf_intel) { +TEST(MATH_TEST, significandf_intel) { DoMathDataTest<1>(g_significandf_intel_data, significandf); } #include "math_data/sin_intel_data.h" -TEST(math, sin_intel) { +TEST(MATH_TEST, sin_intel) { DoMathDataTest<1>(g_sin_intel_data, sin); } #include "math_data/sinf_intel_data.h" -TEST(math, sinf_intel) { +TEST(MATH_TEST, sinf_intel) { DoMathDataTest<1>(g_sinf_intel_data, sinf); } #include "math_data/sinh_intel_data.h" -TEST(math, sinh_intel) { +TEST(MATH_TEST, sinh_intel) { DoMathDataTest<2>(g_sinh_intel_data, sinh); } #include "math_data/sinhf_intel_data.h" -TEST(math, sinhf_intel) { +TEST(MATH_TEST, sinhf_intel) { DoMathDataTest<2>(g_sinhf_intel_data, sinhf); } #include "math_data/sincos_intel_data.h" -TEST(math, sincos_intel) { +TEST(MATH_TEST, sincos_intel) { DoMathDataTest<1>(g_sincos_intel_data, sincos); } #include "math_data/sincosf_intel_data.h" -TEST(math, sincosf_intel) { +TEST(MATH_TEST, sincosf_intel) { DoMathDataTest<1>(g_sincosf_intel_data, sincosf); } #include "math_data/sqrt_intel_data.h" -TEST(math, sqrt_intel) { +TEST(MATH_TEST, sqrt_intel) { DoMathDataTest<1>(g_sqrt_intel_data, sqrt); } #include "math_data/sqrtf_intel_data.h" -TEST(math, sqrtf_intel) { +TEST(MATH_TEST, sqrtf_intel) { DoMathDataTest<1>(g_sqrtf_intel_data, sqrtf); } #include "math_data/tan_intel_data.h" -TEST(math, tan_intel) { +TEST(MATH_TEST, tan_intel) { DoMathDataTest<1>(g_tan_intel_data, tan); } #include "math_data/tanf_intel_data.h" -TEST(math, tanf_intel) { +TEST(MATH_TEST, tanf_intel) { DoMathDataTest<1>(g_tanf_intel_data, tanf); } #include "math_data/tanh_intel_data.h" -TEST(math, tanh_intel) { +TEST(MATH_TEST, tanh_intel) { DoMathDataTest<2>(g_tanh_intel_data, tanh); } #include "math_data/tanhf_intel_data.h" -TEST(math, tanhf_intel) { +TEST(MATH_TEST, tanhf_intel) { DoMathDataTest<2>(g_tanhf_intel_data, tanhf); } #include "math_data/trunc_intel_data.h" -TEST(math, trunc_intel) { +TEST(MATH_TEST, trunc_intel) { DoMathDataTest<1>(g_trunc_intel_data, trunc); } #include "math_data/truncf_intel_data.h" -TEST(math, truncf_intel) { +TEST(MATH_TEST, truncf_intel) { DoMathDataTest<1>(g_truncf_intel_data, truncf); } |