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