1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9// UNSUPPORTED: c++03, c++11, c++14, c++17
10
11// template<class T, class U, class Cat = partial_ordering>
12// concept three_way_comparable_with = // see below
13
14#include <compare>
15
16#include "compare_types.h"
17
18template <class T, class U = T, typename Cat = std::partial_ordering>
19constexpr bool check_three_way_comparable_with() {
20 constexpr bool result = std::three_way_comparable_with<T, U, Cat>;
21 static_assert(std::three_way_comparable_with<U, T, Cat> == result);
22 static_assert(std::three_way_comparable_with<T, U const, Cat> == result);
23 static_assert(std::three_way_comparable_with<T const, U const, Cat> == result);
24 static_assert(std::three_way_comparable_with<T, U const&, Cat> == result);
25 static_assert(std::three_way_comparable_with<T const, U const&, Cat> == result);
26 static_assert(std::three_way_comparable_with<T, U const&&, Cat> == result);
27 static_assert(std::three_way_comparable_with<T const, U const&&, Cat> == result);
28 if constexpr (!std::is_void_v<T>) {
29 static_assert(std::three_way_comparable_with<T&, U const, Cat> == result);
30 static_assert(std::three_way_comparable_with<T const&, U const, Cat> == result);
31 static_assert(std::three_way_comparable_with<T&, U const&, Cat> == result);
32 static_assert(std::three_way_comparable_with<T const&, U const&, Cat> == result);
33 static_assert(std::three_way_comparable_with<T&, U const&&, Cat> == result);
34 static_assert(std::three_way_comparable_with<T const&, U const&&, Cat> == result);
35 static_assert(std::three_way_comparable_with<T&&, U const, Cat> == result);
36 static_assert(std::three_way_comparable_with<T const&&, U const, Cat> == result);
37 static_assert(std::three_way_comparable_with<T&&, U const&, Cat> == result);
38 static_assert(std::three_way_comparable_with<T const&&, U const&, Cat> == result);
39 static_assert(std::three_way_comparable_with<T&&, U const&&, Cat> == result);
40 static_assert(std::three_way_comparable_with<T const&&, U const&&, Cat> == result);
41 }
42 return result;
43}
44
45namespace fundamentals {
46static_assert(check_three_way_comparable_with<int, int>());
47static_assert(check_three_way_comparable_with<int, char>());
48static_assert(!check_three_way_comparable_with<int, unsigned int>());
49static_assert(check_three_way_comparable_with<int, double>());
50static_assert(check_three_way_comparable_with<int*, int*>());
51
52static_assert(check_three_way_comparable_with<int, int, std::strong_ordering>());
53static_assert(check_three_way_comparable_with<int, char, std::strong_ordering>());
54static_assert(check_three_way_comparable_with<int, short, std::strong_ordering>());
55
56static_assert(check_three_way_comparable_with<int, int, std::weak_ordering>());
57static_assert(check_three_way_comparable_with<int, char, std::weak_ordering>());
58static_assert(!check_three_way_comparable_with<int, unsigned int, std::weak_ordering>());
59
60static_assert(!check_three_way_comparable_with<int, bool>());
61static_assert(!check_three_way_comparable_with<int, int*>());
62static_assert(!check_three_way_comparable_with<int, int[5]>());
63static_assert(!check_three_way_comparable_with<int, int (*)()>());
64static_assert(!check_three_way_comparable_with<int, int (&)()>());
65struct S {};
66static_assert(!check_three_way_comparable_with<int, int S::*>());
67static_assert(!check_three_way_comparable_with<int, int (S::*)()>());
68static_assert(!check_three_way_comparable_with<int, int (S::*)() noexcept>());
69static_assert(!check_three_way_comparable_with<int, int (S::*)() const>());
70static_assert(!check_three_way_comparable_with<int, int (S::*)() const noexcept>());
71static_assert(!check_three_way_comparable_with<int, int (S::*)() volatile>());
72static_assert(!check_three_way_comparable_with<int, int (S::*)() volatile noexcept>());
73static_assert(!check_three_way_comparable_with<int, int (S::*)() const volatile>());
74static_assert(!check_three_way_comparable_with<int, int (S::*)() const volatile noexcept>());
75static_assert(!check_three_way_comparable_with<int, int (S::*)() &>());
76static_assert(!check_three_way_comparable_with<int, int (S::*)() & noexcept>());
77static_assert(!check_three_way_comparable_with<int, int (S::*)() const&>());
78static_assert(!check_three_way_comparable_with<int, int (S::*)() const & noexcept>());
79static_assert(!check_three_way_comparable_with<int, int (S::*)() volatile&>());
80static_assert(!check_three_way_comparable_with<int, int (S::*)() volatile & noexcept>());
81static_assert(!check_three_way_comparable_with<int, int (S::*)() const volatile&>());
82static_assert(!check_three_way_comparable_with<int, int (S::*)() const volatile & noexcept>());
83static_assert(!check_three_way_comparable_with<int, int (S::*)() &&>());
84static_assert(!check_three_way_comparable_with<int, int (S::*)() && noexcept>());
85static_assert(!check_three_way_comparable_with<int, int (S::*)() const&&>());
86static_assert(!check_three_way_comparable_with<int, int (S::*)() const&& noexcept>());
87static_assert(!check_three_way_comparable_with<int, int (S::*)() volatile&&>());
88static_assert(!check_three_way_comparable_with<int, int (S::*)() volatile&& noexcept>());
89static_assert(!check_three_way_comparable_with<int, int (S::*)() const volatile&&>());
90static_assert(!check_three_way_comparable_with<int, int (S::*)() const volatile&& noexcept>());
91static_assert(!check_three_way_comparable_with<int*, int[5]>());
92static_assert(!check_three_way_comparable_with<int[5], int[5]>());
93static_assert(!check_three_way_comparable_with<std::nullptr_t, int>());
94static_assert(!check_three_way_comparable_with<std::nullptr_t, int*>());
95static_assert(!check_three_way_comparable_with<std::nullptr_t, int[5]>());
96static_assert(!check_three_way_comparable_with<std::nullptr_t, int (*)()>());
97static_assert(!check_three_way_comparable_with<std::nullptr_t, int (&)()>());
98static_assert(!check_three_way_comparable_with<std::nullptr_t, int (S::*)()>());
99static_assert(!check_three_way_comparable_with<void, int>());
100static_assert(!check_three_way_comparable_with<void, int*>());
101static_assert(!check_three_way_comparable_with<void, std::nullptr_t>());
102static_assert(!check_three_way_comparable_with<void, int[5]>());
103static_assert(!check_three_way_comparable_with<void, int (*)()>());
104static_assert(!check_three_way_comparable_with<void, int (&)()>());
105static_assert(!check_three_way_comparable_with<void, int S::*>());
106static_assert(!check_three_way_comparable_with<void, int (S::*)()>());
107} // namespace fundamentals
108
109namespace user_defined {
110struct S {
111 bool operator==(int) const;
112 std::strong_ordering operator<=>(int) const;
113 operator int() const;
114
115 bool operator==(const S&) const = default;
116 auto operator<=>(const S&) const = default;
117};
118
119static_assert(check_three_way_comparable_with<S, int>());
120static_assert(check_three_way_comparable_with<S, int, std::strong_ordering>());
121static_assert(check_three_way_comparable_with<S, int, std::weak_ordering>());
122
123struct SpaceshipNotDeclared {
124};
125
126static_assert(!check_three_way_comparable_with<SpaceshipNotDeclared>());
127
128struct SpaceshipDeleted {
129 auto operator<=>(const SpaceshipDeleted&) const = delete;
130};
131
132static_assert(!check_three_way_comparable_with<SpaceshipDeleted>());
133
134struct SpaceshipWithoutEqualityOperator {
135 auto operator<=>(const SpaceshipWithoutEqualityOperator&) const;
136};
137
138static_assert(!check_three_way_comparable_with<SpaceshipWithoutEqualityOperator>());
139
140struct EqualityOperatorDeleted {
141 bool operator==(const EqualityOperatorDeleted&) const = delete;
142};
143
144static_assert(!check_three_way_comparable_with<EqualityOperatorDeleted>());
145
146struct EqualityOperatorOnly {
147 bool operator==(const EqualityOperatorOnly&) const = default;
148};
149
150static_assert(!check_three_way_comparable_with<EqualityOperatorOnly>());
151
152struct SpaceshipDeclaredEqualityOperatorDeleted {
153 bool operator==(const SpaceshipDeclaredEqualityOperatorDeleted&) const = delete;
154 auto operator<=>(const SpaceshipDeclaredEqualityOperatorDeleted&) const = default;
155};
156
157static_assert(!check_three_way_comparable_with<SpaceshipDeclaredEqualityOperatorDeleted>());
158
159struct AllInequalityOperators {
160 bool operator<(const AllInequalityOperators&) const;
161 bool operator<=(const AllInequalityOperators&) const;
162 bool operator>(const AllInequalityOperators&) const;
163 bool operator>=(const AllInequalityOperators&) const;
164 bool operator!=(const AllInequalityOperators&) const;
165};
166
167static_assert(!check_three_way_comparable_with<AllInequalityOperators>());
168
169struct AllComparisonOperators {
170 bool operator<(const AllComparisonOperators&) const;
171 bool operator<=(const AllComparisonOperators&) const;
172 bool operator>(const AllComparisonOperators&) const;
173 bool operator>=(const AllComparisonOperators&) const;
174 bool operator!=(const AllComparisonOperators&) const;
175 bool operator==(const AllComparisonOperators&) const;
176};
177
178static_assert(!check_three_way_comparable_with<AllComparisonOperators>());
179
180struct AllButOneInequalityOperators {
181 bool operator<(const AllButOneInequalityOperators&) const;
182 bool operator<=(const AllButOneInequalityOperators&) const;
183 bool operator>(const AllButOneInequalityOperators&) const;
184 bool operator!=(const AllButOneInequalityOperators&) const;
185};
186
187static_assert(!check_three_way_comparable_with<AllButOneInequalityOperators>());
188
189struct AllInequalityOperatorsOneDeleted {
190 bool operator<(const AllInequalityOperatorsOneDeleted&) const;
191 bool operator<=(const AllInequalityOperatorsOneDeleted&) const;
192 bool operator>(const AllInequalityOperatorsOneDeleted&) const;
193 bool operator>=(const AllInequalityOperatorsOneDeleted&) const = delete;
194 bool operator!=(const AllInequalityOperatorsOneDeleted&) const;
195};
196
197static_assert(!check_three_way_comparable_with<AllInequalityOperatorsOneDeleted>());
198
199struct EqualityOperatorWrongReturnType {
200 int operator==(const EqualityOperatorWrongReturnType&);
201 auto operator<=>(const EqualityOperatorWrongReturnType&) const = default;
202};
203
204static_assert(!check_three_way_comparable_with<EqualityOperatorWrongReturnType>());
205
206struct SpaceshipWrongReturnType {
207 bool operator==(const SpaceshipWrongReturnType&) const = default;
208 int operator<=>(const SpaceshipWrongReturnType&);
209};
210
211static_assert(!check_three_way_comparable_with<SpaceshipWrongReturnType>());
212
213struct EqualityOperatorNonConstArgument {
214 bool operator==(EqualityOperatorNonConstArgument&);
215 auto operator<=>(const EqualityOperatorNonConstArgument&) const = default;
216};
217
218static_assert(!check_three_way_comparable_with<EqualityOperatorNonConstArgument>());
219
220struct SpaceshipNonConstArgument {
221 bool operator==(const SpaceshipNonConstArgument&) const = default;
222 auto operator<=>(SpaceshipNonConstArgument&);
223};
224
225static_assert(!check_three_way_comparable_with<SpaceshipNonConstArgument>());
226} // namespace user_defined
227

source code of libcxx/test/std/language.support/cmp/cmp.concept/three_way_comparable_with.compile.pass.cpp