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