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 //  A set of routines for testing the comparison operators of a type
9 //
10 //      FooOrder<expected-ordering>  All seven comparison operators, requires C++20 or newer.
11 //      FooComparison                All six pre-C++20 comparison operators
12 //      FooEquality                  Equality operators operator== and operator!=
13 //
14 //      AssertXAreNoexcept           static_asserts that the operations are all noexcept.
15 //      AssertXReturnBool            static_asserts that the operations return bool.
16 //      AssertOrderReturn            static_asserts that the pre-C++20 comparison operations
17 //                                   return bool and operator<=> returns the proper type.
18 //      AssertXConvertibleToBool     static_asserts that the operations return something convertible to bool.
19 //      testXValues                  returns the result of the comparison of all operations.
20 //
21 //      AssertOrderConvertibleToBool doesn't exist yet. It will be implemented when needed.
22 
23 #ifndef TEST_COMPARISONS_H
24 #define TEST_COMPARISONS_H
25 
26 #include <type_traits>
27 #include <cassert>
28 #include "test_macros.h"
29 
30 //  Test all six comparison operations for sanity
31 template <class T, class U = T>
32 TEST_CONSTEXPR_CXX14 bool testComparisons(const T& t1, const U& t2, bool isEqual, bool isLess)
33 {
34     assert(!(isEqual && isLess) && "isEqual and isLess cannot be both true");
35     if (isEqual)
36         {
37         if (!(t1 == t2)) return false;
38         if (!(t2 == t1)) return false;
39         if ( (t1 != t2)) return false;
40         if ( (t2 != t1)) return false;
41         if ( (t1  < t2)) return false;
42         if ( (t2  < t1)) return false;
43         if (!(t1 <= t2)) return false;
44         if (!(t2 <= t1)) return false;
45         if ( (t1  > t2)) return false;
46         if ( (t2  > t1)) return false;
47         if (!(t1 >= t2)) return false;
48         if (!(t2 >= t1)) return false;
49         }
50     else if (isLess)
51         {
52         if ( (t1 == t2)) return false;
53         if ( (t2 == t1)) return false;
54         if (!(t1 != t2)) return false;
55         if (!(t2 != t1)) return false;
56         if (!(t1  < t2)) return false;
57         if ( (t2  < t1)) return false;
58         if (!(t1 <= t2)) return false;
59         if ( (t2 <= t1)) return false;
60         if ( (t1  > t2)) return false;
61         if (!(t2  > t1)) return false;
62         if ( (t1 >= t2)) return false;
63         if (!(t2 >= t1)) return false;
64         }
65     else /* greater */
66         {
67         if ( (t1 == t2)) return false;
68         if ( (t2 == t1)) return false;
69         if (!(t1 != t2)) return false;
70         if (!(t2 != t1)) return false;
71         if ( (t1  < t2)) return false;
72         if (!(t2  < t1)) return false;
73         if ( (t1 <= t2)) return false;
74         if (!(t2 <= t1)) return false;
75         if (!(t1  > t2)) return false;
76         if ( (t2  > t1)) return false;
77         if (!(t1 >= t2)) return false;
78         if ( (t2 >= t1)) return false;
79         }
80 
81     return true;
82 }
83 
84 //  Easy call when you can init from something already comparable.
85 template <class T, class Param>
86 TEST_CONSTEXPR_CXX14 bool testComparisonsValues(Param val1, Param val2)
87 {
88     const bool isEqual = val1 == val2;
89     const bool isLess  = val1  < val2;
90 
91     return testComparisons(T(val1), T(val2), isEqual, isLess);
92 }
93 
94 template <class T, class U = T>
95 void AssertComparisonsAreNoexcept()
96 {
97     ASSERT_NOEXCEPT(std::declval<const T&>() == std::declval<const U&>());
98     ASSERT_NOEXCEPT(std::declval<const T&>() != std::declval<const U&>());
99     ASSERT_NOEXCEPT(std::declval<const T&>() <  std::declval<const U&>());
100     ASSERT_NOEXCEPT(std::declval<const T&>() <= std::declval<const U&>());
101     ASSERT_NOEXCEPT(std::declval<const T&>() >  std::declval<const U&>());
102     ASSERT_NOEXCEPT(std::declval<const T&>() >= std::declval<const U&>());
103 }
104 
105 template <class T, class U = T>
106 void AssertComparisonsReturnBool()
107 {
108     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() == std::declval<const U&>()), bool);
109     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() != std::declval<const U&>()), bool);
110     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() <  std::declval<const U&>()), bool);
111     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() <= std::declval<const U&>()), bool);
112     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() >  std::declval<const U&>()), bool);
113     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() >= std::declval<const U&>()), bool);
114 }
115 
116 
117 template <class T, class U = T>
118 void AssertComparisonsConvertibleToBool()
119 {
120     static_assert((std::is_convertible<decltype(std::declval<const T&>() == std::declval<const U&>()), bool>::value), "");
121     static_assert((std::is_convertible<decltype(std::declval<const T&>() != std::declval<const U&>()), bool>::value), "");
122     static_assert((std::is_convertible<decltype(std::declval<const T&>() <  std::declval<const U&>()), bool>::value), "");
123     static_assert((std::is_convertible<decltype(std::declval<const T&>() <= std::declval<const U&>()), bool>::value), "");
124     static_assert((std::is_convertible<decltype(std::declval<const T&>() >  std::declval<const U&>()), bool>::value), "");
125     static_assert((std::is_convertible<decltype(std::declval<const T&>() >= std::declval<const U&>()), bool>::value), "");
126 }
127 
128 #if TEST_STD_VER > 17
129 template <class T, class U = T>
130 void AssertOrderAreNoexcept() {
131   AssertComparisonsAreNoexcept<T, U>();
132   ASSERT_NOEXCEPT(std::declval<const T&>() <=> std::declval<const U&>());
133 }
134 
135 template <class Order, class T, class U = T>
136 void AssertOrderReturn() {
137   AssertComparisonsReturnBool<T, U>();
138   ASSERT_SAME_TYPE(decltype(std::declval<const T&>() <=> std::declval<const U&>()), Order);
139 }
140 
141 template <class Order, class T, class U = T>
142 constexpr bool testOrder(const T& t1, const U& t2, Order order) {
143   return (t1 <=> t2 == order) &&
144          testComparisons(t1, t2, order == Order::equal || order == Order::equivalent, order == Order::less);
145 }
146 
147 template <class T, class Param>
148 constexpr bool testOrderValues(Param val1, Param val2) {
149   return testOrder(T(val1), T(val2), val1 <=> val2);
150 }
151 
152 #endif
153 
154 //  Test all two comparison operations for sanity
155 template <class T, class U = T>
156 TEST_CONSTEXPR_CXX14 bool testEquality(const T& t1, const U& t2, bool isEqual)
157 {
158     if (isEqual)
159         {
160         if (!(t1 == t2)) return false;
161         if (!(t2 == t1)) return false;
162         if ( (t1 != t2)) return false;
163         if ( (t2 != t1)) return false;
164         }
165     else /* not equal */
166         {
167         if ( (t1 == t2)) return false;
168         if ( (t2 == t1)) return false;
169         if (!(t1 != t2)) return false;
170         if (!(t2 != t1)) return false;
171         }
172 
173     return true;
174 }
175 
176 //  Easy call when you can init from something already comparable.
177 template <class T, class Param>
178 TEST_CONSTEXPR_CXX14 bool testEqualityValues(Param val1, Param val2)
179 {
180     const bool isEqual = val1 == val2;
181 
182     return testEquality(T(val1), T(val2), isEqual);
183 }
184 
185 template <class T, class U = T>
186 void AssertEqualityAreNoexcept()
187 {
188     ASSERT_NOEXCEPT(std::declval<const T&>() == std::declval<const U&>());
189     ASSERT_NOEXCEPT(std::declval<const T&>() != std::declval<const U&>());
190 }
191 
192 template <class T, class U = T>
193 void AssertEqualityReturnBool()
194 {
195     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() == std::declval<const U&>()), bool);
196     ASSERT_SAME_TYPE(decltype(std::declval<const T&>() != std::declval<const U&>()), bool);
197 }
198 
199 
200 template <class T, class U = T>
201 void AssertEqualityConvertibleToBool()
202 {
203     static_assert((std::is_convertible<decltype(std::declval<const T&>() == std::declval<const U&>()), bool>::value), "");
204     static_assert((std::is_convertible<decltype(std::declval<const T&>() != std::declval<const U&>()), bool>::value), "");
205 }
206 
207 struct LessAndEqComp {
208   int value;
209 
210   TEST_CONSTEXPR_CXX14 LessAndEqComp(int v) : value(v) {}
211 
212   friend TEST_CONSTEXPR_CXX14 bool operator<(const LessAndEqComp& lhs, const LessAndEqComp& rhs) {
213     return lhs.value < rhs.value;
214   }
215 
216   friend TEST_CONSTEXPR_CXX14 bool operator==(const LessAndEqComp& lhs, const LessAndEqComp& rhs) {
217     return lhs.value == rhs.value;
218   }
219 };
220 #endif // TEST_COMPARISONS_H
221