diff options
Diffstat (limited to 'src/boost/libs/fusion/test/functional')
12 files changed, 2157 insertions, 0 deletions
diff --git a/src/boost/libs/fusion/test/functional/fused.cpp b/src/boost/libs/fusion/test/functional/fused.cpp new file mode 100644 index 000000000..b2ce8dde9 --- /dev/null +++ b/src/boost/libs/fusion/test/functional/fused.cpp @@ -0,0 +1,97 @@ +/*============================================================================= + Copyright (c) 2006-2007 Tobias Schwinger + + Use modification and distribution are subject to the Boost Software + License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at + http://www.boost.org/LICENSE_1_0.txt). +==============================================================================*/ + +#include <boost/fusion/functional/adapter/fused.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/noncopyable.hpp> + +#include <boost/fusion/container/generation/make_vector.hpp> +#include <boost/fusion/container/vector.hpp> + +#include <boost/type_traits/is_same.hpp> +#include <boost/mpl/assert.hpp> +#include <boost/mpl/empty_base.hpp> + +namespace fusion = boost::fusion; +using boost::noncopyable; + +template <class Base = boost::mpl::empty_base> +struct test_func + : Base +{ + typedef int result_type; + + template <typename T0, typename T1> + int operator()(T0 const & x, T1 const & y) const + { + return 1+x-y; + } + + template <typename T0, typename T1> + int operator()(T0 const & x, T1 const & y) + { + return 2+x-y; + } + + template <typename T0, typename T1> + int operator()(T0 & x, T1 & y) const + { + return 3+x-y; + } + + template <typename T0, typename T1> + int operator()(T0 & x, T1 & y) + { + return 4+x-y; + } +}; + +int main() +{ + test_func<noncopyable> f; + + typedef fusion::fused< test_func<> > ff; + ff fused_func; + + typedef fusion::fused< test_func<noncopyable> & > ffr; + ffr fused_func_ref(f); + + typedef fusion::fused< test_func<> const > ffc; + ffc fused_func_c; + + typedef fusion::fused< test_func<> > const ffc2; + ffc2 fused_func_c2; + + typedef fusion::fused< test_func<noncopyable> const & > ffcr; + ffcr fused_func_c_ref(f); + + typedef fusion::vector<int,char> vec; + vec lv_vec(1,'\004'); + + BOOST_MPL_ASSERT((boost::is_same<boost::result_of<ff(vec)>::type, int>)); + BOOST_TEST(fused_func(lv_vec) == 1); + BOOST_MPL_ASSERT((boost::is_same<boost::result_of<ffr(vec)>::type, int>)); + BOOST_TEST(fused_func_c(lv_vec) == 0); + BOOST_MPL_ASSERT((boost::is_same<boost::result_of<ffc(vec)>::type, int>)); + BOOST_TEST(fused_func_c2(lv_vec) == 0); + BOOST_TEST(fused_func_ref(lv_vec) == 1); + BOOST_MPL_ASSERT((boost::is_same<boost::result_of<ffcr(vec)>::type, int>)); + BOOST_TEST(fused_func_c_ref(lv_vec) == 0); + + BOOST_TEST(fused_func(fusion::make_vector(2,'\003')) == 1); + BOOST_TEST(fused_func_c(fusion::make_vector(2,'\003')) == 0); + BOOST_TEST(fused_func_c2(fusion::make_vector(2,'\003')) == 0); + BOOST_TEST(fused_func_ref(fusion::make_vector(2,'\003')) == 1); + BOOST_TEST(fused_func_c_ref(fusion::make_vector(2,'\003')) == 0); + + return boost::report_errors(); +} + + + diff --git a/src/boost/libs/fusion/test/functional/fused_function_object.cpp b/src/boost/libs/fusion/test/functional/fused_function_object.cpp new file mode 100644 index 000000000..399745a06 --- /dev/null +++ b/src/boost/libs/fusion/test/functional/fused_function_object.cpp @@ -0,0 +1,83 @@ +/*============================================================================= + Copyright (c) 2006-2007 Tobias Schwinger + + Use modification and distribution are subject to the Boost Software + License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at + http://www.boost.org/LICENSE_1_0.txt). +==============================================================================*/ + +#include <boost/fusion/functional/adapter/fused_function_object.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/noncopyable.hpp> +#include <boost/mpl/empty_base.hpp> + +#include <boost/fusion/container/generation/make_vector.hpp> +#include <boost/fusion/container/vector.hpp> + +namespace fusion = boost::fusion; +using boost::noncopyable; + +template <class Base = boost::mpl::empty_base> +struct test_func + : Base +{ + template<typename T> + struct result; + + template<class Self, typename T0, typename T1> + struct result< Self(T0, T1) > + { + typedef int type; + }; + + template <typename T0, typename T1> + int operator()(T0 const & x, T1 const & y) const + { + return 1+x-y; + } + + template <typename T0, typename T1> + int operator()(T0 const & x, T1 const & y) + { + return 2+x-y; + } + + template <typename T0, typename T1> + int operator()(T0 & x, T1 & y) const + { + return 3+x-y; + } + + template <typename T0, typename T1> + int operator()(T0 & x, T1 & y) + { + return 4+x-y; + } +}; + +int main() +{ + test_func<noncopyable> f; + fusion::fused_function_object< test_func<> > fused_func; + fusion::fused_function_object< test_func<noncopyable> & > fused_func_ref(f); + fusion::fused_function_object< test_func<> const > fused_func_c; + fusion::fused_function_object< test_func<> > const fused_func_c2; + fusion::fused_function_object< test_func<noncopyable> const & > fused_func_c_ref(f); + + fusion::vector<int,char> lv_vec(1,'\004'); + BOOST_TEST(fused_func(lv_vec) == 1); + BOOST_TEST(fused_func_c(lv_vec) == 0); + BOOST_TEST(fused_func_c2(lv_vec) == 0); + BOOST_TEST(fused_func_ref(lv_vec) == 1); + BOOST_TEST(fused_func_c_ref(lv_vec) == 0); + + BOOST_TEST(fused_func(fusion::make_vector(2,'\003')) == 1); + BOOST_TEST(fused_func_c(fusion::make_vector(2,'\003')) == 0); + BOOST_TEST(fused_func_c2(fusion::make_vector(2,'\003')) == 0); + BOOST_TEST(fused_func_ref(fusion::make_vector(2,'\003')) == 1); + BOOST_TEST(fused_func_c_ref(fusion::make_vector(2,'\003')) == 0); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/functional/fused_procedure.cpp b/src/boost/libs/fusion/test/functional/fused_procedure.cpp new file mode 100644 index 000000000..1ed0ddf73 --- /dev/null +++ b/src/boost/libs/fusion/test/functional/fused_procedure.cpp @@ -0,0 +1,82 @@ +/*============================================================================= + Copyright (c) 2006-2007 Tobias Schwinger + + Use modification and distribution are subject to the Boost Software + License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at + http://www.boost.org/LICENSE_1_0.txt). +==============================================================================*/ + +#include <boost/fusion/functional/adapter/fused_procedure.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/noncopyable.hpp> +#include <boost/mpl/empty_base.hpp> + +#include <boost/fusion/container/generation/make_vector.hpp> +#include <boost/fusion/container/vector.hpp> + +namespace fusion = boost::fusion; +using boost::noncopyable; + +int effect; + +#define CHECK_EFFECT(t,e) \ + { \ + effect = 1234567; t; \ + BOOST_TEST(effect == e); \ + } + +template <class Base = boost::mpl::empty_base> +struct test_func + : Base +{ + template <typename T0, typename T1> + int operator()(T0 const & x, T1 const & y) const + { + return effect = 1+x-y; + } + + template <typename T0, typename T1> + int operator()(T0 const & x, T1 const & y) + { + return effect = 2+x-y; + } + + template <typename T0, typename T1> + int operator()(T0 & x, T1 & y) const + { + return effect = 3+x-y; + } + + template <typename T0, typename T1> + int operator()(T0 & x, T1 & y) + { + return effect = 4+x-y; + } +}; + +int main() +{ + test_func<noncopyable> f; + fusion::fused_procedure< test_func<> > fused_proc; + fusion::fused_procedure< test_func<noncopyable> & > fused_proc_ref(f); + fusion::fused_procedure< test_func<> const > fused_proc_c; + fusion::fused_procedure< test_func<> > const fused_proc_c2; + fusion::fused_procedure< test_func<noncopyable> const & > fused_proc_c_ref(f); + + fusion::vector<int,char> lv_vec(1,'\004'); + CHECK_EFFECT(fused_proc(lv_vec), 1); + CHECK_EFFECT(fused_proc_c(lv_vec), 0); + CHECK_EFFECT(fused_proc_c2(lv_vec), 0); + CHECK_EFFECT(fused_proc_ref(lv_vec), 1); + CHECK_EFFECT(fused_proc_c_ref(lv_vec), 0); + + CHECK_EFFECT(fused_proc(fusion::make_vector(2,'\003')), 1); + CHECK_EFFECT(fused_proc_c(fusion::make_vector(2,'\003')), 0); + CHECK_EFFECT(fused_proc_c2(fusion::make_vector(2,'\003')), 0); + CHECK_EFFECT(fused_proc_ref(fusion::make_vector(2,'\003')), 1); + CHECK_EFFECT(fused_proc_c_ref(fusion::make_vector(2,'\003')), 0); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/functional/invoke.cpp b/src/boost/libs/fusion/test/functional/invoke.cpp new file mode 100644 index 000000000..3117eb3f1 --- /dev/null +++ b/src/boost/libs/fusion/test/functional/invoke.cpp @@ -0,0 +1,562 @@ +/*============================================================================= + Copyright (c) 2005-2006 Joao Abecasis + Copyright (c) 2006-2007 Tobias Schwinger + + Use modification and distribution are subject to the Boost Software + License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at + http://www.boost.org/LICENSE_1_0.txt). +==============================================================================*/ + +#include <boost/config.hpp> +#include <boost/fusion/functional/invocation/invoke.hpp> +#include <boost/detail/lightweight_test.hpp> + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +#include <functional> +#endif + +#include <memory> +#include <boost/noncopyable.hpp> + +#include <boost/type_traits/is_same.hpp> + +#include <boost/mpl/int.hpp> + +#include <boost/fusion/container/vector.hpp> +#include <boost/fusion/container/list.hpp> +#include <boost/fusion/sequence/intrinsic/size.hpp> +#include <boost/fusion/sequence/intrinsic/begin.hpp> +#include <boost/fusion/view/single_view.hpp> +#include <boost/fusion/view/iterator_range.hpp> +#include <boost/fusion/iterator/advance.hpp> +#include <boost/fusion/algorithm/transformation/join.hpp> + +#include "../compile_time/sfinae_friendly.hpp" + +namespace mpl = boost::mpl; +namespace fusion = boost::fusion; + +template <typename T> +inline T const & const_(T const & t) +{ + return t; +} + +struct object {}; +struct object_nc : boost::noncopyable {}; + +struct fobj +{ + // Handle nullary separately to exercise result_of support + template <typename Sig> + struct result; + + template <class Self, typename T0> + struct result< Self(T0) > + { + typedef int type; + }; + + template <class Self, typename T0, typename T1> + struct result< Self(T0, T1) > + { + typedef int type; + }; + + template <class Self, typename T0, typename T1, typename T2> + struct result< Self(T0, T1, T2) > + { + typedef int type; + }; + + int operator()(int i) { return 2 + i; } + int operator()(int i) const { return 3 + i; } + + int operator()(int i, object &) { return 4 + i; } + int operator()(int i, object &) const { return 5 + i; } + int operator()(int i, object const &) { return 6 + i; } + int operator()(int i, object const &) const { return 7 + i; } + + int operator()(int i, object &, object_nc &) { return 10 + i; } + int operator()(int i, object &, object_nc &) const { return 11 + i; } + int operator()(int i, object const &, object_nc &); + int operator()(int i, object const &, object_nc &) const; +}; +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<fobj, sfinae_friendly::v0>)); +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<fobj, sfinae_friendly::v1>)); +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<fobj, sfinae_friendly::v2>)); +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<fobj, sfinae_friendly::v3>)); + + +struct nullary_fobj +{ + typedef int result_type; + + int operator()() { return 0; } + int operator()() const { return 1; } +}; +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<nullary_fobj, sfinae_friendly::v1>)); +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<nullary_fobj, sfinae_friendly::v2>)); +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<nullary_fobj, sfinae_friendly::v3>)); + + +struct fobj_nc + : boost::noncopyable +{ + // Handle nullary separately to exercise result_of support + template <typename Sig> + struct result; + + template <class Self, typename T0> + struct result< Self(T0)> + { + typedef int type; + }; + + int operator()(int i) { return 14 + i; } + int operator()(int i) const { return 15 + i; } +}; +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<fobj_nc, sfinae_friendly::v0>)); +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<fobj_nc, sfinae_friendly::v1>)); +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<fobj_nc, sfinae_friendly::v2>)); +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<fobj_nc, sfinae_friendly::v3>)); + + +struct nullary_fobj_nc + : boost::noncopyable +{ + typedef int result_type; + + int operator()() { return 12; } + int operator()() const { return 13; } +}; +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<nullary_fobj_nc, sfinae_friendly::v1>)); +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<nullary_fobj_nc, sfinae_friendly::v2>)); +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<nullary_fobj_nc, sfinae_friendly::v3>)); + + +int nullary() { return 16; } +int unary(int i) { return 17 + i; } +int binary1(int i, object &) { return 18 + i; } +int binary2(int i, object const &) { return 19 + i; } +//FIXME +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<int(*)(), sfinae_friendly::v1>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<int(*)(), sfinae_friendly::v2>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<int(*)(), sfinae_friendly::v3>)); +// +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<int(*)(int), sfinae_friendly::v0>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<int(*)(int), sfinae_friendly::v1>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<int(*)(int), sfinae_friendly::v2>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<int(*)(int), sfinae_friendly::v3>)); +// +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<int(*)(int, object &), sfinae_friendly::v0>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<int(*)(int, object &), sfinae_friendly::v1>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<int(*)(int, object &), sfinae_friendly::v2>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<int(*)(int, object &), sfinae_friendly::v3>)); +// +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<int(*)(int, object const &), sfinae_friendly::v0>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<int(*)(int, object const &), sfinae_friendly::v1>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<int(*)(int, object const &), sfinae_friendly::v2>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<int(*)(int, object const &), sfinae_friendly::v3>)); + +typedef int (* func_ptr)(int); +typedef int (* const c_func_ptr)(int); +typedef int (* volatile v_func_ptr)(int); +typedef int (* const volatile cv_func_ptr)(int); + + func_ptr func_ptr1 = &unary; + c_func_ptr func_ptr2 = &unary; + v_func_ptr func_ptr3 = &unary; +cv_func_ptr func_ptr4 = &unary; + +class members +{ + public: + int data; + + members() + : data(20) + { } + + int nullary() { return data + 1; } + int nullary_c() const { return data + 2; } + int unary(int i) { return data + 3 + i; } + int unary_c(int i) const { return data + 4 + i; } + int binary(int i, object) { return data + 5 + i; } + int binary_c(int i, object) const { return data + 6 + i; } +}; + +#ifdef BOOST_NO_CXX11_SMART_PTR +typedef std::auto_ptr<members > members_ptr; +typedef std::auto_ptr<members const> const_members_ptr; +#else +typedef std::unique_ptr<members > members_ptr; +typedef std::unique_ptr<members const> const_members_ptr; +#endif + +struct derived + : members +{ +}; + +#ifdef BOOST_NO_CXX11_SMART_PTR +typedef std::auto_ptr<derived > derived_ptr; +typedef std::auto_ptr<derived const> const_derived_ptr; +#else +typedef std::unique_ptr<derived > derived_ptr; +typedef std::unique_ptr<derived const> const_derived_ptr; +#endif + + +typedef int element1_type; +typedef object element2_type; +typedef object_nc & element3_type; + +int element1 = 100; +object element2 = object(); +object_nc element3; + +members that; + +members_ptr spt_that(new members); +const_members_ptr spt_that_c(new members); + +typedef fusion::single_view<members > sv_obj; +typedef fusion::single_view<members &> sv_ref; +typedef fusion::single_view<members *> sv_ptr; +typedef fusion::single_view<members const > sv_obj_c; +typedef fusion::single_view<members const &> sv_ref_c; +typedef fusion::single_view<members const *> sv_ptr_c; +typedef fusion::single_view<members_ptr const &> sv_spt; +typedef fusion::single_view<const_members_ptr const &> sv_spt_c; + +sv_obj sv_obj_ctx( that); +sv_ref sv_ref_ctx( that); +sv_ptr sv_ptr_ctx(& that); +sv_obj_c sv_obj_c_ctx( that); +sv_ref_c sv_ref_c_ctx( that); +sv_ptr_c sv_ptr_c_ctx(& that); +sv_spt sv_spt_ctx(spt_that); +sv_spt_c sv_spt_c_ctx(spt_that_c); +template <typename F, typename S> +struct sv_helper +{ + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<F, typename fusion::result_of::join<sv_obj , S>::type>)); + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<F, typename fusion::result_of::join<sv_ref , S>::type>)); + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<F, typename fusion::result_of::join<sv_ptr , S>::type>)); + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<F, typename fusion::result_of::join<sv_obj_c, S>::type>)); + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<F, typename fusion::result_of::join<sv_ref_c, S>::type>)); + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<F, typename fusion::result_of::join<sv_ptr_c, S>::type>)); + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<F, typename fusion::result_of::join<sv_spt , S>::type>)); + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<F, typename fusion::result_of::join<sv_spt_c, S>::type>)); +}; +// FIXME: +//template struct sv_helper<int (members::*)() , sfinae_friendly::v1>; +//template struct sv_helper<int (members::*)() , sfinae_friendly::v2>; +//template struct sv_helper<int (members::*)() , sfinae_friendly::v3>; +//template struct sv_helper<int (members::*)() const, sfinae_friendly::v1>; +//template struct sv_helper<int (members::*)() const, sfinae_friendly::v2>; +//template struct sv_helper<int (members::*)() const, sfinae_friendly::v3>; + +//template struct sv_helper<int (members::*)(int) , sfinae_friendly::v0>; +//template struct sv_helper<int (members::*)(int) , sfinae_friendly::v1>; +//template struct sv_helper<int (members::*)(int) , sfinae_friendly::v2>; +//template struct sv_helper<int (members::*)(int) , sfinae_friendly::v3>; +//template struct sv_helper<int (members::*)(int) const, sfinae_friendly::v0>; +//template struct sv_helper<int (members::*)(int) const, sfinae_friendly::v1>; +//template struct sv_helper<int (members::*)(int) const, sfinae_friendly::v2>; +//template struct sv_helper<int (members::*)(int) const, sfinae_friendly::v3>; + +//template struct sv_helper<int (members::*)(int, object) , sfinae_friendly::v0>; +//template struct sv_helper<int (members::*)(int, object) , sfinae_friendly::v1>; +//template struct sv_helper<int (members::*)(int, object) , sfinae_friendly::v2>; +//template struct sv_helper<int (members::*)(int, object) , sfinae_friendly::v3>; +//template struct sv_helper<int (members::*)(int, object) const, sfinae_friendly::v0>; +//template struct sv_helper<int (members::*)(int, object) const, sfinae_friendly::v1>; +//template struct sv_helper<int (members::*)(int, object) const, sfinae_friendly::v2>; +//template struct sv_helper<int (members::*)(int, object) const, sfinae_friendly::v3>; + +derived derived_that; + +derived_ptr spt_derived_that(new derived); +const_derived_ptr spt_derived_that_c(new derived); + +typedef fusion::single_view<derived > sv_obj_d; +typedef fusion::single_view<derived &> sv_ref_d; +typedef fusion::single_view<derived *> sv_ptr_d; +typedef fusion::single_view<derived const > sv_obj_c_d; +typedef fusion::single_view<derived const &> sv_ref_c_d; +typedef fusion::single_view<derived const *> sv_ptr_c_d; +typedef fusion::single_view<derived_ptr const &> sv_spt_d; +typedef fusion::single_view<const_derived_ptr const &> sv_spt_c_d; + +sv_obj_d sv_obj_d_ctx( derived_that); +sv_ref_d sv_ref_d_ctx( derived_that); +sv_ptr_d sv_ptr_d_ctx(& derived_that); +sv_obj_c_d sv_obj_c_d_ctx( derived_that); +sv_ref_c_d sv_ref_c_d_ctx( derived_that); +sv_ptr_c_d sv_ptr_c_d_ctx(& derived_that); +sv_spt_d sv_spt_d_ctx(spt_derived_that); +sv_spt_c_d sv_spt_c_d_ctx(spt_derived_that_c); +template <typename F, typename S> +struct sv_d_helper +{ + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<F, typename fusion::result_of::join<sv_obj_d , S>::type>)); + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<F, typename fusion::result_of::join<sv_ref_d , S>::type>)); + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<F, typename fusion::result_of::join<sv_ptr_d , S>::type>)); + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<F, typename fusion::result_of::join<sv_obj_c_d, S>::type>)); + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<F, typename fusion::result_of::join<sv_ref_c_d, S>::type>)); + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<F, typename fusion::result_of::join<sv_ptr_c_d, S>::type>)); + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<F, typename fusion::result_of::join<sv_spt_d , S>::type>)); + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke<F, typename fusion::result_of::join<sv_spt_c_d, S>::type>)); +}; +// FIXME: +//template struct sv_d_helper<int (members::*)() , sfinae_friendly::v1>; +//template struct sv_d_helper<int (members::*)() , sfinae_friendly::v2>; +//template struct sv_d_helper<int (members::*)() , sfinae_friendly::v3>; +//template struct sv_d_helper<int (members::*)() const, sfinae_friendly::v1>; +//template struct sv_d_helper<int (members::*)() const, sfinae_friendly::v2>; +//template struct sv_d_helper<int (members::*)() const, sfinae_friendly::v3>; + +//template struct sv_d_helper<int (members::*)(int) , sfinae_friendly::v0>; +//template struct sv_d_helper<int (members::*)(int) , sfinae_friendly::v1>; +//template struct sv_d_helper<int (members::*)(int) , sfinae_friendly::v2>; +//template struct sv_d_helper<int (members::*)(int) , sfinae_friendly::v3>; +//template struct sv_d_helper<int (members::*)(int) const, sfinae_friendly::v0>; +//template struct sv_d_helper<int (members::*)(int) const, sfinae_friendly::v1>; +//template struct sv_d_helper<int (members::*)(int) const, sfinae_friendly::v2>; +//template struct sv_d_helper<int (members::*)(int) const, sfinae_friendly::v3>; + +//template struct sv_d_helper<int (members::*)(int, object) , sfinae_friendly::v0>; +//template struct sv_d_helper<int (members::*)(int, object) , sfinae_friendly::v1>; +//template struct sv_d_helper<int (members::*)(int, object) , sfinae_friendly::v2>; +//template struct sv_d_helper<int (members::*)(int, object) , sfinae_friendly::v3>; +//template struct sv_d_helper<int (members::*)(int, object) const, sfinae_friendly::v0>; +//template struct sv_d_helper<int (members::*)(int, object) const, sfinae_friendly::v1>; +//template struct sv_d_helper<int (members::*)(int, object) const, sfinae_friendly::v2>; +//template struct sv_d_helper<int (members::*)(int, object) const, sfinae_friendly::v3>; + +template <class Sequence> +void test_sequence_n(Sequence & seq, mpl::int_<0>) +{ + // Function Objects + + nullary_fobj f; + + BOOST_TEST(f () == fusion::invoke(f , seq )); + BOOST_TEST(f () == fusion::invoke(f , const_(seq))); + + // Note: The function object is taken by value, so we request the copy + // to be const with an explicit template argument. We can also request + // the function object to be pased by reference... + BOOST_TEST(const_(f)() == fusion::invoke<nullary_fobj const >(const_(f), seq )); + BOOST_TEST(const_(f)() == fusion::invoke<nullary_fobj const &>(const_(f), const_(seq))); + + nullary_fobj_nc nc_f; + // ...and we further ensure there is no copying in this case, using a + // noncopyable function object. + BOOST_TEST(nc_f () == fusion::invoke<nullary_fobj_nc &>(nc_f , seq )); + BOOST_TEST(nc_f () == fusion::invoke<nullary_fobj_nc &>(nc_f , const_(seq))); + BOOST_TEST(const_(nc_f)() == fusion::invoke<nullary_fobj_nc const &>(const_(nc_f), seq )); + BOOST_TEST(const_(nc_f)() == fusion::invoke<nullary_fobj_nc const &>(const_(nc_f), const_(seq))); + + // Builtin Functions + + // Call through ref/ptr to function + BOOST_TEST(nullary() == fusion::invoke<int (&)()>(nullary, seq)); + BOOST_TEST(nullary() == fusion::invoke(& nullary, seq)); + + // Call through ptr to member function + // Note: The non-const function members::nullary can't be invoked with + // fusion::join(sv_obj_ctx,seq)), which is const and so is its first element + BOOST_TEST(that.nullary() == fusion::invoke(& members::nullary, fusion::join(sv_ref_ctx,seq))); + BOOST_TEST(that.nullary() == fusion::invoke(& members::nullary, fusion::join(sv_ptr_ctx,seq))); + BOOST_TEST(that.nullary() == fusion::invoke(& members::nullary, fusion::join(sv_spt_ctx,seq))); + BOOST_TEST(that.nullary_c() == fusion::invoke(& members::nullary_c, fusion::join(sv_obj_ctx,seq))); + BOOST_TEST(that.nullary_c() == fusion::invoke(& members::nullary_c, fusion::join(sv_ref_ctx,seq))); + BOOST_TEST(that.nullary_c() == fusion::invoke(& members::nullary_c, fusion::join(sv_ptr_ctx,seq))); + BOOST_TEST(that.nullary_c() == fusion::invoke(& members::nullary_c, fusion::join(sv_spt_ctx,seq))); + BOOST_TEST(that.nullary_c() == fusion::invoke(& members::nullary_c, fusion::join(sv_obj_c_ctx,seq))); + BOOST_TEST(that.nullary_c() == fusion::invoke(& members::nullary_c, fusion::join(sv_ref_c_ctx,seq))); + BOOST_TEST(that.nullary_c() == fusion::invoke(& members::nullary_c, fusion::join(sv_ptr_c_ctx,seq))); + BOOST_TEST(that.nullary_c() == fusion::invoke(& members::nullary_c, fusion::join(sv_spt_c_ctx,seq))); + + // Pointer to data member + + // $$$ JDG $$$ disabling this test due to C++11 error: assignment of read-only location + //~ BOOST_TEST(that.data == (fusion::invoke(& members::data, fusion::join(sv_obj_ctx,seq)) = that.data)); + BOOST_TEST(that.data == (fusion::invoke(& members::data, fusion::join(sv_ref_ctx,seq)) = that.data)); + BOOST_TEST(that.data == (fusion::invoke(& members::data, fusion::join(sv_ptr_ctx,seq)) = that.data)); + BOOST_TEST(that.data == (fusion::invoke(& members::data, fusion::join(sv_spt_ctx,seq)) = that.data)); + // disabling this test, since it tries to return local address which is undefined behavior + //~ BOOST_TEST(that.data == fusion::invoke(& members::data, fusion::join(sv_obj_c_ctx,seq))); + BOOST_TEST(that.data == fusion::invoke(& members::data, fusion::join(sv_ref_c_ctx,seq))); + BOOST_TEST(that.data == fusion::invoke(& members::data, fusion::join(sv_ptr_c_ctx,seq))); + BOOST_TEST(that.data == fusion::invoke(& members::data, fusion::join(sv_spt_c_ctx,seq))); + + // $$$ JDG $$$ disabling this test due to C++11 error: assignment of read-only location + //~ BOOST_TEST(that.data == (fusion::invoke(& members::data, fusion::join(sv_obj_d_ctx,seq)) = that.data)); + BOOST_TEST(that.data == (fusion::invoke(& members::data, fusion::join(sv_ref_d_ctx,seq)) = that.data)); + BOOST_TEST(that.data == (fusion::invoke(& members::data, fusion::join(sv_ptr_d_ctx,seq)) = that.data)); + BOOST_TEST(that.data == (fusion::invoke(& members::data, fusion::join(sv_spt_d_ctx,seq)) = that.data)); + // disabling this test, since it tries to return local address which is undefined behavior + //~ BOOST_TEST(that.data == fusion::invoke(& members::data, fusion::join(sv_obj_c_d_ctx,seq))); + BOOST_TEST(that.data == fusion::invoke(& members::data, fusion::join(sv_ref_c_d_ctx,seq))); + BOOST_TEST(that.data == fusion::invoke(& members::data, fusion::join(sv_ptr_c_d_ctx,seq))); + BOOST_TEST(that.data == fusion::invoke(& members::data, fusion::join(sv_spt_c_d_ctx,seq))); +} + +template <class Sequence> +void test_sequence_n(Sequence & seq, mpl::int_<1>) +{ + fobj f; + BOOST_TEST(f(element1) == fusion::invoke(f , seq )); + BOOST_TEST(f(element1) == fusion::invoke(f , const_(seq))); + BOOST_TEST(const_(f)(element1) == fusion::invoke<fobj const >(const_(f), seq )); + BOOST_TEST(const_(f)(element1) == fusion::invoke<fobj const &>(const_(f), const_(seq))); + + fobj_nc nc_f; + BOOST_TEST(nc_f(element1) == fusion::invoke<fobj_nc &>(nc_f, seq )); + BOOST_TEST(nc_f(element1) == fusion::invoke<fobj_nc &>(nc_f, const_(seq))); + BOOST_TEST(const_(nc_f)(element1) == fusion::invoke<fobj_nc const &>(const_(nc_f), seq )); + BOOST_TEST(const_(nc_f)(element1) == fusion::invoke<fobj_nc const &>(const_(nc_f), const_(seq))); + + BOOST_TEST(unary(element1) == fusion::invoke<int (&)(int)>(unary, seq)); + BOOST_TEST(func_ptr1(element1) == fusion::invoke(func_ptr1, seq)); + BOOST_TEST(func_ptr2(element1) == fusion::invoke(func_ptr2, seq)); + BOOST_TEST(func_ptr3(element1) == fusion::invoke(func_ptr3, seq)); + BOOST_TEST(func_ptr4(element1) == fusion::invoke(func_ptr4, seq)); + + BOOST_TEST(that.unary(element1) == fusion::invoke(& members::unary, fusion::join(sv_ref_ctx,seq))); + BOOST_TEST(that.unary(element1) == fusion::invoke(& members::unary, fusion::join(sv_ptr_ctx,seq))); + BOOST_TEST(that.unary(element1) == fusion::invoke(& members::unary, fusion::join(sv_spt_ctx,seq))); + BOOST_TEST(that.unary_c(element1) == fusion::invoke(& members::unary_c, fusion::join(sv_obj_ctx,seq))); + BOOST_TEST(that.unary_c(element1) == fusion::invoke(& members::unary_c, fusion::join(sv_ref_ctx,seq))); + BOOST_TEST(that.unary_c(element1) == fusion::invoke(& members::unary_c, fusion::join(sv_ptr_ctx,seq))); + BOOST_TEST(that.unary_c(element1) == fusion::invoke(& members::unary_c, fusion::join(sv_spt_ctx,seq))); + BOOST_TEST(that.unary_c(element1) == fusion::invoke(& members::unary_c, fusion::join(sv_obj_c_ctx,seq))); + BOOST_TEST(that.unary_c(element1) == fusion::invoke(& members::unary_c, fusion::join(sv_ref_c_ctx,seq))); + BOOST_TEST(that.unary_c(element1) == fusion::invoke(& members::unary_c, fusion::join(sv_ptr_c_ctx,seq))); + BOOST_TEST(that.unary_c(element1) == fusion::invoke(& members::unary_c, fusion::join(sv_spt_c_ctx,seq))); + + BOOST_TEST(that.unary(element1) == fusion::invoke(& members::unary, fusion::join(sv_ref_d_ctx,seq))); + BOOST_TEST(that.unary(element1) == fusion::invoke(& members::unary, fusion::join(sv_ptr_d_ctx,seq))); + BOOST_TEST(that.unary(element1) == fusion::invoke(& members::unary, fusion::join(sv_spt_d_ctx,seq))); + BOOST_TEST(that.unary_c(element1) == fusion::invoke(& members::unary_c, fusion::join(sv_obj_d_ctx,seq))); + BOOST_TEST(that.unary_c(element1) == fusion::invoke(& members::unary_c, fusion::join(sv_ref_d_ctx,seq))); + BOOST_TEST(that.unary_c(element1) == fusion::invoke(& members::unary_c, fusion::join(sv_ptr_d_ctx,seq))); + BOOST_TEST(that.unary_c(element1) == fusion::invoke(& members::unary_c, fusion::join(sv_spt_d_ctx,seq))); + BOOST_TEST(that.unary_c(element1) == fusion::invoke(& members::unary_c, fusion::join(sv_obj_c_d_ctx,seq))); + BOOST_TEST(that.unary_c(element1) == fusion::invoke(& members::unary_c, fusion::join(sv_ref_c_d_ctx,seq))); + BOOST_TEST(that.unary_c(element1) == fusion::invoke(& members::unary_c, fusion::join(sv_ptr_c_d_ctx,seq))); + BOOST_TEST(that.unary_c(element1) == fusion::invoke(& members::unary_c, fusion::join(sv_spt_c_d_ctx,seq))); +} + +template <class Sequence> +void test_sequence_n(Sequence & seq, mpl::int_<2>) +{ + fobj f; + BOOST_TEST(f (element1, element2) == fusion::invoke(f , seq)); + BOOST_TEST(f (element1, const_(element2)) == fusion::invoke(f , const_(seq))); + BOOST_TEST(const_(f)(element1, element2) == fusion::invoke<fobj const>(const_(f), seq)); + BOOST_TEST(const_(f)(element1, const_(element2)) == fusion::invoke<fobj const>(const_(f), const_(seq))); + + BOOST_TEST(binary1(element1, element2) == fusion::invoke(binary1, seq)); + BOOST_TEST(binary2(element1, element2) == fusion::invoke(binary2, seq)); + + BOOST_TEST(that.binary(element1,element2) == fusion::invoke(& members::binary, fusion::join(sv_ref_ctx,seq))); + BOOST_TEST(that.binary(element1,element2) == fusion::invoke(& members::binary, fusion::join(sv_ptr_ctx,seq))); + BOOST_TEST(that.binary(element1,element2) == fusion::invoke(& members::binary, fusion::join(sv_spt_ctx,seq))); + BOOST_TEST(that.binary_c(element1,element2) == fusion::invoke(& members::binary_c, fusion::join(sv_obj_ctx,seq))); + BOOST_TEST(that.binary_c(element1,element2) == fusion::invoke(& members::binary_c, fusion::join(sv_ref_ctx,seq))); + BOOST_TEST(that.binary_c(element1,element2) == fusion::invoke(& members::binary_c, fusion::join(sv_ptr_ctx,seq))); + BOOST_TEST(that.binary_c(element1,element2) == fusion::invoke(& members::binary_c, fusion::join(sv_spt_ctx,seq))); + BOOST_TEST(that.binary_c(element1,element2) == fusion::invoke(& members::binary_c, fusion::join(sv_obj_c_ctx,seq))); + BOOST_TEST(that.binary_c(element1,element2) == fusion::invoke(& members::binary_c, fusion::join(sv_ref_c_ctx,seq))); + BOOST_TEST(that.binary_c(element1,element2) == fusion::invoke(& members::binary_c, fusion::join(sv_ptr_c_ctx,seq))); + BOOST_TEST(that.binary_c(element1,element2) == fusion::invoke(& members::binary_c, fusion::join(sv_spt_c_ctx,seq))); +} + +template <class Sequence> +void test_sequence_n(Sequence & seq, mpl::int_<3>) +{ + fobj f; + + BOOST_TEST(f(element1, element2, element3) == fusion::invoke(f, seq)); + BOOST_TEST(const_(f)(element1, element2, element3) == fusion::invoke<fobj const>(const_(f), seq)); +} + +template <class Sequence> +void test_sequence(Sequence & seq) +{ + test_sequence_n(seq, mpl::int_<boost::fusion::result_of::size<Sequence>::value>()); +} + + +void result_type_tests() +{ + using boost::is_same; + + BOOST_TEST(( is_same< + boost::fusion::result_of::invoke<int (*)(), fusion::vector0<> >::type, int + >::value )); +// disabled until boost::result_of supports it +// BOOST_TEST(( is_same< +// boost::fusion::result_of::invoke<int (*)(...), fusion::vector1<int> >::type, int +// >::value )); + BOOST_TEST(( is_same< + boost::fusion::result_of::invoke<int (members::*)(), fusion::vector1<members*> >::type, int + >::value )); +// disabled until boost::result_of supports it +// BOOST_TEST(( is_same< +// boost::fusion::result_of::invoke<int (members::*)(...), fusion::vector2<members*,int> >::type, int +// >::value )); +} + +int main() +{ + result_type_tests(); + + typedef fusion::vector<> vector0; + typedef fusion::vector<element1_type> vector1; + typedef fusion::vector<element1_type, element2_type> vector2; + typedef fusion::vector<element1_type, element2_type, element3_type> vector3; + + vector0 v0; + vector1 v1(element1); + vector2 v2(element1, element2); + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + // Note: C++11 will pickup the rvalue overload for the d argument + // since we do not have all permutations (expensive!) for all const& + // and && arguments. We either have all && or all const& arguments only. + // For that matter, use std::ref to disambiguate the call. + + vector3 v3(element1, element2, std::ref(element3)); +#else + vector3 v3(element1, element2, element3); +#endif + + test_sequence(v0); + test_sequence(v1); + test_sequence(v2); + test_sequence(v3); + + typedef fusion::list<> list0; + typedef fusion::list<element1_type> list1; + typedef fusion::list<element1_type, element2_type> list2; + typedef fusion::list<element1_type, element2_type, element3_type> list3; + + list0 l0; + list1 l1(element1); + list2 l2(element1, element2); + list3 l3(element1, element2, element3); + + test_sequence(l0); + test_sequence(l1); + test_sequence(l2); + test_sequence(l3); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/functional/invoke_function_object.cpp b/src/boost/libs/fusion/test/functional/invoke_function_object.cpp new file mode 100644 index 000000000..7c75f06d1 --- /dev/null +++ b/src/boost/libs/fusion/test/functional/invoke_function_object.cpp @@ -0,0 +1,265 @@ +/*============================================================================= + Copyright (c) 2005-2006 Joao Abecasis + Copyright (c) 2006-2007 Tobias Schwinger + + Use modification and distribution are subject to the Boost Software + License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at + http://www.boost.org/LICENSE_1_0.txt). +==============================================================================*/ + +#include <boost/fusion/functional/invocation/invoke_function_object.hpp> +#include <boost/detail/lightweight_test.hpp> + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +#include <functional> +#endif + +#include <boost/type_traits/is_same.hpp> + +#include <memory> +#include <boost/noncopyable.hpp> + +#include <boost/mpl/int.hpp> + +#include <boost/fusion/container/vector.hpp> +#include <boost/fusion/container/list.hpp> +#include <boost/fusion/sequence/intrinsic/size.hpp> +#include <boost/fusion/sequence/intrinsic/begin.hpp> +#include <boost/fusion/view/single_view.hpp> +#include <boost/fusion/view/iterator_range.hpp> +#include <boost/fusion/iterator/advance.hpp> +#include <boost/fusion/algorithm/transformation/join.hpp> + +#include "../compile_time/sfinae_friendly.hpp" + +namespace mpl = boost::mpl; +namespace fusion = boost::fusion; + +template <typename T> +inline T const & const_(T const & t) +{ + return t; +} + +struct object {}; +struct object_nc : boost::noncopyable {}; + +struct fobj +{ + // Handle nullary separately to exercise result_of support + template <typename Sig> + struct result; + + template <class Self, typename T0> + struct result< Self(T0) > + { + typedef int type; + }; + + template <class Self, typename T0, typename T1> + struct result< Self(T0, T1) > + { + typedef int type; + }; + + template <class Self, typename T0, typename T1, typename T2> + struct result< Self(T0, T1, T2) > + { + typedef int type; + }; + + int operator()() { return 0; } + int operator()() const { return 1; } + + int operator()(int i) { return 2 + i; } + int operator()(int i) const { return 3 + i; } + + int operator()(int i, object &) { return 4 + i; } + int operator()(int i, object &) const { return 5 + i; } + int operator()(int i, object const &) { return 6 + i; } + int operator()(int i, object const &) const { return 7 + i; } + + int operator()(int i, object &, object_nc &) { return 10 + i; } + int operator()(int i, object &, object_nc &) const { return 11 + i; } + int operator()(int i, object const &, object_nc &); + int operator()(int i, object const &, object_nc &) const; +}; +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_function_object<fobj, sfinae_friendly::v1>)); +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_function_object<fobj, sfinae_friendly::v2>)); +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_function_object<fobj, sfinae_friendly::v3>)); + +struct nullary_fobj +{ + typedef int result_type; + + int operator()() { return 0; } + int operator()() const { return 1; } +}; +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_function_object<nullary_fobj, sfinae_friendly::v1>)); +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_function_object<nullary_fobj, sfinae_friendly::v2>)); +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_function_object<nullary_fobj, sfinae_friendly::v3>)); + +struct fobj_nc + : boost::noncopyable +{ + // Handle nullary separately to exercise result_of support + template <typename T> + struct result; + + template <class Self, typename T0> + struct result< Self(T0) > + { + typedef int type; + }; + + int operator()(int i) { return 14 + i; } + int operator()(int i) const { return 15 + i; } +}; +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_function_object<fobj_nc, sfinae_friendly::v0>)); +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_function_object<fobj_nc, sfinae_friendly::v1>)); +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_function_object<fobj_nc, sfinae_friendly::v2>)); +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_function_object<fobj_nc, sfinae_friendly::v3>)); + +struct nullary_fobj_nc + : boost::noncopyable +{ + typedef int result_type; + + int operator()() { return 12; } + int operator()() const { return 13; } +}; +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_function_object<nullary_fobj_nc, sfinae_friendly::v1>)); +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_function_object<nullary_fobj_nc, sfinae_friendly::v2>)); +SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_function_object<nullary_fobj_nc, sfinae_friendly::v3>)); + + +typedef int element1_type; +typedef object element2_type; +typedef object_nc & element3_type; + +int element1 = 100; +object element2 = object(); +object_nc element3; + +template <class Sequence> +void test_sequence_n(Sequence & seq, mpl::int_<0>) +{ + // Function Objects + + nullary_fobj f; + BOOST_TEST(f () == fusion::invoke_function_object(f , seq )); + BOOST_TEST(f () == fusion::invoke_function_object(f , const_(seq))); + + // Note: The function object is taken by value, so we request the copy + // to be const with an explicit template argument. We can also request + // the function object to be pased by reference... + BOOST_TEST(const_(f)() == fusion::invoke_function_object<nullary_fobj const >(const_(f), seq )); + BOOST_TEST(const_(f)() == fusion::invoke_function_object<nullary_fobj const &>(const_(f), const_(seq))); + + nullary_fobj_nc nc_f; + // ...and we further ensure there is no copying in this case, using a + // noncopyable function object. + BOOST_TEST(nc_f () == fusion::invoke_function_object<nullary_fobj_nc &>(nc_f , seq )); + BOOST_TEST(nc_f () == fusion::invoke_function_object<nullary_fobj_nc &>(nc_f , const_(seq))); + BOOST_TEST(const_(nc_f)() == fusion::invoke_function_object<nullary_fobj_nc const &>(const_(nc_f), seq )); + BOOST_TEST(const_(nc_f)() == fusion::invoke_function_object<nullary_fobj_nc const &>(const_(nc_f), const_(seq))); +} + +template <class Sequence> +void test_sequence_n(Sequence & seq, mpl::int_<1>) +{ + fobj f; + BOOST_TEST(f(element1) == fusion::invoke_function_object(f , seq )); + BOOST_TEST(f(element1) == fusion::invoke_function_object(f , const_(seq))); + BOOST_TEST(const_(f)(element1) == fusion::invoke_function_object<fobj const >(const_(f), seq )); + BOOST_TEST(const_(f)(element1) == fusion::invoke_function_object<fobj const &>(const_(f), const_(seq))); + + fobj_nc nc_f; + BOOST_TEST(nc_f(element1) == fusion::invoke_function_object<fobj_nc &>(nc_f, seq )); + BOOST_TEST(nc_f(element1) == fusion::invoke_function_object<fobj_nc &>(nc_f, const_(seq))); + BOOST_TEST(const_(nc_f)(element1) == fusion::invoke_function_object<fobj_nc const &>(const_(nc_f), seq )); + BOOST_TEST(const_(nc_f)(element1) == fusion::invoke_function_object<fobj_nc const &>(const_(nc_f), const_(seq))); +} + +template <class Sequence> +void test_sequence_n(Sequence & seq, mpl::int_<2>) +{ + fobj f; + BOOST_TEST(f (element1, element2) == fusion::invoke_function_object(f , seq)); + BOOST_TEST(f (element1, const_(element2)) == fusion::invoke_function_object(f , const_(seq))); + BOOST_TEST(const_(f)(element1, element2) == fusion::invoke_function_object<fobj const>(const_(f), seq)); + BOOST_TEST(const_(f)(element1, const_(element2)) == fusion::invoke_function_object<fobj const>(const_(f), const_(seq))); +} + +template <class Sequence> +void test_sequence_n(Sequence & seq, mpl::int_<3>) +{ + fobj f; + + BOOST_TEST(f(element1, element2, element3) == fusion::invoke_function_object(f, seq)); + BOOST_TEST(const_(f)(element1, element2, element3) == fusion::invoke_function_object<fobj const>(const_(f), seq)); +} + +template <class Sequence> +void test_sequence(Sequence & seq) +{ + test_sequence_n(seq, mpl::int_<boost::fusion::result_of::size<Sequence>::value>()); +} + +void result_type_tests() +{ + using boost::is_same; + + BOOST_TEST(( is_same< boost::fusion::result_of::invoke_function_object< nullary_fobj, fusion::vector<> >::type, int >::value )); + BOOST_TEST(( is_same< boost::fusion::result_of::invoke_function_object< fobj, fusion::vector<element1_type> >::type, int >::value )); + BOOST_TEST(( is_same< boost::fusion::result_of::invoke_function_object< fobj, fusion::vector<element1_type,element2_type> >::type, int >::value )); +} + + +int main() +{ + result_type_tests(); + + typedef fusion::vector<> vector0; + typedef fusion::vector<element1_type> vector1; + typedef fusion::vector<element1_type, element2_type> vector2; + typedef fusion::vector<element1_type, element2_type, element3_type> vector3; + + vector0 v0; + vector1 v1(element1); + vector2 v2(element1, element2); + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + // Note: C++11 will pickup the rvalue overload for the d argument + // since we do not have all permutations (expensive!) for all const& + // and && arguments. We either have all && or all const& arguments only. + // For that matter, use std::ref to disambiguate the call. + + vector3 v3(element1, element2, std::ref(element3)); +#else + vector3 v3(element1, element2, element3); +#endif + + test_sequence(v0); + test_sequence(v1); + test_sequence(v2); + test_sequence(v3); + + typedef fusion::list<> list0; + typedef fusion::list<element1_type> list1; + typedef fusion::list<element1_type, element2_type> list2; + typedef fusion::list<element1_type, element2_type, element3_type> list3; + + list0 l0; + list1 l1(element1); + list2 l2(element1, element2); + list3 l3(element1, element2, element3); + + test_sequence(l0); + test_sequence(l1); + test_sequence(l2); + test_sequence(l3); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/functional/invoke_procedure.cpp b/src/boost/libs/fusion/test/functional/invoke_procedure.cpp new file mode 100644 index 000000000..3877ca30c --- /dev/null +++ b/src/boost/libs/fusion/test/functional/invoke_procedure.cpp @@ -0,0 +1,385 @@ +/*============================================================================= + Copyright (c) 2005-2006 Joao Abecasis + Copyright (c) 2006-2007 Tobias Schwinger + + Use modification and distribution are subject to the Boost Software + License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at + http://www.boost.org/LICENSE_1_0.txt). +==============================================================================*/ + +#include <boost/config.hpp> +#include <boost/fusion/functional/invocation/invoke_procedure.hpp> +#include <boost/detail/lightweight_test.hpp> + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +#include <functional> +#endif + +#include <memory> +#include <boost/noncopyable.hpp> + +#include <boost/mpl/int.hpp> + +#include <boost/fusion/container/vector.hpp> +#include <boost/fusion/container/list.hpp> +#include <boost/fusion/sequence/intrinsic/size.hpp> +#include <boost/fusion/sequence/intrinsic/begin.hpp> +#include <boost/fusion/view/single_view.hpp> +#include <boost/fusion/view/iterator_range.hpp> +#include <boost/fusion/iterator/advance.hpp> +#include <boost/fusion/algorithm/transformation/join.hpp> + +#include "../compile_time/sfinae_friendly.hpp" + +namespace mpl = boost::mpl; +namespace fusion = boost::fusion; + +template <typename T> +inline T const & const_(T const & t) +{ + return t; +} + +struct object {}; +struct object_nc : boost::noncopyable {}; + +typedef int element1_type; +typedef object element2_type; +typedef object_nc & element3_type; + +int element1 = 100; +object element2 = object(); +object_nc element3; + +class members +{ + public: + int data; + + members() + : data(20) + { } + + int nullary() { return element1 = data + 1; } + int nullary_c() const { return element1 = data + 2; } + int unary(int & i) { return i = data + 3; } + int unary_c(int & i) const { return i = data + 4; } + int binary(int & i, object) { return i = data + 5; } + int binary_c(int & i, object) const { return i = data + 6; } +}; + +#ifdef BOOST_NO_CXX11_SMART_PTR +typedef std::auto_ptr<members > members_ptr; +typedef std::auto_ptr<members const> const_members_ptr; +#else +typedef std::unique_ptr<members > members_ptr; +typedef std::unique_ptr<members const> const_members_ptr; +#endif + +members that; +members_ptr spt_that(new members); +const_members_ptr spt_that_c(new members); + +typedef fusion::single_view<members > sv_obj; +typedef fusion::single_view<members &> sv_ref; +typedef fusion::single_view<members *> sv_ptr; +typedef fusion::single_view<members const > sv_obj_c; +typedef fusion::single_view<members const &> sv_ref_c; +typedef fusion::single_view<members const *> sv_ptr_c; +typedef fusion::single_view<members_ptr const &> sv_spt; +typedef fusion::single_view<const_members_ptr const &> sv_spt_c; + +sv_obj sv_obj_ctx( that); +sv_ref sv_ref_ctx( that); +sv_ptr sv_ptr_ctx(& that); +sv_obj_c sv_obj_c_ctx( that); +sv_ref_c sv_ref_c_ctx( that); +sv_ptr_c sv_ptr_c_ctx(& that); +sv_spt sv_spt_ctx(spt_that); +sv_spt_c sv_spt_c_ctx(spt_that_c); +template <typename F, typename S> +struct sv_helper +{ + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<F, typename fusion::result_of::join<sv_obj , S>::type>)); + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<F, typename fusion::result_of::join<sv_ref , S>::type>)); + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<F, typename fusion::result_of::join<sv_ptr , S>::type>)); + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<F, typename fusion::result_of::join<sv_obj_c, S>::type>)); + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<F, typename fusion::result_of::join<sv_ref_c, S>::type>)); + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<F, typename fusion::result_of::join<sv_ptr_c, S>::type>)); + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<F, typename fusion::result_of::join<sv_spt , S>::type>)); + SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<F, typename fusion::result_of::join<sv_spt_c, S>::type>)); +}; +// FIXME: +//template struct sv_helper<int (members::*)() , sfinae_friendly::v1>; +//template struct sv_helper<int (members::*)() , sfinae_friendly::v2>; +//template struct sv_helper<int (members::*)() , sfinae_friendly::v3>; +//template struct sv_helper<int (members::*)() const, sfinae_friendly::v1>; +//template struct sv_helper<int (members::*)() const, sfinae_friendly::v2>; +//template struct sv_helper<int (members::*)() const, sfinae_friendly::v3>; + +//template struct sv_helper<int (members::*)(int) , sfinae_friendly::v0>; +//template struct sv_helper<int (members::*)(int) , sfinae_friendly::v1>; +//template struct sv_helper<int (members::*)(int) , sfinae_friendly::v2>; +//template struct sv_helper<int (members::*)(int) , sfinae_friendly::v3>; +//template struct sv_helper<int (members::*)(int) const, sfinae_friendly::v0>; +//template struct sv_helper<int (members::*)(int) const, sfinae_friendly::v1>; +//template struct sv_helper<int (members::*)(int) const, sfinae_friendly::v2>; +//template struct sv_helper<int (members::*)(int) const, sfinae_friendly::v3>; + +//template struct sv_helper<int (members::*)(int, object) , sfinae_friendly::v0>; +//template struct sv_helper<int (members::*)(int, object) , sfinae_friendly::v1>; +//template struct sv_helper<int (members::*)(int, object) , sfinae_friendly::v2>; +//template struct sv_helper<int (members::*)(int, object) , sfinae_friendly::v3>; +//template struct sv_helper<int (members::*)(int, object) const, sfinae_friendly::v0>; +//template struct sv_helper<int (members::*)(int, object) const, sfinae_friendly::v1>; +//template struct sv_helper<int (members::*)(int, object) const, sfinae_friendly::v2>; +//template struct sv_helper<int (members::*)(int, object) const, sfinae_friendly::v3>; + +struct fobj +{ + int operator()() { return element1 = 0; } + int operator()() const { return element1 = 1; } + + int operator()(int & i) { return i = 2 ; } + int operator()(int & i) const { return i = 3; } + + int operator()(int & i, object &) { return i = 4; } + int operator()(int & i, object &) const { return i = 5; } + int operator()(int & i, object const &) { return i = 6; } + int operator()(int & i, object const &) const { return i = 7; } + + int operator()(int & i, object &, object_nc &) { return i = 10; } + int operator()(int & i, object &, object_nc &) const { return i = 11; } +}; +// FIXME: +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<fobj, sfinae_friendly::v0>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<fobj, sfinae_friendly::v1>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<fobj, sfinae_friendly::v2>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<fobj, sfinae_friendly::v3>)); + +struct fobj_nc + : boost::noncopyable +{ + int operator()() { return element1 = 12; } + int operator()() const { return element1 = 13; } + + int operator()(int & i) { return i = 14; } + int operator()(int & i) const { return i = 15; } +}; +// FIXME: +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<fobj_nc, sfinae_friendly::v0>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<fobj_nc, sfinae_friendly::v1>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<fobj_nc, sfinae_friendly::v2>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<fobj_nc, sfinae_friendly::v3>)); + +int nullary() { return element1 = 16; } +int unary(int & i) { return i = 17; } +int binary1(int & i, object &) { return i = 18; } +int binary2(int & i, object const &) { return i = 19; } +//FIXME +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<int(*)(), sfinae_friendly::v1>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<int(*)(), sfinae_friendly::v2>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<int(*)(), sfinae_friendly::v3>)); +// +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<int(*)(int), sfinae_friendly::v0>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<int(*)(int), sfinae_friendly::v1>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<int(*)(int), sfinae_friendly::v2>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<int(*)(int), sfinae_friendly::v3>)); +// +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<int(*)(int, object &), sfinae_friendly::v0>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<int(*)(int, object &), sfinae_friendly::v1>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<int(*)(int, object &), sfinae_friendly::v2>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<int(*)(int, object &), sfinae_friendly::v3>)); +// +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<int(*)(int, object const &), sfinae_friendly::v0>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<int(*)(int, object const &), sfinae_friendly::v1>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<int(*)(int, object const &), sfinae_friendly::v2>)); +//SFINAE_FRIENDLY_ASSERT((fusion::result_of::invoke_procedure<int(*)(int, object const &), sfinae_friendly::v3>)); + +typedef int (* func_ptr)(int &); +typedef int (* const c_func_ptr)(int &); +typedef int (* volatile v_func_ptr)(int &); +typedef int (* const volatile cv_func_ptr)(int &); + + func_ptr func_ptr1 = &unary; + c_func_ptr func_ptr2 = &unary; + v_func_ptr func_ptr3 = &unary; +cv_func_ptr func_ptr4 = &unary; + + + +#define COMPARE_EFFECT(e,t) \ + { \ + element1 = 1234567; e; \ + int expected = element1; \ + element1 = 1234567; t; \ + BOOST_TEST(expected == element1 ); \ + } + + +template <class Sequence> +void test_sequence_n(Sequence & seq, mpl::int_<0>) +{ + // Function Objects + + fobj f; + + COMPARE_EFFECT(f (), fusion::invoke_procedure(f , seq )); + COMPARE_EFFECT(f (), fusion::invoke_procedure(f , const_(seq))); + + // Note: The function object is taken by value, so we request the copy + // to be const with an explicit template argument. We can also request + // the function object to be pased by reference... + COMPARE_EFFECT(const_(f)(), fusion::invoke_procedure<fobj const >(const_(f), seq )); + COMPARE_EFFECT(const_(f)(), fusion::invoke_procedure<fobj const &>(const_(f), const_(seq))); + + fobj_nc nc_f; + // ...and we further ensure there is no copying in this case, using a + // noncopyable function object. + COMPARE_EFFECT(nc_f (), fusion::invoke_procedure<fobj_nc &>(nc_f , seq )); + COMPARE_EFFECT(nc_f (), fusion::invoke_procedure<fobj_nc &>(nc_f , const_(seq))); + COMPARE_EFFECT(const_(nc_f)(), fusion::invoke_procedure<fobj_nc const &>(const_(nc_f), seq )); + COMPARE_EFFECT(const_(nc_f)(), fusion::invoke_procedure<fobj_nc const &>(const_(nc_f), const_(seq))); + + // Builtin Functions + + // Call through ref/ptr to function + COMPARE_EFFECT(nullary(), fusion::invoke_procedure<int (&)()>(nullary, seq)); + COMPARE_EFFECT(nullary(), fusion::invoke_procedure(& nullary, seq)); + + // Call through ptr to member function + // Note: The non-const function members::nullary can't be invoked with + // fusion::join(sv_obj_ctx,seq)), which is const and so is its first element + COMPARE_EFFECT(that.nullary(), fusion::invoke_procedure(& members::nullary, fusion::join(sv_ref_ctx,seq))); + COMPARE_EFFECT(that.nullary(), fusion::invoke_procedure(& members::nullary, fusion::join(sv_ptr_ctx,seq))); + COMPARE_EFFECT(that.nullary(), fusion::invoke_procedure(& members::nullary, fusion::join(sv_spt_ctx,seq))); + COMPARE_EFFECT(that.nullary_c(), fusion::invoke_procedure(& members::nullary_c, fusion::join(sv_obj_ctx,seq))); + COMPARE_EFFECT(that.nullary_c(), fusion::invoke_procedure(& members::nullary_c, fusion::join(sv_ref_ctx,seq))); + COMPARE_EFFECT(that.nullary_c(), fusion::invoke_procedure(& members::nullary_c, fusion::join(sv_ptr_ctx,seq))); + COMPARE_EFFECT(that.nullary_c(), fusion::invoke_procedure(& members::nullary_c, fusion::join(sv_spt_ctx,seq))); + COMPARE_EFFECT(that.nullary_c(), fusion::invoke_procedure(& members::nullary_c, fusion::join(sv_obj_c_ctx,seq))); + COMPARE_EFFECT(that.nullary_c(), fusion::invoke_procedure(& members::nullary_c, fusion::join(sv_ref_c_ctx,seq))); + COMPARE_EFFECT(that.nullary_c(), fusion::invoke_procedure(& members::nullary_c, fusion::join(sv_ptr_c_ctx,seq))); + COMPARE_EFFECT(that.nullary_c(), fusion::invoke_procedure(& members::nullary_c, fusion::join(sv_spt_c_ctx,seq))); +} + +template <class Sequence> +void test_sequence_n(Sequence & seq, mpl::int_<1>) +{ + fobj f; + COMPARE_EFFECT(f(element1), fusion::invoke_procedure(f , seq )); + COMPARE_EFFECT(f(element1), fusion::invoke_procedure(f , const_(seq))); + COMPARE_EFFECT(const_(f)(element1), fusion::invoke_procedure<fobj const >(const_(f), seq )); + COMPARE_EFFECT(const_(f)(element1), fusion::invoke_procedure<fobj const &>(const_(f), const_(seq))); + + fobj_nc nc_f; + COMPARE_EFFECT(nc_f(element1), fusion::invoke_procedure<fobj_nc &>(nc_f, seq )); + COMPARE_EFFECT(nc_f(element1), fusion::invoke_procedure<fobj_nc &>(nc_f, const_(seq))); + COMPARE_EFFECT(const_(nc_f)(element1), fusion::invoke_procedure<fobj_nc const &>(const_(nc_f), seq )); + COMPARE_EFFECT(const_(nc_f)(element1), fusion::invoke_procedure<fobj_nc const &>(const_(nc_f), const_(seq))); + + COMPARE_EFFECT(unary(element1), fusion::invoke_procedure<int (&)(int &)>(unary, seq)); + COMPARE_EFFECT(func_ptr1(element1), fusion::invoke_procedure(func_ptr1, seq)); + COMPARE_EFFECT(func_ptr2(element1), fusion::invoke_procedure(func_ptr2, seq)); + COMPARE_EFFECT(func_ptr3(element1), fusion::invoke_procedure(func_ptr3, seq)); + COMPARE_EFFECT(func_ptr4(element1), fusion::invoke_procedure(func_ptr4, seq)); + + COMPARE_EFFECT(that.unary(element1), fusion::invoke_procedure(& members::unary, fusion::join(sv_ref_ctx,seq))); + COMPARE_EFFECT(that.unary(element1), fusion::invoke_procedure(& members::unary, fusion::join(sv_ptr_ctx,seq))); + COMPARE_EFFECT(that.unary(element1), fusion::invoke_procedure(& members::unary, fusion::join(sv_spt_ctx,seq))); + COMPARE_EFFECT(that.unary_c(element1), fusion::invoke_procedure(& members::unary_c, fusion::join(sv_obj_ctx,seq))); + COMPARE_EFFECT(that.unary_c(element1), fusion::invoke_procedure(& members::unary_c, fusion::join(sv_ref_ctx,seq))); + COMPARE_EFFECT(that.unary_c(element1), fusion::invoke_procedure(& members::unary_c, fusion::join(sv_ptr_ctx,seq))); + COMPARE_EFFECT(that.unary_c(element1), fusion::invoke_procedure(& members::unary_c, fusion::join(sv_spt_ctx,seq))); + COMPARE_EFFECT(that.unary_c(element1), fusion::invoke_procedure(& members::unary_c, fusion::join(sv_obj_c_ctx,seq))); + COMPARE_EFFECT(that.unary_c(element1), fusion::invoke_procedure(& members::unary_c, fusion::join(sv_ref_c_ctx,seq))); + COMPARE_EFFECT(that.unary_c(element1), fusion::invoke_procedure(& members::unary_c, fusion::join(sv_ptr_c_ctx,seq))); + COMPARE_EFFECT(that.unary_c(element1), fusion::invoke_procedure(& members::unary_c, fusion::join(sv_spt_c_ctx,seq))); +} + +template <class Sequence> +void test_sequence_n(Sequence & seq, mpl::int_<2>) +{ + fobj f; + COMPARE_EFFECT(f (element1, element2), fusion::invoke_procedure(f , seq)); + COMPARE_EFFECT(f (element1, const_(element2)), fusion::invoke_procedure(f , const_(seq))); + COMPARE_EFFECT(const_(f)(element1, element2), fusion::invoke_procedure<fobj const>(const_(f), seq)); + COMPARE_EFFECT(const_(f)(element1, const_(element2)), fusion::invoke_procedure<fobj const>(const_(f), const_(seq))); + + COMPARE_EFFECT(binary1(element1, element2), fusion::invoke_procedure(binary1, seq)); + COMPARE_EFFECT(binary2(element1, element2), fusion::invoke_procedure(binary2, seq)); + + COMPARE_EFFECT(that.binary(element1,element2), fusion::invoke_procedure(& members::binary, fusion::join(sv_ref_ctx,seq))); + COMPARE_EFFECT(that.binary(element1,element2), fusion::invoke_procedure(& members::binary, fusion::join(sv_ptr_ctx,seq))); + COMPARE_EFFECT(that.binary(element1,element2), fusion::invoke_procedure(& members::binary, fusion::join(sv_spt_ctx,seq))); + COMPARE_EFFECT(that.binary_c(element1,element2), fusion::invoke_procedure(& members::binary_c, fusion::join(sv_obj_ctx,seq))); + COMPARE_EFFECT(that.binary_c(element1,element2), fusion::invoke_procedure(& members::binary_c, fusion::join(sv_ref_ctx,seq))); + COMPARE_EFFECT(that.binary_c(element1,element2), fusion::invoke_procedure(& members::binary_c, fusion::join(sv_ptr_ctx,seq))); + COMPARE_EFFECT(that.binary_c(element1,element2), fusion::invoke_procedure(& members::binary_c, fusion::join(sv_spt_ctx,seq))); + COMPARE_EFFECT(that.binary_c(element1,element2), fusion::invoke_procedure(& members::binary_c, fusion::join(sv_obj_c_ctx,seq))); + COMPARE_EFFECT(that.binary_c(element1,element2), fusion::invoke_procedure(& members::binary_c, fusion::join(sv_ref_c_ctx,seq))); + COMPARE_EFFECT(that.binary_c(element1,element2), fusion::invoke_procedure(& members::binary_c, fusion::join(sv_ptr_c_ctx,seq))); + COMPARE_EFFECT(that.binary_c(element1,element2), fusion::invoke_procedure(& members::binary_c, fusion::join(sv_spt_c_ctx,seq))); +} + +template <class Sequence> +void test_sequence_n(Sequence & seq, mpl::int_<3>) +{ + fobj f; + + COMPARE_EFFECT(f(element1, element2, element3), fusion::invoke_procedure(f, seq)); + COMPARE_EFFECT(const_(f)(element1, element2, element3), fusion::invoke_procedure<fobj const>(const_(f), seq)); +} + +template <class Sequence> +void test_sequence(Sequence & seq) +{ + test_sequence_n(seq, mpl::int_<boost::fusion::result_of::size<Sequence>::value>()); +} + +int main() +{ + typedef fusion::vector<> vector0; + typedef fusion::vector<element1_type &> vector1; + typedef fusion::vector<element1_type &, element2_type> vector2; + typedef fusion::vector<element1_type &, element2_type, element3_type> vector3; + + vector0 v0; + vector1 v1(element1); + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + // Note: C++11 will pickup the rvalue overload for the d argument + // since we do not have all permutations (expensive!) for all const& + // and && arguments. We either have all && or all const& arguments only. + // For that matter, use std::ref to disambiguate the call. + + vector2 v2(std::ref(element1), element2); + vector3 v3(std::ref(element1), element2, std::ref(element3)); +#else + vector2 v2(element1, element2); + vector3 v3(element1, element2, element3); +#endif + + test_sequence(v0); + test_sequence(v1); + test_sequence(v2); + test_sequence(v3); + + typedef fusion::list<> list0; + typedef fusion::list<element1_type &> list1; + typedef fusion::list<element1_type &, element2_type> list2; + typedef fusion::list<element1_type &, element2_type, element3_type> list3; + + list0 l0; + list1 l1(element1); + list2 l2(element1, element2); + list3 l3(element1, element2, element3); + + test_sequence(l0); + test_sequence(l1); + test_sequence(l2); + test_sequence(l3); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/functional/make_fused.cpp b/src/boost/libs/fusion/test/functional/make_fused.cpp new file mode 100644 index 000000000..ceb82063e --- /dev/null +++ b/src/boost/libs/fusion/test/functional/make_fused.cpp @@ -0,0 +1,85 @@ +/*============================================================================= + Copyright (c) 2006-2007 Tobias Schwinger + + Use modification and distribution are subject to the Boost Software + License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at + http://www.boost.org/LICENSE_1_0.txt). +==============================================================================*/ + +#include <boost/fusion/functional/generation/make_fused.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/noncopyable.hpp> +#include <boost/mpl/empty_base.hpp> + +#include <boost/fusion/container/generation/make_vector.hpp> +#include <boost/fusion/container/vector.hpp> + +namespace fusion = boost::fusion; +using boost::noncopyable; +using boost::cref; +using boost::ref; + +template <class Base = boost::mpl::empty_base> +struct test_func + : Base +{ + typedef int result_type; + + template <typename T0, typename T1> + int operator()(T0 const & x, T1 const & y) const + { + return 1+x-y; + } + + template <typename T0, typename T1> + int operator()(T0 const & x, T1 const & y) + { + return 2+x-y; + } + + template <typename T0, typename T1> + int operator()(T0 & x, T1 & y) const + { + return 3+x-y; + } + + template <typename T0, typename T1> + int operator()(T0 & x, T1 & y) + { + return 4+x-y; + } +}; + +template <typename T> +inline T const & const_(T const & t) +{ + return t; +} + +int main() +{ + fusion::vector<int,char> lv_vec(1,'\004'); + test_func<> f; + test_func<noncopyable> f_nc; + + boost::fusion::result_of::make_fused< test_func<> >::type fused_func + = fusion::make_fused(f); + + BOOST_TEST(fused_func(lv_vec) == 1); + BOOST_TEST(const_(fused_func)(lv_vec) == 0); + BOOST_TEST(fusion::make_fused(const_(f))(lv_vec) == 1); + BOOST_TEST(fusion::make_fused(ref(f_nc))(lv_vec) == 1); + BOOST_TEST(fusion::make_fused(cref(f_nc))(lv_vec) == 0); + + BOOST_TEST(fused_func(fusion::make_vector(2,'\003')) == 1); + BOOST_TEST(const_(fused_func)(fusion::make_vector(2,'\003')) == 0); + BOOST_TEST(fusion::make_fused(const_(f))(fusion::make_vector(2,'\003')) == 1); + BOOST_TEST(fusion::make_fused(ref(f_nc))(fusion::make_vector(2,'\003')) == 1); + BOOST_TEST(fusion::make_fused(cref(f_nc))(fusion::make_vector(2,'\003')) == 0); + + return boost::report_errors(); +} + + + diff --git a/src/boost/libs/fusion/test/functional/make_fused_function_object.cpp b/src/boost/libs/fusion/test/functional/make_fused_function_object.cpp new file mode 100644 index 000000000..79ea517ba --- /dev/null +++ b/src/boost/libs/fusion/test/functional/make_fused_function_object.cpp @@ -0,0 +1,95 @@ +/*============================================================================= + Copyright (c) 2006-2007 Tobias Schwinger + + Use modification and distribution are subject to the Boost Software + License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at + http://www.boost.org/LICENSE_1_0.txt). +==============================================================================*/ + +#include <boost/fusion/functional/generation/make_fused_function_object.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/noncopyable.hpp> +#include <boost/mpl/empty_base.hpp> + +#include <boost/fusion/container/generation/make_vector.hpp> +#include <boost/fusion/container/vector.hpp> + +namespace fusion = boost::fusion; +using boost::noncopyable; +using boost::cref; +using boost::ref; + +template <class Base = boost::mpl::empty_base> +struct test_func + : Base +{ + template<typename T> + struct result + { + }; + + + template<class Self, typename T0, typename T1> + struct result< Self(T0, T1) > + { + typedef int type; + }; + + template <typename T0, typename T1> + int operator()(T0 const & x, T1 const & y) const + { + return 1+x-y; + } + + template <typename T0, typename T1> + int operator()(T0 const & x, T1 const & y) + { + return 2+x-y; + } + + template <typename T0, typename T1> + int operator()(T0 & x, T1 & y) const + { + return 3+x-y; + } + + template <typename T0, typename T1> + int operator()(T0 & x, T1 & y) + { + return 4+x-y; + } +}; + +template <typename T> +inline T const & const_(T const & t) +{ + return t; +} + +int main() +{ + fusion::vector<int,char> lv_vec(1,'\004'); + test_func<> f; + test_func<noncopyable> f_nc; + + boost::fusion::result_of::make_fused_function_object< test_func<> >::type fused_func + = fusion::make_fused_function_object(f); + + BOOST_TEST(fused_func(lv_vec) == 1); + BOOST_TEST(const_(fused_func)(lv_vec) == 0); + BOOST_TEST(fusion::make_fused_function_object(const_(f))(lv_vec) == 1); + BOOST_TEST(fusion::make_fused_function_object(ref(f_nc))(lv_vec) == 1); + BOOST_TEST(fusion::make_fused_function_object(cref(f_nc))(lv_vec) == 0); + + BOOST_TEST(fused_func(fusion::make_vector(2,'\003')) == 1); + BOOST_TEST(const_(fused_func)(fusion::make_vector(2,'\003')) == 0); + BOOST_TEST(fusion::make_fused_function_object(const_(f))(fusion::make_vector(2,'\003')) == 1); + BOOST_TEST(fusion::make_fused_function_object(ref(f_nc))(fusion::make_vector(2,'\003')) == 1); + BOOST_TEST(fusion::make_fused_function_object(cref(f_nc))(fusion::make_vector(2,'\003')) == 0); + + return boost::report_errors(); +} + + + diff --git a/src/boost/libs/fusion/test/functional/make_fused_procedure.cpp b/src/boost/libs/fusion/test/functional/make_fused_procedure.cpp new file mode 100644 index 000000000..2fa2762c5 --- /dev/null +++ b/src/boost/libs/fusion/test/functional/make_fused_procedure.cpp @@ -0,0 +1,91 @@ +/*============================================================================= + Copyright (c) 2006-2007 Tobias Schwinger + + Use modification and distribution are subject to the Boost Software + License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at + http://www.boost.org/LICENSE_1_0.txt). +==============================================================================*/ + +#include <boost/fusion/functional/generation/make_fused_procedure.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/noncopyable.hpp> +#include <boost/mpl/empty_base.hpp> + +#include <boost/fusion/container/generation/make_vector.hpp> +#include <boost/fusion/container/vector.hpp> + +namespace fusion = boost::fusion; +using boost::noncopyable; +using boost::cref; +using boost::ref; + +int effect; + +#define CHECK_EFFECT(t,e) \ + { \ + effect = 1234567; t; \ + BOOST_TEST(effect == e); \ + } + +template <class Base = boost::mpl::empty_base> +struct test_func + : Base +{ + template <typename T0, typename T1> + int operator()(T0 const & x, T1 const & y) const + { + return effect = 1+x-y; + } + + template <typename T0, typename T1> + int operator()(T0 const & x, T1 const & y) + { + return effect = 2+x-y; + } + + template <typename T0, typename T1> + int operator()(T0 & x, T1 & y) const + { + return effect = 3+x-y; + } + + template <typename T0, typename T1> + int operator()(T0 & x, T1 & y) + { + return effect = 4+x-y; + } +}; + +template <typename T> +inline T const & const_(T const & t) +{ + return t; +} + +int main() +{ + fusion::vector<int,char> lv_vec(1,'\004'); + test_func<> f; + test_func<noncopyable> f_nc; + + boost::fusion::result_of::make_fused_procedure< test_func<> >::type fused_func + = fusion::make_fused_procedure(f); + + CHECK_EFFECT(fused_func(lv_vec), 1); + CHECK_EFFECT(const_(fused_func)(lv_vec), 0); + CHECK_EFFECT(fusion::make_fused_procedure(const_(f))(lv_vec), 1); + CHECK_EFFECT(fusion::make_fused_procedure(ref(f_nc))(lv_vec), 1); + CHECK_EFFECT(fusion::make_fused_procedure(cref(f_nc))(lv_vec), 0); + + CHECK_EFFECT(fused_func(fusion::make_vector(2,'\003')), 1); + CHECK_EFFECT(const_(fused_func)(fusion::make_vector(2,'\003')), 0); + CHECK_EFFECT(fusion::make_fused_procedure(const_(f))(fusion::make_vector(2,'\003')), 1); + CHECK_EFFECT(fusion::make_fused_procedure(ref(f_nc))(fusion::make_vector(2,'\003')), 1); + CHECK_EFFECT(fusion::make_fused_procedure(cref(f_nc))(fusion::make_vector(2,'\003')), 0); + + return boost::report_errors(); +} + + + diff --git a/src/boost/libs/fusion/test/functional/make_unfused.cpp b/src/boost/libs/fusion/test/functional/make_unfused.cpp new file mode 100644 index 000000000..73be142b4 --- /dev/null +++ b/src/boost/libs/fusion/test/functional/make_unfused.cpp @@ -0,0 +1,128 @@ +/*============================================================================= + Copyright (c) 2006-2007 Tobias Schwinger + + Use modification and distribution are subject to the Boost Software + License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at + http://www.boost.org/LICENSE_1_0.txt). +==============================================================================*/ + +#include <boost/fusion/functional/generation/make_unfused.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/noncopyable.hpp> + +#include <boost/mpl/empty_base.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/and.hpp> +#include <boost/mpl/not.hpp> +#include <boost/mpl/bool.hpp> + +#include <boost/utility/result_of.hpp> +#include <boost/core/enable_if.hpp> + +#include <boost/fusion/sequence/intrinsic/empty.hpp> +#include <boost/fusion/algorithm/iteration/fold.hpp> + +#include <boost/ref.hpp> + +namespace fusion = boost::fusion; +namespace mpl = boost::mpl; + +using boost::noncopyable; +typedef mpl::true_ no_nullary_call; + +using boost::ref; +using boost::cref; + +template <class Base = mpl::empty_base, class RemoveNullary = mpl::false_> +struct test_func + : Base +{ + template <typename Sig> + struct result; + + template <class Self, class Seq> + struct result< Self(Seq &) > + : boost::enable_if< + mpl::not_<mpl::and_<boost::fusion::result_of::empty<Seq>, RemoveNullary> >, + long> + { }; + + template <typename Seq> + long operator()(Seq const & seq) const + { + long state = 0; + return fusion::fold(seq, state, fold_op()); + } + + template < typename Seq > + long operator()(Seq const & seq) + { + long state = 100; + return fusion::fold(seq, state, fold_op()); + } + + private: + + struct fold_op + { + typedef long result_type; + + template <typename T> + long operator()(long value, T & elem) const + { + elem += sizeof(T); + return value + elem; + } + }; +}; + +template <typename T> +inline T const & const_(T const & t) +{ + return t; +} + +int main() +{ + test_func<> f; + test_func<noncopyable> f_nc; + + boost::fusion::result_of::make_unfused< test_func<> >::type unfused_func = + fusion::make_unfused(f); + + boost::fusion::result_of::make_unfused< boost::reference_wrapper< + test_func<noncopyable> > >::type unfused_func_ref = + fusion::make_unfused(ref(f_nc)); + + boost::fusion::result_of::make_unfused< boost::reference_wrapper< + test_func<noncopyable> const> >::type unfused_func_c_ref = + fusion::make_unfused(cref(f_nc)); + + BOOST_TEST(unfused_func() == 100); + BOOST_TEST(const_(unfused_func)() == 0); + BOOST_TEST(unfused_func_ref() == 100); + BOOST_TEST(unfused_func_c_ref() == 0); + + long lv1 = 2; int lv2 = 3l; char lv3 = '\007'; + long expected; + + expected = lv1+sizeof(lv1) + lv2+sizeof(lv2) + lv3+sizeof(lv3); + BOOST_TEST(unfused_func(lv1,lv2,lv3) == 100 + expected); + BOOST_TEST(lv1 == 2+1*sizeof(lv1) && lv2 == 3+1*sizeof(lv2) && lv3 == 7+1*sizeof(lv3)); + + expected = lv1+sizeof(lv1) + lv2+sizeof(lv2) + lv3+sizeof(lv3); + BOOST_TEST(const_(unfused_func)(lv1,lv2,lv3) == 0 + expected); + BOOST_TEST(lv1 == 2+2*sizeof(lv1) && lv2 == 3+2*sizeof(lv2) && lv3 == 7+2*sizeof(lv3)); + + expected = lv1+sizeof(lv1) + lv2+sizeof(lv2) + lv3+sizeof(lv3); + BOOST_TEST(unfused_func_ref(lv1,lv2,lv3) == 100 + expected); + BOOST_TEST(lv1 == 2+3*sizeof(lv1) && lv2 == 3+3*sizeof(lv2) && lv3 == 7+3*sizeof(lv3)); + + expected = lv1+sizeof(lv1) + lv2+sizeof(lv2) + lv3+sizeof(lv3); + BOOST_TEST(unfused_func_c_ref(lv1,lv2,lv3) == 0 + expected); + BOOST_TEST(lv1 == 2+4*sizeof(lv1) && lv2 == 3+4*sizeof(lv2) && lv3 == 7+4*sizeof(lv3)); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/functional/unfused.cpp b/src/boost/libs/fusion/test/functional/unfused.cpp new file mode 100644 index 000000000..1e30eabd3 --- /dev/null +++ b/src/boost/libs/fusion/test/functional/unfused.cpp @@ -0,0 +1,119 @@ +/*============================================================================= + Copyright (c) 2006-2007 Tobias Schwinger + + Use modification and distribution are subject to the Boost Software + License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at + http://www.boost.org/LICENSE_1_0.txt). +==============================================================================*/ + +#include <boost/fusion/functional/adapter/unfused.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/noncopyable.hpp> + +#include <boost/mpl/empty_base.hpp> +#include <boost/mpl/identity.hpp> + +#include <boost/utility/result_of.hpp> + +#include <boost/fusion/sequence/intrinsic/empty.hpp> +#include <boost/fusion/algorithm/iteration/fold.hpp> + +namespace fusion = boost::fusion; +namespace mpl = boost::mpl; + +using boost::noncopyable; + +template <class Base = boost::mpl::empty_base> +struct test_func + : Base +{ + template <typename Sig> + struct result; + + template <class Self, class Seq> + struct result< Self(Seq) > + : mpl::identity<long> + { }; + + template <typename Seq> + long operator()(Seq const & seq) const + { + long state = 0; + return fusion::fold(seq, state, fold_op()); + } + + template <typename Seq> + long operator()(Seq const & seq) + { + long state = 100; + return fusion::fold(seq, state, fold_op()); + } + + private: + + struct fold_op + { + typedef long result_type; + + template <typename T> + long operator()(long value, T & elem) const + { + elem += sizeof(T); + return value + elem; + } + }; +}; + +void result_type_tests() +{ + using boost::is_same; + + typedef fusion::unfused< test_func<> > t; + BOOST_TEST(( is_same< boost::result_of< t () >::type, long >::value )); + BOOST_TEST(( is_same< boost::result_of< t (int &) >::type, long >::value )); +} + +int main() +{ + result_type_tests(); + + test_func<noncopyable> f; + fusion::unfused< test_func<> > unfused_func; + fusion::unfused< test_func<noncopyable> & > unfused_func_ref(f); + fusion::unfused< test_func<> const > unfused_func_c; + fusion::unfused< test_func<> > const unfused_func_c2; + fusion::unfused< test_func<noncopyable> const & > unfused_func_c_ref(f); + + BOOST_TEST(unfused_func() == 100); + BOOST_TEST(unfused_func_ref() == 100); + BOOST_TEST(unfused_func_c() == 0); + BOOST_TEST(unfused_func_c2() == 0); + BOOST_TEST(unfused_func_c_ref() == 0); + + long lv1 = 2; int lv2 = 3l; char lv3 = '\007'; + long expected; + + expected = lv1+sizeof(lv1) + lv2+sizeof(lv2) + lv3+sizeof(lv3); + BOOST_TEST(unfused_func(lv1,lv2,lv3) == 100 + expected); + BOOST_TEST(lv1 == 2+1*sizeof(lv1) && lv2 == 3+1*sizeof(lv2) && lv3 == 7+1*sizeof(lv3)); + + expected = lv1+sizeof(lv1) + lv2+sizeof(lv2) + lv3+sizeof(lv3); + BOOST_TEST(unfused_func_ref(lv1,lv2,lv3) == 100 + expected); + BOOST_TEST(lv1 == 2+2*sizeof(lv1) && lv2 == 3+2*sizeof(lv2) && lv3 == 7+2*sizeof(lv3)); + + expected = lv1+sizeof(lv1) + lv2+sizeof(lv2) + lv3+sizeof(lv3); + BOOST_TEST(unfused_func_c(lv1,lv2,lv3) == 0 + expected); + BOOST_TEST(lv1 == 2+3*sizeof(lv1) && lv2 == 3+3*sizeof(lv2) && lv3 == 7+3*sizeof(lv3)); + + expected = lv1+sizeof(lv1) + lv2+sizeof(lv2) + lv3+sizeof(lv3); + BOOST_TEST(unfused_func_c2(lv1,lv2,lv3) == 0 + expected); + BOOST_TEST(lv1 == 2+4*sizeof(lv1) && lv2 == 3+4*sizeof(lv2) && lv3 == 7+4*sizeof(lv3)); + + expected = lv1+sizeof(lv1) + lv2+sizeof(lv2) + lv3+sizeof(lv3); + BOOST_TEST(unfused_func_c_ref(lv1,lv2,lv3) == 0 + expected); + BOOST_TEST(lv1 == 2+5*sizeof(lv1) && lv2 == 3+5*sizeof(lv2) && lv3 == 7+5*sizeof(lv3)); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/fusion/test/functional/unfused_typed.cpp b/src/boost/libs/fusion/test/functional/unfused_typed.cpp new file mode 100644 index 000000000..eaa03425f --- /dev/null +++ b/src/boost/libs/fusion/test/functional/unfused_typed.cpp @@ -0,0 +1,165 @@ +/*============================================================================= + Copyright (c) 2006-2007 Tobias Schwinger + + Use modification and distribution are subject to the Boost Software + License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at + http://www.boost.org/LICENSE_1_0.txt). +==============================================================================*/ + +#include <boost/fusion/functional/adapter/unfused_typed.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/noncopyable.hpp> + +#include <boost/mpl/empty_base.hpp> +#include <boost/mpl/identity.hpp> +#include <boost/mpl/placeholders.hpp> + +#include <boost/utility/result_of.hpp> + +#include <boost/fusion/algorithm/iteration/fold.hpp> + +namespace fusion = boost::fusion; +namespace mpl = boost::mpl; +using mpl::placeholders::_; + +using boost::noncopyable; + +typedef fusion::vector<> types0; +typedef fusion::vector<long &> types1; +typedef fusion::vector<long &,int,char> types3; + +template <class Base = boost::mpl::empty_base> +struct test_func + : Base +{ + template<typename T> + struct result; + + template <class Self, class Seq> + struct result< Self(Seq) > + : mpl::identity<long> + { }; + + template <typename Seq> + long operator()(Seq const & seq) const + { + long state = 0; + return fusion::fold(seq, state, fold_op()); + } + + template < typename Seq > + long operator()(Seq const & seq) + { + long state = 100; + return fusion::fold(seq, state, fold_op()); + } + + private: + + struct fold_op + { + typedef long result_type; + + template <typename T> + long operator()(long value, T const & elem) const + { + return value + sizeof(T) * elem; + } + + template <typename T> + long operator()(long value, T & elem) const + { + elem += sizeof(T); + return value; + } + }; +}; + +void result_type_tests() +{ + using boost::is_same; + + typedef fusion::unfused_typed< test_func<>, types0 > t0; + BOOST_TEST(( is_same< boost::result_of< t0 () >::type, long >::value )); + typedef fusion::unfused_typed< test_func<>, types1 > t1; + BOOST_TEST(( is_same< boost::result_of< t1 (long &) >::type, long >::value )); +} + +#if defined(BOOST_MSVC) && BOOST_MSVC < 1400 +# define BOOST_TEST_NO_VC71(cond) (void)((cond)?0:1) +#else +# define BOOST_TEST_NO_VC71(cond) BOOST_TEST(cond) +#endif + +void nullary_tests() +{ + test_func<noncopyable> f; + fusion::unfused_typed< test_func<>, types0 > unfused_func; + fusion::unfused_typed< test_func<noncopyable> &, types0 > unfused_func_ref(f); + fusion::unfused_typed< test_func<> const, types0 > unfused_func_c; + fusion::unfused_typed< test_func<>, types0 > const unfused_func_c2; + fusion::unfused_typed< test_func<noncopyable> const &, types0 > unfused_func_c_ref(f); + + BOOST_TEST(unfused_func() == 100); + BOOST_TEST(unfused_func_ref() == 100); + BOOST_TEST(unfused_func_c() == 0); + BOOST_TEST(unfused_func_c2() == 0); + BOOST_TEST(unfused_func_c_ref() == 0); +} + +void unary_tests() +{ + test_func<noncopyable> f; + fusion::unfused_typed< test_func<>, types1 > unfused_func; + fusion::unfused_typed< test_func<noncopyable> &, types1 > unfused_func_ref(f); + fusion::unfused_typed< test_func<> const, types1 > unfused_func_c; + fusion::unfused_typed< test_func<>, types1 > const unfused_func_c2; + fusion::unfused_typed< test_func<noncopyable> const &, types1 > unfused_func_c_ref(f); + + long lvalue = 1; + BOOST_TEST_NO_VC71(unfused_func(lvalue) == 100); + BOOST_TEST(lvalue == 1 + 1*sizeof(lvalue)); + BOOST_TEST(unfused_func_ref(lvalue) == 100); + BOOST_TEST(lvalue == 1 + 2*sizeof(lvalue)); + BOOST_TEST(unfused_func_c(lvalue) == 0); + BOOST_TEST(lvalue == 1 + 3*sizeof(lvalue)); + BOOST_TEST(unfused_func_c2(lvalue) == 0); + BOOST_TEST(lvalue == 1 + 4*sizeof(lvalue)); + BOOST_TEST(unfused_func_c_ref(lvalue) == 0); + BOOST_TEST(lvalue == 1 + 5*sizeof(lvalue)); +} + +void ternary_tests() +{ + test_func<noncopyable> f; + fusion::unfused_typed< test_func<>, types3 > unfused_func; + fusion::unfused_typed< test_func<noncopyable> &, types3 > unfused_func_ref(f); + fusion::unfused_typed< test_func<> const, types3 > unfused_func_c; + fusion::unfused_typed< test_func<>, types3 > const unfused_func_c2; + fusion::unfused_typed< test_func<noncopyable> const &, types3 > unfused_func_c_ref(f); + + long lvalue = 1; + static const long expected = 2*sizeof(int) + 7*sizeof(char); + BOOST_TEST_NO_VC71(unfused_func(lvalue,2,'\007') == 100 + expected); + BOOST_TEST(lvalue == 1 + 1*sizeof(lvalue)); + BOOST_TEST(unfused_func_ref(lvalue,2,'\007') == 100 + expected); + BOOST_TEST(lvalue == 1 + 2*sizeof(lvalue)); + BOOST_TEST(unfused_func_c(lvalue,2,'\007') == 0 + expected); + BOOST_TEST(lvalue == 1 + 3*sizeof(lvalue)); + BOOST_TEST(unfused_func_c2(lvalue,2,'\007') == 0 + expected); + BOOST_TEST(lvalue == 1 + 4*sizeof(lvalue)); + BOOST_TEST(unfused_func_c_ref(lvalue,2,'\007') == 0 + expected); + BOOST_TEST(lvalue == 1 + 5*sizeof(lvalue)); +} + +int main() +{ + result_type_tests(); + nullary_tests(); + unary_tests(); + ternary_tests(); + + return boost::report_errors(); +} + |