mirrors/turtle
3
0
Fork 0
mirror of https://github.com/mat007/turtle.git synced 2026-06-22 12:13:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Preview of clang-format changes and CI

Browse source
This commit is contained in:
Alexander Grund 2020-09-05 14:37:48 +02:00
parent bfd1701fcb
commit 805e3b02bf
No known key found for this signature in database
GPG key ID: E92C451FC21EF13F
98 changed files with 6339 additions and 11357 deletions
Download patch file Download diff file Expand all files Collapse all files

35
include/turtle/catch.hpp
View file

@ -11,34 +11,31 @@
#include <catch.hpp>
template< typename Result >
template<typename Result>
struct catch_mock_error_policy
{
static Result abort()
{
FAIL( "Aborted" );
throw std::runtime_error( "unreachable" );
FAIL("Aborted");
throw std::runtime_error("unreachable");
}
template< typename Context >
static void fail( const char* message, const Context& context,
const char* file = "file://unknown-location", int line = 0 )
template<typename Context>
static void fail(const char* message, const Context& context, const char* file = "file://unknown-location",
int line = 0)
{
CAPTURE( context );
FAIL_CHECK( message << " in: " << file << ":" << line );
CAPTURE(context);
FAIL_CHECK(message << " in: " << file << ":" << line);
}
template< typename Context >
static void call( const Context& context, const char* file, int line )
template<typename Context>
static void call(const Context& context, const char* file, int line)
{
CAPTURE( context );
INFO( file << ":" << line );
}
static void pass( const char* file, int line )
{
INFO( file << ":" << line );
CAPTURE(context);
INFO(file << ":" << line);
}
static void pass(const char* file, int line) { INFO(file << ":" << line); }
};
#define MOCK_ERROR_POLICY catch_mock_error_policy

27
include/turtle/cleanup.hpp
View file

@ -10,30 +10,25 @@
#define MOCK_CLEANUP_HPP_INCLUDED
#include "config.hpp"
#include "verify.hpp"
#include "reset.hpp"
#include "verify.hpp"
#ifdef MOCK_USE_BOOST_TEST
#include <boost/test/unit_test_suite.hpp>
# include <boost/test/unit_test_suite.hpp>
#endif
namespace mock
namespace mock {
struct cleanup
{
struct cleanup
{
~cleanup()
{
mock::reset();
}
};
~cleanup() { mock::reset(); }
};
#ifdef MOCK_USE_BOOST_TEST
BOOST_GLOBAL_FIXTURE( cleanup )
#if BOOST_VERSION >= 105900
;
#endif
BOOST_GLOBAL_FIXTURE(cleanup)
# if BOOST_VERSION >= 105900
;
# endif
#endif
} // mock
} // namespace mock
#endif // MOCK_CLEANUP_HPP_INCLUDED

79
include/turtle/config.hpp
View file

@ -16,89 +16,88 @@
#include <boost/preprocessor/comparison/less.hpp>
#ifndef MOCK_ERROR_POLICY
# define MOCK_ERROR_POLICY mock::error
# define MOCK_USE_BOOST_TEST
# define MOCK_ERROR_POLICY mock::error
# define MOCK_USE_BOOST_TEST
#endif
#ifndef MOCK_MAX_ARGS
# define MOCK_MAX_ARGS 9
# define MOCK_MAX_ARGS 9
#endif
#ifndef MOCK_MAX_SEQUENCES
# define MOCK_MAX_SEQUENCES 10
# define MOCK_MAX_SEQUENCES 10
#endif
#ifndef BOOST_FUNCTION_MAX_ARGS
# define BOOST_FUNCTION_MAX_ARGS MOCK_MAX_ARGS
# define BOOST_FUNCTION_MAX_ARGS MOCK_MAX_ARGS
#elif BOOST_PP_LESS(BOOST_FUNCTION_MAX_ARGS, MOCK_MAX_ARGS)
# error BOOST_FUNCTION_MAX_ARGS must be set to MOCK_MAX_ARGS or higher
# error BOOST_FUNCTION_MAX_ARGS must be set to MOCK_MAX_ARGS or higher
#endif
#ifndef BOOST_FT_MAX_ARITY
# define BOOST_FT_MAX_ARITY BOOST_PP_INC(MOCK_MAX_ARGS)
# define BOOST_FT_MAX_ARITY BOOST_PP_INC(MOCK_MAX_ARGS)
#elif BOOST_PP_LESS_EQUAL(BOOST_FT_MAX_ARITY, MOCK_MAX_ARGS)
# error BOOST_FT_MAX_ARITY must be set to MOCK_MAX_ARGS + 1 or higher
# error BOOST_FT_MAX_ARITY must be set to MOCK_MAX_ARGS + 1 or higher
#endif
#if !defined(BOOST_NO_CXX11_NULLPTR) && !defined(BOOST_NO_NULLPTR)
# ifndef MOCK_NO_NULLPTR
# define MOCK_NULLPTR
# endif
# ifndef MOCK_NO_NULLPTR
# define MOCK_NULLPTR
# endif
#endif
#if !defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_DECLTYPE)
# ifndef MOCK_NO_DECLTYPE
# define MOCK_DECLTYPE
# endif
# ifndef MOCK_NO_DECLTYPE
# define MOCK_DECLTYPE
# endif
#endif
#if !defined(BOOST_NO_CXX11_VARIADIC_MACROS) && !defined(BOOST_NO_VARIADIC_MACROS)
# ifndef MOCK_NO_VARIADIC_MACROS
# define MOCK_VARIADIC_MACROS
# endif
# ifndef MOCK_NO_VARIADIC_MACROS
# define MOCK_VARIADIC_MACROS
# endif
#endif
#if !defined(BOOST_NO_CXX11_SMART_PTR) && !defined(BOOST_NO_SMART_PTR)
# ifndef MOCK_NO_SMART_PTR
# define MOCK_SMART_PTR
# endif
# ifndef MOCK_NO_SMART_PTR
# define MOCK_SMART_PTR
# endif
#endif
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_RVALUE_REFERENCES)
# ifndef MOCK_NO_RVALUE_REFERENCES
# define MOCK_RVALUE_REFERENCES
# endif
# ifndef MOCK_NO_RVALUE_REFERENCES
# define MOCK_RVALUE_REFERENCES
# endif
#endif
#if !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
# ifndef MOCK_NO_HDR_FUNCTIONAL
# define MOCK_HDR_FUNCTIONAL
# endif
# ifndef MOCK_NO_HDR_FUNCTIONAL
# define MOCK_HDR_FUNCTIONAL
# endif
#endif
#if !defined(BOOST_NO_CXX11_HDR_MUTEX) && !defined(BOOST_NO_0X_HDR_MUTEX)
# ifndef MOCK_NO_HDR_MUTEX
# define MOCK_HDR_MUTEX
# endif
# ifndef MOCK_NO_HDR_MUTEX
# define MOCK_HDR_MUTEX
# endif
#endif
#if !defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_LAMBDAS)
# ifndef MOCK_NO_LAMBDAS
# define MOCK_LAMBDAS
# endif
# ifndef MOCK_NO_LAMBDAS
# define MOCK_LAMBDAS
# endif
#endif
#if !defined(BOOST_NO_AUTO_PTR)
# ifndef MOCK_NO_AUTO_PTR
# define MOCK_AUTO_PTR
# endif
# ifndef MOCK_NO_AUTO_PTR
# define MOCK_AUTO_PTR
# endif
#endif
#if defined(__cpp_lib_uncaught_exceptions) || \
defined(_MSC_VER) && (_MSC_VER >= 1900)
# ifndef MOCK_NO_UNCAUGHT_EXCEPTIONS
# define MOCK_UNCAUGHT_EXCEPTIONS
# endif
#if defined(__cpp_lib_uncaught_exceptions) || defined(_MSC_VER) && (_MSC_VER >= 1900)
# ifndef MOCK_NO_UNCAUGHT_EXCEPTIONS
# define MOCK_UNCAUGHT_EXCEPTIONS
# endif
#endif
#endif // MOCK_CONFIG_HPP_INCLUDED

304
include/turtle/constraint.hpp
View file

@ -11,248 +11,194 @@
#include "config.hpp"
#include "log.hpp"
#include <boost/ref.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <boost/move/move.hpp>
#include <boost/preprocessor/array.hpp>
#include <boost/preprocessor/control/if.hpp>
#include <boost/preprocessor/variadic/to_array.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
#include <boost/preprocessor/array.hpp>
#include <boost/move/move.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <boost/preprocessor/variadic/to_array.hpp>
#include <boost/ref.hpp>
#include <boost/type_traits/decay.hpp>
namespace mock
namespace mock {
template<typename Constraint>
struct constraint
{
template< typename Constraint >
struct constraint
{
constraint()
{}
constraint( const Constraint& c )
: c_( c )
{}
Constraint c_;
};
constraint() {}
constraint(const Constraint& c) : c_(c) {}
Constraint c_;
};
namespace detail
{
template< typename Lhs, typename Rhs >
namespace detail {
template<typename Lhs, typename Rhs>
class and_
{
public:
and_( const Lhs& lhs, const Rhs& rhs )
: lhs_( lhs )
, rhs_( rhs )
{}
template< typename Actual >
bool operator()( const Actual& actual ) const
and_(const Lhs& lhs, const Rhs& rhs) : lhs_(lhs), rhs_(rhs) {}
template<typename Actual>
bool operator()(const Actual& actual) const
{
return lhs_( actual ) && rhs_( actual );
return lhs_(actual) && rhs_(actual);
}
friend std::ostream& operator<<( std::ostream& s, const and_& a )
friend std::ostream& operator<<(std::ostream& s, const and_& a)
{
return s << "( " << mock::format( a.lhs_ )
<< " && " << mock::format( a.rhs_ ) << " )";
return s << "( " << mock::format(a.lhs_) << " && " << mock::format(a.rhs_) << " )";
}
private:
Lhs lhs_;
Rhs rhs_;
};
template< typename Lhs, typename Rhs >
template<typename Lhs, typename Rhs>
class or_
{
public:
or_( const Lhs& lhs, const Rhs& rhs )
: lhs_( lhs )
, rhs_( rhs )
{}
template< typename Actual >
bool operator()( const Actual& actual ) const
or_(const Lhs& lhs, const Rhs& rhs) : lhs_(lhs), rhs_(rhs) {}
template<typename Actual>
bool operator()(const Actual& actual) const
{
return lhs_( actual ) || rhs_( actual );
return lhs_(actual) || rhs_(actual);
}
friend std::ostream& operator<<( std::ostream& s, const or_& o )
friend std::ostream& operator<<(std::ostream& s, const or_& o)
{
return s << "( " << mock::format( o.lhs_ )
<< " || " << mock::format( o.rhs_ )<< " )";
return s << "( " << mock::format(o.lhs_) << " || " << mock::format(o.rhs_) << " )";
}
private:
Lhs lhs_;
Rhs rhs_;
};
template< typename Constraint >
template<typename Constraint>
class not_
{
public:
explicit not_( const Constraint& c )
: c_( c )
{}
template< typename Actual >
bool operator()( const Actual& actual ) const
explicit not_(const Constraint& c) : c_(c) {}
template<typename Actual>
bool operator()(const Actual& actual) const
{
return ! c_( actual );
}
friend std::ostream& operator<<( std::ostream& s, const not_& n )
{
return s << "! " << mock::format( n.c_ );
return !c_(actual);
}
friend std::ostream& operator<<(std::ostream& s, const not_& n) { return s << "! " << mock::format(n.c_); }
private:
Constraint c_;
};
} // namespace detail
template<typename Lhs, typename Rhs>
const constraint<detail::or_<Lhs, Rhs>> operator||(const constraint<Lhs>& lhs, const constraint<Rhs>& rhs)
{
return detail::or_<Lhs, Rhs>(lhs.c_, rhs.c_);
}
template< typename Lhs, typename Rhs >
const constraint< detail::or_< Lhs, Rhs > >
operator||( const constraint< Lhs >& lhs,
const constraint< Rhs >& rhs )
{
return detail::or_< Lhs, Rhs >( lhs.c_, rhs.c_ );
}
template<typename Lhs, typename Rhs>
const constraint<detail::and_<Lhs, Rhs>> operator&&(const constraint<Lhs>& lhs, const constraint<Rhs>& rhs)
{
return detail::and_<Lhs, Rhs>(lhs.c_, rhs.c_);
}
template< typename Lhs, typename Rhs >
const constraint< detail::and_< Lhs, Rhs > >
operator&&( const constraint< Lhs >& lhs,
const constraint< Rhs >& rhs )
{
return detail::and_< Lhs, Rhs >( lhs.c_, rhs.c_ );
}
template<typename Constraint>
const constraint<detail::not_<Constraint>> operator!(const constraint<Constraint>& c)
{
return detail::not_<Constraint>(c.c_);
}
} // namespace mock
template< typename Constraint >
const constraint< detail::not_< Constraint > >
operator!( const constraint< Constraint >& c )
{
return detail::not_< Constraint >( c.c_ );
}
} // mock
#define MOCK_UNARY_CONSTRAINT(Name, n, Args, Expr) \
namespace detail { \
struct Name \
{ \
template<typename Actual> \
bool operator()(const Actual& actual) const \
{ \
return Expr; \
} \
friend std::ostream& operator<<(std::ostream& s, const Name&) { return s << BOOST_STRINGIZE(Name); } \
}; \
} \
const mock::constraint<detail::Name> Name;
#define MOCK_UNARY_CONSTRAINT(Name, n, Args, Expr) \
namespace detail \
{ \
struct Name \
{ \
template< typename Actual > \
bool operator()( const Actual& actual ) const \
{ \
return Expr; \
} \
friend std::ostream& operator<<( std::ostream& s, const Name& ) \
{ \
return s << BOOST_STRINGIZE(Name); \
} \
}; \
} \
const mock::constraint< detail::Name > Name;
#define MOCK_CONSTRAINT_ASSIGN(z, n, d) expected##n(boost::forward<T##n>(e##n))
#define MOCK_CONSTRAINT_ASSIGN(z, n, d) \
expected##n( boost::forward< T##n >(e##n) )
#define MOCK_CONSTRAINT_UNWRAP_REF(z, n, d) boost::unwrap_ref(expected##n)
#define MOCK_CONSTRAINT_UNWRAP_REF(z, n, d) \
boost::unwrap_ref( expected##n )
#define MOCK_CONSTRAINT_FORMAT(z, n, d) BOOST_PP_IF(n, << ", " <<, ) mock::format(c.expected##n)
#define MOCK_CONSTRAINT_FORMAT(z, n, d) \
BOOST_PP_IF(n, << ", " <<,) mock::format( c.expected##n )
#define MOCK_CONSTRAINT_MEMBER(z, n, d) Expected_##n expected##n;
#define MOCK_CONSTRAINT_MEMBER(z, n, d) \
Expected_##n expected##n;
#define MOCK_CONSTRAINT_TPL_TYPE(z, n, d) \
typename boost::decay< const T##n >::type
#define MOCK_CONSTRAINT_TPL_TYPE(z, n, d) typename boost::decay<const T##n>::type
#define MOCK_CONSTRAINT_CREF_PARAM(z, n, Args) \
const typename boost::unwrap_reference< Expected_##n >::type& \
BOOST_PP_ARRAY_ELEM(n, Args)
const typename boost::unwrap_reference<Expected_##n>::type& BOOST_PP_ARRAY_ELEM(n, Args)
#define MOCK_CONSTRAINT_ARG(z, n, Args) \
BOOST_FWD_REF(T##n) BOOST_PP_ARRAY_ELEM(n, Args)
#define MOCK_CONSTRAINT_ARG(z, n, Args) BOOST_FWD_REF(T##n) BOOST_PP_ARRAY_ELEM(n, Args)
#define MOCK_CONSTRAINT_ARGS(z, n, Args) \
BOOST_FWD_REF(T##n) e##n
#define MOCK_CONSTRAINT_ARGS(z, n, Args) BOOST_FWD_REF(T##n) e##n
#define MOCK_CONSTRAINT_PARAM(z, n, Args) \
boost::forward< T##n >( BOOST_PP_ARRAY_ELEM(n, Args) )
#define MOCK_CONSTRAINT_PARAM(z, n, Args) boost::forward<T##n>(BOOST_PP_ARRAY_ELEM(n, Args))
#define MOCK_NARY_CONSTRAINT(Name, n, Args, Expr) \
namespace detail \
{ \
template< BOOST_PP_ENUM_PARAMS(n, typename Expected_) > \
struct Name \
{ \
template< BOOST_PP_ENUM_PARAMS(n, typename T) > \
explicit Name( \
BOOST_PP_ENUM(n, MOCK_CONSTRAINT_ARGS, _) ) \
: BOOST_PP_ENUM(n, MOCK_CONSTRAINT_ASSIGN, _) \
{} \
template< typename Actual > \
bool operator()( const Actual& actual ) const \
{ \
return test( actual, \
BOOST_PP_ENUM(n, MOCK_CONSTRAINT_UNWRAP_REF, _) ); \
} \
template< typename Actual > \
bool test( const Actual& actual, \
BOOST_PP_ENUM(n, \
MOCK_CONSTRAINT_CREF_PARAM, (n, Args)) ) const \
{ \
return Expr; \
} \
friend std::ostream& operator<<( std::ostream& s, const Name& c ) \
{ \
return s << BOOST_STRINGIZE(Name) << "( " \
<< BOOST_PP_REPEAT(n, MOCK_CONSTRAINT_FORMAT, _) \
<< " )"; \
} \
BOOST_PP_REPEAT(n, MOCK_CONSTRAINT_MEMBER, _) \
}; \
} \
template< BOOST_PP_ENUM_PARAMS(n, typename T) > \
mock::constraint< \
detail::Name< BOOST_PP_ENUM(n, MOCK_CONSTRAINT_TPL_TYPE, _) > \
> Name( BOOST_PP_ENUM(n, MOCK_CONSTRAINT_ARG, (n, Args)) ) \
{ \
return detail::Name< BOOST_PP_ENUM(n, MOCK_CONSTRAINT_TPL_TYPE, _) >( \
BOOST_PP_ENUM(n, MOCK_CONSTRAINT_PARAM, (n, Args)) ); \
#define MOCK_NARY_CONSTRAINT(Name, n, Args, Expr) \
namespace detail { \
template<BOOST_PP_ENUM_PARAMS(n, typename Expected_)> \
struct Name \
{ \
template<BOOST_PP_ENUM_PARAMS(n, typename T)> \
explicit Name(BOOST_PP_ENUM(n, MOCK_CONSTRAINT_ARGS, _)) : BOOST_PP_ENUM(n, MOCK_CONSTRAINT_ASSIGN, _) \
{} \
template<typename Actual> \
bool operator()(const Actual& actual) const \
{ \
return test(actual, BOOST_PP_ENUM(n, MOCK_CONSTRAINT_UNWRAP_REF, _)); \
} \
template<typename Actual> \
bool test(const Actual& actual, BOOST_PP_ENUM(n, MOCK_CONSTRAINT_CREF_PARAM, (n, Args))) const \
{ \
return Expr; \
} \
friend std::ostream& operator<<(std::ostream& s, const Name& c) \
{ \
return s << BOOST_STRINGIZE(Name) << "( " << BOOST_PP_REPEAT(n, MOCK_CONSTRAINT_FORMAT, _) << " )"; \
} \
BOOST_PP_REPEAT(n, MOCK_CONSTRAINT_MEMBER, _) \
}; \
} \
template<BOOST_PP_ENUM_PARAMS(n, typename T)> \
mock::constraint<detail::Name<BOOST_PP_ENUM(n, MOCK_CONSTRAINT_TPL_TYPE, _)>> Name( \
BOOST_PP_ENUM(n, MOCK_CONSTRAINT_ARG, (n, Args))) \
{ \
return detail::Name<BOOST_PP_ENUM(n, MOCK_CONSTRAINT_TPL_TYPE, _)>( \
BOOST_PP_ENUM(n, MOCK_CONSTRAINT_PARAM, (n, Args))); \
}
#define MOCK_CONSTRAINT_EXT(Name, n, Args, Expr) \
BOOST_PP_IF(n, \
MOCK_NARY_CONSTRAINT, \
MOCK_UNARY_CONSTRAINT)(Name, n, Args, Expr)
BOOST_PP_IF(n, MOCK_NARY_CONSTRAINT, MOCK_UNARY_CONSTRAINT)(Name, n, Args, Expr)
#ifdef MOCK_VARIADIC_MACROS
#ifdef BOOST_MSVC
# define MOCK_VARIADIC_SIZE(...) \
BOOST_PP_CAT(MOCK_VARIADIC_SIZE_I(__VA_ARGS__, \
32, 31, 30, 29, 28, 27, 26, 25, 24, 23, \
22, 21, 20, 19, 18, 17, 16, 15, 14, 13, \
12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,),)
#else // BOOST_MSVC
# define MOCK_VARIADIC_SIZE(...) \
MOCK_VARIADIC_SIZE_I(__VA_ARGS__, \
32, 31, 30, 29, 28, 27, 26, 25, 24, 23, \
22, 21, 20, 19, 18, 17, 16, 15, 14, 13, \
12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,)
#endif // BOOST_MSVC
#define MOCK_VARIADIC_SIZE_I( \
e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, \
e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, \
e25, e26, e27, e28, e29, e30, e31, size, ...) size
# ifdef BOOST_MSVC
# define MOCK_VARIADIC_SIZE(...) \
BOOST_PP_CAT(MOCK_VARIADIC_SIZE_I(__VA_ARGS__, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, \
17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, ), )
# else // BOOST_MSVC
# define MOCK_VARIADIC_SIZE(...) \
MOCK_VARIADIC_SIZE_I(__VA_ARGS__, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, \
14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, )
# endif // BOOST_MSVC
# define MOCK_VARIADIC_SIZE_I(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, \
e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, size, ...) \
size
#define MOCK_CONSTRAINT_AUX_AUX(Name, n, Array) \
MOCK_CONSTRAINT_EXT( \
Name, n, \
BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_POP_BACK(Array)), \
BOOST_PP_ARRAY_ELEM(n, Array))
# define MOCK_CONSTRAINT_AUX_AUX(Name, n, Array) \
MOCK_CONSTRAINT_EXT(Name, n, BOOST_PP_ARRAY_TO_TUPLE(BOOST_PP_ARRAY_POP_BACK(Array)), \
BOOST_PP_ARRAY_ELEM(n, Array))
#define MOCK_CONSTRAINT_AUX(Name, Size, Tuple) \
MOCK_CONSTRAINT_AUX_AUX(Name, BOOST_PP_DEC(Size), (Size,Tuple))
# define MOCK_CONSTRAINT_AUX(Name, Size, Tuple) MOCK_CONSTRAINT_AUX_AUX(Name, BOOST_PP_DEC(Size), (Size, Tuple))
#define MOCK_CONSTRAINT(Name, ...) \
MOCK_CONSTRAINT_AUX( \
Name, MOCK_VARIADIC_SIZE(__VA_ARGS__), (__VA_ARGS__))
# define MOCK_CONSTRAINT(Name, ...) MOCK_CONSTRAINT_AUX(Name, MOCK_VARIADIC_SIZE(__VA_ARGS__), (__VA_ARGS__))
#endif // MOCK_VARIADIC_MACROS

339
include/turtle/constraints.hpp
View file

@ -14,299 +14,244 @@
#include "detail/addressof.hpp"
#include "detail/move_helper.hpp"
#include <boost/ref.hpp>
#include <boost/version.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/common_type.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/has_equal_to.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/version.hpp>
#if BOOST_VERSION >= 107000
#include <boost/test/tools/floating_point_comparison.hpp>
# include <boost/test/tools/floating_point_comparison.hpp>
#else
#include <boost/test/floating_point_comparison.hpp>
# include <boost/test/floating_point_comparison.hpp>
#endif
namespace mock
{
MOCK_UNARY_CONSTRAINT( any, 0,, ((void)actual, true) )
MOCK_UNARY_CONSTRAINT( affirm, 0,, !! actual )
MOCK_UNARY_CONSTRAINT( negate, 0,, ! actual )
MOCK_UNARY_CONSTRAINT( evaluate, 0,, actual() )
namespace mock {
MOCK_UNARY_CONSTRAINT(any, 0, , ((void)actual, true))
MOCK_UNARY_CONSTRAINT(affirm, 0, , !!actual)
MOCK_UNARY_CONSTRAINT(negate, 0, , !actual)
MOCK_UNARY_CONSTRAINT(evaluate, 0, , actual())
MOCK_NARY_CONSTRAINT( less, 1, ( expected ), actual < expected )
MOCK_NARY_CONSTRAINT( greater, 1, ( expected ), actual > expected )
MOCK_NARY_CONSTRAINT( less_equal, 1, ( expected ), actual <= expected )
MOCK_NARY_CONSTRAINT( greater_equal, 1, ( expected ), actual >= expected )
MOCK_NARY_CONSTRAINT(less, 1, (expected), actual < expected)
MOCK_NARY_CONSTRAINT(greater, 1, (expected), actual > expected)
MOCK_NARY_CONSTRAINT(less_equal, 1, (expected), actual <= expected)
MOCK_NARY_CONSTRAINT(greater_equal, 1, (expected), actual >= expected)
#if BOOST_VERSION < 105900
# define MOCK_SMALL() \
boost::test_tools::check_is_small( actual, tolerance )
# define MOCK_PERCENT_TOLERANCE() \
boost::test_tools::check_is_close( \
actual, \
expected, \
boost::test_tools::percent_tolerance( tolerance ) )
# define MOCK_FRACTION_TOLERANCE() \
boost::test_tools::check_is_close( \
actual, \
expected, \
boost::test_tools::fraction_tolerance( tolerance ) )
# define MOCK_SMALL() boost::test_tools::check_is_small(actual, tolerance)
# define MOCK_PERCENT_TOLERANCE() \
boost::test_tools::check_is_close(actual, expected, boost::test_tools::percent_tolerance(tolerance))
# define MOCK_FRACTION_TOLERANCE() \
boost::test_tools::check_is_close(actual, expected, boost::test_tools::fraction_tolerance(tolerance))
#else // BOOST_VERSION < 105900
namespace detail
{
template< typename T, typename Tolerance >
bool is_small( const T& t, const Tolerance& tolerance )
namespace detail {
template<typename T, typename Tolerance>
bool is_small(const T& t, const Tolerance& tolerance)
{
return boost::math::fpc::small_with_tolerance< T >( tolerance )( t );
return boost::math::fpc::small_with_tolerance<T>(tolerance)(t);
}
template< typename T1, typename T2, typename Tolerance >
bool is_close( const T1& t1, const T2& t2, const Tolerance& tolerance )
template<typename T1, typename T2, typename Tolerance>
bool is_close(const T1& t1, const T2& t2, const Tolerance& tolerance)
{
typedef typename boost::common_type< T1, T2 >::type common_type;
return boost::math::fpc::close_at_tolerance< common_type >(
tolerance, boost::math::fpc::FPC_STRONG )( t1, t2 );
typedef typename boost::common_type<T1, T2>::type common_type;
return boost::math::fpc::close_at_tolerance<common_type>(tolerance, boost::math::fpc::FPC_STRONG)(t1, t2);
}
}
} // namespace detail
# define MOCK_SMALL() \
detail::is_small( actual, tolerance )
# define MOCK_PERCENT_TOLERANCE() \
detail::is_close( actual, expected, \
boost::math::fpc::percent_tolerance( tolerance ) )
# define MOCK_FRACTION_TOLERANCE() \
detail::is_close( actual, expected, tolerance )
# define MOCK_SMALL() detail::is_small(actual, tolerance)
# define MOCK_PERCENT_TOLERANCE() detail::is_close(actual, expected, boost::math::fpc::percent_tolerance(tolerance))
# define MOCK_FRACTION_TOLERANCE() detail::is_close(actual, expected, tolerance)
#endif // BOOST_VERSION < 105900
#ifdef small
# pragma push_macro( "small" )
# undef small
# define MOCK_SMALL_DEFINED
# pragma push_macro("small")
# undef small
# define MOCK_SMALL_DEFINED
#endif
MOCK_NARY_CONSTRAINT( small, 1, ( tolerance ),
( MOCK_SMALL() ) )
MOCK_NARY_CONSTRAINT(small, 1, (tolerance), (MOCK_SMALL()))
#ifdef MOCK_SMALL_DEFINED
# pragma pop_macro( "small" )
# pragma pop_macro("small")
#endif
MOCK_NARY_CONSTRAINT( close, 2, ( expected, tolerance ),
( MOCK_PERCENT_TOLERANCE() ) )
MOCK_NARY_CONSTRAINT(close, 2, (expected, tolerance), (MOCK_PERCENT_TOLERANCE()))
MOCK_NARY_CONSTRAINT( close_fraction, 2, ( expected, tolerance ),
( MOCK_FRACTION_TOLERANCE() ) )
MOCK_NARY_CONSTRAINT(close_fraction, 2, (expected, tolerance), (MOCK_FRACTION_TOLERANCE()))
#undef MOCK_PERCENT_TOLERANCE
#undef MOCK_FRACTION_TOLERANCE
#ifdef near
# pragma push_macro( "near" )
# undef near
# define MOCK_NEAR_DEFINED
# pragma push_macro("near")
# undef near
# define MOCK_NEAR_DEFINED
#endif
MOCK_NARY_CONSTRAINT( near, 2, ( expected, tolerance ),
std::abs( actual - expected ) < tolerance )
MOCK_NARY_CONSTRAINT(near, 2, (expected, tolerance), std::abs(actual - expected) < tolerance)
#ifdef MOCK_NEAR_DEFINED
# pragma pop_macro( "near" )
# pragma pop_macro("near")
#endif
namespace detail
{
template< typename Expected >
namespace detail {
template<typename Expected>
struct equal
{
explicit equal( Expected expected )
: expected_( expected )
{}
template< typename Actual >
bool operator()( const Actual& actual,
typename boost::enable_if<
boost::has_equal_to<
Actual,
typename
boost::unwrap_reference< Expected >::type
>
>::type* = 0 ) const
explicit equal(Expected expected) : expected_(expected) {}
template<typename Actual>
bool
operator()(const Actual& actual,
typename boost::enable_if<
boost::has_equal_to<Actual, typename boost::unwrap_reference<Expected>::type>>::type* = 0) const
{
return actual == boost::unwrap_ref( expected_ );
return actual == boost::unwrap_ref(expected_);
}
template< typename Actual >
bool operator()( const Actual& actual,
typename boost::disable_if<
boost::has_equal_to<
Actual,
typename
boost::unwrap_reference< Expected >::type
>
>::type* = 0 ) const
template<typename Actual>
bool
operator()(const Actual& actual,
typename boost::disable_if<
boost::has_equal_to<Actual, typename boost::unwrap_reference<Expected>::type>>::type* = 0) const
{
return actual && *actual == boost::unwrap_ref( expected_ );
return actual && *actual == boost::unwrap_ref(expected_);
}
friend std::ostream& operator<<( std::ostream& s, const equal& e )
friend std::ostream& operator<<(std::ostream& s, const equal& e)
{
return s << "equal( " << mock::format( e.expected_ ) << " )";
return s << "equal( " << mock::format(e.expected_) << " )";
}
Expected expected_;
};
template< typename Expected >
template<typename Expected>
struct same
{
explicit same( const Expected& expected )
: expected_( detail::addressof( boost::unwrap_ref( expected ) ) )
{}
template< typename Actual >
bool operator()( const Actual& actual ) const
explicit same(const Expected& expected) : expected_(detail::addressof(boost::unwrap_ref(expected))) {}
template<typename Actual>
bool operator()(const Actual& actual) const
{
return detail::addressof( actual ) == expected_;
return detail::addressof(actual) == expected_;
}
friend std::ostream& operator<<( std::ostream& os, const same& s )
friend std::ostream& operator<<(std::ostream& os, const same& s)
{
return os << "same( " << mock::format( *s.expected_ ) << " )";
return os << "same( " << mock::format(*s.expected_) << " )";
}
const typename
boost::unwrap_reference< Expected >::type* expected_;
const typename boost::unwrap_reference<Expected>::type* expected_;
};
template< typename Expected >
template<typename Expected>
struct retrieve
{
explicit retrieve( Expected& expected )
: expected_( detail::addressof( boost::unwrap_ref( expected ) ) )
{}
template< typename Actual >
bool operator()( const Actual& actual,
typename boost::disable_if<
boost::is_convertible<
const Actual*,
typename
boost::unwrap_reference< Expected >::type
>
>::type* = 0 ) const
explicit retrieve(Expected& expected) : expected_(detail::addressof(boost::unwrap_ref(expected))) {}
template<typename Actual>
bool operator()(
const Actual& actual,
typename boost::disable_if<
boost::is_convertible<const Actual*, typename boost::unwrap_reference<Expected>::type>>::type* = 0) const
{
*expected_ = actual;
return true;
}
template< typename Actual >
bool operator()( BOOST_RV_REF(Actual) actual,
typename boost::disable_if<
boost::is_convertible<
const Actual*,
typename
boost::unwrap_reference< Expected >::type
>
>::type* = 0 ) const
template<typename Actual>
bool operator()(
BOOST_RV_REF(Actual) actual,
typename boost::disable_if<
boost::is_convertible<const Actual*, typename boost::unwrap_reference<Expected>::type>>::type* = 0) const
{
*expected_ = boost::move( actual );
*expected_ = boost::move(actual);
return true;
}
template< typename Actual >
bool operator()( Actual& actual,
typename boost::enable_if<
boost::is_convertible< Actual*,
typename
boost::unwrap_reference< Expected >::type
>
>::type* = 0 ) const
template<typename Actual>
bool
operator()(Actual& actual,
typename boost::enable_if<
boost::is_convertible<Actual*, typename boost::unwrap_reference<Expected>::type>>::type* = 0) const
{
*expected_ = detail::addressof( actual );
*expected_ = detail::addressof(actual);
return true;
}
friend std::ostream& operator<<( std::ostream& s, const retrieve& r )
friend std::ostream& operator<<(std::ostream& s, const retrieve& r)
{
return s << "retrieve( " << mock::format( *r.expected_ ) << " )";
return s << "retrieve( " << mock::format(*r.expected_) << " )";
}
typename
boost::unwrap_reference< Expected >::type* expected_;
typename boost::unwrap_reference<Expected>::type* expected_;
};
template< typename Expected >
template<typename Expected>
struct assign
{
explicit assign( const Expected& expected )
: expected_( expected )
{}
template< typename Actual >
bool operator()( Actual& actual ) const
explicit assign(const Expected& expected) : expected_(expected) {}
template<typename Actual>
bool operator()(Actual& actual) const
{
actual = boost::unwrap_ref( expected_ );
actual = boost::unwrap_ref(expected_);
return true;
}
template< typename Actual >
bool operator()( Actual* actual,
typename boost::enable_if<
boost::is_convertible<
typename
boost::unwrap_reference< Expected >::type,
Actual
>
>::type* = 0 ) const
template<typename Actual>
bool
operator()(Actual* actual,
typename boost::enable_if<
boost::is_convertible<typename boost::unwrap_reference<Expected>::type, Actual>>::type* = 0) const
{
if( ! actual )
if(!actual)
return false;
*actual = boost::unwrap_ref( expected_ );
*actual = boost::unwrap_ref(expected_);
return true;
}
friend std::ostream& operator<<( std::ostream& s, const assign& a )
friend std::ostream& operator<<(std::ostream& s, const assign& a)
{
return s << "assign( " << mock::format( a.expected_ ) << " )";
return s << "assign( " << mock::format(a.expected_) << " )";
}
Expected expected_;
};
template< typename Expected >
template<typename Expected>
struct contain
{
explicit contain( const Expected& expected )
: expected_( expected )
{}
bool operator()( const std::string& actual ) const
explicit contain(const Expected& expected) : expected_(expected) {}
bool operator()(const std::string& actual) const
{
return actual.find( boost::unwrap_ref( expected_ ) )
!= std::string::npos;
return actual.find(boost::unwrap_ref(expected_)) != std::string::npos;
}
friend std::ostream& operator<<( std::ostream& s, const contain& n )
friend std::ostream& operator<<(std::ostream& s, const contain& n)
{
return s << "contain( " << mock::format( n.expected_ ) << " )";
return s << "contain( " << mock::format(n.expected_) << " )";
}
Expected expected_;
};
} // namespace detail
template<typename T>
constraint<detail::equal<typename detail::forward_type<T>::type>> equal(BOOST_FWD_REF(T) t)
{
return detail::equal<typename detail::forward_type<T>::type>(boost::forward<T>(t));
}
template< typename T >
constraint< detail::equal< typename detail::forward_type< T >::type > > equal( BOOST_FWD_REF(T) t )
{
return detail::equal< typename detail::forward_type< T >::type >( boost::forward< T >( t ) );
}
template<typename T>
constraint<detail::same<T>> same(T& t)
{
return detail::same<T>(t);
}
template<typename T>
constraint<detail::retrieve<T>> retrieve(T& t)
{
return detail::retrieve<T>(t);
}
template<typename T>
constraint<detail::assign<T>> assign(T t)
{
return detail::assign<T>(t);
}
template<typename T>
constraint<detail::contain<T>> contain(T t)
{
return detail::contain<T>(t);
}
template< typename T >
constraint< detail::same< T > > same( T& t )
{
return detail::same< T >( t );
}
template< typename T >
constraint< detail::retrieve< T > > retrieve( T& t )
{
return detail::retrieve< T >( t );
}
template< typename T >
constraint< detail::assign< T > > assign( T t )
{
return detail::assign< T >( t );
}
template< typename T >
constraint< detail::contain< T > > contain( T t )
{
return detail::contain< T >( t );
}
template< typename T >
constraint< T > call( T t )
{
return constraint< T >( t );
}
} // mock
template<typename T>
constraint<T> call(T t)
{
return constraint<T>(t);
}
} // namespace mock
#endif // MOCK_CONSTRAINTS_HPP_INCLUDED

206
include/turtle/detail/action.hpp
View file

@ -10,77 +10,62 @@
#define MOCK_ACTION_HPP_INCLUDED
#include "../config.hpp"
#include <boost/type_traits/remove_reference.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/move/move.hpp>
#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <boost/function.hpp>
#include <boost/move/move.hpp>
#include <boost/noncopyable.hpp>
#include <boost/ref.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_reference.hpp>
namespace mock
{
namespace detail
{
template< typename Result, typename Signature >
namespace mock { namespace detail {
template<typename Result, typename Signature>
class action_base
{
private:
#ifdef MOCK_HDR_FUNCTIONAL
typedef std::function< Signature > functor_type;
typedef std::function< Result() > action_type;
typedef std::function<Signature> functor_type;
typedef std::function<Result()> action_type;
#else
typedef boost::function< Signature > functor_type;
typedef boost::function< Result() > action_type;
typedef boost::function<Signature> functor_type;
typedef boost::function<Result()> action_type;
#endif
public:
const functor_type& functor() const
{
return f_;
}
bool valid() const
{
return f_ || a_;
}
Result trigger() const
{
return a_();
}
const functor_type& functor() const { return f_; }
bool valid() const { return f_ || a_; }
Result trigger() const { return a_(); }
void calls( const functor_type& f )
void calls(const functor_type& f)
{
if( ! f )
throw std::invalid_argument( "null functor" );
if(!f)
throw std::invalid_argument("null functor");
f_ = f;
}
template< typename Exception >
void throws( Exception e )
template<typename Exception>
void throws(Exception e)
{
a_ = boost::bind( &do_throw< Exception >, e );
a_ = boost::bind(&do_throw<Exception>, e);
}
protected:
void set( const action_type& a )
void set(const action_type& a) { a_ = a; }
template<typename Y>
void set(const boost::reference_wrapper<Y>& r)
{
a_ = a;
}
template< typename Y >
void set( const boost::reference_wrapper< Y >& r )
{
a_ = boost::bind( &do_ref< Y >, r.get_pointer() );
a_ = boost::bind(&do_ref<Y>, r.get_pointer());
}
private:
template< typename T >
static T& do_ref( T* t )
template<typename T>
static T& do_ref(T* t)
{
return *t;
}
template< typename T >
static Result do_throw( T t )
template<typename T>
static Result do_throw(T t)
{
throw t;
}
@ -89,138 +74,117 @@ namespace detail
action_type a_;
};
template< typename Result, typename Signature >
class action : public action_base< Result, Signature >
template<typename Result, typename Signature>
class action : public action_base<Result, Signature>
{
public:
template< typename Value >
void returns( const Value& v )
template<typename Value>
void returns(const Value& v)
{
this->set( boost::ref( store( v ) ) );
this->set(boost::ref(store(v)));
}
template< typename Y >
void returns( const boost::reference_wrapper< Y >& r )
template<typename Y>
void returns(const boost::reference_wrapper<Y>& r)
{
this->set( r );
this->set(r);
}
template< typename Value >
void moves( BOOST_RV_REF(Value) v )
template<typename Value>
void moves(BOOST_RV_REF(Value) v)
{
this->set(
boost::bind(
&move< typename boost::remove_reference< Value >::type >,
boost::ref( store( boost::move( v ) ) ) ) );
boost::bind(&move<typename boost::remove_reference<Value>::type>, boost::ref(store(boost::move(v)))));
}
private:
template< typename Value >
static BOOST_RV_REF(Value) move( Value& t )
template<typename Value>
static BOOST_RV_REF(Value) move(Value& t)
{
return boost::move( t );
return boost::move(t);
}
struct value : boost::noncopyable
{
virtual ~value()
{}
virtual ~value() {}
};
template< typename T >
template<typename T>
struct value_imp : value
{
typedef
typename boost::remove_const<
typename boost::remove_reference<
T
>::type
>::type value_type;
typedef typename boost::remove_const<typename boost::remove_reference<T>::type>::type value_type;
value_imp( BOOST_RV_REF(value_type) t )
: t_( boost::move( t ) )
{}
value_imp( const value_type& t )
: t_( t )
{}
template< typename Y >
value_imp( Y* y )
: t_( y )
value_imp(BOOST_RV_REF(value_type) t) : t_(boost::move(t)) {}
value_imp(const value_type& t) : t_(t) {}
template<typename Y>
value_imp(Y* y) : t_(y)
{}
value_type t_;
};
template< typename T >
T& store( BOOST_RV_REF(T) t )
template<typename T>
T& store(BOOST_RV_REF(T) t)
{
v_.reset( new value_imp< T >( boost::move( t ) ) );
return static_cast< value_imp< T >& >( *v_ ).t_;
v_.reset(new value_imp<T>(boost::move(t)));
return static_cast<value_imp<T>&>(*v_).t_;
}
template< typename T >
T& store( const T& t )
template<typename T>
T& store(const T& t)
{
v_.reset( new value_imp< T >( t ) );
return static_cast< value_imp< T >& >( *v_ ).t_;
v_.reset(new value_imp<T>(t));
return static_cast<value_imp<T>&>(*v_).t_;
}
template< typename T >
typename boost::remove_reference< Result >::type& store( T* t )
template<typename T>
typename boost::remove_reference<Result>::type& store(T* t)
{
v_.reset( new value_imp< Result >( t ) );
return static_cast< value_imp< Result >& >( *v_ ).t_;
v_.reset(new value_imp<Result>(t));
return static_cast<value_imp<Result>&>(*v_).t_;
}
boost::shared_ptr< value > v_;
boost::shared_ptr<value> v_;
};
template< typename Signature >
class action< void, Signature > : public action_base< void, Signature >
template<typename Signature>
class action<void, Signature> : public action_base<void, Signature>
{
public:
action()
{
this->set( boost::bind( &do_nothing ) );
}
action() { this->set(boost::bind(&do_nothing)); }
private:
static void do_nothing()
{}
static void do_nothing() {}
};
#ifdef MOCK_AUTO_PTR
template< typename Result, typename Signature >
class action< std::auto_ptr< Result >, Signature >
: public action_base< std::auto_ptr< Result >, Signature >
template<typename Result, typename Signature>
class action<std::auto_ptr<Result>, Signature> : public action_base<std::auto_ptr<Result>, Signature>
{
public:
action()
{}
action( const action& rhs )
: v_( rhs.v_.release() )
action() {}
action(const action& rhs) : v_(rhs.v_.release())
{
if( v_.get() )
returns( boost::ref( v_ ) );
if(v_.get())
returns(boost::ref(v_));
}
template< typename Y >
void returns( Y* r )
template<typename Y>
void returns(Y* r)
{
v_.reset( r );
this->set( boost::ref( v_ ) );
v_.reset(r);
this->set(boost::ref(v_));
}
template< typename Y >
void returns( std::auto_ptr< Y > r )
template<typename Y>
void returns(std::auto_ptr<Y> r)
{
v_ = r;
this->set( boost::ref( v_ ) );
this->set(boost::ref(v_));
}
template< typename Y >
void returns( const boost::reference_wrapper< Y >& r )
template<typename Y>
void returns(const boost::reference_wrapper<Y>& r)
{
this->set( r );
this->set(r);
}
private:
mutable std::auto_ptr< Result > v_;
mutable std::auto_ptr<Result> v_;
};
#endif // MOCK_AUTO_PTR
}
} // mock
}} // namespace mock::detail
#endif // MOCK_ACTION_HPP_INCLUDED

18
include/turtle/detail/addressof.hpp
View file

@ -12,25 +12,15 @@
#include "../config.hpp"
#include <boost/utility/addressof.hpp>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
using boost::addressof;
#ifdef MOCK_NULLPTR
inline const std::nullptr_t* addressof( const std::nullptr_t& p )
{
return &p;
}
inline std::nullptr_t* addressof( std::nullptr_t& p )
{
return &p;
}
inline const std::nullptr_t* addressof(const std::nullptr_t& p) { return &p; }
inline std::nullptr_t* addressof(std::nullptr_t& p) { return &p; }
#endif
}
} // mock
}} // namespace mock::detail
#endif // MOCK_ADDRESSOF_HPP_INCLUDED

31
include/turtle/detail/child.hpp
View file

@ -10,43 +10,36 @@
#define MOCK_CHILD_HPP_INCLUDED
#include "../config.hpp"
#include "type_name.hpp"
#include "parent.hpp"
#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
#include "type_name.hpp"
#include <boost/optional.hpp>
#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
#include <ostream>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
class child
{
public:
child()
: parent_( 0 )
{}
void update( parent& p,
boost::unit_test::const_string instance,
boost::optional< type_name > type,
boost::unit_test::const_string name )
child() : parent_(0) {}
void update(parent& p, boost::unit_test::const_string instance, boost::optional<type_name> type,
boost::unit_test::const_string name)
{
if( instance != "?." || name_.empty() )
p = parent( instance, type );
if(instance != "?." || name_.empty())
p = parent(instance, type);
parent_ = &p;
name_ = name;
}
friend std::ostream& operator<<( std::ostream& s, const child& c )
friend std::ostream& operator<<(std::ostream& s, const child& c)
{
if( c.parent_ )
if(c.parent_)
s << *c.parent_;
return s << c.name_;
}
private:
const parent* parent_;
boost::unit_test::const_string name_;
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_CHILD_HPP_INCLUDED

21
include/turtle/detail/context.hpp
View file

@ -16,10 +16,7 @@
#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
#include <ostream>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
class verifiable;
class context : boost::noncopyable
@ -28,17 +25,13 @@ namespace detail
context() {}
virtual ~context() {}
virtual void add( const void* p, verifiable& v,
boost::unit_test::const_string instance,
boost::optional< type_name > type,
boost::unit_test::const_string name ) = 0;
virtual void add( verifiable& v ) = 0;
virtual void remove( verifiable& v ) = 0;
virtual void add(const void* p, verifiable& v, boost::unit_test::const_string instance,
boost::optional<type_name> type, boost::unit_test::const_string name) = 0;
virtual void add(verifiable& v) = 0;
virtual void remove(verifiable& v) = 0;
virtual void serialize( std::ostream& s,
const verifiable& v ) const = 0;
virtual void serialize(std::ostream& s, const verifiable& v) const = 0;
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_CONTEXT_HPP_INCLUDED

246
include/turtle/detail/expectation_template.hpp
View file

@ -8,115 +8,84 @@
#include "matcher_base_template.hpp"
#define MOCK_EXPECTATION_INITIALIZE(z, n, d) \
BOOST_PP_COMMA_IF(n) c##n##_( c##n )
#define MOCK_EXPECTATION_INITIALIZE(z, n, d) BOOST_PP_COMMA_IF(n) c##n##_(c##n)
#define MOCK_EXPECTATION_MEMBER(z, n, d) \
matcher< T##n, Constraint_##n > c##n##_;
#define MOCK_EXPECTATION_MEMBER(z, n, d) matcher<T##n, Constraint_##n> c##n##_;
#define MOCK_EXPECTATION_IS_VALID(z, n, d) \
BOOST_PP_IF(n, &&,) c##n##_( mock::detail::move_if_not_lvalue_reference< T##n >( a##n ) )
BOOST_PP_IF(n, &&, ) c##n##_(mock::detail::move_if_not_lvalue_reference<T##n>(a##n))
#define MOCK_EXPECTATION_SERIALIZE(z, n, d) \
BOOST_PP_IF(n, << ", " <<,) c##n##_
#define MOCK_EXPECTATION_SERIALIZE(z, n, d) BOOST_PP_IF(n, << ", " <<, ) c##n##_
#define MOCK_EXPECTATION_SERIALIZE_ANY(z, n, d) \
BOOST_PP_IF(n, << ", " <<,) "any"
#define MOCK_EXPECTATION_SERIALIZE_ANY(z, n, d) BOOST_PP_IF(n, << ", " <<, ) "any"
#define MOCK_EXPECTATION_PARAM(z, n, Args) \
mock::detail::move_if_not_lvalue_reference< T##n >( a##n )
#define MOCK_EXPECTATION_PARAM(z, n, Args) mock::detail::move_if_not_lvalue_reference<T##n>(a##n)
#define MOCK_REF_ARG(z, n, d) \
typename ref_arg< T##n >::type a##n
#define MOCK_REF_ARG(z, n, d) typename ref_arg<T##n>::type a##n
#define MOCK_REF_ARG_T(z, n, d) \
typename ref_arg< T##n >::type
#define MOCK_REF_ARG_T(z, n, d) typename ref_arg<T##n>::type
namespace mock
{
namespace detail
{
template< typename Signature > class default_matcher;
namespace mock { namespace detail {
template<typename Signature>
class default_matcher;
template<
BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename T) >
class default_matcher< void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) >
: public matcher_base< void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) >
template<BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename T)>
class default_matcher<void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))> :
public matcher_base<void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))>
{
private:
virtual bool operator()(
BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG_T, _) )
virtual bool operator()(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG_T, _)) { return true; }
virtual void serialize(std::ostream& s) const
{
return true;
}
virtual void serialize( std::ostream& s ) const
{
s << "" BOOST_PP_REPEAT(MOCK_NUM_ARGS,
MOCK_EXPECTATION_SERIALIZE_ANY, _);
s << "" BOOST_PP_REPEAT(MOCK_NUM_ARGS, MOCK_EXPECTATION_SERIALIZE_ANY, _);
}
};
#ifndef MOCK_NUM_ARGS_0
template< typename Constraint, typename Signature > class single_matcher;
template<typename Constraint, typename Signature>
class single_matcher;
template<
BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename Constraint_),
BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename T)
>
class single_matcher<
void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, Constraint_) ),
void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) )
>
: public matcher_base< void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) >
template<BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename Constraint_), BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename T)>
class single_matcher<void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, Constraint_)),
void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))> :
public matcher_base<void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))>
{
public:
single_matcher(
BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, Constraint_, c) )
: BOOST_PP_REPEAT(MOCK_NUM_ARGS,
MOCK_EXPECTATION_INITIALIZE, _)
single_matcher(BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, Constraint_, c))
: BOOST_PP_REPEAT(MOCK_NUM_ARGS, MOCK_EXPECTATION_INITIALIZE, _)
{}
private:
virtual bool operator()(
BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG, _) )
virtual bool operator()(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG, _))
{
return BOOST_PP_REPEAT(MOCK_NUM_ARGS,
MOCK_EXPECTATION_IS_VALID, _);
return BOOST_PP_REPEAT(MOCK_NUM_ARGS, MOCK_EXPECTATION_IS_VALID, _);
}
virtual void serialize( std::ostream& s ) const
virtual void serialize(std::ostream& s) const
{
s << BOOST_PP_REPEAT(MOCK_NUM_ARGS,
MOCK_EXPECTATION_SERIALIZE, _);
s << BOOST_PP_REPEAT(MOCK_NUM_ARGS, MOCK_EXPECTATION_SERIALIZE, _);
}
private:
BOOST_PP_REPEAT(
MOCK_NUM_ARGS, MOCK_EXPECTATION_MEMBER, _)
};
BOOST_PP_REPEAT(MOCK_NUM_ARGS, MOCK_EXPECTATION_MEMBER, _)
};
template< typename F, typename Signature > class multi_matcher;
template<typename F, typename Signature>
class multi_matcher;
template< typename F,
BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename T) >
class multi_matcher< F, void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) >
: public matcher_base< void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) >
template<typename F, BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename T)>
class multi_matcher<F, void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))> :
public matcher_base<void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))>
{
public:
multi_matcher( const F& f )
: f_( f )
{}
multi_matcher(const F& f) : f_(f) {}
private:
virtual bool operator()(
BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG, _) )
virtual bool operator()(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG, _))
{
return f_( BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_EXPECTATION_PARAM, _) );
}
virtual void serialize( std::ostream& s ) const
{
s << mock::format( f_ );
return f_(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_EXPECTATION_PARAM, _));
}
virtual void serialize(std::ostream& s) const { s << mock::format(f_); }
private:
F f_;
@ -124,146 +93,99 @@ namespace detail
#endif
template< typename Signature > class expectation;
template<typename Signature>
class expectation;
template< typename R
BOOST_PP_ENUM_TRAILING_PARAMS(MOCK_NUM_ARGS, typename T) >
class expectation< R (BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS,T)) >
: public action< R, R (BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS,T)) >
template<typename R BOOST_PP_ENUM_TRAILING_PARAMS(MOCK_NUM_ARGS, typename T)>
class expectation<R(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))> :
public action<R, R(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))>
{
public:
expectation()
: invocation_( boost::make_shared< unlimited >() )
, matcher_(
boost::make_shared<
default_matcher<
void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) )
>
> () )
, file_( "unknown location" )
, line_( 0 )
: invocation_(boost::make_shared<unlimited>()),
matcher_(boost::make_shared<default_matcher<void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))>>()),
file_("unknown location"), line_(0)
{}
expectation( const char* file, int line )
: invocation_( boost::make_shared< unlimited >() )
, matcher_(
boost::make_shared<
default_matcher<
void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) )
>
> () )
, file_( file )
, line_( line )
expectation(const char* file, int line)
: invocation_(boost::make_shared<unlimited>()),
matcher_(boost::make_shared<default_matcher<void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))>>()),
file_(file), line_(line)
{}
~expectation()
{
for( sequences_cit it = sequences_.begin();
it != sequences_.end(); ++it )
(*it)->remove( this );
for(sequences_cit it = sequences_.begin(); it != sequences_.end(); ++it)
(*it)->remove(this);
}
void invoke( const boost::shared_ptr< invocation >& i )
{
invocation_ = i;
}
void invoke(const boost::shared_ptr<invocation>& i) { invocation_ = i; }
#ifndef MOCK_NUM_ARGS_0
template<
BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename Constraint_)
>
expectation& with(
BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, Constraint_, c) )
template<BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename Constraint_)>
expectation& with(BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, Constraint_, c))
{
matcher_.reset(
new single_matcher<
void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, Constraint_) ),
void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) )
>( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, c) ) );
new single_matcher<void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, Constraint_)),
void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))>(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, c)));
return *this;
}
#if MOCK_NUM_ARGS > 1
template< typename Constraint >
expectation& with( const Constraint& c )
# if MOCK_NUM_ARGS > 1
template<typename Constraint>
expectation& with(const Constraint& c)
{
matcher_.reset(
new multi_matcher<
Constraint,
void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) )
>( c ) );
matcher_.reset(new multi_matcher<Constraint, void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))>(c));
return *this;
}
#endif
# endif
#endif
void add( sequence& s )
void add(sequence& s)
{
s.impl_->add( this );
sequences_.push_back( s.impl_ );
s.impl_->add(this);
sequences_.push_back(s.impl_);
}
bool verify() const
{
return invocation_->verify();
}
bool verify() const { return invocation_->verify(); }
bool is_valid(
BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG, _) ) const
bool is_valid(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG, _)) const
{
return !invocation_->exhausted()
&& (*matcher_)( BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_EXPECTATION_PARAM, _) );
return !invocation_->exhausted() && (*matcher_)(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_EXPECTATION_PARAM, _));
}
bool invoke() const
{
for( sequences_cit it = sequences_.begin();
it != sequences_.end(); ++it )
if( ! (*it)->is_valid( this ) )
for(sequences_cit it = sequences_.begin(); it != sequences_.end(); ++it)
if(!(*it)->is_valid(this))
return false;
bool result = invocation_->invoke();
for( sequences_cit it = sequences_.begin();
it != sequences_.end(); ++it )
(*it)->invalidate( this );
for(sequences_cit it = sequences_.begin(); it != sequences_.end(); ++it)
(*it)->invalidate(this);
return result;
}
const char* file() const
{
return file_;
}
int line() const
{
return line_;
}
const char* file() const { return file_; }
int line() const { return line_; }
friend std::ostream& operator<<(
std::ostream& s, const expectation& e )
friend std::ostream& operator<<(std::ostream& s, const expectation& e)
{
return s << ( e.invocation_->exhausted() ? 'v' : '.' )
<< ' ' << *e.invocation_
return s << (e.invocation_->exhausted() ? 'v' : '.') << ' ' << *e.invocation_
#ifndef MOCK_NUM_ARGS_0
<< ".with( " << *e.matcher_ << " )"
<< ".with( " << *e.matcher_ << " )"
#endif
;
;
}
private:
typedef std::vector<
boost::shared_ptr< sequence_impl >
> sequences_type;
typedef std::vector<boost::shared_ptr<sequence_impl>> sequences_type;
typedef sequences_type::const_iterator sequences_cit;
boost::shared_ptr< invocation > invocation_;
boost::shared_ptr<
matcher_base<
void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) )
>
> matcher_;
boost::shared_ptr<invocation> invocation_;
boost::shared_ptr<matcher_base<void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))>> matcher_;
sequences_type sequences_;
const char* file_;
int line_;
};
}
} // mock
}} // namespace mock::detail
#undef MOCK_EXPECTATION_INITIALIZE
#undef MOCK_EXPECTATION_MEMBER

33
include/turtle/detail/formatter.hpp
View file

@ -13,38 +13,29 @@
#include "../stream.hpp"
#include "addressof.hpp"
namespace mock
{
namespace detail
{
template< typename T >
namespace mock { namespace detail {
template<typename T>
struct formatter
{
explicit formatter( const T& t )
: t_( detail::addressof( t ) )
{}
void serialize( stream& s ) const
{
detail::serialize( s, *t_ );
}
explicit formatter(const T& t) : t_(detail::addressof(t)) {}
void serialize(stream& s) const { detail::serialize(s, *t_); }
const T* t_;
};
template< typename T >
stream& operator<<( stream& s, const formatter< T >& f )
template<typename T>
stream& operator<<(stream& s, const formatter<T>& f)
{
f.serialize( s );
f.serialize(s);
return s;
}
template< typename T >
std::ostream& operator<<( std::ostream& s, const formatter< T >& f )
template<typename T>
std::ostream& operator<<(std::ostream& s, const formatter<T>& f)
{
stream ss( s );
f.serialize( ss );
stream ss(s);
f.serialize(ss);
return s;
}
}
} // mock
}} // namespace mock::detail
#endif // MOCK_FORMATTER_HPP_INCLUDED

81
include/turtle/detail/function.hpp
View file

@ -10,79 +10,67 @@
#define MOCK_FUNCTION_HPP_INCLUDED
#include "../config.hpp"
#include "../constraints.hpp"
#include "../error.hpp"
#include "../log.hpp"
#include "../constraints.hpp"
#include "../sequence.hpp"
#include "../matcher.hpp"
#include "../sequence.hpp"
#include "action.hpp"
#include "verifiable.hpp"
#include "invocation.hpp"
#include "type_name.hpp"
#include "context.hpp"
#include "mutex.hpp"
#include "invocation.hpp"
#include "move_helper.hpp"
#include <boost/preprocessor/iteration/iterate.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include "mutex.hpp"
#include "type_name.hpp"
#include "verifiable.hpp"
#include <boost/call_traits.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/make_shared.hpp>
#include <boost/move/move.hpp>
#include <boost/noncopyable.hpp>
#include <boost/optional.hpp>
#include <boost/preprocessor/comparison/equal.hpp>
#include <boost/preprocessor/comparison/greater.hpp>
#include <boost/preprocessor/iteration/iterate.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
#include <boost/test/utils/lazy_ostream.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/call_traits.hpp>
#include <boost/make_shared.hpp>
#include <boost/noncopyable.hpp>
#include <boost/move/move.hpp>
#include <boost/optional.hpp>
#include <list>
#include <ostream>
#include <vector>
#include <list>
namespace mock
{
namespace detail
{
template< typename R, typename E >
namespace mock { namespace detail {
template<typename R, typename E>
struct wrapper_base
{
wrapper_base( E& e )
: e_( &e )
{}
wrapper_base(E& e) : e_(&e) {}
template< typename T >
void returns( T t )
template<typename T>
void returns(T t)
{
e_->returns( t );
e_->returns(t);
}
E* e_;
};
template< typename E >
struct wrapper_base< void, E >
template<typename E>
struct wrapper_base<void, E>
{
wrapper_base( E& e )
: e_( &e )
{}
wrapper_base(E& e) : e_(&e) {}
E* e_;
};
template< typename R, typename E >
struct wrapper_base< R*, E >
template<typename R, typename E>
struct wrapper_base<R*, E>
{
wrapper_base( E& e )
: e_( &e )
{}
wrapper_base(E& e) : e_(&e) {}
void returns( R* r )
void returns(R* r) { e_->returns(r); }
template<typename Y>
void returns(const boost::reference_wrapper<Y>& r)
{
e_->returns( r );
}
template< typename Y >
void returns( const boost::reference_wrapper< Y >& r )
{
e_->returns( r );
e_->returns(r);
}
E* e_;
@ -97,8 +85,7 @@ namespace detail
return std::uncaught_exception() ? 1 : 0;
#endif
}
}
} // mock
}} // namespace mock::detail
#define MOCK_NUM_ARGS 0
#define MOCK_NUM_ARGS_0

283
include/turtle/detail/function_impl_template.hpp
View file

@ -9,200 +9,163 @@
#include "expectation_template.hpp"
#ifndef MOCK_ERROR_POLICY
# error no error policy has been set
# error no error policy has been set
#endif
#define MOCK_FUNCTION_FORMAT(z, n, N) \
<< ' ' << mock::format( t##n ) \
<< BOOST_PP_IF(BOOST_PP_EQUAL(N,n), ' ', ',')
#define MOCK_FUNCTION_FORMAT(z, n, N) << ' ' << mock::format(t##n) << BOOST_PP_IF(BOOST_PP_EQUAL(N, n), ' ', ',')
#define MOCK_FUNCTION_CONTEXT \
boost::unit_test::lazy_ostream::instance() \
<< lazy_context( this ) \
<< '(' BOOST_PP_REPEAT(MOCK_NUM_ARGS, MOCK_FUNCTION_FORMAT, \
BOOST_PP_DEC(MOCK_NUM_ARGS)) \
<< ')' \
<< lazy_expectations( this )
#define MOCK_FUNCTION_CONTEXT \
boost::unit_test::lazy_ostream::instance() \
<< lazy_context(this) << '(' BOOST_PP_REPEAT(MOCK_NUM_ARGS, MOCK_FUNCTION_FORMAT, BOOST_PP_DEC(MOCK_NUM_ARGS)) \
<< ')' << lazy_expectations(this)
#define MOCK_MOVE(z, n, d) \
mock::detail::move_if_not_lvalue_reference< T##n >( t##n )
#define MOCK_MOVE(z, n, d) mock::detail::move_if_not_lvalue_reference<T##n>(t##n)
namespace mock
{
namespace detail
{
template< typename Signature > class function_impl;
namespace mock { namespace detail {
template<typename Signature>
class function_impl;
template< typename R
BOOST_PP_ENUM_TRAILING_PARAMS(MOCK_NUM_ARGS, typename T) >
class function_impl< R ( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) >
: public verifiable, public boost::enable_shared_from_this<
function_impl< R ( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) )> >
template<typename R BOOST_PP_ENUM_TRAILING_PARAMS(MOCK_NUM_ARGS, typename T)>
class function_impl<R(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))> :
public verifiable,
public boost::enable_shared_from_this<function_impl<R(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))>>
{
public:
typedef safe_error< R, MOCK_ERROR_POLICY< R > > error_type;
typedef safe_error<R, MOCK_ERROR_POLICY<R>> error_type;
public:
function_impl()
: context_( 0 )
, valid_( true )
, exceptions_( exceptions() )
, mutex_( boost::make_shared< mutex >() )
{}
function_impl() : context_(0), valid_(true), exceptions_(exceptions()), mutex_(boost::make_shared<mutex>()) {}
virtual ~function_impl()
{
if( valid_ && exceptions_ >= exceptions() )
for( expectations_cit it = expectations_.begin();
it != expectations_.end(); ++it )
if( ! it->verify() )
error_type::fail( "untriggered expectation",
boost::unit_test::lazy_ostream::instance()
<< lazy_context( this )
<< lazy_expectations( this ),
it->file(), it->line() );
if( context_ )
context_->remove( *this );
if(valid_ && exceptions_ >= exceptions())
for(expectations_cit it = expectations_.begin(); it != expectations_.end(); ++it)
if(!it->verify())
error_type::fail("untriggered expectation",
boost::unit_test::lazy_ostream::instance()
<< lazy_context(this) << lazy_expectations(this),
it->file(), it->line());
if(context_)
context_->remove(*this);
}
virtual bool verify() const
{
lock _( mutex_ );
for( expectations_cit it = expectations_.begin();
it != expectations_.end(); ++it )
if( ! it->verify() )
lock _(mutex_);
for(expectations_cit it = expectations_.begin(); it != expectations_.end(); ++it)
if(!it->verify())
{
valid_ = false;
error_type::fail( "verification failed",
boost::unit_test::lazy_ostream::instance()
<< lazy_context( this )
<< lazy_expectations( this ),
it->file(), it->line() );
error_type::fail("verification failed",
boost::unit_test::lazy_ostream::instance()
<< lazy_context(this) << lazy_expectations(this),
it->file(), it->line());
}
return valid_;
}
virtual void reset()
{
lock _( mutex_ );
lock _(mutex_);
valid_ = true;
boost::shared_ptr< function_impl > guard =
this->shared_from_this();
boost::shared_ptr<function_impl> guard = this->shared_from_this();
expectations_.clear();
}
private:
typedef expectation<
R( BOOST_PP_ENUM_PARAMS( MOCK_NUM_ARGS, T ) )
> expectation_type;
typedef expectation<R(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))> expectation_type;
class wrapper : public wrapper_base< R, expectation_type >
class wrapper : public wrapper_base<R, expectation_type>
{
private:
typedef wrapper_base< R, expectation_type > base_type;
typedef wrapper_base<R, expectation_type> base_type;
BOOST_MOVABLE_BUT_NOT_COPYABLE(wrapper)
public:
wrapper( const boost::shared_ptr< mutex >& m, expectation_type& e )
: base_type( e )
, lock_( m )
{}
wrapper( BOOST_RV_REF( wrapper ) x )
: base_type( x )
, lock_( boost::move( x.lock_) )
{}
wrapper& operator=( BOOST_RV_REF( wrapper ) x )
wrapper(const boost::shared_ptr<mutex>& m, expectation_type& e) : base_type(e), lock_(m) {}
wrapper(BOOST_RV_REF(wrapper) x) : base_type(x), lock_(boost::move(x.lock_)) {}
wrapper& operator=(BOOST_RV_REF(wrapper) x)
{
static_cast< base_type& >( *this ) = x;
lock_ = boost::move( x.lock_ );
static_cast<base_type&>(*this) = x;
lock_ = boost::move(x.lock_);
return *this;
}
wrapper& once()
{
this->e_->invoke( boost::make_shared< detail::once >() );
this->e_->invoke(boost::make_shared<detail::once>());
return *this;
}
wrapper& never()
{
this->e_->invoke( boost::make_shared< detail::never >() );
this->e_->invoke(boost::make_shared<detail::never>());
return *this;
}
wrapper& exactly( std::size_t count )
wrapper& exactly(std::size_t count)
{
this->e_->invoke(
boost::make_shared< detail::exactly >( count ) );
this->e_->invoke(boost::make_shared<detail::exactly>(count));
return *this;
}
wrapper& at_least( std::size_t min )
wrapper& at_least(std::size_t min)
{
this->e_->invoke(
boost::make_shared< detail::at_least >( min ) );
this->e_->invoke(boost::make_shared<detail::at_least>(min));
return *this;
}
wrapper& at_most( std::size_t max )
wrapper& at_most(std::size_t max)
{
this->e_->invoke(
boost::make_shared< detail::at_most >( max ) );
this->e_->invoke(boost::make_shared<detail::at_most>(max));
return *this;
}
wrapper& between( std::size_t min, std::size_t max )
wrapper& between(std::size_t min, std::size_t max)
{
this->e_->invoke(
boost::make_shared< detail::between >( min, max ) );
this->e_->invoke(boost::make_shared<detail::between>(min, max));
return *this;
}
#ifndef MOCK_NUM_ARGS_0
template<
BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename Constraint_)
>
wrapper& with(
BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, Constraint_, c) )
template<BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename Constraint_)>
wrapper& with(BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, Constraint_, c))
{
this->e_->with(
BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, c) );
this->e_->with(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, c));
return *this;
}
#if MOCK_NUM_ARGS > 1
template< typename Constraint >
wrapper& with( const Constraint& c )
# if MOCK_NUM_ARGS > 1
template<typename Constraint>
wrapper& with(const Constraint& c)
{
this->e_->with( c );
this->e_->with(c);
return *this;
}
#endif
# endif
#endif
#define MOCK_FUNCTION_IN_ADD(z, n, d) \
this->e_->add( s##n );
#define MOCK_FUNCTION_IN_ADD(z, n, d) this->e_->add(s##n);
#define MOCK_FUNCTION_IN(z, n, d) \
wrapper& in( BOOST_PP_ENUM_PARAMS(n, sequence& s) ) \
{ \
BOOST_PP_REPEAT(n, MOCK_FUNCTION_IN_ADD, _) \
return *this; \
#define MOCK_FUNCTION_IN(z, n, d) \
wrapper& in(BOOST_PP_ENUM_PARAMS(n, sequence& s)) \
{ \
BOOST_PP_REPEAT(n, MOCK_FUNCTION_IN_ADD, _) \
return *this; \
}
BOOST_PP_REPEAT(MOCK_MAX_SEQUENCES,
MOCK_FUNCTION_IN, _)
BOOST_PP_REPEAT(MOCK_MAX_SEQUENCES, MOCK_FUNCTION_IN, _)
#undef MOCK_FUNCTION_IN
#undef MOCK_FUNCTION_IN_ADD
template< typename TT >
void calls( TT t )
template<typename TT>
void calls(TT t)
{
this->e_->calls( t );
this->e_->calls(t);
}
template< typename TT >
void throws( TT t )
template<typename TT>
void throws(TT t)
{
this->e_->throws( t );
this->e_->throws(t);
}
template< typename TT >
void moves( BOOST_RV_REF(TT) t )
template<typename TT>
void moves(BOOST_RV_REF(TT) t)
{
this->e_->moves( boost::move( t ) );
this->e_->moves(boost::move(t));
}
lock lock_;
@ -211,84 +174,71 @@ namespace detail
public:
typedef wrapper wrapper_type;
wrapper expect( const char* file, int line )
wrapper expect(const char* file, int line)
{
lock _( mutex_ );
expectations_.push_back( expectation_type( file, line ) );
lock _(mutex_);
expectations_.push_back(expectation_type(file, line));
valid_ = true;
return wrapper( mutex_, expectations_.back() );
return wrapper(mutex_, expectations_.back());
}
wrapper expect()
{
lock _( mutex_ );
expectations_.push_back( expectation_type() );
lock _(mutex_);
expectations_.push_back(expectation_type());
valid_ = true;
return wrapper( mutex_, expectations_.back() );
return wrapper(mutex_, expectations_.back());
}
R operator()(
BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, T, t) ) const
R operator()(BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, T, t)) const
{
lock _( mutex_ );
lock _(mutex_);
valid_ = false;
for( expectations_cit it = expectations_.begin();
it != expectations_.end(); ++it )
if( it->is_valid(
BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_MOVE, _) ) )
for(expectations_cit it = expectations_.begin(); it != expectations_.end(); ++it)
if(it->is_valid(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_MOVE, _)))
{
if( ! it->invoke() )
if(!it->invoke())
{
error_type::fail( "sequence failed",
MOCK_FUNCTION_CONTEXT, it->file(), it->line() );
error_type::fail("sequence failed", MOCK_FUNCTION_CONTEXT, it->file(), it->line());
return error_type::abort();
}
if( ! it->valid() )
if(!it->valid())
{
error_type::fail( "missing action",
MOCK_FUNCTION_CONTEXT, it->file(), it->line() );
error_type::fail("missing action", MOCK_FUNCTION_CONTEXT, it->file(), it->line());
return error_type::abort();
}
valid_ = true;
error_type::call(
MOCK_FUNCTION_CONTEXT, it->file(), it->line() );
if( it->functor() )
return it->functor()(
BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_MOVE, _) );
error_type::call(MOCK_FUNCTION_CONTEXT, it->file(), it->line());
if(it->functor())
return it->functor()(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_MOVE, _));
return it->trigger();
}
error_type::fail( "unexpected call", MOCK_FUNCTION_CONTEXT );
error_type::fail("unexpected call", MOCK_FUNCTION_CONTEXT);
return error_type::abort();
}
void add( context& c, const void* p,
boost::unit_test::const_string instance,
boost::optional< type_name > type,
boost::unit_test::const_string name )
void add(context& c, const void* p, boost::unit_test::const_string instance, boost::optional<type_name> type,
boost::unit_test::const_string name)
{
lock _( mutex_ );
if( ! context_ )
c.add( *this );
c.add( p, *this, instance, type, name );
lock _(mutex_);
if(!context_)
c.add(*this);
c.add(p, *this, instance, type, name);
context_ = &c;
}
friend std::ostream& operator<<(
std::ostream& s, const function_impl& impl )
friend std::ostream& operator<<(std::ostream& s, const function_impl& impl)
{
lock _( impl.mutex_ );
return s << lazy_context( &impl ) << lazy_expectations( &impl );
lock _(impl.mutex_);
return s << lazy_context(&impl) << lazy_expectations(&impl);
}
struct lazy_context
{
lazy_context( const function_impl* impl )
: impl_( impl )
{}
friend std::ostream& operator<<(
std::ostream& s, const lazy_context& c )
lazy_context(const function_impl* impl) : impl_(impl) {}
friend std::ostream& operator<<(std::ostream& s, const lazy_context& c)
{
if( c.impl_->context_ )
c.impl_->context_->serialize( s, *c.impl_ );
if(c.impl_->context_)
c.impl_->context_->serialize(s, *c.impl_);
else
s << '?';
return s;
@ -298,31 +248,26 @@ namespace detail
struct lazy_expectations
{
lazy_expectations( const function_impl* impl )
: impl_( impl )
{}
friend std::ostream& operator<<(
std::ostream& s, const lazy_expectations& e )
lazy_expectations(const function_impl* impl) : impl_(impl) {}
friend std::ostream& operator<<(std::ostream& s, const lazy_expectations& e)
{
for( expectations_cit it = e.impl_->expectations_.begin();
it != e.impl_->expectations_.end(); ++it )
for(expectations_cit it = e.impl_->expectations_.begin(); it != e.impl_->expectations_.end(); ++it)
s << std::endl << *it;
return s;
}
const function_impl* impl_;
};
typedef std::list< expectation_type > expectations_type;
typedef std::list<expectation_type> expectations_type;
typedef typename expectations_type::const_iterator expectations_cit;
expectations_type expectations_;
context* context_;
mutable bool valid_;
const int exceptions_;
const boost::shared_ptr< mutex > mutex_;
const boost::shared_ptr<mutex> mutex_;
};
}
} // mock
}} // namespace mock::detail
#undef MOCK_FUNCTION_FORMAT
#undef MOCK_FUNCTION_CONTEXT

85
include/turtle/detail/function_template.hpp
View file

@ -8,99 +8,74 @@
#include "function_impl_template.hpp"
#define MOCK_MOVE(z, n, d) \
mock::detail::move_if_not_lvalue_reference< T##n >( t##n )
#define MOCK_MOVE(z, n, d) mock::detail::move_if_not_lvalue_reference<T##n>(t##n)
namespace mock
{
namespace detail
{
template< typename Signature > class function;
namespace mock { namespace detail {
template<typename Signature>
class function;
template< typename R
BOOST_PP_ENUM_TRAILING_PARAMS(MOCK_NUM_ARGS, typename T) >
class function< R ( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) >
template<typename R BOOST_PP_ENUM_TRAILING_PARAMS(MOCK_NUM_ARGS, typename T)>
class function<R(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))>
{
public:
typedef R result_type;
template< typename Args >
template<typename Args>
struct sig
{
typedef R type;
};
private:
typedef function_impl<
R ( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) )
> impl_type;
typedef function_impl<R(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))> impl_type;
typedef typename impl_type::wrapper_type expectation_type;
typedef typename impl_type::error_type error_type;
public:
function()
: impl_( boost::make_shared< impl_type >() )
{}
function() : impl_(boost::make_shared<impl_type>()) {}
bool verify() const
bool verify() const { return impl_->verify(); }
bool verify(const char* file, int line) const
{
error_type::pass(file, line);
return impl_->verify();
}
bool verify( const char* file, int line ) const
void reset() { impl_->reset(); }
void reset(const char* file, int line)
{
error_type::pass( file, line );
return impl_->verify();
}
void reset()
{
impl_->reset();
}
void reset( const char* file, int line )
{
error_type::pass( file, line );
error_type::pass(file, line);
impl_->reset();
}
expectation_type expect( const char* file, int line )
expectation_type expect(const char* file, int line)
{
error_type::pass( file, line );
return impl_->expect( file, line );
error_type::pass(file, line);
return impl_->expect(file, line);
}
expectation_type expect()
expectation_type expect() { return impl_->expect(); }
R operator()(BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, T, t)) const
{
return impl_->expect();
return (*impl_)(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_MOVE, _));
}
R operator()(
BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, T, t) ) const
{
return (*impl_)( BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_MOVE, _) );
}
friend std::ostream& operator<<(std::ostream& s, const function& f) { return s << *f.impl_; }
friend std::ostream& operator<<( std::ostream& s, const function& f )
function& operator()(context& c, boost::unit_test::const_string instance)
{
return s << *f.impl_;
}
function& operator()( context& c,
boost::unit_test::const_string instance )
{
impl_->add( c, impl_.get(), instance, boost::none, "" );
impl_->add(c, impl_.get(), instance, boost::none, "");
return *this;
}
void configure( context& c, const void* p,
boost::unit_test::const_string instance,
boost::optional< type_name > type,
boost::unit_test::const_string name ) const
void configure(context& c, const void* p, boost::unit_test::const_string instance,
boost::optional<type_name> type, boost::unit_test::const_string name) const
{
impl_->add( c, p, instance, type, name );
impl_->add(c, p, instance, type, name);
}
private:
boost::shared_ptr< impl_type > impl_;
boost::shared_ptr<impl_type> impl_;
};
}
} // mock
}} // namespace mock::detail
#undef MOCK_MOVE

27
include/turtle/detail/functor.hpp
View file

@ -14,39 +14,32 @@
#include "mutex.hpp"
#include "singleton.hpp"
namespace mock
{
namespace detail
{
class functor_mutex_t :
public singleton< functor_mutex_t >,
public mutex
namespace mock { namespace detail {
class functor_mutex_t : public singleton<functor_mutex_t>, public mutex
{
MOCK_SINGLETON_CONS( functor_mutex_t );
MOCK_SINGLETON_CONS(functor_mutex_t);
};
MOCK_SINGLETON_INST( functor_mutex )
MOCK_SINGLETON_INST(functor_mutex)
template< typename Signature >
struct functor : function< Signature >
template<typename Signature>
struct functor : function<Signature>
{
functor()
{
scoped_lock _( functor_mutex );
scoped_lock _(functor_mutex);
static functor* f = 0;
if( f )
if(f)
{
*this = *f;
f = 0;
functor_mutex.unlock();
}
else
} else
{
functor_mutex.lock();
f = this;
}
}
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_FUNCTOR_HPP_INCLUDED

34
include/turtle/detail/group.hpp
View file

@ -11,54 +11,42 @@
#include "../config.hpp"
#include "verifiable.hpp"
#include <functional>
#include <algorithm>
#include <functional>
#include <vector>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
class group
{
public:
void add( verifiable& v )
void add(verifiable& v) { verifiables_.push_back(&v); }
void remove(verifiable& v)
{
verifiables_.push_back( &v );
}
void remove( verifiable& v )
{
verifiables_.erase(
std::remove( verifiables_.begin(), verifiables_.end(), &v ),
verifiables_.end() );
verifiables_.erase(std::remove(verifiables_.begin(), verifiables_.end(), &v), verifiables_.end());
}
bool verify() const
{
bool valid = true;
for( verifiables_cit it = verifiables_.begin();
it != verifiables_.end(); ++it )
if( ! (*it)->verify() )
for(verifiables_cit it = verifiables_.begin(); it != verifiables_.end(); ++it)
if(!(*it)->verify())
valid = false;
return valid;
}
void reset()
{
const verifiables_t verifiables = verifiables_;
for( verifiables_cit it = verifiables.begin();
it != verifiables.end(); ++it )
if( std::find( verifiables_.begin(), verifiables_.end(), *it )
!= verifiables_.end() )
for(verifiables_cit it = verifiables.begin(); it != verifiables.end(); ++it)
if(std::find(verifiables_.begin(), verifiables_.end(), *it) != verifiables_.end())
(*it)->reset();
}
private:
typedef std::vector< verifiable* > verifiables_t;
typedef std::vector<verifiable*> verifiables_t;
typedef verifiables_t::const_iterator verifiables_cit;
verifiables_t verifiables_;
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_GROUP_HPP_INCLUDED

90
include/turtle/detail/invocation.hpp
View file

@ -11,14 +11,11 @@
#include "../config.hpp"
#include <boost/noncopyable.hpp>
#include <stdexcept>
#include <ostream>
#include <limits>
#include <ostream>
#include <stdexcept>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
class invocation : private boost::noncopyable
{
public:
@ -30,66 +27,51 @@ namespace detail
virtual bool exhausted() const = 0;
friend std::ostream& operator<<( std::ostream& s, const invocation& i )
{
return i.serialize( s );
}
friend std::ostream& operator<<(std::ostream& s, const invocation& i) { return i.serialize(s); }
private:
virtual std::ostream& serialize( std::ostream& s ) const = 0;
virtual std::ostream& serialize(std::ostream& s) const = 0;
};
class between : public invocation
{
public:
between( std::size_t min, std::size_t max )
: min_( min )
, max_( max )
, count_( 0 )
between(std::size_t min, std::size_t max) : min_(min), max_(max), count_(0)
{
if( min > max )
throw std::invalid_argument( "'min' > 'max'" );
if(min > max)
throw std::invalid_argument("'min' > 'max'");
}
virtual bool invoke()
{
if( count_ == max_ )
if(count_ == max_)
return false;
++count_;
return true;
}
virtual bool exhausted() const
{
return count_ >= max_;
}
virtual bool exhausted() const { return count_ >= max_; }
virtual bool verify() const
{
return min_ <= count_ && count_ <= max_;
}
virtual bool verify() const { return min_ <= count_ && count_ <= max_; }
protected:
const std::size_t min_, max_;
std::size_t count_;
private:
virtual std::ostream& serialize( std::ostream& s ) const
virtual std::ostream& serialize(std::ostream& s) const
{
return s << "between( " << count_
<< "/[" << min_ << ',' << max_ << "] )";
return s << "between( " << count_ << "/[" << min_ << ',' << max_ << "] )";
}
};
class exactly : public between
{
public:
explicit exactly( std::size_t count )
: between( count, count )
{}
explicit exactly(std::size_t count) : between(count, count) {}
private:
virtual std::ostream& serialize( std::ostream& s ) const
virtual std::ostream& serialize(std::ostream& s) const
{
return s << "exactly( " << count_ << '/' << max_ << " )";
}
@ -98,40 +80,28 @@ namespace detail
class never : public exactly
{
public:
never()
: exactly( 0 )
{}
never() : exactly(0) {}
private:
virtual std::ostream& serialize( std::ostream& s ) const
{
return s << "never()";
}
virtual std::ostream& serialize(std::ostream& s) const { return s << "never()"; }
};
class once : public exactly
{
public:
once()
: exactly( 1 )
{}
once() : exactly(1) {}
private:
virtual std::ostream& serialize( std::ostream& s ) const
{
return s << "once()";
}
virtual std::ostream& serialize(std::ostream& s) const { return s << "once()"; }
};
class at_least : public between
{
public:
explicit at_least( std::size_t min )
: between( min, (std::numeric_limits< std::size_t >::max)() )
{}
explicit at_least(std::size_t min) : between(min, (std::numeric_limits<std::size_t>::max)()) {}
private:
virtual std::ostream& serialize( std::ostream& s ) const
virtual std::ostream& serialize(std::ostream& s) const
{
return s << "at_least( " << count_ << '/' << min_ << " )";
}
@ -140,12 +110,10 @@ namespace detail
class at_most : public between
{
public:
explicit at_most( std::size_t max )
: between( 0, max )
{}
explicit at_most(std::size_t max) : between(0, max) {}
private:
virtual std::ostream& serialize( std::ostream& s ) const
virtual std::ostream& serialize(std::ostream& s) const
{
return s << "at_most( " << count_ << '/' << max_ << " )";
}
@ -154,17 +122,11 @@ namespace detail
class unlimited : public at_least
{
public:
unlimited()
: at_least( 0 )
{}
unlimited() : at_least(0) {}
private:
virtual std::ostream& serialize( std::ostream& s ) const
{
return s << "unlimited()";
}
virtual std::ostream& serialize(std::ostream& s) const { return s << "unlimited()"; }
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_INVOCATION_HPP_INCLUDED

46
include/turtle/detail/is_functor.hpp
View file

@ -11,52 +11,42 @@
#include "../config.hpp"
#include <boost/function_types/is_callable_builtin.hpp>
#include <boost/type_traits/detail/yes_no_type.hpp>
#include <boost/utility/declval.hpp>
#include <boost/mpl/has_xxx.hpp>
#include <boost/mpl/or.hpp>
#include <boost/type_traits/detail/yes_no_type.hpp>
#include <boost/utility/declval.hpp>
namespace mock
{
namespace detail
{
BOOST_MPL_HAS_XXX_TRAIT_DEF( result_type )
BOOST_MPL_HAS_XXX_TEMPLATE_DEF( sig )
BOOST_MPL_HAS_XXX_TEMPLATE_DEF( result )
namespace mock { namespace detail {
BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)
BOOST_MPL_HAS_XXX_TEMPLATE_DEF(sig)
BOOST_MPL_HAS_XXX_TEMPLATE_DEF(result)
#ifdef MOCK_DECLTYPE
template< typename F, typename P >
template<typename F, typename P>
struct is_callable
{
typedef boost::type_traits::yes_type yes_type;
typedef boost::type_traits::no_type no_type;
template< typename T >
static yes_type check(
decltype( boost::declval< T >()( boost::declval< P >() ) )* );
template< typename T >
static no_type check( ... );
template<typename T>
static yes_type check(decltype(boost::declval<T>()(boost::declval<P>()))*);
template<typename T>
static no_type check(...);
typedef boost::mpl::bool_<
sizeof( check< F >( 0 ) ) == sizeof( yes_type ) > type;
typedef boost::mpl::bool_<sizeof(check<F>(0)) == sizeof(yes_type)> type;
};
#endif // MOCK_DECLTYPE
template< typename T, typename P >
struct is_functor
: boost::mpl::or_<
boost::function_types::is_callable_builtin< T >,
template<typename T, typename P>
struct is_functor :
boost::mpl::or_<boost::function_types::is_callable_builtin<T>,
#ifdef MOCK_DECLTYPE
is_callable< T, P >,
is_callable<T, P>,
#endif
has_result_type< T >,
has_result< T >,
has_sig< T >
>
has_result_type<T>, has_result<T>, has_sig<T>>
{};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_IS_FUNCTOR_HPP_INCLUDED

30
include/turtle/detail/matcher_base_template.hpp
View file

@ -6,37 +6,29 @@
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#define MOCK_REF_ARG(z, n, d) \
typename ref_arg< T##n >::type
#define MOCK_REF_ARG(z, n, d) typename ref_arg<T##n>::type
namespace mock
{
namespace detail
{
template< typename Signature > class matcher_base;
namespace mock { namespace detail {
template<typename Signature>
class matcher_base;
template<
BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename T) >
class matcher_base< void( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T) ) >
: boost::noncopyable
template<BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename T)>
class matcher_base<void(BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, T))> : boost::noncopyable
{
public:
virtual ~matcher_base() {}
virtual bool operator()(
BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG, _) ) = 0;
virtual bool operator()(BOOST_PP_ENUM(MOCK_NUM_ARGS, MOCK_REF_ARG, _)) = 0;
friend std::ostream& operator<<(
std::ostream& s, const matcher_base& m )
friend std::ostream& operator<<(std::ostream& s, const matcher_base& m)
{
m.serialize( s );
m.serialize(s);
return s;
}
private:
virtual void serialize( std::ostream& ) const = 0;
virtual void serialize(std::ostream&) const = 0;
};
}
} // mock
}} // namespace mock::detail
#undef MOCK_REF_ARG

59
include/turtle/detail/move_helper.hpp
View file

@ -10,69 +10,62 @@
#define MOCK_MOVE_HELPER_HPP_INCLUDED
#include "../config.hpp"
#include <boost/type_traits/conditional.hpp>
#include <boost/type_traits/is_reference.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/type_traits/add_reference.hpp>
#include <boost/type_traits/add_rvalue_reference.hpp>
#include <boost/type_traits/conditional.hpp>
#include <boost/type_traits/decay.hpp>
#include <boost/type_traits/is_reference.hpp>
#include <boost/type_traits/remove_reference.hpp>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
#ifdef MOCK_RVALUE_REFERENCES
template< typename T >
template<typename T>
struct forward_type
{
typedef T type;
};
template< typename T >
template<typename T>
struct ref_arg
{
typedef typename boost::conditional<
boost::is_reference< T >::value,
T,
typename boost::add_rvalue_reference< T >::type >::type type;
typedef typename boost::conditional<boost::is_reference<T>::value, T,
typename boost::add_rvalue_reference<T>::type>::type type;
};
template< typename T >
inline T&& move_if_not_lvalue_reference(typename boost::remove_reference< T >::type& t)
template<typename T>
inline T&& move_if_not_lvalue_reference(typename boost::remove_reference<T>::type& t)
{
return static_cast< T&& >(t);
return static_cast<T&&>(t);
}
template< typename T >
inline T&& move_if_not_lvalue_reference(typename boost::remove_reference< T >::type&& t)
template<typename T>
inline T&& move_if_not_lvalue_reference(typename boost::remove_reference<T>::type&& t)
{
return static_cast< T&& >(t);
return static_cast<T&&>(t);
}
#else
template< typename T >
template<typename T>
struct forward_type
{
typedef typename boost::decay< const T >::type type;
typedef typename boost::decay<const T>::type type;
};
template< class T>
struct forward_type< boost::rv< T > >
template<class T>
struct forward_type<boost::rv<T>>
{
typedef T type;
};
template< typename T >
template<typename T>
struct ref_arg
{
typedef typename boost::conditional<
boost::is_reference< T >::value,
T,
const typename boost::add_reference< T >::type >::type type;
typedef typename boost::conditional<boost::is_reference<T>::value, T,
const typename boost::add_reference<T>::type>::type type;
};
template< typename T >
inline typename boost::remove_reference< T >::type& move_if_not_lvalue_reference(typename boost::remove_reference< T >::type& t)
template<typename T>
inline typename boost::remove_reference<T>::type&
move_if_not_lvalue_reference(typename boost::remove_reference<T>::type& t)
{
return t;
}
#endif
}
}
}} // namespace mock::detail
#endif // MOCK_MOVE_HELPER_HPP_INCLUDED
#endif // MOCK_MOVE_HELPER_HPP_INCLUDED

128
include/turtle/detail/mutex.hpp
View file

@ -17,24 +17,21 @@
#ifdef MOCK_THREAD_SAFE
#ifdef MOCK_HDR_MUTEX
#include <mutex>
#else
#include <boost/thread/recursive_mutex.hpp>
#include <boost/thread/lock_guard.hpp>
#endif
# ifdef MOCK_HDR_MUTEX
# include <mutex>
# else
# include <boost/thread/lock_guard.hpp>
# include <boost/thread/recursive_mutex.hpp>
# endif
namespace mock
{
namespace detail
{
#ifdef MOCK_HDR_MUTEX
namespace mock { namespace detail {
# ifdef MOCK_HDR_MUTEX
typedef std::recursive_mutex mutex;
typedef std::lock_guard< mutex > scoped_lock;
#else
typedef std::lock_guard<mutex> scoped_lock;
# else
typedef boost::recursive_mutex mutex;
typedef boost::lock_guard< mutex > scoped_lock;
#endif
typedef boost::lock_guard<mutex> scoped_lock;
# endif
struct lock
{
@ -42,23 +39,18 @@ namespace detail
BOOST_MOVABLE_BUT_NOT_COPYABLE(lock)
public:
lock( const boost::shared_ptr< mutex >& m )
: m_( m )
{
m_->lock();
}
lock(const boost::shared_ptr<mutex>& m) : m_(m) { m_->lock(); }
~lock()
{
if( m_ )
if(m_)
m_->unlock();
}
lock( BOOST_RV_REF( lock ) x )
: m_( x.m_ )
lock(BOOST_RV_REF(lock) x) : m_(x.m_)
{
// Explicit reset to avoid unlock in destructor
x.m_.reset();
}
lock& operator=( BOOST_RV_REF( lock ) x )
lock& operator=(BOOST_RV_REF(lock) x)
{
m_ = x.m_;
x.m_.reset();
@ -66,32 +58,24 @@ namespace detail
}
private:
boost::shared_ptr< mutex > m_;
boost::shared_ptr<mutex> m_;
};
}
} // mock
}} // namespace mock::detail
#else // MOCK_THREAD_SAFE
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
struct mutex : boost::noncopyable
{
void lock()
{}
void unlock()
{}
void lock() {}
void unlock() {}
};
// Dummy lock classes.
// Constructor + Destructor make it RAII classes for compilers and avoid unused variable warnings
struct scoped_lock : boost::noncopyable
{
scoped_lock( mutex& )
{}
~scoped_lock()
{}
scoped_lock(mutex&) {}
~scoped_lock() {}
};
class lock : boost::noncopyable
{
@ -99,68 +83,56 @@ namespace detail
BOOST_MOVABLE_BUT_NOT_COPYABLE(lock)
public:
lock( const boost::shared_ptr< mutex >& )
{}
~lock()
{}
lock( BOOST_RV_REF( lock ) )
{}
lock& operator=( BOOST_RV_REF( lock ) )
{
return *this;
}
lock(const boost::shared_ptr<mutex>&) {}
~lock() {}
lock(BOOST_RV_REF(lock)) {}
lock& operator=(BOOST_RV_REF(lock)) { return *this; }
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_THREAD_SAFE
namespace mock
{
namespace detail
{
class error_mutex_t : public singleton< error_mutex_t >,
public mutex
namespace mock { namespace detail {
class error_mutex_t : public singleton<error_mutex_t>, public mutex
{
MOCK_SINGLETON_CONS( error_mutex_t );
MOCK_SINGLETON_CONS(error_mutex_t);
};
MOCK_SINGLETON_INST( error_mutex )
MOCK_SINGLETON_INST(error_mutex)
#ifdef BOOST_MSVC
# pragma warning( push )
# pragma warning( disable: 4702 )
# pragma warning(push)
# pragma warning(disable : 4702)
#endif
template< typename Result, typename Error >
template<typename Result, typename Error>
struct safe_error
{
static Result abort()
{
scoped_lock _( error_mutex );
scoped_lock _(error_mutex);
return Error::abort();
}
template< typename Context >
static void fail( const char* message, const Context& context,
const char* file = "unknown location", int line = 0 )
template<typename Context>
static void fail(const char* message, const Context& context, const char* file = "unknown location",
int line = 0)
{
scoped_lock _( error_mutex );
Error::fail( message, context, file, line );
scoped_lock _(error_mutex);
Error::fail(message, context, file, line);
}
template< typename Context >
static void call( const Context& context, const char* file, int line )
template<typename Context>
static void call(const Context& context, const char* file, int line)
{
scoped_lock _( error_mutex );
Error::call( context, file, line );
scoped_lock _(error_mutex);
Error::call(context, file, line);
}
static void pass( const char* file, int line )
static void pass(const char* file, int line)
{
scoped_lock _( error_mutex );
Error::pass( file, line );
scoped_lock _(error_mutex);
Error::pass(file, line);
}
};
#ifdef BOOST_MSVC
# pragma warning( pop )
# pragma warning(pop)
#endif
}
} // mock
}} // namespace mock::detail
#endif // MOCK_MUTEX_HPP_INCLUDED

75
include/turtle/detail/object_impl.hpp
View file

@ -10,58 +10,50 @@
#define MOCK_OBJECT_IMPL_HPP_INCLUDED
#include "../config.hpp"
#include "root.hpp"
#include "parent.hpp"
#include "type_name.hpp"
#include "context.hpp"
#include "child.hpp"
#include "context.hpp"
#include "mutex.hpp"
#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
#include "parent.hpp"
#include "root.hpp"
#include "type_name.hpp"
#include <boost/enable_shared_from_this.hpp>
#include <boost/make_shared.hpp>
#include <boost/optional.hpp>
#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
namespace mock
{
namespace detail
{
class object_impl : public context, public verifiable,
public boost::enable_shared_from_this< object_impl >
namespace mock { namespace detail {
class object_impl : public context, public verifiable, public boost::enable_shared_from_this<object_impl>
{
public:
object_impl()
: mutex_( boost::make_shared< mutex >() )
{}
object_impl() : mutex_(boost::make_shared<mutex>()) {}
virtual void add( const void* /*p*/, verifiable& v,
boost::unit_test::const_string instance,
boost::optional< type_name > type,
boost::unit_test::const_string name )
virtual void add(const void* /*p*/, verifiable& v, boost::unit_test::const_string instance,
boost::optional<type_name> type, boost::unit_test::const_string name)
{
lock _( mutex_ );
if( children_.empty() )
detail::root.add( *this );
children_[ &v ].update( parent_, instance, type, name );
lock _(mutex_);
if(children_.empty())
detail::root.add(*this);
children_[&v].update(parent_, instance, type, name);
}
virtual void add( verifiable& v )
virtual void add(verifiable& v)
{
lock _( mutex_ );
group_.add( v );
lock _(mutex_);
group_.add(v);
}
virtual void remove( verifiable& v )
virtual void remove(verifiable& v)
{
lock _( mutex_ );
group_.remove( v );
children_.erase( &v );
if( children_.empty() )
detail::root.remove( *this );
lock _(mutex_);
group_.remove(v);
children_.erase(&v);
if(children_.empty())
detail::root.remove(*this);
}
virtual void serialize( std::ostream& s, const verifiable& v ) const
virtual void serialize(std::ostream& s, const verifiable& v) const
{
lock _( mutex_ );
children_cit it = children_.find( &v );
if( it != children_.end() )
lock _(mutex_);
children_cit it = children_.find(&v);
if(it != children_.end())
s << it->second;
else
s << "?";
@ -69,26 +61,25 @@ namespace detail
virtual bool verify() const
{
lock _( mutex_ );
lock _(mutex_);
return group_.verify();
}
virtual void reset()
{
lock _( mutex_ );
boost::shared_ptr< object_impl > guard = shared_from_this();
lock _(mutex_);
boost::shared_ptr<object_impl> guard = shared_from_this();
group_.reset();
}
private:
typedef std::map< const verifiable*, child > children_t;
typedef std::map<const verifiable*, child> children_t;
typedef children_t::const_iterator children_cit;
group group_;
parent parent_;
children_t children_;
const boost::shared_ptr< mutex > mutex_;
const boost::shared_ptr<mutex> mutex_;
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_OBJECT_IMPL_HPP_INCLUDED

19
include/turtle/detail/parameter.hpp
View file

@ -10,25 +10,16 @@
#define MOCK_PARAMETER_HPP_INCLUDED
#include "../config.hpp"
#include <boost/function_types/parameter_types.hpp>
#include <boost/function_types/function_arity.hpp>
#include <boost/function_types/parameter_types.hpp>
#include <boost/mpl/at.hpp>
namespace mock
{
namespace detail
{
template< typename Signature, int n >
namespace mock { namespace detail {
template<typename Signature, int n>
struct parameter
{
typedef typename
boost::mpl::at_c<
typename
boost::function_types::parameter_types< Signature >,
n
>::type type;
typedef typename boost::mpl::at_c<typename boost::function_types::parameter_types<Signature>, n>::type type;
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_PARAMETER_HPP_INCLUDED

26
include/turtle/detail/parent.hpp
View file

@ -11,36 +11,30 @@
#include "../config.hpp"
#include "type_name.hpp"
#include <boost/test/utils/basic_cstring/io.hpp>
#include <boost/optional.hpp>
#include <boost/test/utils/basic_cstring/io.hpp>
#include <ostream>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
class parent
{
public:
parent()
parent() {}
parent(boost::unit_test::const_string instance, boost::optional<type_name> type)
: instance_(instance), type_(type)
{}
parent( boost::unit_test::const_string instance,
boost::optional< type_name > type )
: instance_( instance )
, type_( type )
{}
friend std::ostream& operator<<( std::ostream& s, const parent& p )
friend std::ostream& operator<<(std::ostream& s, const parent& p)
{
s << p.instance_;
if( p.type_ )
if(p.type_)
s << *p.type_ << "::";
return s;
}
private:
boost::unit_test::const_string instance_;
boost::optional< type_name > type_;
boost::optional<type_name> type_;
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_PARENT_HPP_INCLUDED

101
include/turtle/detail/root.hpp
View file

@ -10,117 +10,99 @@
#define MOCK_ROOT_HPP_INCLUDED
#include "../config.hpp"
#include "parent.hpp"
#include "group.hpp"
#include "context.hpp"
#include "child.hpp"
#include "context.hpp"
#include "group.hpp"
#include "mutex.hpp"
#include "parent.hpp"
#include "singleton.hpp"
#include <boost/optional.hpp>
#include <ostream>
#include <map>
#include <ostream>
namespace mock
{
namespace detail
{
class root_t : public singleton< root_t >, public context
namespace mock { namespace detail {
class root_t : public singleton<root_t>, public context
{
public:
virtual void add( const void* p, verifiable& v,
boost::unit_test::const_string instance,
boost::optional< type_name > type,
boost::unit_test::const_string name )
virtual void add(const void* p, verifiable& v, boost::unit_test::const_string instance,
boost::optional<type_name> type, boost::unit_test::const_string name)
{
scoped_lock _( mutex_ );
children_t::iterator it = children_.lower_bound( &v );
if( it == children_.end() ||
children_.key_comp()( &v, it->first ) )
it = children_.insert( it,
std::make_pair( &v, counter_child( parents_, p ) ) );
it->second.update( instance, type, name );
scoped_lock _(mutex_);
children_t::iterator it = children_.lower_bound(&v);
if(it == children_.end() || children_.key_comp()(&v, it->first))
it = children_.insert(it, std::make_pair(&v, counter_child(parents_, p)));
it->second.update(instance, type, name);
}
virtual void add( verifiable& v )
virtual void add(verifiable& v)
{
scoped_lock _( mutex_ );
group_.add( v );
scoped_lock _(mutex_);
group_.add(v);
}
virtual void remove( verifiable& v )
virtual void remove(verifiable& v)
{
scoped_lock _( mutex_ );
group_.remove( v );
children_.erase( &v );
scoped_lock _(mutex_);
group_.remove(v);
children_.erase(&v);
}
bool verify() const
{
scoped_lock _( mutex_ );
scoped_lock _(mutex_);
return group_.verify();
}
void reset()
{
scoped_lock _( mutex_ );
scoped_lock _(mutex_);
group_.reset();
}
virtual void serialize( std::ostream& s, const verifiable& v ) const
virtual void serialize(std::ostream& s, const verifiable& v) const
{
scoped_lock _( mutex_ );
children_cit it = children_.find( &v );
if( it != children_.end() )
scoped_lock _(mutex_);
children_cit it = children_.find(&v);
if(it != children_.end())
s << it->second;
else
s << "?";
}
private:
typedef std::map< const void*,
std::pair< parent, std::size_t > > parents_t;
typedef std::map<const void*, std::pair<parent, std::size_t>> parents_t;
class counter_child
{
public:
counter_child( parents_t& parents, const void* p )
: parents_( &parents )
, it_( parents.insert(
std::make_pair( p, parents_t::mapped_type() ) ).first )
counter_child(parents_t& parents, const void* p)
: parents_(&parents), it_(parents.insert(std::make_pair(p, parents_t::mapped_type())).first)
{
++it_->second.second;
}
counter_child( const counter_child& rhs )
: parents_( rhs.parents_ )
, it_( rhs.it_ )
, child_( rhs.child_ )
counter_child(const counter_child& rhs) : parents_(rhs.parents_), it_(rhs.it_), child_(rhs.child_)
{
++it_->second.second;
}
~counter_child()
{
if( --it_->second.second == 0 )
parents_->erase( it_ );
if(--it_->second.second == 0)
parents_->erase(it_);
}
void update( boost::unit_test::const_string instance,
boost::optional< type_name > type,
boost::unit_test::const_string name )
void update(boost::unit_test::const_string instance, boost::optional<type_name> type,
boost::unit_test::const_string name)
{
child_.update( it_->second.first, instance, type, name );
}
friend std::ostream& operator<<( std::ostream& s,
const counter_child& c )
{
return s << c.child_;
child_.update(it_->second.first, instance, type, name);
}
friend std::ostream& operator<<(std::ostream& s, const counter_child& c) { return s << c.child_; }
private:
counter_child& operator=( const counter_child& );
counter_child& operator=(const counter_child&);
parents_t* parents_;
parents_t::iterator it_;
child child_;
};
typedef std::map< const verifiable*, counter_child > children_t;
typedef std::map<const verifiable*, counter_child> children_t;
typedef children_t::const_iterator children_cit;
parents_t parents_;
@ -128,10 +110,9 @@ namespace detail
group group_;
mutable mutex mutex_;
MOCK_SINGLETON_CONS( root_t );
MOCK_SINGLETON_CONS(root_t);
};
MOCK_SINGLETON_INST( root )
}
} // mock
MOCK_SINGLETON_INST(root)
}} // namespace mock::detail
#endif // MOCK_ROOT_HPP_INCLUDED

49
include/turtle/detail/sequence_impl.hpp
View file

@ -11,57 +11,48 @@
#include "../config.hpp"
#include "mutex.hpp"
#include <boost/noncopyable.hpp>
#include <boost/make_shared.hpp>
#include <boost/noncopyable.hpp>
#include <algorithm>
#include <vector>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
class sequence_impl : private boost::noncopyable
{
public:
sequence_impl()
: mutex_( boost::make_shared< mutex >() )
{}
sequence_impl() : mutex_(boost::make_shared<mutex>()) {}
void add( void* e )
void add(void* e)
{
lock _( mutex_ );
elements_.push_back( e );
lock _(mutex_);
elements_.push_back(e);
}
void remove( void* e )
void remove(void* e)
{
lock _( mutex_ );
elements_.erase( std::remove( elements_.begin(),
elements_.end(), e ), elements_.end() );
lock _(mutex_);
elements_.erase(std::remove(elements_.begin(), elements_.end(), e), elements_.end());
}
bool is_valid( const void* e ) const
bool is_valid(const void* e) const
{
lock _( mutex_ );
return std::find( elements_.begin(), elements_.end(), e )
!= elements_.end();
lock _(mutex_);
return std::find(elements_.begin(), elements_.end(), e) != elements_.end();
}
void invalidate( const void* e )
void invalidate(const void* e)
{
lock _( mutex_ );
elements_type::iterator it =
std::find( elements_.begin(), elements_.end(), e );
if( it != elements_.end() )
elements_.erase( elements_.begin(), it );
lock _(mutex_);
elements_type::iterator it = std::find(elements_.begin(), elements_.end(), e);
if(it != elements_.end())
elements_.erase(elements_.begin(), it);
}
private:
typedef std::vector< void* > elements_type;
typedef std::vector<void*> elements_type;
elements_type elements_;
const boost::shared_ptr< mutex > mutex_;
const boost::shared_ptr<mutex> mutex_;
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_SEQUENCE_IMPL_HPP_INCLUDED

44
include/turtle/detail/signature.hpp
View file

@ -10,36 +10,24 @@
#define MOCK_SIGNATURE_HPP_INCLUDED
#include "../config.hpp"
#include <boost/function_types/parameter_types.hpp>
#include <boost/function_types/function_type.hpp>
#include <boost/function_types/parameter_types.hpp>
#include <boost/function_types/result_type.hpp>
#include <boost/mpl/single_view.hpp>
#include <boost/mpl/joint_view.hpp>
#include <boost/mpl/pop_front.hpp>
#include <boost/mpl/single_view.hpp>
#define BOOST_TYPEOF_SILENT
#include <boost/typeof/typeof.hpp>
namespace mock
{
namespace detail
{
template< typename M >
namespace mock { namespace detail {
template<typename M>
struct signature :
boost::function_types::function_type<
boost::mpl::joint_view<
boost::mpl::single_view<
typename
boost::function_types::result_type< M >::type
>,
typename boost::mpl::pop_front<
typename
boost::function_types::parameter_types< M >
>::type
>
>
boost::function_types::function_type<boost::mpl::joint_view<
boost::mpl::single_view<typename boost::function_types::result_type<M>::type>,
typename boost::mpl::pop_front<typename boost::function_types::parameter_types<M>>::type>>
{};
template< typename T >
template<typename T>
struct base
{
typedef T base_type;
@ -48,16 +36,12 @@ namespace detail
// if an error is generated by the line below it means
// the method is ambiguous : specify its signature to
// disambiguate
template< typename T >
T& ambiguous_method_requires_to_specify_signature( const T& );
}
} // mock
template<typename T>
T& ambiguous_method_requires_to_specify_signature(const T&);
}} // namespace mock::detail
#define MOCK_SIGNATURE(M) \
mock::detail::signature< \
BOOST_TYPEOF( \
mock::detail::ambiguous_method_requires_to_specify_signature( \
&base_type::M ) ) \
>::type
#define MOCK_SIGNATURE(M) \
mock::detail::signature<BOOST_TYPEOF( \
mock::detail::ambiguous_method_requires_to_specify_signature(&base_type::M))>::type
#endif // MOCK_SIGNATURE_HPP_INCLUDED

44
include/turtle/detail/singleton.hpp
View file

@ -11,36 +11,34 @@
#include <boost/config.hpp>
namespace mock {
namespace detail {
namespace mock { namespace detail {
template< typename Derived >
class singleton {
public:
static Derived& instance()
template<typename Derived>
class singleton
{
static Derived the_inst;
return the_inst;
}
public:
static Derived& instance()
{
static Derived the_inst;
return the_inst;
}
BOOST_DELETED_FUNCTION(singleton(singleton const&))
BOOST_DELETED_FUNCTION(singleton& operator=(singleton const&))
BOOST_DELETED_FUNCTION(singleton(singleton const&))
BOOST_DELETED_FUNCTION(singleton& operator=(singleton const&))
protected:
BOOST_DEFAULTED_FUNCTION(singleton(), {})
BOOST_DEFAULTED_FUNCTION(~singleton(), {})
};
protected:
BOOST_DEFAULTED_FUNCTION(singleton(), {})
BOOST_DEFAULTED_FUNCTION(~singleton(), {})
};
} // detail
} // mock
}} // namespace mock::detail
// Add a private ctor to the type to prevent misuse
#define MOCK_SINGLETON_CONS( type ) \
private: \
friend class mock::detail::singleton< type >; \
type() {}
#define MOCK_SINGLETON_CONS(type) \
private: \
friend class mock::detail::singleton<type>; \
type() {}
#define MOCK_SINGLETON_INST( inst ) \
static BOOST_JOIN( inst, _t )& inst = BOOST_JOIN( inst, _t )::instance();
#define MOCK_SINGLETON_INST(inst) static BOOST_JOIN(inst, _t)& inst = BOOST_JOIN(inst, _t)::instance();
#endif // MOCK_SINGLETON_HPP

104
include/turtle/detail/type_name.hpp
View file

@ -10,108 +10,101 @@
#define MOCK_TYPE_NAME_HPP_INCLUDED
#include "../config.hpp"
#include <boost/test/utils/basic_cstring/io.hpp>
#include <boost/algorithm/string/replace.hpp>
#include <boost/algorithm/string/erase.hpp>
#include <boost/algorithm/string/replace.hpp>
#include <boost/algorithm/string/trim.hpp>
#include <boost/test/utils/basic_cstring/io.hpp>
#include <boost/version.hpp>
#if BOOST_VERSION >= 107000
# include <boost/core/typeinfo.hpp>
# define MOCK_TYPEID( t ) BOOST_CORE_TYPEID(t)
# define MOCK_TYPEINFO boost::core::typeinfo
# include <boost/core/typeinfo.hpp>
# define MOCK_TYPEID(t) BOOST_CORE_TYPEID(t)
# define MOCK_TYPEINFO boost::core::typeinfo
#else
# include <boost/detail/sp_typeinfo.hpp>
# define MOCK_TYPEID( t ) BOOST_SP_TYPEID(t)
# define MOCK_TYPEINFO boost::detail::sp_typeinfo
# include <boost/detail/sp_typeinfo.hpp>
# define MOCK_TYPEID(t) BOOST_SP_TYPEID(t)
# define MOCK_TYPEINFO boost::detail::sp_typeinfo
#endif
#include <boost/shared_ptr.hpp>
#include <ostream>
#include <stdexcept>
#include <typeinfo>
#include <ostream>
#ifdef __GNUC__
#include <cxxabi.h>
#include <cstdlib>
# include <cstdlib>
# include <cxxabi.h>
#endif
#define MOCK_TYPE_NAME( t ) mock::detail::type_name( MOCK_TYPEID(t) )
#define MOCK_TYPE_NAME(t) mock::detail::type_name(MOCK_TYPEID(t))
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
class type_name
{
public:
explicit type_name( const MOCK_TYPEINFO& info )
: info_( &info )
{}
friend std::ostream& operator<<( std::ostream& s, const type_name& t )
explicit type_name(const MOCK_TYPEINFO& info) : info_(&info) {}
friend std::ostream& operator<<(std::ostream& s, const type_name& t)
{
t.serialize( s, *t.info_ );
t.serialize(s, *t.info_);
return s;
}
private:
void serialize( std::ostream& s,
const MOCK_TYPEINFO& info ) const
void serialize(std::ostream& s, const MOCK_TYPEINFO& info) const
{
const char* name = info.name();
#ifdef __GNUC__
int status = 0;
boost::shared_ptr< char > demangled(
abi::__cxa_demangle( name, 0, 0, &status ),
&std::free );
if( ! status && demangled )
serialize( s, demangled.get() );
boost::shared_ptr<char> demangled(abi::__cxa_demangle(name, 0, 0, &status), &std::free);
if(!status && demangled)
serialize(s, demangled.get());
else
#endif
serialize( s, name );
serialize(s, name);
}
typedef std::string::size_type size_type;
void serialize( std::ostream& s, std::string name ) const
void serialize(std::ostream& s, std::string name) const
{
const size_type nm = rfind( name, ':' ) + 1;
const size_type tpl = name.find( '<', nm );
s << clean( name.substr( nm, tpl - nm ) );
if( tpl == std::string::npos )
const size_type nm = rfind(name, ':') + 1;
const size_type tpl = name.find('<', nm);
s << clean(name.substr(nm, tpl - nm));
if(tpl == std::string::npos)
return;
s << '<';
list( s, name.substr( tpl + 1, name.rfind( '>' ) - tpl - 1 ) );
list(s, name.substr(tpl + 1, name.rfind('>') - tpl - 1));
s << '>';
}
void list( std::ostream& s, const std::string& name ) const
void list(std::ostream& s, const std::string& name) const
{
const size_type comma = rfind( name, ',' );
if( comma != std::string::npos )
const size_type comma = rfind(name, ',');
if(comma != std::string::npos)
{
list( s, name.substr( 0, comma ) );
list(s, name.substr(0, comma));
s << ", ";
}
serialize( s, name.substr( comma + 1 ) );
serialize(s, name.substr(comma + 1));
}
std::string clean( std::string name ) const
std::string clean(std::string name) const
{
boost::algorithm::trim( name );
boost::algorithm::erase_all( name, "class " );
boost::algorithm::erase_all( name, "struct " );
boost::algorithm::erase_all( name, "__ptr64" );
boost::algorithm::replace_all( name, " &", "&" );
boost::algorithm::replace_all( name, "& ", "&" );
boost::algorithm::replace_all( name, " *", "*" );
boost::algorithm::replace_all( name, "* ", "*" );
boost::algorithm::trim(name);
boost::algorithm::erase_all(name, "class ");
boost::algorithm::erase_all(name, "struct ");
boost::algorithm::erase_all(name, "__ptr64");
boost::algorithm::replace_all(name, " &", "&");
boost::algorithm::replace_all(name, "& ", "&");
boost::algorithm::replace_all(name, " *", "*");
boost::algorithm::replace_all(name, "* ", "*");
return name;
}
size_type rfind( const std::string& name, char c ) const
size_type rfind(const std::string& name, char c) const
{
size_type count = 0;
for( size_type i = name.size() - 1; i > 0; --i )
for(size_type i = name.size() - 1; i > 0; --i)
{
if( name[ i ] == '>' )
if(name[i] == '>')
++count;
else if( name[ i ] == '<' )
else if(name[i] == '<')
--count;
if( name[ i ] == c && count == 0 )
if(name[i] == c && count == 0)
return i;
}
return std::string::npos;
@ -119,7 +112,6 @@ namespace detail
const MOCK_TYPEINFO* info_;
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_TYPE_NAME_HPP_INCLUDED

8
include/turtle/detail/verifiable.hpp
View file

@ -12,10 +12,7 @@
#include "../config.hpp"
#include <boost/noncopyable.hpp>
namespace mock
{
namespace detail
{
namespace mock { namespace detail {
class verifiable : private boost::noncopyable
{
public:
@ -26,7 +23,6 @@ namespace detail
virtual void reset() = 0;
};
}
} // mock
}} // namespace mock::detail
#endif // MOCK_VERIFIABLE_HPP_INCLUDED

104
include/turtle/error.hpp
View file

@ -11,69 +11,59 @@
#include "config.hpp"
#ifdef MOCK_USE_BOOST_TEST
#include "exception.hpp"
#include <boost/version.hpp>
#include <boost/test/framework.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test_suite.hpp>
#include <boost/exception/enable_current_exception.hpp>
# include "exception.hpp"
# include <boost/exception/enable_current_exception.hpp>
# include <boost/test/framework.hpp>
# include <boost/test/test_tools.hpp>
# include <boost/test/unit_test_suite.hpp>
# include <boost/version.hpp>
namespace mock
namespace mock {
template<typename Result>
struct error
{
template< typename Result >
struct error
static Result abort()
{
static Result abort()
{
boost::unit_test::framework::test_unit_aborted(
boost::unit_test::framework::current_test_case() );
throw boost::enable_current_exception( exception() );
}
boost::unit_test::framework::test_unit_aborted(boost::unit_test::framework::current_test_case());
throw boost::enable_current_exception(exception());
}
static void pass( const char* file, int line )
{
boost::unit_test::unit_test_log.set_checkpoint( file,
static_cast< std::size_t >( line ) );
}
static void pass(const char* file, int line)
{
boost::unit_test::unit_test_log.set_checkpoint(file, static_cast<std::size_t>(line));
}
template< typename Context >
static void fail( const char* message, const Context& context,
const char* file = "unknown location", int line = 0 )
{
boost::unit_test::framework::assertion_result(
#if BOOST_VERSION < 105900
false
#else
boost::unit_test::AR_FAILED
#endif
);
boost::unit_test::unit_test_log
<< boost::unit_test::log::begin( file,
static_cast< std::size_t >( line ) )
<< boost::unit_test::log_all_errors
<< message << ": " << context
<< boost::unit_test::log::end();
}
template<typename Context>
static void fail(const char* message, const Context& context, const char* file = "unknown location", int line = 0)
{
boost::unit_test::framework::assertion_result(
# if BOOST_VERSION < 105900
false
# else
boost::unit_test::AR_FAILED
# endif
);
boost::unit_test::unit_test_log << boost::unit_test::log::begin(file, static_cast<std::size_t>(line))
<< boost::unit_test::log_all_errors << message << ": " << context
<< boost::unit_test::log::end();
}
template< typename Context >
static void call( const Context& context, const char* file, int line )
{
boost::unit_test::framework::assertion_result(
#if BOOST_VERSION < 105900
true
#else
boost::unit_test::AR_PASSED
#endif
);
boost::unit_test::unit_test_log
<< boost::unit_test::log::begin( file,
static_cast< std::size_t >( line ) )
<< boost::unit_test::log_successful_tests
<< "mock expectation fulfilled: " << context
<< boost::unit_test::log::end();
}
};
} // mock
template<typename Context>
static void call(const Context& context, const char* file, int line)
{
boost::unit_test::framework::assertion_result(
# if BOOST_VERSION < 105900
true
# else
boost::unit_test::AR_PASSED
# endif
);
boost::unit_test::unit_test_log << boost::unit_test::log::begin(file, static_cast<std::size_t>(line))
<< boost::unit_test::log_successful_tests
<< "mock expectation fulfilled: " << context << boost::unit_test::log::end();
}
};
} // namespace mock
#endif // MOCK_USE_BOOST_TEST

11
include/turtle/exception.hpp
View file

@ -11,13 +11,12 @@
#include "config.hpp"
#ifdef MOCK_USE_BOOST_TEST
#include <boost/test/execution_monitor.hpp>
# include <boost/test/execution_monitor.hpp>
namespace mock
{
struct exception : virtual boost::execution_aborted
{};
} // mock
namespace mock {
struct exception : virtual boost::execution_aborted
{};
} // namespace mock
#endif // MOCK_USE_BOOST_TEST

13
include/turtle/format.hpp
View file

@ -12,14 +12,13 @@
#include "config.hpp"
#include "detail/formatter.hpp"
namespace mock
namespace mock {
template<typename T>
detail::formatter<T> format(const T& t)
{
template< typename T >
detail::formatter< T > format( const T& t )
{
return detail::formatter< T >( t );
}
return detail::formatter<T>(t);
}
} // mock
} // namespace mock
#endif // MOCK_FORMAT_HPP_INCLUDED

315
include/turtle/log.hpp
View file

@ -10,195 +10,186 @@
#define MOCK_LOG_HPP_INCLUDED
#include "config.hpp"
#include "stream.hpp"
#include "format.hpp"
#include <boost/utility/enable_if.hpp>
#include "stream.hpp"
#include <boost/detail/container_fwd.hpp>
#include <boost/function_types/is_callable_builtin.hpp>
#include <boost/none.hpp>
#include <boost/utility/enable_if.hpp>
#include <memory>
namespace boost
{
template< typename T > class shared_ptr;
template< typename T > class weak_ptr;
template< typename T > class reference_wrapper;
template< typename T > class optional;
namespace boost {
template<typename T>
class shared_ptr;
template<typename T>
class weak_ptr;
template<typename T>
class reference_wrapper;
template<typename T>
class optional;
namespace phoenix
{
template< typename T > struct actor;
namespace phoenix {
template<typename T>
struct actor;
}
namespace lambda
{
template< typename T > class lambda_functor;
}
namespace assign_detail
{
template< typename T > class generic_list;
namespace lambda {
template<typename T>
class lambda_functor;
}
namespace assign_detail {
template<typename T>
class generic_list;
}
} // namespace boost
namespace mock
{
namespace detail
{
template< typename T >
void serialize( stream& s, const T& begin, const T& end )
namespace mock {
namespace detail {
template<typename T>
void serialize(stream& s, const T& begin, const T& end)
{
s << '(';
for( T it = begin; it != end; ++it )
s << (it == begin ? "" : ",") << mock::format( *it );
for(T it = begin; it != end; ++it)
s << (it == begin ? "" : ",") << mock::format(*it);
s << ')';
}
}
} // namespace detail
#ifdef MOCK_AUTO_PTR
template< typename T >
stream& operator<<( stream& s, const std::auto_ptr< T >& t )
{
return s << mock::format( t.get() );
}
template<typename T>
stream& operator<<(stream& s, const std::auto_ptr<T>& t)
{
return s << mock::format(t.get());
}
#endif // MOCK_AUTO_PTR
template< typename T1, typename T2 >
stream& operator<<( stream& s, const std::pair< T1, T2 >& p )
{
return s << '(' << mock::format( p.first )
<< ',' << mock::format( p.second ) << ')';
}
template<typename T1, typename T2>
stream& operator<<(stream& s, const std::pair<T1, T2>& p)
{
return s << '(' << mock::format(p.first) << ',' << mock::format(p.second) << ')';
}
template< typename T, typename A >
stream& operator<<( stream& s, const std::deque< T, A >& t )
{
detail::serialize( s, t.begin(), t.end() );
return s;
}
template< typename T, typename A >
stream& operator<<( stream& s, const std::list< T, A >& t )
{
detail::serialize( s, t.begin(), t.end() );
return s;
}
template< typename T, typename A >
stream& operator<<( stream& s, const std::vector< T, A >& t )
{
detail::serialize( s, t.begin(), t.end() );
return s;
}
template< typename K, typename T, typename C, typename A >
stream& operator<<( stream& s, const std::map< K, T, C, A >& t )
{
detail::serialize( s, t.begin(), t.end() );
return s;
}
template< typename K, typename T, typename C, typename A >
stream& operator<<( stream& s, const std::multimap< K, T, C, A >& t )
{
detail::serialize( s, t.begin(), t.end() );
return s;
}
template< typename T, typename C, typename A >
stream& operator<<( stream& s, const std::set< T, C, A >& t )
{
detail::serialize( s, t.begin(), t.end() );
return s;
}
template< typename T, typename C, typename A >
stream& operator<<( stream& s, const std::multiset< T, C, A >& t )
{
detail::serialize( s, t.begin(), t.end() );
return s;
}
template< typename T >
stream& operator<<( stream& s,
const boost::assign_detail::generic_list< T >& t )
{
detail::serialize( s, t.begin(), t.end() );
return s;
}
template< typename T >
stream& operator<<( stream& s, const boost::reference_wrapper< T >& t )
{
return s << mock::format( t.get() );
}
template< typename T >
stream& operator<<( stream& s, const boost::shared_ptr< T >& t )
{
return s << mock::format( t.get() );
}
template< typename T >
stream& operator<<( stream& s, const boost::weak_ptr< T >& t )
{
return s << mock::format( t.lock() );
}
inline stream& operator<<( stream& s, const boost::none_t& )
{
return s << "none";
}
template< typename T >
stream& operator<<( stream& s, const boost::optional< T >& t )
{
if( t )
return s << mock::format( t.get() );
return s << boost::none;
}
template<typename T, typename A>
stream& operator<<(stream& s, const std::deque<T, A>& t)
{
detail::serialize(s, t.begin(), t.end());
return s;
}
template<typename T, typename A>
stream& operator<<(stream& s, const std::list<T, A>& t)
{
detail::serialize(s, t.begin(), t.end());
return s;
}
template<typename T, typename A>
stream& operator<<(stream& s, const std::vector<T, A>& t)
{
detail::serialize(s, t.begin(), t.end());
return s;
}
template<typename K, typename T, typename C, typename A>
stream& operator<<(stream& s, const std::map<K, T, C, A>& t)
{
detail::serialize(s, t.begin(), t.end());
return s;
}
template<typename K, typename T, typename C, typename A>
stream& operator<<(stream& s, const std::multimap<K, T, C, A>& t)
{
detail::serialize(s, t.begin(), t.end());
return s;
}
template<typename T, typename C, typename A>
stream& operator<<(stream& s, const std::set<T, C, A>& t)
{
detail::serialize(s, t.begin(), t.end());
return s;
}
template<typename T, typename C, typename A>
stream& operator<<(stream& s, const std::multiset<T, C, A>& t)
{
detail::serialize(s, t.begin(), t.end());
return s;
}
template<typename T>
stream& operator<<(stream& s, const boost::assign_detail::generic_list<T>& t)
{
detail::serialize(s, t.begin(), t.end());
return s;
}
template<typename T>
stream& operator<<(stream& s, const boost::reference_wrapper<T>& t)
{
return s << mock::format(t.get());
}
template<typename T>
stream& operator<<(stream& s, const boost::shared_ptr<T>& t)
{
return s << mock::format(t.get());
}
template<typename T>
stream& operator<<(stream& s, const boost::weak_ptr<T>& t)
{
return s << mock::format(t.lock());
}
inline stream& operator<<(stream& s, const boost::none_t&)
{
return s << "none";
}
template<typename T>
stream& operator<<(stream& s, const boost::optional<T>& t)
{
if(t)
return s << mock::format(t.get());
return s << boost::none;
}
#ifdef MOCK_SMART_PTR
template< typename T >
stream& operator<<( stream& s, const std::shared_ptr< T >& t )
{
return s << mock::format( t.get() );
}
template< typename T >
stream& operator<<( stream& s, const std::weak_ptr< T >& t )
{
return s << mock::format( t.lock() );
}
template< typename T, typename D >
stream& operator<<( stream& s, const std::unique_ptr< T, D >& p )
{
return s << mock::format( p.get() );
}
template<typename T>
stream& operator<<(stream& s, const std::shared_ptr<T>& t)
{
return s << mock::format(t.get());
}
template<typename T>
stream& operator<<(stream& s, const std::weak_ptr<T>& t)
{
return s << mock::format(t.lock());
}
template<typename T, typename D>
stream& operator<<(stream& s, const std::unique_ptr<T, D>& p)
{
return s << mock::format(p.get());
}
#endif
template< typename T >
stream& operator<<( stream& s, const boost::lambda::lambda_functor< T >& )
{
return s << '?';
}
template< typename T >
stream& operator<<( stream& s, const boost::phoenix::actor< T >& )
{
return s << '?';
}
template<typename T>
stream& operator<<(stream& s, const boost::lambda::lambda_functor<T>&)
{
return s << '?';
}
template<typename T>
stream& operator<<(stream& s, const boost::phoenix::actor<T>&)
{
return s << '?';
}
#ifdef MOCK_NULLPTR
inline stream& operator<<( stream& s, std::nullptr_t )
{
return s << "nullptr";
}
inline stream& operator<<(stream& s, std::nullptr_t)
{
return s << "nullptr";
}
#endif
template< typename T >
typename boost::enable_if<
boost::function_types::is_callable_builtin< T >,
stream&
>::type
operator<<( stream& s, T* )
{
return s << '?';
}
template< typename T >
typename boost::disable_if<
boost::function_types::is_callable_builtin< T >,
stream&
>::type
operator<<( stream& s, T* t )
{
*s.s_ << t;
return s;
}
} // mock
template<typename T>
typename boost::enable_if<boost::function_types::is_callable_builtin<T>, stream&>::type operator<<(stream& s, T*)
{
return s << '?';
}
template<typename T>
typename boost::disable_if<boost::function_types::is_callable_builtin<T>, stream&>::type operator<<(stream& s, T* t)
{
*s.s_ << t;
return s;
}
} // namespace mock
#endif // MOCK_LOG_HPP_INCLUDED

139
include/turtle/matcher.hpp
View file

@ -10,101 +10,72 @@
#define MOCK_MATCHER_HPP_INCLUDED
#include "config.hpp"
#include "log.hpp"
#include "constraints.hpp"
#include "detail/is_functor.hpp"
#include "detail/move_helper.hpp"
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/add_reference.hpp>
#include "log.hpp"
#include <boost/ref.hpp>
#include <boost/type_traits/add_reference.hpp>
#include <boost/utility/enable_if.hpp>
#include <cstring>
namespace mock
namespace mock {
template<typename Actual, typename Expected, typename Enable = void>
class matcher
{
template< typename Actual, typename Expected, typename Enable = void >
class matcher
public:
explicit matcher(Expected expected) : expected_(expected) {}
bool operator()(typename boost::add_reference<const Actual>::type actual)
{
public:
explicit matcher( Expected expected )
: expected_( expected )
{}
bool operator()( typename boost::add_reference< const Actual >::type actual )
{
return mock::equal(
boost::unwrap_ref( expected_ ) ).c_( actual );
}
friend std::ostream& operator<<(
std::ostream& s, const matcher& m )
{
return s << mock::format( m.expected_ );
}
private:
Expected expected_;
};
return mock::equal(boost::unwrap_ref(expected_)).c_(actual);
}
friend std::ostream& operator<<(std::ostream& s, const matcher& m) { return s << mock::format(m.expected_); }
template<>
class matcher< const char*, const char* >
{
public:
explicit matcher( const char* expected )
: expected_( expected )
{}
bool operator()( const char* actual )
{
return std::strcmp( actual, expected_ ) == 0;
}
friend std::ostream& operator<<(
std::ostream& s, const matcher& m )
{
return s << mock::format( m.expected_ );
}
private:
const char* expected_;
};
private:
Expected expected_;
};
template< typename Actual, typename Constraint >
class matcher< Actual, mock::constraint< Constraint > >
{
public:
explicit matcher( const constraint< Constraint >& c )
: c_( c.c_ )
{}
bool operator()( typename detail::ref_arg< Actual >::type actual )
{
return c_( mock::detail::move_if_not_lvalue_reference< typename detail::ref_arg< Actual >::type >( actual ) );
}
friend std::ostream& operator<<(
std::ostream& s, const matcher& m )
{
return s << mock::format( m.c_ );
}
private:
Constraint c_;
};
template<>
class matcher<const char*, const char*>
{
public:
explicit matcher(const char* expected) : expected_(expected) {}
bool operator()(const char* actual) { return std::strcmp(actual, expected_) == 0; }
friend std::ostream& operator<<(std::ostream& s, const matcher& m) { return s << mock::format(m.expected_); }
template< typename Actual, typename Functor >
class matcher< Actual, Functor,
typename boost::enable_if<
detail::is_functor< Functor, Actual >
>::type
>
private:
const char* expected_;
};
template<typename Actual, typename Constraint>
class matcher<Actual, mock::constraint<Constraint>>
{
public:
explicit matcher(const constraint<Constraint>& c) : c_(c.c_) {}
bool operator()(typename detail::ref_arg<Actual>::type actual)
{
public:
explicit matcher( const Functor& f )
: c_( f )
{}
bool operator()( typename detail::ref_arg< Actual >::type actual )
{
return c_( mock::detail::move_if_not_lvalue_reference< typename detail::ref_arg< Actual >::type >( actual ) );
}
friend std::ostream& operator<<(
std::ostream& s, const matcher& m )
{
return s << mock::format( m.c_ );
}
private:
Functor c_;
};
} // mock
return c_(mock::detail::move_if_not_lvalue_reference<typename detail::ref_arg<Actual>::type>(actual));
}
friend std::ostream& operator<<(std::ostream& s, const matcher& m) { return s << mock::format(m.c_); }
private:
Constraint c_;
};
template<typename Actual, typename Functor>
class matcher<Actual, Functor, typename boost::enable_if<detail::is_functor<Functor, Actual>>::type>
{
public:
explicit matcher(const Functor& f) : c_(f) {}
bool operator()(typename detail::ref_arg<Actual>::type actual)
{
return c_(mock::detail::move_if_not_lvalue_reference<typename detail::ref_arg<Actual>::type>(actual));
}
friend std::ostream& operator<<(std::ostream& s, const matcher& m) { return s << mock::format(m.c_); }
private:
Functor c_;
};
} // namespace mock
#endif // MOCK_MATCHER_HPP_INCLUDED

287
include/turtle/mock.hpp
View file

@ -9,245 +9,198 @@
#ifndef MOCK_MOCK_HPP_INCLUDED
#define MOCK_MOCK_HPP_INCLUDED
#include "cleanup.hpp"
#include "config.hpp"
#include "detail/function.hpp"
#include "detail/functor.hpp"
#include "detail/parameter.hpp"
#include "detail/signature.hpp"
#include "detail/type_name.hpp"
#include "object.hpp"
#include "reset.hpp"
#include "verify.hpp"
#include "cleanup.hpp"
#include "detail/functor.hpp"
#include "detail/function.hpp"
#include "detail/type_name.hpp"
#include "detail/signature.hpp"
#include "detail/parameter.hpp"
#include <boost/mpl/assert.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <boost/utility/identity_type.hpp>
#include <boost/mpl/assert.hpp>
#define MOCK_CLASS(T) \
struct T : mock::object
#define MOCK_CLASS(T) struct T : mock::object
#define MOCK_FUNCTION_TYPE(S, tpn) \
tpn boost::remove_pointer< tpn BOOST_IDENTITY_TYPE(S) >::type
#define MOCK_FUNCTION_TYPE(S, tpn) tpn boost::remove_pointer<tpn BOOST_IDENTITY_TYPE(S)>::type
#ifdef MOCK_VARIADIC_MACROS
#define MOCK_BASE_CLASS(T, ...) \
struct T : __VA_ARGS__, mock::object, mock::detail::base< __VA_ARGS__ >
# define MOCK_BASE_CLASS(T, ...) struct T : __VA_ARGS__, mock::object, mock::detail::base<__VA_ARGS__>
#define MOCK_FUNCTOR(f, ...) \
mock::detail::functor< MOCK_FUNCTION_TYPE((__VA_ARGS__),) > f, f##_mock
#define MOCK_FUNCTOR_TPL(f, ...) \
mock::detail::functor< \
MOCK_FUNCTION_TYPE((__VA_ARGS__), typename) > f, f##_mock
# define MOCK_FUNCTOR(f, ...) mock::detail::functor<MOCK_FUNCTION_TYPE((__VA_ARGS__), )> f, f##_mock
# define MOCK_FUNCTOR_TPL(f, ...) mock::detail::functor<MOCK_FUNCTION_TYPE((__VA_ARGS__), typename)> f, f##_mock
#else // MOCK_VARIADIC_MACROS
#define MOCK_BASE_CLASS(T, I) \
struct T : I, mock::object, mock::detail::base< I >
# define MOCK_BASE_CLASS(T, I) struct T : I, mock::object, mock::detail::base<I>
#define MOCK_FUNCTOR(f, S) \
mock::detail::functor< MOCK_FUNCTION_TYPE((S),) > f, f##_mock
#define MOCK_FUNCTOR_TPL(f, S) \
mock::detail::functor< \
MOCK_FUNCTION_TYPE((S), typename) > f, f##_mock
# define MOCK_FUNCTOR(f, S) mock::detail::functor<MOCK_FUNCTION_TYPE((S), )> f, f##_mock
# define MOCK_FUNCTOR_TPL(f, S) mock::detail::functor<MOCK_FUNCTION_TYPE((S), typename)> f, f##_mock
#endif // MOCK_VARIADIC_MACROS
#define MOCK_HELPER(t) \
t##_mock( mock::detail::root, BOOST_PP_STRINGIZE(t) )
#define MOCK_ANONYMOUS_HELPER(t) \
t##_mock( mock::detail::root, "?." )
#define MOCK_HELPER(t) t##_mock(mock::detail::root, BOOST_PP_STRINGIZE(t))
#define MOCK_ANONYMOUS_HELPER(t) t##_mock(mock::detail::root, "?.")
#define MOCK_METHOD_HELPER(S, t, tpn) \
mutable mock::detail::function< MOCK_FUNCTION_TYPE((S), tpn) > t##_mock_; \
mock::detail::function< MOCK_FUNCTION_TYPE((S), tpn) >& t##_mock( \
const mock::detail::context&, \
const boost::unit_test::const_string& instance ) const \
{ \
mock::detail::configure( *this, t##_mock_, \
instance.substr( 0, instance.rfind( BOOST_PP_STRINGIZE(t) ) ), \
MOCK_TYPE_NAME(*this), \
BOOST_PP_STRINGIZE(t) ); \
return t##_mock_; \
#define MOCK_METHOD_HELPER(S, t, tpn) \
mutable mock::detail::function<MOCK_FUNCTION_TYPE((S), tpn)> t##_mock_; \
mock::detail::function<MOCK_FUNCTION_TYPE((S), tpn)>& t##_mock( \
const mock::detail::context&, const boost::unit_test::const_string& instance) const \
{ \
mock::detail::configure(*this, t##_mock_, instance.substr(0, instance.rfind(BOOST_PP_STRINGIZE(t))), \
MOCK_TYPE_NAME(*this), BOOST_PP_STRINGIZE(t)); \
return t##_mock_; \
}
#define MOCK_PARAM(S, tpn) \
tpn mock::detail::parameter< MOCK_FUNCTION_TYPE((S), tpn)
#define MOCK_DECL_PARAM(z, n, d) \
BOOST_PP_COMMA_IF(n) d, n >::type p##n
#define MOCK_DECL_PARAMS(n, S, tpn) \
BOOST_PP_REPEAT(n, MOCK_DECL_PARAM, MOCK_PARAM(S, tpn))
#define MOCK_PARAM(S, tpn) tpn mock::detail::parameter < MOCK_FUNCTION_TYPE((S), tpn)
#define MOCK_DECL_PARAM(z, n, d) BOOST_PP_COMMA_IF(n) d, n > ::type p##n
#define MOCK_DECL_PARAMS(n, S, tpn) BOOST_PP_REPEAT(n, MOCK_DECL_PARAM, MOCK_PARAM(S, tpn))
#define MOCK_DECL(M, n, S, c, tpn) \
tpn boost::function_types::result_type< \
MOCK_FUNCTION_TYPE((S), tpn) >::type M( \
MOCK_DECL_PARAMS(n, S, tpn) ) c
tpn boost::function_types::result_type<MOCK_FUNCTION_TYPE((S), tpn)>::type M(MOCK_DECL_PARAMS(n, S, tpn)) c
#define MOCK_FORWARD_PARAM(z, n, d) \
BOOST_PP_COMMA_IF(n) d, n >::type >( p##n )
#define MOCK_FORWARD_PARAM(z, n, d) BOOST_PP_COMMA_IF(n) d, n > ::type > (p##n)
#define MOCK_FORWARD_PARAMS(n, S, tpn) \
BOOST_PP_REPEAT(n, MOCK_FORWARD_PARAM, \
mock::detail::move_if_not_lvalue_reference< MOCK_PARAM(S, tpn))
#define MOCK_METHOD_AUX(M, n, S, t, c, tpn) \
MOCK_DECL(M, n, S, c, tpn) \
{ \
BOOST_MPL_ASSERT_RELATION( n, ==, \
boost::function_types::function_arity< \
MOCK_FUNCTION_TYPE((S), tpn) >::value ); \
return MOCK_ANONYMOUS_HELPER(t)( \
MOCK_FORWARD_PARAMS(n, S, tpn) ); \
BOOST_PP_REPEAT(n, MOCK_FORWARD_PARAM, mock::detail::move_if_not_lvalue_reference < MOCK_PARAM(S, tpn))
#define MOCK_METHOD_AUX(M, n, S, t, c, tpn) \
MOCK_DECL(M, n, S, c, tpn) \
{ \
BOOST_MPL_ASSERT_RELATION(n, ==, boost::function_types::function_arity<MOCK_FUNCTION_TYPE((S), tpn)>::value); \
return MOCK_ANONYMOUS_HELPER(t)(MOCK_FORWARD_PARAMS(n, S, tpn)); \
}
#define MOCK_METHOD_EXT(M, n, S, t) \
MOCK_METHOD_AUX(M, n, S, t,,) \
MOCK_METHOD_AUX(M, n, S, t, const,) \
MOCK_METHOD_HELPER(S, t,)
#define MOCK_METHOD_EXT(M, n, S, t) \
MOCK_METHOD_AUX(M, n, S, t, , ) \
MOCK_METHOD_AUX(M, n, S, t, const, ) \
MOCK_METHOD_HELPER(S, t, )
#define MOCK_CONST_METHOD_EXT(M, n, S, t) \
MOCK_METHOD_AUX(M, n, S, t, const,) \
MOCK_METHOD_HELPER(S, t,)
MOCK_METHOD_AUX(M, n, S, t, const, ) \
MOCK_METHOD_HELPER(S, t, )
#define MOCK_NON_CONST_METHOD_EXT(M, n, S, t) \
MOCK_METHOD_AUX(M, n, S, t,,) \
MOCK_METHOD_HELPER(S, t,)
MOCK_METHOD_AUX(M, n, S, t, , ) \
MOCK_METHOD_HELPER(S, t, )
#define MOCK_METHOD_EXT_TPL(M, n, S, t) \
MOCK_METHOD_AUX(M, n, S, t,, typename) \
#define MOCK_METHOD_EXT_TPL(M, n, S, t) \
MOCK_METHOD_AUX(M, n, S, t, , typename) \
MOCK_METHOD_AUX(M, n, S, t, const, typename) \
MOCK_METHOD_HELPER(S, t, typename)
#define MOCK_CONST_METHOD_EXT_TPL(M, n, S, t) \
#define MOCK_CONST_METHOD_EXT_TPL(M, n, S, t) \
MOCK_METHOD_AUX(M, n, S, t, const, typename) \
MOCK_METHOD_HELPER(S, t, typename)
#define MOCK_NON_CONST_METHOD_EXT_TPL(M, n, S, t) \
MOCK_METHOD_AUX(M, n, S, t,, typename) \
MOCK_METHOD_AUX(M, n, S, t, , typename) \
MOCK_METHOD_HELPER(S, t, typename)
#define MOCK_CONVERSION_OPERATOR(M, T, t) \
#define MOCK_CONVERSION_OPERATOR(M, T, t) \
M T() const { return MOCK_ANONYMOUS_HELPER(t)(); } \
M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \
MOCK_METHOD_HELPER(T(), t,)
#define MOCK_CONST_CONVERSION_OPERATOR(M, T, t) \
M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \
MOCK_METHOD_HELPER(T(), t, )
#define MOCK_CONST_CONVERSION_OPERATOR(M, T, t) \
M T() const { return MOCK_ANONYMOUS_HELPER(t)(); } \
MOCK_METHOD_HELPER(T(), t,)
MOCK_METHOD_HELPER(T(), t, )
#define MOCK_NON_CONST_CONVERSION_OPERATOR(M, T, t) \
M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \
MOCK_METHOD_HELPER(T(), t,)
M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \
MOCK_METHOD_HELPER(T(), t, )
#define MOCK_CONVERSION_OPERATOR_TPL(M, T, t) \
#define MOCK_CONVERSION_OPERATOR_TPL(M, T, t) \
M T() const { return MOCK_ANONYMOUS_HELPER(t)(); } \
M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \
M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \
MOCK_METHOD_HELPER(T(), t, typename)
#define MOCK_CONST_CONVERSION_OPERATOR_TPL(M, T, t) \
#define MOCK_CONST_CONVERSION_OPERATOR_TPL(M, T, t) \
M T() const { return MOCK_ANONYMOUS_HELPER(t)(); } \
MOCK_METHOD_HELPER(T(), t, typename)
#define MOCK_NON_CONST_CONVERSION_OPERATOR_TPL(M, T, t) \
M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \
M T() { return MOCK_ANONYMOUS_HELPER(t)(); } \
MOCK_METHOD_HELPER(T(), t, typename)
#define MOCK_FUNCTION_HELPER(S, t, s, tpn) \
s mock::detail::function< MOCK_FUNCTION_TYPE((S), tpn) >& t##_mock( \
mock::detail::context& context, \
boost::unit_test::const_string instance ) \
{ \
static mock::detail::function< MOCK_FUNCTION_TYPE((S), tpn) > f; \
return f( context, instance ); \
#define MOCK_FUNCTION_HELPER(S, t, s, tpn) \
s mock::detail::function<MOCK_FUNCTION_TYPE((S), tpn)>& t##_mock(mock::detail::context& context, \
boost::unit_test::const_string instance) \
{ \
static mock::detail::function<MOCK_FUNCTION_TYPE((S), tpn)> f; \
return f(context, instance); \
}
#define MOCK_CONSTRUCTOR_AUX(T, n, A, t, tpn) \
T( MOCK_DECL_PARAMS(n, void A, tpn) ) \
{ \
MOCK_HELPER(t)( MOCK_FORWARD_PARAMS(n, void A, tpn) ); \
} \
#define MOCK_CONSTRUCTOR_AUX(T, n, A, t, tpn) \
T(MOCK_DECL_PARAMS(n, void A, tpn)) { MOCK_HELPER(t)(MOCK_FORWARD_PARAMS(n, void A, tpn)); } \
MOCK_FUNCTION_HELPER(void A, t, static, tpn)
#define MOCK_CONSTRUCTOR(T, n, A, t) \
MOCK_CONSTRUCTOR_AUX(T, n, A, t,)
#define MOCK_CONSTRUCTOR_TPL(T, n, A, t) \
MOCK_CONSTRUCTOR_AUX(T, n, A, t, typename)
#define MOCK_CONSTRUCTOR(T, n, A, t) MOCK_CONSTRUCTOR_AUX(T, n, A, t, )
#define MOCK_CONSTRUCTOR_TPL(T, n, A, t) MOCK_CONSTRUCTOR_AUX(T, n, A, t, typename)
#define MOCK_DESTRUCTOR(T, t) \
T() { try { MOCK_ANONYMOUS_HELPER(t)(); } catch( ... ) {} } \
MOCK_METHOD_HELPER(void(), t,)
#define MOCK_DESTRUCTOR(T, t) \
T() \
{ \
try \
{ \
MOCK_ANONYMOUS_HELPER(t)(); \
} catch(...) \
{} \
} \
MOCK_METHOD_HELPER(void(), t, )
#define MOCK_FUNCTION_AUX(F, n, S, t, s, tpn) \
MOCK_FUNCTION_HELPER(S, t, s, tpn) \
s MOCK_DECL(F, n, S,,tpn) \
{ \
BOOST_MPL_ASSERT_RELATION( n, ==, \
boost::function_types::function_arity< \
MOCK_FUNCTION_TYPE((S), tpn) >::value ); \
return MOCK_HELPER(t)( MOCK_FORWARD_PARAMS(n, S, tpn) ); \
#define MOCK_FUNCTION_AUX(F, n, S, t, s, tpn) \
MOCK_FUNCTION_HELPER(S, t, s, tpn) \
s MOCK_DECL(F, n, S, , tpn) \
{ \
BOOST_MPL_ASSERT_RELATION(n, ==, boost::function_types::function_arity<MOCK_FUNCTION_TYPE((S), tpn)>::value); \
return MOCK_HELPER(t)(MOCK_FORWARD_PARAMS(n, S, tpn)); \
}
#ifdef MOCK_VARIADIC_MACROS
#define MOCK_VARIADIC_ELEM_0(e0, ...) e0
#define MOCK_VARIADIC_ELEM_1(e0, e1, ...) e1
#define MOCK_VARIADIC_ELEM_2(e0, e1, e2, ...) e2
# define MOCK_VARIADIC_ELEM_0(e0, ...) e0
# define MOCK_VARIADIC_ELEM_1(e0, e1, ...) e1
# define MOCK_VARIADIC_ELEM_2(e0, e1, e2, ...) e2
#define MOCK_METHOD(M, ...) \
MOCK_METHOD_EXT(M, \
MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_VARIADIC_ELEM_1(__VA_ARGS__, MOCK_SIGNATURE(M), ), \
MOCK_VARIADIC_ELEM_2(__VA_ARGS__, M, M, ))
#define MOCK_CONST_METHOD(M, ...) \
MOCK_CONST_METHOD_EXT(M, \
MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_VARIADIC_ELEM_1(__VA_ARGS__, MOCK_SIGNATURE(M), ), \
MOCK_VARIADIC_ELEM_2(__VA_ARGS__, M, M, ))
#define MOCK_NON_CONST_METHOD(M, ...) \
MOCK_NON_CONST_METHOD_EXT(M, \
MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_VARIADIC_ELEM_1(__VA_ARGS__, MOCK_SIGNATURE(M), ), \
MOCK_VARIADIC_ELEM_2(__VA_ARGS__, M, M, ))
# define MOCK_METHOD(M, ...) \
MOCK_METHOD_EXT(M, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_VARIADIC_ELEM_1(__VA_ARGS__, MOCK_SIGNATURE(M), ), \
MOCK_VARIADIC_ELEM_2(__VA_ARGS__, M, M, ))
# define MOCK_CONST_METHOD(M, ...) \
MOCK_CONST_METHOD_EXT(M, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_VARIADIC_ELEM_1(__VA_ARGS__, MOCK_SIGNATURE(M), ), \
MOCK_VARIADIC_ELEM_2(__VA_ARGS__, M, M, ))
# define MOCK_NON_CONST_METHOD(M, ...) \
MOCK_NON_CONST_METHOD_EXT(M, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_VARIADIC_ELEM_1(__VA_ARGS__, MOCK_SIGNATURE(M), ), \
MOCK_VARIADIC_ELEM_2(__VA_ARGS__, M, M, ))
#define MOCK_METHOD_TPL(M, n, ...) \
MOCK_METHOD_EXT_TPL(M, n, \
MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, ))
#define MOCK_CONST_METHOD_TPL(M, n, ...) \
MOCK_CONST_METHOD_EXT_TPL(M, n, \
MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, ))
#define MOCK_NON_CONST_METHOD_TPL(M, n, ...) \
MOCK_NON_CONST_METHOD_EXT_TPL(M, n, \
MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, ))
# define MOCK_METHOD_TPL(M, n, ...) \
MOCK_METHOD_EXT_TPL(M, n, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, ))
# define MOCK_CONST_METHOD_TPL(M, n, ...) \
MOCK_CONST_METHOD_EXT_TPL(M, n, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, ))
# define MOCK_NON_CONST_METHOD_TPL(M, n, ...) \
MOCK_NON_CONST_METHOD_EXT_TPL(M, n, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), MOCK_VARIADIC_ELEM_1(__VA_ARGS__, M, ))
#define MOCK_FUNCTION(F, n, ...) \
MOCK_FUNCTION_AUX(F, n, \
MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_VARIADIC_ELEM_1(__VA_ARGS__, F, ), \
inline,)
# define MOCK_FUNCTION(F, n, ...) \
MOCK_FUNCTION_AUX(F, n, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), MOCK_VARIADIC_ELEM_1(__VA_ARGS__, F, ), inline, )
#define MOCK_STATIC_METHOD(F, n, ...) \
MOCK_FUNCTION_AUX(F, n, \
MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_VARIADIC_ELEM_1(__VA_ARGS__, F, ), \
static,)
# define MOCK_STATIC_METHOD(F, n, ...) \
MOCK_FUNCTION_AUX(F, n, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), MOCK_VARIADIC_ELEM_1(__VA_ARGS__, F, ), static, )
#define MOCK_STATIC_METHOD_TPL(F, n, ...) \
MOCK_FUNCTION_AUX(F, n, \
MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), \
MOCK_VARIADIC_ELEM_1(__VA_ARGS__, F, ), \
static, typename)
# define MOCK_STATIC_METHOD_TPL(F, n, ...) \
MOCK_FUNCTION_AUX(F, n, MOCK_VARIADIC_ELEM_0(__VA_ARGS__, ), MOCK_VARIADIC_ELEM_1(__VA_ARGS__, F, ), static, \
typename)
#else // MOCK_VARIADIC_MACROS
#define MOCK_METHOD(M, n) \
MOCK_METHOD_EXT(M, n, MOCK_SIGNATURE(M), M)
# define MOCK_METHOD(M, n) MOCK_METHOD_EXT(M, n, MOCK_SIGNATURE(M), M)
#define MOCK_FUNCTION(F, n, S, t) \
MOCK_FUNCTION_AUX(F, n, S, t, inline,)
# define MOCK_FUNCTION(F, n, S, t) MOCK_FUNCTION_AUX(F, n, S, t, inline, )
#define MOCK_STATIC_METHOD(F, n, S, t) \
MOCK_FUNCTION_AUX(F, n, S, t, static,)
# define MOCK_STATIC_METHOD(F, n, S, t) MOCK_FUNCTION_AUX(F, n, S, t, static, )
#define MOCK_STATIC_METHOD_TPL(F, n, S, t) \
MOCK_FUNCTION_AUX(F, n, S, t, static, typename)
# define MOCK_STATIC_METHOD_TPL(F, n, S, t) MOCK_FUNCTION_AUX(F, n, S, t, static, typename)
#endif // MOCK_VARIADIC_MACROS
#define MOCK_EXPECT(t) MOCK_HELPER(t).expect( __FILE__, __LINE__ )
#define MOCK_RESET(t) MOCK_HELPER(t).reset( __FILE__, __LINE__ )
#define MOCK_VERIFY(t) MOCK_HELPER(t).verify( __FILE__, __LINE__ )
#define MOCK_EXPECT(t) MOCK_HELPER(t).expect(__FILE__, __LINE__)
#define MOCK_RESET(t) MOCK_HELPER(t).reset(__FILE__, __LINE__)
#define MOCK_VERIFY(t) MOCK_HELPER(t).verify(__FILE__, __LINE__)
#endif // MOCK_MOCK_HPP_INCLUDED

78
include/turtle/object.hpp
View file

@ -10,65 +10,53 @@
#define MOCK_OBJECT_HPP_INCLUDED
#include "config.hpp"
#include "detail/object_impl.hpp"
#include "detail/root.hpp"
#include "detail/type_name.hpp"
#include "detail/object_impl.hpp"
#include <boost/make_shared.hpp>
#include <boost/optional.hpp>
#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
#include <boost/type_traits/is_base_of.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/make_shared.hpp>
#include <boost/optional.hpp>
namespace mock
{
class object;
namespace mock {
class object;
namespace detail
{
template< typename E >
E& configure( const object& o, E& e,
boost::unit_test::const_string instance,
boost::optional< type_name > type,
boost::unit_test::const_string name );
namespace detail {
template<typename E>
E& configure(const object& o, E& e, boost::unit_test::const_string instance, boost::optional<type_name> type,
boost::unit_test::const_string name);
template< typename T, typename E >
E& configure( const T& t, E& e,
boost::unit_test::const_string instance,
boost::optional< type_name > type,
boost::unit_test::const_string name,
typename boost::disable_if<
typename boost::is_base_of< object, T >
>::type* = 0 )
template<typename T, typename E>
E& configure(const T& t, E& e, boost::unit_test::const_string instance, boost::optional<type_name> type,
boost::unit_test::const_string name,
typename boost::disable_if<typename boost::is_base_of<object, T>>::type* = 0)
{
e.configure( detail::root, &t, instance, type, name );
e.configure(detail::root, &t, instance, type, name);
return e;
}
}
class object
{
public:
object()
: impl_( boost::make_shared< detail::object_impl >() )
{}
protected:
~object()
{}
public:
boost::shared_ptr< detail::object_impl > impl_;
};
namespace detail
} // namespace detail
class object
{
template< typename E >
E& configure( const object& o, E& e,
boost::unit_test::const_string instance,
boost::optional< type_name > type,
boost::unit_test::const_string name )
public:
object() : impl_(boost::make_shared<detail::object_impl>()) {}
protected:
~object() {}
public:
boost::shared_ptr<detail::object_impl> impl_;
};
namespace detail {
template<typename E>
E& configure(const object& o, E& e, boost::unit_test::const_string instance, boost::optional<type_name> type,
boost::unit_test::const_string name)
{
e.configure( *o.impl_, o.impl_.get(), instance, type, name );
e.configure(*o.impl_, o.impl_.get(), instance, type, name);
return e;
}
}
} // mock
} // namespace detail
} // namespace mock
#endif // MOCK_OBJECT_HPP_INCLUDED

33
include/turtle/reset.hpp
View file

@ -10,25 +10,24 @@
#define MOCK_RESET_HPP_INCLUDED
#include "config.hpp"
#include "object.hpp"
#include "detail/root.hpp"
#include "detail/functor.hpp"
#include "detail/root.hpp"
#include "object.hpp"
namespace mock
namespace mock {
inline void reset()
{
inline void reset()
{
detail::root.reset();
}
inline void reset( const object& o )
{
o.impl_->reset();
}
template< typename Signature >
void reset( detail::functor< Signature >& f )
{
f.reset();
}
} // mock
detail::root.reset();
}
inline void reset(const object& o)
{
o.impl_->reset();
}
template<typename Signature>
void reset(detail::functor<Signature>& f)
{
f.reset();
}
} // namespace mock
#endif // MOCK_RESET_HPP_INCLUDED

17
include/turtle/sequence.hpp
View file

@ -12,17 +12,14 @@
#include "config.hpp"
#include "detail/sequence_impl.hpp"
namespace mock
namespace mock {
class sequence
{
class sequence
{
public:
sequence()
: impl_( boost::make_shared< detail::sequence_impl >() )
{}
public:
sequence() : impl_(boost::make_shared<detail::sequence_impl>()) {}
boost::shared_ptr< detail::sequence_impl > impl_;
};
} // mock
boost::shared_ptr<detail::sequence_impl> impl_;
};
} // namespace mock
#endif // MOCK_SEQUENCE_HPP_INCLUDED

119
include/turtle/stream.hpp
View file

@ -13,48 +13,36 @@
#include <boost/noncopyable.hpp>
#include <ostream>
namespace mock
namespace mock {
struct stream
{
struct stream
{
explicit stream( std::ostream& s )
: s_( &s )
{}
std::ostream* s_;
};
explicit stream(std::ostream& s) : s_(&s) {}
std::ostream* s_;
};
#ifdef MOCK_USE_CONVERSIONS
namespace detail
{
namespace conversion
{
namespace detail { namespace conversion {
struct sink
{
template< typename T >
sink( const T& )
template<typename T>
sink(const T&)
{}
};
inline std::ostream& operator<<( std::ostream& s, const sink& )
{
return s << '?';
}
inline std::ostream& operator<<(std::ostream& s, const sink&) { return s << '?'; }
struct holder : boost::noncopyable
{
virtual ~holder()
{}
virtual void serialize( std::ostream& s ) const = 0;
virtual ~holder() {}
virtual void serialize(std::ostream& s) const = 0;
};
template< typename T >
template<typename T>
struct holder_imp : holder
{
explicit holder_imp( const T& t )
: t_( t )
{}
virtual void serialize( std::ostream& s ) const
explicit holder_imp(const T& t) : t_(t) {}
virtual void serialize(std::ostream& s) const
{
// if an error about an ambiguous conversion is generated by the
// line below the solution is to add a serialization operator to a
@ -66,77 +54,58 @@ namespace conversion
struct any : boost::noncopyable
{
template< typename T >
any( const T& t )
: h_( new holder_imp< T >( t ) )
template<typename T>
any(const T& t) : h_(new holder_imp<T>(t))
{}
~any()
{
delete h_;
}
~any() { delete h_; }
holder* h_;
};
}
}
}} // namespace detail::conversion
inline stream& operator<<( stream& s, const detail::conversion::any& d )
{
d.h_->serialize( *s.s_ );
return s;
}
inline stream& operator<<(stream& s, const detail::conversion::any& d)
{
d.h_->serialize(*s.s_);
return s;
}
#else // MOCK_USE_CONVERSIONS
namespace detail
{
namespace conversion
{
template< typename S, typename T >
S& operator<<( S &s, const T& )
namespace detail { namespace conversion {
template<typename S, typename T>
S& operator<<(S& s, const T&)
{
return s << '?';
}
}
}
}} // namespace detail::conversion
template< typename T >
stream& operator<<( stream& s, const T& t )
{
using namespace detail::conversion;
*s.s_ << t;
return s;
}
template<typename T>
stream& operator<<(stream& s, const T& t)
{
using namespace detail::conversion;
*s.s_ << t;
return s;
}
#endif // MOCK_USE_CONVERSIONS
namespace detail
{
template< typename T >
void serialize( stream& s, const T& t )
namespace detail {
template<typename T>
void serialize(stream& s, const T& t)
{
// if an error about an ambiguous conversion is generated by the
// line below the solution is to add a serialization operator to a
// mock::stream for T
s << t;
}
inline void serialize( stream& s, bool b )
{
s << (b ? "true" : "false");
}
template< typename C, typename T, typename A >
void serialize( stream& s, const std::basic_string< C, T, A >& str )
inline void serialize(stream& s, bool b) { s << (b ? "true" : "false"); }
template<typename C, typename T, typename A>
void serialize(stream& s, const std::basic_string<C, T, A>& str)
{
s << '"' << str << '"';
}
inline void serialize( stream& s, const char* const str )
{
s << '"' << str << '"';
}
inline void serialize( stream& s, unsigned char c )
{
s << static_cast< int >( c );
}
}
} // mock
inline void serialize(stream& s, const char* const str) { s << '"' << str << '"'; }
inline void serialize(stream& s, unsigned char c) { s << static_cast<int>(c); }
} // namespace detail
} // namespace mock
#endif // MOCK_STREAM_HPP_INCLUDED

33
include/turtle/verify.hpp
View file

@ -10,25 +10,24 @@
#define MOCK_VERIFY_HPP_INCLUDED
#include "config.hpp"
#include "object.hpp"
#include "detail/root.hpp"
#include "detail/functor.hpp"
#include "detail/root.hpp"
#include "object.hpp"
namespace mock
namespace mock {
inline bool verify()
{
inline bool verify()
{
return detail::root.verify();
}
inline bool verify( const object& o )
{
return o.impl_->verify();
}
template< typename Signature >
bool verify( const detail::functor< Signature >& f )
{
return f.verify();
}
} // mock
return detail::root.verify();
}
inline bool verify(const object& o)
{
return o.impl_->verify();
}
template<typename Signature>
bool verify(const detail::functor<Signature>& f)
{
return f.verify();
}
} // namespace mock
#endif // MOCK_VERIFY_HPP_INCLUDED