From 51072bd6bf79ef2bc6a922079bff57c31c1effbc Mon Sep 17 00:00:00 2001 From: Dimitry Andric Date: Sat, 23 Jul 2016 20:47:26 +0000 Subject: Vendor import of libc++ release_39 branch r276489: https://llvm.org/svn/llvm-project/libcxx/branches/release_39@276489 --- .../func.require/INVOKE_tested_elsewhere.pass.cpp | 16 + .../func.require/bullet_1_and_2.pass.cpp | 318 -------------------- .../func.require/bullet_3_and_4.pass.cpp | 164 ----------- .../func.require/bullet_5.pass.cpp | 327 --------------------- .../function.objects/func.require/invoke.pass.cpp | 50 ---- .../function.objects/func.require/invoke_helpers.h | 326 -------------------- 6 files changed, 16 insertions(+), 1185 deletions(-) create mode 100644 test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp delete mode 100644 test/std/utilities/function.objects/func.require/bullet_1_and_2.pass.cpp delete mode 100644 test/std/utilities/function.objects/func.require/bullet_3_and_4.pass.cpp delete mode 100644 test/std/utilities/function.objects/func.require/bullet_5.pass.cpp delete mode 100644 test/std/utilities/function.objects/func.require/invoke.pass.cpp delete mode 100644 test/std/utilities/function.objects/func.require/invoke_helpers.h (limited to 'test/std/utilities/function.objects/func.require') diff --git a/test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp b/test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp new file mode 100644 index 000000000000..d61c3773e539 --- /dev/null +++ b/test/std/utilities/function.objects/func.require/INVOKE_tested_elsewhere.pass.cpp @@ -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() {} diff --git a/test/std/utilities/function.objects/func.require/bullet_1_and_2.pass.cpp b/test/std/utilities/function.objects/func.require/bullet_1_and_2.pass.cpp deleted file mode 100644 index e579f207a33f..000000000000 --- a/test/std/utilities/function.objects/func.require/bullet_1_and_2.pass.cpp +++ /dev/null @@ -1,318 +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. -// -//===----------------------------------------------------------------------===// - -// - -// INVOKE (f, t1, t2, ..., tN) - -//------------------------------------------------------------------------------ -// TESTING INVOKE(f, t1, t2, ..., tN) -// - Bullet 1 -- (t1.*f)(t2, ..., tN) -// - Bullet 2 -- ((*t1).*f)(t2, ..., tN) -// -// Overview: -// Bullets 1 and 2 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 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. -// -// -// 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()' -// -// 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 -#include -#include - -#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::setUncheckedCall(); } \ - R f(__VA_ARGS__) const { return MethodID::setUncheckedCall(); } \ - R f(__VA_ARGS__) volatile { return MethodID::setUncheckedCall(); } \ - R f(__VA_ARGS__) const volatile { return MethodID::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::setUncheckedCall(); } \ - R f(__VA_ARGS__) const & { return MethodID::setUncheckedCall(); } \ - R f(__VA_ARGS__) volatile & { return MethodID::setUncheckedCall(); } \ - R f(__VA_ARGS__) const volatile & { return MethodID::setUncheckedCall(); } \ - R f(__VA_ARGS__) && { return MethodID::setUncheckedCall(); } \ - R f(__VA_ARGS__) const && { return MethodID::setUncheckedCall(); } \ - R f(__VA_ARGS__) volatile && { return MethodID::setUncheckedCall(); } \ - R f(__VA_ARGS__) const volatile && { return MethodID::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 -struct TestCaseImp { -public: - - static void run() { TestCaseImp().doTest(); } - -private: - //========================================================================== - // TEST DISPATCH - void doTest() { - // (Plan-2) Create test call objects. - typedef ClassType T; - typedef DerivedFromType D; - T obj; - T* obj_ptr = &obj; - D der; - D* der_ptr = &der; - DerefToType dref; - DerefPropType dref2; - - // (Plan-3) Dispatch based on the CV tags. - CV tag; - Bool NotRValue; - runTestDispatch(tag, obj); - runTestDispatch(tag, der); - runTestDispatch(tag, dref2); - runTestDispatchIf(NotRValue, tag, dref); - runTestDispatchIf(NotRValue, tag, obj_ptr); - runTestDispatchIf(NotRValue, tag, der_ptr); - } - - template - void runTestDispatchIf(Bool, QT q, Tp& v) { - runTestDispatch(q, v); - } - - template - void runTestDispatchIf(Bool, QT, Tp&) { - } - - template - void runTestDispatch(Q_None, Tp& v) { - runTest(v); - } - - template - void runTestDispatch(Q_Const, Tp& v) { - Tp const& cv = v; - runTest(v); - runTest(cv); - } - - template - void runTestDispatch(Q_Volatile, Tp& v) { - Tp volatile& vv = v; - runTest(v); - runTest(vv); - } - - template - void runTestDispatch(Q_CV, Tp& v) { - Tp const& cv = v; - Tp volatile& vv = v; - Tp const volatile& cvv = v; - runTest(v); - runTest(cv); - runTest(vv); - runTest(cvv); - } - - template - void runTest(Obj& obj) { - typedef Caster SCast; - typedef Caster ACast; - typedef CallSig (ClassType::*MemPtr); - // Delegate test to logic in invoke_helpers.h - BasicTest, Arity, SCast, ACast> b; - b.runTest( (MemPtr)&ClassType::f, obj); - } -}; - -template -struct TestCase : public TestCaseImp {}; - -#if TEST_STD_VER >= 11 -template -struct TestCase11 : public TestCaseImp {}; -#endif - -int main() { - typedef void*& R; - typedef ArgType A; - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - -#if TEST_STD_VER >= 11 - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); - TestCase11::run(); -#endif -} \ No newline at end of file diff --git a/test/std/utilities/function.objects/func.require/bullet_3_and_4.pass.cpp b/test/std/utilities/function.objects/func.require/bullet_3_and_4.pass.cpp deleted file mode 100644 index b6fe190bd2a7..000000000000 --- a/test/std/utilities/function.objects/func.require/bullet_3_and_4.pass.cpp +++ /dev/null @@ -1,164 +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. -// -//===----------------------------------------------------------------------===// - -// - -// INVOKE (f, t1, t2, ..., tN) - -//------------------------------------------------------------------------------ -// TESTING INVOKE(f, t1, t2, ..., tN) -// - Bullet 3 -- t1.*f -// - Bullet 4 -- (*t1).*f -// -// Overview: -// Bullets 3 and 4 handle the case where 'f' is a pointer to member object. -// Bullet 3 only handles the cases where t1 is an object of type T or a -// type derived from 'T'. Bullet 4 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. - -#include -#include -#include - -#include "test_macros.h" -#include "invoke_helpers.h" - -template -struct TestMemberObject { - TestMemberObject() : object() {} - Tp object; -private: - TestMemberObject(TestMemberObject const&); - TestMemberObject& operator=(TestMemberObject const&); -}; - -template -struct TestCase { - public: - - static void run() { TestCase().doTest(); } - -private: - typedef TestMemberObject TestType; - - //========================================================================== - // TEST DISPATCH - void doTest() { - typedef DerivedFromType Derived; - TestType obj; - TestType* obj_ptr = &obj; - Derived der; - Derived* der_ptr = &der; - DerefToType dref; - DerefPropType dref2; - - { - typedef ObjectType (TestType::*MemPtr); - typedef ObjectType E; - MemPtr M = &TestType::object; - runTestDispatch(M, obj, &obj.object); - runTestDispatch(M, der, &der.object); - runTestDispatch(M, dref2, &dref2.object.object); - runTestPointerDispatch(M, obj_ptr, &obj_ptr->object); - runTestPointerDispatch(M, der_ptr, &der_ptr->object); - runTestPointerDispatch(M, dref, &dref.object.object); - } - { - typedef ObjectType const (TestType::*CMemPtr); - typedef ObjectType const E; - CMemPtr M = &TestType::object; - runTestDispatch(M, obj, &obj.object); - runTestDispatch(M, der, &der.object); - runTestDispatch(M, dref2, &dref2.object.object); - runTestPointerDispatch(M, obj_ptr, &obj_ptr->object); - runTestPointerDispatch(M, der_ptr, &der_ptr->object); - runTestPointerDispatch(M, dref, &dref.object.object); - } - { - typedef ObjectType volatile (TestType::*VMemPtr); - typedef ObjectType volatile E; - VMemPtr M = &TestType::object; - runTestDispatch(M, obj, &obj.object); - runTestDispatch(M, der, &der.object); - runTestDispatch(M, dref2, &dref2.object.object); - runTestPointerDispatch(M, obj_ptr, &obj_ptr->object); - runTestPointerDispatch(M, der_ptr, &der_ptr->object); - runTestPointerDispatch(M, dref, &dref.object.object); - } - { - typedef ObjectType const volatile (TestType::*CVMemPtr); - typedef ObjectType const volatile E; - CVMemPtr M = &TestType::object; - runTestDispatch(M, obj, &obj.object); - runTestDispatch(M, der, &der.object); - runTestDispatch(M, dref2, &dref2.object.object); - runTestPointerDispatch(M, obj_ptr, &obj_ptr->object); - runTestPointerDispatch(M, der_ptr, &der_ptr->object); - runTestPointerDispatch(M, dref, &dref.object.object); - } - } - - template - void runTestDispatch(Fn M, T& obj, ObjectType* expect) { - runTest (M, C_(obj), expect); - runTest (M, C_(obj), expect); - runTest (M, C_(obj), expect); - runTest(M, C_(obj), expect); -#if TEST_STD_VER >= 11 - runTest (M, C_(obj), expect); - runTest (M, C_(obj), expect); - runTest (M, C_(obj), expect); - runTest(M, C_(obj), expect); -#endif - } - - template - void runTestPointerDispatch(Fn M, T& obj, ObjectType* expect) { - runTest(M, C_(obj), expect); - runTest(M, C_(obj), expect); - runTest(M, C_(obj), expect); - runTest(M, C_(obj), expect); -#if TEST_STD_VER >= 11 - runTest(M, C_(obj), expect); - runTest(M, C_(obj), expect); - runTest(M, C_(obj), expect); - runTest(M, C_(obj), expect); -#endif - } - - template -#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(obj))), Expect - >::value), ""); - Expect e = std::__invoke(M, std::forward(obj)); - assert(&e == expect); - } -}; - -int main() { - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); - TestCase::run(); -} \ No newline at end of file diff --git a/test/std/utilities/function.objects/func.require/bullet_5.pass.cpp b/test/std/utilities/function.objects/func.require/bullet_5.pass.cpp deleted file mode 100644 index 3f3c96a9b9bd..000000000000 --- a/test/std/utilities/function.objects/func.require/bullet_5.pass.cpp +++ /dev/null @@ -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. -// -//===----------------------------------------------------------------------===// - -// - -// INVOKE (f, t1, t2, ..., tN) - -//------------------------------------------------------------------------------ -// TESTING INVOKE(f, t1, t2, ..., tN) -// - Bullet 5 -- f(t2, ..., tN) -// -// Overview: -// Bullet 5 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 -#include -#include - -#include "test_macros.h" -#include "invoke_helpers.h" - - -//============================================================================== -// freeFunction03 - A C++03 free function. -void*& freeFunction03() { - return FunctionPtrID::setUncheckedCall(); -} - -void*& freeFunction03(...) { - return FunctionPtrID::setUncheckedCall(); -} - -template -void*& freeFunction03(A0&) { - return FunctionPtrID::setUncheckedCall(); -} - - -template -void*& freeFunction03(A0&, ...) { - return FunctionPtrID::setUncheckedCall(); -} - -template -void*& freeFunction03(A0&, A1&) { - return FunctionPtrID::setUncheckedCall(); -} - - -template -void*& freeFunction03(A0&, A1&, ...) { - return FunctionPtrID::setUncheckedCall(); -} - -template -void*& freeFunction03(A0&, A1&, A2&) { - return FunctionPtrID::setUncheckedCall(); -} - -template -void*& freeFunction03(A0&, A1&, A2&, ...) { - return FunctionPtrID::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::setUncheckedCall(); } \ - __VA_ARGS__ R operator() Args const { return MethodID::setUncheckedCall(); } \ - __VA_ARGS__ R operator() Args volatile { return MethodID::setUncheckedCall(); } \ - __VA_ARGS__ R operator() Args const volatile { return MethodID::setUncheckedCall(); } -# - F(()) - F((A0&), template ) - F((A0&, A1&), template ) - F((A0&, A1&, A2&), template ) -#undef F -public: - Functor03() {} -private: - Functor03(Functor03 const&); - Functor03& operator=(Functor03 const&); -}; - - -#if TEST_STD_VER >= 11 - -//============================================================================== -// freeFunction11 - A C++11 free function. -template -void*& freeFunction11(Args&&...) { - return FunctionPtrID::setUncheckedCall(); -} - -template -void*& freeFunction11(Args&&...,...) { - return FunctionPtrID::setUncheckedCall(); -} - -//============================================================================== -// Functor11 - C++11 reference qualified test member functions. -struct Functor11 { - typedef void*& R; - typedef Functor11 C; - -#define F(CV) \ - template \ - R operator()(Args&&...) CV { return MethodID::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 -struct TestCaseFunctorImp { -public: - static void run() { - typedef MethodID MID; - BasicTest t; - typedef ClassType T; - typedef DerivedFromType 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 -struct TestCaseFreeFunction { -public: - static void run() { - typedef FunctionPtrID FID; - BasicTest t; - - DerefToType deref_to(FnPtr); - DerefToType 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 -void runFunctionTestCase11() { - TestCaseFreeFunction(); -} -#endif - -template -void runFunctionTestCase() { - TestCaseFreeFunction(); -#if TEST_STD_VER >= 11 - runFunctionTestCase11(); -#endif -} - -template -void runFunctorTestCase() { - TestCaseFunctorImp::run(); -} - -template -void runFunctorTestCase() { - TestCaseFunctorImp::run(); -} - -#if TEST_STD_VER >= 11 -// runTestCase - Run a test case for C++11 class functor types -template -void runFunctorTestCase11() { - TestCaseFunctorImp::run(); -} -#endif - -// runTestCase - Run a test case for both function and functor types. -template -void runTestCase() { - runFunctionTestCase(); - runFunctorTestCase (); -}; - -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(); - runFunctionTestCase(); - runFunctionTestCase(); - runFunctionTestCase(); - -#if TEST_STD_VER >= 11 - runFunctionTestCase11(); - runFunctionTestCase11(); -#endif - - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - { - typedef ConstCaster CC; - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - runFunctorTestCase(); - } - -#if TEST_STD_VER >= 11 - runFunctorTestCase11(); - runFunctorTestCase11(); - runFunctorTestCase11(); - runFunctorTestCase11(); - runFunctorTestCase11(); - runFunctorTestCase11(); - runFunctorTestCase11(); - runFunctorTestCase11(); - { - typedef MoveCaster MC; - runFunctorTestCase11(); - runFunctorTestCase11(); - runFunctorTestCase11(); - runFunctorTestCase11(); - runFunctorTestCase11(); - runFunctorTestCase11(); - runFunctorTestCase11(); - runFunctorTestCase11(); - } -#endif -} diff --git a/test/std/utilities/function.objects/func.require/invoke.pass.cpp b/test/std/utilities/function.objects/func.require/invoke.pass.cpp deleted file mode 100644 index 25681630a80c..000000000000 --- a/test/std/utilities/function.objects/func.require/invoke.pass.cpp +++ /dev/null @@ -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 - -template -struct Array -{ - typedef T type[N]; -}; - -struct Type -{ - Array::type& f1(); - Array::type& f2() const; - - Array::type& g1() &; - Array::type& g2() const &; -#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - Array::type& g3() &&; - Array::type& g4() const &&; -#endif -}; - -int main() -{ - static_assert(sizeof(std::__invoke(&Type::f1, std::declval())) == 1, ""); - static_assert(sizeof(std::__invoke(&Type::f2, std::declval())) == 2, ""); - - static_assert(sizeof(std::__invoke(&Type::g1, std::declval())) == 1, ""); - static_assert(sizeof(std::__invoke(&Type::g2, std::declval())) == 2, ""); -#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - static_assert(sizeof(std::__invoke(&Type::g3, std::declval())) == 3, ""); - static_assert(sizeof(std::__invoke(&Type::g4, std::declval())) == 4, ""); -#endif -} -#endif diff --git a/test/std/utilities/function.objects/func.require/invoke_helpers.h b/test/std/utilities/function.objects/func.require/invoke_helpers.h deleted file mode 100644 index a85b39f37175..000000000000 --- a/test/std/utilities/function.objects/func.require/invoke_helpers.h +++ /dev/null @@ -1,326 +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 -#include -#include - -#include "test_macros.h" - -template -struct Int : public std::integral_constant {}; - -template -struct Bool : public std::integral_constant {}; - -struct Q_None { - template - struct apply { typedef T type; }; -}; - -struct Q_Const { - template - struct apply { typedef T const type; }; -}; - -struct Q_Volatile { - template - struct apply { typedef T volatile type; }; -}; - -struct Q_CV { - template - 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 -struct Caster { - template - struct apply { - typedef typename std::remove_reference::type RawType; - typedef typename QualTag::template apply::type CVType; -#if TEST_STD_VER >= 11 - typedef typename std::conditional::type type; -#else - typedef CVType& type; -#endif - }; - - template - typename apply::type - operator()(T& obj) const { - typedef typename apply::type OutType; - return static_cast(obj); - } -}; - -typedef Caster LValueCaster; -typedef Caster ConstCaster; -typedef Caster VolatileCaster; -typedef Caster CVCaster; -typedef Caster MoveCaster; -typedef Caster MoveConstCaster; -typedef Caster MoveVolatileCaster; -typedef Caster MoveCVCaster; - -// A shorter name for 'static_cast' -template -QualType C_(Tp& v) { return static_cast(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 -struct DerivedFromType : public Base { - DerivedFromType() : Base() {} - template - 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 -struct DerefToType { - To object; - - DerefToType() {} - - template - explicit DerefToType(Up const& val) : object(val) {} - - To& operator*() const volatile { return const_cast(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 -struct DerefPropType { - To object; - - DerefPropType() {} - - template - 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(object); } - To const&& operator*() const && { return static_cast(object); } - To volatile&& operator*() volatile && { return static_cast(object); } - To const volatile&& operator*() const volatile && { return static_cast(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()` to assert -// that the method has been called and that the return value of `__invoke` -// matches what the method actually returned. -template -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 int MethodID::dummy = 0; -template void* MethodID::id = (void*)&MethodID::dummy; -template bool MethodID::unchecked_call = false; - - -//============================================================================== -// FunctionPtrID - Like MethodID but for free function pointers. -template -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 int FunctionPtrID::dummy = 0; -template void* FunctionPtrID::id = (void*)&FunctionPtrID::dummy; -template bool FunctionPtrID::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 -struct BasicTest { - template - void runTest(ObjectT& object) { - Int A; - runTestImp(A, object); - } - - template - void runTest(MethodPtr ptr, ObjectT& object) { - Int A; - runTestImp(A, ptr, object); - } - -private: - typedef void*& CallRet; - ObjectCaster object_cast; - ArgCaster arg_cast; - ArgType a0, a1, a2; - - //========================================================================== - // BULLET 1 AND 2 TEST METHODS - //========================================================================== - template - 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)); - } - - template - 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)); - } - - template - 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)); - } - - template - 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)); - } - - //========================================================================== - // BULLET 5 TEST METHODS - //========================================================================== - template - 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)); - } - - template - 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)); - } - - template - 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)); - } - - template - 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)); - } -}; - -#endif // INVOKE_HELPERS_H -- cgit v1.2.3