[libc++][nfc] Add TEST_HAS_NO_LOCALIZATION.

[Mordante]

Summary

This avoids using an libc++ internal macro in our tests.

[ldionne]

I would have sworn I already did this!

[Mordante]

Fix typo to fix CI.

[Mordante]

Fix CI.

libcxx/test/std/input.output/filesystems/class.path/path.nonmember/path.factory.pass.cpp

int main(int, char**)
   {
     path p = fs::u8path(In2.data());
     assert(p == In1);
   }
   {
     path p = fs::u8path(In3, In3End);
     assert(p == In1);
   }
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t) && defined(_LIBCPP_VERSION) && \
-    !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#if TEST_STD_VER > 17 && defined(__cpp_char8_t) && defined(_LIBCPP_VERSION) && !defined(TEST_HAS_NO_LOCALIZATION)
   const char8_t* u8In1 = u8"abcd/efg";
   const std::u8string u8In2(u8In1);
   const auto u8In3 = u8In2.begin();
   const auto u8In3End = u8In2.end();
   // Proposed in P1423, marked tested only for libc++
   {
     path p = fs::u8path(u8In1);
     assert(p == In1);

libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp

 #include <optional>
 #include <set>
 #include <string>
 #include <string_view>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
-# include <regex>
-# include <ostream>
-# include <istream>
+#include "test_macros.h"
+
+#ifndef TEST_HAS_NO_LOCALIZATION
+#  include <regex>
+#  include <ostream>
+#  include <istream>
 #endif
 
 #ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
 # include <filesystem>
 #endif
 
 #include "test_macros.h"
 #include "test_iterators.h"

 static_assert(testConstWithoutConcept<std::unordered_multiset<int>::const_local_iterator, int, std::forward_iterator_tag>());
 
 static_assert(testWithoutConcept<std::reverse_iterator<int*>, int, std::random_access_iterator_tag>());
 static_assert(testIOIterator<std::back_insert_iterator<std::vector<int>>, std::output_iterator_tag>());
 static_assert(testIOIterator<std::front_insert_iterator<std::vector<int>>, std::output_iterator_tag>());
 static_assert(testIOIterator<std::insert_iterator<std::vector<int>>, std::output_iterator_tag>());
 static_assert(testConstWithoutConcept<std::istream_iterator<int, char>, int, std::input_iterator_tag>());
 
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#if !defined(TEST_HAS_NO_LOCALIZATION)
 static_assert(testWithoutConcept<std::istreambuf_iterator<char>, char, long long, char, char*, std::input_iterator_tag>());
 static_assert(testWithoutConcept<std::move_iterator<int*>, int, std::ptrdiff_t, int&&, int*, std::random_access_iterator_tag>());
 static_assert(testIOIterator<std::ostream_iterator<int, char>, std::output_iterator_tag>());
 static_assert(testIOIterator<std::ostreambuf_iterator<int, char>, std::output_iterator_tag>());
 static_assert(testConstWithoutConcept<std::cregex_iterator, std::cmatch, std::forward_iterator_tag>());
 static_assert(testConstWithoutConcept<std::cregex_token_iterator, std::csub_match, std::forward_iterator_tag>());
-#endif // !_LIBCPP_HAS_NO_LOCALIZATION
+#endif // !TEST_HAS_NO_LOCALIZATION
 
 #ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
 static_assert(testWithoutConcept<std::filesystem::directory_iterator, std::filesystem::directory_entry, std::ptrdiff_t,
                                  const std::filesystem::directory_entry&, const std::filesystem::directory_entry*,
                                  std::input_iterator_tag>());
 static_assert(testWithoutConcept<std::filesystem::recursive_directory_iterator, std::filesystem::directory_entry,
                                  std::ptrdiff_t, const std::filesystem::directory_entry&,
                                  const std::filesystem::directory_entry*, std::input_iterator_tag>());

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

std::basic_format_args args = format_arg_store;
     assert(test_basic_format_arg(context.arg(2), 42));
     assert(test_basic_format_arg(context.arg(3),
                                  std::basic_string_view<CharT>(string)));
 
     context.out() = CharT('a');
     assert(output.size() == 1);
     assert(output.front() == CharT('a'));
 
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#ifndef TEST_HAS_NO_LOCALIZATION
     assert(context.locale() == std::locale());
 #endif
   }
 
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#ifndef TEST_HAS_NO_LOCALIZATION
   std::locale en_US{LOCALE_en_US_UTF_8};
   std::locale fr_FR{LOCALE_fr_FR_UTF_8};
   {
     std::basic_string<CharT> output;
     OutIt out_it{output};
     std::basic_format_context context =
         test_format_context_create(out_it, args, en_US);
 

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.floating_point.pass.cpp

void test_hex_lower_case_precision(ArithmeticT value) {
   std::rotate(buffer.begin(), buffer.end() - ((size + 1) / 2), buffer.end());
   test_termination_condition(STR("#>25000.20000a}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
   std::fill_n(buffer.begin(), size, '0');
   if (std::signbit(value)) {
     buffer[0] = '-';
     buffer[size] = '0';
   }
   test_termination_condition(STR("025000.20000a}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#ifndef TEST_HAS_NO_LOCALIZATION
   end = std::to_chars(buffer.begin(), buffer.end(), value, std::chars_format::hex, 20'000).ptr;
   test_termination_condition(STR(".20000La}"), value, std::basic_string<CharT>{buffer.begin(), end});
 
   size = buffer.end() - end;
   std::fill_n(end, size, '#');
   test_termination_condition(STR("#<25000.20000La}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
   std::rotate(buffer.begin(), buffer.end() - (size / 2), buffer.end());
   test_termination_condition(STR("#^25000.20000La}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
void test_hex_upper_case_precision(ArithmeticT value) {
   std::rotate(buffer.begin(), buffer.end() - ((size + 1) / 2), buffer.end());
   test_termination_condition(STR("#>25000.20000A}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
   std::fill_n(buffer.begin(), size, '0');
   if (std::signbit(value)) {
     buffer[0] = '-';
     buffer[size] = '0';
   }
   test_termination_condition(STR("025000.20000A}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#ifndef TEST_HAS_NO_LOCALIZATION
   end = std::to_chars(buffer.begin(), buffer.end(), value, std::chars_format::hex, 20'000).ptr;
   std::transform(buffer.begin(), end, buffer.begin(), [](char c) { return std::toupper(c); });
   test_termination_condition(STR(".20000LA}"), value, std::basic_string<CharT>{buffer.begin(), end});
 
   size = buffer.end() - end;
   std::fill_n(end, size, '#');
   test_termination_condition(STR("#<25000.20000LA}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
   std::rotate(buffer.begin(), buffer.end() - (size / 2), buffer.end());
void test_scientific_lower_case_precision(ArithmeticT value) {
   std::rotate(buffer.begin(), buffer.end() - ((size + 1) / 2), buffer.end());
   test_termination_condition(STR("#>25000.20000e}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
   std::fill_n(buffer.begin(), size, '0');
   if (std::signbit(value)) {
     buffer[0] = '-';
     buffer[size] = '0';
   }
   test_termination_condition(STR("025000.20000e}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#ifndef TEST_HAS_NO_LOCALIZATION
   end = std::to_chars(buffer.begin(), buffer.end(), value, std::chars_format::scientific, 20'000).ptr;
   test_termination_condition(STR(".20000Le}"), value, std::basic_string<CharT>{buffer.begin(), end});
 
   size = buffer.end() - end;
   std::fill_n(end, size, '#');
   test_termination_condition(STR("#<25000.20000Le}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
   std::rotate(buffer.begin(), buffer.end() - (size / 2), buffer.end());
   test_termination_condition(STR("#^25000.20000Le}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
void test_scientific_upper_case_precision(ArithmeticT value) {
   std::rotate(buffer.begin(), buffer.end() - ((size + 1) / 2), buffer.end());
   test_termination_condition(STR("#>25000.20000E}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
   std::fill_n(buffer.begin(), size, '0');
   if (std::signbit(value)) {
     buffer[0] = '-';
     buffer[size] = '0';
   }
   test_termination_condition(STR("025000.20000E}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#ifndef TEST_HAS_NO_LOCALIZATION
   end = std::to_chars(buffer.begin(), buffer.end(), value, std::chars_format::scientific, 20'000).ptr;
   std::transform(buffer.begin(), end, buffer.begin(), [](char c) { return std::toupper(c); });
   test_termination_condition(STR(".20000LE}"), value, std::basic_string<CharT>{buffer.begin(), end});
 
   size = buffer.end() - end;
   std::fill_n(end, size, '#');
   test_termination_condition(STR("#<25000.20000LE}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
   std::rotate(buffer.begin(), buffer.end() - (size / 2), buffer.end());
void test_fixed_lower_case_precision(ArithmeticT value) {
   std::rotate(buffer.begin(), buffer.end() - ((size + 1) / 2), buffer.end());
   test_termination_condition(STR("#>25000.20000f}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
   std::fill_n(buffer.begin(), size, '0');
   if (std::signbit(value)) {
     buffer[0] = '-';
     buffer[size] = '0';
   }
   test_termination_condition(STR("025000.20000f}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#ifndef TEST_HAS_NO_LOCALIZATION
   end = std::to_chars(buffer.begin(), buffer.end(), value, std::chars_format::fixed, 20'000).ptr;
   test_termination_condition(STR(".20000Lf}"), value, std::basic_string<CharT>{buffer.begin(), end});
 
   size = buffer.end() - end;
   std::fill_n(end, size, '#');
   test_termination_condition(STR("#<25000.20000Lf}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
   std::rotate(buffer.begin(), buffer.end() - (size / 2), buffer.end());
   test_termination_condition(STR("#^25000.20000Lf}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
void test_fixed_upper_case_precision(ArithmeticT value) {
   std::rotate(buffer.begin(), buffer.end() - ((size + 1) / 2), buffer.end());
   test_termination_condition(STR("#>25000.20000F}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
   std::fill_n(buffer.begin(), size, '0');
   if (std::signbit(value)) {
     buffer[0] = '-';
     buffer[size] = '0';
   }
   test_termination_condition(STR("025000.20000F}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#ifndef TEST_HAS_NO_LOCALIZATION
   end = std::to_chars(buffer.begin(), buffer.end(), value, std::chars_format::fixed, 20'000).ptr;
   std::transform(buffer.begin(), end, buffer.begin(), [](char c) { return std::toupper(c); });
   test_termination_condition(STR(".20000LF}"), value, std::basic_string<CharT>{buffer.begin(), end});
 
   size = buffer.end() - end;
   std::fill_n(end, size, '#');
   test_termination_condition(STR("#<25000.20000LF}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
   std::rotate(buffer.begin(), buffer.end() - (size / 2), buffer.end());
void test_general_lower_case_precision(ArithmeticT value) {
   std::rotate(buffer.begin(), buffer.end() - ((size + 1) / 2), buffer.end());
   test_termination_condition(STR("#>25000.20000g}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
   std::fill_n(buffer.begin(), size, '0');
   if (std::signbit(value)) {
     buffer[0] = '-';
     buffer[size] = '0';
   }
   test_termination_condition(STR("025000.20000g}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#ifndef TEST_HAS_NO_LOCALIZATION
   end = std::to_chars(buffer.begin(), buffer.end(), value, std::chars_format::general, 20'000).ptr;
   test_termination_condition(STR(".20000Lg}"), value, std::basic_string<CharT>{buffer.begin(), end});
 
   size = buffer.end() - end;
   std::fill_n(end, size, '#');
   test_termination_condition(STR("#<25000.20000Lg}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
   std::rotate(buffer.begin(), buffer.end() - (size / 2), buffer.end());
   test_termination_condition(STR("#^25000.20000Lg}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
void test_general_upper_case_precision(ArithmeticT value) {
   std::rotate(buffer.begin(), buffer.end() - ((size + 1) / 2), buffer.end());
   test_termination_condition(STR("#>25000.20000G}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
   std::fill_n(buffer.begin(), size, '0');
   if (std::signbit(value)) {
     buffer[0] = '-';
     buffer[size] = '0';
   }
   test_termination_condition(STR("025000.20000G}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#ifndef TEST_HAS_NO_LOCALIZATION
   end = std::to_chars(buffer.begin(), buffer.end(), value, std::chars_format::general, 20'000).ptr;
   std::transform(buffer.begin(), end, buffer.begin(), [](char c) { return std::toupper(c); });
   test_termination_condition(STR(".20000LG}"), value, std::basic_string<CharT>{buffer.begin(), end});
 
   size = buffer.end() - end;
   std::fill_n(end, size, '#');
   test_termination_condition(STR("#<25000.20000LG}"), value, std::basic_string<CharT>{buffer.begin(), buffer.end()});
   std::rotate(buffer.begin(), buffer.end() - (size / 2), buffer.end());

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

 #endif
 #include <format>
 #include <forward_list>
 #include <list>
 #include <memory>
 #include <map>
 #include <optional>
 #include <queue>
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
-#  include <regex>
-#endif
 #include <set>
 #include <stack>
 #include <span>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #  include <thread>
 #endif
 #include <tuple>
 #include <type_traits>
 #include <unordered_map>
 #include <unordered_set>
 #include <valarray>
 #include <variant>
 
 #include "test_macros.h"
 
+#ifndef TEST_HAS_NO_LOCALIZATION
+#  include <regex>
+#endif
+
 // Validate default template argument.
 static_assert(std::same_as<std::formatter<int>, std::formatter<int, char>>);
 
 // Concept for an enabled formatter.
 //
 // Since it's not possible to extract the T and CharT types from the formatter
 // they are specified and the proper formatter is always intended to be
 // defaulted.
void test_P1636() {
   assert_formatter_is_disabled<std::basic_streambuf<CharT>, CharT>();
   assert_formatter_is_disabled<std::bitset<42>, CharT>();
   assert_formatter_is_disabled<std::complex<double>, CharT>();
   assert_formatter_is_disabled<std::error_code, CharT>();
 #ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
   assert_formatter_is_disabled<std::filesystem::path, CharT>();
 #endif
   assert_formatter_is_disabled<std::shared_ptr<int>, CharT>();
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#ifndef TEST_HAS_NO_LOCALIZATION
   assert_formatter_is_disabled<std::sub_match<CharT*>, CharT>();
 #endif
 #ifndef _LIBCPP_HAS_NO_THREADS
   assert_formatter_is_disabled<std::thread::id, CharT>();
 #endif
   assert_formatter_is_disabled<std::unique_ptr<int>, CharT>();
 }
 

libcxx/test/std/utilities/format/format.functions/format.pass.cpp

 
 // template<class... Args>
 //   string format(string_view fmt, const Args&... args);
 // template<class... Args>
 //   wstring format(wstring_view fmt, const Args&... args);
 
 #include <format>
 #include <cassert>
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
-#  include <iostream>
-#endif
 #include <vector>
 
 #include "test_macros.h"
 #include "format_tests.h"
 
+#ifndef TEST_HAS_NO_LOCALIZATION
+#  include <iostream>
+#endif
+
 auto test = []<class CharT, class... Args>(std::basic_string_view<CharT> expected, std::basic_string_view<CharT> fmt,
                                            const Args&... args) {
   std::basic_string<CharT> out = std::format(fmt, args...);
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#ifndef TEST_HAS_NO_LOCALIZATION
   if constexpr (std::same_as<CharT, char>)
     if (out != expected)
       std::cerr << "\nFormat string   " << fmt << "\nExpected output " << expected << "\nActual output   " << out
                 << '\n';
 #endif
   assert(out == expected);
 };
 
 auto test_exception = []<class CharT, class... Args>(std::string_view what, std::basic_string_view<CharT> fmt,
                                                      const Args&... args) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   try {
     std::format(fmt, args...);
-#  ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#  ifndef TEST_HAS_NO_LOCALIZATION
     if constexpr (std::same_as<CharT, char>)
       std::cerr << "\nFormat string   " << fmt << "\nDidn't throw an exception.\n";
 #  endif
     assert(false);
   } catch (const std::format_error& e) {
-#  if defined(_LIBCPP_VERSION) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
     if constexpr (std::same_as<CharT, char>)
+#  if defined(_LIBCPP_VERSION) && !defined(TEST_HAS_NO_LOCALIZATION)
       if (e.what() != what)
         std::cerr << "\nFormat string   " << fmt << "\nExpected exception " << what << "\nActual exception   "
                   << e.what() << '\n';
 #  endif
     LIBCPP_ASSERT(e.what() == what);
     return;
   }
   assert(false);

libcxx/test/support/test_macros.h

 #if defined(_LIBCPP_HAS_NO_INT128) || defined(TEST_COMPILER_MSVC)
 #   define TEST_HAS_NO_INT128
 #endif
 
 #if defined(_LIBCPP_HAS_NO_UNICODE_CHARS)
 #   define TEST_HAS_NO_UNICODE_CHARS
 #endif
 
+#if defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  define TEST_HAS_NO_LOCALIZATION
+#endif
+
 #if defined(__GNUC__)
 #pragma GCC diagnostic pop
 #endif
 
 #endif // SUPPORT_TEST_MACROS_HPP