1 | //===----------------------------------------------------------------------===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | |
9 | // UNSUPPORTED: c++03, c++11, c++14, c++17 |
10 | |
11 | // template<class T> |
12 | // concept equality_comparable = // see below |
13 | |
14 | #include <concepts> |
15 | |
16 | #include <array> |
17 | #include <cstddef> |
18 | #include <deque> |
19 | #include <forward_list> |
20 | #include <list> |
21 | #include <map> |
22 | #include <optional> |
23 | #include <set> |
24 | #include <unordered_map> |
25 | #include <unordered_set> |
26 | #include <vector> |
27 | |
28 | #include "compare_types.h" |
29 | #include "test_macros.h" |
30 | |
31 | namespace fundamentals { |
32 | static_assert(std::equality_comparable<int>); |
33 | static_assert(std::equality_comparable<double>); |
34 | static_assert(std::equality_comparable<void*>); |
35 | static_assert(std::equality_comparable<char*>); |
36 | static_assert(std::equality_comparable<char const*>); |
37 | static_assert(std::equality_comparable<char volatile*>); |
38 | static_assert(std::equality_comparable<char const volatile*>); |
39 | static_assert(std::equality_comparable<wchar_t&>); |
40 | static_assert(std::equality_comparable<char8_t const&>); |
41 | static_assert(std::equality_comparable<char16_t volatile&>); |
42 | static_assert(std::equality_comparable<char32_t const volatile&>); |
43 | static_assert(std::equality_comparable<unsigned char&&>); |
44 | static_assert(std::equality_comparable<unsigned short const&&>); |
45 | static_assert(std::equality_comparable<unsigned int volatile&&>); |
46 | static_assert(std::equality_comparable<unsigned long const volatile&&>); |
47 | // Array comparisons are ill-formed in C++26, but Clang doesn't implement this yet. |
48 | #if TEST_STD_VER <= 23 || defined(TEST_COMPILER_CLANG) |
49 | static_assert(std::equality_comparable<int[5]>); |
50 | #else |
51 | static_assert(!std::equality_comparable<int[5]>); |
52 | #endif |
53 | static_assert(std::equality_comparable<int (*)(int)>); |
54 | static_assert(std::equality_comparable<int (&)(int)>); |
55 | static_assert(std::equality_comparable<int (*)(int) noexcept>); |
56 | static_assert(std::equality_comparable<int (&)(int) noexcept>); |
57 | static_assert(std::equality_comparable<std::nullptr_t>); |
58 | |
59 | struct S {}; |
60 | static_assert(std::equality_comparable<int S::*>); |
61 | static_assert(std::equality_comparable<int (S::*)()>); |
62 | static_assert(std::equality_comparable<int (S::*)() noexcept>); |
63 | static_assert(std::equality_comparable<int (S::*)() &>); |
64 | static_assert(std::equality_comparable<int (S::*)() & noexcept>); |
65 | static_assert(std::equality_comparable<int (S::*)() &&>); |
66 | static_assert(std::equality_comparable<int (S::*)() && noexcept>); |
67 | static_assert(std::equality_comparable<int (S::*)() const>); |
68 | static_assert(std::equality_comparable<int (S::*)() const noexcept>); |
69 | static_assert(std::equality_comparable<int (S::*)() const&>); |
70 | static_assert(std::equality_comparable<int (S::*)() const & noexcept>); |
71 | static_assert(std::equality_comparable<int (S::*)() const&&>); |
72 | static_assert(std::equality_comparable<int (S::*)() const && noexcept>); |
73 | static_assert(std::equality_comparable<int (S::*)() volatile>); |
74 | static_assert(std::equality_comparable<int (S::*)() volatile noexcept>); |
75 | static_assert(std::equality_comparable<int (S::*)() volatile&>); |
76 | static_assert(std::equality_comparable<int (S::*)() volatile & noexcept>); |
77 | static_assert(std::equality_comparable<int (S::*)() volatile&&>); |
78 | static_assert(std::equality_comparable<int (S::*)() volatile && noexcept>); |
79 | static_assert(std::equality_comparable<int (S::*)() const volatile>); |
80 | static_assert(std::equality_comparable<int (S::*)() const volatile noexcept>); |
81 | static_assert(std::equality_comparable<int (S::*)() const volatile&>); |
82 | static_assert(std::equality_comparable<int (S::*)() const volatile & noexcept>); |
83 | static_assert(std::equality_comparable<int (S::*)() const volatile&&>); |
84 | static_assert( |
85 | std::equality_comparable<int (S::*)() const volatile && noexcept>); |
86 | |
87 | static_assert(!std::equality_comparable<void>); |
88 | } // namespace fundamentals |
89 | |
90 | namespace standard_types { |
91 | static_assert(std::equality_comparable<std::array<int, 10>>); |
92 | static_assert(std::equality_comparable<std::deque<int>>); |
93 | static_assert(std::equality_comparable<std::forward_list<int>>); |
94 | static_assert(std::equality_comparable<std::list<int>>); |
95 | static_assert(std::equality_comparable<std::map<int, void*>>); |
96 | static_assert(std::equality_comparable<std::optional<int>>); |
97 | static_assert(std::equality_comparable<std::set<int>>); |
98 | static_assert(std::equality_comparable<std::unordered_map<int, void*>>); |
99 | static_assert(std::equality_comparable<std::unordered_set<int>>); |
100 | static_assert(std::equality_comparable<std::vector<bool>>); |
101 | static_assert(std::equality_comparable<std::vector<int>>); |
102 | } // namespace standard_types |
103 | |
104 | namespace types_fit_for_purpose { |
105 | static_assert(std::equality_comparable<cxx20_member_eq>); |
106 | static_assert(std::equality_comparable<cxx20_friend_eq>); |
107 | static_assert(std::equality_comparable<member_three_way_comparable>); |
108 | static_assert(std::equality_comparable<friend_three_way_comparable>); |
109 | static_assert(std::equality_comparable<explicit_operators>); |
110 | static_assert(std::equality_comparable<different_return_types>); |
111 | static_assert(std::equality_comparable<one_member_one_friend>); |
112 | static_assert(std::equality_comparable<equality_comparable_with_ec1>); |
113 | |
114 | static_assert(!std::equality_comparable<no_eq>); |
115 | static_assert(!std::equality_comparable<no_neq>); |
116 | static_assert(std::equality_comparable<no_lt>); |
117 | static_assert(std::equality_comparable<no_gt>); |
118 | static_assert(std::equality_comparable<no_le>); |
119 | static_assert(std::equality_comparable<no_ge>); |
120 | |
121 | static_assert(!std::equality_comparable<wrong_return_type_eq>); |
122 | static_assert(!std::equality_comparable<wrong_return_type_ne>); |
123 | static_assert(std::equality_comparable<wrong_return_type_lt>); |
124 | static_assert(std::equality_comparable<wrong_return_type_gt>); |
125 | static_assert(std::equality_comparable<wrong_return_type_le>); |
126 | static_assert(std::equality_comparable<wrong_return_type_ge>); |
127 | static_assert(!std::equality_comparable<wrong_return_type>); |
128 | static_assert( |
129 | !std::equality_comparable<cxx20_member_eq_operator_with_deleted_ne>); |
130 | static_assert( |
131 | !std::equality_comparable<cxx20_friend_eq_operator_with_deleted_ne>); |
132 | static_assert( |
133 | !std::equality_comparable<member_three_way_comparable_with_deleted_eq>); |
134 | static_assert( |
135 | !std::equality_comparable<member_three_way_comparable_with_deleted_ne>); |
136 | static_assert( |
137 | !std::equality_comparable<friend_three_way_comparable_with_deleted_eq>); |
138 | static_assert( |
139 | !std::equality_comparable<friend_three_way_comparable_with_deleted_ne>); |
140 | |
141 | static_assert(!std::equality_comparable<eq_returns_explicit_bool>); |
142 | static_assert(!std::equality_comparable<ne_returns_explicit_bool>); |
143 | static_assert(std::equality_comparable<lt_returns_explicit_bool>); |
144 | static_assert(std::equality_comparable<gt_returns_explicit_bool>); |
145 | static_assert(std::equality_comparable<le_returns_explicit_bool>); |
146 | static_assert(std::equality_comparable<ge_returns_explicit_bool>); |
147 | static_assert(std::equality_comparable<returns_true_type>); |
148 | static_assert(std::equality_comparable<returns_int_ptr>); |
149 | } // namespace types_fit_for_purpose |
150 | |