From fe3d419f66cfec9561f7bb5be33b5bfa7859c38a Mon Sep 17 00:00:00 2001 From: mat007 Date: Sat, 20 Feb 2010 22:25:49 +0000 Subject: [PATCH] Made template parameters names more user friendly in order to provide better diagnostic upon compilation error git-svn-id: https://svn.code.sf.net/p/turtle/code/trunk@127 860be788-9bd5-4423-9f1e-828f051e677b --- src/libraries/turtle/check.hpp | 33 ++++--- src/libraries/turtle/constraint.hpp | 50 +++++----- src/libraries/turtle/functional.hpp | 144 ++++++++++++++-------------- src/libraries/turtle/matcher.hpp | 2 +- 4 files changed, 114 insertions(+), 115 deletions(-) diff --git a/src/libraries/turtle/check.hpp b/src/libraries/turtle/check.hpp index 4b21846..3abc59b 100644 --- a/src/libraries/turtle/check.hpp +++ b/src/libraries/turtle/check.hpp @@ -22,48 +22,47 @@ namespace mock { namespace detail { - template< typename Arg > + template< typename Actual > class check { typedef BOOST_DEDUCED_TYPENAME - boost::function< bool( Arg ) > functor_type; + boost::function< bool( Actual ) > functor_type; public: - template< typename F > - explicit check( const F& f, + template< typename Functor > + explicit check( const Functor& functor, BOOST_DEDUCED_TYPENAME boost::enable_if< - BOOST_DEDUCED_TYPENAME detail::is_functor< F >::type + BOOST_DEDUCED_TYPENAME detail::is_functor< Functor > >::type* = 0 ) - : functor_( f ) + : functor_( functor ) , desc_ ( "?" ) { if( !functor_ ) std::invalid_argument( "invalid functor" ); } - template< typename T > - explicit check( const T& t, + template< typename Expected > + explicit check( const Expected& expected, BOOST_DEDUCED_TYPENAME boost::disable_if< - BOOST_DEDUCED_TYPENAME detail::is_functor< T >::type + BOOST_DEDUCED_TYPENAME detail::is_functor< Expected > >::type* = 0 ) - : functor_( equal( t ).functor_ ) - , desc_ ( format( t ) ) + : functor_( mock::equal( expected ).functor_ ) + , desc_ ( format( expected ) ) { if( !functor_ ) std::invalid_argument( "invalid functor" ); } template< typename Constraint > - explicit check( const placeholder< Constraint >& p ) - : functor_( p.functor_ ) - , desc_ ( p.desc_ ) + explicit check( const placeholder< Constraint >& ph ) + : functor_( ph.functor_ ) + , desc_ ( ph.desc_ ) { if( !functor_ ) std::invalid_argument( "invalid functor" ); } - template< typename Y > - bool operator()( Y& y ) const + bool operator()( Actual actual ) const { - return functor_( y ); + return functor_( actual ); } friend std::ostream& operator<<( std::ostream& s, const check& c ) diff --git a/src/libraries/turtle/constraint.hpp b/src/libraries/turtle/constraint.hpp index ae2a322..507fe43 100644 --- a/src/libraries/turtle/constraint.hpp +++ b/src/libraries/turtle/constraint.hpp @@ -41,65 +41,65 @@ namespace mock namespace detail { template<> - struct placeholder< nothing > + struct placeholder< any > { placeholder() : desc_( "any" ) {} - nothing functor_; + any functor_; std::string desc_; }; template<> - struct placeholder< negation > + struct placeholder< negate > { placeholder() : desc_( "negate" ) {} - negation functor_; + negate functor_; std::string desc_; }; template<> - struct placeholder< evaluation > + struct placeholder< evaluate > { placeholder() : desc_( "evaluate" ) {} - evaluation functor_; + evaluate functor_; std::string desc_; }; } - const detail::placeholder< detail::nothing > any; - const detail::placeholder< detail::negation > negate; - const detail::placeholder< detail::evaluation > evaluate; + const detail::placeholder< detail::any > any; + const detail::placeholder< detail::negate > negate; + const detail::placeholder< detail::evaluate > evaluate; template< typename T > - detail::placeholder< detail::equality< T > > equal( T t ) + detail::placeholder< detail::equal< T > > equal( T t ) { - return constraint( detail::equality< T >( t ), "equal", t ); + return constraint( detail::equal< T >( t ), "equal", t ); } template< typename T > - detail::placeholder< detail::identity< T > > same( T& t ) + detail::placeholder< detail::same< T > > same( T& t ) { - return constraint( detail::identity< T >( boost::ref( t ) ), + return constraint( detail::same< T >( boost::ref( t ) ), "same", &t ); } template< typename T > - detail::placeholder< detail::inferiority< T > > less( T t ) + detail::placeholder< detail::less< T > > less( T t ) { - return constraint( detail::inferiority< T >( t ), "less", t ); + return constraint( detail::less< T >( t ), "less", t ); } template< typename T > - detail::placeholder< detail::superiority< T > > greater( T t ) + detail::placeholder< detail::greater< T > > greater( T t ) { - return constraint( detail::superiority< T >( t ), "greater", t ); + return constraint( detail::greater< T >( t ), "greater", t ); } template< typename T > detail::placeholder< - detail::or_< detail::inferiority< T >, detail::equality< T > > > + detail::or_< detail::less< T >, detail::equal< T > > > less_equal( T t ) { return constraint( (less( t ) || equal( t )).functor_, @@ -108,7 +108,7 @@ namespace detail template< typename T > detail::placeholder< - detail::or_< detail::superiority< T >, detail::equality< T > > > + detail::or_< detail::greater< T >, detail::equal< T > > > greater_equal( T t ) { return constraint( (greater( t ) || equal( t )).functor_, @@ -116,22 +116,22 @@ namespace detail } template< typename T > - detail::placeholder< detail::assignment< T > > assign( T t ) + detail::placeholder< detail::assign< T > > assign( T t ) { - return constraint( detail::assignment< T >( t ), "assign", t ); + return constraint( detail::assign< T >( t ), "assign", t ); } template< typename T > - detail::placeholder< detail::retrieval< T > > retrieve( T& t ) + detail::placeholder< detail::retrieve< T > > retrieve( T& t ) { - return constraint( detail::retrieval< T >( boost::ref( t ) ), + return constraint( detail::retrieve< T >( boost::ref( t ) ), "retrieve", t ); } template< typename T > - detail::placeholder< detail::container< T > > contain( T t ) + detail::placeholder< detail::contains< T > > contain( T t ) { - return constraint( detail::container< T >( t ), "contain", t ); + return constraint( detail::contains< T >( t ), "contain", t ); } } diff --git a/src/libraries/turtle/functional.hpp b/src/libraries/turtle/functional.hpp index fb54d69..a227bcd 100644 --- a/src/libraries/turtle/functional.hpp +++ b/src/libraries/turtle/functional.hpp @@ -18,158 +18,158 @@ namespace mock { namespace detail { - class nothing + class any { public: - template< typename Y > - bool operator()( const Y& ) const + template< typename Actual > + bool operator()( const Actual& ) const { return true; } }; - class negation + class negate { public: - template< typename Y > - bool operator()( const Y& y ) const + template< typename Actual > + bool operator()( const Actual& actual ) const { - return ! y; + return ! actual; } }; - class evaluation + class evaluate { public: - template< typename Y > - bool operator()( const Y& y ) const + template< typename Actual > + bool operator()( const Actual& actual ) const { - return y(); + return actual(); } }; - template< typename T > - class equality + template< typename Expected > + class equal { public: - explicit equality( const T& t ) - : t_( t ) + explicit equal( const Expected& expected ) + : expected_( expected ) {} - template< typename Y > - bool operator()( const Y& y ) const + template< typename Actual > + bool operator()( const Actual& actual ) const { - return y == t_; + return actual == expected_; } private: - T t_; + Expected expected_; }; - template< typename T > - class identity + template< typename Expected > + class same { public: - explicit identity( const boost::reference_wrapper< T >& t ) - : t_( t ) + explicit same( const boost::reference_wrapper< Expected >& expected ) + : expected_( expected ) {} - template< typename Y > - bool operator()( const Y& y ) const + template< typename Actual > + bool operator()( const Actual& actual ) const { - return &y == t_.get_pointer(); + return &actual == expected_.get_pointer(); } private: - boost::reference_wrapper< T > t_; + boost::reference_wrapper< Expected > expected_; }; - template< typename T > - class inferiority + template< typename Expected > + class less { public: - explicit inferiority( const T& t ) - : t_( t ) + explicit less( const Expected& expected ) + : expected_( expected ) {} - template< typename Y > - bool operator()( const Y& y ) const + template< typename Actual > + bool operator()( const Actual& actual ) const { - return y < t_; + return actual < expected_; } private: - T t_; + Expected expected_; }; - template< typename T > - class superiority + template< typename Expected > + class greater { public: - explicit superiority( const T& t ) - : t_( t ) + explicit greater( const Expected& expected ) + : expected_( expected ) {} - template< typename Y > - bool operator()( const Y& y ) const + template< typename Actual > + bool operator()( const Actual& actual ) const { - return y > t_; + return actual > expected_; } private: - T t_; + Expected expected_; }; - template< typename T > - class assignment + template< typename Expected > + class assign { public: - explicit assignment( const T& t ) - : t_( t ) + explicit assign( const Expected& expected ) + : expected_( expected ) {} - template< typename Y > - bool operator()( Y& y ) const + template< typename Actual > + bool operator()( Actual& actual ) const { - y = t_; + actual = expected_; return true; } private: - T t_; + Expected expected_; }; - template< typename T > - class retrieval + template< typename Expected > + class retrieve { public: - explicit retrieval( const boost::reference_wrapper< T >& t ) - : t_( t ) + explicit retrieve( const boost::reference_wrapper< Expected >& expected ) + : expected_( expected ) {} - template< typename Y > - bool operator()( const Y& y, + template< typename Actual > + bool operator()( const Actual& actual, BOOST_DEDUCED_TYPENAME boost::disable_if< - boost::is_convertible< const Y*, T >, Y >::type* = 0 ) const + boost::is_convertible< const Actual*, Expected >, Actual >::type* = 0 ) const { - t_.get() = y; + expected_.get() = actual; return true; } - template< typename Y > - bool operator()( Y& y, + template< typename Actual > + bool operator()( Actual& actual, BOOST_DEDUCED_TYPENAME boost::enable_if< - boost::is_convertible< Y*, T >, Y >::type* = 0 ) const + boost::is_convertible< Actual*, Expected >, Actual >::type* = 0 ) const { - t_.get() = &y; + expected_.get() = &actual; return true; } private: - boost::reference_wrapper< T > t_; + boost::reference_wrapper< Expected > expected_; }; - template< typename T > - class container + template< typename Expected > + class contains { public: - explicit container( const T& t ) - : t_( t ) + explicit contains( const Expected& expected ) + : expected_( expected ) {} - template< typename Y > - bool operator()( const Y& y ) const + template< typename Actual > + bool operator()( const Actual& actual ) const { - return boost::algorithm::contains( y, t_ ); + return boost::algorithm::contains( actual, expected_ ); } private: - T t_; + Expected expected_; }; } } diff --git a/src/libraries/turtle/matcher.hpp b/src/libraries/turtle/matcher.hpp index b862c3c..015a345 100644 --- a/src/libraries/turtle/matcher.hpp +++ b/src/libraries/turtle/matcher.hpp @@ -173,7 +173,7 @@ namespace detail n \ >::type arg##n##_type; \ typedef detail::check< arg##n##_type > constraint##n##_type; -#define MOCK_MATCHER_CONSTRUCTOR(z, n, d) BOOST_PP_COMMA_IF(n) c##n##_ ( any ) +#define MOCK_MATCHER_CONSTRUCTOR(z, n, d) BOOST_PP_COMMA_IF(n) c##n##_( mock::any ) #define MOCK_MATCHER_WITH(z, n, d) c##n##_ = constraint##n##_type( c##n ); #define MOCK_MATCHER_MEMBER(z, n, d) constraint##n##_type c##n##_; #define MOCK_MATCHER_ARGS(z, n, d) BOOST_PP_COMMA_IF(n) arg##n##_type a##n