From 4eadca553b919f666ca6dc9e2109f07fe1905f3f Mon Sep 17 00:00:00 2001 From: Thomas Bernard Date: Tue, 5 Jan 2016 17:00:29 +0100 Subject: [PATCH] Add support for asynchronous expectations. --- .../turtle/detail/expectation_template.hpp | 54 ++++++++++- .../turtle/detail/function_impl_template.hpp | 95 +++++++++++++------ include/turtle/detail/mutex.hpp | 48 +++++----- include/turtle/detail/object_impl.hpp | 22 +++-- test/test_async.cpp | 67 +++++++++++++ 5 files changed, 222 insertions(+), 64 deletions(-) create mode 100644 test/test_async.cpp diff --git a/include/turtle/detail/expectation_template.hpp b/include/turtle/detail/expectation_template.hpp index a4f14a0..1cdc763 100644 --- a/include/turtle/detail/expectation_template.hpp +++ b/include/turtle/detail/expectation_template.hpp @@ -7,6 +7,7 @@ // http://www.boost.org/LICENSE_1_0.txt) #include "matcher_base_template.hpp" +#include #define MOCK_EXPECTATION_INITIALIZE(z, n, d) \ BOOST_PP_COMMA_IF(n) c##n##_( c##n ) @@ -132,8 +133,11 @@ namespace detail > > () ) , file_( "unknown location" ) - , line_( 0 ) - {} + , line_( 0 ) +#if defined(MOCK_THREAD_SAFE) + , blocked(ATOMIC_VAR_INIT(false)) +#endif + { } expectation( const char* file, int line ) : invocation_( boost::make_shared< unlimited >() ) , matcher_( @@ -144,7 +148,10 @@ namespace detail > () ) , file_( file ) , line_( line ) - {} +#if defined(MOCK_THREAD_SAFE) + , blocked(ATOMIC_VAR_INIT(false)) +#endif + { } ~expectation() { @@ -185,7 +192,15 @@ namespace detail } #endif #endif - +#if defined(MOCK_THREAD_SAFE) + template < typename duration> + expectation &async(const duration timeout) + { + timeout_ = timeout; + blocked = false; + return *this; + } +#endif void add( sequence& s ) { s.impl_->add( this ); @@ -196,16 +211,41 @@ namespace detail { return invocation_->verify(); } - +#if defined(MOCK_THREAD_SAFE) + bool verify(const boost::shared_ptr< condition_variable> &cv, lock &lk) const + { + if (timeout_) + { + while (!invocation_->verify()) + { + if (MOCK_THREAD_NAMESPACE::cv_status::timeout == cv->wait_for(lk.get_unique_lock(), *timeout_)) + { + std::atomic_store(&blocked,true); + return false; + } + } + } + return invocation_->verify(); + } +#endif bool is_valid( BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, T, a) ) const { +#if defined(MOCK_THREAD_SAFE) + return !blocked && !invocation_->exhausted() + && (*matcher_)( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, a) ); +#else return !invocation_->exhausted() && (*matcher_)( BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, a) ); +#endif } bool invoke() const { +#if defined(MOCK_THREAD_SAFE) + if (blocked.load(std::memory_order_acquire)) + return false; +#endif for( sequences_cit it = sequences_.begin(); it != sequences_.end(); ++it ) if( ! (*it)->is_valid( this ) ) @@ -252,6 +292,10 @@ namespace detail sequences_type sequences_; const char* file_; int line_; +#if defined(MOCK_THREAD_SAFE) + boost::optional timeout_; + mutable std::atomic_bool blocked; +#endif }; } } // mock diff --git a/include/turtle/detail/function_impl_template.hpp b/include/turtle/detail/function_impl_template.hpp index 32f04b3..0da6e80 100644 --- a/include/turtle/detail/function_impl_template.hpp +++ b/include/turtle/detail/function_impl_template.hpp @@ -7,6 +7,7 @@ // http://www.boost.org/LICENSE_1_0.txt) #include "expectation_template.hpp" +#include #ifndef MOCK_ERROR_POLICY # error no error policy has been set @@ -44,20 +45,30 @@ namespace detail : context_( 0 ) , valid_( true ) , mutex_( boost::make_shared< mutex >() ) +#if defined(MOCK_THREAD_SAFE) + , cv_( boost::make_shared< condition_variable>() ) +#endif {} virtual ~function_impl() { - if( valid_ && ! std::uncaught_exception() ) - 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_ && !std::uncaught_exception()){ + lock _(mutex_); + for (expectations_cit it = expectations_.begin(); + it != expectations_.end(); ++it) +#if defined(MOCK_THREAD_SAFE) + if (!it->verify(cv_, _)) +#else + if (!it->verify()) +#endif + error_type::fail("untriggered expectation", + boost::unit_test::lazy_ostream::instance() + << lazy_context(this) + << lazy_expectations(this), + it->file(), it->line()); + } + context *c = context_.load(std::memory_order_acquire); + if (c) + c->remove( *this ); } virtual bool verify() const @@ -65,7 +76,11 @@ namespace detail lock _( mutex_ ); for( expectations_cit it = expectations_.begin(); it != expectations_.end(); ++it ) +#if defined(MOCK_THREAD_SAFE) + if( ! it->verify(cv_,_) ) +#else if( ! it->verify() ) +#endif { valid_ = false; error_type::fail( "verification failed", @@ -76,7 +91,7 @@ namespace detail } return valid_; } - + virtual void reset() { lock _( mutex_ ); @@ -97,36 +112,38 @@ namespace detail : wrapper_base< R, expectation_type >( e ) , lock_( m ) {} + + wrapper(const wrapper &) = delete; - wrapper once() + wrapper &once() { this->e_->invoke( boost::make_shared< detail::once >() ); return *this; } - wrapper never() + wrapper &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 ) ); 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 ) ); 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 ) ); 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 ) ); @@ -137,7 +154,7 @@ namespace detail template< BOOST_PP_ENUM_PARAMS(MOCK_NUM_ARGS, typename Constraint_) > - wrapper with( + wrapper &with( BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, Constraint_, c) ) { this->e_->with( @@ -146,7 +163,7 @@ namespace detail } #if MOCK_NUM_ARGS > 1 template< typename Constraint > - wrapper with( const Constraint& c ) + wrapper &with( const Constraint& c ) { this->e_->with( c ); return *this; @@ -158,7 +175,7 @@ namespace detail this->e_->add( s##n ); #define MOCK_FUNCTION_IN(z, n, d) \ - wrapper in( BOOST_PP_ENUM_PARAMS(n, sequence& s) ) \ + wrapper &in( BOOST_PP_ENUM_PARAMS(n, sequence& s) ) \ { \ BOOST_PP_REPEAT(n, MOCK_FUNCTION_IN_ADD, _) \ return *this; \ @@ -169,7 +186,13 @@ namespace detail #undef MOCK_FUNCTION_IN #undef MOCK_FUNCTION_IN_ADD - +#if defined(MOCK_THREAD_SAFE) + wrapper &async(const nanoseconds &timeout) + { + this->e_->async(timeout); + return *this; + } +#endif template< typename TT > void calls( TT t ) { @@ -211,6 +234,19 @@ namespace detail BOOST_PP_ENUM_BINARY_PARAMS(MOCK_NUM_ARGS, T, t) ) const { lock _( mutex_ ); +#if defined(MOCK_THREAD_SAFE) + struct notify_cv_on_exit + { + notify_cv_on_exit(condition_variable &cv) + : cv(cv){} + ~notify_cv_on_exit() + { + cv.notify_one(); + } + condition_variable &cv; + }; + notify_cv_on_exit _cv(*cv_); +#endif valid_ = false; for( expectations_cit it = expectations_.begin(); it != expectations_.end(); ++it ) @@ -246,11 +282,9 @@ namespace detail boost::optional< type_name > type, boost::unit_test::const_string name ) { - lock _( mutex_ ); - if( ! context_ ) + if (!context_.exchange(&c,std::memory_order_release)) c.add( *this ); c.add( p, *this, instance, type, name ); - context_ = &c; } friend std::ostream& operator<<( @@ -268,8 +302,10 @@ namespace detail friend std::ostream& operator<<( std::ostream& s, const lazy_context& c ) { - if( c.impl_->context_ ) - c.impl_->context_->serialize( s, *c.impl_ ); + + context *pContext = c.impl_->context_.load(std::memory_order_acquire); + if( pContext ) + pContext->serialize( s, *c.impl_ ); else s << '?'; return s; @@ -297,9 +333,12 @@ namespace detail typedef typename expectations_type::const_iterator expectations_cit; expectations_type expectations_; - context* context_; + std::atomic context_; mutable bool valid_; const boost::shared_ptr< mutex > mutex_; +#if defined(MOCK_THREAD_SAFE) + const boost::shared_ptr cv_; +#endif }; } } // mock diff --git a/include/turtle/detail/mutex.hpp b/include/turtle/detail/mutex.hpp index 4837c6c..6180b6b 100644 --- a/include/turtle/detail/mutex.hpp +++ b/include/turtle/detail/mutex.hpp @@ -17,44 +17,44 @@ #ifdef MOCK_HDR_MUTEX #include +#include +#include #else #include #include +#include +#include +#endif + +#ifdef MOCK_HDR_MUTEX +#define MOCK_THREAD_NAMESPACE std +#else +#define MOCK_THREAD_NAMESPACE boost #endif namespace mock { namespace detail { -#ifdef MOCK_HDR_MUTEX - typedef std::recursive_mutex mutex; - typedef std::lock_guard< mutex > scoped_lock; -#else - typedef boost::recursive_mutex mutex; - typedef boost::lock_guard< mutex > scoped_lock; -#endif - - struct lock + typedef MOCK_THREAD_NAMESPACE::recursive_mutex mutex; + typedef MOCK_THREAD_NAMESPACE::lock_guard< mutex > scoped_lock; + typedef MOCK_THREAD_NAMESPACE::condition_variable_any condition_variable; + typedef MOCK_THREAD_NAMESPACE::chrono::nanoseconds nanoseconds; + typedef MOCK_THREAD_NAMESPACE::unique_lock lock_base; + + struct lock : public lock_base { - lock( const boost::shared_ptr< mutex >& m ) - : m_( m ) - { - m_->lock(); - } - lock( const lock& rhs ) - { - m_.swap( rhs.m_ ); - } + lock(const boost::shared_ptr< detail::mutex > &m) + : lock_base (*m) + , m_(m) + {} ~lock() { - if( m_ ) - m_->unlock(); + unlock(); } + lock_base &get_unique_lock() { return *this; } - private: - lock& operator=( const lock& rhs ); - - mutable boost::shared_ptr< mutex > m_; + boost::shared_ptr< detail::mutex > m_; }; } } // mock diff --git a/include/turtle/detail/object_impl.hpp b/include/turtle/detail/object_impl.hpp index 6aa215f..ba85adf 100644 --- a/include/turtle/detail/object_impl.hpp +++ b/include/turtle/detail/object_impl.hpp @@ -31,6 +31,7 @@ namespace detail public: object_impl() : mutex_( boost::make_shared< mutex >() ) + , children_mutex_( boost::make_shared< mutex >() ) {} virtual void add( const void* /*p*/, verifiable& v, @@ -38,7 +39,7 @@ namespace detail boost::optional< type_name > type, boost::unit_test::const_string name ) { - lock _( mutex_ ); + lock _( children_mutex_ ); if( children_.empty() ) detail::root.add( *this ); children_[ &v ].update( parent_, instance, type, name ); @@ -50,16 +51,21 @@ namespace detail } 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); + } + { + lock _( children_mutex_ ); + children_.erase(&v); + if (children_.empty()) + detail::root.remove(*this); + } } virtual void serialize( std::ostream& s, const verifiable& v ) const { - lock _( mutex_ ); + lock _( children_mutex_ ); children_cit it = children_.find( &v ); if( it != children_.end() ) s << it->second; @@ -72,6 +78,7 @@ namespace detail lock _( mutex_ ); return group_.verify(); } + virtual void reset() { lock _( mutex_ ); @@ -87,6 +94,7 @@ namespace detail parent parent_; children_t children_; const boost::shared_ptr< mutex > mutex_; + const boost::shared_ptr< mutex > children_mutex_; }; } } // mock diff --git a/test/test_async.cpp b/test/test_async.cpp new file mode 100644 index 0000000..f7853c3 --- /dev/null +++ b/test/test_async.cpp @@ -0,0 +1,67 @@ +// http://turtle.sourceforge.net +// +// Copyright Mathieu Champlon 2009 +// +// 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 +#include +#include + +#if defined(MOCK_HDR_MUTEX) +#include +#else +#include +#endif + +namespace +{ + MOCK_CLASS( mock_class ) + { + MOCK_METHOD_EXT( my_method, 1, void( const std::string& ), my_tag ) + }; +} + +BOOST_FIXTURE_TEST_CASE( mock_object_asynchonous_call_expectation, mock_error_fixture ) +{ +#if defined(MOCK_THREAD_SAFE) + const mock_class m; + MOCK_EXPECT( m.my_tag ).async(MOCK_THREAD_NAMESPACE::chrono::milliseconds(50)).once().with( "some parameter" ); + MOCK_THREAD_NAMESPACE::thread context([&](){ + MOCK_THREAD_NAMESPACE::this_thread::sleep_for(MOCK_THREAD_NAMESPACE::chrono::milliseconds(10)); + m.my_method("some parameter"); + }); + mock::verify(); + CHECK_CALLS( 1 ); + context.join(); +#endif + +} + +BOOST_AUTO_TEST_CASE( mock_object_asynchonous_call_expectation_fails ) +{ +#if defined(MOCK_THREAD_SAFE) + const mock_class m; + bool unexpected_call_received = false; + MOCK_EXPECT( m.my_tag ).async(MOCK_THREAD_NAMESPACE::chrono::milliseconds(50)).once().with( "some parameter" ); + MOCK_THREAD_NAMESPACE::thread context([&](){ + MOCK_THREAD_NAMESPACE::this_thread::sleep_for(MOCK_THREAD_NAMESPACE::chrono::milliseconds(100)); + try{ + m.my_method("some parameter"); + } + catch (std::exception &) + { + unexpected_call_received = true; + } + }); + CHECK_ERROR( + BOOST_CHECK(!mock::verify()), + "verification failed", 0, "m.mock_class::my_tag\n. once().with( \"some parameter\" )"); + context.join(); + BOOST_CHECK(unexpected_call_received == true); +#endif +} \ No newline at end of file