[libc++] Remove macros for IBM compiler

[ldionne]

Summary

It's not tested or used anymore -- instead a Clang-based compiler is
used on IBM nowadays.

[Mordante]

Nice cleanup LGTM! I think it would be good to add some of the IBM people as reviewer too.

libcxx/include/__config

520

Can _LIBCPP_HAS_NO_UNICODE_CHARS be set in CMake by users? If not this seems to be the only place where _LIBCPP_HAS_NO_UNICODE_CHARS is defined.

In that case do you want to make a followup patch to remove this, or do you want me to do it?

[ldionne]

In D127650#3578528, @Mordante wrote:

Nice cleanup LGTM! I think it would be good to add some of the IBM people as reviewer too.

We discussed this with @SeanP, but adding others as well.

libcxx/include/__config

520

Oh, wow, that's freakin' great. I've been meaning to clean this up for a very long time, but I didn't know how to. I'll actually fold the removal into this patch since it's directly tied to _LIBCPP_COMPILER_IBM.

[hubert.reinterpretcast]

In D127650#3579911, @ldionne wrote:

We discussed this with @SeanP, but adding others as well.

I am on board for this.

[ldionne]

Remove _LIBCPP_HAS_NO_UNICODE_CHARS

[daltenty]

LGTM, as noted the the configuration for the IBM XL compiler is unused, modern Open XL goes down the clang paths.

[SeanP]

These look good to me. I do see the the AIX CI build is broken. This is due to -X32_64 being passed to llvm-ar. That appears independent of this change. @daltenty will need to take a look at that.

[ldionne]

Thanks for double-checking folks!

[Mordante]

In D127650#3579921, @ldionne wrote:

Remove _LIBCPP_HAS_NO_UNICODE_CHARS

Great, thanks a lot!

libcxx/include/__config

 #    define _LIBCPP_APPLE_CLANG_VER (__apple_build_version__ / 10000)
 #  elif defined(__clang__)
 #    define _LIBCPP_COMPILER_CLANG_BASED
 #    define _LIBCPP_CLANG_VER (__clang_major__ * 100 + __clang_minor__)
 #  elif defined(__GNUC__)
 #    define _LIBCPP_COMPILER_GCC
 #  elif defined(_MSC_VER)
 #    define _LIBCPP_COMPILER_MSVC
-#  elif defined(__IBMCPP__)
-#    define _LIBCPP_COMPILER_IBM
 #  endif
 
 #  if defined(_LIBCPP_COMPILER_GCC) && __cplusplus < 201103L
 #    error "libc++ does not support using GCC with C++03. Please enable C++11"
 #  endif
 
 // FIXME: ABI detection should be done via compiler builtin macros. This
 // is just a placeholder until Clang implements such macros. For now assume

 #    define _LIBCPP_HAS_NO_ASAN
 
 #    define _LIBCPP_ALWAYS_INLINE __forceinline
 
 #    define _LIBCPP_HAS_NO_VECTOR_EXTENSION
 
 #    define _LIBCPP_DISABLE_EXTENSION_WARNING
 
-#  elif defined(_LIBCPP_COMPILER_IBM)
-
-#    define _ALIGNAS(x) __attribute__((__aligned__(x)))
-#    define _ALIGNAS_TYPE(x) __attribute__((__aligned__(_LIBCPP_ALIGNOF(x))))
-#    define _ATTRIBUTE(x) __attribute__((x))
-#    define _LIBCPP_NORETURN __attribute__((noreturn))
-
-#    define _LIBCPP_HAS_NO_UNICODE_CHARS
-
-#    if defined(_AIX)
-#      define __MULTILOCALE_API
-#    endif
-
-#    define _LIBCPP_HAS_NO_ASAN
-
-#    define _LIBCPP_ALWAYS_INLINE __attribute__((__always_inline__))
-
-#    define _LIBCPP_HAS_NO_VECTOR_EXTENSION
-
-#    define _LIBCPP_DISABLE_EXTENSION_WARNING
-
-#  endif // _LIBCPP_COMPILER_[CLANG|GCC|MSVC|IBM]
+#  endif // _LIBCPP_COMPILER_[CLANG|GCC|MSVC]
 
 #  if defined(_LIBCPP_OBJECT_FORMAT_COFF)
 
 #    ifdef _DLL
 #      define _LIBCPP_CRT_FUNC __declspec(dllimport)
 #    else
 #      define _LIBCPP_CRT_FUNC
 #    endif

 #  ifndef _LIBCPP_HAS_NO_NOEXCEPT
 #    define _NOEXCEPT noexcept
 #    define _NOEXCEPT_(x) noexcept(x)
 #  else
 #    define _NOEXCEPT throw()
 #    define _NOEXCEPT_(x)
 #  endif
 
-#  ifdef _LIBCPP_HAS_NO_UNICODE_CHARS
-    typedef unsigned short char16_t;
-typedef unsigned int char32_t;
-#  endif
-
 #  ifndef __SIZEOF_INT128__
 #    define _LIBCPP_HAS_NO_INT128
 #  endif
 
 #  ifdef _LIBCPP_CXX03_LANG
 #    define static_assert(...) _Static_assert(__VA_ARGS__)
 #    define decltype(...) __decltype(__VA_ARGS__)
 #  endif // _LIBCPP_CXX03_LANG

libcxx/include/__functional/hash.h

#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
     _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t result_type;
     _LIBCPP_DEPRECATED_IN_CXX17 typedef char8_t argument_type;
 #endif
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(char8_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
 };
 #endif // !_LIBCPP_HAS_NO_CHAR8_T
 
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 struct _LIBCPP_TEMPLATE_VIS hash<char16_t>
 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES)
     : public unary_function<char16_t, size_t>
 #endif
 {
 _LIBCPP_SUPPRESS_DEPRECATED_POP

 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
     _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t result_type;
     _LIBCPP_DEPRECATED_IN_CXX17 typedef char32_t argument_type;
 #endif
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(char32_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
 };
 
-#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
-
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 struct _LIBCPP_TEMPLATE_VIS hash<wchar_t>
 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES)
     : public unary_function<wchar_t, size_t>
 #endif
 {

libcxx/include/__string/char_traits.h

for (; __n; --__n)
             return __s;
         ++__s;
     }
     return nullptr;
 }
 
 #endif // _LIBCPP_HAS_NO_CHAR8_T
 
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-
 template <>
 struct _LIBCPP_TEMPLATE_VIS char_traits<char16_t>
 {
     typedef char16_t       char_type;
     typedef uint_least16_t int_type;
     typedef streamoff      off_type;
     typedef u16streampos   pos_type;
     typedef mbstate_t      state_type;
char_traits<char32_t>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT
     {
         if (eq(*__s, __a))
             return __s;
         ++__s;
     }
     return nullptr;
 }
 
-#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
-
 // helper fns for basic_string and string_view
 
 // __str_find
 template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
 inline _SizeT _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 __str_find(const _CharT *__p, _SizeT __sz,
              _CharT __c, _SizeT __pos) _NOEXCEPT
 {

libcxx/include/__type_traits/is_integral.h

 template <>          struct __libcpp_is_integral<signed char>        { enum { value = 1 }; };
 template <>          struct __libcpp_is_integral<unsigned char>      { enum { value = 1 }; };
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <>          struct __libcpp_is_integral<wchar_t>            { enum { value = 1 }; };
 #endif
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
 template <>          struct __libcpp_is_integral<char8_t>            { enum { value = 1 }; };
 #endif
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 template <>          struct __libcpp_is_integral<char16_t>           { enum { value = 1 }; };
 template <>          struct __libcpp_is_integral<char32_t>           { enum { value = 1 }; };
-#endif
 template <>          struct __libcpp_is_integral<short>              { enum { value = 1 }; };
 template <>          struct __libcpp_is_integral<unsigned short>     { enum { value = 1 }; };
 template <>          struct __libcpp_is_integral<int>                { enum { value = 1 }; };
 template <>          struct __libcpp_is_integral<unsigned int>       { enum { value = 1 }; };
 template <>          struct __libcpp_is_integral<long>               { enum { value = 1 }; };
 template <>          struct __libcpp_is_integral<unsigned long>      { enum { value = 1 }; };
 template <>          struct __libcpp_is_integral<long long>          { enum { value = 1 }; };
 template <>          struct __libcpp_is_integral<unsigned long long> { enum { value = 1 }; };

libcxx/include/__utility/cmp.h

 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17
 template<class _Tp, class... _Up>
 struct _IsSameAsAny : _Or<_IsSame<_Tp, _Up>...> {};
 
 template<class _Tp>
 concept __is_safe_integral_cmp = is_integral_v<_Tp> &&
-                      !_IsSameAsAny<_Tp, bool, char
+                      !_IsSameAsAny<_Tp, bool, char, char16_t, char32_t
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
                                     , char8_t
 #endif
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-                                    , char16_t, char32_t
-#endif
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
                                     , wchar_t
 #endif
                                     >::value;
 
 template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
 _LIBCPP_INLINE_VISIBILITY constexpr
 bool cmp_equal(_Tp __t, _Up __u) noexcept

libcxx/include/iosfwd

template <class _CharT, class _Traits>
     class _LIBCPP_PREFERRED_NAME(fstream) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wfstream)) basic_fstream;
 
 template <class _State>             class _LIBCPP_TEMPLATE_VIS fpos;
 typedef fpos<mbstate_t>    streampos;
 typedef fpos<mbstate_t>    wstreampos;
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
 typedef fpos<mbstate_t>    u8streampos;
 #endif
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 typedef fpos<mbstate_t>    u16streampos;
 typedef fpos<mbstate_t>    u32streampos;
-#endif
 
 #if defined(_NEWLIB_VERSION)
 // On newlib, off_t is 'long int'
 typedef long int streamoff;         // for char_traits in <string>
 #else
 typedef long long streamoff;        // for char_traits in <string>
 #endif
 

libcxx/include/string

 #include <__string/char_traits.h>
 #include <__string/extern_template_lists.h>
 #include <__utility/auto_cast.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__utility/unreachable.h>
 #include <climits>
 #include <compare>
+#include <cstdint>
 #include <cstdio>  // EOF
 #include <cstdlib>
 #include <cstring>
 #include <initializer_list>
 #include <iosfwd>
 #include <iterator> // TODO: Remove this include
 #include <limits>
 #include <memory>
 #include <stdexcept>
 #include <string_view>
 #include <type_traits>
 #include <version>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #  include <cwchar>
 #endif
 
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-#  include <cstdint>
-#endif
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 

 struct __can_be_converted_to_string_view : public _BoolConstant<
       is_convertible<const _Tp&, basic_string_view<_CharT, _Traits> >::value &&
      !is_convertible<const _Tp&, const _CharT*>::value
     > {};
 
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
 typedef basic_string<char8_t> u8string;
 #endif
-
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 typedef basic_string<char16_t> u16string;
 typedef basic_string<char32_t> u32string;
-#endif
 
 struct __uninitialized_size_tag {};
 
 template<class _CharT, class _Traits, class _Allocator>
 class
     _LIBCPP_TEMPLATE_VIS
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
     _LIBCPP_PREFERRED_NAME(u8string)
 #endif
-#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     _LIBCPP_PREFERRED_NAME(u16string)
     _LIBCPP_PREFERRED_NAME(u32string)
-#endif
     basic_string
 {
 public:
     typedef basic_string                                 __self;
     typedef basic_string_view<_CharT, _Traits>           __self_view;
     typedef _Traits                                      traits_type;
     typedef _CharT                                       value_type;
     typedef _Allocator                                   allocator_type;

libcxx/test/libcxx/strings/basic.string/string.capacity/max_size.pass.cpp

#ifndef TEST_HAS_NO_CHAR8_T
   assert(u8str.max_size() == std::numeric_limits<size_t>::max() - alignment);
 #endif
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   std::wstring wstr;
   assert(wstr.max_size() == std::numeric_limits<size_t>::max() / sizeof(wchar_t) - alignment);
 #endif
 
-#ifndef TEST_HAS_NO_UNICODE_CHARS
   std::u16string u16str;
   std::u32string u32str;
   assert(u16str.max_size() == std::numeric_limits<size_t>::max() / 2 - alignment);
   assert(u32str.max_size() == std::numeric_limits<size_t>::max() / 4 - alignment);
-#endif
 }
 
 void half_size() {
   std::string str;
   assert(str.max_size() == std::numeric_limits<size_t>::max() / 2 - alignment);
 
 #ifndef TEST_HAS_NO_CHAR8_T
   std::u8string u8str;
   assert(u8str.max_size() == std::numeric_limits<size_t>::max() / 2 - alignment);
 #endif
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   std::wstring wstr;
   assert(wstr.max_size() == std::numeric_limits<size_t>::max() / std::max<size_t>(2ul, sizeof(wchar_t)) - alignment);
 #endif
 
-#ifndef TEST_HAS_NO_UNICODE_CHARS
   std::u16string u16str;
   std::u32string u32str;
   assert(u16str.max_size() == std::numeric_limits<size_t>::max() / 2 - alignment);
   assert(u32str.max_size() == std::numeric_limits<size_t>::max() / 4 - alignment);
-#endif
 }
 
 bool test() {
 
 #if _LIBCPP_ABI_VERSION == 1
 
 # if defined(__x86_64__)
   full_size();

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_string.pass.cpp

 constexpr bool test() {
   test<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
   test<char8_t>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
   test<char16_t>();
   test<char32_t>();
-#endif
 
   return true;
 }
 
 int main(int, char**) {
 #ifndef _WIN32
   // Make sure the parsers match the expectations. The layout of the
   // subobjects is chosen to minimize the size required.

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_string_non_unicode.pass.cpp

 constexpr bool test() {
   test<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
   test<char8_t>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
   test<char16_t>();
   test<char32_t>();
-#endif
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/libcxx/utilities/format/format.string/format.string.std/std_format_spec_string_unicode.pass.cpp

 constexpr bool test() {
   test<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
   test<char8_t>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
   test<char16_t>();
   test<char32_t>();
-#endif
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.generic/integral.pass.cpp

int main(int, char**)
     test<std::atomic_uint, unsigned int>();
     test<std::atomic_long, long>();
     test<std::atomic_ulong, unsigned long>();
     test<std::atomic_llong, long long>();
     test<std::atomic_ullong, unsigned long long>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<std::atomic_char8_t, char8_t>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<std::atomic_char16_t, char16_t>();
     test<std::atomic_char32_t, char32_t>();
-#endif
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test<std::atomic_wchar_t, wchar_t>();
 #endif
 
     test<std::atomic_int8_t,    int8_t>();
     test<std::atomic_uint8_t,  uint8_t>();
     test<std::atomic_int16_t,   int16_t>();
     test<std::atomic_uint16_t, uint16_t>();
     test<std::atomic_int32_t,   int32_t>();
     test<std::atomic_uint32_t, uint32_t>();
     test<std::atomic_int64_t,   int64_t>();
     test<std::atomic_uint64_t, uint64_t>();
 
     test<volatile std::atomic_char, char>();
     test<volatile std::atomic_schar, signed char>();
     test<volatile std::atomic_uchar, unsigned char>();
     test<volatile std::atomic_short, short>();
     test<volatile std::atomic_ushort, unsigned short>();
     test<volatile std::atomic_int, int>();
     test<volatile std::atomic_uint, unsigned int>();
     test<volatile std::atomic_long, long>();
     test<volatile std::atomic_ulong, unsigned long>();
     test<volatile std::atomic_llong, long long>();
     test<volatile std::atomic_ullong, unsigned long long>();
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<volatile std::atomic_char16_t, char16_t>();
     test<volatile std::atomic_char32_t, char32_t>();
-#endif
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test<volatile std::atomic_wchar_t, wchar_t>();
 #endif
 
     test<volatile std::atomic_int8_t,    int8_t>();
     test<volatile std::atomic_uint8_t,  uint8_t>();
     test<volatile std::atomic_int16_t,   int16_t>();
     test<volatile std::atomic_uint16_t, uint16_t>();
     test<volatile std::atomic_int32_t,   int32_t>();
     test<volatile std::atomic_uint32_t, uint32_t>();
     test<volatile std::atomic_int64_t,   int64_t>();
     test<volatile std::atomic_uint64_t, uint64_t>();
 
   return 0;
 }

libcxx/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp

int main(int, char**)
     static_assert((std::is_same<std::atomic<long long>, std::atomic_llong>::value), "");
     static_assert((std::is_same<std::atomic<unsigned long long>, std::atomic_ullong>::value), "");
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     static_assert((std::is_same<std::atomic<wchar_t>, std::atomic_wchar_t>::value), "");
 #endif
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     static_assert((std::is_same<std::atomic<char8_t>, std::atomic_char8_t>::value), "");
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     static_assert((std::is_same<std::atomic<char16_t>, std::atomic_char16_t>::value), "");
     static_assert((std::is_same<std::atomic<char32_t>, std::atomic_char32_t>::value), "");
-#endif
 
 //  Added by LWG 2441
     static_assert((std::is_same<std::atomic<intptr_t>,  std::atomic_intptr_t>::value), "");
     static_assert((std::is_same<std::atomic<uintptr_t>, std::atomic_uintptr_t>::value), "");
 
     static_assert((std::is_same<std::atomic<int8_t>,    std::atomic_int8_t>::value), "");
     static_assert((std::is_same<std::atomic<uint8_t>,   std::atomic_uint8_t>::value), "");
     static_assert((std::is_same<std::atomic<int16_t>,   std::atomic_int16_t>::value), "");
     static_assert((std::is_same<std::atomic<uint16_t>,  std::atomic_uint16_t>::value), "");
     static_assert((std::is_same<std::atomic<int32_t>,   std::atomic_int32_t>::value), "");
     static_assert((std::is_same<std::atomic<uint32_t>,  std::atomic_uint32_t>::value), "");
     static_assert((std::is_same<std::atomic<int64_t>,   std::atomic_int64_t>::value), "");
     static_assert((std::is_same<std::atomic<uint64_t>,  std::atomic_uint64_t>::value), "");
 
   return 0;
 }

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

 static_assert(std::three_way_comparable<char*>);
 static_assert(std::three_way_comparable<char const*>);
 static_assert(std::three_way_comparable<char volatile*>);
 static_assert(std::three_way_comparable<char const volatile*>);
 static_assert(std::three_way_comparable<wchar_t&>);
 #ifndef TEST_HAS_NO_CHAR8_T
 static_assert(std::three_way_comparable<char8_t const&>);
 #endif
-#ifndef TEST_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 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

 int main(int, char**)
 {
     test<bool>();
     test<char>();
     test<wchar_t>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t>();
     test<char32_t>();
-#endif
     test<signed char>();
     test<unsigned char>();
     test<signed short>();
     test<unsigned short>();
     test<signed int>();
     test<unsigned int>();
     test<signed long>();
     test<unsigned long>();

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

int main(int, char**)
     test<bool>(false);
     test<char>(0);
     test<signed char>(0);
     test<unsigned char>(0);
     test<wchar_t>(0);
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t>(0);
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t>(0);
     test<char32_t>(0);
-#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);

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

int main(int, char**)
     test<bool, 1>();
     test<char, std::numeric_limits<char>::is_signed ? 7 : 8>();
     test<signed char, 7>();
     test<unsigned char, 8>();
     test<wchar_t, std::numeric_limits<wchar_t>::is_signed ? sizeof(wchar_t)*8-1 : sizeof(wchar_t)*8>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, 8>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t, 16>();
     test<char32_t, 32>();
-#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>();

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

int main(int, char**)
     test<bool, 0>();
     test<char, 2>();
     test<signed char, 2>();
     test<unsigned char, 2>();
     test<wchar_t, 5*sizeof(wchar_t)/2-1>();  // 4 -> 9 and 2 -> 4
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, 2>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t, 4>();
     test<char32_t, 9>();
-#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>();

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

int main(int, char**)
     test<bool>(false);
     test<char>(0);
     test<signed char>(0);
     test<unsigned char>(0);
     test<wchar_t>(0);
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t>(0);
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t>(0);
     test<char32_t>(0);
-#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);

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

int main(int, char**)
     test<bool, std::denorm_absent>();
     test<char, std::denorm_absent>();
     test<signed char, std::denorm_absent>();
     test<unsigned char, std::denorm_absent>();
     test<wchar_t, std::denorm_absent>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, std::denorm_absent>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t, std::denorm_absent>();
     test<char32_t, std::denorm_absent>();
-#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>();

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

int main(int, char**)
     test<bool, false>();
     test<char, false>();
     test<signed char, false>();
     test<unsigned char, false>();
     test<wchar_t, false>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, false>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t, false>();
     test<char32_t, false>();
-#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>();

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

int main(int, char**)
     test<bool, false>();
     test<char, false>();
     test<signed char, false>();
     test<unsigned char, false>();
     test<wchar_t, false>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, false>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t, false>();
     test<char32_t, false>();
-#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>();

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

int main(int, char**)
     test<bool, false>();
     test<char, false>();
     test<signed char, false>();
     test<unsigned char, false>();
     test<wchar_t, false>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, false>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t, false>();
     test<char32_t, false>();
-#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>();

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

int main(int, char**)
     test<bool, false>();
     test<char, false>();
     test<signed char, false>();
     test<unsigned char, false>();
     test<wchar_t, false>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, false>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t, false>();
     test<char32_t, false>();
-#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>();

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

int main(int, char**)
     test<bool>(false);
     test<char>(0);
     test<signed char>(0);
     test<unsigned char>(0);
     test<wchar_t>(0);
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t>(0);
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t>(0);
     test<char32_t>(0);
-#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);

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

int main(int, char**)
     test<bool, true>();
     test<char, true>();
     test<signed char, true>();
     test<unsigned char, true>();
     test<wchar_t, true>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, true>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t, true>();
     test<char32_t, true>();
-#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>();

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

int main(int, char**)
     test<bool, true>();
     test<char, true>();
     test<signed char, true>();
     test<unsigned char, true>();
     test<wchar_t, true>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, true>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t, true>();
     test<char32_t, true>();
-#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>();

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

int main(int, char**)
     test<bool, false>();
     test<char, false>();
     test<signed char, false>();
     test<unsigned char, false>();
     test<wchar_t, false>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, false>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t, false>();
     test<char32_t, false>();
-#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>();

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

int main(int, char**)
     test<bool, true>();
     test<char, true>();
     test<signed char, true>();
     test<unsigned char, true>();
     test<wchar_t, true>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, true>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t, true>();
     test<char32_t, true>();
-#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>();

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

int main(int, char**)
     test<bool, false>();
 //    test<char, false>(); // don't know
     test<signed char, false>();
     test<unsigned char, true>();
 //    test<wchar_t, false>(); // don't know
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, true>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t, true>();
     test<char32_t, true>();
-#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>();

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

int main(int, char**)
     test<bool, false>();
     test<char, char(-1) < char(0)>();
     test<signed char, true>();
     test<unsigned char, false>();
     test<wchar_t, wchar_t(-1) < wchar_t(0)>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, false>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t, false>();
     test<char32_t, false>();
-#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>();

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

int main(int, char**)
     test<signed char>(SCHAR_MIN);
     test<unsigned char>(0);
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test<wchar_t>(WCHAR_MIN);
 #endif
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t>(0);
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t>(0);
     test<char32_t>(0);
-#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);

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

int main(int, char**)
     test<signed char>(SCHAR_MAX);
     test<unsigned char>(UCHAR_MAX);
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test<wchar_t>(WCHAR_MAX);
 #endif
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t>(UCHAR_MAX); // ??
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t>(USHRT_MAX);
     test<char32_t>(UINT_MAX);
-#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);

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

int main(int, char**)
     test<bool, 0>();
     test<char, 0>();
     test<signed char, 0>();
     test<unsigned char, 0>();
     test<wchar_t, 0>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, 0>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t, 0>();
     test<char32_t, 0>();
-#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>();

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

int main(int, char**)
     test<bool, 0>();
     test<char, 0>();
     test<signed char, 0>();
     test<unsigned char, 0>();
     test<wchar_t, 0>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, 0>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t, 0>();
     test<char32_t, 0>();
-#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>();

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

int main(int, char**)
     test<bool, 0>();
     test<char, 0>();
     test<signed char, 0>();
     test<unsigned char, 0>();
     test<wchar_t, 0>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, 0>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t, 0>();
     test<char32_t, 0>();
-#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>();

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

int main(int, char**)
     test<signed char>(SCHAR_MIN);
     test<unsigned char>(0);
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test<wchar_t>(WCHAR_MIN);
 #endif
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t>(0);
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t>(0);
     test<char32_t>(0);
-#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);

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

int main(int, char**)
     test<bool, 0>();
     test<char, 0>();
     test<signed char, 0>();
     test<unsigned char, 0>();
     test<wchar_t, 0>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, 0>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t, 0>();
     test<char32_t, 0>();
-#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>();

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

int main(int, char**)
     test<bool, 0>();
     test<char, 0>();
     test<signed char, 0>();
     test<unsigned char, 0>();
     test<wchar_t, 0>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, 0>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t, 0>();
     test<char32_t, 0>();
-#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>();

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

int main(int, char**)
     test<bool>();
     test<char>();
     test<signed char>();
     test<unsigned char>();
     test<wchar_t>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t>();
     test<char32_t>();
-#endif
     test<short>();
     test<unsigned short>();
     test<int>();
     test<unsigned int>();
     test<long>();
     test<unsigned long>();
     test<long long>();
     test<unsigned long long>();

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

int main(int, char**)
     test<bool, 2>();
     test<char, 2>();
     test<signed char, 2>();
     test<unsigned char, 2>();
     test<wchar_t, 2>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, 2>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t, 2>();
     test<char32_t, 2>();
-#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>();

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

int main(int, char**)
     test<bool>(false);
     test<char>(0);
     test<signed char>(0);
     test<unsigned char>(0);
     test<wchar_t>(0);
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t>(0);
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t>(0);
     test<char32_t>(0);
-#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);

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

int main(int, char**)
     test<bool, std::round_toward_zero>();
     test<char, std::round_toward_zero>();
     test<signed char, std::round_toward_zero>();
     test<unsigned char, std::round_toward_zero>();
     test<wchar_t, std::round_toward_zero>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, std::round_toward_zero>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t, std::round_toward_zero>();
     test<char32_t, std::round_toward_zero>();
-#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>();

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

int main(int, char**)
     test<bool>();
     test<char>();
     test<signed char>();
     test<unsigned char>();
     test<wchar_t>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t>();
     test<char32_t>();
-#endif // TEST_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>();

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

int main(int, char**)
     test<bool, false>();
     test<char, false>();
     test<signed char, false>();
     test<unsigned char, false>();
     test<wchar_t, false>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, false>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t, false>();
     test<char32_t, false>();
-#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>();

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

int main(int, char**)
     test<bool, false>();
     test<char, integral_types_trap>();
     test<signed char, integral_types_trap>();
     test<unsigned char, integral_types_trap>();
     test<wchar_t, integral_types_trap>();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t, integral_types_trap>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<char16_t, integral_types_trap>();
     test<char32_t, integral_types_trap>();
-#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>();

libcxx/test/std/strings/basic.string.hash/enabled_hashes.pass.cpp

int main(int, char**) {
   {
     test_hash_enabled_for_type<std::string>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test_hash_enabled_for_type<std::wstring>();
 #endif
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     test_hash_enabled_for_type<std::u8string>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test_hash_enabled_for_type<std::u16string>();
     test_hash_enabled_for_type<std::u32string>();
-#endif
   }
 
   return 0;
 }

libcxx/test/std/strings/basic.string.hash/strings.pass.cpp

 }
 
 int main(int, char**)
 {
     test<std::string>();
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     test<std::u8string>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<std::u16string>();
     test<std::u32string>();
-#endif
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test<std::wstring>();
 #endif
 
   return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign2.pass.cpp

constexpr bool test_constexpr()
     char16_t c = u'1';
     std::char_traits<char16_t>::assign(c, u'a');
     return c == u'a';
 }
 #endif
 
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
     char16_t c = u'\0';
     std::char_traits<char16_t>::assign(c, u'a');
     assert(c == u'a');
 #endif
 
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
   return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/assign3.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
 TEST_CONSTEXPR_CXX20 bool test()
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     char16_t s2[3] = {0};
     assert(std::char_traits<char16_t>::assign(s2, 3, char16_t(5)) == s2);
     assert(s2[0] == char16_t(5));
     assert(s2[1] == char16_t(5));
     assert(s2[2] == char16_t(5));
     assert(std::char_traits<char16_t>::assign(NULL, 0, char16_t(5)) == NULL);
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
   return true;
 }
 
 int main(int, char**)
 {
     test();
 
 #if TEST_STD_VER > 17
     static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/compare.pass.cpp

return std::char_traits<char16_t>::compare(u"123", u"223", 3) < 0
         && std::char_traits<char16_t>::compare(u"223", u"123", 3) > 0
         && std::char_traits<char16_t>::compare(u"123", u"123", 3) == 0;
 }
 #endif
 
 
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
     assert(std::char_traits<char16_t>::compare(u"", u"", 0) == 0);
     assert(std::char_traits<char16_t>::compare(NULL, NULL, 0) == 0);
 
     assert(std::char_traits<char16_t>::compare(u"1", u"1", 1) == 0);
     assert(std::char_traits<char16_t>::compare(u"1", u"2", 1) < 0);
     assert(std::char_traits<char16_t>::compare(u"2", u"1", 1) > 0);
 
#if TEST_STD_VER >= 11
     assert(std::char_traits<char16_t>::compare(u"223", u"123", 3) > 0);
     assert(std::char_traits<char16_t>::compare(u"133", u"123", 3) > 0);
     assert(std::char_traits<char16_t>::compare(u"124", u"123", 3) > 0);
 #endif
 
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
   return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/copy.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
 TEST_CONSTEXPR_CXX20 bool test()
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     char16_t s1[] = {1, 2, 3};
     char16_t s2[3] = {0};
     assert(std::char_traits<char16_t>::copy(s2, s1, 3) == s2);
     assert(s2[0] == char16_t(1));
     assert(s2[1] == char16_t(2));
     assert(s2[2] == char16_t(3));
     assert(std::char_traits<char16_t>::copy(NULL, s1, 0) == NULL);
     assert(std::char_traits<char16_t>::copy(s1, NULL, 0) == s1);
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
     return true;
 }
 
 int main(int, char**)
 {
     test();
 
 #if TEST_STD_VER > 17
     static_assert(test());
 #endif
 
     return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eof.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<> struct char_traits<char16_t>
 
 // static constexpr int_type eof();
 
 #include <string>
-#include <cassert>
-
-#include "test_macros.h"
 
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     std::char_traits<char16_t>::int_type i = std::char_traits<char16_t>::eof();
     ((void)i); // Prevent unused warning
-#endif
-
     return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<> struct char_traits<char16_t>
 
 // static constexpr bool eq(char_type c1, char_type c2);
 
+// UNSUPPORTED: c++03
+
 #include <string>
 #include <cassert>
 
-#include "test_macros.h"
-
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
-#if TEST_STD_VER >= 11
     assert(std::char_traits<char16_t>::eq(u'a', u'a'));
     assert(!std::char_traits<char16_t>::eq(u'a', u'A'));
-#endif
-#endif // TEST_HAS_NO_UNICODE_CHARS
-
     return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/eq_int_type.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
     assert( std::char_traits<char16_t>::eq_int_type(u'a', u'a'));
     assert(!std::char_traits<char16_t>::eq_int_type(u'a', u'A'));
     assert(!std::char_traits<char16_t>::eq_int_type(std::char_traits<char16_t>::eof(), u'A'));
 #endif
     assert( std::char_traits<char16_t>::eq_int_type(std::char_traits<char16_t>::eof(),
                                                     std::char_traits<char16_t>::eof()));
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
     return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/find.pass.cpp

return std::char_traits<char16_t>::find(p, 3, u'1') == p
         && std::char_traits<char16_t>::find(p, 3, u'2') == p + 1
         && std::char_traits<char16_t>::find(p, 3, u'3') == p + 2
         && std::char_traits<char16_t>::find(p, 3, u'4') == nullptr;
 }
 #endif
 
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     char16_t s1[] = {1, 2, 3};
     assert(std::char_traits<char16_t>::find(s1, 3, char16_t(1)) == s1);
     assert(std::char_traits<char16_t>::find(s1, 3, char16_t(2)) == s1+1);
     assert(std::char_traits<char16_t>::find(s1, 3, char16_t(3)) == s1+2);
     assert(std::char_traits<char16_t>::find(s1, 3, char16_t(4)) == 0);
     assert(std::char_traits<char16_t>::find(s1, 3, char16_t(0)) == 0);
     assert(std::char_traits<char16_t>::find(NULL, 0, char16_t(0)) == 0);
 
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
   return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/length.pass.cpp

 {
     return std::char_traits<char16_t>::length(u"") == 0
         && std::char_traits<char16_t>::length(u"abcd") == 4;
 }
 #endif
 
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
     assert(std::char_traits<char16_t>::length(u"") == 0);
     assert(std::char_traits<char16_t>::length(u"a") == 1);
     assert(std::char_traits<char16_t>::length(u"aa") == 2);
     assert(std::char_traits<char16_t>::length(u"aaa") == 3);
     assert(std::char_traits<char16_t>::length(u"aaaa") == 4);
 #endif
 
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
   return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/lt.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<> struct char_traits<char16_t>
 
 // static constexpr bool lt(char_type c1, char_type c2);
 
+// UNSUPPORTED: c++03
+
 #include <string>
 #include <cassert>
 
-#include "test_macros.h"
-
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
-#if TEST_STD_VER >= 11
     assert(!std::char_traits<char16_t>::lt(u'a', u'a'));
     assert( std::char_traits<char16_t>::lt(u'A', u'a'));
-#endif
-#endif // TEST_HAS_NO_UNICODE_CHARS
-
     return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/move.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
 TEST_CONSTEXPR_CXX20 bool test()
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     char16_t s1[] = {1, 2, 3};
     assert(std::char_traits<char16_t>::move(s1, s1+1, 2) == s1);
     assert(s1[0] == char16_t(2));
     assert(s1[1] == char16_t(3));
     assert(s1[2] == char16_t(3));
     s1[2] = char16_t(0);
     assert(std::char_traits<char16_t>::move(s1+1, s1, 2) == s1+1);
     assert(s1[0] == char16_t(2));
     assert(s1[1] == char16_t(2));
     assert(s1[2] == char16_t(3));
     assert(std::char_traits<char16_t>::move(NULL, s1, 0) == NULL);
     assert(std::char_traits<char16_t>::move(s1, NULL, 0) == s1);
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
     return true;
 }
 
 int main(int, char**)
 {
     test();
 
 #if TEST_STD_VER > 17
     static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/not_eof.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
     assert(std::char_traits<char16_t>::not_eof(u'a') == u'a');
     assert(std::char_traits<char16_t>::not_eof(u'A') == u'A');
 #endif
     assert(std::char_traits<char16_t>::not_eof(0) == 0);
     assert(std::char_traits<char16_t>::not_eof(std::char_traits<char16_t>::eof()) !=
            std::char_traits<char16_t>::eof());
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
   return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_char_type.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
     assert(std::char_traits<char16_t>::to_char_type(u'a') == u'a');
     assert(std::char_traits<char16_t>::to_char_type(u'A') == u'A');
 #endif
     assert(std::char_traits<char16_t>::to_char_type(0) == 0);
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
   return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/to_int_type.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
     assert(std::char_traits<char16_t>::to_int_type(u'a') == u'a');
     assert(std::char_traits<char16_t>::to_int_type(u'A') == u'A');
 #endif
     assert(std::char_traits<char16_t>::to_int_type(0) == 0);
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
   return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char16_t/types.pass.cpp

 #include <string>
 #include <type_traits>
 #include <cstdint>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     static_assert((std::is_same<std::char_traits<char16_t>::char_type, char16_t>::value), "");
     static_assert((std::is_same<std::char_traits<char16_t>::int_type, std::uint_least16_t>::value), "");
     static_assert((std::is_same<std::char_traits<char16_t>::off_type, std::streamoff>::value), "");
     static_assert((std::is_same<std::char_traits<char16_t>::pos_type, std::u16streampos>::value), "");
     static_assert((std::is_same<std::char_traits<char16_t>::state_type, std::mbstate_t>::value), "");
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
     return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign2.pass.cpp

constexpr bool test_constexpr()
     char32_t c = U'1';
     std::char_traits<char32_t>::assign(c, U'a');
     return c == U'a';
 }
 #endif
 
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
     char32_t c = U'\0';
     std::char_traits<char32_t>::assign(c, U'a');
     assert(c == U'a');
 #endif
 
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
     return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/assign3.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
 TEST_CONSTEXPR_CXX20 bool test()
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     char32_t s2[3] = {0};
     assert(std::char_traits<char32_t>::assign(s2, 3, char32_t(5)) == s2);
     assert(s2[0] == char32_t(5));
     assert(s2[1] == char32_t(5));
     assert(s2[2] == char32_t(5));
     assert(std::char_traits<char32_t>::assign(NULL, 0, char32_t(5)) == NULL);
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
     return true;
 }
 
 int main(int, char**)
 {
     test();
 
 #if TEST_STD_VER > 17
     static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/compare.pass.cpp

constexpr bool test_constexpr()
     return std::char_traits<char32_t>::compare(U"123", U"223", 3) < 0
         && std::char_traits<char32_t>::compare(U"223", U"123", 3) > 0
         && std::char_traits<char32_t>::compare(U"123", U"123", 3) == 0;
 }
 #endif
 
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
     assert(std::char_traits<char32_t>::compare(U"", U"", 0) == 0);
     assert(std::char_traits<char32_t>::compare(NULL, NULL, 0) == 0);
 
     assert(std::char_traits<char32_t>::compare(U"1", U"1", 1) == 0);
     assert(std::char_traits<char32_t>::compare(U"1", U"2", 1) < 0);
     assert(std::char_traits<char32_t>::compare(U"2", U"1", 1) > 0);
 
#if TEST_STD_VER >= 11
     assert(std::char_traits<char32_t>::compare(U"223", U"123", 3) > 0);
     assert(std::char_traits<char32_t>::compare(U"133", U"123", 3) > 0);
     assert(std::char_traits<char32_t>::compare(U"124", U"123", 3) > 0);
 #endif
 
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
   return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/copy.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
 TEST_CONSTEXPR_CXX20 bool test()
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     char32_t s1[] = {1, 2, 3};
     char32_t s2[3] = {0};
     assert(std::char_traits<char32_t>::copy(s2, s1, 3) == s2);
     assert(s2[0] == char32_t(1));
     assert(s2[1] == char32_t(2));
     assert(s2[2] == char32_t(3));
     assert(std::char_traits<char32_t>::copy(NULL, s1, 0) == NULL);
     assert(std::char_traits<char32_t>::copy(s1, NULL, 0) == s1);
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
     return true;
 }
 
 int main(int, char**)
 {
     test();
 
 #if TEST_STD_VER > 17
     static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eof.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     std::char_traits<char32_t>::int_type i = std::char_traits<char32_t>::eof();
     ((void)i); // Prevent unused warning
-#endif
 
     return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<> struct char_traits<char32_t>
 
 // static constexpr bool eq(char_type c1, char_type c2);
 
+// UNSUPPORTED: c++03
+
 #include <string>
 #include <cassert>
 
-#include "test_macros.h"
-
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
-#if TEST_STD_VER >= 11
     assert(std::char_traits<char32_t>::eq(U'a', U'a'));
     assert(!std::char_traits<char32_t>::eq(U'a', U'A'));
-#endif
-#endif // TEST_HAS_NO_UNICODE_CHARS
-
     return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/eq_int_type.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
     assert( std::char_traits<char32_t>::eq_int_type(U'a', U'a'));
     assert(!std::char_traits<char32_t>::eq_int_type(U'a', U'A'));
     assert(!std::char_traits<char32_t>::eq_int_type(std::char_traits<char32_t>::eof(), U'A'));
 #endif
     assert( std::char_traits<char32_t>::eq_int_type(std::char_traits<char32_t>::eof(),
                                                     std::char_traits<char32_t>::eof()));
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
     return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/find.pass.cpp

return std::char_traits<char32_t>::find(p, 3, U'1') == p
         && std::char_traits<char32_t>::find(p, 3, U'2') == p + 1
         && std::char_traits<char32_t>::find(p, 3, U'3') == p + 2
         && std::char_traits<char32_t>::find(p, 3, U'4') == nullptr;
 }
 #endif
 
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     char32_t s1[] = {1, 2, 3};
     assert(std::char_traits<char32_t>::find(s1, 3, char32_t(1)) == s1);
     assert(std::char_traits<char32_t>::find(s1, 3, char32_t(2)) == s1+1);
     assert(std::char_traits<char32_t>::find(s1, 3, char32_t(3)) == s1+2);
     assert(std::char_traits<char32_t>::find(s1, 3, char32_t(4)) == 0);
     assert(std::char_traits<char32_t>::find(s1, 3, char32_t(0)) == 0);
     assert(std::char_traits<char32_t>::find(NULL, 0, char32_t(0)) == 0);
 
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
     return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/length.pass.cpp

 {
     return std::char_traits<char32_t>::length(U"") == 0
         && std::char_traits<char32_t>::length(U"abcd") == 4;
 }
 #endif
 
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
     assert(std::char_traits<char32_t>::length(U"") == 0);
     assert(std::char_traits<char32_t>::length(U"a") == 1);
     assert(std::char_traits<char32_t>::length(U"aa") == 2);
     assert(std::char_traits<char32_t>::length(U"aaa") == 3);
     assert(std::char_traits<char32_t>::length(U"aaaa") == 4);
 #endif
 
 #if TEST_STD_VER > 14
     static_assert(test_constexpr(), "" );
 #endif
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
     return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/lt.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<> struct char_traits<char32_t>
 
 // static constexpr bool lt(char_type c1, char_type c2);
 
+// UNSUPPORTED: c++03
+
 #include <string>
 #include <cassert>
 
-#include "test_macros.h"
-
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
-#if TEST_STD_VER >= 11
     assert(!std::char_traits<char32_t>::lt(U'a', U'a'));
     assert( std::char_traits<char32_t>::lt(U'A', U'a'));
-#endif
-#endif // TEST_HAS_NO_UNICODE_CHARS
-
     return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/move.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
 TEST_CONSTEXPR_CXX20 bool test()
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     char32_t s1[] = {1, 2, 3};
     assert(std::char_traits<char32_t>::move(s1, s1+1, 2) == s1);
     assert(s1[0] == char32_t(2));
     assert(s1[1] == char32_t(3));
     assert(s1[2] == char32_t(3));
     s1[2] = char32_t(0);
     assert(std::char_traits<char32_t>::move(s1+1, s1, 2) == s1+1);
     assert(s1[0] == char32_t(2));
     assert(s1[1] == char32_t(2));
     assert(s1[2] == char32_t(3));
     assert(std::char_traits<char32_t>::move(NULL, s1, 0) == NULL);
     assert(std::char_traits<char32_t>::move(s1, NULL, 0) == s1);
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
     return true;
 }
 
 int main(int, char**)
 {
     test();
 
 #if TEST_STD_VER > 17
     static_assert(test());
 #endif
 
   return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/not_eof.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
     assert(std::char_traits<char32_t>::not_eof(U'a') == U'a');
     assert(std::char_traits<char32_t>::not_eof(U'A') == U'A');
 #endif
     assert(std::char_traits<char32_t>::not_eof(0) == 0);
     assert(std::char_traits<char32_t>::not_eof(std::char_traits<char32_t>::eof()) !=
            std::char_traits<char32_t>::eof());
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
     return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_char_type.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
     assert(std::char_traits<char32_t>::to_char_type(U'a') == U'a');
     assert(std::char_traits<char32_t>::to_char_type(U'A') == U'A');
 #endif
     assert(std::char_traits<char32_t>::to_char_type(0) == 0);
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
     return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/to_int_type.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-#ifndef TEST_HAS_NO_UNICODE_CHARS
 #if TEST_STD_VER >= 11
     assert(std::char_traits<char32_t>::to_int_type(U'a') == U'a');
     assert(std::char_traits<char32_t>::to_int_type(U'A') == U'A');
 #endif
     assert(std::char_traits<char32_t>::to_int_type(0) == 0);
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
     return 0;
 }

libcxx/test/std/strings/char.traits/char.traits.specializations/char.traits.specializations.char32_t/types.compile.pass.cpp

 // typedef streamoff      off_type;
 // typedef u32streampos   pos_type;
 // typedef mbstate_t      state_type;
 
 #include <string>
 #include <type_traits>
 #include <cstdint>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
-#ifndef TEST_HAS_NO_UNICODE_CHARS
-    static_assert((std::is_same<std::char_traits<char32_t>::char_type, char32_t>::value), "");
-    static_assert((std::is_same<std::char_traits<char32_t>::int_type, std::uint_least32_t>::value), "");
-    static_assert((std::is_same<std::char_traits<char32_t>::off_type, std::streamoff>::value), "");
-    static_assert((std::is_same<std::char_traits<char32_t>::pos_type, std::u32streampos>::value), "");
-    static_assert((std::is_same<std::char_traits<char32_t>::state_type, std::mbstate_t>::value), "");
-#endif // TEST_HAS_NO_UNICODE_CHARS
-
-  return 0;
-}

libcxx/test/std/strings/string.classes/typedefs.compile.pass.cpp

 // typedef basic_string<char32_t> u32string;
 // typedef basic_string<wchar_t>  wstring;
 
 #include <string>
 #include <type_traits>
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    static_assert((std::is_same<std::string, std::basic_string<char> >::value), "");
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
-    static_assert((std::is_same<std::wstring, std::basic_string<wchar_t> >::value), "");
 #endif
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
-    static_assert((std::is_same<std::u8string, std::basic_string<char8_t> >::value), "");
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
-    static_assert((std::is_same<std::u16string, std::basic_string<char16_t> >::value), "");
-    static_assert((std::is_same<std::u32string, std::basic_string<char32_t> >::value), "");
-#endif // TEST_HAS_NO_UNICODE_CHARS
-
-  return 0;
-}

libcxx/test/std/strings/string.view/string.view.hash/enabled_hashes.pass.cpp

int main(int, char**) {
   {
     test_hash_enabled_for_type<std::string_view>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test_hash_enabled_for_type<std::wstring_view>();
 #endif
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     test_hash_enabled_for_type<std::u8string_view>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test_hash_enabled_for_type<std::u16string_view>();
     test_hash_enabled_for_type<std::u32string_view>();
-#endif
   }
 
   return 0;
 }

libcxx/test/std/strings/string.view/string.view.hash/string_view.pass.cpp

 }
 
 int main(int, char**)
 {
     test<std::string_view>();
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     test<std::u8string_view>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     test<std::u16string_view>();
     test<std::u32string_view>();
-#endif
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test<std::wstring_view>();
 #endif
 
   return 0;
 }

libcxx/test/std/strings/string.view/string.view.cons/assign.pass.cpp

 
 int main(int, char**) {
 
     assert( test<std::string_view>    (  "1234"));
 #if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     assert( test<std::u8string_view>  (u8"1234"));
 #endif
 #if TEST_STD_VER >= 11
-#   ifndef TEST_HAS_NO_UNICODE_CHARS
     assert( test<std::u16string_view> ( u"1234"));
     assert( test<std::u32string_view> ( U"1234"));
-#   endif
-#endif
+#endif
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     assert( test<std::wstring_view>   ( L"1234"));
 #endif
 
 #if TEST_STD_VER > 11
     static_assert( test<std::string_view>    ({  "abc", 3}), "");
 #   if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
     static_assert( test<std::u8string_view>  ({u8"abc", 3}), "");
 #   endif
-#   ifndef TEST_HAS_NO_UNICODE_CHARS
     static_assert( test<std::u16string_view> ({ u"abc", 3}), "");
     static_assert( test<std::u32string_view> ({ U"abc", 3}), "");
-#   endif
 #   ifndef TEST_HAS_NO_WIDE_CHARACTERS
     static_assert( test<std::wstring_view>   ({ L"abc", 3}), "");
 #   endif
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/format/format.arguments/format.arg/ctor.pass.cpp

 }
 
 void test() {
   test<char>();
   test<wchar_t>();
 #ifndef TEST_HAS_NO_CHAR8_T
   test<char8_t>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
   test<char16_t>();
   test<char32_t>();
-#endif
 }
 
 int main(int, char**) {
   test();
 
   return 0;
 }

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/advance_to.pass.cpp

test(std::basic_format_args(
       std::make_format_args<std::basic_format_context<
           std::back_insert_iterator<std::basic_string<wchar_t>>, wchar_t>>()));
 #endif
 #ifndef TEST_HAS_NO_CHAR8_T
   test(std::basic_format_args(
       std::make_format_args<std::basic_format_context<
           std::back_insert_iterator<std::basic_string<char8_t>>, char8_t>>()));
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
   test(std::basic_format_args(
       std::make_format_args<std::basic_format_context<
           std::back_insert_iterator<std::basic_string<char16_t>>,
           char16_t>>()));
   test(std::basic_format_args(
       std::make_format_args<std::basic_format_context<
           std::back_insert_iterator<std::basic_string<char32_t>>,
           char32_t>>()));
-#endif
 }
 
 int main(int, char**) {
   test();
 
   return 0;
 }

libcxx/test/std/utilities/format/format.formatter/format.context/format.context/out.pass.cpp

test(std::basic_format_args(
       std::make_format_args<std::basic_format_context<
           std::back_insert_iterator<std::basic_string<wchar_t>>, wchar_t>>()));
 #endif
 #ifndef TEST_HAS_NO_CHAR8_T
   test(std::basic_format_args(
       std::make_format_args<std::basic_format_context<
           std::back_insert_iterator<std::basic_string<char8_t>>, char8_t>>()));
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
   test(std::basic_format_args(
       std::make_format_args<std::basic_format_context<
           std::back_insert_iterator<std::basic_string<char16_t>>,
           char16_t>>()));
   test(std::basic_format_args(
       std::make_format_args<std::basic_format_context<
           std::back_insert_iterator<std::basic_string<char32_t>>,
           char32_t>>()));
-#endif
 }
 
 int main(int, char**) {
   test();
 
   return 0;
 }

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/advance_to.pass.cpp

 }
 
 constexpr bool test() {
   test("abc");
   test(L"abc");
 #ifndef TEST_HAS_NO_CHAR8_T
   test(u8"abc");
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
   test(u"abc");
   test(U"abc");
-#endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/begin.pass.cpp

 }
 
 constexpr bool test() {
   test("abc");
   test(L"abc");
 #ifndef TEST_HAS_NO_CHAR8_T
   test(u8"abc");
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
   test(u"abc");
   test(U"abc");
-#endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/ctor.pass.cpp

 }
 
 constexpr bool test() {
   test("abc");
   test(L"abc");
 #ifndef TEST_HAS_NO_CHAR8_T
   test(u8"abc");
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
   test(u"abc");
   test(U"abc");
-#endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/end.pass.cpp

 }
 
 constexpr bool test() {
   test("abc");
   test(L"abc");
 #ifndef TEST_HAS_NO_CHAR8_T
   test(u8"abc");
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
   test(u"abc");
   test(U"abc");
-#endif
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

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

 constexpr void test() {
   test<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
 #ifndef TEST_HAS_NO_CHAR8_T
   test<char8_t>();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
   test<char16_t>();
   test<char32_t>();
-#endif
 }
 
 static_assert(std::is_same_v<std::format_parse_context,
                              std::basic_format_parse_context<char> >);
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
 static_assert(std::is_same_v<std::wformat_parse_context,
                              std::basic_format_parse_context<wchar_t> >);
 #endif
 
 // Required for MSVC internal test runner compatibility.
 int main(int, char**) { return 0; }

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.fail.cpp

constexpr void test_char8t() {
   std::cmp_greater_equal(T(), T()); // expected-error 1 {{no matching function for call to 'cmp_greater_equal'}}
   std::cmp_greater_equal(T(), int()); // expected-error 1 {{no matching function for call to 'cmp_greater_equal'}}
   std::cmp_greater_equal(int(), T()); // expected-error 1 {{no matching function for call to 'cmp_greater_equal'}}
   std::in_range<T>(int()); // expected-error 1 {{no matching function for call to 'in_range'}}
   std::in_range<int>(T()); // expected-error 1 {{no matching function for call to 'in_range'}}
 }
 #endif // TEST_HAS_NO_CHAR8_T
 
-#ifndef TEST_HAS_NO_UNICODE_CHARS
 template <class T>
 constexpr void test_uchars() {
   std::cmp_equal(T(), T()); // expected-error 2 {{no matching function for call to 'cmp_equal'}}
   std::cmp_equal(T(), int()); // expected-error 2 {{no matching function for call to 'cmp_equal'}}
   std::cmp_equal(int(), T()); // expected-error 2 {{no matching function for call to 'cmp_equal'}}
   std::cmp_not_equal(T(), T()); // expected-error 2 {{no matching function for call to 'cmp_not_equal'}}
   std::cmp_not_equal(T(), int()); // expected-error 2 {{no matching function for call to 'cmp_not_equal'}}
   std::cmp_not_equal(int(), T()); // expected-error 2 {{no matching function for call to 'cmp_not_equal'}}
   std::cmp_less(T(), T()); // expected-error 2 {{no matching function for call to 'cmp_less'}}
   std::cmp_less(T(), int()); // expected-error 2 {{no matching function for call to 'cmp_less'}}
   std::cmp_less(int(), T()); // expected-error 2 {{no matching function for call to 'cmp_less'}}
   std::cmp_less_equal(T(), T()); // expected-error 2 {{no matching function for call to 'cmp_less_equal'}}
   std::cmp_less_equal(T(), int()); // expected-error 2 {{no matching function for call to 'cmp_less_equal'}}
   std::cmp_less_equal(int(), T()); // expected-error 2 {{no matching function for call to 'cmp_less_equal'}}
   std::cmp_greater(T(), T()); // expected-error 2 {{no matching function for call to 'cmp_greater'}}
   std::cmp_greater(T(), int()); // expected-error 2 {{no matching function for call to 'cmp_greater'}}
   std::cmp_greater(int(), T()); // expected-error 2 {{no matching function for call to 'cmp_greater'}}
   std::cmp_greater_equal(T(), T()); // expected-error 2 {{no matching function for call to 'cmp_greater_equal'}}
   std::cmp_greater_equal(T(), int()); // expected-error 2 {{no matching function for call to 'cmp_greater_equal'}}
   std::cmp_greater_equal(int(), T()); // expected-error 2 {{no matching function for call to 'cmp_greater_equal'}}
   std::in_range<T>(int()); // expected-error 2 {{no matching function for call to 'in_range'}}
   std::in_range<int>(T()); // expected-error 2 {{no matching function for call to 'in_range'}}
 }
-#endif // TEST_HAS_NO_UNICODE_CHARS
 
 int main(int, char**) {
   test<bool>();
   test<char>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test<wchar_t>();
 #endif
   test<float>();
   test<double>();
   test<long double>();
   test<std::byte>();
   test<NonEmptyT>();
   test<ColorT>();
   test<std::nullptr_t>();
   test<EmptyT>();
 
 #ifndef TEST_HAS_NO_CHAR8_T
   test_char8t<char8_t>();
 #endif // TEST_HAS_NO_CHAR8_T
 
-#ifndef TEST_HAS_NO_UNICODE_CHARS
   test_uchars<char16_t>();
   test_uchars<char32_t>();
-#endif
 
   return 0;
 }

libcxx/test/support/atomic_helpers.h

void operator()() const {
     TestFunctor<long>()();
     TestFunctor<unsigned long>()();
     TestFunctor<long long>()();
     TestFunctor<unsigned long long>()();
     TestFunctor<wchar_t>()();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     TestFunctor<char8_t>()();
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
     TestFunctor<char16_t>()();
     TestFunctor<char32_t>()();
-#endif
     TestFunctor<int8_t>()();
     TestFunctor<uint8_t>()();
     TestFunctor<int16_t>()();
     TestFunctor<uint16_t>()();
     TestFunctor<int32_t>()();
     TestFunctor<uint32_t>()();
     TestFunctor<int64_t>()();
     TestFunctor<uint64_t>()();

libcxx/test/support/poisoned_hash_helper.h

 #endif
       bool,
       char,
       signed char,
       unsigned char,
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
       wchar_t,
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
       char16_t,
       char32_t,
-#endif
       short,
       unsigned short,
       int,
       unsigned int,
       long,
       unsigned long,
       long long,
       unsigned long long,

libcxx/test/support/test.support/make_string_header.pass.cpp

 #endif
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
   assert(MAKE_STRING(char8_t,
          " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN"
              "OPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~")
     == u8" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN"
              "OPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~");
 #endif
-#ifndef TEST_HAS_NO_UNICODE_CHARS
   assert(MAKE_STRING(char16_t,
          " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN"
              "OPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~")
     ==  u" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN"
              "OPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~");
 
   assert(MAKE_STRING(char32_t,
          " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN"
              "OPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~")
     ==  U" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN"
              "OPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~");
-#endif
 
   // clang-format on
   return 0;
 }

libcxx/test/support/test_macros.h

 #elif defined(_MSVC_EXECUTION_CHARACTER_SET) && _MSVC_EXECUTION_CHARACTER_SET != 65001
 #   define TEST_HAS_NO_UNICODE
 #endif
 
 #if defined(_LIBCPP_HAS_NO_INT128) || defined(_MSVC_STL_VERSION)
 #   define TEST_HAS_NO_INT128
 #endif
 
-#if defined(_LIBCPP_HAS_NO_UNICODE_CHARS)
-#   define TEST_HAS_NO_UNICODE_CHARS
-#endif
-
 #if defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #  define TEST_HAS_NO_LOCALIZATION
 #endif
 
 #if TEST_STD_VER <= 17 || !defined(__cpp_char8_t)
 #  define TEST_HAS_NO_CHAR8_T
 #endif