[libc++] Add a libc++ configuration that does not support localization

[ldionne]

Summary

When porting libc++ to embedded systems, it can be useful to drop support for localization, which these systems don't implement or care about.

[ldionne]

Rebase and finish missing UNSUPPORTED markup

[ldionne]

Rebase onto master and skip some modules tests

[ldionne]

All CI passed after restarting some jobs. I'll be committing this.

[xiaoxiang781216]

libcxx/test/libcxx/double_include.sh.cpp

152

I would expect all stream/regex still support. only the encoding/format conversion or wide char version has to be skipped.

[JonChesterfield]

[ldionne]

libcxx/test/libcxx/double_include.sh.cpp

152

Good luck pulling those out of the library. If you're willing to spend the time and make that work, I'll be more than happy to expand the no-localization mode to include some of <iostream>. Just make sure it doesn't become too complex.

Also note that this is primarily aimed at people doing embedded development. I would expect most of them probably don't care about <iostream> at all.

[xiaoxiang781216]

libcxx/test/libcxx/double_include.sh.cpp

152

Ok, it's fine to disable the whole iostream/regex in the initial patch, we can do more fine tune in the furture.

libcxx/CMakeLists.txt

option(LIBCXX_ENABLE_DEBUG_MODE_SUPPORT
    debug mode when compiling a program against libc++, it will fail to link
    since the required support isn't provided in the library." ON)
 option(LIBCXX_ENABLE_RANDOM_DEVICE
   "Whether to include support for std::random_device in the library. Disabling
    this can be useful when building the library for platforms that don't have
    a source of randomness, such as some embedded platforms. When this is not
    supported, most of <random> will still be available, but std::random_device
    will not." ON)
+option(LIBCXX_ENABLE_LOCALIZATION
+  "Whether to include support for localization in the library. Disabling
+   localization can be useful when porting to platforms that don't support
+   the C locale API (e.g. embedded). When localization is not supported,
+   several parts of the library will be disabled: <iostream>, <regex>, <locale>
+   will be completely unusable, and other parts may be only partly available." ON)
 option(LIBCXX_TEST_GDB_PRETTY_PRINTERS "Test gdb pretty printers." OFF)
 set(LIBCXX_TEST_CONFIG "${CMAKE_CURRENT_SOURCE_DIR}/test/configs/legacy.cfg.in" CACHE STRING
     "The Lit testing configuration to use when running the tests.")
 set(LIBCXX_TEST_PARAMS "" CACHE STRING
     "A list of parameters to run the Lit test suite with.")
 
 # Benchmark options -----------------------------------------------------------
 option(LIBCXX_INCLUDE_BENCHMARKS "Build the libc++ benchmarks and their dependencies" ON)

 config_define_if(LIBCXX_HAS_PTHREAD_API _LIBCPP_HAS_THREAD_API_PTHREAD)
 config_define_if(LIBCXX_HAS_EXTERNAL_THREAD_API _LIBCPP_HAS_THREAD_API_EXTERNAL)
 config_define_if(LIBCXX_HAS_WIN32_THREAD_API _LIBCPP_HAS_THREAD_API_WIN32)
 config_define_if(LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY _LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL)
 config_define_if(LIBCXX_HAS_MUSL_LIBC _LIBCPP_HAS_MUSL_LIBC)
 config_define_if(LIBCXX_NO_VCRUNTIME _LIBCPP_NO_VCRUNTIME)
 config_define_if(LIBCXX_ENABLE_PARALLEL_ALGORITHMS _LIBCPP_HAS_PARALLEL_ALGORITHMS)
 config_define_if_not(LIBCXX_ENABLE_RANDOM_DEVICE _LIBCPP_HAS_NO_RANDOM_DEVICE)
+config_define_if_not(LIBCXX_ENABLE_LOCALIZATION _LIBCPP_HAS_NO_LOCALIZATION)
 
 if (LIBCXX_ABI_DEFINES)
   set(abi_defines)
   foreach (abi_define ${LIBCXX_ABI_DEFINES})
     if (NOT abi_define MATCHES "^_LIBCPP_ABI_")
       message(SEND_ERROR "Invalid ABI macro ${abi_define} in LIBCXX_ABI_DEFINES")
     endif()
     list(APPEND abi_defines "#define ${abi_define}")

libcxx/cmake/caches/Generic-no-localization.cmake

+set(LIBCXX_ENABLE_LOCALIZATION OFF CACHE BOOL "")

libcxx/include/__config_site.in

 #cmakedefine _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
 #cmakedefine _LIBCPP_NO_VCRUNTIME
 #ifndef _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION
 #cmakedefine _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION @_LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION@
 #endif
 #cmakedefine _LIBCPP_ABI_NAMESPACE @_LIBCPP_ABI_NAMESPACE@
 #cmakedefine _LIBCPP_HAS_PARALLEL_ALGORITHMS
 #cmakedefine _LIBCPP_HAS_NO_RANDOM_DEVICE
+#cmakedefine _LIBCPP_HAS_NO_LOCALIZATION
 
 @_LIBCPP_ABI_DEFINES@
 
 #endif // _LIBCPP_CONFIG_SITE

libcxx/include/__locale

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___LOCALE
 #define _LIBCPP___LOCALE
 
 #include <__config>
+
+#if defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   error "Localization is not supported by this configuration of libc++"
+#endif
+
 #include <string>
 #include <memory>
 #include <utility>
 #include <mutex>
 #include <cstdint>
 #include <cctype>
 #include <locale.h>
 #if defined(_LIBCPP_MSVCRT_LIKE)

libcxx/include/complex

 
 */
 
 #include <__config>
 #include <type_traits>
 #include <stdexcept>
 #include <cmath>
 #include <iosfwd>
-#include <sstream>
 #include <version>
 
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   include <sstream> // for std::basic_ostringstream
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template<class _Tp> class _LIBCPP_TEMPLATE_VIS complex;
 
if (__is.good())
                 __is.setstate(__is.failbit);
         }
     }
     else
         __is.setstate(__is.failbit);
     return __is;
 }
 
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 template<class _Tp, class _CharT, class _Traits>
 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
 {
     basic_ostringstream<_CharT, _Traits> __s;
     __s.flags(__os.flags());
     __s.imbue(__os.getloc());
     __s.precision(__os.precision());
     __s << '(' << __x.real() << ',' << __x.imag() << ')';
     return __os << __s.str();
 }
+#endif // !_LIBCPP_HAS_NO_LOCALIZATION
 
 #if _LIBCPP_STD_VER > 11
 // Literal suffix for complex number literals [complex.literals]
 inline namespace literals
 {
   inline namespace complex_literals
   {
     constexpr complex<long double> operator""il(long double __im)

libcxx/include/filesystem

 */
 
 #include <__config>
 #include <cstddef>
 #include <cstdlib>
 #include <chrono>
 #include <iterator>
 #include <iosfwd>
-#include <locale>
 #include <memory>
 #include <stack>
 #include <string>
 #include <system_error>
 #include <utility>
-#include <iomanip> // for quoted
 #include <string_view>
 #include <version>
 
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+# include <locale>
+# include <iomanip> // for quoted
+#endif
+
 #include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

 template <class _Tp>
 struct __is_pathable<_Tp, false, true, false> : __is_pathable_char_array<_Tp> {
 };
 
 template <class _Tp>
 struct __is_pathable<_Tp, false, false, true> : __is_pathable_iter<_Tp> {};
 
 template <class _ECharT>
+struct _PathCVT;
+
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+template <class _ECharT>
 struct _PathCVT {
   static_assert(__can_convert_char<_ECharT>::value,
                 "Char type not convertible");
 
   typedef __narrow_to_utf8<sizeof(_ECharT) * __CHAR_BIT__> _Narrower;
 
   static void __append_range(string& __dest, _ECharT const* __b,
                              _ECharT const* __e) {
struct _PathCVT {
 
   template <class _Source>
   static void __append_source(string& __dest, _Source const& __s) {
     using _Traits = __is_pathable<_Source>;
     __append_range(__dest, _Traits::__range_begin(__s),
                    _Traits::__range_end(__s));
   }
 };
+#endif // !_LIBCPP_HAS_NO_LOCALIZATION
 
 template <>
 struct _PathCVT<char> {
 
   template <class _Iter>
   static typename enable_if<__is_exactly_cpp17_input_iterator<_Iter>::value>::type
   __append_range(string& __dest, _Iter __b, _Iter __e) {
     for (; __b != __e; ++__b)
public:
   }
 
   template <class _InputIt>
   path(_InputIt __first, _InputIt __last, format = format::auto_format) {
     typedef typename iterator_traits<_InputIt>::value_type _ItVal;
     _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
   }
 
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
   // TODO Implement locale conversions.
   template <class _Source, class = _EnableIfPathable<_Source, void> >
   path(const _Source& __src, const locale& __loc, format = format::auto_format);
   template <class _InputIt>
   path(_InputIt __first, _InputIt _last, const locale& __loc,
        format = format::auto_format);
+#endif
 
   _LIBCPP_INLINE_VISIBILITY
   ~path() = default;
 
   // assignments
   _LIBCPP_INLINE_VISIBILITY
   path& operator=(const path& __p) {
     __pn_ = __p.__pn_;
public:
   _LIBCPP_INLINE_VISIBILITY
   const string_type& native() const noexcept { return __pn_; }
 
   _LIBCPP_INLINE_VISIBILITY
   const value_type* c_str() const noexcept { return __pn_.c_str(); }
 
   _LIBCPP_INLINE_VISIBILITY operator string_type() const { return __pn_; }
 
+  _LIBCPP_INLINE_VISIBILITY std::string string() const { return __pn_; }
+  _LIBCPP_INLINE_VISIBILITY std::string u8string() const { return __pn_; }
+
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
   template <class _ECharT, class _Traits = char_traits<_ECharT>,
             class _Allocator = allocator<_ECharT> >
   basic_string<_ECharT, _Traits, _Allocator>
   string(const _Allocator& __a = _Allocator()) const {
     using _CVT = __widen_from_utf8<sizeof(_ECharT) * __CHAR_BIT__>;
     using _Str = basic_string<_ECharT, _Traits, _Allocator>;
     _Str __s(__a);
     __s.reserve(__pn_.size());
     _CVT()(back_inserter(__s), __pn_.data(), __pn_.data() + __pn_.size());
     return __s;
   }
 
-  _LIBCPP_INLINE_VISIBILITY std::string string() const { return __pn_; }
   _LIBCPP_INLINE_VISIBILITY std::wstring wstring() const {
     return string<wchar_t>();
   }
-  _LIBCPP_INLINE_VISIBILITY std::string u8string() const { return __pn_; }
   _LIBCPP_INLINE_VISIBILITY std::u16string u16string() const {
     return string<char16_t>();
   }
   _LIBCPP_INLINE_VISIBILITY std::u32string u32string() const {
     return string<char32_t>();
   }
+#endif
 
   // generic format observers
+  std::string generic_string() const { return __pn_; }
+  std::string generic_u8string() const { return __pn_; }
+
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
   template <class _ECharT, class _Traits = char_traits<_ECharT>,
             class _Allocator = allocator<_ECharT> >
   basic_string<_ECharT, _Traits, _Allocator>
   generic_string(const _Allocator& __a = _Allocator()) const {
     return string<_ECharT, _Traits, _Allocator>(__a);
   }
 
-  std::string generic_string() const { return __pn_; }
   std::wstring generic_wstring() const { return string<wchar_t>(); }
-  std::string generic_u8string() const { return __pn_; }
   std::u16string generic_u16string() const { return string<char16_t>(); }
   std::u32string generic_u32string() const { return string<char32_t>(); }
+#endif
 
 private:
   int __compare(__string_view) const;
   __string_view __root_name() const;
   __string_view __root_directory() const;
   __string_view __root_path_raw() const;
   __string_view __relative_path() const;
   __string_view __parent_path() const;
public:
 
   // iterators
   class _LIBCPP_TYPE_VIS iterator;
   typedef iterator const_iterator;
 
   iterator begin() const;
   iterator end() const;
 
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
   template <class _CharT, class _Traits>
   _LIBCPP_INLINE_VISIBILITY friend
       typename enable_if<is_same<_CharT, char>::value &&
                              is_same<_Traits, char_traits<char> >::value,
                          basic_ostream<_CharT, _Traits>&>::type
       operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
     __os << std::__quoted(__p.native());
     return __os;
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
   template <class _CharT, class _Traits>
   _LIBCPP_INLINE_VISIBILITY friend basic_istream<_CharT, _Traits>&
   operator>>(basic_istream<_CharT, _Traits>& __is, path& __p) {
     basic_string<_CharT, _Traits> __tmp;
     __is >> __quoted(__tmp);
     __p = __tmp;
     return __is;
   }
+#endif // !_LIBCPP_HAS_NO_LOCALIZATION
 
   friend _LIBCPP_INLINE_VISIBILITY bool operator==(const path& __lhs, const path& __rhs) noexcept {
     return __lhs.compare(__rhs) == 0;
   }
   friend _LIBCPP_INLINE_VISIBILITY bool operator!=(const path& __lhs, const path& __rhs) noexcept {
     return __lhs.compare(__rhs) != 0;
   }
   friend _LIBCPP_INLINE_VISIBILITY bool operator<(const path& __lhs, const path& __rhs) noexcept {

libcxx/src/CMakeLists.txt

set(LIBCXX_SOURCES
   exception.cpp
   functional.cpp
   future.cpp
   hash.cpp
   include/apple_availability.h
   include/atomic_support.h
   include/config_elast.h
   include/refstring.h
-  ios.cpp
-  iostream.cpp
-  locale.cpp
   memory.cpp
   mutex.cpp
   mutex_destructor.cpp
   new.cpp
   optional.cpp
   random_shuffle.cpp
-  regex.cpp
   shared_mutex.cpp
   stdexcept.cpp
   string.cpp
-  strstream.cpp
   support/runtime/exception_fallback.ipp
   support/runtime/exception_glibcxx.ipp
   support/runtime/exception_libcxxabi.ipp
   support/runtime/exception_libcxxrt.ipp
   support/runtime/exception_msvc.ipp
   support/runtime/exception_pointer_cxxabi.ipp
   support/runtime/exception_pointer_glibcxx.ipp
   support/runtime/exception_pointer_msvc.ipp

 endif()
 
 if (LIBCXX_ENABLE_RANDOM_DEVICE)
   list(APPEND LIBCXX_SOURCES
     random.cpp
     )
 endif()
 
+if (LIBCXX_ENABLE_LOCALIZATION)
+  list(APPEND LIBCXX_SOURCES
+    ios.cpp
+    iostream.cpp
+    locale.cpp
+    regex.cpp
+    strstream.cpp
+    )
+endif()
+
 if(WIN32)
   list(APPEND LIBCXX_SOURCES
     support/win32/locale_win32.cpp
     support/win32/support.cpp
     support/win32/thread_win32.cpp
     )
 elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "SunOS")
   list(APPEND LIBCXX_SOURCES

libcxx/test/libcxx/depr/depr.str.strstreams/version.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <strstream>
 
 #include <strstream>
 
 #include "test_macros.h"
 
 #ifndef _LIBCPP_VERSION
 #error _LIBCPP_VERSION not defined
 #endif
 
 int main(int, char**)
 {
 
   return 0;
 }

libcxx/test/libcxx/double_include.sh.cpp

 #include <cfloat>
 #include <charconv>
 #include <chrono>
 #include <cinttypes>
 #include <ciso646>
 #include <climits>
 #include <clocale>
 #include <cmath>
-#include <codecvt>
 #include <compare>
 #include <complex>
 #include <complex.h>
 #include <concepts>
 #include <condition_variable>
 #include <csetjmp>
 #include <csignal>
 #include <cstdarg>

 #include <deque>
 #include <errno.h>
 #include <exception>
 #include <execution>
 #include <fenv.h>
 #include <filesystem>
 #include <float.h>
 #include <forward_list>
-#include <fstream>
 #include <functional>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <future>
 #endif
 #include <initializer_list>
 #include <inttypes.h>
-#include <iomanip>
-#include <ios>
 #include <iosfwd>
-#include <iostream>
-#include <istream>
 #include <iterator>
 #include <limits>
 #include <limits.h>
 #include <list>
-#include <locale>
 #include <locale.h>
 #include <map>
 #include <math.h>
 #include <memory>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <mutex>
 #endif
 #include <new>
 #include <numbers>
 #include <numeric>
 #include <optional>
-#include <ostream>
 #include <queue>
 #include <random>
 #include <ratio>
-#include <regex>
 #include <scoped_allocator>
 #include <set>
 #include <setjmp.h>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <shared_mutex>
 #endif
 #include <span>
-#include <sstream>
 #include <stack>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdexcept>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <streambuf>
 #include <string>
 #include <string.h>
 #include <string_view>
-#include <strstream>
 #include <system_error>
 #include <tgmath.h>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <thread>
 #endif
 #include <tuple>
 #include <typeindex>
 #include <typeinfo>
 #include <type_traits>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
 #include <valarray>
 #include <variant>
 #include <vector>
 #include <version>
 #include <wchar.h>
 #include <wctype.h>
 
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#   include <codecvt>
+#   include <fstream>
+#   include <iomanip>
+#   include <ios>
+#   include <iostream>
+#   include <istream>
+#   include <locale>
+#   include <ostream>
+#   include <regex>
+#   include <sstream>
+#   include <streambuf>
+#   include <strstream>
+#   if __cplusplus >= 201103L
+#       include <experimental/regex>
+#   endif
+#endif
+
 // experimental headers
 #if __cplusplus >= 201103L
 #include <experimental/algorithm>
 #if defined(__cpp_coroutines)
 #include <experimental/coroutine>
 #endif
 #include <experimental/deque>
 #include <experimental/filesystem>
 #include <experimental/forward_list>
 #include <experimental/functional>
 #include <experimental/iterator>
 #include <experimental/list>
 #include <experimental/map>
 #include <experimental/memory_resource>
 #include <experimental/propagate_const>
-#include <experimental/regex>
 #include <experimental/simd>
 #include <experimental/set>
 #include <experimental/string>
 #include <experimental/type_traits>
 #include <experimental/unordered_map>
 #include <experimental/unordered_set>
 #include <experimental/utility>
 #include <experimental/vector>

libcxx/test/libcxx/experimental/memory/memory.resource.aliases/header_regex_libcpp_version.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: libcpp-has-no-localization
 
 // <experimental/regex>
 
 #include <experimental/regex>
 
 #include "test_macros.h"
 
 #ifndef _LIBCPP_VERSION
 #error header must provide _LIBCPP_VERSION
 #endif
 
 int main(int, char**)
 {
 
   return 0;
 }

libcxx/test/libcxx/fuzzing/regex.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 // UNSUPPORTED: no-exceptions
+// UNSUPPORTED: libcpp-has-no-localization
 
 #include <cstddef>
 #include <cstdint>
 #include <regex>
 #include <string>
 
 #include "fuzz.h"
 

libcxx/test/libcxx/input.output/file.streams/lit.local.cfg

+# Load the same local configuration as the corresponding one in libcxx/test/std
+import os
+localConfig = os.path.realpath(__file__).replace('/test/libcxx/', '/test/std/')
+config.load_from_path(localConfig, lit_config)

libcxx/test/libcxx/input.output/iostream.format/lit.local.cfg

+# Load the same local configuration as the corresponding one in libcxx/test/std
+import os
+localConfig = os.path.realpath(__file__).replace('/test/libcxx/', '/test/std/')
+config.load_from_path(localConfig, lit_config)

libcxx/test/libcxx/input.output/iostream.objects/lit.local.cfg

+# Load the same local configuration as the corresponding one in libcxx/test/std
+import os
+localConfig = os.path.realpath(__file__).replace('/test/libcxx/', '/test/std/')
+config.load_from_path(localConfig, lit_config)

libcxx/test/libcxx/input.output/iostreams.base/lit.local.cfg

+# Load the same local configuration as the corresponding one in libcxx/test/std
+import os
+localConfig = os.path.realpath(__file__).replace('/test/libcxx/', '/test/std/')
+config.load_from_path(localConfig, lit_config)

libcxx/test/libcxx/input.output/stream.buffers/lit.local.cfg

+# Load the same local configuration as the corresponding one in libcxx/test/std
+import os
+localConfig = os.path.realpath(__file__).replace('/test/libcxx/', '/test/std/')
+config.load_from_path(localConfig, lit_config)

libcxx/test/libcxx/input.output/string.streams/lit.local.cfg

+# Load the same local configuration as the corresponding one in libcxx/test/std
+import os
+localConfig = os.path.realpath(__file__).replace('/test/libcxx/', '/test/std/')
+config.load_from_path(localConfig, lit_config)

libcxx/test/libcxx/localization/lit.local.cfg

+# Load the same local configuration as the corresponding one in libcxx/test/std
+import os
+localConfig = os.path.realpath(__file__).replace('/test/libcxx/', '/test/std/')
+config.load_from_path(localConfig, lit_config)

libcxx/test/libcxx/min_max_macros.compile.pass.cpp

 #include <ciso646>
 TEST_MACROS();
 #include <climits>
 TEST_MACROS();
 #include <clocale>
 TEST_MACROS();
 #include <cmath>
 TEST_MACROS();
-#include <codecvt>
-TEST_MACROS();
 #include <complex>
 TEST_MACROS();
 #include <complex.h>
 TEST_MACROS();
 #include <condition_variable>
 TEST_MACROS();
 #include <csetjmp>
 TEST_MACROS();

 #include <exception>
 TEST_MACROS();
 #include <filesystem>
 TEST_MACROS();
 #include <float.h>
 TEST_MACROS();
 #include <forward_list>
 TEST_MACROS();
-#include <fstream>
-TEST_MACROS();
 #include <functional>
 TEST_MACROS();
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <future>
 TEST_MACROS();
 #endif
 #include <initializer_list>
 TEST_MACROS();
 #include <inttypes.h>
 TEST_MACROS();
-#include <iomanip>
-TEST_MACROS();
-#include <ios>
-TEST_MACROS();
 #include <iosfwd>
 TEST_MACROS();
-#include <iostream>
-TEST_MACROS();
-#include <istream>
-TEST_MACROS();
 #include <iterator>
 TEST_MACROS();
 #include <limits>
 TEST_MACROS();
 #include <limits.h>
 TEST_MACROS();
 #include <list>
 TEST_MACROS();
-#include <locale>
-TEST_MACROS();
 #include <locale.h>
 TEST_MACROS();
 #include <map>
 TEST_MACROS();
 #include <math.h>
 TEST_MACROS();
 #include <memory>
 TEST_MACROS();
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <mutex>
 TEST_MACROS();
 #endif
 #include <new>
 TEST_MACROS();
 #include <numeric>
 TEST_MACROS();
 #include <optional>
 TEST_MACROS();
-#include <ostream>
-TEST_MACROS();
 #include <queue>
 TEST_MACROS();
 #include <random>
 TEST_MACROS();
 #include <ratio>
 TEST_MACROS();
-#include <regex>
-TEST_MACROS();
 #include <scoped_allocator>
 TEST_MACROS();
 #include <set>
 TEST_MACROS();
 #include <setjmp.h>
 TEST_MACROS();
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <shared_mutex>
 TEST_MACROS();
 #endif
 #include <span>
 TEST_MACROS();
-#include <sstream>
-TEST_MACROS();
 #include <stack>
 TEST_MACROS();
 #include <stdbool.h>
 TEST_MACROS();
 #include <stddef.h>
 TEST_MACROS();
 #include <stdexcept>
 TEST_MACROS();
 #include <stdint.h>
 TEST_MACROS();
 #include <stdio.h>
 TEST_MACROS();
 #include <stdlib.h>
 TEST_MACROS();
-#include <streambuf>
-TEST_MACROS();
 #include <string>
 TEST_MACROS();
 #include <string.h>
 TEST_MACROS();
 #include <string_view>
 TEST_MACROS();
-#include <strstream>
-TEST_MACROS();
 #include <system_error>
 TEST_MACROS();
 #include <tgmath.h>
 TEST_MACROS();
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <thread>
 TEST_MACROS();
 #endif

 TEST_MACROS();
 #include <vector>
 TEST_MACROS();
 #include <wchar.h>
 TEST_MACROS();
 #include <wctype.h>
 TEST_MACROS();
 
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#   include <codecvt>
+    TEST_MACROS();
+#   include <fstream>
+    TEST_MACROS();
+#   include <iomanip>
+    TEST_MACROS();
+#   include <ios>
+    TEST_MACROS();
+#   include <iostream>
+    TEST_MACROS();
+#   include <istream>
+    TEST_MACROS();
+#   include <locale>
+    TEST_MACROS();
+#   include <ostream>
+    TEST_MACROS();
+#   include <regex>
+    TEST_MACROS();
+#   include <sstream>
+    TEST_MACROS();
+#   include <streambuf>
+    TEST_MACROS();
+#   include <strstream>
+    TEST_MACROS();
+#   if __cplusplus >= 201103L
+#       include <experimental/regex>
+        TEST_MACROS();
+#   endif
+#endif
+
 // experimental headers
 #if __cplusplus >= 201103L
 #include <experimental/algorithm>
 TEST_MACROS();
 #include <experimental/deque>
 TEST_MACROS();
 #include <experimental/filesystem>
 TEST_MACROS();
 #include <experimental/forward_list>
 TEST_MACROS();
 #include <experimental/functional>
 TEST_MACROS();
 #include <experimental/iterator>
 TEST_MACROS();
 #include <experimental/list>
 TEST_MACROS();
 #include <experimental/map>
 TEST_MACROS();
 #include <experimental/memory_resource>
 TEST_MACROS();
 #include <experimental/propagate_const>
 TEST_MACROS();
-#include <experimental/regex>
-TEST_MACROS();
 #include <experimental/set>
 TEST_MACROS();
 #include <experimental/string>
 TEST_MACROS();
 #include <experimental/type_traits>
 TEST_MACROS();
 #include <experimental/unordered_map>
 TEST_MACROS();

libcxx/test/libcxx/modules/cinttypes_exports.compile.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
 //
 //===----------------------------------------------------------------------===//
 
 // This test fails on Windows because the underlying libc headers on Windows
 // are not modular
 // XFAIL: LIBCXX-WINDOWS-FIXME
 
-// FIXME: The <atomic> header is not supported for single-threaded systems,
-// but still gets built as part of the 'std' module, which breaks the build.
-// XFAIL: libcpp-has-no-threads
+// Some headers are not available when these features are disabled, but they
+// still get built as part of the 'std' module, which breaks the build.
+// UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: libcpp-has-no-localization
 
 // REQUIRES: modules-support
 // ADDITIONAL_COMPILE_FLAGS: -fmodules
 
 // Test that <cinttypes> re-exports <cstdint>
 
 #include <cinttypes>
 
 int main(int, char**) {
   int8_t x; (void)x;
   std::int8_t y; (void)y;
 
   return 0;
 }

libcxx/test/libcxx/modules/clocale_exports.compile.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
 //
 //===----------------------------------------------------------------------===//
 
 // This test fails on Windows because the underlying libc headers on Windows
 // are not modular
 // XFAIL: LIBCXX-WINDOWS-FIXME
 
-// FIXME: The <atomic> header is not supported for single-threaded systems,
-// but still gets built as part of the 'std' module, which breaks the build.
-// XFAIL: libcpp-has-no-threads
+// Some headers are not available when these features are disabled, but they
+// still get built as part of the 'std' module, which breaks the build.
+// UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: libcpp-has-no-localization
 
 // UNSUPPORTED: c++03
 
 // REQUIRES: modules-support
 // ADDITIONAL_COMPILE_FLAGS: -fmodules
 
 #include <clocale>
 
 int main(int, char**) {
   std::lconv l; (void)l;
   using T = decltype(std::setlocale(0, ""));
   using U = decltype(std::localeconv());
 
   return 0;
 }

libcxx/test/libcxx/modules/cstdint_exports.compile.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
 //
 //===----------------------------------------------------------------------===//
 
 // This test fails on Windows because the underlying libc headers on Windows
 // are not modular
 // XFAIL: LIBCXX-WINDOWS-FIXME
 
-// FIXME: The <atomic> header is not supported for single-threaded systems,
-// but still gets built as part of the 'std' module, which breaks the build.
-// XFAIL: libcpp-has-no-threads
+// Some headers are not available when these features are disabled, but they
+// still get built as part of the 'std' module, which breaks the build.
+// UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: libcpp-has-no-localization
 
 // Test that <cstdint> re-exports <stdint.h>
 
 // REQUIRES: modules-support
 // ADDITIONAL_COMPILE_FLAGS: -fmodules
 
 #include <cstdint>
 
 int main(int, char**) {
   int8_t x; (void)x;
   std::int8_t y; (void)y;
 
   return 0;
 }

libcxx/test/libcxx/modules/inttypes_h_exports.compile.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
 //
 //===----------------------------------------------------------------------===//
 
 // This test fails on Windows because the underlying libc headers on Windows
 // are not modular
 // XFAIL: LIBCXX-WINDOWS-FIXME
 
-// FIXME: The <atomic> header is not supported for single-threaded systems,
-// but still gets built as part of the 'std' module, which breaks the build.
-// XFAIL: libcpp-has-no-threads
+// Some headers are not available when these features are disabled, but they
+// still get built as part of the 'std' module, which breaks the build.
+// UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: libcpp-has-no-localization
 
 // Test that intypes.h re-exports stdint.h
 
 // REQUIRES: modules-support
 // ADDITIONAL_COMPILE_FLAGS: -fmodules
 
 #include <inttypes.h>
 
 int main(int, char**) {
   int8_t x; (void)x;
 
   return 0;
 }

libcxx/test/libcxx/modules/stdint_h_exports.compile.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
 //
 //===----------------------------------------------------------------------===//
 
-// FIXME: The <atomic> header is not supported for single-threaded systems,
-// but still gets built as part of the 'std' module, which breaks the build.
-// XFAIL: libcpp-has-no-threads
+// Some headers are not available when these features are disabled, but they
+// still get built as part of the 'std' module, which breaks the build.
+// UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: libcpp-has-no-localization
 
 // Test that int8_t and the like are exported from stdint.h, not inttypes.h
 
 // REQUIRES: modules-support
 // ADDITIONAL_COMPILE_FLAGS: -fmodules
 
 #include <stdint.h>
 
 int main(int, char**) {
   int8_t x; (void)x;
 
   return 0;
 }

libcxx/test/libcxx/modules/stds_include.sh.cpp

 // enabled in various Standard modes. This is a common source of breakage
 // since the 'std' module will include all headers, so if something in a
 // header fails under a standard mode, importing anything will fail.
 
 // This test fails on Windows because the underlying libc headers on Windows
 // are not modular
 // XFAIL: LIBCXX-WINDOWS-FIXME
 
-// FIXME: The <atomic> header is not supported for single-threaded systems,
-// but still gets built as part of the 'std' module, which breaks the build.
-// XFAIL: libcpp-has-no-threads
+// Some headers are not available when these features are disabled, but they
+// still get built as part of the 'std' module, which breaks the build.
+// UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: libcpp-has-no-localization
 
 // REQUIRES: modules-support
 
 // NOTE: The -std=XXX flag is present in %{flags}, so we overwrite it by passing it after %{flags}.
 // FIXME: Remove the `-DINVALIDATE_CACHE_FOO` macros. Their purpose is to workaround a bug in older Clang versions
 //        the same modules caches were reused across standard dialects.
 // RUN: %{cxx} %{flags} %{compile_flags} -fmodules -fcxx-modules -fsyntax-only -std=c++03 -DINVALIDATE_CACHE_CXX03 %s
 // RUN: %{cxx} %{flags} %{compile_flags} -fmodules -fcxx-modules -fsyntax-only -std=c++11 -DINVALIDATE_CACHE_CXX11 %s

libcxx/test/libcxx/no_assert_include.compile.pass.cpp

 #include <cfloat>
 #include <charconv>
 #include <chrono>
 #include <cinttypes>
 #include <ciso646>
 #include <climits>
 #include <clocale>
 #include <cmath>
-#include <codecvt>
 #include <compare>
 #include <complex>
 #include <complex.h>
 #include <condition_variable>
 #include <csetjmp>
 #include <csignal>
 #include <cstdarg>
 #include <cstdbool>

 #include <deque>
 #include <errno.h>
 #include <exception>
 #include <execution>
 #include <fenv.h>
 #include <filesystem>
 #include <float.h>
 #include <forward_list>
-#include <fstream>
 #include <functional>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <future>
 #endif
 #include <initializer_list>
 #include <inttypes.h>
-#include <iomanip>
-#include <ios>
 #include <iosfwd>
-#include <iostream>
-#include <istream>
 #include <iterator>
 #include <limits>
 #include <limits.h>
 #include <list>
-#include <locale>
 #include <locale.h>
 #include <map>
 #include <math.h>
 #include <memory>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <mutex>
 #endif
 #include <new>
 #include <numeric>
 #include <optional>
-#include <ostream>
 #include <queue>
 #include <random>
 #include <ratio>
-#include <regex>
 #include <scoped_allocator>
 #include <set>
 #include <setjmp.h>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <shared_mutex>
 #endif
 #include <span>
-#include <sstream>
 #include <stack>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdexcept>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <streambuf>
 #include <string>
 #include <string.h>
 #include <string_view>
-#include <strstream>
 #include <system_error>
 #include <tgmath.h>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <thread>
 #endif
 #include <tuple>
 #include <typeindex>
 #include <typeinfo>
 #include <type_traits>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
 #include <valarray>
 #include <variant>
 #include <vector>
 #include <version>
 #include <wchar.h>
 #include <wctype.h>
 
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#   include <codecvt>
+#   include <fstream>
+#   include <iomanip>
+#   include <ios>
+#   include <iostream>
+#   include <istream>
+#   include <locale>
+#   include <ostream>
+#   include <regex>
+#   include <sstream>
+#   include <streambuf>
+#   include <strstream>
+#   if __cplusplus >= 201103L
+#       include <experimental/regex>
+#   endif
+#endif
+
 // experimental headers
 #if __cplusplus >= 201103L
 #include <experimental/algorithm>
 #if defined(__cpp_coroutines)
 #include <experimental/coroutine>
 #endif
 #include <experimental/deque>
 #include <experimental/filesystem>
 #include <experimental/forward_list>
 #include <experimental/functional>
 #include <experimental/iterator>
 #include <experimental/list>
 #include <experimental/map>
 #include <experimental/memory_resource>
 #include <experimental/propagate_const>
-#include <experimental/regex>
 #include <experimental/simd>
 #include <experimental/set>
 #include <experimental/string>
 #include <experimental/type_traits>
 #include <experimental/unordered_map>
 #include <experimental/unordered_set>
 #include <experimental/utility>
 #include <experimental/vector>

libcxx/test/std/depr/depr.ios.members/lit.local.cfg

+if 'libcpp-has-no-localization' in config.available_features:
+  config.unsupported = True

libcxx/test/std/depr/depr.str.strstreams/lit.local.cfg

+if 'libcpp-has-no-localization' in config.available_features:
+  config.unsupported = True

libcxx/test/std/diagnostics/syserr/syserr.errcode/syserr.errcode.nonmembers/stream_inserter.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <system_error>
 
 // class error_code
 
 // template <class charT, class traits>
 //   basic_ostream<charT,traits>&
 //   operator<<(basic_ostream<charT,traits>& os, const error_code& ec);
 

libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.cons/ostream_joiner.cons.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: libcpp-has-no-localization
 
 // <experimental/iterator>
 //
 // template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
 //   class ostream_joiner;
 //
 //     ostream_joiner(ostream_type& __os, _Delim&& __d);
 //     ostream_joiner(ostream_type& __os, const _Delim& __d);

libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.creation/make_ostream_joiner.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: libcpp-has-no-localization
 
 // <experimental/iterator>
 //
 // template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
 //   class ostream_joiner;
 //
 //   template <class _CharT, class _Traits, class _Delim>
 //   ostream_joiner<typename decay<_Delim>::type, _CharT, _Traits>

libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: libcpp-has-no-localization
 
 // <experimental/iterator>
 //
 // template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
 //   class ostream_joiner;
 //
 //   template<typename T>
 //   ostream_joiner & operator=(const T&)

libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.postincrement.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: libcpp-has-no-localization
 
 // <experimental/iterator>
 //
 // template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
 //   class ostream_joiner;
 //
 //   ostream_joiner & operator++(int) noexcept
 //     returns *this;

libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.pretincrement.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: libcpp-has-no-localization
 
 // <experimental/iterator>
 //
 // template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
 //   class ostream_joiner;
 //
 //   ostream_joiner & operator++() noexcept
 //     returns *this;

libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.star.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: libcpp-has-no-localization
 
 // <experimental/iterator>
 //
 // template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
 //   class ostream_joiner;
 //
 //   ostream_joiner & operator*() noexcept
 //     returns *this;

libcxx/test/std/experimental/memory/memory.resource.aliases/header_regex_synop.pass.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: libcpp-has-no-localization
 
 // <experimental/regex>
 
 // namespace std { namespace experimental { namespace pmr {
 //
 //  template <class BidirectionalIterator>
 //  using match_results =
 //    std::match_results<BidirectionalIterator,

libcxx/test/std/input.output/file.streams/lit.local.cfg

+# All non-trivial uses of iostreams require localization support
+if 'libcpp-has-no-localization' in config.available_features:
+  config.unsupported = True

libcxx/test/std/input.output/filesystems/class.path/path.member/path.append.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
+// These tests require locale for non-char paths
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <filesystem>
 
 // class path
 
 // path& operator/=(path const&)
 // template <class Source>
 //      path& operator/=(Source const&);
 // template <class Source>

libcxx/test/std/input.output/filesystems/class.path/path.member/path.assign/source.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
+// These tests require locale for non-char paths
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <filesystem>
 
 // class path
 
 // template <class Source>
 //      path& operator=(Source const&);
 //  path& operator=(string_type&&);
 // template <class Source>

libcxx/test/std/input.output/filesystems/class.path/path.member/path.concat.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
+// These tests require locale for non-char paths
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <filesystem>
 
 // class path
 
 // path& operator+=(const path& x);
 // path& operator+=(const string_type& x);
 // path& operator+=(string_view x);
 // path& operator+=(const value_type* x);

libcxx/test/std/input.output/filesystems/class.path/path.member/path.construct/source.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
+// These tests require locale for non-char paths
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <filesystem>
 
 // class path
 
 // template <class Source>
 //      path(const Source& source);
 // template <class InputIterator>
 //      path(InputIterator first, InputIterator last);

libcxx/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/generic_string_alloc.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
+// These tests require locale for non-char paths
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <filesystem>
 
 // class path
 
 // template <class ECharT, class Traits = char_traits<ECharT>,
 //           class Allocator = allocator<ECharT>>
 // basic_string<ECharT, Traits, Allocator>
 // generic_string(const Allocator& a = Allocator()) const;

libcxx/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/named_overloads.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
+// These tests require locale for non-char paths
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <filesystem>
 
 // class path
 
 // std::string  generic_string() const;
 // std::wstring generic_wstring() const;
 // std::u8string  generic_u8string() const;
 // std::u16string generic_u16string() const;

libcxx/test/std/input.output/filesystems/class.path/path.member/path.native.obs/named_overloads.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
+// These tests require locale for non-char paths
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <filesystem>
 
 // class path
 
 // std::string  string() const;
 // std::wstring wstring() const;
 // std::u8string  u8string() const;
 // std::u16string u16string() const;

libcxx/test/std/input.output/filesystems/class.path/path.member/path.native.obs/string_alloc.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 // REQUIRES: libc++
 
+// These tests require locale for non-char paths
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <filesystem>
 
 // class path
 
 // template <class ECharT, class Traits = char_traits<ECharT>,
 //           class Allocator = allocator<ECharT>>
 // basic_string<ECharT, Traits, Allocator>
 // string(const Allocator& a = Allocator()) const;

libcxx/test/std/input.output/filesystems/class.path/path.nonmember/path.io.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: libcpp-has-no-localization
 
 // <filesystem>
 
 // class path
 
 // template <class charT, class traits>
 // basic_ostream<charT, traits>&
 // operator<<(basic_ostream<charT, traits>& os, const path& p);

libcxx/test/std/input.output/input.output.general/lit.local.cfg

+# All non-trivial uses of iostreams require localization support
+if 'libcpp-has-no-localization' in config.available_features:
+  config.unsupported = True

libcxx/test/std/input.output/iostream.format/lit.local.cfg

+# All non-trivial uses of iostreams require localization support
+if 'libcpp-has-no-localization' in config.available_features:
+  config.unsupported = True

libcxx/test/std/input.output/iostream.forward/lit.local.cfg

+# All non-trivial uses of iostreams require localization support
+if 'libcpp-has-no-localization' in config.available_features:
+  config.unsupported = True

libcxx/test/std/input.output/iostream.objects/lit.local.cfg

+# All non-trivial uses of iostreams require localization support
+if 'libcpp-has-no-localization' in config.available_features:
+  config.unsupported = True

libcxx/test/std/input.output/iostreams.base/lit.local.cfg

+# All non-trivial uses of iostreams require localization support
+if 'libcpp-has-no-localization' in config.available_features:
+  config.unsupported = True

libcxx/test/std/input.output/iostreams.requirements/lit.local.cfg

+# All non-trivial uses of iostreams require localization support
+if 'libcpp-has-no-localization' in config.available_features:
+  config.unsupported = True

libcxx/test/std/input.output/stream.buffers/lit.local.cfg

+# All non-trivial uses of iostreams require localization support
+if 'libcpp-has-no-localization' in config.available_features:
+  config.unsupported = True

libcxx/test/std/input.output/string.streams/lit.local.cfg

+# All non-trivial uses of iostreams require localization support
+if 'libcpp-has-no-localization' in config.available_features:
+  config.unsupported = True

libcxx/test/std/iterators/stream.iterators/lit.local.cfg

+# stream iterators rely on the streams library, which requires localization
+if 'libcpp-has-no-localization' in config.available_features:
+  config.unsupported = True

libcxx/test/std/language.support/support.limits/support.limits.general/iomanip.version.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
 //
 //===----------------------------------------------------------------------===//
 //
 // WARNING: This test was generated by generate_feature_test_macro_components.py
 // and should not be edited manually.
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <iomanip>
 
 // Test the feature test macros defined by <iomanip>
 
 /*  Constant                      Value
     __cpp_lib_quoted_string_io    201304L [C++14]
 */
 

libcxx/test/std/language.support/support.limits/support.limits.general/istream.version.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
 //
 //===----------------------------------------------------------------------===//
 //
 // WARNING: This test was generated by generate_feature_test_macro_components.py
 // and should not be edited manually.
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <istream>
 
 // Test the feature test macros defined by <istream>
 
 /*  Constant             Value
     __cpp_lib_char8_t    201811L [C++2a]
 */
 

libcxx/test/std/language.support/support.limits/support.limits.general/locale.version.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
 //
 //===----------------------------------------------------------------------===//
 //
 // WARNING: This test was generated by generate_feature_test_macro_components.py
 // and should not be edited manually.
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <locale>
 
 // Test the feature test macros defined by <locale>
 
 /*  Constant             Value
     __cpp_lib_char8_t    201811L [C++2a]
 */
 

libcxx/test/std/language.support/support.limits/support.limits.general/ostream.version.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
 //
 //===----------------------------------------------------------------------===//
 //
 // WARNING: This test was generated by generate_feature_test_macro_components.py
 // and should not be edited manually.
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <ostream>
 
 // Test the feature test macros defined by <ostream>
 
 /*  Constant             Value
     __cpp_lib_char8_t    201811L [C++2a]
 */
 

libcxx/test/std/language.support/support.limits/support.limits.general/regex.version.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
 //
 //===----------------------------------------------------------------------===//
 //
 // WARNING: This test was generated by generate_feature_test_macro_components.py
 // and should not be edited manually.
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <regex>
 
 // Test the feature test macros defined by <regex>
 
 /*  Constant                                Value
     __cpp_lib_nonmember_container_access    201411L [C++17]
 */
 

libcxx/test/std/localization/lit.local.cfg

+# <locale> tests are obviously not supported when localization support is disabled
+if 'libcpp-has-no-localization' in config.available_features:
+  config.unsupported = True

libcxx/test/std/namespace/addressable_functions.sh.cpp

 // in C++20, we test it in all standard modes because it's basic QOI to provide
 // a consistent behavior for that across standard modes.
 
 // RUN: %{cxx} %{flags} %{compile_flags} -c %s -o %t.tu1.o -DTU1
 // RUN: %{cxx} %{flags} %{compile_flags} -c %s -o %t.tu2.o -DTU2
 // RUN: %{cxx} %t.tu1.o %t.tu2.o %{flags} %{link_flags} -o %t.exe
 // RUN: %{exec} %t.exe
 
+// The functions checked below come from <iostream> & friends
+// UNSUPPORTED: libcpp-has-no-localization
+
 #include <cassert>
 #include <ios>
 #include <istream>
 #include <map>
 #include <ostream>
 #include <string>
 #include <utility>
 

libcxx/test/std/numerics/complex.number/complex.ops/stream_input.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <complex>
 
 // template<class T, class charT, class traits>
 //   basic_istream<charT, traits>&
 //   operator>>(basic_istream<charT, traits>& is, complex<T>& x);
 
 #include <complex>
 #include <sstream>

libcxx/test/std/numerics/complex.number/complex.ops/stream_output.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <complex>
 
 // template<class T, class charT, class traits>
 //   basic_ostream<charT, traits>&
 //   operator<<(basic_ostream<charT, traits>& o, const complex<T>& x);
 
 #include <complex>
 #include <sstream>

libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_result_type.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
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class Engine, size_t p, size_t r>
 // class discard_block_engine
 
 // explicit discard_block_engine(result_type s = default_seed);
 
+// Serializing/deserializing the state of the RNG requires iostreams
+// UNSUPPORTED: libcpp-has-no-localization
+
 #include <random>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
 void
 test1()

libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.disc/ctor_sseq.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
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class Engine, size_t p, size_t r>
 // class discard_block_engine
 
 // template<class Sseq> explicit discard_block_engine(Sseq& q);
 
+// Serializing/deserializing the state of the RNG requires iostreams
+// UNSUPPORTED: libcpp-has-no-localization
+
 #include <random>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
 void
 test1()

libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.disc/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class Engine, size_t p, size_t r>
 // class discard_block_engine
 
 // template <class charT, class traits,
 //           class Engine, size_t p, size_t r>
 // basic_ostream<charT, traits>&

libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_result_type.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
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class Engine, size_t w, class UIntType>
 // class independent_bits_engine
 
 // explicit independent_bits_engine(result_type s = default_seed);
 
+// Serializing/deserializing the state of the RNG requires iostreams
+// UNSUPPORTED: libcpp-has-no-localization
+
 #include <random>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
 void
 test1()

libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_sseq.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
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class Engine, size_t w, class UIntType>
 // class independent_bits_engine
 
 // template<class Sseq> explicit independent_bits_engine(Sseq& q);
 
+// Serializing/deserializing the state of the RNG requires iostreams
+// UNSUPPORTED: libcpp-has-no-localization
+
 #include <random>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
 void
 test1()

libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.ibits/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class Engine, size_t w, class UIntType>
 // class independent_bits_engine
 
 // template <class charT, class traits,
 //           class Engine, size_t w, class UIntType>
 // basic_ostream<charT, traits>&

libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_result_type.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
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class Engine, size_t k>
 // class shuffle_order_engine
 
 // explicit shuffle_order_engine(result_type s = default_seed);
 
+// Serializing/deserializing the state of the RNG requires iostreams
+// UNSUPPORTED: libcpp-has-no-localization
+
 #include <random>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
 void
 test1()

libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/ctor_sseq.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
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class Engine, size_t k>
 // class shuffle_order_engine
 
 // template<class Sseq> explicit shuffle_order_engine(Sseq& q);
 
+// Serializing/deserializing the state of the RNG requires iostreams
+// UNSUPPORTED: libcpp-has-no-localization
+
 #include <random>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
 void
 test1()

libcxx/test/std/numerics/rand/rand.adapt/rand.adapt.shuf/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class Engine, size_t k>
 // class shuffle_order_engine
 
 // template <class charT, class traits,
 //           class Engine, size_t k>
 // basic_ostream<charT, traits>&

libcxx/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // class bernoulli_distribution
 
 // template <class charT, class traits>
 // basic_ostream<charT, traits>&
 // operator<<(basic_ostream<charT, traits>& os,
 //            const bernoulli_distribution& x);

libcxx/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval.PR44847.pass.cpp

 
 // template<class IntType = int>
 // class binomial_distribution
 
 // template<class _URNG> result_type operator()(_URNG& g);
 
 // Test the fix for https://llvm.org/PR44847.
 
+// Serializing/deserializing the state of the RNG requires iostreams
+// UNSUPPORTED: libcpp-has-no-localization
+
 #include <random>
 #include <numeric>
 #include <vector>
 #include <cassert>
 #include <sstream>
 
 #include "test_macros.h"
 

libcxx/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class IntType = int>
 // class binomial_distribution
 
 // template <class charT, class traits>
 // basic_ostream<charT, traits>&
 // operator<<(basic_ostream<charT, traits>& os,

libcxx/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class IntType = int>
 // class geometric_distribution
 
 // template <class charT, class traits>
 // basic_ostream<charT, traits>&
 // operator<<(basic_ostream<charT, traits>& os,

libcxx/test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class IntType = int>
 // class negative_binomial_distribution
 
 // template <class charT, class traits>
 // basic_ostream<charT, traits>&
 // operator<<(basic_ostream<charT, traits>& os,

libcxx/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class RealType = double>
 // class cauchy_distribution
 
 // template <class CharT, class Traits, class RealType>
 // basic_ostream<CharT, Traits>&
 // operator<<(basic_ostream<CharT, Traits>& os,

libcxx/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.chisq/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class RealType = double>
 // class chi_squared_distribution
 
 // template <class CharT, class Traits, class RealType>
 // basic_ostream<CharT, Traits>&
 // operator<<(basic_ostream<CharT, Traits>& os,

libcxx/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.f/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class RealType = double>
 // class fisher_f_distribution
 
 // template <class CharT, class Traits, class RealType>
 // basic_ostream<CharT, Traits>&
 // operator<<(basic_ostream<CharT, Traits>& os,

libcxx/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class RealType = double>
 // class lognormal_distribution
 
 // template <class CharT, class Traits, class RealType>
 // basic_ostream<CharT, Traits>&
 // operator<<(basic_ostream<CharT, Traits>& os,

libcxx/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.normal/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class RealType = double>
 // class normal_distribution
 
 // template <class CharT, class Traits, class RealType>
 // basic_ostream<CharT, Traits>&
 // operator<<(basic_ostream<CharT, Traits>& os,

libcxx/test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.t/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class RealType = double>
 // class student_t_distribution
 
 // template <class CharT, class Traits, class RealType>
 // basic_ostream<CharT, Traits>&
 // operator<<(basic_ostream<CharT, Traits>& os,

libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.exp/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class RealType = double>
 // class exponential_distribution
 
 // template <class CharT, class Traits, class RealType>
 // basic_ostream<CharT, Traits>&
 // operator<<(basic_ostream<CharT, Traits>& os,

libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class RealType = double>
 // class extreme_value_distribution
 
 // template <class CharT, class Traits, class RealType>
 // basic_ostream<CharT, Traits>&
 // operator<<(basic_ostream<CharT, Traits>& os,

libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.gamma/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class RealType = double>
 // class gamma_distribution
 
 // template <class CharT, class Traits, class RealType>
 // basic_ostream<CharT, Traits>&
 // operator<<(basic_ostream<CharT, Traits>& os,

libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.poisson/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class IntType = int>
 // class poisson_distribution
 
 // template <class CharT, class Traits, class IntType>
 // basic_ostream<CharT, Traits>&
 // operator<<(basic_ostream<CharT, Traits>& os,

libcxx/test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.weibull/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class RealType = double>
 // class weibull_distribution
 
 // template <class CharT, class Traits, class RealType>
 // basic_ostream<CharT, Traits>&
 // operator<<(basic_ostream<CharT, Traits>& os,

libcxx/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.discrete/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class IntType = int>
 // class discrete_distribution
 
 // template <class charT, class traits>
 // basic_ostream<charT, traits>&
 // operator<<(basic_ostream<charT, traits>& os,

libcxx/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class RealType = double>
 // class piecewise_constant_distribution
 
 // template <class charT, class traits>
 // basic_ostream<charT, traits>&
 // operator<<(basic_ostream<charT, traits>& os,

libcxx/test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class RealType = double>
 // class piecewise_linear_distribution
 
 // template <class charT, class traits>
 // basic_ostream<charT, traits>&
 // operator<<(basic_ostream<charT, traits>& os,

libcxx/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class _IntType = int>
 // class uniform_int_distribution
 
 // template <class charT, class traits>
 // basic_ostream<charT, traits>&
 // operator<<(basic_ostream<charT, traits>& os,

libcxx/test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class RealType = double>
 // class uniform_real_distribution
 
 // template <class charT, class traits>
 // basic_ostream<charT, traits>&
 // operator<<(basic_ostream<charT, traits>& os,

libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/ctor_result_type.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
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template <class UIntType, UIntType a, UIntType c, UIntType m>
 //   class linear_congruential_engine;
 
 // explicit linear_congruential_engine(result_type s = default_seed);
 
+// Serializing/deserializing the state of the RNG requires iostreams
+// UNSUPPORTED: libcpp-has-no-localization
+
 #include <random>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
 void

libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template <class UIntType, UIntType a, UIntType c, UIntType m>
 //   class linear_congruential_engine;
 
 // template <class charT, class traits,
 //           class UIntType, UIntType a, UIntType c, UIntType m>
 // basic_ostream<charT, traits>&

libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp

 
 // template <class UIntType, size_t w, size_t n, size_t m, size_t r,
 //           UIntType a, size_t u, UIntType d, size_t s,
 //           UIntType b, size_t t, UIntType c, size_t l, UIntType f>
 // class mersenne_twister_engine;
 
 // explicit mersenne_twister_engine(result_type s = default_seed);
 
+// Serializing/deserializing the state of the RNG requires iostreams
+// UNSUPPORTED: libcpp-has-no-localization
+
 #include <random>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
 void
 test1()

libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq.pass.cpp

 
 // template <class UIntType, size_t w, size_t n, size_t m, size_t r,
 //           UIntType a, size_t u, UIntType d, size_t s,
 //           UIntType b, size_t t, UIntType c, size_t l, UIntType f>
 // class mersenne_twister_engine;
 
 // template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
 
+// Serializing/deserializing the state of the RNG requires iostreams
+// UNSUPPORTED: libcpp-has-no-localization
+
 #include <random>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
 void
 test1()

libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template <class UIntType, size_t w, size_t n, size_t m, size_t r,
 //           UIntType a, size_t u, UIntType d, size_t s,
 //           UIntType b, size_t t, UIntType c, size_t l, UIntType f>
 // class mersenne_twister_engine;
 
 // template <class charT, class traits,

libcxx/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.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
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class UIntType, size_t w, size_t s, size_t r>
 // class subtract_with_carry_engine;
 
 // explicit subtract_with_carry_engine(result_type s = default_seed);
 
+// Serializing/deserializing the state of the RNG requires iostreams
+// UNSUPPORTED: libcpp-has-no-localization
+
 #include <random>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
 void
 test1()

libcxx/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_sseq.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
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // template<class UIntType, size_t w, size_t s, size_t r>
 // class subtract_with_carry_engine;
 
 // template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
 
+// Serializing/deserializing the state of the RNG requires iostreams
+// UNSUPPORTED: libcpp-has-no-localization
+
 #include <random>
 #include <sstream>
 #include <cassert>
 
 #include "test_macros.h"
 
 void
 test1()

libcxx/test/std/numerics/rand/rand.eng/rand.eng.sub/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <random>
 
 // template<class UIntType, size_t w, size_t s, size_t r>
 // class subtract_with_carry_engine;
 
 // template <class charT, class traits,
 //           class UIntType, size_t w, size_t s, size_t r>
 // basic_ostream<charT, traits>&

libcxx/test/std/re/lit.local.cfg

+# Unfortunately, <regex> uses locales in regex_traits
+if 'libcpp-has-no-localization' in config.available_features:
+  config.unsupported = True

libcxx/test/std/strings/basic.string/string.nonmembers/string.io/lit.local.cfg

+# These std::string functions require iostreams, which requires localization
+if 'libcpp-has-no-localization' in config.available_features:
+  config.unsupported = True

libcxx/test/std/strings/string.view/string.view.io/stream_insert.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <string>
 
 // template<class charT, class traits, class Allocator>
 //   basic_ostream<charT, traits>&
 //   operator<<(basic_ostream<charT, traits>& os,
 //              const basic_string_view<charT,traits> str);
 
 #include <string_view>

libcxx/test/std/strings/string.view/string.view.nonmem/quoted.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: libcpp-has-no-localization
 
 // <iomanip>
 
 // quoted
 
 #include <iomanip>
 #include <sstream>
 #include <string_view>

libcxx/test/std/thread/thread.threads/thread.thread.class/thread.thread.id/stream.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
 //
 //===----------------------------------------------------------------------===//
-//
+
 // UNSUPPORTED: libcpp-has-no-threads
+// UNSUPPORTED: libcpp-has-no-localization
 
 // <thread>
 
 // class thread::id
 
 // template<class charT, class traits>
 // basic_ostream<charT, traits>&
 // operator<<(basic_ostream<charT, traits>& out, thread::id id);

libcxx/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03
-//  Because we don't have a functioning decltype in C++03
+// Because we don't have a functioning decltype in C++03
+// UNSUPPORTED: c++03
+
+// UNSUPPORTED: libcpp-has-no-localization
 
 // <memory>
 
 // unique_ptr
 
 // template<class CharT, class Traits, class Y, class D>
 //   basic_ostream<CharT, Traits>&
 //   operator<<(basic_ostream<CharT, Traits>& os, const unique_ptr<Y, D>& p);

libcxx/test/std/utilities/memory/unique.ptr/unique.ptr.special/io.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 //  Because we don't have a functioning decltype in C++03
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <memory>
 
 // unique_ptr
 
 // template<class CharT, class Traits, class Y, class D>
 //   basic_ostream<CharT, Traits>&
 //   operator<<(basic_ostream<CharT, Traits>& os, const unique_ptr<Y, D>& p);
 

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.io/io.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // <memory>
 
 // shared_ptr
 
 // template<class CharT, class Traits, class Y>
 //   basic_ostream<CharT, Traits>&
 //   operator<<(basic_ostream<CharT, Traits>& os, shared_ptr<Y> const& p);
 

libcxx/test/std/utilities/template.bitset/bitset.operators/stream_in.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // test:
 
 // template <class charT, class traits, size_t N>
 // basic_istream<charT, traits>&
 // operator>>(basic_istream<charT, traits>& is, bitset<N>& x);
 
 #include <bitset>
 #include <sstream>

libcxx/test/std/utilities/template.bitset/bitset.operators/stream_out.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: libcpp-has-no-localization
+
 // test:
 
 // template <class charT, class traits, size_t N>
 // basic_ostream<charT, traits>&
 // operator<<(basic_ostream<charT, traits>& os, const bitset<N>& x);
 
 #include <bitset>
 #include <sstream>

libcxx/test/std/utilities/time/time.cal/time.cal.day/time.cal.day.nonmembers/streaming.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
 //
 //===----------------------------------------------------------------------===//
+
 // UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-localization
 // XFAIL: *
 
 // <chrono>
 // class day;
 
 // template<class charT, class traits>
 //   basic_ostream<charT, traits>&
 //   operator<<(basic_ostream<charT, traits>& os, const day& d);

libcxx/utils/ci/buildkite-pipeline.yml

steps:
 
   - label: "No random device"
     command: "libcxx/utils/ci/run-buildbot.sh generic-no-random_device"
     artifact_paths:
       - "**/test-results.xml"
     agents:
       queue: "libcxx-builders"
 
+  - label: "No locale"
+    command: "libcxx/utils/ci/run-buildbot.sh generic-no-localization"
+    artifact_paths:
+      - "**/test-results.xml"
+    agents:
+      queue: "libcxx-builders"
+
   - label: "MacOS C++20"
     command: "libcxx/utils/ci/run-buildbot.sh generic-cxx2a"
     artifact_paths:
       - "**/test-results.xml"
     agents:
       queue: "libcxx-macos-builders"
 
   - label: "Benchmarks"

libcxx/utils/ci/run-buildbot.sh

generic-nodebug)
     check-cxx-cxxabi
 ;;
 generic-no-random_device)
     export CC=clang
     export CXX=clang++
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-random_device.cmake"
     check-cxx-cxxabi
 ;;
+generic-no-localization)
+    export CC=clang
+    export CXX=clang++
+    generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-localization.cmake"
+    check-cxx-cxxabi
+;;
 x86_64-apple-system)
     export CC=clang
     export CXX=clang++
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Apple.cmake"
     check-cxx-cxxabi
 ;;
 x86_64-apple-system-noexceptions)
     export CC=clang

libcxx/utils/generate_feature_test_macro_components.py

 #
 # For example, when threads are not supported, any feature-test-macro test
 # that includes <thread> should be marked as UNSUPPORTED, because including
 # <thread> is a hard error in that case.
 lit_markup = {
   "atomic": ["UNSUPPORTED: libcpp-has-no-threads"],
   "shared_mutex": ["UNSUPPORTED: libcpp-has-no-threads"],
   "thread": ["UNSUPPORTED: libcpp-has-no-threads"],
+  "iomanip": ["UNSUPPORTED: libcpp-has-no-localization"],
+  "istream": ["UNSUPPORTED: libcpp-has-no-localization"],
+  "locale": ["UNSUPPORTED: libcpp-has-no-localization"],
+  "ostream": ["UNSUPPORTED: libcpp-has-no-localization"],
+  "regex": ["UNSUPPORTED: libcpp-has-no-localization"],
 }
 
 def get_std_dialects():
   std_dialects = ['c++14', 'c++17', 'c++2a']
   return list(std_dialects)
 
 def get_first_std(d):
     for s in get_std_dialects():

libcxx/utils/libcxx/test/features.py

macros = {
   '_LIBCPP_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS': 'libcpp-has-no-thread-unsafe-c-functions',
   '_LIBCPP_HAS_NO_THREADS': 'libcpp-has-no-threads',
   '_LIBCPP_HAS_THREAD_API_EXTERNAL': 'libcpp-has-thread-api-external',
   '_LIBCPP_HAS_THREAD_API_PTHREAD': 'libcpp-has-thread-api-pthread',
   '_LIBCPP_NO_VCRUNTIME': 'libcpp-no-vcruntime',
   '_LIBCPP_ABI_VERSION': 'libcpp-abi-version',
   '_LIBCPP_ABI_UNSTABLE': 'libcpp-abi-unstable',
   '_LIBCPP_HAS_NO_RANDOM_DEVICE': 'libcpp-has-no-random-device',
+  '_LIBCPP_HAS_NO_LOCALIZATION': 'libcpp-has-no-localization',
 }
 for macro, feature in macros.items():
   DEFAULT_FEATURES += [
     Feature(name=lambda cfg, m=macro, f=feature: f + (
               '={}'.format(compilerMacros(cfg)[m]) if compilerMacros(cfg)[m] else ''
             ),
             when=lambda cfg, m=macro: m in compilerMacros(cfg),