mirror of
https://github.com/mat007/turtle.git
synced 2026-06-22 12:13:43 +00:00
692 lines
17 KiB
C++
692 lines
17 KiB
C++
// http://turtle.sourceforge.net
|
|
//
|
|
// Copyright Mathieu Champlon 2008
|
|
//
|
|
// Distributed under the Boost Software License, Version 1.0.
|
|
// (See accompanying file LICENSE_1_0.txt or copy at
|
|
// http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
#include "mock_error.hpp"
|
|
#include "undefined.hpp"
|
|
#include <turtle/mock.hpp>
|
|
#include <boost/test/auto_unit_test.hpp>
|
|
#include <boost/noncopyable.hpp>
|
|
#include <boost/optional.hpp>
|
|
#include <boost/ref.hpp>
|
|
#include <cmath>
|
|
|
|
namespace
|
|
{
|
|
struct my_custom_mock
|
|
{
|
|
MOCK_METHOD_EXT( my_method, 0, void(), my_tag )
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( custom_mock_object_without_macros_and_without_inheriting_from_object, mock_error_fixture )
|
|
{
|
|
my_custom_mock m;
|
|
MOCK_EXPECT( m.my_tag ).once();
|
|
m.my_method();
|
|
CHECK_CALLS( 1 );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
struct my_custom_mock_object
|
|
{
|
|
MOCK_METHOD_EXT( my_method, 0, void(), my_tag )
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( custom_mock_object_without_macros, mock_error_fixture )
|
|
{
|
|
my_custom_mock_object m;
|
|
MOCK_EXPECT( m.my_tag ).once();
|
|
m.my_method();
|
|
CHECK_CALLS( 1 );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
MOCK_CLASS( my_mock )
|
|
{
|
|
MOCK_METHOD_EXT( my_method, 1, int( int ), my_tag )
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( basic_mock_object_usage, mock_error_fixture )
|
|
{
|
|
my_mock m;
|
|
{
|
|
MOCK_EXPECT( m.my_tag ).once().returns( 0 );
|
|
BOOST_CHECK_EQUAL( 0, m.my_method( 13 ) );
|
|
CHECK_CALLS( 1 );
|
|
}
|
|
mock::verify();
|
|
mock::reset();
|
|
{
|
|
MOCK_EXPECT( m.my_tag ).once().with( 42 ).returns( 7 );
|
|
BOOST_CHECK_EQUAL( 7, m.my_method( 42 ) );
|
|
CHECK_CALLS( 1 );
|
|
}
|
|
mock::verify();
|
|
mock::reset();
|
|
{
|
|
MOCK_EXPECT( m.my_tag ).once().returns( 51 );
|
|
BOOST_CHECK_EQUAL( 51, m.my_method( 27 ) );
|
|
CHECK_CALLS( 1 );
|
|
}
|
|
}
|
|
|
|
namespace
|
|
{
|
|
class my_ambiguited_interface : boost::noncopyable
|
|
{
|
|
public:
|
|
virtual ~my_ambiguited_interface() {}
|
|
|
|
virtual void my_method() = 0;
|
|
virtual void my_method( int ) = 0;
|
|
};
|
|
|
|
MOCK_BASE_CLASS( my_ambiguited_mock, my_ambiguited_interface )
|
|
{
|
|
MOCK_METHOD_EXT( my_method, 0, void(), my_tag1 )
|
|
MOCK_METHOD_EXT( my_method, 1, void( int ), my_tag_2 )
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( mock_object_method_disambiguation, mock_error_fixture )
|
|
{
|
|
my_ambiguited_mock m;
|
|
MOCK_EXPECT( m.my_tag1 );
|
|
m.my_method();
|
|
CHECK_ERROR( m.my_method( 12 ), "unexpected call", 1, "?.my_ambiguited_mock::my_tag_2( 12 )" );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
class my_const_ambiguited_interface : boost::noncopyable
|
|
{
|
|
public:
|
|
virtual ~my_const_ambiguited_interface() {}
|
|
|
|
virtual void my_method() = 0;
|
|
virtual void my_method() const = 0;
|
|
};
|
|
|
|
MOCK_BASE_CLASS( my_const_ambiguited_mock, my_const_ambiguited_interface )
|
|
{
|
|
MOCK_NON_CONST_METHOD_EXT( my_method, 0, void(), tag1 )
|
|
MOCK_CONST_METHOD_EXT( my_method, 0, void(), tag_2 )
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( mock_object_method_const_disambiguation, mock_error_fixture )
|
|
{
|
|
my_const_ambiguited_mock mock;
|
|
MOCK_EXPECT( mock.tag1 );
|
|
BOOST_CHECK_NO_THROW( mock.my_method() );
|
|
const my_const_ambiguited_mock const_mock;
|
|
CHECK_ERROR( const_mock.my_method(), "unexpected call", 1, "?.my_const_ambiguited_mock::tag_2()" );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
MOCK_CLASS( my_undefined_mock )
|
|
{
|
|
MOCK_METHOD_EXT( m, 1, void( undefined& ), t )
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( mock_object_method_with_declared_but_not_defined_parameter_is_valid, mock_error_fixture )
|
|
{
|
|
my_undefined_mock mock;
|
|
MOCK_EXPECT( mock.t );
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( mock_functor_in_function_is_supported, mock_error_fixture )
|
|
{
|
|
boost::function< int( float, const std::string& ) > func;
|
|
{
|
|
MOCK_FUNCTOR( f, int( float, const std::string& ) );
|
|
MOCK_EXPECT( f ).once().with( 3, "op" ).returns( 42 );
|
|
func = f;
|
|
}
|
|
BOOST_CHECK_EQUAL( 42, func( 3, "op" ) );
|
|
CHECK_CALLS( 1 );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
struct functor_fixture : mock_error_fixture
|
|
{
|
|
MOCK_FUNCTOR( f, int( float, const std::string& ) );
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( mock_functor_in_fixture_is_supported, functor_fixture )
|
|
{
|
|
MOCK_EXPECT( f ).once().with( 3, "op" ).returns( 42 );
|
|
BOOST_CHECK_EQUAL( 42, f( 3.f, "op" ) );
|
|
CHECK_CALLS( 1 );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
template< typename T >
|
|
struct my_template_mock
|
|
{
|
|
MOCK_METHOD_EXT( my_method, 0, void(), my_tag )
|
|
MOCK_METHOD_EXT_TPL( my_method, 2, void( T, std::string ), my_tpl_tag )
|
|
MOCK_METHOD_EXT_TPL( my_other_method, 0, void(), my_other_tag )
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( mocking_a_template_class_method_is_supported, mock_error_fixture )
|
|
{
|
|
my_template_mock< int > m;
|
|
MOCK_EXPECT( m.my_tpl_tag ).with( 3, "" );
|
|
m.my_method( 3, "" );
|
|
BOOST_CHECK( MOCK_VERIFY( m.my_tpl_tag ) );
|
|
CHECK_CALLS( 1 );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
template< typename T >
|
|
struct my_template_base_class
|
|
{
|
|
virtual ~my_template_base_class()
|
|
{}
|
|
virtual void my_method( T ) = 0;
|
|
virtual void my_other_method() = 0;
|
|
};
|
|
template< typename T >
|
|
MOCK_BASE_CLASS( my_template_base_class_mock, my_template_base_class< T > )
|
|
{
|
|
MOCK_METHOD_EXT_TPL( my_method, 1, void( T ), my_method )
|
|
MOCK_METHOD_EXT_TPL( my_other_method, 0, void(), my_other_method )
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( mocking_a_template_base_class_method_is_supported, mock_error_fixture )
|
|
{
|
|
my_template_base_class_mock< int > m;
|
|
MOCK_EXPECT( m.my_method ).once().with( 3 );
|
|
m.my_method( 3 );
|
|
BOOST_CHECK( MOCK_VERIFY( m.my_method ) );
|
|
CHECK_CALLS( 1 );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
class my_observer : boost::noncopyable
|
|
{
|
|
public:
|
|
virtual ~my_observer()
|
|
{}
|
|
virtual void notify( int value ) = 0;
|
|
};
|
|
|
|
class my_manager : boost::noncopyable
|
|
{
|
|
public:
|
|
virtual ~my_manager()
|
|
{}
|
|
virtual my_observer& get_observer() const = 0;
|
|
};
|
|
|
|
class my_subject : boost::noncopyable
|
|
{
|
|
public:
|
|
explicit my_subject( my_manager& f )
|
|
: o_( f.get_observer() )
|
|
, value_( 0 )
|
|
{}
|
|
void increment()
|
|
{
|
|
o_.notify( ++value_ );
|
|
}
|
|
private:
|
|
my_observer& o_;
|
|
int value_;
|
|
};
|
|
|
|
MOCK_BASE_CLASS( my_mock_observer, my_observer )
|
|
{
|
|
MOCK_METHOD( notify, 1 )
|
|
};
|
|
|
|
MOCK_BASE_CLASS( my_mock_manager, my_manager )
|
|
{
|
|
MOCK_METHOD( get_observer, 0 )
|
|
};
|
|
|
|
struct fixture : mock_error_fixture
|
|
{
|
|
my_mock_manager manager;
|
|
my_mock_observer observer;
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( basic_mock_object_collaboration_usage, fixture )
|
|
{
|
|
MOCK_EXPECT( manager.get_observer ).returns( boost::ref( observer ) );
|
|
my_subject subject( manager );
|
|
MOCK_EXPECT( observer.notify ).once().with( 1 );
|
|
subject.increment();
|
|
MOCK_EXPECT( observer.notify ).once().with( 2 );
|
|
subject.increment();
|
|
MOCK_EXPECT( observer.notify ).once().with( 3 );
|
|
subject.increment();
|
|
CHECK_CALLS( 4 );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
MOCK_CLASS( my_constructed_class )
|
|
{
|
|
MOCK_CONSTRUCTOR( my_constructed_class, 2, ( int, const std::string& ), constructor )
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( mocking_a_constructor, mock_error_fixture )
|
|
{
|
|
MOCK_EXPECT( my_constructed_class::constructor ).with( 42, "some text" ).once();
|
|
my_constructed_class( 42, "some text" );
|
|
BOOST_CHECK( MOCK_VERIFY( my_constructed_class::constructor ) );
|
|
CHECK_CALLS( 1 );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
template< typename T >
|
|
MOCK_CLASS( my_constructed_template_class )
|
|
{
|
|
MOCK_CONSTRUCTOR_TPL( my_constructed_template_class, 2, ( T, const std::string& ), constructor )
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( mocking_a_template_class_constructor, mock_error_fixture )
|
|
{
|
|
MOCK_EXPECT( my_constructed_template_class< int >::constructor ).with( 42, "some text" ).once();
|
|
my_constructed_template_class< int >( 42, "some text" );
|
|
BOOST_CHECK( MOCK_VERIFY( my_constructed_template_class< int >::constructor ) );
|
|
CHECK_CALLS( 1 );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
MOCK_CLASS( my_destroyed_class )
|
|
{
|
|
MOCK_DESTRUCTOR( ~my_destroyed_class, destructor )
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( mocking_a_destructor, mock_error_fixture )
|
|
{
|
|
{
|
|
my_destroyed_class c;
|
|
MOCK_EXPECT( c.destructor ).once();
|
|
}
|
|
CHECK_CALLS( 1 );
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( failed_expectation_in_mocked_destructor_does_not_throw, mock_error_fixture )
|
|
{
|
|
CHECK_ERROR(
|
|
try
|
|
{
|
|
my_destroyed_class c;
|
|
throw std::runtime_error( "should not crash" );
|
|
}
|
|
catch( std::runtime_error& )
|
|
{
|
|
},
|
|
"unexpected call", 0, "?.my_destroyed_class::destructor()" );
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( failed_sequence_in_mocked_destructor_does_not_throw, mock_error_fixture )
|
|
{
|
|
mock::sequence s;
|
|
my_custom_mock m;
|
|
CHECK_ERROR(
|
|
{
|
|
my_destroyed_class c;
|
|
MOCK_EXPECT( c.destructor ).once().in( s );
|
|
MOCK_EXPECT( m.my_tag ).once().in( s );
|
|
m.my_method();
|
|
},
|
|
"sequence failed", 1, "c.my_destroyed_class::destructor()\n. once()" );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
MOCK_CLASS( boost_optional )
|
|
{
|
|
MOCK_METHOD_EXT( method, 0, boost::optional< my_observer& >(), tag )
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( boost_optional_on_base_class_reference_as_return_type_is_supported, mock_error_fixture )
|
|
{
|
|
boost_optional b;
|
|
my_mock_observer o;
|
|
MOCK_EXPECT( b.tag ).once().returns( boost::ref( o ) );
|
|
b.method();
|
|
CHECK_CALLS( 1 );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
bool serialized = false;
|
|
|
|
struct custom_argument
|
|
{
|
|
friend std::ostream& operator<<( std::ostream& s, custom_argument )
|
|
{
|
|
serialized = true;
|
|
return s;
|
|
}
|
|
};
|
|
struct custom_constraint
|
|
{
|
|
template< typename Actual >
|
|
friend bool operator==( Actual, custom_constraint )
|
|
{
|
|
return true;
|
|
}
|
|
friend std::ostream& operator<<( std::ostream& s, custom_constraint )
|
|
{
|
|
serialized = true;
|
|
return s;
|
|
}
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( constraints_and_arguments_are_serialized_lazily, mock_error_fixture )
|
|
{
|
|
MOCK_FUNCTOR( f, void( const custom_argument& ) );
|
|
MOCK_EXPECT( f ).with( custom_constraint() );
|
|
f( custom_argument() );
|
|
BOOST_CHECK( ! serialized );
|
|
CHECK_CALLS( 1 );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
struct custom_constraint_with_non_const_operator
|
|
{
|
|
template< typename Actual >
|
|
bool operator()( Actual actual )
|
|
{
|
|
return actual == 42;
|
|
}
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( custom_constraint_function_operator_does_not_need_to_be_const, mock_error_fixture )
|
|
{
|
|
MOCK_FUNCTOR( f, void( float ) );
|
|
MOCK_EXPECT( f ).with( mock::constraint< custom_constraint_with_non_const_operator >( custom_constraint_with_non_const_operator() ) );
|
|
f( 42 );
|
|
CHECK_CALLS( 1 );
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( boost_reference_wrapper_is_supported_in_value_constraint, mock_error_fixture )
|
|
{
|
|
MOCK_FUNCTOR( f, void( const std::string& ) );
|
|
std::string s;
|
|
MOCK_EXPECT( f ).once().with( boost::cref( s ) );
|
|
s = "string";
|
|
f( "string" );
|
|
CHECK_CALLS( 1 );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
template< typename T >
|
|
void nothing( T )
|
|
{}
|
|
|
|
struct member_pointer_mock_class
|
|
{
|
|
MOCK_CONST_METHOD_EXT( my_method, 0, void(), my_method )
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( member_pointer_on_mock_method_is_valid, mock_error_fixture )
|
|
{
|
|
nothing( &member_pointer_mock_class::my_method );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
MOCK_FUNCTION( free_function, 1, void( int ), free_function )
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( a_free_function_can_be_mocked, mock_error_fixture )
|
|
{
|
|
MOCK_EXPECT( free_function ).once();
|
|
CHECK_ERROR(
|
|
BOOST_CHECK( ! MOCK_VERIFY( free_function ) ),
|
|
"verification failed", 0, "free_function\n. once().with( any )" );
|
|
free_function( 42 );
|
|
CHECK_CALLS( 1 );
|
|
BOOST_CHECK( MOCK_VERIFY( free_function ) );
|
|
MOCK_RESET( free_function );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
struct some_class : mock::object
|
|
{
|
|
MOCK_STATIC_METHOD( some_static_method, 1, void( int ), some_static_method )
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( a_static_method_can_be_mocked, mock_error_fixture )
|
|
{
|
|
MOCK_EXPECT( some_class::some_static_method ).once();
|
|
CHECK_ERROR(
|
|
BOOST_CHECK( ! MOCK_VERIFY( some_class::some_static_method ) ),
|
|
"verification failed", 0, "some_class::some_static_method\n. once().with( any )" );
|
|
some_class::some_static_method( 42 );
|
|
CHECK_CALLS( 1 );
|
|
BOOST_CHECK( MOCK_VERIFY( some_class::some_static_method ) );
|
|
MOCK_RESET( some_class::some_static_method );
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( a_static_method_is_not_reset_when_resetting_an_instance_of_the_class, mock_error_fixture )
|
|
{
|
|
MOCK_EXPECT( some_class::some_static_method ).once();
|
|
some_class c;
|
|
mock::reset( c );
|
|
CHECK_ERROR(
|
|
BOOST_CHECK( ! MOCK_VERIFY( some_class::some_static_method ) ),
|
|
"verification failed", 0, "some_class::some_static_method\n. once().with( any )" );
|
|
MOCK_RESET( some_class::some_static_method );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
template< typename T >
|
|
struct some_template_class
|
|
{
|
|
MOCK_STATIC_METHOD_TPL( some_static_method, 1, void( T ), some_static_method )
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( a_static_method_in_a_template_class_can_be_mocked, mock_error_fixture )
|
|
{
|
|
MOCK_EXPECT( some_template_class< int >::some_static_method ).once();
|
|
CHECK_ERROR(
|
|
BOOST_CHECK( ! MOCK_VERIFY( some_template_class< int >::some_static_method ) ),
|
|
"verification failed", 0, "some_template_class< int >::some_static_method\n. once().with( any )" );
|
|
some_template_class< int >::some_static_method( 42 );
|
|
BOOST_CHECK( mock::verify() );
|
|
BOOST_CHECK( MOCK_VERIFY( some_template_class< int >::some_static_method ) );
|
|
MOCK_RESET( some_template_class< int >::some_static_method );
|
|
CHECK_CALLS( 1 );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
MOCK_CLASS( mock_class )
|
|
{
|
|
MOCK_METHOD_EXT( m, 0, void(), t );
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( resetting_referenced_mock_class_does_not_crash, mock_error_fixture )
|
|
{
|
|
MOCK_FUNCTOR( f, mock_class() );
|
|
{
|
|
mock_class c;
|
|
MOCK_EXPECT( f ).returns( c );
|
|
MOCK_EXPECT( c.t );
|
|
}
|
|
mock::reset();
|
|
}
|
|
|
|
namespace
|
|
{
|
|
MOCK_CLASS( mock_class2 )
|
|
{
|
|
MOCK_METHOD_EXT( m, 0, mock_class2(), t );
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( resetting_self_referenced_mock_class_does_not_crash, mock_error_fixture )
|
|
{
|
|
{
|
|
mock_class2 c;
|
|
MOCK_EXPECT( c.t ).returns( c );
|
|
}
|
|
mock::reset();
|
|
}
|
|
|
|
namespace
|
|
{
|
|
template< typename T1, typename T2 >
|
|
struct my_base
|
|
{};
|
|
MOCK_BASE_CLASS( my_comma_mock, my_base< int BOOST_PP_COMMA() int > )
|
|
{};
|
|
}
|
|
|
|
#ifdef MOCK_THREAD_SAFE
|
|
|
|
#include <boost/thread.hpp>
|
|
|
|
namespace
|
|
{
|
|
void create_class()
|
|
{
|
|
my_mock m;
|
|
MOCK_EXPECT( m.my_tag ).once().with( 3 ).returns( 42 );
|
|
try
|
|
{
|
|
m.my_method( 3 );
|
|
}
|
|
catch( ... )
|
|
{}
|
|
}
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( mock_class_creation_is_thread_safe, mock_error_fixture )
|
|
{
|
|
boost::thread_group group;
|
|
for( int i = 0; i < 100; ++i )
|
|
group.create_thread( &create_class );
|
|
group.join_all();
|
|
CHECK_CALLS( 100 );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
void create_functor( int i )
|
|
{
|
|
mock::detail::functor< void( int ) > f;
|
|
boost::this_thread::sleep( boost::posix_time::milliseconds( 100 ) );
|
|
mock::detail::functor< void( int ) > f_mock;
|
|
MOCK_EXPECT( f ).once().with( i );
|
|
try
|
|
{
|
|
f( i );
|
|
}
|
|
catch( ... )
|
|
{}
|
|
}
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( mock_functor_creation_is_thread_safe, mock_error_fixture )
|
|
{
|
|
boost::thread_group group;
|
|
for( int i = 0; i < 100; ++i )
|
|
group.create_thread( boost::bind( &create_functor, i ) );
|
|
group.join_all();
|
|
CHECK_CALLS( 100 );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
void iterate( my_mock& m )
|
|
{
|
|
MOCK_EXPECT( m.my_tag ).once().with( 3 ).returns( 42 );
|
|
BOOST_CHECK_EQUAL( 42, m.my_method( 3 ) );
|
|
}
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( mock_class_is_thread_safe, mock_error_fixture )
|
|
{
|
|
my_mock m;
|
|
boost::thread_group group;
|
|
for( int i = 0; i < 100; ++i )
|
|
group.create_thread( boost::bind( &iterate, boost::ref( m ) ) );
|
|
group.join_all();
|
|
CHECK_CALLS( 100 );
|
|
}
|
|
|
|
#endif // MOCK_THREAD_SAFE
|
|
|
|
namespace
|
|
{
|
|
MOCK_CLASS( my_multi_mock )
|
|
{
|
|
MOCK_METHOD_EXT( m1, 1, void( int ), m1 );
|
|
MOCK_METHOD_EXT( m2, 2, void( int, int ), m2 );
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( mock_method_accepts_multi_constraint, mock_error_fixture )
|
|
{
|
|
my_multi_mock m;
|
|
MOCK_FUNCTOR( f, bool( int, int ) );
|
|
MOCK_EXPECT( m.m2 ).once().with( f );
|
|
MOCK_EXPECT( f ).once().with( 1, 2 ).returns( true );
|
|
m.m2( 1, 2 );
|
|
CHECK_CALLS( 2 );
|
|
}
|
|
|
|
namespace
|
|
{
|
|
struct my_polymorphic_constraint
|
|
{
|
|
template< typename T1, typename T2 >
|
|
bool operator()( T1, T2 ) const
|
|
{
|
|
return true;
|
|
}
|
|
};
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( mock_method_accepts_polymorphic_multi_constraint, mock_error_fixture )
|
|
{
|
|
my_multi_mock m;
|
|
MOCK_EXPECT( m.m2 ).once().with( my_polymorphic_constraint() );
|
|
m.m2( 1, 2 );
|
|
CHECK_CALLS( 1 );
|
|
}
|