diff --git a/libc/bionic/strtold.cpp b/libc/bionic/strtold.cpp
index c55dd61..6b673e6 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 f7bd433..41df854 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 79fe07c..3fe8f35 100644
--- a/libc/include/complex.h
+++ b/libc/include/complex.h
@@ -61,99 +61,99 @@
 /* 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 248ed3c..3d0ec49 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_VALF	__builtin_huge_valf()
-#define HUGE_VALL	__builtin_huge_vall()
-#define INFINITY	__builtin_inff()
-#define NAN		__builtin_nanf("")
+#define HUGE_VAL __builtin_huge_val()
+#define HUGE_VALF __builtin_huge_valf()
+#define HUGE_VALL __builtin_huge_vall()
 
-#define MATH_ERRNO	1
-#define MATH_ERREXCEPT	2
-#define math_errhandling	MATH_ERREXCEPT
+#define INFINITY __builtin_inff()
+
+#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,20 +53,257 @@
 #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 signbit(x) \
+    ((sizeof(x) == sizeof(float)) ? __builtin_signbitf(x) \
+    : (sizeof(x) == sizeof(double)) ? __builtin_signbit(x) \
+    : __builtin_signbitl(x))
+
+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);
+float expf(float __x);
+long double expl(long double __x) __RENAME_LDBL(exp, 3, 21);
+
+double exp2(double __x);
+float exp2f(float __x);
+long double exp2l(long double __x) __RENAME_LDBL(exp2, 3, 21);
+
+double expm1(double __x);
+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__;
+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);
+float log2f(float __x) __INTRODUCED_IN(18);
+long double log2l(long double __x) __RENAME_LDBL(log2, 18, 18);
+
+double logb(double __x);
+float logbf(float __x);
+long double logbl(long double __x) __RENAME_LDBL(logb, 3, 18);
+
+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 scalbn(double __x, int __exponent);
+float scalbnf(float __x, int __exponent);
+long double scalbnl(long double __x, int __exponent) __RENAME_LDBL(scalbn, 3, 3);
+
+/* 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;
+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;
+
+double cbrt(double __x);
+float cbrtf(float __x);
+long double cbrtl(long double __x) __RENAME_LDBL(cbrt, 3, 21);
+
+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);
+
+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);
+long double powl(long double __x, long double __y) __RENAME_LDBL(pow, 3, 21);
+
+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);
+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);
+
+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);
+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);
+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);
+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);
+
+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))
@@ -67,92 +311,6 @@
 #define islessgreater(x, y) __builtin_islessgreater((x), (y))
 #define isunordered(x, y) __builtin_isunordered((x), (y))
 
-#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);
-double asin(double __x);
-double atan(double __x);
-double atan2(double __y, double __x);
-double cos(double __x);
-double sin(double __x);
-double tan(double __x);
-
-double cosh(double __x);
-double sinh(double __x);
-double tanh(double __x);
-
-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);
-
-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);
-double expm1(double __x);
-double fma(double __x, double __y, double __z);
-double hypot(double __x, double __y);
-int ilogb(double __x) __attribute_const__;
-double lgamma(double __x);
-long long llrint(double __x);
-long long llround(double __x);
-double log1p(double __x);
-double log2(double __x) __INTRODUCED_IN(18);
-double logb(double __x);
-long lrint(double __x);
-long lround(double __x);
-
 /*
  * 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
@@ -167,150 +325,9 @@
 int (isinf)(double __x) __attribute_const__ __INTRODUCED_IN(21);
 int (isnan)(double __x) __attribute_const__;
 
-double nan(const char* __kind) __attribute_const__ __INTRODUCED_IN_ARM(13) __INTRODUCED_IN_MIPS(13)
-    __INTRODUCED_IN_X86(9);
+/* POSIX extensions. */
 
-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 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);
-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 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);
-
-float coshf(float __x);
-float sinhf(float __x);
-float tanhf(float __x);
-
-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__ */
-
-float powf(float __x, float __y);
-float sqrtf(float __x);
-
-float ceilf(float __x);
-float fabsf(float __x) __attribute_const__;
-float floorf(float __x);
-float fmodf(float __x, float __y);
-float roundf(float __x);
-
-float erff(float __x);
-float erfcf(float __x);
-float hypotf(float __x, float __y);
-float lgammaf(float __x);
-float tgammaf(float __x) __INTRODUCED_IN_ARM(13) __INTRODUCED_IN_MIPS(13) __INTRODUCED_IN_X86(9);
-
-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);
-long lrintf(float __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);
-float remainderf(float __x, float __y);
-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);
-
-float fdimf(float __x, float __y);
-float fmaf(float __x, float __y, float __z);
-float fmaxf(float __x, float __y) __attribute_const__;
-float fminf(float __x, float __y) __attribute_const__;
-
-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);
+extern int signgam;
 
 double j0(double __x);
 double j1(double __x);
@@ -335,6 +352,38 @@
 
 #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 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 4182f2d..86336a0 100644
--- a/libc/include/stdlib.h
+++ b/libc/include/stdlib.h
@@ -75,7 +75,7 @@
 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 58eebc5..063b51d 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 1dda4bd..1cf498c83 100644
--- a/libc/include/wchar.h
+++ b/libc/include/wchar.h
@@ -98,7 +98,7 @@
 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 e5cb029..bf86264 100644
--- a/libm/Android.bp
+++ b/libm/Android.bp
@@ -506,6 +506,7 @@
     ],
 
     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 075822a..3731156 100644
--- a/tests/Android.bp
+++ b/tests/Android.bp
@@ -57,6 +57,7 @@
         "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 @@
         "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 0000000..2ea7bd4
--- /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 3a5ef74..85b20de 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 @@
   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 0000000..432182b
--- /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 b960944..0fc4e50 100644
--- a/tests/math_test.cpp
+++ b/tests/math_test.cpp
@@ -48,6 +48,12 @@
 }
 }
 
+#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 @@
 
 #include <android-base/scopeguard.h>
 
-float float_subnormal() {
+static float float_subnormal() {
   union {
     float f;
     uint32_t i;
@@ -68,7 +74,7 @@
   return u.f;
 }
 
-double double_subnormal() {
+static double double_subnormal() {
   union {
     double d;
     uint64_t i;
@@ -77,7 +83,7 @@
   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 @@
   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 @@
   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 @@
   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 @@
   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 @@
   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 @@
 }
 
 // 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 @@
   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 @@
   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 @@
   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 @@
   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 @@
   ASSERT_FALSE(__isfinite(HUGE_VAL));
 }
 
-TEST(math, __isfinitef) {
+TEST(MATH_TEST, __isfinitef) {
 #if defined(__GLIBC__)
 #define __isfinitef __finitef
 #endif
@@ -218,7 +224,7 @@
   ASSERT_FALSE(__isfinitef(HUGE_VALF));
 }
 
-TEST(math, __isfinitel) {
+TEST(MATH_TEST, __isfinitel) {
 #if defined(__GLIBC__)
 #define __isfinitel __finitel
 #endif
@@ -226,49 +232,49 @@
   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 @@
 #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 @@
 #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 @@
 #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 @@
   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 @@
   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 @@
   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 @@
   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 @@
   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 @@
   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 @@
   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 @@
   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 @@
   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 @@
   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 @@
   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 @@
   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 @@
   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 @@
   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 @@
   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 @@
   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 @@
   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 @@
   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 @@
   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 @@
 #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 @@
 #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 @@
   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 @@
   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 @@
   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 @@
 }
 
 // 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 @@
   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 @@
 }
 
 #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);
 }