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