2 * Copyright 2017-present Facebook, Inc.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 #include <folly/lang/PropagateConst.h>
21 #include <folly/portability/GTest.h>
23 using namespace folly;
25 class PropagateConstTest : public testing::Test {};
27 // force complete template instantiations
28 template class folly::propagate_const<int*>;
29 template class folly::propagate_const<std::unique_ptr<int>>;
30 template class folly::propagate_const<std::shared_ptr<int>>;
33 static bool is_const(T&&) {
34 return std::is_const<_t<std::remove_reference<T>>>::value;
38 using pc = propagate_const<T>;
40 TEST_F(PropagateConstTest, construct_assign) {
48 /* implicit */ Implicit(Source) {}
53 explicit Explicit(Source) {}
56 EXPECT_TRUE((std::is_constructible<pc<Implicit>, Source>::value));
57 EXPECT_TRUE((std::is_constructible<pc<Explicit>, Source>::value));
58 EXPECT_TRUE((std::is_convertible<Source, pc<Implicit>>::value));
59 EXPECT_FALSE((std::is_convertible<Source, pc<Explicit>>::value));
60 EXPECT_TRUE((std::is_assignable<pc<Implicit>, Source>::value));
61 EXPECT_FALSE((std::is_assignable<pc<Explicit>, Source>::value));
63 EXPECT_TRUE((std::is_constructible<pc<Implicit>, pc<Source>>::value));
64 EXPECT_TRUE((std::is_constructible<pc<Explicit>, pc<Source>>::value));
65 EXPECT_TRUE((std::is_convertible<pc<Source>, pc<Implicit>>::value));
66 EXPECT_FALSE((std::is_convertible<pc<Source>, pc<Explicit>>::value));
67 EXPECT_TRUE((std::is_assignable<pc<Implicit>, pc<Source>>::value));
68 EXPECT_FALSE((std::is_assignable<pc<Explicit>, pc<Source>>::value));
71 TEST_F(PropagateConstTest, op_assign_move) {
72 auto ptr = pc<std::unique_ptr<int>>{std::make_unique<int>(1)};
75 ptr = std::make_unique<int>(2);
79 TEST_F(PropagateConstTest, get) {
81 auto pc_a = pc<int*>(&a);
83 EXPECT_EQ(&a, pc_a.get());
84 EXPECT_EQ(&a, as_const(pc_a).get());
85 EXPECT_FALSE(is_const(*pc_a.get()));
86 EXPECT_TRUE(is_const(*as_const(pc_a).get()));
89 TEST_F(PropagateConstTest, op_indirect) {
91 auto pc_a = pc<int*>(&a);
93 EXPECT_EQ(&a, &*pc_a);
94 EXPECT_EQ(&a, &*as_const(pc_a));
95 EXPECT_FALSE(is_const(*pc_a));
96 EXPECT_TRUE(is_const(*as_const(pc_a)));
99 TEST_F(PropagateConstTest, op_element_type_ptr) {
101 auto pc_a = pc<int*>(&a);
103 EXPECT_EQ(&a, static_cast<int*>(pc_a));
104 EXPECT_EQ(&a, static_cast<int const*>(as_const(pc_a)));
107 TEST_F(PropagateConstTest, op_bool) {
109 auto pc_a = pc<int*>(&a);
110 auto pc_0 = pc<int*>(nullptr);
116 TEST_F(PropagateConstTest, get_underlying) {
118 auto pc_a = pc<int*>(&a);
120 EXPECT_EQ(&a, get_underlying(pc_a));
121 EXPECT_EQ(&a, get_underlying(as_const(pc_a)));
122 EXPECT_FALSE(is_const(get_underlying(pc_a)));
123 EXPECT_TRUE(is_const(get_underlying(as_const(pc_a))));
124 EXPECT_TRUE(&get_underlying(pc_a) == &get_underlying(as_const(pc_a)));
127 TEST_F(PropagateConstTest, swap) {
130 auto pc_a = pc<int*>(&a);
131 auto pc_b = pc<int*>(&b);
142 TEST_F(PropagateConstTest, op_equal_to) {
145 auto pc_a = pc<int*>(&a);
146 auto pc_b = pc<int*>(&b);
148 auto _ = [](auto&& x, auto&& y) { return x == y; };
149 EXPECT_TRUE(_(pc_a, pc_a));
150 EXPECT_FALSE(_(pc_a, pc_b));
151 EXPECT_FALSE(_(pc_a, nullptr));
152 EXPECT_TRUE(_(pc_a, &a));
153 EXPECT_FALSE(_(pc_a, &b));
154 EXPECT_TRUE(_(&a, pc_a));
155 EXPECT_FALSE(_(&b, pc_a));
158 TEST_F(PropagateConstTest, op_not_equal_to) {
161 auto pc_a = pc<int*>(&a);
162 auto pc_b = pc<int*>(&b);
164 auto _ = [](auto&& x, auto&& y) { return x != y; };
165 EXPECT_FALSE(_(pc_a, pc_a));
166 EXPECT_TRUE(_(pc_a, pc_b));
167 EXPECT_TRUE(_(pc_a, nullptr));
168 EXPECT_FALSE(_(pc_a, &a));
169 EXPECT_TRUE(_(pc_a, &b));
170 EXPECT_FALSE(_(&a, pc_a));
171 EXPECT_TRUE(_(&b, pc_a));
174 TEST_F(PropagateConstTest, op_less) {
177 auto pc_a = pc<int*>(&a);
178 auto pc_b = pc<int*>(&b);
180 auto _ = [](auto&& x, auto&& y) { return x < y; };
181 EXPECT_FALSE(_(pc_a, pc_a));
182 EXPECT_FALSE(_(pc_a, &a));
183 EXPECT_FALSE(_(&a, pc_a));
184 EXPECT_TRUE(_(pc_a, pc_b));
185 EXPECT_TRUE(_(pc_a, &b));
186 EXPECT_TRUE(_(&a, pc_b));
187 EXPECT_FALSE(_(pc_b, pc_a));
188 EXPECT_FALSE(_(pc_b, &a));
189 EXPECT_FALSE(_(&b, pc_a));
190 EXPECT_FALSE(_(pc_b, pc_b));
191 EXPECT_FALSE(_(pc_b, &b));
192 EXPECT_FALSE(_(&b, pc_b));
195 TEST_F(PropagateConstTest, op_greater) {
198 auto pc_a = pc<int*>(&a);
199 auto pc_b = pc<int*>(&b);
201 auto _ = [](auto&& x, auto&& y) { return x > y; };
202 EXPECT_FALSE(_(pc_a, pc_a));
203 EXPECT_FALSE(_(pc_a, &a));
204 EXPECT_FALSE(_(&a, pc_a));
205 EXPECT_FALSE(_(pc_a, pc_b));
206 EXPECT_FALSE(_(pc_a, &b));
207 EXPECT_FALSE(_(&a, pc_b));
208 EXPECT_TRUE(_(pc_b, pc_a));
209 EXPECT_TRUE(_(pc_b, &a));
210 EXPECT_TRUE(_(&b, pc_a));
211 EXPECT_FALSE(_(pc_b, pc_b));
212 EXPECT_FALSE(_(pc_b, &b));
213 EXPECT_FALSE(_(&b, pc_b));
216 TEST_F(PropagateConstTest, op_less_equal) {
219 auto pc_a = pc<int*>(&a);
220 auto pc_b = pc<int*>(&b);
222 auto _ = [](auto&& x, auto&& y) { return x <= y; };
223 EXPECT_TRUE(_(pc_a, pc_a));
224 EXPECT_TRUE(_(pc_a, &a));
225 EXPECT_TRUE(_(&a, pc_a));
226 EXPECT_TRUE(_(pc_a, pc_b));
227 EXPECT_TRUE(_(pc_a, &b));
228 EXPECT_TRUE(_(&a, pc_b));
229 EXPECT_FALSE(_(pc_b, pc_a));
230 EXPECT_FALSE(_(pc_b, &a));
231 EXPECT_FALSE(_(&b, pc_a));
232 EXPECT_TRUE(_(pc_b, pc_b));
233 EXPECT_TRUE(_(pc_b, &b));
234 EXPECT_TRUE(_(&b, pc_b));
237 TEST_F(PropagateConstTest, op_greater_equal) {
240 auto pc_a = pc<int*>(&a);
241 auto pc_b = pc<int*>(&b);
243 auto _ = [](auto&& x, auto&& y) { return x >= y; };
244 EXPECT_TRUE(_(pc_a, pc_a));
245 EXPECT_TRUE(_(pc_a, &a));
246 EXPECT_TRUE(_(&a, pc_a));
247 EXPECT_FALSE(_(pc_a, pc_b));
248 EXPECT_FALSE(_(pc_a, &b));
249 EXPECT_FALSE(_(&a, pc_b));
250 EXPECT_TRUE(_(pc_b, pc_a));
251 EXPECT_TRUE(_(pc_b, &a));
252 EXPECT_TRUE(_(&b, pc_a));
253 EXPECT_TRUE(_(pc_b, pc_b));
254 EXPECT_TRUE(_(pc_b, &b));
255 EXPECT_TRUE(_(&b, pc_b));
258 TEST_F(PropagateConstTest, hash) {
260 auto pc_a = pc<int*>(&a);
262 EXPECT_EQ(std::hash<int*>()(&a), std::hash<pc<int*>>()(pc_a));
265 TEST_F(PropagateConstTest, equal_to) {
268 auto pc_a = pc<int*>(&a);
269 auto pc_b = pc<int*>(&b);
271 auto _ = std::equal_to<pc<int*>>{};
272 EXPECT_TRUE(_(pc_a, pc_a));
273 EXPECT_FALSE(_(pc_a, pc_b));
276 TEST_F(PropagateConstTest, not_equal_to) {
279 auto pc_a = pc<int*>(&a);
280 auto pc_b = pc<int*>(&b);
282 auto _ = std::not_equal_to<pc<int*>>{};
283 EXPECT_FALSE(_(pc_a, pc_a));
284 EXPECT_TRUE(_(pc_a, pc_b));
287 TEST_F(PropagateConstTest, less) {
290 auto pc_a = pc<int*>(&a);
291 auto pc_b = pc<int*>(&b);
293 auto _ = std::less<pc<int*>>{};
294 EXPECT_FALSE(_(pc_a, pc_a));
295 EXPECT_TRUE(_(pc_a, pc_b));
296 EXPECT_FALSE(_(pc_b, pc_a));
297 EXPECT_FALSE(_(pc_b, pc_b));
300 TEST_F(PropagateConstTest, greater) {
303 auto pc_a = pc<int*>(&a);
304 auto pc_b = pc<int*>(&b);
306 auto _ = std::greater<pc<int*>>{};
307 EXPECT_FALSE(_(pc_a, pc_a));
308 EXPECT_FALSE(_(pc_a, pc_b));
309 EXPECT_TRUE(_(pc_b, pc_a));
310 EXPECT_FALSE(_(pc_b, pc_b));
313 TEST_F(PropagateConstTest, less_equal) {
316 auto pc_a = pc<int*>(&a);
317 auto pc_b = pc<int*>(&b);
319 auto _ = std::less_equal<pc<int*>>{};
320 EXPECT_TRUE(_(pc_a, pc_a));
321 EXPECT_TRUE(_(pc_a, pc_b));
322 EXPECT_FALSE(_(pc_b, pc_a));
323 EXPECT_TRUE(_(pc_b, pc_b));
326 TEST_F(PropagateConstTest, greater_equal) {
329 auto pc_a = pc<int*>(&a);
330 auto pc_b = pc<int*>(&b);
332 auto _ = std::greater_equal<pc<int*>>{};
333 EXPECT_TRUE(_(pc_a, pc_a));
334 EXPECT_FALSE(_(pc_a, pc_b));
335 EXPECT_TRUE(_(pc_b, pc_a));
336 EXPECT_TRUE(_(pc_b, pc_b));