Merged the logging branch

git-svn-id: https://svn.code.sf.net/p/turtle/code/trunk@220 860be788-9bd5-4423-9f1e-828f051e677b

src/libraries/turtle/check.hpp

@@ -13,11 +13,8 @@
 #include "constraints.hpp"
 #include "operators.hpp"
 #include "format.hpp"
-#include <boost/function.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/concept_check.hpp>
-#include <stdexcept>
-#include <ostream>
 
 namespace mock
 {
@@ -30,8 +27,8 @@ namespace detail
         BOOST_CONCEPT_USAGE( FunctorCompatible )
         {
             boost::require_boolean_expr(
-                // if an error is generated by the line below it means an argument
+                // if an error is generated by the line below it means
-                // passed to 'with' was of the wrong type.
+                // an argument passed to 'with' was of the wrong type.
                 functor_accepts( actual_argument_type )
             );
         }
@@ -48,8 +45,8 @@ namespace detail
         BOOST_CONCEPT_USAGE( EqualityComparable )
         {
             boost::require_boolean_expr(
-                // if an error is generated by the line below it means an argument
+                // if an error is generated by the line below it means
-                // passed to 'with' was of the wrong type.
+                // an argument passed to 'with' was of the wrong type.
                 actual_argument_type == expected_argument_type
             );
         }
@@ -60,56 +57,91 @@ namespace detail
     };
 
     template< typename Actual >
-    class check
+    class check_base : boost::noncopyable
     {
     public:
-        template< typename Functor >
+        virtual ~check_base() {}
-        explicit check( const Functor& f,
+
-            BOOST_DEDUCED_TYPENAME boost::enable_if<
+        virtual bool operator()( Actual ) const = 0;
-                    BOOST_DEDUCED_TYPENAME detail::is_functor< Functor >
+
-            >::type* = 0 )
+        friend std::ostream& operator<<( std::ostream& s, const check_base& c )
-            : desc_( mock::format( f ) )
         {
-            BOOST_CONCEPT_ASSERT(( FunctorCompatible< Functor, Actual > ));
+            c.format( s );
-            f_ = f;
+            return s;
-            if( ! f_ )
-                std::invalid_argument( "invalid constraint" );
         }
-        template< typename Expected >
+    private:
-        explicit check( const Expected& expected,
+        virtual void format( std::ostream& ) const = 0;
-            BOOST_DEDUCED_TYPENAME boost::disable_if<
+    };
-                    BOOST_DEDUCED_TYPENAME detail::is_functor< Expected >
+
-            >::type* = 0 )
+    template< typename Actual, typename Expected, typename Enable = void >
-            : desc_( mock::format( expected ) )
+    class check : public check_base< Actual >
+    {
+    public:
+        explicit check( Expected expected )
+            : expected_( expected )
         {
             BOOST_CONCEPT_ASSERT(( EqualityComparable< Expected, Actual > ));
-            f_ = mock::equal( expected ).f_;
-            if( ! f_ )
-                std::invalid_argument( "invalid constraint" );
         }
-        template< typename Functor >
+    private:
-        explicit check( const constraint< Functor >& ph )
+        virtual bool operator()( Actual actual ) const
-            : desc_( mock::format( ph.f_ ) )
+        {
+            return actual == expected_;
+        }
+        virtual void format( std::ostream& s ) const
+        {
+            s << mock::format( expected_ );
+        }
+    private:
+        Expected expected_;
+    };
+
+    template< typename Actual, typename Constraint >
+    class check< Actual, mock::constraint< Constraint > >
+        : public check_base< Actual >
+    {
+    public:
+        explicit check( const constraint< Constraint >& c )
+            : c_( c.f_ )
+        {
+            BOOST_CONCEPT_ASSERT(( FunctorCompatible< Constraint, Actual > ));
+        }
+    private:
+        virtual bool operator()( Actual actual ) const
+        {
+            return c_( actual );
+        }
+        virtual void format( std::ostream& s ) const
+        {
+            s << mock::format( c_ );
+        }
+    private:
+        Constraint c_;
+    };
+
+    template< typename Actual, typename Functor >
+    class check< Actual, Functor,
+        BOOST_DEDUCED_TYPENAME boost::enable_if<
+            detail::is_functor< Functor >
+        >::type
+    > : public check_base< Actual >
+    {
+    public:
+        explicit check( const Functor& f )
+            : f_( f )
         {
             BOOST_CONCEPT_ASSERT(( FunctorCompatible< Functor, Actual > ));
-            f_ = ph.f_;
-            if( ! f_ )
-                std::invalid_argument( "invalid constraint" );
         }
-
+    private:
-        bool operator()( Actual actual ) const
+        virtual bool operator()( Actual actual ) const
         {
             return f_( actual );
         }
-
+        virtual void format( std::ostream& s ) const
-        friend std::ostream& operator<<( std::ostream& s, const check& c )
         {
-            return s << c.desc_;
+            s << mock::format( f_ );
         }
-
     private:
-        boost::function< bool( Actual ) > f_;
+        Functor f_;
-        std::string desc_;
     };
 }
 }

src/libraries/turtle/error.hpp

@@ -37,27 +37,27 @@ namespace mock
             throw boost::enable_current_exception( exception() );
         }
 
+        template< typename Context >
         static void fail(
-            const std::string& message, const std::string& context,
+            const std::string& message, const Context& context,
             const std::string& file = "unknown location", int line = 0 )
         {
             boost::unit_test::framework::assertion_result( false );
             boost::unit_test::unit_test_log
                 << boost::unit_test::log::begin( file, (std::size_t)line )
                 << boost::unit_test::log_all_errors
-                << boost::unit_test::lazy_ostream::instance()
                 << message << ": " << context
                 << boost::unit_test::log::end();
         }
 
-        static void expected_call( const std::string& context,
+        template< typename Context >
+        static void expected_call( const Context& context,
             const std::string& file, int line )
         {
             boost::unit_test::framework::assertion_result( true );
             boost::unit_test::unit_test_log
                 << boost::unit_test::log::begin( file, (std::size_t)line )
                 << boost::unit_test::log_successful_tests
-                << boost::unit_test::lazy_ostream::instance()
                 << "mock expectation fulfilled: " << context
                 << boost::unit_test::log::end();
         }
@@ -75,40 +75,47 @@ namespace mock
             throw exception();
         }
 
+        template< typename Context >
         static void fail(
-            const std::string& message, const std::string& context,
+            const std::string& message, const Context& context,
             const std::string& file = "unknown location", int line = 0 )
         {
             std::cerr << file << '(' << line << "): "
                 << message << ": " << context << std::endl;
         }
 
-        static void expected_call( const std::string& /*context*/,
+        template< typename Context >
+        static void expected_call( const Context& /*context*/,
             const std::string& /*file*/, int /*line*/ )
         {}
 
 #endif // MOCK_USE_BOOST_TEST
 
-        static void missing_action( const std::string& context,
+        template< typename Context >
+        static void missing_action( const Context& context,
             const std::string& file, int line )
         {
             fail( "missing action", context, file, line );
         }
-        static void unexpected_call( const std::string& context )
+        template< typename Context >
+        static void unexpected_call( const Context& context )
         {
             fail( "unexpected call", context );
         }
-        static void sequence_failed( const std::string& context,
+        template< typename Context >
+        static void sequence_failed( const Context& context,
             const std::string& /*file*/, int /*line*/ )
         {
             fail( "sequence failed", context );
         }
-        static void verification_failed( const std::string& context,
+        template< typename Context >
+        static void verification_failed( const Context& context,
             const std::string& file, int line )
         {
             fail( "verification failed", context, file, line );
         }
-        static void untriggered_expectation( const std::string& context,
+        template< typename Context >
+        static void untriggered_expectation( const Context& context,
             const std::string& file, int line )
         {
             fail( "untriggered expectation", context, file, line );

src/libraries/turtle/expectation.hpp

@@ -172,14 +172,13 @@ namespace detail
             BOOST_DEDUCED_TYPENAME \
                 boost::function_types::parameter_types< Signature >, \
             n \
-        >::type arg##n##_type; \
+        >::type arg##n##_type;
-    typedef detail::check< arg##n##_type > constraint##n##_type;
+#define MOCK_EXPECTATION_CONSTRUCTOR(z, n, d) BOOST_PP_COMMA_IF(n) c##n##_( new detail::check< arg##n##_type, constraint< detail::any > >( mock::any ) )
-#define MOCK_EXPECTATION_CONSTRUCTOR(z, n, d) BOOST_PP_COMMA_IF(n) c##n##_( mock::any )
+#define MOCK_EXPECTATION_WITH(z, n, d) c##n##_.reset( new detail::check< arg##n##_type, Constraint##n >( c##n ) );
-#define MOCK_EXPECTATION_WITH(z, n, d) c##n##_ = constraint##n##_type( c##n );
+#define MOCK_EXPECTATION_MEMBER(z, n, d) boost::shared_ptr< detail::check_base< arg##n##_type > > c##n##_;
-#define MOCK_EXPECTATION_MEMBER(z, n, d) constraint##n##_type c##n##_;
 #define MOCK_EXPECTATION_ARGS(z, n, d) BOOST_PP_COMMA_IF(n) arg##n##_type a##n
-#define MOCK_EXPECTATION_IS_VALID(z, n, d) && c##n##_( a##n )
+#define MOCK_EXPECTATION_IS_VALID(z, n, d) && (*c##n##_)( a##n )
-#define MOCK_EXPECTATION_SERIALIZE(z, n, d) BOOST_PP_IF(n, << ", " <<,) m.c##n##_
+#define MOCK_EXPECTATION_SERIALIZE(z, n, d) BOOST_PP_IF(n, << ", " <<,) *m.c##n##_
 #define MOCK_EXPECTATION(z, n, d) \
     template< typename Signature > \
     class expectation< Signature, n > \
@@ -193,7 +192,7 @@ namespace detail
             : BOOST_PP_REPEAT_FROM_TO(0, n, MOCK_EXPECTATION_CONSTRUCTOR, BOOST_PP_EMPTY) \
         {} \
         template< BOOST_PP_ENUM_PARAMS(n, typename Constraint) > \
-        expectation& with( BOOST_PP_ENUM_BINARY_PARAMS(n, const Constraint, & c) ) \
+        expectation& with( BOOST_PP_ENUM_BINARY_PARAMS(n, Constraint, c) ) \
         { \
             BOOST_PP_REPEAT_FROM_TO(0, n, MOCK_EXPECTATION_WITH, BOOST_PP_EMPTY) \
             return *this; \

src/libraries/turtle/format.hpp

@@ -9,107 +9,214 @@
 #ifndef MOCK_FORMAT_HPP_INCLUDED
 #define MOCK_FORMAT_HPP_INCLUDED
 
-#include <boost/type_traits.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/noncopyable.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <boost/exception/detail/is_output_streamable.hpp>
+#include <boost/type_traits/integral_constant.hpp>
-#ifndef MOCK_NO_STL_FORMAT
 #include <boost/detail/container_fwd.hpp>
-#endif // MOCK_NO_STL_FORMAT
-#include <sstream>
 #include <ostream>
+#include <string>
 
 namespace mock
 {
+    struct stream : boost::noncopyable
+    {
+        stream( std::ostream& s )
+            : s_( s )
+        {
+            s << std::boolalpha;
+        }
+
+#define MOCK_STREAM_OPERATOR(Type) \
+        stream& operator<<( Type val ) \
+        { \
+            s_ << val; \
+            return *this; \
+        }
+        MOCK_STREAM_OPERATOR( bool )
+        MOCK_STREAM_OPERATOR( short )
+        MOCK_STREAM_OPERATOR( unsigned short )
+        MOCK_STREAM_OPERATOR( int )
+        MOCK_STREAM_OPERATOR( unsigned int )
+        MOCK_STREAM_OPERATOR( long )
+        MOCK_STREAM_OPERATOR( unsigned long )
+        MOCK_STREAM_OPERATOR( float )
+        MOCK_STREAM_OPERATOR( double )
+        MOCK_STREAM_OPERATOR( long double )
+        MOCK_STREAM_OPERATOR( char )
+        MOCK_STREAM_OPERATOR( unsigned char )
+#undef MOCK_STREAM_OPERATOR
+
+        std::ostream& s_;
+    };
+
 namespace detail
 {
+namespace protect
+{
+    template< typename S, typename T >
+    char operator<<( S&, const T& );
+
+    template< typename S, typename T >
+    struct is_serializable_impl
+    {
+        BOOST_STATIC_ASSERT( sizeof( S& ) != sizeof( char ) );
+        static S* s;
+        static T* t;
+        enum { value = sizeof( *s << *t ) == sizeof( S& ) };
+    };
+
+    template< typename S, typename T >
+    struct is_serializable : boost::integral_constant< bool, is_serializable_impl< S, T >::value >
+    {};
+}
+
     template< typename T >
-    std::string serialize( const T& t,
+    void serialize( std::ostream& s, const T& t,
         BOOST_DEDUCED_TYPENAME boost::enable_if<
-            BOOST_DEDUCED_TYPENAME boost::is_output_streamable< T > >::type* = 0 )
+            BOOST_DEDUCED_TYPENAME protect::is_serializable< std::ostream, T > >::type* = 0 )
     {
-        std::stringstream s;
+        s << t;
-        s << std::boolalpha << t;
-        return s.str();
     }
     template< typename T >
-    std::string serialize( const T&,
+    void serialize( std::ostream& s, const T&,
         BOOST_DEDUCED_TYPENAME boost::disable_if<
-            BOOST_DEDUCED_TYPENAME boost::is_output_streamable< T > >::type* = 0 )
+            BOOST_DEDUCED_TYPENAME protect::is_serializable< std::ostream, T > >::type* = 0 )
     {
-        return "?";
+        s << "?";
-    }
     }
 
     template< typename T >
-    std::string format( const T& t )
+    void serialize( mock::stream& s, const T& t,
+        BOOST_DEDUCED_TYPENAME boost::enable_if<
+            BOOST_DEDUCED_TYPENAME protect::is_serializable< mock::stream, T > >::type* = 0 )
     {
-        return detail::serialize( t );
+        s << t;
-    }
-
-    inline std::string format( const char* s )
-    {
-        return '"' + std::string( s ) + '"';
-    }
-
-#ifndef MOCK_NO_STL_FORMAT
-    inline std::string format( const std::string& s )
-    {
-        return '"' + s + '"';
-    }
-    template< typename T1, typename T2 >
-    inline std::string format( const std::pair< T1, T2 >& p )
-    {
-        return '(' + mock::format( p.first ) + ',' + mock::format( p.second ) + ')';
     }
     template< typename T >
-    std::string format( const T& begin, const T& end )
+    void serialize( mock::stream& s, const T& t,
+        BOOST_DEDUCED_TYPENAME boost::disable_if<
+            BOOST_DEDUCED_TYPENAME protect::is_serializable< mock::stream, T > >::type* = 0 )
+    {
+        detail::serialize( s.s_, t );
+    }
+
+    template< typename T >
+    struct formatter
+    {
+        explicit formatter( const T& t )
+            : t_( &t )
+        {}
+        friend std::ostream& operator<<( std::ostream& s, const formatter& t )
+        {
+            mock::stream ms( s );
+            detail::serialize( ms, *t.t_ );
+            return s;
+        }
+        friend mock::stream& operator<<( mock::stream& s, const formatter& t )
+        {
+            detail::serialize( s, *t.t_ );
+            return s;
+        }
+        const T* t_;
+    };
+    template<>
+    struct formatter< std::string >
+    {
+        explicit formatter( const std::string& s )
+            : s_( &s )
+        {}
+        friend std::ostream& operator<<( std::ostream& s, const formatter& t )
+        {
+            return s << '"' << *t.s_ << '"';
+        }
+        friend mock::stream& operator<<( mock::stream& s, const formatter& t )
+        {
+            s.s_ << '"' << *t.s_ << '"';
+            return s;
+        }
+        const std::string* s_;
+    };
+    template<>
+    struct formatter< const char* >
+    {
+        explicit formatter( const char* s )
+            : s_( s )
+        {}
+        friend std::ostream& operator<<( std::ostream& s, const formatter& t )
+        {
+            return s << '"' << t.s_ << '"';
+        }
+        friend mock::stream& operator<<( mock::stream& s, const formatter& t )
+        {
+            s.s_ << '"' << t.s_ << '"';
+            return s;
+        }
+        const char* s_;
+    };
+}
+
+    template< typename T >
+    detail::formatter< T > format( const T& t )
+    {
+        return detail::formatter< T >( t );
+    }
+
+    template< typename T >
+    mock::stream& serialize( mock::stream& s, const T& begin, const T& end )
     {
-        std::stringstream s;
         s << '(';
         for( T it = begin; it != end; ++it )
-            s << (it == begin ? "" : ",") << mock::format( *it );
-        s << ')';
-        return s.str();
-    }
-    template< typename T, typename A >
-    std::string format( const std::deque< T, A >& d )
         {
-        return format( d.begin(), d.end() );
+            if( it != begin )
+                s << ',';
+            s << mock::format( *it );
+        }
+        return s << ')';
+    }
+
+    template< typename T1, typename T2 >
+    mock::stream& operator<<( mock::stream& s, const std::pair< T1, T2 >& p )
+    {
+        return s << '(' << mock::format( p.first ) << ',' << mock::format( p.second ) << ')';
+    }
+    template< typename T, typename A >
+    mock::stream& operator<<( mock::stream& s, const std::deque< T, A >& c )
+    {
+        return mock::serialize( s, c.begin(), c.end() );
+    }
+    template< typename T, typename A >
+    mock::stream& operator<<( mock::stream& s, const std::list< T, A >& c )
+    {
+        return mock::serialize( s, c.begin(), c.end() );
+    }
+    template< typename T, typename A >
+    mock::stream& operator<<( mock::stream& s, const std::vector< T, A >& c )
+    {
+        return mock::serialize( s, c.begin(), c.end() );
+    }
+    template< typename K, typename T, typename C, typename A >
+    mock::stream& operator<<( mock::stream& s, const std::map< K, T, C, A >& c )
+    {
+        return mock::serialize( s, c.begin(), c.end() );
+    }
+    template< typename K, typename T, typename C, typename A >
+    mock::stream& operator<<( mock::stream& s, const std::multimap< K, T, C, A >& c )
+    {
+        return mock::serialize( s, c.begin(), c.end() );
+    }
+    template< typename T, typename C, typename A >
+    mock::stream& operator<<( mock::stream& s, const std::set< T, C, A >& c )
+    {
+        return mock::serialize( s, c.begin(), c.end() );
+    }
+    template< typename T, typename C, typename A >
+    mock::stream& operator<<( mock::stream& s, const std::multiset< T, C, A >& c )
+    {
+        return mock::serialize( s, c.begin(), c.end() );
     }
-    template< typename T, typename A >
-    std::string format( const std::list< T, A >& l )
-    {
-        return format( l.begin(), l.end() );
-    }
-    template< typename T, typename A >
-    std::string format( const std::vector< T, A >& v )
-    {
-        return format( v.begin(), v.end() );
-    }
-    template< typename K, typename T, typename C, typename A >
-    std::string format( const std::map< K, T, C, A >& m )
-    {
-        return format( m.begin(), m.end() );
-    }
-    template< typename K, typename T, typename C, typename A >
-    std::string format( const std::multimap< K, T, C, A >& m )
-    {
-        return format( m.begin(), m.end() );
-    }
-    template< typename T, typename C, typename A >
-    std::string format( const std::set< T, C, A >& s )
-    {
-        return format( s.begin(), s.end() );
-    }
-    template< typename T, typename C, typename A >
-    std::string format( const std::multiset< T, C, A >& s )
-    {
-        return format( s.begin(), s.end() );
-    }
-#endif // MOCK_NO_STL_FORMAT
 }
 
-#ifndef MOCK_NO_BOOST_FORMAT
 namespace boost
 {
 namespace assign_detail
@@ -120,11 +227,10 @@ namespace assign_detail
 namespace mock
 {
     template< typename T >
-    std::string format( const boost::assign_detail::generic_list< T >& l )
+    mock::stream& operator<<( mock::stream& s, const boost::assign_detail::generic_list< T >& c )
     {
-        return format( l.begin(), l.end() );
+        return mock::serialize( s, c.begin(), c.end() );
     }
 }
-#endif // MOCK_NO_BOOST_FORMAT
 
 #endif // #ifndef MOCK_FORMAT_HPP_INCLUDED

src/libraries/turtle/function.hpp

@@ -21,6 +21,8 @@
 #include <boost/preprocessor/repetition/repeat_from_to.hpp>
 #include <boost/preprocessor/repetition/enum_params.hpp>
 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/comparison/equal.hpp>
+#include <boost/test/utils/lazy_ostream.hpp>
 #include <boost/shared_ptr.hpp>
 #include <ostream>
 #include <list>
@@ -113,6 +115,11 @@ namespace mock
             return s << *e.impl_;
         }
 
+#define MOCK_EXPECTATION_CONTEXT \
+    boost::unit_test::lazy_ostream::instance() \
+        << lazy_context( parent_, name_ ) \
+        << lazy_expectations( expectations_ )
+
     private:
         class function_impl : private verifiable
         {
@@ -132,13 +139,41 @@ namespace mock
                     {
                         if( ! it->verify() )
                             ErrorPolicy::untriggered_expectation(
-                                context(), it->file(), it->line() );
+                                MOCK_EXPECTATION_CONTEXT,
+                                it->file(), it->line() );
                         else if( ! it->invoked() )
                             ErrorPolicy::expected_call(
-                                context(), it->file(), it->line() );
+                                MOCK_EXPECTATION_CONTEXT,
+                                it->file(), it->line() );
                     }
             }
 
+            virtual bool verify() const
+            {
+                for( expectations_cit it = expectations_.begin();
+                    it != expectations_.end(); ++it )
+                    if( !it->verify() )
+                    {
+                        valid_ = false;
+                        ErrorPolicy::verification_failed(
+                            MOCK_EXPECTATION_CONTEXT,
+                            it->file(), it->line() );
+                    }
+                return valid_;
+            }
+
+#undef MOCK_EXPECTATION_CONTEXT
+
+            virtual void reset()
+            {
+                valid_ = true;
+                expectations_.clear();
+            }
+            virtual void untie()
+            {
+                parent_ = 0;
+            }
+
             void tag( const std::string& name )
             {
                 name_ = name;
@@ -155,28 +190,6 @@ namespace mock
                 parent_ = &parent;
             }
 
-            virtual bool verify() const
-            {
-                for( expectations_cit it = expectations_.begin();
-                    it != expectations_.end(); ++it )
-                    if( !it->verify() )
-                    {
-                        valid_ = false;
-                        ErrorPolicy::verification_failed( context(),
-                            it->file(), it->line() );
-                    }
-                return valid_;
-            }
-            virtual void reset()
-            {
-                valid_ = true;
-                expectations_.clear();
-            }
-            virtual void untie()
-            {
-                parent_ = 0;
-            }
-
             expectation_type& expect( const std::string& file, int line )
             {
                 expectation_type& e = expect();
@@ -192,26 +205,14 @@ namespace mock
                 return expectations_.back();
             }
 
-            struct no_throw_abort
+#define MOCK_EXPECTATION_FORMAT(z, n, N) \
-            {
+    << " " << mock::format( p##n ) << BOOST_PP_IF(BOOST_PP_EQUAL(N,n), " ", ",")
-                static void abort() {}
+#define MOCK_EXPECTATION_CALL_CONTEXT(n) \
-            };
+    boost::unit_test::lazy_ostream::instance() \
-            void test() const
+        << lazy_context( parent_, name_ ) \
-            {
+        << "(" BOOST_PP_REPEAT_FROM_TO(0, n, MOCK_EXPECTATION_FORMAT, BOOST_PP_DEC(n)) << ")" \
-                invoke< no_throw_abort >();
+        << lazy_expectations( expectations_ )
-            }
+#define MOCK_EXPECTATION_INVOKE(z, n, A) \
-
-            result_type operator()() const
-            {
-                return invoke< ErrorPolicy >();
-            }
-
-#define MOCK_EXPECTATION_FORMAT(z, n, d) \
-    BOOST_PP_IF(n, + ", " +,) mock::format( p##n )
-#define MOCK_EXPECTATION_CONTEXT(n) \
-    context( BOOST_PP_REPEAT_FROM_TO(0, n, MOCK_EXPECTATION_FORMAT, BOOST_PP_EMPTY) )
-#define MOCK_EXPECTATION_OPERATOR(z, n, d) \
-    MOCK_DECL(operator(), n, Signature, const, BOOST_DEDUCED_TYPENAME) \
     { \
         for( expectations_cit it = expectations_.begin(); it != expectations_.end(); ++it ) \
             if( it->is_valid( BOOST_PP_ENUM_PARAMS(n, p) ) ) \
@@ -219,59 +220,39 @@ namespace mock
                 if( ! it->invoke() ) \
                 { \
                     valid_ = false; \
-                    ErrorPolicy::sequence_failed( MOCK_EXPECTATION_CONTEXT(n), it->file(), it->line() ); \
+                    ErrorPolicy::sequence_failed( MOCK_EXPECTATION_CALL_CONTEXT(n), it->file(), it->line() ); \
-                    return ErrorPolicy::abort(); \
+                    return A; \
                 } \
                 if( ! it->functor() ) \
                 { \
-                    ErrorPolicy::missing_action( MOCK_EXPECTATION_CONTEXT(n), it->file(), it->line() ); \
+                    ErrorPolicy::missing_action( MOCK_EXPECTATION_CALL_CONTEXT(n), it->file(), it->line() ); \
-                    return ErrorPolicy::abort(); \
+                    return A; \
                 } \
-                ErrorPolicy::expected_call( MOCK_EXPECTATION_CONTEXT(n), it->file(), it->line() ); \
+                ErrorPolicy::expected_call( MOCK_EXPECTATION_CALL_CONTEXT(n), it->file(), it->line() ); \
                 return it->functor()( BOOST_PP_ENUM_PARAMS(n, p) ); \
             } \
         valid_ = false; \
-        ErrorPolicy::unexpected_call( MOCK_EXPECTATION_CONTEXT(n) ); \
+        ErrorPolicy::unexpected_call( MOCK_EXPECTATION_CALL_CONTEXT(n) ); \
-        return ErrorPolicy::abort(); \
+        return A; \
     }
-    BOOST_PP_REPEAT_FROM_TO(1, MOCK_NUM_ARGS, MOCK_EXPECTATION_OPERATOR, BOOST_PP_EMPTY)
+#define MOCK_EXPECTATION_OPERATOR(z, n, P) \
-#undef MOCK_EXPECTATION_CONTEXT
+    MOCK_DECL(operator(), n, Signature, const, BOOST_DEDUCED_TYPENAME) \
+    MOCK_EXPECTATION_INVOKE(z, n, P)
+
+            BOOST_PP_REPEAT_FROM_TO(0, MOCK_NUM_ARGS, MOCK_EXPECTATION_OPERATOR, ErrorPolicy::abort())
+
+            void test() const
+            MOCK_EXPECTATION_INVOKE(, 0,)
+
 #undef MOCK_EXPECTATION_FORMAT
 #undef MOCK_EXPECTATION_OPERATOR
+#undef MOCK_EXPECTATION_INVOKE
+#undef MOCK_EXPECTATION_CALL_CONTEXT
 
             friend std::ostream& operator<<( std::ostream& s, const function_impl& e )
             {
-                return s << e.context();
+                return s << lazy_context( e.parent_, e.name_ )
-            }
+                    << lazy_expectations( e.expectations_ );
-
-        private:
-            template< typename T >
-            result_type invoke() const
-            {
-                for( expectations_cit it = expectations_.begin();
-                    it != expectations_.end(); ++it )
-                    if( it->is_valid() )
-                    {
-                        if( ! it->invoke() )
-                        {
-                            valid_ = false;
-                            ErrorPolicy::sequence_failed( context( "" ),
-                                it->file(), it->line() );
-                            return T::abort();
-                        }
-                        if( ! it->functor() )
-                        {
-                            ErrorPolicy::missing_action( context( "" ),
-                                it->file(), it->line() );
-                            return T::abort();
-                        }
-                        ErrorPolicy::expected_call( context( "" ),
-                                it->file(), it->line() );
-                        return it->functor()();
-                    }
-                valid_ = false;
-                ErrorPolicy::unexpected_call( context( "" ) );
-                return T::abort();
             }
 
         private:
@@ -279,31 +260,39 @@ namespace mock
             typedef BOOST_DEDUCED_TYPENAME
                 expectations_type::const_iterator expectations_cit;
 
-            std::string context() const
+            struct lazy_context
             {
-                std::stringstream s;
+                lazy_context( const node* parent, const std::string& name )
-                serialize( s, "" );
+                    : parent_( parent )
-                return s.str();
+                    , name_( &name )
+                {}
+                friend std::ostream& operator<<( std::ostream& s, const lazy_context& e )
+                {
+                    if( e.parent_ )
+                        s << e.parent_->tag();
+                    return s << *e.name_;
                 }
-            std::string context( const std::string& parameters ) const
+                const node* parent_;
+                const std::string* name_;
+            };
+
+            struct lazy_expectations
             {
-                std::stringstream s;
+                lazy_expectations( const expectations_type& expectations )
-                if( parameters.empty() )
+                    : expectations_( &expectations )
-                    serialize( s, "()" );
+                {}
-                else
+                friend std::ostream& operator<<( std::ostream& s,
-                    serialize( s, "( " + parameters + " )" );
+                    const lazy_expectations& e )
-                return s.str();
-            }
-            void serialize( std::ostream& s,
-                const std::string& parameters ) const
                 {
-                if( parent_ )
+                    typedef BOOST_DEDUCED_TYPENAME
-                    s << parent_->tag();
+                        expectations_type::const_iterator expectations_cit;
-                s << name_ << parameters;
+                    for( expectations_cit it = e.expectations_->begin();
-                for( expectations_cit it = expectations_.begin();
+                        it != e.expectations_->end(); ++it )
-                    it != expectations_.end(); ++it )
                         s << std::endl << *it;
+                    return s;
                 }
+                const expectations_type* expectations_;
+            };
 
             std::string name_;
             node* parent_;

src/libraries/turtle/object.hpp

@@ -12,7 +12,6 @@
 #include "node.hpp"
 #include "root.hpp"
 #include <boost/shared_ptr.hpp>
-#include <ostream>
 #include <string>
 
 namespace mock

src/libraries/turtle/operators.hpp

@@ -10,60 +10,63 @@
 #define MOCK_OPERATORS_HPP_INCLUDED
 
 #include "constraint.hpp"
+#include "format.hpp"
 
 namespace mock
 {
 namespace detail
 {
-    template< typename Functor1, typename Functor2 >
+    template< typename Constraint1, typename Constraint2 >
     class and_
     {
     public:
-        and_( const Functor1& f1, const Functor2& f2 )
+        and_( const Constraint1& c1, const Constraint2& c2 )
-            : f1_( f1 )
+            : c1_( c1 )
-            , f2_( f2 )
+            , c2_( c2 )
         {}
         template< typename Actual >
         bool operator()( const Actual& actual ) const
         {
-            return f1_( actual ) && f2_( actual );
+            return c1_( actual ) && c2_( actual );
         }
         friend std::ostream& operator<<( std::ostream& s, const and_& a )
         {
-            return s << "( " << a.f1_ << " && " << a.f2_ << " )";
+            return s << "( " << mock::format( a.c1_ )
+                << " && " << mock::format( a.c2_ ) << " )";
         }
     private:
-        Functor1 f1_;
+        Constraint1 c1_;
-        Functor2 f2_;
+        Constraint2 c2_;
     };
 
-    template< typename Functor1, typename Functor2 >
+    template< typename Constraint1, typename Constraint2 >
     class or_
     {
     public:
-        or_( const Functor1& f1, const Functor2& f2 )
+        or_( const Constraint1& c1, const Constraint2& c2 )
-            : f1_( f1 )
+            : c1_( c1 )
-            , f2_( f2 )
+            , c2_( c2 )
         {}
         template< typename Actual >
         bool operator()( const Actual& actual ) const
         {
-            return f1_( actual ) || f2_( actual );
+            return c1_( actual ) || c2_( actual );
         }
         friend std::ostream& operator<<( std::ostream& s, const or_& o )
         {
-            return s << "( " << o.f1_ << " || " << o.f2_ << " )";
+            return s << "( " << mock::format( o.c1_ )
+                << " || " << mock::format( o.c2_ )<< " )";
         }
     private:
-        Functor1 f1_;
+        Constraint1 c1_;
-        Functor2 f2_;
+        Constraint2 c2_;
     };
 
-    template< typename Functor >
+    template< typename Constraint >
     class not_
     {
     public:
-        explicit not_( const Functor& f )
+        explicit not_( const Constraint& f )
             : f_( f )
         {}
         template< typename Actual >
@@ -73,34 +76,34 @@ namespace detail
         }
         friend std::ostream& operator<<( std::ostream& s, const not_& n )
         {
-            return s << "! " << n.f_;
+            return s << "! " << mock::format( n.f_ );
         }
     private:
-        Functor f_;
+        Constraint f_;
     };
 }
 
-    template< typename Functor1, typename Functor2 >
+    template< typename Constraint1, typename Constraint2 >
-    const constraint< detail::or_< Functor1, Functor2 > >
+    const constraint< detail::or_< Constraint1, Constraint2 > >
-        operator||( const constraint< Functor1 >& lhs,
+        operator||( const constraint< Constraint1 >& lhs,
-                    const constraint< Functor2 >& rhs )
+                    const constraint< Constraint2 >& rhs )
     {
-        return detail::or_< Functor1, Functor2 >( lhs.f_, rhs.f_ );
+        return detail::or_< Constraint1, Constraint2 >( lhs.f_, rhs.f_ );
     }
 
-    template< typename Functor1, typename Functor2 >
+    template< typename Constraint1, typename Constraint2 >
-    const constraint< detail::and_< Functor1, Functor2 > >
+    const constraint< detail::and_< Constraint1, Constraint2 > >
-        operator&&( const constraint< Functor1 >& lhs,
+        operator&&( const constraint< Constraint1 >& lhs,
-                    const constraint< Functor2 >& rhs )
+                    const constraint< Constraint2 >& rhs )
     {
-        return detail::and_< Functor1, Functor2 >( lhs.f_, rhs.f_ );
+        return detail::and_< Constraint1, Constraint2 >( lhs.f_, rhs.f_ );
     }
 
-    template< typename Functor >
+    template< typename Constraint >
-    const constraint< detail::not_< Functor > >
+    const constraint< detail::not_< Constraint > >
-        operator!( const constraint< Functor >& c )
+        operator!( const constraint< Constraint >& c )
     {
-        return detail::not_< Functor >( c.f_ );
+        return detail::not_< Constraint >( c.f_ );
     }
 }
 

src/tests/turtle_test/format_test.cpp

@@ -8,10 +8,9 @@
 
 #include <turtle/format.hpp>
 #include <boost/assign.hpp>
-#include <ostream>
+#include <vector>
 #include <deque>
 #include <list>
-#include <vector>
 #include <map>
 #include <set>
 

src/tests/turtle_test/function_test.cpp

@@ -20,11 +20,12 @@
 #define CHECK_CALLS( calls ) \
     BOOST_CHECK_EQUAL( calls, expected_call_count ); \
     expected_call_count = 0;
-#define CHECK_ERROR( expr, error, calls ) \
+#define CHECK_ERROR( expr, error, calls, context ) \
     BOOST_CHECK( verify() ); \
     expr; \
     BOOST_CHECK_EQUAL( 1, error##_count ); \
     CHECK_CALLS( calls ); \
+    BOOST_CHECK_EQUAL( context, last_context ); \
     reset();
 
 namespace
@@ -48,6 +49,7 @@ namespace
             sequence_failed_count = 0;
             verification_failed_count = 0;
             untriggered_expectation_count = 0;
+            last_context.clear();
         }
         bool verify() const
         {
@@ -87,11 +89,11 @@ BOOST_FIXTURE_TEST_CASE( triggering_an_unconfigured_function_calls_unexpected_ca
 {
     {
         mock::function< void() > f;
-        CHECK_ERROR( f(), unexpected_call, 0 );
+        CHECK_ERROR( f(), unexpected_call, 0, "?()" );
     }
     {
         mock::function< int( int, const std::string& ) > f;
-        CHECK_ERROR( f( 1, "s" ), unexpected_call, 0 );
+        CHECK_ERROR( f( 1, "s" ), unexpected_call, 0, "?( 1, \"s\" )" );
     }
 }
 
@@ -100,12 +102,12 @@ BOOST_FIXTURE_TEST_CASE( triggering_a_never_expectation_calls_unexpected_call_er
     {
         mock::function< void() > f;
         f.expect().never();
-        CHECK_ERROR( f(), unexpected_call, 0 );
+        CHECK_ERROR( f(), unexpected_call, 0, "?()\nv never()" );
     }
     {
         mock::function< int( int, const std::string& ) > f;
         f.expect().never();
-        CHECK_ERROR( f( 1, "s" ), unexpected_call, 0 );
+        CHECK_ERROR( f( 1, "s" ), unexpected_call, 0, "?( 1, \"s\" )\nv never().with( any, any )" );
     }
 }
 
@@ -133,13 +135,13 @@ BOOST_FIXTURE_TEST_CASE( triggering_a_once_expectation_calls_unexpected_call_err
         mock::function< void() > f;
         f.expect().once();
         f();
-        CHECK_ERROR( f(), unexpected_call, 1 );
+        CHECK_ERROR( f(), unexpected_call, 1, "?()\nv once()" );
     }
     {
         mock::function< void( int, const std::string& ) > f;
         f.expect().once();
         f( 1, "s" );
-        CHECK_ERROR( f( 1, "s" ), unexpected_call, 1 );
+        CHECK_ERROR( f( 1, "s" ), unexpected_call, 1, "?( 1, \"s\" )\nv once().with( any, any )" );
     }
 }
 
@@ -206,12 +208,12 @@ BOOST_FIXTURE_TEST_CASE( verifying_a_once_expectation_before_the_call_fails, err
     {
         mock::function< void() > f;
         f.expect().once();
-        CHECK_ERROR( BOOST_CHECK( ! f.verify() ), verification_failed, 0 );
+        CHECK_ERROR( BOOST_CHECK( ! f.verify() ), verification_failed, 0, "?\n. once()" );
     }
     {
         mock::function< int( int, const std::string& ) > f;
         f.expect().once();
-        CHECK_ERROR( BOOST_CHECK( ! f.verify() ), verification_failed, 0 );
+        CHECK_ERROR( BOOST_CHECK( ! f.verify() ), verification_failed, 0, "?\n. once().with( any, any )" );
     }
 }
 
@@ -223,13 +225,13 @@ BOOST_FIXTURE_TEST_CASE( triggering_a_reset_function_calls_unexpected_call_error
         mock::function< void() > f;
         f.expect();
         f.reset();
-        CHECK_ERROR( f(), unexpected_call, 0 );
+        CHECK_ERROR( f(), unexpected_call, 0, "?()" );
     }
     {
         mock::function< int( int, const std::string& ) > f;
         f.expect();
         f.reset();
-        CHECK_ERROR( f( 1, "s" ), unexpected_call, 0 );
+        CHECK_ERROR( f( 1, "s" ), unexpected_call, 0, "?( 1, \"s\" )" );
     }
 }
 
@@ -256,12 +258,12 @@ BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_with_wrong_parameter_value_in
     {
         mock::function< void( int ) > f;
         f.expect().with( 42 );
-        CHECK_ERROR( f( 43 ), unexpected_call, 0 );
+        CHECK_ERROR( f( 43 ), unexpected_call, 0, "?( 43 )\n. unlimited().with( 42 )" );
     }
     {
         mock::function< int( int, const std::string& ) > f;
         f.expect().with( 42, "expected" );
-        CHECK_ERROR( f( 42, "actual" ), unexpected_call, 0 );
+        CHECK_ERROR( f( 42, "actual" ), unexpected_call, 0, "?( 42, \"actual\" )\n. unlimited().with( 42, \"expected\" )" );
     }
 }
 
@@ -271,7 +273,7 @@ BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_with_wrong_parameter_value_in
     f.expect().with( mock::equal( 42 ) || mock::less( 42 ) );
     f( 41 );
     f( 42 );
-    CHECK_ERROR( f( 43 ), unexpected_call, 2 );
+    CHECK_ERROR( f( 43 ), unexpected_call, 2, "?( 43 )\n. unlimited().with( ( equal( 42 ) || less( 42 ) ) )" );
 }
 
 BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_with_wrong_parameter_value_in_equal_and_not_less_constraint_calls_unexpected_call_error, error_fixture )
@@ -279,7 +281,7 @@ BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_with_wrong_parameter_value_in
     mock::function< void( int ) > f;
     f.expect().with( mock::equal( 42 ) && ! mock::less( 41 ) );
     f( 42 );
-    CHECK_ERROR( f( 43 ), unexpected_call, 1 );
+    CHECK_ERROR( f( 43 ), unexpected_call, 1, "?( 43 )\n. unlimited().with( ( equal( 42 ) && ! less( 41 ) ) )" );
 }
 
 namespace
@@ -328,12 +330,12 @@ BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_with_failing_custom_constrain
     {
         mock::function< void( int ) > f;
         f.expect().with( &custom_constraint );
-        CHECK_ERROR( f( 42 ), unexpected_call, 0 );
+        CHECK_ERROR( f( 42 ), unexpected_call, 0, "?( 42 )\n. unlimited().with( ? )" );
     }
     {
         mock::function< int( int, const std::string& ) > f;
         f.expect().with( &custom_constraint, "actual" );
-        CHECK_ERROR( f( 42, "actual" ), unexpected_call, 0 );
+        CHECK_ERROR( f( 42, "actual" ), unexpected_call, 0, "?( 42, \"actual\" )\n. unlimited().with( ?, \"actual\" )" );
     }
 }
 
@@ -354,17 +356,17 @@ BOOST_FIXTURE_TEST_CASE( triggering_an_expectation_with_no_return_set_calls_miss
     {
         mock::function< int() > f;
         f.expect();
-        CHECK_ERROR( f(), missing_action, 0 );
+        CHECK_ERROR( f(), missing_action, 0, "?()\n. unlimited()" );
     }
     {
         mock::function< int&() > f;
         f.expect();
-        CHECK_ERROR( f(), missing_action, 0 );
+        CHECK_ERROR( f(), missing_action, 0, "?()\n. unlimited()" );
     }
     {
         mock::function< const std::string&() > f;
         f.expect();
-        CHECK_ERROR( f(), missing_action, 0 );
+        CHECK_ERROR( f(), missing_action, 0, "?()\n. unlimited()" );
     }
 }
 
@@ -582,7 +584,7 @@ BOOST_FIXTURE_TEST_CASE( expecting_twice_a_single_expectation_makes_it_callable_
         f.expect().once();
         f();
         f();
-        CHECK_ERROR( f(), unexpected_call, 2 );
+        CHECK_ERROR( f(), unexpected_call, 2, "?()\nv once()\nv once()" );
     }
     {
         mock::function< void( const std::string& ) > f;
@@ -590,7 +592,7 @@ BOOST_FIXTURE_TEST_CASE( expecting_twice_a_single_expectation_makes_it_callable_
         f.expect().once().with( "second" );
         f( "first" );
         f( "second" );
-        CHECK_ERROR( f( "third"), unexpected_call, 2 );
+        CHECK_ERROR( f( "third"), unexpected_call, 2, "?( \"third\" )\nv once().with( \"first\" )\nv once().with( \"second\" )" );
     }
 }
 
@@ -602,7 +604,7 @@ BOOST_FIXTURE_TEST_CASE( best_expectation_is_selected_first, error_fixture )
         f.expect().once().with( 2 );
         f( 2 );
         f( 1 );
-        CHECK_ERROR( f( 3 ), unexpected_call, 2 );
+        CHECK_ERROR( f( 3 ), unexpected_call, 2, "?( 3 )\nv once().with( 1 )\nv once().with( 2 )" );
     }
     {
         mock::function< void( const std::string& ) > f;
@@ -610,7 +612,7 @@ BOOST_FIXTURE_TEST_CASE( best_expectation_is_selected_first, error_fixture )
         f.expect().once().with( "second" );
         f( "second" );
         f( "first" );
-        CHECK_ERROR( f( "third"), unexpected_call, 2 );
+        CHECK_ERROR( f( "third"), unexpected_call, 2, "?( \"third\" )\nv once().with( \"first\" )\nv once().with( \"second\" )" );
     }
 }
 
@@ -714,28 +716,28 @@ BOOST_FIXTURE_TEST_CASE( expectation_with_remaining_untriggered_matches_upon_des
 {
     std::auto_ptr< mock::function< void() > > f( new mock::function< void() > );
     f->expect().once();
-    CHECK_ERROR( f.reset(), untriggered_expectation, 0 );
+    CHECK_ERROR( f.reset(), untriggered_expectation, 0, "?\n. once()" );
 }
 
 BOOST_FIXTURE_TEST_CASE( verifying_expectation_with_remaining_matches_disables_the_automatic_verification_upon_destruction, error_fixture )
 {
     mock::function< void() > f;
     f.expect().once();
-    CHECK_ERROR( f.verify(), verification_failed, 0 );
+    CHECK_ERROR( f.verify(), verification_failed, 0, "?\n. once()" );
 }
 
 BOOST_FIXTURE_TEST_CASE( triggering_unexpected_call_call_disables_the_automatic_verification_upon_destruction, error_fixture )
 {
     mock::function< void() > f;
-    CHECK_ERROR( f(), unexpected_call, 0 );
+    CHECK_ERROR( f(), unexpected_call, 0, "?()" );
 }
 
 BOOST_FIXTURE_TEST_CASE( adding_a_expectation_reactivates_the_verification_upon_destruction, error_fixture )
 {
     std::auto_ptr< mock::function< void() > > f( new mock::function< void() > );
-    CHECK_ERROR( (*f)(), unexpected_call, 0 );
+    CHECK_ERROR( (*f)(), unexpected_call, 0, "?()" );
     f->expect().once();
-    CHECK_ERROR( f.reset(), untriggered_expectation, 0 );
+    CHECK_ERROR( f.reset(), untriggered_expectation, 0, "?\n. once()" );
 }
 
 BOOST_FIXTURE_TEST_CASE( throwing_an_exception_disables_the_automatic_verification_upon_destruction, error_fixture )

src/tests/turtle_test/integration_test.cpp

@@ -329,6 +329,41 @@ BOOST_AUTO_TEST_CASE( boost_optional_on_base_class_reference_as_return_type_is_s
     b.method();
 }
 
+namespace
+{
+    bool serialized = false;
+
+    struct custom_argument
+    {
+        friend std::ostream& operator<<( std::ostream& s, const custom_argument& )
+        {
+            serialized = true;
+            return s;
+        }
+    };
+    struct custom_constraint
+    {
+        template< typename Actual >
+        friend bool operator==( Actual, const custom_constraint& )
+        {
+            return true;
+        }
+        friend std::ostream& operator<<( std::ostream& s, const custom_constraint& )
+        {
+            serialized = true;
+            return s;
+        }
+    };
+}
+
+BOOST_AUTO_TEST_CASE( constraints_and_arguments_are_serialized_lazily )
+{
+    MOCK_FUNCTOR( void( custom_argument ) ) f;
+    MOCK_EXPECT( f, _ ).with( custom_constraint() );
+    f( custom_argument() );
+    BOOST_CHECK( ! serialized );
+}
+
 namespace
 {
     template< typename Expected >

src/tests/turtle_test/mock_error.hpp

@@ -10,6 +10,7 @@
 #define MOCK_TEST_MOCK_ERROR_HPP_INCLUDED
 
 #include <boost/type_traits/remove_reference.hpp>
+#include <boost/lexical_cast.hpp>
 #include <string>
 
 namespace
@@ -20,6 +21,8 @@ namespace
     int sequence_failed_count = 0;
     int verification_failed_count = 0;
     int untriggered_expectation_count = 0;
+
+    std::string last_context;
 }
 namespace mock
 {
@@ -32,33 +35,45 @@ namespace mock
             return r;
         }
 
-        static void missing_action( const std::string& /*context*/,
+        template< typename Context >
+        static void missing_action( const Context& context,
             const std::string& /*file*/, int /*line*/ )
         {
+            last_context = boost::lexical_cast< std::string >( context );
             ++missing_action_count;
         }
-        static void expected_call( const std::string& /*context*/,
+        template< typename Context >
+        static void expected_call( const Context& context,
             const std::string& /*file*/, int /*line*/ )
         {
+            last_context = boost::lexical_cast< std::string >( context );
             ++expected_call_count;
         }
-        static void unexpected_call( const std::string& /*context*/ )
+        template< typename Context >
+        static void unexpected_call( const Context& context )
         {
+            last_context = boost::lexical_cast< std::string >( context );
             ++unexpected_call_count;
         }
-        static void sequence_failed( const std::string& /*context*/,
+        template< typename Context >
+        static void sequence_failed( const Context& context,
             const std::string& /*file*/, int /*line*/ )
         {
+            last_context = boost::lexical_cast< std::string >( context );
             ++sequence_failed_count;
         }
-        static void verification_failed( const std::string& /*context*/,
+        template< typename Context >
+        static void verification_failed( const Context& context,
             const std::string& /*file*/, int /*line*/ )
         {
+            last_context = boost::lexical_cast< std::string >( context );
             ++verification_failed_count;
         }
-        static void untriggered_expectation( const std::string& /*context*/,
+        template< typename Context >
+        static void untriggered_expectation( const Context& context,
             const std::string& /*file*/, int /*line*/ )
         {
+            last_context = boost::lexical_cast< std::string >( context );
             ++untriggered_expectation_count;
         }
     };
@@ -67,33 +82,45 @@ namespace mock
     {
         static void abort()
         {}
-        static void missing_action( const std::string& /*context*/,
+        template< typename Context >
+        static void missing_action( const Context& context,
             const std::string& /*file*/, int /*line*/ )
         {
+            last_context = boost::lexical_cast< std::string >( context );
             ++missing_action_count;
         }
-        static void expected_call( const std::string& /*context*/,
+        template< typename Context >
+        static void expected_call( const Context& context,
             const std::string& /*file*/, int /*line*/ )
         {
+            last_context = boost::lexical_cast< std::string >( context );
             ++expected_call_count;
         }
-        static void unexpected_call( const std::string& /*context*/ )
+        template< typename Context >
+        static void unexpected_call( const Context& context )
         {
+            last_context = boost::lexical_cast< std::string >( context );
             ++unexpected_call_count;
         }
-        static void sequence_failed( const std::string& /*context*/,
+        template< typename Context >
+        static void sequence_failed( const Context& context,
             const std::string& /*file*/, int /*line*/ )
         {
+            last_context = boost::lexical_cast< std::string >( context );
             ++sequence_failed_count;
         }
-        static void verification_failed( const std::string& /*context*/,
+        template< typename Context >
+        static void verification_failed( const Context& context,
             const std::string& /*file*/, int /*line*/ )
         {
+            last_context = boost::lexical_cast< std::string >( context );
             ++verification_failed_count;
         }
-        static void untriggered_expectation( const std::string& /*context*/,
+        template< typename Context >
+        static void untriggered_expectation( const Context& context,
             const std::string& /*file*/, int /*line*/ )
         {
+            last_context = boost::lexical_cast< std::string >( context );
             ++untriggered_expectation_count;
         }
     };

src/tests/turtle_test/silent_error.hpp

@@ -10,7 +10,6 @@
 #define MOCK_TEST_SILENT_ERROR_HPP_INCLUDED
 
 #include <string>
-#include <sstream>
 #include <stdexcept>
 
 namespace mock
@@ -22,21 +21,27 @@ namespace mock
         {
             throw std::runtime_error( "abort" );
         }
-        static void expected_call( const std::string& /*context*/,
+        template< typename Context >
+        static void expected_call( const Context& /*context*/,
             const std::string& /*file*/, int /*line*/ )
         {}
-        static void unexpected_call( const std::string& /*context*/ )
+        template< typename Context >
+        static void unexpected_call( const Context& /*context*/ )
         {}
-        static void missing_action( const std::string& /*context*/,
+        template< typename Context >
+        static void missing_action( const Context& /*context*/,
             const std::string& /*file*/, int /*line*/ )
         {}
-        static void sequence_failed( const std::string& /*context*/,
+        template< typename Context >
+        static void sequence_failed( const Context& /*context*/,
             const std::string& /*file*/, int /*line*/ )
         {}
-        static void verification_failed( const std::string& /*context*/,
+        template< typename Context >
+        static void verification_failed( const Context& /*context*/,
             const std::string& /*file*/, int /*line*/ )
         {}
-        static void untriggered_expectation( const std::string& /*context*/,
+        template< typename Context >
+        static void untriggered_expectation( const Context& /*context*/,
             const std::string& /*file*/, int /*line*/ )
         {}
     };