[libc++][nfc] Add TEST_HAS_NO_INT128.

[Mordante]

Summary

Avoid using the libc++ internal _LIBCPP_HAS_NO_INT128 in our tests.

I've created D117993 as an RFC to guard against using _LIBCPP_HAS_NO_INT128 in our tests in the future.

[ldionne]

Awesome, thanks a lot! Ship-it once CI passes.

libcxx/test/libcxx/algorithms/half_positive.pass.cpp

 int main(int, char**)
 {
     {
         assert(test<char>());
         assert(test<int>());
         assert(test<long>());
         assert((test<UserDefinedIntegral<int>, int>()));
         assert(test<size_t>());
-#if !defined(_LIBCPP_HAS_NO_INT128)
+#if !defined(TEST_HAS_NO_INT128)
         assert(test<__int128_t>());
-#endif // !defined(_LIBCPP_HAS_NO_INT128)
+#endif // !defined(TEST_HAS_NO_INT128)
     }
 
 #if TEST_STD_VER >= 11
     {
         static_assert(test<char>(), "");
         static_assert(test<int>(), "");
         static_assert(test<long>(), "");
         static_assert(test<size_t>(), "");
-#if !defined(_LIBCPP_HAS_NO_INT128)
+#if !defined(TEST_HAS_NO_INT128)
         static_assert(test<__int128_t>(), "");
-#endif // !defined(_LIBCPP_HAS_NO_INT128)
+#endif // !defined(TEST_HAS_NO_INT128)
     }
 #endif // TEST_STD_VER >= 11
 
   return 0;
 }

libcxx/test/libcxx/numerics/numeric.ops/midpoint.integer.pass.cpp

int main(int, char**)
     test<unsigned long>();
     test<unsigned long long>();
 
     test<uint8_t>();
     test<uint16_t>();
     test<uint32_t>();
     test<uint64_t>();
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t>();
     test<__uint128_t>();
 #endif
 
     test<char>();
     test<ptrdiff_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/libcxx/type_traits/convert_to_integral.pass.cpp

#endif
   check_integral_types<short, int>();
   check_integral_types<unsigned short, int>();
   check_integral_types<int, int>();
   check_integral_types<unsigned, unsigned>();
   check_integral_types<long, long>();
   check_integral_types<unsigned long, unsigned long>();
   check_integral_types<long long, long long>();
   check_integral_types<unsigned long long, unsigned long long>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
   check_integral_types<__int128_t, __int128_t>();
   check_integral_types<__uint128_t, __uint128_t>();
 #endif
     // TODO(ericwf): Not standard
   typedef std::underlying_type<enum1>::type Enum1UT;
   check_enum_types<enum1, decltype(((Enum1UT)1) + 1)>();
   typedef std::underlying_type<enum2>::type Enum2UT;
   check_enum_types<enum2, decltype(((Enum2UT)1) + 1)>();
 
   return 0;
 }

libcxx/test/libcxx/utilities/format/format.arguments/format.arg/visit_format_arg.pass.cpp

void test() {
   test<Context, long long, long long>(std::numeric_limits<signed char>::min());
   test<Context, long long, long long>(0);
   test<Context, long long, long long>(std::numeric_limits<signed char>::max());
   test<Context, long long, long long>(std::numeric_limits<short>::max());
   test<Context, long long, long long>(std::numeric_limits<int>::max());
   test<Context, long long, long long>(std::numeric_limits<long>::max());
   test<Context, long long, long long>(std::numeric_limits<long long>::max());
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
   test<Context, __int128_t, __int128_t>(std::numeric_limits<__int128_t>::min());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<long long>::min());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<long>::min());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<int>::min());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<short>::min());
   test<Context, __int128_t, __int128_t>(
       std::numeric_limits<signed char>::min());
   test<Context, __int128_t, __int128_t>(0);
test<Context, unsigned long long, unsigned long long>(
       std::numeric_limits<unsigned short>::max());
   test<Context, unsigned long long, unsigned long long>(
       std::numeric_limits<unsigned>::max());
   test<Context, unsigned long long, unsigned long long>(
       std::numeric_limits<unsigned long>::max());
   test<Context, unsigned long long, unsigned long long>(
       std::numeric_limits<unsigned long long>::max());
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
   test<Context, __uint128_t, __uint128_t>(0);
   test<Context, __uint128_t, __uint128_t>(
       std::numeric_limits<unsigned char>::max());
   test<Context, __uint128_t, __uint128_t>(
       std::numeric_limits<unsigned short>::max());
   test<Context, __uint128_t, __uint128_t>(
       std::numeric_limits<unsigned int>::max());
   test<Context, __uint128_t, __uint128_t>(

libcxx/test/libcxx/utilities/format/format.arguments/format.args/get.pass.cpp

void test() {
   test<Context, long long, long long>(std::numeric_limits<signed char>::min());
   test<Context, long long, long long>(0);
   test<Context, long long, long long>(std::numeric_limits<signed char>::max());
   test<Context, long long, long long>(std::numeric_limits<short>::max());
   test<Context, long long, long long>(std::numeric_limits<int>::max());
   test<Context, long long, long long>(std::numeric_limits<long>::max());
   test<Context, long long, long long>(std::numeric_limits<long long>::max());
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
   test<Context, __int128_t, __int128_t>(std::numeric_limits<__int128_t>::min());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<long long>::min());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<long>::min());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<int>::min());
   test<Context, __int128_t, __int128_t>(std::numeric_limits<short>::min());
   test<Context, __int128_t, __int128_t>(
       std::numeric_limits<signed char>::min());
   test<Context, __int128_t, __int128_t>(0);
test<Context, unsigned long long, unsigned long long>(
       std::numeric_limits<unsigned short>::max());
   test<Context, unsigned long long, unsigned long long>(
       std::numeric_limits<unsigned>::max());
   test<Context, unsigned long long, unsigned long long>(
       std::numeric_limits<unsigned long>::max());
   test<Context, unsigned long long, unsigned long long>(
       std::numeric_limits<unsigned long long>::max());
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
   test<Context, __uint128_t, __uint128_t>(0);
   test<Context, __uint128_t, __uint128_t>(
       std::numeric_limits<unsigned char>::max());
   test<Context, __uint128_t, __uint128_t>(
       std::numeric_limits<unsigned short>::max());
   test<Context, __uint128_t, __uint128_t>(
       std::numeric_limits<unsigned int>::max());
   test<Context, __uint128_t, __uint128_t>(

libcxx/test/std/concepts/concepts.lang/concept.common/common_with.compile.pass.cpp

 }
 
 namespace BuiltinTypes {
 // fundamental types
 static_assert(std::common_with<void, void>);
 static_assert(CheckCommonWith<int, int>());
 static_assert(CheckCommonWith<int, long>());
 static_assert(CheckCommonWith<int, unsigned char>());
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
 static_assert(CheckCommonWith<int, __int128_t>());
 #endif
 static_assert(CheckCommonWith<int, double>());
 
 // arrays
 static_assert(CheckCommonWith<int[5], int[5]>());
 
 // pointers

libcxx/test/std/concepts/concepts.lang/concept.commonref/common_reference.compile.pass.cpp

 }
 
 namespace BuiltinTypes {
 // fundamental types
 static_assert(std::common_reference_with<void, void>);
 static_assert(CheckCommonReferenceWith<int, int>());
 static_assert(CheckCommonReferenceWith<int, long>());
 static_assert(CheckCommonReferenceWith<int, unsigned char>());
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
 static_assert(CheckCommonReferenceWith<int, __int128_t>());
 #endif
 static_assert(CheckCommonReferenceWith<int, double>());
 
 // arrays
 static_assert(CheckCommonReferenceWith<int[5], int[5]>());
 
 // pointers (common with void*)

libcxx/test/std/concepts/concepts.lang/concepts.arithmetic/integral.pass.cpp

 static_assert(CheckIntegralQualifiers<int>());
 static_assert(CheckIntegralQualifiers<unsigned int>());
 static_assert(CheckIntegralQualifiers<long>());
 static_assert(CheckIntegralQualifiers<unsigned long>());
 static_assert(CheckIntegralQualifiers<long long>());
 static_assert(CheckIntegralQualifiers<unsigned long long>());
 
 // extended integers
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
 static_assert(CheckIntegralQualifiers<__int128_t>());
 static_assert(CheckIntegralQualifiers<__uint128_t>());
 #endif
 
 // bool and char types are also integral
 static_assert(CheckIntegralQualifiers<wchar_t>());
 static_assert(CheckIntegralQualifiers<bool>());
 static_assert(CheckIntegralQualifiers<char>());

libcxx/test/std/concepts/concepts.lang/concepts.arithmetic/signed_integral.pass.cpp

 // integers that aren't signed integrals
 static_assert(!CheckSignedIntegralQualifiers<unsigned char>());
 static_assert(!CheckSignedIntegralQualifiers<unsigned short>());
 static_assert(!CheckSignedIntegralQualifiers<unsigned int>());
 static_assert(!CheckSignedIntegralQualifiers<unsigned long>());
 static_assert(!CheckSignedIntegralQualifiers<unsigned long long>());
 
 // extended integers
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
 static_assert(CheckSignedIntegralQualifiers<__int128_t>());
 static_assert(!CheckSignedIntegralQualifiers<__uint128_t>());
 #endif
 
 // types that aren't even integers shouldn't be signed integers!
 static_assert(!std::signed_integral<void>);
 static_assert(!CheckSignedIntegralQualifiers<float>());
 static_assert(!CheckSignedIntegralQualifiers<double>());

libcxx/test/std/concepts/concepts.lang/concepts.arithmetic/unsigned_integral.pass.cpp

 static_assert(CheckUnsignedIntegralQualifiers<char8_t>() ==
               !std::is_signed_v<char8_t>);
 static_assert(CheckUnsignedIntegralQualifiers<char16_t>() ==
               !std::is_signed_v<char16_t>);
 static_assert(CheckUnsignedIntegralQualifiers<char32_t>() ==
               !std::is_signed_v<char32_t>);
 
 // extended integers
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
 static_assert(CheckUnsignedIntegralQualifiers<__uint128_t>());
 static_assert(!CheckUnsignedIntegralQualifiers<__int128_t>());
 #endif
 
 // integer types that aren't unsigned integrals
 static_assert(!CheckUnsignedIntegralQualifiers<signed char>());
 static_assert(!CheckUnsignedIntegralQualifiers<short>());
 static_assert(!CheckUnsignedIntegralQualifiers<int>());

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable.compile.pass.cpp

 static_assert(std::three_way_comparable<wchar_t&>);
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
 static_assert(std::three_way_comparable<char8_t const&>);
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 static_assert(std::three_way_comparable<char16_t volatile&>);
 static_assert(std::three_way_comparable<char32_t const volatile&>);
 #endif
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
 static_assert(std::three_way_comparable<__int128_t const&>);
 static_assert(std::three_way_comparable<__uint128_t const&>);
 #endif
 static_assert(std::three_way_comparable<unsigned char&&>);
 static_assert(std::three_way_comparable<unsigned short const&&>);
 static_assert(std::three_way_comparable<unsigned int volatile&&>);
 static_assert(std::three_way_comparable<unsigned long const volatile&&>);
 

libcxx/test/std/language.support/support.limits/limits/is_specialized.pass.cpp

#endif
     test<signed short>();
     test<unsigned short>();
     test<signed int>();
     test<unsigned int>();
     test<signed long>();
     test<unsigned long>();
     test<signed long long>();
     test<unsigned long long>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t>();
     test<__uint128_t>();
 #endif
     test<float>();
     test<double>();
     test<long double>();
     static_assert(!std::numeric_limits<std::complex<double> >::is_specialized,
                  "!std::numeric_limits<std::complex<double> >::is_specialized");
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp

#endif
     TEST_NUMERIC_LIMITS(const volatile int)
 
     // long
     TEST_NUMERIC_LIMITS(long)
     TEST_NUMERIC_LIMITS(const long)
     TEST_NUMERIC_LIMITS(volatile long)
     TEST_NUMERIC_LIMITS(const volatile long)
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     TEST_NUMERIC_LIMITS(__int128_t)
     TEST_NUMERIC_LIMITS(const __int128_t)
     TEST_NUMERIC_LIMITS(volatile __int128_t)
     TEST_NUMERIC_LIMITS(const volatile __int128_t)
 #endif
 
     // long long
     TEST_NUMERIC_LIMITS(long long)
#endif
     TEST_NUMERIC_LIMITS(const volatile unsigned long)
 
     // unsigned long long
     TEST_NUMERIC_LIMITS(unsigned long long)
     TEST_NUMERIC_LIMITS(const unsigned long long)
     TEST_NUMERIC_LIMITS(volatile unsigned long long)
     TEST_NUMERIC_LIMITS(const volatile unsigned long long)
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     TEST_NUMERIC_LIMITS(__uint128_t)
     TEST_NUMERIC_LIMITS(const __uint128_t)
     TEST_NUMERIC_LIMITS(volatile __uint128_t)
     TEST_NUMERIC_LIMITS(const volatile __uint128_t)
 #endif
 
     // float
     TEST_NUMERIC_LIMITS(float)

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/denorm_min.pass.cpp

#endif
     test<short>(0);
     test<unsigned short>(0);
     test<int>(0);
     test<unsigned int>(0);
     test<long>(0);
     test<unsigned long>(0);
     test<long long>(0);
     test<unsigned long long>(0);
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t>(0);
     test<__uint128_t>(0);
 #endif
 #if defined(__FLT_DENORM_MIN__) // guarded because these macros are extensions.
     test<float>(__FLT_DENORM_MIN__);
     test<double>(__DBL_DENORM_MIN__);
     test<long double>(__LDBL_DENORM_MIN__);
 #endif

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/digits.pass.cpp

#endif
     test<short, 15>();
     test<unsigned short, 16>();
     test<int, 31>();
     test<unsigned int, 32>();
     test<long, sizeof(long) == 4 ? 31 : 63>();
     test<unsigned long, sizeof(long) == 4 ? 32 : 64>();
     test<long long, 63>();
     test<unsigned long long, 64>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t, 127>();
     test<__uint128_t, 128>();
 #endif
     test<float, FLT_MANT_DIG>();
     test<double, DBL_MANT_DIG>();
     test<long double, LDBL_MANT_DIG>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/digits10.pass.cpp

#endif
     test<short, 4>();
     test<unsigned short, 4>();
     test<int, 9>();
     test<unsigned int, 9>();
     test<long, sizeof(long) == 4 ? 9 : 18>();
     test<unsigned long, sizeof(long) == 4 ? 9 : 19>();
     test<long long, 18>();
     test<unsigned long long, 19>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t, 38>();
     test<__uint128_t, 38>();
 #endif
     test<float, FLT_DIG>();
     test<double, DBL_DIG>();
     test<long double, LDBL_DIG>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/epsilon.pass.cpp

#endif
     test<short>(0);
     test<unsigned short>(0);
     test<int>(0);
     test<unsigned int>(0);
     test<long>(0);
     test<unsigned long>(0);
     test<long long>(0);
     test<unsigned long long>(0);
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t>(0);
     test<__uint128_t>(0);
 #endif
     test<float>(FLT_EPSILON);
     test<double>(DBL_EPSILON);
     test<long double>(LDBL_EPSILON);
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm.pass.cpp

#endif
     test<short, std::denorm_absent>();
     test<unsigned short, std::denorm_absent>();
     test<int, std::denorm_absent>();
     test<unsigned int, std::denorm_absent>();
     test<long, std::denorm_absent>();
     test<unsigned long, std::denorm_absent>();
     test<long long, std::denorm_absent>();
     test<unsigned long long, std::denorm_absent>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t, std::denorm_absent>();
     test<__uint128_t, std::denorm_absent>();
 #endif
     test<float, std::denorm_present>();
     test<double, std::denorm_present>();
     test<long double, std::denorm_present>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm_loss.pass.cpp

#endif
     test<short, false>();
     test<unsigned short, false>();
     test<int, false>();
     test<unsigned int, false>();
     test<long, false>();
     test<unsigned long, false>();
     test<long long, false>();
     test<unsigned long long, false>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t, false>();
     test<__uint128_t, false>();
 #endif
     test<float, false>();
     test<double, false>();
     test<long double, false>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/has_infinity.pass.cpp

#endif
     test<short, false>();
     test<unsigned short, false>();
     test<int, false>();
     test<unsigned int, false>();
     test<long, false>();
     test<unsigned long, false>();
     test<long long, false>();
     test<unsigned long long, false>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t, false>();
     test<__uint128_t, false>();
 #endif
     test<float, true>();
     test<double, true>();
     test<long double, true>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/has_quiet_NaN.pass.cpp

#endif
     test<short, false>();
     test<unsigned short, false>();
     test<int, false>();
     test<unsigned int, false>();
     test<long, false>();
     test<unsigned long, false>();
     test<long long, false>();
     test<unsigned long long, false>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t, false>();
     test<__uint128_t, false>();
 #endif
     test<float, true>();
     test<double, true>();
     test<long double, true>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/has_signaling_NaN.pass.cpp

#endif
     test<short, false>();
     test<unsigned short, false>();
     test<int, false>();
     test<unsigned int, false>();
     test<long, false>();
     test<unsigned long, false>();
     test<long long, false>();
     test<unsigned long long, false>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t, false>();
     test<__uint128_t, false>();
 #endif
     test<float, true>();
     test<double, true>();
     test<long double, true>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/infinity.pass.cpp

#endif
     test<short>(0);
     test<unsigned short>(0);
     test<int>(0);
     test<unsigned int>(0);
     test<long>(0);
     test<unsigned long>(0);
     test<long long>(0);
     test<unsigned long long>(0);
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t>(0);
     test<__uint128_t>(0);
 #endif
     test<float>(1.f/zero);
     test<double>(1./zero);
     test<long double>(1./zero);
 
   return 0;
 }
 
 float zero = 0;

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/is_bounded.pass.cpp

#endif
     test<short, true>();
     test<unsigned short, true>();
     test<int, true>();
     test<unsigned int, true>();
     test<long, true>();
     test<unsigned long, true>();
     test<long long, true>();
     test<unsigned long long, true>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t, true>();
     test<__uint128_t, true>();
 #endif
     test<float, true>();
     test<double, true>();
     test<long double, true>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/is_exact.pass.cpp

#endif
     test<short, true>();
     test<unsigned short, true>();
     test<int, true>();
     test<unsigned int, true>();
     test<long, true>();
     test<unsigned long, true>();
     test<long long, true>();
     test<unsigned long long, true>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t, true>();
     test<__uint128_t, true>();
 #endif
     test<float, false>();
     test<double, false>();
     test<long double, false>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/is_iec559.pass.cpp

#endif
     test<short, false>();
     test<unsigned short, false>();
     test<int, false>();
     test<unsigned int, false>();
     test<long, false>();
     test<unsigned long, false>();
     test<long long, false>();
     test<unsigned long long, false>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t, false>();
     test<__uint128_t, false>();
 #endif
     test<float, true>();
     test<double, true>();
 #if (defined(__ppc__) || defined(__ppc64__))
     test<long double, false>();
 #else
     test<long double, true>();
 #endif
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/is_integer.pass.cpp

#endif
     test<short, true>();
     test<unsigned short, true>();
     test<int, true>();
     test<unsigned int, true>();
     test<long, true>();
     test<unsigned long, true>();
     test<long long, true>();
     test<unsigned long long, true>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t, true>();
     test<__uint128_t, true>();
 #endif
     test<float, false>();
     test<double, false>();
     test<long double, false>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/is_modulo.pass.cpp

#endif
     test<short, false>();
     test<unsigned short, true>();
     test<int, false>();
     test<unsigned int, true>();
     test<long, false>();
     test<unsigned long, true>();
     test<long long, false>();
     test<unsigned long long, true>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t, false>();
     test<__uint128_t, true>();
 #endif
     test<float, false>();
     test<double, false>();
     test<long double, false>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/is_signed.pass.cpp

#endif
     test<short, true>();
     test<unsigned short, false>();
     test<int, true>();
     test<unsigned int, false>();
     test<long, true>();
     test<unsigned long, false>();
     test<long long, true>();
     test<unsigned long long, false>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t, true>();
     test<__uint128_t, false>();
 #endif
     test<float, true>();
     test<double, true>();
     test<long double, true>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/lowest.pass.cpp

#endif
     test<short>(SHRT_MIN);
     test<unsigned short>(0);
     test<int>(INT_MIN);
     test<unsigned int>(0);
     test<long>(LONG_MIN);
     test<unsigned long>(0);
     test<long long>(LLONG_MIN);
     test<unsigned long long>(0);
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t>(-__int128_t(__uint128_t(-1)/2) - 1);
     test<__uint128_t>(0);
 #endif
     test<float>(-FLT_MAX);
     test<double>(-DBL_MAX);
     test<long double>(-LDBL_MAX);
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/max.pass.cpp

#endif
     test<short>(SHRT_MAX);
     test<unsigned short>(USHRT_MAX);
     test<int>(INT_MAX);
     test<unsigned int>(UINT_MAX);
     test<long>(LONG_MAX);
     test<unsigned long>(ULONG_MAX);
     test<long long>(LLONG_MAX);
     test<unsigned long long>(ULLONG_MAX);
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t>(__int128_t(__uint128_t(-1)/2));
     test<__uint128_t>(__uint128_t(-1));
 #endif
     test<float>(FLT_MAX);
     test<double>(DBL_MAX);
     test<long double>(LDBL_MAX);
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/max_digits10.pass.cpp

#endif
     test<short, 0>();
     test<unsigned short, 0>();
     test<int, 0>();
     test<unsigned int, 0>();
     test<long, 0>();
     test<unsigned long, 0>();
     test<long long, 0>();
     test<unsigned long long, 0>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t, 0>();
     test<__uint128_t, 0>();
 #endif
     test<float, 2+(FLT_MANT_DIG * 30103)/100000>();
     test<double, 2+(DBL_MANT_DIG * 30103)/100000>();
     test<long double, 2+(LDBL_MANT_DIG * 30103)/100000>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent.pass.cpp

#endif
     test<short, 0>();
     test<unsigned short, 0>();
     test<int, 0>();
     test<unsigned int, 0>();
     test<long, 0>();
     test<unsigned long, 0>();
     test<long long, 0>();
     test<unsigned long long, 0>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t, 0>();
     test<__uint128_t, 0>();
 #endif
     test<float, FLT_MAX_EXP>();
     test<double, DBL_MAX_EXP>();
     test<long double, LDBL_MAX_EXP>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent10.pass.cpp

#endif
     test<short, 0>();
     test<unsigned short, 0>();
     test<int, 0>();
     test<unsigned int, 0>();
     test<long, 0>();
     test<unsigned long, 0>();
     test<long long, 0>();
     test<unsigned long long, 0>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t, 0>();
     test<__uint128_t, 0>();
 #endif
     test<float, FLT_MAX_10_EXP>();
     test<double, DBL_MAX_10_EXP>();
     test<long double, LDBL_MAX_10_EXP>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/min.pass.cpp

#endif
     test<short>(SHRT_MIN);
     test<unsigned short>(0);
     test<int>(INT_MIN);
     test<unsigned int>(0);
     test<long>(LONG_MIN);
     test<unsigned long>(0);
     test<long long>(LLONG_MIN);
     test<unsigned long long>(0);
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t>(-__int128_t(__uint128_t(-1)/2) - 1);
     test<__uint128_t>(0);
 #endif
     test<float>(FLT_MIN);
     test<double>(DBL_MIN);
     test<long double>(LDBL_MIN);
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent.pass.cpp

#endif
     test<short, 0>();
     test<unsigned short, 0>();
     test<int, 0>();
     test<unsigned int, 0>();
     test<long, 0>();
     test<unsigned long, 0>();
     test<long long, 0>();
     test<unsigned long long, 0>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t, 0>();
     test<__uint128_t, 0>();
 #endif
     test<float, FLT_MIN_EXP>();
     test<double, DBL_MIN_EXP>();
     test<long double, LDBL_MIN_EXP>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent10.pass.cpp

#endif
     test<short, 0>();
     test<unsigned short, 0>();
     test<int, 0>();
     test<unsigned int, 0>();
     test<long, 0>();
     test<unsigned long, 0>();
     test<long long, 0>();
     test<unsigned long long, 0>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t, 0>();
     test<__uint128_t, 0>();
 #endif
     test<float, FLT_MIN_10_EXP>();
     test<double, DBL_MIN_10_EXP>();
     test<long double, LDBL_MIN_10_EXP>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/quiet_NaN.pass.cpp

#endif
     test<short>();
     test<unsigned short>();
     test<int>();
     test<unsigned int>();
     test<long>();
     test<unsigned long>();
     test<long long>();
     test<unsigned long long>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t>();
     test<__uint128_t>();
 #endif
     test<float>();
     test<double>();
     test<long double>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/radix.pass.cpp

#endif
     test<short, 2>();
     test<unsigned short, 2>();
     test<int, 2>();
     test<unsigned int, 2>();
     test<long, 2>();
     test<unsigned long, 2>();
     test<long long, 2>();
     test<unsigned long long, 2>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t, 2>();
     test<__uint128_t, 2>();
 #endif
     test<float, FLT_RADIX>();
     test<double, FLT_RADIX>();
     test<long double, FLT_RADIX>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/round_error.pass.cpp

#endif
     test<short>(0);
     test<unsigned short>(0);
     test<int>(0);
     test<unsigned int>(0);
     test<long>(0);
     test<unsigned long>(0);
     test<long long>(0);
     test<unsigned long long>(0);
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t>(0);
     test<__uint128_t>(0);
 #endif
     test<float>(0.5);
     test<double>(0.5);
     test<long double>(0.5);
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/round_style.pass.cpp

#endif
     test<short, std::round_toward_zero>();
     test<unsigned short, std::round_toward_zero>();
     test<int, std::round_toward_zero>();
     test<unsigned int, std::round_toward_zero>();
     test<long, std::round_toward_zero>();
     test<unsigned long, std::round_toward_zero>();
     test<long long, std::round_toward_zero>();
     test<unsigned long long, std::round_toward_zero>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t, std::round_toward_zero>();
     test<__uint128_t, std::round_toward_zero>();
 #endif
     test<float, std::round_to_nearest>();
     test<double, std::round_to_nearest>();
     test<long double, std::round_to_nearest>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/signaling_NaN.pass.cpp

#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short>();
     test<unsigned short>();
     test<int>();
     test<unsigned int>();
     test<long>();
     test<unsigned long>();
     test<long long>();
     test<unsigned long long>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t>();
     test<__uint128_t>();
 #endif
     test<float>();
     test<double>();
     test<long double>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/tinyness_before.pass.cpp

#endif
     test<short, false>();
     test<unsigned short, false>();
     test<int, false>();
     test<unsigned int, false>();
     test<long, false>();
     test<unsigned long, false>();
     test<long long, false>();
     test<unsigned long long, false>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t, false>();
     test<__uint128_t, false>();
 #endif
     test<float, false>();
     test<double, false>();
     test<long double, false>();
 
   return 0;
 }

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/traps.pass.cpp

#endif
     test<short, integral_types_trap>();
     test<unsigned short, integral_types_trap>();
     test<int, integral_types_trap>();
     test<unsigned int, integral_types_trap>();
     test<long, integral_types_trap>();
     test<unsigned long, integral_types_trap>();
     test<long long, integral_types_trap>();
     test<unsigned long long, integral_types_trap>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t, integral_types_trap>();
     test<__uint128_t, integral_types_trap>();
 #endif
     test<float, false>();
     test<double, false>();
     test<long double, false>();
 
   return 0;
 }

libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.pass.cpp

constexpr bool test()
     assert(std::bit_ceil(T(63)) == T(64));
     assert(std::bit_ceil(T(64)) == T(64));
     assert(std::bit_ceil(T(65)) == T(128));
     assert(std::bit_ceil(T(66)) == T(128));
     assert(std::bit_ceil(T(67)) == T(128));
     assert(std::bit_ceil(T(68)) == T(128));
     assert(std::bit_ceil(T(69)) == T(128));
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     if constexpr (std::is_same_v<T, __uint128_t>) {
         T val = 168;
         T ceil = 256;
 
         assert(std::bit_ceil(val) == ceil);
         assert(std::bit_ceil(val << 32) == (ceil << 32));
         assert(std::bit_ceil((val << 64) | 0x1) == (ceil << 64));
         assert(std::bit_ceil((val << 72) | 0x1) == (ceil << 72));
int main(int, char**)
     auto lambda = [](auto x) -> decltype(std::bit_ceil(x)) {};
     using L = decltype(lambda);
 
     static_assert(!std::is_invocable_v<L, signed char>);
     static_assert(!std::is_invocable_v<L, short>);
     static_assert(!std::is_invocable_v<L, int>);
     static_assert(!std::is_invocable_v<L, long>);
     static_assert(!std::is_invocable_v<L, long long>);
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     static_assert(!std::is_invocable_v<L, int8_t>);
     static_assert(!std::is_invocable_v<L, int16_t>);
     static_assert(!std::is_invocable_v<L, int32_t>);
     static_assert(!std::is_invocable_v<L, int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
#endif
     static_assert(!std::is_invocable_v<L, E2>);
     }
 
     static_assert(test<unsigned char>());
     static_assert(test<unsigned short>());
     static_assert(test<unsigned int>());
     static_assert(test<unsigned long>());
     static_assert(test<unsigned long long>());
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
     static_assert(test<uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<uint8_t>();
     test<uint16_t>();
     test<uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bit.pow.two/bit_floor.pass.cpp

constexpr bool test()
     assert(std::bit_floor(T(9)) == T(8));
     assert(std::bit_floor(T(125)) == T(64));
     assert(std::bit_floor(T(126)) == T(64));
     assert(std::bit_floor(T(127)) == T(64));
     assert(std::bit_floor(T(128)) == T(128));
     assert(std::bit_floor(T(129)) == T(128));
     assert(std::bit_floor(max) == T(max - (max >> 1)));
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     if constexpr (std::is_same_v<T, __uint128_t>) {
         T val = T(128) << 32;
         assert(std::bit_floor(val-1) == val/2);
         assert(std::bit_floor(val)   == val);
         assert(std::bit_floor(val+1) == val);
         val <<= 60;
         assert(std::bit_floor(val-1) == val/2);
         assert(std::bit_floor(val)   == val);
int main(int, char**)
     auto lambda = [](auto x) -> decltype(std::bit_floor(x)) {};
     using L = decltype(lambda);
 
     static_assert(!std::is_invocable_v<L, signed char>);
     static_assert(!std::is_invocable_v<L, short>);
     static_assert(!std::is_invocable_v<L, int>);
     static_assert(!std::is_invocable_v<L, long>);
     static_assert(!std::is_invocable_v<L, long long>);
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     static_assert(!std::is_invocable_v<L, int8_t>);
     static_assert(!std::is_invocable_v<L, int16_t>);
     static_assert(!std::is_invocable_v<L, int32_t>);
     static_assert(!std::is_invocable_v<L, int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
#endif
     static_assert(!std::is_invocable_v<L, E2>);
     }
 
     static_assert(test<unsigned char>());
     static_assert(test<unsigned short>());
     static_assert(test<unsigned int>());
     static_assert(test<unsigned long>());
     static_assert(test<unsigned long long>());
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
 
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
     static_assert(test<uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
 
     test<uint8_t>();
     test<uint16_t>();
     test<uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bit.pow.two/bit_width.pass.cpp

constexpr bool test()
     assert(std::bit_width(T(126)) == T(7));
     assert(std::bit_width(T(127)) == T(7));
     assert(std::bit_width(T(128)) == T(8));
     assert(std::bit_width(T(129)) == T(8));
     assert(std::bit_width(T(130)) == T(8));
     assert(std::bit_width(T(max - 1)) == T(std::numeric_limits<T>::digits));
     assert(std::bit_width(max) == T(std::numeric_limits<T>::digits));
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     if constexpr (std::is_same_v<T, __uint128_t>) {
         T val = 128;
         val <<= 32;
         assert(std::bit_width(val-1) == 39);
         assert(std::bit_width(val)   == 40);
         assert(std::bit_width(val+1) == 40);
         val <<= 60;
         assert(std::bit_width(val-1) == 99);
int main(int, char**)
     auto lambda = [](auto x) -> decltype(std::bit_width(x)) {};
     using L = decltype(lambda);
 
     static_assert(!std::is_invocable_v<L, signed char>);
     static_assert(!std::is_invocable_v<L, short>);
     static_assert(!std::is_invocable_v<L, int>);
     static_assert(!std::is_invocable_v<L, long>);
     static_assert(!std::is_invocable_v<L, long long>);
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     static_assert(!std::is_invocable_v<L, int8_t>);
     static_assert(!std::is_invocable_v<L, int16_t>);
     static_assert(!std::is_invocable_v<L, int32_t>);
     static_assert(!std::is_invocable_v<L, int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
#endif
     static_assert(!std::is_invocable_v<L, E2>);
     }
 
     static_assert(test<unsigned char>());
     static_assert(test<unsigned short>());
     static_assert(test<unsigned int>());
     static_assert(test<unsigned long>());
     static_assert(test<unsigned long long>());
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
     static_assert(test<uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<uint8_t>();
     test<uint16_t>();
     test<uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bit.pow.two/has_single_bit.pass.cpp

constexpr bool test()
     assert(!std::has_single_bit(T(7)));
     assert( std::has_single_bit(T(8)));
     assert(!std::has_single_bit(T(9)));
     assert(!std::has_single_bit(T(127)));
     assert( std::has_single_bit(T(128)));
     assert(!std::has_single_bit(T(129)));
     assert(!std::has_single_bit(max));
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     if constexpr (std::is_same_v<T, __uint128_t>) {
         T val = T(1) << 32;
         assert(!std::has_single_bit(val-1));
         assert( std::has_single_bit(val));
         assert(!std::has_single_bit(val+1));
         val <<= 60;
         assert(!std::has_single_bit(val-1));
         assert( std::has_single_bit(val));
int main(int, char**)
     auto lambda = [](auto x) -> decltype(std::has_single_bit(x)) {};
     using L = decltype(lambda);
 
     static_assert(!std::is_invocable_v<L, signed char>);
     static_assert(!std::is_invocable_v<L, short>);
     static_assert(!std::is_invocable_v<L, int>);
     static_assert(!std::is_invocable_v<L, long>);
     static_assert(!std::is_invocable_v<L, long long>);
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     static_assert(!std::is_invocable_v<L, int8_t>);
     static_assert(!std::is_invocable_v<L, int16_t>);
     static_assert(!std::is_invocable_v<L, int32_t>);
     static_assert(!std::is_invocable_v<L, int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
#endif
     static_assert(!std::is_invocable_v<L, E2>);
     }
 
     static_assert(test<unsigned char>());
     static_assert(test<unsigned short>());
     static_assert(test<unsigned int>());
     static_assert(test<unsigned long>());
     static_assert(test<unsigned long long>());
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
     static_assert(test<uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<uint8_t>();
     test<uint16_t>();
     test<uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bitops.count/countl_one.pass.cpp

constexpr bool test()
     assert(std::countl_one(T(max - 6)) == std::numeric_limits<T>::digits - 3);
     assert(std::countl_one(T(max - 7)) == std::numeric_limits<T>::digits - 3);
     assert(std::countl_one(T(max - 8)) == std::numeric_limits<T>::digits - 4);
     assert(std::countl_one(T(max - 9)) == std::numeric_limits<T>::digits - 4);
     assert(std::countl_one(T(max - 126)) == std::numeric_limits<T>::digits - 7);
     assert(std::countl_one(T(max - 127)) == std::numeric_limits<T>::digits - 7);
     assert(std::countl_one(T(max - 128)) == std::numeric_limits<T>::digits - 8);
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     if constexpr (std::is_same_v<T, __uint128_t>) {
         T val = 128;
         assert(std::countl_one(~val) == 120);
         val <<= 32;
         assert(std::countl_one(~val) == 88);
         val <<= 60;
         assert(std::countl_one(~val) == 28);
     }
 #endif
 
     return true;
 }
 
 int main(int, char**)
 {
     {
     auto lambda = [](auto x) -> decltype(std::countl_one(x)) {};
     using L = decltype(lambda);
 
     static_assert(!std::is_invocable_v<L, signed char>);
     static_assert(!std::is_invocable_v<L, short>);
     static_assert(!std::is_invocable_v<L, int>);
     static_assert(!std::is_invocable_v<L, long>);
     static_assert(!std::is_invocable_v<L, long long>);
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     static_assert(!std::is_invocable_v<L, int8_t>);
     static_assert(!std::is_invocable_v<L, int16_t>);
     static_assert(!std::is_invocable_v<L, int32_t>);
     static_assert(!std::is_invocable_v<L, int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
#endif
     static_assert(!std::is_invocable_v<L, E2>);
     }
 
     static_assert(test<unsigned char>());
     static_assert(test<unsigned short>());
     static_assert(test<unsigned int>());
     static_assert(test<unsigned long>());
     static_assert(test<unsigned long long>());
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
     static_assert(test<uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<uint8_t>();
     test<uint16_t>();
     test<uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }
 

libcxx/test/std/numerics/bit/bitops.count/countl_zero.pass.cpp

constexpr bool test()
     assert(std::countl_zero(T(6)) == dig - 3);
     assert(std::countl_zero(T(7)) == dig - 3);
     assert(std::countl_zero(T(8)) == dig - 4);
     assert(std::countl_zero(T(9)) == dig - 4);
     assert(std::countl_zero(T(127)) == dig - 7);
     assert(std::countl_zero(T(128)) == dig - 8);
     assert(std::countl_zero(max) == 0);
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     if constexpr (std::is_same_v<T, __uint128_t>) {
         T val = T(128) << 32;
         assert(std::countl_zero(val-1) == 89);
         assert(std::countl_zero(val)   == 88);
         assert(std::countl_zero(val+1) == 88);
         val <<= 60;
         assert(std::countl_zero(val-1) == 29);
         assert(std::countl_zero(val)   == 28);
int main(int, char**)
     auto lambda = [](auto x) -> decltype(std::countl_zero(x)) {};
     using L = decltype(lambda);
 
     static_assert(!std::is_invocable_v<L, signed char>);
     static_assert(!std::is_invocable_v<L, short>);
     static_assert(!std::is_invocable_v<L, int>);
     static_assert(!std::is_invocable_v<L, long>);
     static_assert(!std::is_invocable_v<L, long long>);
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     static_assert(!std::is_invocable_v<L, int8_t>);
     static_assert(!std::is_invocable_v<L, int16_t>);
     static_assert(!std::is_invocable_v<L, int32_t>);
     static_assert(!std::is_invocable_v<L, int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
#endif
     static_assert(!std::is_invocable_v<L, E2>);
     }
 
     static_assert(test<unsigned char>());
     static_assert(test<unsigned short>());
     static_assert(test<unsigned int>());
     static_assert(test<unsigned long>());
     static_assert(test<unsigned long long>());
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
     static_assert(test<uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<uint8_t>();
     test<uint16_t>();
     test<uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bitops.count/countr_one.pass.cpp

constexpr bool test()
     assert(std::countr_one(T(8)) == 0);
     assert(std::countr_one(T(9)) == 1);
     assert(std::countr_one(T(126)) == 0);
     assert(std::countr_one(T(127)) == 7);
     assert(std::countr_one(T(128)) == 0);
     assert(std::countr_one(T(max - 1)) == 0);
     assert(std::countr_one(max) == std::numeric_limits<T>::digits);
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     if constexpr (std::is_same_v<T, __uint128_t>) {
         T val = 128;
         assert(std::countr_one(val-1) ==  7);
         assert(std::countr_one(val)   ==  0);
         assert(std::countr_one(val+1) ==  1);
         val <<= 32;
         assert(std::countr_one(val-1) == 39);
         assert(std::countr_one(val)   ==  0);
int main(int, char**)
     auto lambda = [](auto x) -> decltype(std::countr_one(x)) {};
     using L = decltype(lambda);
 
     static_assert(!std::is_invocable_v<L, signed char>);
     static_assert(!std::is_invocable_v<L, short>);
     static_assert(!std::is_invocable_v<L, int>);
     static_assert(!std::is_invocable_v<L, long>);
     static_assert(!std::is_invocable_v<L, long long>);
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     static_assert(!std::is_invocable_v<L, int8_t>);
     static_assert(!std::is_invocable_v<L, int16_t>);
     static_assert(!std::is_invocable_v<L, int32_t>);
     static_assert(!std::is_invocable_v<L, int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
#endif
     static_assert(!std::is_invocable_v<L, E2>);
     }
 
     static_assert(test<unsigned char>());
     static_assert(test<unsigned short>());
     static_assert(test<unsigned int>());
     static_assert(test<unsigned long>());
     static_assert(test<unsigned long long>());
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
     static_assert(test<uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<uint8_t>();
     test<uint16_t>();
     test<uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bitops.count/countr_zero.pass.cpp

constexpr bool test()
     assert(std::countr_zero(T(9)) == 0);
     assert(std::countr_zero(T(126)) == 1);
     assert(std::countr_zero(T(127)) == 0);
     assert(std::countr_zero(T(128)) == 7);
     assert(std::countr_zero(T(129)) == 0);
     assert(std::countr_zero(T(130)) == 1);
     assert(std::countr_zero(max) == 0);
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     if constexpr (std::is_same_v<T, __uint128_t>) {
         T val = T(128) << 32;
         assert(std::countr_zero(val-1) ==  0);
         assert(std::countr_zero(val)   == 39);
         assert(std::countr_zero(val+1) ==  0);
         val <<= 60;
         assert(std::countr_zero(val-1) ==  0);
         assert(std::countr_zero(val)   == 99);
int main(int, char**)
     auto lambda = [](auto x) -> decltype(std::countr_zero(x)) {};
     using L = decltype(lambda);
 
     static_assert(!std::is_invocable_v<L, signed char>);
     static_assert(!std::is_invocable_v<L, short>);
     static_assert(!std::is_invocable_v<L, int>);
     static_assert(!std::is_invocable_v<L, long>);
     static_assert(!std::is_invocable_v<L, long long>);
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     static_assert(!std::is_invocable_v<L, int8_t>);
     static_assert(!std::is_invocable_v<L, int16_t>);
     static_assert(!std::is_invocable_v<L, int32_t>);
     static_assert(!std::is_invocable_v<L, int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
#endif
     static_assert(!std::is_invocable_v<L, E2>);
     }
 
     static_assert(test<unsigned char>());
     static_assert(test<unsigned short>());
     static_assert(test<unsigned int>());
     static_assert(test<unsigned long>());
     static_assert(test<unsigned long long>());
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
     static_assert(test<uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<uint8_t>();
     test<uint16_t>();
     test<uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp

constexpr bool test()
     assert(std::popcount(T(121)) == 5);
     assert(std::popcount(T(127)) == 7);
     assert(std::popcount(T(128)) == 1);
     assert(std::popcount(T(130)) == 2);
     assert(std::popcount(T(max >> 1)) == std::numeric_limits<T>::digits - 1);
     assert(std::popcount(T(max - 1)) == std::numeric_limits<T>::digits - 1);
     assert(std::popcount(max) == std::numeric_limits<T>::digits);
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     if constexpr (std::is_same_v<T, __uint128_t>) {
         T val = 128;
         assert(std::popcount(val-1) ==  7);
         assert(std::popcount(val)   ==  1);
         assert(std::popcount(val+1) ==  2);
         val <<= 32;
         assert(std::popcount(val-1) == 39);
         assert(std::popcount(val)   ==  1);
int main(int, char**)
     auto lambda = [](auto x) -> decltype(std::popcount(x)) {};
     using L = decltype(lambda);
 
     static_assert(!std::is_invocable_v<L, signed char>);
     static_assert(!std::is_invocable_v<L, short>);
     static_assert(!std::is_invocable_v<L, int>);
     static_assert(!std::is_invocable_v<L, long>);
     static_assert(!std::is_invocable_v<L, long long>);
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     static_assert(!std::is_invocable_v<L, int8_t>);
     static_assert(!std::is_invocable_v<L, int16_t>);
     static_assert(!std::is_invocable_v<L, int32_t>);
     static_assert(!std::is_invocable_v<L, int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
#endif
     static_assert(!std::is_invocable_v<L, E2>);
     }
 
     static_assert(test<unsigned char>());
     static_assert(test<unsigned short>());
     static_assert(test<unsigned int>());
     static_assert(test<unsigned long>());
     static_assert(test<unsigned long long>());
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
     static_assert(test<uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<uint8_t>();
     test<uint16_t>();
     test<uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp

constexpr bool test()
     assert(std::rotl(T(1), 1) == T(2));
     assert(std::rotl(T(1), 2) == T(4));
     assert(std::rotl(T(1), 3) == T(8));
     assert(std::rotl(T(1), 4) == T(16));
     assert(std::rotl(T(1), 5) == T(32));
     assert(std::rotl(T(1), 6) == T(64));
     assert(std::rotl(T(1), 7) == T(128));
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     if constexpr (std::is_same_v<T, __uint128_t>) {
         T val = (T(1) << 63) | (T(1) << 64);
         assert(std::rotl(val, 0) == val);
         assert(std::rotl(val, 128) == val);
         assert(std::rotl(val, 256) == val);
         assert(std::rotl(val, 1) == val << 1);
         assert(std::rotl(val, 127) == val >> 1);
         assert(std::rotl(T(3), 127) == ((T(1) << 127) | T(1)));
int main(int, char**)
     auto lambda = [](auto x) -> decltype(std::rotl(x, 1U)) {};
     using L = decltype(lambda);
 
     static_assert(!std::is_invocable_v<L, signed char>);
     static_assert(!std::is_invocable_v<L, short>);
     static_assert(!std::is_invocable_v<L, int>);
     static_assert(!std::is_invocable_v<L, long>);
     static_assert(!std::is_invocable_v<L, long long>);
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     static_assert(!std::is_invocable_v<L, int8_t>);
     static_assert(!std::is_invocable_v<L, int16_t>);
     static_assert(!std::is_invocable_v<L, int32_t>);
     static_assert(!std::is_invocable_v<L, int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
#endif
     static_assert(!std::is_invocable_v<L, E2>);
     }
 
     static_assert(test<unsigned char>());
     static_assert(test<unsigned short>());
     static_assert(test<unsigned int>());
     static_assert(test<unsigned long>());
     static_assert(test<unsigned long long>());
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
 
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
     static_assert(test<uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
 
     test<uint8_t>();
     test<uint16_t>();
     test<uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp

constexpr bool test()
     assert(std::rotr(T(128), 1) == T(64));
     assert(std::rotr(T(128), 2) == T(32));
     assert(std::rotr(T(128), 3) == T(16));
     assert(std::rotr(T(128), 4) == T(8));
     assert(std::rotr(T(128), 5) == T(4));
     assert(std::rotr(T(128), 6) == T(2));
     assert(std::rotr(T(128), 7) == T(1));
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     if constexpr (std::is_same_v<T, __uint128_t>) {
         T val = (T(1) << 63) | (T(1) << 64);
         assert(std::rotr(val, 0) == val);
         assert(std::rotr(val, 128) == val);
         assert(std::rotr(val, 256) == val);
         assert(std::rotr(val, 1) == val >> 1);
         assert(std::rotr(val, 127) == val << 1);
         assert(std::rotr(T(3), 1) == ((T(1) << 127) | T(1)));
int main(int, char**)
     auto lambda = [](auto x) -> decltype(std::rotl(x, 1U)) {};
     using L = decltype(lambda);
 
     static_assert(!std::is_invocable_v<L, signed char>);
     static_assert(!std::is_invocable_v<L, short>);
     static_assert(!std::is_invocable_v<L, int>);
     static_assert(!std::is_invocable_v<L, long>);
     static_assert(!std::is_invocable_v<L, long long>);
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
     static_assert(!std::is_invocable_v<L, int8_t>);
     static_assert(!std::is_invocable_v<L, int16_t>);
     static_assert(!std::is_invocable_v<L, int32_t>);
     static_assert(!std::is_invocable_v<L, int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
#endif
     static_assert(!std::is_invocable_v<L, E2>);
     }
 
     static_assert(test<unsigned char>());
     static_assert(test<unsigned short>());
     static_assert(test<unsigned int>());
     static_assert(test<unsigned long>());
     static_assert(test<unsigned long long>());
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
 
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
     static_assert(test<uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
 
     test<uint8_t>();
     test<uint16_t>();
     test<uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/byteswap.pass.cpp

constexpr bool test() {
   test_num<uint32_t>(0x01234567, 0x67452301);
   test_num<uint64_t>(0x0123456789ABCDEF, 0xEFCDAB8967452301);
 
   test_num<int8_t>(static_cast<int8_t>(0xAB), static_cast<int8_t>(0xAB));
   test_num<int16_t>(static_cast<int16_t>(0xCDEF), static_cast<int16_t>(0xEFCD));
   test_num<int32_t>(0x01234567, 0x67452301);
   test_num<int64_t>(0x0123456789ABCDEF, 0xEFCDAB8967452301);
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
   const auto in = static_cast<__uint128_t>(0x0123456789ABCDEF) << 64 | 0x13579BDF02468ACE;
   const auto expected = static_cast<__uint128_t>(0xCE8A4602DF9B5713) << 64 | 0xEFCDAB8967452301;
   test_num<__uint128_t>(in, expected);
   test_num<__int128_t>(in, expected);
 #endif
 
   test_num<bool>(true, true);
   test_num<bool>(false, false);

libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.pass.cpp

int main(int, char**)
     unsigned_test<unsigned long>();
     unsigned_test<unsigned long long>();
 
     unsigned_test<uint8_t>();
     unsigned_test<uint16_t>();
     unsigned_test<uint32_t>();
     unsigned_test<uint64_t>();
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     unsigned_test<__uint128_t>();
     signed_test<__int128_t>();
 #endif
 
 //     int_test<char>();
     signed_test<ptrdiff_t>();
     unsigned_test<size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp

int main(int, char**)
     // http://eel.is/c++draft/rand.req#genl-1.5
     // The effect of instantiating a template that has a parameter
     // named IntType is undefined unless the corresponding template
     // argument is cv-unqualified and is one of short, int, long,
     // long long, unsigned short, unsigned int, unsigned long,
     // or unsigned long long.
     // (We support __int128 as an extension.)
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test_statistics<__int128_t, std::minstd_rand0>();
     test_statistics<__uint128_t, std::minstd_rand0>();
 
     test_statistics<__int128_t, std::minstd_rand0>(-100, 900);
     test_statistics<__int128_t, std::minstd_rand0>(0, UINT64_MAX);
     test_statistics<__int128_t, std::minstd_rand0>(std::numeric_limits<__int128_t>::min(), std::numeric_limits<__int128_t>::max());
     test_statistics<__uint128_t, std::minstd_rand0>(0, UINT64_MAX);
 #endif
 
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/int128.pass.cpp

 
 #include <random>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**) {
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
 
   // Test that values outside of the 64-bit range can be produced.
   {
     std::minstd_rand0 e;
     std::uniform_int_distribution<__int128_t> d;
     assert(d.min() == 0 && d.max() == std::numeric_limits<__int128_t>::max());
     bool all_in_64bit_range = true;
     for (int i = 0; i < 100; ++i) {
// Regression test for PR#51520:
     std::uniform_int_distribution<__int128_t> d(INT64_MIN, INT64_MAX);
     assert(d.min() == INT64_MIN && d.max() == INT64_MAX);
     for (int i = 0; i < 100; ++i) {
       __int128_t n = d(e);
       assert((INT64_MIN <= n) && (n <= INT64_MAX));
     }
   }
 
-#endif // _LIBCPP_HAS_NO_INT128
+#endif // TEST_HAS_NO_INT128
 
   return 0;
 }

libcxx/test/std/numerics/rand/rand.req/rand.req.urng/uniform_random_bit_generator.compile.pass.cpp

 // template<class T>
 // concept uniform_random_bit_generator = // see below
 
 #include <random>
 
 static_assert(std::uniform_random_bit_generator<
               std::linear_congruential_engine<unsigned int, 0U, 1U, 2U> >);
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
 static_assert(std::uniform_random_bit_generator<
               std::subtract_with_carry_engine<__uint128_t, 1U, 2U, 3U> >);
 #endif
 
 // Not invocable
 static_assert(!std::uniform_random_bit_generator<void>);
 static_assert(!std::uniform_random_bit_generator<int>);
 static_assert(!std::uniform_random_bit_generator<int[10]>);

libcxx/test/std/utilities/format/format.formatter/format.context/format.formatter.spec/formatter.signed_integral.pass.cpp

 
 template <class CharT>
 void test_all_signed_integral_types() {
   test_signed_integral_type<signed char, CharT>();
   test_signed_integral_type<short, CharT>();
   test_signed_integral_type<int, CharT>();
   test_signed_integral_type<long, CharT>();
   test_signed_integral_type<long long, CharT>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
   test_signed_integral_type<__int128_t, CharT>();
 #endif
 }
 
 int main(int, char**) {
   test_all_signed_integral_types<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test_all_signed_integral_types<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/format/format.formatter/format.context/format.formatter.spec/formatter.unsigned_integral.pass.cpp

 
 template <class CharT>
 void test_all_unsigned_integral_types() {
   test_unsigned_integral_type<unsigned char, CharT>();
   test_unsigned_integral_type<unsigned short, CharT>();
   test_unsigned_integral_type<unsigned, CharT>();
   test_unsigned_integral_type<unsigned long, CharT>();
   test_unsigned_integral_type<unsigned long long, CharT>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
   test_unsigned_integral_type<__uint128_t, CharT>();
 #endif
 }
 
 int main(int, char**) {
   test_all_unsigned_integral_types<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test_all_unsigned_integral_types<wchar_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/format/format.formatter/format.context/types.compile.pass.cpp

constexpr void test() {
   static_assert(
       std::is_same_v<typename std::basic_format_context<
                          OutIt, CharT>::template formatter_type<long long>,
                      std::formatter<long long, CharT>>);
   static_assert(
       std::is_same_v<typename std::basic_format_context<OutIt, CharT>::
                          template formatter_type<unsigned long long>,
                      std::formatter<unsigned long long, CharT>>);
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
   static_assert(
       std::is_same_v<typename std::basic_format_context<
                          OutIt, CharT>::template formatter_type<__int128_t>,
                      std::formatter<__int128_t, CharT>>);
   static_assert(
       std::is_same_v<typename std::basic_format_context<
                          OutIt, CharT>::template formatter_type<__uint128_t>,
                      std::formatter<__uint128_t, CharT>>);

libcxx/test/std/utilities/format/format.functions/format_tests.h

 template <class CharT, class TestFunction, class ExceptionTest>
 void format_test_signed_integer(TestFunction check,
                                 ExceptionTest check_exception) {
   format_test_integer<signed char, CharT>(check, check_exception);
   format_test_integer<short, CharT>(check, check_exception);
   format_test_integer<int, CharT>(check, check_exception);
   format_test_integer<long, CharT>(check, check_exception);
   format_test_integer<long long, CharT>(check, check_exception);
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
   format_test_integer<__int128_t, CharT>(check, check_exception);
 #endif
   // *** check the minma and maxima ***
   check(STR("-0b10000000"), STR("{:#b}"), std::numeric_limits<int8_t>::min());
   check(STR("-0200"), STR("{:#o}"), std::numeric_limits<int8_t>::min());
   check(STR("-128"), STR("{:#}"), std::numeric_limits<int8_t>::min());
   check(STR("-0x80"), STR("{:#x}"), std::numeric_limits<int8_t>::min());
 

 template <class CharT, class TestFunction, class ExceptionTest>
 void format_test_unsigned_integer(TestFunction check,
                                   ExceptionTest check_exception) {
   format_test_integer<unsigned char, CharT>(check, check_exception);
   format_test_integer<unsigned short, CharT>(check, check_exception);
   format_test_integer<unsigned, CharT>(check, check_exception);
   format_test_integer<unsigned long, CharT>(check, check_exception);
   format_test_integer<unsigned long long, CharT>(check, check_exception);
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
   format_test_integer<__uint128_t, CharT>(check, check_exception);
 #endif
   // *** test the maxima ***
   check(STR("0b11111111"), STR("{:#b}"), std::numeric_limits<uint8_t>::max());
   check(STR("0377"), STR("{:#o}"), std::numeric_limits<uint8_t>::max());
   check(STR("255"), STR("{:#}"), std::numeric_limits<uint8_t>::max());
   check(STR("0xff"), STR("{:#x}"), std::numeric_limits<uint8_t>::max());
 
void format_tests(TestFunction check, ExceptionTest check_exception) {
   format_test_bool_as_integer<CharT>(check, check_exception);
 
   // *** Test signed integral format argument ***
   check(STR("hello 42"), STR("hello {}"), static_cast<signed char>(42));
   check(STR("hello 42"), STR("hello {}"), static_cast<short>(42));
   check(STR("hello 42"), STR("hello {}"), static_cast<int>(42));
   check(STR("hello 42"), STR("hello {}"), static_cast<long>(42));
   check(STR("hello 42"), STR("hello {}"), static_cast<long long>(42));
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
   check(STR("hello 42"), STR("hello {}"), static_cast<__int128_t>(42));
   {
     // Note 128-bit support is only partly implemented test the range
     // conditions here.
     std::basic_string<CharT> min =
         std::format(STR("{}"), std::numeric_limits<long long>::min());
     check(min, STR("{}"),
           static_cast<__int128_t>(std::numeric_limits<long long>::min()));
#endif
   format_test_signed_integer<CharT>(check, check_exception);
 
   // ** Test unsigned integral format argument ***
   check(STR("hello 42"), STR("hello {}"), static_cast<unsigned char>(42));
   check(STR("hello 42"), STR("hello {}"), static_cast<unsigned short>(42));
   check(STR("hello 42"), STR("hello {}"), static_cast<unsigned>(42));
   check(STR("hello 42"), STR("hello {}"), static_cast<unsigned long>(42));
   check(STR("hello 42"), STR("hello {}"), static_cast<unsigned long long>(42));
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
   check(STR("hello 42"), STR("hello {}"), static_cast<__uint128_t>(42));
   {
     // Note 128-bit support is only partly implemented test the range
     // conditions here.
     std::basic_string<CharT> max =
         std::format(STR("{}"), std::numeric_limits<unsigned long long>::max());
     check(max, STR("{}"),
           static_cast<__uint128_t>(

libcxx/test/std/utilities/function.objects/unord.hash/integral.pass.cpp

//  LWG #2119
     test<uint_least8_t>();
     test<uint_least16_t>();
     test<uint_least32_t>();
     test<uint_least64_t>();
 
     test<uintmax_t>();
     test<uintptr_t>();
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test<__int128_t>();
     test<__uint128_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/meta/meta.trans/meta.trans.sign/make_signed.pass.cpp

 #else
 enum BigEnum
 #endif
 {
     bigzero,
     big = 0xFFFFFFFFFFFFFFFFULL
 };
 
-#if !defined(_LIBCPP_HAS_NO_INT128) && !defined(_LIBCPP_HAS_NO_STRONG_ENUMS)
+#if !defined(TEST_HAS_NO_INT128) && !defined(_LIBCPP_HAS_NO_STRONG_ENUMS)
 enum HugeEnum : __uint128_t
 {
     hugezero
 };
 #endif
 
 template <class T, class U>
 void test_make_signed()
int main(int, char**)
     test_make_signed< long, signed long >();
     test_make_signed< unsigned long, long >();
     test_make_signed< long long, signed long long >();
     test_make_signed< unsigned long long, signed long long >();
     test_make_signed< wchar_t, std::conditional<sizeof(wchar_t) == 4, int, short>::type >();
     test_make_signed< const wchar_t, std::conditional<sizeof(wchar_t) == 4, const int, const short>::type >();
     test_make_signed< const Enum, std::conditional<sizeof(Enum) == sizeof(int), const int, const signed char>::type >();
     test_make_signed< BigEnum, std::conditional<sizeof(long) == 4, long long, long>::type >();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test_make_signed< __int128_t, __int128_t >();
     test_make_signed< __uint128_t, __int128_t >();
 # ifndef _LIBCPP_HAS_NO_STRONG_ENUMS
     test_make_signed< HugeEnum, __int128_t >();
 # endif
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/meta/meta.trans/meta.trans.sign/make_unsigned.pass.cpp

 #else
 enum BigEnum
 #endif
 {
     bigzero,
     big = 0xFFFFFFFFFFFFFFFFULL
 };
 
-#if !defined(_LIBCPP_HAS_NO_INT128) && !defined(_LIBCPP_HAS_NO_STRONG_ENUMS)
+#if !defined(TEST_HAS_NO_INT128) && !defined(_LIBCPP_HAS_NO_STRONG_ENUMS)
 enum HugeEnum : __int128_t
 {
     hugezero
 };
 #endif
 
 template <class T, class U>
 void test_make_unsigned()
int main(int, char**)
     test_make_unsigned<unsigned long, unsigned long> ();
     test_make_unsigned<long long, unsigned long long> ();
     test_make_unsigned<unsigned long long, unsigned long long> ();
     test_make_unsigned<wchar_t, std::conditional<sizeof(wchar_t) == 4, unsigned int, unsigned short>::type> ();
     test_make_unsigned<const wchar_t, std::conditional<sizeof(wchar_t) == 4, const unsigned int, const unsigned short>::type> ();
     test_make_unsigned<const Enum, std::conditional<sizeof(Enum) == sizeof(int), const unsigned int, const unsigned char>::type >();
     test_make_unsigned<BigEnum,
                    std::conditional<sizeof(long) == 4, unsigned long long, unsigned long>::type> ();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test_make_unsigned<__int128_t, __uint128_t>();
     test_make_unsigned<__uint128_t, __uint128_t>();
 # ifndef _LIBCPP_HAS_NO_STRONG_ENUMS
     test_make_unsigned<HugeEnum, __uint128_t>();
 # endif
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/meta/meta.unary/meta.unary.cat/integral.pass.cpp

int main(int, char**)
     test_integral<short>();
     test_integral<unsigned short>();
     test_integral<int>();
     test_integral<unsigned int>();
     test_integral<long>();
     test_integral<unsigned long>();
     test_integral<long long>();
     test_integral<unsigned long long>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test_integral<__int128_t>();
     test_integral<__uint128_t>();
 #endif
 
 //  LWG#2582
     static_assert(!std::is_integral<incomplete_type>::value, "");
 
   return 0;
 }

libcxx/test/std/utilities/meta/meta.unary/meta.unary.comp/integral.pass.cpp

int main(int, char**)
     test_integral<short>();
     test_integral<unsigned short>();
     test_integral<int>();
     test_integral<unsigned int>();
     test_integral<long>();
     test_integral<unsigned long>();
     test_integral<long long>();
     test_integral<unsigned long long>();
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test_integral<__int128_t>();
     test_integral<__uint128_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_signed.pass.cpp

int main(int, char**)
   test_is_not_signed<unsigned char>();
   test_is_not_signed<unsigned short>();
   test_is_not_signed<unsigned int>();
   test_is_not_signed<unsigned long>();
 
   test_is_not_signed<bool>();
   test_is_not_signed<unsigned>();
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test_is_signed<__int128_t>();
     test_is_not_signed<__uint128_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_unsigned.pass.cpp

int main(int, char**)
   test_is_unsigned<unsigned char>();
   test_is_unsigned<unsigned short>();
   test_is_unsigned<unsigned int>();
   test_is_unsigned<unsigned long>();
 
   test_is_unsigned<bool>();
   test_is_unsigned<unsigned>();
 
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
     test_is_unsigned<__uint128_t>();
     test_is_not_unsigned<__int128_t>();
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_equal/cmp_equal.pass.cpp

 
 template <class... Ts, class UTuple>
 constexpr void test2(const std::tuple<Ts...>&, const UTuple& utuple) {
   (test2_impl<Ts>(utuple) , ...);
 }
 
 constexpr bool test() {
   std::tuple<
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
       __int128_t, __uint128_t,
 #endif
       unsigned long long, long long, unsigned long, long, unsigned int, int,
       unsigned short, short, unsigned char, signed char> types;
   test1(types);
   test2(types, types);
   return true;
 }
 
 int main(int, char**) {
   ASSERT_NOEXCEPT(std::cmp_equal(0, 0));
   test();
   static_assert(test());
   return 0;
 }

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_greater/cmp_greater.pass.cpp

 
 template <class... Ts, class UTuple>
 constexpr void test2(const std::tuple<Ts...>&, const UTuple& utuple) {
   (test2_impl<Ts>(utuple) , ...);
 }
 
 constexpr bool test() {
   std::tuple<
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
       __int128_t, __uint128_t,
 #endif
       unsigned long long, long long, unsigned long, long, unsigned int, int,
       unsigned short, short, unsigned char, signed char> types;
   test1(types);
   test2(types, types);
   return true;
 }
 
 int main(int, char**) {
   ASSERT_NOEXCEPT(std::cmp_greater(1, 0));
   test();
   static_assert(test());
   return 0;
 }

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_greater_equal/cmp_greater_equal.pass.cpp

 
 template <class... Ts, class UTuple>
 constexpr void test2(const std::tuple<Ts...>&, const UTuple& utuple) {
   (test2_impl<Ts>(utuple) , ...);
 }
 
 constexpr bool test() {
   std::tuple<
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
       __int128_t, __uint128_t,
 #endif
       unsigned long long, long long, unsigned long, long, unsigned int, int,
       unsigned short, short, unsigned char, signed char> types;
   test1(types);
   test2(types, types);
   return true;
 }
 
 int main(int, char**) {
   ASSERT_NOEXCEPT(std::cmp_greater_equal(1, 0));
   test();
   static_assert(test());
   return 0;
 }

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_less/cmp_less.pass.cpp

 
 template <class... Ts, class UTuple>
 constexpr void test2(const std::tuple<Ts...>&, const UTuple& utuple) {
   (test2_impl<Ts>(utuple) , ...);
 }
 
 constexpr bool test() {
   std::tuple<
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
       __int128_t, __uint128_t,
 #endif
       unsigned long long, long long, unsigned long, long, unsigned int, int,
       unsigned short, short, unsigned char, signed char> types;
   test1(types);
   test2(types, types);
   return true;
 }
 
 int main(int, char**) {
   ASSERT_NOEXCEPT(std::cmp_less(0, 1));
   test();
   static_assert(test());
   return 0;
 }

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_less_equal/cmp_less_equal.pass.cpp

 
 template <class... Ts, class UTuple>
 constexpr void test2(const std::tuple<Ts...>&, const UTuple& utuple) {
   (test2_impl<Ts>(utuple) , ...);
 }
 
 constexpr bool test() {
   std::tuple<
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
       __int128_t, __uint128_t,
 #endif
       unsigned long long, long long, unsigned long, long, unsigned int, int,
       unsigned short, short, unsigned char, signed char> types;
   test1(types);
   test2(types, types);
   return true;
 }
 
 int main(int, char**) {
   ASSERT_NOEXCEPT(std::cmp_less_equal(0, 1));
   test();
   static_assert(test());
   return 0;
 }

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_not_equal/cmp_not_equal.pass.cpp

 
 template <class... Ts, class UTuple>
 constexpr void test2(const std::tuple<Ts...>&, const UTuple& utuple) {
   (test2_impl<Ts>(utuple) , ...);
 }
 
 constexpr bool test() {
   std::tuple<
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
       __int128_t, __uint128_t,
 #endif
       unsigned long long, long long, unsigned long, long, unsigned int, int,
       unsigned short, short, unsigned char, signed char> types;
   test1(types);
   test2(types, types);
   return true;
 }
 
 int main(int, char**) {
   ASSERT_NOEXCEPT(std::cmp_not_equal(0, 0));
   test();
   static_assert(test());
   return 0;
 }

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp

 
 template <class... Ts>
 constexpr void test1(const std::tuple<Ts...>&) {
   (test_in_range1<Ts>() , ...);
 }
 
 constexpr bool test() {
   std::tuple<
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
       __int128_t, __uint128_t,
 #endif
       unsigned long long, long long, unsigned long, long, unsigned int, int,
       unsigned short, short, unsigned char, signed char> types;
   test1(types);
   test_in_range();
   return true;
 }
 
 int main(int, char**) {
   ASSERT_NOEXCEPT(std::in_range<int>(-1));
   test();
   static_assert(test());
   return 0;
 }

libcxx/test/support/msvc_stdlib_force_include.h

#if !defined(__clang__)
     // Silence compiler warnings.
     #pragma warning(disable: 4180) // qualifier applied to function type has no meaning; ignored
     #pragma warning(disable: 4324) // structure was padded due to alignment specifier
     #pragma warning(disable: 4521) // multiple copy constructors specified
     #pragma warning(disable: 4702) // unreachable code
     #pragma warning(disable: 28251) // Inconsistent annotation for 'new': this instance has no annotations.
 #endif // !defined(__clang__)
 
-// MSVC doesn't have __int128_t.
-#define _LIBCPP_HAS_NO_INT128
-
 #ifndef _LIBCXX_IN_DEVCRT
     // atomic_is_lock_free.pass.cpp needs this VS 2015 Update 2 fix.
     #define _ENABLE_ATOMIC_ALIGNMENT_FIX
 
     // Restore features that are removed in C++20.
     #define _HAS_FEATURES_REMOVED_IN_CXX20 1
 
     // Silence warnings about features that are deprecated in C++17 and C++20.

libcxx/test/support/poisoned_hash_helper.h

#endif
       short,
       unsigned short,
       int,
       unsigned int,
       long,
       unsigned long,
       long long,
       unsigned long long,
-#ifndef _LIBCPP_HAS_NO_INT128
+#ifndef TEST_HAS_NO_INT128
       __int128_t,
       __uint128_t,
 #endif
       float,
       double,
       long double,
 #if TEST_STD_VER >= 14
       // Enum types

libcxx/test/support/test_macros.h

 #endif
 
 #if defined(_LIBCPP_HAS_NO_UNICODE)
 #   define TEST_HAS_NO_UNICODE
 #elif defined(_MSVC_EXECUTION_CHARACTER_SET) && _MSVC_EXECUTION_CHARACTER_SET != 65001
 #   define TEST_HAS_NO_UNICODE
 #endif
 
+#if defined(_LIBCPP_HAS_NO_INT128) || defined(TEST_COMPILER_MSVC)
+#   define TEST_HAS_NO_INT128
+#endif
+
 #if defined(__GNUC__)
 #pragma GCC diagnostic pop
 #endif
 
 #endif // SUPPORT_TEST_MACROS_HPP