Update of /cvsroot/boost/boost/libs/fusion/test/functional
In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv17293/functional
Added Files:
fused.cpp fused_function_object.cpp fused_procedure.cpp
invoke.cpp invoke_function_object.cpp invoke_procedure.cpp
make_fused.cpp make_fused_function_object.cpp
make_fused_procedure.cpp make_unfused_generic.cpp
make_unfused_lvalue_args.cpp make_unfused_rvalue_args.cpp
unfused_generic.cpp unfused_lvalue_args.cpp
unfused_rvalue_args.cpp unfused_typed.cpp
Log Message:
adds test suite for functional module
--- NEW FILE: fused.cpp ---
/*=============================================================================
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/blank.hpp>
#include <boost/fusion/sequence/generation/make_vector.hpp>
#include <boost/fusion/sequence/container/vector.hpp>
namespace fusion = boost::fusion;
using boost::noncopyable;
template <class Base = boost::blank>
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;
fusion::fused< test_func<> > fused_func;
fusion::fused< test_func<noncopyable> & > fused_func_ref(f);
fusion::fused< test_func<> const > fused_func_c;
fusion::fused< test_func<> > const fused_func_c2;
fusion::fused< 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();
}
--- NEW FILE: fused_function_object.cpp ---
/*=============================================================================
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/blank.hpp>
#include <boost/fusion/sequence/generation/make_vector.hpp>
#include <boost/fusion/sequence/container/vector.hpp>
namespace fusion = boost::fusion;
using boost::noncopyable;
template <class Base = boost::blank>
struct test_func
: Base
{
template <typename T0, typename T1>
struct result
{
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();
}
--- NEW FILE: fused_procedure.cpp ---
/*=============================================================================
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/blank.hpp>
#include <boost/fusion/sequence/generation/make_vector.hpp>
#include <boost/fusion/sequence/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::blank>
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();
}
--- NEW FILE: invoke.cpp ---
(This appears to be a binary file; contents omitted.)
--- NEW FILE: invoke_function_object.cpp ---
(This appears to be a binary file; contents omitted.)
--- NEW FILE: invoke_procedure.cpp ---
(This appears to be a binary file; contents omitted.)
--- NEW FILE: make_fused.cpp ---
/*=============================================================================
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/blank.hpp>
#include <boost/fusion/sequence/generation/make_vector.hpp>
#include <boost/fusion/sequence/container/vector.hpp>
namespace fusion = boost::fusion;
using boost::noncopyable;
using boost::cref;
using boost::ref;
template <class Base = boost::blank>
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;
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();
}
--- NEW FILE: make_fused_function_object.cpp ---
/*=============================================================================
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/blank.hpp>
#include <boost/fusion/sequence/generation/make_vector.hpp>
#include <boost/fusion/sequence/container/vector.hpp>
namespace fusion = boost::fusion;
using boost::noncopyable;
using boost::cref;
using boost::ref;
template <class Base = boost::blank>
struct test_func
: Base
{
template <typename T0, typename T1>
struct result
{
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;
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();
}
--- NEW FILE: make_fused_procedure.cpp ---
/*=============================================================================
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/blank.hpp>
#include <boost/fusion/sequence/generation/make_vector.hpp>
#include <boost/fusion/sequence/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::blank>
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;
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();
}
--- NEW FILE: make_unfused_generic.cpp ---
/*=============================================================================
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_generic.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/fusion/functional/adapter/detail/has_type.hpp>
#include <boost/noncopyable.hpp>
#include <boost/blank.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/identity.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 = boost::blank, class RemoveNullary = mpl::false_>
struct test_func
: Base
{
template <class Seq> struct result
: mpl::if_< mpl::and_< fusion::result_of::empty<Seq>, RemoveNullary >,
boost::blank, mpl::identity<long> >::type
{ };
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
{
template <typename T>
long operator()(T const & elem, long value) const
{
return value + sizeof(T) * elem;
}
template <typename T>
long operator()(T & elem, long value) const
{
elem += sizeof(T);
return value;
}
template <typename T0, typename T1> struct result
: mpl::identity<long>
{ };
};
};
template <typename T>
inline T const & const_(T const & t)
{
return t;
}
int main()
{
test_func<> f;
test_func<noncopyable> f_nc;
fusion::result_of::make_unfused_generic< test_func<> >::type unfused_func =
fusion::make_unfused_generic(f);
fusion::result_of::make_unfused_generic< boost::reference_wrapper<
test_func<noncopyable> > >::type unfused_func_ref =
fusion::make_unfused_generic(ref(f_nc));
fusion::result_of::make_unfused_generic< boost::reference_wrapper<
test_func<noncopyable> const> >::type unfused_func_c_ref =
fusion::make_unfused_generic(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 lvalue = 12;
static const long expected = 1*sizeof(int) + 2*sizeof(long) +
7*sizeof(char);
BOOST_TEST(unfused_func(lvalue,lvalue,1,2l,'\007') == 100 + expected);
BOOST_TEST(lvalue == 12 + 2*sizeof(long));
BOOST_TEST(const_(unfused_func)(lvalue,lvalue,1,2l,'\007') == 0 +
expected);
BOOST_TEST(lvalue == 12 + 4*sizeof(long));
BOOST_TEST(unfused_func_ref(lvalue,lvalue,1,2l,'\007') == 100 + expected);
BOOST_TEST(lvalue == 12 + 6*sizeof(long));
BOOST_TEST(unfused_func_c_ref(lvalue,lvalue,1,2l,'\007') == 0 + expected);
BOOST_TEST(lvalue == 12 + 8*sizeof(long));
return boost::report_errors();
}
--- NEW FILE: make_unfused_lvalue_args.cpp ---
/*=============================================================================
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_lvalue_args.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <boost/noncopyable.hpp>
#include <boost/blank.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/bool.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>
#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 = boost::blank, class RemoveNullary = mpl::false_>
struct test_func
: Base
{
template <class Seq> struct result
: mpl::if_< mpl::and_< fusion::result_of::empty<Seq>, RemoveNullary >,
boost::blank, mpl::identity<long> >::type
{ };
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
{
template <typename T>
long operator()(T & elem, long value) const
{
elem += sizeof(T);
return value + elem;
}
template <typename T0, typename T1> struct result
: mpl::identity<long>
{ };
};
};
template <typename T>
inline T const & const_(T const & t)
{
return t;
}
int main()
{
test_func<> f;
test_func<noncopyable> f_nc;
fusion::result_of::make_unfused_lvalue_args< test_func<> >::type
unfused_func =
fusion::make_unfused_lvalue_args(f);
fusion::result_of::make_unfused_lvalue_args< boost::reference_wrapper<
test_func<noncopyable> > >::type unfused_func_ref =
fusion::make_unfused_lvalue_args(ref(f_nc));
fusion::result_of::make_unfused_lvalue_args< boost::reference_wrapper<
test_func<noncopyable> const> >::type unfused_func_c_ref =
fusion::make_unfused_lvalue_args(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();
}
--- NEW FILE: make_unfused_rvalue_args.cpp ---
/*=============================================================================
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_rvalue_args.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <boost/noncopyable.hpp>
#include <boost/blank.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/identity.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 = boost::blank, class RemoveNullary = mpl::false_>
struct test_func
: Base
{
template <class Seq> struct result
: mpl::if_< mpl::and_< fusion::result_of::empty<Seq>, RemoveNullary >,
boost::blank, mpl::identity<long> >::type
{ };
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
{
template <typename T>
long operator()(T const & elem, long value) const
{
return value + sizeof(T) * elem;
}
template <typename T0, typename T1> struct result
: mpl::identity<long>
{ };
};
};
template <typename T>
inline T const & const_(T const & t)
{
return t;
}
int main()
{
test_func<> f;
test_func<noncopyable> f_nc;
fusion::result_of::make_unfused_rvalue_args< test_func<> >::type
unfused_func =
fusion::make_unfused_rvalue_args(f);
fusion::result_of::make_unfused_rvalue_args< boost::reference_wrapper<
test_func<noncopyable> > >::type unfused_func_ref =
fusion::make_unfused_rvalue_args(ref(f_nc));
fusion::result_of::make_unfused_rvalue_args< boost::reference_wrapper<
test_func<noncopyable> const> >::type unfused_func_c_ref =
fusion::make_unfused_rvalue_args(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);
static const long expected = 1*sizeof(int) + 2*sizeof(long) +
7*sizeof(char);
BOOST_TEST(unfused_func(1,2l,'\007') == 100 + expected);
BOOST_TEST(const_(unfused_func)(1,2l,'\007') == 0 + expected);
BOOST_TEST(unfused_func_ref(1,2l,'\007') == 100 + expected);
BOOST_TEST(unfused_func_c_ref(1,2l,'\007') == 0 + expected);
return boost::report_errors();
}
--- NEW FILE: unfused_generic.cpp ---
/*=============================================================================
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_generic.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/fusion/functional/adapter/detail/has_type.hpp>
#include <boost/noncopyable.hpp>
#include <boost/blank.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/bool.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;
typedef mpl::true_ no_nullary_call;
template <class Base = boost::blank, class RemoveNullary = mpl::false_>
struct test_func
: Base
{
template <class Seq> struct result
: mpl::if_< mpl::and_< fusion::result_of::empty<Seq>, RemoveNullary >,
boost::blank, mpl::identity<long> >::type
{ };
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
{
template <typename T>
long operator()(T const & elem, long value) const
{
return value + sizeof(T) * elem;
}
template <typename T>
long operator()(T & elem, long value) const
{
elem += sizeof(T);
return value;
}
template <typename T0, typename T1> struct result
: mpl::identity<long>
{ };
};
};
void result_type_tests()
{
using boost::is_same;
using boost::fusion::detail::has_type;
typedef fusion::unfused_generic< test_func<noncopyable, no_nullary_call> >
test_func_1;
typedef fusion::unfused_generic< test_func<noncopyable> > test_func_0;
BOOST_TEST(( has_type< test_func_0::result<> >::value ));
BOOST_TEST(( has_type< test_func_1::result<int> >::value ));
BOOST_TEST(( ! has_type< test_func_1::result<> >::value ));
BOOST_TEST(( is_same< boost::result_of< test_func_0() >::type, long
>::value ));
BOOST_TEST(( is_same< boost::result_of< test_func_1(int) >::type, long
>::value ));
}
int main()
{
result_type_tests();
test_func<noncopyable> f;
fusion::unfused_generic< test_func<> > unfused_func;
fusion::unfused_generic< test_func<noncopyable> & > unfused_func_ref(f);
fusion::unfused_generic< test_func<> const > unfused_func_c;
fusion::unfused_generic< test_func<> > const unfused_func_c2;
fusion::unfused_generic< 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 lvalue = 12;
static const long expected = 1*sizeof(int) + 2*sizeof(long) +
7*sizeof(char);
BOOST_TEST(unfused_func(lvalue,lvalue,1,2l,'\007') == 100 + expected);
BOOST_TEST(lvalue == 12 + 2*sizeof(long));
BOOST_TEST(unfused_func_ref(lvalue,lvalue,1,2l,'\007') == 100 + expected);
BOOST_TEST(lvalue == 12 + 4*sizeof(long));
BOOST_TEST(unfused_func_c(lvalue,lvalue,1,2l,'\007') == 0 + expected);
BOOST_TEST(lvalue == 12 + 6*sizeof(long));
BOOST_TEST(unfused_func_c2(lvalue,lvalue,1,2l,'\007') == 0 + expected);
BOOST_TEST(lvalue == 12 + 8*sizeof(long));
BOOST_TEST(unfused_func_c_ref(lvalue,lvalue,1,2l,'\007') == 0 + expected);
BOOST_TEST(lvalue == 12 + 10*sizeof(long));
return boost::report_errors();
}
--- NEW FILE: unfused_lvalue_args.cpp ---
/*=============================================================================
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_lvalue_args.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <boost/noncopyable.hpp>
#include <boost/blank.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/bool.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;
typedef mpl::true_ no_nullary_call;
template <class Base = boost::blank, class RemoveNullary = mpl::false_>
struct test_func
: Base
{
template <class Seq> struct result
: mpl::if_< mpl::and_< fusion::result_of::empty<Seq>, RemoveNullary >,
boost::blank, mpl::identity<long> >::type
{ };
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
{
template <typename T>
long operator()(T & elem, long value) const
{
elem += sizeof(T);
return value + elem;
}
template <typename T0, typename T1> struct result
: mpl::identity<long>
{ };
};
};
void result_type_tests()
{
using boost::is_same;
using boost::fusion::detail::has_type;
typedef fusion::unfused_lvalue_args< test_func<noncopyable,
no_nullary_call> > test_func_1;
typedef fusion::unfused_lvalue_args< test_func<noncopyable> > test_func_0;
BOOST_TEST(( has_type< test_func_0::result<> >::value ));
BOOST_TEST(( has_type< test_func_1::result<int> >::value ));
BOOST_TEST(( ! has_type< test_func_1::result<> >::value ));
BOOST_TEST(( is_same< boost::result_of< test_func_0() >::type, long
>::value ));
BOOST_TEST(( is_same< boost::result_of< test_func_1(int) >::type, long
>::value ));
}
int main()
{
result_type_tests();
test_func<noncopyable> f;
fusion::unfused_lvalue_args< test_func<> > unfused_func;
fusion::unfused_lvalue_args< test_func<noncopyable> & > unfused_func_ref(f);
fusion::unfused_lvalue_args< test_func<> const > unfused_func_c;
fusion::unfused_lvalue_args< test_func<> > const unfused_func_c2;
fusion::unfused_lvalue_args< 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();
}
--- NEW FILE: unfused_rvalue_args.cpp ---
/*=============================================================================
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_rvalue_args.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <boost/noncopyable.hpp>
#include <boost/blank.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/bool.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;
typedef mpl::true_ no_nullary_call;
template <class Base = boost::blank, class RemoveNullary = mpl::false_>
struct test_func
: Base
{
template <class Seq> struct result
: mpl::if_< mpl::and_< fusion::result_of::empty<Seq>, RemoveNullary >,
boost::blank, mpl::identity<long> >::type
{ };
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
{
template <typename T>
long operator()(T const & elem, long value) const
{
return value + sizeof(T) * elem;
}
template <typename T0, typename T1> struct result
: mpl::identity<long>
{ };
};
};
void result_type_tests()
{
using boost::is_same;
using boost::fusion::detail::has_type;
typedef fusion::unfused_rvalue_args< test_func<noncopyable,
no_nullary_call> > test_func_1;
typedef fusion::unfused_rvalue_args< test_func<noncopyable> > test_func_0;
BOOST_TEST(( has_type< test_func_0::result<> >::value ));
BOOST_TEST(( has_type< test_func_1::result<int> >::value ));
BOOST_TEST(( ! has_type< test_func_1::result<> >::value ));
BOOST_TEST(( is_same< boost::result_of< test_func_0() >::type, long
>::value ));
BOOST_TEST(( is_same< boost::result_of< test_func_1(int) >::type, long
>::value ));
}
int main()
{
result_type_tests();
test_func<noncopyable> f;
fusion::unfused_rvalue_args< test_func<> > unfused_func;
fusion::unfused_rvalue_args< test_func<noncopyable> & > unfused_func_ref(f);
fusion::unfused_rvalue_args< test_func<> const > unfused_func_c;
fusion::unfused_rvalue_args< test_func<> > const unfused_func_c2;
fusion::unfused_rvalue_args< 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);
static const long expected = 1*sizeof(int) + 2*sizeof(long) +
7*sizeof(char);
BOOST_TEST(unfused_func(1,2l,'\007') == 100 + expected);
BOOST_TEST(unfused_func_ref(1,2l,'\007') == 100 + expected);
BOOST_TEST(unfused_func_c(1,2l,'\007') == 0 + expected);
BOOST_TEST(unfused_func_c2(1,2l,'\007') == 0 + expected);
BOOST_TEST(unfused_func_c_ref(1,2l,'\007') == 0 + expected);
return boost::report_errors();
}
--- NEW FILE: unfused_typed.cpp ---
/*=============================================================================
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/blank.hpp>
#include <boost/noncopyable.hpp>
#include <boost/utility/result_of.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/apply.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/equal_to.hpp>
#include <boost/utility/result_of.hpp>
#include <boost/fusion/sequence/intrinsic/size.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<long &,int,char> types;
typedef mpl::always< mpl::true_ > unconstrained;
typedef mpl::equal_to< fusion::result_of::size<_>,
fusion::result_of::size<types> > non_variadic;
template <class Base = boost::blank, class Validation = unconstrained>
struct test_func
: Base
{
template <class Seq> struct result
: mpl::if_< typename mpl::apply<Validation, Seq>::type,
mpl::identity<long>, boost::blank >::type
{ };
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
{
template <typename T>
long operator()(T const & elem, long value) const
{
return value + sizeof(T) * elem;
}
template <typename T>
long operator()(T & elem, long value) const
{
elem += sizeof(T);
return value;
}
template <typename T0, typename T1> struct result
: mpl::identity<long>
{ };
};
};
void result_type_tests()
{
using boost::is_same;
using boost::fusion::detail::has_type;
typedef fusion::unfused_typed< test_func<noncopyable, non_variadic>, types
> test_func_3;
typedef fusion::unfused_typed< test_func<noncopyable>, types > test_func_0;
BOOST_TEST(( has_type< test_func_0::result<> >::value ));
BOOST_TEST(( has_type< test_func_3::result<long &, int, char> >::value ));
BOOST_TEST(( ! has_type< test_func_3::result<> >::value ));
BOOST_TEST(( is_same< boost::result_of< test_func_0() >::type, long
>::value ));
BOOST_TEST(( is_same< boost::result_of< test_func_3(long &, int, char)
>::type, long >::value ));
}
int main()
{
result_type_tests();
test_func<noncopyable> f;
fusion::unfused_typed< test_func<>, types > unfused_func;
fusion::unfused_typed< test_func<noncopyable> &, types >
unfused_func_ref(f);
fusion::unfused_typed< test_func<> const, types > unfused_func_c;
fusion::unfused_typed< test_func<>, types > const unfused_func_c2;
fusion::unfused_typed< test_func<noncopyable> const &, types >
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 lvalue = 1;
BOOST_TEST(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));
static const long expected = 2*sizeof(int) + 7*sizeof(char);
BOOST_TEST(unfused_func(lvalue,2,'\007') == 100 + expected);
BOOST_TEST(lvalue == 1 + 6*sizeof(lvalue));
BOOST_TEST(unfused_func_ref(lvalue,2,'\007') == 100 + expected);
BOOST_TEST(lvalue == 1 + 7*sizeof(lvalue));
BOOST_TEST(unfused_func_c(lvalue,2,'\007') == 0 + expected);
BOOST_TEST(lvalue == 1 + 8*sizeof(lvalue));
BOOST_TEST(unfused_func_c2(lvalue,2,'\007') == 0 + expected);
BOOST_TEST(lvalue == 1 + 9*sizeof(lvalue));
BOOST_TEST(unfused_func_c_ref(lvalue,2,'\007') == 0 + expected);
BOOST_TEST(lvalue == 1 + 10*sizeof(lvalue));
return boost::report_errors();
}
-------------------------------------------------------------------------
Take Surveys. Earn Cash. Influence the Future of IT
Join SourceForge.net's Techsay panel and you'll get the chance to share your
opinions on IT & business topics through brief surveys-and earn cash
http://www.techsay.com/default.php?page=join.php&p=sourceforge&CID=DEVDEV
_______________________________________________
Boost-cvs mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/boost-cvs
