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 // UNSUPPORTED: libcpp-no-concepts
11 
12 // template<class T, class U>
13 // concept equality_comparable_with = // see below
14 
15 #include <concepts>
16 
17 #include <array>
18 #include <deque>
19 #include <forward_list>
20 #include <list>
21 #include <map>
22 #include <memory>
23 #include <optional>
24 #include <set>
25 #include <unordered_map>
26 #include <unordered_set>
27 #include <vector>
28 
29 #ifndef _LIBCPP_HAS_NO_THREADS
30 #   include <mutex>
31 #endif
32 
33 #include "compare_types.h"
34 
35 template <class T, class U>
36 constexpr bool check_equality_comparable_with() {
37   constexpr bool result = std::equality_comparable_with<T, U>;
38   static_assert(std::equality_comparable_with<U, T> == result);
39   static_assert(std::equality_comparable_with<T, U const> == result);
40   static_assert(std::equality_comparable_with<T const, U const> == result);
41   static_assert(std::equality_comparable_with<T, U const&> == result);
42   static_assert(std::equality_comparable_with<T const, U const&> == result);
43   static_assert(std::equality_comparable_with<T&, U const> == result);
44   static_assert(std::equality_comparable_with<T const&, U const> == result);
45   static_assert(std::equality_comparable_with<T&, U const&> == result);
46   static_assert(std::equality_comparable_with<T const&, U const&> == result);
47   static_assert(std::equality_comparable_with<T, U const&&> == result);
48   static_assert(std::equality_comparable_with<T const, U const&&> == result);
49   static_assert(std::equality_comparable_with<T&, U const&&> == result);
50   static_assert(std::equality_comparable_with<T const&, U const&&> == result);
51   static_assert(std::equality_comparable_with<T&&, U const> == result);
52   static_assert(std::equality_comparable_with<T const&&, U const> == result);
53   static_assert(std::equality_comparable_with<T&&, U const&> == result);
54   static_assert(std::equality_comparable_with<T const&&, U const&> == result);
55   static_assert(std::equality_comparable_with<T&&, U const&&> == result);
56   static_assert(std::equality_comparable_with<T const&&, U const&&> == result);
57   return result;
58 }
59 
60 namespace fundamentals {
61 static_assert(check_equality_comparable_with<int, int>());
62 static_assert(check_equality_comparable_with<int, bool>());
63 static_assert(check_equality_comparable_with<int, char>());
64 static_assert(check_equality_comparable_with<int, wchar_t>());
65 static_assert(check_equality_comparable_with<int, double>());
66 static_assert(!check_equality_comparable_with<int, int*>());
67 static_assert(!check_equality_comparable_with<int, int[5]>());
68 static_assert(!check_equality_comparable_with<int, int (*)()>());
69 static_assert(!check_equality_comparable_with<int, int (&)()>());
70 
71 struct S {};
72 static_assert(!check_equality_comparable_with<int, int S::*>());
73 static_assert(!check_equality_comparable_with<int, int (S::*)()>());
74 static_assert(!check_equality_comparable_with<int, int (S::*)() noexcept>());
75 static_assert(!check_equality_comparable_with<int, int (S::*)() const>());
76 static_assert(
77     !check_equality_comparable_with<int, int (S::*)() const noexcept>());
78 static_assert(!check_equality_comparable_with<int, int (S::*)() volatile>());
79 static_assert(
80     !check_equality_comparable_with<int, int (S::*)() volatile noexcept>());
81 static_assert(
82     !check_equality_comparable_with<int, int (S::*)() const volatile>());
83 static_assert(!check_equality_comparable_with<
84               int, int (S::*)() const volatile noexcept>());
85 static_assert(!check_equality_comparable_with<int, int (S::*)() &>());
86 static_assert(!check_equality_comparable_with<int, int (S::*)() & noexcept>());
87 static_assert(!check_equality_comparable_with<int, int (S::*)() const&>());
88 static_assert(
89     !check_equality_comparable_with<int, int (S::*)() const & noexcept>());
90 static_assert(!check_equality_comparable_with<int, int (S::*)() volatile&>());
91 static_assert(
92     !check_equality_comparable_with<int, int (S::*)() volatile & noexcept>());
93 static_assert(
94     !check_equality_comparable_with<int, int (S::*)() const volatile&>());
95 static_assert(!check_equality_comparable_with<int, int (S::*)() const volatile &
96                                                        noexcept>());
97 static_assert(!check_equality_comparable_with<int, int (S::*)() &&>());
98 static_assert(!check_equality_comparable_with < int,
99               int (S::*)() && noexcept > ());
100 static_assert(!check_equality_comparable_with<int, int (S::*)() const&&>());
101 static_assert(!check_equality_comparable_with < int,
102               int (S::*)() const&& noexcept > ());
103 static_assert(!check_equality_comparable_with<int, int (S::*)() volatile&&>());
104 static_assert(!check_equality_comparable_with < int,
105               int (S::*)() volatile&& noexcept > ());
106 static_assert(
107     !check_equality_comparable_with<int, int (S::*)() const volatile&&>());
108 static_assert(!check_equality_comparable_with < int,
109               int (S::*)() const volatile&& noexcept > ());
110 
111 static_assert(check_equality_comparable_with<int*, int*>());
112 static_assert(check_equality_comparable_with<int*, int[5]>());
113 static_assert(!check_equality_comparable_with<int*, int (*)()>());
114 static_assert(!check_equality_comparable_with<int*, int (&)()>());
115 static_assert(!check_equality_comparable_with<int*, int (S::*)()>());
116 static_assert(!check_equality_comparable_with<int*, int (S::*)() noexcept>());
117 static_assert(!check_equality_comparable_with<int*, int (S::*)() const>());
118 static_assert(
119     !check_equality_comparable_with<int*, int (S::*)() const noexcept>());
120 static_assert(!check_equality_comparable_with<int*, int (S::*)() volatile>());
121 static_assert(
122     !check_equality_comparable_with<int*, int (S::*)() volatile noexcept>());
123 static_assert(
124     !check_equality_comparable_with<int*, int (S::*)() const volatile>());
125 static_assert(!check_equality_comparable_with<
126               int*, int (S::*)() const volatile noexcept>());
127 static_assert(!check_equality_comparable_with<int*, int (S::*)() &>());
128 static_assert(!check_equality_comparable_with<int*, int (S::*)() & noexcept>());
129 static_assert(!check_equality_comparable_with<int*, int (S::*)() const&>());
130 static_assert(
131     !check_equality_comparable_with<int*, int (S::*)() const & noexcept>());
132 static_assert(!check_equality_comparable_with<int*, int (S::*)() volatile&>());
133 static_assert(
134     !check_equality_comparable_with<int*, int (S::*)() volatile & noexcept>());
135 static_assert(
136     !check_equality_comparable_with<int*, int (S::*)() const volatile&>());
137 static_assert(!check_equality_comparable_with<
138               int*, int (S::*)() const volatile & noexcept>());
139 static_assert(!check_equality_comparable_with<int*, int (S::*)() &&>());
140 static_assert(!check_equality_comparable_with < int*,
141               int (S::*)() && noexcept > ());
142 static_assert(!check_equality_comparable_with<int*, int (S::*)() const&&>());
143 static_assert(!check_equality_comparable_with < int*,
144               int (S::*)() const&& noexcept > ());
145 static_assert(!check_equality_comparable_with<int*, int (S::*)() volatile&&>());
146 static_assert(!check_equality_comparable_with < int*,
147               int (S::*)() volatile&& noexcept > ());
148 static_assert(
149     !check_equality_comparable_with<int*, int (S::*)() const volatile&&>());
150 static_assert(!check_equality_comparable_with < int*,
151               int (S::*)() const volatile&& noexcept > ());
152 
153 static_assert(check_equality_comparable_with<int[5], int[5]>());
154 static_assert(!check_equality_comparable_with<int[5], int (*)()>());
155 static_assert(!check_equality_comparable_with<int[5], int (&)()>());
156 static_assert(!check_equality_comparable_with<int[5], int (S::*)()>());
157 static_assert(!check_equality_comparable_with<int[5], int (S::*)() noexcept>());
158 static_assert(!check_equality_comparable_with<int[5], int (S::*)() const>());
159 static_assert(
160     !check_equality_comparable_with<int[5], int (S::*)() const noexcept>());
161 static_assert(!check_equality_comparable_with<int[5], int (S::*)() volatile>());
162 static_assert(
163     !check_equality_comparable_with<int[5], int (S::*)() volatile noexcept>());
164 static_assert(
165     !check_equality_comparable_with<int[5], int (S::*)() const volatile>());
166 static_assert(!check_equality_comparable_with<
167               int[5], int (S::*)() const volatile noexcept>());
168 static_assert(!check_equality_comparable_with<int[5], int (S::*)() &>());
169 static_assert(
170     !check_equality_comparable_with<int[5], int (S::*)() & noexcept>());
171 static_assert(!check_equality_comparable_with<int[5], int (S::*)() const&>());
172 static_assert(
173     !check_equality_comparable_with<int[5], int (S::*)() const & noexcept>());
174 static_assert(
175     !check_equality_comparable_with<int[5], int (S::*)() volatile&>());
176 static_assert(!check_equality_comparable_with<int[5], int (S::*)() volatile &
177                                                           noexcept>());
178 static_assert(
179     !check_equality_comparable_with<int[5], int (S::*)() const volatile&>());
180 static_assert(!check_equality_comparable_with<
181               int[5], int (S::*)() const volatile & noexcept>());
182 static_assert(!check_equality_comparable_with<int[5], int (S::*)() &&>());
183 static_assert(!check_equality_comparable_with < int[5],
184               int (S::*)() && noexcept > ());
185 static_assert(!check_equality_comparable_with<int[5], int (S::*)() const&&>());
186 static_assert(!check_equality_comparable_with < int[5],
187               int (S::*)() const&& noexcept > ());
188 static_assert(
189     !check_equality_comparable_with<int[5], int (S::*)() volatile&&>());
190 static_assert(!check_equality_comparable_with < int[5],
191               int (S::*)() volatile&& noexcept > ());
192 static_assert(
193     !check_equality_comparable_with<int[5], int (S::*)() const volatile&&>());
194 static_assert(!check_equality_comparable_with < int[5],
195               int (S::*)() const volatile&& noexcept > ());
196 
197 static_assert(check_equality_comparable_with<int (*)(), int (*)()>());
198 static_assert(check_equality_comparable_with<int (*)(), int (&)()>());
199 static_assert(!check_equality_comparable_with<int (*)(), int (S::*)()>());
200 static_assert(
201     !check_equality_comparable_with<int (*)(), int (S::*)() noexcept>());
202 static_assert(!check_equality_comparable_with<int (*)(), int (S::*)() const>());
203 static_assert(
204     !check_equality_comparable_with<int (*)(), int (S::*)() const noexcept>());
205 static_assert(
206     !check_equality_comparable_with<int (*)(), int (S::*)() volatile>());
207 static_assert(!check_equality_comparable_with<
208               int (*)(), int (S::*)() volatile noexcept>());
209 static_assert(
210     !check_equality_comparable_with<int (*)(), int (S::*)() const volatile>());
211 static_assert(!check_equality_comparable_with<
212               int (*)(), int (S::*)() const volatile noexcept>());
213 static_assert(!check_equality_comparable_with<int (*)(), int (S::*)() &>());
214 static_assert(
215     !check_equality_comparable_with<int (*)(), int (S::*)() & noexcept>());
216 static_assert(
217     !check_equality_comparable_with<int (*)(), int (S::*)() const&>());
218 static_assert(!check_equality_comparable_with<int (*)(),
219                                               int (S::*)() const & noexcept>());
220 static_assert(
221     !check_equality_comparable_with<int (*)(), int (S::*)() volatile&>());
222 static_assert(!check_equality_comparable_with<int (*)(), int (S::*)() volatile &
223                                                              noexcept>());
224 static_assert(
225     !check_equality_comparable_with<int (*)(), int (S::*)() const volatile&>());
226 static_assert(!check_equality_comparable_with<
227               int (*)(), int (S::*)() const volatile & noexcept>());
228 static_assert(!check_equality_comparable_with<int (*)(), int (S::*)() &&>());
229 static_assert(!check_equality_comparable_with < int (*)(),
230               int (S::*)() && noexcept > ());
231 static_assert(
232     !check_equality_comparable_with<int (*)(), int (S::*)() const&&>());
233 static_assert(!check_equality_comparable_with < int (*)(),
234               int (S::*)() const&& noexcept > ());
235 static_assert(
236     !check_equality_comparable_with<int (*)(), int (S::*)() volatile&&>());
237 static_assert(!check_equality_comparable_with < int (*)(),
238               int (S::*)() volatile&& noexcept > ());
239 static_assert(!check_equality_comparable_with<int (*)(),
240                                               int (S::*)() const volatile&&>());
241 static_assert(!check_equality_comparable_with < int (*)(),
242               int (S::*)() const volatile&& noexcept > ());
243 
244 static_assert(check_equality_comparable_with<int (&)(), int (&)()>());
245 static_assert(!check_equality_comparable_with<int (&)(), int (S::*)()>());
246 static_assert(
247     !check_equality_comparable_with<int (&)(), int (S::*)() noexcept>());
248 static_assert(!check_equality_comparable_with<int (&)(), int (S::*)() const>());
249 static_assert(
250     !check_equality_comparable_with<int (&)(), int (S::*)() const noexcept>());
251 static_assert(
252     !check_equality_comparable_with<int (&)(), int (S::*)() volatile>());
253 static_assert(!check_equality_comparable_with<
254               int (&)(), int (S::*)() volatile noexcept>());
255 static_assert(
256     !check_equality_comparable_with<int (&)(), int (S::*)() const volatile>());
257 static_assert(!check_equality_comparable_with<
258               int (&)(), int (S::*)() const volatile noexcept>());
259 static_assert(!check_equality_comparable_with<int (&)(), int (S::*)() &>());
260 static_assert(
261     !check_equality_comparable_with<int (&)(), int (S::*)() & noexcept>());
262 static_assert(
263     !check_equality_comparable_with<int (&)(), int (S::*)() const&>());
264 static_assert(!check_equality_comparable_with<int (&)(),
265                                               int (S::*)() const & noexcept>());
266 static_assert(
267     !check_equality_comparable_with<int (&)(), int (S::*)() volatile&>());
268 static_assert(!check_equality_comparable_with<int (&)(), int (S::*)() volatile &
269                                                              noexcept>());
270 static_assert(
271     !check_equality_comparable_with<int (&)(), int (S::*)() const volatile&>());
272 static_assert(!check_equality_comparable_with<
273               int (&)(), int (S::*)() const volatile & noexcept>());
274 static_assert(!check_equality_comparable_with<int (&)(), int (S::*)() &&>());
275 static_assert(!check_equality_comparable_with < int (&)(),
276               int (S::*)() && noexcept > ());
277 static_assert(
278     !check_equality_comparable_with<int (&)(), int (S::*)() const&&>());
279 static_assert(!check_equality_comparable_with < int (&)(),
280               int (S::*)() const&& noexcept > ());
281 static_assert(
282     !check_equality_comparable_with<int (&)(), int (S::*)() volatile&&>());
283 static_assert(!check_equality_comparable_with < int (&)(),
284               int (S::*)() volatile&& noexcept > ());
285 static_assert(!check_equality_comparable_with<int (&)(),
286                                               int (S::*)() const volatile&&>());
287 static_assert(!check_equality_comparable_with < int (&)(),
288               int (S::*)() const volatile&& noexcept > ());
289 
290 static_assert(check_equality_comparable_with<int (S::*)(), int (S::*)()>());
291 static_assert(
292     check_equality_comparable_with<int (S::*)(), int (S::*)() noexcept>());
293 static_assert(
294     !check_equality_comparable_with<int (S::*)(), int (S::*)() const>());
295 static_assert(!check_equality_comparable_with<int (S::*)(),
296                                               int (S::*)() const noexcept>());
297 static_assert(
298     !check_equality_comparable_with<int (S::*)(), int (S::*)() volatile>());
299 static_assert(!check_equality_comparable_with<
300               int (S::*)(), int (S::*)() volatile noexcept>());
301 static_assert(!check_equality_comparable_with<int (S::*)(),
302                                               int (S::*)() const volatile>());
303 static_assert(!check_equality_comparable_with<
304               int (S::*)(), int (S::*)() const volatile noexcept>());
305 static_assert(!check_equality_comparable_with<int (S::*)(), int (S::*)() &>());
306 static_assert(
307     !check_equality_comparable_with<int (S::*)(), int (S::*)() & noexcept>());
308 static_assert(
309     !check_equality_comparable_with<int (S::*)(), int (S::*)() const&>());
310 static_assert(!check_equality_comparable_with<int (S::*)(),
311                                               int (S::*)() const & noexcept>());
312 static_assert(
313     !check_equality_comparable_with<int (S::*)(), int (S::*)() volatile&>());
314 static_assert(!check_equality_comparable_with<
315               int (S::*)(), int (S::*)() volatile & noexcept>());
316 static_assert(!check_equality_comparable_with<int (S::*)(),
317                                               int (S::*)() const volatile&>());
318 static_assert(!check_equality_comparable_with<
319               int (S::*)(), int (S::*)() const volatile & noexcept>());
320 static_assert(!check_equality_comparable_with<int (S::*)(), int (S::*)() &&>());
321 static_assert(!check_equality_comparable_with < int (S::*)(),
322               int (S::*)() && noexcept > ());
323 static_assert(
324     !check_equality_comparable_with<int (S::*)(), int (S::*)() const&&>());
325 static_assert(!check_equality_comparable_with < int (S::*)(),
326               int (S::*)() const&& noexcept > ());
327 static_assert(
328     !check_equality_comparable_with<int (S::*)(), int (S::*)() volatile&&>());
329 static_assert(!check_equality_comparable_with < int (S::*)(),
330               int (S::*)() volatile&& noexcept > ());
331 static_assert(!check_equality_comparable_with<int (S::*)(),
332                                               int (S::*)() const volatile&&>());
333 static_assert(!check_equality_comparable_with < int (S::*)(),
334               int (S::*)() const volatile&& noexcept > ());
335 
336 static_assert(check_equality_comparable_with<int (S::*)() noexcept,
337                                              int (S::*)() noexcept>());
338 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
339                                               int (S::*)() const>());
340 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
341                                               int (S::*)() const noexcept>());
342 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
343                                               int (S::*)() volatile>());
344 static_assert(!check_equality_comparable_with<
345               int (S::*)() noexcept, int (S::*)() volatile noexcept>());
346 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
347                                               int (S::*)() const volatile>());
348 static_assert(!check_equality_comparable_with<
349               int (S::*)() noexcept, int (S::*)() const volatile noexcept>());
350 static_assert(
351     !check_equality_comparable_with<int (S::*)() noexcept, int (S::*)() &>());
352 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
353                                               int (S::*)() & noexcept>());
354 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
355                                               int (S::*)() const&>());
356 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
357                                               int (S::*)() const & noexcept>());
358 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
359                                               int (S::*)() volatile&>());
360 static_assert(!check_equality_comparable_with<
361               int (S::*)() noexcept, int (S::*)() volatile & noexcept>());
362 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
363                                               int (S::*)() const volatile&>());
364 static_assert(!check_equality_comparable_with<
365               int (S::*)() noexcept, int (S::*)() const volatile & noexcept>());
366 static_assert(
367     !check_equality_comparable_with<int (S::*)() noexcept, int (S::*)() &&>());
368 static_assert(!check_equality_comparable_with < int (S::*)() noexcept,
369               int (S::*)() && noexcept > ());
370 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
371                                               int (S::*)() const&&>());
372 static_assert(!check_equality_comparable_with < int (S::*)() noexcept,
373               int (S::*)() const&& noexcept > ());
374 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
375                                               int (S::*)() volatile&&>());
376 static_assert(!check_equality_comparable_with < int (S::*)() noexcept,
377               int (S::*)() volatile&& noexcept > ());
378 static_assert(!check_equality_comparable_with<int (S::*)() noexcept,
379                                               int (S::*)() const volatile&&>());
380 static_assert(!check_equality_comparable_with < int (S::*)() noexcept,
381               int (S::*)() const volatile&& noexcept > ());
382 
383 static_assert(
384     check_equality_comparable_with<int (S::*)() const, int (S::*)() const>());
385 static_assert(check_equality_comparable_with<int (S::*)() const,
386                                              int (S::*)() const noexcept>());
387 static_assert(!check_equality_comparable_with<int (S::*)() const,
388                                               int (S::*)() volatile>());
389 static_assert(!check_equality_comparable_with<
390               int (S::*)() const, int (S::*)() volatile noexcept>());
391 static_assert(!check_equality_comparable_with<int (S::*)() const,
392                                               int (S::*)() const volatile>());
393 static_assert(!check_equality_comparable_with<
394               int (S::*)() const, int (S::*)() const volatile noexcept>());
395 static_assert(
396     !check_equality_comparable_with<int (S::*)() const, int (S::*)() &>());
397 static_assert(!check_equality_comparable_with<int (S::*)() const,
398                                               int (S::*)() & noexcept>());
399 static_assert(
400     !check_equality_comparable_with<int (S::*)() const, int (S::*)() const&>());
401 static_assert(!check_equality_comparable_with<int (S::*)() const,
402                                               int (S::*)() const & noexcept>());
403 static_assert(!check_equality_comparable_with<int (S::*)() const,
404                                               int (S::*)() volatile&>());
405 static_assert(!check_equality_comparable_with<
406               int (S::*)() const, int (S::*)() volatile & noexcept>());
407 static_assert(!check_equality_comparable_with<int (S::*)() const,
408                                               int (S::*)() const volatile&>());
409 static_assert(!check_equality_comparable_with<
410               int (S::*)() const, int (S::*)() const volatile & noexcept>());
411 static_assert(
412     !check_equality_comparable_with<int (S::*)() const, int (S::*)() &&>());
413 static_assert(!check_equality_comparable_with < int (S::*)() const,
414               int (S::*)() && noexcept > ());
415 static_assert(!check_equality_comparable_with<int (S::*)() const,
416                                               int (S::*)() const&&>());
417 static_assert(!check_equality_comparable_with < int (S::*)() const,
418               int (S::*)() const&& noexcept > ());
419 static_assert(!check_equality_comparable_with<int (S::*)() const,
420                                               int (S::*)() volatile&&>());
421 static_assert(!check_equality_comparable_with < int (S::*)() const,
422               int (S::*)() volatile&& noexcept > ());
423 static_assert(!check_equality_comparable_with<int (S::*)() const,
424                                               int (S::*)() const volatile&&>());
425 static_assert(!check_equality_comparable_with < int (S::*)() const,
426               int (S::*)() const volatile&& noexcept > ());
427 
428 static_assert(check_equality_comparable_with<int (S::*)() const noexcept,
429                                              int (S::*)() const noexcept>());
430 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
431                                               int (S::*)() volatile>());
432 static_assert(!check_equality_comparable_with<
433               int (S::*)() const noexcept, int (S::*)() volatile noexcept>());
434 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
435                                               int (S::*)() const volatile>());
436 static_assert(
437     !check_equality_comparable_with<int (S::*)() const noexcept,
438                                     int (S::*)() const volatile noexcept>());
439 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
440                                               int (S::*)() &>());
441 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
442                                               int (S::*)() & noexcept>());
443 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
444                                               int (S::*)() const&>());
445 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
446                                               int (S::*)() const & noexcept>());
447 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
448                                               int (S::*)() volatile&>());
449 static_assert(!check_equality_comparable_with<
450               int (S::*)() const noexcept, int (S::*)() volatile & noexcept>());
451 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
452                                               int (S::*)() const volatile&>());
453 static_assert(
454     !check_equality_comparable_with<int (S::*)() const noexcept,
455                                     int (S::*)() const volatile & noexcept>());
456 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
457                                               int (S::*)() &&>());
458 static_assert(!check_equality_comparable_with < int (S::*)() const noexcept,
459               int (S::*)() && noexcept > ());
460 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
461                                               int (S::*)() const&&>());
462 static_assert(!check_equality_comparable_with < int (S::*)() const noexcept,
463               int (S::*)() const&& noexcept > ());
464 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
465                                               int (S::*)() volatile&&>());
466 static_assert(!check_equality_comparable_with < int (S::*)() const noexcept,
467               int (S::*)() volatile&& noexcept > ());
468 static_assert(!check_equality_comparable_with<int (S::*)() const noexcept,
469                                               int (S::*)() const volatile&&>());
470 static_assert(!check_equality_comparable_with < int (S::*)() const noexcept,
471               int (S::*)() const volatile&& noexcept > ());
472 
473 static_assert(check_equality_comparable_with<int (S::*)() volatile,
474                                              int (S::*)() volatile>());
475 static_assert(check_equality_comparable_with<int (S::*)() volatile,
476                                              int (S::*)() volatile noexcept>());
477 static_assert(!check_equality_comparable_with<int (S::*)() volatile,
478                                               int (S::*)() const volatile>());
479 static_assert(!check_equality_comparable_with<
480               int (S::*)() volatile, int (S::*)() const volatile noexcept>());
481 static_assert(
482     !check_equality_comparable_with<int (S::*)() volatile, int (S::*)() &>());
483 static_assert(!check_equality_comparable_with<int (S::*)() volatile,
484                                               int (S::*)() & noexcept>());
485 static_assert(!check_equality_comparable_with<int (S::*)() volatile,
486                                               int (S::*)() const&>());
487 static_assert(!check_equality_comparable_with<int (S::*)() volatile,
488                                               int (S::*)() const & noexcept>());
489 static_assert(!check_equality_comparable_with<int (S::*)() volatile,
490                                               int (S::*)() volatile&>());
491 static_assert(!check_equality_comparable_with<
492               int (S::*)() volatile, int (S::*)() volatile & noexcept>());
493 static_assert(!check_equality_comparable_with<int (S::*)() volatile,
494                                               int (S::*)() const volatile&>());
495 static_assert(!check_equality_comparable_with<
496               int (S::*)() volatile, int (S::*)() const volatile & noexcept>());
497 static_assert(
498     !check_equality_comparable_with<int (S::*)() volatile, int (S::*)() &&>());
499 static_assert(!check_equality_comparable_with < int (S::*)() volatile,
500               int (S::*)() && noexcept > ());
501 static_assert(!check_equality_comparable_with<int (S::*)() volatile,
502                                               int (S::*)() const&&>());
503 static_assert(!check_equality_comparable_with < int (S::*)() volatile,
504               int (S::*)() const&& noexcept > ());
505 static_assert(!check_equality_comparable_with<int (S::*)() volatile,
506                                               int (S::*)() volatile&&>());
507 static_assert(!check_equality_comparable_with < int (S::*)() volatile,
508               int (S::*)() volatile&& noexcept > ());
509 static_assert(!check_equality_comparable_with<int (S::*)() volatile,
510                                               int (S::*)() const volatile&&>());
511 static_assert(!check_equality_comparable_with < int (S::*)() volatile,
512               int (S::*)() const volatile&& noexcept > ());
513 
514 static_assert(check_equality_comparable_with<int (S::*)() volatile noexcept,
515                                              int (S::*)() volatile noexcept>());
516 static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
517                                               int (S::*)() const volatile>());
518 static_assert(
519     !check_equality_comparable_with<int (S::*)() volatile noexcept,
520                                     int (S::*)() const volatile noexcept>());
521 static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
522                                               int (S::*)() &>());
523 static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
524                                               int (S::*)() & noexcept>());
525 static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
526                                               int (S::*)() const&>());
527 static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
528                                               int (S::*)() const & noexcept>());
529 static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
530                                               int (S::*)() volatile&>());
531 static_assert(
532     !check_equality_comparable_with<int (S::*)() volatile noexcept,
533                                     int (S::*)() volatile & noexcept>());
534 static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
535                                               int (S::*)() const volatile&>());
536 static_assert(
537     !check_equality_comparable_with<int (S::*)() volatile noexcept,
538                                     int (S::*)() const volatile & noexcept>());
539 static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
540                                               int (S::*)() &&>());
541 static_assert(!check_equality_comparable_with < int (S::*)() volatile noexcept,
542               int (S::*)() && noexcept > ());
543 static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
544                                               int (S::*)() const&&>());
545 static_assert(!check_equality_comparable_with < int (S::*)() volatile noexcept,
546               int (S::*)() const&& noexcept > ());
547 static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
548                                               int (S::*)() volatile&&>());
549 static_assert(!check_equality_comparable_with < int (S::*)() volatile noexcept,
550               int (S::*)() volatile&& noexcept > ());
551 static_assert(!check_equality_comparable_with<int (S::*)() volatile noexcept,
552                                               int (S::*)() const volatile&&>());
553 static_assert(!check_equality_comparable_with < int (S::*)() volatile noexcept,
554               int (S::*)() const volatile&& noexcept > ());
555 
556 static_assert(check_equality_comparable_with<int (S::*)() const volatile,
557                                              int (S::*)() const volatile>());
558 static_assert(
559     check_equality_comparable_with<int (S::*)() const volatile,
560                                    int (S::*)() const volatile noexcept>());
561 static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
562                                               int (S::*)() &>());
563 static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
564                                               int (S::*)() & noexcept>());
565 static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
566                                               int (S::*)() const&>());
567 static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
568                                               int (S::*)() const & noexcept>());
569 static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
570                                               int (S::*)() volatile&>());
571 static_assert(!check_equality_comparable_with<
572               int (S::*)() const volatile, int (S::*)() volatile & noexcept>());
573 static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
574                                               int (S::*)() const volatile&>());
575 static_assert(
576     !check_equality_comparable_with<int (S::*)() const volatile,
577                                     int (S::*)() const volatile & noexcept>());
578 static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
579                                               int (S::*)() &&>());
580 static_assert(!check_equality_comparable_with < int (S::*)() const volatile,
581               int (S::*)() && noexcept > ());
582 static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
583                                               int (S::*)() const&&>());
584 static_assert(!check_equality_comparable_with < int (S::*)() const volatile,
585               int (S::*)() const&& noexcept > ());
586 static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
587                                               int (S::*)() volatile&&>());
588 static_assert(!check_equality_comparable_with < int (S::*)() const volatile,
589               int (S::*)() volatile&& noexcept > ());
590 static_assert(!check_equality_comparable_with<int (S::*)() const volatile,
591                                               int (S::*)() const volatile&&>());
592 static_assert(!check_equality_comparable_with < int (S::*)() const volatile,
593               int (S::*)() const volatile&& noexcept > ());
594 
595 static_assert(
596     check_equality_comparable_with<int (S::*)() const volatile noexcept,
597                                    int (S::*)() const volatile noexcept>());
598 static_assert(!check_equality_comparable_with<
599               int (S::*)() const volatile noexcept, int (S::*)() &>());
600 static_assert(!check_equality_comparable_with<
601               int (S::*)() const volatile noexcept, int (S::*)() & noexcept>());
602 static_assert(!check_equality_comparable_with<
603               int (S::*)() const volatile noexcept, int (S::*)() const&>());
604 static_assert(
605     !check_equality_comparable_with<int (S::*)() const volatile noexcept,
606                                     int (S::*)() const & noexcept>());
607 static_assert(!check_equality_comparable_with<
608               int (S::*)() const volatile noexcept, int (S::*)() volatile&>());
609 static_assert(
610     !check_equality_comparable_with<int (S::*)() const volatile noexcept,
611                                     int (S::*)() volatile & noexcept>());
612 static_assert(
613     !check_equality_comparable_with<int (S::*)() const volatile noexcept,
614                                     int (S::*)() const volatile&>());
615 static_assert(
616     !check_equality_comparable_with<int (S::*)() const volatile noexcept,
617                                     int (S::*)() const volatile & noexcept>());
618 static_assert(!check_equality_comparable_with<
619               int (S::*)() const volatile noexcept, int (S::*)() &&>());
620 static_assert(!check_equality_comparable_with < int (S::*)()
621                                                     const volatile noexcept,
622               int (S::*)() && noexcept > ());
623 static_assert(!check_equality_comparable_with<
624               int (S::*)() const volatile noexcept, int (S::*)() const&&>());
625 static_assert(!check_equality_comparable_with < int (S::*)()
626                                                     const volatile noexcept,
627               int (S::*)() const&& noexcept > ());
628 static_assert(!check_equality_comparable_with<
629               int (S::*)() const volatile noexcept, int (S::*)() volatile&&>());
630 static_assert(!check_equality_comparable_with < int (S::*)()
631                                                     const volatile noexcept,
632               int (S::*)() volatile&& noexcept > ());
633 static_assert(
634     !check_equality_comparable_with<int (S::*)() const volatile noexcept,
635                                     int (S::*)() const volatile&&>());
636 static_assert(!check_equality_comparable_with < int (S::*)()
637                                                     const volatile noexcept,
638               int (S::*)() const volatile&& noexcept > ());
639 
640 static_assert(check_equality_comparable_with<int (S::*)() &, int (S::*)() &>());
641 static_assert(
642     check_equality_comparable_with<int (S::*)() &, int (S::*)() & noexcept>());
643 static_assert(
644     !check_equality_comparable_with<int (S::*)() &, int (S::*)() const&>());
645 static_assert(!check_equality_comparable_with<int (S::*)() &,
646                                               int (S::*)() const & noexcept>());
647 static_assert(
648     !check_equality_comparable_with<int (S::*)() &, int (S::*)() volatile&>());
649 static_assert(!check_equality_comparable_with<
650               int (S::*)() &, int (S::*)() volatile & noexcept>());
651 static_assert(!check_equality_comparable_with<int (S::*)() &,
652                                               int (S::*)() const volatile&>());
653 static_assert(!check_equality_comparable_with<
654               int (S::*)() &, int (S::*)() const volatile & noexcept>());
655 static_assert(
656     !check_equality_comparable_with<int (S::*)() &, int (S::*)() &&>());
657 static_assert(!check_equality_comparable_with < int (S::*)() &,
658               int (S::*)() && noexcept > ());
659 static_assert(
660     !check_equality_comparable_with<int (S::*)() &, int (S::*)() const&&>());
661 static_assert(!check_equality_comparable_with < int (S::*)() &,
662               int (S::*)() const&& noexcept > ());
663 static_assert(
664     !check_equality_comparable_with<int (S::*)() &, int (S::*)() volatile&&>());
665 static_assert(!check_equality_comparable_with < int (S::*)() &,
666               int (S::*)() volatile&& noexcept > ());
667 static_assert(!check_equality_comparable_with<int (S::*)() &,
668                                               int (S::*)() const volatile&&>());
669 static_assert(!check_equality_comparable_with < int (S::*)() &,
670               int (S::*)() const volatile&& noexcept > ());
671 
672 static_assert(check_equality_comparable_with<int (S::*)() & noexcept,
673                                              int (S::*)() & noexcept>());
674 static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
675                                               int (S::*)() const&>());
676 static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
677                                               int (S::*)() const & noexcept>());
678 static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
679                                               int (S::*)() volatile&>());
680 static_assert(!check_equality_comparable_with<
681               int (S::*)() & noexcept, int (S::*)() volatile & noexcept>());
682 static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
683                                               int (S::*)() const volatile&>());
684 static_assert(
685     !check_equality_comparable_with<int (S::*)() & noexcept,
686                                     int (S::*)() const volatile & noexcept>());
687 static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
688                                               int (S::*)() &&>());
689 static_assert(!check_equality_comparable_with < int (S::*)() & noexcept,
690               int (S::*)() && noexcept > ());
691 static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
692                                               int (S::*)() const&&>());
693 static_assert(!check_equality_comparable_with < int (S::*)() & noexcept,
694               int (S::*)() const&& noexcept > ());
695 static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
696                                               int (S::*)() volatile&&>());
697 static_assert(!check_equality_comparable_with < int (S::*)() & noexcept,
698               int (S::*)() volatile&& noexcept > ());
699 static_assert(!check_equality_comparable_with<int (S::*)() & noexcept,
700                                               int (S::*)() const volatile&&>());
701 static_assert(!check_equality_comparable_with < int (S::*)() & noexcept,
702               int (S::*)() const volatile&& noexcept > ());
703 
704 static_assert(
705     check_equality_comparable_with<int (S::*)() const&, int (S::*)() const&>());
706 static_assert(check_equality_comparable_with<int (S::*)() const&,
707                                              int (S::*)() const & noexcept>());
708 static_assert(!check_equality_comparable_with<int (S::*)() const&,
709                                               int (S::*)() volatile&>());
710 static_assert(!check_equality_comparable_with<
711               int (S::*)() const&, int (S::*)() volatile & noexcept>());
712 static_assert(!check_equality_comparable_with<int (S::*)() const&,
713                                               int (S::*)() const volatile&>());
714 static_assert(!check_equality_comparable_with<
715               int (S::*)() const&, int (S::*)() const volatile & noexcept>());
716 static_assert(
717     !check_equality_comparable_with<int (S::*)() const&, int (S::*)() &&>());
718 static_assert(!check_equality_comparable_with < int (S::*)() const&,
719               int (S::*)() && noexcept > ());
720 static_assert(!check_equality_comparable_with<int (S::*)() const&,
721                                               int (S::*)() const&&>());
722 static_assert(!check_equality_comparable_with < int (S::*)() const&,
723               int (S::*)() const&& noexcept > ());
724 static_assert(!check_equality_comparable_with<int (S::*)() const&,
725                                               int (S::*)() volatile&&>());
726 static_assert(!check_equality_comparable_with < int (S::*)() const&,
727               int (S::*)() volatile&& noexcept > ());
728 static_assert(!check_equality_comparable_with<int (S::*)() const&,
729                                               int (S::*)() const volatile&&>());
730 static_assert(!check_equality_comparable_with < int (S::*)() const&,
731               int (S::*)() const volatile&& noexcept > ());
732 
733 static_assert(check_equality_comparable_with<int (S::*)() const & noexcept,
734                                              int (S::*)() const & noexcept>());
735 static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
736                                               int (S::*)() volatile&>());
737 static_assert(
738     !check_equality_comparable_with<int (S::*)() const & noexcept,
739                                     int (S::*)() volatile & noexcept>());
740 static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
741                                               int (S::*)() const volatile&>());
742 static_assert(
743     !check_equality_comparable_with<int (S::*)() const & noexcept,
744                                     int (S::*)() const volatile & noexcept>());
745 static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
746                                               int (S::*)() &&>());
747 static_assert(!check_equality_comparable_with < int (S::*)() const& noexcept,
748               int (S::*)() && noexcept > ());
749 static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
750                                               int (S::*)() const&&>());
751 static_assert(!check_equality_comparable_with < int (S::*)() const& noexcept,
752               int (S::*)() const&& noexcept > ());
753 static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
754                                               int (S::*)() volatile&&>());
755 static_assert(!check_equality_comparable_with < int (S::*)() const& noexcept,
756               int (S::*)() volatile&& noexcept > ());
757 static_assert(!check_equality_comparable_with<int (S::*)() const & noexcept,
758                                               int (S::*)() const volatile&&>());
759 static_assert(!check_equality_comparable_with < int (S::*)() const& noexcept,
760               int (S::*)() const volatile&& noexcept > ());
761 
762 static_assert(check_equality_comparable_with<int (S::*)() volatile&,
763                                              int (S::*)() volatile&>());
764 static_assert(check_equality_comparable_with<
765               int (S::*)() volatile&, int (S::*)() volatile & noexcept>());
766 static_assert(!check_equality_comparable_with<int (S::*)() volatile&,
767                                               int (S::*)() const volatile&>());
768 static_assert(
769     !check_equality_comparable_with<int (S::*)() volatile&,
770                                     int (S::*)() const volatile & noexcept>());
771 static_assert(
772     !check_equality_comparable_with<int (S::*)() volatile&, int (S::*)() &&>());
773 static_assert(!check_equality_comparable_with < int (S::*)() volatile&,
774               int (S::*)() && noexcept > ());
775 static_assert(!check_equality_comparable_with<int (S::*)() volatile&,
776                                               int (S::*)() const&&>());
777 static_assert(!check_equality_comparable_with < int (S::*)() volatile&,
778               int (S::*)() const&& noexcept > ());
779 static_assert(!check_equality_comparable_with<int (S::*)() volatile&,
780                                               int (S::*)() volatile&&>());
781 static_assert(!check_equality_comparable_with < int (S::*)() volatile&,
782               int (S::*)() volatile&& noexcept > ());
783 static_assert(!check_equality_comparable_with<int (S::*)() volatile&,
784                                               int (S::*)() const volatile&&>());
785 static_assert(!check_equality_comparable_with < int (S::*)() volatile&,
786               int (S::*)() const volatile&& noexcept > ());
787 
788 static_assert(
789     check_equality_comparable_with<int (S::*)() volatile & noexcept,
790                                    int (S::*)() volatile & noexcept>());
791 static_assert(!check_equality_comparable_with<int (S::*)() volatile & noexcept,
792                                               int (S::*)() const volatile&>());
793 static_assert(
794     !check_equality_comparable_with<int (S::*)() volatile & noexcept,
795                                     int (S::*)() const volatile & noexcept>());
796 static_assert(!check_equality_comparable_with<int (S::*)() volatile & noexcept,
797                                               int (S::*)() &&>());
798 static_assert(!check_equality_comparable_with < int (S::*)() volatile& noexcept,
799               int (S::*)() && noexcept > ());
800 static_assert(!check_equality_comparable_with<int (S::*)() volatile & noexcept,
801                                               int (S::*)() const&&>());
802 static_assert(!check_equality_comparable_with < int (S::*)() volatile& noexcept,
803               int (S::*)() const&& noexcept > ());
804 static_assert(!check_equality_comparable_with<int (S::*)() volatile & noexcept,
805                                               int (S::*)() volatile&&>());
806 static_assert(!check_equality_comparable_with < int (S::*)() volatile& noexcept,
807               int (S::*)() volatile&& noexcept > ());
808 static_assert(!check_equality_comparable_with<int (S::*)() volatile & noexcept,
809                                               int (S::*)() const volatile&&>());
810 static_assert(!check_equality_comparable_with < int (S::*)() volatile& noexcept,
811               int (S::*)() const volatile&& noexcept > ());
812 
813 static_assert(check_equality_comparable_with<int (S::*)() const volatile&,
814                                              int (S::*)() const volatile&>());
815 static_assert(
816     check_equality_comparable_with<int (S::*)() const volatile&,
817                                    int (S::*)() const volatile & noexcept>());
818 static_assert(!check_equality_comparable_with<int (S::*)() const volatile&,
819                                               int (S::*)() &&>());
820 static_assert(!check_equality_comparable_with < int (S::*)() const volatile&,
821               int (S::*)() && noexcept > ());
822 static_assert(!check_equality_comparable_with<int (S::*)() const volatile&,
823                                               int (S::*)() const&&>());
824 static_assert(!check_equality_comparable_with < int (S::*)() const volatile&,
825               int (S::*)() const&& noexcept > ());
826 static_assert(!check_equality_comparable_with<int (S::*)() const volatile&,
827                                               int (S::*)() volatile&&>());
828 static_assert(!check_equality_comparable_with < int (S::*)() const volatile&,
829               int (S::*)() volatile&& noexcept > ());
830 static_assert(!check_equality_comparable_with<int (S::*)() const volatile&,
831                                               int (S::*)() const volatile&&>());
832 static_assert(!check_equality_comparable_with < int (S::*)() const volatile&,
833               int (S::*)() const volatile&& noexcept > ());
834 
835 static_assert(
836     check_equality_comparable_with<int (S::*)() const volatile & noexcept,
837                                    int (S::*)() const volatile & noexcept>());
838 static_assert(!check_equality_comparable_with<
839               int (S::*)() const volatile & noexcept, int (S::*)() &&>());
840 static_assert(!check_equality_comparable_with < int (S::*)()
841                                                     const volatile& noexcept,
842               int (S::*)() && noexcept > ());
843 static_assert(!check_equality_comparable_with<
844               int (S::*)() const volatile & noexcept, int (S::*)() const&&>());
845 static_assert(!check_equality_comparable_with < int (S::*)()
846                                                     const volatile& noexcept,
847               int (S::*)() const&& noexcept > ());
848 static_assert(
849     !check_equality_comparable_with<int (S::*)() const volatile & noexcept,
850                                     int (S::*)() volatile&&>());
851 static_assert(!check_equality_comparable_with < int (S::*)()
852                                                     const volatile& noexcept,
853               int (S::*)() volatile&& noexcept > ());
854 static_assert(
855     !check_equality_comparable_with<int (S::*)() const volatile & noexcept,
856                                     int (S::*)() const volatile&&>());
857 static_assert(!check_equality_comparable_with < int (S::*)()
858                                                     const volatile& noexcept,
859               int (S::*)() const volatile&& noexcept > ());
860 
861 static_assert(
862     check_equality_comparable_with<int (S::*)() &&, int (S::*)() &&>());
863 static_assert(check_equality_comparable_with<int (S::*)() &&,
864                                              int (S::*)() && noexcept>());
865 static_assert(
866     !check_equality_comparable_with<int (S::*)() &&, int (S::*)() const&&>());
867 static_assert(!check_equality_comparable_with < int (S::*)() &&,
868               int (S::*)() const&& noexcept > ());
869 static_assert(!check_equality_comparable_with<int (S::*)() &&,
870                                               int (S::*)() volatile&&>());
871 static_assert(!check_equality_comparable_with < int (S::*)() &&,
872               int (S::*)() volatile&& noexcept > ());
873 static_assert(!check_equality_comparable_with<int (S::*)() &&,
874                                               int (S::*)() const volatile&&>());
875 static_assert(!check_equality_comparable_with < int (S::*)() &&,
876               int (S::*)() const volatile&& noexcept > ());
877 
878 static_assert(check_equality_comparable_with<int (S::*)() && noexcept,
879                                              int (S::*)() && noexcept>());
880 static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
881               int (S::*)() const&& > ());
882 static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
883               int (S::*)() const&& noexcept > ());
884 static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
885               int (S::*)() volatile&& > ());
886 static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
887               int (S::*)() volatile&& noexcept > ());
888 static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
889               int (S::*)() const volatile&& > ());
890 static_assert(!check_equality_comparable_with < int (S::*)() && noexcept,
891               int (S::*)() const volatile&& noexcept > ());
892 
893 static_assert(check_equality_comparable_with<int (S::*)() const&&,
894                                              int (S::*)() const&&>());
895 static_assert(check_equality_comparable_with<int (S::*)() const&&,
896                                              int (S::*)() const && noexcept>());
897 static_assert(!check_equality_comparable_with<int (S::*)() const&&,
898                                               int (S::*)() volatile&&>());
899 static_assert(!check_equality_comparable_with < int (S::*)() const&&,
900               int (S::*)() volatile&& noexcept > ());
901 static_assert(!check_equality_comparable_with<int (S::*)() const&&,
902                                               int (S::*)() const volatile&&>());
903 static_assert(!check_equality_comparable_with < int (S::*)() const&&,
904               int (S::*)() const volatile&& noexcept > ());
905 
906 static_assert(check_equality_comparable_with<int (S::*)() const && noexcept,
907                                              int (S::*)() const && noexcept>());
908 static_assert(!check_equality_comparable_with < int (S::*)() const&& noexcept,
909               int (S::*)() volatile&& > ());
910 static_assert(!check_equality_comparable_with < int (S::*)() const&& noexcept,
911               int (S::*)() volatile&& noexcept > ());
912 static_assert(!check_equality_comparable_with < int (S::*)() const&& noexcept,
913               int (S::*)() const volatile&& > ());
914 static_assert(!check_equality_comparable_with < int (S::*)() const&& noexcept,
915               int (S::*)() const volatile&& noexcept > ());
916 
917 static_assert(check_equality_comparable_with<int (S::*)() volatile&&,
918                                              int (S::*)() volatile&&>());
919 static_assert(check_equality_comparable_with<
920               int (S::*)() volatile&&, int (S::*)() volatile && noexcept>());
921 static_assert(!check_equality_comparable_with<int (S::*)() volatile&&,
922                                               int (S::*)() const volatile&&>());
923 static_assert(!check_equality_comparable_with < int (S::*)() volatile&&,
924               int (S::*)() const volatile&& noexcept > ());
925 
926 static_assert(
927     check_equality_comparable_with<int (S::*)() volatile && noexcept,
928                                    int (S::*)() volatile && noexcept>());
929 static_assert(!check_equality_comparable_with <
930                   int (S::*)() volatile&& noexcept,
931               int (S::*)() const volatile&& > ());
932 static_assert(!check_equality_comparable_with <
933                   int (S::*)() volatile&& noexcept,
934               int (S::*)() const volatile&& noexcept > ());
935 
936 static_assert(check_equality_comparable_with<int (S::*)() const volatile&&,
937                                              int (S::*)() const volatile&&>());
938 static_assert(
939     check_equality_comparable_with<int (S::*)() const volatile&&,
940                                    int (S::*)() const volatile && noexcept>());
941 static_assert(
942     check_equality_comparable_with<int (S::*)() const volatile && noexcept,
943                                    int (S::*)() const volatile && noexcept>());
944 
945 static_assert(!check_equality_comparable_with<std::nullptr_t, int>());
946 static_assert(check_equality_comparable_with<std::nullptr_t, int*>());
947 static_assert(check_equality_comparable_with<std::nullptr_t, int[5]>());
948 static_assert(check_equality_comparable_with<std::nullptr_t, int (*)()>());
949 static_assert(check_equality_comparable_with<std::nullptr_t, int (&)()>());
950 static_assert(check_equality_comparable_with<std::nullptr_t, int (S::*)()>());
951 static_assert(
952     check_equality_comparable_with<std::nullptr_t, int (S::*)() noexcept>());
953 static_assert(
954     check_equality_comparable_with<std::nullptr_t, int (S::*)() const>());
955 static_assert(check_equality_comparable_with<std::nullptr_t,
956                                              int (S::*)() const noexcept>());
957 static_assert(
958     check_equality_comparable_with<std::nullptr_t, int (S::*)() volatile>());
959 static_assert(check_equality_comparable_with<std::nullptr_t,
960                                              int (S::*)() volatile noexcept>());
961 static_assert(check_equality_comparable_with<std::nullptr_t,
962                                              int (S::*)() const volatile>());
963 static_assert(check_equality_comparable_with<
964               std::nullptr_t, int (S::*)() const volatile noexcept>());
965 static_assert(check_equality_comparable_with<std::nullptr_t, int (S::*)() &>());
966 static_assert(
967     check_equality_comparable_with<std::nullptr_t, int (S::*)() & noexcept>());
968 static_assert(
969     check_equality_comparable_with<std::nullptr_t, int (S::*)() const&>());
970 static_assert(check_equality_comparable_with<std::nullptr_t,
971                                              int (S::*)() const & noexcept>());
972 static_assert(
973     check_equality_comparable_with<std::nullptr_t, int (S::*)() volatile&>());
974 static_assert(check_equality_comparable_with<
975               std::nullptr_t, int (S::*)() volatile & noexcept>());
976 static_assert(check_equality_comparable_with<std::nullptr_t,
977                                              int (S::*)() const volatile&>());
978 static_assert(check_equality_comparable_with<
979               std::nullptr_t, int (S::*)() const volatile & noexcept>());
980 static_assert(
981     check_equality_comparable_with<std::nullptr_t, int (S::*)() &&>());
982 static_assert(
983     check_equality_comparable_with<std::nullptr_t, int (S::*)() && noexcept>());
984 static_assert(
985     check_equality_comparable_with<std::nullptr_t, int (S::*)() const&&>());
986 static_assert(check_equality_comparable_with<std::nullptr_t,
987                                              int (S::*)() const && noexcept>());
988 static_assert(
989     check_equality_comparable_with<std::nullptr_t, int (S::*)() volatile&&>());
990 static_assert(check_equality_comparable_with<
991               std::nullptr_t, int (S::*)() volatile && noexcept>());
992 static_assert(check_equality_comparable_with<std::nullptr_t,
993                                              int (S::*)() const volatile&&>());
994 static_assert(check_equality_comparable_with<
995               std::nullptr_t, int (S::*)() const volatile && noexcept>());
996 
997 static_assert(!std::equality_comparable_with<void, int>);
998 static_assert(!std::equality_comparable_with<void, int*>);
999 static_assert(!std::equality_comparable_with<void, std::nullptr_t>);
1000 static_assert(!std::equality_comparable_with<void, int[5]>);
1001 static_assert(!std::equality_comparable_with<void, int (*)()>);
1002 static_assert(!std::equality_comparable_with<void, int (&)()>);
1003 static_assert(!std::equality_comparable_with<void, int S::*>);
1004 static_assert(!std::equality_comparable_with<void, int (S::*)()>);
1005 static_assert(!std::equality_comparable_with<void, int (S::*)() noexcept>);
1006 static_assert(!std::equality_comparable_with<void, int (S::*)() const>);
1007 static_assert(
1008     !std::equality_comparable_with<void, int (S::*)() const noexcept>);
1009 static_assert(!std::equality_comparable_with<void, int (S::*)() volatile>);
1010 static_assert(
1011     !std::equality_comparable_with<void, int (S::*)() volatile noexcept>);
1012 static_assert(
1013     !std::equality_comparable_with<void, int (S::*)() const volatile>);
1014 static_assert(
1015     !std::equality_comparable_with<void, int (S::*)() const volatile noexcept>);
1016 static_assert(!std::equality_comparable_with<void, int (S::*)() &>);
1017 static_assert(!std::equality_comparable_with<void, int (S::*)() & noexcept>);
1018 static_assert(!std::equality_comparable_with<void, int (S::*)() const&>);
1019 static_assert(
1020     !std::equality_comparable_with<void, int (S::*)() const & noexcept>);
1021 static_assert(!std::equality_comparable_with<void, int (S::*)() volatile&>);
1022 static_assert(
1023     !std::equality_comparable_with<void, int (S::*)() volatile & noexcept>);
1024 static_assert(
1025     !std::equality_comparable_with<void, int (S::*)() const volatile&>);
1026 static_assert(!std::equality_comparable_with<void, int (S::*)() const volatile &
1027                                                        noexcept>);
1028 static_assert(!std::equality_comparable_with<void, int (S::*)() &&>);
1029 static_assert(!std::equality_comparable_with < void,
1030               int (S::*)() && noexcept >);
1031 static_assert(!std::equality_comparable_with<void, int (S::*)() const&&>);
1032 static_assert(!std::equality_comparable_with < void,
1033               int (S::*)() const&& noexcept >);
1034 static_assert(!std::equality_comparable_with<void, int (S::*)() volatile&&>);
1035 static_assert(!std::equality_comparable_with < void,
1036               int (S::*)() volatile&& noexcept >);
1037 static_assert(
1038     !std::equality_comparable_with<void, int (S::*)() const volatile&&>);
1039 static_assert(!std::equality_comparable_with < void,
1040               int (S::*)() const volatile&& noexcept >);
1041 } // namespace fundamentals
1042 
1043 namespace standard_types {
1044 static_assert(check_equality_comparable_with<std::array<int, 10>,
1045                                              std::array<int, 10> >());
1046 static_assert(!check_equality_comparable_with<std::array<int, 10>,
1047                                               std::array<double, 10> >());
1048 static_assert(
1049     check_equality_comparable_with<std::deque<int>, std::deque<int> >());
1050 static_assert(
1051     !check_equality_comparable_with<std::deque<int>, std::vector<int> >());
1052 static_assert(check_equality_comparable_with<std::forward_list<int>,
1053                                              std::forward_list<int> >());
1054 static_assert(!check_equality_comparable_with<std::forward_list<int>,
1055                                               std::vector<int> >());
1056 static_assert(
1057     check_equality_comparable_with<std::list<int>, std::list<int> >());
1058 static_assert(
1059     !check_equality_comparable_with<std::list<int>, std::vector<int> >());
1060 
1061 #ifndef _LIBCPP_HAS_NO_THREADS
1062 static_assert(!check_equality_comparable_with<std::lock_guard<std::mutex>,
1063                                               std::lock_guard<std::mutex> >());
1064 static_assert(!check_equality_comparable_with<std::lock_guard<std::mutex>,
1065                                               std::vector<int> >());
1066 static_assert(!check_equality_comparable_with<std::mutex, std::mutex>());
1067 static_assert(!check_equality_comparable_with<std::mutex, std::vector<int> >());
1068 #endif
1069 
1070 static_assert(check_equality_comparable_with<std::map<int, void*>,
1071                                              std::map<int, void*> >());
1072 static_assert(
1073     !check_equality_comparable_with<std::map<int, void*>, std::vector<int> >());
1074 static_assert(
1075     check_equality_comparable_with<std::optional<std::vector<int> >,
1076                                    std::optional<std::vector<int> > >());
1077 static_assert(check_equality_comparable_with<std::optional<std::vector<int> >,
1078                                              std::vector<int> >());
1079 static_assert(
1080     check_equality_comparable_with<std::vector<int>, std::vector<int> >());
1081 static_assert(!check_equality_comparable_with<std::vector<int>, int>());
1082 } // namespace standard_types
1083 
1084 namespace types_fit_for_purpose {
1085 static_assert(
1086     check_equality_comparable_with<cxx20_member_eq, cxx20_member_eq>());
1087 static_assert(
1088     check_equality_comparable_with<cxx20_friend_eq, cxx20_friend_eq>());
1089 static_assert(
1090     !check_equality_comparable_with<cxx20_member_eq, cxx20_friend_eq>());
1091 
1092 static_assert(check_equality_comparable_with<member_three_way_comparable,
1093                                              member_three_way_comparable>());
1094 static_assert(check_equality_comparable_with<friend_three_way_comparable,
1095                                              friend_three_way_comparable>());
1096 static_assert(!check_equality_comparable_with<member_three_way_comparable,
1097                                               friend_three_way_comparable>());
1098 
1099 static_assert(
1100     check_equality_comparable_with<explicit_operators, explicit_operators>());
1101 static_assert(check_equality_comparable_with<equality_comparable_with_ec1,
1102                                              equality_comparable_with_ec1>());
1103 static_assert(check_equality_comparable_with<different_return_types,
1104                                              different_return_types>());
1105 static_assert(check_equality_comparable_with<explicit_operators,
1106                                              equality_comparable_with_ec1>());
1107 static_assert(check_equality_comparable_with<explicit_operators,
1108                                              different_return_types>());
1109 
1110 static_assert(check_equality_comparable_with<one_way_eq, one_way_eq>());
1111 static_assert(
1112     std::common_reference_with<one_way_eq const&, explicit_operators const&>);
1113 static_assert(
1114     !check_equality_comparable_with<one_way_eq, explicit_operators>());
1115 
1116 static_assert(check_equality_comparable_with<one_way_ne, one_way_ne>());
1117 static_assert(
1118     std::common_reference_with<one_way_ne const&, explicit_operators const&>);
1119 static_assert(
1120     !check_equality_comparable_with<one_way_ne, explicit_operators>());
1121 } // namespace types_fit_for_purpose
1122 
1123 int main(int, char**) { return 0; }
1124