[libc++][NFC] Add missing conditionals for the existence of wide characters

[ldionne]

Trigger CI

[Mordante]

Thanks for the cleanup, LGTM!

[ldionne]

Generate files.

libcxx/include/locale

 extern template _LIBCPP_FUNC_VIS time_base::dateorder __time_get_storage<_CharT>::__do_date_order() const; \
 extern template _LIBCPP_FUNC_VIS __time_get_storage<_CharT>::__time_get_storage(const char*); \
 extern template _LIBCPP_FUNC_VIS __time_get_storage<_CharT>::__time_get_storage(const string&); \
 extern template _LIBCPP_FUNC_VIS void __time_get_storage<_CharT>::init(const ctype<_CharT>&); \
 extern template _LIBCPP_FUNC_VIS __time_get_storage<_CharT>::string_type __time_get_storage<_CharT>::__analyze(char, const ctype<_CharT>&); \
 /**/
 
 _LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION(char)
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 _LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION(wchar_t)
+#endif
 #undef _LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION
 
 template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
 class _LIBCPP_TEMPLATE_VIS time_get_byname
     : public time_get<_CharT, _InputIterator>,
       private __time_get_storage<_CharT>
 {
 public:
class _LIBCPP_TYPE_VIS __time_put
     locale_t __loc_;
 protected:
     _LIBCPP_INLINE_VISIBILITY __time_put() : __loc_(_LIBCPP_GET_C_LOCALE) {}
     __time_put(const char* __nm);
     __time_put(const string& __nm);
     ~__time_put();
     void __do_put(char* __nb, char*& __ne, const tm* __tm,
                   char __fmt, char __mod) const;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
     void __do_put(wchar_t* __wb, wchar_t*& __we, const tm* __tm,
                   char __fmt, char __mod) const;
+#endif
 };
 
 template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
 class _LIBCPP_TEMPLATE_VIS time_put
     : public locale::facet,
       private __time_put
 {
 public:

libcxx/include/streambuf

 template <class _CharT, class _Traits>
 typename basic_streambuf<_CharT, _Traits>::int_type
 basic_streambuf<_CharT, _Traits>::overflow(int_type)
 {
     return traits_type::eof();
 }
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_streambuf<char>;
-extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_streambuf<wchar_t>;
-
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ios<char>;
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_streambuf<wchar_t>;
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ios<wchar_t>;
+#endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_STREAMBUF

libcxx/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <fstream>
 
 // template<class charT, class traits = char_traits<charT>>
 //   class basic_filebuf;
 //
 // The char type of the stream and the char_type of the traits have to match
 
+// UNSUPPORTED: no-wide-characters
+
 #include <fstream>
 
 int main(int, char**)
 {
   std::basic_filebuf<char, std::char_traits<wchar_t> > f;
   // expected-error-re@streambuf:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
   // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
   // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}

libcxx/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // <fstream>
 
 // template <class charT, class traits = char_traits<charT> >
 // class basic_fstream
 
 // The char type of the stream and the char_type of the traits have to match
 
+// UNSUPPORTED: no-wide-characters
+
 #include <fstream>
 
 int main(int, char**)
 {
   std::basic_fstream<char, std::char_traits<wchar_t> > f;
 //  expected-error-re@ios:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
 //  expected-error-re@streambuf:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
 

libcxx/test/libcxx/utilities/format/format.string/format.string.std/extended_grapheme_cluster.h

 
 #ifndef LIBCXX_TEST_STD_UTILITIES_FORMAT_FORMAT_STRING_FORMAT_STRING_STD_EXTENDED_GRAPHEME_CLUSTER_H
 #define LIBCXX_TEST_STD_UTILITIES_FORMAT_FORMAT_STRING_FORMAT_STRING_STD_EXTENDED_GRAPHEME_CLUSTER_H
 
 #include <array>
 #include <string_view>
 #include <vector>
 
+#include "test_macros.h"
+
 template <class CharT>
 struct data {
   /// The input to parse.
   std::basic_string_view<CharT> input;
 
   /// The first code point all extended grapheme clusters in the input.
   std::vector<char32_t> code_points;
 
std::array<data<char>, 602> data_utf8 = {{
      {"\U00000061\U0001f3ff\U0001f476", {97, 128118}, {5, 9}},
      {"\U00000061\U0001f3ff\U0001f476\U0000200d\U0001f6d1", {97, 128118}, {5, 16}},
      {"\U0001f476\U0001f3ff\U00000308\U0000200d\U0001f476\U0001f3ff", {128118}, {21}},
      {"\U0001f6d1\U0000200d\U0001f6d1", {128721}, {11}},
      {"\U00000061\U0000200d\U0001f6d1", {97, 128721}, {4, 8}},
      {"\U00002701\U0000200d\U00002701", {9985}, {9}},
      {"\U00000061\U0000200d\U00002701", {97, 9985}, {4, 7}}}};
 
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
 /// The data for UTF-16.
 ///
 /// Note that most of the data for the UTF-16 and UTF-32 are identical. However
 /// since the size of the code units differ the breaks can contain different
 /// values.
 std::array<data<wchar_t>, 602> data_utf16 = {{
      {L"\U00000020\U00000020", {32, 32}, {1, 2}},
      {L"\U00000020\U00000308\U00000020", {32, 32}, {2, 3}},
std::array<data<wchar_t>, 602> data_utf32 = {{
      {L"\U0001f476\U0001f3ff\U0001f476", {128118, 128118}, {2, 3}},
      {L"\U00000061\U0001f3ff\U0001f476", {97, 128118}, {2, 3}},
      {L"\U00000061\U0001f3ff\U0001f476\U0000200d\U0001f6d1", {97, 128118}, {2, 5}},
      {L"\U0001f476\U0001f3ff\U00000308\U0000200d\U0001f476\U0001f3ff", {128118}, {6}},
      {L"\U0001f6d1\U0000200d\U0001f6d1", {128721}, {3}},
      {L"\U00000061\U0000200d\U0001f6d1", {97, 128721}, {2, 3}},
      {L"\U00002701\U0000200d\U00002701", {9985}, {3}},
      {L"\U00000061\U0000200d\U00002701", {97, 9985}, {2, 3}}}};
+#endif // TEST_HAS_NO_WIDE_CHARACTERS
 
 #endif // LIBCXX_TEST_STD_UTILITIES_FORMAT_FORMAT_STRING_FORMAT_STRING_STD_EXTENDED_GRAPHEME_CLUSTER_H

libcxx/test/std/re/re.iter/re.tokiter/re.tokiter.cnstr/default.pass.cpp

test()
     typedef std::regex_token_iterator<const CharT*> I;
     I i1;
     assert(i1 == I());
 }
 
 int main(int, char**)
 {
     test<char>();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test<wchar_t>();
+#endif
 
     return 0;
 }

libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp

 template <class Iter, class Alloc, class = void>
 struct CanDeduce : std::false_type { };
 
 template <class Iter, class Alloc>
 struct CanDeduce<Iter, Alloc, decltype((void)
   std::basic_string{std::declval<Iter>(), std::declval<Iter>(), std::declval<Alloc>()}
 )> : std::true_type { };
 
-static_assert( CanDeduce<int*, std::allocator<int>>::value);
+static_assert( CanDeduce<char*, std::allocator<char>>::value);
 static_assert(!CanDeduce<NotAnIterator, std::allocator<char>>::value);
 static_assert(!CanDeduce<NotAnInputIterator, std::allocator<char16_t>>::value);
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+static_assert( CanDeduce<wchar_t*, std::allocator<wchar_t>>::value);
 static_assert(!CanDeduce<wchar_t const*, NotAnAllocator<wchar_t>>::value);
+#endif
 
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     const char* s = "12345678901234";
     std::basic_string s1(s, s+10);  // Can't use {} here
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                      char>,  "");
     static_assert(std::is_same_v<S::traits_type,    std::char_traits<char>>, "");
     static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
     assert(s1.size() == 10);
     assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
   }
   {
     const char* s = "12345678901234";
     std::basic_string s1{s, s+10, std::allocator<char>{}};
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                      char>,  "");
     static_assert(std::is_same_v<S::traits_type,    std::char_traits<char>>, "");
     static_assert(std::is_same_v<S::allocator_type,   std::allocator<char>>, "");
     assert(s1.size() == 10);
     assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
   }
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
   {
     const wchar_t* s = L"12345678901234";
     std::basic_string s1{s, s+10, test_allocator<wchar_t>{}};
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                      wchar_t>,  "");
     static_assert(std::is_same_v<S::traits_type,    std::char_traits<wchar_t>>, "");
     static_assert(std::is_same_v<S::allocator_type,   test_allocator<wchar_t>>, "");
     assert(s1.size() == 10);
     assert(s1.compare(0, s1.size(), s, s1.size()) == 0);
   }
+#endif
   {
     const char16_t* s = u"12345678901234";
     std::basic_string s1{s, s+10, min_allocator<char16_t>{}};
     using S = decltype(s1); // what type did we get?
     static_assert(std::is_same_v<S::value_type,                      char16_t>,  "");
     static_assert(std::is_same_v<S::traits_type,    std::char_traits<char16_t>>, "");
     static_assert(std::is_same_v<S::allocator_type,    min_allocator<char16_t>>, "");
     assert(s1.size() == 10);

libcxx/test/std/strings/basic.string/traits_mismatch.verify.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>
 //   The strings's value type must be the same as the traits's char_type
 
+// UNSUPPORTED: no-wide-characters
+
 #include <string>
 
 std::basic_string<char, std::char_traits<wchar_t> > s; // expected-error@*:* {{traits_type::char_type must be the same type as CharT}}

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

static_assert((std::is_same<
         typename S::const_reverse_iterator,
         std::reverse_iterator<typename S::const_iterator> >::value), "");
     static_assert(S::npos == -1, "");
 }
 
 int main(int, char**)
 {
     test<test_traits<char>, test_allocator<char> >();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test<std::char_traits<wchar_t>, std::allocator<wchar_t> >();
+#endif
     static_assert((std::is_same<std::basic_string<char>::traits_type,
                                 std::char_traits<char> >::value), "");
     static_assert((std::is_same<std::basic_string<char>::allocator_type,
                                 std::allocator<char> >::value), "");
 #if TEST_STD_VER >= 11
     test<std::char_traits<char>, min_allocator<char> >();
 #endif
 
   return 0;
 }

libcxx/test/std/strings/string.view/string.view.access/at.pass.cpp

#ifndef TEST_HAS_NO_EXCEPTIONS
     assert ( false );
 #endif
 }
 
 int main(int, char**) {
     test ( "ABCDE", 5 );
     test ( "a", 1 );
 
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test ( L"ABCDE", 5 );
     test ( L"a", 1 );
+#endif
 
 #if TEST_STD_VER >= 11
     test ( u"ABCDE", 5 );
     test ( u"a", 1 );
 
     test ( U"ABCDE", 5 );
     test ( U"a", 1 );
 #endif

libcxx/test/std/strings/string.view/string.view.access/back.pass.cpp

bool test ( const CharT *s, size_t len ) {
     assert ( sv.back() == s[len-1] );
     return &sv.back() == s + len - 1;
     }
 
 int main(int, char**) {
     assert ( test ( "ABCDE", 5 ));
     assert ( test ( "a", 1 ));
 
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     assert ( test ( L"ABCDE", 5 ));
     assert ( test ( L"a", 1 ));
+#endif
 
 #if TEST_STD_VER >= 11
     assert ( test ( u"ABCDE", 5 ));
     assert ( test ( u"a", 1 ));
 
     assert ( test ( U"ABCDE", 5 ));
     assert ( test ( U"a", 1 ));
 #endif

libcxx/test/std/strings/string.view/string.view.access/data.pass.cpp

//  make sure we pick up std::data, too!
     assert ( sv.data() == std::data(sv));
 #endif
     }
 
 int main(int, char**) {
     test ( "ABCDE", 5 );
     test ( "a", 1 );
 
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test ( L"ABCDE", 5 );
     test ( L"a", 1 );
+#endif
 
 #if TEST_STD_VER >= 11
     test ( u"ABCDE", 5 );
     test ( u"a", 1 );
 
     test ( U"ABCDE", 5 );
     test ( U"a", 1 );
 #endif

libcxx/test/std/strings/string.view/string.view.access/front.pass.cpp

bool test ( const CharT *s, size_t len ) {
     assert ( sv.front() == s[0] );
     return &sv.front() == s;
     }
 
 int main(int, char**) {
     assert ( test ( "ABCDE", 5 ));
     assert ( test ( "a", 1 ));
 
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     assert ( test ( L"ABCDE", 5 ));
     assert ( test ( L"a", 1 ));
+#endif
 
 #if TEST_STD_VER >= 11
     assert ( test ( u"ABCDE", 5 ));
     assert ( test ( u"a", 1 ));
 
     assert ( test ( U"ABCDE", 5 ));
     assert ( test ( U"a", 1 ));
 #endif

libcxx/test/std/strings/string.view/string.view.access/index.pass.cpp

for ( size_t i = 0; i < len; ++i ) {
         assert ( &sv[i] == s + i );
         }
     }
 
 int main(int, char**) {
     test ( "ABCDE", 5 );
     test ( "a", 1 );
 
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test ( L"ABCDE", 5 );
     test ( L"a", 1 );
+#endif
 
 #if TEST_STD_VER >= 11
     test ( u"ABCDE", 5 );
     test ( u"a", 1 );
 
     test ( U"ABCDE", 5 );
     test ( U"a", 1 );
 #endif

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

 
 
 int main(int, char**) {
 
     test ( "QBCDE" );
     test ( "A" );
     test ( "" );
 
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test ( L"QBCDE" );
     test ( L"A" );
     test ( L"" );
+#endif
 
 #if TEST_STD_VER >= 11
     test ( u"QBCDE" );
     test ( u"A" );
     test ( u"" );
 
     test ( U"QBCDE" );
     test ( U"A" );

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

#if TEST_STD_VER > 11
     {
     constexpr const char *s = "QBCDE";
     constexpr std::basic_string_view<char> sv1 ( s, 2 );
     static_assert ( sv1.size() == 2, "" );
     static_assert ( sv1.data() == s, "" );
     }
 #endif
 
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test ( L"QBCDE", 5 );
     test ( L"QBCDE", 2 );
     test ( L"", 0 );
 #if TEST_STD_VER > 11
     {
     constexpr const wchar_t *s = L"QBCDE";
     constexpr std::basic_string_view<wchar_t> sv1 ( s, 2 );
     static_assert ( sv1.size() == 2, "" );
     static_assert ( sv1.data() == s, "" );
     }
 #endif
+#endif // TEST_HAS_NO_WIDE_CHARACTERS
 
 #if TEST_STD_VER >= 11
     test ( u"QBCDE", 5 );
     test ( u"QBCDE", 2 );
     test ( u"", 0 );
 #if TEST_STD_VER > 11
     {
     constexpr const char16_t *s = u"QBCDE";

libcxx/test/std/strings/string.view/string.view.ops/compare.pointer.pass.cpp

int main(int, char**)
     test("abcdefghij", "abcdefghij", 0);
     test("abcdefghij", "abcdefghijklmnopqrst", -10);
     test("abcdefghijklmnopqrst", "", 20);
     test("abcdefghijklmnopqrst", "abcde", 15);
     test("abcdefghijklmnopqrst", "abcdefghij", 10);
     test("abcdefghijklmnopqrst", "abcdefghijklmnopqrst", 0);
     }
 
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
     test(L"", L"", 0);
     test(L"", L"abcde", -5);
     test(L"", L"abcdefghij", -10);
     test(L"", L"abcdefghijklmnopqrst", -20);
     test(L"abcde", L"", 5);
     test(L"abcde", L"abcde", 0);
     test(L"abcde", L"abcdefghij", -5);
     test(L"abcde", L"abcdefghijklmnopqrst", -15);
     test(L"abcdefghij", L"", 10);
     test(L"abcdefghij", L"abcde", 5);
     test(L"abcdefghij", L"abcdefghij", 0);
     test(L"abcdefghij", L"abcdefghijklmnopqrst", -10);
     test(L"abcdefghijklmnopqrst", L"", 20);
     test(L"abcdefghijklmnopqrst", L"abcde", 15);
     test(L"abcdefghijklmnopqrst", L"abcdefghij", 10);
     test(L"abcdefghijklmnopqrst", L"abcdefghijklmnopqrst", 0);
     }
+#endif
 
 #if TEST_STD_VER >= 11
     {
     test(U"", U"", 0);
     test(U"", U"abcde", -5);
     test(U"", U"abcdefghij", -10);
     test(U"", U"abcdefghijklmnopqrst", -20);
     test(U"abcde", U"", 5);

libcxx/test/std/strings/string.view/string.view.ops/compare.pointer_size.pass.cpp

int main(int, char**)
     test("abcdefghij", 3, 3, "def", 0);
     test("abcdefghij", 0, 4, "abcdefghijklmnopqrst", -10);
     test("abcdefghijklmnopqrst", 5, 5, "", 20);
     test("abcdefghijklmnopqrst", 0, 8, "abcde", 15);
     test("abcdefghijklmnopqrst", 0, 12, "abcdefghij", 10);
     test("abcdefghijklmnopqrst", 0, static_cast<size_t>(-1), "abcdefghijklmnopqrst", 0);
     }
 
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
     test(L"", 0, 0, L"", 0);
     test(L"", 0, 0, L"abcde", -5);
     test(L"", 0, 0, L"abcdefghij", -10);
     test(L"", 0, 0, L"abcdefghijklmnopqrst", -20);
     test(L"abcde", 0, 2, L"", 5);
     test(L"abcde", 0, 6, L"abcde", 0);
     test(L"abcde", 0, 6, L"abcdefghij", -5);
     test(L"abcde", 0, 6, L"abcdefghijklmnopqrst", -15);
     test(L"abcdefghij", 3, 3, L"", 10);
     test(L"abcdefghij", 3, 3, L"abcde", 5);
     test(L"abcdefghij", 3, 3, L"def", 0);
     test(L"abcdefghij", 0, 4, L"abcdefghijklmnopqrst", -10);
     test(L"abcdefghijklmnopqrst", 5, 5, L"", 20);
     test(L"abcdefghijklmnopqrst", 0, 8, L"abcde", 15);
     test(L"abcdefghijklmnopqrst", 0, 12, L"abcdefghij", 10);
     test(L"abcdefghijklmnopqrst", 0, static_cast<size_t>(-1), L"abcdefghijklmnopqrst", 0);
     }
+#endif
 
 #if TEST_STD_VER >= 11
     {
     test(U"", 0, 0, U"", 0);
     test(U"", 0, 0, U"abcde", -5);
     test(U"", 0, 0, U"abcdefghij", -10);
     test(U"", 0, 0, U"abcdefghijklmnopqrst", -20);
     test(U"abcde", 0, 2, U"", 5);

libcxx/test/std/strings/string.view/string.view.ops/compare.size_size_sv.pass.cpp

int main(int, char**) {
 
     {
     test("abcde", 5, 1, "", 0);
     test("abcde", 2, 4, "", 3);
     test("abcde", 2, 4, "abcde", 2);
     test("ABCde", 2, 4, "abcde", -1);
     }
 
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
     test(L"abcde", 5, 1, L"", 0);
     test(L"abcde", 2, 4, L"", 3);
     test(L"abcde", 2, 4, L"abcde", 2);
     test(L"ABCde", 2, 4, L"abcde", -1);
     }
+#endif
 
 #if TEST_STD_VER >= 11
     {
     test(u"abcde", 5, 1, u"", 0);
     test(u"abcde", 2, 4, u"", 3);
     test(u"abcde", 2, 4, u"abcde", 2);
     test(u"ABCde", 2, 4, u"abcde", -1);
     }

libcxx/test/std/strings/string.view/string.view.ops/compare.size_size_sv_pointer_size.pass.cpp

int main(int, char**) {
     {
     test("", 0, 0, "abcde", 0, 0);
     test("", 0, 0, "abcde", 1, -1);
     test("abcdefghijklmnopqrst", 21, 0, "abcde", 0, 0);
     test("abcdefghijklmnopqrst", 21, 0, "abcde", 1, 0);
     test("abcdefghijklmnopqrst", 10, 0, "abcdefghij", 10, -10);
     }
 
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
     test(L"", 0, 0, L"abcde", 0, 0);
     test(L"", 0, 0, L"abcde", 1, -1);
     test(L"abcdefghijklmnopqrst", 21, 0, L"abcde", 0, 0);
     test(L"abcdefghijklmnopqrst", 21, 0, L"abcde", 1, 0);
     test(L"abcdefghijklmnopqrst", 10, 0, L"abcdefghij", 10, -10);
     }
+#endif
 
 #if TEST_STD_VER >= 11
     {
     test(U"", 0, 0, U"abcde", 0, 0);
     test(U"", 0, 0, U"abcde", 1, -1);
     test(U"abcdefghijklmnopqrst", 21, 0, U"abcde", 0, 0);
     test(U"abcdefghijklmnopqrst", 21, 0, U"abcde", 1, 0);
     test(U"abcdefghijklmnopqrst", 10, 0, U"abcdefghij", 10, -10);

libcxx/test/std/strings/string.view/string.view.ops/compare.size_size_sv_size_size.pass.cpp

int main(int, char**) {
 
     {
     test("abcde", 5, 1, "", 0, 0, 0);
     test("abcde", 2, 4, "", 0, 0, 3);
     test("abcde", 2, 4, "abcde", 3, 4, -2);
     test("ABCde", 2, 4, "abcde", 2, 4, -1);
     }
 
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     {
     test(L"abcde", 5, 1, L"", 0, 0, 0);
     test(L"abcde", 2, 4, L"", 0, 0, 3);
     test(L"abcde", 2, 4, L"abcde", 3, 4, -2);
     test(L"ABCde", 2, 4, L"abcde", 2, 4, -1);
     }
+#endif
 
 #if TEST_STD_VER >= 11
     {
     test(u"abcde", 5, 1, u"", 0, 0, 0);
     test(u"abcde", 2, 4, u"", 0, 0, 3);
     test(u"abcde", 2, 4, u"abcde", 3, 4, -2);
     test(u"ABCde", 2, 4, u"abcde", 2, 4, -1);
     }

libcxx/test/std/strings/string.view/string.view.ops/compare.sv.pass.cpp

int main(int, char**) {
     test("abcdefghij",           "abcde", 5);
     test("abcdefghij",           "abcdefghij", 0);
     test("abcdefghij",           "abcdefghijklmnopqrst", -10);
     test("abcdefghijklmnopqrst", "", 20);
     test("abcdefghijklmnopqrst", "abcde", 15);
     test("abcdefghijklmnopqrst", "abcdefghij", 10);
     test("abcdefghijklmnopqrst", "abcdefghijklmnopqrst", 0);
 
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test(L"",                     L"", 0);
     test(L"",                     L"abcde", -5);
     test(L"",                     L"abcdefghij", -10);
     test(L"",                     L"abcdefghijklmnopqrst", -20);
     test(L"abcde",                L"", 5);
     test(L"abcde",                L"abcde", 0);
     test(L"abcde",                L"abcdefghij", -5);
     test(L"abcde",                L"abcdefghijklmnopqrst", -15);
     test(L"abcdefghij",           L"", 10);
     test(L"abcdefghij",           L"abcde", 5);
     test(L"abcdefghij",           L"abcdefghij", 0);
     test(L"abcdefghij",           L"abcdefghijklmnopqrst", -10);
     test(L"abcdefghijklmnopqrst", L"", 20);
     test(L"abcdefghijklmnopqrst", L"abcde", 15);
     test(L"abcdefghijklmnopqrst", L"abcdefghij", 10);
     test(L"abcdefghijklmnopqrst", L"abcdefghijklmnopqrst", 0);
+#endif
 
 #if TEST_STD_VER >= 11
     test(u"",                     u"", 0);
     test(u"",                     u"abcde", -5);
     test(u"",                     u"abcdefghij", -10);
     test(u"",                     u"abcdefghijklmnopqrst", -20);
     test(u"abcde",                u"", 5);
     test(u"abcde",                u"abcde", 0);

libcxx/test/std/strings/string.view/string.view.ops/copy.pass.cpp

 }
 
 int main(int, char**) {
     test ( "ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE" );
     test ( "ABCDE");
     test ( "a" );
     test ( "" );
 
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test ( L"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE" );
     test ( L"ABCDE" );
     test ( L"a" );
     test ( L"" );
+#endif
 
 #if TEST_STD_VER >= 11
     test ( u"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE" );
     test ( u"ABCDE" );
     test ( u"a" );
     test ( u"" );
 
     test ( U"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE" );
     test ( U"ABCDE" );
     test ( U"a" );
     test ( U"" );
 #endif
 
     test_constexpr_copy("ABCDE", "GHIJK", "BCDJK");
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test_constexpr_copy(L"ABCDE", L"GHIJK", L"BCDJK");
+#endif
 #if TEST_STD_VER >= 11
     test_constexpr_copy(u"ABCDE", u"GHIJK", u"BCDJK");
     test_constexpr_copy(U"ABCDE", U"GHIJK", U"BCDJK");
 #endif
 #if TEST_STD_VER >= 17
     test_constexpr_copy(u8"ABCDE", u8"GHIJK", u8"BCDJK");
 #endif
 #if TEST_STD_VER >= 20
     static_assert(test_constexpr_copy("ABCDE", "GHIJK", "BCDJK"));
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     static_assert(test_constexpr_copy(L"ABCDE", L"GHIJK", L"BCDJK"));
+#endif
     static_assert(test_constexpr_copy(u"ABCDE", u"GHIJK", u"BCDJK"));
     static_assert(test_constexpr_copy(U"ABCDE", U"GHIJK", U"BCDJK"));
     static_assert(test_constexpr_copy(u8"ABCDE", u8"GHIJK", u8"BCDJK"));
 #endif
 
   return 0;
 }

libcxx/test/std/strings/string.view/string.view.ops/substr.pass.cpp

 }
 
 int main(int, char**) {
     test ( "ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE" );
     test ( "ABCDE");
     test ( "a" );
     test ( "" );
 
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test ( L"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE" );
     test ( L"ABCDE" );
     test ( L"a" );
     test ( L"" );
+#endif
 
 #if TEST_STD_VER >= 11
     test ( u"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE" );
     test ( u"ABCDE" );
     test ( u"a" );
     test ( u"" );
 
     test ( U"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE" );

libcxx/test/std/strings/string.view/types.pass.cpp

test()
     static_assert(S::npos == -1, "");
     static_assert((std::is_same<typename S::iterator,         typename S::const_iterator>::value), "");
     static_assert((std::is_same<typename S::reverse_iterator, typename S::const_reverse_iterator>::value), "");
 }
 
 int main(int, char**)
 {
     test<std::char_traits<char> >();
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test<std::char_traits<wchar_t> >();
+#endif
 #ifndef TEST_HAS_NO_CHAR8_T
     test<std::char_traits<char8_t> >();
 #endif
     static_assert((std::is_same<std::basic_string_view<char>::traits_type,
                                 std::char_traits<char> >::value), "");
 
   return 0;
 }

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

constexpr void test(const CharT* fmt) {
 
     context.advance_to(context.begin() + 1);
     assert(context.begin() == context.end());
   }
 }
 
 constexpr bool test() {
   test("abc");
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test(L"abc");
+#endif
 #ifndef TEST_HAS_NO_CHAR8_T
   test(u8"abc");
 #endif
   test(u"abc");
   test(U"abc");
 
   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 void test(const CharT* fmt) {
     std::basic_format_parse_context context(view);
     assert(context.begin() == view.begin());
     ASSERT_NOEXCEPT(context.begin());
   }
 }
 
 constexpr bool test() {
   test("abc");
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test(L"abc");
+#endif
 #ifndef TEST_HAS_NO_CHAR8_T
   test(u8"abc");
 #endif
   test(u"abc");
   test(U"abc");
 
   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

ASSERT_NOEXCEPT(std::basic_format_parse_context{std::basic_string_view<CharT>{}, 42});
     std::basic_format_parse_context context(view);
     assert(context.begin() == view.begin());
     assert(context.end() == view.end());
   }
 }
 
 constexpr bool test() {
   test("abc");
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test(L"abc");
+#endif
 #ifndef TEST_HAS_NO_CHAR8_T
   test(u8"abc");
 #endif
   test(u"abc");
   test(U"abc");
 
   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 void test(const CharT* fmt) {
     std::basic_format_parse_context context(view);
     assert(context.end() == view.end());
     ASSERT_NOEXCEPT(context.end());
   }
 }
 
 constexpr bool test() {
   test("abc");
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test(L"abc");
+#endif
 #ifndef TEST_HAS_NO_CHAR8_T
   test(u8"abc");
 #endif
   test(u"abc");
   test(U"abc");
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }