[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

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

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.assignable/assignable_from.compile.pass.cpp

 //   requires (LHS lhs, RHS&& rhs) {
 //     { lhs = std::forward<RHS>(rhs) } -> std::same_as<LHS>;
 //   };
 
 #include <concepts>
 #include <type_traits>
 
 #include "MoveOnly.h"
+#include "test_macros.h"
 
 struct NoCommonRef {
   NoCommonRef& operator=(const int&);
 };
 static_assert(std::is_assignable_v<NoCommonRef&, const int&>);
 static_assert(!std::assignable_from<NoCommonRef&, const int&>); // no common reference type
 
 struct Base {};

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/concept.constructible/constructible_from.compile.pass.cpp

 //    destructible<T> && is_constructible_v<T, Args...>;
 
 #include <array>
 #include <concepts>
 #include <memory>
 #include <string>
 #include <type_traits>
 
+#include "test_macros.h"
+
 struct Empty {};
 
 struct Defaulted {
   ~Defaulted() = default;
 };
 struct Deleted {
   ~Deleted() = delete;
 };

libcxx/test/std/concepts/concepts.lang/concept.convertible/convertible_to.pass.cpp

 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class From, class To>
 // concept convertible_to;
 
 #include <concepts>
 #include <type_traits>
 
+#include "test_macros.h"
+
 namespace {
 enum ClassicEnum { a, b };
 enum class ScopedEnum { x, y };
 struct Empty {};
 using nullptr_t = decltype(nullptr);
 
 template <class T, class U>
 void CheckConvertibleTo() {

libcxx/test/std/concepts/concepts.lang/concept.copyconstructible/copy_constructible.compile.pass.cpp

 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class T>
 // concept copy_constructible;
 
 #include <concepts>
 #include <type_traits>
 
+#include "test_macros.h"
 #include "type_classification/moveconstructible.h"
 
 // Tests in this namespace are shared with moveconstructible.pass.cpp
 // There are some interesting differences, so it's best if they're tested here
 // too.
 namespace MoveConstructibleTests {
 static_assert(std::copy_constructible<int>);
 static_assert(std::copy_constructible<int*>);

libcxx/test/std/concepts/concepts.lang/concept.derived/derived_from.pass.cpp

 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class Derived, class Base>
 // concept derived_from;
 
 #include <concepts>
 #include <type_traits>
 
+#include "test_macros.h"
+
 struct Base1 {};
 struct Derived1 : Base1 {};
 struct Derived2 : Base1 {};
 
 struct DerivedPrivate : private Base1 {};
 struct Derived3 : DerivedPrivate {};
 
 struct DerivedProtected : protected DerivedPrivate {};

libcxx/test/std/concepts/concepts.lang/concept.destructible/destructible.compile.pass.cpp

 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class T>
 // concept destructible = is_nothrow_destructible_v<T>;
 
 #include <concepts>
 #include <type_traits>
 
+#include "test_macros.h"
+
 struct Empty {};
 
 struct Defaulted {
   ~Defaulted() = default;
 };
 struct Deleted {
   ~Deleted() = delete;
 };

libcxx/test/std/concepts/concepts.lang/concept.moveconstructible/move_constructible.compile.pass.cpp

 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class T>
 // concept move_constructible;
 
 #include <concepts>
 #include <type_traits>
 
+#include "test_macros.h"
 #include "type_classification/moveconstructible.h"
 
 static_assert(std::move_constructible<int>);
 static_assert(std::move_constructible<int*>);
 static_assert(std::move_constructible<int&>);
 static_assert(std::move_constructible<int&&>);
 static_assert(std::move_constructible<const int>);
 static_assert(std::move_constructible<const int&>);

libcxx/test/std/concepts/concepts.lang/concept.same/same_as.pass.cpp

 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class T, class U>
 // concept same_as;
 
 #include <concepts>
 #include <type_traits>
 
+#include "test_macros.h"
+
 struct S1 {};
 struct S2 {
   int i;
 
   int& f();
   double g(int x) const;
 };
 struct S3 {

libcxx/test/std/concepts/concepts.lang/concept.swappable/swappable_with.compile.pass.cpp

 #include <map>
 #include <memory>
 #include <optional>
 #include <set>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
+#include "test_macros.h"
 #include "type_classification/moveconstructible.h"
 #include "type_classification/swappable.h"
 
 template <class T, class U>
 constexpr bool check_swappable_with_impl() {
   static_assert(std::swappable_with<T, U> == std::swappable_with<U, T>);
   return std::swappable_with<T, U>;
 }

libcxx/test/std/concepts/concepts.lang/concepts.arithmetic/arithmetic.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 LIBCXX_TEST_CONCEPTS_LANG_CONCEPTS_ARITHMETIC_H_
 #define LIBCXX_TEST_CONCEPTS_LANG_CONCEPTS_ARITHMETIC_H_
 
 #include <concepts>
 
+#include "test_macros.h"
+
 // This overload should never be called. It exists solely to force subsumption.
 template <std::integral I>
 constexpr bool CheckSubsumption(I) {
   return false;
 }
 
 // clang-format off
 template <std::integral I>

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

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

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.categories.pre/zero_type.verify.cpp

 
 // <compare>
 
 // Ensure we reject all cases where an argument other than a literal 0 is used
 // for a comparison against a comparison category type.
 
 #include <compare>
 
+#include "test_macros.h"
+
 #define TEST_FAIL(v, op)                                                       \
   void(v op 0L);                                                               \
   void(0L op v);                                                               \
   void(v op nullptr);                                                          \
   void(nullptr op v);                                                          \
   void(v op(1 - 1));                                                           \
   void((1 - 1) op v)
 

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/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp

 // UNSUPPORTED: libcpp-no-concepts
 
 // template<class T, class U, class Cat = partial_ordering>
 // concept three_way_comparable_with = // see below
 
 #include <compare>
 
 #include "compare_types.h"
+#include "test_macros.h"
 
 template <class T, class U = T, typename Cat = std::partial_ordering>
 constexpr bool check_three_way_comparable_with() {
   constexpr bool result = std::three_way_comparable_with<T, U, Cat>;
   static_assert(std::three_way_comparable_with<U, T, Cat> == result);
   static_assert(std::three_way_comparable_with<T, U const, Cat> == result);
   static_assert(std::three_way_comparable_with<T const, U const, Cat> == result);
   static_assert(std::three_way_comparable_with<T, U const&, Cat> == result);

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size.verify.cpp

 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // REQUIRES: -faligned-allocation
 // ADDITIONAL_COMPILE_FLAGS: -faligned-allocation
 
 #include <new>
 
+#include "test_macros.h"
+
 int main(int, char**) {
     ::operator new[](4);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
     return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align.verify.cpp

 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
 // REQUIRES: -faligned-allocation
 // ADDITIONAL_COMPILE_FLAGS: -faligned-allocation
 
 #include <new>
 
+#include "test_macros.h"
+
 int main(int, char**) {
     ::operator new[](4, std::align_val_t{4});  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
     return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_align_nothrow.verify.cpp

 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
 // REQUIRES: -faligned-allocation
 // ADDITIONAL_COMPILE_FLAGS: -faligned-allocation
 
 #include <new>
 
+#include "test_macros.h"
+
 int main(int, char**) {
     ::operator new[](4, std::align_val_t{4}, std::nothrow);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
     return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.array/new_size_nothrow.verify.cpp

 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // REQUIRES: -faligned-allocation
 // ADDITIONAL_COMPILE_FLAGS: -faligned-allocation
 
 #include <new>
 
+#include "test_macros.h"
+
 int main(int, char**) {
     ::operator new[](4, std::nothrow);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
     return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align.verify.cpp

 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
 // REQUIRES: -faligned-allocation
 // ADDITIONAL_COMPILE_FLAGS: -faligned-allocation
 
 #include <new>
 
+#include "test_macros.h"
+
 int main(int, char**) {
     ::operator new(4, std::align_val_t{4});  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
     return 0;
 }

libcxx/test/std/language.support/support.dynamic/new.delete/new.delete.single/new_size_align_nothrow.verify.cpp

 // nor does the dynamic library shipped with z/OS.
 // UNSUPPORTED: target={{.+}}-zos{{.*}}
 
 // REQUIRES: -faligned-allocation
 // ADDITIONAL_COMPILE_FLAGS: -faligned-allocation
 
 #include <new>
 
+#include "test_macros.h"
+
 int main(int, char**) {
     ::operator new(4, std::align_val_t{4}, std::nothrow);  // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
     return 0;
 }

libcxx/test/std/language.support/support.dynamic/nothrow_t.fail.cpp

 //   explicit nothrow_t() = default;
 // };
 // extern const nothrow_t nothrow;
 
 // This test checks for LWG 2510.
 
 #include <new>
 
+#include "test_macros.h"
 
 std::nothrow_t f() { return {}; } // expected-error 1 {{chosen constructor is explicit in copy-initialization}}
 
 int main(int, char**) {
     return 0;
 }

libcxx/test/std/language.support/support.dynamic/nothrow_t.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // struct nothrow_t {
 //   explicit nothrow_t() = default;
 // };
 // extern const nothrow_t nothrow;
 
 #include <new>
 
+#include "test_macros.h"
 
 int main(int, char**) {
   std::nothrow_t x = std::nothrow;
   (void)x;
 
   return 0;
 }

libcxx/test/std/language.support/support.runtime/cstdlib.aligned_alloc.compile.pass.cpp

 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14}}
 
 // ::aligned_alloc is not implemented on Windows
 // XFAIL: target={{.+}}-windows-{{.+}}
 
 #include <cstdlib>
 #include <type_traits>
 
+#include "test_macros.h"
+
 static_assert(std::is_same<decltype(std::aligned_alloc(1, 0)), void*>::value, "");

libcxx/test/std/language.support/support.runtime/ctime.timespec.compile.pass.cpp

 // Mark the test as unsupported for a transition period, to avoid spurious
 // failures when upgrading the precommit testing environment. After
 // the testing environment is upgraded, we could remove the marking altogether.
 // UNSUPPORTED: target={{.+}}-windows-gnu
 
 #include <ctime>
 #include <type_traits>
 
+#include "test_macros.h"
+
 #ifndef TIME_UTC
 #error TIME_UTC not defined
 #endif
 
 std::timespec tmspec = {};
 static_assert(std::is_same<decltype(std::timespec_get(&tmspec, 0)), int>::value, "");

libcxx/test/std/language.support/support.start.term/quick_exit.pass.cpp

 //       guesses the host triple to be darwin instead of macosx when on macOS.
 // XFAIL: target={{.+}}-apple-macos{{.*}}
 // XFAIL: target={{.+}}-apple-darwin{{.+}}
 
 // test quick_exit and at_quick_exit
 
 #include <cstdlib>
 
+#include "test_macros.h"
+
 void f() {}
 
 int main(int, char**) {
     std::at_quick_exit(f);
     std::quick_exit(0);
     return 0;
 }

libcxx/test/std/language.support/support.types/nullptr_t_integral_cast.compile.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
 //
 //===----------------------------------------------------------------------===//
 
 // typedef decltype(nullptr) nullptr_t;
 
 #include <cstddef>
 
+#include "test_macros.h"
+
 int main(int, char**)
 {
     std::ptrdiff_t i = static_cast<std::ptrdiff_t>(nullptr);
 
   return 0;
 }

libcxx/test/std/numerics/bit/bit.cast/bit_cast.compile.pass.cpp

 //
 // Also check that it's ill-formed when the return type would be
 // ill-formed, even though that is not explicitly mentioned in the
 // specification (but it can be inferred from the synopsis).
 
 #include <bit>
 #include <concepts>
 
+#include "test_macros.h"
+
 template<class To, class From>
 concept bit_cast_is_valid = requires(From from) {
     { std::bit_cast<To>(from) } -> std::same_as<To>;
 };
 
 // Types are not the same size
 namespace ns1 {
     struct To { char a; };

libcxx/test/std/numerics/bit/bit.cast/bit_cast.pass.cpp

 #include <array>
 #include <bit>
 #include <cassert>
 #include <cmath>
 #include <cstdint>
 #include <cstring>
 #include <limits>
 
+#include "test_macros.h"
+
 // std::bit_cast does not preserve padding bits, so if T has padding bits,
 // the results might not memcmp cleanly.
 template<bool HasUniqueObjectRepresentations = true, typename T>
 void test_roundtrip_through_buffer(T from) {
     struct Buffer { char buffer[sizeof(T)]; };
     Buffer middle = std::bit_cast<Buffer>(from);
     T to = std::bit_cast<T>(middle);
     Buffer middle2 = std::bit_cast<Buffer>(to);

libcxx/test/std/numerics/c.math/abs.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 #include <cmath>
 
+#include "test_macros.h"
+
 void f() {
     unsigned int ui = -5;
     (void)std::abs(ui); // expected-error {{call to 'abs' is ambiguous}}
 
     unsigned char uc = -5;
     (void)std::abs(uc); // expected-warning {{taking the absolute value of unsigned type 'unsigned char' has no effect}}
 
     unsigned short us = -5;
     (void)std::abs(us); // expected-warning {{taking the absolute value of unsigned type 'unsigned short' has no effect}}
 
     unsigned long ul = -5;
     (void)std::abs(ul); // expected-error {{call to 'abs' is ambiguous}}
 
     unsigned long long ull = -5;
     (void)std::abs(ull); // expected-error {{call to 'abs' is ambiguous}}
 }

libcxx/test/std/numerics/complex.number/cases.h

 // test cases
 
 #ifndef CASES_H
 #define CASES_H
 
 #include <complex>
 #include <cassert>
 
+#include "test_macros.h"
+
 const std::complex<double> testcases[] =
 {
     std::complex<double>( 1.e-6,  1.e-6),
     std::complex<double>(-1.e-6,  1.e-6),
     std::complex<double>(-1.e-6, -1.e-6),
     std::complex<double>( 1.e-6, -1.e-6),
 
     std::complex<double>( 1.e+6,  1.e-6),

libcxx/test/std/numerics/complex.number/cmplx.over/UDT_is_rejected.fail.cpp

 
 // Test that UDT's convertible to an integral or floating point type do not
 // participate in overload resolution.
 
 #include <complex>
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class IntT>
 struct UDT {
   operator IntT() const { return 1; }
 };
 
 UDT<float> ft;
 UDT<double> dt;
 UDT<long double> ldt;

libcxx/test/std/numerics/complex.number/complex.special/double_long_double_implicit.compile.fail.cpp

 // {
 // public:
 //     explicit constexpr complex(const complex<long double>&);
 // };
 
 #include <complex>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main(int, char**)
 {
     const std::complex<long double> cd(2.5, 3.5);
     std::complex<double> cf = cd;
     assert(cf.real() == cd.real());
     assert(cf.imag() == cd.imag());
 
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.special/float_double_implicit.compile.fail.cpp

 // {
 // public:
 //     explicit constexpr complex(const complex<double>&);
 // };
 
 #include <complex>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main(int, char**)
 {
     const std::complex<double> cd(2.5, 3.5);
     std::complex<float> cf = cd;
     assert(cf.real() == cd.real());
     assert(cf.imag() == cd.imag());
 
   return 0;
 }

libcxx/test/std/numerics/complex.number/complex.special/float_long_double_implicit.compile.fail.cpp

 // {
 // public:
 //     explicit constexpr complex(const complex<long double>&);
 // };
 
 #include <complex>
 #include <cassert>
 
+#include "test_macros.h"
+
 int main(int, char**)
 {
     const std::complex<long double> cd(2.5, 3.5);
     std::complex<float> cf = cd;
     assert(cf.real() == cd.real());
     assert(cf.imag() == cd.imag());
 
   return 0;
 }

libcxx/test/std/numerics/numarray/template.gslice.array/default.compile.fail.cpp

 
 // template <class T> class gslice_array
 
 // gslice_array() = delete;
 
 #include <valarray>
 #include <type_traits>
 
+#include "test_macros.h"
+
 int main(int, char**)
 {
     std::gslice_array<int> gs;
 
   return 0;
 }

libcxx/test/std/numerics/numarray/template.indirect.array/default.compile.fail.cpp

 
 // template <class T> class indirect_array
 
 // indirect_array() = delete;
 
 #include <valarray>
 #include <type_traits>
 
+#include "test_macros.h"
+
 int main(int, char**)
 {
     std::indirect_array<int> ia;
 
   return 0;
 }

libcxx/test/std/numerics/numarray/template.mask.array/default.compile.fail.cpp

 
 // template <class T> class mask_array
 
 // mask_array() = delete;
 
 #include <valarray>
 #include <type_traits>
 
+#include "test_macros.h"
+
 int main(int, char**)
 {
     std::mask_array<int> s;
 
   return 0;
 }

libcxx/test/std/numerics/numarray/template.slice.array/default.compile.fail.cpp

 
 // template <class T> class slice_array
 
 // slice_array() = delete;
 
 #include <valarray>
 #include <type_traits>
 
+#include "test_macros.h"
+
 int main(int, char**)
 {
     std::slice_array<int> s;
 
   return 0;
 }

libcxx/test/std/numerics/numbers/defined.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
 
 #include <numbers>
 
+#include "test_macros.h"
+
 constexpr bool tests() {
   [[maybe_unused]] const double* dd0{&std::numbers::e};
   [[maybe_unused]] const double* dd1{&std::numbers::log2e};
   [[maybe_unused]] const double* dd2{&std::numbers::log10e};
   [[maybe_unused]] const double* dd3{&std::numbers::pi};
   [[maybe_unused]] const double* dd4{&std::numbers::inv_pi};
   [[maybe_unused]] const double* dd5{&std::numbers::inv_sqrtpi};
   [[maybe_unused]] const double* dd6{&std::numbers::ln2};

libcxx/test/std/numerics/numbers/illformed.verify.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
 
 #include <numbers>
 
+#include "test_macros.h"
+
 // Initializing the primary template is ill-formed.
 int log2e{std::numbers::log2e_v<
     int>}; // expected-error-re@numbers:* {{static_assert failed {{.*}} "A program that instantiates a primary template of a mathematical constant variable template is ill-formed."}}
 int log10e{std::numbers::log10e_v<int>};
 int pi{std::numbers::pi_v<int>};
 int inv_pi{std::numbers::inv_pi_v<int>};
 int inv_sqrtpi{std::numbers::inv_sqrtpi_v<int>};
 int ln2{std::numbers::ln2_v<int>};
 int ln10{std::numbers::ln10_v<int>};
 int sqrt2{std::numbers::sqrt2_v<int>};
 int sqrt3{std::numbers::sqrt3_v<int>};
 int inv_sqrt3{std::numbers::inv_sqrt3_v<int>};
 int egamma{std::numbers::egamma_v<int>};
 int phi{std::numbers::phi_v<int>};
 
 int main(int, char**) { return 0; }

libcxx/test/std/numerics/numbers/specialize.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
 
 #include <cassert>
 #include <numbers>
 
+#include "test_macros.h"
+
 constexpr bool tests() {
   [[maybe_unused]] float f0{std::numbers::e_v<float>};
   [[maybe_unused]] float f1{std::numbers::log2e_v<float>};
   [[maybe_unused]] float f2{std::numbers::log10e_v<float>};
   [[maybe_unused]] float f3{std::numbers::pi_v<float>};
   [[maybe_unused]] float f4{std::numbers::inv_pi_v<float>};
   [[maybe_unused]] float f5{std::numbers::inv_sqrtpi_v<float>};
   [[maybe_unused]] float f6{std::numbers::ln2_v<float>};

libcxx/test/std/numerics/numbers/user_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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 
 #include <numbers>
 
+#include "test_macros.h"
+
 struct user {
   int value;
 };
 
 template <>
 user std::numbers::e_v<user>{};
 
 template <>

libcxx/test/std/numerics/numbers/value.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
 
 #include <cassert>
 #include <numbers>
 
+#include "test_macros.h"
+
 constexpr bool tests() {
   assert(std::numbers::e == 0x1.5bf0a8b145769p+1);
   assert(std::numbers::e_v<double> == 0x1.5bf0a8b145769p+1);
   assert(std::numbers::e_v<long double> == 0x1.5bf0a8b145769p+1l);
   assert(std::numbers::e_v<float> == 0x1.5bf0a8p+1f);
 
   assert(std::numbers::log2e == 0x1.71547652b82fep+0);
   assert(std::numbers::log2e_v<double> == 0x1.71547652b82fep+0);

libcxx/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool1.compile.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, c++11, c++14
 // <numeric>
 
 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> gcd(_M __m, _N __n)
 
 // Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
+#include "test_macros.h"
+
 
 int main(int, char**)
 {
     std::gcd(false, 4);
 
   return 0;
 }

libcxx/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool2.compile.fail.cpp

 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> gcd(_M __m, _N __n)
 
 // Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
+#include "test_macros.h"
 
 int main(int, char**)
 {
     std::gcd(2, true);
 
   return 0;
 }

libcxx/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool3.compile.fail.cpp

 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> gcd(_M __m, _N __n)
 
 // Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
+#include "test_macros.h"
 
 int main(int, char**)
 {
     std::gcd<volatile bool, int>(false, 4);
 
   return 0;
 }

libcxx/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.bool4.compile.fail.cpp

 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> gcd(_M __m, _N __n)
 
 // Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
+#include "test_macros.h"
 
 int main(int, char**)
 {
     std::gcd<int, const bool>(2, true);
 
   return 0;
 }

libcxx/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral1.compile.fail.cpp

 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> gcd(_M __m, _N __n)
 
 // Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
+#include "test_macros.h"
 
 int main(int, char**)
 {
     std::gcd(2.0, 4);
 
   return 0;
 }

libcxx/test/std/numerics/numeric.ops/numeric.ops.gcd/gcd.not_integral2.compile.fail.cpp

 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> gcd(_M __m, _N __n)
 
 // Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
+#include "test_macros.h"
 
 int main(int, char**)
 {
     std::gcd(4, 6.0);
 
   return 0;
 }

libcxx/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool1.compile.fail.cpp

 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> lcm(_M __m, _N __n)
 
 // Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
+#include "test_macros.h"
 
 int main(int, char**)
 {
     std::lcm(false, 4);
 
   return 0;
 }

libcxx/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool2.compile.fail.cpp

 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> lcm(_M __m, _N __n)
 
 // Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
+#include "test_macros.h"
 
 int main(int, char**)
 {
     std::lcm(2, true);
 
   return 0;
 }

libcxx/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool3.compile.fail.cpp

 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> lcm(_M __m, _N __n)
 
 // Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
+#include "test_macros.h"
 
 int main(int, char**)
 {
     std::lcm<volatile bool, int>(false, 4);
 
   return 0;
 }

libcxx/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.bool4.compile.fail.cpp

 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> lcm(_M __m, _N __n)
 
 // Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
+#include "test_macros.h"
 
 int main(int, char**)
 {
     std::lcm<int, const bool>(2, true);
 
   return 0;
 }

libcxx/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral1.compile.fail.cpp

 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> lcm(_M __m, _N __n)
 
 // Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
+#include "test_macros.h"
 
 int main(int, char**)
 {
     std::lcm(2.0, 4);
 
   return 0;
 }

libcxx/test/std/numerics/numeric.ops/numeric.ops.lcm/lcm.not_integral2.compile.fail.cpp

 // template<class _M, class _N>
 // constexpr common_type_t<_M,_N> lcm(_M __m, _N __n)
 
 // Remarks: If either M or N is not an integer type,
 // or if either is (a possibly cv-qualified) bool, the program is ill-formed.
 
 #include <numeric>
 
+#include "test_macros.h"
 
 int main(int, char**)
 {
     std::lcm(4, 6.0);
 
   return 0;
 }

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

 
 // template<class _URNG> result_type operator()(_URNG& g);
 
 #include <random>
 #include <numeric>
 #include <vector>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class T>
 inline
 T
 sqr(T x)
 {
     return x * x;
 }
 

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

 
 // template<class _URNG> result_type operator()(_URNG& g);
 
 #include <random>
 #include <numeric>
 #include <vector>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class T>
 inline
 T
 sqr(T x)
 {
     return x * x;
 }
 

libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/params.fail.cpp

 
 // template <class UIntType, UIntType a, UIntType c, UIntType m>
 //   class linear_congruential_engine;
 
 // requirements on parameters
 
 #include <random>
 
+#include "test_macros.h"
+
 int main(int, char**)
 {
     typedef unsigned long long T;
 
     // expected-error@*:* {{static_assert failed due to requirement '1ULL == 0 || 1ULL < 1ULL' "linear_congruential_engine invalid parameters"}}
     std::linear_congruential_engine<T, 0, 0, 0> e2;
     // expected-error@*:* {{static_assert failed due to requirement '1ULL == 0 || 1ULL < 1ULL' "linear_congruential_engine invalid parameters"}}
     std::linear_congruential_engine<T, 0, 1, 1> e3;
     std::linear_congruential_engine<T, 1, 0, 1> e4;
     // expected-error@*:* {{static_assert failed due to requirement 'is_unsigned<int>::value' "_UIntType must be unsigned type"}}
     std::linear_congruential_engine<int, 0, 0, 0> e5;
 
     return 0;
 }

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 TEST_HAS_NO_INT128
 static_assert(std::uniform_random_bit_generator<
               std::subtract_with_carry_engine<__uint128_t, 1U, 2U, 3U> >);
 #endif
 

libcxx/test/std/numerics/rand/rand.util/rand.util.seedseq/assign.compile.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
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // class seed_seq;
 
 // seed_seq();
 
 #include <random>
 
+#include "test_macros.h"
+
 int main(int, char**)
 {
     std::seed_seq s0;
     std::seed_seq s;
     s = s0;
 
   return 0;
 }

libcxx/test/std/numerics/rand/rand.util/rand.util.seedseq/copy.compile.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
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 // class seed_seq;
 
 // seed_seq();
 
 #include <random>
 
+#include "test_macros.h"
+
 int main(int, char**)
 {
     std::seed_seq s0;
     std::seed_seq s(s0);
 
   return 0;
 }