[libc++][nfc] Include test_macros.h in more tests.

[Mordante]

Summary

This should fix the regressions detected in D117992.

Note this should land before D117992, the dependency is added to test
the combination of the two patches.

Depends on D117992

[ldionne]

libcxx/test/std/concepts/concepts.lang/concept.assignable/assignable_from.compile.pass.cpp

26 ↗

(On Diff #402579)

I don't understand why this is needed in several of the places where you're including the file. For example, here, I don't see anything that uses a macro in test_macros.h. Am I missing it?

[Mordante]

Addresses review comment.

[Mordante]

libcxx/test/std/concepts/concepts.lang/concept.assignable/assignable_from.compile.pass.cpp

26 ↗

(On Diff #402579)

As discussed on Discord, there was some confusion about the policy whether or not to always include this header. The header should only be included when needed. So the unneeded occurrences have been removed.

libcxx/test/std/concepts/concepts.lang/concept.common/common_with.compile.pass.cpp

 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class From, class To>
 // concept common_with;
 
 #include <concepts>
 #include <type_traits>
 
+#include "test_macros.h"
+
 template <class T, class U>
 constexpr bool CheckCommonWith() noexcept {
   constexpr bool result = std::common_with<T, U>;
   static_assert(std::common_with<T, U&> == result);
   static_assert(std::common_with<T, const U&> == result);
   static_assert(std::common_with<T, volatile U&> == result);
   static_assert(std::common_with<T, const volatile U&> == result);
   static_assert(std::common_with<T, U&&> == result);

libcxx/test/std/concepts/concepts.lang/concept.commonref/common_reference.compile.pass.cpp

 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class From, class To>
 // concept common_reference_with;
 
 #include <concepts>
 #include <type_traits>
 
+#include "test_macros.h"
+
 template <class T, class U>
 constexpr bool CheckCommonReferenceWith() noexcept {
   static_assert(std::common_reference_with<T, U&>);
   static_assert(std::common_reference_with<T, const U&>);
   static_assert(std::common_reference_with<T, volatile U&>);
   static_assert(std::common_reference_with<T, const volatile U&>);
   static_assert(std::common_reference_with<T, U&&>);
   static_assert(std::common_reference_with<T, const U&&>);

libcxx/test/std/concepts/concepts.lang/concepts.arithmetic/integral.pass.cpp

 
 // template<class T>
 // concept integral = // see below
 
 #include <concepts>
 #include <type_traits>
 
 #include "arithmetic.h"
+#include "test_macros.h"
 
 template <typename T>
 constexpr bool CheckIntegralQualifiers() {
   constexpr bool result = std::integral<T>;
   static_assert(std::integral<const T> == result);
   static_assert(std::integral<volatile T> == result);
   static_assert(std::integral<const volatile T> == result);
 

libcxx/test/std/concepts/concepts.lang/concepts.arithmetic/signed_integral.pass.cpp

 
 // template<class T>
 // concept signed_integral = // see below
 
 #include <concepts>
 #include <type_traits>
 
 #include "arithmetic.h"
+#include "test_macros.h"
 
 template <typename T>
 constexpr bool CheckSignedIntegralQualifiers() {
   constexpr bool result = std::signed_integral<T>;
   static_assert(std::signed_integral<const T> == result);
   static_assert(std::signed_integral<volatile T> == result);
   static_assert(std::signed_integral<const volatile T> == result);
 

libcxx/test/std/concepts/concepts.lang/concepts.arithmetic/unsigned_integral.pass.cpp

 
 // template<class T>
 // concept unsigned_integral = // see below
 
 #include <concepts>
 #include <type_traits>
 
 #include "arithmetic.h"
+#include "test_macros.h"
 
 template <typename T>
 constexpr bool CheckUnsignedIntegralQualifiers() {
   constexpr bool result = std::unsigned_integral<T>;
   static_assert(std::unsigned_integral<const T> == result);
   static_assert(std::unsigned_integral<volatile T> == result);
   static_assert(std::unsigned_integral<const volatile T> == result);
 

libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable.compile.pass.cpp

 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class T, class Cat = partial_ordering>
 // concept three_way_comparable = // see below
 
 #include <compare>
 
 #include "compare_types.h"
+#include "test_macros.h"
 
 namespace fundamentals {
 // with default ordering
 static_assert(std::three_way_comparable<int>);
 static_assert(std::three_way_comparable<double>);
 static_assert(std::three_way_comparable<void*>);
 static_assert(std::three_way_comparable<char*>);
 static_assert(std::three_way_comparable<char const*>);

libcxx/test/std/numerics/rand/rand.req/rand.req.urng/uniform_random_bit_generator.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class T>
 // concept uniform_random_bit_generator = // see below
 
 #include <random>
 
+#include "test_macros.h"
+
 static_assert(std::uniform_random_bit_generator<
               std::linear_congruential_engine<unsigned int, 0U, 1U, 2U> >);
 
 #ifndef _LIBCPP_HAS_NO_INT128
 static_assert(std::uniform_random_bit_generator<
               std::subtract_with_carry_engine<__uint128_t, 1U, 2U, 3U> >);
 #endif