[libc++] Use TEST_HAS_NO_UNICODE instead of _LIBCPP_HAS_NO_UNICODE in the test suite

[jloser]

I like the consistency with this approach - LGTM.

[CaseyCarter]

Excellent - always happy to see _LIBCPP_MEOW macros removed from test code.

[Mordante]

Thanks for the cleanup!

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

 //===----------------------------------------------------------------------===//
 // 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 TEST_STD_UTILITIES_FORMAT_FORMAT_FUNCTIONS_FORMAT_TESTS_H
 #define TEST_STD_UTILITIES_FORMAT_FORMAT_FUNCTIONS_FORMAT_TESTS_H
 
 #include <format>
 
 #include "make_string.h"
+#include "test_macros.h"
 
 // In this file the following template types are used:
 // TestFunction must be callable as check(expected-result, string-to-format, args-to-format...)
 // ExceptionTest must be callable as check_exception(expected-exception, string-to-format, args-to-format...)
 
 #define STR(S) MAKE_STRING(CharT, S)
 #define CSTR(S) MAKE_CSTRING(CharT, S)
 
#endif
   for (const auto& fmt : invalid_types<CharT>("s"))
     check_exception(
         "The format-spec type has a type not supported for a string argument",
         fmt, world);
 }
 
 template <class CharT, class TestFunction>
 void format_test_string_unicode(TestFunction check) {
-#ifndef _LIBCPP_HAS_NO_UNICODE
+  (void)check;
+#ifndef TEST_HAS_NO_UNICODE
   // ß requires one column
   check(STR("aßc"), STR("{}"), STR("aßc"));
 
   check(STR("aßc"), STR("{:.3}"), STR("aßc"));
   check(STR("aß"), STR("{:.2}"), STR("aßc"));
   check(STR("a"), STR("{:.1}"), STR("aßc"));
 
   check(STR("aßc"), STR("{:3.3}"), STR("aßc"));
#ifndef TEST_HAS_NO_UNICODE
   check(STR("a\u1100c"), STR("{:-<4.4}"), STR("a\u1100c"));
   check(STR("a\u1100"), STR("{:-<3.3}"), STR("a\u1100c"));
   check(STR("a-"), STR("{:-<2.2}"), STR("a\u1100c"));
   check(STR("a"), STR("{:-<1.1}"), STR("a\u1100c"));
 
   check(STR("a\u1110c---"), STR("{:-<7}"), STR("a\u1110c"));
   check(STR("-a\u1110c--"), STR("{:-^7}"), STR("a\u1110c"));
   check(STR("---a\u1110c"), STR("{:->7}"), STR("a\u1110c"));
-#else
-  (void)check;
-#endif
+#endif // TEST_HAS_NO_UNICODE
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void format_string_tests(TestFunction check, ExceptionTest check_exception) {
   std::basic_string<CharT> world = STR("world");
   std::basic_string<CharT> universe = STR("universe");
 
   // Testing the char const[] is a bit tricky due to array to pointer decay.

libcxx/test/std/utilities/format/format.functions/locale-specific_form.pass.cpp

void test(std::basic_string<CharT> expected, std::locale loc,
   }
   // *** formatted_size ***
   {
     size_t size = std::formatted_size(loc, fmt, args...);
     assert(size == expected.size());
   }
 }
 
-#ifndef _LIBCPP_HAS_NO_UNICODE
+#ifndef TEST_HAS_NO_UNICODE
 template <class CharT>
 struct numpunct_unicode;
 
 template <>
 struct numpunct_unicode<char> : std::numpunct<char> {
   string_type do_truename() const override { return "gültig"; }
   string_type do_falsename() const override { return "ungültig"; }
 };
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
 template <>
 struct numpunct_unicode<wchar_t> : std::numpunct<wchar_t> {
   string_type do_truename() const override { return L"gültig"; }
   string_type do_falsename() const override { return L"ungültig"; }
 };
 #endif
-#endif // _LIBCPP_HAS_NO_UNICODE
+#endif // TEST_HAS_NO_UNICODE
 
 template <class CharT>
 void test_bool() {
   std::locale loc = std::locale(std::locale(), new numpunct<CharT>());
 
   std::locale::global(std::locale(LOCALE_en_US_UTF_8));
   assert(std::locale().name() == LOCALE_en_US_UTF_8);
   test(STR("true"), STR("{:L}"), true);
   test(STR("false"), STR("{:L}"), false);
 
   test(STR("yes"), loc, STR("{:L}"), true);
   test(STR("no"), loc, STR("{:L}"), false);
 
   std::locale::global(loc);
   test(STR("yes"), STR("{:L}"), true);
   test(STR("no"), STR("{:L}"), false);
 
   test(STR("true"), std::locale(LOCALE_en_US_UTF_8), STR("{:L}"), true);
   test(STR("false"), std::locale(LOCALE_en_US_UTF_8), STR("{:L}"), false);
 
-#ifndef _LIBCPP_HAS_NO_UNICODE
+#ifndef TEST_HAS_NO_UNICODE
   std::locale loc_unicode =
       std::locale(std::locale(), new numpunct_unicode<CharT>());
 
   test(STR("gültig"), loc_unicode, STR("{:L}"), true);
   test(STR("ungültig"), loc_unicode, STR("{:L}"), false);
 
   test(STR("gültig   "), loc_unicode, STR("{:9L}"), true);
   test(STR("gültig!!!"), loc_unicode, STR("{:!<9L}"), true);
   test(STR("_gültig__"), loc_unicode, STR("{:_^9L}"), true);
   test(STR("   gültig"), loc_unicode, STR("{:>9L}"), true);
-#endif
+#endif // TEST_HAS_NO_UNICODE
 }
 
 template <class CharT>
 void test_integer() {
   std::locale loc = std::locale(std::locale(), new numpunct<CharT>());
   std::locale en_US = std::locale(LOCALE_en_US_UTF_8);
 
   // *** Decimal ***

libcxx/test/support/msvc_stdlib_force_include.h

 #define _LIBCPP_SUPPRESS_DEPRECATED_PUSH \
     __pragma(warning(push)) \
     __pragma(warning(disable : 4996)) \
     __pragma(warning(disable : 5215))
 #define _LIBCPP_SUPPRESS_DEPRECATED_POP \
     __pragma(warning(pop))
 #endif // __clang__
 
-#if defined(_MSVC_EXECUTION_CHARACTER_SET) && _MSVC_EXECUTION_CHARACTER_SET != 65001
-#define _LIBCPP_HAS_NO_UNICODE 1
-#endif
-
 #endif // SUPPORT_MSVC_STDLIB_FORCE_INCLUDE_H

libcxx/test/support/test_macros.h

 #define TEST_WIN_NO_FILESYSTEM_PERMS_NONE
 #endif
 
 // Support for carving out parts of the test suite, like removing wide characters, etc.
 #if defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
 #   define TEST_HAS_NO_WIDE_CHARACTERS
 #endif
 
+#if defined(_LIBCPP_HAS_NO_UNICODE)
+#   define TEST_HAS_NO_UNICODE
+#elif defined(_MSVC_EXECUTION_CHARACTER_SET) && _MSVC_EXECUTION_CHARACTER_SET != 65001
+#   define TEST_HAS_NO_UNICODE
+#endif
+
 #if defined(__GNUC__)
 #pragma GCC diagnostic pop
 #endif
 
 #endif // SUPPORT_TEST_MACROS_HPP