1 //===----------------------------------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 // UNSUPPORTED: c++98, c++03, c++11, c++14
11
12 // template <class F> unspecified not_fn(F&& f);
13
14 #include <functional>
15 #include <type_traits>
16 #include <string>
17 #include <cassert>
18
19 #include "test_macros.h"
20 #include "type_id.h"
21
22
23 ///////////////////////////////////////////////////////////////////////////////
24 // CALLABLE TEST TYPES
25 ///////////////////////////////////////////////////////////////////////////////
26
returns_true()27 bool returns_true() { return true; }
28
29 template <class Ret = bool>
30 struct MoveOnlyCallable {
31 MoveOnlyCallable(MoveOnlyCallable const&) = delete;
MoveOnlyCallableMoveOnlyCallable32 MoveOnlyCallable(MoveOnlyCallable&& other)
33 : value(other.value)
34 { other.value = !other.value; }
35
36 template <class ...Args>
operator ()MoveOnlyCallable37 Ret operator()(Args&&...) { return Ret{value}; }
38
MoveOnlyCallableMoveOnlyCallable39 explicit MoveOnlyCallable(bool x) : value(x) {}
40 Ret value;
41 };
42
43 template <class Ret = bool>
44 struct CopyCallable {
CopyCallableCopyCallable45 CopyCallable(CopyCallable const& other)
46 : value(other.value) {}
47
CopyCallableCopyCallable48 CopyCallable(CopyCallable&& other)
49 : value(other.value) { other.value = !other.value; }
50
51 template <class ...Args>
operator ()CopyCallable52 Ret operator()(Args&&...) { return Ret{value}; }
53
CopyCallableCopyCallable54 explicit CopyCallable(bool x) : value(x) {}
55 Ret value;
56 };
57
58
59 template <class Ret = bool>
60 struct ConstCallable {
ConstCallableConstCallable61 ConstCallable(ConstCallable const& other)
62 : value(other.value) {}
63
ConstCallableConstCallable64 ConstCallable(ConstCallable&& other)
65 : value(other.value) { other.value = !other.value; }
66
67 template <class ...Args>
operator ()ConstCallable68 Ret operator()(Args&&...) const { return Ret{value}; }
69
ConstCallableConstCallable70 explicit ConstCallable(bool x) : value(x) {}
71 Ret value;
72 };
73
74
75
76 template <class Ret = bool>
77 struct NoExceptCallable {
NoExceptCallableNoExceptCallable78 NoExceptCallable(NoExceptCallable const& other)
79 : value(other.value) {}
80
81 template <class ...Args>
operator ()NoExceptCallable82 Ret operator()(Args&&...) noexcept { return Ret{value}; }
83
84 template <class ...Args>
operator ()NoExceptCallable85 Ret operator()(Args&&...) const noexcept { return Ret{value}; }
86
NoExceptCallableNoExceptCallable87 explicit NoExceptCallable(bool x) : value(x) {}
88 Ret value;
89 };
90
91 struct CopyAssignableWrapper {
92 CopyAssignableWrapper(CopyAssignableWrapper const&) = default;
93 CopyAssignableWrapper(CopyAssignableWrapper&&) = default;
94 CopyAssignableWrapper& operator=(CopyAssignableWrapper const&) = default;
95 CopyAssignableWrapper& operator=(CopyAssignableWrapper &&) = default;
96
97 template <class ...Args>
operator ()CopyAssignableWrapper98 bool operator()(Args&&...) { return value; }
99
CopyAssignableWrapperCopyAssignableWrapper100 explicit CopyAssignableWrapper(bool x) : value(x) {}
101 bool value;
102 };
103
104
105 struct MoveAssignableWrapper {
106 MoveAssignableWrapper(MoveAssignableWrapper const&) = delete;
107 MoveAssignableWrapper(MoveAssignableWrapper&&) = default;
108 MoveAssignableWrapper& operator=(MoveAssignableWrapper const&) = delete;
109 MoveAssignableWrapper& operator=(MoveAssignableWrapper &&) = default;
110
111 template <class ...Args>
operator ()MoveAssignableWrapper112 bool operator()(Args&&...) { return value; }
113
MoveAssignableWrapperMoveAssignableWrapper114 explicit MoveAssignableWrapper(bool x) : value(x) {}
115 bool value;
116 };
117
118 struct MemFunCallable {
MemFunCallableMemFunCallable119 explicit MemFunCallable(bool x) : value(x) {}
120
return_valueMemFunCallable121 bool return_value() const { return value; }
return_value_ncMemFunCallable122 bool return_value_nc() { return value; }
123 bool value;
124 };
125
126 enum CallType : unsigned {
127 CT_None,
128 CT_NonConst = 1,
129 CT_Const = 2,
130 CT_LValue = 4,
131 CT_RValue = 8
132 };
133
operator |(CallType LHS,CallType RHS)134 inline constexpr CallType operator|(CallType LHS, CallType RHS) {
135 return static_cast<CallType>(static_cast<unsigned>(LHS) | static_cast<unsigned>(RHS));
136 }
137
138 struct ForwardingCallObject {
139
140 template <class ...Args>
operator ()ForwardingCallObject141 bool operator()(Args&&...) & {
142 set_call<Args&&...>(CT_NonConst | CT_LValue);
143 return true;
144 }
145
146 template <class ...Args>
operator ()ForwardingCallObject147 bool operator()(Args&&...) const & {
148 set_call<Args&&...>(CT_Const | CT_LValue);
149 return true;
150 }
151
152 // Don't allow the call operator to be invoked as an rvalue.
153 template <class ...Args>
operator ()ForwardingCallObject154 bool operator()(Args&&...) && {
155 set_call<Args&&...>(CT_NonConst | CT_RValue);
156 return true;
157 }
158
159 template <class ...Args>
operator ()ForwardingCallObject160 bool operator()(Args&&...) const && {
161 set_call<Args&&...>(CT_Const | CT_RValue);
162 return true;
163 }
164
165 template <class ...Args>
set_callForwardingCallObject166 static void set_call(CallType type) {
167 assert(last_call_type == CT_None);
168 assert(last_call_args == nullptr);
169 last_call_type = type;
170 last_call_args = &makeArgumentID<Args...>();
171 }
172
173 template <class ...Args>
check_callForwardingCallObject174 static bool check_call(CallType type) {
175 bool result =
176 last_call_type == type
177 && last_call_args
178 && *last_call_args == makeArgumentID<Args...>();
179 last_call_type = CT_None;
180 last_call_args = nullptr;
181 return result;
182 }
183
184 static CallType last_call_type;
185 static TypeID const* last_call_args;
186 };
187
188 CallType ForwardingCallObject::last_call_type = CT_None;
189 TypeID const* ForwardingCallObject::last_call_args = nullptr;
190
191
192
193 ///////////////////////////////////////////////////////////////////////////////
194 // BOOL TEST TYPES
195 ///////////////////////////////////////////////////////////////////////////////
196
197 struct EvilBool {
198 static int bang_called;
199
200 EvilBool(EvilBool const&) = default;
201 EvilBool(EvilBool&&) = default;
202
operator !(EvilBool const & other)203 friend EvilBool operator!(EvilBool const& other) {
204 ++bang_called;
205 return EvilBool{!other.value};
206 }
207
208 private:
209 friend struct MoveOnlyCallable<EvilBool>;
210 friend struct CopyCallable<EvilBool>;
211 friend struct NoExceptCallable<EvilBool>;
212
EvilBoolEvilBool213 explicit EvilBool(bool x) : value(x) {}
214 EvilBool& operator=(EvilBool const& other) = default;
215
216 public:
217 bool value;
218 };
219
220 int EvilBool::bang_called = 0;
221
222 struct ExplicitBool {
223 ExplicitBool(ExplicitBool const&) = default;
224 ExplicitBool(ExplicitBool&&) = default;
225
operator boolExplicitBool226 explicit operator bool() const { return value; }
227
228 private:
229 friend struct MoveOnlyCallable<ExplicitBool>;
230 friend struct CopyCallable<ExplicitBool>;
231
ExplicitBoolExplicitBool232 explicit ExplicitBool(bool x) : value(x) {}
operator =ExplicitBool233 ExplicitBool& operator=(bool x) {
234 value = x;
235 return *this;
236 }
237
238 bool value;
239 };
240
241
242 struct NoExceptEvilBool {
243 NoExceptEvilBool(NoExceptEvilBool const&) = default;
244 NoExceptEvilBool(NoExceptEvilBool&&) = default;
245 NoExceptEvilBool& operator=(NoExceptEvilBool const& other) = default;
246
NoExceptEvilBoolNoExceptEvilBool247 explicit NoExceptEvilBool(bool x) : value(x) {}
248
operator !(NoExceptEvilBool const & other)249 friend NoExceptEvilBool operator!(NoExceptEvilBool const& other) noexcept {
250 return NoExceptEvilBool{!other.value};
251 }
252
253 bool value;
254 };
255
256
257
constructor_tests()258 void constructor_tests()
259 {
260 {
261 using T = MoveOnlyCallable<bool>;
262 T value(true);
263 using RetT = decltype(std::not_fn(std::move(value)));
264 static_assert(std::is_move_constructible<RetT>::value, "");
265 static_assert(!std::is_copy_constructible<RetT>::value, "");
266 static_assert(!std::is_move_assignable<RetT>::value, "");
267 static_assert(!std::is_copy_assignable<RetT>::value, "");
268 auto ret = std::not_fn(std::move(value));
269 // test it was moved from
270 assert(value.value == false);
271 // test that ret() negates the original value 'true'
272 assert(ret() == false);
273 assert(ret(0, 0.0, "blah") == false);
274 // Move ret and test that it was moved from and that ret2 got the
275 // original value.
276 auto ret2 = std::move(ret);
277 assert(ret() == true);
278 assert(ret2() == false);
279 assert(ret2(42) == false);
280 }
281 {
282 using T = CopyCallable<bool>;
283 T value(false);
284 using RetT = decltype(std::not_fn(value));
285 static_assert(std::is_move_constructible<RetT>::value, "");
286 static_assert(std::is_copy_constructible<RetT>::value, "");
287 static_assert(!std::is_move_assignable<RetT>::value, "");
288 static_assert(!std::is_copy_assignable<RetT>::value, "");
289 auto ret = std::not_fn(value);
290 // test that value is unchanged (copied not moved)
291 assert(value.value == false);
292 // test 'ret' has the original value
293 assert(ret() == true);
294 assert(ret(42, 100) == true);
295 // move from 'ret' and check that 'ret2' has the original value.
296 auto ret2 = std::move(ret);
297 assert(ret() == false);
298 assert(ret2() == true);
299 assert(ret2("abc") == true);
300 }
301 {
302 using T = CopyAssignableWrapper;
303 T value(true);
304 T value2(false);
305 using RetT = decltype(std::not_fn(value));
306 static_assert(std::is_move_constructible<RetT>::value, "");
307 static_assert(std::is_copy_constructible<RetT>::value, "");
308 static_assert(std::is_move_assignable<RetT>::value, "");
309 static_assert(std::is_copy_assignable<RetT>::value, "");
310 auto ret = std::not_fn(value);
311 assert(ret() == false);
312 auto ret2 = std::not_fn(value2);
313 assert(ret2() == true);
314 ret = ret2;
315 assert(ret() == true);
316 assert(ret2() == true);
317 }
318 {
319 using T = MoveAssignableWrapper;
320 T value(true);
321 T value2(false);
322 using RetT = decltype(std::not_fn(std::move(value)));
323 static_assert(std::is_move_constructible<RetT>::value, "");
324 static_assert(!std::is_copy_constructible<RetT>::value, "");
325 static_assert(std::is_move_assignable<RetT>::value, "");
326 static_assert(!std::is_copy_assignable<RetT>::value, "");
327 auto ret = std::not_fn(std::move(value));
328 assert(ret() == false);
329 auto ret2 = std::not_fn(std::move(value2));
330 assert(ret2() == true);
331 ret = std::move(ret2);
332 assert(ret() == true);
333 }
334 }
335
return_type_tests()336 void return_type_tests()
337 {
338 using std::is_same;
339 {
340 using T = CopyCallable<bool>;
341 auto ret = std::not_fn(T{false});
342 static_assert(is_same<decltype(ret()), bool>::value, "");
343 static_assert(is_same<decltype(ret("abc")), bool>::value, "");
344 assert(ret() == true);
345 }
346 {
347 using T = CopyCallable<ExplicitBool>;
348 auto ret = std::not_fn(T{true});
349 static_assert(is_same<decltype(ret()), bool>::value, "");
350 static_assert(is_same<decltype(ret(std::string("abc"))), bool>::value, "");
351 assert(ret() == false);
352 }
353 {
354 using T = CopyCallable<EvilBool>;
355 auto ret = std::not_fn(T{false});
356 static_assert(is_same<decltype(ret()), EvilBool>::value, "");
357 EvilBool::bang_called = 0;
358 auto value_ret = ret();
359 assert(EvilBool::bang_called == 1);
360 assert(value_ret.value == true);
361 ret();
362 assert(EvilBool::bang_called == 2);
363 }
364 }
365
366 // Other tests only test using objects with call operators. Test various
367 // other callable types here.
other_callable_types_test()368 void other_callable_types_test()
369 {
370 { // test with function pointer
371 auto ret = std::not_fn(returns_true);
372 assert(ret() == false);
373 }
374 { // test with lambda
375 auto returns_value = [](bool value) { return value; };
376 auto ret = std::not_fn(returns_value);
377 assert(ret(true) == false);
378 assert(ret(false) == true);
379 }
380 { // test with pointer to member function
381 MemFunCallable mt(true);
382 const MemFunCallable mf(false);
383 auto ret = std::not_fn(&MemFunCallable::return_value);
384 assert(ret(mt) == false);
385 assert(ret(mf) == true);
386 assert(ret(&mt) == false);
387 assert(ret(&mf) == true);
388 }
389 { // test with pointer to member function
390 MemFunCallable mt(true);
391 MemFunCallable mf(false);
392 auto ret = std::not_fn(&MemFunCallable::return_value_nc);
393 assert(ret(mt) == false);
394 assert(ret(mf) == true);
395 assert(ret(&mt) == false);
396 assert(ret(&mf) == true);
397 }
398 { // test with pointer to member data
399 MemFunCallable mt(true);
400 const MemFunCallable mf(false);
401 auto ret = std::not_fn(&MemFunCallable::value);
402 assert(ret(mt) == false);
403 assert(ret(mf) == true);
404 assert(ret(&mt) == false);
405 assert(ret(&mf) == true);
406 }
407 }
408
throws_in_constructor_test()409 void throws_in_constructor_test()
410 {
411 #ifndef TEST_HAS_NO_EXCEPTIONS
412 struct ThrowsOnCopy {
413 ThrowsOnCopy(ThrowsOnCopy const&) {
414 throw 42;
415 }
416 ThrowsOnCopy() = default;
417 bool operator()() const {
418 assert(false);
419 #if defined(_LIBCPP_MSVC)
420 __assume(0);
421 #else
422 __builtin_unreachable();
423 #endif
424 }
425 };
426 {
427 ThrowsOnCopy cp;
428 try {
429 std::not_fn(cp);
430 assert(false);
431 } catch (int const& value) {
432 assert(value == 42);
433 }
434 }
435 #endif
436 }
437
call_operator_sfinae_test()438 void call_operator_sfinae_test() {
439 { // wrong number of arguments
440 using T = decltype(std::not_fn(returns_true));
441 static_assert(std::is_callable<T()>::value, ""); // callable only with no args
442 static_assert(!std::is_callable<T(bool)>::value, "");
443 }
444 { // violates const correctness (member function pointer)
445 using T = decltype(std::not_fn(&MemFunCallable::return_value_nc));
446 static_assert(std::is_callable<T(MemFunCallable&)>::value, "");
447 static_assert(!std::is_callable<T(const MemFunCallable&)>::value, "");
448 }
449 { // violates const correctness (call object)
450 using Obj = CopyCallable<bool>;
451 using NCT = decltype(std::not_fn(Obj{true}));
452 using CT = const NCT;
453 static_assert(std::is_callable<NCT()>::value, "");
454 static_assert(!std::is_callable<CT()>::value, "");
455 }
456 { // returns bad type with no operator!
457 auto fn = [](auto x) { return x; };
458 using T = decltype(std::not_fn(fn));
459 static_assert(std::is_callable<T(bool)>::value, "");
460 static_assert(!std::is_callable<T(std::string)>::value, "");
461 }
462 }
463
call_operator_forwarding_test()464 void call_operator_forwarding_test()
465 {
466 using Fn = ForwardingCallObject;
467 auto obj = std::not_fn(Fn{});
468 const auto& c_obj = obj;
469 { // test zero args
470 obj();
471 assert(Fn::check_call<>(CT_NonConst | CT_LValue));
472 std::move(obj)();
473 assert(Fn::check_call<>(CT_NonConst | CT_RValue));
474 c_obj();
475 assert(Fn::check_call<>(CT_Const | CT_LValue));
476 std::move(c_obj)();
477 assert(Fn::check_call<>(CT_Const | CT_RValue));
478 }
479 { // test value categories
480 int x = 42;
481 const int cx = 42;
482 obj(x);
483 assert(Fn::check_call<int&>(CT_NonConst | CT_LValue));
484 obj(cx);
485 assert(Fn::check_call<const int&>(CT_NonConst | CT_LValue));
486 obj(std::move(x));
487 assert(Fn::check_call<int&&>(CT_NonConst | CT_LValue));
488 obj(std::move(cx));
489 assert(Fn::check_call<const int&&>(CT_NonConst | CT_LValue));
490 obj(42);
491 assert(Fn::check_call<int&&>(CT_NonConst | CT_LValue));
492 }
493 { // test value categories - rvalue
494 int x = 42;
495 const int cx = 42;
496 std::move(obj)(x);
497 assert(Fn::check_call<int&>(CT_NonConst | CT_RValue));
498 std::move(obj)(cx);
499 assert(Fn::check_call<const int&>(CT_NonConst | CT_RValue));
500 std::move(obj)(std::move(x));
501 assert(Fn::check_call<int&&>(CT_NonConst | CT_RValue));
502 std::move(obj)(std::move(cx));
503 assert(Fn::check_call<const int&&>(CT_NonConst | CT_RValue));
504 std::move(obj)(42);
505 assert(Fn::check_call<int&&>(CT_NonConst | CT_RValue));
506 }
507 { // test value categories - const call
508 int x = 42;
509 const int cx = 42;
510 c_obj(x);
511 assert(Fn::check_call<int&>(CT_Const | CT_LValue));
512 c_obj(cx);
513 assert(Fn::check_call<const int&>(CT_Const | CT_LValue));
514 c_obj(std::move(x));
515 assert(Fn::check_call<int&&>(CT_Const | CT_LValue));
516 c_obj(std::move(cx));
517 assert(Fn::check_call<const int&&>(CT_Const | CT_LValue));
518 c_obj(42);
519 assert(Fn::check_call<int&&>(CT_Const | CT_LValue));
520 }
521 { // test value categories - const call rvalue
522 int x = 42;
523 const int cx = 42;
524 std::move(c_obj)(x);
525 assert(Fn::check_call<int&>(CT_Const | CT_RValue));
526 std::move(c_obj)(cx);
527 assert(Fn::check_call<const int&>(CT_Const | CT_RValue));
528 std::move(c_obj)(std::move(x));
529 assert(Fn::check_call<int&&>(CT_Const | CT_RValue));
530 std::move(c_obj)(std::move(cx));
531 assert(Fn::check_call<const int&&>(CT_Const | CT_RValue));
532 std::move(c_obj)(42);
533 assert(Fn::check_call<int&&>(CT_Const | CT_RValue));
534 }
535 { // test multi arg
536 const double y = 3.14;
537 std::string s = "abc";
538 obj(42, std::move(y), s, std::string{"foo"});
539 Fn::check_call<int&&, const double&&, std::string&, std::string&&>(CT_NonConst | CT_LValue);
540 std::move(obj)(42, std::move(y), s, std::string{"foo"});
541 Fn::check_call<int&&, const double&&, std::string&, std::string&&>(CT_NonConst | CT_RValue);
542 c_obj(42, std::move(y), s, std::string{"foo"});
543 Fn::check_call<int&&, const double&&, std::string&, std::string&&>(CT_Const | CT_LValue);
544 std::move(c_obj)(42, std::move(y), s, std::string{"foo"});
545 Fn::check_call<int&&, const double&&, std::string&, std::string&&>(CT_Const | CT_RValue);
546 }
547 }
548
call_operator_noexcept_test()549 void call_operator_noexcept_test()
550 {
551 {
552 using T = ConstCallable<bool>;
553 T value(true);
554 auto ret = std::not_fn(value);
555 static_assert(!noexcept(ret()), "call should not be noexcept");
556 auto const& cret = ret;
557 static_assert(!noexcept(cret()), "call should not be noexcept");
558 }
559 {
560 using T = NoExceptCallable<bool>;
561 T value(true);
562 auto ret = std::not_fn(value);
563 LIBCPP_STATIC_ASSERT(noexcept(!_VSTD::__invoke(value)), "");
564 #if TEST_STD_VER > 14
565 static_assert(noexcept(!std::invoke(value)), "");
566 #endif
567 static_assert(noexcept(ret()), "call should be noexcept");
568 auto const& cret = ret;
569 static_assert(noexcept(cret()), "call should be noexcept");
570 }
571 {
572 using T = NoExceptCallable<NoExceptEvilBool>;
573 T value(true);
574 auto ret = std::not_fn(value);
575 static_assert(noexcept(ret()), "call should not be noexcept");
576 auto const& cret = ret;
577 static_assert(noexcept(cret()), "call should not be noexcept");
578 }
579 {
580 using T = NoExceptCallable<EvilBool>;
581 T value(true);
582 auto ret = std::not_fn(value);
583 static_assert(!noexcept(ret()), "call should not be noexcept");
584 auto const& cret = ret;
585 static_assert(!noexcept(cret()), "call should not be noexcept");
586 }
587 }
588
test_lwg2767()589 void test_lwg2767() {
590 // See http://wg21.link/LWG2767
591 struct Abstract { virtual void f() const = 0; };
592 struct Derived : public Abstract { void f() const {} };
593 struct F { bool operator()(Abstract&&) { return false; } };
594 {
595 Derived d;
596 Abstract &a = d;
597 bool b = std::not_fn(F{})(std::move(a));
598 assert(b);
599 }
600 }
601
main()602 int main()
603 {
604 constructor_tests();
605 return_type_tests();
606 other_callable_types_test();
607 throws_in_constructor_test();
608 call_operator_sfinae_test(); // somewhat of an extension
609 call_operator_forwarding_test();
610 call_operator_noexcept_test();
611 test_lwg2767();
612 }
613