From 7f7ea6bc8fd1839d6b990dfc726ca99124ea70b6 Mon Sep 17 00:00:00 2001 From: mat007 Date: Mon, 7 Jan 2013 16:16:07 +0000 Subject: [PATCH] Updated documentation git-svn-id: https://svn.code.sf.net/p/turtle/code/trunk@579 860be788-9bd5-4423-9f1e-828f051e677b --- build/boost/doc/Jamfile.jam | 3 + build/boost/doc/example/async_call.cpp | 53 ++++++++++ build/boost/doc/example/invoke_functor.cpp | 36 +++++++ build/boost/doc/example/retrieve_cref.cpp | 42 ++++++++ build/boost/doc/patterns.qbk | 116 +++------------------ 5 files changed, 148 insertions(+), 102 deletions(-) create mode 100644 build/boost/doc/example/async_call.cpp create mode 100644 build/boost/doc/example/invoke_functor.cpp create mode 100644 build/boost/doc/example/retrieve_cref.cpp diff --git a/build/boost/doc/Jamfile.jam b/build/boost/doc/Jamfile.jam index 236ddd1..60e406e 100644 --- a/build/boost/doc/Jamfile.jam +++ b/build/boost/doc/Jamfile.jam @@ -47,3 +47,6 @@ project example compile example/motivation.cpp ; compile example/getting_started.cpp ; compile example/customisation.cpp ; +compile example/async_call.cpp ; +compile example/retrieve_cref.cpp ; +compile example/invoke_functor.cpp ; diff --git a/build/boost/doc/example/async_call.cpp b/build/boost/doc/example/async_call.cpp new file mode 100644 index 0000000..9b55894 --- /dev/null +++ b/build/boost/doc/example/async_call.cpp @@ -0,0 +1,53 @@ +//[ async_call_problem +namespace +{ + class base_class + { + public: + virtual void method() = 0; + }; + + class my_class + { + public: + explicit my_class( base_class& ); + + void flush(); // repetitively calling this method will in turn call base_class::method at some point + }; +} +//] + +//[ async_call_solution +#define BOOST_AUTO_TEST_MAIN +#include +#include +#include +#include + +namespace +{ + template< typename F > + void wait( bool& condition, F flush, int timeout = 100, int sleep = 100 ) + { + while( !condition && timeout > 0 ) + { + --timeout; + boost::this_thread::sleep( boost::posix_time::milliseconds( sleep ) ); + flush(); + } + } + MOCK_BASE_CLASS( mock_base_class, base_class ) + { + MOCK_METHOD( method, 0 ) + }; +} + +BOOST_AUTO_TEST_CASE( method_is_called ) +{ + mock_base_class mock; + my_class c( mock ); + bool done = false; + MOCK_EXPECT( mock.method ).once().calls( boost::lambda::var( done ) = true ); // when method is called it will set done to true + wait( done, boost::bind( &my_class::flush, &c ) ); // just wait on done flushing from time to time +} +//] diff --git a/build/boost/doc/example/invoke_functor.cpp b/build/boost/doc/example/invoke_functor.cpp new file mode 100644 index 0000000..70578e5 --- /dev/null +++ b/build/boost/doc/example/invoke_functor.cpp @@ -0,0 +1,36 @@ +//[ invoke_functor_problem +#include + +namespace +{ + class base_class + { + public: + virtual void method( boost::function< void( int ) > functor ) = 0; + }; + + void function( base_class& ); // the function will call 'method' with a functor to be applied +} +//] + +//[ invoke_functor_solution +#define BOOST_AUTO_TEST_MAIN +#include +#include +#include + +namespace +{ + MOCK_BASE_CLASS( mock_class, base_class ) + { + MOCK_METHOD( method, 1 ) + }; +} + +BOOST_AUTO_TEST_CASE( how_to_invoke_a_functor_passed_as_parameter_of_a_mock_method ) +{ + mock_class mock; + MOCK_EXPECT( mock.method ).calls( boost::bind( boost::apply< void >(), _1, 42 ) ); // whenever 'method' is called, invoke the functor with 42 + function( mock ); +} +//] diff --git a/build/boost/doc/example/retrieve_cref.cpp b/build/boost/doc/example/retrieve_cref.cpp new file mode 100644 index 0000000..027581f --- /dev/null +++ b/build/boost/doc/example/retrieve_cref.cpp @@ -0,0 +1,42 @@ +//[ retrieve_cref_problem +namespace +{ + class base_class + { + public: + virtual void method( int value ) = 0; + }; + + class my_class + { + public: + explicit my_class( base_class& ); + + void process(); // the processing will call 'method' two times with the same value, but we don't know what value beforehand + }; +} +//] + +//[ retrieve_cref_solution +#define BOOST_AUTO_TEST_MAIN +#include +#include + +namespace +{ + MOCK_BASE_CLASS( mock_base_class, base_class ) + { + MOCK_METHOD( method, 1 ) + }; +} + +BOOST_AUTO_TEST_CASE( method_is_called_two_times_with_the_same_value ) +{ + mock_base_class mock; + my_class c( mock ); + int value; + MOCK_EXPECT( mock.method ).once().with( mock::retrieve( value ) ); // on first call retrieve the value, this expectation takes precedence because it can never fail + MOCK_EXPECT( mock.method ).once().with( boost::cref( value ) ); // on second call compare the previously retrieved value with the newly received one + c.process(); +} +//] diff --git a/build/boost/doc/patterns.qbk b/build/boost/doc/patterns.qbk index 8c95cab..c95bbfd 100644 --- a/build/boost/doc/patterns.qbk +++ b/build/boost/doc/patterns.qbk @@ -1,4 +1,7 @@ [section Patterns] +[import example/async_call.cpp] +[import example/retrieve_cref.cpp] +[import example/invoke_functor.cpp] This section highlights not-so-obvious features of the library gathered from real use cases. @@ -6,55 +9,11 @@ This section highlights not-so-obvious features of the library gathered from rea Problem : - namespace - { - class base_class - { - public: - virtual void method() = 0; - }; - - class my_class - { - public: - explicit my_class( base_class& ); - - void flush(); // repetitively calling this method will in turn call base_class::method at some point - }; - } +[async_call_problem] Solution : - #include - #include - #include - - namespace - { - template< typename F > - void wait( bool& condition, F flush, int timeout = 100, int sleep = 100 ) - { - while( !condition && timeout > 0 ) - { - --timeout; - boost::this_thread::sleep( boost::posix_time::milliseconds( sleep ) ); - flush(); - } - } - MOCK_BASE_CLASS( mock_base_class, base_class ) - { - MOCK_METHOD( method, 0 ) - }; - } - - BOOST_AUTO_TEST_CASE( method_is_called ) - { - mock_base_class mock; - my_class c( mock ); - bool done = false; - MOCK_EXPECT( mock.method ).once().calls( boost::lambda::var( done ) = true ); // when method is called it will set done to true - wait( done, boost::bind( &my_class::flush, &c ) ); // just wait on done flushing from time to time - } +[async_call_solution] [endsect] @@ -62,70 +21,23 @@ Solution : Problem : - namespace - { - class base_class - { - public: - virtual void method( int value ) = 0; - }; - - class my_class - { - public: - explicit my_class( base_class& ); - - void process(); // the processing will call 'method' two times with the same value, but we don't know what value beforehand - }; - } +[retrieve_cref_problem] Solution : - #include - - namespace - { - MOCK_BASE_CLASS( mock_base_class, base_class ) - { - MOCK_METHOD( method, 1 ) - }; - } - - BOOST_AUTO_TEST_CASE( method_is_called_two_times_with_the_same_value ) - { - mock_base_class mock; - my_class c( mock ); - int value; - MOCK_EXPECT( mock.method ).once().with( mock::retrieve( value ) ); // on first call retrieve the value, this expectation takes precedence because it can never fail - MOCK_EXPECT( mock.method ).once().with( boost::cref( value ) ); // on second call compare the previously retrieved value with the newly received one - c.process(); - } +[retrieve_cref_solution] [endsect] [section Invoking a functor received as parameter] - #include - #include - #include - #include - - namespace - { - MOCK_CLASS( mock_class ) - { - MOCK_METHOD_EXT( method, 1, void( boost::function< void( int ) > ), method ) - }; - } - - BOOST_AUTO_TEST_CASE( how_to_invoke_a_functor_passed_as_parameter_of_a_mock_method ) - { - mock_class mock; - MOCK_EXPECT( mock.method ).calls( boost::bind( boost::apply< void >(), _1, 42 ) ); // whenever 'method' is called, invoke the functor with 42 - MOCK_FUNCTOR( f, void( int ) ); // create a mock functor to verify this - MOCK_EXPECT( f ).once().with( 42 ); // expect it to be called with 42 - mock.method( f ); // call 'method' with the mock functor - } +Problem : + +[invoke_functor_problem] + +Solution : + +[invoke_functor_solution] [endsect]