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 // <compare>
12
13 // template<class T> constexpr weak_ordering weak_order(const T& a, const T& b);
14
15 #include <compare>
16
17 #include <cassert>
18 #include <cmath>
19 #include <iterator> // std::size
20 #include <limits>
21 #include <type_traits>
22 #include <utility>
23
24 #include "test_macros.h"
25
26 template<class T, class U>
has_weak_order(T && t,U && u)27 constexpr auto has_weak_order(T&& t, U&& u)
28 -> decltype(std::weak_order(static_cast<T&&>(t), static_cast<U&&>(u)), true)
29 {
30 return true;
31 }
32
has_weak_order(...)33 constexpr bool has_weak_order(...) {
34 return false;
35 }
36
37 namespace N11 {
38 struct A {};
39 struct B {};
weak_order(const A &,const A &)40 std::strong_ordering weak_order(const A&, const A&) { return std::strong_ordering::less; }
41 std::strong_ordering weak_order(const A&, const B&);
42 }
43
test_1_1()44 void test_1_1()
45 {
46 // If the decayed types of E and F differ, weak_order(E, F) is ill-formed.
47
48 static_assert( has_weak_order(1, 2));
49 static_assert(!has_weak_order(1, (short)2));
50 static_assert(!has_weak_order(1, 2.0));
51 static_assert(!has_weak_order(1.0f, 2.0));
52
53 static_assert( has_weak_order((int*)nullptr, (int*)nullptr));
54 static_assert(!has_weak_order((int*)nullptr, (const int*)nullptr));
55 static_assert(!has_weak_order((const int*)nullptr, (int*)nullptr));
56 static_assert( has_weak_order((const int*)nullptr, (const int*)nullptr));
57
58 N11::A a;
59 N11::B b;
60 static_assert( has_weak_order(a, a));
61 static_assert(!has_weak_order(a, b));
62 }
63
64 namespace N12 {
65 struct A {};
weak_order(A &,A &&)66 std::strong_ordering weak_order(A&, A&&) { return std::strong_ordering::less; }
weak_order(A &&,A &&)67 std::strong_ordering weak_order(A&&, A&&) { return std::strong_ordering::equal; }
68 std::strong_ordering weak_order(const A&, const A&);
69
70 struct B {
71 friend std::partial_ordering weak_order(B&, B&);
72 };
73
74 struct WeakOrder {
operator std::weak_orderingN12::WeakOrder75 explicit operator std::weak_ordering() const { return std::weak_ordering::less; }
76 };
77 struct C {
78 bool touched = false;
weak_order(C & lhs,C &)79 friend WeakOrder weak_order(C& lhs, C&) { lhs.touched = true; return WeakOrder(); }
80 };
81 }
82
test_1_2()83 void test_1_2()
84 {
85 // Otherwise, weak_ordering(weak_order(E, F))
86 // if it is a well-formed expression with overload resolution performed
87 // in a context that does not include a declaration of std::weak_order.
88
89 // Test that weak_order does not const-qualify the forwarded arguments.
90 N12::A a;
91 assert(std::weak_order(a, std::move(a)) == std::weak_ordering::less);
92 assert(std::weak_order(std::move(a), std::move(a)) == std::weak_ordering::equivalent);
93
94 // The type of weak_order(e,f) must be explicitly convertible to weak_ordering.
95 N12::B b;
96 static_assert(!has_weak_order(b, b));
97
98 N12::C c1, c2;
99 ASSERT_SAME_TYPE(decltype(std::weak_order(c1, c2)), std::weak_ordering);
100 assert(std::weak_order(c1, c2) == std::weak_ordering::less);
101 assert(c1.touched);
102 assert(!c2.touched);
103 }
104
105 template<class F>
test_1_3()106 constexpr bool test_1_3()
107 {
108 // Otherwise, if the decayed type T of E is a floating-point type,
109 // yields a value of type weak_ordering that is consistent with
110 // the ordering observed by T's comparison operators and strong_order,
111 // and if numeric_limits<T>::is_iec559 is true, is additionally consistent with
112 // the following equivalence classes...
113
114 // std::numeric_limits<F>::is_iec559 is usually true.
115 // It is false for F=long double on AIX; but this test is still expected
116 // to pass (e.g. std::weak_order(+0, -0) == weak_ordering::equivalent,
117 // even on AIX).
118
119 ASSERT_SAME_TYPE(decltype(std::weak_order(F(0), F(0))), std::weak_ordering);
120
121 F v[] = {
122 -std::numeric_limits<F>::infinity(),
123 std::numeric_limits<F>::lowest(), // largest (finite) negative number
124 F(-1.0), F(-0.1),
125 -std::numeric_limits<F>::min(), // smallest (normal) negative number
126 F(-0.0), // negative zero
127 F(0.0),
128 std::numeric_limits<F>::min(), // smallest (normal) positive number
129 F(0.1), F(1.0), F(2.0), F(3.14),
130 std::numeric_limits<F>::max(), // largest (finite) positive number
131 std::numeric_limits<F>::infinity(),
132 };
133
134 static_assert(std::size(v) == 14);
135
136 // Sanity-check that array 'v' is indeed in the right order.
137 for (int i=0; i < 14; ++i) {
138 for (int j=0; j < 14; ++j) {
139 auto naturalOrder = (v[i] <=> v[j]);
140 if (v[i] == 0 && v[j] == 0) {
141 assert(naturalOrder == std::partial_ordering::equivalent);
142 } else {
143 assert(naturalOrder == std::partial_ordering::unordered || naturalOrder == (i <=> j));
144 }
145 }
146 }
147
148 assert(std::weak_order(v[0], v[0]) == std::weak_ordering::equivalent);
149 assert(std::weak_order(v[0], v[1]) == std::weak_ordering::less);
150 assert(std::weak_order(v[0], v[2]) == std::weak_ordering::less);
151 assert(std::weak_order(v[0], v[3]) == std::weak_ordering::less);
152 assert(std::weak_order(v[0], v[4]) == std::weak_ordering::less);
153 assert(std::weak_order(v[0], v[5]) == std::weak_ordering::less);
154 assert(std::weak_order(v[0], v[6]) == std::weak_ordering::less);
155 assert(std::weak_order(v[0], v[7]) == std::weak_ordering::less);
156 assert(std::weak_order(v[0], v[8]) == std::weak_ordering::less);
157 assert(std::weak_order(v[0], v[9]) == std::weak_ordering::less);
158 assert(std::weak_order(v[0], v[10]) == std::weak_ordering::less);
159 assert(std::weak_order(v[0], v[11]) == std::weak_ordering::less);
160 assert(std::weak_order(v[0], v[12]) == std::weak_ordering::less);
161 assert(std::weak_order(v[0], v[13]) == std::weak_ordering::less);
162 assert(std::weak_order(v[1], v[0]) == std::weak_ordering::greater);
163 assert(std::weak_order(v[1], v[1]) == std::weak_ordering::equivalent);
164 assert(std::weak_order(v[1], v[2]) == std::weak_ordering::less);
165 assert(std::weak_order(v[1], v[3]) == std::weak_ordering::less);
166 assert(std::weak_order(v[1], v[4]) == std::weak_ordering::less);
167 assert(std::weak_order(v[1], v[5]) == std::weak_ordering::less);
168 assert(std::weak_order(v[1], v[6]) == std::weak_ordering::less);
169 assert(std::weak_order(v[1], v[7]) == std::weak_ordering::less);
170 assert(std::weak_order(v[1], v[8]) == std::weak_ordering::less);
171 assert(std::weak_order(v[1], v[9]) == std::weak_ordering::less);
172 assert(std::weak_order(v[1], v[10]) == std::weak_ordering::less);
173 assert(std::weak_order(v[1], v[11]) == std::weak_ordering::less);
174 assert(std::weak_order(v[1], v[12]) == std::weak_ordering::less);
175 assert(std::weak_order(v[1], v[13]) == std::weak_ordering::less);
176 assert(std::weak_order(v[2], v[0]) == std::weak_ordering::greater);
177 assert(std::weak_order(v[2], v[1]) == std::weak_ordering::greater);
178 assert(std::weak_order(v[2], v[2]) == std::weak_ordering::equivalent);
179 assert(std::weak_order(v[2], v[3]) == std::weak_ordering::less);
180 assert(std::weak_order(v[2], v[4]) == std::weak_ordering::less);
181 assert(std::weak_order(v[2], v[5]) == std::weak_ordering::less);
182 assert(std::weak_order(v[2], v[6]) == std::weak_ordering::less);
183 assert(std::weak_order(v[2], v[7]) == std::weak_ordering::less);
184 assert(std::weak_order(v[2], v[8]) == std::weak_ordering::less);
185 assert(std::weak_order(v[2], v[9]) == std::weak_ordering::less);
186 assert(std::weak_order(v[2], v[10]) == std::weak_ordering::less);
187 assert(std::weak_order(v[2], v[11]) == std::weak_ordering::less);
188 assert(std::weak_order(v[2], v[12]) == std::weak_ordering::less);
189 assert(std::weak_order(v[2], v[13]) == std::weak_ordering::less);
190 assert(std::weak_order(v[3], v[0]) == std::weak_ordering::greater);
191 assert(std::weak_order(v[3], v[1]) == std::weak_ordering::greater);
192 assert(std::weak_order(v[3], v[2]) == std::weak_ordering::greater);
193 assert(std::weak_order(v[3], v[3]) == std::weak_ordering::equivalent);
194 assert(std::weak_order(v[3], v[4]) == std::weak_ordering::less);
195 assert(std::weak_order(v[3], v[5]) == std::weak_ordering::less);
196 assert(std::weak_order(v[3], v[6]) == std::weak_ordering::less);
197 assert(std::weak_order(v[3], v[7]) == std::weak_ordering::less);
198 assert(std::weak_order(v[3], v[8]) == std::weak_ordering::less);
199 assert(std::weak_order(v[3], v[9]) == std::weak_ordering::less);
200 assert(std::weak_order(v[3], v[10]) == std::weak_ordering::less);
201 assert(std::weak_order(v[3], v[11]) == std::weak_ordering::less);
202 assert(std::weak_order(v[3], v[12]) == std::weak_ordering::less);
203 assert(std::weak_order(v[3], v[13]) == std::weak_ordering::less);
204 assert(std::weak_order(v[4], v[0]) == std::weak_ordering::greater);
205 assert(std::weak_order(v[4], v[1]) == std::weak_ordering::greater);
206 assert(std::weak_order(v[4], v[2]) == std::weak_ordering::greater);
207 assert(std::weak_order(v[4], v[3]) == std::weak_ordering::greater);
208 assert(std::weak_order(v[4], v[4]) == std::weak_ordering::equivalent);
209 assert(std::weak_order(v[4], v[5]) == std::weak_ordering::less);
210 assert(std::weak_order(v[4], v[6]) == std::weak_ordering::less);
211 assert(std::weak_order(v[4], v[7]) == std::weak_ordering::less);
212 assert(std::weak_order(v[4], v[8]) == std::weak_ordering::less);
213 assert(std::weak_order(v[4], v[9]) == std::weak_ordering::less);
214 assert(std::weak_order(v[4], v[10]) == std::weak_ordering::less);
215 assert(std::weak_order(v[4], v[11]) == std::weak_ordering::less);
216 assert(std::weak_order(v[4], v[12]) == std::weak_ordering::less);
217 assert(std::weak_order(v[4], v[13]) == std::weak_ordering::less);
218 assert(std::weak_order(v[5], v[0]) == std::weak_ordering::greater);
219 assert(std::weak_order(v[5], v[1]) == std::weak_ordering::greater);
220 assert(std::weak_order(v[5], v[2]) == std::weak_ordering::greater);
221 assert(std::weak_order(v[5], v[3]) == std::weak_ordering::greater);
222 assert(std::weak_order(v[5], v[4]) == std::weak_ordering::greater);
223 assert(std::weak_order(v[5], v[5]) == std::weak_ordering::equivalent);
224 assert(std::weak_order(v[5], v[6]) == std::weak_ordering::equivalent);
225 assert(std::weak_order(v[5], v[7]) == std::weak_ordering::less);
226 assert(std::weak_order(v[5], v[8]) == std::weak_ordering::less);
227 assert(std::weak_order(v[5], v[9]) == std::weak_ordering::less);
228 assert(std::weak_order(v[5], v[10]) == std::weak_ordering::less);
229 assert(std::weak_order(v[5], v[11]) == std::weak_ordering::less);
230 assert(std::weak_order(v[5], v[12]) == std::weak_ordering::less);
231 assert(std::weak_order(v[5], v[13]) == std::weak_ordering::less);
232 assert(std::weak_order(v[6], v[0]) == std::weak_ordering::greater);
233 assert(std::weak_order(v[6], v[1]) == std::weak_ordering::greater);
234 assert(std::weak_order(v[6], v[2]) == std::weak_ordering::greater);
235 assert(std::weak_order(v[6], v[3]) == std::weak_ordering::greater);
236 assert(std::weak_order(v[6], v[4]) == std::weak_ordering::greater);
237 assert(std::weak_order(v[6], v[5]) == std::weak_ordering::equivalent);
238 assert(std::weak_order(v[6], v[6]) == std::weak_ordering::equivalent);
239 assert(std::weak_order(v[6], v[7]) == std::weak_ordering::less);
240 assert(std::weak_order(v[6], v[8]) == std::weak_ordering::less);
241 assert(std::weak_order(v[6], v[9]) == std::weak_ordering::less);
242 assert(std::weak_order(v[6], v[10]) == std::weak_ordering::less);
243 assert(std::weak_order(v[6], v[11]) == std::weak_ordering::less);
244 assert(std::weak_order(v[6], v[12]) == std::weak_ordering::less);
245 assert(std::weak_order(v[6], v[13]) == std::weak_ordering::less);
246 assert(std::weak_order(v[7], v[0]) == std::weak_ordering::greater);
247 assert(std::weak_order(v[7], v[1]) == std::weak_ordering::greater);
248 assert(std::weak_order(v[7], v[2]) == std::weak_ordering::greater);
249 assert(std::weak_order(v[7], v[3]) == std::weak_ordering::greater);
250 assert(std::weak_order(v[7], v[4]) == std::weak_ordering::greater);
251 assert(std::weak_order(v[7], v[5]) == std::weak_ordering::greater);
252 assert(std::weak_order(v[7], v[6]) == std::weak_ordering::greater);
253 assert(std::weak_order(v[7], v[7]) == std::weak_ordering::equivalent);
254 assert(std::weak_order(v[7], v[8]) == std::weak_ordering::less);
255 assert(std::weak_order(v[7], v[9]) == std::weak_ordering::less);
256 assert(std::weak_order(v[7], v[10]) == std::weak_ordering::less);
257 assert(std::weak_order(v[7], v[11]) == std::weak_ordering::less);
258 assert(std::weak_order(v[7], v[12]) == std::weak_ordering::less);
259 assert(std::weak_order(v[7], v[13]) == std::weak_ordering::less);
260 assert(std::weak_order(v[8], v[0]) == std::weak_ordering::greater);
261 assert(std::weak_order(v[8], v[1]) == std::weak_ordering::greater);
262 assert(std::weak_order(v[8], v[2]) == std::weak_ordering::greater);
263 assert(std::weak_order(v[8], v[3]) == std::weak_ordering::greater);
264 assert(std::weak_order(v[8], v[4]) == std::weak_ordering::greater);
265 assert(std::weak_order(v[8], v[5]) == std::weak_ordering::greater);
266 assert(std::weak_order(v[8], v[6]) == std::weak_ordering::greater);
267 assert(std::weak_order(v[8], v[7]) == std::weak_ordering::greater);
268 assert(std::weak_order(v[8], v[8]) == std::weak_ordering::equivalent);
269 assert(std::weak_order(v[8], v[9]) == std::weak_ordering::less);
270 assert(std::weak_order(v[8], v[10]) == std::weak_ordering::less);
271 assert(std::weak_order(v[8], v[11]) == std::weak_ordering::less);
272 assert(std::weak_order(v[8], v[12]) == std::weak_ordering::less);
273 assert(std::weak_order(v[8], v[13]) == std::weak_ordering::less);
274 assert(std::weak_order(v[9], v[0]) == std::weak_ordering::greater);
275 assert(std::weak_order(v[9], v[1]) == std::weak_ordering::greater);
276 assert(std::weak_order(v[9], v[2]) == std::weak_ordering::greater);
277 assert(std::weak_order(v[9], v[3]) == std::weak_ordering::greater);
278 assert(std::weak_order(v[9], v[4]) == std::weak_ordering::greater);
279 assert(std::weak_order(v[9], v[5]) == std::weak_ordering::greater);
280 assert(std::weak_order(v[9], v[6]) == std::weak_ordering::greater);
281 assert(std::weak_order(v[9], v[7]) == std::weak_ordering::greater);
282 assert(std::weak_order(v[9], v[8]) == std::weak_ordering::greater);
283 assert(std::weak_order(v[9], v[9]) == std::weak_ordering::equivalent);
284 assert(std::weak_order(v[9], v[10]) == std::weak_ordering::less);
285 assert(std::weak_order(v[9], v[11]) == std::weak_ordering::less);
286 assert(std::weak_order(v[9], v[12]) == std::weak_ordering::less);
287 assert(std::weak_order(v[9], v[13]) == std::weak_ordering::less);
288 assert(std::weak_order(v[10], v[0]) == std::weak_ordering::greater);
289 assert(std::weak_order(v[10], v[1]) == std::weak_ordering::greater);
290 assert(std::weak_order(v[10], v[2]) == std::weak_ordering::greater);
291 assert(std::weak_order(v[10], v[3]) == std::weak_ordering::greater);
292 assert(std::weak_order(v[10], v[4]) == std::weak_ordering::greater);
293 assert(std::weak_order(v[10], v[5]) == std::weak_ordering::greater);
294 assert(std::weak_order(v[10], v[6]) == std::weak_ordering::greater);
295 assert(std::weak_order(v[10], v[7]) == std::weak_ordering::greater);
296 assert(std::weak_order(v[10], v[8]) == std::weak_ordering::greater);
297 assert(std::weak_order(v[10], v[9]) == std::weak_ordering::greater);
298 assert(std::weak_order(v[10], v[10]) == std::weak_ordering::equivalent);
299 assert(std::weak_order(v[10], v[11]) == std::weak_ordering::less);
300 assert(std::weak_order(v[10], v[12]) == std::weak_ordering::less);
301 assert(std::weak_order(v[10], v[13]) == std::weak_ordering::less);
302 assert(std::weak_order(v[11], v[0]) == std::weak_ordering::greater);
303 assert(std::weak_order(v[11], v[1]) == std::weak_ordering::greater);
304 assert(std::weak_order(v[11], v[2]) == std::weak_ordering::greater);
305 assert(std::weak_order(v[11], v[3]) == std::weak_ordering::greater);
306 assert(std::weak_order(v[11], v[4]) == std::weak_ordering::greater);
307 assert(std::weak_order(v[11], v[5]) == std::weak_ordering::greater);
308 assert(std::weak_order(v[11], v[6]) == std::weak_ordering::greater);
309 assert(std::weak_order(v[11], v[7]) == std::weak_ordering::greater);
310 assert(std::weak_order(v[11], v[8]) == std::weak_ordering::greater);
311 assert(std::weak_order(v[11], v[9]) == std::weak_ordering::greater);
312 assert(std::weak_order(v[11], v[10]) == std::weak_ordering::greater);
313 assert(std::weak_order(v[11], v[11]) == std::weak_ordering::equivalent);
314 assert(std::weak_order(v[11], v[12]) == std::weak_ordering::less);
315 assert(std::weak_order(v[11], v[13]) == std::weak_ordering::less);
316 assert(std::weak_order(v[12], v[0]) == std::weak_ordering::greater);
317 assert(std::weak_order(v[12], v[1]) == std::weak_ordering::greater);
318 assert(std::weak_order(v[12], v[2]) == std::weak_ordering::greater);
319 assert(std::weak_order(v[12], v[3]) == std::weak_ordering::greater);
320 assert(std::weak_order(v[12], v[4]) == std::weak_ordering::greater);
321 assert(std::weak_order(v[12], v[5]) == std::weak_ordering::greater);
322 assert(std::weak_order(v[12], v[6]) == std::weak_ordering::greater);
323 assert(std::weak_order(v[12], v[7]) == std::weak_ordering::greater);
324 assert(std::weak_order(v[12], v[8]) == std::weak_ordering::greater);
325 assert(std::weak_order(v[12], v[9]) == std::weak_ordering::greater);
326 assert(std::weak_order(v[12], v[10]) == std::weak_ordering::greater);
327 assert(std::weak_order(v[12], v[11]) == std::weak_ordering::greater);
328 assert(std::weak_order(v[12], v[12]) == std::weak_ordering::equivalent);
329 assert(std::weak_order(v[12], v[13]) == std::weak_ordering::less);
330 assert(std::weak_order(v[13], v[0]) == std::weak_ordering::greater);
331 assert(std::weak_order(v[13], v[1]) == std::weak_ordering::greater);
332 assert(std::weak_order(v[13], v[2]) == std::weak_ordering::greater);
333 assert(std::weak_order(v[13], v[3]) == std::weak_ordering::greater);
334 assert(std::weak_order(v[13], v[4]) == std::weak_ordering::greater);
335 assert(std::weak_order(v[13], v[5]) == std::weak_ordering::greater);
336 assert(std::weak_order(v[13], v[6]) == std::weak_ordering::greater);
337 assert(std::weak_order(v[13], v[7]) == std::weak_ordering::greater);
338 assert(std::weak_order(v[13], v[8]) == std::weak_ordering::greater);
339 assert(std::weak_order(v[13], v[9]) == std::weak_ordering::greater);
340 assert(std::weak_order(v[13], v[10]) == std::weak_ordering::greater);
341 assert(std::weak_order(v[13], v[11]) == std::weak_ordering::greater);
342 assert(std::weak_order(v[13], v[12]) == std::weak_ordering::greater);
343 assert(std::weak_order(v[13], v[13]) == std::weak_ordering::equivalent);
344
345
346 // There's no way to produce a specifically positive or negative NAN
347 // at compile-time, so the NAN-related tests must be runtime-only.
348
349 if (!std::is_constant_evaluated()) {
350 F nq = std::copysign(std::numeric_limits<F>::quiet_NaN(), F(-1));
351 F ns = std::copysign(std::numeric_limits<F>::signaling_NaN(), F(-1));
352 F ps = std::copysign(std::numeric_limits<F>::signaling_NaN(), F(+1));
353 F pq = std::copysign(std::numeric_limits<F>::quiet_NaN(), F(+1));
354
355 assert(std::weak_order(nq, nq) == std::weak_ordering::equivalent);
356 assert(std::weak_order(nq, ns) == std::weak_ordering::equivalent);
357 for (int i=0; i < 14; ++i) {
358 assert(std::weak_order(nq, v[i]) == std::weak_ordering::less);
359 }
360 assert(std::weak_order(nq, ps) == std::weak_ordering::less);
361 assert(std::weak_order(nq, pq) == std::weak_ordering::less);
362
363 assert(std::weak_order(ns, nq) == std::weak_ordering::equivalent);
364 assert(std::weak_order(ns, ns) == std::weak_ordering::equivalent);
365 for (int i=0; i < 14; ++i) {
366 assert(std::weak_order(ns, v[i]) == std::weak_ordering::less);
367 }
368 assert(std::weak_order(ns, ps) == std::weak_ordering::less);
369 assert(std::weak_order(ns, pq) == std::weak_ordering::less);
370
371 assert(std::weak_order(ps, nq) == std::weak_ordering::greater);
372 assert(std::weak_order(ps, ns) == std::weak_ordering::greater);
373 for (int i=0; i < 14; ++i) {
374 assert(std::weak_order(ps, v[i]) == std::weak_ordering::greater);
375 }
376 assert(std::weak_order(ps, ps) == std::weak_ordering::equivalent);
377 assert(std::weak_order(ps, pq) == std::weak_ordering::equivalent);
378
379 assert(std::weak_order(pq, nq) == std::weak_ordering::greater);
380 assert(std::weak_order(pq, ns) == std::weak_ordering::greater);
381 for (int i=0; i < 14; ++i) {
382 assert(std::weak_order(pq, v[i]) == std::weak_ordering::greater);
383 }
384 assert(std::weak_order(pq, ps) == std::weak_ordering::equivalent);
385 assert(std::weak_order(pq, pq) == std::weak_ordering::equivalent);
386 }
387
388 return true;
389 }
390
391 namespace N14 {
392 // Compare to N12::A.
393 struct A {};
394 bool operator==(const A&, const A&);
operator <=>(A &,A &&)395 constexpr std::weak_ordering operator<=>(A&, A&&) { return std::weak_ordering::less; }
operator <=>(A &&,A &&)396 constexpr std::weak_ordering operator<=>(A&&, A&&) { return std::weak_ordering::equivalent; }
397 std::weak_ordering operator<=>(const A&, const A&);
398 static_assert(std::three_way_comparable<A>);
399
400 struct B {
401 std::weak_ordering operator<=>(const B&) const; // lacks operator==
402 };
403 static_assert(!std::three_way_comparable<B>);
404
405 struct C {
406 bool *touched;
407 bool operator==(const C&) const;
operator <=>N14::C408 constexpr std::weak_ordering operator<=>(const C& rhs) const {
409 *rhs.touched = true;
410 return std::weak_ordering::equivalent;
411 }
412 };
413 static_assert(std::three_way_comparable<C>);
414 }
415
test_1_4()416 constexpr bool test_1_4()
417 {
418 // Otherwise, weak_ordering(compare_three_way()(E, F)) if it is a well-formed expression.
419
420 // Test neither weak_order nor compare_three_way const-qualify the forwarded arguments.
421 N14::A a;
422 assert(std::weak_order(a, std::move(a)) == std::weak_ordering::less);
423 assert(std::weak_order(std::move(a), std::move(a)) == std::weak_ordering::equivalent);
424
425 N14::B b;
426 static_assert(!has_weak_order(b, b));
427
428 // Test that the arguments are passed to <=> in the correct order.
429 bool c1_touched = false;
430 bool c2_touched = false;
431 N14::C c1 = {&c1_touched};
432 N14::C c2 = {&c2_touched};
433 assert(std::weak_order(c1, c2) == std::weak_ordering::equivalent);
434 assert(!c1_touched);
435 assert(c2_touched);
436
437 return true;
438 }
439
440 namespace N15 {
441 struct A {};
strong_order(A &,A &&)442 constexpr std::strong_ordering strong_order(A&, A&&) { return std::strong_ordering::less; }
strong_order(A &&,A &&)443 constexpr std::strong_ordering strong_order(A&&, A&&) { return std::strong_ordering::equal; }
444 std::strong_ordering strong_order(const A&, const A&);
445
446 struct B {
447 friend std::weak_ordering strong_order(B&, B&);
448 };
449
450 struct WeakOrder {
operator std::weak_orderingN15::WeakOrder451 operator std::weak_ordering() const { return std::weak_ordering::less; }
452 };
453 struct C {
454 friend WeakOrder strong_order(C& lhs, C&);
455 };
456
457 struct StrongOrder {
operator std::strong_orderingN15::StrongOrder458 constexpr explicit operator std::strong_ordering() const { return std::strong_ordering::less; }
459 operator std::weak_ordering() const = delete;
460 };
461 struct D {
462 bool touched = false;
strong_order(D & lhs,D &)463 friend constexpr StrongOrder strong_order(D& lhs, D&) { lhs.touched = true; return StrongOrder(); }
464 };
465 }
466
test_1_5()467 constexpr bool test_1_5()
468 {
469 // Otherwise, weak_ordering(strong_order(E, F)) [that is, std::strong_order]
470 // if it is a well-formed expression.
471
472 // Test that weak_order and strong_order do not const-qualify the forwarded arguments.
473 N15::A a;
474 assert(std::weak_order(a, std::move(a)) == std::weak_ordering::less);
475 assert(std::weak_order(std::move(a), std::move(a)) == std::weak_ordering::equivalent);
476
477 // The type of ADL strong_order(e,f) must be explicitly convertible to strong_ordering
478 // (not just to weak_ordering), or else std::strong_order(e,f) won't exist.
479 N15::B b;
480 static_assert(!has_weak_order(b, b));
481
482 // The type of ADL strong_order(e,f) must be explicitly convertible to strong_ordering
483 // (not just to weak_ordering), or else std::strong_order(e,f) won't exist.
484 N15::C c;
485 static_assert(!has_weak_order(c, c));
486
487 N15::D d1, d2;
488 ASSERT_SAME_TYPE(decltype(std::weak_order(d1, d2)), std::weak_ordering);
489 assert(std::weak_order(d1, d2) == std::weak_ordering::less);
490 assert(d1.touched);
491 assert(!d2.touched);
492
493 return true;
494 }
495
main(int,char **)496 int main(int, char**)
497 {
498 test_1_1();
499 test_1_2();
500 test_1_3<float>();
501 test_1_3<double>();
502 test_1_3<long double>();
503 test_1_4();
504 test_1_5();
505
506 static_assert(test_1_3<float>());
507 static_assert(test_1_3<double>());
508 static_assert(test_1_3<long double>());
509 static_assert(test_1_4());
510 static_assert(test_1_5());
511
512 return 0;
513 }
514