[libcxx] r267973 - Move INVOKE tests into test/libcxx sub-tree.
Eric Fiselier via cfe-commits
cfe-commits at lists.llvm.org
Thu Apr 28 18:52:58 PDT 2016
Author: ericwf
Date: Thu Apr 28 20:52:57 2016
New Revision: 267973
URL: http://llvm.org/viewvc/llvm-project?rev=267973&view=rev
Log:
Move INVOKE tests into test/libcxx sub-tree.
Testing the concrete implementation of INVOKE means calling the implementation
specific names `__invoke` and `__invoke_constexpr`. For this reason the test
are non-standard. For this reason it's best if the tests live outside of the
`test/std` directory.
Added:
libcxx/trunk/test/libcxx/utilities/function.objects/
libcxx/trunk/test/libcxx/utilities/function.objects/func.require/
libcxx/trunk/test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp
libcxx/trunk/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
libcxx/trunk/test/libcxx/utilities/function.objects/func.require/bullet_7.pass.cpp
libcxx/trunk/test/libcxx/utilities/function.objects/func.require/invoke.pass.cpp
libcxx/trunk/test/libcxx/utilities/function.objects/func.require/invoke_helpers.h
libcxx/trunk/test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp
Removed:
libcxx/trunk/test/std/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp
libcxx/trunk/test/std/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
libcxx/trunk/test/std/utilities/function.objects/func.require/bullet_7.pass.cpp
libcxx/trunk/test/std/utilities/function.objects/func.require/invoke.pass.cpp
libcxx/trunk/test/std/utilities/function.objects/func.require/invoke_helpers.h
Added: libcxx/trunk/test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp?rev=267973&view=auto
==============================================================================
--- libcxx/trunk/test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp (added)
+++ libcxx/trunk/test/libcxx/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp Thu Apr 28 20:52:57 2016
@@ -0,0 +1,370 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// INVOKE (f, t1, t2, ..., tN)
+
+//------------------------------------------------------------------------------
+// TESTING INVOKE(f, t1, t2, ..., tN)
+// - Bullet 1 -- (t1.*f)(t2, ..., tN)
+// - Bullet 2 -- (t1.get().*f)(t2, ..., tN) // t1 is a reference_wrapper
+// - Bullet 3 -- ((*t1).*f)(t2, ..., tN)
+//
+// Overview:
+// Bullets 1, 2 and 3 handle the case where 'f' is a pointer to member function.
+// Bullet 1 only handles the cases where t1 is an object of type T or a
+// type derived from 'T'. Bullet 2 handles the case where 't1' is a reference
+// wrapper and bullet 3 handles all other cases.
+//
+// Concerns:
+// 1) cv-qualified member function signatures are accepted.
+// 2) reference qualified member function signatures are accepted.
+// 3) member functions with varargs at the end are accepted.
+// 4) The arguments are perfect forwarded to the member function call.
+// 5) Classes that are publicly derived from 'T' are accepted as the call object
+// 6) All types that dereference to T or a type derived from T can be used
+// as the call object.
+// 7) Pointers to T or a type derived from T can be used as the call object.
+// 8) Reference return types are properly deduced.
+// 9) reference_wrappers are properly handled and unwrapped.
+//
+//
+// Plan:
+// 1) Create a class that contains a set, 'S', of non-static functions.
+// 'S' should include functions that cover every single combination
+// of qualifiers and varargs for arities of 0, 1 and 2 (C-1,2,3).
+// The argument types used in the functions should be non-copyable (C-4).
+// The functions should return 'MethodID::setUncheckedCall()'.
+//
+// 2) Create a set of supported call object, 'Objs', of different types
+// and behaviors. (C-5,6,7)
+//
+// 3) Attempt to call each function, 'f', in 'S' with each call object, 'c',
+// in 'Objs'. After every attempted call to 'f' check that 'f' was
+// actually called using 'MethodID::checkCalled(<return-value>)'
+//
+// 3b) If 'f' is reference qualified call 'f' with the properly qualified
+// call object. Otherwise call 'f' with lvalue call objects.
+//
+// 3a) If 'f' is const, volatile, or cv qualified then call it with call
+// objects that are equally or less cv-qualified.
+
+#include <functional>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "invoke_helpers.h"
+
+//==============================================================================
+// MemFun03 - C++03 compatible set of test member functions.
+struct MemFun03 {
+ typedef void*& R;
+#define F(...) \
+ R f(__VA_ARGS__) { return MethodID<R(MemFun03::*)(__VA_ARGS__)>::setUncheckedCall(); } \
+ R f(__VA_ARGS__) const { return MethodID<R(MemFun03::*)(__VA_ARGS__) const>::setUncheckedCall(); } \
+ R f(__VA_ARGS__) volatile { return MethodID<R(MemFun03::*)(__VA_ARGS__) volatile>::setUncheckedCall(); } \
+ R f(__VA_ARGS__) const volatile { return MethodID<R(MemFun03::*)(__VA_ARGS__) const volatile>::setUncheckedCall(); }
+#
+ F()
+ F(...)
+ F(ArgType&)
+ F(ArgType&, ...)
+ F(ArgType&, ArgType&)
+ F(ArgType&, ArgType&, ...)
+ F(ArgType&, ArgType&, ArgType&)
+ F(ArgType&, ArgType&, ArgType&, ...)
+#undef F
+public:
+ MemFun03() {}
+private:
+ MemFun03(MemFun03 const&);
+ MemFun03& operator=(MemFun03 const&);
+};
+
+
+#if TEST_STD_VER >= 11
+
+//==============================================================================
+// MemFun11 - C++11 reference qualified test member functions.
+struct MemFun11 {
+ typedef void*& R;
+ typedef MemFun11 C;
+#define F(...) \
+ R f(__VA_ARGS__) & { return MethodID<R(C::*)(__VA_ARGS__) &>::setUncheckedCall(); } \
+ R f(__VA_ARGS__) const & { return MethodID<R(C::*)(__VA_ARGS__) const &>::setUncheckedCall(); } \
+ R f(__VA_ARGS__) volatile & { return MethodID<R(C::*)(__VA_ARGS__) volatile &>::setUncheckedCall(); } \
+ R f(__VA_ARGS__) const volatile & { return MethodID<R(C::*)(__VA_ARGS__) const volatile &>::setUncheckedCall(); } \
+ R f(__VA_ARGS__) && { return MethodID<R(C::*)(__VA_ARGS__) &&>::setUncheckedCall(); } \
+ R f(__VA_ARGS__) const && { return MethodID<R(C::*)(__VA_ARGS__) const &&>::setUncheckedCall(); } \
+ R f(__VA_ARGS__) volatile && { return MethodID<R(C::*)(__VA_ARGS__) volatile &&>::setUncheckedCall(); } \
+ R f(__VA_ARGS__) const volatile && { return MethodID<R(C::*)(__VA_ARGS__) const volatile &&>::setUncheckedCall(); }
+#
+ F()
+ F(...)
+ F(ArgType&&)
+ F(ArgType&&, ...)
+ F(ArgType&&, ArgType&&)
+ F(ArgType&&, ArgType&&, ...)
+ F(ArgType&&, ArgType&&, ArgType&&)
+ F(ArgType&&, ArgType&&, ArgType&&, ...)
+#undef F
+public:
+ MemFun11() {}
+private:
+ MemFun11(MemFun11 const&);
+ MemFun11& operator=(MemFun11 const&);
+};
+
+#endif // TEST_STD_VER >= 11
+
+
+
+//==============================================================================
+// TestCase - A test case for a single member function.
+// ClassType - The type of the class being tested.
+// CallSig - The function signature of the method being tested.
+// Arity - the arity of 'CallSig'
+// CV - the cv qualifiers of 'CallSig' represented as a type tag.
+// RValue - The method is RValue qualified.
+// ArgRValue - Call the method with RValue arguments.
+template <class ClassType, class CallSig, int Arity, class CV,
+ bool RValue = false, bool ArgRValue = false>
+struct TestCaseImp {
+public:
+
+ static void run() { TestCaseImp().doTest(); }
+
+private:
+ //==========================================================================
+ // TEST DISPATCH
+ void doTest() {
+ // (Plan-2) Create test call objects.
+ typedef ClassType T;
+ typedef DerivedFromType<T> D;
+ T obj;
+ T* obj_ptr = &obj;
+ D der;
+ D* der_ptr = &der;
+ DerefToType<T> dref;
+ DerefPropType<T> dref2;
+ std::reference_wrapper<T> rref(obj);
+ std::reference_wrapper<D> drref(der);
+
+ // (Plan-3) Dispatch based on the CV tags.
+ CV tag;
+ Bool<!RValue> NotRValue;
+ runTestDispatch(tag, obj);
+ runTestDispatch(tag, der);
+ runTestDispatch(tag, dref2);
+ runTestDispatchIf(NotRValue, tag, dref);
+ runTestDispatchIf(NotRValue, tag, obj_ptr);
+ runTestDispatchIf(NotRValue, tag, der_ptr);
+#if TEST_STD_VER >= 11
+ runTestDispatchIf(NotRValue, tag, rref);
+ runTestDispatchIf(NotRValue, tag, drref);
+#endif
+ }
+
+ template <class QT, class Tp>
+ void runTestDispatchIf(Bool<true>, QT q, Tp& v) {
+ runTestDispatch(q, v);
+ }
+
+ template <class QT, class Tp>
+ void runTestDispatchIf(Bool<false>, QT, Tp&) {
+ }
+
+ template <class Tp>
+ void runTestDispatch(Q_None, Tp& v) {
+ runTest(v);
+ }
+
+ template <class Tp>
+ void runTestDispatch(Q_Const, Tp& v) {
+ runTest(v);
+ runTest(makeConst(v));
+ }
+
+ template <class Tp>
+ void runTestDispatch(Q_Volatile, Tp& v) {
+ runTest(v);
+ runTest(makeVolatile(v));
+
+ }
+
+ template <class Tp>
+ void runTestDispatch(Q_CV, Tp& v) {
+ runTest(v);
+ runTest(makeConst(v));
+ runTest(makeVolatile(v));
+ runTest(makeCV(v));
+ }
+
+ template <class T>
+ void runTest(const std::reference_wrapper<T>& obj) {
+ typedef Caster<Q_None, RValue> SCast;
+ typedef Caster<Q_None, ArgRValue> ACast;
+ typedef CallSig (ClassType::*MemPtr);
+ // Delegate test to logic in invoke_helpers.h
+ BasicTest<MethodID<MemPtr>, Arity, SCast, ACast> b;
+ b.runTest( (MemPtr)&ClassType::f, obj);
+ }
+
+ template <class T>
+ void runTest(T* obj) {
+ typedef Caster<Q_None, RValue> SCast;
+ typedef Caster<Q_None, ArgRValue> ACast;
+ typedef CallSig (ClassType::*MemPtr);
+ // Delegate test to logic in invoke_helpers.h
+ BasicTest<MethodID<MemPtr>, Arity, SCast, ACast> b;
+ b.runTest( (MemPtr)&ClassType::f, obj);
+ }
+
+ template <class Obj>
+ void runTest(Obj& obj) {
+ typedef Caster<Q_None, RValue> SCast;
+ typedef Caster<Q_None, ArgRValue> ACast;
+ typedef CallSig (ClassType::*MemPtr);
+ // Delegate test to logic in invoke_helpers.h
+ BasicTest<MethodID<MemPtr>, Arity, SCast, ACast> b;
+ b.runTest( (MemPtr)&ClassType::f, obj);
+ }
+};
+
+template <class Sig, int Arity, class CV>
+struct TestCase : public TestCaseImp<MemFun03, Sig, Arity, CV> {};
+
+#if TEST_STD_VER >= 11
+template <class Sig, int Arity, class CV, bool RValue = false>
+struct TestCase11 : public TestCaseImp<MemFun11, Sig, Arity, CV, RValue, true> {};
+#endif
+
+template <class Tp>
+struct DerivedFromRefWrap : public std::reference_wrapper<Tp> {
+ DerivedFromRefWrap(Tp& tp) : std::reference_wrapper<Tp>(tp) {}
+};
+
+#if TEST_STD_VER >= 11
+void test_derived_from_ref_wrap() {
+ int x = 42;
+ std::reference_wrapper<int> r(x);
+ std::reference_wrapper<std::reference_wrapper<int>> r2(r);
+ DerivedFromRefWrap<int> d(x);
+ auto get_fn = &std::reference_wrapper<int>::get;
+ auto& ret = std::__invoke(get_fn, r);
+ auto& cret = std::__invoke_constexpr(get_fn, r);
+ assert(&ret == &x);
+ assert(&cret == &x);
+ auto& ret2 = std::__invoke(get_fn, d);
+ auto& cret2 = std::__invoke_constexpr(get_fn, d);
+ assert(&ret2 == &x);
+ auto& ret3 = std::__invoke(get_fn, r2);
+ assert(&ret3 == &x);
+}
+#endif
+
+int main() {
+ typedef void*& R;
+ typedef ArgType A;
+ TestCase<R(), 0, Q_None>::run();
+ TestCase<R() const, 0, Q_Const>::run();
+ TestCase<R() volatile, 0, Q_Volatile>::run();
+ TestCase<R() const volatile, 0, Q_CV>::run();
+ TestCase<R(...), 0, Q_None>::run();
+ TestCase<R(...) const, 0, Q_Const>::run();
+ TestCase<R(...) volatile, 0, Q_Volatile>::run();
+ TestCase<R(...) const volatile, 0, Q_CV>::run();
+ TestCase<R(A&), 1, Q_None>::run();
+ TestCase<R(A&) const, 1, Q_Const>::run();
+ TestCase<R(A&) volatile, 1, Q_Volatile>::run();
+ TestCase<R(A&) const volatile, 1, Q_CV>::run();
+ TestCase<R(A&, ...), 1, Q_None>::run();
+ TestCase<R(A&, ...) const, 1, Q_Const>::run();
+ TestCase<R(A&, ...) volatile, 1, Q_Volatile>::run();
+ TestCase<R(A&, ...) const volatile, 1, Q_CV>::run();
+ TestCase<R(A&, A&), 2, Q_None>::run();
+ TestCase<R(A&, A&) const, 2, Q_Const>::run();
+ TestCase<R(A&, A&) volatile, 2, Q_Volatile>::run();
+ TestCase<R(A&, A&) const volatile, 2, Q_CV>::run();
+ TestCase<R(A&, A&, ...), 2, Q_None>::run();
+ TestCase<R(A&, A&, ...) const, 2, Q_Const>::run();
+ TestCase<R(A&, A&, ...) volatile, 2, Q_Volatile>::run();
+ TestCase<R(A&, A&, ...) const volatile, 2, Q_CV>::run();
+ TestCase<R(A&, A&, A&), 3, Q_None>::run();
+ TestCase<R(A&, A&, A&) const, 3, Q_Const>::run();
+ TestCase<R(A&, A&, A&) volatile, 3, Q_Volatile>::run();
+ TestCase<R(A&, A&, A&) const volatile, 3, Q_CV>::run();
+ TestCase<R(A&, A&, A&, ...), 3, Q_None>::run();
+ TestCase<R(A&, A&, A&, ...) const, 3, Q_Const>::run();
+ TestCase<R(A&, A&, A&, ...) volatile, 3, Q_Volatile>::run();
+ TestCase<R(A&, A&, A&, ...) const volatile, 3, Q_CV>::run();
+
+#if TEST_STD_VER >= 11
+ TestCase11<R() &, 0, Q_None>::run();
+ TestCase11<R() const &, 0, Q_Const>::run();
+ TestCase11<R() volatile &, 0, Q_Volatile>::run();
+ TestCase11<R() const volatile &, 0, Q_CV>::run();
+ TestCase11<R(...) &, 0, Q_None>::run();
+ TestCase11<R(...) const &, 0, Q_Const>::run();
+ TestCase11<R(...) volatile &, 0, Q_Volatile>::run();
+ TestCase11<R(...) const volatile &, 0, Q_CV>::run();
+ TestCase11<R(A&&) &, 1, Q_None>::run();
+ TestCase11<R(A&&) const &, 1, Q_Const>::run();
+ TestCase11<R(A&&) volatile &, 1, Q_Volatile>::run();
+ TestCase11<R(A&&) const volatile &, 1, Q_CV>::run();
+ TestCase11<R(A&&, ...) &, 1, Q_None>::run();
+ TestCase11<R(A&&, ...) const &, 1, Q_Const>::run();
+ TestCase11<R(A&&, ...) volatile &, 1, Q_Volatile>::run();
+ TestCase11<R(A&&, ...) const volatile &, 1, Q_CV>::run();
+ TestCase11<R(A&&, A&&) &, 2, Q_None>::run();
+ TestCase11<R(A&&, A&&) const &, 2, Q_Const>::run();
+ TestCase11<R(A&&, A&&) volatile &, 2, Q_Volatile>::run();
+ TestCase11<R(A&&, A&&) const volatile &, 2, Q_CV>::run();
+ TestCase11<R(A&&, A&&, ...) &, 2, Q_None>::run();
+ TestCase11<R(A&&, A&&, ...) const &, 2, Q_Const>::run();
+ TestCase11<R(A&&, A&&, ...) volatile &, 2, Q_Volatile>::run();
+ TestCase11<R(A&&, A&&, ...) const volatile &, 2, Q_CV>::run();
+ TestCase11<R() &&, 0, Q_None, /* RValue */ true>::run();
+ TestCase11<R() const &&, 0, Q_Const, /* RValue */ true>::run();
+ TestCase11<R() volatile &&, 0, Q_Volatile, /* RValue */ true>::run();
+ TestCase11<R() const volatile &&, 0, Q_CV, /* RValue */ true>::run();
+ TestCase11<R(...) &&, 0, Q_None, /* RValue */ true>::run();
+ TestCase11<R(...) const &&, 0, Q_Const, /* RValue */ true>::run();
+ TestCase11<R(...) volatile &&, 0, Q_Volatile, /* RValue */ true>::run();
+ TestCase11<R(...) const volatile &&, 0, Q_CV, /* RValue */ true>::run();
+ TestCase11<R(A&&) &&, 1, Q_None, /* RValue */ true>::run();
+ TestCase11<R(A&&) const &&, 1, Q_Const, /* RValue */ true>::run();
+ TestCase11<R(A&&) volatile &&, 1, Q_Volatile, /* RValue */ true>::run();
+ TestCase11<R(A&&) const volatile &&, 1, Q_CV, /* RValue */ true>::run();
+ TestCase11<R(A&&, ...) &&, 1, Q_None, /* RValue */ true>::run();
+ TestCase11<R(A&&, ...) const &&, 1, Q_Const, /* RValue */ true>::run();
+ TestCase11<R(A&&, ...) volatile &&, 1, Q_Volatile, /* RValue */ true>::run();
+ TestCase11<R(A&&, ...) const volatile &&, 1, Q_CV, /* RValue */ true>::run();
+ TestCase11<R(A&&, A&&) &&, 2, Q_None, /* RValue */ true>::run();
+ TestCase11<R(A&&, A&&) const &&, 2, Q_Const, /* RValue */ true>::run();
+ TestCase11<R(A&&, A&&) volatile &&, 2, Q_Volatile, /* RValue */ true>::run();
+ TestCase11<R(A&&, A&&) const volatile &&, 2, Q_CV, /* RValue */ true>::run();
+ TestCase11<R(A&&, A&&, ...) &&, 2, Q_None, /* RValue */ true>::run();
+ TestCase11<R(A&&, A&&, ...) const &&, 2, Q_Const, /* RValue */ true>::run();
+ TestCase11<R(A&&, A&&, ...) volatile &&, 2, Q_Volatile, /* RValue */ true>::run();
+ TestCase11<R(A&&, A&&, ...) const volatile &&, 2, Q_CV, /* RValue */ true>::run();
+ TestCase11<R(A&&, A&&, A&&) &&, 3, Q_None, /* RValue */ true>::run();
+ TestCase11<R(A&&, A&&, A&&) const &&, 3, Q_Const, /* RValue */ true>::run();
+ TestCase11<R(A&&, A&&, A&&) volatile &&, 3, Q_Volatile, /* RValue */ true>::run();
+ TestCase11<R(A&&, A&&, A&&) const volatile &&, 3, Q_CV, /* RValue */ true>::run();
+ TestCase11<R(A&&, A&&, A&&, ...) &&, 3, Q_None, /* RValue */ true>::run();
+ TestCase11<R(A&&, A&&, A&&, ...) const &&, 3, Q_Const, /* RValue */ true>::run();
+ TestCase11<R(A&&, A&&, A&&, ...) volatile &&, 3, Q_Volatile, /* RValue */ true>::run();
+ TestCase11<R(A&&, A&&, A&&, ...) const volatile &&, 3, Q_CV, /* RValue */ true>::run();
+
+ test_derived_from_ref_wrap();
+#endif
+}
\ No newline at end of file
Added: libcxx/trunk/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp?rev=267973&view=auto
==============================================================================
--- libcxx/trunk/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp (added)
+++ libcxx/trunk/test/libcxx/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp Thu Apr 28 20:52:57 2016
@@ -0,0 +1,216 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// INVOKE (f, t1, t2, ..., tN)
+
+//------------------------------------------------------------------------------
+// TESTING INVOKE(f, t1, t2, ..., tN)
+// - Bullet 4 -- t1.*f
+// - Bullet 5 -- t1.get().*f // t1 is a reference wrapper.
+// - Bullet 6 -- (*t1).*f
+//
+// Overview:
+// Bullets 4, 5 and 6 handle the case where 'f' is a pointer to member object.
+// Bullet 4 only handles the cases where t1 is an object of type T or a
+// type derived from 'T'. Bullet 5 handles cases where 't1' is a reference_wrapper
+// and bullet 6 handles all other cases.
+//
+// Concerns:
+// 1) The return type is always an lvalue reference.
+// 2) The return type is not less cv-qualified that the object that contains it.
+// 3) The return type is not less cv-qualified than object type.
+// 4) The call object is perfectly forwarded.
+// 5) Classes that are publicly derived from 'T' are accepted as the call object
+// 6) All types that dereference to T or a type derived from T can be used
+// as the call object.
+// 7) Pointers to T or a type derived from T can be used as the call object.
+// 8) reference_wrapper's are properly unwrapped before invoking the function.
+
+#include <functional>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "invoke_helpers.h"
+
+template <class Tp>
+struct TestMemberObject {
+ TestMemberObject() : object() {}
+ Tp object;
+private:
+ TestMemberObject(TestMemberObject const&);
+ TestMemberObject& operator=(TestMemberObject const&);
+};
+
+template <class ObjectType>
+struct TestCase {
+ public:
+
+ static void run() { TestCase().doTest(); }
+
+private:
+ typedef TestMemberObject<ObjectType> TestType;
+
+ //==========================================================================
+ // TEST DISPATCH
+ void doTest() {
+ typedef DerivedFromType<TestType> Derived;
+ TestType obj;
+ TestType* obj_ptr = &obj;
+ Derived der;
+ Derived* der_ptr = &der;
+ DerefToType<TestType> dref;
+ DerefPropType<TestType> dref2;
+ std::reference_wrapper<TestType> rref(obj);
+ std::reference_wrapper<Derived> drref(der);
+
+ {
+ typedef ObjectType (TestType::*MemPtr);
+ typedef ObjectType E;
+ MemPtr M = &TestType::object;
+ runTestDispatch<E>(M, obj, &obj.object);
+ runTestDispatch<E>(M, der, &der.object);
+ runTestDispatch<E>(M, dref2, &dref2.object.object);
+ runTestPropCVDispatch<E>(M, obj_ptr, &obj_ptr->object);
+ runTestPropCVDispatch<E>(M, der_ptr, &der_ptr->object);
+#if TEST_STD_VER >= 11
+ runTestPropCVDispatch<E>(M, rref, &(rref.get().object));
+ runTestPropCVDispatch<E>(M, drref, &(drref.get().object));
+#endif
+ runTestNoPropDispatch<E>(M, dref, &dref.object.object);
+ }
+ {
+ typedef ObjectType const (TestType::*CMemPtr);
+ typedef ObjectType const E;
+ CMemPtr M = &TestType::object;
+ runTestDispatch<E>(M, obj, &obj.object);
+ runTestDispatch<E>(M, der, &der.object);
+ runTestDispatch<E>(M, dref2, &dref2.object.object);
+ runTestPropCVDispatch<E>(M, obj_ptr, &obj_ptr->object);
+ runTestPropCVDispatch<E>(M, der_ptr, &der_ptr->object);
+#if TEST_STD_VER >= 11
+ runTestPropCVDispatch<E>(M, rref, &(rref.get().object));
+ runTestPropCVDispatch<E>(M, drref, &(drref.get().object));
+#endif
+ runTestNoPropDispatch<E>(M, dref, &dref.object.object);
+ }
+ {
+ typedef ObjectType volatile (TestType::*VMemPtr);
+ typedef ObjectType volatile E;
+ VMemPtr M = &TestType::object;
+ runTestDispatch<E>(M, obj, &obj.object);
+ runTestDispatch<E>(M, der, &der.object);
+ runTestDispatch<E>(M, dref2, &dref2.object.object);
+ runTestPropCVDispatch<E>(M, obj_ptr, &obj_ptr->object);
+ runTestPropCVDispatch<E>(M, der_ptr, &der_ptr->object);
+#if TEST_STD_VER >= 11
+ runTestPropCVDispatch<E>(M, rref, &(rref.get().object));
+ runTestPropCVDispatch<E>(M, drref, &(drref.get().object));
+#endif
+ runTestNoPropDispatch<E>(M, dref, &dref.object.object);
+ }
+ {
+ typedef ObjectType const volatile (TestType::*CVMemPtr);
+ typedef ObjectType const volatile E;
+ CVMemPtr M = &TestType::object;
+ runTestDispatch<E>(M, obj, &obj.object);
+ runTestDispatch<E>(M, der, &der.object);
+ runTestDispatch<E>(M, dref2, &dref2.object.object);
+ runTestPropCVDispatch<E>(M, obj_ptr, &obj_ptr->object);
+ runTestPropCVDispatch<E>(M, der_ptr, &der_ptr->object);
+#if TEST_STD_VER >= 11
+ runTestPropCVDispatch<E>(M, rref, &(rref.get().object));
+ runTestPropCVDispatch<E>(M, drref, &(drref.get().object));
+#endif
+ runTestNoPropDispatch<E>(M, dref, &dref.object.object);
+ }
+ }
+
+ template <class Expect, class Fn, class T>
+ void runTestDispatch(Fn M, T& obj, ObjectType* expect) {
+ runTest<Expect &> (M, C_<T&>(obj), expect);
+ runTest<Expect const&> (M, C_<T const&>(obj), expect);
+ runTest<Expect volatile&> (M, C_<T volatile&>(obj), expect);
+ runTest<Expect const volatile&>(M, C_<T const volatile&>(obj), expect);
+#if TEST_STD_VER >= 11
+ runTest<Expect&&> (M, C_<T&&>(obj), expect);
+ runTest<Expect const&&> (M, C_<T const&&>(obj), expect);
+ runTest<Expect volatile&&> (M, C_<T volatile&&>(obj), expect);
+ runTest<Expect const volatile&&>(M, C_<T const volatile&&>(obj), expect);
+#endif
+ }
+
+ template <class Expect, class Fn, class T>
+ void runTestPropCVDispatch(Fn M, T& obj, ObjectType* expect) {
+ runTest<Expect &> (M, obj, expect);
+ runTest<Expect const&> (M, makeConst(obj), expect);
+ runTest<Expect volatile&> (M, makeVolatile(obj), expect);
+ runTest<Expect const volatile&>(M, makeCV(obj), expect);
+ }
+
+ template <class Expect, class Fn, class T>
+ void runTestNoPropDispatch(Fn M, T& obj, ObjectType* expect) {
+ runTest<Expect&>(M, C_<T &>(obj), expect);
+ runTest<Expect&>(M, C_<T const&>(obj), expect);
+ runTest<Expect&>(M, C_<T volatile&>(obj), expect);
+ runTest<Expect&>(M, C_<T const volatile&>(obj), expect);
+#if TEST_STD_VER >= 11
+ runTest<Expect&>(M, C_<T&&>(obj), expect);
+ runTest<Expect&>(M, C_<T const&&>(obj), expect);
+ runTest<Expect&>(M, C_<T volatile&&>(obj), expect);
+ runTest<Expect&>(M, C_<T const volatile&&>(obj), expect);
+#endif
+ }
+
+ template <class Expect, class Fn, class T>
+ void runTest(Fn M, const T& obj, ObjectType* expect) {
+ static_assert((std::is_same<
+ decltype(std::__invoke(M, obj)), Expect
+ >::value), "");
+ Expect e = std::__invoke(M, obj);
+ assert(&e == expect);
+ }
+
+ template <class Expect, class Fn, class T>
+#if TEST_STD_VER >= 11
+ void runTest(Fn M, T&& obj, ObjectType* expect) {
+#else
+ void runTest(Fn M, T& obj, ObjectType* expect ) {
+#endif
+ {
+ static_assert((std::is_same<
+ decltype(std::__invoke(M, std::forward<T>(obj))), Expect
+ >::value), "");
+ Expect e = std::__invoke(M, std::forward<T>(obj));
+ assert(&e == expect);
+ }
+#if TEST_STD_VER >= 11
+ {
+ static_assert((std::is_same<
+ decltype(std::__invoke_constexpr(M, std::forward<T>(obj))), Expect
+ >::value), "");
+ Expect e = std::__invoke_constexpr(M, std::forward<T>(obj));
+ assert(&e == expect);
+ }
+#endif
+ }
+};
+
+
+
+
+int main() {
+ TestCase<ArgType>::run();
+ TestCase<ArgType const>::run();
+ TestCase<ArgType volatile>::run();
+ TestCase<ArgType const volatile>::run();
+ TestCase<ArgType*>::run();
+}
\ No newline at end of file
Added: libcxx/trunk/test/libcxx/utilities/function.objects/func.require/bullet_7.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/libcxx/utilities/function.objects/func.require/bullet_7.pass.cpp?rev=267973&view=auto
==============================================================================
--- libcxx/trunk/test/libcxx/utilities/function.objects/func.require/bullet_7.pass.cpp (added)
+++ libcxx/trunk/test/libcxx/utilities/function.objects/func.require/bullet_7.pass.cpp Thu Apr 28 20:52:57 2016
@@ -0,0 +1,327 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// INVOKE (f, t1, t2, ..., tN)
+
+//------------------------------------------------------------------------------
+// TESTING INVOKE(f, t1, t2, ..., tN)
+// - Bullet 7 -- f(t2, ..., tN)
+//
+// Overview:
+// Bullet 7 handles the cases where the first argument is not a member
+// function.
+//
+// Concerns:
+// 1) Different types of callable objects are supported. Including
+// 1a) Free Function pointers and references.
+// 1b) Classes which provide a call operator
+// 1c) lambdas
+// 2) The callable objects are perfect forwarded.
+// 3) The arguments are perfect forwarded.
+// 4) Signatures which include varargs are supported.
+// 5) In C++03 3 extra arguments should be allowed.
+//
+// Plan:
+// 1) Define a set of free functions, 'SF', and class types with call
+// operators, 'SC', that address concerns 4 and 5. The free functions should
+// return 'FunctionID::setUncheckedCall()' and the call operators should
+// return 'MethodID::setUncheckedCall()'.
+//
+// 2) For each function 'f' in 'SF' and 'SC' attempt to call 'f'
+// using the correct number of arguments and cv-ref qualifiers. Check that
+// 'f' has been called using 'FunctionID::checkCall()' if 'f' is a free
+// function and 'MethodID::checkCall()' otherwise.
+
+
+
+#include <functional>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+#include "invoke_helpers.h"
+
+
+//==============================================================================
+// freeFunction03 - A C++03 free function.
+void*& freeFunction03() {
+ return FunctionPtrID<void*&(), freeFunction03>::setUncheckedCall();
+}
+
+void*& freeFunction03(...) {
+ return FunctionPtrID<void*&(...), freeFunction03>::setUncheckedCall();
+}
+
+template <class A0>
+void*& freeFunction03(A0&) {
+ return FunctionPtrID<void*&(A0&), freeFunction03>::setUncheckedCall();
+}
+
+
+template <class A0>
+void*& freeFunction03(A0&, ...) {
+ return FunctionPtrID<void*&(A0&, ...), freeFunction03>::setUncheckedCall();
+}
+
+template <class A0, class A1>
+void*& freeFunction03(A0&, A1&) {
+ return FunctionPtrID<void*&(A0&, A1&), freeFunction03>::setUncheckedCall();
+}
+
+
+template <class A0, class A1>
+void*& freeFunction03(A0&, A1&, ...) {
+ return FunctionPtrID<void*&(A0&, A1&, ...), freeFunction03>::setUncheckedCall();
+}
+
+template <class A0, class A1, class A2>
+void*& freeFunction03(A0&, A1&, A2&) {
+ return FunctionPtrID<void*&(A0&, A1&, A2&), freeFunction03>::setUncheckedCall();
+}
+
+template <class A0, class A1, class A2>
+void*& freeFunction03(A0&, A1&, A2&, ...) {
+ return FunctionPtrID<void*&(A0&, A1&, A2&, ...), freeFunction03>::setUncheckedCall();
+}
+
+//==============================================================================
+// Functor03 - C++03 compatible functor object
+struct Functor03 {
+ typedef void*& R;
+ typedef Functor03 C;
+#define F(Args, ...) \
+ __VA_ARGS__ R operator() Args { return MethodID<R(C::*) Args>::setUncheckedCall(); } \
+ __VA_ARGS__ R operator() Args const { return MethodID<R(C::*) Args const>::setUncheckedCall(); } \
+ __VA_ARGS__ R operator() Args volatile { return MethodID<R(C::*) Args volatile>::setUncheckedCall(); } \
+ __VA_ARGS__ R operator() Args const volatile { return MethodID<R(C::*) Args const volatile>::setUncheckedCall(); }
+#
+ F(())
+ F((A0&), template <class A0>)
+ F((A0&, A1&), template <class A0, class A1>)
+ F((A0&, A1&, A2&), template <class A0, class A1, class A2>)
+#undef F
+public:
+ Functor03() {}
+private:
+ Functor03(Functor03 const&);
+ Functor03& operator=(Functor03 const&);
+};
+
+
+#if TEST_STD_VER >= 11
+
+//==============================================================================
+// freeFunction11 - A C++11 free function.
+template <class ...Args>
+void*& freeFunction11(Args&&...) {
+ return FunctionPtrID<void*&(Args&&...), freeFunction11>::setUncheckedCall();
+}
+
+template <class ...Args>
+void*& freeFunction11(Args&&...,...) {
+ return FunctionPtrID<void*&(Args&&...,...), freeFunction11>::setUncheckedCall();
+}
+
+//==============================================================================
+// Functor11 - C++11 reference qualified test member functions.
+struct Functor11 {
+ typedef void*& R;
+ typedef Functor11 C;
+
+#define F(CV) \
+ template <class ...Args> \
+ R operator()(Args&&...) CV { return MethodID<R(C::*)(Args&&...) CV>::setUncheckedCall(); }
+#
+ F(&)
+ F(const &)
+ F(volatile &)
+ F(const volatile &)
+ F(&&)
+ F(const &&)
+ F(volatile &&)
+ F(const volatile &&)
+#undef F
+public:
+ Functor11() {}
+private:
+ Functor11(Functor11 const&);
+ Functor11& operator=(Functor11 const&);
+};
+
+#endif // TEST_STD_VER >= 11
+
+
+//==============================================================================
+// TestCaseFunctorImp - A test case for an operator() class method.
+// ClassType - The type of the call object.
+// CallSig - The function signature of the call operator being tested.
+// Arity - the arity of 'CallSig'
+// ObjCaster - Transformation function applied to call object.
+// ArgCaster - Transformation function applied to the extra arguments.
+template <class ClassType, class CallSig, int Arity,
+ class ObjCaster, class ArgCaster = LValueCaster>
+struct TestCaseFunctorImp {
+public:
+ static void run() {
+ typedef MethodID<CallSig ClassType::*> MID;
+ BasicTest<MID, Arity, ObjCaster, ArgCaster> t;
+ typedef ClassType T;
+ typedef DerivedFromType<T> D;
+ T obj;
+ D der;
+ t.runTest(obj);
+ t.runTest(der);
+ }
+};
+
+//==============================================================================
+// TestCaseFreeFunction - A test case for a free function.
+// CallSig - The function signature of the free function being tested.
+// FnPtr - The function being tested.
+// Arity - the arity of 'CallSig'
+// ArgCaster - Transformation function to be applied to the extra arguments.
+template <class CallSig, CallSig* FnPtr, int Arity, class ArgCaster>
+struct TestCaseFreeFunction {
+public:
+ static void run() {
+ typedef FunctionPtrID<CallSig, FnPtr> FID;
+ BasicTest<FID, Arity, LValueCaster, ArgCaster> t;
+
+ DerefToType<CallSig*> deref_to(FnPtr);
+ DerefToType<CallSig&> deref_to_ref(*FnPtr);
+
+ t.runTest(FnPtr);
+ t.runTest(*FnPtr);
+ t.runTest(deref_to);
+ t.runTest(deref_to_ref);
+ }
+};
+
+//==============================================================================
+// runTest Helpers
+//==============================================================================
+#if TEST_STD_VER >= 11
+template <class Sig, int Arity, class ArgCaster>
+void runFunctionTestCase11() {
+ TestCaseFreeFunction<Sig, freeFunction11, Arity, ArgCaster>();
+}
+#endif
+
+template <class Sig, int Arity, class ArgCaster>
+void runFunctionTestCase() {
+ TestCaseFreeFunction<Sig, freeFunction03, Arity, ArgCaster>();
+#if TEST_STD_VER >= 11
+ runFunctionTestCase11<Sig, Arity, ArgCaster>();
+#endif
+}
+
+template <class Sig, int Arity, class ObjCaster, class ArgCaster>
+void runFunctorTestCase() {
+ TestCaseFunctorImp<Functor03, Sig, Arity, ObjCaster, ArgCaster>::run();
+}
+
+template <class Sig, int Arity, class ObjCaster>
+void runFunctorTestCase() {
+ TestCaseFunctorImp<Functor03, Sig, Arity, ObjCaster>::run();
+}
+
+#if TEST_STD_VER >= 11
+// runTestCase - Run a test case for C++11 class functor types
+template <class Sig, int Arity, class ObjCaster, class ArgCaster = LValueCaster>
+void runFunctorTestCase11() {
+ TestCaseFunctorImp<Functor11, Sig, Arity, ObjCaster, ArgCaster>::run();
+}
+#endif
+
+// runTestCase - Run a test case for both function and functor types.
+template <class Sig, int Arity, class ArgCaster>
+void runTestCase() {
+ runFunctionTestCase<Sig, Arity, ArgCaster>();
+ runFunctorTestCase <Sig, Arity, LValueCaster, ArgCaster>();
+};
+
+int main() {
+ typedef void*& R;
+ typedef ArgType A;
+ typedef A const CA;
+
+ runTestCase< R(), 0, LValueCaster >();
+ runTestCase< R(A&), 1, LValueCaster >();
+ runTestCase< R(A&, A&), 2, LValueCaster >();
+ runTestCase< R(A&, A&, A&), 3, LValueCaster >();
+ runTestCase< R(CA&), 1, ConstCaster >();
+ runTestCase< R(CA&, CA&), 2, ConstCaster >();
+ runTestCase< R(CA&, CA&, CA&), 3, ConstCaster >();
+
+ runFunctionTestCase<R(...), 0, LValueCaster >();
+ runFunctionTestCase<R(A&, ...), 1, LValueCaster >();
+ runFunctionTestCase<R(A&, A&, ...), 2, LValueCaster >();
+ runFunctionTestCase<R(A&, A&, A&, ...), 3, LValueCaster >();
+
+#if TEST_STD_VER >= 11
+ runFunctionTestCase11<R(A&&), 1, MoveCaster >();
+ runFunctionTestCase11<R(A&&, ...), 1, MoveCaster >();
+#endif
+
+ runFunctorTestCase<R(), 0, LValueCaster >();
+ runFunctorTestCase<R() const, 0, ConstCaster >();
+ runFunctorTestCase<R() volatile, 0, VolatileCaster >();
+ runFunctorTestCase<R() const volatile, 0, CVCaster >();
+ runFunctorTestCase<R(A&), 1, LValueCaster >();
+ runFunctorTestCase<R(A&) const, 1, ConstCaster >();
+ runFunctorTestCase<R(A&) volatile, 1, VolatileCaster >();
+ runFunctorTestCase<R(A&) const volatile, 1, CVCaster >();
+ runFunctorTestCase<R(A&, A&), 2, LValueCaster >();
+ runFunctorTestCase<R(A&, A&) const, 2, ConstCaster >();
+ runFunctorTestCase<R(A&, A&) volatile, 2, VolatileCaster >();
+ runFunctorTestCase<R(A&, A&) const volatile, 2, CVCaster >();
+ runFunctorTestCase<R(A&, A&, A&), 3, LValueCaster >();
+ runFunctorTestCase<R(A&, A&, A&) const, 3, ConstCaster >();
+ runFunctorTestCase<R(A&, A&, A&) volatile, 3, VolatileCaster >();
+ runFunctorTestCase<R(A&, A&, A&) const volatile, 3, CVCaster >();
+ {
+ typedef ConstCaster CC;
+ runFunctorTestCase<R(CA&), 1, LValueCaster, CC>();
+ runFunctorTestCase<R(CA&) const, 1, ConstCaster, CC>();
+ runFunctorTestCase<R(CA&) volatile, 1, VolatileCaster, CC>();
+ runFunctorTestCase<R(CA&) const volatile, 1, CVCaster, CC>();
+ runFunctorTestCase<R(CA&, CA&), 2, LValueCaster, CC>();
+ runFunctorTestCase<R(CA&, CA&) const, 2, ConstCaster, CC>();
+ runFunctorTestCase<R(CA&, CA&) volatile, 2, VolatileCaster, CC>();
+ runFunctorTestCase<R(CA&, CA&) const volatile, 2, CVCaster, CC>();
+ runFunctorTestCase<R(CA&, CA&, CA&), 3, LValueCaster, CC>();
+ runFunctorTestCase<R(CA&, CA&, CA&) const, 3, ConstCaster, CC>();
+ runFunctorTestCase<R(CA&, CA&, CA&) volatile, 3, VolatileCaster, CC>();
+ runFunctorTestCase<R(CA&, CA&, CA&) const volatile, 3, CVCaster, CC>();
+ }
+
+#if TEST_STD_VER >= 11
+ runFunctorTestCase11<R() &, 0, LValueCaster >();
+ runFunctorTestCase11<R() const &, 0, ConstCaster >();
+ runFunctorTestCase11<R() volatile &, 0, VolatileCaster >();
+ runFunctorTestCase11<R() const volatile &, 0, CVCaster >();
+ runFunctorTestCase11<R() &&, 0, MoveCaster >();
+ runFunctorTestCase11<R() const &&, 0, MoveConstCaster >();
+ runFunctorTestCase11<R() volatile &&, 0, MoveVolatileCaster >();
+ runFunctorTestCase11<R() const volatile &&, 0, MoveCVCaster >();
+ {
+ typedef MoveCaster MC;
+ runFunctorTestCase11<R(A&&) &, 1, LValueCaster, MC>();
+ runFunctorTestCase11<R(A&&) const &, 1, ConstCaster, MC>();
+ runFunctorTestCase11<R(A&&) volatile &, 1, VolatileCaster, MC>();
+ runFunctorTestCase11<R(A&&) const volatile &, 1, CVCaster, MC>();
+ runFunctorTestCase11<R(A&&) &&, 1, MoveCaster, MC>();
+ runFunctorTestCase11<R(A&&) const &&, 1, MoveConstCaster, MC>();
+ runFunctorTestCase11<R(A&&) volatile &&, 1, MoveVolatileCaster, MC>();
+ runFunctorTestCase11<R(A&&) const volatile &&, 1, MoveCVCaster, MC>();
+ }
+#endif
+}
Added: libcxx/trunk/test/libcxx/utilities/function.objects/func.require/invoke.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/libcxx/utilities/function.objects/func.require/invoke.pass.cpp?rev=267973&view=auto
==============================================================================
--- libcxx/trunk/test/libcxx/utilities/function.objects/func.require/invoke.pass.cpp (added)
+++ libcxx/trunk/test/libcxx/utilities/function.objects/func.require/invoke.pass.cpp Thu Apr 28 20:52:57 2016
@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// [func.require]
+
+#include <type_traits>
+#include <functional>
+
+#include "test_macros.h"
+
+template <typename T, int N>
+struct Array
+{
+ typedef T type[N];
+};
+
+struct Type
+{
+ Array<char, 1>::type& f1();
+ Array<char, 2>::type& f2() const;
+#if TEST_STD_VER >= 11
+ Array<char, 1>::type& g1() &;
+ Array<char, 2>::type& g2() const &;
+ Array<char, 3>::type& g3() &&;
+ Array<char, 4>::type& g4() const &&;
+#endif
+};
+
+int main()
+{
+ static_assert(sizeof(std::__invoke(&Type::f1, std::declval<Type >())) == 1, "");
+ static_assert(sizeof(std::__invoke(&Type::f2, std::declval<Type const >())) == 2, "");
+#if TEST_STD_VER >= 11
+ static_assert(sizeof(std::__invoke(&Type::g1, std::declval<Type &>())) == 1, "");
+ static_assert(sizeof(std::__invoke(&Type::g2, std::declval<Type const &>())) == 2, "");
+ static_assert(sizeof(std::__invoke(&Type::g3, std::declval<Type &&>())) == 3, "");
+ static_assert(sizeof(std::__invoke(&Type::g4, std::declval<Type const&&>())) == 4, "");
+#endif
+}
Added: libcxx/trunk/test/libcxx/utilities/function.objects/func.require/invoke_helpers.h
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/libcxx/utilities/function.objects/func.require/invoke_helpers.h?rev=267973&view=auto
==============================================================================
--- libcxx/trunk/test/libcxx/utilities/function.objects/func.require/invoke_helpers.h (added)
+++ libcxx/trunk/test/libcxx/utilities/function.objects/func.require/invoke_helpers.h Thu Apr 28 20:52:57 2016
@@ -0,0 +1,456 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef INVOKE_HELPERS_H
+#define INVOKE_HELPERS_H
+
+#include <type_traits>
+#include <cassert>
+#include <functional>
+
+#include "test_macros.h"
+
+template <int I>
+struct Int : public std::integral_constant<int, I> {};
+
+template <bool P>
+struct Bool : public std::integral_constant<bool, P> {};
+
+struct Q_None {
+ template <class T>
+ struct apply { typedef T type; };
+};
+
+struct Q_Const {
+ template <class T>
+ struct apply { typedef T const type; };
+};
+
+struct Q_Volatile {
+ template <class T>
+ struct apply { typedef T volatile type; };
+};
+
+struct Q_CV {
+ template <class T>
+ struct apply { typedef T const volatile type; };
+};
+
+// Caster - A functor object that performs cv-qualifier and value category
+// conversions.
+// QualTag - A metafunction type that applies cv-qualifiers to its argument.
+// RValue - True if the resulting object should be an RValue reference.
+// False otherwise.
+template <class QualTag, bool RValue = false>
+struct Caster {
+ template <class T>
+ struct apply {
+ typedef typename std::remove_reference<T>::type RawType;
+ typedef typename QualTag::template apply<RawType>::type CVType;
+#if TEST_STD_VER >= 11
+ typedef typename std::conditional<RValue,
+ CVType&&, CVType&
+ >::type type;
+#else
+ typedef CVType& type;
+#endif
+ };
+
+ template <class T>
+ typename apply<T>::type
+ operator()(T& obj) const {
+ typedef typename apply<T>::type OutType;
+ return static_cast<OutType>(obj);
+ }
+};
+
+typedef Caster<Q_None> LValueCaster;
+typedef Caster<Q_Const> ConstCaster;
+typedef Caster<Q_Volatile> VolatileCaster;
+typedef Caster<Q_CV> CVCaster;
+typedef Caster<Q_None, true> MoveCaster;
+typedef Caster<Q_Const, true> MoveConstCaster;
+typedef Caster<Q_Volatile, true> MoveVolatileCaster;
+typedef Caster<Q_CV, true> MoveCVCaster;
+
+
+template <class Tp>
+Tp const& makeConst(Tp& ref) { return ref; }
+
+template <class Tp>
+Tp const* makeConst(Tp* ptr) { return ptr; }
+
+template <class Tp>
+std::reference_wrapper<const Tp> makeConst(std::reference_wrapper<Tp>& ref) {
+ return std::reference_wrapper<const Tp>(ref.get());
+}
+
+template <class Tp>
+Tp volatile& makeVolatile(Tp& ref) { return ref; }
+
+template <class Tp>
+Tp volatile* makeVolatile(Tp* ptr) { return ptr; }
+
+template <class Tp>
+std::reference_wrapper<volatile Tp> makeVolatile(std::reference_wrapper<Tp>& ref) {
+ return std::reference_wrapper<volatile Tp>(ref.get());
+}
+
+template <class Tp>
+Tp const volatile& makeCV(Tp& ref) { return ref; }
+
+template <class Tp>
+Tp const volatile* makeCV(Tp* ptr) { return ptr; }
+
+template <class Tp>
+std::reference_wrapper<const volatile Tp> makeCV(std::reference_wrapper<Tp>& ref) {
+ return std::reference_wrapper<const volatile Tp>(ref.get());
+}
+
+// A shorter name for 'static_cast'
+template <class QualType, class Tp>
+QualType C_(Tp& v) { return static_cast<QualType>(v); };
+
+//==============================================================================
+// ArgType - A non-copyable type intended to be used as a dummy argument type
+// to test functions.
+struct ArgType {
+ int value;
+ explicit ArgType(int val = 0) : value(val) {}
+private:
+ ArgType(ArgType const&);
+ ArgType& operator=(ArgType const&);
+};
+
+//==============================================================================
+// DerivedFromBase - A type that derives from it's template argument 'Base'
+template <class Base>
+struct DerivedFromType : public Base {
+ DerivedFromType() : Base() {}
+ template <class Tp>
+ explicit DerivedFromType(Tp const& t) : Base(t) {}
+};
+
+//==============================================================================
+// DerefToType - A type that dereferences to it's template argument 'To'.
+// The cv-ref qualifiers of the 'DerefToType' object do not propagate
+// to the resulting 'To' object.
+template <class To>
+struct DerefToType {
+ To object;
+
+ DerefToType() {}
+
+ template <class Up>
+ explicit DerefToType(Up const& val) : object(val) {}
+
+ To& operator*() const volatile { return const_cast<To&>(object); }
+};
+
+//==============================================================================
+// DerefPropToType - A type that dereferences to it's template argument 'To'.
+// The cv-ref qualifiers of the 'DerefPropToType' object propagate
+// to the resulting 'To' object.
+template <class To>
+struct DerefPropType {
+ To object;
+
+ DerefPropType() {}
+
+ template <class Up>
+ explicit DerefPropType(Up const& val) : object(val) {}
+
+#if TEST_STD_VER < 11
+ To& operator*() { return object; }
+ To const& operator*() const { return object; }
+ To volatile& operator*() volatile { return object; }
+ To const volatile& operator*() const volatile { return object; }
+#else
+ To& operator*() & { return object; }
+ To const& operator*() const & { return object; }
+ To volatile& operator*() volatile & { return object; }
+ To const volatile& operator*() const volatile & { return object; }
+ To&& operator*() && { return static_cast<To &&>(object); }
+ To const&& operator*() const && { return static_cast<To const&&>(object); }
+ To volatile&& operator*() volatile && { return static_cast<To volatile&&>(object); }
+ To const volatile&& operator*() const volatile && { return static_cast<To const volatile&&>(object); }
+#endif
+};
+
+//==============================================================================
+// MethodID - A type that uniquely identifies a member function for a class.
+// This type is used to communicate between the member functions being tested
+// and the tests invoking them.
+// - Test methods should call 'setUncheckedCall()' whenever they are invoked.
+// - Tests consume the unchecked call using checkCall(<return-value>)` to assert
+// that the method has been called and that the return value of `__invoke`
+// matches what the method actually returned.
+template <class T>
+struct MethodID {
+ typedef void* IDType;
+
+ static int dummy; // A dummy memory location.
+ static void* id; // The "ID" is the value of this pointer.
+ static bool unchecked_call; // Has a call happened that has not been checked.
+
+ static void*& setUncheckedCall() {
+ assert(unchecked_call == false);
+ unchecked_call = true;
+ return id;
+ }
+
+ static bool checkCalled(void*& return_value) {
+ bool old = unchecked_call;
+ unchecked_call = false;
+ return old && id == return_value && &id == &return_value;
+ }
+};
+
+template <class T> int MethodID<T>::dummy = 0;
+template <class T> void* MethodID<T>::id = (void*)&MethodID<T>::dummy;
+template <class T> bool MethodID<T>::unchecked_call = false;
+
+
+//==============================================================================
+// FunctionPtrID - Like MethodID but for free function pointers.
+template <class T, T*>
+struct FunctionPtrID {
+ static int dummy; // A dummy memory location.
+ static void* id; // The "ID" is the value of this pointer.
+ static bool unchecked_call; // Has a call happened that has not been checked.
+
+ static void*& setUncheckedCall() {
+ assert(unchecked_call == false);
+ unchecked_call = true;
+ return id;
+ }
+
+ static bool checkCalled(void*& return_value) {
+ bool old = unchecked_call;
+ unchecked_call = false;
+ return old && id == return_value && &id == &return_value;
+ }
+};
+
+template <class T, T* Ptr> int FunctionPtrID<T, Ptr>::dummy = 0;
+template <class T, T* Ptr> void* FunctionPtrID<T, Ptr>::id = (void*)&FunctionPtrID<T, Ptr>::dummy;
+template <class T, T* Ptr> bool FunctionPtrID<T, Ptr>::unchecked_call = false;
+
+//==============================================================================
+// BasicTest - The basic test structure for everything except
+// member object pointers.
+// ID - The "Function Identifier" type used either MethodID or FunctionPtrID.
+// Arity - The Arity of the call signature.
+// ObjectCaster - The object transformation functor type.
+// ArgCaster - The extra argument transformation functor type.
+template <class ID, int Arity, class ObjectCaster = LValueCaster,
+ class ArgCaster = LValueCaster>
+struct BasicTest {
+ template <class ObjectT>
+ void runTest(ObjectT& object) {
+ Int<Arity> A;
+ runTestImp(A, object);
+ }
+
+ template <class MethodPtr, class ObjectT>
+ void runTest(MethodPtr ptr, ObjectT& object) {
+ Int<Arity> A;
+ runTestImp(A, ptr, object);
+ }
+
+private:
+ typedef void*& CallRet;
+ ObjectCaster object_cast;
+ ArgCaster arg_cast;
+ ArgType a0, a1, a2;
+
+ //==========================================================================
+ // BULLET 1, 2 AND 3 TEST METHODS
+ //==========================================================================
+ template <class MethodPtr, class ObjectT>
+ void runTestImp(Int<0>, MethodPtr ptr, ObjectT& object) {
+ {
+ static_assert((std::is_same<
+ decltype(std::__invoke(ptr, object_cast(object)))
+ , CallRet>::value), "");
+ assert(ID::unchecked_call == false);
+ CallRet ret = std::__invoke(ptr, object_cast(object));
+ assert(ID::checkCalled(ret));
+ }
+#if TEST_STD_VER >= 11
+ {
+ static_assert((std::is_same<
+ decltype(std::__invoke_constexpr(ptr, object_cast(object)))
+ , CallRet>::value), "");
+ assert(ID::unchecked_call == false);
+ CallRet ret = std::__invoke_constexpr(ptr, object_cast(object));
+ assert(ID::checkCalled(ret));
+ }
+#endif
+ }
+
+ template <class MethodPtr, class ObjectT>
+ void runTestImp(Int<1>, MethodPtr ptr, ObjectT& object) {
+ {
+ static_assert((std::is_same<
+ decltype(std::__invoke(ptr, object_cast(object), arg_cast(a0)))
+ , CallRet>::value), "");
+ assert(ID::unchecked_call == false);
+ CallRet ret = std::__invoke(ptr, object_cast(object), arg_cast(a0));
+ assert(ID::checkCalled(ret));
+ }
+#if TEST_STD_VER >= 11
+ {
+ static_assert((std::is_same<
+ decltype(std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0)))
+ , CallRet>::value), "");
+ assert(ID::unchecked_call == false);
+ CallRet ret = std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0));
+ assert(ID::checkCalled(ret));
+ }
+#endif
+ }
+
+ template <class MethodPtr, class ObjectT>
+ void runTestImp(Int<2>, MethodPtr ptr, ObjectT& object) {
+ {
+ static_assert((std::is_same<
+ decltype(std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1)))
+ , CallRet>::value), "");
+ assert(ID::unchecked_call == false);
+ CallRet ret = std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1));
+ assert(ID::checkCalled(ret));
+ }
+#if TEST_STD_VER >= 11
+ {
+ static_assert((std::is_same<
+ decltype(std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0), arg_cast(a1)))
+ , CallRet>::value), "");
+ assert(ID::unchecked_call == false);
+ CallRet ret = std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0), arg_cast(a1));
+ assert(ID::checkCalled(ret));
+ }
+#endif
+ }
+
+ template <class MethodPtr, class ObjectT>
+ void runTestImp(Int<3>, MethodPtr ptr, ObjectT& object) {
+ {
+ static_assert((std::is_same<
+ decltype(std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2)))
+ , CallRet>::value), "");
+ assert(ID::unchecked_call == false);
+ CallRet ret = std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2));
+ assert(ID::checkCalled(ret));
+ }
+#if TEST_STD_VER >= 11
+ {
+ static_assert((std::is_same<
+ decltype(std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2)))
+ , CallRet>::value), "");
+ assert(ID::unchecked_call == false);
+ CallRet ret = std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2));
+ assert(ID::checkCalled(ret));
+ }
+#endif
+ }
+
+ //==========================================================================
+ // BULLET 7 TEST METHODS
+ //==========================================================================
+ template <class ObjectT>
+ void runTestImp(Int<0>, ObjectT& object) {
+ {
+ static_assert((std::is_same<
+ decltype(std::__invoke(object_cast(object)))
+ , CallRet>::value), "");
+ assert(ID::unchecked_call == false);
+ CallRet ret = std::__invoke(object_cast(object));
+ assert(ID::checkCalled(ret));
+ }
+#if TEST_STD_VER >= 11
+ {
+ static_assert((std::is_same<
+ decltype(std::__invoke_constexpr(object_cast(object)))
+ , CallRet>::value), "");
+ assert(ID::unchecked_call == false);
+ CallRet ret = std::__invoke_constexpr(object_cast(object));
+ assert(ID::checkCalled(ret));
+ }
+#endif
+ }
+
+ template <class ObjectT>
+ void runTestImp(Int<1>, ObjectT& object) {
+ {
+ static_assert((std::is_same<
+ decltype(std::__invoke(object_cast(object), arg_cast(a0)))
+ , CallRet>::value), "");
+ assert(ID::unchecked_call == false);
+ CallRet ret = std::__invoke(object_cast(object), arg_cast(a0));
+ assert(ID::checkCalled(ret));
+ }
+#if TEST_STD_VER >= 11
+ {
+ static_assert((std::is_same<
+ decltype(std::__invoke_constexpr(object_cast(object), arg_cast(a0)))
+ , CallRet>::value), "");
+ assert(ID::unchecked_call == false);
+ CallRet ret = std::__invoke_constexpr(object_cast(object), arg_cast(a0));
+ assert(ID::checkCalled(ret));
+ }
+#endif
+ }
+
+ template <class ObjectT>
+ void runTestImp(Int<2>, ObjectT& object) {
+ {
+ static_assert((std::is_same<
+ decltype(std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1)))
+ , CallRet>::value), "");
+ assert(ID::unchecked_call == false);
+ CallRet ret = std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1));
+ assert(ID::checkCalled(ret));
+ }
+#if TEST_STD_VER >= 11
+ {
+ static_assert((std::is_same<
+ decltype(std::__invoke_constexpr(object_cast(object), arg_cast(a0), arg_cast(a1)))
+ , CallRet>::value), "");
+ assert(ID::unchecked_call == false);
+ CallRet ret = std::__invoke_constexpr(object_cast(object), arg_cast(a0), arg_cast(a1));
+ assert(ID::checkCalled(ret));
+ }
+#endif
+ }
+
+ template <class ObjectT>
+ void runTestImp(Int<3>, ObjectT& object) {
+ {
+ static_assert((std::is_same<
+ decltype(std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2)))
+ , CallRet>::value), "");
+ assert(ID::unchecked_call == false);
+ CallRet ret = std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2));
+ assert(ID::checkCalled(ret));
+ }
+#if TEST_STD_VER >= 11
+ {
+ static_assert((std::is_same<
+ decltype(std::__invoke_constexpr(object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2)))
+ , CallRet>::value), "");
+ assert(ID::unchecked_call == false);
+ CallRet ret = std::__invoke_constexpr(object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2));
+ assert(ID::checkCalled(ret));
+ }
+#endif
+ }
+};
+
+#endif // INVOKE_HELPERS_H
Added: libcxx/trunk/test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp?rev=267973&view=auto
==============================================================================
--- libcxx/trunk/test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp (added)
+++ libcxx/trunk/test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp Thu Apr 28 20:52:57 2016
@@ -0,0 +1,16 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// INVOKE (f, t1, t2, ..., tN)
+
+// The tests for INVOKE (f, t1, t2, ..., tN) live in the "test/libcxx" tree
+// since they require calling the implementation specific "__invoke" and
+// "__invoke_constexpr" functions.
+
+int main() {}
Removed: libcxx/trunk/test/std/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp?rev=267972&view=auto
==============================================================================
--- libcxx/trunk/test/std/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp (original)
+++ libcxx/trunk/test/std/utilities/function.objects/func.require/bullet_1_2_3.pass.cpp (removed)
@@ -1,370 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// <functional>
-
-// INVOKE (f, t1, t2, ..., tN)
-
-//------------------------------------------------------------------------------
-// TESTING INVOKE(f, t1, t2, ..., tN)
-// - Bullet 1 -- (t1.*f)(t2, ..., tN)
-// - Bullet 2 -- (t1.get().*f)(t2, ..., tN) // t1 is a reference_wrapper
-// - Bullet 3 -- ((*t1).*f)(t2, ..., tN)
-//
-// Overview:
-// Bullets 1, 2 and 3 handle the case where 'f' is a pointer to member function.
-// Bullet 1 only handles the cases where t1 is an object of type T or a
-// type derived from 'T'. Bullet 2 handles the case where 't1' is a reference
-// wrapper and bullet 3 handles all other cases.
-//
-// Concerns:
-// 1) cv-qualified member function signatures are accepted.
-// 2) reference qualified member function signatures are accepted.
-// 3) member functions with varargs at the end are accepted.
-// 4) The arguments are perfect forwarded to the member function call.
-// 5) Classes that are publicly derived from 'T' are accepted as the call object
-// 6) All types that dereference to T or a type derived from T can be used
-// as the call object.
-// 7) Pointers to T or a type derived from T can be used as the call object.
-// 8) Reference return types are properly deduced.
-// 9) reference_wrappers are properly handled and unwrapped.
-//
-//
-// Plan:
-// 1) Create a class that contains a set, 'S', of non-static functions.
-// 'S' should include functions that cover every single combination
-// of qualifiers and varargs for arities of 0, 1 and 2 (C-1,2,3).
-// The argument types used in the functions should be non-copyable (C-4).
-// The functions should return 'MethodID::setUncheckedCall()'.
-//
-// 2) Create a set of supported call object, 'Objs', of different types
-// and behaviors. (C-5,6,7)
-//
-// 3) Attempt to call each function, 'f', in 'S' with each call object, 'c',
-// in 'Objs'. After every attempted call to 'f' check that 'f' was
-// actually called using 'MethodID::checkCalled(<return-value>)'
-//
-// 3b) If 'f' is reference qualified call 'f' with the properly qualified
-// call object. Otherwise call 'f' with lvalue call objects.
-//
-// 3a) If 'f' is const, volatile, or cv qualified then call it with call
-// objects that are equally or less cv-qualified.
-
-#include <functional>
-#include <type_traits>
-#include <cassert>
-
-#include "test_macros.h"
-#include "invoke_helpers.h"
-
-//==============================================================================
-// MemFun03 - C++03 compatible set of test member functions.
-struct MemFun03 {
- typedef void*& R;
-#define F(...) \
- R f(__VA_ARGS__) { return MethodID<R(MemFun03::*)(__VA_ARGS__)>::setUncheckedCall(); } \
- R f(__VA_ARGS__) const { return MethodID<R(MemFun03::*)(__VA_ARGS__) const>::setUncheckedCall(); } \
- R f(__VA_ARGS__) volatile { return MethodID<R(MemFun03::*)(__VA_ARGS__) volatile>::setUncheckedCall(); } \
- R f(__VA_ARGS__) const volatile { return MethodID<R(MemFun03::*)(__VA_ARGS__) const volatile>::setUncheckedCall(); }
-#
- F()
- F(...)
- F(ArgType&)
- F(ArgType&, ...)
- F(ArgType&, ArgType&)
- F(ArgType&, ArgType&, ...)
- F(ArgType&, ArgType&, ArgType&)
- F(ArgType&, ArgType&, ArgType&, ...)
-#undef F
-public:
- MemFun03() {}
-private:
- MemFun03(MemFun03 const&);
- MemFun03& operator=(MemFun03 const&);
-};
-
-
-#if TEST_STD_VER >= 11
-
-//==============================================================================
-// MemFun11 - C++11 reference qualified test member functions.
-struct MemFun11 {
- typedef void*& R;
- typedef MemFun11 C;
-#define F(...) \
- R f(__VA_ARGS__) & { return MethodID<R(C::*)(__VA_ARGS__) &>::setUncheckedCall(); } \
- R f(__VA_ARGS__) const & { return MethodID<R(C::*)(__VA_ARGS__) const &>::setUncheckedCall(); } \
- R f(__VA_ARGS__) volatile & { return MethodID<R(C::*)(__VA_ARGS__) volatile &>::setUncheckedCall(); } \
- R f(__VA_ARGS__) const volatile & { return MethodID<R(C::*)(__VA_ARGS__) const volatile &>::setUncheckedCall(); } \
- R f(__VA_ARGS__) && { return MethodID<R(C::*)(__VA_ARGS__) &&>::setUncheckedCall(); } \
- R f(__VA_ARGS__) const && { return MethodID<R(C::*)(__VA_ARGS__) const &&>::setUncheckedCall(); } \
- R f(__VA_ARGS__) volatile && { return MethodID<R(C::*)(__VA_ARGS__) volatile &&>::setUncheckedCall(); } \
- R f(__VA_ARGS__) const volatile && { return MethodID<R(C::*)(__VA_ARGS__) const volatile &&>::setUncheckedCall(); }
-#
- F()
- F(...)
- F(ArgType&&)
- F(ArgType&&, ...)
- F(ArgType&&, ArgType&&)
- F(ArgType&&, ArgType&&, ...)
- F(ArgType&&, ArgType&&, ArgType&&)
- F(ArgType&&, ArgType&&, ArgType&&, ...)
-#undef F
-public:
- MemFun11() {}
-private:
- MemFun11(MemFun11 const&);
- MemFun11& operator=(MemFun11 const&);
-};
-
-#endif // TEST_STD_VER >= 11
-
-
-
-//==============================================================================
-// TestCase - A test case for a single member function.
-// ClassType - The type of the class being tested.
-// CallSig - The function signature of the method being tested.
-// Arity - the arity of 'CallSig'
-// CV - the cv qualifiers of 'CallSig' represented as a type tag.
-// RValue - The method is RValue qualified.
-// ArgRValue - Call the method with RValue arguments.
-template <class ClassType, class CallSig, int Arity, class CV,
- bool RValue = false, bool ArgRValue = false>
-struct TestCaseImp {
-public:
-
- static void run() { TestCaseImp().doTest(); }
-
-private:
- //==========================================================================
- // TEST DISPATCH
- void doTest() {
- // (Plan-2) Create test call objects.
- typedef ClassType T;
- typedef DerivedFromType<T> D;
- T obj;
- T* obj_ptr = &obj;
- D der;
- D* der_ptr = &der;
- DerefToType<T> dref;
- DerefPropType<T> dref2;
- std::reference_wrapper<T> rref(obj);
- std::reference_wrapper<D> drref(der);
-
- // (Plan-3) Dispatch based on the CV tags.
- CV tag;
- Bool<!RValue> NotRValue;
- runTestDispatch(tag, obj);
- runTestDispatch(tag, der);
- runTestDispatch(tag, dref2);
- runTestDispatchIf(NotRValue, tag, dref);
- runTestDispatchIf(NotRValue, tag, obj_ptr);
- runTestDispatchIf(NotRValue, tag, der_ptr);
-#if TEST_STD_VER >= 11
- runTestDispatchIf(NotRValue, tag, rref);
- runTestDispatchIf(NotRValue, tag, drref);
-#endif
- }
-
- template <class QT, class Tp>
- void runTestDispatchIf(Bool<true>, QT q, Tp& v) {
- runTestDispatch(q, v);
- }
-
- template <class QT, class Tp>
- void runTestDispatchIf(Bool<false>, QT, Tp&) {
- }
-
- template <class Tp>
- void runTestDispatch(Q_None, Tp& v) {
- runTest(v);
- }
-
- template <class Tp>
- void runTestDispatch(Q_Const, Tp& v) {
- runTest(v);
- runTest(makeConst(v));
- }
-
- template <class Tp>
- void runTestDispatch(Q_Volatile, Tp& v) {
- runTest(v);
- runTest(makeVolatile(v));
-
- }
-
- template <class Tp>
- void runTestDispatch(Q_CV, Tp& v) {
- runTest(v);
- runTest(makeConst(v));
- runTest(makeVolatile(v));
- runTest(makeCV(v));
- }
-
- template <class T>
- void runTest(const std::reference_wrapper<T>& obj) {
- typedef Caster<Q_None, RValue> SCast;
- typedef Caster<Q_None, ArgRValue> ACast;
- typedef CallSig (ClassType::*MemPtr);
- // Delegate test to logic in invoke_helpers.h
- BasicTest<MethodID<MemPtr>, Arity, SCast, ACast> b;
- b.runTest( (MemPtr)&ClassType::f, obj);
- }
-
- template <class T>
- void runTest(T* obj) {
- typedef Caster<Q_None, RValue> SCast;
- typedef Caster<Q_None, ArgRValue> ACast;
- typedef CallSig (ClassType::*MemPtr);
- // Delegate test to logic in invoke_helpers.h
- BasicTest<MethodID<MemPtr>, Arity, SCast, ACast> b;
- b.runTest( (MemPtr)&ClassType::f, obj);
- }
-
- template <class Obj>
- void runTest(Obj& obj) {
- typedef Caster<Q_None, RValue> SCast;
- typedef Caster<Q_None, ArgRValue> ACast;
- typedef CallSig (ClassType::*MemPtr);
- // Delegate test to logic in invoke_helpers.h
- BasicTest<MethodID<MemPtr>, Arity, SCast, ACast> b;
- b.runTest( (MemPtr)&ClassType::f, obj);
- }
-};
-
-template <class Sig, int Arity, class CV>
-struct TestCase : public TestCaseImp<MemFun03, Sig, Arity, CV> {};
-
-#if TEST_STD_VER >= 11
-template <class Sig, int Arity, class CV, bool RValue = false>
-struct TestCase11 : public TestCaseImp<MemFun11, Sig, Arity, CV, RValue, true> {};
-#endif
-
-template <class Tp>
-struct DerivedFromRefWrap : public std::reference_wrapper<Tp> {
- DerivedFromRefWrap(Tp& tp) : std::reference_wrapper<Tp>(tp) {}
-};
-
-#if TEST_STD_VER >= 11
-void test_derived_from_ref_wrap() {
- int x = 42;
- std::reference_wrapper<int> r(x);
- std::reference_wrapper<std::reference_wrapper<int>> r2(r);
- DerivedFromRefWrap<int> d(x);
- auto get_fn = &std::reference_wrapper<int>::get;
- auto& ret = std::__invoke(get_fn, r);
- auto& cret = std::__invoke_constexpr(get_fn, r);
- assert(&ret == &x);
- assert(&cret == &x);
- auto& ret2 = std::__invoke(get_fn, d);
- auto& cret2 = std::__invoke_constexpr(get_fn, d);
- assert(&ret2 == &x);
- auto& ret3 = std::__invoke(get_fn, r2);
- assert(&ret3 == &x);
-}
-#endif
-
-int main() {
- typedef void*& R;
- typedef ArgType A;
- TestCase<R(), 0, Q_None>::run();
- TestCase<R() const, 0, Q_Const>::run();
- TestCase<R() volatile, 0, Q_Volatile>::run();
- TestCase<R() const volatile, 0, Q_CV>::run();
- TestCase<R(...), 0, Q_None>::run();
- TestCase<R(...) const, 0, Q_Const>::run();
- TestCase<R(...) volatile, 0, Q_Volatile>::run();
- TestCase<R(...) const volatile, 0, Q_CV>::run();
- TestCase<R(A&), 1, Q_None>::run();
- TestCase<R(A&) const, 1, Q_Const>::run();
- TestCase<R(A&) volatile, 1, Q_Volatile>::run();
- TestCase<R(A&) const volatile, 1, Q_CV>::run();
- TestCase<R(A&, ...), 1, Q_None>::run();
- TestCase<R(A&, ...) const, 1, Q_Const>::run();
- TestCase<R(A&, ...) volatile, 1, Q_Volatile>::run();
- TestCase<R(A&, ...) const volatile, 1, Q_CV>::run();
- TestCase<R(A&, A&), 2, Q_None>::run();
- TestCase<R(A&, A&) const, 2, Q_Const>::run();
- TestCase<R(A&, A&) volatile, 2, Q_Volatile>::run();
- TestCase<R(A&, A&) const volatile, 2, Q_CV>::run();
- TestCase<R(A&, A&, ...), 2, Q_None>::run();
- TestCase<R(A&, A&, ...) const, 2, Q_Const>::run();
- TestCase<R(A&, A&, ...) volatile, 2, Q_Volatile>::run();
- TestCase<R(A&, A&, ...) const volatile, 2, Q_CV>::run();
- TestCase<R(A&, A&, A&), 3, Q_None>::run();
- TestCase<R(A&, A&, A&) const, 3, Q_Const>::run();
- TestCase<R(A&, A&, A&) volatile, 3, Q_Volatile>::run();
- TestCase<R(A&, A&, A&) const volatile, 3, Q_CV>::run();
- TestCase<R(A&, A&, A&, ...), 3, Q_None>::run();
- TestCase<R(A&, A&, A&, ...) const, 3, Q_Const>::run();
- TestCase<R(A&, A&, A&, ...) volatile, 3, Q_Volatile>::run();
- TestCase<R(A&, A&, A&, ...) const volatile, 3, Q_CV>::run();
-
-#if TEST_STD_VER >= 11
- TestCase11<R() &, 0, Q_None>::run();
- TestCase11<R() const &, 0, Q_Const>::run();
- TestCase11<R() volatile &, 0, Q_Volatile>::run();
- TestCase11<R() const volatile &, 0, Q_CV>::run();
- TestCase11<R(...) &, 0, Q_None>::run();
- TestCase11<R(...) const &, 0, Q_Const>::run();
- TestCase11<R(...) volatile &, 0, Q_Volatile>::run();
- TestCase11<R(...) const volatile &, 0, Q_CV>::run();
- TestCase11<R(A&&) &, 1, Q_None>::run();
- TestCase11<R(A&&) const &, 1, Q_Const>::run();
- TestCase11<R(A&&) volatile &, 1, Q_Volatile>::run();
- TestCase11<R(A&&) const volatile &, 1, Q_CV>::run();
- TestCase11<R(A&&, ...) &, 1, Q_None>::run();
- TestCase11<R(A&&, ...) const &, 1, Q_Const>::run();
- TestCase11<R(A&&, ...) volatile &, 1, Q_Volatile>::run();
- TestCase11<R(A&&, ...) const volatile &, 1, Q_CV>::run();
- TestCase11<R(A&&, A&&) &, 2, Q_None>::run();
- TestCase11<R(A&&, A&&) const &, 2, Q_Const>::run();
- TestCase11<R(A&&, A&&) volatile &, 2, Q_Volatile>::run();
- TestCase11<R(A&&, A&&) const volatile &, 2, Q_CV>::run();
- TestCase11<R(A&&, A&&, ...) &, 2, Q_None>::run();
- TestCase11<R(A&&, A&&, ...) const &, 2, Q_Const>::run();
- TestCase11<R(A&&, A&&, ...) volatile &, 2, Q_Volatile>::run();
- TestCase11<R(A&&, A&&, ...) const volatile &, 2, Q_CV>::run();
- TestCase11<R() &&, 0, Q_None, /* RValue */ true>::run();
- TestCase11<R() const &&, 0, Q_Const, /* RValue */ true>::run();
- TestCase11<R() volatile &&, 0, Q_Volatile, /* RValue */ true>::run();
- TestCase11<R() const volatile &&, 0, Q_CV, /* RValue */ true>::run();
- TestCase11<R(...) &&, 0, Q_None, /* RValue */ true>::run();
- TestCase11<R(...) const &&, 0, Q_Const, /* RValue */ true>::run();
- TestCase11<R(...) volatile &&, 0, Q_Volatile, /* RValue */ true>::run();
- TestCase11<R(...) const volatile &&, 0, Q_CV, /* RValue */ true>::run();
- TestCase11<R(A&&) &&, 1, Q_None, /* RValue */ true>::run();
- TestCase11<R(A&&) const &&, 1, Q_Const, /* RValue */ true>::run();
- TestCase11<R(A&&) volatile &&, 1, Q_Volatile, /* RValue */ true>::run();
- TestCase11<R(A&&) const volatile &&, 1, Q_CV, /* RValue */ true>::run();
- TestCase11<R(A&&, ...) &&, 1, Q_None, /* RValue */ true>::run();
- TestCase11<R(A&&, ...) const &&, 1, Q_Const, /* RValue */ true>::run();
- TestCase11<R(A&&, ...) volatile &&, 1, Q_Volatile, /* RValue */ true>::run();
- TestCase11<R(A&&, ...) const volatile &&, 1, Q_CV, /* RValue */ true>::run();
- TestCase11<R(A&&, A&&) &&, 2, Q_None, /* RValue */ true>::run();
- TestCase11<R(A&&, A&&) const &&, 2, Q_Const, /* RValue */ true>::run();
- TestCase11<R(A&&, A&&) volatile &&, 2, Q_Volatile, /* RValue */ true>::run();
- TestCase11<R(A&&, A&&) const volatile &&, 2, Q_CV, /* RValue */ true>::run();
- TestCase11<R(A&&, A&&, ...) &&, 2, Q_None, /* RValue */ true>::run();
- TestCase11<R(A&&, A&&, ...) const &&, 2, Q_Const, /* RValue */ true>::run();
- TestCase11<R(A&&, A&&, ...) volatile &&, 2, Q_Volatile, /* RValue */ true>::run();
- TestCase11<R(A&&, A&&, ...) const volatile &&, 2, Q_CV, /* RValue */ true>::run();
- TestCase11<R(A&&, A&&, A&&) &&, 3, Q_None, /* RValue */ true>::run();
- TestCase11<R(A&&, A&&, A&&) const &&, 3, Q_Const, /* RValue */ true>::run();
- TestCase11<R(A&&, A&&, A&&) volatile &&, 3, Q_Volatile, /* RValue */ true>::run();
- TestCase11<R(A&&, A&&, A&&) const volatile &&, 3, Q_CV, /* RValue */ true>::run();
- TestCase11<R(A&&, A&&, A&&, ...) &&, 3, Q_None, /* RValue */ true>::run();
- TestCase11<R(A&&, A&&, A&&, ...) const &&, 3, Q_Const, /* RValue */ true>::run();
- TestCase11<R(A&&, A&&, A&&, ...) volatile &&, 3, Q_Volatile, /* RValue */ true>::run();
- TestCase11<R(A&&, A&&, A&&, ...) const volatile &&, 3, Q_CV, /* RValue */ true>::run();
-
- test_derived_from_ref_wrap();
-#endif
-}
\ No newline at end of file
Removed: libcxx/trunk/test/std/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp?rev=267972&view=auto
==============================================================================
--- libcxx/trunk/test/std/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp (original)
+++ libcxx/trunk/test/std/utilities/function.objects/func.require/bullet_4_5_6.pass.cpp (removed)
@@ -1,216 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// <functional>
-
-// INVOKE (f, t1, t2, ..., tN)
-
-//------------------------------------------------------------------------------
-// TESTING INVOKE(f, t1, t2, ..., tN)
-// - Bullet 4 -- t1.*f
-// - Bullet 5 -- t1.get().*f // t1 is a reference wrapper.
-// - Bullet 6 -- (*t1).*f
-//
-// Overview:
-// Bullets 4, 5 and 6 handle the case where 'f' is a pointer to member object.
-// Bullet 4 only handles the cases where t1 is an object of type T or a
-// type derived from 'T'. Bullet 5 handles cases where 't1' is a reference_wrapper
-// and bullet 6 handles all other cases.
-//
-// Concerns:
-// 1) The return type is always an lvalue reference.
-// 2) The return type is not less cv-qualified that the object that contains it.
-// 3) The return type is not less cv-qualified than object type.
-// 4) The call object is perfectly forwarded.
-// 5) Classes that are publicly derived from 'T' are accepted as the call object
-// 6) All types that dereference to T or a type derived from T can be used
-// as the call object.
-// 7) Pointers to T or a type derived from T can be used as the call object.
-// 8) reference_wrapper's are properly unwrapped before invoking the function.
-
-#include <functional>
-#include <type_traits>
-#include <cassert>
-
-#include "test_macros.h"
-#include "invoke_helpers.h"
-
-template <class Tp>
-struct TestMemberObject {
- TestMemberObject() : object() {}
- Tp object;
-private:
- TestMemberObject(TestMemberObject const&);
- TestMemberObject& operator=(TestMemberObject const&);
-};
-
-template <class ObjectType>
-struct TestCase {
- public:
-
- static void run() { TestCase().doTest(); }
-
-private:
- typedef TestMemberObject<ObjectType> TestType;
-
- //==========================================================================
- // TEST DISPATCH
- void doTest() {
- typedef DerivedFromType<TestType> Derived;
- TestType obj;
- TestType* obj_ptr = &obj;
- Derived der;
- Derived* der_ptr = &der;
- DerefToType<TestType> dref;
- DerefPropType<TestType> dref2;
- std::reference_wrapper<TestType> rref(obj);
- std::reference_wrapper<Derived> drref(der);
-
- {
- typedef ObjectType (TestType::*MemPtr);
- typedef ObjectType E;
- MemPtr M = &TestType::object;
- runTestDispatch<E>(M, obj, &obj.object);
- runTestDispatch<E>(M, der, &der.object);
- runTestDispatch<E>(M, dref2, &dref2.object.object);
- runTestPropCVDispatch<E>(M, obj_ptr, &obj_ptr->object);
- runTestPropCVDispatch<E>(M, der_ptr, &der_ptr->object);
-#if TEST_STD_VER >= 11
- runTestPropCVDispatch<E>(M, rref, &(rref.get().object));
- runTestPropCVDispatch<E>(M, drref, &(drref.get().object));
-#endif
- runTestNoPropDispatch<E>(M, dref, &dref.object.object);
- }
- {
- typedef ObjectType const (TestType::*CMemPtr);
- typedef ObjectType const E;
- CMemPtr M = &TestType::object;
- runTestDispatch<E>(M, obj, &obj.object);
- runTestDispatch<E>(M, der, &der.object);
- runTestDispatch<E>(M, dref2, &dref2.object.object);
- runTestPropCVDispatch<E>(M, obj_ptr, &obj_ptr->object);
- runTestPropCVDispatch<E>(M, der_ptr, &der_ptr->object);
-#if TEST_STD_VER >= 11
- runTestPropCVDispatch<E>(M, rref, &(rref.get().object));
- runTestPropCVDispatch<E>(M, drref, &(drref.get().object));
-#endif
- runTestNoPropDispatch<E>(M, dref, &dref.object.object);
- }
- {
- typedef ObjectType volatile (TestType::*VMemPtr);
- typedef ObjectType volatile E;
- VMemPtr M = &TestType::object;
- runTestDispatch<E>(M, obj, &obj.object);
- runTestDispatch<E>(M, der, &der.object);
- runTestDispatch<E>(M, dref2, &dref2.object.object);
- runTestPropCVDispatch<E>(M, obj_ptr, &obj_ptr->object);
- runTestPropCVDispatch<E>(M, der_ptr, &der_ptr->object);
-#if TEST_STD_VER >= 11
- runTestPropCVDispatch<E>(M, rref, &(rref.get().object));
- runTestPropCVDispatch<E>(M, drref, &(drref.get().object));
-#endif
- runTestNoPropDispatch<E>(M, dref, &dref.object.object);
- }
- {
- typedef ObjectType const volatile (TestType::*CVMemPtr);
- typedef ObjectType const volatile E;
- CVMemPtr M = &TestType::object;
- runTestDispatch<E>(M, obj, &obj.object);
- runTestDispatch<E>(M, der, &der.object);
- runTestDispatch<E>(M, dref2, &dref2.object.object);
- runTestPropCVDispatch<E>(M, obj_ptr, &obj_ptr->object);
- runTestPropCVDispatch<E>(M, der_ptr, &der_ptr->object);
-#if TEST_STD_VER >= 11
- runTestPropCVDispatch<E>(M, rref, &(rref.get().object));
- runTestPropCVDispatch<E>(M, drref, &(drref.get().object));
-#endif
- runTestNoPropDispatch<E>(M, dref, &dref.object.object);
- }
- }
-
- template <class Expect, class Fn, class T>
- void runTestDispatch(Fn M, T& obj, ObjectType* expect) {
- runTest<Expect &> (M, C_<T&>(obj), expect);
- runTest<Expect const&> (M, C_<T const&>(obj), expect);
- runTest<Expect volatile&> (M, C_<T volatile&>(obj), expect);
- runTest<Expect const volatile&>(M, C_<T const volatile&>(obj), expect);
-#if TEST_STD_VER >= 11
- runTest<Expect&&> (M, C_<T&&>(obj), expect);
- runTest<Expect const&&> (M, C_<T const&&>(obj), expect);
- runTest<Expect volatile&&> (M, C_<T volatile&&>(obj), expect);
- runTest<Expect const volatile&&>(M, C_<T const volatile&&>(obj), expect);
-#endif
- }
-
- template <class Expect, class Fn, class T>
- void runTestPropCVDispatch(Fn M, T& obj, ObjectType* expect) {
- runTest<Expect &> (M, obj, expect);
- runTest<Expect const&> (M, makeConst(obj), expect);
- runTest<Expect volatile&> (M, makeVolatile(obj), expect);
- runTest<Expect const volatile&>(M, makeCV(obj), expect);
- }
-
- template <class Expect, class Fn, class T>
- void runTestNoPropDispatch(Fn M, T& obj, ObjectType* expect) {
- runTest<Expect&>(M, C_<T &>(obj), expect);
- runTest<Expect&>(M, C_<T const&>(obj), expect);
- runTest<Expect&>(M, C_<T volatile&>(obj), expect);
- runTest<Expect&>(M, C_<T const volatile&>(obj), expect);
-#if TEST_STD_VER >= 11
- runTest<Expect&>(M, C_<T&&>(obj), expect);
- runTest<Expect&>(M, C_<T const&&>(obj), expect);
- runTest<Expect&>(M, C_<T volatile&&>(obj), expect);
- runTest<Expect&>(M, C_<T const volatile&&>(obj), expect);
-#endif
- }
-
- template <class Expect, class Fn, class T>
- void runTest(Fn M, const T& obj, ObjectType* expect) {
- static_assert((std::is_same<
- decltype(std::__invoke(M, obj)), Expect
- >::value), "");
- Expect e = std::__invoke(M, obj);
- assert(&e == expect);
- }
-
- template <class Expect, class Fn, class T>
-#if TEST_STD_VER >= 11
- void runTest(Fn M, T&& obj, ObjectType* expect) {
-#else
- void runTest(Fn M, T& obj, ObjectType* expect ) {
-#endif
- {
- static_assert((std::is_same<
- decltype(std::__invoke(M, std::forward<T>(obj))), Expect
- >::value), "");
- Expect e = std::__invoke(M, std::forward<T>(obj));
- assert(&e == expect);
- }
-#if TEST_STD_VER >= 11
- {
- static_assert((std::is_same<
- decltype(std::__invoke_constexpr(M, std::forward<T>(obj))), Expect
- >::value), "");
- Expect e = std::__invoke_constexpr(M, std::forward<T>(obj));
- assert(&e == expect);
- }
-#endif
- }
-};
-
-
-
-
-int main() {
- TestCase<ArgType>::run();
- TestCase<ArgType const>::run();
- TestCase<ArgType volatile>::run();
- TestCase<ArgType const volatile>::run();
- TestCase<ArgType*>::run();
-}
\ No newline at end of file
Removed: libcxx/trunk/test/std/utilities/function.objects/func.require/bullet_7.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/utilities/function.objects/func.require/bullet_7.pass.cpp?rev=267972&view=auto
==============================================================================
--- libcxx/trunk/test/std/utilities/function.objects/func.require/bullet_7.pass.cpp (original)
+++ libcxx/trunk/test/std/utilities/function.objects/func.require/bullet_7.pass.cpp (removed)
@@ -1,327 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// <functional>
-
-// INVOKE (f, t1, t2, ..., tN)
-
-//------------------------------------------------------------------------------
-// TESTING INVOKE(f, t1, t2, ..., tN)
-// - Bullet 7 -- f(t2, ..., tN)
-//
-// Overview:
-// Bullet 7 handles the cases where the first argument is not a member
-// function.
-//
-// Concerns:
-// 1) Different types of callable objects are supported. Including
-// 1a) Free Function pointers and references.
-// 1b) Classes which provide a call operator
-// 1c) lambdas
-// 2) The callable objects are perfect forwarded.
-// 3) The arguments are perfect forwarded.
-// 4) Signatures which include varargs are supported.
-// 5) In C++03 3 extra arguments should be allowed.
-//
-// Plan:
-// 1) Define a set of free functions, 'SF', and class types with call
-// operators, 'SC', that address concerns 4 and 5. The free functions should
-// return 'FunctionID::setUncheckedCall()' and the call operators should
-// return 'MethodID::setUncheckedCall()'.
-//
-// 2) For each function 'f' in 'SF' and 'SC' attempt to call 'f'
-// using the correct number of arguments and cv-ref qualifiers. Check that
-// 'f' has been called using 'FunctionID::checkCall()' if 'f' is a free
-// function and 'MethodID::checkCall()' otherwise.
-
-
-
-#include <functional>
-#include <type_traits>
-#include <cassert>
-
-#include "test_macros.h"
-#include "invoke_helpers.h"
-
-
-//==============================================================================
-// freeFunction03 - A C++03 free function.
-void*& freeFunction03() {
- return FunctionPtrID<void*&(), freeFunction03>::setUncheckedCall();
-}
-
-void*& freeFunction03(...) {
- return FunctionPtrID<void*&(...), freeFunction03>::setUncheckedCall();
-}
-
-template <class A0>
-void*& freeFunction03(A0&) {
- return FunctionPtrID<void*&(A0&), freeFunction03>::setUncheckedCall();
-}
-
-
-template <class A0>
-void*& freeFunction03(A0&, ...) {
- return FunctionPtrID<void*&(A0&, ...), freeFunction03>::setUncheckedCall();
-}
-
-template <class A0, class A1>
-void*& freeFunction03(A0&, A1&) {
- return FunctionPtrID<void*&(A0&, A1&), freeFunction03>::setUncheckedCall();
-}
-
-
-template <class A0, class A1>
-void*& freeFunction03(A0&, A1&, ...) {
- return FunctionPtrID<void*&(A0&, A1&, ...), freeFunction03>::setUncheckedCall();
-}
-
-template <class A0, class A1, class A2>
-void*& freeFunction03(A0&, A1&, A2&) {
- return FunctionPtrID<void*&(A0&, A1&, A2&), freeFunction03>::setUncheckedCall();
-}
-
-template <class A0, class A1, class A2>
-void*& freeFunction03(A0&, A1&, A2&, ...) {
- return FunctionPtrID<void*&(A0&, A1&, A2&, ...), freeFunction03>::setUncheckedCall();
-}
-
-//==============================================================================
-// Functor03 - C++03 compatible functor object
-struct Functor03 {
- typedef void*& R;
- typedef Functor03 C;
-#define F(Args, ...) \
- __VA_ARGS__ R operator() Args { return MethodID<R(C::*) Args>::setUncheckedCall(); } \
- __VA_ARGS__ R operator() Args const { return MethodID<R(C::*) Args const>::setUncheckedCall(); } \
- __VA_ARGS__ R operator() Args volatile { return MethodID<R(C::*) Args volatile>::setUncheckedCall(); } \
- __VA_ARGS__ R operator() Args const volatile { return MethodID<R(C::*) Args const volatile>::setUncheckedCall(); }
-#
- F(())
- F((A0&), template <class A0>)
- F((A0&, A1&), template <class A0, class A1>)
- F((A0&, A1&, A2&), template <class A0, class A1, class A2>)
-#undef F
-public:
- Functor03() {}
-private:
- Functor03(Functor03 const&);
- Functor03& operator=(Functor03 const&);
-};
-
-
-#if TEST_STD_VER >= 11
-
-//==============================================================================
-// freeFunction11 - A C++11 free function.
-template <class ...Args>
-void*& freeFunction11(Args&&...) {
- return FunctionPtrID<void*&(Args&&...), freeFunction11>::setUncheckedCall();
-}
-
-template <class ...Args>
-void*& freeFunction11(Args&&...,...) {
- return FunctionPtrID<void*&(Args&&...,...), freeFunction11>::setUncheckedCall();
-}
-
-//==============================================================================
-// Functor11 - C++11 reference qualified test member functions.
-struct Functor11 {
- typedef void*& R;
- typedef Functor11 C;
-
-#define F(CV) \
- template <class ...Args> \
- R operator()(Args&&...) CV { return MethodID<R(C::*)(Args&&...) CV>::setUncheckedCall(); }
-#
- F(&)
- F(const &)
- F(volatile &)
- F(const volatile &)
- F(&&)
- F(const &&)
- F(volatile &&)
- F(const volatile &&)
-#undef F
-public:
- Functor11() {}
-private:
- Functor11(Functor11 const&);
- Functor11& operator=(Functor11 const&);
-};
-
-#endif // TEST_STD_VER >= 11
-
-
-//==============================================================================
-// TestCaseFunctorImp - A test case for an operator() class method.
-// ClassType - The type of the call object.
-// CallSig - The function signature of the call operator being tested.
-// Arity - the arity of 'CallSig'
-// ObjCaster - Transformation function applied to call object.
-// ArgCaster - Transformation function applied to the extra arguments.
-template <class ClassType, class CallSig, int Arity,
- class ObjCaster, class ArgCaster = LValueCaster>
-struct TestCaseFunctorImp {
-public:
- static void run() {
- typedef MethodID<CallSig ClassType::*> MID;
- BasicTest<MID, Arity, ObjCaster, ArgCaster> t;
- typedef ClassType T;
- typedef DerivedFromType<T> D;
- T obj;
- D der;
- t.runTest(obj);
- t.runTest(der);
- }
-};
-
-//==============================================================================
-// TestCaseFreeFunction - A test case for a free function.
-// CallSig - The function signature of the free function being tested.
-// FnPtr - The function being tested.
-// Arity - the arity of 'CallSig'
-// ArgCaster - Transformation function to be applied to the extra arguments.
-template <class CallSig, CallSig* FnPtr, int Arity, class ArgCaster>
-struct TestCaseFreeFunction {
-public:
- static void run() {
- typedef FunctionPtrID<CallSig, FnPtr> FID;
- BasicTest<FID, Arity, LValueCaster, ArgCaster> t;
-
- DerefToType<CallSig*> deref_to(FnPtr);
- DerefToType<CallSig&> deref_to_ref(*FnPtr);
-
- t.runTest(FnPtr);
- t.runTest(*FnPtr);
- t.runTest(deref_to);
- t.runTest(deref_to_ref);
- }
-};
-
-//==============================================================================
-// runTest Helpers
-//==============================================================================
-#if TEST_STD_VER >= 11
-template <class Sig, int Arity, class ArgCaster>
-void runFunctionTestCase11() {
- TestCaseFreeFunction<Sig, freeFunction11, Arity, ArgCaster>();
-}
-#endif
-
-template <class Sig, int Arity, class ArgCaster>
-void runFunctionTestCase() {
- TestCaseFreeFunction<Sig, freeFunction03, Arity, ArgCaster>();
-#if TEST_STD_VER >= 11
- runFunctionTestCase11<Sig, Arity, ArgCaster>();
-#endif
-}
-
-template <class Sig, int Arity, class ObjCaster, class ArgCaster>
-void runFunctorTestCase() {
- TestCaseFunctorImp<Functor03, Sig, Arity, ObjCaster, ArgCaster>::run();
-}
-
-template <class Sig, int Arity, class ObjCaster>
-void runFunctorTestCase() {
- TestCaseFunctorImp<Functor03, Sig, Arity, ObjCaster>::run();
-}
-
-#if TEST_STD_VER >= 11
-// runTestCase - Run a test case for C++11 class functor types
-template <class Sig, int Arity, class ObjCaster, class ArgCaster = LValueCaster>
-void runFunctorTestCase11() {
- TestCaseFunctorImp<Functor11, Sig, Arity, ObjCaster, ArgCaster>::run();
-}
-#endif
-
-// runTestCase - Run a test case for both function and functor types.
-template <class Sig, int Arity, class ArgCaster>
-void runTestCase() {
- runFunctionTestCase<Sig, Arity, ArgCaster>();
- runFunctorTestCase <Sig, Arity, LValueCaster, ArgCaster>();
-};
-
-int main() {
- typedef void*& R;
- typedef ArgType A;
- typedef A const CA;
-
- runTestCase< R(), 0, LValueCaster >();
- runTestCase< R(A&), 1, LValueCaster >();
- runTestCase< R(A&, A&), 2, LValueCaster >();
- runTestCase< R(A&, A&, A&), 3, LValueCaster >();
- runTestCase< R(CA&), 1, ConstCaster >();
- runTestCase< R(CA&, CA&), 2, ConstCaster >();
- runTestCase< R(CA&, CA&, CA&), 3, ConstCaster >();
-
- runFunctionTestCase<R(...), 0, LValueCaster >();
- runFunctionTestCase<R(A&, ...), 1, LValueCaster >();
- runFunctionTestCase<R(A&, A&, ...), 2, LValueCaster >();
- runFunctionTestCase<R(A&, A&, A&, ...), 3, LValueCaster >();
-
-#if TEST_STD_VER >= 11
- runFunctionTestCase11<R(A&&), 1, MoveCaster >();
- runFunctionTestCase11<R(A&&, ...), 1, MoveCaster >();
-#endif
-
- runFunctorTestCase<R(), 0, LValueCaster >();
- runFunctorTestCase<R() const, 0, ConstCaster >();
- runFunctorTestCase<R() volatile, 0, VolatileCaster >();
- runFunctorTestCase<R() const volatile, 0, CVCaster >();
- runFunctorTestCase<R(A&), 1, LValueCaster >();
- runFunctorTestCase<R(A&) const, 1, ConstCaster >();
- runFunctorTestCase<R(A&) volatile, 1, VolatileCaster >();
- runFunctorTestCase<R(A&) const volatile, 1, CVCaster >();
- runFunctorTestCase<R(A&, A&), 2, LValueCaster >();
- runFunctorTestCase<R(A&, A&) const, 2, ConstCaster >();
- runFunctorTestCase<R(A&, A&) volatile, 2, VolatileCaster >();
- runFunctorTestCase<R(A&, A&) const volatile, 2, CVCaster >();
- runFunctorTestCase<R(A&, A&, A&), 3, LValueCaster >();
- runFunctorTestCase<R(A&, A&, A&) const, 3, ConstCaster >();
- runFunctorTestCase<R(A&, A&, A&) volatile, 3, VolatileCaster >();
- runFunctorTestCase<R(A&, A&, A&) const volatile, 3, CVCaster >();
- {
- typedef ConstCaster CC;
- runFunctorTestCase<R(CA&), 1, LValueCaster, CC>();
- runFunctorTestCase<R(CA&) const, 1, ConstCaster, CC>();
- runFunctorTestCase<R(CA&) volatile, 1, VolatileCaster, CC>();
- runFunctorTestCase<R(CA&) const volatile, 1, CVCaster, CC>();
- runFunctorTestCase<R(CA&, CA&), 2, LValueCaster, CC>();
- runFunctorTestCase<R(CA&, CA&) const, 2, ConstCaster, CC>();
- runFunctorTestCase<R(CA&, CA&) volatile, 2, VolatileCaster, CC>();
- runFunctorTestCase<R(CA&, CA&) const volatile, 2, CVCaster, CC>();
- runFunctorTestCase<R(CA&, CA&, CA&), 3, LValueCaster, CC>();
- runFunctorTestCase<R(CA&, CA&, CA&) const, 3, ConstCaster, CC>();
- runFunctorTestCase<R(CA&, CA&, CA&) volatile, 3, VolatileCaster, CC>();
- runFunctorTestCase<R(CA&, CA&, CA&) const volatile, 3, CVCaster, CC>();
- }
-
-#if TEST_STD_VER >= 11
- runFunctorTestCase11<R() &, 0, LValueCaster >();
- runFunctorTestCase11<R() const &, 0, ConstCaster >();
- runFunctorTestCase11<R() volatile &, 0, VolatileCaster >();
- runFunctorTestCase11<R() const volatile &, 0, CVCaster >();
- runFunctorTestCase11<R() &&, 0, MoveCaster >();
- runFunctorTestCase11<R() const &&, 0, MoveConstCaster >();
- runFunctorTestCase11<R() volatile &&, 0, MoveVolatileCaster >();
- runFunctorTestCase11<R() const volatile &&, 0, MoveCVCaster >();
- {
- typedef MoveCaster MC;
- runFunctorTestCase11<R(A&&) &, 1, LValueCaster, MC>();
- runFunctorTestCase11<R(A&&) const &, 1, ConstCaster, MC>();
- runFunctorTestCase11<R(A&&) volatile &, 1, VolatileCaster, MC>();
- runFunctorTestCase11<R(A&&) const volatile &, 1, CVCaster, MC>();
- runFunctorTestCase11<R(A&&) &&, 1, MoveCaster, MC>();
- runFunctorTestCase11<R(A&&) const &&, 1, MoveConstCaster, MC>();
- runFunctorTestCase11<R(A&&) volatile &&, 1, MoveVolatileCaster, MC>();
- runFunctorTestCase11<R(A&&) const volatile &&, 1, MoveCVCaster, MC>();
- }
-#endif
-}
Removed: libcxx/trunk/test/std/utilities/function.objects/func.require/invoke.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/utilities/function.objects/func.require/invoke.pass.cpp?rev=267972&view=auto
==============================================================================
--- libcxx/trunk/test/std/utilities/function.objects/func.require/invoke.pass.cpp (original)
+++ libcxx/trunk/test/std/utilities/function.objects/func.require/invoke.pass.cpp (removed)
@@ -1,50 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// [func.require]
-
-// INVOKE
-#if __cplusplus < 201103L
-int main () {} // no __invoke in C++03
-#else
-
-#include <type_traits>
-
-template <typename T, int N>
-struct Array
-{
- typedef T type[N];
-};
-
-struct Type
-{
- Array<char, 1>::type& f1();
- Array<char, 2>::type& f2() const;
-
- Array<char, 1>::type& g1() &;
- Array<char, 2>::type& g2() const &;
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
- Array<char, 3>::type& g3() &&;
- Array<char, 4>::type& g4() const &&;
-#endif
-};
-
-int main()
-{
- static_assert(sizeof(std::__invoke(&Type::f1, std::declval<Type >())) == 1, "");
- static_assert(sizeof(std::__invoke(&Type::f2, std::declval<Type const >())) == 2, "");
-
- static_assert(sizeof(std::__invoke(&Type::g1, std::declval<Type &>())) == 1, "");
- static_assert(sizeof(std::__invoke(&Type::g2, std::declval<Type const &>())) == 2, "");
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
- static_assert(sizeof(std::__invoke(&Type::g3, std::declval<Type &&>())) == 3, "");
- static_assert(sizeof(std::__invoke(&Type::g4, std::declval<Type const&&>())) == 4, "");
-#endif
-}
-#endif
Removed: libcxx/trunk/test/std/utilities/function.objects/func.require/invoke_helpers.h
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/utilities/function.objects/func.require/invoke_helpers.h?rev=267972&view=auto
==============================================================================
--- libcxx/trunk/test/std/utilities/function.objects/func.require/invoke_helpers.h (original)
+++ libcxx/trunk/test/std/utilities/function.objects/func.require/invoke_helpers.h (removed)
@@ -1,456 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef INVOKE_HELPERS_H
-#define INVOKE_HELPERS_H
-
-#include <type_traits>
-#include <cassert>
-#include <functional>
-
-#include "test_macros.h"
-
-template <int I>
-struct Int : public std::integral_constant<int, I> {};
-
-template <bool P>
-struct Bool : public std::integral_constant<bool, P> {};
-
-struct Q_None {
- template <class T>
- struct apply { typedef T type; };
-};
-
-struct Q_Const {
- template <class T>
- struct apply { typedef T const type; };
-};
-
-struct Q_Volatile {
- template <class T>
- struct apply { typedef T volatile type; };
-};
-
-struct Q_CV {
- template <class T>
- struct apply { typedef T const volatile type; };
-};
-
-// Caster - A functor object that performs cv-qualifier and value category
-// conversions.
-// QualTag - A metafunction type that applies cv-qualifiers to its argument.
-// RValue - True if the resulting object should be an RValue reference.
-// False otherwise.
-template <class QualTag, bool RValue = false>
-struct Caster {
- template <class T>
- struct apply {
- typedef typename std::remove_reference<T>::type RawType;
- typedef typename QualTag::template apply<RawType>::type CVType;
-#if TEST_STD_VER >= 11
- typedef typename std::conditional<RValue,
- CVType&&, CVType&
- >::type type;
-#else
- typedef CVType& type;
-#endif
- };
-
- template <class T>
- typename apply<T>::type
- operator()(T& obj) const {
- typedef typename apply<T>::type OutType;
- return static_cast<OutType>(obj);
- }
-};
-
-typedef Caster<Q_None> LValueCaster;
-typedef Caster<Q_Const> ConstCaster;
-typedef Caster<Q_Volatile> VolatileCaster;
-typedef Caster<Q_CV> CVCaster;
-typedef Caster<Q_None, true> MoveCaster;
-typedef Caster<Q_Const, true> MoveConstCaster;
-typedef Caster<Q_Volatile, true> MoveVolatileCaster;
-typedef Caster<Q_CV, true> MoveCVCaster;
-
-
-template <class Tp>
-Tp const& makeConst(Tp& ref) { return ref; }
-
-template <class Tp>
-Tp const* makeConst(Tp* ptr) { return ptr; }
-
-template <class Tp>
-std::reference_wrapper<const Tp> makeConst(std::reference_wrapper<Tp>& ref) {
- return std::reference_wrapper<const Tp>(ref.get());
-}
-
-template <class Tp>
-Tp volatile& makeVolatile(Tp& ref) { return ref; }
-
-template <class Tp>
-Tp volatile* makeVolatile(Tp* ptr) { return ptr; }
-
-template <class Tp>
-std::reference_wrapper<volatile Tp> makeVolatile(std::reference_wrapper<Tp>& ref) {
- return std::reference_wrapper<volatile Tp>(ref.get());
-}
-
-template <class Tp>
-Tp const volatile& makeCV(Tp& ref) { return ref; }
-
-template <class Tp>
-Tp const volatile* makeCV(Tp* ptr) { return ptr; }
-
-template <class Tp>
-std::reference_wrapper<const volatile Tp> makeCV(std::reference_wrapper<Tp>& ref) {
- return std::reference_wrapper<const volatile Tp>(ref.get());
-}
-
-// A shorter name for 'static_cast'
-template <class QualType, class Tp>
-QualType C_(Tp& v) { return static_cast<QualType>(v); };
-
-//==============================================================================
-// ArgType - A non-copyable type intended to be used as a dummy argument type
-// to test functions.
-struct ArgType {
- int value;
- explicit ArgType(int val = 0) : value(val) {}
-private:
- ArgType(ArgType const&);
- ArgType& operator=(ArgType const&);
-};
-
-//==============================================================================
-// DerivedFromBase - A type that derives from it's template argument 'Base'
-template <class Base>
-struct DerivedFromType : public Base {
- DerivedFromType() : Base() {}
- template <class Tp>
- explicit DerivedFromType(Tp const& t) : Base(t) {}
-};
-
-//==============================================================================
-// DerefToType - A type that dereferences to it's template argument 'To'.
-// The cv-ref qualifiers of the 'DerefToType' object do not propagate
-// to the resulting 'To' object.
-template <class To>
-struct DerefToType {
- To object;
-
- DerefToType() {}
-
- template <class Up>
- explicit DerefToType(Up const& val) : object(val) {}
-
- To& operator*() const volatile { return const_cast<To&>(object); }
-};
-
-//==============================================================================
-// DerefPropToType - A type that dereferences to it's template argument 'To'.
-// The cv-ref qualifiers of the 'DerefPropToType' object propagate
-// to the resulting 'To' object.
-template <class To>
-struct DerefPropType {
- To object;
-
- DerefPropType() {}
-
- template <class Up>
- explicit DerefPropType(Up const& val) : object(val) {}
-
-#if TEST_STD_VER < 11
- To& operator*() { return object; }
- To const& operator*() const { return object; }
- To volatile& operator*() volatile { return object; }
- To const volatile& operator*() const volatile { return object; }
-#else
- To& operator*() & { return object; }
- To const& operator*() const & { return object; }
- To volatile& operator*() volatile & { return object; }
- To const volatile& operator*() const volatile & { return object; }
- To&& operator*() && { return static_cast<To &&>(object); }
- To const&& operator*() const && { return static_cast<To const&&>(object); }
- To volatile&& operator*() volatile && { return static_cast<To volatile&&>(object); }
- To const volatile&& operator*() const volatile && { return static_cast<To const volatile&&>(object); }
-#endif
-};
-
-//==============================================================================
-// MethodID - A type that uniquely identifies a member function for a class.
-// This type is used to communicate between the member functions being tested
-// and the tests invoking them.
-// - Test methods should call 'setUncheckedCall()' whenever they are invoked.
-// - Tests consume the unchecked call using checkCall(<return-value>)` to assert
-// that the method has been called and that the return value of `__invoke`
-// matches what the method actually returned.
-template <class T>
-struct MethodID {
- typedef void* IDType;
-
- static int dummy; // A dummy memory location.
- static void* id; // The "ID" is the value of this pointer.
- static bool unchecked_call; // Has a call happened that has not been checked.
-
- static void*& setUncheckedCall() {
- assert(unchecked_call == false);
- unchecked_call = true;
- return id;
- }
-
- static bool checkCalled(void*& return_value) {
- bool old = unchecked_call;
- unchecked_call = false;
- return old && id == return_value && &id == &return_value;
- }
-};
-
-template <class T> int MethodID<T>::dummy = 0;
-template <class T> void* MethodID<T>::id = (void*)&MethodID<T>::dummy;
-template <class T> bool MethodID<T>::unchecked_call = false;
-
-
-//==============================================================================
-// FunctionPtrID - Like MethodID but for free function pointers.
-template <class T, T*>
-struct FunctionPtrID {
- static int dummy; // A dummy memory location.
- static void* id; // The "ID" is the value of this pointer.
- static bool unchecked_call; // Has a call happened that has not been checked.
-
- static void*& setUncheckedCall() {
- assert(unchecked_call == false);
- unchecked_call = true;
- return id;
- }
-
- static bool checkCalled(void*& return_value) {
- bool old = unchecked_call;
- unchecked_call = false;
- return old && id == return_value && &id == &return_value;
- }
-};
-
-template <class T, T* Ptr> int FunctionPtrID<T, Ptr>::dummy = 0;
-template <class T, T* Ptr> void* FunctionPtrID<T, Ptr>::id = (void*)&FunctionPtrID<T, Ptr>::dummy;
-template <class T, T* Ptr> bool FunctionPtrID<T, Ptr>::unchecked_call = false;
-
-//==============================================================================
-// BasicTest - The basic test structure for everything except
-// member object pointers.
-// ID - The "Function Identifier" type used either MethodID or FunctionPtrID.
-// Arity - The Arity of the call signature.
-// ObjectCaster - The object transformation functor type.
-// ArgCaster - The extra argument transformation functor type.
-template <class ID, int Arity, class ObjectCaster = LValueCaster,
- class ArgCaster = LValueCaster>
-struct BasicTest {
- template <class ObjectT>
- void runTest(ObjectT& object) {
- Int<Arity> A;
- runTestImp(A, object);
- }
-
- template <class MethodPtr, class ObjectT>
- void runTest(MethodPtr ptr, ObjectT& object) {
- Int<Arity> A;
- runTestImp(A, ptr, object);
- }
-
-private:
- typedef void*& CallRet;
- ObjectCaster object_cast;
- ArgCaster arg_cast;
- ArgType a0, a1, a2;
-
- //==========================================================================
- // BULLET 1, 2 AND 3 TEST METHODS
- //==========================================================================
- template <class MethodPtr, class ObjectT>
- void runTestImp(Int<0>, MethodPtr ptr, ObjectT& object) {
- {
- static_assert((std::is_same<
- decltype(std::__invoke(ptr, object_cast(object)))
- , CallRet>::value), "");
- assert(ID::unchecked_call == false);
- CallRet ret = std::__invoke(ptr, object_cast(object));
- assert(ID::checkCalled(ret));
- }
-#if TEST_STD_VER >= 11
- {
- static_assert((std::is_same<
- decltype(std::__invoke_constexpr(ptr, object_cast(object)))
- , CallRet>::value), "");
- assert(ID::unchecked_call == false);
- CallRet ret = std::__invoke_constexpr(ptr, object_cast(object));
- assert(ID::checkCalled(ret));
- }
-#endif
- }
-
- template <class MethodPtr, class ObjectT>
- void runTestImp(Int<1>, MethodPtr ptr, ObjectT& object) {
- {
- static_assert((std::is_same<
- decltype(std::__invoke(ptr, object_cast(object), arg_cast(a0)))
- , CallRet>::value), "");
- assert(ID::unchecked_call == false);
- CallRet ret = std::__invoke(ptr, object_cast(object), arg_cast(a0));
- assert(ID::checkCalled(ret));
- }
-#if TEST_STD_VER >= 11
- {
- static_assert((std::is_same<
- decltype(std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0)))
- , CallRet>::value), "");
- assert(ID::unchecked_call == false);
- CallRet ret = std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0));
- assert(ID::checkCalled(ret));
- }
-#endif
- }
-
- template <class MethodPtr, class ObjectT>
- void runTestImp(Int<2>, MethodPtr ptr, ObjectT& object) {
- {
- static_assert((std::is_same<
- decltype(std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1)))
- , CallRet>::value), "");
- assert(ID::unchecked_call == false);
- CallRet ret = std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1));
- assert(ID::checkCalled(ret));
- }
-#if TEST_STD_VER >= 11
- {
- static_assert((std::is_same<
- decltype(std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0), arg_cast(a1)))
- , CallRet>::value), "");
- assert(ID::unchecked_call == false);
- CallRet ret = std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0), arg_cast(a1));
- assert(ID::checkCalled(ret));
- }
-#endif
- }
-
- template <class MethodPtr, class ObjectT>
- void runTestImp(Int<3>, MethodPtr ptr, ObjectT& object) {
- {
- static_assert((std::is_same<
- decltype(std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2)))
- , CallRet>::value), "");
- assert(ID::unchecked_call == false);
- CallRet ret = std::__invoke(ptr, object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2));
- assert(ID::checkCalled(ret));
- }
-#if TEST_STD_VER >= 11
- {
- static_assert((std::is_same<
- decltype(std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2)))
- , CallRet>::value), "");
- assert(ID::unchecked_call == false);
- CallRet ret = std::__invoke_constexpr(ptr, object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2));
- assert(ID::checkCalled(ret));
- }
-#endif
- }
-
- //==========================================================================
- // BULLET 7 TEST METHODS
- //==========================================================================
- template <class ObjectT>
- void runTestImp(Int<0>, ObjectT& object) {
- {
- static_assert((std::is_same<
- decltype(std::__invoke(object_cast(object)))
- , CallRet>::value), "");
- assert(ID::unchecked_call == false);
- CallRet ret = std::__invoke(object_cast(object));
- assert(ID::checkCalled(ret));
- }
-#if TEST_STD_VER >= 11
- {
- static_assert((std::is_same<
- decltype(std::__invoke_constexpr(object_cast(object)))
- , CallRet>::value), "");
- assert(ID::unchecked_call == false);
- CallRet ret = std::__invoke_constexpr(object_cast(object));
- assert(ID::checkCalled(ret));
- }
-#endif
- }
-
- template <class ObjectT>
- void runTestImp(Int<1>, ObjectT& object) {
- {
- static_assert((std::is_same<
- decltype(std::__invoke(object_cast(object), arg_cast(a0)))
- , CallRet>::value), "");
- assert(ID::unchecked_call == false);
- CallRet ret = std::__invoke(object_cast(object), arg_cast(a0));
- assert(ID::checkCalled(ret));
- }
-#if TEST_STD_VER >= 11
- {
- static_assert((std::is_same<
- decltype(std::__invoke_constexpr(object_cast(object), arg_cast(a0)))
- , CallRet>::value), "");
- assert(ID::unchecked_call == false);
- CallRet ret = std::__invoke_constexpr(object_cast(object), arg_cast(a0));
- assert(ID::checkCalled(ret));
- }
-#endif
- }
-
- template <class ObjectT>
- void runTestImp(Int<2>, ObjectT& object) {
- {
- static_assert((std::is_same<
- decltype(std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1)))
- , CallRet>::value), "");
- assert(ID::unchecked_call == false);
- CallRet ret = std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1));
- assert(ID::checkCalled(ret));
- }
-#if TEST_STD_VER >= 11
- {
- static_assert((std::is_same<
- decltype(std::__invoke_constexpr(object_cast(object), arg_cast(a0), arg_cast(a1)))
- , CallRet>::value), "");
- assert(ID::unchecked_call == false);
- CallRet ret = std::__invoke_constexpr(object_cast(object), arg_cast(a0), arg_cast(a1));
- assert(ID::checkCalled(ret));
- }
-#endif
- }
-
- template <class ObjectT>
- void runTestImp(Int<3>, ObjectT& object) {
- {
- static_assert((std::is_same<
- decltype(std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2)))
- , CallRet>::value), "");
- assert(ID::unchecked_call == false);
- CallRet ret = std::__invoke(object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2));
- assert(ID::checkCalled(ret));
- }
-#if TEST_STD_VER >= 11
- {
- static_assert((std::is_same<
- decltype(std::__invoke_constexpr(object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2)))
- , CallRet>::value), "");
- assert(ID::unchecked_call == false);
- CallRet ret = std::__invoke_constexpr(object_cast(object), arg_cast(a0), arg_cast(a1), arg_cast(a2));
- assert(ID::checkCalled(ret));
- }
-#endif
- }
-};
-
-#endif // INVOKE_HELPERS_H
More information about the cfe-commits
mailing list