[libcxx] rearranges all concept tests

[cjdb]

Summary

moves tests into directories matching their stable names so that the
tests can reflect the concept name

[ldionne]

I'm fine with this but I would like to see CI passing. Is this based on top of another patch that isn't in main? Also, if we agree that we don't like .compile.pass.cpp tests, I think we should get rid of that test format completely. I must admit I agree with @EricWF's comment about .compile.pass.cpp tests potentially causing runtime tests to be skipped.

[CaseyCarter]

In D99104#2642503, @ldionne wrote:

I must admit I agree with @EricWF's comment about .compile.pass.cpp tests potentially causing runtime tests to be skipped.

FWIW, we use a convention that main in a compile-only test is annotated (int main() {} // COMPILE-ONLY) to avoid such problems. This convention predates us actually having technology in our test runners to support compile-only tests, or we'd probably be using the superior int main() { return 1; } // COMPILE-ONLY. (Hmmm, I may go make a PR for that change right now.)

[cjdb]

removed the very unnecessary dependency on D98983

[zoecarver]

I won't oppose this patch, but FWIW, I would rather keep the .compile.pass.cpp tests and apply a comment as @CaseyCarter suggested. If there's a comment at the end of the function, I don't think anyone will accidentally modify it (and if they do, it will be easy to catch in review). Then we don't have to slow down the test suite (actually, it would be super interesting to see how much slower the test suite is after this change).

libcxx/test/std/concepts/concepts.callable/concept.regularinvocable/regular_invocable.pass.cpp

20

What do you think about doing this in two patches?

1. rename .compile.pass.cpp -> .pass.cpp.
2. move around the location in tree/rename files.

[• Quuxplusone]

@zoecarver wrote:

If there's a comment at the end of the function, I don't think anyone will accidentally modify it (and if they do, it will be easy to catch in review).

The failure mode to defend against is "someone creates a new .compile.pass.cpp test (maybe brain fart, or maybe because they think that's just the naming convention), without adding such a comment; and then adds runtime assertions to it." But suppose we have no .compile.pass.cpp tests checked in, so that nobody ever creates a new one by accident (because there's no old ones to copy); then that failure mode goes away forever. Also, any need to explain the difference to newbies also goes away. I think that getting into that world would be worth some (but not an arbitrarily large) buildbot slowdown.

It might be interesting for someone to measure the slowdown from globally changing all .compile.pass.cpp tests into .pass.cpp tests.

[cjdb]

libcxx/test/std/concepts/concepts.callable/concept.regularinvocable/regular_invocable.pass.cpp

20

What's the motivation? I'm not against it, just want to make sure the effort is justified.

[cjdb]

@zoecarver, for your inspection

[ldionne]

The original motivation for .compile.pass.cpp is to avoid running the tests when it's not needed. It doesn't actually matter in any current configuration we test in the CI, but it does matter a bit more when the executor is slow, for example when running the tests through SSH or when running on an emulator for some embedded chip. I still think it would be reasonable to get rid of them for the reasons explained by others, but I wanted to clarify what the actual purpose of that test format is.

[zoecarver]

Thanks for separating the patches. Now it's super easy to verify correctness. This LGTM (sans the comment about functions.h).

libcxx/test/std/concepts/callable/invocable.compile.pass.cpp

21

Where else is functions.h used? Maybe we should move it into this directory. Or maybe in the support folder?

[cjdb]

Will merge once CI passes.

libcxx/test/std/concepts/callable/invocable.compile.pass.cpp

21

I deliberately kept this one here because it's pretty specific to the tests for [concepts.callable] (and if I get my way, functions.h will be deleted in D99398).

[cjdb]

rebases to (hopefully) fix CI

libcxx/test/std/concepts/concepts.callable/concept.invocable/invocable.compile.pass.cpp

 // concept invocable;
 
 #include <chrono>
 #include <concepts>
 #include <memory>
 #include <random>
 #include <type_traits>
 
-#include "functions.h"
+#include "../functions.h"
 
+// clang-format off
 template <class F, class... Args>
-requires std::invocable<F, Args...> constexpr void
-ModelsInvocable(F, Args&&...) noexcept{};
+requires std::invocable<F, Args...>
+constexpr void ModelsInvocable(F, Args&&...) noexcept{}
 
 template <class F, class... Args>
-requires(!std::invocable<F, Args...>) constexpr
-    void NotInvocable(F, Args&&...) noexcept {}
+requires(!std::invocable<F, Args...>)
+constexpr void NotInvocable(F, Args&&...) noexcept {}
+// clang-format on
 
 static_assert(!std::invocable<void>);
 static_assert(!std::invocable<void*>);
 static_assert(!std::invocable<int>);
 static_assert(!std::invocable<int&>);
 static_assert(!std::invocable<int&&>);
 
 int main(int, char**) {

libcxx/test/std/concepts/concepts.callable/concept.regularinvocable/regular_invocable.pass.cpp

 // template<class T, class U>
 // concept regular_invocable;
 
 #include <concepts>
 #include <memory>
 #include <random>
 #include <type_traits>
 
-#include "functions.h"
+#include "../functions.h"
 
 template <class F, class... Args>
 requires std::invocable<F, Args...> constexpr void
 ModelsRegularInvocable(F, Args&&...) noexcept{};
 
 template <class F, class... Args>
 requires(!std::invocable<F, Args...>) constexpr
     void NotRegularInvocable(F, Args&&...) noexcept {}

libcxx/test/std/concepts/concepts.callable/functions.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 CALLABLE_FUNCTIONS_H
 #define CALLABLE_FUNCTIONS_H
 
 namespace RegularInvocable {
 struct A {
   int I = 13;
   constexpr int F() const noexcept { return 42; }
   constexpr int G(int X) { return 2 * X + 1; }
   constexpr int H(int J) && { return I * J; }
 };
 
 constexpr int F() noexcept { return 13; }
 constexpr int G(int I) { return 2 * I + 1; }
 } // namespace RegularInvocable
 
 namespace Predicate {
 struct L2rSorted {
   template <class T>
   constexpr bool operator()(T const& A, T const& B, T const& C) const noexcept {
     return A <= B && B <= C;
   }
 };
 
 struct NotAPredicate {
   void operator()() const noexcept {}
 };
 } // namespace Predicate
 
 namespace Relation {
 int Greater(int X, int Y) noexcept { return X > Y; }
 } // namespace Relation
 
 #endif // CALLABLE_FUNCTIONS_H

libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable.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 equality_comparable = // see below
 
 #include <concepts>
 
 #include <array>
 #include <deque>
 #include <forward_list>
 #include <list>
 #include <map>
 #include <memory>
 #include <mutex>
 #include <optional>
 #include <set>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 #include "../types.h"
 
 namespace fundamentals {
 static_assert(std::equality_comparable<int>);
 static_assert(std::equality_comparable<double>);
 static_assert(std::equality_comparable<void*>);
 static_assert(std::equality_comparable<char*>);
 static_assert(std::equality_comparable<char const*>);
 static_assert(std::equality_comparable<char volatile*>);
 static_assert(std::equality_comparable<char const volatile*>);
 static_assert(std::equality_comparable<wchar_t&>);
 static_assert(std::equality_comparable<char8_t const&>);
 static_assert(std::equality_comparable<char16_t volatile&>);
 static_assert(std::equality_comparable<char32_t const volatile&>);
 static_assert(std::equality_comparable<unsigned char&&>);
 static_assert(std::equality_comparable<unsigned short const&&>);
 static_assert(std::equality_comparable<unsigned int volatile&&>);
 static_assert(std::equality_comparable<unsigned long const volatile&&>);
 static_assert(std::equality_comparable<int[5]>);
 static_assert(std::equality_comparable<int (*)(int)>);
 static_assert(std::equality_comparable<int (&)(int)>);
 static_assert(std::equality_comparable<int (*)(int) noexcept>);
 static_assert(std::equality_comparable<int (&)(int) noexcept>);
 static_assert(std::equality_comparable<std::nullptr_t>);
 
 struct S {};
 static_assert(std::equality_comparable<int S::*>);
 static_assert(std::equality_comparable<int (S::*)()>);
 static_assert(std::equality_comparable<int (S::*)() noexcept>);
 static_assert(std::equality_comparable<int (S::*)() &>);
 static_assert(std::equality_comparable<int (S::*)() & noexcept>);
 static_assert(std::equality_comparable<int (S::*)() &&>);
 static_assert(std::equality_comparable<int (S::*)() && noexcept>);
 static_assert(std::equality_comparable<int (S::*)() const>);
 static_assert(std::equality_comparable<int (S::*)() const noexcept>);
 static_assert(std::equality_comparable<int (S::*)() const&>);
 static_assert(std::equality_comparable<int (S::*)() const & noexcept>);
 static_assert(std::equality_comparable<int (S::*)() const&&>);
 static_assert(std::equality_comparable<int (S::*)() const && noexcept>);
 static_assert(std::equality_comparable<int (S::*)() volatile>);
 static_assert(std::equality_comparable<int (S::*)() volatile noexcept>);
 static_assert(std::equality_comparable<int (S::*)() volatile&>);
 static_assert(std::equality_comparable<int (S::*)() volatile & noexcept>);
 static_assert(std::equality_comparable<int (S::*)() volatile&&>);
 static_assert(std::equality_comparable<int (S::*)() volatile && noexcept>);
 static_assert(std::equality_comparable<int (S::*)() const volatile>);
 static_assert(std::equality_comparable<int (S::*)() const volatile noexcept>);
 static_assert(std::equality_comparable<int (S::*)() const volatile&>);
 static_assert(std::equality_comparable<int (S::*)() const volatile & noexcept>);
 static_assert(std::equality_comparable<int (S::*)() const volatile&&>);
 static_assert(
     std::equality_comparable<int (S::*)() const volatile && noexcept>);
 
 static_assert(!std::equality_comparable<void>);
 } // namespace fundamentals
 
 namespace standard_types {
 static_assert(std::equality_comparable<std::array<int, 10> >);
 static_assert(std::equality_comparable<std::deque<int> >);
 static_assert(std::equality_comparable<std::forward_list<int> >);
 static_assert(std::equality_comparable<std::list<int> >);
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 static_assert(!std::equality_comparable<std::lock_guard<std::mutex> >);
 static_assert(std::equality_comparable<std::map<int, void*> >);
 static_assert(!std::equality_comparable<std::mutex>);
 static_assert(
     !std::equality_comparable<std::optional<std::lock_guard<std::mutex> > >);
 static_assert(!std::equality_comparable<std::optional<std::mutex> >);
 #endif
 
 static_assert(std::equality_comparable<std::optional<int> >);
 static_assert(std::equality_comparable<std::set<int> >);
 static_assert(std::equality_comparable<std::unordered_map<int, void*> >);
 static_assert(std::equality_comparable<std::unordered_set<int> >);
 static_assert(std::equality_comparable<std::vector<bool> >);
 static_assert(std::equality_comparable<std::vector<int> >);
 } // namespace standard_types
 
 namespace types_fit_for_purpose {
 static_assert(std::equality_comparable<cxx20_member_eq>);
 static_assert(std::equality_comparable<cxx20_friend_eq>);
 static_assert(std::equality_comparable<member_three_way_comparable>);
 static_assert(std::equality_comparable<friend_three_way_comparable>);
 static_assert(std::equality_comparable<explicit_operators>);
 static_assert(std::equality_comparable<eq_neq_different_return_types>);
 static_assert(std::equality_comparable<one_member_one_friend>);
 static_assert(std::equality_comparable<equality_comparable_with_ec1>);
 
 static_assert(!std::equality_comparable<no_eq>);
 static_assert(!std::equality_comparable<no_neq>);
 static_assert(!std::equality_comparable<wrong_return_type_eq>);
 static_assert(!std::equality_comparable<wrong_return_type_ne>);
 static_assert(!std::equality_comparable<wrong_return_type>);
 static_assert(
     !std::equality_comparable<cxx20_member_eq_operator_with_deleted_ne>);
 static_assert(
     !std::equality_comparable<cxx20_friend_eq_operator_with_deleted_ne>);
 static_assert(
     !std::equality_comparable<member_three_way_comparable_with_deleted_eq>);
 static_assert(
     !std::equality_comparable<member_three_way_comparable_with_deleted_ne>);
 static_assert(
     !std::equality_comparable<friend_three_way_comparable_with_deleted_eq>);
 static_assert(
     !std::equality_comparable<friend_three_way_comparable_with_deleted_ne>);
 
 static_assert(!std::equality_comparable<returns_explicit_bool>);
 static_assert(std::equality_comparable<returns_true_type>);
 static_assert(std::equality_comparable<returns_false_type>);
 static_assert(std::equality_comparable<returns_int_ptr>);
 } // namespace types_fit_for_purpose
 
 int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.compare/concept.equalitycomparable/equality_comparable_with.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, class U>
 // concept equality_comparable_with = // see below
 
 #include <concepts>
 
 #include <array>
 #include <deque>
 #include <forward_list>
 #include <list>
 #include <map>
 #include <memory>
 #include <mutex>
 #include <optional>
 #include <set>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 #include "../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(std::equality_comparable_with<T, U const> == result);
   static_assert(std::equality_comparable_with<T const, U const> == result);
   static_assert(std::equality_comparable_with<T, U const&> == result);
   static_assert(std::equality_comparable_with<T const, U const&> == result);
   static_assert(std::equality_comparable_with<T&, U const> == result);
   static_assert(std::equality_comparable_with<T const&, U const> == result);
   static_assert(std::equality_comparable_with<T&, U const&> == result);
   static_assert(std::equality_comparable_with<T const&, U const&> == result);
   static_assert(std::equality_comparable_with<T, U const&&> == result);
   static_assert(std::equality_comparable_with<T const, U const&&> == result);
   static_assert(std::equality_comparable_with<T&, U const&&> == result);
   static_assert(std::equality_comparable_with<T const&, U const&&> == result);
   static_assert(std::equality_comparable_with<T&&, U const> == result);
   static_assert(std::equality_comparable_with<T const&&, U const> == result);
   static_assert(std::equality_comparable_with<T&&, U const&> == result);
   static_assert(std::equality_comparable_with<T const&&, U const&> == result);
   static_assert(std::equality_comparable_with<T&&, U const&&> == result);
   static_assert(std::equality_comparable_with<T const&&, U const&&> == result);
   return result;
 }
 
 namespace fundamentals {
 static_assert(check_equality_comparable_with<int, int>());
 static_assert(check_equality_comparable_with<int, bool>());
 static_assert(check_equality_comparable_with<int, char>());
 static_assert(check_equality_comparable_with<int, wchar_t>());
 static_assert(check_equality_comparable_with<int, double>());
 static_assert(!check_equality_comparable_with<int, int*>());
 static_assert(!check_equality_comparable_with<int, int[5]>());
 static_assert(!check_equality_comparable_with<int, int (*)()>());
 static_assert(!check_equality_comparable_with<int, int (&)()>());
 
 struct S {};
 static_assert(!check_equality_comparable_with<int, int S::*>());
 static_assert(!check_equality_comparable_with<int, int (S::*)()>());
 static_assert(!check_equality_comparable_with<int, int (S::*)() noexcept>());
 static_assert(!check_equality_comparable_with<int, int (S::*)() const>());
 static_assert(
     !check_equality_comparable_with<int, int (S::*)() const noexcept>());
 static_assert(!check_equality_comparable_with<int, int (S::*)() volatile>());
 static_assert(
     !check_equality_comparable_with<int, int (S::*)() volatile noexcept>());
 static_assert(
     !check_equality_comparable_with<int, int (S::*)() const volatile>());
 static_assert(!check_equality_comparable_with<
               int, int (S::*)() const volatile noexcept>());
 static_assert(!check_equality_comparable_with<int, int (S::*)() &>());
 static_assert(!check_equality_comparable_with<int, int (S::*)() & noexcept>());
 static_assert(!check_equality_comparable_with<int, int (S::*)() const&>());
 static_assert(
     !check_equality_comparable_with<int, int (S::*)() const & noexcept>());
 static_assert(!check_equality_comparable_with<int, int (S::*)() volatile&>());
 static_assert(
     !check_equality_comparable_with<int, int (S::*)() volatile & noexcept>());
 static_assert(
     !check_equality_comparable_with<int, int (S::*)() const volatile&>());
 static_assert(!check_equality_comparable_with<int, int (S::*)() const volatile &
                                                        noexcept>());
 static_assert(!check_equality_comparable_with<int, int (S::*)() &&>());
 static_assert(!check_equality_comparable_with < int,
               int (S::*)() && noexcept > ());
 static_assert(!check_equality_comparable_with<int, int (S::*)() const&&>());
 static_assert(!check_equality_comparable_with < int,
               int (S::*)() const&& noexcept > ());
 static_assert(!check_equality_comparable_with<int, int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int,
               int (S::*)() volatile&& noexcept > ());
 static_assert(
     !check_equality_comparable_with<int, int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(check_equality_comparable_with<int*, int*>());
 static_assert(check_equality_comparable_with<int*, int[5]>());
 static_assert(!check_equality_comparable_with<int*, int (*)()>());
 static_assert(!check_equality_comparable_with<int*, int (&)()>());
 static_assert(!check_equality_comparable_with<int*, int (S::*)()>());
 static_assert(!check_equality_comparable_with<int*, int (S::*)() noexcept>());
 static_assert(!check_equality_comparable_with<int*, int (S::*)() const>());
 static_assert(
     !check_equality_comparable_with<int*, int (S::*)() const noexcept>());
 static_assert(!check_equality_comparable_with<int*, int (S::*)() volatile>());
 static_assert(
     !check_equality_comparable_with<int*, int (S::*)() volatile noexcept>());
 static_assert(
     !check_equality_comparable_with<int*, int (S::*)() const volatile>());
 static_assert(!check_equality_comparable_with<
               int*, int (S::*)() const volatile noexcept>());
 static_assert(!check_equality_comparable_with<int*, int (S::*)() &>());
 static_assert(!check_equality_comparable_with<int*, int (S::*)() & noexcept>());
 static_assert(!check_equality_comparable_with<int*, int (S::*)() const&>());
 static_assert(
     !check_equality_comparable_with<int*, int (S::*)() const & noexcept>());
 static_assert(!check_equality_comparable_with<int*, int (S::*)() volatile&>());
 static_assert(
     !check_equality_comparable_with<int*, int (S::*)() volatile & noexcept>());
 static_assert(
     !check_equality_comparable_with<int*, int (S::*)() const volatile&>());
 static_assert(!check_equality_comparable_with<
               int*, int (S::*)() const volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int*, int (S::*)() &&>());
 static_assert(!check_equality_comparable_with < int*,
               int (S::*)() && noexcept > ());
 static_assert(!check_equality_comparable_with<int*, int (S::*)() const&&>());
 static_assert(!check_equality_comparable_with < int*,
               int (S::*)() const&& noexcept > ());
 static_assert(!check_equality_comparable_with<int*, int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int*,
               int (S::*)() volatile&& noexcept > ());
 static_assert(
     !check_equality_comparable_with<int*, int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int*,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(check_equality_comparable_with<int[5], int[5]>());
 static_assert(!check_equality_comparable_with<int[5], int (*)()>());
 static_assert(!check_equality_comparable_with<int[5], int (&)()>());
 static_assert(!check_equality_comparable_with<int[5], int (S::*)()>());
 static_assert(!check_equality_comparable_with<int[5], int (S::*)() noexcept>());
 static_assert(!check_equality_comparable_with<int[5], int (S::*)() const>());
 static_assert(
     !check_equality_comparable_with<int[5], int (S::*)() const noexcept>());
 static_assert(!check_equality_comparable_with<int[5], int (S::*)() volatile>());
 static_assert(
     !check_equality_comparable_with<int[5], int (S::*)() volatile noexcept>());
 static_assert(
     !check_equality_comparable_with<int[5], int (S::*)() const volatile>());
 static_assert(!check_equality_comparable_with<
               int[5], int (S::*)() const volatile noexcept>());
 static_assert(!check_equality_comparable_with<int[5], int (S::*)() &>());
 static_assert(
     !check_equality_comparable_with<int[5], int (S::*)() & noexcept>());
 static_assert(!check_equality_comparable_with<int[5], int (S::*)() const&>());
 static_assert(
     !check_equality_comparable_with<int[5], int (S::*)() const & noexcept>());
 static_assert(
     !check_equality_comparable_with<int[5], int (S::*)() volatile&>());
 static_assert(!check_equality_comparable_with<int[5], int (S::*)() volatile &
                                                           noexcept>());
 static_assert(
     !check_equality_comparable_with<int[5], int (S::*)() const volatile&>());
 static_assert(!check_equality_comparable_with<
               int[5], int (S::*)() const volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int[5], int (S::*)() &&>());
 static_assert(!check_equality_comparable_with < int[5],
               int (S::*)() && noexcept > ());
 static_assert(!check_equality_comparable_with<int[5], int (S::*)() const&&>());
 static_assert(!check_equality_comparable_with < int[5],
               int (S::*)() const&& noexcept > ());
 static_assert(
     !check_equality_comparable_with<int[5], int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int[5],
               int (S::*)() volatile&& noexcept > ());
 static_assert(
     !check_equality_comparable_with<int[5], int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int[5],
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(check_equality_comparable_with<int (*)(), int (*)()>());
 static_assert(check_equality_comparable_with<int (*)(), int (&)()>());
 static_assert(!check_equality_comparable_with<int (*)(), int (S::*)()>());
 static_assert(
     !check_equality_comparable_with<int (*)(), int (S::*)() noexcept>());
 static_assert(!check_equality_comparable_with<int (*)(), int (S::*)() const>());
 static_assert(
     !check_equality_comparable_with<int (*)(), int (S::*)() const noexcept>());
 static_assert(
     !check_equality_comparable_with<int (*)(), int (S::*)() volatile>());
 static_assert(!check_equality_comparable_with<
               int (*)(), int (S::*)() volatile noexcept>());
 static_assert(
     !check_equality_comparable_with<int (*)(), int (S::*)() const volatile>());
 static_assert(!check_equality_comparable_with<
               int (*)(), int (S::*)() const volatile noexcept>());
 static_assert(!check_equality_comparable_with<int (*)(), int (S::*)() &>());
 static_assert(
     !check_equality_comparable_with<int (*)(), int (S::*)() & noexcept>());
 static_assert(
     !check_equality_comparable_with<int (*)(), int (S::*)() const&>());
 static_assert(!check_equality_comparable_with<int (*)(),
                                               int (S::*)() const & noexcept>());
 static_assert(
     !check_equality_comparable_with<int (*)(), int (S::*)() volatile&>());
 static_assert(!check_equality_comparable_with<int (*)(), int (S::*)() volatile &
                                                              noexcept>());
 static_assert(
     !check_equality_comparable_with<int (*)(), int (S::*)() const volatile&>());
 static_assert(!check_equality_comparable_with<
               int (*)(), int (S::*)() const volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (*)(), int (S::*)() &&>());
 static_assert(!check_equality_comparable_with < int (*)(),
               int (S::*)() && noexcept > ());
 static_assert(
     !check_equality_comparable_with<int (*)(), int (S::*)() const&&>());
 static_assert(!check_equality_comparable_with < int (*)(),
               int (S::*)() const&& noexcept > ());
 static_assert(
     !check_equality_comparable_with<int (*)(), int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int (*)(),
               int (S::*)() volatile&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (*)(),
                                               int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int (*)(),
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(check_equality_comparable_with<int (&)(), int (&)()>());
 static_assert(!check_equality_comparable_with<int (&)(), int (S::*)()>());
 static_assert(
     !check_equality_comparable_with<int (&)(), int (S::*)() noexcept>());
 static_assert(!check_equality_comparable_with<int (&)(), int (S::*)() const>());
 static_assert(
     !check_equality_comparable_with<int (&)(), int (S::*)() const noexcept>());
 static_assert(
     !check_equality_comparable_with<int (&)(), int (S::*)() volatile>());
 static_assert(!check_equality_comparable_with<
               int (&)(), int (S::*)() volatile noexcept>());
 static_assert(
     !check_equality_comparable_with<int (&)(), int (S::*)() const volatile>());
 static_assert(!check_equality_comparable_with<
               int (&)(), int (S::*)() const volatile noexcept>());
 static_assert(!check_equality_comparable_with<int (&)(), int (S::*)() &>());
 static_assert(
     !check_equality_comparable_with<int (&)(), int (S::*)() & noexcept>());
 static_assert(
     !check_equality_comparable_with<int (&)(), int (S::*)() const&>());
 static_assert(!check_equality_comparable_with<int (&)(),
                                               int (S::*)() const & noexcept>());
 static_assert(
     !check_equality_comparable_with<int (&)(), int (S::*)() volatile&>());
 static_assert(!check_equality_comparable_with<int (&)(), int (S::*)() volatile &
                                                              noexcept>());
 static_assert(
     !check_equality_comparable_with<int (&)(), int (S::*)() const volatile&>());
 static_assert(!check_equality_comparable_with<
               int (&)(), int (S::*)() const volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (&)(), int (S::*)() &&>());
 static_assert(!check_equality_comparable_with < int (&)(),
               int (S::*)() && noexcept > ());
 static_assert(
     !check_equality_comparable_with<int (&)(), int (S::*)() const&&>());
 static_assert(!check_equality_comparable_with < int (&)(),
               int (S::*)() const&& noexcept > ());
 static_assert(
     !check_equality_comparable_with<int (&)(), int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int (&)(),
               int (S::*)() volatile&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (&)(),
                                               int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int (&)(),
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(check_equality_comparable_with<int (S::*)(), int (S::*)()>());
 static_assert(
     check_equality_comparable_with<int (S::*)(), int (S::*)() noexcept>());
 static_assert(
     !check_equality_comparable_with<int (S::*)(), int (S::*)() const>());
 static_assert(!check_equality_comparable_with<int (S::*)(),
                                               int (S::*)() const noexcept>());
 static_assert(
     !check_equality_comparable_with<int (S::*)(), int (S::*)() volatile>());
 static_assert(!check_equality_comparable_with<
               int (S::*)(), int (S::*)() volatile noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)(),
                                               int (S::*)() const volatile>());
 static_assert(!check_equality_comparable_with<
               int (S::*)(), int (S::*)() const volatile noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)(), int (S::*)() &>());
 static_assert(
     !check_equality_comparable_with<int (S::*)(), int (S::*)() & noexcept>());
 static_assert(
     !check_equality_comparable_with<int (S::*)(), int (S::*)() const&>());
 static_assert(!check_equality_comparable_with<int (S::*)(),
                                               int (S::*)() const & noexcept>());
 static_assert(
     !check_equality_comparable_with<int (S::*)(), int (S::*)() volatile&>());
 static_assert(!check_equality_comparable_with<
               int (S::*)(), int (S::*)() volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)(),
                                               int (S::*)() const volatile&>());
 static_assert(!check_equality_comparable_with<
               int (S::*)(), int (S::*)() const volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)(), int (S::*)() &&>());
 static_assert(!check_equality_comparable_with < int (S::*)(),
               int (S::*)() && noexcept > ());
 static_assert(
     !check_equality_comparable_with<int (S::*)(), int (S::*)() const&&>());
 static_assert(!check_equality_comparable_with < int (S::*)(),
               int (S::*)() const&& noexcept > ());
 static_assert(
     !check_equality_comparable_with<int (S::*)(), int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)(),
               int (S::*)() volatile&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)(),
                                               int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)(),
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(check_equality_comparable_with<int (S::*)() noexcept,
                                              int (S::*)() noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
                                               int (S::*)() const>());
 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
                                               int (S::*)() const noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
                                               int (S::*)() volatile>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() noexcept, int (S::*)() volatile noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
                                               int (S::*)() const volatile>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() noexcept, int (S::*)() const volatile noexcept>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() noexcept, int (S::*)() &>());
 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
                                               int (S::*)() & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
                                               int (S::*)() const&>());
 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
                                               int (S::*)() const & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
                                               int (S::*)() volatile&>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() noexcept, int (S::*)() volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
                                               int (S::*)() const volatile&>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() noexcept, int (S::*)() const volatile & noexcept>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() noexcept, int (S::*)() &&>());
 static_assert(!check_equality_comparable_with < int (S::*)() noexcept,
               int (S::*)() && noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
                                               int (S::*)() const&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() noexcept,
               int (S::*)() const&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
                                               int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() noexcept,
               int (S::*)() volatile&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
                                               int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() noexcept,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(
     check_equality_comparable_with<int (S::*)() const, int (S::*)() const>());
 static_assert(check_equality_comparable_with<int (S::*)() const,
                                              int (S::*)() const noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const,
                                               int (S::*)() volatile>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() const, int (S::*)() volatile noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const,
                                               int (S::*)() const volatile>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() const, int (S::*)() const volatile noexcept>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() const, int (S::*)() &>());
 static_assert(!check_equality_comparable_with<int (S::*)() const,
                                               int (S::*)() & noexcept>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() const, int (S::*)() const&>());
 static_assert(!check_equality_comparable_with<int (S::*)() const,
                                               int (S::*)() const & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const,
                                               int (S::*)() volatile&>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() const, int (S::*)() volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const,
                                               int (S::*)() const volatile&>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() const, int (S::*)() const volatile & noexcept>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() const, int (S::*)() &&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const,
               int (S::*)() && noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() const,
                                               int (S::*)() const&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const,
               int (S::*)() const&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() const,
                                               int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const,
               int (S::*)() volatile&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() const,
                                               int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(check_equality_comparable_with<int (S::*)() const noexcept,
                                              int (S::*)() const noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
                                               int (S::*)() volatile>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() const noexcept, int (S::*)() volatile noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
                                               int (S::*)() const volatile>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() const noexcept,
                                     int (S::*)() const volatile noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
                                               int (S::*)() &>());
 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
                                               int (S::*)() & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
                                               int (S::*)() const&>());
 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
                                               int (S::*)() const & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
                                               int (S::*)() volatile&>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() const noexcept, int (S::*)() volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
                                               int (S::*)() const volatile&>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() const noexcept,
                                     int (S::*)() const volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
                                               int (S::*)() &&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const noexcept,
               int (S::*)() && noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
                                               int (S::*)() const&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const noexcept,
               int (S::*)() const&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
                                               int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const noexcept,
               int (S::*)() volatile&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
                                               int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const noexcept,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(check_equality_comparable_with<int (S::*)() volatile,
                                              int (S::*)() volatile>());
 static_assert(check_equality_comparable_with<int (S::*)() volatile,
                                              int (S::*)() volatile noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile,
                                               int (S::*)() const volatile>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() volatile, int (S::*)() const volatile noexcept>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() volatile, int (S::*)() &>());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile,
                                               int (S::*)() & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile,
                                               int (S::*)() const&>());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile,
                                               int (S::*)() const & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile,
                                               int (S::*)() volatile&>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() volatile, int (S::*)() volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile,
                                               int (S::*)() const volatile&>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() volatile, int (S::*)() const volatile & noexcept>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() volatile, int (S::*)() &&>());
 static_assert(!check_equality_comparable_with < int (S::*)() volatile,
               int (S::*)() && noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile,
                                               int (S::*)() const&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() volatile,
               int (S::*)() const&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile,
                                               int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() volatile,
               int (S::*)() volatile&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile,
                                               int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() volatile,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(check_equality_comparable_with<int (S::*)() volatile noexcept,
                                              int (S::*)() volatile noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
                                               int (S::*)() const volatile>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() volatile noexcept,
                                     int (S::*)() const volatile noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
                                               int (S::*)() &>());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
                                               int (S::*)() & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
                                               int (S::*)() const&>());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
                                               int (S::*)() const & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
                                               int (S::*)() volatile&>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() volatile noexcept,
                                     int (S::*)() volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
                                               int (S::*)() const volatile&>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() volatile noexcept,
                                     int (S::*)() const volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
                                               int (S::*)() &&>());
 static_assert(!check_equality_comparable_with < int (S::*)() volatile noexcept,
               int (S::*)() && noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
                                               int (S::*)() const&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() volatile noexcept,
               int (S::*)() const&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
                                               int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() volatile noexcept,
               int (S::*)() volatile&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
                                               int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() volatile noexcept,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(check_equality_comparable_with<int (S::*)() const volatile,
                                              int (S::*)() const volatile>());
 static_assert(
     check_equality_comparable_with<int (S::*)() const volatile,
                                    int (S::*)() const volatile noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
                                               int (S::*)() &>());
 static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
                                               int (S::*)() & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
                                               int (S::*)() const&>());
 static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
                                               int (S::*)() const & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
                                               int (S::*)() volatile&>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() const volatile, int (S::*)() volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
                                               int (S::*)() const volatile&>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() const volatile,
                                     int (S::*)() const volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
                                               int (S::*)() &&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const volatile,
               int (S::*)() && noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
                                               int (S::*)() const&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const volatile,
               int (S::*)() const&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
                                               int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const volatile,
               int (S::*)() volatile&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
                                               int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const volatile,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(
     check_equality_comparable_with<int (S::*)() const volatile noexcept,
                                    int (S::*)() const volatile noexcept>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() const volatile noexcept, int (S::*)() &>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() const volatile noexcept, int (S::*)() & noexcept>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() const volatile noexcept, int (S::*)() const&>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() const volatile noexcept,
                                     int (S::*)() const & noexcept>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() const volatile noexcept, int (S::*)() volatile&>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() const volatile noexcept,
                                     int (S::*)() volatile & noexcept>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() const volatile noexcept,
                                     int (S::*)() const volatile&>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() const volatile noexcept,
                                     int (S::*)() const volatile & noexcept>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() const volatile noexcept, int (S::*)() &&>());
 static_assert(!check_equality_comparable_with < int (S::*)()
                                                     const volatile noexcept,
               int (S::*)() && noexcept > ());
 static_assert(!check_equality_comparable_with<
               int (S::*)() const volatile noexcept, int (S::*)() const&&>());
 static_assert(!check_equality_comparable_with < int (S::*)()
                                                     const volatile noexcept,
               int (S::*)() const&& noexcept > ());
 static_assert(!check_equality_comparable_with<
               int (S::*)() const volatile noexcept, int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)()
                                                     const volatile noexcept,
               int (S::*)() volatile&& noexcept > ());
 static_assert(
     !check_equality_comparable_with<int (S::*)() const volatile noexcept,
                                     int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)()
                                                     const volatile noexcept,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(check_equality_comparable_with<int (S::*)() &, int (S::*)() &>());
 static_assert(
     check_equality_comparable_with<int (S::*)() &, int (S::*)() & noexcept>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() &, int (S::*)() const&>());
 static_assert(!check_equality_comparable_with<int (S::*)() &,
                                               int (S::*)() const & noexcept>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() &, int (S::*)() volatile&>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() &, int (S::*)() volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() &,
                                               int (S::*)() const volatile&>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() &, int (S::*)() const volatile & noexcept>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() &, int (S::*)() &&>());
 static_assert(!check_equality_comparable_with < int (S::*)() &,
               int (S::*)() && noexcept > ());
 static_assert(
     !check_equality_comparable_with<int (S::*)() &, int (S::*)() const&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() &,
               int (S::*)() const&& noexcept > ());
 static_assert(
     !check_equality_comparable_with<int (S::*)() &, int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() &,
               int (S::*)() volatile&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() &,
                                               int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() &,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(check_equality_comparable_with<int (S::*)() & noexcept,
                                              int (S::*)() & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
                                               int (S::*)() const&>());
 static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
                                               int (S::*)() const & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
                                               int (S::*)() volatile&>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() & noexcept, int (S::*)() volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
                                               int (S::*)() const volatile&>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() & noexcept,
                                     int (S::*)() const volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
                                               int (S::*)() &&>());
 static_assert(!check_equality_comparable_with < int (S::*)() & noexcept,
               int (S::*)() && noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
                                               int (S::*)() const&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() & noexcept,
               int (S::*)() const&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
                                               int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() & noexcept,
               int (S::*)() volatile&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
                                               int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() & noexcept,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(
     check_equality_comparable_with<int (S::*)() const&, int (S::*)() const&>());
 static_assert(check_equality_comparable_with<int (S::*)() const&,
                                              int (S::*)() const & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const&,
                                               int (S::*)() volatile&>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() const&, int (S::*)() volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const&,
                                               int (S::*)() const volatile&>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() const&, int (S::*)() const volatile & noexcept>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() const&, int (S::*)() &&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const&,
               int (S::*)() && noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() const&,
                                               int (S::*)() const&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const&,
               int (S::*)() const&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() const&,
                                               int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const&,
               int (S::*)() volatile&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() const&,
                                               int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const&,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(check_equality_comparable_with<int (S::*)() const & noexcept,
                                              int (S::*)() const & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
                                               int (S::*)() volatile&>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() const & noexcept,
                                     int (S::*)() volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
                                               int (S::*)() const volatile&>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() const & noexcept,
                                     int (S::*)() const volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
                                               int (S::*)() &&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const& noexcept,
               int (S::*)() && noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
                                               int (S::*)() const&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const& noexcept,
               int (S::*)() const&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
                                               int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const& noexcept,
               int (S::*)() volatile&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
                                               int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const& noexcept,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(check_equality_comparable_with<int (S::*)() volatile&,
                                              int (S::*)() volatile&>());
 static_assert(check_equality_comparable_with<
               int (S::*)() volatile&, int (S::*)() volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile&,
                                               int (S::*)() const volatile&>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() volatile&,
                                     int (S::*)() const volatile & noexcept>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() volatile&, int (S::*)() &&>());
 static_assert(!check_equality_comparable_with < int (S::*)() volatile&,
               int (S::*)() && noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile&,
                                               int (S::*)() const&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() volatile&,
               int (S::*)() const&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile&,
                                               int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() volatile&,
               int (S::*)() volatile&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile&,
                                               int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() volatile&,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(
     check_equality_comparable_with<int (S::*)() volatile & noexcept,
                                    int (S::*)() volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile & noexcept,
                                               int (S::*)() const volatile&>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() volatile & noexcept,
                                     int (S::*)() const volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile & noexcept,
                                               int (S::*)() &&>());
 static_assert(!check_equality_comparable_with < int (S::*)() volatile& noexcept,
               int (S::*)() && noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile & noexcept,
                                               int (S::*)() const&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() volatile& noexcept,
               int (S::*)() const&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile & noexcept,
                                               int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() volatile& noexcept,
               int (S::*)() volatile&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile & noexcept,
                                               int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() volatile& noexcept,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(check_equality_comparable_with<int (S::*)() const volatile&,
                                              int (S::*)() const volatile&>());
 static_assert(
     check_equality_comparable_with<int (S::*)() const volatile&,
                                    int (S::*)() const volatile & noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const volatile&,
                                               int (S::*)() &&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const volatile&,
               int (S::*)() && noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() const volatile&,
                                               int (S::*)() const&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const volatile&,
               int (S::*)() const&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() const volatile&,
                                               int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const volatile&,
               int (S::*)() volatile&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() const volatile&,
                                               int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const volatile&,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(
     check_equality_comparable_with<int (S::*)() const volatile & noexcept,
                                    int (S::*)() const volatile & noexcept>());
 static_assert(!check_equality_comparable_with<
               int (S::*)() const volatile & noexcept, int (S::*)() &&>());
 static_assert(!check_equality_comparable_with < int (S::*)()
                                                     const volatile& noexcept,
               int (S::*)() && noexcept > ());
 static_assert(!check_equality_comparable_with<
               int (S::*)() const volatile & noexcept, int (S::*)() const&&>());
 static_assert(!check_equality_comparable_with < int (S::*)()
                                                     const volatile& noexcept,
               int (S::*)() const&& noexcept > ());
 static_assert(
     !check_equality_comparable_with<int (S::*)() const volatile & noexcept,
                                     int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)()
                                                     const volatile& noexcept,
               int (S::*)() volatile&& noexcept > ());
 static_assert(
     !check_equality_comparable_with<int (S::*)() const volatile & noexcept,
                                     int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)()
                                                     const volatile& noexcept,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(
     check_equality_comparable_with<int (S::*)() &&, int (S::*)() &&>());
 static_assert(check_equality_comparable_with<int (S::*)() &&,
                                              int (S::*)() && noexcept>());
 static_assert(
     !check_equality_comparable_with<int (S::*)() &&, int (S::*)() const&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() &&,
               int (S::*)() const&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() &&,
                                               int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() &&,
               int (S::*)() volatile&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() &&,
                                               int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() &&,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(check_equality_comparable_with<int (S::*)() && noexcept,
                                              int (S::*)() && noexcept>());
 static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
               int (S::*)() const&& > ());
 static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
               int (S::*)() const&& noexcept > ());
 static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
               int (S::*)() volatile&& > ());
 static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
               int (S::*)() volatile&& noexcept > ());
 static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
               int (S::*)() const volatile&& > ());
 static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(check_equality_comparable_with<int (S::*)() const&&,
                                              int (S::*)() const&&>());
 static_assert(check_equality_comparable_with<int (S::*)() const&&,
                                              int (S::*)() const && noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() const&&,
                                               int (S::*)() volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const&&,
               int (S::*)() volatile&& noexcept > ());
 static_assert(!check_equality_comparable_with<int (S::*)() const&&,
                                               int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() const&&,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(check_equality_comparable_with<int (S::*)() const && noexcept,
                                              int (S::*)() const && noexcept>());
 static_assert(!check_equality_comparable_with < int (S::*)() const&& noexcept,
               int (S::*)() volatile&& > ());
 static_assert(!check_equality_comparable_with < int (S::*)() const&& noexcept,
               int (S::*)() volatile&& noexcept > ());
 static_assert(!check_equality_comparable_with < int (S::*)() const&& noexcept,
               int (S::*)() const volatile&& > ());
 static_assert(!check_equality_comparable_with < int (S::*)() const&& noexcept,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(check_equality_comparable_with<int (S::*)() volatile&&,
                                              int (S::*)() volatile&&>());
 static_assert(check_equality_comparable_with<
               int (S::*)() volatile&&, int (S::*)() volatile && noexcept>());
 static_assert(!check_equality_comparable_with<int (S::*)() volatile&&,
                                               int (S::*)() const volatile&&>());
 static_assert(!check_equality_comparable_with < int (S::*)() volatile&&,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(
     check_equality_comparable_with<int (S::*)() volatile && noexcept,
                                    int (S::*)() volatile && noexcept>());
 static_assert(!check_equality_comparable_with <
                   int (S::*)() volatile&& noexcept,
               int (S::*)() const volatile&& > ());
 static_assert(!check_equality_comparable_with <
                   int (S::*)() volatile&& noexcept,
               int (S::*)() const volatile&& noexcept > ());
 
 static_assert(check_equality_comparable_with<int (S::*)() const volatile&&,
                                              int (S::*)() const volatile&&>());
 static_assert(
     check_equality_comparable_with<int (S::*)() const volatile&&,
                                    int (S::*)() const volatile && noexcept>());
 static_assert(
     check_equality_comparable_with<int (S::*)() const volatile && noexcept,
                                    int (S::*)() const volatile && noexcept>());
 
 static_assert(!check_equality_comparable_with<std::nullptr_t, int>());
 static_assert(check_equality_comparable_with<std::nullptr_t, int*>());
 static_assert(check_equality_comparable_with<std::nullptr_t, int[5]>());
 static_assert(check_equality_comparable_with<std::nullptr_t, int (*)()>());
 static_assert(check_equality_comparable_with<std::nullptr_t, int (&)()>());
 static_assert(check_equality_comparable_with<std::nullptr_t, int (S::*)()>());
 static_assert(
     check_equality_comparable_with<std::nullptr_t, int (S::*)() noexcept>());
 static_assert(
     check_equality_comparable_with<std::nullptr_t, int (S::*)() const>());
 static_assert(check_equality_comparable_with<std::nullptr_t,
                                              int (S::*)() const noexcept>());
 static_assert(
     check_equality_comparable_with<std::nullptr_t, int (S::*)() volatile>());
 static_assert(check_equality_comparable_with<std::nullptr_t,
                                              int (S::*)() volatile noexcept>());
 static_assert(check_equality_comparable_with<std::nullptr_t,
                                              int (S::*)() const volatile>());
 static_assert(check_equality_comparable_with<
               std::nullptr_t, int (S::*)() const volatile noexcept>());
 static_assert(check_equality_comparable_with<std::nullptr_t, int (S::*)() &>());
 static_assert(
     check_equality_comparable_with<std::nullptr_t, int (S::*)() & noexcept>());
 static_assert(
     check_equality_comparable_with<std::nullptr_t, int (S::*)() const&>());
 static_assert(check_equality_comparable_with<std::nullptr_t,
                                              int (S::*)() const & noexcept>());
 static_assert(
     check_equality_comparable_with<std::nullptr_t, int (S::*)() volatile&>());
 static_assert(check_equality_comparable_with<
               std::nullptr_t, int (S::*)() volatile & noexcept>());
 static_assert(check_equality_comparable_with<std::nullptr_t,
                                              int (S::*)() const volatile&>());
 static_assert(check_equality_comparable_with<
               std::nullptr_t, int (S::*)() const volatile & noexcept>());
 static_assert(
     check_equality_comparable_with<std::nullptr_t, int (S::*)() &&>());
 static_assert(
     check_equality_comparable_with<std::nullptr_t, int (S::*)() && noexcept>());
 static_assert(
     check_equality_comparable_with<std::nullptr_t, int (S::*)() const&&>());
 static_assert(check_equality_comparable_with<std::nullptr_t,
                                              int (S::*)() const && noexcept>());
 static_assert(
     check_equality_comparable_with<std::nullptr_t, int (S::*)() volatile&&>());
 static_assert(check_equality_comparable_with<
               std::nullptr_t, int (S::*)() volatile && noexcept>());
 static_assert(check_equality_comparable_with<std::nullptr_t,
                                              int (S::*)() const volatile&&>());
 static_assert(check_equality_comparable_with<
               std::nullptr_t, int (S::*)() const volatile && noexcept>());
 
 static_assert(!std::equality_comparable_with<void, int>);
 static_assert(!std::equality_comparable_with<void, int*>);
 static_assert(!std::equality_comparable_with<void, std::nullptr_t>);
 static_assert(!std::equality_comparable_with<void, int[5]>);
 static_assert(!std::equality_comparable_with<void, int (*)()>);
 static_assert(!std::equality_comparable_with<void, int (&)()>);
 static_assert(!std::equality_comparable_with<void, int S::*>);
 static_assert(!std::equality_comparable_with<void, int (S::*)()>);
 static_assert(!std::equality_comparable_with<void, int (S::*)() noexcept>);
 static_assert(!std::equality_comparable_with<void, int (S::*)() const>);
 static_assert(
     !std::equality_comparable_with<void, int (S::*)() const noexcept>);
 static_assert(!std::equality_comparable_with<void, int (S::*)() volatile>);
 static_assert(
     !std::equality_comparable_with<void, int (S::*)() volatile noexcept>);
 static_assert(
     !std::equality_comparable_with<void, int (S::*)() const volatile>);
 static_assert(
     !std::equality_comparable_with<void, int (S::*)() const volatile noexcept>);
 static_assert(!std::equality_comparable_with<void, int (S::*)() &>);
 static_assert(!std::equality_comparable_with<void, int (S::*)() & noexcept>);
 static_assert(!std::equality_comparable_with<void, int (S::*)() const&>);
 static_assert(
     !std::equality_comparable_with<void, int (S::*)() const & noexcept>);
 static_assert(!std::equality_comparable_with<void, int (S::*)() volatile&>);
 static_assert(
     !std::equality_comparable_with<void, int (S::*)() volatile & noexcept>);
 static_assert(
     !std::equality_comparable_with<void, int (S::*)() const volatile&>);
 static_assert(!std::equality_comparable_with<void, int (S::*)() const volatile &
                                                        noexcept>);
 static_assert(!std::equality_comparable_with<void, int (S::*)() &&>);
 static_assert(!std::equality_comparable_with < void,
               int (S::*)() && noexcept >);
 static_assert(!std::equality_comparable_with<void, int (S::*)() const&&>);
 static_assert(!std::equality_comparable_with < void,
               int (S::*)() const&& noexcept >);
 static_assert(!std::equality_comparable_with<void, int (S::*)() volatile&&>);
 static_assert(!std::equality_comparable_with < void,
               int (S::*)() volatile&& noexcept >);
 static_assert(
     !std::equality_comparable_with<void, int (S::*)() const volatile&&>);
 static_assert(!std::equality_comparable_with < void,
               int (S::*)() const volatile&& noexcept >);
 } // namespace fundamentals
 
 namespace standard_types {
 static_assert(check_equality_comparable_with<std::array<int, 10>,
                                              std::array<int, 10> >());
 static_assert(!check_equality_comparable_with<std::array<int, 10>,
                                               std::array<double, 10> >());
 static_assert(
     check_equality_comparable_with<std::deque<int>, std::deque<int> >());
 static_assert(
     !check_equality_comparable_with<std::deque<int>, std::vector<int> >());
 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
 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
 
 static_assert(check_equality_comparable_with<std::map<int, void*>,
                                              std::map<int, void*> >());
 static_assert(
     !check_equality_comparable_with<std::map<int, void*>, std::vector<int> >());
 static_assert(
     check_equality_comparable_with<std::optional<std::vector<int> >,
                                    std::optional<std::vector<int> > >());
 static_assert(check_equality_comparable_with<std::optional<std::vector<int> >,
                                              std::vector<int> >());
 static_assert(
     check_equality_comparable_with<std::vector<int>, std::vector<int> >());
 static_assert(!check_equality_comparable_with<std::vector<int>, int>());
 } // namespace standard_types
 
 namespace types_fit_for_purpose {
 static_assert(
     check_equality_comparable_with<cxx20_member_eq, cxx20_member_eq>());
 static_assert(
     check_equality_comparable_with<cxx20_friend_eq, cxx20_friend_eq>());
 static_assert(
     !check_equality_comparable_with<cxx20_member_eq, cxx20_friend_eq>());
 
 static_assert(check_equality_comparable_with<member_three_way_comparable,
                                              member_three_way_comparable>());
 static_assert(check_equality_comparable_with<friend_three_way_comparable,
                                              friend_three_way_comparable>());
 static_assert(!check_equality_comparable_with<member_three_way_comparable,
                                               friend_three_way_comparable>());
 
 static_assert(
     check_equality_comparable_with<explicit_operators, explicit_operators>());
 static_assert(check_equality_comparable_with<equality_comparable_with_ec1,
                                              equality_comparable_with_ec1>());
 static_assert(check_equality_comparable_with<eq_neq_different_return_types,
                                              eq_neq_different_return_types>());
 static_assert(check_equality_comparable_with<explicit_operators,
                                              equality_comparable_with_ec1>());
 static_assert(check_equality_comparable_with<explicit_operators,
                                              eq_neq_different_return_types>());
 
 static_assert(check_equality_comparable_with<one_way_eq, one_way_eq>());
 static_assert(
     std::common_reference_with<one_way_eq const&, explicit_operators const&>);
 static_assert(
     !check_equality_comparable_with<one_way_eq, explicit_operators>());
 
 static_assert(check_equality_comparable_with<one_way_ne, one_way_ne>());
 static_assert(
     std::common_reference_with<one_way_ne const&, explicit_operators const&>);
 static_assert(
     !check_equality_comparable_with<one_way_ne, explicit_operators>());
 } // namespace types_fit_for_purpose
 
 int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.compare/types.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_CONCEPTS_COMPARISON_EQUALITYCOMPARABLE_H
 #define TEST_STD_CONCEPTS_COMPARISON_EQUALITYCOMPARABLE_H
 
 #include <compare>
 #include <concepts>
 #include <type_traits>
 
 // `noexcept` specifiers deliberately imperfect since not all programmers bother to put the
 // specifiers on their overloads.
 
 struct equality_comparable_with_ec1;
 struct no_neq;
 
 struct cxx20_member_eq {
   bool operator==(cxx20_member_eq const&) const = default;
 };
 
 struct cxx20_friend_eq {
   friend bool operator==(cxx20_friend_eq const&,
                          cxx20_friend_eq const&) = default;
 };
 
 struct member_three_way_comparable {
   auto operator<=>(member_three_way_comparable const&) const = default;
 };
 
 struct friend_three_way_comparable {
   friend auto operator<=>(friend_three_way_comparable const&,
                           friend_three_way_comparable const&) = default;
 };
 
 struct explicit_operators {
   friend bool operator==(explicit_operators, explicit_operators) noexcept;
   friend bool operator!=(explicit_operators, explicit_operators) noexcept;
 
   friend bool operator==(explicit_operators const&,
                          equality_comparable_with_ec1 const&) noexcept;
   friend bool operator==(equality_comparable_with_ec1 const&,
                          explicit_operators const&) noexcept;
   friend bool operator!=(explicit_operators const&,
                          equality_comparable_with_ec1 const&) noexcept;
   friend bool operator!=(equality_comparable_with_ec1 const&,
                          explicit_operators const&) noexcept;
 };
 
 struct eq_neq_different_return_types {
   int operator==(eq_neq_different_return_types) const noexcept;
   friend long operator!=(eq_neq_different_return_types,
                          eq_neq_different_return_types) noexcept;
 
   friend int operator==(explicit_operators, eq_neq_different_return_types);
   friend int operator==(eq_neq_different_return_types, explicit_operators);
   friend long operator!=(explicit_operators, eq_neq_different_return_types);
   friend long operator!=(eq_neq_different_return_types, explicit_operators);
 
   operator explicit_operators() const;
 };
 
 struct boolean {
   operator bool() const noexcept;
 };
 
 struct one_member_one_friend {
   friend boolean operator==(one_member_one_friend,
                             one_member_one_friend) noexcept;
   boolean operator!=(one_member_one_friend) const noexcept;
 
   operator explicit_operators() const noexcept;
   operator eq_neq_different_return_types() const noexcept;
 };
 
 struct equality_comparable_with_ec1 {
   bool operator==(equality_comparable_with_ec1) const noexcept;
   bool operator!=(equality_comparable_with_ec1) const noexcept;
   operator explicit_operators() const noexcept;
 };
 
 struct no_eq {
   friend bool operator!=(no_eq, no_eq) noexcept;
 };
 
 struct no_neq {
   friend bool operator==(no_neq, no_neq) noexcept;
   friend bool operator!=(no_neq, no_neq) = delete;
 };
 
 struct wrong_return_type_eq {
   void operator==(wrong_return_type_eq) const noexcept;
   bool operator!=(wrong_return_type_eq) const noexcept;
 };
 
 struct wrong_return_type_ne {
   bool operator==(wrong_return_type_ne) const noexcept;
   void operator!=(wrong_return_type_ne) const noexcept;
 };
 
 struct wrong_return_type {
   void operator==(wrong_return_type) const noexcept;
   void operator!=(wrong_return_type) const noexcept;
 };
 
 struct cxx20_member_eq_operator_with_deleted_ne {
   bool
   operator==(cxx20_member_eq_operator_with_deleted_ne const&) const = default;
   bool
   operator!=(cxx20_member_eq_operator_with_deleted_ne const&) const = delete;
 };
 
 struct cxx20_friend_eq_operator_with_deleted_ne {
   friend bool
   operator==(cxx20_friend_eq_operator_with_deleted_ne const&,
              cxx20_friend_eq_operator_with_deleted_ne const&) = default;
   friend bool
   operator!=(cxx20_friend_eq_operator_with_deleted_ne const&,
              cxx20_friend_eq_operator_with_deleted_ne const&) = delete;
 };
 
 struct member_three_way_comparable_with_deleted_eq {
   auto operator<=>(member_three_way_comparable_with_deleted_eq const&) const =
       default;
   bool
   operator==(member_three_way_comparable_with_deleted_eq const&) const = delete;
 };
 
 struct member_three_way_comparable_with_deleted_ne {
   auto operator<=>(member_three_way_comparable_with_deleted_ne const&) const =
       default;
   bool
   operator!=(member_three_way_comparable_with_deleted_ne const&) const = delete;
 };
 
 struct friend_three_way_comparable_with_deleted_eq {
   friend auto
   operator<=>(friend_three_way_comparable_with_deleted_eq const&,
               friend_three_way_comparable_with_deleted_eq const&) = default;
   friend bool
   operator==(friend_three_way_comparable_with_deleted_eq const&,
              friend_three_way_comparable_with_deleted_eq const&) = delete;
 };
 
 struct friend_three_way_comparable_with_deleted_ne {
   friend auto
   operator<=>(friend_three_way_comparable_with_deleted_ne const&,
               friend_three_way_comparable_with_deleted_ne const&) = default;
   friend bool
   operator!=(friend_three_way_comparable_with_deleted_ne const&,
              friend_three_way_comparable_with_deleted_ne const&) = delete;
 };
 
 struct one_way_eq {
   bool operator==(one_way_eq const&) const = default;
   friend bool operator==(one_way_eq, explicit_operators);
   friend bool operator==(explicit_operators, one_way_eq) = delete;
 
   operator explicit_operators() const;
 };
 
 struct one_way_ne {
   bool operator==(one_way_ne const&) const = default;
   friend bool operator==(one_way_ne, explicit_operators);
   friend bool operator!=(one_way_ne, explicit_operators) = delete;
 
   operator explicit_operators() const;
 };
 static_assert(requires(explicit_operators const x, one_way_ne const y) {
   x != y;
 });
 
 struct explicit_bool {
   explicit operator bool() const noexcept;
 };
 
 struct returns_explicit_bool {
   friend explicit_bool operator==(returns_explicit_bool, returns_explicit_bool);
   friend explicit_bool operator!=(returns_explicit_bool, returns_explicit_bool);
 };
 
 struct returns_true_type {
   friend std::true_type operator==(returns_true_type, returns_true_type);
   friend std::true_type operator!=(returns_true_type, returns_true_type);
 };
 
 struct returns_false_type {
   friend std::false_type operator==(returns_false_type, returns_false_type);
   friend std::false_type operator!=(returns_false_type, returns_false_type);
 };
 
 struct returns_int_ptr {
   friend int* operator==(returns_int_ptr, returns_int_ptr);
   friend int* operator!=(returns_int_ptr, returns_int_ptr);
 };
 
 #endif // TEST_STD_CONCEPTS_COMPARISON_EQUALITYCOMPARABLE_H

libcxx/test/std/concepts/concepts.lang/concept.assignable/assignable_from.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 From, class To>
 // concept assignable_from;
 
 #include <concepts>
 
 #include <deque>
 #include <forward_list>
 #include <list>
 #include <map>
 #include <memory>
 #include <mutex>
 #include <optional>
 #include <string>
 #include <string_view>
 #include <unordered_map>
 #include <vector>
 
 #include "../support/allocators.h"
 
 // Note: is_lvalue_reference is checked in all ModelsAssignableFrom calls.
 template <typename T1, typename T2>
 constexpr void NeverAssignableFrom() {
   static_assert(!std::assignable_from<T1, T2>);
   static_assert(!std::assignable_from<T1, const T2>);
   static_assert(!std::assignable_from<T1, T2&>);
   static_assert(!std::assignable_from<T1, const T2&>);
   static_assert(!std::assignable_from<T1, volatile T2&>);
   static_assert(!std::assignable_from<T1, const volatile T2&>);
   static_assert(!std::assignable_from<T1, T2&&>);
   static_assert(!std::assignable_from<T1, const T2&&>);
   static_assert(!std::assignable_from<T1, volatile T2&&>);
   static_assert(!std::assignable_from<T1, const volatile T2&&>);
 
   static_assert(!std::assignable_from<const volatile T1&, T2>);
   static_assert(!std::assignable_from<const volatile T1&, const T2>);
   static_assert(!std::assignable_from<const volatile T1&, T2&>);
   static_assert(!std::assignable_from<const volatile T1&, const T2&>);
   static_assert(!std::assignable_from<const volatile T1&, volatile T2&>);
   static_assert(!std::assignable_from<const volatile T1&, const volatile T2&>);
   static_assert(!std::assignable_from<const volatile T1&, T2&&>);
   static_assert(!std::assignable_from<const volatile T1&, const T2&&>);
   static_assert(!std::assignable_from<const volatile T1&, volatile T2&&>);
   static_assert(!std::assignable_from<const volatile T1&, const volatile T2&&>);
 
   static_assert(!std::assignable_from<T1&&, T2>);
   static_assert(!std::assignable_from<T1&&, const T2>);
   static_assert(!std::assignable_from<T1&&, T2&>);
   static_assert(!std::assignable_from<T1&&, const T2&>);
   static_assert(!std::assignable_from<T1&&, volatile T2&>);
   static_assert(!std::assignable_from<T1&&, const volatile T2&>);
   static_assert(!std::assignable_from<T1&&, T2&&>);
   static_assert(!std::assignable_from<T1&&, const T2&&>);
   static_assert(!std::assignable_from<T1&&, volatile T2&&>);
   static_assert(!std::assignable_from<T1&&, const volatile T2&&>);
 
   static_assert(!std::assignable_from<const T1&&, T2>);
   static_assert(!std::assignable_from<const T1&&, const T2>);
   static_assert(!std::assignable_from<const T1&&, T2&>);
   static_assert(!std::assignable_from<const T1&&, const T2&>);
   static_assert(!std::assignable_from<const T1&&, volatile T2&>);
   static_assert(!std::assignable_from<const T1&&, const volatile T2&>);
   static_assert(!std::assignable_from<const T1&&, T2&&>);
   static_assert(!std::assignable_from<const T1&&, const T2&&>);
   static_assert(!std::assignable_from<const T1&&, volatile T2&&>);
   static_assert(!std::assignable_from<const T1&&, const volatile T2&&>);
 
   static_assert(!std::assignable_from<volatile T1&&, T2>);
   static_assert(!std::assignable_from<volatile T1&&, const T2>);
   static_assert(!std::assignable_from<volatile T1&&, T2&>);
   static_assert(!std::assignable_from<volatile T1&&, const T2&>);
   static_assert(!std::assignable_from<volatile T1&&, volatile T2&>);
   static_assert(!std::assignable_from<volatile T1&&, const volatile T2&>);
   static_assert(!std::assignable_from<volatile T1&&, T2&&>);
   static_assert(!std::assignable_from<volatile T1&&, const T2&&>);
   static_assert(!std::assignable_from<volatile T1&&, volatile T2&&>);
   static_assert(!std::assignable_from<volatile T1&&, const volatile T2&&>);
 
   static_assert(!std::assignable_from<const volatile T1&&, T2>);
   static_assert(!std::assignable_from<const volatile T1&&, const T2>);
   static_assert(!std::assignable_from<const volatile T1&&, T2&>);
   static_assert(!std::assignable_from<const volatile T1&&, const T2&>);
   static_assert(!std::assignable_from<const volatile T1&&, volatile T2&>);
   static_assert(!std::assignable_from<const volatile T1&&, const volatile T2&>);
   static_assert(!std::assignable_from<const volatile T1&&, T2&&>);
   static_assert(!std::assignable_from<const volatile T1&&, const T2&&>);
   static_assert(!std::assignable_from<const volatile T1&&, volatile T2&&>);
   static_assert(
       !std::assignable_from<const volatile T1&&, const volatile T2&&>);
 
   static_assert(!std::assignable_from<const T1&, T2>);
   static_assert(!std::assignable_from<const T1&, const T2>);
   static_assert(!std::assignable_from<const T1&, T2&>);
   static_assert(!std::assignable_from<const T1&, const T2&>);
   static_assert(!std::assignable_from<const T1&, volatile T2&>);
   static_assert(!std::assignable_from<const T1&, const volatile T2&>);
   static_assert(!std::assignable_from<const T1&, T2&&>);
   static_assert(!std::assignable_from<const T1&, const T2&&>);
   static_assert(!std::assignable_from<const T1&, volatile T2&&>);
   static_assert(!std::assignable_from<const T1&, const volatile T2&&>);
 
   static_assert(!std::assignable_from<const volatile T1&, T2>);
   static_assert(!std::assignable_from<const volatile T1&, const T2>);
   static_assert(!std::assignable_from<const volatile T1&, T2&>);
   static_assert(!std::assignable_from<const volatile T1&, const T2&>);
   static_assert(!std::assignable_from<const volatile T1&, volatile T2&>);
   static_assert(!std::assignable_from<const volatile T1&, const volatile T2&>);
   static_assert(!std::assignable_from<const volatile T1&, T2&&>);
   static_assert(!std::assignable_from<const volatile T1&, const T2&&>);
   static_assert(!std::assignable_from<const volatile T1&, volatile T2&&>);
   static_assert(!std::assignable_from<const volatile T1&, const volatile T2&&>);
 }
 
 template <typename T1, typename T2>
 constexpr bool CheckAssignableFromRvalues() {
   NeverAssignableFrom<T1, T2>();
 
   constexpr bool Result = std::assignable_from<T1&, T2>;
   static_assert(std::assignable_from<T1&, T2&&> == Result);
 
   return Result;
 }
 
 template <typename T1, typename T2>
 constexpr bool CheckAssignableFromLvalues() {
   NeverAssignableFrom<T1, T2>();
 
   constexpr bool Result = std::assignable_from<T1&, const T2&>;
   static_assert(std::assignable_from<T1&, T2&> == Result);
   static_assert(std::assignable_from<T1&, const T2&> == Result);
 
   return Result;
 }
 
 template <typename T1, typename T2>
 constexpr bool CheckAssignableFromLvaluesAndRvalues() {
   return CheckAssignableFromLvalues<T1, T2>() &&
          CheckAssignableFromRvalues<T1, T2>();
 }
 
 namespace BuiltinTypes {
 static_assert(CheckAssignableFromLvaluesAndRvalues<int, int>());
 static_assert(CheckAssignableFromLvaluesAndRvalues<int, double>());
 static_assert(CheckAssignableFromLvaluesAndRvalues<double, int>());
 static_assert(CheckAssignableFromLvaluesAndRvalues<int*, int*>());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<int*, const int*>());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<int*, volatile int*>());
 static_assert(
     !CheckAssignableFromLvaluesAndRvalues<int*, const volatile int*>());
 static_assert(CheckAssignableFromLvaluesAndRvalues<const int*, int*>());
 static_assert(CheckAssignableFromLvaluesAndRvalues<const int*, const int*>());
 static_assert(
     !CheckAssignableFromLvaluesAndRvalues<const int*, volatile int*>());
 static_assert(
     !CheckAssignableFromLvaluesAndRvalues<const int*, const volatile int*>());
 static_assert(CheckAssignableFromLvaluesAndRvalues<volatile int*, int*>());
 static_assert(
     !CheckAssignableFromLvaluesAndRvalues<volatile int*, const int*>());
 static_assert(
     CheckAssignableFromLvaluesAndRvalues<volatile int*, volatile int*>());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<volatile int*,
                                                     const volatile int*>());
 static_assert(
     CheckAssignableFromLvaluesAndRvalues<const volatile int*, int*>());
 static_assert(
     CheckAssignableFromLvaluesAndRvalues<const volatile int*, const int*>());
 static_assert(
     CheckAssignableFromLvaluesAndRvalues<const volatile int*, volatile int*>());
 static_assert(CheckAssignableFromLvaluesAndRvalues<const volatile int*,
                                                    const volatile int*>());
 
 static_assert(CheckAssignableFromLvaluesAndRvalues<int (*)(), int (*)()>());
 static_assert(
     CheckAssignableFromLvaluesAndRvalues<int (*)(), int (*)() noexcept>());
 static_assert(
     !CheckAssignableFromLvaluesAndRvalues<int (*)() noexcept, int (*)()>());
 
 struct S {};
 static_assert(CheckAssignableFromLvaluesAndRvalues<int S::*, int S::*>());
 static_assert(CheckAssignableFromLvaluesAndRvalues<const int S::*, int S::*>());
 static_assert(
     CheckAssignableFromLvaluesAndRvalues<int (S::*)(), int (S::*)()>());
 static_assert(CheckAssignableFromLvaluesAndRvalues<int (S::*)(),
                                                    int (S::*)() noexcept>());
 static_assert(CheckAssignableFromLvaluesAndRvalues<int (S::*)() const,
                                                    int (S::*)() const>());
 static_assert(CheckAssignableFromLvaluesAndRvalues<
               int (S::*)() const, int (S::*)() const noexcept>());
 static_assert(CheckAssignableFromLvaluesAndRvalues<int (S::*)() volatile,
                                                    int (S::*)() volatile>());
 static_assert(CheckAssignableFromLvaluesAndRvalues<
               int (S::*)() volatile, int (S::*)() volatile noexcept>());
 static_assert(CheckAssignableFromLvaluesAndRvalues<
               int (S::*)() const volatile, int (S::*)() const volatile>());
 static_assert(
     CheckAssignableFromLvaluesAndRvalues<
         int (S::*)() const volatile, int (S::*)() const volatile noexcept>());
 
 static_assert(!std::assignable_from<void, int>);
 static_assert(!std::assignable_from<void, void>);
 static_assert(!std::assignable_from<int*&, long*>);
 static_assert(!std::assignable_from<int (&)[5], int[5]>);
 static_assert(!std::assignable_from<int (S::*&)(), int (S::*)() const>);
 static_assert(!std::assignable_from<int (S::*&)() const, int (S::*)()>);
 static_assert(!std::assignable_from<int (S::*&)(), int (S::*)() volatile>);
 static_assert(!std::assignable_from<int (S::*&)() volatile, int (S::*)()>);
 static_assert(
     !std::assignable_from<int (S::*&)(), int (S::*)() const volatile>);
 static_assert(
     !std::assignable_from<int (S::*&)() const volatile, int (S::*)()>);
 static_assert(!std::assignable_from<int (S::*&)() noexcept, int (S::*)()>);
 static_assert(
     !std::assignable_from<int (S::*&)() const noexcept, int (S::*)() const>);
 static_assert(!std::assignable_from<int (S::*&)() volatile noexcept,
                                     int (S::*)() volatile>);
 static_assert(!std::assignable_from<int (S::*&)() const volatile noexcept,
                                     int (S::*)() const volatile>);
 } // namespace BuiltinTypes
 
 namespace TypesFitForPurpose {
 struct T1 {};
 
 struct NoCommonReference {};
 static_assert(!std::common_reference_with<const T1&, const NoCommonReference&>);
 static_assert(!std::assignable_from<NoCommonReference&, T1>);
 
 struct AssignmentReturnsNonReference {
   AssignmentReturnsNonReference operator=(T1);
   operator T1() const;
 };
 static_assert(std::common_reference_with<const T1&,
                                          const AssignmentReturnsNonReference&>);
 static_assert(!std::assignable_from<AssignmentReturnsNonReference&, T1>);
 
 struct NonCVAssignmentOnly {
   NonCVAssignmentOnly& operator=(T1);
   operator T1() const;
 };
 static_assert(
     std::common_reference_with<const T1&, const NonCVAssignmentOnly&>);
 static_assert(std::assignable_from<NonCVAssignmentOnly&, T1>);
 static_assert(!std::assignable_from<const NonCVAssignmentOnly&, T1>);
 static_assert(!std::assignable_from<volatile NonCVAssignmentOnly&, T1>);
 static_assert(!std::assignable_from<const volatile NonCVAssignmentOnly&, T1>);
 
 struct NonCVAssignmentOnlyConstQualified {
   NonCVAssignmentOnlyConstQualified& operator=(T1) const;
   operator T1() const;
 };
 static_assert(std::common_reference_with<
               const T1&, const NonCVAssignmentOnlyConstQualified&>);
 static_assert(std::assignable_from<NonCVAssignmentOnlyConstQualified&, T1>);
 static_assert(
     !std::assignable_from<const NonCVAssignmentOnlyConstQualified&, T1>);
 static_assert(
     !std::assignable_from<volatile NonCVAssignmentOnlyConstQualified&, T1>);
 static_assert(!std::assignable_from<
               const volatile NonCVAssignmentOnlyConstQualified&, T1>);
 
 struct NonCVAssignmentVolatileQualified {
   NonCVAssignmentVolatileQualified& operator=(T1) volatile;
   operator T1() const volatile;
 };
 static_assert(std::common_reference_with<
               const T1&, const NonCVAssignmentVolatileQualified&>);
 static_assert(std::assignable_from<NonCVAssignmentVolatileQualified&, T1>);
 static_assert(
     !std::assignable_from<const NonCVAssignmentVolatileQualified&, T1>);
 static_assert(
     !std::assignable_from<volatile NonCVAssignmentVolatileQualified&, T1>);
 static_assert(!std::assignable_from<
               const volatile NonCVAssignmentVolatileQualified&, T1>);
 
 struct NonCVAssignmentOnlyCVQualified {
   NonCVAssignmentOnlyCVQualified& operator=(T1) const volatile;
   operator T1() const volatile;
 };
 static_assert(std::common_reference_with<
               const T1&, const NonCVAssignmentOnlyCVQualified&>);
 static_assert(std::assignable_from<NonCVAssignmentOnlyCVQualified&, T1>);
 static_assert(!std::assignable_from<const NonCVAssignmentOnlyCVQualified&, T1>);
 static_assert(
     !std::assignable_from<volatile NonCVAssignmentOnlyCVQualified&, T1>);
 static_assert(
     !std::assignable_from<const volatile NonCVAssignmentOnlyCVQualified&, T1>);
 
 struct ConstAssignmentOnly {
   const ConstAssignmentOnly& operator=(T1) const;
   operator T1() const;
 };
 static_assert(
     std::common_reference_with<const T1&, const ConstAssignmentOnly&>);
 static_assert(std::assignable_from<const ConstAssignmentOnly&, T1>);
 static_assert(!std::assignable_from<ConstAssignmentOnly&, T1>);
 static_assert(!std::assignable_from<volatile ConstAssignmentOnly&, T1>);
 static_assert(!std::assignable_from<const volatile ConstAssignmentOnly&, T1>);
 
 struct VolatileAssignmentOnly {
   volatile VolatileAssignmentOnly& operator=(T1) volatile;
   operator T1() const volatile;
 };
 static_assert(
     std::common_reference_with<const T1&, const VolatileAssignmentOnly&>);
 static_assert(!std::assignable_from<VolatileAssignmentOnly&, T1>);
 static_assert(std::assignable_from<volatile VolatileAssignmentOnly&, T1>);
 
 struct CVAssignmentOnly {
   const volatile CVAssignmentOnly& operator=(T1) const volatile;
   operator T1() const volatile;
 };
 static_assert(std::common_reference_with<const T1&, const CVAssignmentOnly&>);
 static_assert(std::assignable_from<const volatile CVAssignmentOnly&, T1>);
 static_assert(!std::assignable_from<CVAssignmentOnly&, T1>);
 static_assert(!std::assignable_from<const CVAssignmentOnly&, T1>);
 static_assert(!std::assignable_from<volatile CVAssignmentOnly&, T1>);
 
 struct LvalueRefQualifiedWithRvalueT1Only {
   LvalueRefQualifiedWithRvalueT1Only& operator=(T1&&) &;
   const LvalueRefQualifiedWithRvalueT1Only& operator=(T1&&) const&;
   volatile LvalueRefQualifiedWithRvalueT1Only& operator=(T1&&) volatile&;
   const volatile LvalueRefQualifiedWithRvalueT1Only& operator=(T1&&) const
       volatile&;
   operator T1() const volatile;
 };
 static_assert(std::common_reference_with<
               const T1&, const LvalueRefQualifiedWithRvalueT1Only&>);
 static_assert(std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, T1&&>);
 static_assert(
     std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&, T1&&>);
 static_assert(
     std::assignable_from<volatile LvalueRefQualifiedWithRvalueT1Only&, T1&&>);
 static_assert(std::assignable_from<
               const volatile LvalueRefQualifiedWithRvalueT1Only&, T1&&>);
 static_assert(!std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, T1&>);
 static_assert(
     !std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&, T1&>);
 static_assert(
     !std::assignable_from<volatile LvalueRefQualifiedWithRvalueT1Only&, T1&>);
 static_assert(!std::assignable_from<
               const volatile LvalueRefQualifiedWithRvalueT1Only&, T1&>);
 static_assert(
     !std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, const T1&>);
 static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
                                     const T1&>);
 static_assert(!std::assignable_from<
               volatile LvalueRefQualifiedWithRvalueT1Only&, const T1&>);
 static_assert(!std::assignable_from<
               const volatile LvalueRefQualifiedWithRvalueT1Only&, const T1&>);
 static_assert(
     !std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, volatile T1&>);
 static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
                                     volatile T1&>);
 static_assert(!std::assignable_from<
               volatile LvalueRefQualifiedWithRvalueT1Only&, volatile T1&>);
 static_assert(
     !std::assignable_from<const volatile LvalueRefQualifiedWithRvalueT1Only&,
                           volatile T1&>);
 static_assert(!std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&,
                                     const volatile T1&>);
 static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
                                     const volatile T1&>);
 static_assert(
     !std::assignable_from<volatile LvalueRefQualifiedWithRvalueT1Only&,
                           const volatile T1&>);
 static_assert(
     !std::assignable_from<const volatile LvalueRefQualifiedWithRvalueT1Only&,
                           const volatile T1&>);
 static_assert(
     !std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, const T1&&>);
 static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
                                     const T1&&>);
 static_assert(!std::assignable_from<
               volatile LvalueRefQualifiedWithRvalueT1Only&, const T1&&>);
 static_assert(!std::assignable_from<
               const volatile LvalueRefQualifiedWithRvalueT1Only&, const T1&&>);
 static_assert(
     !std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&, volatile T1&&>);
 static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
                                     volatile T1&&>);
 static_assert(!std::assignable_from<
               volatile LvalueRefQualifiedWithRvalueT1Only&, volatile T1&&>);
 static_assert(
     !std::assignable_from<const volatile LvalueRefQualifiedWithRvalueT1Only&,
                           volatile T1&&>);
 static_assert(!std::assignable_from<LvalueRefQualifiedWithRvalueT1Only&,
                                     const volatile T1&&>);
 static_assert(!std::assignable_from<const LvalueRefQualifiedWithRvalueT1Only&,
                                     const volatile T1&&>);
 static_assert(
     !std::assignable_from<volatile LvalueRefQualifiedWithRvalueT1Only&,
                           const volatile T1&&>);
 static_assert(
     !std::assignable_from<const volatile LvalueRefQualifiedWithRvalueT1Only&,
                           const volatile T1&&>);
 
 struct NoLvalueRefAssignment {
   NoLvalueRefAssignment& operator=(T1) &&;
   const NoLvalueRefAssignment& operator=(T1) const&&;
   volatile NoLvalueRefAssignment& operator=(T1) volatile&&;
   const volatile NoLvalueRefAssignment& operator=(T1) const volatile&&;
   operator T1() const volatile;
 };
 static_assert(
     std::common_reference_with<const T1&, const NoLvalueRefAssignment&>);
 static_assert(!std::assignable_from<NoLvalueRefAssignment&, T1>);
 static_assert(!std::assignable_from<NoLvalueRefAssignment&, const T1>);
 static_assert(!std::assignable_from<NoLvalueRefAssignment&, volatile T1>);
 static_assert(!std::assignable_from<NoLvalueRefAssignment&, const volatile T1>);
 static_assert(!std::assignable_from<const NoLvalueRefAssignment&, T1>);
 static_assert(!std::assignable_from<const NoLvalueRefAssignment&, const T1>);
 static_assert(!std::assignable_from<const NoLvalueRefAssignment&, volatile T1>);
 static_assert(
     !std::assignable_from<const NoLvalueRefAssignment&, const volatile T1>);
 static_assert(!std::assignable_from<volatile NoLvalueRefAssignment&, T1>);
 static_assert(!std::assignable_from<volatile NoLvalueRefAssignment&, const T1>);
 static_assert(
     !std::assignable_from<volatile NoLvalueRefAssignment&, volatile T1>);
 static_assert(
     !std::assignable_from<volatile NoLvalueRefAssignment&, const volatile T1>);
 static_assert(!std::assignable_from<const volatile NoLvalueRefAssignment&, T1>);
 static_assert(
     !std::assignable_from<const volatile NoLvalueRefAssignment&, const T1>);
 static_assert(
     !std::assignable_from<const volatile NoLvalueRefAssignment&, volatile T1>);
 static_assert(!std::assignable_from<const volatile NoLvalueRefAssignment&,
                                     const volatile T1>);
 } // namespace TypesFitForPurpose
 
 namespace StandardTypes {
 static_assert(
     CheckAssignableFromLvaluesAndRvalues<std::deque<int>, std::deque<int> >());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<std::deque<int>,
                                                     std::deque<const int> >());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<
               std::deque<int>, std::deque<int, A1<int> > >());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<std::deque<int>,
                                                     std::vector<int> >());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<std::deque<int>, int>());
 
 static_assert(CheckAssignableFromLvaluesAndRvalues<std::forward_list<int>,
                                                    std::forward_list<int> >());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<
               std::forward_list<int>, std::forward_list<const int> >());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<
               std::forward_list<int>, std::forward_list<int, A1<int> > >());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<std::forward_list<int>,
                                                     std::vector<int> >());
 static_assert(
     !CheckAssignableFromLvaluesAndRvalues<std::forward_list<int>, int>());
 
 static_assert(
     CheckAssignableFromLvaluesAndRvalues<std::list<int>, std::list<int> >());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<std::list<int>,
                                                     std::list<const int> >());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<
               std::list<int>, std::list<int, A1<int> > >());
 static_assert(
     !CheckAssignableFromLvaluesAndRvalues<std::list<int>, std::vector<int> >());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<std::list<int>, int>());
 
 static_assert(CheckAssignableFromLvaluesAndRvalues<std::map<int, void*>,
                                                    std::map<int, void*> >());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<
               std::map<int, void*>, std::map<const int, void*> >());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<
               std::map<int, void*>,
               std::map<int, void*, A1<std::pair<int, void*> > > >());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<
               std::map<int, void*>, std::unordered_map<int, void*> >());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<std::map<int, void*>,
                                                     std::pair<int, void*> >());
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 static_assert(!CheckAssignableFromRvalues<std::mutex, std::mutex>());
 static_assert(!CheckAssignableFromLvalues<std::mutex, std::mutex>());
 #endif
 
 static_assert(CheckAssignableFromLvaluesAndRvalues<std::optional<int>, int>());
 static_assert(
     CheckAssignableFromLvaluesAndRvalues<std::optional<int>, double>());
 static_assert(CheckAssignableFromLvaluesAndRvalues<std::optional<int>,
                                                    std::optional<int> >());
 static_assert(
     !CheckAssignableFromLvaluesAndRvalues<int, std::optional<int> >());
 static_assert(
     !CheckAssignableFromLvaluesAndRvalues<double, std::optional<int> >());
 
 static_assert(
     !std::common_reference_with<std::optional<int>, std::optional<double> >);
 static_assert(
     !CheckAssignableFromRvalues<std::optional<int>, std::optional<double> >());
 static_assert(
     !CheckAssignableFromLvalues<std::optional<int>, std::optional<double> >());
 
 static_assert(CheckAssignableFromLvaluesAndRvalues<std::string, std::string>());
 static_assert(
     CheckAssignableFromLvaluesAndRvalues<std::string, std::string_view>());
 static_assert(CheckAssignableFromLvaluesAndRvalues<std::string, char*>());
 static_assert(CheckAssignableFromLvaluesAndRvalues<std::string, const char*>());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<
               std::string, std::basic_string<wchar_t> >());
 static_assert(
     !CheckAssignableFromLvaluesAndRvalues<std::string, std::vector<char> >());
 
 static_assert(
     CheckAssignableFromLvaluesAndRvalues<std::string_view, std::string_view>());
 static_assert(
     CheckAssignableFromLvaluesAndRvalues<std::string_view, std::string>());
 static_assert(CheckAssignableFromLvaluesAndRvalues<std::string_view, char*>());
 static_assert(
     CheckAssignableFromLvaluesAndRvalues<std::string_view, const char*>());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<
               std::string_view, std::basic_string_view<wchar_t> >());
 
 static_assert(
     CheckAssignableFromRvalues<std::unique_ptr<int>, std::unique_ptr<int> >());
 static_assert(
     !CheckAssignableFromLvalues<std::unique_ptr<int>, std::unique_ptr<int> >());
 
 static_assert(
     CheckAssignableFromLvaluesAndRvalues<std::unordered_map<int, void*>,
                                          std::unordered_map<int, void*> >());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<
               std::unordered_map<int, void*>,
               std::unordered_map<const int, void*> >());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<
               std::unordered_map<int, void*>,
               std::unordered_map<int, void*, A1<std::pair<int, void*> > > >());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<
               std::unordered_map<int, void*>, std::map<int, void*> >());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<
               std::unordered_map<int, void*>, std::pair<int, void*> >());
 
 static_assert(CheckAssignableFromLvaluesAndRvalues<std::vector<int>,
                                                    std::vector<int> >());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<std::deque<int>,
                                                     std::deque<const int> >());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<
               std::vector<int>, std::vector<int, A1<int> > >());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<std::vector<int>,
                                                     std::deque<int> >());
 static_assert(!CheckAssignableFromLvaluesAndRvalues<std::vector<int>, int>());
 } // namespace StandardTypes
 
 int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.lang/concept.common/common_with.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 From, class To>
 // concept common_with;
 
 #include <concepts>
 
 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);
   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);
   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<const T&, U&&> == result);
   static_assert(std::common_with<const T&, const U&&> == result);
   static_assert(std::common_with<const T&, volatile U&&> == result);
   static_assert(std::common_with<const T&, const volatile U&&> == result);
   static_assert(std::common_with<volatile T&, U&&> == result);
   static_assert(std::common_with<volatile T&, const U&&> == result);
   static_assert(std::common_with<volatile T&, volatile U&&> == result);
   static_assert(std::common_with<volatile T&, const volatile U&&> == result);
   static_assert(std::common_with<const volatile T&, U&&> == result);
   static_assert(std::common_with<const volatile T&, const U&&> == result);
   static_assert(std::common_with<const volatile T&, volatile U&&> == result);
   static_assert(std::common_with<const volatile T&, const volatile U&&> ==
                 result);
   return result;
 }
 
 template <class T, class U>
 constexpr bool HasValidCommonType() noexcept {
   return requires { typename std::common_type_t<T, U>; }
   &&std::same_as<std::common_type_t<T, U>, std::common_type_t<U, T> >;
 }
 
 namespace BuiltinTypes {
 // fundamental types
 static_assert(std::common_with<void, void>);
 static_assert(CheckCommonWith<int, int>());
 static_assert(CheckCommonWith<int, long>());
 static_assert(CheckCommonWith<int, unsigned char>());
 #ifndef _LIBCPP_HAS_NO_INT128
 static_assert(CheckCommonWith<int, __int128_t>());
 #endif
 static_assert(CheckCommonWith<int, double>());
 
 // arrays
 static_assert(CheckCommonWith<int[5], int[5]>());
 
 // pointers
 static_assert(CheckCommonWith<int*, int*>());
 static_assert(CheckCommonWith<int*, const int*>());
 static_assert(CheckCommonWith<int*, volatile int*>());
 static_assert(CheckCommonWith<int*, const volatile int*>());
 static_assert(CheckCommonWith<const int*, const int*>());
 static_assert(CheckCommonWith<const int*, volatile int*>());
 static_assert(CheckCommonWith<const int*, const volatile int*>());
 static_assert(CheckCommonWith<volatile int*, const int*>());
 static_assert(CheckCommonWith<volatile int*, volatile int*>());
 static_assert(CheckCommonWith<volatile int*, const volatile int*>());
 static_assert(CheckCommonWith<const volatile int*, const int*>());
 static_assert(CheckCommonWith<const volatile int*, volatile int*>());
 static_assert(CheckCommonWith<const volatile int*, const volatile int*>());
 
 static_assert(CheckCommonWith<int (*)(), int (*)()>());
 static_assert(CheckCommonWith<int (*)(), int (*)() noexcept>());
 static_assert(CheckCommonWith<int (&)(), int (&)()>());
 static_assert(CheckCommonWith<int (&)(), int (&)() noexcept>());
 static_assert(CheckCommonWith<int (&)(), int (*)()>());
 static_assert(CheckCommonWith<int (&)(), int (*)() noexcept>());
 
 struct S {};
 static_assert(CheckCommonWith<int S::*, int S::*>());
 static_assert(CheckCommonWith<int S::*, const int S::*>());
 static_assert(CheckCommonWith<int (S::*)(), int (S::*)()>());
 static_assert(CheckCommonWith<int (S::*)(), int (S::*)() noexcept>());
 static_assert(CheckCommonWith<int (S::*)() const, int (S::*)() const>());
 static_assert(
     CheckCommonWith<int (S::*)() const, int (S::*)() const noexcept>());
 static_assert(CheckCommonWith<int (S::*)() volatile, int (S::*)() volatile>());
 static_assert(
     CheckCommonWith<int (S::*)() volatile, int (S::*)() volatile noexcept>());
 static_assert(CheckCommonWith<int (S::*)() const volatile,
                               int (S::*)() const volatile>());
 static_assert(CheckCommonWith<int (S::*)() const volatile,
                               int (S::*)() const volatile noexcept>());
 
 // nonsense
 static_assert(!CheckCommonWith<double, float*>());
 static_assert(!CheckCommonWith<int, int[5]>());
 static_assert(!CheckCommonWith<int*, long*>());
 static_assert(!CheckCommonWith<int*, unsigned int*>());
 static_assert(!CheckCommonWith<int (*)(), int (*)(int)>());
 static_assert(!CheckCommonWith<int S::*, float S::*>());
 static_assert(!CheckCommonWith<int (S::*)(), int (S::*)() const>());
 static_assert(!CheckCommonWith<int (S::*)(), int (S::*)() volatile>());
 static_assert(!CheckCommonWith<int (S::*)(), int (S::*)() const volatile>());
 static_assert(!CheckCommonWith<int (S::*)() const, int (S::*)() volatile>());
 static_assert(
     !CheckCommonWith<int (S::*)() const, int (S::*)() const volatile>());
 static_assert(
     !CheckCommonWith<int (S::*)() volatile, int (S::*)() const volatile>());
 } // namespace BuiltinTypes
 
 namespace NoDefaultCommonType {
 class T {};
 
 static_assert(!CheckCommonWith<T, int>());
 static_assert(!CheckCommonWith<int, T>());
 static_assert(!CheckCommonWith<T, int[10]>());
 static_assert(!CheckCommonWith<T[10], int>());
 static_assert(!CheckCommonWith<T*, int*>());
 static_assert(!CheckCommonWith<T*, const int*>());
 static_assert(!CheckCommonWith<T*, volatile int*>());
 static_assert(!CheckCommonWith<T*, const volatile int*>());
 static_assert(!CheckCommonWith<const T*, int*>());
 static_assert(!CheckCommonWith<volatile T*, int*>());
 static_assert(!CheckCommonWith<const volatile T*, int*>());
 static_assert(!CheckCommonWith<const T*, const int*>());
 static_assert(!CheckCommonWith<const T*, volatile int*>());
 static_assert(!CheckCommonWith<const T*, const volatile int*>());
 static_assert(!CheckCommonWith<const T*, const int*>());
 static_assert(!CheckCommonWith<volatile T*, const int*>());
 static_assert(!CheckCommonWith<const volatile T*, const int*>());
 static_assert(!CheckCommonWith<volatile T*, const int*>());
 static_assert(!CheckCommonWith<volatile T*, volatile int*>());
 static_assert(!CheckCommonWith<volatile T*, const volatile int*>());
 static_assert(!CheckCommonWith<const T*, volatile int*>());
 static_assert(!CheckCommonWith<volatile T*, volatile int*>());
 static_assert(!CheckCommonWith<const volatile T*, volatile int*>());
 static_assert(!CheckCommonWith<const volatile T*, const int*>());
 static_assert(!CheckCommonWith<const volatile T*, volatile int*>());
 static_assert(!CheckCommonWith<const volatile T*, const volatile int*>());
 static_assert(!CheckCommonWith<const T*, const volatile int*>());
 static_assert(!CheckCommonWith<volatile T*, const volatile int*>());
 static_assert(!CheckCommonWith<const volatile T*, const volatile int*>());
 static_assert(!CheckCommonWith<T&, int&>());
 static_assert(!CheckCommonWith<T&, const int&>());
 static_assert(!CheckCommonWith<T&, volatile int&>());
 static_assert(!CheckCommonWith<T&, const volatile int&>());
 static_assert(!CheckCommonWith<const T&, int&>());
 static_assert(!CheckCommonWith<volatile T&, int&>());
 static_assert(!CheckCommonWith<const volatile T&, int&>());
 static_assert(!CheckCommonWith<const T&, const int&>());
 static_assert(!CheckCommonWith<const T&, volatile int&>());
 static_assert(!CheckCommonWith<const T&, const volatile int&>());
 static_assert(!CheckCommonWith<const T&, const int&>());
 static_assert(!CheckCommonWith<volatile T&, const int&>());
 static_assert(!CheckCommonWith<const volatile T&, const int&>());
 static_assert(!CheckCommonWith<volatile T&, const int&>());
 static_assert(!CheckCommonWith<volatile T&, volatile int&>());
 static_assert(!CheckCommonWith<volatile T&, const volatile int&>());
 static_assert(!CheckCommonWith<const T&, volatile int&>());
 static_assert(!CheckCommonWith<volatile T&, volatile int&>());
 static_assert(!CheckCommonWith<const volatile T&, volatile int&>());
 static_assert(!CheckCommonWith<const volatile T&, const int&>());
 static_assert(!CheckCommonWith<const volatile T&, volatile int&>());
 static_assert(!CheckCommonWith<const volatile T&, const volatile int&>());
 static_assert(!CheckCommonWith<const T&, const volatile int&>());
 static_assert(!CheckCommonWith<volatile T&, const volatile int&>());
 static_assert(!CheckCommonWith<const volatile T&, const volatile int&>());
 static_assert(!CheckCommonWith<T&, int&&>());
 static_assert(!CheckCommonWith<T&, const int&&>());
 static_assert(!CheckCommonWith<T&, volatile int&&>());
 static_assert(!CheckCommonWith<T&, const volatile int&&>());
 static_assert(!CheckCommonWith<const T&, int&&>());
 static_assert(!CheckCommonWith<volatile T&, int&&>());
 static_assert(!CheckCommonWith<const volatile T&, int&&>());
 static_assert(!CheckCommonWith<const T&, const int&&>());
 static_assert(!CheckCommonWith<const T&, volatile int&&>());
 static_assert(!CheckCommonWith<const T&, const volatile int&&>());
 static_assert(!CheckCommonWith<const T&, const int&&>());
 static_assert(!CheckCommonWith<volatile T&, const int&&>());
 static_assert(!CheckCommonWith<const volatile T&, const int&&>());
 static_assert(!CheckCommonWith<volatile T&, const int&&>());
 static_assert(!CheckCommonWith<volatile T&, volatile int&&>());
 static_assert(!CheckCommonWith<volatile T&, const volatile int&&>());
 static_assert(!CheckCommonWith<const T&, volatile int&&>());
 static_assert(!CheckCommonWith<volatile T&, volatile int&&>());
 static_assert(!CheckCommonWith<const volatile T&, volatile int&&>());
 static_assert(!CheckCommonWith<const volatile T&, const int&&>());
 static_assert(!CheckCommonWith<const volatile T&, volatile int&&>());
 static_assert(!CheckCommonWith<const volatile T&, const volatile int&&>());
 static_assert(!CheckCommonWith<const T&, const volatile int&&>());
 static_assert(!CheckCommonWith<volatile T&, const volatile int&&>());
 static_assert(!CheckCommonWith<const volatile T&, const volatile int&&>());
 static_assert(!CheckCommonWith<T&&, int&>());
 static_assert(!CheckCommonWith<T&&, const int&>());
 static_assert(!CheckCommonWith<T&&, volatile int&>());
 static_assert(!CheckCommonWith<T&&, const volatile int&>());
 static_assert(!CheckCommonWith<const T&&, int&>());
 static_assert(!CheckCommonWith<volatile T&&, int&>());
 static_assert(!CheckCommonWith<const volatile T&&, int&>());
 static_assert(!CheckCommonWith<const T&&, const int&>());
 static_assert(!CheckCommonWith<const T&&, volatile int&>());
 static_assert(!CheckCommonWith<const T&&, const volatile int&>());
 static_assert(!CheckCommonWith<const T&&, const int&>());
 static_assert(!CheckCommonWith<volatile T&&, const int&>());
 static_assert(!CheckCommonWith<const volatile T&&, const int&>());
 static_assert(!CheckCommonWith<volatile T&&, const int&>());
 static_assert(!CheckCommonWith<volatile T&&, volatile int&>());
 static_assert(!CheckCommonWith<volatile T&&, const volatile int&>());
 static_assert(!CheckCommonWith<const T&&, volatile int&>());
 static_assert(!CheckCommonWith<volatile T&&, volatile int&>());
 static_assert(!CheckCommonWith<const volatile T&&, volatile int&>());
 static_assert(!CheckCommonWith<const volatile T&&, const int&>());
 static_assert(!CheckCommonWith<const volatile T&&, volatile int&>());
 static_assert(!CheckCommonWith<const volatile T&&, const volatile int&>());
 static_assert(!CheckCommonWith<const T&&, const volatile int&>());
 static_assert(!CheckCommonWith<volatile T&&, const volatile int&>());
 static_assert(!CheckCommonWith<const volatile T&&, const volatile int&>());
 static_assert(!CheckCommonWith<T&&, int&&>());
 static_assert(!CheckCommonWith<T&&, const int&&>());
 static_assert(!CheckCommonWith<T&&, volatile int&&>());
 static_assert(!CheckCommonWith<T&&, const volatile int&&>());
 static_assert(!CheckCommonWith<const T&&, int&&>());
 static_assert(!CheckCommonWith<volatile T&&, int&&>());
 static_assert(!CheckCommonWith<const volatile T&&, int&&>());
 static_assert(!CheckCommonWith<const T&&, const int&&>());
 static_assert(!CheckCommonWith<const T&&, volatile int&&>());
 static_assert(!CheckCommonWith<const T&&, const volatile int&&>());
 static_assert(!CheckCommonWith<const T&&, const int&&>());
 static_assert(!CheckCommonWith<volatile T&&, const int&&>());
 static_assert(!CheckCommonWith<const volatile T&&, const int&&>());
 static_assert(!CheckCommonWith<volatile T&&, const int&&>());
 static_assert(!CheckCommonWith<volatile T&&, volatile int&&>());
 static_assert(!CheckCommonWith<volatile T&&, const volatile int&&>());
 static_assert(!CheckCommonWith<const T&&, volatile int&&>());
 static_assert(!CheckCommonWith<volatile T&&, volatile int&&>());
 static_assert(!CheckCommonWith<const volatile T&&, volatile int&&>());
 static_assert(!CheckCommonWith<const volatile T&&, const int&&>());
 static_assert(!CheckCommonWith<const volatile T&&, volatile int&&>());
 static_assert(!CheckCommonWith<const volatile T&&, const volatile int&&>());
 static_assert(!CheckCommonWith<const T&&, const volatile int&&>());
 static_assert(!CheckCommonWith<volatile T&&, const volatile int&&>());
 static_assert(!CheckCommonWith<const volatile T&&, const volatile int&&>());
 } // namespace NoDefaultCommonType
 
 struct BadBasicCommonType {
   // This test is ill-formed, NDR. If it ever blows up in our faces: that's a good thing.
   // In the meantime, the test should be included. If compiler support is added, then an include guard
   // should be placed so the test doesn't get deleted.
 };
 
 namespace std {
 template <>
 struct common_type<BadBasicCommonType, int> {
   using type = BadBasicCommonType;
 };
 
 template <>
 struct common_type<int, BadBasicCommonType> {
   using type = int;
 };
 } // namespace std
 static_assert(requires {
   typename std::common_type_t<BadBasicCommonType, int>;
 });
 static_assert(requires {
   typename std::common_type_t<int, BadBasicCommonType>;
 });
 static_assert(!std::same_as<std::common_type_t<BadBasicCommonType, int>,
                             std::common_type_t<int, BadBasicCommonType> >);
 static_assert(!CheckCommonWith<BadBasicCommonType, int>());
 
 struct DullCommonType {};
 static_assert(!std::convertible_to<DullCommonType, int>);
 
 struct T1 {};
 static_assert(!std::convertible_to<DullCommonType, T1>);
 
 namespace std {
 template <>
 struct common_type<T1, int> {
   using type = DullCommonType;
 };
 
 template <>
 struct common_type<int, T1> {
   using type = DullCommonType;
 };
 } // namespace std
 static_assert(HasValidCommonType<T1, int>());
 static_assert(!CheckCommonWith<T1, int>());
 
 struct CommonTypeImplicitlyConstructibleFromInt {
   explicit(false) CommonTypeImplicitlyConstructibleFromInt(int);
 };
 static_assert(requires {
   static_cast<CommonTypeImplicitlyConstructibleFromInt>(0);
 });
 
 struct T2 {};
 static_assert(
     !std::convertible_to<CommonTypeImplicitlyConstructibleFromInt, T2>);
 
 namespace std {
 template <>
 struct common_type<T2, int> {
   using type = CommonTypeImplicitlyConstructibleFromInt;
 };
 
 template <>
 struct common_type<int, T2> {
   using type = CommonTypeImplicitlyConstructibleFromInt;
 };
 } // namespace std
 static_assert(HasValidCommonType<T2, int>());
 static_assert(!CheckCommonWith<T2, int>());
 
 struct CommonTypeExplicitlyConstructibleFromInt {
   explicit CommonTypeExplicitlyConstructibleFromInt(int);
 };
 static_assert(requires {
   static_cast<CommonTypeExplicitlyConstructibleFromInt>(0);
 });
 
 struct T3 {};
 static_assert(
     !std::convertible_to<CommonTypeExplicitlyConstructibleFromInt, T2>);
 
 namespace std {
 template <>
 struct common_type<T3, int> {
   using type = CommonTypeExplicitlyConstructibleFromInt;
 };
 
 template <>
 struct common_type<int, T3> {
   using type = CommonTypeExplicitlyConstructibleFromInt;
 };
 } // namespace std
 static_assert(HasValidCommonType<T3, int>());
 static_assert(!CheckCommonWith<T3, int>());
 
 struct T4 {};
 struct CommonTypeImplicitlyConstructibleFromT4 {
   explicit(false) CommonTypeImplicitlyConstructibleFromT4(T4);
 };
 static_assert(requires(T4 t4) {
   static_cast<CommonTypeImplicitlyConstructibleFromT4>(t4);
 });
 
 namespace std {
 template <>
 struct common_type<T4, int> {
   using type = CommonTypeImplicitlyConstructibleFromT4;
 };
 
 template <>
 struct common_type<int, T4> {
   using type = CommonTypeImplicitlyConstructibleFromT4;
 };
 } // namespace std
 static_assert(HasValidCommonType<T4, int>());
 static_assert(!CheckCommonWith<T4, int>());
 
 struct T5 {};
 struct CommonTypeExplicitlyConstructibleFromT5 {
   explicit CommonTypeExplicitlyConstructibleFromT5(T5);
 };
 static_assert(requires(T5 t5) {
   static_cast<CommonTypeExplicitlyConstructibleFromT5>(t5);
 });
 
 namespace std {
 template <>
 struct common_type<T5, int> {
   using type = CommonTypeExplicitlyConstructibleFromT5;
 };
 
 template <>
 struct common_type<int, T5> {
   using type = CommonTypeExplicitlyConstructibleFromT5;
 };
 } // namespace std
 static_assert(HasValidCommonType<T5, int>());
 static_assert(!CheckCommonWith<T5, int>());
 
 struct T6 {};
 struct CommonTypeNoCommonReference {
   CommonTypeNoCommonReference(T6);
   CommonTypeNoCommonReference(int);
 };
 
 namespace std {
 template <>
 struct common_type<T6, int> {
   using type = CommonTypeNoCommonReference;
 };
 
 template <>
 struct common_type<int, T6> {
   using type = CommonTypeNoCommonReference;
 };
 
 template <>
 struct common_type<T6&, int&> {};
 
 template <>
 struct common_type<int&, T6&> {};
 
 template <>
 struct common_type<T6&, const int&> {};
 
 template <>
 struct common_type<int&, const T6&> {};
 
 template <>
 struct common_type<T6&, volatile int&> {};
 
 template <>
 struct common_type<int&, volatile T6&> {};
 
 template <>
 struct common_type<T6&, const volatile int&> {};
 
 template <>
 struct common_type<int&, const volatile T6&> {};
 
 template <>
 struct common_type<const T6&, int&> {};
 
 template <>
 struct common_type<const int&, T6&> {};
 
 template <>
 struct common_type<const T6&, const int&> {};
 
 template <>
 struct common_type<const int&, const T6&> {};
 
 template <>
 struct common_type<const T6&, volatile int&> {};
 
 template <>
 struct common_type<const int&, volatile T6&> {};
 
 template <>
 struct common_type<const T6&, const volatile int&> {};
 
 template <>
 struct common_type<const int&, const volatile T6&> {};
 
 template <>
 struct common_type<volatile T6&, int&> {};
 
 template <>
 struct common_type<volatile int&, T6&> {};
 
 template <>
 struct common_type<volatile T6&, const int&> {};
 
 template <>
 struct common_type<volatile int&, const T6&> {};
 
 template <>
 struct common_type<volatile T6&, volatile int&> {};
 
 template <>
 struct common_type<volatile int&, volatile T6&> {};
 
 template <>
 struct common_type<volatile T6&, const volatile int&> {};
 
 template <>
 struct common_type<volatile int&, const volatile T6&> {};
 
 template <>
 struct common_type<const volatile T6&, int&> {};
 
 template <>
 struct common_type<const volatile int&, T6&> {};
 
 template <>
 struct common_type<const volatile T6&, const int&> {};
 
 template <>
 struct common_type<const volatile int&, const T6&> {};
 
 template <>
 struct common_type<const volatile T6&, volatile int&> {};
 
 template <>
 struct common_type<const volatile int&, volatile T6&> {};
 
 template <>
 struct common_type<const volatile T6&, const volatile int&> {};
 
 template <>
 struct common_type<const volatile int&, const volatile T6&> {};
 } // namespace std
 
 template <typename T, typename U>
 constexpr bool HasCommonReference() noexcept {
   return requires { typename std::common_reference_t<T, U>; };
 }
 
 static_assert(HasValidCommonType<T6, int>());
 static_assert(!HasCommonReference<const T6&, const int&>());
 static_assert(!CheckCommonWith<T6, int>());
 
 struct T7 {};
 struct CommonTypeNoMetaCommonReference {
   CommonTypeNoMetaCommonReference(T7);
   CommonTypeNoMetaCommonReference(int);
 };
 
 namespace std {
 template <>
 struct common_type<T7, int> {
   using type = CommonTypeNoMetaCommonReference;
 };
 
 template <>
 struct common_type<int, T7> {
   using type = CommonTypeNoMetaCommonReference;
 };
 
 template <>
 struct common_type<T7&, int&> {
   using type = void;
 };
 
 template <>
 struct common_type<int&, T7&> {
   using type = void;
 };
 
 template <>
 struct common_type<T7&, const int&> {
   using type = void;
 };
 
 template <>
 struct common_type<int&, const T7&> {
   using type = void;
 };
 
 template <>
 struct common_type<T7&, volatile int&> {
   using type = void;
 };
 
 template <>
 struct common_type<int&, volatile T7&> {
   using type = void;
 };
 
 template <>
 struct common_type<T7&, const volatile int&> {
   using type = void;
 };
 
 template <>
 struct common_type<int&, const volatile T7&> {
   using type = void;
 };
 
 template <>
 struct common_type<const T7&, int&> {
   using type = void;
 };
 
 template <>
 struct common_type<const int&, T7&> {
   using type = void;
 };
 
 template <>
 struct common_type<const T7&, const int&> {
   using type = void;
 };
 
 template <>
 struct common_type<const int&, const T7&> {
   using type = void;
 };
 
 template <>
 struct common_type<const T7&, volatile int&> {
   using type = void;
 };
 
 template <>
 struct common_type<const int&, volatile T7&> {
   using type = void;
 };
 
 template <>
 struct common_type<const T7&, const volatile int&> {
   using type = void;
 };
 
 template <>
 struct common_type<const int&, const volatile T7&> {
   using type = void;
 };
 
 template <>
 struct common_type<volatile T7&, int&> {
   using type = void;
 };
 
 template <>
 struct common_type<volatile int&, T7&> {
   using type = void;
 };
 
 template <>
 struct common_type<volatile T7&, const int&> {
   using type = void;
 };
 
 template <>
 struct common_type<volatile int&, const T7&> {
   using type = void;
 };
 
 template <>
 struct common_type<volatile T7&, volatile int&> {
   using type = void;
 };
 
 template <>
 struct common_type<volatile int&, volatile T7&> {
   using type = void;
 };
 
 template <>
 struct common_type<volatile T7&, const volatile int&> {
   using type = void;
 };
 
 template <>
 struct common_type<volatile int&, const volatile T7&> {
   using type = void;
 };
 
 template <>
 struct common_type<const volatile T7&, int&> {
   using type = void;
 };
 
 template <>
 struct common_type<const volatile int&, T7&> {
   using type = void;
 };
 
 template <>
 struct common_type<const volatile T7&, const int&> {
   using type = void;
 };
 
 template <>
 struct common_type<const volatile int&, const T7&> {
   using type = void;
 };
 
 template <>
 struct common_type<const volatile T7&, volatile int&> {
   using type = void;
 };
 
 template <>
 struct common_type<const volatile int&, volatile T7&> {
   using type = void;
 };
 
 template <>
 struct common_type<const volatile T7&, const volatile int&> {
   using type = void;
 };
 
 template <>
 struct common_type<const volatile int&, const volatile T7&> {
   using type = void;
 };
 } // namespace std
 static_assert(HasValidCommonType<T7, int>());
 static_assert(HasValidCommonType<const T7&, const int&>());
 static_assert(HasCommonReference<const T7&, const int&>());
 static_assert(
     !HasCommonReference<std::common_type_t<T7, int>&,
                         std::common_reference_t<const T7&, const int&> >());
 static_assert(!CheckCommonWith<T7, int>());
 
 struct CommonWithInt {
   operator int() const volatile;
 };
 
 namespace std {
 template <>
 struct common_type<CommonWithInt, int> {
   using type = int;
 };
 
 template <>
 struct common_type<int, CommonWithInt> : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<CommonWithInt&, int&> : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<int&, CommonWithInt&> : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<CommonWithInt&, const int&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<int&, const CommonWithInt&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<CommonWithInt&, volatile int&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<int&, volatile CommonWithInt&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<CommonWithInt&, const volatile int&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<int&, const volatile CommonWithInt&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<const CommonWithInt&, int&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<const int&, CommonWithInt&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<const CommonWithInt&, const int&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<const int&, const CommonWithInt&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<const CommonWithInt&, volatile int&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<const int&, volatile CommonWithInt&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<const CommonWithInt&, const volatile int&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<const int&, const volatile CommonWithInt&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<volatile CommonWithInt&, int&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<volatile int&, CommonWithInt&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<volatile CommonWithInt&, const int&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<volatile int&, const CommonWithInt&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<volatile CommonWithInt&, volatile int&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<volatile int&, volatile CommonWithInt&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<volatile CommonWithInt&, const volatile int&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<volatile int&, const volatile CommonWithInt&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<const volatile CommonWithInt&, int&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<const volatile int&, CommonWithInt&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<const volatile CommonWithInt&, const int&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<const volatile int&, const CommonWithInt&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<const volatile CommonWithInt&, volatile int&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<const volatile int&, volatile CommonWithInt&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<const volatile CommonWithInt&, const volatile int&>
     : common_type<CommonWithInt, int> {};
 
 template <>
 struct common_type<const volatile int&, const volatile CommonWithInt&>
     : common_type<CommonWithInt, int> {};
 } // namespace std
 static_assert(CheckCommonWith<CommonWithInt, int>());
 
 struct CommonWithIntButRefLong {
   operator int() const volatile;
 };
 
 namespace std {
 template <>
 struct common_type<CommonWithIntButRefLong, int> {
   using type = int;
 };
 
 template <>
 struct common_type<int, CommonWithIntButRefLong>
     : common_type<CommonWithIntButRefLong, int> {};
 
 template <>
 struct common_type<CommonWithIntButRefLong&, int&> {
   using type = long;
 };
 
 template <>
 struct common_type<int&, CommonWithIntButRefLong&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<CommonWithIntButRefLong&, const int&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<int&, const CommonWithIntButRefLong&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<CommonWithIntButRefLong&, volatile int&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<int&, volatile CommonWithIntButRefLong&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<CommonWithIntButRefLong&, const volatile int&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<int&, const volatile CommonWithIntButRefLong&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<const CommonWithIntButRefLong&, int&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<const int&, CommonWithIntButRefLong&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<const CommonWithIntButRefLong&, const int&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<const int&, const CommonWithIntButRefLong&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<const CommonWithIntButRefLong&, volatile int&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<const int&, volatile CommonWithIntButRefLong&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<const CommonWithIntButRefLong&, const volatile int&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<const int&, const volatile CommonWithIntButRefLong&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<volatile CommonWithIntButRefLong&, int&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<volatile int&, CommonWithIntButRefLong&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<volatile CommonWithIntButRefLong&, const int&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<volatile int&, const CommonWithIntButRefLong&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<volatile CommonWithIntButRefLong&, volatile int&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<volatile int&, volatile CommonWithIntButRefLong&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<volatile CommonWithIntButRefLong&, const volatile int&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<volatile int&, const volatile CommonWithIntButRefLong&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<const volatile CommonWithIntButRefLong&, int&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<const volatile int&, CommonWithIntButRefLong&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<const volatile CommonWithIntButRefLong&, const int&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<const volatile int&, const CommonWithIntButRefLong&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<const volatile CommonWithIntButRefLong&, volatile int&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<const volatile int&, volatile CommonWithIntButRefLong&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<const volatile CommonWithIntButRefLong&, const volatile int&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 
 template <>
 struct common_type<const volatile int&, const volatile CommonWithIntButRefLong&>
     : common_type<CommonWithIntButRefLong&, int&> {};
 } // namespace std
 static_assert(CheckCommonWith<CommonWithIntButRefLong, int>());
 
 int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.lang/concept.commonref/common_reference.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 From, class To>
 // concept common_reference_with;
 
 #include <concepts>
 
 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&&>);
   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&&>);
   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<const T&, U&&>);
   static_assert(std::common_reference_with<const T&, const U&&>);
   static_assert(std::common_reference_with<const T&, volatile U&&>);
   static_assert(std::common_reference_with<const T&, const volatile U&&>);
   static_assert(std::common_reference_with<volatile T&, U&&>);
   static_assert(std::common_reference_with<volatile T&, const U&&>);
   static_assert(std::common_reference_with<volatile T&, volatile U&&>);
   static_assert(std::common_reference_with<volatile T&, const volatile U&&>);
   static_assert(std::common_reference_with<const volatile T&, U&&>);
   static_assert(std::common_reference_with<const volatile T&, const U&&>);
   static_assert(std::common_reference_with<const volatile T&, volatile U&&>);
   static_assert(
       std::common_reference_with<const volatile T&, const volatile U&&>);
 
   return std::common_reference_with<T, U>;
 }
 
 namespace BuiltinTypes {
 // fundamental types
 static_assert(std::common_reference_with<void, void>);
 static_assert(CheckCommonReferenceWith<int, int>());
 static_assert(CheckCommonReferenceWith<int, long>());
 static_assert(CheckCommonReferenceWith<int, unsigned char>());
 #ifndef _LIBCPP_HAS_NO_INT128
 static_assert(CheckCommonReferenceWith<int, __int128_t>());
 #endif
 static_assert(CheckCommonReferenceWith<int, double>());
 
 // arrays
 static_assert(CheckCommonReferenceWith<int[5], int[5]>());
 
 // pointers (common with void*)
 static_assert(CheckCommonReferenceWith<int*, void*>());
 static_assert(CheckCommonReferenceWith<int*, const void*>());
 static_assert(CheckCommonReferenceWith<int*, volatile void*>());
 static_assert(CheckCommonReferenceWith<int*, const volatile void*>());
 static_assert(CheckCommonReferenceWith<const int*, void*>());
 static_assert(CheckCommonReferenceWith<const int*, const void*>());
 static_assert(CheckCommonReferenceWith<const int*, volatile void*>());
 static_assert(CheckCommonReferenceWith<const int*, const volatile void*>());
 static_assert(CheckCommonReferenceWith<volatile int*, void*>());
 static_assert(CheckCommonReferenceWith<volatile int*, const void*>());
 static_assert(CheckCommonReferenceWith<volatile int*, volatile void*>());
 static_assert(CheckCommonReferenceWith<volatile int*, const volatile void*>());
 static_assert(CheckCommonReferenceWith<const volatile int*, void*>());
 static_assert(CheckCommonReferenceWith<const volatile int*, const void*>());
 static_assert(CheckCommonReferenceWith<const volatile int*, volatile void*>());
 static_assert(
     CheckCommonReferenceWith<const volatile int*, const volatile void*>());
 
 static_assert(CheckCommonReferenceWith<int (*)(), int (*)()>());
 static_assert(CheckCommonReferenceWith<int (*)(), int (*)() noexcept>());
 struct S {};
 static_assert(CheckCommonReferenceWith<int S::*, int S::*>());
 static_assert(CheckCommonReferenceWith<int S::*, const int S::*>());
 static_assert(CheckCommonReferenceWith<int (S::*)(), int (S::*)()>());
 static_assert(CheckCommonReferenceWith<int (S::*)(), int (S::*)() noexcept>());
 static_assert(
     CheckCommonReferenceWith<int (S::*)() const, int (S::*)() const>());
 static_assert(CheckCommonReferenceWith<int (S::*)() const,
                                        int (S::*)() const noexcept>());
 static_assert(
     CheckCommonReferenceWith<int (S::*)() volatile, int (S::*)() volatile>());
 static_assert(CheckCommonReferenceWith<int (S::*)() volatile,
                                        int (S::*)() volatile noexcept>());
 static_assert(CheckCommonReferenceWith<int (S::*)() const volatile,
                                        int (S::*)() const volatile>());
 static_assert(CheckCommonReferenceWith<int (S::*)() const volatile,
                                        int (S::*)() const volatile noexcept>());
 
 // nonsense
 static_assert(!std::common_reference_with<double, float*>);
 static_assert(!std::common_reference_with<int, int[5]>);
 static_assert(!std::common_reference_with<int*, long*>);
 static_assert(!std::common_reference_with<int*, unsigned int*>);
 static_assert(!std::common_reference_with<int (*)(), int (*)(int)>);
 static_assert(!std::common_reference_with<int S::*, float S::*>);
 static_assert(!std::common_reference_with<int (S::*)(), int (S::*)() const>);
 static_assert(!std::common_reference_with<int (S::*)(), int (S::*)() volatile>);
 static_assert(
     !std::common_reference_with<int (S::*)(), int (S::*)() const volatile>);
 static_assert(
     !std::common_reference_with<int (S::*)() const, int (S::*)() volatile>);
 static_assert(!std::common_reference_with<int (S::*)() const,
                                           int (S::*)() const volatile>);
 static_assert(!std::common_reference_with<int (S::*)() volatile,
                                           int (S::*)() const volatile>);
 } // namespace BuiltinTypes
 
 namespace NoDefaultCommonReference {
 class T {};
 
 static_assert(!std::common_reference_with<T, int>);
 static_assert(!std::common_reference_with<int, T>);
 static_assert(!std::common_reference_with<T, int[10]>);
 static_assert(!std::common_reference_with<T[10], int>);
 static_assert(!std::common_reference_with<T*, int*>);
 static_assert(!std::common_reference_with<T*, const int*>);
 static_assert(!std::common_reference_with<T*, volatile int*>);
 static_assert(!std::common_reference_with<T*, const volatile int*>);
 static_assert(!std::common_reference_with<const T*, int*>);
 static_assert(!std::common_reference_with<volatile T*, int*>);
 static_assert(!std::common_reference_with<const volatile T*, int*>);
 static_assert(!std::common_reference_with<const T*, const int*>);
 static_assert(!std::common_reference_with<const T*, volatile int*>);
 static_assert(!std::common_reference_with<const T*, const volatile int*>);
 static_assert(!std::common_reference_with<const T*, const int*>);
 static_assert(!std::common_reference_with<volatile T*, const int*>);
 static_assert(!std::common_reference_with<const volatile T*, const int*>);
 static_assert(!std::common_reference_with<volatile T*, const int*>);
 static_assert(!std::common_reference_with<volatile T*, volatile int*>);
 static_assert(!std::common_reference_with<volatile T*, const volatile int*>);
 static_assert(!std::common_reference_with<const T*, volatile int*>);
 static_assert(!std::common_reference_with<volatile T*, volatile int*>);
 static_assert(!std::common_reference_with<const volatile T*, volatile int*>);
 static_assert(!std::common_reference_with<const volatile T*, const int*>);
 static_assert(!std::common_reference_with<const volatile T*, volatile int*>);
 static_assert(
     !std::common_reference_with<const volatile T*, const volatile int*>);
 static_assert(!std::common_reference_with<const T*, const volatile int*>);
 static_assert(!std::common_reference_with<volatile T*, const volatile int*>);
 static_assert(
     !std::common_reference_with<const volatile T*, const volatile int*>);
 static_assert(!std::common_reference_with<T&, int&>);
 static_assert(!std::common_reference_with<T&, const int&>);
 static_assert(!std::common_reference_with<T&, volatile int&>);
 static_assert(!std::common_reference_with<T&, const volatile int&>);
 static_assert(!std::common_reference_with<const T&, int&>);
 static_assert(!std::common_reference_with<volatile T&, int&>);
 static_assert(!std::common_reference_with<const volatile T&, int&>);
 static_assert(!std::common_reference_with<const T&, const int&>);
 static_assert(!std::common_reference_with<const T&, volatile int&>);
 static_assert(!std::common_reference_with<const T&, const volatile int&>);
 static_assert(!std::common_reference_with<const T&, const int&>);
 static_assert(!std::common_reference_with<volatile T&, const int&>);
 static_assert(!std::common_reference_with<const volatile T&, const int&>);
 static_assert(!std::common_reference_with<volatile T&, const int&>);
 static_assert(!std::common_reference_with<volatile T&, volatile int&>);
 static_assert(!std::common_reference_with<volatile T&, const volatile int&>);
 static_assert(!std::common_reference_with<const T&, volatile int&>);
 static_assert(!std::common_reference_with<volatile T&, volatile int&>);
 static_assert(!std::common_reference_with<const volatile T&, volatile int&>);
 static_assert(!std::common_reference_with<const volatile T&, const int&>);
 static_assert(!std::common_reference_with<const volatile T&, volatile int&>);
 static_assert(
     !std::common_reference_with<const volatile T&, const volatile int&>);
 static_assert(!std::common_reference_with<const T&, const volatile int&>);
 static_assert(!std::common_reference_with<volatile T&, const volatile int&>);
 static_assert(
     !std::common_reference_with<const volatile T&, const volatile int&>);
 static_assert(!std::common_reference_with<T&, int&&>);
 static_assert(!std::common_reference_with<T&, const int&&>);
 static_assert(!std::common_reference_with<T&, volatile int&&>);
 static_assert(!std::common_reference_with<T&, const volatile int&&>);
 static_assert(!std::common_reference_with<const T&, int&&>);
 static_assert(!std::common_reference_with<volatile T&, int&&>);
 static_assert(!std::common_reference_with<const volatile T&, int&&>);
 static_assert(!std::common_reference_with<const T&, const int&&>);
 static_assert(!std::common_reference_with<const T&, volatile int&&>);
 static_assert(!std::common_reference_with<const T&, const volatile int&&>);
 static_assert(!std::common_reference_with<const T&, const int&&>);
 static_assert(!std::common_reference_with<volatile T&, const int&&>);
 static_assert(!std::common_reference_with<const volatile T&, const int&&>);
 static_assert(!std::common_reference_with<volatile T&, const int&&>);
 static_assert(!std::common_reference_with<volatile T&, volatile int&&>);
 static_assert(!std::common_reference_with<volatile T&, const volatile int&&>);
 static_assert(!std::common_reference_with<const T&, volatile int&&>);
 static_assert(!std::common_reference_with<volatile T&, volatile int&&>);
 static_assert(!std::common_reference_with<const volatile T&, volatile int&&>);
 static_assert(!std::common_reference_with<const volatile T&, const int&&>);
 static_assert(!std::common_reference_with<const volatile T&, volatile int&&>);
 static_assert(
     !std::common_reference_with<const volatile T&, const volatile int&&>);
 static_assert(!std::common_reference_with<const T&, const volatile int&&>);
 static_assert(!std::common_reference_with<volatile T&, const volatile int&&>);
 static_assert(
     !std::common_reference_with<const volatile T&, const volatile int&&>);
 static_assert(!std::common_reference_with<T&&, int&>);
 static_assert(!std::common_reference_with<T&&, const int&>);
 static_assert(!std::common_reference_with<T&&, volatile int&>);
 static_assert(!std::common_reference_with<T&&, const volatile int&>);
 static_assert(!std::common_reference_with<const T&&, int&>);
 static_assert(!std::common_reference_with<volatile T&&, int&>);
 static_assert(!std::common_reference_with<const volatile T&&, int&>);
 static_assert(!std::common_reference_with<const T&&, const int&>);
 static_assert(!std::common_reference_with<const T&&, volatile int&>);
 static_assert(!std::common_reference_with<const T&&, const volatile int&>);
 static_assert(!std::common_reference_with<const T&&, const int&>);
 static_assert(!std::common_reference_with<volatile T&&, const int&>);
 static_assert(!std::common_reference_with<const volatile T&&, const int&>);
 static_assert(!std::common_reference_with<volatile T&&, const int&>);
 static_assert(!std::common_reference_with<volatile T&&, volatile int&>);
 static_assert(!std::common_reference_with<volatile T&&, const volatile int&>);
 static_assert(!std::common_reference_with<const T&&, volatile int&>);
 static_assert(!std::common_reference_with<volatile T&&, volatile int&>);
 static_assert(!std::common_reference_with<const volatile T&&, volatile int&>);
 static_assert(!std::common_reference_with<const volatile T&&, const int&>);
 static_assert(!std::common_reference_with<const volatile T&&, volatile int&>);
 static_assert(
     !std::common_reference_with<const volatile T&&, const volatile int&>);
 static_assert(!std::common_reference_with<const T&&, const volatile int&>);
 static_assert(!std::common_reference_with<volatile T&&, const volatile int&>);
 static_assert(
     !std::common_reference_with<const volatile T&&, const volatile int&>);
 static_assert(!std::common_reference_with<T&&, int&&>);
 static_assert(!std::common_reference_with<T&&, const int&&>);
 static_assert(!std::common_reference_with<T&&, volatile int&&>);
 static_assert(!std::common_reference_with<T&&, const volatile int&&>);
 static_assert(!std::common_reference_with<const T&&, int&&>);
 static_assert(!std::common_reference_with<volatile T&&, int&&>);
 static_assert(!std::common_reference_with<const volatile T&&, int&&>);
 static_assert(!std::common_reference_with<const T&&, const int&&>);
 static_assert(!std::common_reference_with<const T&&, volatile int&&>);
 static_assert(!std::common_reference_with<const T&&, const volatile int&&>);
 static_assert(!std::common_reference_with<const T&&, const int&&>);
 static_assert(!std::common_reference_with<volatile T&&, const int&&>);
 static_assert(!std::common_reference_with<const volatile T&&, const int&&>);
 static_assert(!std::common_reference_with<volatile T&&, const int&&>);
 static_assert(!std::common_reference_with<volatile T&&, volatile int&&>);
 static_assert(!std::common_reference_with<volatile T&&, const volatile int&&>);
 static_assert(!std::common_reference_with<const T&&, volatile int&&>);
 static_assert(!std::common_reference_with<volatile T&&, volatile int&&>);
 static_assert(!std::common_reference_with<const volatile T&&, volatile int&&>);
 static_assert(!std::common_reference_with<const volatile T&&, const int&&>);
 static_assert(!std::common_reference_with<const volatile T&&, volatile int&&>);
 static_assert(
     !std::common_reference_with<const volatile T&&, const volatile int&&>);
 static_assert(!std::common_reference_with<const T&&, const volatile int&&>);
 static_assert(!std::common_reference_with<volatile T&&, const volatile int&&>);
 static_assert(
     !std::common_reference_with<const volatile T&&, const volatile int&&>);
 } // namespace NoDefaultCommonReference
 
 struct BadBasicCommonReference {
   // This test is ill-formed, NDR. If it ever blows up in our faces: that's a good thing.
   // In the meantime, the test should be included. If compiler support is added, then an include guard
   // should be placed so the test doesn't get deleted.
   operator int() const;
   operator int&();
 };
 static_assert(std::convertible_to<BadBasicCommonReference, int>);
 static_assert(std::convertible_to<BadBasicCommonReference, int&>);
 
 namespace std {
 template <template <class> class X, template <class> class Y>
 struct basic_common_reference<BadBasicCommonReference, int, X, Y> {
   using type = BadBasicCommonReference&;
 };
 
 template <template <class> class X, template <class> class Y>
 struct basic_common_reference<int, BadBasicCommonReference, X, Y> {
   using type = int&;
 };
 } // namespace std
 static_assert(!std::common_reference_with<BadBasicCommonReference, int>);
 
 struct StructNotConvertibleToCommonReference {
   explicit(false) StructNotConvertibleToCommonReference(int);
 };
 static_assert(std::convertible_to<int, StructNotConvertibleToCommonReference>);
 
 namespace std {
 template <template <class> class X, template <class> class Y>
 struct basic_common_reference<StructNotConvertibleToCommonReference, int, X,
                               Y> {
   using type = int&;
 };
 
 template <template <class> class X, template <class> class Y>
 struct basic_common_reference<int, StructNotConvertibleToCommonReference, X,
                               Y> {
   using type = int&;
 };
 } // namespace std
 static_assert(
     !std::common_reference_with<StructNotConvertibleToCommonReference, int>);
 
 struct IntNotConvertibleToCommonReference {
   operator int&() const;
 };
 
 namespace std {
 template <template <class> class X, template <class> class Y>
 struct basic_common_reference<IntNotConvertibleToCommonReference, int, X, Y> {
   using type = int&;
 };
 
 template <template <class> class X, template <class> class Y>
 struct basic_common_reference<int, IntNotConvertibleToCommonReference, X, Y> {
   using type = int&;
 };
 } // namespace std
 static_assert(
     !std::common_reference_with<StructNotConvertibleToCommonReference, int>);
 
 struct HasCommonReference {
   explicit(false) HasCommonReference(int);
   operator int&() const;
 };
 
 namespace std {
 template <template <class> class X, template <class> class Y>
 struct basic_common_reference<HasCommonReference, int, X, Y> {
   using type = int&;
 };
 
 template <template <class> class X, template <class> class Y>
 struct basic_common_reference<int, HasCommonReference, X, Y> {
   using type = int&;
 };
 } // namespace std
 static_assert(!std::common_reference_with<HasCommonReference, int>);
 static_assert(std::common_reference_with<HasCommonReference, int&>);
 
 int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.lang/concept.constructible/constructible_from.compile.pass.cpp

void test() {
   test<std::unique_ptr<int>, std::unique_ptr<int> >();
   test<std::unique_ptr<int>, std::unique_ptr<int>&>();
   test<std::unique_ptr<int>, std::unique_ptr<int>&&>();
 
   test<std::array<int, 1> >();
   test<std::array<int, 1>, int>();
   test<std::array<int, 1>, int, int>();
 }
+
+int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.lang/concept.convertible/convertible_to.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 From, class To>
 // concept convertible_to;
 
 #include <concepts>
 #include <type_traits>
 
 namespace {
 enum ClassicEnum { a, b };
 enum class ScopedEnum { x, y };
 struct Empty {};
 using nullptr_t = decltype(nullptr);
 
 template <class T, class U>
 void CheckConvertibleTo() {
   static_assert(std::convertible_to<T, U>);
   static_assert(std::convertible_to<const T, U>);
   static_assert(std::convertible_to<T, const U>);
   static_assert(std::convertible_to<const T, const U>);
 }
 
 template <class T, class U>
 void CheckNotConvertibleTo() {
   static_assert(!std::convertible_to<T, U>);
   static_assert(!std::convertible_to<const T, U>);
   static_assert(!std::convertible_to<T, const U>);
   static_assert(!std::convertible_to<const T, const U>);
 }
 
 template <class T, class U>
 void CheckIsConvertibleButNotConvertibleTo() {
   // Sanity check T is either implicitly xor explicitly convertible to U.
   static_assert(std::is_convertible_v<T, U>);
   static_assert(std::is_convertible_v<const T, U>);
   static_assert(std::is_convertible_v<T, const U>);
   static_assert(std::is_convertible_v<const T, const U>);
   CheckNotConvertibleTo<T, U>();
 }
 
 // Tests that should objectively return false (except for bool and nullptr_t)
 template <class T>
 constexpr void CommonlyNotConvertibleTo() {
   CheckNotConvertibleTo<T, void>();
   CheckNotConvertibleTo<T, nullptr_t>();
   CheckNotConvertibleTo<T, T*>();
   CheckNotConvertibleTo<T, T Empty::*>();
   CheckNotConvertibleTo<T, T (Empty::*)()>();
   CheckNotConvertibleTo<T, T[sizeof(T)]>();
   CheckNotConvertibleTo<T, T (*)()>();
   CheckNotConvertibleTo<T, T (&)()>();
   CheckNotConvertibleTo<T, T(&&)()>();
 }
 
 template <std::same_as<bool> >
 constexpr void CommonlyNotConvertibleTo() {
   CheckNotConvertibleTo<bool, void>();
   CheckNotConvertibleTo<bool, nullptr_t>();
   CheckConvertibleTo<bool Empty::*, bool>();
   CheckConvertibleTo<bool (Empty::*)(), bool>();
   CheckConvertibleTo<bool[2], bool>();
   CheckConvertibleTo<bool (*)(), bool>();
   CheckConvertibleTo<bool (&)(), bool>();
   CheckConvertibleTo<bool(&&)(), bool>();
 }
 
 template <std::same_as<nullptr_t> >
 constexpr void CommonlyNotConvertibleTo() {
   CheckNotConvertibleTo<nullptr_t, void>();
   CheckConvertibleTo<nullptr_t, nullptr_t>();
   CheckConvertibleTo<nullptr_t, void*>();
   CheckConvertibleTo<nullptr_t, int Empty::*>();
   CheckConvertibleTo<nullptr_t, void (Empty::*)()>();
   CheckNotConvertibleTo<nullptr_t, int[2]>();
   CheckConvertibleTo<nullptr_t, void (*)()>();
   CheckNotConvertibleTo<nullptr_t, void (&)()>();
   CheckNotConvertibleTo<nullptr_t, void(&&)()>();
 }
 } // namespace
 
 using Function = void();
 using NoexceptFunction = void() noexcept;
 using ConstFunction = void() const;
 using Array = char[1];
 
 struct StringType {
   StringType(const char*) {}
 };
 
 class NonCopyable {
   NonCopyable(NonCopyable&);
 };
 
 template <typename T>
 class CannotInstantiate {
   enum { X = T::ThisExpressionWillBlowUp };
 };
 
 struct abstract {
   virtual int f() = 0;
 };
 
 struct ExplicitlyConvertible;
 struct ImplicitlyConvertible;
 
 struct ExplicitlyConstructible {
   explicit ExplicitlyConstructible(int);
   explicit ExplicitlyConstructible(ExplicitlyConvertible);
   explicit ExplicitlyConstructible(ImplicitlyConvertible) = delete;
 };
 
 struct ExplicitlyConvertible {
   explicit operator ExplicitlyConstructible() const {
     return ExplicitlyConstructible(0);
   }
 };
 
 struct ImplicitlyConstructible;
 
 struct ImplicitlyConvertible {
   operator ExplicitlyConstructible() const;
   operator ImplicitlyConstructible() const = delete;
 };
 
 struct ImplicitlyConstructible {
   ImplicitlyConstructible(ImplicitlyConvertible);
 };
 
 int main(int, char**) {
   // void
   CheckConvertibleTo<void, void>();
   CheckNotConvertibleTo<void, Function>();
   CheckNotConvertibleTo<void, Function&>();
   CheckNotConvertibleTo<void, Function*>();
   CheckNotConvertibleTo<void, NoexceptFunction>();
   CheckNotConvertibleTo<void, NoexceptFunction&>();
   CheckNotConvertibleTo<void, NoexceptFunction*>();
   CheckNotConvertibleTo<void, Array>();
   CheckNotConvertibleTo<void, Array&>();
   CheckNotConvertibleTo<void, char>();
   CheckNotConvertibleTo<void, char&>();
   CheckNotConvertibleTo<void, char*>();
   CheckNotConvertibleTo<char, void>();
 
   // Function
   CheckNotConvertibleTo<Function, void>();
   CheckNotConvertibleTo<Function, Function>();
   CheckNotConvertibleTo<Function, NoexceptFunction>();
   CheckNotConvertibleTo<Function, NoexceptFunction&>();
   CheckNotConvertibleTo<Function, NoexceptFunction*>();
   CheckNotConvertibleTo<Function, NoexceptFunction* const>();
   CheckConvertibleTo<Function, Function&>();
   CheckConvertibleTo<Function, Function*>();
   CheckConvertibleTo<Function, Function* const>();
 
   static_assert(std::convertible_to<Function, Function&&>);
   static_assert(!std::convertible_to<Function, NoexceptFunction&&>);
 
   CheckNotConvertibleTo<Function, Array>();
   CheckNotConvertibleTo<Function, Array&>();
   CheckNotConvertibleTo<Function, char>();
   CheckNotConvertibleTo<Function, char&>();
   CheckNotConvertibleTo<Function, char*>();
 
   // Function&
   CheckNotConvertibleTo<Function&, void>();
   CheckNotConvertibleTo<Function&, Function>();
   CheckConvertibleTo<Function&, Function&>();
 
   CheckConvertibleTo<Function&, Function*>();
   CheckNotConvertibleTo<Function&, Array>();
   CheckNotConvertibleTo<Function&, Array&>();
   CheckNotConvertibleTo<Function&, char>();
   CheckNotConvertibleTo<Function&, char&>();
   CheckNotConvertibleTo<Function&, char*>();
 
   // Function*
   CheckNotConvertibleTo<Function*, void>();
   CheckNotConvertibleTo<Function*, Function>();
   CheckNotConvertibleTo<Function*, Function&>();
   CheckConvertibleTo<Function*, Function*>();
 
   CheckNotConvertibleTo<Function*, Array>();
   CheckNotConvertibleTo<Function*, Array&>();
   CheckNotConvertibleTo<Function*, char>();
   CheckNotConvertibleTo<Function*, char&>();
   CheckNotConvertibleTo<Function*, char*>();
 
   // Non-referencable function type
   static_assert(!std::convertible_to<ConstFunction, Function>);
   static_assert(!std::convertible_to<ConstFunction, Function*>);
   static_assert(!std::convertible_to<ConstFunction, Function&>);
   static_assert(!std::convertible_to<ConstFunction, Function&&>);
   static_assert(!std::convertible_to<Function*, ConstFunction>);
   static_assert(!std::convertible_to<Function&, ConstFunction>);
   static_assert(!std::convertible_to<ConstFunction, ConstFunction>);
   static_assert(!std::convertible_to<ConstFunction, void>);
 
   // NoexceptFunction
   CheckNotConvertibleTo<NoexceptFunction, void>();
   CheckNotConvertibleTo<NoexceptFunction, Function>();
   CheckNotConvertibleTo<NoexceptFunction, NoexceptFunction>();
   CheckConvertibleTo<NoexceptFunction, NoexceptFunction&>();
   CheckConvertibleTo<NoexceptFunction, NoexceptFunction*>();
   CheckConvertibleTo<NoexceptFunction, NoexceptFunction* const>();
   CheckConvertibleTo<NoexceptFunction, Function&>();
   CheckConvertibleTo<NoexceptFunction, Function*>();
   CheckConvertibleTo<NoexceptFunction, Function* const>();
 
   static_assert(std::convertible_to<NoexceptFunction, Function&&>);
   static_assert(std::convertible_to<NoexceptFunction, NoexceptFunction&&>);
 
   CheckNotConvertibleTo<NoexceptFunction, Array>();
   CheckNotConvertibleTo<NoexceptFunction, Array&>();
   CheckNotConvertibleTo<NoexceptFunction, char>();
   CheckNotConvertibleTo<NoexceptFunction, char&>();
   CheckNotConvertibleTo<NoexceptFunction, char*>();
 
   // NoexceptFunction&
   CheckNotConvertibleTo<NoexceptFunction&, void>();
   CheckNotConvertibleTo<NoexceptFunction&, Function>();
   CheckNotConvertibleTo<NoexceptFunction&, NoexceptFunction>();
   CheckConvertibleTo<NoexceptFunction&, Function&>();
   CheckConvertibleTo<NoexceptFunction&, NoexceptFunction&>();
 
   CheckConvertibleTo<NoexceptFunction&, Function*>();
   CheckConvertibleTo<NoexceptFunction&, NoexceptFunction*>();
   CheckNotConvertibleTo<NoexceptFunction&, Array>();
   CheckNotConvertibleTo<NoexceptFunction&, Array&>();
   CheckNotConvertibleTo<NoexceptFunction&, char>();
   CheckNotConvertibleTo<NoexceptFunction&, char&>();
   CheckNotConvertibleTo<NoexceptFunction&, char*>();
 
   // NoexceptFunction*
   CheckNotConvertibleTo<NoexceptFunction*, void>();
   CheckNotConvertibleTo<NoexceptFunction*, Function>();
   CheckNotConvertibleTo<NoexceptFunction*, Function&>();
   CheckNotConvertibleTo<NoexceptFunction*, NoexceptFunction>();
   CheckNotConvertibleTo<NoexceptFunction*, NoexceptFunction&>();
   CheckConvertibleTo<NoexceptFunction*, Function*>();
   CheckConvertibleTo<NoexceptFunction*, NoexceptFunction*>();
 
   CheckNotConvertibleTo<NoexceptFunction*, Array>();
   CheckNotConvertibleTo<NoexceptFunction*, Array&>();
   CheckNotConvertibleTo<NoexceptFunction*, char>();
   CheckNotConvertibleTo<NoexceptFunction*, char&>();
   CheckNotConvertibleTo<NoexceptFunction*, char*>();
 
   // Array
   CheckNotConvertibleTo<Array, void>();
   CheckNotConvertibleTo<Array, Function>();
   CheckNotConvertibleTo<Array, Function&>();
   CheckNotConvertibleTo<Array, Function*>();
   CheckNotConvertibleTo<Array, NoexceptFunction>();
   CheckNotConvertibleTo<Array, NoexceptFunction&>();
   CheckNotConvertibleTo<Array, NoexceptFunction*>();
   CheckNotConvertibleTo<Array, Array>();
 
   static_assert(!std::convertible_to<Array, Array&>);
   static_assert(std::convertible_to<Array, const Array&>);
   static_assert(!std::convertible_to<Array, const volatile Array&>);
 
   static_assert(!std::convertible_to<const Array, Array&>);
   static_assert(std::convertible_to<const Array, const Array&>);
   static_assert(!std::convertible_to<Array, volatile Array&>);
   static_assert(!std::convertible_to<Array, const volatile Array&>);
 
   static_assert(std::convertible_to<Array, Array&&>);
   static_assert(std::convertible_to<Array, const Array&&>);
   static_assert(std::convertible_to<Array, volatile Array&&>);
   static_assert(std::convertible_to<Array, const volatile Array&&>);
   static_assert(std::convertible_to<const Array, const Array&&>);
   static_assert(!std::convertible_to<Array&, Array&&>);
   static_assert(!std::convertible_to<Array&&, Array&>);
 
   CheckNotConvertibleTo<Array, char>();
   CheckNotConvertibleTo<Array, char&>();
 
   static_assert(std::convertible_to<Array, char*>);
   static_assert(std::convertible_to<Array, const char*>);
   static_assert(std::convertible_to<Array, char* const>);
   static_assert(std::convertible_to<Array, char* const volatile>);
 
   static_assert(!std::convertible_to<const Array, char*>);
   static_assert(std::convertible_to<const Array, const char*>);
 
   static_assert(!std::convertible_to<char[42][42], char*>);
   static_assert(!std::convertible_to<char[][1], char*>);
 
   // Array&
   CheckNotConvertibleTo<Array&, void>();
   CheckNotConvertibleTo<Array&, Function>();
   CheckNotConvertibleTo<Array&, Function&>();
   CheckNotConvertibleTo<Array&, Function*>();
   CheckNotConvertibleTo<Array&, NoexceptFunction>();
   CheckNotConvertibleTo<Array&, NoexceptFunction&>();
   CheckNotConvertibleTo<Array&, NoexceptFunction*>();
   CheckNotConvertibleTo<Array&, Array>();
 
   static_assert(std::convertible_to<Array&, Array&>);
   static_assert(std::convertible_to<Array&, const Array&>);
   static_assert(!std::convertible_to<const Array&, Array&>);
   static_assert(std::convertible_to<const Array&, const Array&>);
 
   CheckNotConvertibleTo<Array&, char>();
   CheckNotConvertibleTo<Array&, char&>();
 
   static_assert(std::convertible_to<Array&, char*>);
   static_assert(std::convertible_to<Array&, const char*>);
   static_assert(!std::convertible_to<const Array&, char*>);
   static_assert(std::convertible_to<const Array&, const char*>);
 
   static_assert(std::convertible_to<Array, StringType>);
   static_assert(std::convertible_to<char(&)[], StringType>);
 
   // char
   CheckNotConvertibleTo<char, void>();
   CheckNotConvertibleTo<char, Function>();
   CheckNotConvertibleTo<char, Function&>();
   CheckNotConvertibleTo<char, Function*>();
   CheckNotConvertibleTo<char, NoexceptFunction>();
   CheckNotConvertibleTo<char, NoexceptFunction&>();
   CheckNotConvertibleTo<char, NoexceptFunction*>();
   CheckNotConvertibleTo<char, Array>();
   CheckNotConvertibleTo<char, Array&>();
 
   CheckConvertibleTo<char, char>();
 
   static_assert(!std::convertible_to<char, char&>);
   static_assert(std::convertible_to<char, const char&>);
   static_assert(!std::convertible_to<const char, char&>);
   static_assert(std::convertible_to<const char, const char&>);
 
   CheckNotConvertibleTo<char, char*>();
 
   // char&
   CheckNotConvertibleTo<char&, void>();
   CheckNotConvertibleTo<char&, Function>();
   CheckNotConvertibleTo<char&, Function&>();
   CheckNotConvertibleTo<char&, Function*>();
   CheckNotConvertibleTo<char&, NoexceptFunction>();
   CheckNotConvertibleTo<char&, NoexceptFunction&>();
   CheckNotConvertibleTo<char&, NoexceptFunction*>();
   CheckNotConvertibleTo<char&, Array>();
   CheckNotConvertibleTo<char&, Array&>();
 
   CheckConvertibleTo<char&, char>();
 
   static_assert(std::convertible_to<char&, char&>);
   static_assert(std::convertible_to<char&, const char&>);
   static_assert(!std::convertible_to<const char&, char&>);
   static_assert(std::convertible_to<const char&, const char&>);
 
   CheckNotConvertibleTo<char&, char*>();
 
   // char*
   CheckNotConvertibleTo<char*, void>();
   CheckNotConvertibleTo<char*, Function>();
   CheckNotConvertibleTo<char*, Function&>();
   CheckNotConvertibleTo<char*, Function*>();
   CheckNotConvertibleTo<char*, NoexceptFunction>();
   CheckNotConvertibleTo<char*, NoexceptFunction&>();
   CheckNotConvertibleTo<char*, NoexceptFunction*>();
   CheckNotConvertibleTo<char*, Array>();
   CheckNotConvertibleTo<char*, Array&>();
 
   CheckNotConvertibleTo<char*, char>();
   CheckNotConvertibleTo<char*, char&>();
 
   static_assert(std::convertible_to<char*, char*>);
   static_assert(std::convertible_to<char*, const char*>);
   static_assert(!std::convertible_to<const char*, char*>);
   static_assert(std::convertible_to<const char*, const char*>);
 
   // NonCopyable
   static_assert(std::convertible_to<NonCopyable&, NonCopyable&>);
   static_assert(std::convertible_to<NonCopyable&, const NonCopyable&>);
   static_assert(std::convertible_to<NonCopyable&, const volatile NonCopyable&>);
   static_assert(std::convertible_to<NonCopyable&, volatile NonCopyable&>);
   static_assert(std::convertible_to<const NonCopyable&, const NonCopyable&>);
   static_assert(
       std::convertible_to<const NonCopyable&, const volatile NonCopyable&>);
   static_assert(
       std::convertible_to<volatile NonCopyable&, const volatile NonCopyable&>);
   static_assert(std::convertible_to<const volatile NonCopyable&,
                                     const volatile NonCopyable&>);
   static_assert(!std::convertible_to<const NonCopyable&, NonCopyable&>);
 
   // This test requires Access control SFINAE which we only have in C++11 or when
   // we are using the compiler builtin for convertible_to.
   CheckNotConvertibleTo<NonCopyable&, NonCopyable>();
 
   // Ensure that CannotInstantiate is not instantiated by convertible_to when it is not needed.
   // For example CannotInstantiate is instantiated as a part of ADL lookup for arguments of type CannotInstantiate*.
   static_assert(
       std::convertible_to<CannotInstantiate<int>*, CannotInstantiate<int>*>);
 
   // Test for PR13592
   static_assert(!std::convertible_to<abstract, abstract>);
 
   CommonlyNotConvertibleTo<int>();
   CommonlyNotConvertibleTo<bool>();
   CommonlyNotConvertibleTo<nullptr_t>();
 
   CheckNotConvertibleTo<int, ExplicitlyConstructible>();
   CheckNotConvertibleTo<ExplicitlyConvertible, ExplicitlyConstructible>();
   CheckNotConvertibleTo<ExplicitlyConstructible, ExplicitlyConvertible>();
   CheckIsConvertibleButNotConvertibleTo<ImplicitlyConvertible,
                                         ExplicitlyConstructible>();
   CheckNotConvertibleTo<ImplicitlyConstructible, ImplicitlyConvertible>();
 
   return 0;
 }

libcxx/test/std/concepts/concepts.lang/concept.copyconstructible/copy_constructible.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 copy_constructible;
 
 #include <concepts>
 #include <type_traits>
 
 #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*>);
 static_assert(std::copy_constructible<int&>);
 static_assert(std::copy_constructible<const int>);
 static_assert(std::copy_constructible<const int&>);
 static_assert(std::copy_constructible<volatile int>);
 static_assert(std::copy_constructible<volatile int&>);
 static_assert(std::copy_constructible<int (*)()>);
 static_assert(std::copy_constructible<int (&)()>);
 static_assert(std::copy_constructible<HasDefaultOps>);
 static_assert(std::copy_constructible<const CustomMoveCtor&>);
 static_assert(std::copy_constructible<volatile CustomMoveCtor&>);
 static_assert(std::copy_constructible<const CustomMoveAssign&>);
 static_assert(std::copy_constructible<volatile CustomMoveAssign&>);
 static_assert(std::copy_constructible<int HasDefaultOps::*>);
 static_assert(std::copy_constructible<void (HasDefaultOps::*)(int)>);
 static_assert(std::copy_constructible<MemberLvalueReference>);
 
 static_assert(!std::copy_constructible<void>);
 static_assert(!std::copy_constructible<CustomMoveAssign>);
 static_assert(!std::copy_constructible<const CustomMoveCtor>);
 static_assert(!std::copy_constructible<volatile CustomMoveCtor>);
 static_assert(!std::copy_constructible<const CustomMoveAssign>);
 static_assert(!std::copy_constructible<volatile CustomMoveAssign>);
 static_assert(!std::copy_constructible<int[10]>);
 static_assert(!std::copy_constructible<DeletedMoveCtor>);
 static_assert(!std::copy_constructible<ImplicitlyDeletedMoveCtor>);
 static_assert(!std::copy_constructible<DeletedMoveAssign>);
 static_assert(!std::copy_constructible<ImplicitlyDeletedMoveAssign>);
 
 static_assert(std::copy_constructible<DeletedMoveCtor&>);
 static_assert(std::copy_constructible<const DeletedMoveCtor&>);
 static_assert(std::copy_constructible<ImplicitlyDeletedMoveCtor&>);
 static_assert(std::copy_constructible<const ImplicitlyDeletedMoveCtor&>);
 static_assert(std::copy_constructible<DeletedMoveAssign&>);
 static_assert(std::copy_constructible<const DeletedMoveAssign&>);
 static_assert(std::copy_constructible<ImplicitlyDeletedMoveAssign&>);
 static_assert(std::copy_constructible<const ImplicitlyDeletedMoveAssign&>);
 
 // different to moveconstructible.pass.cpp
 static_assert(!std::copy_constructible<int&&>);
 static_assert(!std::copy_constructible<const int&&>);
 static_assert(!std::copy_constructible<volatile int&&>);
 static_assert(!std::copy_constructible<CustomMoveCtor>);
 static_assert(!std::copy_constructible<MoveOnly>);
 static_assert(!std::copy_constructible<const CustomMoveCtor&&>);
 static_assert(!std::copy_constructible<volatile CustomMoveCtor&&>);
 static_assert(!std::copy_constructible<const CustomMoveAssign&&>);
 static_assert(!std::copy_constructible<volatile CustomMoveAssign&&>);
 static_assert(!std::copy_constructible<DeletedMoveCtor&&>);
 static_assert(!std::copy_constructible<const DeletedMoveCtor&&>);
 static_assert(!std::copy_constructible<ImplicitlyDeletedMoveCtor&&>);
 static_assert(!std::copy_constructible<const ImplicitlyDeletedMoveCtor&&>);
 static_assert(!std::copy_constructible<DeletedMoveAssign&&>);
 static_assert(!std::copy_constructible<const DeletedMoveAssign&&>);
 static_assert(!std::copy_constructible<ImplicitlyDeletedMoveAssign&&>);
 static_assert(!std::copy_constructible<const ImplicitlyDeletedMoveAssign&&>);
 static_assert(!std::copy_constructible<MemberRvalueReference>);
 } // namespace MoveConstructibleTests
 
 namespace CopyConstructibleTests {
 struct CopyCtorUserDefined {
   CopyCtorUserDefined(CopyCtorUserDefined&&) noexcept = default;
   CopyCtorUserDefined(const CopyCtorUserDefined&);
 };
 static_assert(std::copy_constructible<CopyCtorUserDefined>);
 
 struct CopyAssignUserDefined {
   CopyAssignUserDefined& operator=(CopyAssignUserDefined&&) noexcept = default;
   CopyAssignUserDefined& operator=(const CopyAssignUserDefined&);
 };
 static_assert(!std::copy_constructible<CopyAssignUserDefined>);
 
 struct CopyCtorAndAssignUserDefined {
   CopyCtorAndAssignUserDefined(CopyCtorAndAssignUserDefined&&) noexcept =
       default;
   CopyCtorAndAssignUserDefined(const CopyCtorAndAssignUserDefined&);
   CopyCtorAndAssignUserDefined&
   operator=(CopyCtorAndAssignUserDefined&&) noexcept = default;
   CopyCtorAndAssignUserDefined& operator=(const CopyCtorAndAssignUserDefined&);
 };
 static_assert(std::copy_constructible<CopyCtorAndAssignUserDefined>);
 
 struct CopyCtorDeleted {
   CopyCtorDeleted(CopyCtorDeleted&&) noexcept = default;
   CopyCtorDeleted(const CopyCtorDeleted&) = delete;
 };
 static_assert(!std::copy_constructible<CopyCtorDeleted>);
 
 struct CopyAssignDeleted {
   CopyAssignDeleted(CopyAssignDeleted&&) noexcept = default;
   CopyAssignDeleted(const CopyAssignDeleted&) = delete;
 };
 static_assert(!std::copy_constructible<CopyAssignDeleted>);
 
 struct CopyCtorHasMutableRef {
   CopyCtorHasMutableRef(CopyCtorHasMutableRef&&) noexcept = default;
   CopyCtorHasMutableRef(CopyCtorHasMutableRef&) = default;
 };
 static_assert(!std::copy_constructible<CopyCtorHasMutableRef>);
 
 struct CopyCtorProhibitsMutableRef {
   CopyCtorProhibitsMutableRef(CopyCtorProhibitsMutableRef&&) noexcept = default;
   CopyCtorProhibitsMutableRef(const CopyCtorProhibitsMutableRef&) = default;
   CopyCtorProhibitsMutableRef(CopyCtorProhibitsMutableRef&) = delete;
 };
 static_assert(!std::copy_constructible<CopyCtorProhibitsMutableRef>);
 
 struct CopyAssignHasMutableRef {
   CopyAssignHasMutableRef&
   operator=(CopyAssignHasMutableRef&&) noexcept = default;
   CopyAssignHasMutableRef& operator=(CopyAssignHasMutableRef&) = default;
 };
 static_assert(!std::copy_constructible<CopyAssignHasMutableRef>);
 
 struct CopyAssignProhibitsMutableRef {
   CopyAssignProhibitsMutableRef&
   operator=(CopyAssignProhibitsMutableRef&&) noexcept = default;
   CopyAssignProhibitsMutableRef&
   operator=(const CopyAssignProhibitsMutableRef&) = default;
   CopyAssignProhibitsMutableRef&
   operator=(CopyAssignProhibitsMutableRef&) = delete;
 };
 static_assert(!std::copy_constructible<CopyAssignProhibitsMutableRef>);
 
 struct CopyCtorOnly {
   CopyCtorOnly(CopyCtorOnly&&) noexcept = delete;
   CopyCtorOnly(const CopyCtorOnly&) = default;
 };
 static_assert(!std::copy_constructible<CopyCtorOnly>);
 
 struct CopyAssignOnly {
   CopyAssignOnly& operator=(CopyAssignOnly&&) noexcept = delete;
   CopyAssignOnly& operator=(const CopyAssignOnly&) = default;
 };
 static_assert(!std::copy_constructible<CopyAssignOnly>);
 
 struct CopyOnly {
   CopyOnly(CopyOnly&&) noexcept = delete;
   CopyOnly(const CopyOnly&) = default;
 
   CopyOnly& operator=(CopyOnly&&) noexcept = delete;
   CopyOnly& operator=(const CopyOnly&) = default;
 };
 static_assert(!std::copy_constructible<CopyOnly>);
 
 struct ExplicitlyCopyable {
   ExplicitlyCopyable(ExplicitlyCopyable&&) = default;
   explicit ExplicitlyCopyable(const ExplicitlyCopyable&);
 };
 static_assert(!std::copy_constructible<ExplicitlyCopyable>);
 } // namespace CopyConstructibleTests
 
 int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.lang/concept.default.init/default_initializable.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 default_initializable = constructible_from<T> &&
 //     requires { T{}; } &&
 //     is-default-initializable<T>;
 
 #include <array>
 #include <concepts>
 #include <deque>
 #include <forward_list>
 #include <list>
 #include <map>
 #include <memory>
 #include <queue>
 #include <set>
 #include <span>
 #include <stack>
 #include <string>
 #include <string_view>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 #include "test_macros.h"
 
 struct Empty {};
 
 struct CtorDefaulted {
   CtorDefaulted() = default;
 };
 struct CtorDeleted {
   CtorDeleted() = delete;
 };
 struct DtorDefaulted {
   ~DtorDefaulted() = default;
 };
 struct DtorDeleted {
   ~DtorDeleted() = delete;
 };
 
 struct Noexcept {
   ~Noexcept() noexcept;
 };
 struct NoexceptTrue {
   ~NoexceptTrue() noexcept(true);
 };
 struct NoexceptFalse {
   ~NoexceptFalse() noexcept(false);
 };
 
 struct CtorProtected {
 protected:
   CtorProtected() = default;
 };
 struct CtorPrivate {
 private:
   CtorPrivate() = default;
 };
 struct DtorProtected {
 protected:
   ~DtorProtected() = default;
 };
 struct DtorPrivate {
 private:
   ~DtorPrivate() = default;
 };
 
 template <class T>
 struct NoexceptDependant {
   ~NoexceptDependant() noexcept(std::is_same_v<T, int>);
 };
 
 struct CtorExplicit {
   explicit CtorExplicit() = default;
 };
 struct CtorArgument {
   CtorArgument(int) {}
 };
 struct CtorDefaultArgument {
   CtorDefaultArgument(int = 0) {}
 };
 struct CtorExplicitDefaultArgument {
   explicit CtorExplicitDefaultArgument(int = 0) {}
 };
 
 struct Derived : public Empty {};
 
 class Abstract {
   virtual void foo() = 0;
 };
 
 class AbstractDestructor {
   virtual ~AbstractDestructor() = 0;
 };
 
 class OperatorNewDeleted {
   void* operator new(std::size_t) = delete;
   void operator delete(void* ptr) = delete;
 };
 
 [[maybe_unused]] auto Lambda = [](const int&, int&&, double){};
 
 template<class T>
 void test_not_const()
 {
     static_assert( std::default_initializable<               T>);
     static_assert(!std::default_initializable<const          T>);
     static_assert( std::default_initializable<      volatile T>);
     static_assert(!std::default_initializable<const volatile T>);
 }
 
 template<class T>
 void test_true()
 {
     static_assert( std::default_initializable<               T>);
     static_assert( std::default_initializable<const          T>);
     static_assert( std::default_initializable<      volatile T>);
     static_assert( std::default_initializable<const volatile T>);
 }
 
 template<class T>
 void test_false()
 {
     static_assert(!std::default_initializable<               T>);
     static_assert(!std::default_initializable<const          T>);
     static_assert(!std::default_initializable<      volatile T>);
     static_assert(!std::default_initializable<const volatile T>);
 }
 
 void test()
 {
     test_not_const<bool>();
     test_not_const<char>();
     test_not_const<int>();
     test_not_const<double>();
 
     test_false    <void>();
     test_not_const<void*>();
 
     test_not_const<int*>();
     test_false    <int[]>();
     test_not_const<int[1]>();
     test_false    <int&>();
     test_false    <int&&>();
 
     test_true     <Empty>();
 
     test_true     <CtorDefaulted>();
     test_false    <CtorDeleted>();
     test_true     <DtorDefaulted>();
     test_false    <DtorDeleted>();
 
     test_true     <Noexcept>();
     test_true     <NoexceptTrue>();
     test_false    <NoexceptFalse>();
 
     test_false    <CtorProtected>();
     test_false    <CtorPrivate>();
     test_false    <DtorProtected>();
     test_false    <DtorPrivate>();
 
     test_true     <NoexceptDependant<int>>();
     test_false    <NoexceptDependant<double>>();
 
     test_true     <CtorExplicit>();
     test_false    <CtorArgument>();
     test_true     <CtorDefaultArgument>();
     test_true     <CtorExplicitDefaultArgument>();
 
     test_true     <Derived>();
     test_false    <Abstract>();
     test_false    <AbstractDestructor>();
 
     test_true     <OperatorNewDeleted>();
 
     test_true     <decltype(Lambda)>();
     test_not_const<void(*)(const int&)>();
     test_not_const<void(Empty::*)(const int&)               >();
     test_not_const<void(Empty::*)(const int&) const         >();
     test_not_const<void(Empty::*)(const int&)       volatile>();
     test_not_const<void(Empty::*)(const int&) const volatile>();
     test_not_const<void(Empty::*)(const int&) &>();
     test_not_const<void(Empty::*)(const int&) &&>();
     test_not_const<void(Empty::*)(const int&) noexcept>();
     test_not_const<void(Empty::*)(const int&) noexcept(true)>();
     test_not_const<void(Empty::*)(const int&) noexcept(false)>();
 
     // Sequence containers
     test_not_const<std::array<               int, 0>>();
     test_not_const<std::array<               int, 1>>();
     test_false    <std::array<const          int, 1>>();
     test_not_const<std::array<      volatile int, 1>>();
     test_false    <std::array<const volatile int, 1>>();
     test_true     <std::deque<               int>>();
 #ifdef _LIBCPP_VERSION
     test_true     <std::deque<const          int>>();
     test_true     <std::deque<      volatile int>>();
     test_true     <std::deque<const volatile int>>();
 #endif // _LIBCPP_VERSION
     test_true     <std::forward_list<int>>();
     test_true     <std::list<int>>();
     test_true     <std::vector<int>>();
 
     // Associative containers
     test_true     <std::set<int>>();
     test_true     <std::map<int, int>>();
     test_true     <std::multiset<int>>();
     test_true     <std::multimap<int, int>>();
 
     // Unordered associative containers
     test_true     <std::unordered_set<int>>();
     test_true     <std::unordered_map<int, int>>();
     test_true     <std::unordered_multiset<int>>();
     test_true     <std::unordered_multimap<int, int>>();
 
     // Container adaptors
     test_true     <std::stack<               int>>();
 #ifdef _LIBCPP_VERSION
     test_true     <std::stack<const          int>>();
     test_true     <std::stack<      volatile int>>();
     test_true     <std::stack<const volatile int>>();
 #endif // _LIBCPP_VERSION
     test_true     <std::queue<int>>();
     test_true     <std::priority_queue<int>>();
 
     test_true     <std::span<               int>>();
     test_true     <std::span<const          int>>();
     test_true     <std::span<      volatile int>>();
     test_true     <std::span<const volatile int>>();
 
     // Strings
     test_true     <std::string>();
     test_true     <std::wstring>();
     test_true     <std::u8string>();
     test_true     <std::u16string>();
     test_true     <std::u32string>();
 
     // String views
     test_true     <std::string_view>();
     test_true     <std::wstring_view>();
     test_true     <std::u8string_view>();
     test_true     <std::u16string_view>();
     test_true     <std::u32string_view>();
 
     // Smart pointers
     test_true     <std::unique_ptr<int>>();
     test_true     <std::shared_ptr<int>>();
     test_true     <std::weak_ptr<int>>();
 
 }
 
 // Required for MSVC internal test runner compatibility.
 int main(int, char**) {
     return 0;
 }

libcxx/test/std/concepts/concepts.lang/concept.default.init/default_initializable.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
 
 // template<class T>
 //     concept default_initializable = constructible_from<T> &&
 //     requires { T{}; } &&
 //     is-default-initializable<T>;
 
 #include <concepts>
 #include <cassert>
 
 #include "test_macros.h"
 
 template<class T>
 concept brace_initializable = requires { T{}; };
 
 void test() {
     // LWG3149
     // Changed the concept from constructible_from<T>
     // to constructible_from<T> &&
     //    requires { T{}; } && is-default-initializable <T>
     struct S0 { explicit S0() = default; };
     S0 x0;
     S0 y0{};
     static_assert( std::constructible_from<S0>);
     static_assert( brace_initializable<S0>);
     LIBCPP_STATIC_ASSERT( std::__default_initializable<S0>);
     static_assert( std::default_initializable<S0>);
 
     struct S1 { S0 x; }; // Note: aggregate
     S1 x1;
     S1 y1{}; // expected-error {{chosen constructor is explicit in copy-initialization}}
     static_assert( std::constructible_from<S1>);
     static_assert(!brace_initializable<S1>);
     LIBCPP_STATIC_ASSERT( std::__default_initializable<S1>);
     static_assert(!std::default_initializable<S1>);
 
     const int x2; // expected-error {{default initialization of an object of const type 'const int'}}
     const int y2{};
 
     static_assert( std::constructible_from<const int>);
     static_assert( brace_initializable<const int>);
     LIBCPP_STATIC_ASSERT(!std::__default_initializable<const int>);
     static_assert(!std::default_initializable<const int>);
 
     const int x3[1]; // expected-error {{default initialization of an object of const type 'const int [1]'}}
     const int y3[1]{};
     static_assert( std::constructible_from<const int[1]>);
     static_assert( brace_initializable<const int[1]>);
     LIBCPP_STATIC_ASSERT(!std::__default_initializable<const int[1]>);
     static_assert(!std::default_initializable<const int[1]>);
 
     // Zero-length array extension
     const int x4[]; // expected-error {{definition of variable with array type needs an explicit size or an initializer}}
     const int y4[]{};
     static_assert(!std::constructible_from<const int[]>);
     static_assert( brace_initializable<const int[]>);
     LIBCPP_STATIC_ASSERT(!std::__default_initializable<const int[]>);
     static_assert(!std::default_initializable<const int[]>);
 }
 
 int main(int, char**) {
     test();
 
     return 0;
 }

libcxx/test/std/concepts/concepts.lang/concept.derived/derived_from.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 Derived, class Base>
 // concept derived_from;
 
 #include <concepts>
 #include <type_traits>
 
 struct Base1 {};
 struct Derived1 : Base1 {};
 struct Derived2 : Base1 {};
 
 struct DerivedPrivate : private Base1 {};
 struct Derived3 : DerivedPrivate {};
 
 struct DerivedProtected : protected DerivedPrivate {};
 struct Derived4 : DerivedProtected {};
 struct Derived5 : Derived4 {};
 
 template <typename From, typename To>
 constexpr void CheckNotDerivedFromPointer() {
   { // From as pointer
     static_assert(!std::derived_from<From*, To>);
     static_assert(!std::derived_from<From*, const To>);
     static_assert(!std::derived_from<From*, volatile To>);
     static_assert(!std::derived_from<From*, const volatile To>);
 
     if constexpr (!std::same_as<To, void>) {
       static_assert(!std::derived_from<From*, To&>);
       static_assert(!std::derived_from<From*, const To&>);
       static_assert(!std::derived_from<From*, volatile To&>);
       static_assert(!std::derived_from<From*, const volatile To&>);
 
       static_assert(!std::derived_from<From*, To&&>);
       static_assert(!std::derived_from<From*, const To&&>);
       static_assert(!std::derived_from<From*, volatile To&&>);
       static_assert(!std::derived_from<From*, const volatile To&&>);
 
       static_assert(!std::derived_from<const From*, To&>);
       static_assert(!std::derived_from<const From*, const To&>);
       static_assert(!std::derived_from<const From*, volatile To&>);
       static_assert(!std::derived_from<const From*, const volatile To&>);
 
       static_assert(!std::derived_from<const From*, To&&>);
       static_assert(!std::derived_from<const From*, const To&&>);
       static_assert(!std::derived_from<const From*, volatile To&&>);
       static_assert(!std::derived_from<const From*, const volatile To&&>);
 
       static_assert(!std::derived_from<volatile From*, To&>);
       static_assert(!std::derived_from<volatile From*, const To&>);
       static_assert(!std::derived_from<volatile From*, volatile To&>);
       static_assert(!std::derived_from<volatile From*, const volatile To&>);
 
       static_assert(!std::derived_from<volatile From*, To&&>);
       static_assert(!std::derived_from<volatile From*, const To&&>);
       static_assert(!std::derived_from<volatile From*, volatile To&&>);
       static_assert(!std::derived_from<volatile From*, const volatile To&&>);
 
       static_assert(!std::derived_from<const volatile From*, To&>);
       static_assert(!std::derived_from<const volatile From*, const To&>);
       static_assert(!std::derived_from<const volatile From*, volatile To&>);
       static_assert(
           !std::derived_from<const volatile From*, const volatile To&>);
 
       static_assert(!std::derived_from<const volatile From*, To&&>);
       static_assert(!std::derived_from<const volatile From*, const To&&>);
       static_assert(!std::derived_from<const volatile From*, volatile To&&>);
       static_assert(
           !std::derived_from<const volatile From*, const volatile To&&>);
     }
   }
   { // To as pointer
     static_assert(!std::derived_from<From, To*>);
     static_assert(!std::derived_from<From, const To*>);
     static_assert(!std::derived_from<From, volatile To*>);
     static_assert(!std::derived_from<From, const volatile To*>);
 
     if constexpr (!std::same_as<From, void>) {
       static_assert(!std::derived_from<From&, To*>);
       static_assert(!std::derived_from<From&, const To*>);
       static_assert(!std::derived_from<From&, volatile To*>);
       static_assert(!std::derived_from<From&, const volatile To*>);
 
       static_assert(!std::derived_from<From&&, To*>);
       static_assert(!std::derived_from<From&&, const To*>);
       static_assert(!std::derived_from<From&&, volatile To*>);
       static_assert(!std::derived_from<From&&, const volatile To*>);
 
       static_assert(!std::derived_from<const From&, To*>);
       static_assert(!std::derived_from<const From&, const To*>);
       static_assert(!std::derived_from<const From&, volatile To*>);
       static_assert(!std::derived_from<const From&, const volatile To*>);
 
       static_assert(!std::derived_from<const From&&, To*>);
       static_assert(!std::derived_from<const From&&, const To*>);
       static_assert(!std::derived_from<const From&&, volatile To*>);
       static_assert(!std::derived_from<const From&&, const volatile To*>);
 
       static_assert(!std::derived_from<volatile From&, To*>);
       static_assert(!std::derived_from<volatile From&, const To*>);
       static_assert(!std::derived_from<volatile From&, volatile To*>);
       static_assert(!std::derived_from<volatile From&, const volatile To*>);
 
       static_assert(!std::derived_from<volatile From&&, To*>);
       static_assert(!std::derived_from<volatile From&&, const To*>);
       static_assert(!std::derived_from<volatile From&&, volatile To*>);
       static_assert(!std::derived_from<volatile From&&, const volatile To*>);
 
       static_assert(!std::derived_from<const volatile From&, To*>);
       static_assert(!std::derived_from<const volatile From&, const To*>);
       static_assert(!std::derived_from<const volatile From&, volatile To*>);
       static_assert(
           !std::derived_from<const volatile From&, const volatile To*>);
 
       static_assert(!std::derived_from<const volatile From&&, To*>);
       static_assert(!std::derived_from<const volatile From&&, const To*>);
       static_assert(!std::derived_from<const volatile From&&, volatile To*>);
       static_assert(
           !std::derived_from<const volatile From&&, const volatile To*>);
     }
   }
   { // Both as pointers
     static_assert(!std::derived_from<From*, To*>);
     static_assert(!std::derived_from<From*, const To*>);
     static_assert(!std::derived_from<From*, volatile To*>);
     static_assert(!std::derived_from<From*, const volatile To*>);
 
     static_assert(!std::derived_from<const From*, To*>);
     static_assert(!std::derived_from<const From*, const To*>);
     static_assert(!std::derived_from<const From*, volatile To*>);
     static_assert(!std::derived_from<const From*, const volatile To*>);
 
     static_assert(!std::derived_from<volatile From*, To*>);
     static_assert(!std::derived_from<volatile From*, const To*>);
     static_assert(!std::derived_from<volatile From*, volatile To*>);
     static_assert(!std::derived_from<volatile From*, const volatile To*>);
 
     static_assert(!std::derived_from<const volatile From*, To*>);
     static_assert(!std::derived_from<const volatile From*, const To*>);
     static_assert(!std::derived_from<const volatile From*, volatile To*>);
     static_assert(!std::derived_from<const volatile From*, const volatile To*>);
   }
 
   // From as the return type of a pointer-to-function
   if constexpr (!std::is_array_v<From>) {
     static_assert(!std::derived_from<From (*)(), To>);
     static_assert(!std::derived_from<From (*)(int), To>);
   }
 
   // To as the return type of a pointer-to-function
   if constexpr (!std::is_array_v<To>) {
     static_assert(!std::derived_from<From, To (*)()>);
     static_assert(!std::derived_from<From, To (*)(double)>);
   }
 
   // Both as the return type of a pointer-to-function
   if constexpr (!std::is_array_v<From> && !std::is_array_v<To>) {
     static_assert(!std::derived_from<From (*)(), To (*)()>);
     static_assert(!std::derived_from<From (*)(int), To (*)(double)>);
   }
   { // pointer-to-member
     if constexpr (std::is_class_v<From> && !std::same_as<To, void>) {
       static_assert(!std::derived_from<To From::*, To>);
     }
 
     if constexpr (std::is_class_v<To> && !std::same_as<From, void>) {
       static_assert(!std::derived_from<From To::*, From>);
     }
   }
   { // pointer-to-member-functions
     if constexpr (std::is_class_v<From>) {
       static_assert(!std::derived_from<From (From::*)(), To>);
     }
 
     if constexpr (std::is_class_v<To>) {
       static_assert(!std::derived_from<To (To::*)(), From>);
     }
   }
 }
 
 template <typename From, typename To>
 constexpr void CheckNotDerivedFromReference() {
   if constexpr (!std::same_as<To, void>) {
     static_assert(!std::derived_from<From, To&>);
     static_assert(!std::derived_from<From, const To&>);
     static_assert(!std::derived_from<From, volatile To&>);
     static_assert(!std::derived_from<From, const volatile To&>);
 
     static_assert(!std::derived_from<From, To&&>);
     static_assert(!std::derived_from<From, const To&&>);
     static_assert(!std::derived_from<From, volatile To&&>);
     static_assert(!std::derived_from<From, const volatile To&&>);
   }
 
   if constexpr (!std::same_as<From, void>) {
     static_assert(!std::derived_from<From&, To>);
     static_assert(!std::derived_from<From&, To>);
     static_assert(!std::derived_from<From&, To>);
     static_assert(!std::derived_from<From&, To>);
 
     static_assert(!std::derived_from<From&&, To>);
     static_assert(!std::derived_from<From&&, To>);
     static_assert(!std::derived_from<From&&, To>);
     static_assert(!std::derived_from<From&&, To>);
   }
 
   // From as lvalue references
   if constexpr (!std::same_as<From, void> && !std::same_as<To, void>) {
     static_assert(!std::derived_from<From&, To&>);
     static_assert(!std::derived_from<From&, const To&>);
     static_assert(!std::derived_from<From&, volatile To&>);
     static_assert(!std::derived_from<From&, const volatile To&>);
 
     static_assert(!std::derived_from<From&, To&&>);
     static_assert(!std::derived_from<From&, const To&&>);
     static_assert(!std::derived_from<From&, volatile To&&>);
     static_assert(!std::derived_from<From&, const volatile To&&>);
 
     static_assert(!std::derived_from<const From&, To&>);
     static_assert(!std::derived_from<const From&, const To&>);
     static_assert(!std::derived_from<const From&, volatile To&>);
     static_assert(!std::derived_from<const From&, const volatile To&>);
 
     static_assert(!std::derived_from<const From&, To&&>);
     static_assert(!std::derived_from<const From&, const To&&>);
     static_assert(!std::derived_from<const From&, volatile To&&>);
     static_assert(!std::derived_from<const From&, const volatile To&&>);
 
     static_assert(!std::derived_from<volatile From&, To&>);
     static_assert(!std::derived_from<volatile From&, const To&>);
     static_assert(!std::derived_from<volatile From&, volatile To&>);
     static_assert(!std::derived_from<volatile From&, const volatile To&>);
 
     static_assert(!std::derived_from<volatile From&, To&&>);
     static_assert(!std::derived_from<volatile From&, const To&&>);
     static_assert(!std::derived_from<volatile From&, volatile To&&>);
     static_assert(!std::derived_from<volatile From&, const volatile To&&>);
 
     static_assert(!std::derived_from<const volatile From&, To&>);
     static_assert(!std::derived_from<const volatile From&, const To&>);
     static_assert(!std::derived_from<const volatile From&, volatile To&>);
     static_assert(!std::derived_from<const volatile From&, const volatile To&>);
 
     static_assert(!std::derived_from<const volatile From&, To&&>);
     static_assert(!std::derived_from<const volatile From&, const To&&>);
     static_assert(!std::derived_from<const volatile From&, volatile To&&>);
     static_assert(
         !std::derived_from<const volatile From&, const volatile To&&>);
 
     // From as rvalue references
     static_assert(!std::derived_from<From&&, To&>);
     static_assert(!std::derived_from<From&&, const To&>);
     static_assert(!std::derived_from<From&&, volatile To&>);
     static_assert(!std::derived_from<From&&, const volatile To&>);
 
     static_assert(!std::derived_from<From&&, To&&>);
     static_assert(!std::derived_from<From&&, const To&&>);
     static_assert(!std::derived_from<From&&, volatile To&&>);
     static_assert(!std::derived_from<From&&, const volatile To&&>);
 
     static_assert(!std::derived_from<const From&&, To&>);
     static_assert(!std::derived_from<const From&&, const To&>);
     static_assert(!std::derived_from<const From&&, volatile To&>);
     static_assert(!std::derived_from<const From&&, const volatile To&>);
 
     static_assert(!std::derived_from<const From&&, To&&>);
     static_assert(!std::derived_from<const From&&, const To&&>);
     static_assert(!std::derived_from<const From&&, volatile To&&>);
     static_assert(!std::derived_from<const From&&, const volatile To&&>);
 
     static_assert(!std::derived_from<volatile From&&, To&>);
     static_assert(!std::derived_from<volatile From&&, const To&>);
     static_assert(!std::derived_from<volatile From&&, volatile To&>);
     static_assert(!std::derived_from<volatile From&&, const volatile To&>);
 
     static_assert(!std::derived_from<volatile From&&, To&&>);
     static_assert(!std::derived_from<volatile From&&, const To&&>);
     static_assert(!std::derived_from<volatile From&&, volatile To&&>);
     static_assert(!std::derived_from<volatile From&&, const volatile To&&>);
 
     static_assert(!std::derived_from<const volatile From&&, To&>);
     static_assert(!std::derived_from<const volatile From&&, const To&>);
     static_assert(!std::derived_from<const volatile From&&, volatile To&>);
     static_assert(
         !std::derived_from<const volatile From&&, const volatile To&>);
 
     static_assert(!std::derived_from<const volatile From&&, To&&>);
     static_assert(!std::derived_from<const volatile From&&, const To&&>);
     static_assert(!std::derived_from<const volatile From&&, volatile To&&>);
     static_assert(
         !std::derived_from<const volatile From&&, const volatile To&&>);
   }
 
   // From as the return type of a reference-to-function
   if constexpr (!std::is_array_v<From>) {
     static_assert(!std::derived_from<From (&)(), To>);
     static_assert(!std::derived_from<From (&)(int), To>);
   }
   // To as the return type of a reference-to-function
   if constexpr (!std::is_array_v<To>) {
     static_assert(!std::derived_from<From, To (&)()>);
     static_assert(!std::derived_from<From, To (&)(double)>);
   }
   // Both as the return type of a reference-to-function
   if constexpr (!std::is_array_v<From> && !std::is_array_v<To>) {
     static_assert(!std::derived_from<From (&)(), To (&)()>);
     static_assert(!std::derived_from<From (&)(int), To (&)(double)>);
   }
 }
 
 template <typename From, typename To>
 constexpr void CheckDerivedFrom() {
   static_assert(std::derived_from<From, To>);
 
   static_assert(std::derived_from<From, const To>);
   static_assert(std::derived_from<From, volatile To>);
   static_assert(std::derived_from<From, const volatile To>);
 
   static_assert(std::derived_from<const From, const To>);
   static_assert(std::derived_from<const From, volatile To>);
   static_assert(std::derived_from<const From, const volatile To>);
 
   static_assert(std::derived_from<volatile From, const To>);
   static_assert(std::derived_from<volatile From, volatile To>);
   static_assert(std::derived_from<volatile From, const volatile To>);
 
   static_assert(std::derived_from<const volatile From, const To>);
   static_assert(std::derived_from<const volatile From, volatile To>);
   static_assert(std::derived_from<const volatile From, const volatile To>);
 
   CheckNotDerivedFromPointer<From, To>();
   CheckNotDerivedFromReference<From, To>();
 }
 
 template <typename From, typename To>
 constexpr void CheckNotDerivedFrom() {
   static_assert(!std::derived_from<From, To>);
 
   static_assert(!std::derived_from<From, const To>);
   static_assert(!std::derived_from<From, volatile To>);
   static_assert(!std::derived_from<From, const volatile To>);
 
   static_assert(!std::derived_from<const From, const To>);
   static_assert(!std::derived_from<const From, volatile To>);
   static_assert(!std::derived_from<const From, const volatile To>);
 
   static_assert(!std::derived_from<volatile From, const To>);
   static_assert(!std::derived_from<volatile From, volatile To>);
   static_assert(!std::derived_from<volatile From, const volatile To>);
 
   static_assert(!std::derived_from<const volatile From, const To>);
   static_assert(!std::derived_from<const volatile From, volatile To>);
   static_assert(!std::derived_from<const volatile From, const volatile To>);
 
   CheckNotDerivedFromPointer<From, To>();
   CheckNotDerivedFromReference<From, To>();
 }
 
 enum Enumeration { Yes, No };
 enum class ScopedEnumeration : int { No, Yes };
 
 int main(int, char**) {
   { // Fundamentals shouldn't be derived from anything
     CheckNotDerivedFrom<int, long>();
     CheckNotDerivedFrom<signed char, char>();
     CheckNotDerivedFrom<double, Base1>();
 
     CheckNotDerivedFrom<int, Enumeration>();
     CheckNotDerivedFrom<int, ScopedEnumeration>();
 
     CheckNotDerivedFrom<void, void>();
     CheckNotDerivedFrom<int, int>();
   }
   { // Nothing should be derived from a fundamental type
     CheckNotDerivedFrom<Enumeration, int>();
     CheckNotDerivedFrom<ScopedEnumeration, int>();
 
     CheckNotDerivedFrom<Base1, int>();
     CheckNotDerivedFrom<Base1, double>();
     CheckNotDerivedFrom<Derived1, char>();
     CheckNotDerivedFrom<DerivedPrivate, long long>();
   }
   { // Other built-in things shouldn't have derivations
     CheckNotDerivedFrom<Enumeration, Enumeration>();
     CheckNotDerivedFrom<ScopedEnumeration, ScopedEnumeration>();
 
     CheckNotDerivedFrom<Enumeration, ScopedEnumeration>();
     CheckNotDerivedFrom<ScopedEnumeration, Enumeration>();
 
     CheckNotDerivedFrom<Base1[5], Base1>();
     CheckNotDerivedFrom<Derived1[5], Base1>();
 
     CheckNotDerivedFrom<Base1, Base1[5]>();
     CheckNotDerivedFrom<Derived1, Base1[5]>();
   }
 
   { // Base1 is the subject.
     CheckDerivedFrom<Base1, Base1>();
 
     CheckNotDerivedFrom<Base1, void>();
     CheckNotDerivedFrom<Base1, DerivedPrivate>();
     CheckNotDerivedFrom<Base1, DerivedProtected>();
     CheckNotDerivedFrom<Base1, Derived1>();
     CheckNotDerivedFrom<Base1, Derived2>();
     CheckNotDerivedFrom<Base1, Derived3>();
     CheckNotDerivedFrom<Base1, Derived4>();
   }
 
   { // Derived1 is the subject.
     CheckDerivedFrom<Derived1, Base1>();
     CheckDerivedFrom<Derived1, Derived1>();
 
     CheckNotDerivedFromPointer<Derived1, void>();
     CheckNotDerivedFrom<Derived1, DerivedPrivate>();
     CheckNotDerivedFrom<Derived1, DerivedProtected>();
     CheckNotDerivedFrom<Derived1, Derived2>();
     CheckNotDerivedFrom<Derived1, Derived3>();
     CheckNotDerivedFrom<Derived1, Derived4>();
   }
 
   { // Derived2 is the subject.
     CheckDerivedFrom<Derived2, Base1>();
     CheckDerivedFrom<Derived2, Derived2>();
 
     CheckNotDerivedFrom<Derived2, DerivedPrivate>();
     CheckNotDerivedFrom<Derived2, DerivedProtected>();
     CheckNotDerivedFrom<Derived2, Derived1>();
     CheckNotDerivedFrom<Derived2, Derived3>();
     CheckNotDerivedFrom<Derived2, Derived4>();
   }
 
   { // DerivedPrivate is the subject.
     CheckDerivedFrom<DerivedPrivate, DerivedPrivate>();
 
     CheckNotDerivedFrom<DerivedPrivate, Base1>();
     CheckNotDerivedFrom<DerivedPrivate, DerivedProtected>();
     CheckNotDerivedFrom<DerivedPrivate, Derived1>();
     CheckNotDerivedFrom<DerivedPrivate, Derived2>();
     CheckNotDerivedFrom<DerivedPrivate, Derived3>();
     CheckNotDerivedFrom<DerivedPrivate, Derived4>();
   }
 
   { // Derived3 is the subject.
     CheckDerivedFrom<Derived3, DerivedPrivate>();
     CheckDerivedFrom<Derived3, Derived3>();
 
     CheckNotDerivedFrom<Derived3, Base1>();
     CheckNotDerivedFrom<Derived3, DerivedProtected>();
     CheckNotDerivedFrom<Derived3, Derived1>();
     CheckNotDerivedFrom<Derived3, Derived2>();
     CheckNotDerivedFrom<Derived3, Derived4>();
   }
 
   { // DerivedProtected is the subject.
     CheckDerivedFrom<DerivedProtected, DerivedProtected>();
 
     CheckNotDerivedFromPointer<DerivedProtected, Base1>();
     CheckNotDerivedFromPointer<DerivedProtected, DerivedPrivate>();
     CheckNotDerivedFromPointer<DerivedProtected, Derived1>();
     CheckNotDerivedFromPointer<DerivedProtected, Derived2>();
     CheckNotDerivedFromPointer<DerivedProtected, Derived3>();
     CheckNotDerivedFromPointer<DerivedProtected, Derived4>();
   }
 
   { // Derived4 is the subject.
     CheckDerivedFrom<Derived4, DerivedProtected>();
     CheckDerivedFrom<Derived4, Derived4>();
 
     CheckNotDerivedFrom<Derived4, Base1>();
     CheckNotDerivedFrom<Derived4, DerivedPrivate>();
     CheckNotDerivedFrom<Derived4, Derived1>();
     CheckNotDerivedFrom<Derived4, Derived2>();
     CheckNotDerivedFrom<Derived4, Derived3>();
   }
 
   { // Derived5 is the subject.
     CheckDerivedFrom<Derived5, DerivedProtected>();
     CheckDerivedFrom<Derived5, Derived4>();
     CheckDerivedFrom<Derived5, Derived5>();
 
     CheckNotDerivedFrom<Derived5, Base1>();
     CheckNotDerivedFrom<Derived5, DerivedPrivate>();
     CheckNotDerivedFrom<Derived5, Derived1>();
     CheckNotDerivedFrom<Derived5, Derived2>();
     CheckNotDerivedFrom<Derived5, Derived3>();
   }
 
   return 0;
 }

libcxx/test/std/concepts/concepts.lang/concept.destructible/destructible.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 destructible = is_nothrow_destructible_v<T>;
 
 #include <concepts>
 #include <type_traits>
 
 struct Empty {};
 
 struct Defaulted {
   ~Defaulted() = default;
 };
 struct Deleted {
   ~Deleted() = delete;
 };
 
 struct Noexcept {
   ~Noexcept() noexcept;
 };
 struct NoexceptTrue {
   ~NoexceptTrue() noexcept(true);
 };
 struct NoexceptFalse {
   ~NoexceptFalse() noexcept(false);
 };
 
 struct Protected {
 protected:
   ~Protected() = default;
 };
 struct Private {
 private:
   ~Private() = default;
 };
 
 template <class T>
 struct NoexceptDependant {
   ~NoexceptDependant() noexcept(std::is_same_v<T, int>);
 };
 
 template <class T>
 void test() {
   static_assert(std::destructible<T> == std::is_nothrow_destructible_v<T>);
 }
 
 void test() {
   test<Empty>();
 
   test<Defaulted>();
   test<Deleted>();
 
   test<Noexcept>();
   test<NoexceptTrue>();
   test<NoexceptFalse>();
 
   test<Protected>();
   test<Private>();
 
   test<NoexceptDependant<int> >();
   test<NoexceptDependant<double> >();
 
   test<bool>();
   test<char>();
   test<int>();
   test<double>();
 }
 
 // Required for MSVC internal test runner compatibility.
 int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.lang/concept.moveconstructible/move_constructible.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 move_constructible;
 
 #include <concepts>
 #include <type_traits>
 
 #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&>);
 static_assert(std::move_constructible<const int&&>);
 static_assert(std::move_constructible<volatile int>);
 static_assert(std::move_constructible<volatile int&>);
 static_assert(std::move_constructible<volatile int&&>);
 static_assert(std::move_constructible<int (*)()>);
 static_assert(std::move_constructible<int (&)()>);
 static_assert(std::move_constructible<HasDefaultOps>);
 static_assert(std::move_constructible<CustomMoveCtor>);
 static_assert(std::move_constructible<MoveOnly>);
 static_assert(std::move_constructible<const CustomMoveCtor&>);
 static_assert(std::move_constructible<volatile CustomMoveCtor&>);
 static_assert(std::move_constructible<const CustomMoveCtor&&>);
 static_assert(std::move_constructible<volatile CustomMoveCtor&&>);
 static_assert(std::move_constructible<CustomMoveAssign>);
 static_assert(std::move_constructible<const CustomMoveAssign&>);
 static_assert(std::move_constructible<volatile CustomMoveAssign&>);
 static_assert(std::move_constructible<const CustomMoveAssign&&>);
 static_assert(std::move_constructible<volatile CustomMoveAssign&&>);
 static_assert(std::move_constructible<int HasDefaultOps::*>);
 static_assert(std::move_constructible<void (HasDefaultOps::*)(int)>);
 static_assert(std::move_constructible<MemberLvalueReference>);
 static_assert(std::move_constructible<MemberRvalueReference>);
 
 static_assert(!std::move_constructible<void>);
 static_assert(!std::move_constructible<const CustomMoveCtor>);
 static_assert(!std::move_constructible<volatile CustomMoveCtor>);
 static_assert(!std::move_constructible<const CustomMoveAssign>);
 static_assert(!std::move_constructible<volatile CustomMoveAssign>);
 static_assert(!std::move_constructible<int[10]>);
 static_assert(!std::move_constructible<DeletedMoveCtor>);
 static_assert(!std::move_constructible<ImplicitlyDeletedMoveCtor>);
 static_assert(!std::move_constructible<DeletedMoveAssign>);
 static_assert(!std::move_constructible<ImplicitlyDeletedMoveAssign>);
 
 static_assert(std::move_constructible<DeletedMoveCtor&>);
 static_assert(std::move_constructible<DeletedMoveCtor&&>);
 static_assert(std::move_constructible<const DeletedMoveCtor&>);
 static_assert(std::move_constructible<const DeletedMoveCtor&&>);
 static_assert(std::move_constructible<ImplicitlyDeletedMoveCtor&>);
 static_assert(std::move_constructible<ImplicitlyDeletedMoveCtor&&>);
 static_assert(std::move_constructible<const ImplicitlyDeletedMoveCtor&>);
 static_assert(std::move_constructible<const ImplicitlyDeletedMoveCtor&&>);
 static_assert(std::move_constructible<DeletedMoveAssign&>);
 static_assert(std::move_constructible<DeletedMoveAssign&&>);
 static_assert(std::move_constructible<const DeletedMoveAssign&>);
 static_assert(std::move_constructible<const DeletedMoveAssign&&>);
 static_assert(std::move_constructible<ImplicitlyDeletedMoveAssign&>);
 static_assert(std::move_constructible<ImplicitlyDeletedMoveAssign&&>);
 static_assert(std::move_constructible<const ImplicitlyDeletedMoveAssign&>);
 static_assert(std::move_constructible<const ImplicitlyDeletedMoveAssign&&>);
 
 static_assert(!std::move_constructible<NonMovable>);
 static_assert(!std::move_constructible<DerivedFromNonMovable>);
 static_assert(!std::move_constructible<HasANonMovable>);
 
 int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.lang/concept.same/same_as.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, class U>
 // concept same_as;
 
 #include <concepts>
 #include <type_traits>
 
 struct S1 {};
 struct S2 {
   int i;
 
   int& f();
   double g(int x) const;
 };
 struct S3 {
   int& r;
 };
 struct S4 {
   int&& r;
 };
 struct S5 {
   int* p;
 };
 
 class C1 {};
 class C2 {
   [[maybe_unused]] int i;
 };
 
 class C3 {
 public:
   int i;
 };
 
 template <class T1, class T2 = T1>
 class C4 {
   int t1;
   int t2;
 };
 
 template <class T1, class T2 = T1>
 class C5 {
   [[maybe_unused]] T1 t1;
 
 public:
   T2 t2;
 };
 
 template <class T1, class T2 = T1>
 class C6 {
 public:
   [[maybe_unused]] T1 t1;
   [[maybe_unused]] T2 t2;
 };
 
 template <class T>
 struct identity {
   using type = T;
 };
 
 template <template <typename> class Modifier = identity>
 void CheckSameAs() {
   static_assert(
       std::same_as<typename Modifier<int>::type, typename Modifier<int>::type>);
   static_assert(
       std::same_as<typename Modifier<S1>::type, typename Modifier<S1>::type>);
   static_assert(
       std::same_as<typename Modifier<S2>::type, typename Modifier<S2>::type>);
   static_assert(
       std::same_as<typename Modifier<S3>::type, typename Modifier<S3>::type>);
   static_assert(
       std::same_as<typename Modifier<S4>::type, typename Modifier<S4>::type>);
   static_assert(
       std::same_as<typename Modifier<S5>::type, typename Modifier<S5>::type>);
   static_assert(
       std::same_as<typename Modifier<C1>::type, typename Modifier<C1>::type>);
   static_assert(
       std::same_as<typename Modifier<C2>::type, typename Modifier<C2>::type>);
   static_assert(
       std::same_as<typename Modifier<C3>::type, typename Modifier<C3>::type>);
   static_assert(std::same_as<typename Modifier<C4<int> >::type,
                              typename Modifier<C4<int> >::type>);
   static_assert(std::same_as<typename Modifier<C4<int&> >::type,
                              typename Modifier<C4<int&> >::type>);
   static_assert(std::same_as<typename Modifier<C4<int&&> >::type,
                              typename Modifier<C4<int&&> >::type>);
   static_assert(std::same_as<typename Modifier<C5<int> >::type,
                              typename Modifier<C5<int> >::type>);
   static_assert(std::same_as<typename Modifier<C5<int&> >::type,
                              typename Modifier<C5<int&> >::type>);
   static_assert(std::same_as<typename Modifier<C5<int&&> >::type,
                              typename Modifier<C5<int&&> >::type>);
   static_assert(std::same_as<typename Modifier<C6<int> >::type,
                              typename Modifier<C6<int> >::type>);
   static_assert(std::same_as<typename Modifier<C6<int&> >::type,
                              typename Modifier<C6<int&> >::type>);
   static_assert(std::same_as<typename Modifier<C6<int&&> >::type,
                              typename Modifier<C6<int&&> >::type>);
 
   static_assert(std::same_as<typename Modifier<void>::type,
                              typename Modifier<void>::type>);
 }
 
 template <template <typename> class Modifier1,
           template <typename> class Modifier2>
 void CheckNotSameAs() {
   static_assert(!std::same_as<typename Modifier1<int>::type,
                               typename Modifier2<int>::type>);
   static_assert(!std::same_as<typename Modifier1<S1>::type,
                               typename Modifier2<S1>::type>);
   static_assert(!std::same_as<typename Modifier1<S2>::type,
                               typename Modifier2<S2>::type>);
   static_assert(!std::same_as<typename Modifier1<S3>::type,
                               typename Modifier2<S3>::type>);
   static_assert(!std::same_as<typename Modifier1<S4>::type,
                               typename Modifier2<S4>::type>);
   static_assert(!std::same_as<typename Modifier1<S5>::type,
                               typename Modifier2<S5>::type>);
   static_assert(!std::same_as<typename Modifier1<C1>::type,
                               typename Modifier2<C1>::type>);
   static_assert(!std::same_as<typename Modifier1<C2>::type,
                               typename Modifier2<C2>::type>);
   static_assert(!std::same_as<typename Modifier1<C3>::type,
                               typename Modifier2<C3>::type>);
   static_assert(!std::same_as<typename Modifier1<C4<int> >::type,
                               typename Modifier2<C4<int> >::type>);
   static_assert(!std::same_as<typename Modifier1<C4<int&> >::type,
                               typename Modifier2<C4<int&> >::type>);
   static_assert(!std::same_as<typename Modifier1<C4<int&&> >::type,
                               typename Modifier2<C4<int&&> >::type>);
   static_assert(!std::same_as<typename Modifier1<C5<int> >::type,
                               typename Modifier2<C5<int> >::type>);
   static_assert(!std::same_as<typename Modifier1<C5<int&> >::type,
                               typename Modifier2<C5<int&> >::type>);
   static_assert(!std::same_as<typename Modifier1<C5<int&&> >::type,
                               typename Modifier2<C5<int&&> >::type>);
   static_assert(!std::same_as<typename Modifier1<C6<int> >::type,
                               typename Modifier2<C6<int> >::type>);
   static_assert(!std::same_as<typename Modifier1<C6<int&> >::type,
                               typename Modifier2<C6<int&> >::type>);
   static_assert(!std::same_as<typename Modifier1<C6<int&&> >::type,
                               typename Modifier2<C6<int&&> >::type>);
 }
 
 // Checks subsumption works as intended
 template <class T, class U>
 requires std::same_as<T, U> void SubsumptionTest();
 
 // clang-format off
 template <class T, class U>
 requires std::same_as<U, T> && true // NOLINT(readability-simplify-boolean-expr)
 int SubsumptionTest();
 // clang-format on
 
 static_assert(std::same_as<int, decltype(SubsumptionTest<int, int>())>);
 static_assert(std::same_as<int, decltype(SubsumptionTest<void, void>())>);
 static_assert(
     std::same_as<int, decltype(SubsumptionTest<int (*)(), int (*)()>())>);
 static_assert(
     std::same_as<
         int, decltype(SubsumptionTest<double (&)(int), double (&)(int)>())>);
 static_assert(
     std::same_as<int, decltype(SubsumptionTest<int S2::*, int S2::*>())>);
 static_assert(
     std::same_as<int,
                  decltype(SubsumptionTest<int& (S2::*)(), int& (S2::*)()>())>);
 
 int main(int, char**) {
   { // Checks std::same_as<T, T> is true
     CheckSameAs();
 
     // Checks std::same_as<T&, T&> is true
     CheckSameAs<std::add_lvalue_reference>();
 
     // Checks std::same_as<T&&, T&&> is true
     CheckSameAs<std::add_rvalue_reference>();
 
     // Checks std::same_as<const T, const T> is true
     CheckSameAs<std::add_const>();
 
     // Checks std::same_as<volatile T, volatile T> is true
     CheckSameAs<std::add_volatile>();
 
     // Checks std::same_as<const volatile T, const volatile T> is true
     CheckSameAs<std::add_cv>();
 
     // Checks std::same_as<T*, T*> is true
     CheckSameAs<std::add_pointer>();
 
     // Checks concrete types are identical
     static_assert(std::same_as<void, void>);
 
     using Void = void;
     static_assert(std::same_as<void, Void>);
 
     static_assert(std::same_as<int[1], int[1]>);
     static_assert(std::same_as<int[2], int[2]>);
 
     static_assert(std::same_as<int (*)(), int (*)()>);
     static_assert(std::same_as<void (&)(), void (&)()>);
     static_assert(std::same_as<S1& (*)(S1), S1& (*)(S1)>);
     static_assert(std::same_as<C1& (&)(S1, int), C1& (&)(S1, int)>);
 
     static_assert(std::same_as<int S2::*, int S2::*>);
     static_assert(std::same_as<double S2::*, double S2::*>);
 
     static_assert(std::same_as<int& (S2::*)(), int& (S2::*)()>);
     static_assert(std::same_as<double& (S2::*)(int), double& (S2::*)(int)>);
   }
 
   { // Checks that `T` and `T&` are distinct types
     CheckNotSameAs<identity, std::add_lvalue_reference>();
     CheckNotSameAs<std::add_lvalue_reference, identity>();
 
     // Checks that `T` and `T&&` are distinct types
     CheckNotSameAs<identity, std::add_rvalue_reference>();
     CheckNotSameAs<std::add_rvalue_reference, identity>();
 
     // Checks that `T` and `const T` are distinct types
     CheckNotSameAs<identity, std::add_const>();
     CheckNotSameAs<std::add_const, identity>();
 
     // Checks that `T` and `volatile T` are distinct types
     CheckNotSameAs<identity, std::add_volatile>();
     CheckNotSameAs<std::add_volatile, identity>();
 
     // Checks that `T` and `const volatile T` are distinct types
     CheckNotSameAs<identity, std::add_cv>();
     CheckNotSameAs<std::add_cv, identity>();
 
     // Checks that `const T` and `volatile T` are distinct types
     CheckNotSameAs<std::add_const, std::add_volatile>();
     CheckNotSameAs<std::add_volatile, std::add_const>();
 
     // Checks that `const T` and `const volatile T` are distinct types
     CheckNotSameAs<std::add_const, std::add_cv>();
     CheckNotSameAs<std::add_cv, std::add_const>();
 
     // Checks that `volatile T` and `const volatile T` are distinct types
     CheckNotSameAs<std::add_volatile, std::add_cv>();
     CheckNotSameAs<std::add_cv, std::add_volatile>();
 
     // Checks `T&` and `T&&` are distinct types
     CheckNotSameAs<std::add_lvalue_reference, std::add_rvalue_reference>();
     CheckNotSameAs<std::add_rvalue_reference, std::add_lvalue_reference>();
   }
 
   { // Checks different type names are distinct types
     static_assert(!std::same_as<S1, C1>);
     static_assert(!std::same_as<C4<int>, C5<int> >);
     static_assert(!std::same_as<C4<int>, C5<int> >);
     static_assert(!std::same_as<C5<int, double>, C5<double, int> >);
 
     static_assert(!std::same_as<int&, const int&>);
     static_assert(!std::same_as<int&, volatile int&>);
     static_assert(!std::same_as<int&, const volatile int&>);
 
     static_assert(!std::same_as<int&&, const int&>);
     static_assert(!std::same_as<int&&, volatile int&>);
     static_assert(!std::same_as<int&&, const volatile int&>);
 
     static_assert(!std::same_as<int&, const int&&>);
     static_assert(!std::same_as<int&, volatile int&&>);
     static_assert(!std::same_as<int&, const volatile int&&>);
 
     static_assert(!std::same_as<int&&, const int&&>);
     static_assert(!std::same_as<int&&, volatile int&&>);
     static_assert(!std::same_as<int&&, const volatile int&&>);
 
     static_assert(!std::same_as<void, int>);
 
     static_assert(!std::same_as<int[1], int[2]>);
     static_assert(!std::same_as<double[1], int[2]>);
 
     static_assert(!std::same_as<int* (*)(), const int* (*)()>);
     static_assert(!std::same_as<void (&)(), void (&)(S1)>);
     static_assert(!std::same_as<S1 (*)(S1), S1& (*)(S1)>);
     static_assert(!std::same_as<C3 (&)(int), C1& (&)(S1, int)>);
 
     static_assert(!std::same_as<int S2::*, double S2::*>);
 
     static_assert(!std::same_as<int& (S2::*)(), double& (S2::*)(int)>);
   }
 
   return 0;
 }

libcxx/test/std/concepts/concepts.lang/concept.swappable/swappable.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 swappable = // see below
 
 #include <concepts>
 
 #include <algorithm>
 #include <cassert>
 #include <deque>
 #include <map>
 #include <memory>
 #include <string>
 #include <optional>
 #include <unordered_map>
 #include <vector>
 
 #include "test_macros.h"
 #include "type_classification/moveconstructible.h"
 #include "type_classification/swappable.h"
 
 template <class T>
 struct expected {
   T x;
   T y;
 };
 
 // clang-format off
 // Checks [concept.swappable]/2.1
 template <class T, class U>
 requires std::same_as<std::remove_cvref_t<T>, std::remove_cvref_t<U> > &&
          std::swappable<std::remove_cvref_t<T> >
 constexpr bool check_swap_21(T&& x, U&& y) {
   expected<std::remove_cvref_t<T> > const e{y, x};
   std::ranges::swap(std::forward<T>(x), std::forward<U>(y));
   return x == e.x && y == e.y;
 }
 
 // Checks [concept.swappable]/2.2
 template <std::swappable T, std::size_t N>
 constexpr bool check_swap_22(T (&x)[N], T (&y)[N]) {
   expected<T[N]> e;
   std::copy(y, y + N, e.x);
   std::copy(x, x + N, e.y);
 
   std::ranges::swap(x, y);
   return std::equal(x, x + N, e.x, e.x + N) &&
          std::equal(y, y + N, e.y, e.y + N);
 }
 
 // Checks [concept.swappable]/2.3
 template <std::swappable T>
 requires std::copy_constructible<std::remove_cvref_t<T> >
 constexpr bool check_swap_23(T x, T y) {
   expected<std::remove_cvref_t<T> > const e{y, x};
   std::ranges::swap(x, y);
   return x == e.x && y == e.y;
 }
 // clang-format on
 
 constexpr bool check_lvalue_adl_swappable() {
   auto x = lvalue_adl_swappable(0);
   auto y = lvalue_adl_swappable(1);
   constexpr auto is_noexcept = noexcept(std::ranges::swap(x, y));
   return check_swap_21(x, y) && is_noexcept;
 }
 static_assert(check_lvalue_adl_swappable());
 
 constexpr bool check_rvalue_adl_swappable() {
   constexpr auto is_noexcept = noexcept(
       std::ranges::swap(rvalue_adl_swappable(0), rvalue_adl_swappable(1)));
   return check_swap_21(rvalue_adl_swappable(0), rvalue_adl_swappable(1)) &&
          is_noexcept;
 }
 static_assert(check_rvalue_adl_swappable());
 
 constexpr bool check_lvalue_rvalue_adl_swappable() {
   auto x = lvalue_rvalue_adl_swappable(0);
   constexpr auto is_noexcept =
       noexcept(std::ranges::swap(x, lvalue_rvalue_adl_swappable(1)));
   return check_swap_21(x, lvalue_rvalue_adl_swappable(1)) && is_noexcept;
 }
 static_assert(check_lvalue_rvalue_adl_swappable());
 
 constexpr bool check_rvalue_lvalue_adl_swappable() {
   auto x = rvalue_lvalue_adl_swappable(0);
   constexpr auto is_noexcept =
       noexcept(std::ranges::swap(rvalue_lvalue_adl_swappable(1), x));
   return check_swap_21(rvalue_lvalue_adl_swappable(1), x) && is_noexcept;
 }
 static_assert(check_rvalue_lvalue_adl_swappable());
 
 constexpr bool check_throwable_swappable() {
   auto x = throwable_adl_swappable{0};
   auto y = throwable_adl_swappable{1};
   constexpr auto not_noexcept = !noexcept(std::ranges::swap(x, y));
   return check_swap_21(x, y) && not_noexcept;
 }
 static_assert(check_throwable_swappable());
 
 constexpr bool check_non_move_constructible_adl_swappable() {
   auto x = non_move_constructible_adl_swappable{0};
   auto y = non_move_constructible_adl_swappable{1};
   constexpr auto is_noexcept = noexcept(std::ranges::swap(x, y));
   return check_swap_21(x, y) && is_noexcept;
 }
 static_assert(check_non_move_constructible_adl_swappable());
 
 constexpr bool check_non_move_assignable_adl_swappable() {
   auto x = non_move_assignable_adl_swappable{0};
   auto y = non_move_assignable_adl_swappable{1};
   return check_swap_21(x, y) && noexcept(std::ranges::swap(x, y));
 }
 static_assert(check_non_move_assignable_adl_swappable());
 
 namespace swappable_namespace {
 enum unscoped { hello, world };
 void swap(unscoped&, unscoped&);
 
 enum class scoped { hello, world };
 void swap(scoped&, scoped&);
 } // namespace swappable_namespace
 
 static_assert(std::swappable<swappable_namespace::unscoped>);
 static_assert(std::swappable<swappable_namespace::scoped>);
 
 constexpr bool check_swap_arrays() {
   int x[] = {0, 1, 2, 3, 4};
   int y[] = {5, 6, 7, 8, 9};
   return check_swap_22(x, y) && noexcept(std::ranges::swap(x, y));
 }
 static_assert(check_swap_arrays());
 
 constexpr bool check_lvalue_adl_swappable_arrays() {
   lvalue_adl_swappable x[] = {{0}, {1}, {2}, {3}};
   lvalue_adl_swappable y[] = {{4}, {5}, {6}, {7}};
   return check_swap_22(x, y) && noexcept(std::ranges::swap(x, y));
 }
 static_assert(check_lvalue_adl_swappable_arrays());
 
 constexpr bool check_throwable_adl_swappable_arrays() {
   throwable_adl_swappable x[] = {{0}, {1}, {2}, {3}};
   throwable_adl_swappable y[] = {{4}, {5}, {6}, {7}};
   return check_swap_22(x, y) && !noexcept(std::ranges::swap(x, y));
 }
 static_assert(check_throwable_adl_swappable_arrays());
 
 inline auto global_x = 0;
 static_assert(check_swap_23(0, 0) &&
               noexcept(std::ranges::swap(global_x, global_x)));
 static_assert(check_swap_23(0, 1) &&
               noexcept(std::ranges::swap(global_x, global_x)));
 static_assert(check_swap_23(1, 0) &&
               noexcept(std::ranges::swap(global_x, global_x)));
 
 constexpr bool check_swappable_references() {
   int x = 42;
   int y = 64;
   return check_swap_23<int&>(x, y) && noexcept(std::ranges::swap(x, y));
 }
 static_assert(check_swappable_references());
 
 constexpr bool check_swappable_pointers() {
   char const* x = "hello";
   return check_swap_23<char const*>(x, nullptr) &&
          noexcept(std::ranges::swap(x, x));
 }
 static_assert(check_swappable_pointers());
 
 namespace union_swap {
 union adl_swappable {
   int x;
   double y;
 };
 
 void swap(adl_swappable&, adl_swappable&);
 void swap(adl_swappable&&, adl_swappable&&);
 }; // namespace union_swap
 static_assert(std::swappable<union_swap::adl_swappable>);
 static_assert(std::swappable<union_swap::adl_swappable&>);
 static_assert(std::swappable<union_swap::adl_swappable&&>);
 
 // All tests for std::swappable<T> are implicitly confirmed by `check_swap`, so we only need to
 // sanity check for a few positive cases.
 static_assert(std::swappable<int volatile&>);
 static_assert(std::swappable<int&&>);
 static_assert(std::swappable<int (*)()>);
 static_assert(std::swappable<int rvalue_adl_swappable::*>);
 static_assert(std::swappable<int (rvalue_adl_swappable::*)()>);
 static_assert(std::swappable<std::unique_ptr<int> >);
 
 static_assert(!std::swappable<void>);
 static_assert(!std::swappable<int const>);
 static_assert(!std::swappable<int const&>);
 static_assert(!std::swappable<int const&&>);
 static_assert(!std::swappable<int const volatile>);
 static_assert(!std::swappable<int const volatile&>);
 static_assert(!std::swappable<int const volatile&&>);
 static_assert(!std::swappable<int (&)()>);
 static_assert(!std::swappable<DeletedMoveCtor>);
 static_assert(!std::swappable<ImplicitlyDeletedMoveCtor>);
 static_assert(!std::swappable<DeletedMoveAssign>);
 static_assert(!std::swappable<ImplicitlyDeletedMoveAssign>);
 static_assert(!std::swappable<NonMovable>);
 static_assert(!std::swappable<DerivedFromNonMovable>);
 static_assert(!std::swappable<HasANonMovable>);
 
 using swap_type = std::remove_const_t<decltype(std::ranges::swap)>;
 static_assert(std::default_initializable<swap_type>);
 static_assert(std::move_constructible<swap_type>);
 static_assert(std::copy_constructible<swap_type>);
 static_assert(std::assignable_from<swap_type&, swap_type>);
 static_assert(std::assignable_from<swap_type&, swap_type&>);
 static_assert(std::assignable_from<swap_type&, swap_type const&>);
 static_assert(std::assignable_from<swap_type&, swap_type const>);
 static_assert(std::swappable<swap_type>);
 
 template <bool is_noexcept, std::swappable T>
 void check_swap(expected<T> const& e) {
   auto a = e.y;
   auto b = e.x;
 
   std::ranges::swap(a, b);
   assert(a == e.x);
   assert(b == e.y);
 
   std::ranges::swap(a, b);
   assert(a == e.y);
   assert(b == e.x);
 
   static_assert(noexcept(std::ranges::swap(a, b)) == is_noexcept);
 }
 
 int main(int, char**) {
   {
     auto const e = expected<std::deque<int> >{
         .x = {6, 7, 8, 9},
         .y = {0, 1, 2, 3, 4, 5},
     };
     check_swap</*is_noexcept=*/true>(e);
   }
   {
     auto const e = expected<std::map<int, std::string> >{
         .x = {{0, "whole"}, {1, "cashews"}},
         .y = {{-1, "roasted"}, {2, "&"}, {-3, "salted"}},
     };
     check_swap</*is_noexcept=*/true>(e);
   }
   {
     auto const e = expected<std::string>{
         .x = "hello there",
         .y = "general kenobi",
     };
     check_swap</*is_noexcept=*/true>(e);
   }
   {
     auto const e = expected<std::optional<lvalue_adl_swappable> >{
         .x = {10},
         .y = {20},
     };
     check_swap</*is_noexcept=*/true>(e);
   }
   {
     auto const e = expected<std::optional<throwable_adl_swappable> >{
         .x = {10},
         .y = {20},
     };
     check_swap</*is_noexcept=*/false>(e);
   }
   {
     auto const e = expected<std::unordered_map<int, std::string> >{
         .x = {{0, "whole"}, {1, "cashews"}},
         .y = {{-1, "roasted"}, {2, "&"}, {-3, "salted"}},
     };
     check_swap</*is_noexcept=*/true>(e);
   }
   {
     auto const e = expected<std::vector<int> >{
         .x = {0, 1, 2, 3, 4, 5},
         .y = {6, 7, 8, 9},
     };
 
     check_swap</*is_noexcept=*/true>(e);
   }
   return 0;
 }

libcxx/test/std/concepts/concepts.lang/concept.swappable/swappable_with.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, class U>
 // concept swappable_with = // see below
 
 #include <concepts>
 
 #include <array>
 #include <deque>
 #include <forward_list>
 #include <list>
 #include <map>
 #include <memory>
 #include <optional>
 #include <set>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 #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>;
 }
 
 template <class T, class U>
 constexpr bool check_swappable_with() {
   static_assert(!check_swappable_with_impl<T, U>());
   static_assert(!check_swappable_with_impl<T, U const>());
   static_assert(!check_swappable_with_impl<T const, U>());
   static_assert(!check_swappable_with_impl<T const, U const>());
 
   static_assert(!check_swappable_with_impl<T, U&>());
   static_assert(!check_swappable_with_impl<T, U const&>());
   static_assert(!check_swappable_with_impl<T, U volatile&>());
   static_assert(!check_swappable_with_impl<T, U const volatile&>());
   static_assert(!check_swappable_with_impl<T const, U&>());
   static_assert(!check_swappable_with_impl<T const, U const&>());
   static_assert(!check_swappable_with_impl<T const, U volatile&>());
   static_assert(!check_swappable_with_impl<T const, U const volatile&>());
 
   static_assert(!check_swappable_with_impl<T&, U>());
   static_assert(!check_swappable_with_impl<T&, U const>());
   static_assert(!check_swappable_with_impl<T const&, U>());
   static_assert(!check_swappable_with_impl<T const&, U const>());
   static_assert(!check_swappable_with_impl<T volatile&, U>());
   static_assert(!check_swappable_with_impl<T volatile&, U const>());
   static_assert(!check_swappable_with_impl<T const volatile&, U>());
   static_assert(!check_swappable_with_impl<T const volatile&, U const>());
 
   static_assert(!check_swappable_with_impl<T&, U const&>());
   static_assert(!check_swappable_with_impl<T&, U volatile&>());
   static_assert(!check_swappable_with_impl<T&, U const volatile&>());
   static_assert(!check_swappable_with_impl<T const&, U&>());
   static_assert(!check_swappable_with_impl<T const&, U const&>());
   static_assert(!check_swappable_with_impl<T const&, U volatile&>());
   static_assert(!check_swappable_with_impl<T const&, U const volatile&>());
   static_assert(!check_swappable_with_impl<T volatile&, U&>());
   static_assert(!check_swappable_with_impl<T volatile&, U const&>());
   static_assert(!check_swappable_with_impl<T volatile&, U const volatile&>());
   static_assert(!check_swappable_with_impl<T const volatile&, U&>());
   static_assert(!check_swappable_with_impl<T const volatile&, U const&>());
   static_assert(!check_swappable_with_impl<T const volatile&, U volatile&>());
   static_assert(
       !check_swappable_with_impl<T const volatile&, U const volatile&>());
 
   static_assert(!check_swappable_with_impl<T, U&&>());
   static_assert(!check_swappable_with_impl<T, U const&&>());
   static_assert(!check_swappable_with_impl<T, U volatile&&>());
   static_assert(!check_swappable_with_impl<T, U const volatile&&>());
   static_assert(!check_swappable_with_impl<T const, U&&>());
   static_assert(!check_swappable_with_impl<T const, U const&&>());
   static_assert(!check_swappable_with_impl<T const, U volatile&&>());
   static_assert(!check_swappable_with_impl<T const, U const volatile&&>());
 
   static_assert(!check_swappable_with_impl<T&&, U>());
   static_assert(!check_swappable_with_impl<T&&, U const>());
   static_assert(!check_swappable_with_impl<T const&&, U>());
   static_assert(!check_swappable_with_impl<T const&&, U const>());
   static_assert(!check_swappable_with_impl<T volatile&&, U>());
   static_assert(!check_swappable_with_impl<T volatile&&, U const>());
   static_assert(!check_swappable_with_impl<T const volatile&&, U>());
   static_assert(!check_swappable_with_impl<T const volatile&&, U const>());
 
   static_assert(!check_swappable_with_impl<T&, U&&>());
   static_assert(!check_swappable_with_impl<T&, U const&&>());
   static_assert(!check_swappable_with_impl<T&, U volatile&&>());
   static_assert(!check_swappable_with_impl<T&, U const volatile&&>());
   static_assert(!check_swappable_with_impl<T const&, U&&>());
   static_assert(!check_swappable_with_impl<T const&, U const&&>());
   static_assert(!check_swappable_with_impl<T const&, U volatile&&>());
   static_assert(!check_swappable_with_impl<T const&, U const volatile&&>());
   static_assert(!check_swappable_with_impl<T volatile&, U&&>());
   static_assert(!check_swappable_with_impl<T volatile&, U const&&>());
   static_assert(!check_swappable_with_impl<T volatile&, U volatile&&>());
   static_assert(!check_swappable_with_impl<T volatile&, U const volatile&&>());
   static_assert(!check_swappable_with_impl<T const volatile&, U&&>());
   static_assert(!check_swappable_with_impl<T const volatile&, U const&&>());
   static_assert(!check_swappable_with_impl<T const volatile&, U volatile&&>());
   static_assert(
       !check_swappable_with_impl<T const volatile&, U const volatile&&>());
 
   static_assert(!check_swappable_with_impl<T&&, U&>());
   static_assert(!check_swappable_with_impl<T&&, U const&>());
   static_assert(!check_swappable_with_impl<T&&, U volatile&>());
   static_assert(!check_swappable_with_impl<T&&, U const volatile&>());
   static_assert(!check_swappable_with_impl<T const&&, U&>());
   static_assert(!check_swappable_with_impl<T const&&, U const&>());
   static_assert(!check_swappable_with_impl<T const&&, U volatile&>());
   static_assert(!check_swappable_with_impl<T const&&, U const volatile&>());
   static_assert(!check_swappable_with_impl<T volatile&&, U&>());
   static_assert(!check_swappable_with_impl<T volatile&&, U const&>());
   static_assert(!check_swappable_with_impl<T volatile&&, U volatile&>());
   static_assert(!check_swappable_with_impl<T volatile&&, U const volatile&>());
   static_assert(!check_swappable_with_impl<T const volatile&&, U&>());
   static_assert(!check_swappable_with_impl<T const volatile&&, U const&>());
   static_assert(!check_swappable_with_impl<T const volatile&&, U volatile&>());
   static_assert(
       !check_swappable_with_impl<T const volatile&&, U const volatile&>());
 
   static_assert(!check_swappable_with_impl<T&&, U&&>());
   static_assert(!check_swappable_with_impl<T&&, U const&&>());
   static_assert(!check_swappable_with_impl<T&&, U volatile&&>());
   static_assert(!check_swappable_with_impl<T&&, U const volatile&&>());
   static_assert(!check_swappable_with_impl<T const&&, U&&>());
   static_assert(!check_swappable_with_impl<T const&&, U const&&>());
   static_assert(!check_swappable_with_impl<T const&&, U volatile&&>());
   static_assert(!check_swappable_with_impl<T const&&, U const volatile&&>());
   static_assert(!check_swappable_with_impl<T volatile&&, U&&>());
   static_assert(!check_swappable_with_impl<T volatile&&, U const&&>());
   static_assert(!check_swappable_with_impl<T volatile&&, U volatile&&>());
   static_assert(!check_swappable_with_impl<T volatile&&, U const volatile&&>());
   static_assert(!check_swappable_with_impl<T const volatile&&, U&&>());
   static_assert(!check_swappable_with_impl<T const volatile&&, U const&&>());
   static_assert(!check_swappable_with_impl<T const volatile&&, U volatile&&>());
   static_assert(
       !check_swappable_with_impl<T const volatile&&, U const volatile&&>());
   return check_swappable_with_impl<T&, U&>();
 }
 
 template <class T, class U>
 constexpr bool check_swappable_with_including_lvalue_ref_to_volatile() {
   constexpr auto result = check_swappable_with<T, U>();
   static_assert(check_swappable_with_impl<T volatile&, U volatile&>() ==
                 result);
   return result;
 }
 
 namespace fundamental {
 static_assert(
     check_swappable_with_including_lvalue_ref_to_volatile<int, int>());
 static_assert(
     check_swappable_with_including_lvalue_ref_to_volatile<double, double>());
 static_assert(
     !check_swappable_with_including_lvalue_ref_to_volatile<int, double>());
 
 static_assert(
     check_swappable_with_including_lvalue_ref_to_volatile<int*, int*>());
 static_assert(
     !check_swappable_with_including_lvalue_ref_to_volatile<int, int*>());
 static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
               int (*)(), int (*)()>());
 static_assert(
     !check_swappable_with_including_lvalue_ref_to_volatile<int, int (*)()>());
 
 struct S {};
 static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<int, S>());
 static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
               int S::*, int S::*>());
 static_assert(
     !check_swappable_with_including_lvalue_ref_to_volatile<int, int S::*>());
 static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
               int (S::*)(), int (S::*)()>());
 static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
               int, int (S::*)()>());
 static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
               int (S::*)() noexcept, int (S::*)() noexcept>());
 static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
               int (S::*)() noexcept, int (S::*)()>());
 static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
               int (S::*)() const, int (S::*)() const>());
 static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
               int (S::*)() const, int (S::*)()>());
 static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
               int (S::*)() const noexcept, int (S::*)() const noexcept>());
 static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
               int (S::*)() const, int (S::*)() const noexcept>());
 static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
               int (S::*)() volatile, int (S::*)() volatile>());
 static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
               int (S::*)() volatile, int (S::*)()>());
 static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
               int (S::*)() const volatile, int (S::*)() const volatile>());
 static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
               int (S::*)() const volatile, int (S::*)()>());
 
 static_assert(
     check_swappable_with_including_lvalue_ref_to_volatile<int[5], int[5]>());
 static_assert(
     !check_swappable_with_including_lvalue_ref_to_volatile<int[5], int[6]>());
 static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
               int[5], double[5]>());
 static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
               int[5], double[6]>());
 static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<int[5][6],
                                                                      int[5]>());
 static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<int[5][6],
                                                                      int[6]>());
 static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
               int[5][6], double[5]>());
 static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
               int[5][6], double[6]>());
 static_assert(check_swappable_with_including_lvalue_ref_to_volatile<
               int[5][6], int[5][6]>());
 static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
               int[5][6], int[5][4]>());
 static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
               int[5][6], int[6][5]>());
 static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
               int[5][6], double[5][6]>());
 static_assert(!check_swappable_with_including_lvalue_ref_to_volatile<
               int[5][6], double[6][5]>());
 
 // always false
 static_assert(!check_swappable_with_impl<void, void>());
 static_assert(!check_swappable_with_impl<int, void>());
 static_assert(!check_swappable_with_impl<int&, void>());
 static_assert(!check_swappable_with_impl<void, int>());
 static_assert(!check_swappable_with_impl<void, int&>());
 static_assert(!check_swappable_with_impl<int, int()>());
 static_assert(!check_swappable_with_impl<int, int (&)()>());
 } // namespace fundamental
 
 namespace adl {
 static_assert(
     check_swappable_with<lvalue_adl_swappable, lvalue_adl_swappable>());
 static_assert(check_swappable_with<lvalue_rvalue_adl_swappable,
                                    lvalue_rvalue_adl_swappable>());
 static_assert(check_swappable_with<rvalue_lvalue_adl_swappable,
                                    rvalue_lvalue_adl_swappable>());
 static_assert(
     check_swappable_with_impl<rvalue_adl_swappable, rvalue_adl_swappable>());
 static_assert(!check_swappable_with_impl<lvalue_rvalue_adl_swappable&,
                                          lvalue_rvalue_adl_swappable&&>());
 
 struct s1 {};
 struct no_common_reference_with_s1 {
   friend void swap(s1&, no_common_reference_with_s1&);
   friend void swap(no_common_reference_with_s1&, s1&);
 };
 static_assert(!check_swappable_with<s1, no_common_reference_with_s1>());
 
 struct one_way_swappable_with_s1 {
   friend void swap(s1&, one_way_swappable_with_s1&);
   operator s1();
 };
 static_assert(std::common_reference_with<one_way_swappable_with_s1, s1>);
 static_assert(!check_swappable_with<one_way_swappable_with_s1, s1>());
 
 struct one_way_swappable_with_s1_other_way {
   friend void swap(one_way_swappable_with_s1_other_way&, s1&);
   operator s1();
 };
 static_assert(
     std::common_reference_with<one_way_swappable_with_s1_other_way, s1>);
 static_assert(!check_swappable_with<one_way_swappable_with_s1_other_way, s1>());
 
 struct can_swap_with_s1_but_not_swappable {
   can_swap_with_s1_but_not_swappable(can_swap_with_s1_but_not_swappable&&) =
       delete;
   friend void swap(s1&, can_swap_with_s1_but_not_swappable&);
   friend void swap(can_swap_with_s1_but_not_swappable&, s1&);
 
   operator s1() const;
 };
 static_assert(
     std::common_reference_with<can_swap_with_s1_but_not_swappable, s1>);
 static_assert(!std::swappable<can_swap_with_s1_but_not_swappable>);
 static_assert(
     !check_swappable_with<can_swap_with_s1_but_not_swappable&, s1&>());
 
 struct swappable_with_s1 {
   friend void swap(s1&, swappable_with_s1&);
   friend void swap(swappable_with_s1&, s1&);
   operator s1() const;
 };
 static_assert(check_swappable_with<swappable_with_s1, s1>());
 
 struct swappable_with_const_s1_but_not_swappable {
   swappable_with_const_s1_but_not_swappable(
       swappable_with_const_s1_but_not_swappable const&);
   swappable_with_const_s1_but_not_swappable(
       swappable_with_const_s1_but_not_swappable const&&);
   swappable_with_const_s1_but_not_swappable&
   operator=(swappable_with_const_s1_but_not_swappable const&);
   swappable_with_const_s1_but_not_swappable&
   operator=(swappable_with_const_s1_but_not_swappable const&&);
 
   friend void swap(s1 const&, swappable_with_const_s1_but_not_swappable const&);
   friend void swap(swappable_with_const_s1_but_not_swappable const&, s1 const&);
 
   operator s1 const &() const;
 };
 static_assert(
     !std::swappable<swappable_with_const_s1_but_not_swappable const&>);
 static_assert(!std::swappable_with<
               swappable_with_const_s1_but_not_swappable const&, s1 const&>);
 
 struct swappable_with_volatile_s1_but_not_swappable {
   swappable_with_volatile_s1_but_not_swappable(
       swappable_with_volatile_s1_but_not_swappable volatile&);
   swappable_with_volatile_s1_but_not_swappable(
       swappable_with_volatile_s1_but_not_swappable volatile&&);
   swappable_with_volatile_s1_but_not_swappable&
   operator=(swappable_with_volatile_s1_but_not_swappable volatile&);
   swappable_with_volatile_s1_but_not_swappable&
   operator=(swappable_with_volatile_s1_but_not_swappable volatile&&);
 
   friend void swap(s1 volatile&,
                    swappable_with_volatile_s1_but_not_swappable volatile&);
   friend void swap(swappable_with_volatile_s1_but_not_swappable volatile&,
                    s1 volatile&);
 
   operator s1 volatile &() volatile;
 };
 static_assert(
     !std::swappable<swappable_with_volatile_s1_but_not_swappable volatile&>);
 static_assert(
     !std::swappable_with<swappable_with_volatile_s1_but_not_swappable volatile&,
                          s1 volatile&>);
 
 struct swappable_with_cv_s1_but_not_swappable {
   swappable_with_cv_s1_but_not_swappable(
       swappable_with_cv_s1_but_not_swappable const volatile&);
   swappable_with_cv_s1_but_not_swappable(
       swappable_with_cv_s1_but_not_swappable const volatile&&);
   swappable_with_cv_s1_but_not_swappable&
   operator=(swappable_with_cv_s1_but_not_swappable const volatile&);
   swappable_with_cv_s1_but_not_swappable&
   operator=(swappable_with_cv_s1_but_not_swappable const volatile&&);
 
   friend void swap(s1 const volatile&,
                    swappable_with_cv_s1_but_not_swappable const volatile&);
   friend void swap(swappable_with_cv_s1_but_not_swappable const volatile&,
                    s1 const volatile&);
 
   operator s1 const volatile &() const volatile;
 };
 static_assert(
     !std::swappable<swappable_with_cv_s1_but_not_swappable const volatile&>);
 static_assert(
     !std::swappable_with<swappable_with_cv_s1_but_not_swappable const volatile&,
                          s1 const volatile&>);
 
 struct s2 {
   friend void swap(s2 const&, s2 const&);
   friend void swap(s2 volatile&, s2 volatile&);
   friend void swap(s2 const volatile&, s2 const volatile&);
 };
 
 struct swappable_with_const_s2 {
   swappable_with_const_s2(swappable_with_const_s2 const&);
   swappable_with_const_s2(swappable_with_const_s2 const&&);
   swappable_with_const_s2& operator=(swappable_with_const_s2 const&);
   swappable_with_const_s2& operator=(swappable_with_const_s2 const&&);
 
   friend void swap(swappable_with_const_s2 const&,
                    swappable_with_const_s2 const&);
   friend void swap(s2 const&, swappable_with_const_s2 const&);
   friend void swap(swappable_with_const_s2 const&, s2 const&);
 
   operator s2 const &() const;
 };
 static_assert(std::swappable_with<swappable_with_const_s2 const&, s2 const&>);
 
 struct swappable_with_volatile_s2 {
   swappable_with_volatile_s2(swappable_with_volatile_s2 volatile&);
   swappable_with_volatile_s2(swappable_with_volatile_s2 volatile&&);
   swappable_with_volatile_s2& operator=(swappable_with_volatile_s2 volatile&);
   swappable_with_volatile_s2& operator=(swappable_with_volatile_s2 volatile&&);
 
   friend void swap(swappable_with_volatile_s2 volatile&,
                    swappable_with_volatile_s2 volatile&);
   friend void swap(s2 volatile&, swappable_with_volatile_s2 volatile&);
   friend void swap(swappable_with_volatile_s2 volatile&, s2 volatile&);
 
   operator s2 volatile &() volatile;
 };
 static_assert(
     std::swappable_with<swappable_with_volatile_s2 volatile&, s2 volatile&>);
 
 struct swappable_with_cv_s2 {
   swappable_with_cv_s2(swappable_with_cv_s2 const volatile&);
   swappable_with_cv_s2(swappable_with_cv_s2 const volatile&&);
   swappable_with_cv_s2& operator=(swappable_with_cv_s2 const volatile&);
   swappable_with_cv_s2& operator=(swappable_with_cv_s2 const volatile&&);
 
   friend void swap(swappable_with_cv_s2 const volatile&,
                    swappable_with_cv_s2 const volatile&);
   friend void swap(s2 const volatile&, swappable_with_cv_s2 const volatile&);
   friend void swap(swappable_with_cv_s2 const volatile&, s2 const volatile&);
 
   operator s2 const volatile &() const volatile;
 };
 static_assert(std::swappable_with<swappable_with_cv_s2 const volatile&,
                                   s2 const volatile&>);
 
 struct swappable_with_rvalue_ref_to_s1_but_not_swappable {
   friend void swap(swappable_with_rvalue_ref_to_s1_but_not_swappable&&,
                    swappable_with_rvalue_ref_to_s1_but_not_swappable&&);
   friend void swap(s1&&, swappable_with_rvalue_ref_to_s1_but_not_swappable&&);
   friend void swap(swappable_with_rvalue_ref_to_s1_but_not_swappable&&, s1&&);
 
   operator s1() const;
 };
 static_assert(
     !std::swappable<swappable_with_rvalue_ref_to_s1_but_not_swappable const&&>);
 static_assert(
     !std::swappable_with<
         swappable_with_rvalue_ref_to_s1_but_not_swappable const&&, s1 const&&>);
 
 struct swappable_with_rvalue_ref_to_const_s1_but_not_swappable {
   friend void
   swap(s1 const&&,
        swappable_with_rvalue_ref_to_const_s1_but_not_swappable const&&);
   friend void
   swap(swappable_with_rvalue_ref_to_const_s1_but_not_swappable const&&,
        s1 const&&);
 
   operator s1 const() const;
 };
 static_assert(!std::swappable<
               swappable_with_rvalue_ref_to_const_s1_but_not_swappable const&&>);
 static_assert(!std::swappable_with<
               swappable_with_rvalue_ref_to_const_s1_but_not_swappable const&&,
               s1 const&&>);
 
 struct swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable {
   swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable(
       swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&);
   swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable(
       swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&&);
   swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable& operator=(
       swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&);
   swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable& operator=(
       swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&&);
 
   friend void
   swap(s1 volatile&&,
        swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&&);
   friend void
   swap(swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&&,
        s1 volatile&&);
 
   operator s1 volatile &&() volatile&&;
 };
 static_assert(
     !std::swappable<
         swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&&>);
 static_assert(
     !std::swappable_with<
         swappable_with_rvalue_ref_to_volatile_s1_but_not_swappable volatile&&,
         s1 volatile&&>);
 
 struct swappable_with_rvalue_ref_to_cv_s1_but_not_swappable {
   swappable_with_rvalue_ref_to_cv_s1_but_not_swappable(
       swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&);
   swappable_with_rvalue_ref_to_cv_s1_but_not_swappable(
       swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&&);
   swappable_with_rvalue_ref_to_cv_s1_but_not_swappable& operator=(
       swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&);
   swappable_with_rvalue_ref_to_cv_s1_but_not_swappable& operator=(
       swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&&);
 
   friend void
   swap(s1 const volatile&&,
        swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&&);
   friend void
   swap(swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&&,
        s1 const volatile&&);
 
   operator s1 const volatile &&() const volatile&&;
 };
 static_assert(
     !std::swappable<
         swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&&>);
 static_assert(
     !std::swappable_with<
         swappable_with_rvalue_ref_to_cv_s1_but_not_swappable const volatile&&,
         s1 const volatile&&>);
 
 struct s3 {
   friend void swap(s3&&, s3&&);
   friend void swap(s3 const&&, s3 const&&);
   friend void swap(s3 volatile&&, s3 volatile&&);
   friend void swap(s3 const volatile&&, s3 const volatile&&);
 };
 
 struct swappable_with_rvalue_ref_to_s3 {
   friend void swap(swappable_with_rvalue_ref_to_s3&&,
                    swappable_with_rvalue_ref_to_s3&&);
   friend void swap(s3&&, swappable_with_rvalue_ref_to_s3&&);
   friend void swap(swappable_with_rvalue_ref_to_s3&&, s3&&);
 
   operator s3() const;
 };
 static_assert(std::swappable_with<swappable_with_rvalue_ref_to_s3&&, s3&&>);
 
 struct swappable_with_rvalue_ref_to_const_s3 {
   swappable_with_rvalue_ref_to_const_s3(
       swappable_with_rvalue_ref_to_const_s3 const&);
   swappable_with_rvalue_ref_to_const_s3(
       swappable_with_rvalue_ref_to_const_s3 const&&);
   swappable_with_rvalue_ref_to_const_s3&
   operator=(swappable_with_rvalue_ref_to_const_s3 const&);
   swappable_with_rvalue_ref_to_const_s3&
   operator=(swappable_with_rvalue_ref_to_const_s3 const&&);
 
   friend void swap(swappable_with_rvalue_ref_to_const_s3 const&&,
                    swappable_with_rvalue_ref_to_const_s3 const&&);
   friend void swap(s3 const&&, swappable_with_rvalue_ref_to_const_s3 const&&);
   friend void swap(swappable_with_rvalue_ref_to_const_s3 const&&, s3 const&&);
 
   operator s3() const;
 };
 static_assert(std::swappable_with<swappable_with_rvalue_ref_to_const_s3 const&&,
                                   s3 const&&>);
 
 struct swappable_with_rvalue_ref_to_volatile_s3 {
   swappable_with_rvalue_ref_to_volatile_s3(
       swappable_with_rvalue_ref_to_volatile_s3 volatile&);
   swappable_with_rvalue_ref_to_volatile_s3(
       swappable_with_rvalue_ref_to_volatile_s3 volatile&&);
   swappable_with_rvalue_ref_to_volatile_s3&
   operator=(swappable_with_rvalue_ref_to_volatile_s3 volatile&);
   swappable_with_rvalue_ref_to_volatile_s3&
   operator=(swappable_with_rvalue_ref_to_volatile_s3 volatile&&);
 
   friend void swap(swappable_with_rvalue_ref_to_volatile_s3 volatile&&,
                    swappable_with_rvalue_ref_to_volatile_s3 volatile&&);
   friend void swap(s3 volatile&&,
                    swappable_with_rvalue_ref_to_volatile_s3 volatile&&);
   friend void swap(swappable_with_rvalue_ref_to_volatile_s3 volatile&&,
                    s3 volatile&&);
 
   operator s3 volatile &() volatile;
 };
 static_assert(
     std::swappable_with<swappable_with_rvalue_ref_to_volatile_s3 volatile&&,
                         s3 volatile&&>);
 
 struct swappable_with_rvalue_ref_to_cv_s3 {
   swappable_with_rvalue_ref_to_cv_s3(
       swappable_with_rvalue_ref_to_cv_s3 const volatile&);
   swappable_with_rvalue_ref_to_cv_s3(
       swappable_with_rvalue_ref_to_cv_s3 const volatile&&);
   swappable_with_rvalue_ref_to_cv_s3&
   operator=(swappable_with_rvalue_ref_to_cv_s3 const volatile&);
   swappable_with_rvalue_ref_to_cv_s3&
   operator=(swappable_with_rvalue_ref_to_cv_s3 const volatile&&);
 
   friend void swap(swappable_with_rvalue_ref_to_cv_s3 const volatile&&,
                    swappable_with_rvalue_ref_to_cv_s3 const volatile&&);
   friend void swap(s3 const volatile&&,
                    swappable_with_rvalue_ref_to_cv_s3 const volatile&&);
   friend void swap(swappable_with_rvalue_ref_to_cv_s3 const volatile&&,
                    s3 const volatile&&);
 
   operator s3 const volatile &() const volatile;
 };
 static_assert(
     std::swappable_with<swappable_with_rvalue_ref_to_cv_s3 const volatile&&,
                         s3 const volatile&&>);
 
 namespace union_swap {
 union adl_swappable {
   int x;
   double y;
 
   operator int() const;
 };
 
 void swap(adl_swappable&, adl_swappable&) noexcept;
 void swap(adl_swappable&&, adl_swappable&&) noexcept;
 void swap(adl_swappable&, int&) noexcept;
 void swap(int&, adl_swappable&) noexcept;
 } // namespace union_swap
 static_assert(
     std::swappable_with<union_swap::adl_swappable, union_swap::adl_swappable>);
 static_assert(std::swappable_with<union_swap::adl_swappable&,
                                   union_swap::adl_swappable&>);
 static_assert(std::swappable_with<union_swap::adl_swappable&&,
                                   union_swap::adl_swappable&&>);
 static_assert(std::swappable_with<union_swap::adl_swappable&, int&>);
 } // namespace adl
 
 namespace standard_types {
 static_assert(
     check_swappable_with<std::array<int, 10>, std::array<int, 10> >());
 static_assert(
     !check_swappable_with<std::array<int, 10>, std::array<double, 10> >());
 static_assert(check_swappable_with<std::deque<int>, std::deque<int> >());
 static_assert(!check_swappable_with<std::deque<int>, std::vector<int> >());
 static_assert(
     check_swappable_with<std::forward_list<int>, std::forward_list<int> >());
 static_assert(
     !check_swappable_with<std::forward_list<int>, std::vector<int> >());
 static_assert(check_swappable_with<std::list<int>, std::list<int> >());
 static_assert(!check_swappable_with<std::list<int>, std::vector<int> >());
 
 static_assert(
     check_swappable_with<std::map<int, void*>, std::map<int, void*> >());
 static_assert(!check_swappable_with<std::map<int, void*>, std::vector<int> >());
 static_assert(check_swappable_with<std::optional<std::vector<int> >,
                                    std::optional<std::vector<int> > >());
 static_assert(!check_swappable_with<std::optional<std::vector<int> >,
                                     std::vector<int> >());
 static_assert(check_swappable_with<std::vector<int>, std::vector<int> >());
 static_assert(!check_swappable_with<std::vector<int>, int>());
 } // namespace standard_types
 
 namespace types_with_purpose {
 static_assert(!check_swappable_with<DeletedMoveCtor, DeletedMoveCtor>());
 static_assert(!check_swappable_with<ImplicitlyDeletedMoveCtor,
                                     ImplicitlyDeletedMoveCtor>());
 static_assert(!check_swappable_with<DeletedMoveAssign, DeletedMoveAssign>());
 static_assert(!check_swappable_with<ImplicitlyDeletedMoveAssign,
                                     ImplicitlyDeletedMoveAssign>());
 static_assert(!check_swappable_with<NonMovable, NonMovable>());
 static_assert(
     !check_swappable_with<DerivedFromNonMovable, DerivedFromNonMovable>());
 static_assert(!check_swappable_with<HasANonMovable, HasANonMovable>());
 } // namespace types_with_purpose
 
 int main(int, char**) { return 0; }

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>
+
+// This overload should never be called. It exists solely to force subsumption.
+template <std::integral I>
+[[nodiscard]] constexpr bool CheckSubsumption(I) {
+  return false;
+}
+
+// clang-format off
+template <std::integral I>
+requires std::signed_integral<I> && (!std::unsigned_integral<I>)
+[[nodiscard]] constexpr bool CheckSubsumption(I) {
+  return std::is_signed_v<I>;
+}
+
+template <std::integral I>
+requires std::unsigned_integral<I> && (!std::signed_integral<I>)
+[[nodiscard]] constexpr bool CheckSubsumption(I) {
+  return std::is_unsigned_v<I>;
+}
+// clang-format on
+
+enum ClassicEnum { a, b, c };
+enum class ScopedEnum { x, y, z };
+struct EmptyStruct {};
+
+#endif // LIBCXX_TEST_CONCEPTS_LANG_CONCEPTS_ARITHMETIC_H_

libcxx/test/std/concepts/concepts.lang/concepts.arithmetic/floating_point.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 floating_point = // see below
+
+#include <concepts>
+#include <type_traits>
+
+#include "arithmetic.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);
+
+  static_assert(!std::floating_point<T&>);
+  static_assert(!std::floating_point<const T&>);
+  static_assert(!std::floating_point<volatile T&>);
+  static_assert(!std::floating_point<const volatile T&>);
+
+  static_assert(!std::floating_point<T&&>);
+  static_assert(!std::floating_point<const T&&>);
+  static_assert(!std::floating_point<volatile T&&>);
+  static_assert(!std::floating_point<const volatile T&&>);
+
+  static_assert(!std::floating_point<T*>);
+  static_assert(!std::floating_point<const T*>);
+  static_assert(!std::floating_point<volatile T*>);
+  static_assert(!std::floating_point<const volatile T*>);
+
+  static_assert(!std::floating_point<T (*)()>);
+  static_assert(!std::floating_point<T (&)()>);
+  static_assert(!std::floating_point<T(&&)()>);
+
+  return result;
+}
+
+// floating-point types
+static_assert(CheckFloatingPointQualifiers<float>());
+static_assert(CheckFloatingPointQualifiers<double>());
+static_assert(CheckFloatingPointQualifiers<long double>());
+
+// types that aren't floating-point
+static_assert(!CheckFloatingPointQualifiers<signed char>());
+static_assert(!CheckFloatingPointQualifiers<unsigned char>());
+static_assert(!CheckFloatingPointQualifiers<short>());
+static_assert(!CheckFloatingPointQualifiers<unsigned short>());
+static_assert(!CheckFloatingPointQualifiers<int>());
+static_assert(!CheckFloatingPointQualifiers<unsigned int>());
+static_assert(!CheckFloatingPointQualifiers<long>());
+static_assert(!CheckFloatingPointQualifiers<unsigned long>());
+static_assert(!CheckFloatingPointQualifiers<long long>());
+static_assert(!CheckFloatingPointQualifiers<unsigned long long>());
+static_assert(!CheckFloatingPointQualifiers<wchar_t>());
+static_assert(!CheckFloatingPointQualifiers<bool>());
+static_assert(!CheckFloatingPointQualifiers<char>());
+static_assert(!CheckFloatingPointQualifiers<char8_t>());
+static_assert(!CheckFloatingPointQualifiers<char16_t>());
+static_assert(!CheckFloatingPointQualifiers<char32_t>());
+static_assert(!std::floating_point<void>);
+
+static_assert(!CheckFloatingPointQualifiers<ClassicEnum>());
+static_assert(!CheckFloatingPointQualifiers<ScopedEnum>());
+static_assert(!CheckFloatingPointQualifiers<EmptyStruct>());
+static_assert(!CheckFloatingPointQualifiers<int EmptyStruct::*>());
+static_assert(!CheckFloatingPointQualifiers<int (EmptyStruct::*)()>());
+
+int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.lang/concepts.arithmetic/integral.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 integral = // see below
+
+#include <concepts>
+#include <type_traits>
+
+#include "arithmetic.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);
+
+  static_assert(!std::integral<T&>);
+  static_assert(!std::integral<const T&>);
+  static_assert(!std::integral<volatile T&>);
+  static_assert(!std::integral<const volatile T&>);
+
+  static_assert(!std::integral<T&&>);
+  static_assert(!std::integral<const T&&>);
+  static_assert(!std::integral<volatile T&&>);
+  static_assert(!std::integral<const volatile T&&>);
+
+  static_assert(!std::integral<T*>);
+  static_assert(!std::integral<const T*>);
+  static_assert(!std::integral<volatile T*>);
+  static_assert(!std::integral<const volatile T*>);
+
+  static_assert(!std::integral<T (*)()>);
+  static_assert(!std::integral<T (&)()>);
+  static_assert(!std::integral<T(&&)()>);
+
+  return result;
+}
+
+// standard signed and unsigned integers
+static_assert(CheckIntegralQualifiers<signed char>());
+static_assert(CheckIntegralQualifiers<unsigned char>());
+static_assert(CheckIntegralQualifiers<short>());
+static_assert(CheckIntegralQualifiers<unsigned short>());
+static_assert(CheckIntegralQualifiers<int>());
+static_assert(CheckIntegralQualifiers<unsigned int>());
+static_assert(CheckIntegralQualifiers<long>());
+static_assert(CheckIntegralQualifiers<unsigned long>());
+static_assert(CheckIntegralQualifiers<long long>());
+static_assert(CheckIntegralQualifiers<unsigned long long>());
+
+// extended integers
+#ifndef _LIBCPP_HAS_NO_INT128
+static_assert(CheckIntegralQualifiers<__int128_t>());
+static_assert(CheckIntegralQualifiers<__uint128_t>());
+#endif
+
+// bool and char types are also integral
+static_assert(CheckIntegralQualifiers<wchar_t>());
+static_assert(CheckIntegralQualifiers<bool>());
+static_assert(CheckIntegralQualifiers<char>());
+static_assert(CheckIntegralQualifiers<char8_t>());
+static_assert(CheckIntegralQualifiers<char16_t>());
+static_assert(CheckIntegralQualifiers<char32_t>());
+
+// types that aren't integral
+static_assert(!std::integral<void>);
+static_assert(!CheckIntegralQualifiers<float>());
+static_assert(!CheckIntegralQualifiers<double>());
+static_assert(!CheckIntegralQualifiers<long double>());
+
+static_assert(!CheckIntegralQualifiers<ClassicEnum>());
+
+static_assert(!CheckIntegralQualifiers<ScopedEnum>());
+
+static_assert(!CheckIntegralQualifiers<EmptyStruct>());
+static_assert(!CheckIntegralQualifiers<int EmptyStruct::*>());
+static_assert(!CheckIntegralQualifiers<int (EmptyStruct::*)()>());
+
+static_assert(CheckSubsumption(0));
+static_assert(CheckSubsumption(0U));
+
+int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.lang/concepts.arithmetic/signed_integral.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 signed_integral = // see below
+
+#include <concepts>
+#include <type_traits>
+
+#include "arithmetic.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);
+
+  static_assert(!std::signed_integral<T&>);
+  static_assert(!std::signed_integral<const T&>);
+  static_assert(!std::signed_integral<volatile T&>);
+  static_assert(!std::signed_integral<const volatile T&>);
+
+  static_assert(!std::signed_integral<T&&>);
+  static_assert(!std::signed_integral<const T&&>);
+  static_assert(!std::signed_integral<volatile T&&>);
+  static_assert(!std::signed_integral<const volatile T&&>);
+
+  static_assert(!std::signed_integral<T*>);
+  static_assert(!std::signed_integral<const T*>);
+  static_assert(!std::signed_integral<volatile T*>);
+  static_assert(!std::signed_integral<const volatile T*>);
+
+  static_assert(!std::signed_integral<T (*)()>);
+  static_assert(!std::signed_integral<T (&)()>);
+  static_assert(!std::signed_integral<T(&&)()>);
+
+  return result;
+}
+
+// standard signed integers
+static_assert(CheckSignedIntegralQualifiers<signed char>());
+static_assert(CheckSignedIntegralQualifiers<short>());
+static_assert(CheckSignedIntegralQualifiers<int>());
+static_assert(CheckSignedIntegralQualifiers<long>());
+static_assert(CheckSignedIntegralQualifiers<long long>());
+
+// bool and character *may* be signed
+static_assert(CheckSignedIntegralQualifiers<wchar_t>() ==
+              std::is_signed_v<wchar_t>);
+static_assert(CheckSignedIntegralQualifiers<bool>() == std::is_signed_v<bool>);
+static_assert(CheckSignedIntegralQualifiers<char>() == std::is_signed_v<char>);
+static_assert(CheckSignedIntegralQualifiers<char8_t>() ==
+              std::is_signed_v<char8_t>);
+static_assert(CheckSignedIntegralQualifiers<char16_t>() ==
+              std::is_signed_v<char16_t>);
+static_assert(CheckSignedIntegralQualifiers<char32_t>() ==
+              std::is_signed_v<char32_t>);
+
+// integers that aren't signed integrals
+static_assert(!CheckSignedIntegralQualifiers<unsigned char>());
+static_assert(!CheckSignedIntegralQualifiers<unsigned short>());
+static_assert(!CheckSignedIntegralQualifiers<unsigned int>());
+static_assert(!CheckSignedIntegralQualifiers<unsigned long>());
+static_assert(!CheckSignedIntegralQualifiers<unsigned long long>());
+
+// extended integers
+#ifndef _LIBCPP_HAS_NO_INT128
+static_assert(CheckSignedIntegralQualifiers<__int128_t>());
+static_assert(!CheckSignedIntegralQualifiers<__uint128_t>());
+#endif
+
+// types that aren't even integers shouldn't be signed integers!
+static_assert(!std::signed_integral<void>);
+static_assert(!CheckSignedIntegralQualifiers<float>());
+static_assert(!CheckSignedIntegralQualifiers<double>());
+static_assert(!CheckSignedIntegralQualifiers<long double>());
+
+static_assert(!CheckSignedIntegralQualifiers<ClassicEnum>());
+static_assert(!CheckSignedIntegralQualifiers<ScopedEnum>());
+static_assert(!CheckSignedIntegralQualifiers<EmptyStruct>());
+static_assert(!CheckSignedIntegralQualifiers<int EmptyStruct::*>());
+static_assert(!CheckSignedIntegralQualifiers<int (EmptyStruct::*)()>());
+
+static_assert(CheckSubsumption(0));
+static_assert(CheckSubsumption(0U));
+
+int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.lang/concepts.arithmetic/unsigned_integral.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 unsigned_integral = // see below
+
+#include <concepts>
+#include <type_traits>
+
+#include "arithmetic.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);
+
+  static_assert(!std::unsigned_integral<T&>);
+  static_assert(!std::unsigned_integral<const T&>);
+  static_assert(!std::unsigned_integral<volatile T&>);
+  static_assert(!std::unsigned_integral<const volatile T&>);
+
+  static_assert(!std::unsigned_integral<T&&>);
+  static_assert(!std::unsigned_integral<const T&&>);
+  static_assert(!std::unsigned_integral<volatile T&&>);
+  static_assert(!std::unsigned_integral<const volatile T&&>);
+
+  static_assert(!std::unsigned_integral<T*>);
+  static_assert(!std::unsigned_integral<const T*>);
+  static_assert(!std::unsigned_integral<volatile T*>);
+  static_assert(!std::unsigned_integral<const volatile T*>);
+
+  static_assert(!std::unsigned_integral<T (*)()>);
+  static_assert(!std::unsigned_integral<T (&)()>);
+  static_assert(!std::unsigned_integral<T(&&)()>);
+
+  return result;
+}
+
+// standard unsigned types
+static_assert(CheckUnsignedIntegralQualifiers<unsigned char>());
+static_assert(CheckUnsignedIntegralQualifiers<unsigned short>());
+static_assert(CheckUnsignedIntegralQualifiers<unsigned int>());
+static_assert(CheckUnsignedIntegralQualifiers<unsigned long>());
+static_assert(CheckUnsignedIntegralQualifiers<unsigned long long>());
+
+// Whether bool and character types are signed or unsigned is impl-defined
+static_assert(CheckUnsignedIntegralQualifiers<wchar_t>() ==
+              !std::is_signed_v<wchar_t>);
+static_assert(CheckUnsignedIntegralQualifiers<bool>() ==
+              !std::is_signed_v<bool>);
+static_assert(CheckUnsignedIntegralQualifiers<char>() ==
+              !std::is_signed_v<char>);
+static_assert(CheckUnsignedIntegralQualifiers<char8_t>() ==
+              !std::is_signed_v<char8_t>);
+static_assert(CheckUnsignedIntegralQualifiers<char16_t>() ==
+              !std::is_signed_v<char16_t>);
+static_assert(CheckUnsignedIntegralQualifiers<char32_t>() ==
+              !std::is_signed_v<char32_t>);
+
+// extended integers
+#ifndef _LIBCPP_HAS_NO_INT128
+static_assert(CheckUnsignedIntegralQualifiers<__uint128_t>());
+static_assert(!CheckUnsignedIntegralQualifiers<__int128_t>());
+#endif
+
+// integer types that aren't unsigned integrals
+static_assert(!CheckUnsignedIntegralQualifiers<signed char>());
+static_assert(!CheckUnsignedIntegralQualifiers<short>());
+static_assert(!CheckUnsignedIntegralQualifiers<int>());
+static_assert(!CheckUnsignedIntegralQualifiers<long>());
+static_assert(!CheckUnsignedIntegralQualifiers<long long>());
+
+static_assert(!std::unsigned_integral<void>);
+static_assert(!CheckUnsignedIntegralQualifiers<float>());
+static_assert(!CheckUnsignedIntegralQualifiers<double>());
+static_assert(!CheckUnsignedIntegralQualifiers<long double>());
+
+static_assert(!CheckUnsignedIntegralQualifiers<ClassicEnum>());
+static_assert(!CheckUnsignedIntegralQualifiers<ScopedEnum>());
+static_assert(!CheckUnsignedIntegralQualifiers<EmptyStruct>());
+static_assert(!CheckUnsignedIntegralQualifiers<int EmptyStruct::*>());
+static_assert(!CheckUnsignedIntegralQualifiers<int (EmptyStruct::*)()>());
+
+static_assert(CheckSubsumption(0));
+static_assert(CheckSubsumption(0U));
+
+int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.object/copyable.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 copyable = see below;
 
 #include <concepts>
 
 #include <deque>
 #include <forward_list>
 #include <list>
 #include <map>
 #include <memory>
 #include <optional>
 #include <unordered_map>
 #include <vector>
 
 #include "type_classification/copyable.h"
 
 static_assert(std::copyable<int>);
 static_assert(std::copyable<int volatile>);
 static_assert(std::copyable<int*>);
 static_assert(std::copyable<int const*>);
 static_assert(std::copyable<int volatile*>);
 static_assert(std::copyable<int volatile const*>);
 static_assert(std::copyable<int (*)()>);
 
 struct S {};
 static_assert(std::copyable<S>);
 static_assert(std::copyable<int S::*>);
 static_assert(std::copyable<int (S::*)()>);
 static_assert(std::copyable<int (S::*)() noexcept>);
 static_assert(std::copyable<int (S::*)() &>);
 static_assert(std::copyable<int (S::*)() & noexcept>);
 static_assert(std::copyable<int (S::*)() &&>);
 static_assert(std::copyable<int (S::*)() && noexcept>);
 static_assert(std::copyable<int (S::*)() const>);
 static_assert(std::copyable<int (S::*)() const noexcept>);
 static_assert(std::copyable<int (S::*)() const&>);
 static_assert(std::copyable<int (S::*)() const & noexcept>);
 static_assert(std::copyable<int (S::*)() const&&>);
 static_assert(std::copyable<int (S::*)() const && noexcept>);
 static_assert(std::copyable<int (S::*)() volatile>);
 static_assert(std::copyable<int (S::*)() volatile noexcept>);
 static_assert(std::copyable<int (S::*)() volatile&>);
 static_assert(std::copyable<int (S::*)() volatile & noexcept>);
 static_assert(std::copyable<int (S::*)() volatile&&>);
 static_assert(std::copyable<int (S::*)() volatile && noexcept>);
 static_assert(std::copyable<int (S::*)() const volatile>);
 static_assert(std::copyable<int (S::*)() const volatile noexcept>);
 static_assert(std::copyable<int (S::*)() const volatile&>);
 static_assert(std::copyable<int (S::*)() const volatile & noexcept>);
 static_assert(std::copyable<int (S::*)() const volatile&&>);
 static_assert(std::copyable<int (S::*)() const volatile && noexcept>);
 
 static_assert(std::copyable<std::vector<int> >);
 static_assert(std::copyable<std::deque<int> >);
 static_assert(std::copyable<std::forward_list<int> >);
 static_assert(std::copyable<std::list<int> >);
 static_assert(std::copyable<std::shared_ptr<std::unique_ptr<int> > >);
 static_assert(std::copyable<std::optional<std::vector<int> > >);
 static_assert(std::copyable<std::vector<int> >);
 static_assert(std::copyable<std::vector<std::unique_ptr<int> > >);
 
 static_assert(std::copyable<has_volatile_member>);
 static_assert(std::copyable<has_array_member>);
 
 // Not objects
 static_assert(!std::copyable<void>);
 static_assert(!std::copyable<int&>);
 static_assert(!std::copyable<int const&>);
 static_assert(!std::copyable<int volatile&>);
 static_assert(!std::copyable<int const volatile&>);
 static_assert(!std::copyable<int&&>);
 static_assert(!std::copyable<int const&&>);
 static_assert(!std::copyable<int volatile&&>);
 static_assert(!std::copyable<int const volatile&&>);
 static_assert(!std::copyable<int()>);
 static_assert(!std::copyable<int (&)()>);
 static_assert(!std::copyable<int[5]>);
 
 // Not copy constructible or copy assignable
 static_assert(!std::copyable<std::unique_ptr<int> >);
 
 // Not assignable
 static_assert(!std::copyable<int const>);
 static_assert(!std::copyable<int const volatile>);
 static_assert(std::copyable<const_copy_assignment const>);
 static_assert(!std::copyable<volatile_copy_assignment volatile>);
 static_assert(std::copyable<cv_copy_assignment const volatile>);
 
 static_assert(!std::copyable<no_copy_constructor>);
 static_assert(!std::copyable<no_copy_assignment>);
 
 static_assert(std::is_copy_assignable_v<no_copy_assignment_mutable>);
 static_assert(!std::copyable<no_copy_assignment_mutable>);
 static_assert(!std::copyable<derived_from_noncopyable>);
 static_assert(!std::copyable<has_noncopyable>);
 static_assert(!std::copyable<has_const_member>);
 static_assert(!std::copyable<has_cv_member>);
 static_assert(!std::copyable<has_lvalue_reference_member>);
 static_assert(!std::copyable<has_rvalue_reference_member>);
 static_assert(!std::copyable<has_function_ref_member>);
 
 static_assert(
     !std::assignable_from<deleted_assignment_from_const_rvalue&,
                           deleted_assignment_from_const_rvalue const>);
 static_assert(!std::copyable<deleted_assignment_from_const_rvalue>);
 
 int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.object/movable.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 movable = see below;
 
 #include <concepts>
 
 #include <deque>
 #include <forward_list>
 #include <list>
 #include <map>
 #include <mutex>
 #include <optional>
 #include <unordered_map>
 #include <vector>
 
 #include "type_classification/moveconstructible.h"
 #include "type_classification/movable.h"
 
 // Movable types
 static_assert(std::movable<int>);
 static_assert(std::movable<int volatile>);
 static_assert(std::movable<int*>);
 static_assert(std::movable<int const*>);
 static_assert(std::movable<int volatile*>);
 static_assert(std::movable<int const volatile*>);
 static_assert(std::movable<int (*)()>);
 
 struct S {};
 static_assert(std::movable<S>);
 static_assert(std::movable<int S::*>);
 static_assert(std::movable<int (S::*)()>);
 static_assert(std::movable<int (S::*)() noexcept>);
 static_assert(std::movable<int (S::*)() &>);
 static_assert(std::movable<int (S::*)() & noexcept>);
 static_assert(std::movable<int (S::*)() &&>);
 static_assert(std::movable<int (S::*)() && noexcept>);
 static_assert(std::movable<int (S::*)() const>);
 static_assert(std::movable<int (S::*)() const noexcept>);
 static_assert(std::movable<int (S::*)() const&>);
 static_assert(std::movable<int (S::*)() const & noexcept>);
 static_assert(std::movable<int (S::*)() const&&>);
 static_assert(std::movable<int (S::*)() const && noexcept>);
 static_assert(std::movable<int (S::*)() volatile>);
 static_assert(std::movable<int (S::*)() volatile noexcept>);
 static_assert(std::movable<int (S::*)() volatile&>);
 static_assert(std::movable<int (S::*)() volatile & noexcept>);
 static_assert(std::movable<int (S::*)() volatile&&>);
 static_assert(std::movable<int (S::*)() volatile && noexcept>);
 static_assert(std::movable<int (S::*)() const volatile>);
 static_assert(std::movable<int (S::*)() const volatile noexcept>);
 static_assert(std::movable<int (S::*)() const volatile&>);
 static_assert(std::movable<int (S::*)() const volatile & noexcept>);
 static_assert(std::movable<int (S::*)() const volatile&&>);
 static_assert(std::movable<int (S::*)() const volatile && noexcept>);
 
 static_assert(std::movable<std::deque<int> >);
 static_assert(std::movable<std::forward_list<int> >);
 static_assert(std::movable<std::list<int> >);
 static_assert(std::movable<std::optional<std::vector<int> > >);
 static_assert(std::movable<std::vector<int> >);
 
 static_assert(std::movable<traditional_copy_assignment_only>);
 static_assert(std::movable<has_volatile_member>);
 static_assert(std::movable<has_array_member>);
 
 // Not objects
 static_assert(!std::movable<int&>);
 static_assert(!std::movable<int const&>);
 static_assert(!std::movable<int volatile&>);
 static_assert(!std::movable<int const volatile&>);
 static_assert(!std::movable<int&&>);
 static_assert(!std::movable<int const&&>);
 static_assert(!std::movable<int volatile&&>);
 static_assert(!std::movable<int const volatile&&>);
 static_assert(!std::movable<int()>);
 static_assert(!std::movable<int (&)()>);
 static_assert(!std::movable<int[5]>);
 
 // Core non-move assignable.
 static_assert(!std::movable<int const>);
 static_assert(!std::movable<int const volatile>);
 
 static_assert(!std::movable<DeletedMoveCtor>);
 static_assert(!std::movable<ImplicitlyDeletedMoveCtor>);
 static_assert(!std::movable<DeletedMoveAssign>);
 static_assert(!std::movable<ImplicitlyDeletedMoveAssign>);
 static_assert(!std::movable<NonMovable>);
 static_assert(!std::movable<DerivedFromNonMovable>);
 static_assert(!std::movable<HasANonMovable>);
 
 static_assert(std::movable<cpp03_friendly>);
 static_assert(std::movable<const_move_ctor>);
 static_assert(std::movable<volatile_move_ctor>);
 static_assert(std::movable<cv_move_ctor>);
 static_assert(std::movable<multi_param_move_ctor>);
 static_assert(!std::movable<not_quite_multi_param_move_ctor>);
 
 static_assert(!std::assignable_from<copy_assign_with_mutable_parameter&,
                                     copy_assign_with_mutable_parameter>);
 static_assert(!std::movable<copy_assign_with_mutable_parameter>);
 
 static_assert(!std::movable<const_move_assignment>);
 static_assert(std::movable<volatile_move_assignment>);
 static_assert(!std::movable<cv_move_assignment>);
 
 static_assert(!std::movable<const_move_assign_and_traditional_move_assign>);
 static_assert(!std::movable<volatile_move_assign_and_traditional_move_assign>);
 static_assert(!std::movable<cv_move_assign_and_traditional_move_assign>);
 static_assert(std::movable<const_move_assign_and_default_ops>);
 static_assert(std::movable<volatile_move_assign_and_default_ops>);
 static_assert(std::movable<cv_move_assign_and_default_ops>);
 
 static_assert(!std::movable<has_const_member>);
 static_assert(!std::movable<has_cv_member>);
 static_assert(!std::movable<has_lvalue_reference_member>);
 static_assert(!std::movable<has_rvalue_reference_member>);
 static_assert(!std::movable<has_function_ref_member>);
 
 static_assert(std::movable<deleted_assignment_from_const_rvalue>);
 
 // `move_constructible and assignable_from<T&, T>` implies `swappable<T>`,
 // so there's nothing to test for the case of non-swappable.
 
 int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.object/regular.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 regular = see below;
 
 #include <concepts>
 
 #include <deque>
 #include <forward_list>
 #include <list>
 #include <map>
 #include <memory>
 #include <optional>
 #include <stdexcept>
 #include <tuple>
 #include <unordered_map>
 #include <vector>
 
 #include "type_classification/moveconstructible.h"
 #include "type_classification/semiregular.h"
 
 static_assert(std::regular<int>);
 static_assert(std::regular<float>);
 static_assert(std::regular<double>);
 static_assert(std::regular<long double>);
 static_assert(std::regular<int volatile>);
 static_assert(std::regular<void*>);
 static_assert(std::regular<int*>);
 static_assert(std::regular<int const*>);
 static_assert(std::regular<int volatile*>);
 static_assert(std::regular<int volatile const*>);
 static_assert(std::regular<int (*)()>);
 
 struct S {};
 static_assert(!std::regular<S>);
 static_assert(std::regular<int S::*>);
 static_assert(std::regular<int (S::*)()>);
 static_assert(std::regular<int (S::*)() noexcept>);
 static_assert(std::regular<int (S::*)() &>);
 static_assert(std::regular<int (S::*)() & noexcept>);
 static_assert(std::regular<int (S::*)() &&>);
 static_assert(std::regular<int (S::*)() && noexcept>);
 static_assert(std::regular<int (S::*)() const>);
 static_assert(std::regular<int (S::*)() const noexcept>);
 static_assert(std::regular<int (S::*)() const&>);
 static_assert(std::regular<int (S::*)() const & noexcept>);
 static_assert(std::regular<int (S::*)() const&&>);
 static_assert(std::regular<int (S::*)() const && noexcept>);
 static_assert(std::regular<int (S::*)() volatile>);
 static_assert(std::regular<int (S::*)() volatile noexcept>);
 static_assert(std::regular<int (S::*)() volatile&>);
 static_assert(std::regular<int (S::*)() volatile & noexcept>);
 static_assert(std::regular<int (S::*)() volatile&&>);
 static_assert(std::regular<int (S::*)() volatile && noexcept>);
 static_assert(std::regular<int (S::*)() const volatile>);
 static_assert(std::regular<int (S::*)() const volatile noexcept>);
 static_assert(std::regular<int (S::*)() const volatile&>);
 static_assert(std::regular<int (S::*)() const volatile & noexcept>);
 static_assert(std::regular<int (S::*)() const volatile&&>);
 static_assert(std::regular<int (S::*)() const volatile && noexcept>);
 
 union U {};
 static_assert(!std::regular<U>);
 static_assert(std::regular<int U::*>);
 static_assert(std::regular<int (U::*)()>);
 static_assert(std::regular<int (U::*)() noexcept>);
 static_assert(std::regular<int (U::*)() &>);
 static_assert(std::regular<int (U::*)() & noexcept>);
 static_assert(std::regular<int (U::*)() &&>);
 static_assert(std::regular<int (U::*)() && noexcept>);
 static_assert(std::regular<int (U::*)() const>);
 static_assert(std::regular<int (U::*)() const noexcept>);
 static_assert(std::regular<int (U::*)() const&>);
 static_assert(std::regular<int (U::*)() const & noexcept>);
 static_assert(std::regular<int (U::*)() const&&>);
 static_assert(std::regular<int (U::*)() const && noexcept>);
 static_assert(std::regular<int (U::*)() volatile>);
 static_assert(std::regular<int (U::*)() volatile noexcept>);
 static_assert(std::regular<int (U::*)() volatile&>);
 static_assert(std::regular<int (U::*)() volatile & noexcept>);
 static_assert(std::regular<int (U::*)() volatile&&>);
 static_assert(std::regular<int (U::*)() volatile && noexcept>);
 static_assert(std::regular<int (U::*)() const volatile>);
 static_assert(std::regular<int (U::*)() const volatile noexcept>);
 static_assert(std::regular<int (U::*)() const volatile&>);
 static_assert(std::regular<int (U::*)() const volatile & noexcept>);
 static_assert(std::regular<int (U::*)() const volatile&&>);
 static_assert(std::regular<int (U::*)() const volatile && noexcept>);
 
 static_assert(std::regular<std::vector<int> >);
 static_assert(std::regular<std::deque<int> >);
 static_assert(std::regular<std::forward_list<int> >);
 static_assert(std::regular<std::list<int> >);
 static_assert(std::regular<std::shared_ptr<std::unique_ptr<int> > >);
 static_assert(std::regular<std::optional<std::vector<int> > >);
 static_assert(std::regular<std::vector<int> >);
 static_assert(std::regular<std::vector<std::unique_ptr<int> > >);
 static_assert(std::semiregular<std::in_place_t> &&
               !std::regular<std::in_place_t>);
 
 static_assert(!std::regular<has_volatile_member>);
 static_assert(!std::regular<has_array_member>);
 
 // Not objects
 static_assert(!std::regular<void>);
 static_assert(!std::regular<int&>);
 static_assert(!std::regular<int const&>);
 static_assert(!std::regular<int volatile&>);
 static_assert(!std::regular<int const volatile&>);
 static_assert(!std::regular<int&&>);
 static_assert(!std::regular<int const&&>);
 static_assert(!std::regular<int volatile&&>);
 static_assert(!std::regular<int const volatile&&>);
 static_assert(!std::regular<int()>);
 static_assert(!std::regular<int (&)()>);
 static_assert(!std::regular<int[5]>);
 
 // not copyable
 static_assert(!std::regular<std::unique_ptr<int> >);
 static_assert(!std::regular<int const>);
 static_assert(!std::regular<int const volatile>);
 static_assert(!std::regular<volatile_copy_assignment volatile>);
 static_assert(!std::regular<no_copy_constructor>);
 static_assert(!std::regular<no_copy_assignment>);
 static_assert(!std::regular<no_copy_assignment_mutable>);
 static_assert(!std::regular<derived_from_noncopyable>);
 static_assert(!std::regular<has_noncopyable>);
 static_assert(!std::regular<has_const_member>);
 static_assert(!std::regular<has_cv_member>);
 static_assert(!std::regular<has_lvalue_reference_member>);
 static_assert(!std::regular<has_rvalue_reference_member>);
 static_assert(!std::regular<has_function_ref_member>);
 static_assert(!std::regular<deleted_assignment_from_const_rvalue>);
 
 // not default_initializable
 static_assert(!std::regular<std::runtime_error>);
 static_assert(
     !std::regular<std::tuple<std::runtime_error, std::overflow_error> >);
 static_assert(!std::regular<std::nullopt_t>);
 static_assert(!std::regular<no_copy_constructor>);
 static_assert(!std::regular<no_copy_assignment>);
 static_assert(std::is_copy_assignable_v<no_copy_assignment_mutable> &&
               !std::regular<no_copy_assignment_mutable>);
 static_assert(!std::regular<derived_from_noncopyable>);
 static_assert(!std::regular<has_noncopyable>);
 
 static_assert(!std::regular<derived_from_non_default_initializable>);
 static_assert(!std::regular<has_non_default_initializable>);
 
 // not equality_comparable
 static_assert(!std::regular<const_copy_assignment const>);
 static_assert(!std::regular<cv_copy_assignment const volatile>);
 
 struct is_equality_comparable {
   [[nodiscard]] bool operator==(is_equality_comparable const&) const = default;
 };
 static_assert(std::regular<is_equality_comparable>);
 
 int main(int, char**) { return 0; }

libcxx/test/std/concepts/concepts.object/semiregular.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 semiregular = see below;
 
 #include <concepts>
 
 #include <deque>
 #include <forward_list>
 #include <list>
 #include <map>
 #include <memory>
 #include <optional>
 #include <stdexcept>
 #include <tuple>
 #include <unordered_map>
 #include <vector>
 
 #include "type_classification/semiregular.h"
 
 static_assert(std::semiregular<int>);
 static_assert(std::semiregular<int volatile>);
 static_assert(std::semiregular<int*>);
 static_assert(std::semiregular<int const*>);
 static_assert(std::semiregular<int volatile*>);
 static_assert(std::semiregular<int volatile const*>);
 static_assert(std::semiregular<int (*)()>);
 
 struct S {};
 static_assert(std::semiregular<S>);
 static_assert(std::semiregular<int S::*>);
 static_assert(std::semiregular<int (S::*)()>);
 static_assert(std::semiregular<int (S::*)() noexcept>);
 static_assert(std::semiregular<int (S::*)() &>);
 static_assert(std::semiregular<int (S::*)() & noexcept>);
 static_assert(std::semiregular<int (S::*)() &&>);
 static_assert(std::semiregular<int (S::*)() && noexcept>);
 static_assert(std::semiregular<int (S::*)() const>);
 static_assert(std::semiregular<int (S::*)() const noexcept>);
 static_assert(std::semiregular<int (S::*)() const&>);
 static_assert(std::semiregular<int (S::*)() const & noexcept>);
 static_assert(std::semiregular<int (S::*)() const&&>);
 static_assert(std::semiregular<int (S::*)() const && noexcept>);
 static_assert(std::semiregular<int (S::*)() volatile>);
 static_assert(std::semiregular<int (S::*)() volatile noexcept>);
 static_assert(std::semiregular<int (S::*)() volatile&>);
 static_assert(std::semiregular<int (S::*)() volatile & noexcept>);
 static_assert(std::semiregular<int (S::*)() volatile&&>);
 static_assert(std::semiregular<int (S::*)() volatile && noexcept>);
 static_assert(std::semiregular<int (S::*)() const volatile>);
 static_assert(std::semiregular<int (S::*)() const volatile noexcept>);
 static_assert(std::semiregular<int (S::*)() const volatile&>);
 static_assert(std::semiregular<int (S::*)() const volatile & noexcept>);
 static_assert(std::semiregular<int (S::*)() const volatile&&>);
 static_assert(std::semiregular<int (S::*)() const volatile && noexcept>);
 
 static_assert(std::semiregular<std::vector<int> >);
 static_assert(std::semiregular<std::deque<int> >);
 static_assert(std::semiregular<std::forward_list<int> >);
 static_assert(std::semiregular<std::list<int> >);
 static_assert(std::semiregular<std::shared_ptr<std::unique_ptr<int> > >);
 static_assert(std::semiregular<std::optional<std::vector<int> > >);
 static_assert(std::semiregular<std::vector<int> >);
 static_assert(std::semiregular<std::vector<std::unique_ptr<int> > >);
 
 static_assert(std::semiregular<has_volatile_member>);
 static_assert(std::semiregular<has_array_member>);
 
 // Not objects
 static_assert(!std::semiregular<void>);
 static_assert(!std::semiregular<int&>);
 static_assert(!std::semiregular<int const&>);
 static_assert(!std::semiregular<int volatile&>);
 static_assert(!std::semiregular<int const volatile&>);
 static_assert(!std::semiregular<int&&>);
 static_assert(!std::semiregular<int const&&>);
 static_assert(!std::semiregular<int volatile&&>);
 static_assert(!std::semiregular<int const volatile&&>);
 static_assert(!std::semiregular<int()>);
 static_assert(!std::semiregular<int (&)()>);
 static_assert(!std::semiregular<int[5]>);
 
 // Not copyable
 static_assert(!std::semiregular<std::unique_ptr<int> >);
 static_assert(!std::semiregular<int const>);
 static_assert(!std::semiregular<int const volatile>);
 static_assert(std::semiregular<const_copy_assignment const>);
 static_assert(!std::semiregular<volatile_copy_assignment volatile>);
 static_assert(std::semiregular<cv_copy_assignment const volatile>);
 static_assert(!std::semiregular<no_copy_constructor>);
 static_assert(!std::semiregular<no_copy_assignment>);
 static_assert(!std::semiregular<no_copy_assignment_mutable>);
 static_assert(!std::semiregular<derived_from_noncopyable>);
 static_assert(!std::semiregular<has_noncopyable>);
 static_assert(!std::semiregular<has_const_member>);
 static_assert(!std::semiregular<has_cv_member>);
 static_assert(!std::semiregular<has_lvalue_reference_member>);
 static_assert(!std::semiregular<has_rvalue_reference_member>);
 static_assert(!std::semiregular<has_function_ref_member>);
 static_assert(!std::semiregular<deleted_assignment_from_const_rvalue>);
 
 // Not default_initialzable
 static_assert(!std::semiregular<std::runtime_error>);
 static_assert(
     !std::semiregular<std::tuple<std::runtime_error, std::overflow_error> >);
 static_assert(!std::semiregular<std::nullopt_t>);
 static_assert(!std::semiregular<no_copy_constructor>);
 static_assert(!std::semiregular<no_copy_assignment>);
 static_assert(std::is_copy_assignable_v<no_copy_assignment_mutable>);
 static_assert(!std::semiregular<no_copy_assignment_mutable>);
 static_assert(!std::semiregular<derived_from_noncopyable>);
 static_assert(!std::semiregular<has_noncopyable>);
 
 static_assert(!std::semiregular<no_default_ctor>);
 static_assert(!std::semiregular<derived_from_non_default_initializable>);
 static_assert(!std::semiregular<has_non_default_initializable>);
 
 static_assert(!std::semiregular<deleted_default_ctor>);
 static_assert(!std::semiregular<derived_from_deleted_default_ctor>);
 static_assert(!std::semiregular<has_deleted_default_ctor>);
 
 int main(int, char**) { return 0; }

libcxx/test/std/concepts/lang/arithmetic.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 integral = // see below
-
-// template<class T>
-// concept signed_integral = // see below
-
-// template<class T>
-// concept unsigned_integral = // see below
-
-// template<class T>
-// concept floating_point = // see below
-
-#include <concepts>
-#include <type_traits>
-
-namespace {
-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);
-
-  static_assert(!std::integral<T&>);
-  static_assert(!std::integral<const T&>);
-  static_assert(!std::integral<volatile T&>);
-  static_assert(!std::integral<const volatile T&>);
-
-  static_assert(!std::integral<T&&>);
-  static_assert(!std::integral<const T&&>);
-  static_assert(!std::integral<volatile T&&>);
-  static_assert(!std::integral<const volatile T&&>);
-
-  static_assert(!std::integral<T*>);
-  static_assert(!std::integral<const T*>);
-  static_assert(!std::integral<volatile T*>);
-  static_assert(!std::integral<const volatile T*>);
-
-  static_assert(!std::integral<T (*)()>);
-  static_assert(!std::integral<T (&)()>);
-  static_assert(!std::integral<T(&&)()>);
-
-  return result;
-}
-
-enum ClassicEnum { a, b, c };
-enum class ScopedEnum { x, y, z };
-struct EmptyStruct {};
-
-constexpr void CheckIntegral() {
-  // standard signed and unsigned integers
-  static_assert(CheckIntegralQualifiers<signed char>());
-  static_assert(CheckIntegralQualifiers<unsigned char>());
-  static_assert(CheckIntegralQualifiers<short>());
-  static_assert(CheckIntegralQualifiers<unsigned short>());
-  static_assert(CheckIntegralQualifiers<int>());
-  static_assert(CheckIntegralQualifiers<unsigned int>());
-  static_assert(CheckIntegralQualifiers<long>());
-  static_assert(CheckIntegralQualifiers<unsigned long>());
-  static_assert(CheckIntegralQualifiers<long long>());
-  static_assert(CheckIntegralQualifiers<unsigned long long>());
-
-  // extended integers
-#ifndef _LIBCPP_HAS_NO_INT128
-  static_assert(CheckIntegralQualifiers<__int128_t>());
-  static_assert(CheckIntegralQualifiers<__uint128_t>());
-#endif
-
-  // bool and char types are also integral
-  static_assert(CheckIntegralQualifiers<wchar_t>());
-  static_assert(CheckIntegralQualifiers<bool>());
-  static_assert(CheckIntegralQualifiers<char>());
-  static_assert(CheckIntegralQualifiers<char8_t>());
-  static_assert(CheckIntegralQualifiers<char16_t>());
-  static_assert(CheckIntegralQualifiers<char32_t>());
-
-  // types that aren't integral
-  static_assert(!std::integral<void>);
-  static_assert(!CheckIntegralQualifiers<float>());
-  static_assert(!CheckIntegralQualifiers<double>());
-  static_assert(!CheckIntegralQualifiers<long double>());
-
-  static_assert(!CheckIntegralQualifiers<ClassicEnum>());
-
-  static_assert(!CheckIntegralQualifiers<ScopedEnum>());
-
-  static_assert(!CheckIntegralQualifiers<EmptyStruct>());
-  static_assert(!CheckIntegralQualifiers<int EmptyStruct::*>());
-  static_assert(!CheckIntegralQualifiers<int (EmptyStruct::*)()>());
-}
-
-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);
-
-  static_assert(!std::signed_integral<T&>);
-  static_assert(!std::signed_integral<const T&>);
-  static_assert(!std::signed_integral<volatile T&>);
-  static_assert(!std::signed_integral<const volatile T&>);
-
-  static_assert(!std::signed_integral<T&&>);
-  static_assert(!std::signed_integral<const T&&>);
-  static_assert(!std::signed_integral<volatile T&&>);
-  static_assert(!std::signed_integral<const volatile T&&>);
-
-  static_assert(!std::signed_integral<T*>);
-  static_assert(!std::signed_integral<const T*>);
-  static_assert(!std::signed_integral<volatile T*>);
-  static_assert(!std::signed_integral<const volatile T*>);
-
-  static_assert(!std::signed_integral<T (*)()>);
-  static_assert(!std::signed_integral<T (&)()>);
-  static_assert(!std::signed_integral<T(&&)()>);
-
-  return result;
-}
-
-constexpr void CheckSignedIntegral() {
-  // standard signed integers
-  static_assert(CheckSignedIntegralQualifiers<signed char>());
-  static_assert(CheckSignedIntegralQualifiers<short>());
-  static_assert(CheckSignedIntegralQualifiers<int>());
-  static_assert(CheckSignedIntegralQualifiers<long>());
-  static_assert(CheckSignedIntegralQualifiers<long long>());
-
-  // bool and character *may* be signed
-  static_assert(CheckSignedIntegralQualifiers<wchar_t>() ==
-                std::is_signed_v<wchar_t>);
-  static_assert(CheckSignedIntegralQualifiers<bool>() ==
-                std::is_signed_v<bool>);
-  static_assert(CheckSignedIntegralQualifiers<char>() ==
-                std::is_signed_v<char>);
-  static_assert(CheckSignedIntegralQualifiers<char8_t>() ==
-                std::is_signed_v<char8_t>);
-  static_assert(CheckSignedIntegralQualifiers<char16_t>() ==
-                std::is_signed_v<char16_t>);
-  static_assert(CheckSignedIntegralQualifiers<char32_t>() ==
-                std::is_signed_v<char32_t>);
-
-  // integers that aren't signed integrals
-  static_assert(!CheckSignedIntegralQualifiers<unsigned char>());
-  static_assert(!CheckSignedIntegralQualifiers<unsigned short>());
-  static_assert(!CheckSignedIntegralQualifiers<unsigned int>());
-  static_assert(!CheckSignedIntegralQualifiers<unsigned long>());
-  static_assert(!CheckSignedIntegralQualifiers<unsigned long long>());
-
-  // extended integers
-#ifndef _LIBCPP_HAS_NO_INT128
-  static_assert(CheckSignedIntegralQualifiers<__int128_t>());
-  static_assert(!CheckSignedIntegralQualifiers<__uint128_t>());
-#endif
-
-  // types that aren't even integers shouldn't be signed integers!
-  static_assert(!std::signed_integral<void>);
-  static_assert(!CheckSignedIntegralQualifiers<float>());
-  static_assert(!CheckSignedIntegralQualifiers<double>());
-  static_assert(!CheckSignedIntegralQualifiers<long double>());
-
-  static_assert(!CheckSignedIntegralQualifiers<ClassicEnum>());
-  static_assert(!CheckSignedIntegralQualifiers<ScopedEnum>());
-  static_assert(!CheckSignedIntegralQualifiers<EmptyStruct>());
-  static_assert(!CheckSignedIntegralQualifiers<int EmptyStruct::*>());
-  static_assert(!CheckSignedIntegralQualifiers<int (EmptyStruct::*)()>());
-}
-
-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);
-
-  static_assert(!std::unsigned_integral<T&>);
-  static_assert(!std::unsigned_integral<const T&>);
-  static_assert(!std::unsigned_integral<volatile T&>);
-  static_assert(!std::unsigned_integral<const volatile T&>);
-
-  static_assert(!std::unsigned_integral<T&&>);
-  static_assert(!std::unsigned_integral<const T&&>);
-  static_assert(!std::unsigned_integral<volatile T&&>);
-  static_assert(!std::unsigned_integral<const volatile T&&>);
-
-  static_assert(!std::unsigned_integral<T*>);
-  static_assert(!std::unsigned_integral<const T*>);
-  static_assert(!std::unsigned_integral<volatile T*>);
-  static_assert(!std::unsigned_integral<const volatile T*>);
-
-  static_assert(!std::unsigned_integral<T (*)()>);
-  static_assert(!std::unsigned_integral<T (&)()>);
-  static_assert(!std::unsigned_integral<T(&&)()>);
-
-  return result;
-}
-
-constexpr void CheckUnsignedIntegral() {
-  // standard unsigned types
-  static_assert(CheckUnsignedIntegralQualifiers<unsigned char>());
-  static_assert(CheckUnsignedIntegralQualifiers<unsigned short>());
-  static_assert(CheckUnsignedIntegralQualifiers<unsigned int>());
-  static_assert(CheckUnsignedIntegralQualifiers<unsigned long>());
-  static_assert(CheckUnsignedIntegralQualifiers<unsigned long long>());
-
-  // Whether bool and character types are signed or unsigned is impl-defined
-  static_assert(CheckUnsignedIntegralQualifiers<wchar_t>() ==
-                !std::is_signed_v<wchar_t>);
-  static_assert(CheckUnsignedIntegralQualifiers<bool>() ==
-                !std::is_signed_v<bool>);
-  static_assert(CheckUnsignedIntegralQualifiers<char>() ==
-                !std::is_signed_v<char>);
-  static_assert(CheckUnsignedIntegralQualifiers<char8_t>() ==
-                !std::is_signed_v<char8_t>);
-  static_assert(CheckUnsignedIntegralQualifiers<char16_t>() ==
-                !std::is_signed_v<char16_t>);
-  static_assert(CheckUnsignedIntegralQualifiers<char32_t>() ==
-                !std::is_signed_v<char32_t>);
-
-  // extended integers
-#ifndef _LIBCPP_HAS_NO_INT128
-  static_assert(CheckUnsignedIntegralQualifiers<__uint128_t>());
-  static_assert(!CheckUnsignedIntegralQualifiers<__int128_t>());
-#endif
-
-  // integer types that aren't unsigned integrals
-  static_assert(!CheckUnsignedIntegralQualifiers<signed char>());
-  static_assert(!CheckUnsignedIntegralQualifiers<short>());
-  static_assert(!CheckUnsignedIntegralQualifiers<int>());
-  static_assert(!CheckUnsignedIntegralQualifiers<long>());
-  static_assert(!CheckUnsignedIntegralQualifiers<long long>());
-
-  static_assert(!std::unsigned_integral<void>);
-  static_assert(!CheckUnsignedIntegralQualifiers<float>());
-  static_assert(!CheckUnsignedIntegralQualifiers<double>());
-  static_assert(!CheckUnsignedIntegralQualifiers<long double>());
-
-  static_assert(!CheckUnsignedIntegralQualifiers<ClassicEnum>());
-  static_assert(!CheckUnsignedIntegralQualifiers<ScopedEnum>());
-  static_assert(!CheckUnsignedIntegralQualifiers<EmptyStruct>());
-  static_assert(!CheckUnsignedIntegralQualifiers<int EmptyStruct::*>());
-  static_assert(!CheckUnsignedIntegralQualifiers<int (EmptyStruct::*)()>());
-}
-
-// This overload should never be called. It exists solely to force subsumption.
-template <std::integral I>
-[[nodiscard]] constexpr bool CheckSubsumption(I) {
-  return false;
-}
-
-// clang-format off
-template <std::integral I>
-requires std::signed_integral<I> && (!std::unsigned_integral<I>)
-[[nodiscard]] constexpr bool CheckSubsumption(I) {
-  return std::is_signed_v<I>;
-}
-
-template <std::integral I>
-requires std::unsigned_integral<I> && (!std::signed_integral<I>)
-[[nodiscard]] constexpr bool CheckSubsumption(I) {
-  return std::is_unsigned_v<I>;
-}
-// clang-format on
-
-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);
-
-  static_assert(!std::floating_point<T&>);
-  static_assert(!std::floating_point<const T&>);
-  static_assert(!std::floating_point<volatile T&>);
-  static_assert(!std::floating_point<const volatile T&>);
-
-  static_assert(!std::floating_point<T&&>);
-  static_assert(!std::floating_point<const T&&>);
-  static_assert(!std::floating_point<volatile T&&>);
-  static_assert(!std::floating_point<const volatile T&&>);
-
-  static_assert(!std::floating_point<T*>);
-  static_assert(!std::floating_point<const T*>);
-  static_assert(!std::floating_point<volatile T*>);
-  static_assert(!std::floating_point<const volatile T*>);
-
-  static_assert(!std::floating_point<T (*)()>);
-  static_assert(!std::floating_point<T (&)()>);
-  static_assert(!std::floating_point<T(&&)()>);
-
-  return result;
-}
-
-constexpr void CheckFloatingPoint() {
-  // floating-point types
-  static_assert(CheckFloatingPointQualifiers<float>());
-  static_assert(CheckFloatingPointQualifiers<double>());
-  static_assert(CheckFloatingPointQualifiers<long double>());
-
-  // types that aren't floating-point
-  static_assert(!CheckFloatingPointQualifiers<signed char>());
-  static_assert(!CheckFloatingPointQualifiers<unsigned char>());
-  static_assert(!CheckFloatingPointQualifiers<short>());
-  static_assert(!CheckFloatingPointQualifiers<unsigned short>());
-  static_assert(!CheckFloatingPointQualifiers<int>());
-  static_assert(!CheckFloatingPointQualifiers<unsigned int>());
-  static_assert(!CheckFloatingPointQualifiers<long>());
-  static_assert(!CheckFloatingPointQualifiers<unsigned long>());
-  static_assert(!CheckFloatingPointQualifiers<long long>());
-  static_assert(!CheckFloatingPointQualifiers<unsigned long long>());
-  static_assert(!CheckFloatingPointQualifiers<wchar_t>());
-  static_assert(!CheckFloatingPointQualifiers<bool>());
-  static_assert(!CheckFloatingPointQualifiers<char>());
-  static_assert(!CheckFloatingPointQualifiers<char8_t>());
-  static_assert(!CheckFloatingPointQualifiers<char16_t>());
-  static_assert(!CheckFloatingPointQualifiers<char32_t>());
-  static_assert(!std::floating_point<void>);
-
-  static_assert(!CheckFloatingPointQualifiers<ClassicEnum>());
-  static_assert(!CheckFloatingPointQualifiers<ScopedEnum>());
-  static_assert(!CheckFloatingPointQualifiers<EmptyStruct>());
-  static_assert(!CheckFloatingPointQualifiers<int EmptyStruct::*>());
-  static_assert(!CheckFloatingPointQualifiers<int (EmptyStruct::*)()>());
-}
-} // namespace
-
-int main(int, char**) {
-  CheckIntegral();
-  CheckSignedIntegral();
-  CheckUnsignedIntegral();
-  static_assert(CheckSubsumption(0));
-  static_assert(CheckSubsumption(0U));
-  CheckFloatingPoint();
-  return 0;
-}