[libc++][nfc] Add TEST_HAS_NO_THREADS.

[Mordante]

Summary

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

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

 
 // Make sure atomic<TriviallyCopyable> can be instantiated.
 
 #include <atomic>
 #include <new>
 #include <cassert>
 #include <chrono> // for nanoseconds
 
-#ifndef _LIBCPP_HAS_NO_THREADS
-#   include <thread> // for thread_id
+#include "test_macros.h"
+
+#ifndef TEST_HAS_NO_THREADS
+#  include <thread> // for thread_id
 #endif
 
 struct TriviallyCopyable {
   explicit TriviallyCopyable(int i) : i_(i) { }
   int i_;
 };
 
 template <class T>
 void test(T t) {
   std::atomic<T> t0(t);
 }
 
 int main(int, char**) {
   test(TriviallyCopyable(42));
   test(std::chrono::nanoseconds(2));
-#ifndef _LIBCPP_HAS_NO_THREADS
+#ifndef TEST_HAS_NO_THREADS
   test(std::this_thread::get_id());
 #endif
 
   return 0;
 }

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

 //     typedef T value_type;
 // };
 
 #include <atomic>
 #include <chrono>
 #include <memory>
 #include <type_traits>
 
-#ifndef _LIBCPP_HAS_NO_THREADS
-#   include <thread>
+#include "test_macros.h"
+
+#ifndef TEST_HAS_NO_THREADS
+#  include <thread>
 #endif
 
-#include "test_macros.h"
-
 template <class A, bool Integral>
 struct test_atomic
 {
     test_atomic()
     {
         A a; (void)a;
 #if TEST_STD_VER >= 17
     static_assert((std::is_same_v<typename A::value_type, decltype(a.load())>), "");
#ifndef __APPLE__ // Apple doesn't ship libatomic
     /*
         These aren't going to be lock-free,
         so some libatomic.a is necessary.
     */
     test<WeirdTriviallyCopyable>();
     test<LargeTriviallyCopyable>();
 #endif
 
-#ifndef _LIBCPP_HAS_NO_THREADS
+#ifndef TEST_HAS_NO_THREADS
     test<std::thread::id>();
 #endif
     test<std::chrono::nanoseconds>();
     test<float>();
 
 #if TEST_STD_VER >= 20
     test<std::atomic_signed_lock_free::value_type>();
     test<std::atomic_unsigned_lock_free::value_type>();
 /*
     test<std::shared_ptr<int>>();
 */
 #endif
 
     return 0;
 }

libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.compile.pass.cpp

 #include <map>
 #include <memory>
 #include <optional>
 #include <set>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
-#ifndef _LIBCPP_HAS_NO_THREADS
-#   include <mutex>
+#include "test_macros.h"
+
+#ifndef TEST_HAS_NO_THREADS
+#  include <mutex>
 #endif
 
 #include "compare_types.h"
 
 template <class T, class U>
 constexpr bool check_equality_comparable_with() {
   constexpr bool result = std::equality_comparable_with<T, U>;
   static_assert(std::equality_comparable_with<U, T> == result);
static_assert(check_equality_comparable_with<std::forward_list<int>,
                                              std::forward_list<int> >());
 static_assert(!check_equality_comparable_with<std::forward_list<int>,
                                               std::vector<int> >());
 static_assert(
     check_equality_comparable_with<std::list<int>, std::list<int> >());
 static_assert(
     !check_equality_comparable_with<std::list<int>, std::vector<int> >());
 
-#ifndef _LIBCPP_HAS_NO_THREADS
+#ifndef TEST_HAS_NO_THREADS
 static_assert(!check_equality_comparable_with<std::lock_guard<std::mutex>,
                                               std::lock_guard<std::mutex> >());
 static_assert(!check_equality_comparable_with<std::lock_guard<std::mutex>,
                                               std::vector<int> >());
 static_assert(!check_equality_comparable_with<std::mutex, std::mutex>());
 static_assert(!check_equality_comparable_with<std::mutex, std::vector<int> >());
 #endif
 

libcxx/test/std/concepts/concepts.object/movable.compile.pass.cpp

 #include <deque>
 #include <forward_list>
 #include <list>
 #include <map>
 #include <optional>
 #include <unordered_map>
 #include <vector>
 
-#ifndef _LIBCPP_HAS_NO_THREADS
-#   include <mutex>
+#include "test_macros.h"
+
+#ifndef TEST_HAS_NO_THREADS
+#  include <mutex>
 #endif
 
 #include "type_classification/moveconstructible.h"
 #include "type_classification/movable.h"
 
 // Movable types
 static_assert(std::movable<int>);
 static_assert(std::movable<int volatile>);

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

 #include <list>
 #include <memory>
 #include <map>
 #include <optional>
 #include <queue>
 #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
+#ifndef TEST_HAS_NO_THREADS
+#  include <thread>
+#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
void test_P1636() {
   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 TEST_HAS_NO_LOCALIZATION
   assert_formatter_is_disabled<std::sub_match<CharT*>, CharT>();
 #endif
-#ifndef _LIBCPP_HAS_NO_THREADS
+#ifndef TEST_HAS_NO_THREADS
   assert_formatter_is_disabled<std::thread::id, CharT>();
 #endif
   assert_formatter_is_disabled<std::unique_ptr<int>, CharT>();
 }
 
 // Tests for P2286 Formatting ranges
 //
 // The paper hasn't been voted in so currently all formatters are disabled.

libcxx/test/support/test_macros.h

 #if defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #  define TEST_HAS_NO_LOCALIZATION
 #endif
 
 #if TEST_STD_VER <= 17 || !defined(__cpp_char8_t)
 #  define TEST_HAS_NO_CHAR8_T
 #endif
 
+#if defined(_LIBCPP_HAS_NO_THREADS)
+#  define TEST_HAS_NO_THREADS
+#endif
+
 #if defined(__GNUC__)
 #pragma GCC diagnostic pop
 #endif
 
 #endif // SUPPORT_TEST_MACROS_HPP