From d2fbf4167bf7ffd593c8ad037b80d95202318e78 Mon Sep 17 00:00:00 2001 From: mat007 Date: Sun, 12 May 2013 08:58:40 +0000 Subject: [PATCH] Moved examples to source code git-svn-id: https://svn.code.sf.net/p/turtle/code/trunk@643 860be788-9bd5-4423-9f1e-828f051e677b --- build/boost/doc/Jamfile.jam | 27 +- build/boost/doc/example/reference.cpp | 773 ++++++++++++++++++++++++++ build/boost/doc/limitations.qbk | 2 +- build/boost/doc/reference.qbk | 604 +++++--------------- 4 files changed, 914 insertions(+), 492 deletions(-) create mode 100644 build/boost/doc/example/reference.cpp diff --git a/build/boost/doc/Jamfile.jam b/build/boost/doc/Jamfile.jam index b68626b..3542e54 100644 --- a/build/boost/doc/Jamfile.jam +++ b/build/boost/doc/Jamfile.jam @@ -13,19 +13,19 @@ using doxygen ; xml mock : mock.qbk ; -doxygen reference - : - [ glob ../../../boost/mock/*.hpp ] - : - EXPAND_ONLY_PREDEF=YES - HIDE_UNDOC_MEMBERS=NO - QUIET=YES - WARN_IF_UNDOCUMENTED=NO - EXTRACT_PRIVATE=NO - ENABLE_PREPROCESSING=YES - MACRO_EXPANSION=YES - SEARCH_INCLUDES=NO -; +#doxygen reference +# : +# [ glob ../../../boost/mock/*.hpp ] +# : +# EXPAND_ONLY_PREDEF=YES +# HIDE_UNDOC_MEMBERS=NO +# QUIET=YES +# WARN_IF_UNDOCUMENTED=NO +# EXTRACT_PRIVATE=NO +# ENABLE_PREPROCESSING=YES +# MACRO_EXPANSION=YES +# SEARCH_INCLUDES=NO +#; boostbook standalone : @@ -51,3 +51,4 @@ compile example/patterns_async_call.cpp ; compile example/patterns_retrieve_cref.cpp ; compile example/patterns_invoke_functor.cpp ; compile example/patterns_quick_constraint.cpp ; +compile example/reference.cpp ; diff --git a/build/boost/doc/example/reference.cpp b/build/boost/doc/example/reference.cpp new file mode 100644 index 0000000..7fee34f --- /dev/null +++ b/build/boost/doc/example/reference.cpp @@ -0,0 +1,773 @@ +#define BOOST_AUTO_TEST_MAIN +#include +#include + +namespace class_example_1 +{ +//[ class_example_1 +MOCK_CLASS( mock_class ) +{}; + +BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_mock_class ) +{ + mock_class c; +} +//] +} + +namespace class_example_2 +{ +//[ class_example_2 +template< typename T > +MOCK_CLASS( mock_class ) +{}; + +BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_template_mock_class ) +{ + mock_class< int > c; +} +//] +} + +namespace class_example_3 +{ +//[ class_example_3 +struct base_class +{}; + +MOCK_BASE_CLASS( mock_class, base_class ) +{}; + +BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_derived_mock_class ) +{ + mock_class c; +} +//] +} + +namespace class_example_4 +{ +//[ class_example_4 +template< typename T > +struct base_class +{}; + +template< typename T > +MOCK_BASE_CLASS( mock_class, base_class< T > ) +{}; + +BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_template_derived_mock_class ) +{ + mock_class< int > c; +} +//] +} + +namespace class_example_5 +{ +//[ class_example_5 +struct name : mock::object // equivalent to using MOCK_CLASS +{}; +//] +} + +namespace class_example_6 +{ +//[ class_example_6 +template< typename T > +struct name : mock::object // equivalent to using MOCK_CLASS +{}; +//] +} + +namespace class_example_7 +{ +//[ class_example_7 +class base +{}; + +struct name : base, mock::object // equivalent to using MOCK_BASE_CLASS +{ + typedef base base_type; // this is required for MOCK_METHOD to work when not using MOCK_BASE_CLASS +}; +//] +} + +namespace class_example_8 +{ +//[ class_example_8 +template< typename T > +struct base +{}; + +template< typename T > +struct mock : base< T >, mock::object +{ + typedef typename base< T > base_type; +}; +//] +} + +namespace member_function_example_1 +{ +//[ member_function_example_1 +struct base_class +{ + virtual ~base_class() + {} + virtual void method( int ) = 0; +}; + +MOCK_BASE_CLASS( mock_class, base_class ) +{ + MOCK_METHOD( method, 1 ) // only possible when referring unambiguously to a base class method +}; +//] +} + +namespace member_function_example_2 +{ +//[ member_function_example_2 +struct base_class +{ + virtual ~base_class() + {} + virtual void method( int, const std::string& ) = 0; + virtual void method( float ) = 0; +}; + +MOCK_BASE_CLASS( mock_class, base_class ) +{ + MOCK_METHOD( method, 2, void( int, const std::string& ), identifier_1 ) // MOCK_METHOD cannot be used because of overloading + MOCK_METHOD( method, 1, void( float ), identifier_2 ) // the identifier must differ from the previous one in order to fully disambiguate methods +}; +//] +} + +namespace member_function_example_3 +{ +//[ member_function_example_3 +struct base_class +{ + virtual ~base_class() + {} + virtual void method( float ) = 0; + virtual void method( float ) const = 0; +}; + +MOCK_BASE_CLASS( mock_class, base_class ) +{ + MOCK_METHOD( method, 1, void( float ), method ) // this generates both const and non-const versions +}; +//] +} + +namespace member_function_example_4 +{ +//[ member_function_example_4 +struct base_class +{ + virtual ~base_class() + {} + virtual void method( float ) = 0; + virtual void method( float ) const = 0; +}; + +MOCK_BASE_CLASS( mock_class, base_class ) +{ + MOCK_CONST_METHOD( method, 1, void( float ), identifier_1 ) // this generates only the const version + MOCK_NON_CONST_METHOD( method, 1, void( float ), identifier_2 ) // this generates only the non-const version, with a different identifier +}; +//] +} + +namespace member_function_example_5 +{ +//[ member_function_example_5 +struct base_class +{ + virtual ~base_class() + {} + virtual void method( float ) = 0; +}; + +struct mock_class : base_class +{ + typedef base_class base_type; // this is required for MOCK_METHOD to work when not using MOCK_BASE_CLASS + + MOCK_METHOD( method, 1 ) +}; +//] +} + +namespace member_function_example_6 +{ +//[ member_function_example_6 +MOCK_CLASS( mock_class ) +{ + MOCK_NON_CONST_METHOD( operator=, 1, mock_class&( const mock_class& ), assignment ) // operators require a custom identifier +}; +//] +} + +namespace member_function_example_7 +{ +//[ member_function_example_7 +template< typename T > +MOCK_CLASS( mock_class ) +{ + MOCK_METHOD_TPL( method, 1, void( const T& ) ) // the _TPL variants must be used if the signature includes a template parameter of the class +}; +//] +} + +namespace member_function_example_8 +{ +//[ member_function_example_8 +MOCK_CLASS( mock_class ) +{ + MOCK_METHOD( method, 0, (std::map< int, int >()) ) // the signature must be surrounded with round parenthesis if the return type contains a comma +}; +//] +} + +namespace static_member_function_example_1 +{ +//[ static_member_function_example_1 +MOCK_CLASS( mock_class ) +{ + MOCK_STATIC_METHOD( method, 1, float( int ) ) +}; +//] +} + +namespace static_member_function_example_2 +{ +//[ static_member_function_example_2 +template< typename T > +MOCK_CLASS( mock_class ) +{ + MOCK_STATIC_METHOD_TPL( method, 1, void( T ) ) +}; +//] +} + +namespace constructor_example_1 +{ +//[ constructor_example_1 +MOCK_CLASS( mock_class ) +{ + MOCK_CONSTRUCTOR( mock_class, 2, ( int, const std::string& ), identifier ) +}; +//] +} + +namespace constructor_example_2 +{ +//[ constructor_example_2 +template< typename T > +MOCK_CLASS( mock_class ) +{ + MOCK_CONSTRUCTOR( mock_class, 2, ( int, const std::string& ), identifier ) + MOCK_CONSTRUCTOR_TPL( mock_class, 2, ( T, const std::string& ), identifier ) +}; +//] +} + +namespace destructor_example_1 +{ +//[ destructor_example_1 +MOCK_CLASS( mock_class ) +{ + MOCK_DESTRUCTOR( mock_class, destructor ) +}; +//] +} + +namespace conversion_operator_example_1 +{ +//[ conversion_operator_example_1 +MOCK_CLASS( mock_class ) +{ + MOCK_CONVERSION_OPERATOR( int, conversion_to_int ) + MOCK_CONST_CONVERSION_OPERATOR( const std::string&, conversion_to_string ) +}; +//] +} + +namespace conversion_operator_example_2 +{ +//[ conversion_operator_example_2 +template< typename T > +MOCK_CLASS( mock_class ) +{ + MOCK_CONVERSION_OPERATOR_TPL( T, conversion_to_T ) // the _TPL variants must be used if the signature includes a template parameter of the class + MOCK_CONST_CONVERSION_OPERATOR( const std::string&, const_conversion_to_string ) + MOCK_NON_CONST_CONVERSION_OPERATOR( const std::string&, non_const_conversion_to_string ) +}; +//] +} + +namespace functor_example_1 +{ +//[ functor_example_1 +BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_mock_functor ) +{ + MOCK_FUNCTOR( f, void( int ) ); + f( 3 ); +} +//] +} + +namespace functor_example_2 +{ +//[ functor_example_2 +template< typename T > +struct mock_class +{ + MOCK_FUNCTOR_TPL( f, void( T ) ); +}; + +BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_mock_functor ) +{ + mock_class< int > c; + c.f( 3 ); +} +//] +} + +namespace function_example_1 +{ +//[ function_example_1 +MOCK_FUNCTION( f, 1, float( int ) ) + +BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_mock_function ) +{ + f( 3 ); +} +//] +} + +namespace expectation_example_1 +{ +//[ expectation_example_1 +MOCK_CLASS( mock_class ) +{ + MOCK_METHOD( method, 1, int( int ), method ) + MOCK_METHOD( method, 2, void( const std::string&, float ), method2 ) +}; + +BOOST_AUTO_TEST_CASE( demonstrates_configuring_mock_objects ) +{ + mock_class c; + mock::sequence s; + MOCK_EXPECT( c.method ).once().with( 0 ).in( s ).returns( 42 ); + MOCK_EXPECT( c.method2 ).never().with( "ok", mock::any ); + MOCK_EXPECT( c.method2 ).at_least( 2 ).in( s ).throws( std::runtime_error( "error !" ) ); +} +//] +} + +namespace invocation_example_1 +{ +//[ invocation_example_1 +MOCK_CLASS( mock_class ) +{ + MOCK_METHOD( method, 2, void( int, const std::string& ) ) +}; + +BOOST_AUTO_TEST_CASE( demonstrates_setting_up_invocations_on_a_mock_method ) +{ + mock_class c; + MOCK_EXPECT( c.method ).once(); // can only be called once + MOCK_EXPECT( c.method ); // can be called an unlimited number of times +} +//] +} + +namespace invocation_example_2 +{ +//[ invocation_example_2 +BOOST_AUTO_TEST_CASE( demonstrates_setting_up_an_invocation_on_a_mock_functor ) +{ + MOCK_FUNCTOR( f, void( int, const std::string& ) ); + MOCK_EXPECT( f ).once(); +} +//] +} + +namespace invocation_example_3 +{ +//[ invocation_example_3 +MOCK_FUNCTION( f, 1, float( int ) ) + +BOOST_AUTO_TEST_CASE( demonstrates_setting_up_an_invocation_on_a_mock_function ) +{ + MOCK_EXPECT( f ).once(); +} +//] +} + +namespace invocation_example_4 +{ +//[ invocation_example_4 +MOCK_CLASS( mock_class ) +{ + MOCK_STATIC_METHOD( method, 1, float( int ) ) +}; + +BOOST_AUTO_TEST_CASE( demonstrates_setting_up_an_invocation_on_a_mock_static_method ) +{ + mock_class c; + MOCK_EXPECT( c.method ).once(); + MOCK_EXPECT( mock_class::method ).once(); // does the same +} +//] +} + +namespace constraints_example_1 +{ +//[ constraints_example_1 +MOCK_CLASS( mock_class ) +{ + MOCK_METHOD( method, 2, void( int, const std::string& ) ) +}; + +BOOST_AUTO_TEST_CASE( demonstrates_adding_builtin_constraints ) +{ + mock_class c; + MOCK_EXPECT( c.method ).with( mock::equal( 3 ), mock::equal( "some string" ) ); + MOCK_EXPECT( c.method ).with( 3, "some string" ); // equivalent to the previous one using short-cuts +} +//] +} + +namespace constraints_example_2 +{ +//[ constraints_example_2 +MOCK_CLASS( mock_class ) +{ + MOCK_METHOD( method, 1, void( int ) ) +}; + +bool custom_constraint( int actual ) +{ + return actual == 42; +} + +BOOST_AUTO_TEST_CASE( demonstrates_adding_a_custom_constraint_with_a_free_function ) +{ + mock_class c; + MOCK_EXPECT( c.method ).with( &custom_constraint ); +} +//] +} + +namespace constraints_example_3 +{ +//[ constraints_example_3 +MOCK_CLASS( mock_class ) +{ + MOCK_METHOD( method, 1, void( int ) ) +}; + +bool custom_constraint( int expected, int actual ) +{ + return expected == actual; +} + +BOOST_AUTO_TEST_CASE( demonstrates_adding_a_custom_constraint_with_a_standard_library_functor ) +{ + mock_class c; + MOCK_EXPECT( c.method ).with( std::bind1st( std::ptr_fun( &custom_constraint ), 42 ) ); // std::ptr_fun creates an std::unary_function +} +//] +} + +namespace constraints_example_4 +{ +//[ constraints_example_4 +MOCK_CLASS( mock_class ) +{ + MOCK_METHOD( method, 1, void( int ) ) +}; + +bool custom_constraint( int expected, int actual ) +{ + return expected == actual; +} + +BOOST_AUTO_TEST_CASE( demonstrates_adding_a_custom_constraint_with_boost_bind ) +{ + mock_class c; + MOCK_EXPECT( c.method ).with( boost::bind( &custom_constraint, 42, _1 ) ); +} +//] +} + +#include + +namespace constraints_example_5 +{ +//[ constraints_example_5 +MOCK_CLASS( mock_class ) +{ + MOCK_METHOD( method, 1, void( int ) ) +}; + +BOOST_AUTO_TEST_CASE( demonstrates_adding_a_custom_constraint_with_boost_lambda ) +{ + mock_class c; + MOCK_EXPECT( c.method ).with( boost::lambda::_1 == 42 ); +} +//] +} + +#include + +namespace constraints_example_6 +{ +//[ constraints_example_6 +MOCK_CLASS( mock_class ) +{ + MOCK_METHOD( method, 1, void( int ) ) +}; + +BOOST_AUTO_TEST_CASE( demonstrates_adding_a_custom_constraint_with_boost_phoenix ) +{ + mock_class c; + MOCK_EXPECT( c.method ).with( boost::phoenix::arg_names::arg1 == 42 ); + MOCK_EXPECT( c.method ).with( boost::phoenix::arg_names::_1 == 42 ); +} +//] +} + +#if !defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_LAMBDAS) +namespace constraints_example_7 +{ +//[ constraints_example_7 +MOCK_CLASS( mock_class ) +{ + MOCK_METHOD( method, 1, void( int ) ) +}; + +BOOST_AUTO_TEST_CASE( demonstrates_adding_a_constraint_with_cxx11_lambda ) +{ + mock_class c; + MOCK_EXPECT( c.method ).with( []( int actual ) { return 42 == actual; } ); +} +//] +} +#endif + +namespace constraints_example_8 +{ +//[ constraints_example_8 +MOCK_CLASS( mock_class ) +{ + MOCK_METHOD( method, 2, void( int, const std::string& ) ) +}; + +BOOST_AUTO_TEST_CASE( demonstrates_combining_constraints ) +{ + mock_class c; + MOCK_EXPECT( c.method ).with( mock::less( 4 ) && mock::greater( 2 ), ! mock::equal( "" ) ); +} +//] +} + +namespace sequence_example_1 +{ +//[ sequence_example_1 +MOCK_CLASS( mock_class_1 ) +{ + MOCK_METHOD( method_1, 0, void() ) +}; + +MOCK_CLASS( mock_class_2 ) +{ + MOCK_METHOD( method_2, 0, void() ) +}; + +MOCK_CLASS( mock_class_3 ) +{ + MOCK_METHOD( method_3, 0, void() ) +}; + +BOOST_AUTO_TEST_CASE( demonstrates_enforcing_several_expectation_orders ) +{ + mock_class_1 c_1; + mock_class_2 c_2; + mock_class_3 c_3; + mock::sequence s_1, s_2; + MOCK_EXPECT( c_1.method_1 ).in( s_1 ); + MOCK_EXPECT( c_2.method_2 ).in( s_2 ); // c_1.method_1 and c_2.method_2 are in different sequences and can be called in any order + MOCK_EXPECT( c_3.method_3 ).in( s_1, s_2 ); // c_3.method_3 must be called after both c_1.method_1 and c_2.method_2 +} +//] +} + +namespace action_example_1 +{ +//[ action_example_1 +MOCK_CLASS( mock_class ) +{ + MOCK_METHOD( method, 1, int( int ) ) +}; + +int function( int i ) +{ + return i; +} + +BOOST_AUTO_TEST_CASE( demonstrates_configuring_actions ) +{ + mock_class c; + MOCK_EXPECT( c.method ).returns( 42 ); + MOCK_EXPECT( c.method ).throws( std::runtime_error( "error !" ) ); + MOCK_EXPECT( c.method ).calls( &function ); // forwards 'method' parameter to 'function' + MOCK_EXPECT( c.method ).calls( boost::bind( &function, 42 ) ); // drops 'method' parameter and binds 42 as parameter to 'function' + MOCK_EXPECT( c.method ).calls( []( int i ) { return i; } ); // uses a C++11 lambda +} +//] +} + +namespace verification_example_1 +{ +//[ verification_example_1 +MOCK_CLASS( mock_class ) +{ + MOCK_METHOD( method, 0, void() ) +}; + +BOOST_AUTO_TEST_CASE( demonstrates_verifying_a_mock_method ) +{ + mock_class c; + MOCK_VERIFY( c.method ); // logs an error and returns false if not all expectations are met + mock::verify( c ); // verifies all expectations set for all methods of 'c' + mock::verify(); // verifies all existing mock objects, functions and functors +} +//] +} + +namespace verification_example_2 +{ +//[ verification_example_2 +BOOST_AUTO_TEST_CASE( demonstrates_verifying_a_mock_functor ) +{ + MOCK_FUNCTOR( f, void( int ) ); + MOCK_VERIFY( f ); // logs an error and returns false if not all expectations are met + mock::verify( f ); // behaves the same as MOCK_VERIFY + mock::verify(); // verifies all existing mock objects, functions and functors +} +//] +} + +namespace verification_example_3 +{ +//[ verification_example_3 +MOCK_FUNCTION( f, 1, void( int ) ) + +BOOST_AUTO_TEST_CASE( demonstrates_verifying_a_mock_function ) +{ + MOCK_VERIFY( f ); // logs an error and returns false if not all expectations are met + mock::verify(); // verifies all existing mock objects, functions and functors +} +//] +} + +namespace verification_example_4 +{ +//[ verification_example_4 +MOCK_CLASS( mock_class ) +{ + MOCK_STATIC_METHOD( method, 0, void() ) +}; + +BOOST_AUTO_TEST_CASE( demonstrates_verifying_a_static_mock_method ) +{ + mock_class c; + MOCK_VERIFY( c.method ); // logs an error and returns false if not all expectations are met + MOCK_VERIFY( mock_class::method ); // does the same + mock::verify(); // verifies all existing mock objects, functions and functors +} +//] +} + +namespace reset_example_1 +{ +//[ reset_example_1 +MOCK_CLASS( mock_class ) +{ + MOCK_METHOD( method, 0, void() ) +}; + +BOOST_AUTO_TEST_CASE( demonstrates_resetting_a_mock_method ) +{ + mock_class c; + MOCK_RESET( c.method ); // resets all expectations set for 'c.method' + mock::reset( c ); // resets all expectations set on 'c' + mock::reset(); // resets all existing mock objects, functions and functors +} +//] +} + +namespace reset_example_2 +{ +//[ reset_example_2 +BOOST_AUTO_TEST_CASE( demonstrates_resetting_a_mock_functor ) +{ + MOCK_FUNCTOR( f, void( int ) ); + MOCK_RESET( f ); // resets all expectations set for 'f' + mock::reset( f ); // behaves the same as MOCK_RESET + mock::reset(); // resets all existing mock objects, functions and functors +} +//] +} + +namespace reset_example_3 +{ +//[ reset_example_3 +MOCK_FUNCTION( f, 1, void( int ) ) + +BOOST_AUTO_TEST_CASE( demonstrates_resetting_a_mock_function ) +{ + MOCK_RESET( f ); // resets all expectations set for 'f' + mock::reset(); // resets all existing mock objects, functions and functors +} +//] +} + +namespace reset_example_4 +{ +//[ reset_example_4 +MOCK_CLASS( mock_class ) +{ + MOCK_STATIC_METHOD( method, 0, void() ) +}; + +BOOST_AUTO_TEST_CASE( demonstrates_resetting_a_static_mock_method ) +{ + mock_class c; + MOCK_RESET( c.method ); // resets all expectations set for 'c::method' + MOCK_RESET( mock_class::method ); // resets all expectations set for 'c::method' + mock::reset(); // resets all existing mock objects, functions and functors +} +//] +} + +namespace helpers_example_1 +{ +//[ helpers_example_1 +MOCK_UNARY_CONSTRAINT( any, true ) // this is (almost) how mock::any is defined +MOCK_UNARY_CONSTRAINT( forty_two, actual == 42 ) // this defines a 'forty_two' constraint +//] +} + +namespace helpers_example_2 +{ +//[ helpers_example_2 +MOCK_BINARY_CONSTRAINT( equal, actual == expected ) // this is how mock::equal is defined +MOCK_BINARY_CONSTRAINT( near, std::abs( actual - expected ) < 0.01 ) // this defines a 'near' constraint which can be used as 'near( 42 )' +//] +} diff --git a/build/boost/doc/limitations.qbk b/build/boost/doc/limitations.qbk index 470bb73..d8f095b 100644 --- a/build/boost/doc/limitations.qbk +++ b/build/boost/doc/limitations.qbk @@ -179,7 +179,7 @@ Finally another workaround would be to not use the macro at all : struct my_mock : my_base_type< T1, T2 >, mock::object {}; -Note that [@www.boost.org/libs/utility/identity_type/doc/html/index.html Boost.IdentityType] is of little help here because the type is by essence very often abstract, which doesn't work well for some compilers (e.g. gcc)]. +Note that [@www.boost.org/libs/utility/identity_type/doc/html/index.html Boost.IdentityType] is of little help here because the type is by essence very often abstract, which doesn't work well for some compilers (e.g. gcc). [endsect] diff --git a/build/boost/doc/reference.qbk b/build/boost/doc/reference.qbk index 4bc5556..2c54b9f 100644 --- a/build/boost/doc/reference.qbk +++ b/build/boost/doc/reference.qbk @@ -1,12 +1,11 @@ [section Reference] +[import example/reference.cpp] This section describes the library syntax exhaustively. All source code snippets assume the following prerequisite : - #define BOOST_AUTO_TEST_MAIN - #include - #include +[prerequisite] [section Creation] @@ -31,215 +30,98 @@ Most of the time the identifier will be identical to the object name, but in cas [section Class] -The prefered form for defining a mock class is with using MOCK_CLASS and MOCK_BASE_CLASS, however equivalent alternatives exist without the macros. - Synopsis : - MOCK_CLASS( name ) - { - }; - - template< typename T > - MOCK_CLASS( name ) - { - }; - - MOCK_BASE_CLASS( name, base ) - { - }; - - template< typename T > - MOCK_BASE_CLASS( name, base< T > ) - { - }; - - struct name : mock::object // equivalent to using MOCK_CLASS - { - }; - - template< typename T > - struct name : mock::object // equivalent to using MOCK_CLASS - { - }; - - struct name : base, mock::object // equivalent to using MOCK_BASE_CLASS - { - typedef base base_type; - }; - - template< typename T > - struct mock : base< T >, mock::object - { - typedef typename base< T > base_type; - }; + MOCK_CLASS( name ) // defines a class + MOCK_BASE_CLASS( name, base ) // defines a class deriving from a base class + +Example : + +[class_example_1] + +Example : + +[class_example_2] + +Example : + +[class_example_3] + +Example : + +[class_example_4] + +The preferred form for defining a mock class is with using MOCK_CLASS and MOCK_BASE_CLASS, however equivalent alternatives exist without the macros. + +Example : + +[class_example_5] + +Example : + +[class_example_6] + +Example : + +[class_example_7] + +Example : + +[class_example_8] Deriving from mock::object is optional but provides the additional following benefits : * the object acts as a composite to [link turtle.reference.verification verify] and [link turtle.reference.reset reset] all the expectations for all its methods at once * logs involving the object are enhanced because configuring an expectation for a method will set the class name for all the other methods as well -Example : - - MOCK_CLASS( mock_class ) - { - }; - - BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_mock_class ) - { - mock_class c; - } - -Example : - - template< typename T > - MOCK_CLASS( mock_class ) - { - }; - - BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_template_mock_class ) - { - mock_class< int > c; - } - -Example : - - class base_class - { - }; - - MOCK_BASE_CLASS( mock_class, base_class ) - { - }; - - BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_derived_mock_class ) - { - mock_class c; - } - -Example : - - template< typename T > - class base_class - { - }; - - template< typename T > - MOCK_BASE_CLASS( mock_class, base_class< T > ) - { - }; - - BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_template_derived_mock_class ) - { - mock_class< int > c; - } - [endsect] [section Member function] Synopsis : - MOCK_METHOD( name, arity ) // generates both const and non-const methods, only works in the context of a derived MOCK_BASE_CLASS or base_type typedef - MOCK_METHOD( name, arity, signature[, identifier] ) // generates both const and non-const methods, if 'identifier' is omitted it will default to 'name' - MOCK_CONST_METHOD( name, arity, signature[, identifier] ) // generates only the const version of the method, if 'identifier' is omitted it will default to 'name' - MOCK_NON_CONST_METHOD( name, arity, signature[, identifier] ) // generates only the non-const version of the method, if 'identifier' is omitted it will default to 'name' + MOCK_METHOD( name, arity ) // generates both const and non-const methods, only works in the context of a derived MOCK_BASE_CLASS or base_type typedef + MOCK_METHOD( name, arity, signature[, identifier] ) // generates both const and non-const methods, if 'identifier' is omitted it will default to 'name' + MOCK_CONST_METHOD( name, arity, signature[, identifier] ) // generates only the const version of the method, if 'identifier' is omitted it will default to 'name' + MOCK_NON_CONST_METHOD( name, arity, signature[, identifier] ) // generates only the non-const version of the method, if 'identifier' is omitted it will default to 'name' - MOCK_METHOD_TPL( name, arity, signature[, identifier] ) // must be used if the signature uses a template parameter of the class, if 'identifier' is omitted it will default to 'name' - MOCK_CONST_METHOD_TPL( name, arity, signature[, identifier] ) // must be used if the signature uses a template parameter of the class, if 'identifier' is omitted it will default to 'name' - MOCK_NON_CONST_METHOD_TPL( name, arity, signature[, identifier] ) // must be used if the signature uses a template parameter of the class, if 'identifier' is omitted it will default to 'name' + MOCK_METHOD_TPL( name, arity, signature[, identifier] ) // must be used if the signature uses a template parameter of the class, if 'identifier' is omitted it will default to 'name' + MOCK_CONST_METHOD_TPL( name, arity, signature[, identifier] ) // must be used if the signature uses a template parameter of the class, if 'identifier' is omitted it will default to 'name' + MOCK_NON_CONST_METHOD_TPL( name, arity, signature[, identifier] ) // must be used if the signature uses a template parameter of the class, if 'identifier' is omitted it will default to 'name' [note [link turtle.reference.creation.constructor Constructors], [link turtle.reference.creation.destructor destructors] and [link turtle.reference.creation.conversion_operator conversion operators] require special care] -Example : - - class base_class - { - virtual void method( int ) = 0; - }; - - MOCK_BASE_CLASS( mock_class, base_class ) - { - MOCK_METHOD( method, 1 ) // only possible when referring unambiguously to a base class method - }; +[note The signature must be surrounded with round parenthesis if the return type contains a comma] Example : - class base_class - { - virtual void method( int, const std::string& ) = 0; - virtual void method( float ) = 0; - }; - - MOCK_BASE_CLASS( mock_class, base_class ) - { - MOCK_METHOD( method, 2, void( int, const std::string& ), identifier_1 ) // MOCK_METHOD cannot be used because of overloading - MOCK_METHOD( method, 1, void( float ), identifier_2 ) // the identifier must differ from the previous one in order to fully disambiguate methods - }; +[member_function_example_1] + +Example : + +[member_function_example_2] [note For a compiler not supporting variadic macros MOCK_METHOD_EXT must be used instead] Example : - class base_class - { - virtual void method( float ) = 0; - virtual void method( float ) const = 0; - }; - - MOCK_BASE_CLASS( mock_class, base_class ) - { - MOCK_METHOD( method, 1 ) // this generates both const and non-const versions - }; +[member_function_example_3] Example : - class base_class - { - virtual void method( float ) = 0; - virtual void method( float ) const = 0; - }; - - MOCK_BASE_CLASS( mock_class, base_class ) - { - MOCK_CONST_METHOD( method, 1, void( float ), identifier_1 ) // this generates only the const version - MOCK_NON_CONST_METHOD( method, 1, void( float ), identifier_2 ) // this generates only the non-const version, with a different identifier - }; +[member_function_example_4] Example : - class base_class - { - virtual void method( float ) = 0; - }; - - struct mock_class : base_class - { - typedef base_class base_type; // this is required for MOCK_METHOD to work when not using MOCK_BASE_CLASS - - MOCK_METHOD( method, 1 ) - }; +[member_function_example_6] Example : - MOCK_CLASS( mock_class ) - { - MOCK_NON_CONST_METHOD( operator=, 1, mock_class&( const mock_class& ), assignment ) // operators need a custom identifier - }; +[member_function_example_7] Example : - template< typename T > - MOCK_CLASS( mock_class ) - { - MOCK_METHOD_TPL( method, 1, void( const T& ) ) // the _TPL variants must be used if the signature includes a template parameter of the class - }; - -If 'signature' has a return type which contains a comma, for instance std::map< int, int >(), then 'signature' must be surrounded with round parenthesis, for instance : - - struct mock_class - { - MOCK_METHOD( method, 0, (std::map< int, int >()) ) - }; +[member_function_example_8] [endsect] @@ -248,16 +130,18 @@ If 'signature' has a return type which contains a comma, for instance std::map< Synopsis : MOCK_STATIC_METHOD( name, arity, signature[, identifier] ) // if 'identifier' is omitted it will default to 'name' + MOCK_STATIC_METHOD_TPL( name, arity, signature[, identifier] ) // must be used if the signature uses a template parameter of the class, if 'identifier' is omitted it will default to 'name' +[note A static object is used behind the scene in order to keep track of the expectations of a mock static method, therefore to ensure all tests run in isolation it is strongly suggested to manually [link turtle.reference.verification verify] and [link turtle.reference.reset reset] the static method at the end of each test] + Example : - MOCK_CLASS( mock_class ) - { - MOCK_STATIC_METHOD( method, 1, float( int ) ) - }; +[static_member_function_example_1] -[note A static object is used behind the scene in order to keep track of the expectations of a mock static method, therefore to ensure all tests run in isolation it is strongly suggested to manually [link turtle.reference.verification verify] and [link turtle.reference.reset reset] the static method at the end of each test] +Example : + +[static_member_function_example_2] [endsect] @@ -266,25 +150,18 @@ Example : Synopsis : MOCK_CONSTRUCTOR( name, arity, parameters, identifier ) + MOCK_CONSTRUCTOR_TPL( name, arity, parameters, identifier ) // must be used if the signature uses a template parameter of the class [note As constructors do not have a return type, the usual signature gets restricted here to just the parameters] Example : - MOCK_CLASS( mock_class ) - { - MOCK_CONSTRUCTOR( mock_class, 2, ( int, const std::string& ), identifier ) - }; +[constructor_example_1] Example : - template< typename T > - MOCK_CLASS( mock_class ) - { - MOCK_CONSTRUCTOR( mock_class, 2, ( int, const std::string& ), identifier ) - MOCK_CONSTRUCTOR_TPL( mock_class, 2, ( T, const std::string& ), identifier ) - }; +[constructor_example_2] [endsect] @@ -294,14 +171,11 @@ Synopsis : MOCK_DESTRUCTOR( name, identifier ) +[note When mocking a destructor it is strongly suggested to manually [link turtle.reference.verification verify] the expectation at the end of the test, because the automatic verification will not be triggered if the mock object is not destroyed] + Example : - MOCK_CLASS( mock_class ) - { - MOCK_DESTRUCTOR( mock_class, destructor ) - }; - -[note When mocking a destructor it is strongly suggested to manually [link turtle.reference.verification verify] the expectation at the end of the test, because the automatic verification will not be triggered if the mock object is not destroyed] +[destructor_example_1] [endsect] @@ -309,9 +183,9 @@ Example : Synopsis : - MOCK_CONVERSION_OPERATOR( type, identifier ) // this generates both const and non-const operators - MOCK_CONST_CONVERSION_OPERATOR( type, identifier ) - MOCK_NON_CONST_CONVERSION_OPERATOR( type, identifier ) + MOCK_CONVERSION_OPERATOR( type, identifier ) // generates both const and non-const operators + MOCK_CONST_CONVERSION_OPERATOR( type, identifier ) // generates only a const operator + MOCK_NON_CONST_CONVERSION_OPERATOR( type, identifier ) // generates only a non-const operator MOCK_CONVERSION_OPERATOR_TPL( type, identifier ) // must be used if the signature uses a template parameter of the class MOCK_CONST_CONVERSION_OPERATOR_TPL( type, identifier ) // must be used if the signature uses a template parameter of the class @@ -319,21 +193,11 @@ Synopsis : Example : - MOCK_CLASS( mock_class ) - { - MOCK_CONVERSION_OPERATOR( int, conversion_to_int ) - MOCK_CONST_CONVERSION_OPERATOR( const std::string&, conversion_to_string ) - }; +[conversion_operator_example_1] Example : - template< typename T > - MOCK_CLASS( mock_class ) - { - MOCK_CONVERSION_OPERATOR_TPL( T, conversion_to_T ) // the _TPL variants must be used if the signature includes a template parameter of the class - MOCK_CONST_CONVERSION_OPERATOR( const std::string&, const_conversion_to_string ) - MOCK_NON_CONST_CONVERSION_OPERATOR( const std::string&, const_conversion_to_string ) - }; +[conversion_operator_example_2] [endsect] @@ -347,27 +211,11 @@ Synopsis : Example : - BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_mock_functor ) - { - MOCK_FUNCTOR( f, void( int ) ); - } +[functor_example_1] Example : - namespace - { - template< typename T > - struct template_class - { - MOCK_FUNCTOR_TPL( f, void( T ) ); - }; - } - - BOOST_AUTO_TEST_CASE( demonstrates_instantiating_a_mock_template_functor ) - { - template_class< int > c; - c.f( 3 ); - } +[functor_example_2] [endsect] @@ -377,11 +225,11 @@ Synopsis : MOCK_FUNCTION( name, arity, signature[, identifier] ) // if 'identifier' is omitted it will default to 'name' -[note A static object is used behind the scene in order to keep track of the expectations of a mock free function, therefore to ensure all tests run in isolation it is strongly suggested to manually [link turtle.reference.verification verify] and [link turtle.reference.reset reset] the mock function at the end of each test] +[note A static object is used behind the scene in order to keep track of the expectations of a mock function, therefore to ensure all tests run in isolation it is strongly suggested to manually [link turtle.reference.verification verify] and [link turtle.reference.reset reset] the mock function at the end of each test] Example : - MOCK_FUNCTION( mock_function, 1, float( int ) ) +[function_example_1] [endsect] @@ -399,23 +247,12 @@ Synopsis : Example : - MOCK_CLASS( mock_class ) - { - MOCK_METHOD( method, 0, int( int ), method ) - MOCK_METHOD( method, 0, void( const std::string&, float ), method2 ) - }; - - BOOST_AUTO_TEST_CASE( demonstrates_configuring_mock_objects ) - { - mock_class c; - mock::sequence s; - MOCK_EXPECT( c.method ).once().with( 0 ).in( s ).returns( 42 ); - MOCK_EXPECT( c.method2 ).never().with( "ok", mock::any ); - MOCK_EXPECT( c.method2 ).at_least( 2 ).in( s ).throws( std::runtime_error() ); - } +[expectation_example_1] [section Invocation] +An invocation defines how many times a mock object is to be exercised. + Synopsis : MOCK_EXPECT( identifier ); // any number of times including never @@ -428,51 +265,26 @@ Synopsis : Example : - MOCK_CLASS( mock_class ) - { - MOCK_METHOD( method, 2, void( int, const std::string& ) ) - }; - - BOOST_AUTO_TEST_CASE( demonstrates_setting_up_invocations_on_a_mock_method ) - { - mock_class c; - MOCK_EXPECT( c.method ).once(); // can only be called once - MOCK_EXPECT( c.method ); // can be called an unlimited number of times - } +[invocation_example_1] Example : - BOOST_AUTO_TEST_CASE( demonstrates_setting_up_an_invocation_on_a_mock_functor ) - { - MOCK_FUNCTOR( f, void( int, const std::string& ) ); - MOCK_EXPECT( f ); - } +[invocation_example_2] Example : - MOCK_FUNCTION( free_function, 1, float( int ) ) - - BOOST_AUTO_TEST_CASE( demonstrates_setting_up_an_invocation_on_a_mock_function ) - { - MOCK_EXPECT( free_function ).once(); - } +[invocation_example_3] Example : - MOCK_CLASS( mock_class ) - { - MOCK_STATIC_METHOD( method, 1, float( int ) ) - }; - - BOOST_AUTO_TEST_CASE( demonstrates_setting_up_an_invocation_on_a_mock_static_method ) - { - MOCK_EXPECT( mock_class::method ).once(); - } +[invocation_example_4] [endsect] [section Constraints] +A constraint validates the actual parameter value of a call to a mock object. + Synopsis : MOCK_EXPECT( identifier ).with( constraint_1, constraint_2, ... ); @@ -522,170 +334,72 @@ Constraints : Example : - MOCK_CLASS( mock_class ) - { - MOCK_METHOD( method, 2, void( int, const std::string& ) ) - }; - - BOOST_AUTO_TEST_CASE( demonstrates_adding_builtin_constraints ) - { - mock_class c; - MOCK_EXPECT( c.method ).with( mock::equal( 3 ), mock::equal( "some string" ) ); - MOCK_EXPECT( c.method ).with( 3, "some string" ); // equivalent to the previous one using short-cuts - } +[constraints_example_1] Example using a function pointer : - bool custom_constraint( int actual ) - { - return actual == 42; - } - - BOOST_AUTO_TEST_CASE( demonstrates_adding_a_custom_constraint_with_a_free_function ) - { - mock_class c; - MOCK_EXPECT( c.method ).with( &custom_constraint ); - } +[constraints_example_2] Example using a standard library functor : - bool custom_constraint( int expected, int actual ) - { - return expected == actual; - } - - BOOST_AUTO_TEST_CASE( demonstrates_adding_a_custom_constraint_with_a_standard_library_functor ) - { - mock_class c; - MOCK_EXPECT( c.method ).with( std::bind1st( std::ptr_fun( &custom_constraint ), 42 ) ); // std::ptr_fun creates an std::unary_function - } +[constraints_example_3] Example using [@http://www.boost.org/libs/bind Boost.Bind] : - bool custom_constraint( int expected, int actual ) - { - return expected == actual; - } - - BOOST_AUTO_TEST_CASE( demonstrates_adding_a_custom_constraint_with_boost_bind ) - { - mock_class c; - MOCK_EXPECT( c.method ).with( boost::bind( &custom_constraint, 42, _1 ) ) ); - } +[constraints_example_4] Example using [@http://www.boost.org/libs/lambda Boost.Lambda] : - BOOST_AUTO_TEST_CASE( demonstrates_adding_a_custom_constraint_with_boost_lambda ) - { - mock_class c; - MOCK_EXPECT( c.method ).with( boost::lambda::_1 == 42 ); - } +[constraints_example_5] Example using [@http://www.boost.org/libs/phoenix Boost.Phoenix] : - BOOST_AUTO_TEST_CASE( demonstrates_adding_a_custom_constraint_with_boost_phoenix ) - { - mock_class c; - MOCK_EXPECT( c.method ).with( boost::phoenix::arg_names::arg1 == 42 ); - MOCK_EXPECT( c.method ).with( boost::phoenix::arg_names::_1 == 42 ); - } +[constraints_example_6] Example using C++11 lambdas : - BOOST_AUTO_TEST_CASE( demonstrates_adding_a_constraint_with_cxx11_lambda ) - { - mock_class c; - MOCK_EXPECT( c.method ).with( []( int actual ) { return 42 == actual; } ); - } +[constraints_example_7] Example using &&, || and ! : - BOOST_AUTO_TEST_CASE( demonstrates_combining_constraints ) - { - mock_class c; - MOCK_EXPECT( c.method ).with( mock::less( 4 ) && mock::greater( 2 ), ! mock::equal( "" ) ); - } +[constraints_example_8] [endsect] [section Sequence] +A sequence enforces a given order between two or more expectations. + Synopsis : - mock::sequence s_1, s_2; - MOCK_EXPECT( identifier_1 ).in( s_1 ); - MOCK_EXPECT( identifier_2 ).in( s_1, s_2 ); + MOCK_EXPECT( identifier_1 ).in( sequence_1 [, sequence_2 [, ...]] ); + +Each sequence is an instance of mock::sequence. + +The maximum number of sequences that can be set is MOCK_MAX_SEQUENCES which defaults to 10. If needed the value can be increased before including the library : + + #define MOCK_MAX_SEQUENCES 12 + #include Example : - MOCK_CLASS( mock_class_1 ) - { - MOCK_METHOD( method_1, 0, void() ) - }; - MOCK_CLASS( mock_class_2 ) - { - MOCK_METHOD( method_2, 0, void() ) - }; - - BOOST_AUTO_TEST_CASE( demonstrates_enforcing_expectations_order ) - { - mock_class_1 c_1; - mock_class_2 c_2; - mock::sequence s; - MOCK_EXPECT( c_1.method_1 ).in( s ); - MOCK_EXPECT( c_2.method_2 ).in( s ); - } - -Example of setting several sequences : - - MOCK_CLASS( mock_class ) - { - MOCK_METHOD( method, 0, void() ) - }; - - BOOST_AUTO_TEST_CASE( demonstrates_enforcing_several_expectation_orders ) - { - mock_class c; - mock::sequence s_1, s_2; - MOCK_EXPECT( c.method ).in( s_1, s_2 ); - } - -The maximum number of sequences that can be passed to ['in] is MOCK_MAX_SEQUENCES which defaults to 5. If needed the value can be increased before including the library : - - #define MOCK_MAX_SEQUENCES 7 - #include +[sequence_example_1] [endsect] [section Actions] +An action performs additional treatments after an expectation has been deemed valid. + Synopsis : MOCK_EXPECT( identifier ).returns( value ); MOCK_EXPECT( identifier ).throws( exception ); - MOCK_EXPECT( identifier ).calls( functor ); // throws std::invalid_argument if ! ['functor] + MOCK_EXPECT( identifier ).calls( functor ); // gets assigned to a boost::function and throws std::invalid_argument if empty Example : - MOCK_CLASS( mock_class ) - { - MOCK_METHOD( method, 0, int( int ) ) - }; - - int function( int i ) - { - return i; - } - - BOOST_AUTO_TEST_CASE( demonstrates_configuring_actions ) - { - mock_class c; - MOCK_EXPECT( c.method ).returns( 42 ); - MOCK_EXPECT( c.method ).throws( std::runtime_error( "error !" ) ); - MOCK_EXPECT( c.method ).calls( &function ); // forwards 'method' parameter to 'function' - MOCK_EXPECT( c.method ).calls( boost::bind( &function, 42 ) ); // drops 'method' parameter and binds 42 as parameter to 'function' - MOCK_EXPECT( c.method ).calls( []( int i ) { return i; } ); // uses a C++11 lambda - } +[action_example_1] [endsect] @@ -696,9 +410,9 @@ Example : Synopsis : MOCK_VERIFY( identifier ); - mock::verify( object ); // verifies all expectations set for all methods of 'object' which must be an instance of a class created using MOCK_CLASS or MOCK_BASE_CLASS, or inherit mock::object - mock::verify( functor ); // verifies all expectations set for 'functor' which must be an instance of a functor created using MOCK_FUNCTOR - mock::verify(); // verifies all existing mock objects, functions and functors + mock::verify( object ); // verifies all expectations for all methods of 'object' which must be an instance of a class created using MOCK_CLASS or MOCK_BASE_CLASS, or inherit mock::object + mock::verify( functor ); // verifies all expectations for 'functor' which must be an instance of a functor created using MOCK_FUNCTOR + mock::verify(); // verifies all expectations for all mock objects, functions and functors [note These calls all return a boolean indicating whether the verification was successful or not, however usually simply calling them is enough because a failing verification will be logged to the test framework.] @@ -708,52 +422,19 @@ Synopsis : Example : - MOCK_CLASS( mock_class ) - { - MOCK_METHOD( method, 0, void() ) - }; - - BOOST_AUTO_TEST_CASE( demonstrates_verifying_a_mock_method ) - { - mock_class c; - MOCK_VERIFY( c.method ); // logs an error and returns false if not all expectations are met - mock::verify( c ); // verifies all expectations set for all methods of 'c' - mock::verify(); // verifies all existing mock objects, functions and functors - } +[verification_example_1] Example : - BOOST_AUTO_TEST_CASE( demonstrates_verifying_a_mock_functor ) - { - MOCK_FUNCTOR( f, void( int ) ); - MOCK_VERIFY( f ); // logs an error and returns false if not all expectations are met - mock::verify( f ); // behaves the same as MOCK_VERIFY - mock::verify(); // verifies all existing mock objects, functions and functors - } +[verification_example_2] Example : - MOCK_FUNCTION( f, 1, void( int ) ) - - BOOST_AUTO_TEST_CASE( demonstrates_verifying_a_mock_function ) - { - MOCK_VERIFY( f ); // logs an error and returns false if not all expectations are met - mock::verify(); // verifies all existing mock objects, functions and functors - } +[verification_example_3] Example : - MOCK_CLASS( mock_class ) - { - MOCK_STATIC_METHOD( method, 0, void() ) - }; - - BOOST_AUTO_TEST_CASE( demonstrates_verifying_a_static_mock_method ) - { - mock_class c; - MOCK_VERIFY( c::method ); // logs an error and returns false if not all expectations are met - mock::verify(); // verifies all existing mock objects, functions and functors - } +[verification_example_4] [endsect] @@ -762,56 +443,25 @@ Example : Synopsis : MOCK_RESET( identifier ); - mock::reset( object ); // resets all expectations set for all methods of 'object' which must be an instance of a class created using MOCK_CLASS or MOCK_BASE_CLASS, or inherit mock::object - mock::reset(); // resets all existing mock objects, functions and functors + mock::reset( object ); // resets all expectations for all methods of 'object' which must be an instance of a class created using MOCK_CLASS or MOCK_BASE_CLASS, or inherit mock::object + mock::reset( functor ); // resets all expectations for 'functor' which must be an instance of a functor created using MOCK_FUNCTOR + mock::reset(); // resets all expectations for all mock objects, functions and functors Example : - MOCK_CLASS( mock_class ) - { - MOCK_METHOD( method, 0, void() ) - }; - - BOOST_AUTO_TEST_CASE( demonstrates_resetting_a_mock_method ) - { - mock_class c; - MOCK_RESET( c.method ); // resets all expectations set for 'c.method' - mock::reset( c ); // resets all expectations set on 'c' - mock::reset(); // resets all existing mock objects, functions and functors - } +[reset_example_1] Example : - BOOST_AUTO_TEST_CASE( demonstrates_resetting_a_mock_functor ) - { - MOCK_FUNCTOR( f, void( int ) ); - MOCK_RESET( f ); // resets all expectations set for 'f' - mock::reset(); // resets all existing mock objects, functions and functors - } +[reset_example_2] Example : - MOCK_FUNCTION( f, 1, void( int ) ) - - BOOST_AUTO_TEST_CASE( demonstrates_resetting_a_mock_function ) - { - MOCK_RESET( f ); // resets all expectations set for 'f' - mock::reset(); // resets all existing mock objects, functions and functors - } +[reset_example_3] Example : - MOCK_CLASS( mock_class ) - { - MOCK_STATIC_METHOD( method, 0, void() ) - }; - - BOOST_AUTO_TEST_CASE( demonstrates_resetting_a_static_mock_method ) - { - mock_class c; - MOCK_RESET( c::method ); // resets all expectations set for 'c::method' - mock::reset(); // resets all existing mock objects, functions and functors - } +[reset_example_4] [endsect] @@ -829,8 +479,7 @@ The expression manipulates the received parameter 'actual' in order to implement Example : - MOCK_UNARY_CONSTRAINT( any, true ) // this is (almost) how mock::any is defined - MOCK_UNARY_CONSTRAINT( forty_two, actual == 42 ) // this defines a 'forty_two' constraint +[helpers_example_1] [endsect] @@ -846,8 +495,7 @@ The expression manipulates the received parameter 'actual' as well as the passed Example : - MOCK_BINARY_CONSTRAINT( equal, actual == expected ) // this is how mock::equal is defined - MOCK_BINARY_CONSTRAINT( near, std::abs( actual - expected ) < 0.01 ) // this defines a 'near' constraint which can be used as 'near( 42 )' +[helpers_example_2] [endsect]